/*! Magnific Popup - v0.9.9 - 2013-12-04

* http://dimsemenov.com/plugins/magnific-popup/

* Copyright (c) 2013 Dmitry Semenov; */

;(function($) {



/*>>core*/

/**

 *

 * Magnific Popup Core JS file

 *

 */





/**

 * Private static constants

 */

var CLOSE_EVENT = 'Close',

	BEFORE_CLOSE_EVENT = 'BeforeClose',

	AFTER_CLOSE_EVENT = 'AfterClose',

	BEFORE_APPEND_EVENT = 'BeforeAppend',

	MARKUP_PARSE_EVENT = 'MarkupParse',

	OPEN_EVENT = 'Open',

	CHANGE_EVENT = 'Change',

	NS = 'mfp',

	EVENT_NS = '.' + NS,

	READY_CLASS = 'mfp-ready',

	REMOVING_CLASS = 'mfp-removing',

	PREVENT_CLOSE_CLASS = 'mfp-prevent-close';





/**

 * Private vars

 */

var mfp, // As we have only one instance of MagnificPopup object, we define it locally to not to use 'this'

	MagnificPopup = function(){},

	_isJQ = !!(window.jQuery),

	_prevStatus,

	_window = $(window),

	_body,

	_document,

	_prevContentType,

	_wrapClasses,

	_currPopupType;





/**

 * Private functions

 */

var _mfpOn = function(name, f) {

		mfp.ev.on(NS + name + EVENT_NS, f);

	},

	_getEl = function(className, appendTo, html, raw) {

		var el = document.createElement('div');

		el.className = 'mfp-'+className;

		if(html) {

			el.innerHTML = html;

		}

		if(!raw) {

			el = $(el);

			if(appendTo) {

				el.appendTo(appendTo);

			}

		} else if(appendTo) {

			appendTo.appendChild(el);

		}

		return el;

	},

	_mfpTrigger = function(e, data) {

		mfp.ev.triggerHandler(NS + e, data);



		if(mfp.st.callbacks) {

			// converts "mfpEventName" to "eventName" callback and triggers it if it's present

			e = e.charAt(0).toLowerCase() + e.slice(1);

			if(mfp.st.callbacks[e]) {

				mfp.st.callbacks[e].apply(mfp, $.isArray(data) ? data : [data]);

			}

		}

	},

	_getCloseBtn = function(type) {

		if(type !== _currPopupType || !mfp.currTemplate.closeBtn) {

			mfp.currTemplate.closeBtn = $( mfp.st.closeMarkup.replace('%title%', mfp.st.tClose ) );

			_currPopupType = type;

		}

		return mfp.currTemplate.closeBtn;

	},

	// Initialize Magnific Popup only when called at least once

	_checkInstance = function() {

		if(!$.magnificPopup.instance) {

			mfp = new MagnificPopup();

			mfp.init();

			$.magnificPopup.instance = mfp;

		}

	},

	// CSS transition detection, http://stackoverflow.com/questions/7264899/detect-css-transitions-using-javascript-and-without-modernizr

	supportsTransitions = function() {

		var s = document.createElement('p').style, // 's' for style. better to create an element if body yet to exist

			v = ['ms','O','Moz','Webkit']; // 'v' for vendor



		if( s['transition'] !== undefined ) {

			return true;

		}



		while( v.length ) {

			if( v.pop() + 'Transition' in s ) {

				return true;

			}

		}



		return false;

	};







/**

 * Public functions

 */

MagnificPopup.prototype = {



	constructor: MagnificPopup,



	/**

	 * Initializes Magnific Popup plugin.

	 * This function is triggered only once when $.fn.magnificPopup or $.magnificPopup is executed

	 */

	init: function() {

		var appVersion = navigator.appVersion;

		mfp.isIE7 = appVersion.indexOf("MSIE 7.") !== -1;

		mfp.isIE8 = appVersion.indexOf("MSIE 8.") !== -1;

		mfp.isLowIE = mfp.isIE7 || mfp.isIE8;

		mfp.isAndroid = (/android/gi).test(appVersion);

		mfp.isIOS = (/iphone|ipad|ipod/gi).test(appVersion);

		mfp.supportsTransition = supportsTransitions();



		// We disable fixed positioned lightbox on devices that don't handle it nicely.

		// If you know a better way of detecting this - let me know.

		mfp.probablyMobile = (mfp.isAndroid || mfp.isIOS || /(Opera Mini)|Kindle|webOS|BlackBerry|(Opera Mobi)|(Windows Phone)|IEMobile/i.test(navigator.userAgent) );

		_document = $(document);



		mfp.popupsCache = {};

	},



	/**

	 * Opens popup

	 * @param  data [description]

	 */

	open: function(data) {



		if(!_body) {

			_body = $(document.body);

		}



		var i;



		if(data.isObj === false) {

			// convert jQuery collection to array to avoid conflicts later

			mfp.items = data.items.toArray();



			mfp.index = 0;

			var items = data.items,

				item;

			for(i = 0; i < items.length; i++) {

				item = items[i];

				if(item.parsed) {

					item = item.el[0];

				}

				if(item === data.el[0]) {

					mfp.index = i;

					break;

				}

			}

		} else {

			mfp.items = $.isArray(data.items) ? data.items : [data.items];

			mfp.index = data.index || 0;

		}



		// if popup is already opened - we just update the content

		if(mfp.isOpen) {

			mfp.updateItemHTML();

			return;

		}



		mfp.types = [];

		_wrapClasses = '';

		if(data.mainEl && data.mainEl.length) {

			mfp.ev = data.mainEl.eq(0);

		} else {

			mfp.ev = _document;

		}



		if(data.key) {

			if(!mfp.popupsCache[data.key]) {

				mfp.popupsCache[data.key] = {};

			}

			mfp.currTemplate = mfp.popupsCache[data.key];

		} else {

			mfp.currTemplate = {};

		}







		mfp.st = $.extend(true, {}, $.magnificPopup.defaults, data );

		mfp.fixedContentPos = mfp.st.fixedContentPos === 'auto' ? !mfp.probablyMobile : mfp.st.fixedContentPos;



		if(mfp.st.modal) {

			mfp.st.closeOnContentClick = false;

			mfp.st.closeOnBgClick = false;

			mfp.st.showCloseBtn = false;

			mfp.st.enableEscapeKey = false;

		}





		// Building markup

		// main containers are created only once

		if(!mfp.bgOverlay) {



			// Dark overlay

			mfp.bgOverlay = _getEl('bg').on('click'+EVENT_NS, function() {

				mfp.close();

			});



			mfp.wrap = _getEl('wrap').attr('tabindex', -1).on('click'+EVENT_NS, function(e) {

				if(mfp._checkIfClose(e.target)) {

					mfp.close();

				}

			});



			mfp.container = _getEl('container', mfp.wrap);

		}



		mfp.contentContainer = _getEl('content');

		if(mfp.st.preloader) {

			mfp.preloader = _getEl('preloader', mfp.container, mfp.st.tLoading);

		}





		// Initializing modules

		var modules = $.magnificPopup.modules;

		for(i = 0; i < modules.length; i++) {

			var n = modules[i];

			n = n.charAt(0).toUpperCase() + n.slice(1);

			mfp['init'+n].call(mfp);

		}

		_mfpTrigger('BeforeOpen');





		if(mfp.st.showCloseBtn) {

			// Close button

			if(!mfp.st.closeBtnInside) {

				mfp.wrap.append( _getCloseBtn() );

			} else {

				_mfpOn(MARKUP_PARSE_EVENT, function(e, template, values, item) {

					values.close_replaceWith = _getCloseBtn(item.type);

				});

				_wrapClasses += ' mfp-close-btn-in';

			}

		}



		if(mfp.st.alignTop) {

			_wrapClasses += ' mfp-align-top';

		}







		if(mfp.fixedContentPos) {

			mfp.wrap.css({

				overflow: mfp.st.overflowY,

				overflowX: 'hidden',

				overflowY: mfp.st.overflowY

			});

		} else {

			mfp.wrap.css({

				top: _window.scrollTop(),

				position: 'absolute'

			});

		}

		if( mfp.st.fixedBgPos === false || (mfp.st.fixedBgPos === 'auto' && !mfp.fixedContentPos) ) {

			mfp.bgOverlay.css({

				height: _document.height(),

				position: 'absolute'

			});

		}







		if(mfp.st.enableEscapeKey) {

			// Close on ESC key

			_document.on('keyup' + EVENT_NS, function(e) {

				if(e.keyCode === 27) {

					mfp.close();

				}

			});

		}



		_window.on('resize' + EVENT_NS, function() {

			mfp.updateSize();

		});





		if(!mfp.st.closeOnContentClick) {

			_wrapClasses += ' mfp-auto-cursor';

		}



		if(_wrapClasses)

			mfp.wrap.addClass(_wrapClasses);





		// this triggers recalculation of layout, so we get it once to not to trigger twice

		var windowHeight = mfp.wH = _window.height();





		var windowStyles = {};



		if( mfp.fixedContentPos ) {

            if(mfp._hasScrollBar(windowHeight)){

                var s = mfp._getScrollbarSize();

                if(s) {

                    windowStyles.marginRight = s;

                }

            }

        }



		if(mfp.fixedContentPos) {

			if(!mfp.isIE7) {

				windowStyles.overflow = 'hidden';

			} else {

				// ie7 double-scroll bug

				$('body, html').css('overflow', 'hidden');

			}

		}







		var classesToadd = mfp.st.mainClass;

		if(mfp.isIE7) {

			classesToadd += ' mfp-ie7';

		}

		if(classesToadd) {

			mfp._addClassToMFP( classesToadd );

		}



		// add content

		mfp.updateItemHTML();



		_mfpTrigger('BuildControls');



		// remove scrollbar, add margin e.t.c

		$('html').css(windowStyles);



		// add everything to DOM

		mfp.bgOverlay.add(mfp.wrap).prependTo( mfp.st.prependTo || _body );



		// Save last focused element

		mfp._lastFocusedEl = document.activeElement;



		// Wait for next cycle to allow CSS transition

		setTimeout(function() {



			if(mfp.content) {

				mfp._addClassToMFP(READY_CLASS);

				mfp._setFocus();

			} else {

				// if content is not defined (not loaded e.t.c) we add class only for BG

				mfp.bgOverlay.addClass(READY_CLASS);

			}



			// Trap the focus in popup

			_document.on('focusin' + EVENT_NS, mfp._onFocusIn);



		}, 16);



		mfp.isOpen = true;

		mfp.updateSize(windowHeight);

		_mfpTrigger(OPEN_EVENT);



		return data;

	},



	/**

	 * Closes the popup

	 */

	close: function() {

		if(!mfp.isOpen) return;

		_mfpTrigger(BEFORE_CLOSE_EVENT);



		mfp.isOpen = false;

		// for CSS3 animation

		if(mfp.st.removalDelay && !mfp.isLowIE && mfp.supportsTransition )  {

			mfp._addClassToMFP(REMOVING_CLASS);

			setTimeout(function() {

				mfp._close();

			}, mfp.st.removalDelay);

		} else {

			mfp._close();

		}

	},



	/**

	 * Helper for close() function

	 */

	_close: function() {

		_mfpTrigger(CLOSE_EVENT);



		var classesToRemove = REMOVING_CLASS + ' ' + READY_CLASS + ' ';



		mfp.bgOverlay.detach();

		mfp.wrap.detach();

		mfp.container.empty();



		if(mfp.st.mainClass) {

			classesToRemove += mfp.st.mainClass + ' ';

		}



		mfp._removeClassFromMFP(classesToRemove);



		if(mfp.fixedContentPos) {

			var windowStyles = {marginRight: ''};

			if(mfp.isIE7) {

				$('body, html').css('overflow', '');

			} else {

				windowStyles.overflow = '';

			}

			$('html').css(windowStyles);

		}



		_document.off('keyup' + EVENT_NS + ' focusin' + EVENT_NS);

		mfp.ev.off(EVENT_NS);



		// clean up DOM elements that aren't removed

		mfp.wrap.attr('class', 'mfp-wrap').removeAttr('style');

		mfp.bgOverlay.attr('class', 'mfp-bg');

		mfp.container.attr('class', 'mfp-container');



		// remove close button from target element

		if(mfp.st.showCloseBtn &&

		(!mfp.st.closeBtnInside || mfp.currTemplate[mfp.currItem.type] === true)) {

			if(mfp.currTemplate.closeBtn)

				mfp.currTemplate.closeBtn.detach();

		}





		if(mfp._lastFocusedEl) {

			$(mfp._lastFocusedEl).focus(); // put tab focus back

		}

		mfp.currItem = null;

		mfp.content = null;

		mfp.currTemplate = null;

		mfp.prevHeight = 0;



		_mfpTrigger(AFTER_CLOSE_EVENT);

	},



	updateSize: function(winHeight) {



		if(mfp.isIOS) {

			// fixes iOS nav bars https://github.com/dimsemenov/Magnific-Popup/issues/2

			var zoomLevel = document.documentElement.clientWidth / window.innerWidth;

			var height = window.innerHeight * zoomLevel;

			mfp.wrap.css('height', height);

			mfp.wH = height;

		} else {

			mfp.wH = winHeight || _window.height();

		}

		// Fixes #84: popup incorrectly positioned with position:relative on body

		if(!mfp.fixedContentPos) {

			mfp.wrap.css('height', mfp.wH);

		}



		_mfpTrigger('Resize');



	},



	/**

	 * Set content of popup based on current index

	 */

	updateItemHTML: function() {

		var item = mfp.items[mfp.index];



		// Detach and perform modifications

		mfp.contentContainer.detach();



		if(mfp.content)

			mfp.content.detach();



		if(!item.parsed) {

			item = mfp.parseEl( mfp.index );

		}



		var type = item.type;



		_mfpTrigger('BeforeChange', [mfp.currItem ? mfp.currItem.type : '', type]);

		// BeforeChange event works like so:

		// _mfpOn('BeforeChange', function(e, prevType, newType) { });



		mfp.currItem = item;











		if(!mfp.currTemplate[type]) {

			var markup = mfp.st[type] ? mfp.st[type].markup : false;



			// allows to modify markup

			_mfpTrigger('FirstMarkupParse', markup);



			if(markup) {

				mfp.currTemplate[type] = $(markup);

			} else {

				// if there is no markup found we just define that template is parsed

				mfp.currTemplate[type] = true;

			}

		}



		if(_prevContentType && _prevContentType !== item.type) {

			mfp.container.removeClass('mfp-'+_prevContentType+'-holder');

		}



		var newContent = mfp['get' + type.charAt(0).toUpperCase() + type.slice(1)](item, mfp.currTemplate[type]);

		mfp.appendContent(newContent, type);



		item.preloaded = true;



		_mfpTrigger(CHANGE_EVENT, item);

		_prevContentType = item.type;



		// Append container back after its content changed

		mfp.container.prepend(mfp.contentContainer);



		_mfpTrigger('AfterChange');

	},





	/**

	 * Set HTML content of popup

	 */

	appendContent: function(newContent, type) {

		mfp.content = newContent;



		if(newContent) {

			if(mfp.st.showCloseBtn && mfp.st.closeBtnInside &&

				mfp.currTemplate[type] === true) {

				// if there is no markup, we just append close button element inside

				if(!mfp.content.find('.mfp-close').length) {

					mfp.content.append(_getCloseBtn());

				}

			} else {

				mfp.content = newContent;

			}

		} else {

			mfp.content = '';

		}



		_mfpTrigger(BEFORE_APPEND_EVENT);

		mfp.container.addClass('mfp-'+type+'-holder');



		mfp.contentContainer.append(mfp.content);

	},









	/**

	 * Creates Magnific Popup data object based on given data

	 * @param  {int} index Index of item to parse

	 */

	parseEl: function(index) {

		var item = mfp.items[index],

			type = item.type;



		if(item.tagName) {

			item = { el: $(item) };

		} else {

			item = { data: item, src: item.src };

		}



		if(item.el) {

			var types = mfp.types;



			// check for 'mfp-TYPE' class

			for(var i = 0; i < types.length; i++) {

				if( item.el.hasClass('mfp-'+types[i]) ) {

					type = types[i];

					break;

				}

			}



			item.src = item.el.attr('data-mfp-src');

			if(!item.src) {

				item.src = item.el.attr('href');

			}

		}



		item.type = type || mfp.st.type || 'inline';

		item.index = index;

		item.parsed = true;

		mfp.items[index] = item;

		_mfpTrigger('ElementParse', item);



		return mfp.items[index];

	},





	/**

	 * Initializes single popup or a group of popups

	 */

	addGroup: function(el, options) {

		var eHandler = function(e) {

			e.mfpEl = this;

			mfp._openClick(e, el, options);

		};



		if(!options) {

			options = {};

		}



		var eName = 'click.magnificPopup';

		options.mainEl = el;



		if(options.items) {

			options.isObj = true;

			el.off(eName).on(eName, eHandler);

		} else {

			options.isObj = false;

			if(options.delegate) {

				el.off(eName).on(eName, options.delegate , eHandler);

			} else {

				options.items = el;

				el.off(eName).on(eName, eHandler);

			}

		}

	},

	_openClick: function(e, el, options) {

		var midClick = options.midClick !== undefined ? options.midClick : $.magnificPopup.defaults.midClick;





		if(!midClick && ( e.which === 2 || e.ctrlKey || e.metaKey ) ) {

			return;

		}



		var disableOn = options.disableOn !== undefined ? options.disableOn : $.magnificPopup.defaults.disableOn;



		if(disableOn) {

			if($.isFunction(disableOn)) {

				if( !disableOn.call(mfp) ) {

					return true;

				}

			} else { // else it's number

				if( _window.width() < disableOn ) {

					return true;

				}

			}

		}



		if(e.type) {

			e.preventDefault();



			// This will prevent popup from closing if element is inside and popup is already opened

			if(mfp.isOpen) {

				e.stopPropagation();

			}

		}





		options.el = $(e.mfpEl);

		if(options.delegate) {

			options.items = el.find(options.delegate);

		}

		mfp.open(options);

	},





	/**

	 * Updates text on preloader

	 */

	updateStatus: function(status, text) {



		if(mfp.preloader) {

			if(_prevStatus !== status) {

				mfp.container.removeClass('mfp-s-'+_prevStatus);

			}



			if(!text && status === 'loading') {

				text = mfp.st.tLoading;

			}



			var data = {

				status: status,

				text: text

			};

			// allows to modify status

			_mfpTrigger('UpdateStatus', data);



			status = data.status;

			text = data.text;



			mfp.preloader.html(text);



			mfp.preloader.find('a').on('click', function(e) {

				e.stopImmediatePropagation();

			});



			mfp.container.addClass('mfp-s-'+status);

			_prevStatus = status;

		}

	},





	/*

		"Private" helpers that aren't private at all

	 */

	// Check to close popup or not

	// "target" is an element that was clicked

	_checkIfClose: function(target) {



		if($(target).hasClass(PREVENT_CLOSE_CLASS)) {

			return;

		}



		var closeOnContent = mfp.st.closeOnContentClick;

		var closeOnBg = mfp.st.closeOnBgClick;



		if(closeOnContent && closeOnBg) {

			return true;

		} else {



			// We close the popup if click is on close button or on preloader. Or if there is no content.

			if(!mfp.content || $(target).hasClass('mfp-close') || (mfp.preloader && target === mfp.preloader[0]) ) {

				return true;

			}



			// if click is outside the content

			if(  (target !== mfp.content[0] && !$.contains(mfp.content[0], target))  ) {

				if(closeOnBg) {

					// last check, if the clicked element is in DOM, (in case it's removed onclick)

					if( $.contains(document, target) ) {

						return true;

					}

				}

			} else if(closeOnContent) {

				return true;

			}



		}

		return false;

	},

	_addClassToMFP: function(cName) {

		mfp.bgOverlay.addClass(cName);

		mfp.wrap.addClass(cName);

	},

	_removeClassFromMFP: function(cName) {

		this.bgOverlay.removeClass(cName);

		mfp.wrap.removeClass(cName);

	},

	_hasScrollBar: function(winHeight) {

		return (  (mfp.isIE7 ? _document.height() : document.body.scrollHeight) > (winHeight || _window.height()) );

	},

	_setFocus: function() {

		(mfp.st.focus ? mfp.content.find(mfp.st.focus).eq(0) : mfp.wrap).focus();

	},

	_onFocusIn: function(e) {

		if( e.target !== mfp.wrap[0] && !$.contains(mfp.wrap[0], e.target) ) {

			mfp._setFocus();

			return false;

		}

	},

	_parseMarkup: function(template, values, item) {

		var arr;

		if(item.data) {

			values = $.extend(item.data, values);

		}

		_mfpTrigger(MARKUP_PARSE_EVENT, [template, values, item] );



		$.each(values, function(key, value) {

			if(value === undefined || value === false) {

				return true;

			}

			arr = key.split('_');

			if(arr.length > 1) {

				var el = template.find(EVENT_NS + '-'+arr[0]);



				if(el.length > 0) {

					var attr = arr[1];

					if(attr === 'replaceWith') {

						if(el[0] !== value[0]) {

							el.replaceWith(value);

						}

					} else if(attr === 'img') {

						if(el.is('img')) {

							el.attr('src', value);

						} else {

							el.replaceWith( '<img src="'+value+'" class="' + el.attr('class') + '" />' );

						}

					} else {

						el.attr(arr[1], value);

					}

				}



			} else {

				template.find(EVENT_NS + '-'+key).html(value);

			}

		});

	},



	_getScrollbarSize: function() {

		// thx David

		if(mfp.scrollbarSize === undefined) {

			var scrollDiv = document.createElement("div");

			scrollDiv.id = "mfp-sbm";

			scrollDiv.style.cssText = 'width: 99px; height: 99px; overflow: scroll; position: absolute; top: -9999px;';

			document.body.appendChild(scrollDiv);

			mfp.scrollbarSize = scrollDiv.offsetWidth - scrollDiv.clientWidth;

			document.body.removeChild(scrollDiv);

		}

		return mfp.scrollbarSize;

	}



}; /* MagnificPopup core prototype end */









/**

 * Public static functions

 */

$.magnificPopup = {

	instance: null,

	proto: MagnificPopup.prototype,

	modules: [],



	open: function(options, index) {

		_checkInstance();



		if(!options) {

			options = {};

		} else {

			options = $.extend(true, {}, options);

		}





		options.isObj = true;

		options.index = index || 0;

		return this.instance.open(options);

	},



	close: function() {

		return $.magnificPopup.instance && $.magnificPopup.instance.close();

	},



	registerModule: function(name, module) {

		if(module.options) {

			$.magnificPopup.defaults[name] = module.options;

		}

		$.extend(this.proto, module.proto);

		this.modules.push(name);

	},



	defaults: {



		// Info about options is in docs:

		// http://dimsemenov.com/plugins/magnific-popup/documentation.html#options



		disableOn: 0,



		key: null,



		midClick: false,



		mainClass: '',



		preloader: true,



		focus: '', // CSS selector of input to focus after popup is opened



		closeOnContentClick: false,



		closeOnBgClick: true,



		closeBtnInside: true,



		showCloseBtn: true,



		enableEscapeKey: true,



		modal: false,



		alignTop: false,



		removalDelay: 0,



		prependTo: null,



		fixedContentPos: 'auto',



		fixedBgPos: 'auto',



		overflowY: 'auto',



		closeMarkup: '<button title="%title%" type="button" class="mfp-close">&times;</button>',



		tClose: 'Close (Esc)',



		tLoading: 'Loading...'



	}

};







$.fn.magnificPopup = function(options) {

	_checkInstance();



	var jqEl = $(this);



	// We call some API method of first param is a string

	if (typeof options === "string" ) {



		if(options === 'open') {

			var items,

				itemOpts = _isJQ ? jqEl.data('magnificPopup') : jqEl[0].magnificPopup,

				index = parseInt(arguments[1], 10) || 0;



			if(itemOpts.items) {

				items = itemOpts.items[index];

			} else {

				items = jqEl;

				if(itemOpts.delegate) {

					items = items.find(itemOpts.delegate);

				}

				items = items.eq( index );

			}

			mfp._openClick({mfpEl:items}, jqEl, itemOpts);

		} else {

			if(mfp.isOpen)

				mfp[options].apply(mfp, Array.prototype.slice.call(arguments, 1));

		}



	} else {

		// clone options obj

		options = $.extend(true, {}, options);



		/*

		 * As Zepto doesn't support .data() method for objects

		 * and it works only in normal browsers

		 * we assign "options" object directly to the DOM element. FTW!

		 */

		if(_isJQ) {

			jqEl.data('magnificPopup', options);

		} else {

			jqEl[0].magnificPopup = options;

		}



		mfp.addGroup(jqEl, options);



	}

	return jqEl;

};





//Quick benchmark

/*

var start = performance.now(),

	i,

	rounds = 1000;



for(i = 0; i < rounds; i++) {



}

console.log('Test #1:', performance.now() - start);



start = performance.now();

for(i = 0; i < rounds; i++) {



}

console.log('Test #2:', performance.now() - start);

*/





/*>>core*/



/*>>inline*/



var INLINE_NS = 'inline',

	_hiddenClass,

	_inlinePlaceholder,

	_lastInlineElement,

	_putInlineElementsBack = function() {

		if(_lastInlineElement) {

			_inlinePlaceholder.after( _lastInlineElement.addClass(_hiddenClass) ).detach();

			_lastInlineElement = null;

		}

	};



$.magnificPopup.registerModule(INLINE_NS, {

	options: {

		hiddenClass: 'hide', // will be appended with `mfp-` prefix

		markup: '',

		tNotFound: 'Content not found'

	},

	proto: {



		initInline: function() {

			mfp.types.push(INLINE_NS);



			_mfpOn(CLOSE_EVENT+'.'+INLINE_NS, function() {

				_putInlineElementsBack();

			});

		},



		getInline: function(item, template) {



			_putInlineElementsBack();



			if(item.src) {

				var inlineSt = mfp.st.inline,

					el = $(item.src);



				if(el.length) {



					// If target element has parent - we replace it with placeholder and put it back after popup is closed

					var parent = el[0].parentNode;

					if(parent && parent.tagName) {

						if(!_inlinePlaceholder) {

							_hiddenClass = inlineSt.hiddenClass;

							_inlinePlaceholder = _getEl(_hiddenClass);

							_hiddenClass = 'mfp-'+_hiddenClass;

						}

						// replace target inline element with placeholder

						_lastInlineElement = el.after(_inlinePlaceholder).detach().removeClass(_hiddenClass);

					}



					mfp.updateStatus('ready');

				} else {

					mfp.updateStatus('error', inlineSt.tNotFound);

					el = $('<div>');

				}



				item.inlineElement = el;

				return el;

			}



			mfp.updateStatus('ready');

			mfp._parseMarkup(template, {}, item);

			return template;

		}

	}

});



/*>>inline*/



/*>>ajax*/

var AJAX_NS = 'ajax',

	_ajaxCur,

	_removeAjaxCursor = function() {

		if(_ajaxCur) {

			_body.removeClass(_ajaxCur);

		}

	},

	_destroyAjaxRequest = function() {

		_removeAjaxCursor();

		if(mfp.req) {

			mfp.req.abort();

		}

	};



$.magnificPopup.registerModule(AJAX_NS, {



	options: {

		settings: null,

		cursor: 'mfp-ajax-cur',

		tError: '<a href="%url%">The content</a> could not be loaded.'

	},



	proto: {

		initAjax: function() {

			mfp.types.push(AJAX_NS);

			_ajaxCur = mfp.st.ajax.cursor;



			_mfpOn(CLOSE_EVENT+'.'+AJAX_NS, _destroyAjaxRequest);

			_mfpOn('BeforeChange.' + AJAX_NS, _destroyAjaxRequest);

		},

		getAjax: function(item) {



			if(_ajaxCur)

				_body.addClass(_ajaxCur);



			mfp.updateStatus('loading');



			var opts = $.extend({

				url: item.src,

				success: function(data, textStatus, jqXHR) {

					var temp = {

						data:data,

						xhr:jqXHR

					};



					_mfpTrigger('ParseAjax', temp);



					mfp.appendContent( $(temp.data), AJAX_NS );



					item.finished = true;



					_removeAjaxCursor();



					mfp._setFocus();



					setTimeout(function() {

						mfp.wrap.addClass(READY_CLASS);

					}, 16);



					mfp.updateStatus('ready');



					_mfpTrigger('AjaxContentAdded');

				},

				error: function() {

					_removeAjaxCursor();

					item.finished = item.loadError = true;

					mfp.updateStatus('error', mfp.st.ajax.tError.replace('%url%', item.src));

				}

			}, mfp.st.ajax.settings);



			mfp.req = $.ajax(opts);



			return '';

		}

	}

});















/*>>ajax*/



/*>>image*/

var _imgInterval,

	_getTitle = function(item) {

		if(item.data && item.data.title !== undefined)

			return item.data.title;



		var src = mfp.st.image.titleSrc;



		if(src) {

			if($.isFunction(src)) {

				return src.call(mfp, item);

			} else if(item.el) {

				return item.el.attr(src) || '';

			}

		}

		return '';

	};



$.magnificPopup.registerModule('image', {



	options: {

		markup: '<div class="mfp-figure">'+

					'<div class="mfp-close"></div>'+

					'<figure>'+

						'<div class="mfp-img"></div>'+

						'<figcaption>'+

							'<div class="mfp-bottom-bar">'+

								'<div class="mfp-title"></div>'+

								'<div class="mfp-counter"></div>'+

							'</div>'+

						'</figcaption>'+

					'</figure>'+

				'</div>',

		cursor: 'mfp-zoom-out-cur',

		titleSrc: 'title',

		verticalFit: true,

		tError: '<a href="%url%">The image</a> could not be loaded.'

	},



	proto: {

		initImage: function() {

			var imgSt = mfp.st.image,

				ns = '.image';



			mfp.types.push('image');



			_mfpOn(OPEN_EVENT+ns, function() {

				if(mfp.currItem.type === 'image' && imgSt.cursor) {

					_body.addClass(imgSt.cursor);

				}

			});



			_mfpOn(CLOSE_EVENT+ns, function() {

				if(imgSt.cursor) {

					_body.removeClass(imgSt.cursor);

				}

				_window.off('resize' + EVENT_NS);

			});



			_mfpOn('Resize'+ns, mfp.resizeImage);

			if(mfp.isLowIE) {

				_mfpOn('AfterChange', mfp.resizeImage);

			}

		},

		resizeImage: function() {

			var item = mfp.currItem;

			if(!item || !item.img) return;



			if(mfp.st.image.verticalFit) {

				var decr = 0;

				// fix box-sizing in ie7/8

				if(mfp.isLowIE) {

					decr = parseInt(item.img.css('padding-top'), 10) + parseInt(item.img.css('padding-bottom'),10);

				}

				item.img.css('max-height', mfp.wH-decr);

			}

		},

		_onImageHasSize: function(item) {

			if(item.img) {



				item.hasSize = true;



				if(_imgInterval) {

					clearInterval(_imgInterval);

				}



				item.isCheckingImgSize = false;



				_mfpTrigger('ImageHasSize', item);



				if(item.imgHidden) {

					if(mfp.content)

						mfp.content.removeClass('mfp-loading');



					item.imgHidden = false;

				}



			}

		},



		/**

		 * Function that loops until the image has size to display elements that rely on it asap

		 */

		findImageSize: function(item) {



			var counter = 0,

				img = item.img[0],

				mfpSetInterval = function(delay) {



					if(_imgInterval) {

						clearInterval(_imgInterval);

					}

					// decelerating interval that checks for size of an image

					_imgInterval = setInterval(function() {

						if(img.naturalWidth > 0) {

							mfp._onImageHasSize(item);

							return;

						}



						if(counter > 200) {

							clearInterval(_imgInterval);

						}



						counter++;

						if(counter === 3) {

							mfpSetInterval(10);

						} else if(counter === 40) {

							mfpSetInterval(50);

						} else if(counter === 100) {

							mfpSetInterval(500);

						}

					}, delay);

				};



			mfpSetInterval(1);

		},



		getImage: function(item, template) {



			var guard = 0,



				// image load complete handler

				onLoadComplete = function() {

					if(item) {

						if (item.img[0].complete) {

							item.img.off('.mfploader');



							if(item === mfp.currItem){

								mfp._onImageHasSize(item);



								mfp.updateStatus('ready');

							}



							item.hasSize = true;

							item.loaded = true;



							_mfpTrigger('ImageLoadComplete');



						}

						else {

							// if image complete check fails 200 times (20 sec), we assume that there was an error.

							guard++;

							if(guard < 200) {

								setTimeout(onLoadComplete,100);

							} else {

								onLoadError();

							}

						}

					}

				},



				// image error handler

				onLoadError = function() {

					if(item) {

						item.img.off('.mfploader');

						if(item === mfp.currItem){

							mfp._onImageHasSize(item);

							mfp.updateStatus('error', imgSt.tError.replace('%url%', item.src) );

						}



						item.hasSize = true;

						item.loaded = true;

						item.loadError = true;

					}

				},

				imgSt = mfp.st.image;





			var el = template.find('.mfp-img');

			if(el.length) {

				var img = document.createElement('img');

				img.className = 'mfp-img';

				item.img = $(img).on('load.mfploader', onLoadComplete).on('error.mfploader', onLoadError);

				img.src = item.src;



				// without clone() "error" event is not firing when IMG is replaced by new IMG

				// TODO: find a way to avoid such cloning

				if(el.is('img')) {

					item.img = item.img.clone();

				}



				img = item.img[0];

				if(img.naturalWidth > 0) {

					item.hasSize = true;

				} else if(!img.width) {

					item.hasSize = false;

				}

			}



			mfp._parseMarkup(template, {

				title: _getTitle(item),

				img_replaceWith: item.img

			}, item);



			mfp.resizeImage();



			if(item.hasSize) {

				if(_imgInterval) clearInterval(_imgInterval);



				if(item.loadError) {

					template.addClass('mfp-loading');

					mfp.updateStatus('error', imgSt.tError.replace('%url%', item.src) );

				} else {

					template.removeClass('mfp-loading');

					mfp.updateStatus('ready');

				}

				return template;

			}



			mfp.updateStatus('loading');

			item.loading = true;



			if(!item.hasSize) {

				item.imgHidden = true;

				template.addClass('mfp-loading');

				mfp.findImageSize(item);

			}



			return template;

		}

	}

});







/*>>image*/



/*>>zoom*/

var hasMozTransform,

	getHasMozTransform = function() {

		if(hasMozTransform === undefined) {

			hasMozTransform = document.createElement('p').style.MozTransform !== undefined;

		}

		return hasMozTransform;

	};



$.magnificPopup.registerModule('zoom', {



	options: {

		enabled: false,

		easing: 'ease-in-out',

		duration: 300,

		opener: function(element) {

			return element.is('img') ? element : element.find('img');

		}

	},



	proto: {



		initZoom: function() {

			var zoomSt = mfp.st.zoom,

				ns = '.zoom',

				image;



			if(!zoomSt.enabled || !mfp.supportsTransition) {

				return;

			}



			var duration = zoomSt.duration,

				getElToAnimate = function(image) {

					var newImg = image.clone().removeAttr('style').removeAttr('class').addClass('mfp-animated-image'),

						transition = 'all '+(zoomSt.duration/1000)+'s ' + zoomSt.easing,

						cssObj = {

							position: 'fixed',

							zIndex: 9999,

							left: 0,

							top: 0,

							'-webkit-backface-visibility': 'hidden'

						},

						t = 'transition';



					cssObj['-webkit-'+t] = cssObj['-moz-'+t] = cssObj['-o-'+t] = cssObj[t] = transition;



					newImg.css(cssObj);

					return newImg;

				},

				showMainContent = function() {

					mfp.content.css('visibility', 'visible');

				},

				openTimeout,

				animatedImg;



			_mfpOn('BuildControls'+ns, function() {

				if(mfp._allowZoom()) {



					clearTimeout(openTimeout);

					mfp.content.css('visibility', 'hidden');



					// Basically, all code below does is clones existing image, puts in on top of the current one and animated it



					image = mfp._getItemToZoom();



					if(!image) {

						showMainContent();

						return;

					}



					animatedImg = getElToAnimate(image);



					animatedImg.css( mfp._getOffset() );



					mfp.wrap.append(animatedImg);



					openTimeout = setTimeout(function() {

						animatedImg.css( mfp._getOffset( true ) );

						openTimeout = setTimeout(function() {



							showMainContent();



							setTimeout(function() {

								animatedImg.remove();

								image = animatedImg = null;

								_mfpTrigger('ZoomAnimationEnded');

							}, 16); // avoid blink when switching images



						}, duration); // this timeout equals animation duration



					}, 16); // by adding this timeout we avoid short glitch at the beginning of animation





					// Lots of timeouts...

				}

			});

			_mfpOn(BEFORE_CLOSE_EVENT+ns, function() {

				if(mfp._allowZoom()) {



					clearTimeout(openTimeout);



					mfp.st.removalDelay = duration;



					if(!image) {

						image = mfp._getItemToZoom();

						if(!image) {

							return;

						}

						animatedImg = getElToAnimate(image);

					}





					animatedImg.css( mfp._getOffset(true) );

					mfp.wrap.append(animatedImg);

					mfp.content.css('visibility', 'hidden');



					setTimeout(function() {

						animatedImg.css( mfp._getOffset() );

					}, 16);

				}



			});



			_mfpOn(CLOSE_EVENT+ns, function() {

				if(mfp._allowZoom()) {

					showMainContent();

					if(animatedImg) {

						animatedImg.remove();

					}

					image = null;

				}

			});

		},



		_allowZoom: function() {

			return mfp.currItem.type === 'image';

		},



		_getItemToZoom: function() {

			if(mfp.currItem.hasSize) {

				return mfp.currItem.img;

			} else {

				return false;

			}

		},



		// Get element postion relative to viewport

		_getOffset: function(isLarge) {

			var el;

			if(isLarge) {

				el = mfp.currItem.img;

			} else {

				el = mfp.st.zoom.opener(mfp.currItem.el || mfp.currItem);

			}



			var offset = el.offset();

			var paddingTop = parseInt(el.css('padding-top'),10);

			var paddingBottom = parseInt(el.css('padding-bottom'),10);

			offset.top -= ( $(window).scrollTop() - paddingTop );





			/*



			Animating left + top + width/height looks glitchy in Firefox, but perfect in Chrome. And vice-versa.



			 */

			var obj = {

				width: el.width(),

				// fix Zepto height+padding issue

				height: (_isJQ ? el.innerHeight() : el[0].offsetHeight) - paddingBottom - paddingTop

			};



			// I hate to do this, but there is no another option

			if( getHasMozTransform() ) {

				obj['-moz-transform'] = obj['transform'] = 'translate(' + offset.left + 'px,' + offset.top + 'px)';

			} else {

				obj.left = offset.left;

				obj.top = offset.top;

			}

			return obj;

		}



	}

});







/*>>zoom*/



/*>>iframe*/



var IFRAME_NS = 'iframe',

	_emptyPage = '//about:blank',



	_fixIframeBugs = function(isShowing) {

		if(mfp.currTemplate[IFRAME_NS]) {

			var el = mfp.currTemplate[IFRAME_NS].find('iframe');

			if(el.length) {

				// reset src after the popup is closed to avoid "video keeps playing after popup is closed" bug

				if(!isShowing) {

					el[0].src = _emptyPage;

				}



				// IE8 black screen bug fix

				if(mfp.isIE8) {

					el.css('display', isShowing ? 'block' : 'none');

				}

			}

		}

	};



$.magnificPopup.registerModule(IFRAME_NS, {



	options: {

		markup: '<div class="mfp-iframe-scaler">'+

					'<div class="mfp-close"></div>'+

					'<iframe class="mfp-iframe" src="//about:blank" frameborder="0" allowfullscreen></iframe>'+

				'</div>',



		srcAction: 'iframe_src',



		// we don't care and support only one default type of URL by default

		patterns: {

			youtube: {

				index: 'youtube.com',

				id: 'v=',

				src: '//www.youtube.com/embed/%id%?autoplay=1'

			},

			vimeo: {

				index: 'vimeo.com/',

				id: '/',

				src: '//player.vimeo.com/video/%id%?autoplay=1'

			},

			gmaps: {

				index: '//maps.google.',

				src: '%id%&output=embed'

			}

		}

	},



	proto: {

		initIframe: function() {

			mfp.types.push(IFRAME_NS);



			_mfpOn('BeforeChange', function(e, prevType, newType) {

				if(prevType !== newType) {

					if(prevType === IFRAME_NS) {

						_fixIframeBugs(); // iframe if removed

					} else if(newType === IFRAME_NS) {

						_fixIframeBugs(true); // iframe is showing

					}

				}// else {

					// iframe source is switched, don't do anything

				//}

			});



			_mfpOn(CLOSE_EVENT + '.' + IFRAME_NS, function() {

				_fixIframeBugs();

			});

		},



		getIframe: function(item, template) {

			var embedSrc = item.src;

			var iframeSt = mfp.st.iframe;



			$.each(iframeSt.patterns, function() {

				if(embedSrc.indexOf( this.index ) > -1) {

					if(this.id) {

						if(typeof this.id === 'string') {

							embedSrc = embedSrc.substr(embedSrc.lastIndexOf(this.id)+this.id.length, embedSrc.length);

						} else {

							embedSrc = this.id.call( this, embedSrc );

						}

					}

					embedSrc = this.src.replace('%id%', embedSrc );

					return false; // break;

				}

			});



			var dataObj = {};

			if(iframeSt.srcAction) {

				dataObj[iframeSt.srcAction] = embedSrc;

			}

			mfp._parseMarkup(template, dataObj, item);



			mfp.updateStatus('ready');



			return template;

		}

	}

});







/*>>iframe*/



/*>>gallery*/

/**

 * Get looped index depending on number of slides

 */

var _getLoopedId = function(index) {

		var numSlides = mfp.items.length;

		if(index > numSlides - 1) {

			return index - numSlides;

		} else  if(index < 0) {

			return numSlides + index;

		}

		return index;

	},

	_replaceCurrTotal = function(text, curr, total) {

		return text.replace(/%curr%/gi, curr + 1).replace(/%total%/gi, total);

	};



$.magnificPopup.registerModule('gallery', {



	options: {

		enabled: false,

		arrowMarkup: '<button title="%title%" type="button" class="mfp-arrow mfp-arrow-%dir%"></button>',

		preload: [0,2],

		navigateByImgClick: true,

		arrows: true,



		tPrev: 'Previous (Left arrow key)',

		tNext: 'Next (Right arrow key)',

		tCounter: '%curr% of %total%'

	},



	proto: {

		initGallery: function() {



			var gSt = mfp.st.gallery,

				ns = '.mfp-gallery',

				supportsFastClick = Boolean($.fn.mfpFastClick);



			mfp.direction = true; // true - next, false - prev



			if(!gSt || !gSt.enabled ) return false;



			_wrapClasses += ' mfp-gallery';



			_mfpOn(OPEN_EVENT+ns, function() {



				if(gSt.navigateByImgClick) {

					mfp.wrap.on('click'+ns, '.mfp-img', function() {

						if(mfp.items.length > 1) {

							mfp.next();

							return false;

						}

					});

				}



				_document.on('keydown'+ns, function(e) {

					if (e.keyCode === 37) {

						mfp.prev();

					} else if (e.keyCode === 39) {

						mfp.next();

					}

				});

			});



			_mfpOn('UpdateStatus'+ns, function(e, data) {

				if(data.text) {

					data.text = _replaceCurrTotal(data.text, mfp.currItem.index, mfp.items.length);

				}

			});



			_mfpOn(MARKUP_PARSE_EVENT+ns, function(e, element, values, item) {

				var l = mfp.items.length;

				values.counter = l > 1 ? _replaceCurrTotal(gSt.tCounter, item.index, l) : '';

			});



			_mfpOn('BuildControls' + ns, function() {

				if(mfp.items.length > 1 && gSt.arrows && !mfp.arrowLeft) {

					var markup = gSt.arrowMarkup,

						arrowLeft = mfp.arrowLeft = $( markup.replace(/%title%/gi, gSt.tPrev).replace(/%dir%/gi, 'left') ).addClass(PREVENT_CLOSE_CLASS),

						arrowRight = mfp.arrowRight = $( markup.replace(/%title%/gi, gSt.tNext).replace(/%dir%/gi, 'right') ).addClass(PREVENT_CLOSE_CLASS);



					var eName = supportsFastClick ? 'mfpFastClick' : 'click';

					arrowLeft[eName](function() {

						mfp.prev();

					});

					arrowRight[eName](function() {

						mfp.next();

					});



					// Polyfill for :before and :after (adds elements with classes mfp-a and mfp-b)

					if(mfp.isIE7) {

						_getEl('b', arrowLeft[0], false, true);

						_getEl('a', arrowLeft[0], false, true);

						_getEl('b', arrowRight[0], false, true);

						_getEl('a', arrowRight[0], false, true);

					}



					mfp.container.append(arrowLeft.add(arrowRight));

				}

			});



			_mfpOn(CHANGE_EVENT+ns, function() {

				if(mfp._preloadTimeout) clearTimeout(mfp._preloadTimeout);



				mfp._preloadTimeout = setTimeout(function() {

					mfp.preloadNearbyImages();

					mfp._preloadTimeout = null;

				}, 16);

			});





			_mfpOn(CLOSE_EVENT+ns, function() {

				_document.off(ns);

				mfp.wrap.off('click'+ns);



				if(mfp.arrowLeft && supportsFastClick) {

					mfp.arrowLeft.add(mfp.arrowRight).destroyMfpFastClick();

				}

				mfp.arrowRight = mfp.arrowLeft = null;

			});



		},

		next: function() {

			mfp.direction = true;

			mfp.index = _getLoopedId(mfp.index + 1);

			mfp.updateItemHTML();

		},

		prev: function() {

			mfp.direction = false;

			mfp.index = _getLoopedId(mfp.index - 1);

			mfp.updateItemHTML();

		},

		goTo: function(newIndex) {

			mfp.direction = (newIndex >= mfp.index);

			mfp.index = newIndex;

			mfp.updateItemHTML();

		},

		preloadNearbyImages: function() {

			var p = mfp.st.gallery.preload,

				preloadBefore = Math.min(p[0], mfp.items.length),

				preloadAfter = Math.min(p[1], mfp.items.length),

				i;



			for(i = 1; i <= (mfp.direction ? preloadAfter : preloadBefore); i++) {

				mfp._preloadItem(mfp.index+i);

			}

			for(i = 1; i <= (mfp.direction ? preloadBefore : preloadAfter); i++) {

				mfp._preloadItem(mfp.index-i);

			}

		},

		_preloadItem: function(index) {

			index = _getLoopedId(index);



			if(mfp.items[index].preloaded) {

				return;

			}



			var item = mfp.items[index];

			if(!item.parsed) {

				item = mfp.parseEl( index );

			}



			_mfpTrigger('LazyLoad', item);



			if(item.type === 'image') {

				item.img = $('<img class="mfp-img" />').on('load.mfploader', function() {

					item.hasSize = true;

				}).on('error.mfploader', function() {

					item.hasSize = true;

					item.loadError = true;

					_mfpTrigger('LazyLoadError', item);

				}).attr('src', item.src);

			}





			item.preloaded = true;

		}

	}

});



/*

Touch Support that might be implemented some day



addSwipeGesture: function() {

	var startX,

		moved,

		multipleTouches;



		return;



	var namespace = '.mfp',

		addEventNames = function(pref, down, move, up, cancel) {

			mfp._tStart = pref + down + namespace;

			mfp._tMove = pref + move + namespace;

			mfp._tEnd = pref + up + namespace;

			mfp._tCancel = pref + cancel + namespace;

		};



	if(window.navigator.msPointerEnabled) {

		addEventNames('MSPointer', 'Down', 'Move', 'Up', 'Cancel');

	} else if('ontouchstart' in window) {

		addEventNames('touch', 'start', 'move', 'end', 'cancel');

	} else {

		return;

	}

	_window.on(mfp._tStart, function(e) {

		var oE = e.originalEvent;

		multipleTouches = moved = false;

		startX = oE.pageX || oE.changedTouches[0].pageX;

	}).on(mfp._tMove, function(e) {

		if(e.originalEvent.touches.length > 1) {

			multipleTouches = e.originalEvent.touches.length;

		} else {

			//e.preventDefault();

			moved = true;

		}

	}).on(mfp._tEnd + ' ' + mfp._tCancel, function(e) {

		if(moved && !multipleTouches) {

			var oE = e.originalEvent,

				diff = startX - (oE.pageX || oE.changedTouches[0].pageX);



			if(diff > 20) {

				mfp.next();

			} else if(diff < -20) {

				mfp.prev();

			}

		}

	});

},

*/





/*>>gallery*/



/*>>retina*/



var RETINA_NS = 'retina';



$.magnificPopup.registerModule(RETINA_NS, {

	options: {

		replaceSrc: function(item) {

			return item.src.replace(/\.\w+$/, function(m) { return '@2x' + m; });

		},

		ratio: 1 // Function or number.  Set to 1 to disable.

	},

	proto: {

		initRetina: function() {

			if(window.devicePixelRatio > 1) {



				var st = mfp.st.retina,

					ratio = st.ratio;



				ratio = !isNaN(ratio) ? ratio : ratio();



				if(ratio > 1) {

					_mfpOn('ImageHasSize' + '.' + RETINA_NS, function(e, item) {

						item.img.css({

							'max-width': item.img[0].naturalWidth / ratio,

							'width': '100%'

						});

					});

					_mfpOn('ElementParse' + '.' + RETINA_NS, function(e, item) {

						item.src = st.replaceSrc(item, ratio);

					});

				}

			}



		}

	}

});



/*>>retina*/



/*>>fastclick*/

/**

 * FastClick event implementation. (removes 300ms delay on touch devices)

 * Based on https://developers.google.com/mobile/articles/fast_buttons

 *

 * You may use it outside the Magnific Popup by calling just:

 *

 * $('.your-el').mfpFastClick(function() {

 *     console.log('Clicked!');

 * });

 *

 * To unbind:

 * $('.your-el').destroyMfpFastClick();

 *

 *

 * Note that it's a very basic and simple implementation, it blocks ghost click on the same element where it was bound.

 * If you need something more advanced, use plugin by FT Labs https://github.com/ftlabs/fastclick

 *

 */



(function() {

	var ghostClickDelay = 1000,

		supportsTouch = 'ontouchstart' in window,

		unbindTouchMove = function() {

			_window.off('touchmove'+ns+' touchend'+ns);

		},

		eName = 'mfpFastClick',

		ns = '.'+eName;





	// As Zepto.js doesn't have an easy way to add custom events (like jQuery), so we implement it in this way

	$.fn.mfpFastClick = function(callback) {



		return $(this).each(function() {



			var elem = $(this),

				lock;



			if( supportsTouch ) {



				var timeout,

					startX,

					startY,

					pointerMoved,

					point,

					numPointers;



				elem.on('touchstart' + ns, function(e) {

					pointerMoved = false;

					numPointers = 1;



					point = e.originalEvent ? e.originalEvent.touches[0] : e.touches[0];

					startX = point.clientX;

					startY = point.clientY;



					_window.on('touchmove'+ns, function(e) {

						point = e.originalEvent ? e.originalEvent.touches : e.touches;

						numPointers = point.length;

						point = point[0];

						if (Math.abs(point.clientX - startX) > 10 ||

							Math.abs(point.clientY - startY) > 10) {

							pointerMoved = true;

							unbindTouchMove();

						}

					}).on('touchend'+ns, function(e) {

						unbindTouchMove();

						if(pointerMoved || numPointers > 1) {

							return;

						}

						lock = true;

						e.preventDefault();

						clearTimeout(timeout);

						timeout = setTimeout(function() {

							lock = false;

						}, ghostClickDelay);

						callback();

					});

				});



			}



			elem.on('click' + ns, function() {

				if(!lock) {

					callback();

				}

			});

		});

	};



	$.fn.destroyMfpFastClick = function() {

		$(this).off('touchstart' + ns + ' click' + ns);

		if(supportsTouch) _window.off('touchmove'+ns+' touchend'+ns);

	};

})();



/*>>fastclick*/

 _checkInstance(); })(window.jQuery || window.Zepto);