oont-contents/plugins/jetpack/modules/shortcodes/js/jmpress.js

/**
 * jmpress.js v0.4.5
 * http://jmpressjs.github.com/jmpress.js
 *
 * A jQuery plugin to build a website on the infinite canvas.
 *
 * Copyright 2013 Kyle Robinson Young @shama & Tobias Koppers @sokra
 * Licensed MIT
 * http://www.opensource.org/licenses/mit-license.php
 *
 * Based on the foundation laid by Bartek Szopka @bartaz
 */ /*
 * core.js
 * The core of jmpress.js
 */
( function ( $, document, window, undefined ) {
	'use strict';

	/**
	 * Set supported prefixes
	 *
	 * @access protected
	 * @return Function to get prefixed property
	 */
	var pfx = ( function () {
		var style = document.createElement( 'dummy' ).style,
			prefixes = 'Webkit Moz O ms Khtml'.split( ' ' ),
			memory = {};
		return function ( prop ) {
			if ( typeof memory[ prop ] === 'undefined' ) {
				var ucProp = prop.charAt( 0 ).toUpperCase() + prop.substr( 1 ),
					props = ( prop + ' ' + prefixes.join( ucProp + ' ' ) + ucProp ).split( ' ' );
				memory[ prop ] = null;
				for ( var i in props ) {
					if ( style[ props[ i ] ] !== undefined ) {
						memory[ prop ] = props[ i ];
						break;
					}
				}
			}
			return memory[ prop ];
		};
	} )();

	/**
	 * map ex. "WebkitTransform" to "-webkit-transform"
	 */
	function mapProperty( name ) {
		if ( ! name ) {
			return;
		}
		var index = 1 + name.substr( 1 ).search( /[A-Z]/ );
		var prefix = name.substr( 0, index ).toLowerCase();
		var postfix = name.substr( index ).toLowerCase();
		return '-' + prefix + '-' + postfix;
	}
	function addComma( attribute ) {
		if ( ! attribute ) {
			return '';
		}
		return attribute + ',';
	}
	/**
	 * Return an jquery object only if it's not empty
	 */
	function ifNotEmpty( el ) {
		if ( el.length > 0 ) {
			return el;
		}
		return null;
	}

	/**
	 * Default Settings
	 */
	var defaults = {
		/* CLASSES */
		stepSelector: '.step',
		containerClass: '',
		canvasClass: '',
		areaClass: '',
		notSupportedClass: 'not-supported',

		/* CONFIG */
		fullscreen: true,

		/* ANIMATION */
		animation: {
			transformOrigin: 'top left',
			transitionProperty:
				addComma( mapProperty( pfx( 'transform' ) ) ) +
				addComma( mapProperty( pfx( 'perspective' ) ) ) +
				'opacity',
			transitionDuration: '1s',
			transitionDelay: '500ms',
			transitionTimingFunction: 'ease-in-out',
			transformStyle: 'preserve-3d',
		},
		transitionDuration: 1500,
	};
	var callbacks = {
		beforeChange: 1,
		beforeInitStep: 1,
		initStep: 1,
		beforeInit: 1,
		afterInit: 1,
		beforeDeinit: 1,
		afterDeinit: 1,
		applyStep: 1,
		unapplyStep: 1,
		setInactive: 1,
		beforeActive: 1,
		setActive: 1,
		selectInitialStep: 1,
		selectPrev: 1,
		selectNext: 1,
		selectHome: 1,
		selectEnd: 1,
		idle: 1,
		applyTarget: 1,
	};
	for ( var callbackName in callbacks ) {
		defaults[ callbackName ] = [];
	}

	/**
	 * Initialize jmpress
	 */
	function init( args ) {
		args = $.extend( true, {}, args || {} );

		// accept functions and arrays of functions as callbacks
		var callbackArgs = {};
		var callbackName = null;
		for ( callbackName in callbacks ) {
			callbackArgs[ callbackName ] = $.isFunction( args[ callbackName ] )
				? [ args[ callbackName ] ]
				: args[ callbackName ];
			args[ callbackName ] = [];
		}

		// MERGE SETTINGS
		var settings = $.extend( true, {}, defaults, args );

		for ( callbackName in callbacks ) {
			if ( callbackArgs[ callbackName ] ) {
				Array.prototype.push.apply( settings[ callbackName ], callbackArgs[ callbackName ] );
			}
		}

		/*** MEMBER VARS ***/

		var jmpress = $( this ),
			container = null,
			area = null,
			oldStyle = {
				container: '',
				area: '',
			},
			canvas = null,
			current = null,
			active = false,
			activeSubstep = null,
			activeDelegated = false;

		/*** MEMBER FUNCTIONS ***/
		// functions have to be called with this

		/**
		 * Init a single step
		 *
		 * @param element the element of the step
		 * @param idx number of step
		 */
		function doStepInit( element, idx ) {
			var data = dataset( element );
			var step = {
				oldStyle: $( element ).attr( 'style' ) || '',
			};

			var callbackData = {
				data: data,
				stepData: step,
			};
			callCallback.call( this, 'beforeInitStep', $( element ), callbackData );
			step.delegate = data.delegate;
			callCallback.call( this, 'initStep', $( element ), callbackData );

			$( element ).data( 'stepData', step );

			if ( ! $( element ).attr( 'id' ) ) {
				$( element ).attr( 'id', 'step-' + ( idx + 1 ) );
			}

			callCallback.call( this, 'applyStep', $( element ), callbackData );
		}
		/**
		 * Deinit a single step
		 *
		 * @param element the element of the step
		 */
		function doStepDeinit( element ) {
			var stepData = $( element ).data( 'stepData' );

			$( element ).attr( 'style', stepData.oldStyle );

			callCallback.call( this, 'unapplyStep', $( element ), {
				stepData: stepData,
			} );
		}
		/**
		 * Reapplies stepData to the element
		 *
		 * @param element
		 */
		function doStepReapply( element ) {
			callCallback.call( this, 'unapplyStep', $( element ), {
				stepData: element.data( 'stepData' ),
			} );

			callCallback.call( this, 'applyStep', $( element ), {
				stepData: element.data( 'stepData' ),
			} );
		}
		/**
		 * Completly deinit jmpress
		 *
		 */
		function deinit() {
			if ( active ) {
				callCallback.call( this, 'setInactive', active, {
					stepData: $( active ).data( 'stepData' ),
					reason: 'deinit',
				} );
			}
			if ( current.jmpressClass ) {
				$( jmpress ).removeClass( current.jmpressClass );
			}

			callCallback.call( this, 'beforeDeinit', $( this ), {} );

			$( settings.stepSelector, jmpress ).each( function ( idx ) {
				doStepDeinit.call( jmpress, this );
			} );

			container.attr( 'style', oldStyle.container );
			if ( settings.fullscreen ) {
				$( 'html' ).attr( 'style', '' );
			}
			area.attr( 'style', oldStyle.area );
			$( canvas )
				.children()
				.each( function () {
					jmpress.append( $( this ) );
				} );
			if ( settings.fullscreen ) {
				canvas.remove();
			} else {
				canvas.remove();
				area.remove();
			}

			callCallback.call( this, 'afterDeinit', $( this ), {} );

			$( jmpress ).data( 'jmpressmethods', false );
		}
		/**
		 * Call a callback
		 *
		 * @param callbackName String callback which should be called
		 * @param element some arguments to the callback
		 * @param eventData
		 */
		function callCallback( callbackName, element, eventData ) {
			eventData.settings = settings;
			eventData.current = current;
			eventData.container = container;
			eventData.parents = element ? getStepParents( element ) : null;
			eventData.current = current;
			eventData.jmpress = this;
			var result = {};
			$.each( settings[ callbackName ], function ( idx, callback ) {
				result.value = callback.call( jmpress, element, eventData ) || result.value;
			} );
			return result.value;
		}
		/**
		 *
		 */
		function getStepParents( el ) {
			return $( el ).parentsUntil( jmpress ).not( jmpress ).filter( settings.stepSelector );
		}
		/**
		 * Reselect the active step
		 *
		 * @param String type reason of reselecting step
		 */
		function reselect( type ) {
			return select( { step: active, substep: activeSubstep }, type );
		}
		/**
		 * Select a given step
		 *
		 * @param el element to select
		 * @param type reason of changing step
		 * @return Object element selected
		 */
		function select( el, type ) {
			var substep;
			if ( $.isPlainObject( el ) ) {
				substep = el.substep;
				el = el.step;
			}
			if ( typeof el === 'string' ) {
				el = jmpress.find( el ).first();
			}
			if ( ! el || ! $( el ).data( 'stepData' ) ) {
				return false;
			}

			scrollFix.call( this );

			var step = $( el ).data( 'stepData' );

			var cancelSelect = false;
			callCallback.call( this, 'beforeChange', el, {
				stepData: step,
				reason: type,
				cancel: function () {
					cancelSelect = true;
				},
			} );
			if ( cancelSelect ) {
				return undefined;
			}

			var target = {};

			var delegated = el;
			if ( $( el ).data( 'stepData' ).delegate ) {
				delegated =
					ifNotEmpty(
						$( el ).parentsUntil( jmpress ).filter( settings.stepSelector ).filter( step.delegate )
					) ||
					ifNotEmpty( $( el ).near( step.delegate ) ) ||
					ifNotEmpty( $( el ).near( step.delegate, true ) ) ||
					ifNotEmpty( $( step.delegate, jmpress ) );
				if ( delegated ) {
					step = delegated.data( 'stepData' );
				} else {
					// Do not delegate if expression not found
					delegated = el;
				}
			}
			if ( activeDelegated ) {
				callCallback.call( this, 'setInactive', activeDelegated, {
					stepData: $( activeDelegated ).data( 'stepData' ),
					delegatedFrom: active,
					reason: type,
					target: target,
					nextStep: delegated,
					nextSubstep: substep,
					nextStepData: step,
				} );
			}
			var callbackData = {
				stepData: step,
				delegatedFrom: el,
				reason: type,
				target: target,
				substep: substep,
				prevStep: activeDelegated,
				prevSubstep: activeSubstep,
				prevStepData: activeDelegated && $( activeDelegated ).data( 'stepData' ),
			};
			callCallback.call( this, 'beforeActive', delegated, callbackData );
			callCallback.call( this, 'setActive', delegated, callbackData );

			// Set on step class on root element
			if ( current.jmpressClass ) {
				$( jmpress ).removeClass( current.jmpressClass );
			}
			$( jmpress ).addClass( ( current.jmpressClass = 'step-' + $( delegated ).attr( 'id' ) ) );
			if ( current.jmpressDelegatedClass ) {
				$( jmpress ).removeClass( current.jmpressDelegatedClass );
			}
			$( jmpress ).addClass(
				( current.jmpressDelegatedClass = 'delegating-step-' + $( el ).attr( 'id' ) )
			);

			callCallback.call(
				this,
				'applyTarget',
				delegated,
				$.extend(
					{
						canvas: canvas,
						area: area,
						beforeActive: activeDelegated,
					},
					callbackData
				)
			);

			active = el;
			activeSubstep = callbackData.substep;
			activeDelegated = delegated;

			if ( current.idleTimeout ) {
				clearTimeout( current.idleTimeout );
			}
			current.idleTimeout = setTimeout( function () {
				callCallback.call( this, 'idle', delegated, callbackData );
			}, Math.max( 1, settings.transitionDuration - 100 ) );

			return delegated;
		}
		/**
		 * This should fix ANY kind of buggy scrolling
		 */
		function scrollFix() {
			( function fix() {
				if ( $( container )[ 0 ].tagName === 'BODY' ) {
					try {
						window.scrollTo( 0, 0 );
					} catch ( e ) {}
				}
				$( container ).scrollTop( 0 );
				$( container ).scrollLeft( 0 );
				function check() {
					if ( $( container ).scrollTop() !== 0 || $( container ).scrollLeft() !== 0 ) {
						fix();
					}
				}
				setTimeout( check, 1 );
				setTimeout( check, 10 );
				setTimeout( check, 100 );
				setTimeout( check, 200 );
				setTimeout( check, 400 );
			} )();
		}
		/**
		 * Alias for select
		 */
		function goTo( el ) {
			return select.call( this, el, 'jump' );
		}
		/**
		 * Goto Next Slide
		 *
		 * @return Object newly active slide
		 */
		function next() {
			return select.call(
				this,
				callCallback.call( this, 'selectNext', active, {
					stepData: $( active ).data( 'stepData' ),
					substep: activeSubstep,
				} ),
				'next'
			);
		}
		/**
		 * Goto Previous Slide
		 *
		 * @return Object newly active slide
		 */
		function prev() {
			return select.call(
				this,
				callCallback.call( this, 'selectPrev', active, {
					stepData: $( active ).data( 'stepData' ),
					substep: activeSubstep,
				} ),
				'prev'
			);
		}
		/**
		 * Goto First Slide
		 *
		 * @return Object newly active slide
		 */
		function home() {
			return select.call(
				this,
				callCallback.call( this, 'selectHome', active, {
					stepData: $( active ).data( 'stepData' ),
				} ),
				'home'
			);
		}
		/**
		 * Goto Last Slide
		 *
		 * @return Object newly active slide
		 */
		function end() {
			return select.call(
				this,
				callCallback.call( this, 'selectEnd', active, {
					stepData: $( active ).data( 'stepData' ),
				} ),
				'end'
			);
		}
		/**
		 * Manipulate the canvas
		 *
		 * @param props
		 * @return Object
		 */
		function canvasMod( props ) {
			css( canvas, props || {} );
			return $( canvas );
		}
		/**
		 * Return current step
		 *
		 * @return Object
		 */
		function getActive() {
			return activeDelegated && $( activeDelegated );
		}
		/**
		 * fire a callback
		 *
		 * @param callbackName
		 * @param element
		 * @param eventData
		 * @return void
		 */
		function fire( callbackName, element, eventData ) {
			if ( ! callbacks[ callbackName ] ) {
				$.error( 'callback ' + callbackName + ' is not registered.' );
			} else {
				return callCallback.call( this, callbackName, element, eventData );
			}
		}

		/**
		 * PUBLIC METHODS LIST
		 */
		jmpress.data( 'jmpressmethods', {
			select: select,
			reselect: reselect,
			scrollFix: scrollFix,
			goTo: goTo,
			next: next,
			prev: prev,
			home: home,
			end: end,
			canvas: canvasMod,
			container: function () {
				return container;
			},
			settings: function () {
				return settings;
			},
			active: getActive,
			current: function () {
				return current;
			},
			fire: fire,
			init: function ( step ) {
				doStepInit.call( this, $( step ), current.nextIdNumber++ );
			},
			deinit: function ( step ) {
				if ( step ) {
					doStepDeinit.call( this, $( step ) );
				} else {
					deinit.call( this );
				}
			},
			reapply: doStepReapply,
		} );

		/**
		 * Check for support
		 * This will be removed in near future, when support is coming
		 *
		 * @access protected
		 * @return void
		 */
		function checkSupport() {
			var ua = navigator.userAgent.toLowerCase();
			return ua.search( /(iphone)|(ipod)|(android)/ ) === -1 || ua.search( /(chrome)/ ) !== -1;
		}

		// BEGIN INIT

		// CHECK FOR SUPPORT
		if ( checkSupport() === false ) {
			if ( settings.notSupportedClass ) {
				jmpress.addClass( settings.notSupportedClass );
			}
			return;
		} else {
			if ( settings.notSupportedClass ) {
				jmpress.removeClass( settings.notSupportedClass );
			}
		}

		// grabbing all steps
		var steps = $( settings.stepSelector, jmpress );

		// GERNERAL INIT OF FRAME
		container = jmpress;
		area = $( '<div />' );
		canvas = $( '<div />' );
		$( jmpress )
			.children()
			.filter( steps )
			.each( function () {
				canvas.append( $( this ) );
			} );
		if ( settings.fullscreen ) {
			container = $( 'body' );
			$( 'html' ).css( {
				overflow: 'hidden',
			} );
			area = jmpress;
		}
		oldStyle.area = area.attr( 'style' ) || '';
		oldStyle.container = container.attr( 'style' ) || '';
		if ( settings.fullscreen ) {
			container.css( {
				height: '100%',
			} );
			jmpress.append( canvas );
		} else {
			container.css( {
				position: 'relative',
			} );
			area.append( canvas );
			jmpress.append( area );
		}

		$( container ).addClass( settings.containerClass );
		$( area ).addClass( settings.areaClass );
		$( canvas ).addClass( settings.canvasClass );

		document.documentElement.style.height = '100%';
		container.css( {
			overflow: 'hidden',
		} );

		var props = {
			position: 'absolute',
			transitionDuration: '0s',
		};
		props = $.extend( {}, settings.animation, props );
		css( area, props );
		css( area, {
			top: '50%',
			left: '50%',
			perspective: '1000px',
		} );
		css( canvas, props );

		current = {};

		callCallback.call( this, 'beforeInit', null, {} );

		// INITIALIZE EACH STEP
		steps.each( function ( idx ) {
			doStepInit.call( jmpress, this, idx );
		} );
		current.nextIdNumber = steps.length;

		callCallback.call( this, 'afterInit', null, {} );

		// START
		select.call( this, callCallback.call( this, 'selectInitialStep', 'init', {} ) );

		if ( settings.initClass ) {
			$( steps ).removeClass( settings.initClass );
		}
	}
	/**
	 * Return default settings
	 *
	 * @return Object
	 */
	function getDefaults() {
		return defaults;
	}
	/**
	 * Register a callback or a jmpress function
	 *
	 * @access public
	 * @param name String the name of the callback or function
	 * @param func Function? the function to be added
	 */
	function register( name, func ) {
		if ( $.isFunction( func ) ) {
			if ( methods[ name ] ) {
				$.error( 'function ' + name + ' is already registered.' );
			} else {
				methods[ name ] = func;
			}
		} else {
			if ( callbacks[ name ] ) {
				$.error( 'callback ' + name + ' is already registered.' );
			} else {
				callbacks[ name ] = 1;
				defaults[ name ] = [];
			}
		}
	}
	/**
	 * Set CSS on element w/ prefixes
	 *
	 * @return Object element which properties were set
	 *
	 * TODO: Consider bypassing pfx and blindly set as jQuery
	 * already checks for support
	 */
	function css( el, props ) {
		var key,
			pkey,
			cssObj = {};
		for ( key in props ) {
			if ( props.hasOwnProperty( key ) ) {
				pkey = pfx( key );
				if ( pkey !== null ) {
					cssObj[ pkey ] = props[ key ];
				}
			}
		}
		$( el ).css( cssObj );
		return el;
	}
	/**
	 * Return dataset for element
	 *
	 * @param el element
	 * @return Object
	 */
	function dataset( el ) {
		if ( $( el )[ 0 ].dataset ) {
			return $.extend( {}, $( el )[ 0 ].dataset );
		}
		function toCamelcase( str ) {
			str = str.split( '-' );
			for ( var i = 1; i < str.length; i++ ) {
				str[ i ] = str[ i ].substr( 0, 1 ).toUpperCase() + str[ i ].substr( 1 );
			}
			return str.join( '' );
		}
		var returnDataset = {};
		var attrs = $( el )[ 0 ].attributes;
		$.each( attrs, function ( idx, attr ) {
			if ( attr.nodeName.substr( 0, 5 ) === 'data-' ) {
				returnDataset[ toCamelcase( attr.nodeName.substr( 5 ) ) ] = attr.nodeValue;
			}
		} );
		return returnDataset;
	}
	/**
	 * Returns true, if jmpress is initialized
	 *
	 * @return bool
	 */
	function initialized() {
		return !! $( this ).data( 'jmpressmethods' );
	}

	/**
	 * PUBLIC STATIC METHODS LIST
	 */
	var methods = {
		init: init,
		initialized: initialized,
		deinit: function () {},
		css: css,
		pfx: pfx,
		defaults: getDefaults,
		register: register,
		dataset: dataset,
	};

	/**
	 * $.jmpress()
	 */
	$.fn.jmpress = function ( method ) {
		function f() {
			var jmpressmethods = $( this ).data( 'jmpressmethods' );
			if ( jmpressmethods && jmpressmethods[ method ] ) {
				return jmpressmethods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ) );
			} else if ( methods[ method ] ) {
				return methods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ) );
			} else if ( callbacks[ method ] && jmpressmethods ) {
				var settings = jmpressmethods.settings();
				var func = Array.prototype.slice.call( arguments, 1 )[ 0 ];
				if ( $.isFunction( func ) ) {
					settings[ method ] = settings[ method ] || [];
					settings[ method ].push( func );
				}
			} else if ( typeof method === 'object' || ! method ) {
				return init.apply( this, arguments );
			} else {
				$.error( 'Method ' + method + ' does not exist on jQuery.jmpress' );
			}
			// to allow chaining
			return this;
		}
		var args = arguments;
		var result;
		$( this ).each( function ( idx, element ) {
			result = f.apply( element, args );
		} );
		return result;
	};
	$.extend( {
		jmpress: function ( method ) {
			if ( methods[ method ] ) {
				return methods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ) );
			} else if ( callbacks[ method ] ) {
				// plugin interface
				var func = Array.prototype.slice.call( arguments, 1 )[ 0 ];
				if ( $.isFunction( func ) ) {
					defaults[ method ].push( func );
				} else {
					$.error(
						'Second parameter should be a function: $.jmpress( callbackName, callbackFunction )'
					);
				}
			} else {
				$.error( 'Method ' + method + ' does not exist on jQuery.jmpress' );
			}
		},
	} );
} )( jQuery, document, window );

