Team:NKU CHINA/interlab/js5

(function(factory) {

   if (typeof define === 'function' && define.amd) {
       define(['jquery'], factory);
   } else if (typeof module === 'object' && module.exports) {
       module.exports = factory(require('jquery'));
   } else {
       factory(jQuery);
   }

}(function($) {

   var instanceNum = 0,
       $html = $('html'),
       $document = $(document),
       $window = $(window);
   function SimpleLightbox(options) {
       this.init.apply(this, arguments);
   }
   SimpleLightbox.defaults = {
       // add custom classes to lightbox elements
       elementClass: ,
       elementLoadingClass: 'slbLoading',
       htmlClass: 'slbActive',
       closeBtnClass: ,
       nextBtnClass: ,
       prevBtnClass: ,
       loadingTextClass: ,
       // customize / localize controls captions
       closeBtnCaption: 'Close',
       nextBtnCaption: 'Next',
       prevBtnCaption: 'Previous',
       loadingCaption: 'Loading...',
       bindToItems: true, // set click event handler to trigger lightbox on provided $items
       closeOnOverlayClick: true,
       closeOnEscapeKey: true,
       nextOnImageClick: true,
       showCaptions: true,
       captionAttribute: 'title', // choose data source for library to glean image caption from
       urlAttribute: 'href', // where to expect large image
       startAt: 0, // start gallery at custom index
       loadingTimeout: 100, // time after loading element will appear
       appendTarget: 'body', // append elsewhere if needed
       beforeSetContent: null, // convenient hooks for extending library behavoiur
       beforeClose: null,
       beforeDestroy: null,
       videoRegex: new RegExp(/youtube.com|vimeo.com/) // regex which tests load url for iframe content
   };
   $.extend(SimpleLightbox.prototype, {
       init: function(options) {
           this.options = $.extend({}, SimpleLightbox.defaults, options);
           this.ens = '.slb' + (++instanceNum);
           this.items = [];
           this.captions = [];
           var self = this;
           if (this.options.$items) {
               this.$items = this.options.$items;
               this.$items.each(function() {
                   var $item = $(this);
                   self.items.push($item.attr(self.options.urlAttribute));
                   self.captions.push($item.attr(self.options.captionAttribute));
               });
               this.options.bindToItems && this.$items.on('click' + this.ens, function(e) {
                   e.preventDefault();
                   self.showPosition(self.$items.index($(e.currentTarget)));
               });
           } else if (this.options.items) {
               this.items = this.options.items;
           }
           if (this.options.captions) {
               this.captions = this.options.captions;
           }
       },
       next: function() {
           return this.showPosition(this.currentPosition + 1);
       },
       prev: function() {
           return this.showPosition(this.currentPosition - 1);
       },
       normalizePosition: function(position) {
           if (position >= this.items.length) {
               position = 0;
           } else if (position < 0) {
               position = this.items.length - 1;
           }
           return position;
       },
       showPosition: function(position) {
           var self = this;
           this.currentPosition = this.normalizePosition(position);
           return this.setupLightboxHtml().prepareItem(this.currentPosition, this.setContent).show();
       },
       loading: function(on) {
           var self = this;
           if (on) {
               this.loadingTimeout = setTimeout(function() {
                   self.$el.addClass(self.options.elementLoadingClass);
self.$content.html('

' + self.options.loadingCaption + '

');
                   self.show();
               }, this.options.loadingTimeout);
           } else {
               this.$el && this.$el.removeClass(this.options.elementLoadingClass);
               clearTimeout(this.loadingTimeout);
           }
       },
       prepareItem: function(position, callback) {
           var self = this,
               url = this.items[position];
           this.loading(true);
           if (this.options.videoRegex.test(url)) {
callback.call(self, $('
<iframe class="slbIframe" frameborder="0" allowfullscreen src="' + url + '"></iframe>
'));
           } else {
var $imageCont = $('
<img class="slbImage" src="' + url + '" />
');
               this.$currentImage = $imageCont.find('.slbImage');
               if (this.options.showCaptions && this.captions[position]) {
$imageCont.append('
' + this.captions[position] + '
');
               }
               this.loadImage(url, function() {
                   self.setImageDimensions();
                   callback.call(self, $imageCont);
                   self.loadImage(self.items[self.normalizePosition(self.currentPosition + 1)]);
               });
           }
           return this;
       },
       loadImage: function(url, callback) {
           if (!this.options.videoRegex.test(url)) {
               var image = new Image();
               callback && (image.onload = callback);
               image.src = url;
           }
       },
       setupLightboxHtml: function() {
           var o = this.options;
           if (!this.$el) {
               this.$el = $(
'
' + '
' + '
' + '
' + '
' + '
' +
                                   '<button type="button" title="' + o.closeBtnCaption + '" class="slbCloseBtn ' + o.closeBtnClass + '">×</button>' +
'
' + '
' + '
' + '
'
               );
               if (this.items.length > 1) {
                   $(
'
' +
                           '<button type="button" title="' + o.prevBtnCaption + '" class="prev slbArrow' + o.prevBtnClass + '">' + o.prevBtnCaption + '</button>' +
                           '<button type="button" title="' + o.nextBtnCaption + '" class="next slbArrow' + o.nextBtnClass + '">' + o.nextBtnCaption + '</button>' +
'
'
                   ).appendTo(this.$el.find('.slbContentOuter'));
               }
               this.$content = this.$el.find('.slbContent');
           }
           this.$content.empty();
           return this;
       },
       show: function() {
           if (!this.modalInDom) {
               this.$el.appendTo($(this.options.appendTarget));
               $html.addClass(this.options.htmlClass);
               this.setupLightboxEvents();
               this.modalInDom = true;
           }
           return this;
       },
       setContent: function(content) {
           var $content = $(content);
           this.loading(false);
           this.setupLightboxHtml();
           this.options.beforeSetContent && this.options.beforeSetContent($content, this);
           this.$content.html($content);
           return this;
       },
       setImageDimensions: function() {
           this.$currentImage && this.$currentImage.css('max-height', $window.height() + 'px');
       },
       setupLightboxEvents: function() {
           var self = this;
           if (!this.lightboxEventsSetuped) {
               this.$el.on('click' + this.ens, function(e) {
                   var $target = $(e.target);
                   if ($target.is('.slbCloseBtn') || (self.options.closeOnOverlayClick && $target.is('.slbWrap'))) {
                       self.close();
                   } else if ($target.is('.slbArrow')) {
                       $target.hasClass('next') ? self.next() : self.prev();
                   } else if (self.options.nextOnImageClick && self.items.length > 1 && $target.is('.slbImage')) {
                       self.next();
                   }
               });
               $document.on('keyup' + this.ens, function(e) {
                   self.options.closeOnEscapeKey && e.keyCode === 27 && self.close();
                   if (self.items.length > 1) {
                       (e.keyCode === 39 || e.keyCode === 68) && self.next();
                       (e.keyCode === 37 || e.keyCode === 65) && self.prev();
                   }
               });
               $window.on('resize' + this.ens, function() {
                   self.setImageDimensions();
               });
               this.lightboxEventsSetuped = true;
           }
       },
       close: function() {
           if (this.modalInDom) {
               this.options.beforeClose && this.options.beforeClose(this);
               this.$el && this.$el.off(this.ens);
               $document.off(this.ens);
               $window.off(this.ens);
               this.lightboxEventsSetuped = false;
               this.$el.detach();
               $html.removeClass(this.options.htmlClass);
               this.modalInDom = false;
           }
       },
       destroy: function() {
           this.close();
           this.options.beforeDestroy && this.options.beforeDestroy(this);
           this.$items && this.$items.off(this.ens);
           this.$el && this.$el.remove();
       }
   });
   SimpleLightbox.open = function(options) {
       var instance = new SimpleLightbox(options);
       return options.content ? instance.setContent(options.content).show() : instance.showPosition(instance.options.startAt);
   };
   $.fn.simpleLightbox = function(options) {
       var lightboxInstance,
           $items = this;
       return this.each(function() {
           if (!$.data(this, 'simpleLightbox')) {
               lightboxInstance = lightboxInstance || new SimpleLightbox($.extend({}, options, {$items: $items}));
               $.data(this, 'simpleLightbox', lightboxInstance);
           }
       });
   };
   $.simpleLightbox = $.SimpleLightbox = SimpleLightbox;
   return $;

}));

/*

*  jQuery OwlCarousel v1.3.3
*
*  Copyright (c) 2013 Bartosz Wojciechowski
*  http://www.owlgraphic.com/owlcarousel/
*
*  Licensed under MIT
*
*/

/*JS Lint helpers: */ /*global dragMove: false, dragEnd: false, $, jQuery, alert, window, document */ /*jslint nomen: true, continue:true */

if (typeof Object.create !== "function") {

   Object.create = function (obj) {
       function F() {}
       F.prototype = obj;
       return new F();
   };

} (function ($, window, document) {

   var Carousel = {
       init : function (options, el) {
           var base = this;
           base.$elem = $(el);
           base.options = $.extend({}, $.fn.owlCarousel.options, base.$elem.data(), options);
           base.userOptions = options;
           base.loadContent();
       },
       loadContent : function () {
           var base = this, url;
           function getData(data) {
               var i, content = "";
               if (typeof base.options.jsonSuccess === "function") {
                   base.options.jsonSuccess.apply(this, [data]);
               } else {
                   for (i in data.owl) {
                       if (data.owl.hasOwnProperty(i)) {
                           content += data.owl[i].item;
                       }
                   }
                   base.$elem.html(content);
               }
               base.logIn();
           }
           if (typeof base.options.beforeInit === "function") {
               base.options.beforeInit.apply(this, [base.$elem]);
           }
           if (typeof base.options.jsonPath === "string") {
               url = base.options.jsonPath;
               $.getJSON(url, getData);
           } else {
               base.logIn();
           }
       },
       logIn : function () {
           var base = this;
           base.$elem.data("owl-originalStyles", base.$elem.attr("style"));
           base.$elem.data("owl-originalClasses", base.$elem.attr("class"));
           base.$elem.css({opacity: 0});
           base.orignalItems = base.options.items;
           base.checkBrowser();
           base.wrapperWidth = 0;
           base.checkVisible = null;
           base.setVars();
       },
       setVars : function () {
           var base = this;
           if (base.$elem.children().length === 0) {return false; }
           base.baseClass();
           base.eventTypes();
           base.$userItems = base.$elem.children();
           base.itemsAmount = base.$userItems.length;
           base.wrapItems();
           base.$owlItems = base.$elem.find(".owl-item");
           base.$owlWrapper = base.$elem.find(".owl-wrapper");
           base.playDirection = "next";
           base.prevItem = 0;
           base.prevArr = [0];
           base.currentItem = 0;
           base.customEvents();
           base.onStartup();
       },
       onStartup : function () {
           var base = this;
           base.updateItems();
           base.calculateAll();
           base.buildControls();
           base.updateControls();
           base.response();
           base.moveEvents();
           base.stopOnHover();
           base.owlStatus();
           if (base.options.transitionStyle !== false) {
               base.transitionTypes(base.options.transitionStyle);
           }
           if (base.options.autoPlay === true) {
               base.options.autoPlay = 5000;
           }
           base.play();
           base.$elem.find(".owl-wrapper").css("display", "block");
           if (!base.$elem.is(":visible")) {
               base.watchVisibility();
           } else {
               base.$elem.css("opacity", 1);
           }
           base.onstartup = false;
           base.eachMoveUpdate();
           if (typeof base.options.afterInit === "function") {
               base.options.afterInit.apply(this, [base.$elem]);
           }
       },
       eachMoveUpdate : function () {
           var base = this;
           if (base.options.lazyLoad === true) {
               base.lazyLoad();
           }
           if (base.options.autoHeight === true) {
               base.autoHeight();
           }
           base.onVisibleItems();
           if (typeof base.options.afterAction === "function") {
               base.options.afterAction.apply(this, [base.$elem]);
           }
       },
       updateVars : function () {
           var base = this;
           if (typeof base.options.beforeUpdate === "function") {
               base.options.beforeUpdate.apply(this, [base.$elem]);
           }
           base.watchVisibility();
           base.updateItems();
           base.calculateAll();
           base.updatePosition();
           base.updateControls();
           base.eachMoveUpdate();
           if (typeof base.options.afterUpdate === "function") {
               base.options.afterUpdate.apply(this, [base.$elem]);
           }
       },
       reload : function () {
           var base = this;
           window.setTimeout(function () {
               base.updateVars();
           }, 0);
       },
       watchVisibility : function () {
           var base = this;
           if (base.$elem.is(":visible") === false) {
               base.$elem.css({opacity: 0});
               window.clearInterval(base.autoPlayInterval);
               window.clearInterval(base.checkVisible);
           } else {
               return false;
           }
           base.checkVisible = window.setInterval(function () {
               if (base.$elem.is(":visible")) {
                   base.reload();
                   base.$elem.animate({opacity: 1}, 200);
                   window.clearInterval(base.checkVisible);
               }
           }, 500);
       },
       wrapItems : function () {
           var base = this;
base.$userItems.wrapAll("
").wrap("
"); base.$elem.find(".owl-wrapper").wrap("
");
           base.wrapperOuter = base.$elem.find(".owl-wrapper-outer");
           base.$elem.css("display", "block");
       },
       baseClass : function () {
           var base = this,
               hasBaseClass = base.$elem.hasClass(base.options.baseClass),
               hasThemeClass = base.$elem.hasClass(base.options.theme);
           if (!hasBaseClass) {
               base.$elem.addClass(base.options.baseClass);
           }
           if (!hasThemeClass) {
               base.$elem.addClass(base.options.theme);
           }
       },
       updateItems : function () {
           var base = this, width, i;
           if (base.options.responsive === false) {
               return false;
           }
           if (base.options.singleItem === true) {
               base.options.items = base.orignalItems = 1;
               base.options.itemsCustom = false;
               base.options.itemsDesktop = false;
               base.options.itemsDesktopSmall = false;
               base.options.itemsTablet = false;
               base.options.itemsTabletSmall = false;
               base.options.itemsMobile = false;
               return false;
           }
           width = $(base.options.responsiveBaseWidth).width();
           if (width > (base.options.itemsDesktop[0] || base.orignalItems)) {
               base.options.items = base.orignalItems;
           }
           if (base.options.itemsCustom !== false) {
               //Reorder array by screen size
               base.options.itemsCustom.sort(function (a, b) {return a[0] - b[0]; });
               for (i = 0; i < base.options.itemsCustom.length; i += 1) {
                   if (base.options.itemsCustom[i][0] <= width) {
                       base.options.items = base.options.itemsCustom[i][1];
                   }
               }
           } else {
               if (width <= base.options.itemsDesktop[0] && base.options.itemsDesktop !== false) {
                   base.options.items = base.options.itemsDesktop[1];
               }
               if (width <= base.options.itemsDesktopSmall[0] && base.options.itemsDesktopSmall !== false) {
                   base.options.items = base.options.itemsDesktopSmall[1];
               }
               if (width <= base.options.itemsTablet[0] && base.options.itemsTablet !== false) {
                   base.options.items = base.options.itemsTablet[1];
               }
               if (width <= base.options.itemsTabletSmall[0] && base.options.itemsTabletSmall !== false) {
                   base.options.items = base.options.itemsTabletSmall[1];
               }
               if (width <= base.options.itemsMobile[0] && base.options.itemsMobile !== false) {
                   base.options.items = base.options.itemsMobile[1];
               }
           }
           //if number of items is less than declared
           if (base.options.items > base.itemsAmount && base.options.itemsScaleUp === true) {
               base.options.items = base.itemsAmount;
           }
       },
       response : function () {
           var base = this,
               smallDelay,
               lastWindowWidth;
           if (base.options.responsive !== true) {
               return false;
           }
           lastWindowWidth = $(window).width();
           base.resizer = function () {
               if ($(window).width() !== lastWindowWidth) {
                   if (base.options.autoPlay !== false) {
                       window.clearInterval(base.autoPlayInterval);
                   }
                   window.clearTimeout(smallDelay);
                   smallDelay = window.setTimeout(function () {
                       lastWindowWidth = $(window).width();
                       base.updateVars();
                   }, base.options.responsiveRefreshRate);
               }
           };
           $(window).resize(base.resizer);
       },
       updatePosition : function () {
           var base = this;
           base.jumpTo(base.currentItem);
           if (base.options.autoPlay !== false) {
               base.checkAp();
           }
       },
       appendItemsSizes : function () {
           var base = this,
               roundPages = 0,
               lastItem = base.itemsAmount - base.options.items;
           base.$owlItems.each(function (index) {
               var $this = $(this);
               $this
                   .css({"width": base.itemWidth})
                   .data("owl-item", Number(index));
               if (index % base.options.items === 0 || index === lastItem) {
                   if (!(index > lastItem)) {
                       roundPages += 1;
                   }
               }
               $this.data("owl-roundPages", roundPages);
           });
       },
       appendWrapperSizes : function () {
           var base = this,
               width = base.$owlItems.length * base.itemWidth;
           base.$owlWrapper.css({
               "width": width * 2,
               "left": 0
           });
           base.appendItemsSizes();
       },
       calculateAll : function () {
           var base = this;
           base.calculateWidth();
           base.appendWrapperSizes();
           base.loops();
           base.max();
       },
       calculateWidth : function () {
           var base = this;
           base.itemWidth = Math.round(base.$elem.width() / base.options.items);
       },
       max : function () {
           var base = this,
               maximum = ((base.itemsAmount * base.itemWidth) - base.options.items * base.itemWidth) * -1;
           if (base.options.items > base.itemsAmount) {
               base.maximumItem = 0;
               maximum = 0;
               base.maximumPixels = 0;
           } else {
               base.maximumItem = base.itemsAmount - base.options.items;
               base.maximumPixels = maximum;
           }
           return maximum;
       },
       min : function () {
           return 0;
       },
       loops : function () {
           var base = this,
               prev = 0,
               elWidth = 0,
               i,
               item,
               roundPageNum;
           base.positionsInArray = [0];
           base.pagesInArray = [];
           for (i = 0; i < base.itemsAmount; i += 1) {
               elWidth += base.itemWidth;
               base.positionsInArray.push(-elWidth);
               if (base.options.scrollPerPage === true) {
                   item = $(base.$owlItems[i]);
                   roundPageNum = item.data("owl-roundPages");
                   if (roundPageNum !== prev) {
                       base.pagesInArray[prev] = base.positionsInArray[i];
                       prev = roundPageNum;
                   }
               }
           }
       },
       buildControls : function () {
           var base = this;
           if (base.options.navigation === true || base.options.pagination === true) {
               base.owlControls = $("<div class=\"owl-controls\"/>").toggleClass("clickable", !base.browser.isTouch).appendTo(base.$elem);
           }
           if (base.options.pagination === true) {
               base.buildPagination();
           }
           if (base.options.navigation === true) {
               base.buildButtons();
           }
       },
       buildButtons : function () {
           var base = this,
               buttonsWrapper = $("<div class=\"owl-buttons\"/>");
           base.owlControls.append(buttonsWrapper);
           base.buttonPrev = $("<div/>", {
               "class" : "owl-prev",
               "html" : base.options.navigationText[0] || ""
           });
           base.buttonNext = $("<div/>", {
               "class" : "owl-next",
               "html" : base.options.navigationText[1] || ""
           });
           buttonsWrapper
               .append(base.buttonPrev)
               .append(base.buttonNext);
           buttonsWrapper.on("touchstart.owlControls mousedown.owlControls", "div[class^=\"owl\"]", function (event) {
               event.preventDefault();
           });
           buttonsWrapper.on("touchend.owlControls mouseup.owlControls", "div[class^=\"owl\"]", function (event) {
               event.preventDefault();
               if ($(this).hasClass("owl-next")) {
                   base.next();
               } else {
                   base.prev();
               }
           });
       },
       buildPagination : function () {
           var base = this;
           base.paginationWrapper = $("<div class=\"owl-pagination\"/>");
           base.owlControls.append(base.paginationWrapper);
           base.paginationWrapper.on("touchend.owlControls mouseup.owlControls", ".owl-page", function (event) {
               event.preventDefault();
               if (Number($(this).data("owl-page")) !== base.currentItem) {
                   base.goTo(Number($(this).data("owl-page")), true);
               }
           });
       },
       updatePagination : function () {
           var base = this,
               counter,
               lastPage,
               lastItem,
               i,
               paginationButton,
               paginationButtonInner;
           if (base.options.pagination === false) {
               return false;
           }
           base.paginationWrapper.html("");
           counter = 0;
           lastPage = base.itemsAmount - base.itemsAmount % base.options.items;
           for (i = 0; i < base.itemsAmount; i += 1) {
               if (i % base.options.items === 0) {
                   counter += 1;
                   if (lastPage === i) {
                       lastItem = base.itemsAmount - base.options.items;
                   }
                   paginationButton = $("<div/>", {
                       "class" : "owl-page"
                   });
                   paginationButtonInner = $("", {
                       "text": base.options.paginationNumbers === true ? counter : "",
                       "class": base.options.paginationNumbers === true ? "owl-numbers" : ""
                   });
                   paginationButton.append(paginationButtonInner);
                   paginationButton.data("owl-page", lastPage === i ? lastItem : i);
                   paginationButton.data("owl-roundPages", counter);
                   base.paginationWrapper.append(paginationButton);
               }
           }
           base.checkPagination();
       },
       checkPagination : function () {
           var base = this;
           if (base.options.pagination === false) {
               return false;
           }
           base.paginationWrapper.find(".owl-page").each(function () {
               if ($(this).data("owl-roundPages") === $(base.$owlItems[base.currentItem]).data("owl-roundPages")) {
                   base.paginationWrapper
                       .find(".owl-page")
                       .removeClass("active");
                   $(this).addClass("active");
               }
           });
       },
       checkNavigation : function () {
           var base = this;
           if (base.options.navigation === false) {
               return false;
           }
           if (base.options.rewindNav === false) {
               if (base.currentItem === 0 && base.maximumItem === 0) {
                   base.buttonPrev.addClass("disabled");
                   base.buttonNext.addClass("disabled");
               } else if (base.currentItem === 0 && base.maximumItem !== 0) {
                   base.buttonPrev.addClass("disabled");
                   base.buttonNext.removeClass("disabled");
               } else if (base.currentItem === base.maximumItem) {
                   base.buttonPrev.removeClass("disabled");
                   base.buttonNext.addClass("disabled");
               } else if (base.currentItem !== 0 && base.currentItem !== base.maximumItem) {
                   base.buttonPrev.removeClass("disabled");
                   base.buttonNext.removeClass("disabled");
               }
           }
       },
       updateControls : function () {
           var base = this;
           base.updatePagination();
           base.checkNavigation();
           if (base.owlControls) {
               if (base.options.items >= base.itemsAmount) {
                   base.owlControls.hide();
               } else {
                   base.owlControls.show();
               }
           }
       },
       destroyControls : function () {
           var base = this;
           if (base.owlControls) {
               base.owlControls.remove();
           }
       },
       next : function (speed) {
           var base = this;
           if (base.isTransition) {
               return false;
           }
           base.currentItem += base.options.scrollPerPage === true ? base.options.items : 1;
           if (base.currentItem > base.maximumItem + (base.options.scrollPerPage === true ? (base.options.items - 1) : 0)) {
               if (base.options.rewindNav === true) {
                   base.currentItem = 0;
                   speed = "rewind";
               } else {
                   base.currentItem = base.maximumItem;
                   return false;
               }
           }
           base.goTo(base.currentItem, speed);
       },
       prev : function (speed) {
           var base = this;
           if (base.isTransition) {
               return false;
           }
           if (base.options.scrollPerPage === true && base.currentItem > 0 && base.currentItem < base.options.items) {
               base.currentItem = 0;
           } else {
               base.currentItem -= base.options.scrollPerPage === true ? base.options.items : 1;
           }
           if (base.currentItem < 0) {
               if (base.options.rewindNav === true) {
                   base.currentItem = base.maximumItem;
                   speed = "rewind";
               } else {
                   base.currentItem = 0;
                   return false;
               }
           }
           base.goTo(base.currentItem, speed);
       },
       goTo : function (position, speed, drag) {
           var base = this,
               goToPixel;
           if (base.isTransition) {
               return false;
           }
           if (typeof base.options.beforeMove === "function") {
               base.options.beforeMove.apply(this, [base.$elem]);
           }
           if (position >= base.maximumItem) {
               position = base.maximumItem;
           } else if (position <= 0) {
               position = 0;
           }
           base.currentItem = base.owl.currentItem = position;
           if (base.options.transitionStyle !== false && drag !== "drag" && base.options.items === 1 && base.browser.support3d === true) {
               base.swapSpeed(0);
               if (base.browser.support3d === true) {
                   base.transition3d(base.positionsInArray[position]);
               } else {
                   base.css2slide(base.positionsInArray[position], 1);
               }
               base.afterGo();
               base.singleItemTransition();
               return false;
           }
           goToPixel = base.positionsInArray[position];
           if (base.browser.support3d === true) {
               base.isCss3Finish = false;
               if (speed === true) {
                   base.swapSpeed("paginationSpeed");
                   window.setTimeout(function () {
                       base.isCss3Finish = true;
                   }, base.options.paginationSpeed);
               } else if (speed === "rewind") {
                   base.swapSpeed(base.options.rewindSpeed);
                   window.setTimeout(function () {
                       base.isCss3Finish = true;
                   }, base.options.rewindSpeed);
               } else {
                   base.swapSpeed("slideSpeed");
                   window.setTimeout(function () {
                       base.isCss3Finish = true;
                   }, base.options.slideSpeed);
               }
               base.transition3d(goToPixel);
           } else {
               if (speed === true) {
                   base.css2slide(goToPixel, base.options.paginationSpeed);
               } else if (speed === "rewind") {
                   base.css2slide(goToPixel, base.options.rewindSpeed);
               } else {
                   base.css2slide(goToPixel, base.options.slideSpeed);
               }
           }
           base.afterGo();
       },
       jumpTo : function (position) {
           var base = this;
           if (typeof base.options.beforeMove === "function") {
               base.options.beforeMove.apply(this, [base.$elem]);
           }
           if (position >= base.maximumItem || position === -1) {
               position = base.maximumItem;
           } else if (position <= 0) {
               position = 0;
           }
           base.swapSpeed(0);
           if (base.browser.support3d === true) {
               base.transition3d(base.positionsInArray[position]);
           } else {
               base.css2slide(base.positionsInArray[position], 1);
           }
           base.currentItem = base.owl.currentItem = position;
           base.afterGo();
       },
       afterGo : function () {
           var base = this;
           base.prevArr.push(base.currentItem);
           base.prevItem = base.owl.prevItem = base.prevArr[base.prevArr.length - 2];
           base.prevArr.shift(0);
           if (base.prevItem !== base.currentItem) {
               base.checkPagination();
               base.checkNavigation();
               base.eachMoveUpdate();
               if (base.options.autoPlay !== false) {
                   base.checkAp();
               }
           }
           if (typeof base.options.afterMove === "function" && base.prevItem !== base.currentItem) {
               base.options.afterMove.apply(this, [base.$elem]);
           }
       },
       stop : function () {
           var base = this;
           base.apStatus = "stop";
           window.clearInterval(base.autoPlayInterval);
       },
       checkAp : function () {
           var base = this;
           if (base.apStatus !== "stop") {
               base.play();
           }
       },
       play : function () {
           var base = this;
           base.apStatus = "play";
           if (base.options.autoPlay === false) {
               return false;
           }
           window.clearInterval(base.autoPlayInterval);
           base.autoPlayInterval = window.setInterval(function () {
               base.next(true);
           }, base.options.autoPlay);
       },
       swapSpeed : function (action) {
           var base = this;
           if (action === "slideSpeed") {
               base.$owlWrapper.css(base.addCssSpeed(base.options.slideSpeed));
           } else if (action === "paginationSpeed") {
               base.$owlWrapper.css(base.addCssSpeed(base.options.paginationSpeed));
           } else if (typeof action !== "string") {
               base.$owlWrapper.css(base.addCssSpeed(action));
           }
       },
       addCssSpeed : function (speed) {
           return {
               "-webkit-transition": "all " + speed + "ms ease",
               "-moz-transition": "all " + speed + "ms ease",
               "-o-transition": "all " + speed + "ms ease",
               "transition": "all " + speed + "ms ease"
           };
       },
       removeTransition : function () {
           return {
               "-webkit-transition": "",
               "-moz-transition": "",
               "-o-transition": "",
               "transition": ""
           };
       },
       doTranslate : function (pixels) {
           return {
               "-webkit-transform": "translate3d(" + pixels + "px, 0px, 0px)",
               "-moz-transform": "translate3d(" + pixels + "px, 0px, 0px)",
               "-o-transform": "translate3d(" + pixels + "px, 0px, 0px)",
               "-ms-transform": "translate3d(" + pixels + "px, 0px, 0px)",
               "transform": "translate3d(" + pixels + "px, 0px,0px)"
           };
       },
       transition3d : function (value) {
           var base = this;
           base.$owlWrapper.css(base.doTranslate(value));
       },
       css2move : function (value) {
           var base = this;
           base.$owlWrapper.css({"left" : value});
       },
       css2slide : function (value, speed) {
           var base = this;
           base.isCssFinish = false;
           base.$owlWrapper.stop(true, true).animate({
               "left" : value
           }, {
               duration : speed || base.options.slideSpeed,
               complete : function () {
                   base.isCssFinish = true;
               }
           });
       },
       checkBrowser : function () {
           var base = this,
               translate3D = "translate3d(0px, 0px, 0px)",
               tempElem = document.createElement("div"),
               regex,
               asSupport,
               support3d,
               isTouch;
           tempElem.style.cssText = "  -moz-transform:" + translate3D +
                                 "; -ms-transform:"     + translate3D +
                                 "; -o-transform:"      + translate3D +
                                 "; -webkit-transform:" + translate3D +
                                 "; transform:"         + translate3D;
           regex = /translate3d\(0px, 0px, 0px\)/g;
           asSupport = tempElem.style.cssText.match(regex);
           support3d = (asSupport !== null && asSupport.length === 1);
           isTouch = "ontouchstart" in window || window.navigator.msMaxTouchPoints;
           base.browser = {
               "support3d" : support3d,
               "isTouch" : isTouch
           };
       },
       moveEvents : function () {
           var base = this;
           if (base.options.mouseDrag !== false || base.options.touchDrag !== false) {
               base.gestures();
               base.disabledEvents();
           }
       },
       eventTypes : function () {
           var base = this,
               types = ["s", "e", "x"];
           base.ev_types = {};
           if (base.options.mouseDrag === true && base.options.touchDrag === true) {
               types = [
                   "touchstart.owl mousedown.owl",
                   "touchmove.owl mousemove.owl",
                   "touchend.owl touchcancel.owl mouseup.owl"
               ];
           } else if (base.options.mouseDrag === false && base.options.touchDrag === true) {
               types = [
                   "touchstart.owl",
                   "touchmove.owl",
                   "touchend.owl touchcancel.owl"
               ];
           } else if (base.options.mouseDrag === true && base.options.touchDrag === false) {
               types = [
                   "mousedown.owl",
                   "mousemove.owl",
                   "mouseup.owl"
               ];
           }
           base.ev_types.start = types[0];
           base.ev_types.move = types[1];
           base.ev_types.end = types[2];
       },
       disabledEvents :  function () {
           var base = this;
           base.$elem.on("dragstart.owl", function (event) { event.preventDefault(); });
           base.$elem.on("mousedown.disableTextSelect", function (e) {
               return $(e.target).is('input, textarea, select, option');
           });
       },
       gestures : function () {
           /*jslint unparam: true*/
           var base = this,
               locals = {
                   offsetX : 0,
                   offsetY : 0,
                   baseElWidth : 0,
                   relativePos : 0,
                   position: null,
                   minSwipe : null,
                   maxSwipe: null,
                   sliding : null,
                   dargging: null,
                   targetElement : null
               };
           base.isCssFinish = true;
           function getTouches(event) {
               if (event.touches !== undefined) {
                   return {
                       x : event.touches[0].pageX,
                       y : event.touches[0].pageY
                   };
               }
               if (event.touches === undefined) {
                   if (event.pageX !== undefined) {
                       return {
                           x : event.pageX,
                           y : event.pageY
                       };
                   }
                   if (event.pageX === undefined) {
                       return {
                           x : event.clientX,
                           y : event.clientY
                       };
                   }
               }
           }
           function swapEvents(type) {
               if (type === "on") {
                   $(document).on(base.ev_types.move, dragMove);
                   $(document).on(base.ev_types.end, dragEnd);
               } else if (type === "off") {
                   $(document).off(base.ev_types.move);
                   $(document).off(base.ev_types.end);
               }
           }
           function dragStart(event) {
               var ev = event.originalEvent || event || window.event,
                   position;
               if (ev.which === 3) {
                   return false;
               }
               if (base.itemsAmount <= base.options.items) {
                   return;
               }
               if (base.isCssFinish === false && !base.options.dragBeforeAnimFinish) {
                   return false;
               }
               if (base.isCss3Finish === false && !base.options.dragBeforeAnimFinish) {
                   return false;
               }
               if (base.options.autoPlay !== false) {
                   window.clearInterval(base.autoPlayInterval);
               }
               if (base.browser.isTouch !== true && !base.$owlWrapper.hasClass("grabbing")) {
                   base.$owlWrapper.addClass("grabbing");
               }
               base.newPosX = 0;
               base.newRelativeX = 0;
               $(this).css(base.removeTransition());
               position = $(this).position();
               locals.relativePos = position.left;
               locals.offsetX = getTouches(ev).x - position.left;
               locals.offsetY = getTouches(ev).y - position.top;
               swapEvents("on");
               locals.sliding = false;
               locals.targetElement = ev.target || ev.srcElement;
           }
           function dragMove(event) {
               var ev = event.originalEvent || event || window.event,
                   minSwipe,
                   maxSwipe;
               base.newPosX = getTouches(ev).x - locals.offsetX;
               base.newPosY = getTouches(ev).y - locals.offsetY;
               base.newRelativeX = base.newPosX - locals.relativePos;
               if (typeof base.options.startDragging === "function" && locals.dragging !== true && base.newRelativeX !== 0) {
                   locals.dragging = true;
                   base.options.startDragging.apply(base, [base.$elem]);
               }
               if ((base.newRelativeX > 8 || base.newRelativeX < -8) && (base.browser.isTouch === true)) {
                   if (ev.preventDefault !== undefined) {
                       ev.preventDefault();
                   } else {
                       ev.returnValue = false;
                   }
                   locals.sliding = true;
               }
               if ((base.newPosY > 10 || base.newPosY < -10) && locals.sliding === false) {
                   $(document).off("touchmove.owl");
               }
               minSwipe = function () {
                   return base.newRelativeX / 5;
               };
               maxSwipe = function () {
                   return base.maximumPixels + base.newRelativeX / 5;
               };
               base.newPosX = Math.max(Math.min(base.newPosX, minSwipe()), maxSwipe());
               if (base.browser.support3d === true) {
                   base.transition3d(base.newPosX);
               } else {
                   base.css2move(base.newPosX);
               }
           }
           function dragEnd(event) {
               var ev = event.originalEvent || event || window.event,
                   newPosition,
                   handlers,
                   owlStopEvent;
               ev.target = ev.target || ev.srcElement;
               locals.dragging = false;
               if (base.browser.isTouch !== true) {
                   base.$owlWrapper.removeClass("grabbing");
               }
               if (base.newRelativeX < 0) {
                   base.dragDirection = base.owl.dragDirection = "left";
               } else {
                   base.dragDirection = base.owl.dragDirection = "right";
               }
               if (base.newRelativeX !== 0) {
                   newPosition = base.getNewPosition();
                   base.goTo(newPosition, false, "drag");
                   if (locals.targetElement === ev.target && base.browser.isTouch !== true) {
                       $(ev.target).on("click.disable", function (ev) {
                           ev.stopImmediatePropagation();
                           ev.stopPropagation();
                           ev.preventDefault();
                           $(ev.target).off("click.disable");
                       });
                       handlers = $._data(ev.target, "events").click;
                       owlStopEvent = handlers.pop();
                       handlers.splice(0, 0, owlStopEvent);
                   }
               }
               swapEvents("off");
           }
           base.$elem.on(base.ev_types.start, ".owl-wrapper", dragStart);
       },
       getNewPosition : function () {
           var base = this,
               newPosition = base.closestItem();
           if (newPosition > base.maximumItem) {
               base.currentItem = base.maximumItem;
               newPosition  = base.maximumItem;
           } else if (base.newPosX >= 0) {
               newPosition = 0;
               base.currentItem = 0;
           }
           return newPosition;
       },
       closestItem : function () {
           var base = this,
               array = base.options.scrollPerPage === true ? base.pagesInArray : base.positionsInArray,
               goal = base.newPosX,
               closest = null;
           $.each(array, function (i, v) {
               if (goal - (base.itemWidth / 20) > array[i + 1] && goal - (base.itemWidth / 20) < v && base.moveDirection() === "left") {
                   closest = v;
                   if (base.options.scrollPerPage === true) {
                       base.currentItem = $.inArray(closest, base.positionsInArray);
                   } else {
                       base.currentItem = i;
                   }
               } else if (goal + (base.itemWidth / 20) < v && goal + (base.itemWidth / 20) > (array[i + 1] || array[i] - base.itemWidth) && base.moveDirection() === "right") {
                   if (base.options.scrollPerPage === true) {
                       closest = array[i + 1] || array[array.length - 1];
                       base.currentItem = $.inArray(closest, base.positionsInArray);
                   } else {
                       closest = array[i + 1];
                       base.currentItem = i + 1;
                   }
               }
           });
           return base.currentItem;
       },
       moveDirection : function () {
           var base = this,
               direction;
           if (base.newRelativeX < 0) {
               direction = "right";
               base.playDirection = "next";
           } else {
               direction = "left";
               base.playDirection = "prev";
           }
           return direction;
       },
       customEvents : function () {
           /*jslint unparam: true*/
           var base = this;
           base.$elem.on("owl.next", function () {
               base.next();
           });
           base.$elem.on("owl.prev", function () {
               base.prev();
           });
           base.$elem.on("owl.play", function (event, speed) {
               base.options.autoPlay = speed;
               base.play();
               base.hoverStatus = "play";
           });
           base.$elem.on("owl.stop", function () {
               base.stop();
               base.hoverStatus = "stop";
           });
           base.$elem.on("owl.goTo", function (event, item) {
               base.goTo(item);
           });
           base.$elem.on("owl.jumpTo", function (event, item) {
               base.jumpTo(item);
           });
       },
       stopOnHover : function () {
           var base = this;
           if (base.options.stopOnHover === true && base.browser.isTouch !== true && base.options.autoPlay !== false) {
               base.$elem.on("mouseover", function () {
                   base.stop();
               });
               base.$elem.on("mouseout", function () {
                   if (base.hoverStatus !== "stop") {
                       base.play();
                   }
               });
           }
       },
       lazyLoad : function () {
           var base = this,
               i,
               $item,
               itemNumber,
               $lazyImg,
               follow;
           if (base.options.lazyLoad === false) {
               return false;
           }
           for (i = 0; i < base.itemsAmount; i += 1) {
               $item = $(base.$owlItems[i]);
               if ($item.data("owl-loaded") === "loaded") {
                   continue;
               }
               itemNumber = $item.data("owl-item");
               $lazyImg = $item.find(".lazyOwl");
               if (typeof $lazyImg.data("src") !== "string") {
                   $item.data("owl-loaded", "loaded");
                   continue;
               }
               if ($item.data("owl-loaded") === undefined) {
                   $lazyImg.hide();
                   $item.addClass("loading").data("owl-loaded", "checked");
               }
               if (base.options.lazyFollow === true) {
                   follow = itemNumber >= base.currentItem;
               } else {
                   follow = true;
               }
               if (follow && itemNumber < base.currentItem + base.options.items && $lazyImg.length) {
                   base.lazyPreload($item, $lazyImg);
               }
           }
       },
       lazyPreload : function ($item, $lazyImg) {
           var base = this,
               iterations = 0,
               isBackgroundImg;
           if ($lazyImg.prop("tagName") === "DIV") {
               $lazyImg.css("background-image", "url(" + $lazyImg.data("src") + ")");
               isBackgroundImg = true;
           } else {
               $lazyImg[0].src = $lazyImg.data("src");
           }
           function showImage() {
               $item.data("owl-loaded", "loaded").removeClass("loading");
               $lazyImg.removeAttr("data-src");
               if (base.options.lazyEffect === "fade") {
                   $lazyImg.fadeIn(400);
               } else {
                   $lazyImg.show();
               }
               if (typeof base.options.afterLazyLoad === "function") {
                   base.options.afterLazyLoad.apply(this, [base.$elem]);
               }
           }
           function checkLazyImage() {
               iterations += 1;
               if (base.completeImg($lazyImg.get(0)) || isBackgroundImg === true) {
                   showImage();
               } else if (iterations <= 100) {//if image loads in less than 10 seconds 
                   window.setTimeout(checkLazyImage, 100);
               } else {
                   showImage();
               }
           }
           checkLazyImage();
       },
       autoHeight : function () {
           var base = this,
               $currentimg = $(base.$owlItems[base.currentItem]).find("img"),
               iterations;
           function addHeight() {
               var $currentItem = $(base.$owlItems[base.currentItem]).height();
               base.wrapperOuter.css("height", $currentItem + "px");
               if (!base.wrapperOuter.hasClass("autoHeight")) {
                   window.setTimeout(function () {
                       base.wrapperOuter.addClass("autoHeight");
                   }, 0);
               }
           }
           function checkImage() {
               iterations += 1;
               if (base.completeImg($currentimg.get(0))) {
                   addHeight();
               } else if (iterations <= 100) { //if image loads in less than 10 seconds 
                   window.setTimeout(checkImage, 100);
               } else {
                   base.wrapperOuter.css("height", ""); //Else remove height attribute
               }
           }
           if ($currentimg.get(0) !== undefined) {
               iterations = 0;
               checkImage();
           } else {
               addHeight();
           }
       },
       completeImg : function (img) {
           var naturalWidthType;
           if (!img.complete) {
               return false;
           }
           naturalWidthType = typeof img.naturalWidth;
           if (naturalWidthType !== "undefined" && img.naturalWidth === 0) {
               return false;
           }
           return true;
       },
       onVisibleItems : function () {
           var base = this,
               i;
           if (base.options.addClassActive === true) {
               base.$owlItems.removeClass("active");
           }
           base.visibleItems = [];
           for (i = base.currentItem; i < base.currentItem + base.options.items; i += 1) {
               base.visibleItems.push(i);
               if (base.options.addClassActive === true) {
                   $(base.$owlItems[i]).addClass("active");
               }
           }
           base.owl.visibleItems = base.visibleItems;
       },
       transitionTypes : function (className) {
           var base = this;
           //Currently available: "fade", "backSlide", "goDown", "fadeUp"
           base.outClass = "owl-" + className + "-out";
           base.inClass = "owl-" + className + "-in";
       },
       singleItemTransition : function () {
           var base = this,
               outClass = base.outClass,
               inClass = base.inClass,
               $currentItem = base.$owlItems.eq(base.currentItem),
               $prevItem = base.$owlItems.eq(base.prevItem),
               prevPos = Math.abs(base.positionsInArray[base.currentItem]) + base.positionsInArray[base.prevItem],
               origin = Math.abs(base.positionsInArray[base.currentItem]) + base.itemWidth / 2,
               animEnd = 'webkitAnimationEnd oAnimationEnd MSAnimationEnd animationend';
           base.isTransition = true;
           base.$owlWrapper
               .addClass('owl-origin')
               .css({
                   "-webkit-transform-origin" : origin + "px",
                   "-moz-perspective-origin" : origin + "px",
                   "perspective-origin" : origin + "px"
               });
           function transStyles(prevPos) {
               return {
                   "position" : "relative",
                   "left" : prevPos + "px"
               };
           }
           $prevItem
               .css(transStyles(prevPos, 10))
               .addClass(outClass)
               .on(animEnd, function () {
                   base.endPrev = true;
                   $prevItem.off(animEnd);
                   base.clearTransStyle($prevItem, outClass);
               });
           $currentItem
               .addClass(inClass)
               .on(animEnd, function () {
                   base.endCurrent = true;
                   $currentItem.off(animEnd);
                   base.clearTransStyle($currentItem, inClass);
               });
       },
       clearTransStyle : function (item, classToRemove) {
           var base = this;
           item.css({
               "position" : "",
               "left" : ""
           }).removeClass(classToRemove);
           if (base.endPrev && base.endCurrent) {
               base.$owlWrapper.removeClass('owl-origin');
               base.endPrev = false;
               base.endCurrent = false;
               base.isTransition = false;
           }
       },
       owlStatus : function () {
           var base = this;
           base.owl = {
               "userOptions"   : base.userOptions,
               "baseElement"   : base.$elem,
               "userItems"     : base.$userItems,
               "owlItems"      : base.$owlItems,
               "currentItem"   : base.currentItem,
               "prevItem"      : base.prevItem,
               "visibleItems"  : base.visibleItems,
               "isTouch"       : base.browser.isTouch,
               "browser"       : base.browser,
               "dragDirection" : base.dragDirection
           };
       },
       clearEvents : function () {
           var base = this;
           base.$elem.off(".owl owl mousedown.disableTextSelect");
           $(document).off(".owl owl");
           $(window).off("resize", base.resizer);
       },
       unWrap : function () {
           var base = this;
           if (base.$elem.children().length !== 0) {
               base.$owlWrapper.unwrap();
               base.$userItems.unwrap().unwrap();
               if (base.owlControls) {
                   base.owlControls.remove();
               }
           }
           base.clearEvents();
           base.$elem
               .attr("style", base.$elem.data("owl-originalStyles") || "")
               .attr("class", base.$elem.data("owl-originalClasses"));
       },
       destroy : function () {
           var base = this;
           base.stop();
           window.clearInterval(base.checkVisible);
           base.unWrap();
           base.$elem.removeData();
       },
       reinit : function (newOptions) {
           var base = this,
               options = $.extend({}, base.userOptions, newOptions);
           base.unWrap();
           base.init(options, base.$elem);
       },
       addItem : function (htmlString, targetPosition) {
           var base = this,
               position;
           if (!htmlString) {return false; }
           if (base.$elem.children().length === 0) {
               base.$elem.append(htmlString);
               base.setVars();
               return false;
           }
           base.unWrap();
           if (targetPosition === undefined || targetPosition === -1) {
               position = -1;
           } else {
               position = targetPosition;
           }
           if (position >= base.$userItems.length || position === -1) {
               base.$userItems.eq(-1).after(htmlString);
           } else {
               base.$userItems.eq(position).before(htmlString);
           }
           base.setVars();
       },
       removeItem : function (targetPosition) {
           var base = this,
               position;
           if (base.$elem.children().length === 0) {
               return false;
           }
           if (targetPosition === undefined || targetPosition === -1) {
               position = -1;
           } else {
               position = targetPosition;
           }
           base.unWrap();
           base.$userItems.eq(position).remove();
           base.setVars();
       }
   };
   $.fn.owlCarousel = function (options) {
       return this.each(function () {
           if ($(this).data("owl-init") === true) {
               return false;
           }
           $(this).data("owl-init", true);
           var carousel = Object.create(Carousel);
           carousel.init(options, this);
           $.data(this, "owlCarousel", carousel);
       });
   };
   $.fn.owlCarousel.options = {
       items : 5,
       itemsCustom : false,
       itemsDesktop : [1199, 4],
       itemsDesktopSmall : [979, 3],
       itemsTablet : [768, 2],
       itemsTabletSmall : false,
       itemsMobile : [479, 1],
       singleItem : false,
       itemsScaleUp : false,
       slideSpeed : 200,
       paginationSpeed : 800,
       rewindSpeed : 1000,
       autoPlay : false,
       stopOnHover : false,
       navigation : false,
       navigationText : ["prev", "next"],
       rewindNav : true,
       scrollPerPage : false,
       pagination : true,
       paginationNumbers : false,
       responsive : true,
       responsiveRefreshRate : 200,
       responsiveBaseWidth : window,
       baseClass : "owl-carousel",
       theme : "owl-theme",
       lazyLoad : false,
       lazyFollow : true,
       lazyEffect : "fade",
       autoHeight : false,
       jsonPath : false,
       jsonSuccess : false,
       dragBeforeAnimFinish : true,
       mouseDrag : true,
       touchDrag : true,
       addClassActive : false,
       transitionStyle : false,
       beforeUpdate : false,
       afterUpdate : false,
       beforeInit : false,
       afterInit : false,
       beforeMove : false,
       afterMove : false,
       afterAction : false,
       startDragging : false,
       afterLazyLoad: false
   };

}(jQuery, window, document));


/*

* jQuery FlexSlider v2.2.0
* Copyright 2012 WooThemes
* Contributing Author: Tyler Smith
*/

(function ($) {

 //FlexSlider: Object Instance
 $.flexslider = function(el, options) {
   var slider = $(el);
   // making variables public
   slider.vars = $.extend({}, $.flexslider.defaults, options);
   var namespace = slider.vars.namespace,
       msGesture = window.navigator && window.navigator.msPointerEnabled && window.MSGesture,
       touch = (( "ontouchstart" in window ) || msGesture || window.DocumentTouch && document instanceof DocumentTouch) && slider.vars.touch,
       // depricating this idea, as devices are being released with both of these events
       //eventType = (touch) ? "touchend" : "click",
       eventType = "click touchend MSPointerUp",
       watchedEvent = "",
       watchedEventClearTimer,
       vertical = slider.vars.direction === "vertical",
       reverse = slider.vars.reverse,
       carousel = (slider.vars.itemWidth > 0),
       fade = slider.vars.animation === "fade",
       asNav = slider.vars.asNavFor !== "",
       methods = {},
       focused = true;
   // Store a reference to the slider object
   $.data(el, "flexslider", slider);
   // Private slider methods
   methods = {
     init: function() {
       slider.animating = false;
       // Get current slide and make sure it is a number
       slider.currentSlide = parseInt( ( slider.vars.startAt ? slider.vars.startAt : 0) );
       if ( isNaN( slider.currentSlide ) ) slider.currentSlide = 0;
       slider.animatingTo = slider.currentSlide;
       slider.atEnd = (slider.currentSlide === 0 || slider.currentSlide === slider.last);
       slider.containerSelector = slider.vars.selector.substr(0,slider.vars.selector.search(' '));
       slider.slides = $(slider.vars.selector, slider);
       slider.container = $(slider.containerSelector, slider);
       slider.count = slider.slides.length;
       // SYNC:
       slider.syncExists = $(slider.vars.sync).length > 0;
       // SLIDE:
       if (slider.vars.animation === "slide") slider.vars.animation = "swing";
       slider.prop = (vertical) ? "top" : "marginLeft";
       slider.args = {};
       // SLIDESHOW:
       slider.manualPause = false;
       slider.stopped = false;
       //PAUSE WHEN INVISIBLE
       slider.started = false;
       slider.startTimeout = null;
       // TOUCH/USECSS:
       slider.transitions = !slider.vars.video && !fade && slider.vars.useCSS && (function() {
         var obj = document.createElement('div'),
             props = ['perspectiveProperty', 'WebkitPerspective', 'MozPerspective', 'OPerspective', 'msPerspective'];
         for (var i in props) {
           if ( obj.style[ props[i] ] !== undefined ) {
             slider.pfx = props[i].replace('Perspective',).toLowerCase();
             slider.prop = "-" + slider.pfx + "-transform";
             return true;
           }
         }
         return false;
       }());
       // CONTROLSCONTAINER:
       if (slider.vars.controlsContainer !== "") slider.controlsContainer = $(slider.vars.controlsContainer).length > 0 && $(slider.vars.controlsContainer);
       // MANUAL:
       if (slider.vars.manualControls !== "") slider.manualControls = $(slider.vars.manualControls).length > 0 && $(slider.vars.manualControls);
       // RANDOMIZE:
       if (slider.vars.randomize) {
         slider.slides.sort(function() { return (Math.round(Math.random())-0.5); });
         slider.container.empty().append(slider.slides);
       }
       slider.doMath();
       // INIT
       slider.setup("init");
       // CONTROLNAV:
       if (slider.vars.controlNav) methods.controlNav.setup();
       // DIRECTIONNAV:
       if (slider.vars.directionNav) methods.directionNav.setup();
       // KEYBOARD:
       if (slider.vars.keyboard && ($(slider.containerSelector).length === 1 || slider.vars.multipleKeyboard)) {
         $(document).bind('keyup', function(event) {
           var keycode = event.keyCode;
           if (!slider.animating && (keycode === 39 || keycode === 37)) {
             var target = (keycode === 39) ? slider.getTarget('next') :
                          (keycode === 37) ? slider.getTarget('prev') : false;
             slider.flexAnimate(target, slider.vars.pauseOnAction);
           }
         });
       }
       // MOUSEWHEEL:
       if (slider.vars.mousewheel) {
         slider.bind('mousewheel', function(event, delta, deltaX, deltaY) {
           event.preventDefault();
           var target = (delta < 0) ? slider.getTarget('next') : slider.getTarget('prev');
           slider.flexAnimate(target, slider.vars.pauseOnAction);
         });
       }
       // PAUSEPLAY
       if (slider.vars.pausePlay) methods.pausePlay.setup();
       //PAUSE WHEN INVISIBLE
       if (slider.vars.slideshow && slider.vars.pauseInvisible) methods.pauseInvisible.init();
       // SLIDSESHOW
       if (slider.vars.slideshow) {
         if (slider.vars.pauseOnHover) {
           slider.hover(function() {
             if (!slider.manualPlay && !slider.manualPause) slider.pause();
           }, function() {
             if (!slider.manualPause && !slider.manualPlay && !slider.stopped) slider.play();
           });
         }
         // initialize animation
         //If we're visible, or we don't use PageVisibility API
         if(!slider.vars.pauseInvisible || !methods.pauseInvisible.isHidden()) {
           (slider.vars.initDelay > 0) ? slider.startTimeout = setTimeout(slider.play, slider.vars.initDelay) : slider.play();
         }
       }
       // ASNAV:
       if (asNav) methods.asNav.setup();
       // TOUCH
       if (touch && slider.vars.touch) methods.touch();
       // FADE&&SMOOTHHEIGHT || SLIDE:
       if (!fade || (fade && slider.vars.smoothHeight)) $(window).bind("resize orientationchange focus", methods.resize);
       slider.find("img").attr("draggable", "false");
       // API: start() Callback
       setTimeout(function(){
         slider.vars.start(slider);
       }, 200);
     },
     asNav: {
       setup: function() {
         slider.asNav = true;
         slider.animatingTo = Math.floor(slider.currentSlide/slider.move);
         slider.currentItem = slider.currentSlide;
         slider.slides.removeClass(namespace + "active-slide").eq(slider.currentItem).addClass(namespace + "active-slide");
         if(!msGesture){
             slider.slides.click(function(e){
               e.preventDefault();
               var $slide = $(this),
                   target = $slide.index();
               var posFromLeft = $slide.offset().left - $(slider).scrollLeft(); // Find position of slide relative to left of slider container
               if( posFromLeft <= 0 && $slide.hasClass( namespace + 'active-slide' ) ) {
                 slider.flexAnimate(slider.getTarget("prev"), true);
               } else if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass(namespace + "active-slide")) {
                 slider.direction = (slider.currentItem < target) ? "next" : "prev";
                 slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
               }
             });
         }else{
             el._slider = slider;
             slider.slides.each(function (){
                 var that = this;
                 that._gesture = new MSGesture();
                 that._gesture.target = that;
                 that.addEventListener("MSPointerDown", function (e){
                     e.preventDefault();
                     if(e.currentTarget._gesture)
                         e.currentTarget._gesture.addPointer(e.pointerId);
                 }, false);
                 that.addEventListener("MSGestureTap", function (e){
                     e.preventDefault();
                     var $slide = $(this),
                         target = $slide.index();
                     if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass('active')) {
                         slider.direction = (slider.currentItem < target) ? "next" : "prev";
                         slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
                     }
                 });
             });
         }
       }
     },
     controlNav: {
       setup: function() {
         if (!slider.manualControls) {
           methods.controlNav.setupPaging();
         } else { // MANUALCONTROLS:
           methods.controlNav.setupManual();
         }
       },
       setupPaging: function() {
         var type = (slider.vars.controlNav === "thumbnails") ? 'control-thumbs' : 'control-paging',
             j = 1,
             item,
             slide;
slider.controlNavScaffold = $('
    ');
             if (slider.pagingCount > 1) {
               for (var i = 0; i < slider.pagingCount; i++) {
                 slide = slider.slides.eq(i);
                 item = (slider.vars.controlNav === "thumbnails") ? '<img src="' + slide.attr( 'data-thumb' ) + '"/>' : '<a>' + j + '</a>';
                 if ( 'thumbnails' === slider.vars.controlNav && true === slider.vars.thumbCaptions ) {
                   var captn = slide.attr( 'data-thumbcaption' );
                   if (  != captn && undefined != captn ) item += '' + captn + '';
                 }
    
    slider.controlNavScaffold.append('
  1. ' + item + '
  2. ');
                 j++;
               }
             }
    
             // CONTROLSCONTAINER:
             (slider.controlsContainer) ? $(slider.controlsContainer).append(slider.controlNavScaffold) : slider.append(slider.controlNavScaffold);
             methods.controlNav.set();
    
             methods.controlNav.active();
    
             slider.controlNavScaffold.delegate('a, img', eventType, function(event) {
               event.preventDefault();
    
               if (watchedEvent === "" || watchedEvent === event.type) {
                 var $this = $(this),
                     target = slider.controlNav.index($this);
    
                 if (!$this.hasClass(namespace + 'active')) {
                   slider.direction = (target > slider.currentSlide) ? "next" : "prev";
                   slider.flexAnimate(target, slider.vars.pauseOnAction);
                 }
               }
    
               // setup flags to prevent event duplication
               if (watchedEvent === "") {
                 watchedEvent = event.type;
               }
               methods.setToClearWatchedEvent();
    
             });
           },
           setupManual: function() {
             slider.controlNav = slider.manualControls;
             methods.controlNav.active();
    
             slider.controlNav.bind(eventType, function(event) {
               event.preventDefault();
    
               if (watchedEvent === "" || watchedEvent === event.type) {
                 var $this = $(this),
                     target = slider.controlNav.index($this);
    
                 if (!$this.hasClass(namespace + 'active')) {
                   (target > slider.currentSlide) ? slider.direction = "next" : slider.direction = "prev";
                   slider.flexAnimate(target, slider.vars.pauseOnAction);
                 }
               }
    
               // setup flags to prevent event duplication
               if (watchedEvent === "") {
                 watchedEvent = event.type;
               }
               methods.setToClearWatchedEvent();
             });
           },
           set: function() {
             var selector = (slider.vars.controlNav === "thumbnails") ? 'img' : 'a';
             slider.controlNav = $('.' + namespace + 'control-nav li ' + selector, (slider.controlsContainer) ? slider.controlsContainer : slider);
           },
           active: function() {
             slider.controlNav.removeClass(namespace + "active").eq(slider.animatingTo).addClass(namespace + "active");
           },
           update: function(action, pos) {
             if (slider.pagingCount > 1 && action === "add") {
    
    slider.controlNavScaffold.append($('
  3. <a>' + slider.count + '</a>
  4. '));
             } else if (slider.pagingCount === 1) {
               slider.controlNavScaffold.find('li').remove();
             } else {
               slider.controlNav.eq(pos).closest('li').remove();
             }
             methods.controlNav.set();
             (slider.pagingCount > 1 && slider.pagingCount !== slider.controlNav.length) ? slider.update(pos, action) : methods.controlNav.active();
           }
         },
         directionNav: {
           setup: function() {
    
    var directionNavScaffold = $('
    • <a class="' + namespace + 'prev" href="#">' + slider.vars.prevText + '</a>
    • <a class="' + namespace + 'next" href="#">' + slider.vars.nextText + '</a>
    ');
             // CONTROLSCONTAINER:
             if (slider.controlsContainer) {
               $(slider.controlsContainer).append(directionNavScaffold);
               slider.directionNav = $('.' + namespace + 'direction-nav li a', slider.controlsContainer);
             } else {
               slider.append(directionNavScaffold);
               slider.directionNav = $('.' + namespace + 'direction-nav li a', slider);
             }
    
             methods.directionNav.update();
    
             slider.directionNav.bind(eventType, function(event) {
               event.preventDefault();
               var target;
    
               if (watchedEvent === "" || watchedEvent === event.type) {
                 target = ($(this).hasClass(namespace + 'next')) ? slider.getTarget('next') : slider.getTarget('prev');
                 slider.flexAnimate(target, slider.vars.pauseOnAction);
               }
    
               // setup flags to prevent event duplication
               if (watchedEvent === "") {
                 watchedEvent = event.type;
               }
               methods.setToClearWatchedEvent();
             });
           },
           update: function() {
             var disabledClass = namespace + 'disabled';
             if (slider.pagingCount === 1) {
               slider.directionNav.addClass(disabledClass).attr('tabindex', '-1');
             } else if (!slider.vars.animationLoop) {
               if (slider.animatingTo === 0) {
                 slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "prev").addClass(disabledClass).attr('tabindex', '-1');
               } else if (slider.animatingTo === slider.last) {
                 slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "next").addClass(disabledClass).attr('tabindex', '-1');
               } else {
                 slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
               }
             } else {
               slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
             }
           }
         },
         pausePlay: {
           setup: function() {
    
    var pausePlayScaffold = $('
    <a></a>
    ');
             // CONTROLSCONTAINER:
             if (slider.controlsContainer) {
               slider.controlsContainer.append(pausePlayScaffold);
               slider.pausePlay = $('.' + namespace + 'pauseplay a', slider.controlsContainer);
             } else {
               slider.append(pausePlayScaffold);
               slider.pausePlay = $('.' + namespace + 'pauseplay a', slider);
             }
    
             methods.pausePlay.update((slider.vars.slideshow) ? namespace + 'pause' : namespace + 'play');
    
             slider.pausePlay.bind(eventType, function(event) {
               event.preventDefault();
    
               if (watchedEvent === "" || watchedEvent === event.type) {
                 if ($(this).hasClass(namespace + 'pause')) {
                   slider.manualPause = true;
                   slider.manualPlay = false;
                   slider.pause();
                 } else {
                   slider.manualPause = false;
                   slider.manualPlay = true;
                   slider.play();
                 }
               }
    
               // setup flags to prevent event duplication
               if (watchedEvent === "") {
                 watchedEvent = event.type;
               }
               methods.setToClearWatchedEvent();
             });
           },
           update: function(state) {
             (state === "play") ? slider.pausePlay.removeClass(namespace + 'pause').addClass(namespace + 'play').html(slider.vars.playText) : slider.pausePlay.removeClass(namespace + 'play').addClass(namespace + 'pause').html(slider.vars.pauseText);
           }
         },
         touch: function() {
           var startX,
             startY,
             offset,
             cwidth,
             dx,
             startT,
             scrolling = false,
             localX = 0,
             localY = 0,
             accDx = 0;
    
           if(!msGesture){
               el.addEventListener('touchstart', onTouchStart, false);
    
               function onTouchStart(e) {
                 if (slider.animating) {
                   e.preventDefault();
                 } else if ( ( window.navigator.msPointerEnabled ) || e.touches.length === 1 ) {
                   slider.pause();
                   // CAROUSEL:
                   cwidth = (vertical) ? slider.h : slider. w;
                   startT = Number(new Date());
                   // CAROUSEL:
    
                   // Local vars for X and Y points.
                   localX = e.touches[0].pageX;
                   localY = e.touches[0].pageY;
    
                   offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
                            (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
                            (carousel && slider.currentSlide === slider.last) ? slider.limit :
                            (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
                            (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
                   startX = (vertical) ? localY : localX;
                   startY = (vertical) ? localX : localY;
    
                   el.addEventListener('touchmove', onTouchMove, false);
                   el.addEventListener('touchend', onTouchEnd, false);
                 }
               }
    
               function onTouchMove(e) {
                 // Local vars for X and Y points.
    
                 localX = e.touches[0].pageX;
                 localY = e.touches[0].pageY;
    
                 dx = (vertical) ? startX - localY : startX - localX;
                 scrolling = (vertical) ? (Math.abs(dx) < Math.abs(localX - startY)) : (Math.abs(dx) < Math.abs(localY - startY));
    
                 var fxms = 500;
    
                 if ( ! scrolling || Number( new Date() ) - startT > fxms ) {
                   e.preventDefault();
                   if (!fade && slider.transitions) {
                     if (!slider.vars.animationLoop) {
                       dx = dx/((slider.currentSlide === 0 && dx < 0 || slider.currentSlide === slider.last && dx > 0) ? (Math.abs(dx)/cwidth+2) : 1);
                     }
                     slider.setProps(offset + dx, "setTouch");
                   }
                 }
               }
    
               function onTouchEnd(e) {
                 // finish the touch by undoing the touch session
                 el.removeEventListener('touchmove', onTouchMove, false);
    
                 if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
                   var updateDx = (reverse) ? -dx : dx,
                       target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
    
                   if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
                     slider.flexAnimate(target, slider.vars.pauseOnAction);
                   } else {
                     if (!fade) slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);
                   }
                 }
                 el.removeEventListener('touchend', onTouchEnd, false);
    
                 startX = null;
                 startY = null;
                 dx = null;
                 offset = null;
               }
           }else{
               el.style.msTouchAction = "none";
               el._gesture = new MSGesture();
               el._gesture.target = el;
               el.addEventListener("MSPointerDown", onMSPointerDown, false);
               el._slider = slider;
               el.addEventListener("MSGestureChange", onMSGestureChange, false);
               el.addEventListener("MSGestureEnd", onMSGestureEnd, false);
    
               function onMSPointerDown(e){
                   e.stopPropagation();
                   if (slider.animating) {
                       e.preventDefault();
                   }else{
                       slider.pause();
                       el._gesture.addPointer(e.pointerId);
                       accDx = 0;
                       cwidth = (vertical) ? slider.h : slider. w;
                       startT = Number(new Date());
                       // CAROUSEL:
    
                       offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
                           (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
                               (carousel && slider.currentSlide === slider.last) ? slider.limit :
                                   (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
                                       (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
                   }
               }
    
               function onMSGestureChange(e) {
                   e.stopPropagation();
                   var slider = e.target._slider;
                   if(!slider){
                       return;
                   }
                   var transX = -e.translationX,
                       transY = -e.translationY;
    
                   //Accumulate translations.
                   accDx = accDx + ((vertical) ? transY : transX);
                   dx = accDx;
                   scrolling = (vertical) ? (Math.abs(accDx) < Math.abs(-transX)) : (Math.abs(accDx) < Math.abs(-transY));
    
                   if(e.detail === e.MSGESTURE_FLAG_INERTIA){
                       setImmediate(function (){
                           el._gesture.stop();
                       });
    
                       return;
                   }
    
                   if (!scrolling || Number(new Date()) - startT > 500) {
                       e.preventDefault();
                       if (!fade && slider.transitions) {
                           if (!slider.vars.animationLoop) {
                               dx = accDx / ((slider.currentSlide === 0 && accDx < 0 || slider.currentSlide === slider.last && accDx > 0) ? (Math.abs(accDx) / cwidth + 2) : 1);
                           }
                           slider.setProps(offset + dx, "setTouch");
                       }
                   }
               }
    
               function onMSGestureEnd(e) {
                   e.stopPropagation();
                   var slider = e.target._slider;
                   if(!slider){
                       return;
                   }
                   if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
                       var updateDx = (reverse) ? -dx : dx,
                           target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
    
                       if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
                           slider.flexAnimate(target, slider.vars.pauseOnAction);
                       } else {
                           if (!fade) slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);
                       }
                   }
    
                   startX = null;
                   startY = null;
                   dx = null;
                   offset = null;
                   accDx = 0;
               }
           }
         },
         resize: function() {
           if (!slider.animating && slider.is(':visible')) {
             if (!carousel) slider.doMath();
    
             if (fade) {
               // SMOOTH HEIGHT:
               methods.smoothHeight();
             } else if (carousel) { //CAROUSEL:
               slider.slides.width(slider.computedW);
               slider.update(slider.pagingCount);
               slider.setProps();
             }
             else if (vertical) { //VERTICAL:
               slider.viewport.height(slider.h);
               slider.setProps(slider.h, "setTotal");
             } else {
               // SMOOTH HEIGHT:
               if (slider.vars.smoothHeight) methods.smoothHeight();
               slider.newSlides.width(slider.computedW);
               slider.setProps(slider.computedW, "setTotal");
             }
           }
         },
         smoothHeight: function(dur) {
           if (!vertical || fade) {
             var $obj = (fade) ? slider : slider.viewport;
             (dur) ? $obj.animate({"height": slider.slides.eq(slider.animatingTo).height()}, dur) : $obj.height(slider.slides.eq(slider.animatingTo).height());
           }
         },
         sync: function(action) {
           var $obj = $(slider.vars.sync).data("flexslider"),
               target = slider.animatingTo;
    
           switch (action) {
             case "animate": $obj.flexAnimate(target, slider.vars.pauseOnAction, false, true); break;
             case "play": if (!$obj.playing && !$obj.asNav) { $obj.play(); } break;
             case "pause": $obj.pause(); break;
           }
         },
         pauseInvisible: {
           visProp: null,
           init: function() {
             var prefixes = ['webkit','moz','ms','o'];
    
             if ('hidden' in document) return 'hidden';
             for (var i = 0; i < prefixes.length; i++) {
               if ((prefixes[i] + 'Hidden') in document) 
               methods.pauseInvisible.visProp = prefixes[i] + 'Hidden';
             }
             if (methods.pauseInvisible.visProp) {
               var evtname = methods.pauseInvisible.visProp.replace(/[H|h]idden/,) + 'visibilitychange';
               document.addEventListener(evtname, function() {
                 if (methods.pauseInvisible.isHidden()) {
                   if(slider.startTimeout) clearTimeout(slider.startTimeout); //If clock is ticking, stop timer and prevent from starting while invisible
                   else slider.pause(); //Or just pause
                 }
                 else {
                   if(slider.started) slider.play(); //Initiated before, just play
                   else (slider.vars.initDelay > 0) ? setTimeout(slider.play, slider.vars.initDelay) : slider.play(); //Didn't init before: simply init or wait for it
                 }
               });
             }       
           },
           isHidden: function() {
             return document[methods.pauseInvisible.visProp] || false;
           }
         },
         setToClearWatchedEvent: function() {
           clearTimeout(watchedEventClearTimer);
           watchedEventClearTimer = setTimeout(function() {
             watchedEvent = "";
           }, 3000);
         }
       }
    
       // public methods
       slider.flexAnimate = function(target, pause, override, withSync, fromNav) {
         if (!slider.vars.animationLoop && target !== slider.currentSlide) {
           slider.direction = (target > slider.currentSlide) ? "next" : "prev";
         }
    
         if (asNav && slider.pagingCount === 1) slider.direction = (slider.currentItem < target) ? "next" : "prev";
    
         if (!slider.animating && (slider.canAdvance(target, fromNav) || override) && slider.is(":visible")) {
           if (asNav && withSync) {
             var master = $(slider.vars.asNavFor).data('flexslider');
             slider.atEnd = target === 0 || target === slider.count - 1;
             master.flexAnimate(target, true, false, true, fromNav);
             slider.direction = (slider.currentItem < target) ? "next" : "prev";
             master.direction = slider.direction;
    
             if (Math.ceil((target + 1)/slider.visible) - 1 !== slider.currentSlide && target !== 0) {
               slider.currentItem = target;
               slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
               target = Math.floor(target/slider.visible);
             } else {
               slider.currentItem = target;
               slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
               return false;
             }
           }
    
           slider.animating = true;
           slider.animatingTo = target;
    
           // SLIDESHOW:
           if (pause) slider.pause();
    
           // API: before() animation Callback
           slider.vars.before(slider);
    
           // SYNC:
           if (slider.syncExists && !fromNav) methods.sync("animate");
    
           // CONTROLNAV
           if (slider.vars.controlNav) methods.controlNav.active();
    
           // !CAROUSEL:
           // CANDIDATE: slide active class (for add/remove slide)
           if (!carousel) slider.slides.removeClass(namespace + 'active-slide').eq(target).addClass(namespace + 'active-slide');
    
           // INFINITE LOOP:
           // CANDIDATE: atEnd
           slider.atEnd = target === 0 || target === slider.last;
    
           // DIRECTIONNAV:
           if (slider.vars.directionNav) methods.directionNav.update();
    
           if (target === slider.last) {
             // API: end() of cycle Callback
             slider.vars.end(slider);
             // SLIDESHOW && !INFINITE LOOP:
             if (!slider.vars.animationLoop) slider.pause();
           }
    
           // SLIDE:
           if (!fade) {
             var dimension = (vertical) ? slider.slides.filter(':first').height() : slider.computedW,
                 margin, slideString, calcNext;
    
             // INFINITE LOOP / REVERSE:
             if (carousel) {
               //margin = (slider.vars.itemWidth > slider.w) ? slider.vars.itemMargin * 2 : slider.vars.itemMargin;
               margin = slider.vars.itemMargin;
               calcNext = ((slider.itemW + margin) * slider.move) * slider.animatingTo;
               slideString = (calcNext > slider.limit && slider.visible !== 1) ? slider.limit : calcNext;
             } else if (slider.currentSlide === 0 && target === slider.count - 1 && slider.vars.animationLoop && slider.direction !== "next") {
               slideString = (reverse) ? (slider.count + slider.cloneOffset) * dimension : 0;
             } else if (slider.currentSlide === slider.last && target === 0 && slider.vars.animationLoop && slider.direction !== "prev") {
               slideString = (reverse) ? 0 : (slider.count + 1) * dimension;
             } else {
               slideString = (reverse) ? ((slider.count - 1) - target + slider.cloneOffset) * dimension : (target + slider.cloneOffset) * dimension;
             }
             slider.setProps(slideString, "", slider.vars.animationSpeed);
             if (slider.transitions) {
               if (!slider.vars.animationLoop || !slider.atEnd) {
                 slider.animating = false;
                 slider.currentSlide = slider.animatingTo;
               }
               slider.container.unbind("webkitTransitionEnd transitionend");
               slider.container.bind("webkitTransitionEnd transitionend", function() {
                 slider.wrapup(dimension);
               });
             } else {
               slider.container.animate(slider.args, slider.vars.animationSpeed, slider.vars.easing, function(){
                 slider.wrapup(dimension);
               });
             }
           } else { // FADE:
             if (!touch) {
               //slider.slides.eq(slider.currentSlide).fadeOut(slider.vars.animationSpeed, slider.vars.easing);
               //slider.slides.eq(target).fadeIn(slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
    
               slider.slides.eq(slider.currentSlide).css({"zIndex": 1}).animate({"opacity": 0}, slider.vars.animationSpeed, slider.vars.easing);
               slider.slides.eq(target).css({"zIndex": 2}).animate({"opacity": 1}, slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
    
             } else {
               slider.slides.eq(slider.currentSlide).css({ "opacity": 0, "zIndex": 1 });
               slider.slides.eq(target).css({ "opacity": 1, "zIndex": 2 });
               slider.wrapup(dimension);
             }
           }
           // SMOOTH HEIGHT:
           if (slider.vars.smoothHeight) methods.smoothHeight(slider.vars.animationSpeed);
         }
       }
       slider.wrapup = function(dimension) {
         // SLIDE:
         if (!fade && !carousel) {
           if (slider.currentSlide === 0 && slider.animatingTo === slider.last && slider.vars.animationLoop) {
             slider.setProps(dimension, "jumpEnd");
           } else if (slider.currentSlide === slider.last && slider.animatingTo === 0 && slider.vars.animationLoop) {
             slider.setProps(dimension, "jumpStart");
           }
         }
         slider.animating = false;
         slider.currentSlide = slider.animatingTo;
         // API: after() animation Callback
         slider.vars.after(slider);
       }
    
       // SLIDESHOW:
       slider.animateSlides = function() {
         if (!slider.animating && focused ) slider.flexAnimate(slider.getTarget("next"));
       }
       // SLIDESHOW:
       slider.pause = function() {
         clearInterval(slider.animatedSlides);
         slider.animatedSlides = null;
         slider.playing = false;
         // PAUSEPLAY:
         if (slider.vars.pausePlay) methods.pausePlay.update("play");
         // SYNC:
         if (slider.syncExists) methods.sync("pause");
       }
       // SLIDESHOW:
       slider.play = function() {
         if (slider.playing) clearInterval(slider.animatedSlides);
         slider.animatedSlides = slider.animatedSlides || setInterval(slider.animateSlides, slider.vars.slideshowSpeed);
         slider.started = slider.playing = true;
         // PAUSEPLAY:
         if (slider.vars.pausePlay) methods.pausePlay.update("pause");
         // SYNC:
         if (slider.syncExists) methods.sync("play");
       }
       // STOP:
       slider.stop = function () {
         slider.pause();
         slider.stopped = true;
       }
       slider.canAdvance = function(target, fromNav) {
         // ASNAV:
         var last = (asNav) ? slider.pagingCount - 1 : slider.last;
         return (fromNav) ? true :
                (asNav && slider.currentItem === slider.count - 1 && target === 0 && slider.direction === "prev") ? true :
                (asNav && slider.currentItem === 0 && target === slider.pagingCount - 1 && slider.direction !== "next") ? false :
                (target === slider.currentSlide && !asNav) ? false :
                (slider.vars.animationLoop) ? true :
                (slider.atEnd && slider.currentSlide === 0 && target === last && slider.direction !== "next") ? false :
                (slider.atEnd && slider.currentSlide === last && target === 0 && slider.direction === "next") ? false :
                true;
       }
       slider.getTarget = function(dir) {
         slider.direction = dir;
         if (dir === "next") {
           return (slider.currentSlide === slider.last) ? 0 : slider.currentSlide + 1;
         } else {
           return (slider.currentSlide === 0) ? slider.last : slider.currentSlide - 1;
         }
       }
    
       // SLIDE:
       slider.setProps = function(pos, special, dur) {
         var target = (function() {
           var posCheck = (pos) ? pos : ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo,
               posCalc = (function() {
                 if (carousel) {
                   return (special === "setTouch") ? pos :
                          (reverse && slider.animatingTo === slider.last) ? 0 :
                          (reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
                          (slider.animatingTo === slider.last) ? slider.limit : posCheck;
                 } else {
                   switch (special) {
                     case "setTotal": return (reverse) ? ((slider.count - 1) - slider.currentSlide + slider.cloneOffset) * pos : (slider.currentSlide + slider.cloneOffset) * pos;
                     case "setTouch": return (reverse) ? pos : pos;
                     case "jumpEnd": return (reverse) ? pos : slider.count * pos;
                     case "jumpStart": return (reverse) ? slider.count * pos : pos;
                     default: return pos;
                   }
                 }
               }());
    
               return (posCalc * -1) + "px";
             }());
    
         if (slider.transitions) {
           target = (vertical) ? "translate3d(0," + target + ",0)" : "translate3d(" + target + ",0,0)";
           dur = (dur !== undefined) ? (dur/1000) + "s" : "0s";
           slider.container.css("-" + slider.pfx + "-transition-duration", dur);
         }
    
         slider.args[slider.prop] = target;
         if (slider.transitions || dur === undefined) slider.container.css(slider.args);
       }
    
       slider.setup = function(type) {
         // SLIDE:
         if (!fade) {
           var sliderOffset, arr;
    
           if (type === "init") {
    
    slider.viewport = $('
    ').css({"overflow": "hidden", "position": "relative"}).appendTo(slider).append(slider.container);
             // INFINITE LOOP:
             slider.cloneCount = 0;
             slider.cloneOffset = 0;
             // REVERSE:
             if (reverse) {
               arr = $.makeArray(slider.slides).reverse();
               slider.slides = $(arr);
               slider.container.empty().append(slider.slides);
             }
           }
           // INFINITE LOOP && !CAROUSEL:
           if (slider.vars.animationLoop && !carousel) {
             slider.cloneCount = 2;
             slider.cloneOffset = 1;
             // clear out old clones
             if (type !== "init") slider.container.find('.clone').remove();
             slider.container.append(slider.slides.first().clone().addClass('clone').attr('aria-hidden', 'true')).prepend(slider.slides.last().clone().addClass('clone').attr('aria-hidden', 'true'));
           }
           slider.newSlides = $(slider.vars.selector, slider);
    
           sliderOffset = (reverse) ? slider.count - 1 - slider.currentSlide + slider.cloneOffset : slider.currentSlide + slider.cloneOffset;
           // VERTICAL:
           if (vertical && !carousel) {
             slider.container.height((slider.count + slider.cloneCount) * 200 + "%").css("position", "absolute").width("100%");
             setTimeout(function(){
               slider.newSlides.css({"display": "block"});
               slider.doMath();
               slider.viewport.height(slider.h);
               slider.setProps(sliderOffset * slider.h, "init");
             }, (type === "init") ? 100 : 0);
           } else {
             slider.container.width((slider.count + slider.cloneCount) * 200 + "%");
             slider.setProps(sliderOffset * slider.computedW, "init");
             setTimeout(function(){
               slider.doMath();
               slider.newSlides.css({"width": slider.computedW, "float": "left", "display": "block"});
               // SMOOTH HEIGHT:
               if (slider.vars.smoothHeight) methods.smoothHeight();
             }, (type === "init") ? 100 : 0);
           }
         } else { // FADE:
           slider.slides.css({"width": "100%", "float": "left", "marginRight": "-100%", "position": "relative"});
           if (type === "init") {
             if (!touch) {
               //slider.slides.eq(slider.currentSlide).fadeIn(slider.vars.animationSpeed, slider.vars.easing);
               slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).animate({"opacity": 1},slider.vars.animationSpeed,slider.vars.easing);
             } else {
               slider.slides.css({ "opacity": 0, "display": "block", "webkitTransition": "opacity " + slider.vars.animationSpeed / 1000 + "s ease", "zIndex": 1 }).eq(slider.currentSlide).css({ "opacity": 1, "zIndex": 2});
             }
           }
           // SMOOTH HEIGHT:
           if (slider.vars.smoothHeight) methods.smoothHeight();
         }
         // !CAROUSEL:
         // CANDIDATE: active slide
         if (!carousel) slider.slides.removeClass(namespace + "active-slide").eq(slider.currentSlide).addClass(namespace + "active-slide");
       }
    


       slider.doMath = function() {
         var slide = slider.slides.first(),
             slideMargin = slider.vars.itemMargin,
             minItems = slider.vars.minItems,
             maxItems = slider.vars.maxItems;
    
         slider.w = (slider.viewport===undefined) ? slider.width() : slider.viewport.width();
         slider.h = slide.height();
         slider.boxPadding = slide.outerWidth() - slide.width();
    
         // CAROUSEL:
         if (carousel) {
           slider.itemT = slider.vars.itemWidth + slideMargin;
           slider.minW = (minItems) ? minItems * slider.itemT : slider.w;
           slider.maxW = (maxItems) ? (maxItems * slider.itemT) - slideMargin : slider.w;
           slider.itemW = (slider.minW > slider.w) ? (slider.w - (slideMargin * (minItems - 1)))/minItems :
                          (slider.maxW < slider.w) ? (slider.w - (slideMargin * (maxItems - 1)))/maxItems :
                          (slider.vars.itemWidth > slider.w) ? slider.w : slider.vars.itemWidth;
    
           slider.visible = Math.floor(slider.w/(slider.itemW));
           slider.move = (slider.vars.move > 0 && slider.vars.move < slider.visible ) ? slider.vars.move : slider.visible;
           slider.pagingCount = Math.ceil(((slider.count - slider.visible)/slider.move) + 1);
           slider.last =  slider.pagingCount - 1;
           slider.limit = (slider.pagingCount === 1) ? 0 :
                          (slider.vars.itemWidth > slider.w) ? (slider.itemW * (slider.count - 1)) + (slideMargin * (slider.count - 1)) : ((slider.itemW + slideMargin) * slider.count) - slider.w - slideMargin;
         } else {
           slider.itemW = slider.w;
           slider.pagingCount = slider.count;
           slider.last = slider.count - 1;
         }
         slider.computedW = slider.itemW - slider.boxPadding;
       }
    


       slider.update = function(pos, action) {
         slider.doMath();
    
         // update currentSlide and slider.animatingTo if necessary
         if (!carousel) {
           if (pos < slider.currentSlide) {
             slider.currentSlide += 1;
           } else if (pos <= slider.currentSlide && pos !== 0) {
             slider.currentSlide -= 1;
           }
           slider.animatingTo = slider.currentSlide;
         }
    
         // update controlNav
         if (slider.vars.controlNav && !slider.manualControls) {
           if ((action === "add" && !carousel) || slider.pagingCount > slider.controlNav.length) {
             methods.controlNav.update("add");
           } else if ((action === "remove" && !carousel) || slider.pagingCount < slider.controlNav.length) {
             if (carousel && slider.currentSlide > slider.last) {
               slider.currentSlide -= 1;
               slider.animatingTo -= 1;
             }
             methods.controlNav.update("remove", slider.last);
           }
         }
         // update directionNav
         if (slider.vars.directionNav) methods.directionNav.update();
    
       }
    
       slider.addSlide = function(obj, pos) {
         var $obj = $(obj);
    
         slider.count += 1;
         slider.last = slider.count - 1;
    
         // append new slide
         if (vertical && reverse) {
           (pos !== undefined) ? slider.slides.eq(slider.count - pos).after($obj) : slider.container.prepend($obj);
         } else {
           (pos !== undefined) ? slider.slides.eq(pos).before($obj) : slider.container.append($obj);
         }
    
         // update currentSlide, animatingTo, controlNav, and directionNav
         slider.update(pos, "add");
    
         // update slider.slides
         slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
         // re-setup the slider to accomdate new slide
         slider.setup();
    
         //FlexSlider: added() Callback
         slider.vars.added(slider);
       }
       slider.removeSlide = function(obj) {
         var pos = (isNaN(obj)) ? slider.slides.index($(obj)) : obj;
    
         // update count
         slider.count -= 1;
         slider.last = slider.count - 1;
    
         // remove slide
         if (isNaN(obj)) {
           $(obj, slider.slides).remove();
         } else {
           (vertical && reverse) ? slider.slides.eq(slider.last).remove() : slider.slides.eq(obj).remove();
         }
    
         // update currentSlide, animatingTo, controlNav, and directionNav
         slider.doMath();
         slider.update(pos, "remove");
    
         // update slider.slides
         slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
         // re-setup the slider to accomdate new slide
         slider.setup();
    
         // FlexSlider: removed() Callback
         slider.vars.removed(slider);
       }
    
       //FlexSlider: Initialize
       methods.init();
     }
    
     // Ensure the slider isn't focussed if the window loses focus.
     $( window ).blur( function ( e ) {
       focused = false;
     }).focus( function ( e ) {
       focused = true;
     });
    
     //FlexSlider: Default Settings
     $.flexslider.defaults = {
       namespace: "flex-",             //{NEW} String: Prefix string attached to the class of every element generated by the plugin
       selector: ".slides > li",       //{NEW} Selector: Must match a simple pattern. '{container} > {slide}' -- Ignore pattern at your own peril
       animation: "fade",              //String: Select your animation type, "fade" or "slide"
       easing: "swing",                //{NEW} String: Determines the easing method used in jQuery transitions. jQuery easing plugin is supported!
       direction: "horizontal",        //String: Select the sliding direction, "horizontal" or "vertical"
       reverse: false,                 //{NEW} Boolean: Reverse the animation direction
       animationLoop: true,            //Boolean: Should the animation loop? If false, directionNav will received "disable" classes at either end
       smoothHeight: false,            //{NEW} Boolean: Allow height of the slider to animate smoothly in horizontal mode
       startAt: 0,                     //Integer: The slide that the slider should start on. Array notation (0 = first slide)
       slideshow: true,                //Boolean: Animate slider automatically
       slideshowSpeed: 7000,           //Integer: Set the speed of the slideshow cycling, in milliseconds
       animationSpeed: 600,            //Integer: Set the speed of animations, in milliseconds
       initDelay: 0,                   //{NEW} Integer: Set an initialization delay, in milliseconds
       randomize: false,               //Boolean: Randomize slide order
       thumbCaptions: false,           //Boolean: Whether or not to put captions on thumbnails when using the "thumbnails" controlNav.
    
       // Usability features
       pauseOnAction: true,            //Boolean: Pause the slideshow when interacting with control elements, highly recommended.
       pauseOnHover: false,            //Boolean: Pause the slideshow when hovering over slider, then resume when no longer hovering
       pauseInvisible: true,   		//{NEW} Boolean: Pause the slideshow when tab is invisible, resume when visible. Provides better UX, lower CPU usage.
       useCSS: true,                   //{NEW} Boolean: Slider will use CSS3 transitions if available
       touch: true,                    //{NEW} Boolean: Allow touch swipe navigation of the slider on touch-enabled devices
       video: false,                   //{NEW} Boolean: If using video in the slider, will prevent CSS3 3D Transforms to avoid graphical glitches
    
       // Primary Controls
       controlNav: true,               //Boolean: Create navigation for paging control of each clide? Note: Leave true for manualControls usage
       directionNav: true,             //Boolean: Create navigation for previous/next navigation? (true/false)
       prevText: "Previous",           //String: Set the text for the "previous" directionNav item
       nextText: "Next",               //String: Set the text for the "next" directionNav item
    
       // Secondary Navigation
       keyboard: true,                 //Boolean: Allow slider navigating via keyboard left/right keys
       multipleKeyboard: false,        //{NEW} Boolean: Allow keyboard navigation to affect multiple sliders. Default behavior cuts out keyboard navigation with more than one slider present.
       mousewheel: false,              //{UPDATED} Boolean: Requires jquery.mousewheel.js (https://github.com/brandonaaron/jquery-mousewheel) - Allows slider navigating via mousewheel
       pausePlay: false,               //Boolean: Create pause/play dynamic element
       pauseText: "Pause",             //String: Set the text for the "pause" pausePlay item
       playText: "Play",               //String: Set the text for the "play" pausePlay item
    
       // Special properties
       controlsContainer: "",          //{UPDATED} jQuery Object/Selector: Declare which container the navigation elements should be appended too. Default container is the FlexSlider element. Example use would be $(".flexslider-container"). Property is ignored if given element is not found.
       manualControls: "",             //{UPDATED} jQuery Object/Selector: Declare custom control navigation. Examples would be $(".flex-control-nav li") or "#tabs-nav li img", etc. The number of elements in your controlNav should match the number of slides/tabs.
       sync: "",                       //{NEW} Selector: Mirror the actions performed on this slider with another slider. Use with care.
       asNavFor: "",                   //{NEW} Selector: Internal property exposed for turning the slider into a thumbnail navigation for another slider
    
       // Carousel Options
       itemWidth: 0,                   //{NEW} Integer: Box-model width of individual carousel items, including horizontal borders and padding.
       itemMargin: 0,                  //{NEW} Integer: Margin between carousel items.
       minItems: 1,                    //{NEW} Integer: Minimum number of carousel items that should be visible. Items will resize fluidly when below this.
       maxItems: 0,                    //{NEW} Integer: Maxmimum number of carousel items that should be visible. Items will resize fluidly when above this limit.
       move: 0,                        //{NEW} Integer: Number of carousel items that should move on animation. If 0, slider will move all visible items.
       allowOneSlide: true,           //{NEW} Boolean: Whether or not to allow a slider comprised of a single slide
    
       // Callback API
       start: function(){},            //Callback: function(slider) - Fires when the slider loads the first slide
       before: function(){},           //Callback: function(slider) - Fires asynchronously with each slider animation
       after: function(){},            //Callback: function(slider) - Fires after each slider animation completes
       end: function(){},              //Callback: function(slider) - Fires when the slider reaches the last slide (asynchronous)
       added: function(){},            //{NEW} Callback: function(slider) - Fires after a slide is added
       removed: function(){}           //{NEW} Callback: function(slider) - Fires after a slide is removed
     }
    


     //FlexSlider: Plugin Function
     $.fn.flexslider = function(options) {
       if (options === undefined) options = {};
    
       if (typeof options === "object") {
         return this.each(function() {
           var $this = $(this),
               selector = (options.selector) ? options.selector : ".slides > li",
               $slides = $this.find(selector);
    
         if ( ( $slides.length === 1 && options.allowOneSlide === true ) || $slides.length === 0 ) {
             $slides.fadeIn(400);
             if (options.start) options.start($this);
           } else if ($this.data('flexslider') === undefined) {
             new $.flexslider(this, options);
           }
         });
       } else {
         // Helper strings to quickly perform functions on the slider
         var $slider = $(this).data('flexslider');
         switch (options) {
           case "play": $slider.play(); break;
           case "pause": $slider.pause(); break;
           case "stop": $slider.stop(); break;
           case "next": $slider.flexAnimate($slider.getTarget("next"), true); break;
           case "prev":
           case "previous": $slider.flexAnimate($slider.getTarget("prev"), true); break;
           default: if (typeof options === "number") $slider.flexAnimate(options, true);
         }
       }
     }
    

    })(jQuery);




    /*!

    * jquery.lightbox.js
    * https://github.com/duncanmcdougall/Responsive-Lightbox
    * Copyright 2013 Duncan McDougall and other contributors; @license Creative Commons Attribution 2.5
    *
    * Options: 
    * margin - int - default 50. Minimum margin around the image
    * nav - bool - default true. enable navigation
    * blur - bool - default true. Blur other content when open using css filter
    * minSize - int - default 0. Min window width or height to open lightbox. Below threshold will open image in a new tab.
    *
    */
    

    (function ($) {

       'use strict';
    
       $.fn.lightbox = function (options) {
    
           var opts = {
               margin: 50,
               nav: true,
               blur: true,
               minSize: 0
           };
    
           var plugin = {
    
               items: [],
               lightbox: null,
               image: null,
               current: null,
               locked: false,
               caption: null,
         
               init: function (items) {
                   plugin.items = items;
           plugin.selector = "lightbox-"+Math.random().toString().replace('.',);
    
                   if (!plugin.lightbox) {
                       $('body').append(
    
    ''
                       );
    
                       plugin.lightbox = $("#lightbox");
                       plugin.caption = $('.lightbox-caption', plugin.lightbox);
                   }
    
                   if (plugin.items.length > 1 && opts.nav) {
                       $('.lightbox-nav', plugin.lightbox).show();
                   } else {
                       $('.lightbox-nav', plugin.lightbox).hide();
                   }
    
                   plugin.bindEvents();
    
               },
    
               loadImage: function () {
                   if(opts.blur) {
                       $("body").addClass("blurred");
                   }
                   $("img", plugin.lightbox).remove();
                   plugin.lightbox.fadeIn('fast').append('');
    
                   var img = $('<img src="' + $(plugin.current).attr('href') + '" draggable="false">');
    
                   $(img).load(function () {
                       $('.lightbox-loading').remove();
                       plugin.lightbox.append(img);
                       plugin.image = $("img", plugin.lightbox).hide();
                       plugin.resizeImage();
                       plugin.setCaption();
                   });
               },
    
               setCaption: function () {
                   var caption = $(plugin.current).data('caption');
                   if(!!caption && caption.length > 0) {
                       plugin.caption.fadeIn();
                       $('p', plugin.caption).text(caption);
                   }else{
                       plugin.caption.hide();
                   }
               },
    
               resizeImage: function () {
                   var ratio, wHeight, wWidth, iHeight, iWidth;
                   wHeight = $(window).height() - opts.margin;
                   wWidth = $(window).outerWidth(true) - opts.margin;
                   plugin.image.width().height();
                   iHeight = plugin.image.height();
                   iWidth = plugin.image.width();
                   if (iWidth > wWidth) {
                       ratio = wWidth / iWidth;
                       iWidth = wWidth;
                       iHeight = Math.round(iHeight * ratio);
                   }
                   if (iHeight > wHeight) {
                       ratio = wHeight / iHeight;
                       iHeight = wHeight;
                       iWidth = Math.round(iWidth * ratio);
                   }
    
                   plugin.image.width(iWidth).height(iHeight).css({
               'top': ($(window).height() - plugin.image.outerHeight()) / 2 + 'px',
               'left': ($(window).width() - plugin.image.outerWidth()) / 2 + 'px'
             }).show();
                   plugin.locked = false;
               },
    
               getCurrentIndex: function () {
                   return $.inArray(plugin.current, plugin.items);
               },
    
               next: function () {
                   if (plugin.locked) {
                       return false;
                   }
                   plugin.locked = true;
                   if (plugin.getCurrentIndex() >= plugin.items.length - 1) {
                       $(plugin.items[0]).click();
                   } else {
                       $(plugin.items[plugin.getCurrentIndex() + 1]).click();
                   }
               },
    
               previous: function () {
                   if (plugin.locked) {
                       return false;
                   }
                   plugin.locked = true;
                   if (plugin.getCurrentIndex() <= 0) {
                       $(plugin.items[plugin.items.length - 1]).click();
                   } else {
                       $(plugin.items[plugin.getCurrentIndex() - 1]).click();
                   }
               },
    
               bindEvents: function () {
                   $(plugin.items).click(function (e) {
                       if(!$("#lightbox").is(":visible") && ($(window).width() < opts.minSize || $(window).height() < opts.minSize)) {
                           $(this).attr("target", "_blank");
                           return;
                       }
                       var self = $(this)[0];
                       e.preventDefault();
                       plugin.current = self;
                       plugin.loadImage();
    
                       // Bind Keyboard Shortcuts
                       $(document).on('keydown', function (e) {
                           // Close lightbox with ESC
                           if (e.keyCode === 27) {
                               plugin.close();
                           }
                           // Go to next image pressing the right key
                           if (e.keyCode === 39) {
                               plugin.next();
                           }
                           // Go to previous image pressing the left key
                           if (e.keyCode === 37) {
                               plugin.previous();
                           }
                       });
                   });
    
                   // Add click state on overlay background only
                   plugin.lightbox.on('click', function (e) {
                       if (this === e.target) {
                           plugin.close();
                       }
                   });
    
                   // Previous click
                   $(plugin.lightbox).on('click', '.lightbox-previous', function () {
                       plugin.previous();
                       return false;
                   });
    
                   // Next click
                   $(plugin.lightbox).on('click', '.lightbox-next', function () {
                       plugin.next();
                       return false;
                   });
    
                   // Close click
                   $(plugin.lightbox).on('click', '.lightbox-close', function () {
                       plugin.close();
                       return false;
                   });
    
                   $(window).resize(function () {
                       if (!plugin.image) {
                           return;
                       }
                       plugin.resizeImage();
                   });
               },
    
               close: function () {
                   $(document).off('keydown'); // Unbind all key events each time the lightbox is closed
                   $(plugin.lightbox).fadeOut('fast');
                   $('body').removeClass('blurred');
               }
           };
    
           $.extend(opts, options);
    
           plugin.init(this);
       };
    
    })(jQuery);