text: ;
  (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($) {
  
    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.st.autoFocusLast && 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 || e.altKey || e.shiftKey)) {
          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">&#215;</button>',
  
        tClose: 'Close (Esc)',
  
        tLoading: 'Loading...',
  
        autoFocusLast: true
  
      }
    };
  
  
  
    $.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.
  
  			 */
          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();
  }));
  