/*
 * near.js
 * Find steps near each other
 */
( function ( $, document, window, undefined ) {
	'use strict';

	// add near( selector, backwards = false) to jquery

	function checkAndGo( elements, func, selector, backwards ) {
		var next;
		elements.each( function ( idx, element ) {
			if ( backwards ) {
				next = func( element, selector, backwards );
				if ( next ) {
					return false;
				}
			}
			if ( $( element ).is( selector ) ) {
				next = element;
				return false;
			}
			if ( ! backwards ) {
				next = func( element, selector, backwards );
				if ( next ) {
					return false;
				}
			}
		} );
		return next;
	}
	function findNextInChildren( item, selector, backwards ) {
		var children = $( item ).children();
		if ( backwards ) {
			children = $( children.get().reverse() );
		}
		return checkAndGo( children, findNextInChildren, selector, backwards );
	}
	function findNextInSiblings( item, selector, backwards ) {
		return checkAndGo(
			$( item )[ backwards ? 'prevAll' : 'nextAll' ](),
			findNextInChildren,
			selector,
			backwards
		);
	}
	function findNextInParents( item, selector, backwards ) {
		var next;
		var parents = $( item ).parents();
		parents = $( parents.get() );
		$.each( parents.get(), function ( idx, element ) {
			if ( backwards && $( element ).is( selector ) ) {
				next = element;
				return false;
			}
			next = findNextInSiblings( element, selector, backwards );
			if ( next ) {
				return false;
			}
		} );
		return next;
	}

	$.fn.near = function ( selector, backwards ) {
		var array = [];
		$( this ).each( function ( idx, element ) {
			var near =
				( backwards ? false : findNextInChildren( element, selector, backwards ) ) ||
				findNextInSiblings( element, selector, backwards ) ||
				findNextInParents( element, selector, backwards );
			if ( near ) {
				array.push( near );
			}
		} );
		return $( array );
	};
} )( jQuery, document, window );
/*
 * transform.js
 * The engine that powers the transforms or falls back to other methods
 */
