c80_yax 0.1.0.24 → 0.1.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87df0d03c098066acbf02225cee36644e77bf2c5
-  data.tar.gz: 047a6108e1a1f14b77a40abd841aca7e1d998a6c
+  metadata.gz: 382da4ee6b3a742b51b8faeebdaecafdb18c5d74
+  data.tar.gz: bd3794ff530764bb9594b6f600f796ae5b856a04
 SHA512:
-  metadata.gz: 0b3260091bca2e3d5efe84772060b9e459736ed1bd7ea0f0904d66e727ba6e370822a03c5ce7a90c4fc633b788a7039291cf0a745daf0801f7336d92011ce4bd
-  data.tar.gz: 0a24c2e5dde7c9b1e1657875c69ddc414bb7abef9ca2fdfe2ca02a5a9915684bd762d0ccd11e70263c98f9881bea34b56bcd8f603c36e38af95c544319d9bef5
+  metadata.gz: 4743e772689439fe71dfb9393e6acb2860e1b095aa7ea9db679ab49a470c2e5c0c769488acdafae09e440d3fec1cafb4a798d320eeabd0b247b9acb69255a3d0
+  data.tar.gz: f22a9c440aaf0e962fa41c6a72c9b78c463f812b43d2f3d90e74f562128871c6611b16655cd9397e1f2ee0f6637fc065f7c0c92f6f20187172e0711b478816cb

data/app/assets/javascripts/c80_yax.js.coffee

@@ -1,3 +1,4 @@
+#= require_tree ./c80_yax/lib
 #= require_tree ./c80_yax/frontend
 #= require co
 #= require ti

data/app/assets/javascripts/c80_yax/frontend/item_show_magnific_popup.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _init_magnific = function() {
+    var $item_show = $('.item_show');
+    if ($item_show.length > 0) {
+
+        $item_show.magnificPopup({
+            delegate: 'a.image-lnk',
+            removalDelay: 300,
+            mainClass: 'mfp-fade',
+            type: 'image',
+            gallery:{enabled:true}
+        });
+
+    }
+};
+
+$(document).ready(_init_magnific);

data/app/assets/javascripts/c80_yax/lib/jquery.magnific-popup.js

@@ -0,0 +1,2060 @@
+/*! Magnific Popup - v1.0.0 - 2015-01-03
+ * http://dimsemenov.com/plugins/magnific-popup/
+ * Copyright (c) 2015 Dmitry Semenov; */
+;(function (factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(['jquery'], factory);
+    } else if (typeof exports === 'object') {
+        // Node/CommonJS
+        factory(require('jquery'));
+    } else {
+        // Browser globals
+        factory(window.jQuery || window.Zepto);
+    }
+}(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
+     */
+    /*jshint -W079 */
+    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),
+        _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) {
+                /*jshint -W020 */
+                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) {
+
+            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 || $(document.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;
+
+            if(item.tagName) {
+                item = { el: $(item) };
+            } else {
+                type = item.type;
+                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.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) {
+                $(document.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) {
+                    $(document.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) {
+                        $(document.body).addClass(imgSt.cursor);
+                    }
+                });
+
+                _mfpOn(CLOSE_EVENT+ns, function() {
+                    if(imgSt.cursor) {
+                        $(document.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';
+                    if(item.el && item.el.find('img').length) {
+                        img.alt = item.el.find('img').attr('alt');
+                    }
+                    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(); }));