( function ( $, document, window, undefined ) {
	'use strict';

	/* FUNCTIONS */
	function toCssNumber( number ) {
		return Math.round( 10000 * number ) / 10000 + '';
	}

	/**
	 * 3D and 2D engines
	 */
	var engines = {
		3: {
			transform: function ( el, data ) {
				var transform = 'translate(-50%,-50%)';
				$.each( data, function ( idx, item ) {
					var coord = [ 'X', 'Y', 'Z' ];
					var i;
					if ( item[ 0 ] === 'translate' ) {
						// ["translate", x, y, z]
						transform +=
							' translate3d(' +
							toCssNumber( item[ 1 ] || 0 ) +
							'px,' +
							toCssNumber( item[ 2 ] || 0 ) +
							'px,' +
							toCssNumber( item[ 3 ] || 0 ) +
							'px)';
					} else if ( item[ 0 ] === 'rotate' ) {
						var order = item[ 4 ] ? [ 1, 2, 3 ] : [ 3, 2, 1 ];
						for ( i = 0; i < 3; i++ ) {
							transform +=
								' rotate' +
								coord[ order[ i ] - 1 ] +
								'(' +
								toCssNumber( item[ order[ i ] ] || 0 ) +
								'deg)';
						}
					} else if ( item[ 0 ] === 'scale' ) {
						for ( i = 0; i < 3; i++ ) {
							transform += ' scale' + coord[ i ] + '(' + toCssNumber( item[ i + 1 ] || 1 ) + ')';
						}
					}
				} );
				$.jmpress( 'css', el, $.extend( {}, { transform: transform } ) );
			},
		},
		2: {
			transform: function ( el, data ) {
				var transform = 'translate(-50%,-50%)';
				$.each( data, function ( idx, item ) {
					var coord = [ 'X', 'Y' ];
					if ( item[ 0 ] === 'translate' ) {
						// ["translate", x, y, z]
						transform +=
							' translate(' +
							toCssNumber( item[ 1 ] || 0 ) +
							'px,' +
							toCssNumber( item[ 2 ] || 0 ) +
							'px)';
					} else if ( item[ 0 ] === 'rotate' ) {
						transform += ' rotate(' + toCssNumber( item[ 3 ] || 0 ) + 'deg)';
					} else if ( item[ 0 ] === 'scale' ) {
						for ( var i = 0; i < 2; i++ ) {
							transform += ' scale' + coord[ i ] + '(' + toCssNumber( item[ i + 1 ] || 1 ) + ')';
						}
					}
				} );
				$.jmpress( 'css', el, $.extend( {}, { transform: transform } ) );
			},
		},
		1: {
			// CHECK IF SUPPORT IS REALLY NEEDED?
			// this not even work without scaling...
			// it may better to display the normal view
			transform: function ( el, data ) {
				var anitarget = { top: 0, left: 0 };
				$.each( data, function ( idx, item ) {
					var coord = [ 'X', 'Y' ];
					if ( item[ 0 ] === 'translate' ) {
						// ["translate", x, y, z]
						anitarget.left = Math.round( item[ 1 ] || 0 ) + 'px';
						anitarget.top = Math.round( item[ 2 ] || 0 ) + 'px';
					}
				} );
				el.animate( anitarget, 1000 ); // TODO: Use animation duration
			},
		},
	};

	/**
	 * Engine to power cross-browser translate, scale and rotate.
	 */
	var engine = ( function () {
		if ( $.jmpress( 'pfx', 'perspective' ) ) {
			return engines[ 3 ];
		} else if ( $.jmpress( 'pfx', 'transform' ) ) {
			return engines[ 2 ];
		} else {
			// CHECK IF SUPPORT IS REALLY NEEDED?
			return engines[ 1 ];
		}
	} )();

	$.jmpress( 'defaults' ).reasonableAnimation = {};
	$.jmpress( 'initStep', function ( step, eventData ) {
		var data = eventData.data;
		var stepData = eventData.stepData;
		var pf = parseFloat;
		$.extend( stepData, {
			x: pf( data.x ) || 0,
			y: pf( data.y ) || 0,
			z: pf( data.z ) || 0,
			r: pf( data.r ) || 0,
			phi: pf( data.phi ) || 0,
			rotate: pf( data.rotate ) || 0,
			rotateX: pf( data.rotateX ) || 0,
			rotateY: pf( data.rotateY ) || 0,
			rotateZ: pf( data.rotateZ ) || 0,
			revertRotate: false,
			scale: pf( data.scale ) || 1,
			scaleX: pf( data.scaleX ) || false,
			scaleY: pf( data.scaleY ) || false,
			scaleZ: pf( data.scaleZ ) || 1,
		} );
	} );
	$.jmpress( 'afterInit', function ( nil, eventData ) {
		var stepSelector = eventData.settings.stepSelector,
			current = eventData.current;
		current.perspectiveScale = 1;
		current.maxNestedDepth = 0;
		var nestedSteps = $( eventData.jmpress ).find( stepSelector ).children( stepSelector );
		while ( nestedSteps.length ) {
			current.maxNestedDepth++;
			nestedSteps = nestedSteps.children( stepSelector );
		}
	} );
	$.jmpress( 'applyStep', function ( step, eventData ) {
		$.jmpress( 'css', $( step ), {
			position: 'absolute',
			transformStyle: 'preserve-3d',
		} );
		if ( eventData.parents.length > 0 ) {
			$.jmpress( 'css', $( step ), {
				top: '50%',
				left: '50%',
			} );
		}
		var sd = eventData.stepData;
		var transform = [
			[
				'translate',
				sd.x || sd.r * Math.sin( ( sd.phi * Math.PI ) / 180 ),
				sd.y || -sd.r * Math.cos( ( sd.phi * Math.PI ) / 180 ),
				sd.z,
			],
			[ 'rotate', sd.rotateX, sd.rotateY, sd.rotateZ || sd.rotate, true ],
			[ 'scale', sd.scaleX || sd.scale, sd.scaleY || sd.scale, sd.scaleZ || sd.scale ],
		];
		engine.transform( step, transform );
	} );
	$.jmpress( 'setActive', function ( element, eventData ) {
		var target = eventData.target;
		var step = eventData.stepData;
		var tf = ( target.transform = [] );
		target.perspectiveScale = 1;

		for ( var i = eventData.current.maxNestedDepth; i > ( eventData.parents.length || 0 ); i-- ) {
			tf.push( [ 'scale' ], [ 'rotate' ], [ 'translate' ] );
		}

		tf.push( [
			'scale',
			1 / ( step.scaleX || step.scale ),
			1 / ( step.scaleY || step.scale ),
			1 / step.scaleZ,
		] );
		tf.push( [ 'rotate', -step.rotateX, -step.rotateY, -( step.rotateZ || step.rotate ) ] );
		tf.push( [
			'translate',
			-( step.x || step.r * Math.sin( ( step.phi * Math.PI ) / 180 ) ),
			-( step.y || -step.r * Math.cos( ( step.phi * Math.PI ) / 180 ) ),
			-step.z,
		] );
		target.perspectiveScale *= step.scaleX || step.scale;

		$.each( eventData.parents, function ( idx, element ) {
			var step = $( element ).data( 'stepData' );
			tf.push( [
				'scale',
				1 / ( step.scaleX || step.scale ),
				1 / ( step.scaleY || step.scale ),
				1 / step.scaleZ,
			] );
			tf.push( [ 'rotate', -step.rotateX, -step.rotateY, -( step.rotateZ || step.rotate ) ] );
			tf.push( [
				'translate',
				-( step.x || step.r * Math.sin( ( step.phi * Math.PI ) / 180 ) ),
				-( step.y || -step.r * Math.cos( ( step.phi * Math.PI ) / 180 ) ),
				-step.z,
			] );
			target.perspectiveScale *= step.scaleX || step.scale;
		} );

		$.each( tf, function ( idx, item ) {
			if ( item[ 0 ] !== 'rotate' ) {
				return;
			}
			function lowRotate( name ) {
				if ( eventData.current[ 'rotate' + name + '-' + idx ] === undefined ) {
					eventData.current[ 'rotate' + name + '-' + idx ] = item[ name ] || 0;
				}
				var cur = eventData.current[ 'rotate' + name + '-' + idx ],
					tar = item[ name ] || 0,
					curmod = cur % 360,
					tarmod = tar % 360;
				if ( curmod < 0 ) {
					curmod += 360;
				}
				if ( tarmod < 0 ) {
					tarmod += 360;
				}
				var diff = tarmod - curmod;
				if ( diff < -180 ) {
					diff += 360;
				} else if ( diff > 180 ) {
					diff -= 360;
				}
				eventData.current[ 'rotate' + name + '-' + idx ] = item[ name ] = cur + diff;
			}
			lowRotate( 1 );
			lowRotate( 2 );
			lowRotate( 3 );
		} );
	} );
	$.jmpress( 'applyTarget', function ( active, eventData ) {
		var target = eventData.target,
			props,
			step = eventData.stepData,
			settings = eventData.settings,
			zoomin = target.perspectiveScale * 1.3 < eventData.current.perspectiveScale,
			zoomout = target.perspectiveScale > eventData.current.perspectiveScale * 1.3;

		// extract first scale from transform
		var lastScale = -1;
		$.each( target.transform, function ( idx, item ) {
			if ( item.length <= 1 ) {
				return;
			}
			if (
				item[ 0 ] === 'rotate' &&
				item[ 1 ] % 360 === 0 &&
				item[ 2 ] % 360 === 0 &&
				item[ 3 ] % 360 === 0
			) {
				return;
			}
			if ( item[ 0 ] === 'scale' ) {
				lastScale = idx;
			} else {
				return false;
			}
		} );

		if ( lastScale !== eventData.current.oldLastScale ) {
			zoomin = zoomout = false;
			eventData.current.oldLastScale = lastScale;
		}

		var extracted = [];
		if ( lastScale !== -1 ) {
			while ( lastScale >= 0 ) {
				if ( target.transform[ lastScale ][ 0 ] === 'scale' ) {
					extracted.push( target.transform[ lastScale ] );
					target.transform[ lastScale ] = [ 'scale' ];
				}
				lastScale--;
			}
		}

		var animation = settings.animation;
		if ( settings.reasonableAnimation[ eventData.reason ] ) {
			animation = $.extend( {}, animation, settings.reasonableAnimation[ eventData.reason ] );
		}

		props = {
			// to keep the perspective look similar for different scales
			// we need to 'scale' the perspective, too
			perspective: Math.round( target.perspectiveScale * 1000 ) + 'px',
		};
		props = $.extend( {}, animation, props );
		if ( ! zoomin ) {
			props.transitionDelay = '0s';
		}
		if ( ! eventData.beforeActive ) {
			props.transitionDuration = '0s';
			props.transitionDelay = '0s';
		}
		$.jmpress( 'css', eventData.area, props );
		engine.transform( eventData.area, extracted );

		props = $.extend( {}, animation );
		if ( ! zoomout ) {
			props.transitionDelay = '0s';
		}
		if ( ! eventData.beforeActive ) {
			props.transitionDuration = '0s';
			props.transitionDelay = '0s';
		}

		eventData.current.perspectiveScale = target.perspectiveScale;

		$.jmpress( 'css', eventData.canvas, props );
		engine.transform( eventData.canvas, target.transform );
	} );
} )( jQuery, document, window );
/*
 * active.js
 * Set the active classes on steps
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress;

	/* DEFINES */
	var activeClass = 'activeClass',
		nestedActiveClass = 'nestedActiveClass';

	/* DEFAULTS */
	var defaults = $jmpress( 'defaults' );
	defaults[ nestedActiveClass ] = 'nested-active';
	defaults[ activeClass ] = 'active';

	/* HOOKS */
	$jmpress( 'setInactive', function ( step, eventData ) {
		var settings = eventData.settings,
			activeClassSetting = settings[ activeClass ],
			nestedActiveClassSettings = settings[ nestedActiveClass ];
		if ( activeClassSetting ) {
			$( step ).removeClass( activeClassSetting );
		}
		if ( nestedActiveClassSettings ) {
			$.each( eventData.parents, function ( idx, element ) {
				$( element ).removeClass( nestedActiveClassSettings );
			} );
		}
	} );
	$jmpress( 'setActive', function ( step, eventData ) {
		var settings = eventData.settings,
			activeClassSetting = settings[ activeClass ],
			nestedActiveClassSettings = settings[ nestedActiveClass ];
		if ( activeClassSetting ) {
			$( step ).addClass( activeClassSetting );
		}
		if ( nestedActiveClassSettings ) {
			$.each( eventData.parents, function ( idx, element ) {
				$( element ).addClass( nestedActiveClassSettings );
			} );
		}
	} );
} )( jQuery, document, window );
/*
 * circular.js
 * Repeat from start after end
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress;

	/* FUNCTIONS */
	function firstSlide( step, eventData ) {
		return $( this ).find( eventData.settings.stepSelector ).first();
	}
	function prevOrNext( jmpress, step, eventData, prev ) {
		if ( ! step ) {
			return false;
		}
		var stepSelector = eventData.settings.stepSelector;
		step = $( step );
		do {
			var item = step.near( stepSelector, prev );
			if ( item.length === 0 || item.closest( jmpress ).length === 0 ) {
				item = $( jmpress ).find( stepSelector )[ prev ? 'last' : 'first' ](); // eslint-disable-line no-unexpected-multiline
			}
			if ( ! item.length ) {
				return false;
			}
			step = item;
		} while ( step.data( 'stepData' ).exclude );
		return step;
	}

	/* HOOKS */
	$jmpress( 'initStep', function ( step, eventData ) {
		eventData.stepData.exclude =
			eventData.data.exclude && [ 'false', 'no' ].indexOf( eventData.data.exclude ) === -1;
	} );
	$jmpress( 'selectInitialStep', firstSlide );
	$jmpress( 'selectHome', firstSlide );
	$jmpress( 'selectEnd', function ( step, eventData ) {
		return $( this ).find( eventData.settings.stepSelector ).last();
	} );
	$jmpress( 'selectPrev', function ( step, eventData ) {
		return prevOrNext( this, step, eventData, true );
	} );
	$jmpress( 'selectNext', function ( step, eventData ) {
		return prevOrNext( this, step, eventData );
	} );
} )( jQuery, document, window );
/*
 * start.js
 * Set the first step to start on
 */
( function ( $, document, window, undefined ) {
	'use strict';

	/* HOOKS */
	$.jmpress( 'selectInitialStep', function ( nil, eventData ) {
		return eventData.settings.start;
	} );
} )( jQuery, document, window );
/*
 * ways.js
 * Control the flow of the steps
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress;

	/* FUNCTIONS */
	function routeFunc( jmpress, route, type ) {
		for ( var i = 0; i < route.length - 1; i++ ) {
			var from = route[ i ];
			var to = route[ i + 1 ];
			if ( $( jmpress ).jmpress( 'initialized' ) ) {
				$( from, jmpress ).data( 'stepData' )[ type ] = to;
			} else {
				$( from, jmpress ).attr( 'data-' + type, to );
			}
		}
	}
	function selectPrevOrNext( step, eventData, attr, prev ) {
		var stepData = eventData.stepData;
		if ( stepData[ attr ] ) {
			var near = $( step ).near( stepData[ attr ], prev );
			if ( near && near.length ) {
				return near;
			}
			near = $( stepData[ attr ], this )[ prev ? 'last' : 'first' ]();
			if ( near && near.length ) {
				return near;
			}
		}
	}

	/* EXPORTED FUNCTIONS */
	$jmpress( 'register', 'route', function ( route, unidirectional, reversedRoute ) {
		if ( typeof route === 'string' ) {
			route = [ route, route ];
		}
		routeFunc( this, route, reversedRoute ? 'prev' : 'next' );
		if ( ! unidirectional ) {
			routeFunc( this, route.reverse(), reversedRoute ? 'next' : 'prev' );
		}
	} );

	/* HOOKS */
	$jmpress( 'initStep', function ( step, eventData ) {
		for ( var attr in { next: 1, prev: 1 } ) {
			eventData.stepData[ attr ] = eventData.data[ attr ];
		}
	} );
	$jmpress( 'selectNext', function ( step, eventData ) {
		return selectPrevOrNext.call( this, step, eventData, 'next' );
	} );
	$jmpress( 'selectPrev', function ( step, eventData ) {
		return selectPrevOrNext.call( this, step, eventData, 'prev', true );
	} );
} )( jQuery, document, window );
/*
 * ajax.js
 * Load steps via ajax
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress;

	/* DEFINES */
	var afterStepLoaded = 'ajax:afterStepLoaded',
		loadStep = 'ajax:loadStep';

	/* REGISTER EVENTS */
	$jmpress( 'register', loadStep );
	$jmpress( 'register', afterStepLoaded );

	/* DEFAULTS */
	$jmpress( 'defaults' ).ajaxLoadedClass = 'loaded';

	/* HOOKS */
	$jmpress( 'initStep', function ( step, eventData ) {
		eventData.stepData.src = $( step ).attr( 'href' ) || eventData.data.src || false;
		eventData.stepData.srcLoaded = false;
	} );
	$jmpress( loadStep, function ( step, eventData ) {
		var stepData = eventData.stepData,
			href = stepData && stepData.src,
			settings = eventData.settings;
		if ( href ) {
			$( step ).addClass( settings.ajaxLoadedClass );
			stepData.srcLoaded = true;
			$( step ).load( href, function ( response, status, xhr ) {
				$( eventData.jmpress ).jmpress(
					'fire',
					afterStepLoaded,
					step,
					$.extend( {}, eventData, {
						response: response,
						status: status,
						xhr: xhr,
					} )
				);
			} );
		}
	} );
	$jmpress( 'idle', function ( step, eventData ) {
		if ( ! step ) {
			return;
		}
		var settings = eventData.settings,
			jmpress = $( this ),
			stepData = eventData.stepData;
		var siblings = $( step )
			.add( $( step ).near( settings.stepSelector ) )
			.add( $( step ).near( settings.stepSelector, true ) )
			.add(
				jmpress.jmpress( 'fire', 'selectPrev', step, {
					stepData: $( step ).data( 'stepData' ),
				} )
			)
			.add(
				jmpress.jmpress( 'fire', 'selectNext', step, {
					stepData: $( step ).data( 'stepData' ),
				} )
			);
		siblings.each( function () {
			var step = this,
				stepData = $( step ).data( 'stepData' );
			if ( ! stepData.src || stepData.srcLoaded ) {
				return;
			}
			jmpress.jmpress( 'fire', loadStep, step, {
				stepData: $( step ).data( 'stepData' ),
			} );
		} );
	} );
	$jmpress( 'setActive', function ( step, eventData ) {
		var stepData = $( step ).data( 'stepData' );
		if ( ! stepData.src || stepData.srcLoaded ) {
			return;
		}
		$( this ).jmpress( 'fire', loadStep, step, {
			stepData: $( step ).data( 'stepData' ),
		} );
	} );
} )( jQuery, document, window );
/*
 * hash.js
 * Detect and set the URL hash
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress,
		hashLink = "a[href^='#']";

	/* FUNCTIONS */
	function randomString() {
		return '' + Math.round( Math.random() * 100000, 0 );
	}
	/**
	 * getElementFromUrl
	 *
	 * @return String or undefined
	 */
	function getElementFromUrl( settings ) {
		// get id from url # by removing `#` or `#/` from the beginning,
		// so both "fallback" `#slide-id` and "enhanced" `#/slide-id` will work
		// TODO SECURITY check user input to be valid!
		try {
			var el = $( '#' + window.location.hash.replace( /^#\/?/, '' ) );
			return el.length > 0 && el.is( settings.stepSelector ) ? el : undefined;
		} catch ( e ) {}
	}
	function setHash( stepid ) {
		var shouldBeHash = '#/' + stepid;
		if ( window.history && window.history.pushState ) {
			// shouldBeHash = "#" + stepid;
			// consider this for future versions
			//  it has currently issues, when startup with a link with hash (webkit)
			if ( window.location.hash !== shouldBeHash ) {
				window.history.pushState( {}, '', shouldBeHash );
			}
		} else {
			if ( window.location.hash !== shouldBeHash ) {
				window.location.hash = shouldBeHash;
			}
		}
	}

	/* DEFAULTS */
	$jmpress( 'defaults' ).hash = {
		use: true,
		update: true,
		bindChange: true,
		// NOTICE: {use: true, update: false, bindChange: true}
		// will cause a error after clicking on a link to the current step
	};

	/* HOOKS */
	$jmpress( 'selectInitialStep', function ( step, eventData ) {
		var settings = eventData.settings,
			hashSettings = settings.hash,
			current = eventData.current,
			jmpress = $( this );
		eventData.current.hashNamespace = '.jmpress-' + randomString();
		// HASH CHANGE EVENT
		if ( hashSettings.use ) {
			if ( hashSettings.bindChange ) {
				$( window ).bind( 'hashchange' + current.hashNamespace, function ( event ) {
					var urlItem = getElementFromUrl( settings );
					if ( jmpress.jmpress( 'initialized' ) ) {
						jmpress.jmpress( 'scrollFix' );
					}
					if ( urlItem && urlItem.length ) {
						if ( urlItem.attr( 'id' ) !== jmpress.jmpress( 'active' ).attr( 'id' ) ) {
							jmpress.jmpress( 'select', urlItem );
						}
						setHash( urlItem.attr( 'id' ) );
					}
					event.preventDefault();
				} );
				$( hashLink ).on( 'click' + current.hashNamespace, function ( event ) {
					var href = $( this ).attr( 'href' );
					try {
						if ( $( href ).is( settings.stepSelector ) ) {
							jmpress.jmpress( 'select', href );
							event.preventDefault();
							event.stopPropagation();
						}
					} catch ( e ) {}
				} );
			}
			return getElementFromUrl( settings );
		}
	} );
	$jmpress( 'afterDeinit', function ( nil, eventData ) {
		$( hashLink ).off( eventData.current.hashNamespace );
		$( window ).unbind( eventData.current.hashNamespace );
	} );
	$jmpress( 'setActive', function ( step, eventData ) {
		var settings = eventData.settings,
			current = eventData.current;
		// `#/step-id` is used instead of `#step-id` to prevent default browser
		// scrolling to element in hash
		if ( settings.hash.use && settings.hash.update ) {
			clearTimeout( current.hashtimeout );
			current.hashtimeout = setTimeout( function () {
				setHash( $( eventData.delegatedFrom ).attr( 'id' ) );
			}, settings.transitionDuration + 200 );
		}
	} );
} )( jQuery, document, window );
/*
 * keyboard.js
 * Keyboard event mapping and default keyboard actions
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress,
		jmpressNext = 'next',
		jmpressPrev = 'prev';

	/* FUNCTIONS */
	function randomString() {
		return '' + Math.round( Math.random() * 100000, 0 );
	}
	function stopEvent( event ) {
		event.preventDefault();
		event.stopPropagation();
	}

	/* DEFAULTS */
	$jmpress( 'defaults' ).keyboard = {
		use: true,
		keys: {
			33: jmpressPrev, // pg up
			37: jmpressPrev, // left
			38: jmpressPrev, // up

			9: jmpressNext + ':' + jmpressPrev, // tab
			32: jmpressNext, // space
			34: jmpressNext, // pg down
			39: jmpressNext, // right
			40: jmpressNext, // down

			36: 'home', // home

			35: 'end', // end
		},
		ignore: {
			INPUT: [
				32, // space
				37, // left
				38, // up
				39, // right
				40, // down
			],
			TEXTAREA: [
				32, // space
				37, // left
				38, // up
				39, // right
				40, // down
			],
			SELECT: [
				38, // up
				40, // down
			],
		},
		tabSelector: 'a[href]:visible, :input:visible',
	};

	/* HOOKS */
	$jmpress( 'afterInit', function ( nil, eventData ) {
		var settings = eventData.settings,
			keyboardSettings = settings.keyboard,
			ignoreKeyboardSettings = keyboardSettings.ignore,
			current = eventData.current,
			jmpress = $( this );

		// tabindex make it focusable so that it can receive key events
		if ( ! settings.fullscreen ) {
			jmpress.attr( 'tabindex', 0 );
		}

		current.keyboardNamespace = '.jmpress-' + randomString();

		// KEYPRESS EVENT: this fixes a Opera bug
		$( settings.fullscreen ? document : jmpress ).bind(
			'keypress' + current.keyboardNamespace,
			function ( event ) {
				for ( var nodeName in ignoreKeyboardSettings ) {
					if (
						event.target.nodeName === nodeName &&
						ignoreKeyboardSettings[ nodeName ].indexOf( event.which ) !== -1
					) {
						return;
					}
				}
				if ( ( event.which >= 37 && event.which <= 40 ) || event.which === 32 ) {
					stopEvent( event );
				}
			}
		);
		// KEYDOWN EVENT
		$( settings.fullscreen ? document : jmpress ).bind(
			'keydown' + current.keyboardNamespace,
			function ( event ) {
				var eventTarget = $( event.target );

				if (
					( ! settings.fullscreen && ! eventTarget.closest( jmpress ).length ) ||
					! keyboardSettings.use
				) {
					return;
				}

				for ( var nodeName in ignoreKeyboardSettings ) {
					if (
						eventTarget[ 0 ].nodeName === nodeName &&
						ignoreKeyboardSettings[ nodeName ].indexOf( event.which ) !== -1
					) {
						return;
					}
				}

				var reverseSelect = false;
				var nextFocus;
				if ( event.which === 9 ) {
					// tab
					if ( ! eventTarget.closest( jmpress.jmpress( 'active' ) ).length ) {
						if ( ! event.shiftKey ) {
							nextFocus = jmpress
								.jmpress( 'active' )
								.find( 'a[href], :input' )
								.filter( ':visible' )
								.first();
						} else {
							reverseSelect = true;
						}
					} else {
						nextFocus = eventTarget.near( keyboardSettings.tabSelector, event.shiftKey );
						if (
							! $( nextFocus ).closest( settings.stepSelector ).is( jmpress.jmpress( 'active' ) )
						) {
							nextFocus = undefined;
						}
					}
					if ( nextFocus && nextFocus.length > 0 ) {
						nextFocus.focus();
						jmpress.jmpress( 'scrollFix' );
						stopEvent( event );
						return;
					} else {
						if ( event.shiftKey ) {
							reverseSelect = true;
						}
					}
				}

				var action = keyboardSettings.keys[ event.which ];
				if ( typeof action === 'string' ) {
					if ( action.indexOf( ':' ) !== -1 ) {
						action = action.split( ':' );
						action = event.shiftKey ? action[ 1 ] : action[ 0 ];
					}
					jmpress.jmpress( action );
					stopEvent( event );
				} else if ( $.isFunction( action ) ) {
					action.call( jmpress, event );
				} else if ( action ) {
					jmpress.jmpress.apply( jmpress, action );
					stopEvent( event );
				}

				if ( reverseSelect ) {
					// tab
					nextFocus = jmpress
						.jmpress( 'active' )
						.find( 'a[href], :input' )
						.filter( ':visible' )
						.last();
					nextFocus.focus();
					jmpress.jmpress( 'scrollFix' );
				}
			}
		);
	} );
	$jmpress( 'afterDeinit', function ( nil, eventData ) {
		$( document ).unbind( eventData.current.keyboardNamespace );
	} );
} )( jQuery, document, window );
/*
 * viewport.js
 * Scale to fit a given viewport
 */
( function ( $, document, window, undefined ) {
	'use strict';

	function randomString() {
		return '' + Math.round( Math.random() * 100000, 0 );
	}

	var browser = ( function () {
		var ua = navigator.userAgent.toLowerCase();
		var match =
			/(chrome)[ \/]([\w.]+)/.exec( ua ) ||
			/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
			/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
			/(msie) ([\w.]+)/.exec( ua ) ||
			( ua.indexOf( 'compatible' ) < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ) ||
			[];
		return match[ 1 ] || '';
	} )();

	var defaults = $.jmpress( 'defaults' );
	defaults.viewPort = {
		width: false,
		height: false,
		maxScale: 0,
		minScale: 0,
		zoomable: 0,
		zoomBindMove: true,
		zoomBindWheel: true,
	};
	var keys = defaults.keyboard.keys;
	keys[ browser === 'mozilla' ? 107 : 187 ] = 'zoomIn'; // +
	keys[ browser === 'mozilla' ? 109 : 189 ] = 'zoomOut'; // -
	defaults.reasonableAnimation.resize = {
		transitionDuration: '0s',
		transitionDelay: '0ms',
	};
	defaults.reasonableAnimation.zoom = {
		transitionDuration: '0s',
		transitionDelay: '0ms',
	};
	$.jmpress( 'initStep', function ( step, eventData ) {
		for ( var variable in {
			viewPortHeight: 1,
			viewPortWidth: 1,
			viewPortMinScale: 1,
			viewPortMaxScale: 1,
			viewPortZoomable: 1,
		} ) {
			eventData.stepData[ variable ] =
				eventData.data[ variable ] && parseFloat( eventData.data[ variable ] );
		}
	} );
	$.jmpress( 'afterInit', function ( nil, eventData ) {
		var jmpress = this;
		eventData.current.viewPortNamespace = '.jmpress-' + randomString();
		$( window ).bind( 'resize' + eventData.current.viewPortNamespace, function ( event ) {
			$( jmpress ).jmpress( 'reselect', 'resize' );
		} );
		eventData.current.userZoom = 0;
		eventData.current.userTranslateX = 0;
		eventData.current.userTranslateY = 0;
		if ( eventData.settings.viewPort.zoomBindWheel ) {
			$( eventData.settings.fullscreen ? document : this ).bind(
				'mousewheel' +
					eventData.current.viewPortNamespace +
					' DOMMouseScroll' +
					eventData.current.viewPortNamespace,
				function ( event, delta ) {
					delta =
						delta || event.originalEvent.wheelDelta || -event.originalEvent.detail /* mozilla */;
					var direction = delta / Math.abs( delta );
					if ( direction < 0 ) {
						$( eventData.jmpress ).jmpress(
							'zoomOut',
							event.originalEvent.x,
							event.originalEvent.y
						);
					} else if ( direction > 0 ) {
						$( eventData.jmpress ).jmpress(
							'zoomIn',
							event.originalEvent.x,
							event.originalEvent.y
						);
					}
					return false;
				}
			);
		}
		if ( eventData.settings.viewPort.zoomBindMove ) {
			$( eventData.settings.fullscreen ? document : this )
				.bind( 'mousedown' + eventData.current.viewPortNamespace, function ( event ) {
					if ( eventData.current.userZoom ) {
						eventData.current.userTranslating = { x: event.clientX, y: event.clientY };
						event.preventDefault();
						event.stopImmediatePropagation();
					}
				} )
				.bind( 'mousemove' + eventData.current.viewPortNamespace, function ( event ) {
					var userTranslating = eventData.current.userTranslating;
					if ( userTranslating ) {
						$( jmpress ).jmpress(
							'zoomTranslate',
							event.clientX - userTranslating.x,
							event.clientY - userTranslating.y
						);
						userTranslating.x = event.clientX;
						userTranslating.y = event.clientY;
						event.preventDefault();
						event.stopImmediatePropagation();
					}
				} )
				.bind( 'mouseup' + eventData.current.viewPortNamespace, function ( event ) {
					if ( eventData.current.userTranslating ) {
						eventData.current.userTranslating = undefined;
						event.preventDefault();
						event.stopImmediatePropagation();
					}
				} );
		}
	} );
	function maxAbs( value, range ) {
		return Math.max( Math.min( value, range ), -range );
	}
	function zoom( x, y, direction ) {
		var current = $( this ).jmpress( 'current' ),
			settings = $( this ).jmpress( 'settings' ),
			stepData = $( this ).jmpress( 'active' ).data( 'stepData' ),
			container = $( this ).jmpress( 'container' );
		if ( current.userZoom === 0 && direction < 0 ) {
			return;
		}
		var zoomableSteps = stepData.viewPortZoomable || settings.viewPort.zoomable;
		if ( current.userZoom === zoomableSteps && direction > 0 ) {
			return;
		}
		current.userZoom += direction;

		var halfWidth = $( container ).innerWidth() / 2,
			halfHeight = $( container ).innerHeight() / 2;

		x = x ? x - halfWidth : x;
		y = y ? y - halfHeight : y;

		// TODO this is not perfect... too much math... :(
		current.userTranslateX = maxAbs(
			current.userTranslateX - ( direction * x ) / current.zoomOriginWindowScale / zoomableSteps,
			( halfWidth * current.userZoom * current.userZoom ) / zoomableSteps
		);
		current.userTranslateY = maxAbs(
			current.userTranslateY - ( direction * y ) / current.zoomOriginWindowScale / zoomableSteps,
			( halfHeight * current.userZoom * current.userZoom ) / zoomableSteps
		);

		$( this ).jmpress( 'reselect', 'zoom' );
	}
	$.jmpress( 'register', 'zoomIn', function ( x, y ) {
		zoom.call( this, x || 0, y || 0, 1 );
	} );
	$.jmpress( 'register', 'zoomOut', function ( x, y ) {
		zoom.call( this, x || 0, y || 0, -1 );
	} );
	$.jmpress( 'register', 'zoomTranslate', function ( x, y ) {
		var current = $( this ).jmpress( 'current' ),
			settings = $( this ).jmpress( 'settings' ),
			stepData = $( this ).jmpress( 'active' ).data( 'stepData' ),
			container = $( this ).jmpress( 'container' );
		var zoomableSteps = stepData.viewPortZoomable || settings.viewPort.zoomable;
		var halfWidth = $( container ).innerWidth(),
			halfHeight = $( container ).innerHeight();
		current.userTranslateX = maxAbs(
			current.userTranslateX + x / current.zoomOriginWindowScale,
			( halfWidth * current.userZoom * current.userZoom ) / zoomableSteps
		);
		current.userTranslateY = maxAbs(
			current.userTranslateY + y / current.zoomOriginWindowScale,
			( halfHeight * current.userZoom * current.userZoom ) / zoomableSteps
		);
		$( this ).jmpress( 'reselect', 'zoom' );
	} );
	$.jmpress( 'afterDeinit', function ( nil, eventData ) {
		$( eventData.settings.fullscreen ? document : this ).unbind(
			eventData.current.viewPortNamespace
		);
		$( window ).unbind( eventData.current.viewPortNamespace );
	} );
	$.jmpress( 'setActive', function ( step, eventData ) {
		var viewPort = eventData.settings.viewPort;
		var viewPortHeight = eventData.stepData.viewPortHeight || viewPort.height;
		var viewPortWidth = eventData.stepData.viewPortWidth || viewPort.width;
		var viewPortMaxScale = eventData.stepData.viewPortMaxScale || viewPort.maxScale;
		var viewPortMinScale = eventData.stepData.viewPortMinScale || viewPort.minScale;
		// Correct the scale based on the window's size
		var windowScaleY = viewPortHeight && $( eventData.container ).innerHeight() / viewPortHeight;
		var windowScaleX = viewPortWidth && $( eventData.container ).innerWidth() / viewPortWidth;
		var windowScale =
			( windowScaleX || windowScaleY ) &&
			Math.min( windowScaleX || windowScaleY, windowScaleY || windowScaleX );

		if ( windowScale ) {
			windowScale = windowScale || 1;
			if ( viewPortMaxScale ) {
				windowScale = Math.min( windowScale, viewPortMaxScale );
			}
			if ( viewPortMinScale ) {
				windowScale = Math.max( windowScale, viewPortMinScale );
			}

			var zoomableSteps =
				eventData.stepData.viewPortZoomable || eventData.settings.viewPort.zoomable;
			if ( zoomableSteps ) {
				var diff = 1 / windowScale - 1 / viewPortMaxScale;
				diff /= zoomableSteps;
				windowScale = 1 / ( 1 / windowScale - diff * eventData.current.userZoom );
			}

			eventData.target.transform.reverse();
			if ( eventData.current.userTranslateX && eventData.current.userTranslateY ) {
				eventData.target.transform.push( [
					'translate',
					eventData.current.userTranslateX,
					eventData.current.userTranslateY,
					0,
				] );
			} else {
				eventData.target.transform.push( [ 'translate' ] );
			}
			eventData.target.transform.push( [ 'scale', windowScale, windowScale, 1 ] );
			eventData.target.transform.reverse();
			eventData.target.perspectiveScale /= windowScale;
		}
		eventData.current.zoomOriginWindowScale = windowScale;
	} );
	$.jmpress( 'setInactive', function ( step, eventData ) {
		if (
			! eventData.nextStep ||
			! step ||
			$( eventData.nextStep ).attr( 'id' ) !== $( step ).attr( 'id' )
		) {
			eventData.current.userZoom = 0;
			eventData.current.userTranslateX = 0;
			eventData.current.userTranslateY = 0;
		}
	} );
} )( jQuery, document, window );

/*
 * mouse.js
 * Clicking to select a step
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress;

	/* FUNCTIONS */
	function randomString() {
		return '' + Math.round( Math.random() * 100000, 0 );
	}

	/* DEFAULTS */
	$jmpress( 'defaults' ).mouse = {
		clickSelects: true,
	};

	/* HOOKS */
	$jmpress( 'afterInit', function ( nil, eventData ) {
		var settings = eventData.settings,
			stepSelector = settings.stepSelector,
			current = eventData.current,
			jmpress = $( this );
		current.clickableStepsNamespace = '.jmpress-' + randomString();
		jmpress.bind( 'click' + current.clickableStepsNamespace, function ( event ) {
			if ( ! settings.mouse.clickSelects || current.userZoom ) {
				return;
			}

			// get clicked step
			var clickedStep = $( event.target ).closest( stepSelector );

			// clicks on the active step do default
			if ( clickedStep.is( jmpress.jmpress( 'active' ) ) ) {
				return;
			}

			if ( clickedStep.length ) {
				// select the clicked step
				jmpress.jmpress( 'select', clickedStep[ 0 ], 'click' );
				event.preventDefault();
				event.stopPropagation();
			}
		} );
	} );
	$jmpress( 'afterDeinit', function ( nil, eventData ) {
		$( this ).unbind( eventData.current.clickableStepsNamespace );
	} );
} )( jQuery, document, window );
/*
 * mobile.js
 * Adds support for swipe on touch supported browsers
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress;

	/* FUNCTIONS */
	function randomString() {
		return '' + Math.round( Math.random() * 100000, 0 );
	}

	/* HOOKS */
	$jmpress( 'afterInit', function ( step, eventData ) {
		var settings = eventData.settings,
			current = eventData.current,
			jmpress = eventData.jmpress;
		current.mobileNamespace = '.jmpress-' + randomString();
		var data,
			start = [ 0, 0 ];
		$( settings.fullscreen ? document : jmpress )
			.bind( 'touchstart' + current.mobileNamespace, function ( event ) {
				data = event.originalEvent.touches[ 0 ];
				start = [ data.pageX, data.pageY ];
			} )
			.bind( 'touchmove' + current.mobileNamespace, function ( event ) {
				data = event.originalEvent.touches[ 0 ];
				event.preventDefault();
				return false;
			} )
			.bind( 'touchend' + current.mobileNamespace, function ( event ) {
				var end = [ data.pageX, data.pageY ],
					diff = [ end[ 0 ] - start[ 0 ], end[ 1 ] - start[ 1 ] ];

				if ( Math.max( Math.abs( diff[ 0 ] ), Math.abs( diff[ 1 ] ) ) > 50 ) {
					diff = Math.abs( diff[ 0 ] ) > Math.abs( diff[ 1 ] ) ? diff[ 0 ] : diff[ 1 ];
					$( jmpress ).jmpress( diff > 0 ? 'prev' : 'next' );
					event.preventDefault();
					return false;
				}
			} );
	} );
	$jmpress( 'afterDeinit', function ( nil, eventData ) {
		var settings = eventData.settings,
			current = eventData.current,
			jmpress = eventData.jmpress;
		$( settings.fullscreen ? document : jmpress ).unbind( current.mobileNamespace );
	} );
} )( jQuery, document, window );
/*
 * templates.js
 * The amazing template engine
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress,
		templateFromParentIdent = '_template_',
		templateFromApplyIdent = '_applied_template_';

	/* STATIC VARS */
	var templates = {};

	/* FUNCTIONS */
	function addUndefined( target, values, prefix ) {
		for ( var name in values ) {
			var targetName = name;
			if ( prefix ) {
				targetName = prefix + targetName.substr( 0, 1 ).toUpperCase() + targetName.substr( 1 );
			}
			if ( $.isPlainObject( values[ name ] ) ) {
				addUndefined( target, values[ name ], targetName );
			} else if ( target[ targetName ] === undefined ) {
				target[ targetName ] = values[ name ];
			}
		}
	}
	function applyChildrenTemplates( children, templateChildren ) {
		if ( $.isArray( templateChildren ) ) {
			if ( templateChildren.length < children.length ) {
				$.error( 'more nested steps than children in template' );
			} else {
				children.each( function ( idx, child ) {
					child = $( child );
					var tmpl = child.data( templateFromParentIdent ) || {};
					addUndefined( tmpl, templateChildren[ idx ] );
					child.data( templateFromParentIdent, tmpl );
				} );
			}
		} else if ( $.isFunction( templateChildren ) ) {
			children.each( function ( idx, child ) {
				child = $( child );
				var tmpl = child.data( templateFromParentIdent ) || {};
				addUndefined( tmpl, templateChildren( idx, child, children ) );
				child.data( templateFromParentIdent, tmpl );
			} );
		} // TODO: else if(object)
	}
	function applyTemplate( data, element, template, eventData ) {
		if ( template.children ) {
			var children = element.children( eventData.settings.stepSelector );
			applyChildrenTemplates( children, template.children );
		}
		applyTemplateData( data, template );
	}
	function applyTemplateData( data, template ) {
		addUndefined( data, template );
	}

	/* HOOKS */
	$jmpress( 'beforeInitStep', function ( step, eventData ) {
		step = $( step );
		var data = eventData.data,
			templateFromAttr = data.template,
			templateFromApply = step.data( templateFromApplyIdent ),
			templateFromParent = step.data( templateFromParentIdent );
		if ( templateFromAttr ) {
			$.each( templateFromAttr.split( ' ' ), function ( idx, tmpl ) {
				var template = templates[ tmpl ];
				applyTemplate( data, step, template, eventData );
			} );
		}
		if ( templateFromApply ) {
			applyTemplate( data, step, templateFromApply, eventData );
		}
		if ( templateFromParent ) {
			applyTemplate( data, step, templateFromParent, eventData );
			step.data( templateFromParentIdent, null );
			if ( templateFromParent.template ) {
				$.each( templateFromParent.template.split( ' ' ), function ( idx, tmpl ) {
					var template = templates[ tmpl ];
					applyTemplate( data, step, template, eventData );
				} );
			}
		}
	} );
	$jmpress( 'beforeInit', function ( nil, eventData ) {
		var data = $jmpress( 'dataset', this ),
			dataTemplate = data.template,
			stepSelector = eventData.settings.stepSelector;
		if ( dataTemplate ) {
			var template = templates[ dataTemplate ];
			applyChildrenTemplates(
				$( this )
					.find( stepSelector )
					.filter( function () {
						return ! $( this ).parent().is( stepSelector );
					} ),
				template.children
			);
		}
	} );

	/* EXPORTED FUNCTIONS */
	$jmpress( 'register', 'template', function ( name, tmpl ) {
		if ( templates[ name ] ) {
			templates[ name ] = $.extend( true, {}, templates[ name ], tmpl );
		} else {
			templates[ name ] = $.extend( true, {}, tmpl );
		}
	} );
	$jmpress( 'register', 'apply', function ( selector, tmpl ) {
		if ( ! tmpl ) {
			// TODO ERROR because settings not found
			var stepSelector = $( this ).jmpress( 'settings' ).stepSelector;
			applyChildrenTemplates(
				$( this )
					.find( stepSelector )
					.filter( function () {
						return ! $( this ).parent().is( stepSelector );
					} ),
				selector
			);
		} else if ( $.isArray( tmpl ) ) {
			applyChildrenTemplates( $( selector ), tmpl );
		} else {
			var template;
			if ( typeof tmpl === 'string' ) {
				template = templates[ tmpl ];
			} else {
				template = $.extend( true, {}, tmpl );
			}
			$( selector ).each( function ( idx, element ) {
				element = $( element );
				var tmpl = element.data( templateFromApplyIdent ) || {};
				addUndefined( tmpl, template );
				element.data( templateFromApplyIdent, tmpl );
			} );
		}
	} );
} )( jQuery, document, window );
/*
 * jqevents.js
 * Fires jQuery events
 */
( function ( $, document, window, undefined ) {
	'use strict';

	/* HOOKS */
	// the events should not bubble up the tree
	// elsewise nested jmpress would cause buggy behavior
	$.jmpress( 'setActive', function ( step, eventData ) {
		if ( eventData.prevStep !== step ) {
			$( step ).triggerHandler( 'enterStep' );
		}
	} );
	$.jmpress( 'setInactive', function ( step, eventData ) {
		if ( eventData.nextStep !== step ) {
			$( step ).triggerHandler( 'leaveStep' );
		}
	} );
} )( jQuery, document, window );
/*
 * animation.js
 * Apply custom animations to steps
 */
( function ( $, document, window, undefined ) {
	'use strict';

	function parseSubstepInfo( str ) {
		var arr = str.split( ' ' );
		var className = arr[ 0 ];
		var config = {
			willClass: 'will-' + className,
			doClass: 'do-' + className,
			hasClass: 'has-' + className,
		};
		var state = '';
		for ( var i = 1; i < arr.length; i++ ) {
			var s = arr[ i ];
			switch ( state ) {
				case '':
					if ( s === 'after' ) {
						state = 'after';
					} else {
						$.warn( "unknown keyword in '" + str + "'. '" + s + "' unknown." );
					}
					break;
				case 'after':
					if ( s.match( /^[1-9][0-9]*m?s?/ ) ) {
						var value = parseFloat( s );
						if ( s.indexOf( 'ms' ) !== -1 ) {
							value *= 1;
						} else if ( s.indexOf( 's' ) !== -1 ) {
							value *= 1000;
						} else if ( s.indexOf( 'm' ) !== -1 ) {
							value *= 60000;
						}
						config.delay = value;
					} else {
						config.after = Array.prototype.slice.call( arr, i ).join( ' ' );
						i = arr.length;
					}
			}
		}
		return config;
	}
	function find( array, selector, start, end ) {
		end = end || array.length - 1;
		start = start || 0;
		for ( var i = start; i < end + 1; i++ ) {
			if ( $( array[ i ].element ).is( selector ) ) {
				return i;
			}
		}
	}
	function addOn( list, substep, delay ) {
		$.each( substep._on, function ( idx, child ) {
			list.push( { substep: child.substep, delay: child.delay + delay } );
			addOn( list, child.substep, child.delay + delay );
		} );
	}
	$.jmpress( 'defaults' ).customAnimationDataAttribute = 'jmpress';
	$.jmpress( 'afterInit', function ( nil, eventData ) {
		eventData.current.animationTimeouts = [];
		eventData.current.animationCleanupWaiting = [];
	} );
	$.jmpress( 'applyStep', function ( step, eventData ) {
		// read custom animation from elements
		var substepsData = {};
		var listOfSubsteps = [];
		$( step )
			.find( '[data-' + eventData.settings.customAnimationDataAttribute + ']' )
			.each( function ( idx, element ) {
				if ( $( element ).closest( eventData.settings.stepSelector ).is( step ) ) {
					listOfSubsteps.push( { element: element } );
				}
			} );
		if ( listOfSubsteps.length === 0 ) {
			return;
		}
		$.each( listOfSubsteps, function ( idx, substep ) {
			substep.info = parseSubstepInfo(
				$( substep.element ).data( eventData.settings.customAnimationDataAttribute )
			);
			$( substep.element ).addClass( substep.info.willClass );
			substep._on = [];
			substep._after = null;
		} );
		var current = { _after: undefined, _on: [], info: {} }; // virtual zero step
		$.each( listOfSubsteps, function ( idx, substep ) {
			var other = substep.info.after;
			if ( other ) {
				if ( other === 'step' ) {
					other = current;
				} else if ( other === 'prev' ) {
					other = listOfSubsteps[ idx - 1 ];
				} else {
					var index = find( listOfSubsteps, other, 0, idx - 1 );
					if ( index === undefined ) {
						index = find( listOfSubsteps, other );
					}
					other =
						index === undefined || index === idx
							? listOfSubsteps[ idx - 1 ]
							: listOfSubsteps[ index ];
				}
			} else {
				other = listOfSubsteps[ idx - 1 ];
			}
			if ( other ) {
				if ( ! substep.info.delay ) {
					if ( ! other._after ) {
						other._after = substep;
						return;
					}
					other = other._after;
				}
				other._on.push( { substep: substep, delay: substep.info.delay || 0 } );
			}
		} );
		if ( current._after === undefined && current._on.length === 0 ) {
			var startStep = find( listOfSubsteps, eventData.stepData.startSubstep ) || 0;
			current._after = listOfSubsteps[ startStep ];
		}
		var substepsInOrder = [];
		function findNextFunc( idx, item ) {
			if ( item.substep._after ) {
				current = item.substep._after;
				return false;
			}
		}
		do {
			var substepList = [ { substep: current, delay: 0 } ];
			addOn( substepList, current, 0 );
			substepsInOrder.push( substepList );
			current = null;
			$.each( substepList, findNextFunc );
		} while ( current );
		substepsData.list = substepsInOrder;
		$( step ).data( 'substepsData', substepsData );
	} );
	$.jmpress( 'unapplyStep', function ( step, eventData ) {
		var substepsData = $( step ).data( 'substepsData' );
		if ( substepsData ) {
			$.each( substepsData.list, function ( idx, activeSubsteps ) {
				$.each( activeSubsteps, function ( idx, substep ) {
					if ( substep.substep.info.willClass ) {
						$( substep.substep.element ).removeClass( substep.substep.info.willClass );
					}
					if ( substep.substep.info.hasClass ) {
						$( substep.substep.element ).removeClass( substep.substep.info.hasClass );
					}
					if ( substep.substep.info.doClass ) {
						$( substep.substep.element ).removeClass( substep.substep.info.doClass );
					}
				} );
			} );
		}
	} );
	$.jmpress( 'setActive', function ( step, eventData ) {
		var substepsData = $( step ).data( 'substepsData' );
		if ( ! substepsData ) {
			return;
		}
		if ( eventData.substep === undefined ) {
			eventData.substep = eventData.reason === 'prev' ? substepsData.list.length - 1 : 0;
		}
		var substep = eventData.substep;
		$.each( eventData.current.animationTimeouts, function ( idx, timeout ) {
			clearTimeout( timeout );
		} );
		eventData.current.animationTimeouts = [];
		$.each( substepsData.list, function ( idx, activeSubsteps ) {
			var applyHas = idx < substep;
			var applyDo = idx <= substep;
			$.each( activeSubsteps, function ( idx, substep ) {
				if ( substep.substep.info.hasClass ) {
					$( substep.substep.element )[ ( applyHas ? 'add' : 'remove' ) + 'Class' ](
						substep.substep.info.hasClass
					);
				}
				function applyIt() {
					$( substep.substep.element ).addClass( substep.substep.info.doClass );
				}
				if ( applyDo && ! applyHas && substep.delay && eventData.reason !== 'prev' ) {
					if ( substep.substep.info.doClass ) {
						$( substep.substep.element ).removeClass( substep.substep.info.doClass );
						eventData.current.animationTimeouts.push( setTimeout( applyIt, substep.delay ) );
					}
				} else {
					if ( substep.substep.info.doClass ) {
						$( substep.substep.element )[ ( applyDo ? 'add' : 'remove' ) + 'Class' ](
							substep.substep.info.doClass
						);
					}
				}
			} );
		} );
	} );
	$.jmpress( 'setInactive', function ( step, eventData ) {
		if ( eventData.nextStep === step ) {
			return;
		}
		function cleanupAnimation( substepsData ) {
			$.each( substepsData.list, function ( idx, activeSubsteps ) {
				$.each( activeSubsteps, function ( idx, substep ) {
					if ( substep.substep.info.hasClass ) {
						$( substep.substep.element ).removeClass( substep.substep.info.hasClass );
					}
					if ( substep.substep.info.doClass ) {
						$( substep.substep.element ).removeClass( substep.substep.info.doClass );
					}
				} );
			} );
		}
		$.each( eventData.current.animationCleanupWaiting, function ( idx, item ) {
			cleanupAnimation( item );
		} );
		eventData.current.animationCleanupWaiting = [];
		var substepsData = $( step ).data( 'substepsData' );
		if ( substepsData ) {
			eventData.current.animationCleanupWaiting.push( substepsData );
		}
	} );
	$.jmpress( 'selectNext', function ( step, eventData ) {
		if ( eventData.substep === undefined ) {
			return;
		}
		var substepsData = $( step ).data( 'substepsData' );
		if ( ! substepsData ) {
			return;
		}
		if ( eventData.substep < substepsData.list.length - 1 ) {
			return { step: step, substep: eventData.substep + 1 };
		}
	} );
	$.jmpress( 'selectPrev', function ( step, eventData ) {
		if ( eventData.substep === undefined ) {
			return;
		}
		var substepsData = $( step ).data( 'substepsData' );
		if ( ! substepsData ) {
			return;
		}
		if ( eventData.substep > 0 ) {
			return { step: step, substep: eventData.substep - 1 };
		}
	} );
} )( jQuery, document, window );
/*
 * jmpress.toggle plugin
 * For binding a key to toggle de/initialization of jmpress.js.
 */
/*!
 * plugin for jmpress.js v0.4.5
 *
 * Copyright 2013 Kyle Robinson Young @shama & Tobias Koppers @sokra
 * Licensed MIT
 * http://www.opensource.org/licenses/mit-license.php
 */ ( function ( $, document, window, undefined ) {
	'use strict';
	$.jmpress( 'register', 'toggle', function ( key, config, initial ) {
		var jmpress = this;
		$( document ).bind( 'keydown', function ( event ) {
			if ( event.keyCode === key ) {
				if ( $( jmpress ).jmpress( 'initialized' ) ) {
					$( jmpress ).jmpress( 'deinit' );
				} else {
					$( jmpress ).jmpress( config );
				}
			}
		} );
		if ( initial ) {
			$( jmpress ).jmpress( config );
		}
	} );
} )( jQuery, document, window );

/*
 * jmpress.secondary plugin
 * Apply a secondary animation when step is selected.
 */
( function ( $, document, window, undefined ) {
	'use strict';
	$.jmpress( 'initStep', function ( step, eventData ) {
		for ( var name in eventData.data ) {
			if ( name.indexOf( 'secondary' ) === 0 ) {
				eventData.stepData[ name ] = eventData.data[ name ];
			}
		}
	} );
	function exchangeIf( childStepData, condition, step ) {
		if (
			childStepData.secondary &&
			childStepData.secondary.split( ' ' ).indexOf( condition ) !== -1
		) {
			for ( var name in childStepData ) {
				if ( name.length > 9 && name.indexOf( 'secondary' ) === 0 ) {
					var tmp = childStepData[ name ];
					var normal = name.substr( 9 );
					normal = normal.substr( 0, 1 ).toLowerCase() + normal.substr( 1 );
					childStepData[ name ] = childStepData[ normal ];
					childStepData[ normal ] = tmp;
				}
			}
			$( this ).jmpress( 'reapply', $( step ) );
		}
	}
	$.jmpress( 'beforeActive', function ( step, eventData ) {
		exchangeIf.call( eventData.jmpress, $( step ).data( 'stepData' ), 'self', step );
		var parent = $( step ).parent();
		$( parent )
			.children( eventData.settings.stepSelector )
			.each( function ( idx, child ) {
				var childStepData = $( child ).data( 'stepData' );
				exchangeIf.call( eventData.jmpress, childStepData, 'siblings', child );
			} );
		function grandchildrenFunc( idx, child ) {
			var childStepData = $( child ).data( 'stepData' );
			exchangeIf.call( eventData.jmpress, childStepData, 'grandchildren', child );
		}
		for ( var i = 1; i < eventData.parents.length; i++ ) {
			$( eventData.parents[ i ] ).children( eventData.settings.stepSelector ).each();
		}
	} );
	$.jmpress( 'setInactive', function ( step, eventData ) {
		exchangeIf.call( eventData.jmpress, $( step ).data( 'stepData' ), 'self', step );
		var parent = $( step ).parent();
		$( parent )
			.children( eventData.settings.stepSelector )
			.each( function ( idx, child ) {
				var childStepData = $( child ).data( 'stepData' );
				exchangeIf.call( eventData.jmpress, childStepData, 'siblings', child );
			} );
		function grandchildrenFunc( idx, child ) {
			var childStepData = $( child ).data( 'stepData' );
			exchangeIf.call( eventData.jmpress, childStepData, 'grandchildren', child );
		}
		for ( var i = 1; i < eventData.parents.length; i++ ) {
			$( eventData.parents[ i ] )
				.children( eventData.settings.stepSelector )
				.each( grandchildrenFunc );
		}
	} );
} )( jQuery, document, window );

/*
 * jmpress.duration plugin
 * For auto advancing steps after a given duration and optionally displaying a
 * progress bar.
 */
( function ( $, document, window, undefined ) {
	'use strict';

	$.jmpress( 'defaults' ).duration = {
		defaultValue: -1,
		defaultAction: 'next',
		barSelector: undefined,
		barProperty: 'width',
		barPropertyStart: '0',
		barPropertyEnd: '100%',
	};
	$.jmpress( 'initStep', function ( step, eventData ) {
		eventData.stepData.duration =
			eventData.data.duration && parseInt( eventData.data.duration, 10 );
		eventData.stepData.durationAction = eventData.data.durationAction;
	} );
	$.jmpress( 'setInactive', function ( step, eventData ) {
		var settings = eventData.settings,
			durationSettings = settings.duration,
			current = eventData.current;
		var dur = eventData.stepData.duration || durationSettings.defaultValue;
		if ( current.durationTimeout ) {
			if ( durationSettings.barSelector ) {
				var css = {
					transitionProperty: durationSettings.barProperty,
					transitionDuration: '0',
					transitionDelay: '0',
					transitionTimingFunction: 'linear',
				};
				css[ durationSettings.barProperty ] = durationSettings.barPropertyStart;
				var bars = $( durationSettings.barSelector );
				$.jmpress( 'css', bars, css );
				bars.each( function ( idx, element ) {
					var next = $( element ).next();
					var parent = $( element ).parent();
					$( element ).detach();
					if ( next.length ) {
						next.insertBefore( element );
					} else {
						parent.append( element );
					}
				} );
			}
			clearTimeout( current.durationTimeout );
			delete current.durationTimeout;
		}
	} );
	$.jmpress( 'setActive', function ( step, eventData ) {
		var settings = eventData.settings,
			durationSettings = settings.duration,
			current = eventData.current;
		var dur = eventData.stepData.duration || durationSettings.defaultValue;
		if ( dur && dur > 0 ) {
			if ( durationSettings.barSelector ) {
				var css = {
					transitionProperty: durationSettings.barProperty,
					transitionDuration: dur - ( settings.transitionDuration * 2 ) / 3 - 100 + 'ms',
					transitionDelay: ( settings.transitionDuration * 2 ) / 3 + 'ms',
					transitionTimingFunction: 'linear',
				};
				css[ durationSettings.barProperty ] = durationSettings.barPropertyEnd;
				$.jmpress( 'css', $( durationSettings.barSelector ), css );
			}
			var jmpress = this;
			if ( current.durationTimeout ) {
				clearTimeout( current.durationTimeout );
				current.durationTimeout = undefined;
			}
			current.durationTimeout = setTimeout( function () {
				var action = eventData.stepData.durationAction || durationSettings.defaultAction;
				$( jmpress ).jmpress( action );
			}, dur );
		}
	} );
} )( jQuery, document, window );

/*
 * jmpress.presentation-mode plugin
 * Display a window for the presenter with notes and a control and view of the
 * presentation
 */
( function ( $, document, window, undefined ) {
	'use strict';
	var $jmpress = $.jmpress;

	var PREFIX = 'jmpress-presentation-';

	/* FUNCTIONS */
	function randomString() {
		return '' + Math.round( Math.random() * 100000, 0 );
	}

	/* DEFAULTS */
	$jmpress( 'defaults' ).presentationMode = {
		use: true,
		url: 'presentation-screen.html',
		notesUrl: false,
		transferredValues: [ 'userZoom', 'userTranslateX', 'userTranslateY' ],
	};
	$jmpress( 'defaults' ).keyboard.keys[ 80 ] = 'presentationPopup'; // p key

	/* HOOKS */
	$jmpress( 'afterInit', function ( nil, eventData ) {
		var current = eventData.current;

		current.selectMessageListeners = [];

		if ( eventData.settings.presentationMode.use ) {
			window.addEventListener( 'message', function ( event ) {
				// We do not test orgin, because we want to accept messages
				// from all orgins
				try {
					if ( typeof event.data !== 'string' || event.data.indexOf( PREFIX ) !== 0 ) {
						return;
					}
					var json = JSON.parse( event.data.slice( PREFIX.length ) );
					switch ( json.type ) {
						case 'select':
							$.each( eventData.settings.presentationMode.transferredValues, function (
								idx,
								name
							) {
								eventData.current[ name ] = json[ name ];
							} );
							if (
								/[a-z0-9\-]+/i.test( json.targetId ) &&
								typeof json.substep in { number: 1, undefined: 1 }
							) {
								$( eventData.jmpress ).jmpress(
									'select',
									{ step: '#' + json.targetId, substep: json.substep },
									json.reason
								);
							} else {
								$.error(
									'For security reasons the targetId must match /[a-z0-9\\-]+/i and substep must be a number.'
								);
							}
							break;
						case 'listen':
							current.selectMessageListeners.push( event.source );
							break;
						case 'ok':
							clearTimeout( current.presentationPopupTimeout );
							break;
						case 'read':
							try {
								event.source.postMessage(
									PREFIX +
										JSON.stringify( {
											type: 'url',
											url: window.location.href,
											notesUrl: eventData.settings.presentationMode.notesUrl,
										} ),
									'*'
								);
							} catch ( e ) {
								$.error( 'Cannot post message to source: ' + e );
							}
							break;
						default:
							throw 'Unknown message type: ' + json.type;
					}
				} catch ( e ) {
					$.error( 'Received message is malformed: ' + e );
				}
			} );
			try {
				if ( window.parent && window.parent !== window ) {
					window.parent.postMessage(
						PREFIX +
							JSON.stringify( {
								type: 'afterInit',
							} ),
						'*'
					);
				}
			} catch ( e ) {
				$.error( 'Cannot post message to parent: ' + e );
			}
		}
	} );
	$jmpress( 'afterDeinit', function ( nil, eventData ) {
		if ( eventData.settings.presentationMode.use ) {
			try {
				if ( window.parent && window.parent !== window ) {
					window.parent.postMessage(
						PREFIX +
							JSON.stringify( {
								type: 'afterDeinit',
							} ),
						'*'
					);
				}
			} catch ( e ) {
				$.error( 'Cannot post message to parent: ' + e );
			}
		}
	} );
	$jmpress( 'setActive', function ( step, eventData ) {
		var stepId = $( eventData.delegatedFrom ).attr( 'id' ),
			substep = eventData.substep,
			reason = eventData.reason;
		$.each( eventData.current.selectMessageListeners, function ( idx, listener ) {
			try {
				var msg = {
					type: 'select',
					targetId: stepId,
					substep: substep,
					reason: reason,
				};
				$.each( eventData.settings.presentationMode.transferredValues, function ( idx, name ) {
					msg[ name ] = eventData.current[ name ];
				} );
				listener.postMessage( PREFIX + JSON.stringify( msg ), '*' );
			} catch ( e ) {
				$.error( 'Cannot post message to listener: ' + e );
			}
		} );
	} );
	$jmpress( 'register', 'presentationPopup', function () {
		function trySend() {
			jmpress.jmpress( 'current' ).presentationPopupTimeout = setTimeout( trySend, 100 );
			try {
				popup.postMessage(
					PREFIX +
						JSON.stringify( {
							type: 'url',
							url: window.location.href,
							notesUrl: jmpress.jmpress( 'settings' ).presentationMode.notesUrl,
						} ),
					'*'
				);
			} catch ( e ) {}
		}
		var jmpress = $( this ),
			popup;
		if ( jmpress.jmpress( 'settings' ).presentationMode.use ) {
			popup = window.open( $( this ).jmpress( 'settings' ).presentationMode.url );
			jmpress.jmpress( 'current' ).presentationPopupTimeout = setTimeout( trySend, 100 );
		}
	} );
} )( jQuery, document, window );