PageSourceSearch

https://www.blossomflowerdelivery.com/wp-content/themes/blossom-st…/assets/js/jquery.flexslider.js?ver=7.0.7

js blossomflowerdelivery.com collected 2026-10-08 12:39:15 UTC 56,176 bytes, 1,240 lines download raw bytes

vendor: 4,285 bytes, lines 1-101
1/*
2 * jQuery FlexSlider v2.2.0
3 * Copyright 2012 WooThemes
4 * Contributing Author: Tyler Smith
5 */
6;
7(function ($) {
8
9  //FlexSlider: Object Instance
10  $.flexslider = function(el, options) {
11    var slider = $(el);
12
13    // making variables public
14    slider.vars = $.extend({}, $.flexslider.defaults, options);
15
16    var namespace = slider.vars.namespace,
17        msGesture = window.navigator && window.navigator.msPointerEnabled && window.MSGesture,
18        touch = (( "ontouchstart" in window ) || msGesture || window.DocumentTouch && document instanceof DocumentTouch) && slider.vars.touch,
19        // depricating this idea, as devices are being released with both of these events
20        //eventType = (touch) ? "touchend" : "click",
21        eventType = "click touchend MSPointerUp",
22        watchedEvent = "",
23        watchedEventClearTimer,
24        vertical = slider.vars.direction === "vertical",
25        reverse = slider.vars.reverse,
26        carousel = (slider.vars.itemWidth > 0),
27        fade = slider.vars.animation === "fade",
28        asNav = slider.vars.asNavFor !== "",
29        methods = {},
30        focused = true;
31
32    // Store a reference to the slider object
33    $.data(el, "flexslider", slider);
34
35    // Private slider methods
36    methods = {
37      init: function() {
38        slider.animating = false;
39        // Get current slide and make sure it is a number
40        slider.currentSlide = parseInt( ( slider.vars.startAt ? slider.vars.startAt : 0) );
41        if ( isNaN( slider.currentSlide ) ) slider.currentSlide = 0;
42        slider.animatingTo = slider.currentSlide;
43        slider.atEnd = (slider.currentSlide === 0 || slider.currentSlide === slider.last);
44        slider.containerSelector = slider.vars.selector.substr(0,slider.vars.selector.search(' '));
45        slider.slides = $(slider.vars.selector, slider);
46        slider.container = $(slider.containerSelector, slider);
47        slider.count = slider.slides.length;
48        // SYNC:
49        slider.syncExists = $(slider.vars.sync).length > 0;
50        // SLIDE:
51        if (slider.vars.animation === "slide") slider.vars.animation = "swing";
52        slider.prop = (vertical) ? "top" : "marginLeft";
53        slider.args = {};
54        // SLIDESHOW:
55        slider.manualPause = false;
56        slider.stopped = false;
57        //PAUSE WHEN INVISIBLE
58        slider.started = false;
59        slider.startTimeout = null;
60        // TOUCH/USECSS:
61        slider.transitions = !slider.vars.video && !fade && slider.vars.useCSS && (function() {
62          var obj = document.createElement('div'),
63              props = ['perspectiveProperty', 'WebkitPerspective', 'MozPerspective', 'OPerspective', 'msPerspective'];
64          for (var i in props) {
65            if ( obj.style[ props[i] ] !== undefined ) {
66              slider.pfx = props[i].replace('Perspective','').toLowerCase();
67              slider.prop = "-" + slider.pfx + "-transform";
68              return true;
69            }
70          }
71          return false;
72        }());
73        // CONTROLSCONTAINER:
74        if (slider.vars.controlsContainer !== "") slider.controlsContainer = $(slider.vars.controlsContainer).length > 0 && $(slider.vars.controlsContainer);
75        // MANUAL:
76        if (slider.vars.manualControls !== "") slider.manualControls = $(slider.vars.manualControls).length > 0 && $(slider.vars.manualControls);
77
78        // RANDOMIZE:
79        if (slider.vars.randomize) {
80          slider.slides.sort(function() { return (Math.round(Math.random())-0.5); });
81          slider.container.empty().append(slider.slides);
82        }
83
84        slider.doMath();
85
86        // INIT
87        slider.setup("init");
88
89        // CONTROLNAV:
90        if (slider.vars.controlNav) methods.controlNav.setup();
91
92        // DIRECTIONNAV:
93        if (slider.vars.directionNav) methods.directionNav.setup();
94
95        // KEYBOARD:
96        if (slider.vars.keyboard && ($(slider.containerSelector).length === 1 || slider.vars.multipleKeyboard)) {
97          $(document).bind('keyup', function(event) {
98            var keycode = event.keyCode;
99            if (!slider.animating && (keycode === 39 || keycode === 37)) {
100              var target = (keycode === 39) ? slider.getTarget('next') :
101                           (keycode === 37) ? slider.getTarget('prev') : false;
102              slider.flexAnimate(target, slider.vars.pauseOnAction);
103            }
104          });
105        }
106        // MOUSEWHEEL:
107        if (slider.vars.mousewheel) {
108          slider.bind('mousewheel', function(event, delta, deltaX, deltaY) {
109            event.preventDefault();
110            var target = (delta < 0) ? slider.getTarget('next') : slider.getTarget('prev');
111            slider.flexAnimate(target, slider.vars.pauseOnAction);
112          });
113        }
114
115        // PAUSEPLAY
116        if (slider.vars.pausePlay) methods.pausePlay.setup();
117
118        //PAUSE WHEN INVISIBLE
119        if (slider.vars.slideshow && slider.vars.pauseInvisible) methods.pauseInvisible.init();
120
121        // SLIDSESHOW
122        if (slider.vars.slideshow) {
123          if (slider.vars.pauseOnHover) {
124            slider.hover(function() {
125              if (!slider.manualPlay && !slider.manualPause) slider.pause();
126            }, function() {
127              if (!slider.manualPause && !slider.manualPlay && !slider.stopped) slider.play();
128            });
129          }
130          // initialize animation
131          //If we're visible, or we don't use PageVisibility API
132          if(!slider.vars.pauseInvisible || !methods.pauseInvisible.isHidden()) {
133            (slider.vars.initDelay > 0) ? slider.startTimeout = setTimeout(slider.play, slider.vars.initDelay) : slider.play();
134          }
135        }
136
137        // ASNAV:
138        if (asNav) methods.asNav.setup();
139
140        // TOUCH
141        if (touch && slider.vars.touch) methods.touch();
142
143        // FADE&&SMOOTHHEIGHT || SLIDE:
144        if (!fade || (fade && slider.vars.smoothHeight)) $(window).bind("resize orientationchange focus", methods.resize);
145
146        slider.find("img").attr("draggable", "false");
147
148        // API: start() Callback
149        setTimeout(function(){
150          slider.vars.start(slider);
151        }, 200);
152      },
153      asNav: {
154        setup: function() {
155          slider.asNav = true;
156          slider.animatingTo = Math.floor(slider.currentSlide/slider.move);
157          slider.currentItem = slider.currentSlide;
158          slider.slides.removeClass(namespace + "active-slide").eq(slider.currentItem).addClass(namespace + "active-slide");
159          if(!msGesture){
160              slider.slides.click(function(e){
161                e.preventDefault();
162                var $slide = $(this),
163                    target = $slide.index();
164                var posFromLeft = $slide.offset().left - $(slider).scrollLeft(); // Find position of slide relative to left of slider container
165                if( posFromLeft <= 0 && $slide.hasClass( namespace + 'active-slide' ) ) {
166                  slider.flexAnimate(slider.getTarget("prev"), true);
167                } else if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass(namespace + "active-slide")) {
168                  slider.direction = (slider.currentItem < target) ? "next" : "prev";
169                  slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
170                }
171              });
172          }else{
173              el._slider = slider;
174              slider.slides.each(function (){
175                  var that = this;
176                  that._gesture = new MSGesture();
177                  that._gesture.target = that;
178                  that.addEventListener("MSPointerDown", function (e){
179                      e.preventDefault();
180                      if(e.currentTarget._gesture)
181                          e.currentTarget._gesture.addPointer(e.pointerId);
182                  }, false);
183                  that.addEventListener("MSGestureTap", function (e){
184                      e.preventDefault();
185                      var $slide = $(this),
186                          target = $slide.index();
187                      if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass('active')) {
188                          slider.direction = (slider.currentItem < target) ? "next" : "prev";
189                          slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
190                      }
191                  });
192              });
193          }
194        }
195      },
196      controlNav: {
197        setup: function() {
198          if (!slider.manualControls) {
vendor: 39,653 bytes, lines 199-1073
199            methods.controlNav.setupPaging();
200          } else { // MANUALCONTROLS:
201            methods.controlNav.setupManual();
202          }
203        },
204        setupPaging: function() {
205          var type = (slider.vars.controlNav === "thumbnails") ? 'control-thumbs' : 'control-paging',
206              j = 1,
207              item,
208              slide;
209
210          slider.controlNavScaffold = $('<ol class="'+ namespace + 'control-nav ' + namespace + type + '"></ol>');
211
212          if (slider.pagingCount > 1) {
213            for (var i = 0; i < slider.pagingCount; i++) {
214              slide = slider.slides.eq(i);
215              item = (slider.vars.controlNav === "thumbnails") ? '<img src="' + slide.attr( 'data-thumb' ) + '"/>' : '<a>' + j + '</a>';
216              if ( 'thumbnails' === slider.vars.controlNav && true === slider.vars.thumbCaptions ) {
217                var captn = slide.attr( 'data-thumbcaption' );
218                if ( '' != captn && undefined != captn ) item += '<span class="' + namespace + 'caption">' + captn + '</span>';
219              }
220              slider.controlNavScaffold.append('<li>' + item + '</li>');
221              j++;
222            }
223          }
224
225          // CONTROLSCONTAINER:
226          (slider.controlsContainer) ? $(slider.controlsContainer).append(slider.controlNavScaffold) : slider.append(slider.controlNavScaffold);
227          methods.controlNav.set();
228
229          methods.controlNav.active();
230
231          slider.controlNavScaffold.delegate('a, img', eventType, function(event) {
232            event.preventDefault();
233
234            if (watchedEvent === "" || watchedEvent === event.type) {
235              var $this = $(this),
236                  target = slider.controlNav.index($this);
237
238              if (!$this.hasClass(namespace + 'active')) {
239                slider.direction = (target > slider.currentSlide) ? "next" : "prev";
240                slider.flexAnimate(target, slider.vars.pauseOnAction);
241              }
242            }
243
244            // setup flags to prevent event duplication
245            if (watchedEvent === "") {
246              watchedEvent = event.type;
247            }
248            methods.setToClearWatchedEvent();
249
250          });
251        },
252        setupManual: function() {
253          slider.controlNav = slider.manualControls;
254          methods.controlNav.active();
255
256          slider.controlNav.bind(eventType, function(event) {
257            event.preventDefault();
258
259            if (watchedEvent === "" || watchedEvent === event.type) {
260              var $this = $(this),
261                  target = slider.controlNav.index($this);
262
263              if (!$this.hasClass(namespace + 'active')) {
264                (target > slider.currentSlide) ? slider.direction = "next" : slider.direction = "prev";
265                slider.flexAnimate(target, slider.vars.pauseOnAction);
266              }
267            }
268
269            // setup flags to prevent event duplication
270            if (watchedEvent === "") {
271              watchedEvent = event.type;
272            }
273            methods.setToClearWatchedEvent();
274          });
275        },
276        set: function() {
277          var selector = (slider.vars.controlNav === "thumbnails") ? 'img' : 'a';
278          slider.controlNav = $('.' + namespace + 'control-nav li ' + selector, (slider.controlsContainer) ? slider.controlsContainer : slider);
279        },
280        active: function() {
281          slider.controlNav.removeClass(namespace + "active").eq(slider.animatingTo).addClass(namespace + "active");
282        },
283        update: function(action, pos) {
284          if (slider.pagingCount > 1 && action === "add") {
285            slider.controlNavScaffold.append($('<li><a>' + slider.count + '</a></li>'));
286          } else if (slider.pagingCount === 1) {
287            slider.controlNavScaffold.find('li').remove();
288          } else {
289            slider.controlNav.eq(pos).closest('li').remove();
290          }
291          methods.controlNav.set();
292          (slider.pagingCount > 1 && slider.pagingCount !== slider.controlNav.length) ? slider.update(pos, action) : methods.controlNav.active();
293        }
294      },
295      directionNav: {
296        setup: function() {
297          var directionNavScaffold = $('<ul class="' + namespace + 'direction-nav"><li><a class="' + namespace + 'prev" href="#">' + slider.vars.prevText + '</a></li><li><a class="' + namespace + 'next" href="#">' + slider.vars.nextText + '</a></li></ul>');
298
299          // CONTROLSCONTAINER:
300          if (slider.controlsContainer) {
301            $(slider.controlsContainer).append(directionNavScaffold);
302            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider.controlsContainer);
303          } else {
304            slider.append(directionNavScaffold);
305            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider);
306          }
307
308          methods.directionNav.update();
309
310          slider.directionNav.bind(eventType, function(event) {
311            event.preventDefault();
312            var target,
313                disabledClass = namespace + 'disabled';
314
315            if($(this).hasClass(disabledClass)){
316                return this;
317            }
318
319            if (watchedEvent === "" || watchedEvent === event.type) {
320              target = ($(this).hasClass(namespace + 'next')) ? slider.getTarget('next') : slider.getTarget('prev');
321              slider.flexAnimate(target, slider.vars.pauseOnAction);
322            }
323
324            // setup flags to prevent event duplication
325            if (watchedEvent === "") {
326              watchedEvent = event.type;
327            }
328            methods.setToClearWatchedEvent();
329          });
330        },
331        update: function() {
332          var disabledClass = namespace + 'disabled';
333          if (slider.pagingCount === 1) {
334            slider.directionNav.addClass(disabledClass).attr('tabindex', '-1');
335          } else if (!slider.vars.animationLoop) {
336            if (slider.animatingTo === 0) {
337              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "prev").addClass(disabledClass).attr('tabindex', '-1');
338            } else if (slider.animatingTo === slider.last) {
339              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "next").addClass(disabledClass).attr('tabindex', '-1');
340            } else {
341              slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
342            }
343          } else {
344            slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
345          }
346        }
347      },
348      pausePlay: {
349        setup: function() {
350          var pausePlayScaffold = $('<div class="' + namespace + 'pauseplay"><a></a></div>');
351
352          // CONTROLSCONTAINER:
353          if (slider.controlsContainer) {
354            slider.controlsContainer.append(pausePlayScaffold);
355            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider.controlsContainer);
356          } else {
357            slider.append(pausePlayScaffold);
358            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider);
359          }
360
361          methods.pausePlay.update((slider.vars.slideshow) ? namespace + 'pause' : namespace + 'play');
362
363          slider.pausePlay.bind(eventType, function(event) {
364            event.preventDefault();
365
366            if (watchedEvent === "" || watchedEvent === event.type) {
367              if ($(this).hasClass(namespace + 'pause')) {
368                slider.manualPause = true;
369                slider.manualPlay = false;
370                slider.pause();
371              } else {
372                slider.manualPause = false;
373                slider.manualPlay = true;
374                slider.play();
375              }
376            }
377
378            // setup flags to prevent event duplication
379            if (watchedEvent === "") {
380              watchedEvent = event.type;
381            }
382            methods.setToClearWatchedEvent();
383          });
384        },
385        update: function(state) {
386          (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);
387        }
388      },
389      touch: function() {
390        var startX,
391          startY,
392          offset,
393          cwidth,
394          dx,
395          startT,
396          scrolling = false,
397          localX = 0,
398          localY = 0,
399          accDx = 0;
400
401        if(!msGesture){
402            el.addEventListener('touchstart', onTouchStart, false);
403
404            function onTouchStart(e) {
405              if (slider.animating) {
406                e.preventDefault();
407              } else if ( ( window.navigator.msPointerEnabled ) || e.touches.length === 1 ) {
408                slider.pause();
409                // CAROUSEL:
410                cwidth = (vertical) ? slider.h : slider. w;
411                startT = Number(new Date());
412                // CAROUSEL:
413
414                // Local vars for X and Y points.
415                localX = e.touches[0].pageX;
416                localY = e.touches[0].pageY;
417
418                offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
419                         (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
420                         (carousel && slider.currentSlide === slider.last) ? slider.limit :
421                         (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
422                         (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
423                startX = (vertical) ? localY : localX;
424                startY = (vertical) ? localX : localY;
425
426                el.addEventListener('touchmove', onTouchMove, false);
427                el.addEventListener('touchend', onTouchEnd, false);
428              }
429            }
430
431            function onTouchMove(e) {
432              // Local vars for X and Y points.
433
434              localX = e.touches[0].pageX;
435              localY = e.touches[0].pageY;
436
437              dx = (vertical) ? startX - localY : startX - localX;
438              scrolling = (vertical) ? (Math.abs(dx) < Math.abs(localX - startY)) : (Math.abs(dx) < Math.abs(localY - startY));
439
440              var fxms = 500;
441
442              if ( ! scrolling || Number( new Date() ) - startT > fxms ) {
443                e.preventDefault();
444                if (!fade && slider.transitions) {
445                  if (!slider.vars.animationLoop) {
446                    dx = dx/((slider.currentSlide === 0 && dx < 0 || slider.currentSlide === slider.last && dx > 0) ? (Math.abs(dx)/cwidth+2) : 1);
447                  }
448                  slider.setProps(offset + dx, "setTouch");
449                }
450              }
451            }
452
453            function onTouchEnd(e) {
454              // finish the touch by undoing the touch session
455              el.removeEventListener('touchmove', onTouchMove, false);
456
457              if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
458                var updateDx = (reverse) ? -dx : dx,
459                    target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
460
461                if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
462                  slider.flexAnimate(target, slider.vars.pauseOnAction);
463                } else {
464                  if (!fade) slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);
465                }
466              }
467              el.removeEventListener('touchend', onTouchEnd, false);
468
469              startX = null;
470              startY = null;
471              dx = null;
472              offset = null;
473            }
474        }else{
475            el.style.msTouchAction = "none";
476            el._gesture = new MSGesture();
477            el._gesture.target = el;
478            el.addEventListener("MSPointerDown", onMSPointerDown, false);
479            el._slider = slider;
480            el.addEventListener("MSGestureChange", onMSGestureChange, false);
481            el.addEventListener("MSGestureEnd", onMSGestureEnd, false);
482
483            function onMSPointerDown(e){
484                e.stopPropagation();
485                if (slider.animating) {
486                    e.preventDefault();
487                }else{
488                    slider.pause();
489                    el._gesture.addPointer(e.pointerId);
490                    accDx = 0;
491                    cwidth = (vertical) ? slider.h : slider. w;
492                    startT = Number(new Date());
493                    // CAROUSEL:
494
495                    offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
496                        (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
497                            (carousel && slider.currentSlide === slider.last) ? slider.limit :
498                                (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
499                                    (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
500                }
501            }
502
503            function onMSGestureChange(e) {
504                e.stopPropagation();
505                var slider = e.target._slider;
506                if(!slider){
507                    return;
508                }
509                var transX = -e.translationX,
510                    transY = -e.translationY;
511
512                //Accumulate translations.
513                accDx = accDx + ((vertical) ? transY : transX);
514                dx = accDx;
515                scrolling = (vertical) ? (Math.abs(accDx) < Math.abs(-transX)) : (Math.abs(accDx) < Math.abs(-transY));
516
517                if(e.detail === e.MSGESTURE_FLAG_INERTIA){
518                    setImmediate(function (){
519                        el._gesture.stop();
520                    });
521
522                    return;
523                }
524
525                if (!scrolling || Number(new Date()) - startT > 500) {
526                    e.preventDefault();
527                    if (!fade && slider.transitions) {
528                        if (!slider.vars.animationLoop) {
529                            dx = accDx / ((slider.currentSlide === 0 && accDx < 0 || slider.currentSlide === slider.last && accDx > 0) ? (Math.abs(accDx) / cwidth + 2) : 1);
530                        }
531                        slider.setProps(offset + dx, "setTouch");
532                    }
533                }
534            }
535
536            function onMSGestureEnd(e) {
537                e.stopPropagation();
538                var slider = e.target._slider;
539                if(!slider){
540                    return;
541                }
542                if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
543                    var updateDx = (reverse) ? -dx : dx,
544                        target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
545
546                    if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
547                        slider.flexAnimate(target, slider.vars.pauseOnAction);
548                    } else {
549                        if (!fade) slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);
550                    }
551                }
552
553                startX = null;
554                startY = null;
555                dx = null;
556                offset = null;
557                accDx = 0;
558            }
559        }
560      },
561      resize: function() {
562        if (!slider.animating && slider.is(':visible')) {
563          if (!carousel) slider.doMath();
564
565          if (fade) {
566            // SMOOTH HEIGHT:
567            methods.smoothHeight();
568          } else if (carousel) { //CAROUSEL:
569            slider.slides.width(slider.computedW);
570            slider.update(slider.pagingCount);
571            slider.setProps();
572          }
573          else if (vertical) { //VERTICAL:
574            slider.viewport.height(slider.h);
575            slider.setProps(slider.h, "setTotal");
576          } else {
577            // SMOOTH HEIGHT:
578            if (slider.vars.smoothHeight) methods.smoothHeight();
579            slider.newSlides.width(slider.computedW);
580            slider.setProps(slider.computedW, "setTotal");
581          }
582        }
583      },
584      smoothHeight: function(dur) {
585        if (!vertical || fade) {
586          var $obj = (fade) ? slider : slider.viewport;
587          (dur) ? $obj.animate({"height": slider.slides.eq(slider.animatingTo).height()}, dur) : $obj.height(slider.slides.eq(slider.animatingTo).height());
588        }
589      },
590      sync: function(action) {
591        var $obj = $(slider.vars.sync).data("flexslider"),
592            target = slider.animatingTo;
593
594        switch (action) {
595          case "animate": $obj.flexAnimate(target, slider.vars.pauseOnAction, false, true); break;
596          case "play": if (!$obj.playing && !$obj.asNav) { $obj.play(); } break;
597          case "pause": $obj.pause(); break;
598        }
599      },
600      pauseInvisible: {
601        visProp: null,
602        init: function() {
603          var prefixes = ['webkit','moz','ms','o'];
604
605          if ('hidden' in document) return 'hidden';
606          for (var i = 0; i < prefixes.length; i++) {
607            if ((prefixes[i] + 'Hidden') in document)
608            methods.pauseInvisible.visProp = prefixes[i] + 'Hidden';
609          }
610          if (methods.pauseInvisible.visProp) {
611            var evtname = methods.pauseInvisible.visProp.replace(/[H|h]idden/,'') + 'visibilitychange';
612            document.addEventListener(evtname, function() {
613              if (methods.pauseInvisible.isHidden()) {
614                if(slider.startTimeout) clearTimeout(slider.startTimeout); //If clock is ticking, stop timer and prevent from starting while invisible
615                else slider.pause(); //Or just pause
616              }
617              else {
618                if(slider.started) slider.play(); //Initiated before, just play
619                else (slider.vars.initDelay > 0) ? setTimeout(slider.play, slider.vars.initDelay) : slider.play(); //Didn't init before: simply init or wait for it
620              }
621            });
622          }
623        },
624        isHidden: function() {
625          return document[methods.pauseInvisible.visProp] || false;
626        }
627      },
628      setToClearWatchedEvent: function() {
629        clearTimeout(watchedEventClearTimer);
630        watchedEventClearTimer = setTimeout(function() {
631          watchedEvent = "";
632        }, 3000);
633      }
634    }
635
636    // public methods
637    slider.flexAnimate = function(target, pause, override, withSync, fromNav) {
638      if (!slider.vars.animationLoop && target !== slider.currentSlide) {
639        slider.direction = (target > slider.currentSlide) ? "next" : "prev";
640      }
641
642      if (asNav && slider.pagingCount === 1) slider.direction = (slider.currentItem < target) ? "next" : "prev";
643
644      if (!slider.animating && (slider.canAdvance(target, fromNav) || override) && slider.is(":visible")) {
645        if (asNav && withSync) {
646          var master = $(slider.vars.asNavFor).data('flexslider');
647          slider.atEnd = target === 0 || target === slider.count - 1;
648          master.flexAnimate(target, true, false, true, fromNav);
649          slider.direction = (slider.currentItem < target) ? "next" : "prev";
650          master.direction = slider.direction;
651
652          if (Math.ceil((target + 1)/slider.visible) - 1 !== slider.currentSlide && target !== 0) {
653            slider.currentItem = target;
654            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
655            target = Math.floor(target/slider.visible);
656          } else {
657            slider.currentItem = target;
658            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
659            return false;
660          }
661        }
662
663        slider.animating = true;
664        slider.animatingTo = target;
665
666        // SLIDESHOW:
667        if (pause) slider.pause();
668
669        // API: before() animation Callback
670        slider.vars.before(slider);
671
672        // SYNC:
673        if (slider.syncExists && !fromNav) methods.sync("animate");
674
675        // CONTROLNAV
676        if (slider.vars.controlNav) methods.controlNav.active();
677
678        // !CAROUSEL:
679        // CANDIDATE: slide active class (for add/remove slide)
680        if (!carousel) slider.slides.removeClass(namespace + 'active-slide').eq(target).addClass(namespace + 'active-slide');
681
682        // INFINITE LOOP:
683        // CANDIDATE: atEnd
684        slider.atEnd = target === 0 || target === slider.last;
685
686        // DIRECTIONNAV:
687        if (slider.vars.directionNav) methods.directionNav.update();
688
689        if (target === slider.last) {
690          // API: end() of cycle Callback
691          slider.vars.end(slider);
692          // SLIDESHOW && !INFINITE LOOP:
693          if (!slider.vars.animationLoop) slider.pause();
694        }
695
696        // SLIDE:
697        if (!fade) {
698          var dimension = (vertical) ? slider.slides.filter(':first').height() : slider.computedW,
699              margin, slideString, calcNext;
700
701          // INFINITE LOOP / REVERSE:
702          if (carousel) {
703            //margin = (slider.vars.itemWidth > slider.w) ? slider.vars.itemMargin * 2 : slider.vars.itemMargin;
704            margin = slider.vars.itemMargin;
705            calcNext = ((slider.itemW + margin) * slider.move) * slider.animatingTo;
706            slideString = (calcNext > slider.limit && slider.visible !== 1) ? slider.limit : calcNext;
707          } else if (slider.currentSlide === 0 && target === slider.count - 1 && slider.vars.animationLoop && slider.direction !== "next") {
708            slideString = (reverse) ? (slider.count + slider.cloneOffset) * dimension : 0;
709          } else if (slider.currentSlide === slider.last && target === 0 && slider.vars.animationLoop && slider.direction !== "prev") {
710            slideString = (reverse) ? 0 : (slider.count + 1) * dimension;
711          } else {
712            slideString = (reverse) ? ((slider.count - 1) - target + slider.cloneOffset) * dimension : (target + slider.cloneOffset) * dimension;
713          }
714          slider.setProps(slideString, "", slider.vars.animationSpeed);
715          if (slider.transitions) {
716            if (!slider.vars.animationLoop || !slider.atEnd) {
717              slider.animating = false;
718              slider.currentSlide = slider.animatingTo;
719            }
720            slider.container.unbind("webkitTransitionEnd transitionend");
721            slider.container.bind("webkitTransitionEnd transitionend", function() {
722              slider.wrapup(dimension);
723            });
724          } else {
725            slider.container.animate(slider.args, slider.vars.animationSpeed, slider.vars.easing, function(){
726              slider.wrapup(dimension);
727            });
728          }
729        } else { // FADE:
730          if (!touch) {
731            //slider.slides.eq(slider.currentSlide).fadeOut(slider.vars.animationSpeed, slider.vars.easing);
732            //slider.slides.eq(target).fadeIn(slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
733
734            slider.slides.eq(slider.currentSlide).css({"zIndex": 1}).animate({"opacity": 0}, slider.vars.animationSpeed, slider.vars.easing);
735            slider.slides.eq(target).css({"zIndex": 2}).animate({"opacity": 1}, slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
736
737          } else {
738            slider.slides.eq(slider.currentSlide).css({ "opacity": 0, "zIndex": 1 });
739            slider.slides.eq(target).css({ "opacity": 1, "zIndex": 2 });
740            slider.wrapup(dimension);
741          }
742        }
743        // SMOOTH HEIGHT:
744        if (slider.vars.smoothHeight) methods.smoothHeight(slider.vars.animationSpeed);
745      }
746    }
747    slider.wrapup = function(dimension) {
748      // SLIDE:
749      if (!fade && !carousel) {
750        if (slider.currentSlide === 0 && slider.animatingTo === slider.last && slider.vars.animationLoop) {
751          slider.setProps(dimension, "jumpEnd");
752        } else if (slider.currentSlide === slider.last && slider.animatingTo === 0 && slider.vars.animationLoop) {
753          slider.setProps(dimension, "jumpStart");
754        }
755      }
756      slider.animating = false;
757      slider.currentSlide = slider.animatingTo;
758      // API: after() animation Callback
759      slider.vars.after(slider);
760    }
761
762    // SLIDESHOW:
763    slider.animateSlides = function() {
764      if (!slider.animating && focused ) slider.flexAnimate(slider.getTarget("next"));
765    }
766    // SLIDESHOW:
767    slider.pause = function() {
768      clearInterval(slider.animatedSlides);
769      slider.animatedSlides = null;
770      slider.playing = false;
771      // PAUSEPLAY:
772      if (slider.vars.pausePlay) methods.pausePlay.update("play");
773      // SYNC:
774      if (slider.syncExists) methods.sync("pause");
775    }
776    // SLIDESHOW:
777    slider.play = function() {
778      if (slider.playing) clearInterval(slider.animatedSlides);
779      slider.animatedSlides = slider.animatedSlides || setInterval(slider.animateSlides, slider.vars.slideshowSpeed);
780      slider.started = slider.playing = true;
781      // PAUSEPLAY:
782      if (slider.vars.pausePlay) methods.pausePlay.update("pause");
783      // SYNC:
784      if (slider.syncExists) methods.sync("play");
785    }
786    // STOP:
787    slider.stop = function () {
788      slider.pause();
789      slider.stopped = true;
790    }
791    slider.canAdvance = function(target, fromNav) {
792      // ASNAV:
793      var last = (asNav) ? slider.pagingCount - 1 : slider.last;
794      return (fromNav) ? true :
795             (asNav && slider.currentItem === slider.count - 1 && target === 0 && slider.direction === "prev") ? true :
796             (asNav && slider.currentItem === 0 && target === slider.pagingCount - 1 && slider.direction !== "next") ? false :
797             (target === slider.currentSlide && !asNav) ? false :
798             (slider.vars.animationLoop) ? true :
799             (slider.atEnd && slider.currentSlide === 0 && target === last && slider.direction !== "next") ? false :
800             (slider.atEnd && slider.currentSlide === last && target === 0 && slider.direction === "next") ? false :
801             true;
802    }
803    slider.getTarget = function(dir) {
804      slider.direction = dir;
805      if (dir === "next") {
806        return (slider.currentSlide === slider.last) ? 0 : slider.currentSlide + 1;
807      } else {
808        return (slider.currentSlide === 0) ? slider.last : slider.currentSlide - 1;
809      }
810    }
811
812    // SLIDE:
813    slider.setProps = function(pos, special, dur) {
814      var target = (function() {
815        var posCheck = (pos) ? pos : ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo,
816            posCalc = (function() {
817              if (carousel) {
818                return (special === "setTouch") ? pos :
819                       (reverse && slider.animatingTo === slider.last) ? 0 :
820                       (reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
821                       (slider.animatingTo === slider.last) ? slider.limit : posCheck;
822              } else {
823                switch (special) {
824                  case "setTotal": return (reverse) ? ((slider.count - 1) - slider.currentSlide + slider.cloneOffset) * pos : (slider.currentSlide + slider.cloneOffset) * pos;
825                  case "setTouch": return (reverse) ? pos : pos;
826                  case "jumpEnd": return (reverse) ? pos : slider.count * pos;
827                  case "jumpStart": return (reverse) ? slider.count * pos : pos;
828                  default: return pos;
829                }
830              }
831            }());
832
833            return (posCalc * -1) + "px";
834          }());
835
836      if (slider.transitions) {
837        target = (vertical) ? "translate3d(0," + target + ",0)" : "translate3d(" + target + ",0,0)";
838        dur = (dur !== undefined) ? (dur/1000) + "s" : "0s";
839        slider.container.css("-" + slider.pfx + "-transition-duration", dur);
840      }
841
842      slider.args[slider.prop] = target;
843      if (slider.transitions || dur === undefined) slider.container.css(slider.args);
844    }
845
846    slider.setup = function(type) {
847      // SLIDE:
848      if (!fade) {
849        var sliderOffset, arr;
850
851        if (type === "init") {
852          slider.viewport = $('<div class="' + namespace + 'viewport"></div>').css({"overflow": "hidden", "position": "relative"}).appendTo(slider).append(slider.container);
853          // INFINITE LOOP:
854          slider.cloneCount = 0;
855          slider.cloneOffset = 0;
856          // REVERSE:
857          if (reverse) {
858            arr = $.makeArray(slider.slides).reverse();
859            slider.slides = $(arr);
860            slider.container.empty().append(slider.slides);
861          }
862        }
863        // INFINITE LOOP && !CAROUSEL:
864        if (slider.vars.animationLoop && !carousel) {
865          slider.cloneCount = 2;
866          slider.cloneOffset = 1;
867          // clear out old clones
868          if (type !== "init") slider.container.find('.clone').remove();
869          slider.container.append(slider.slides.first().clone().addClass('clone').attr('aria-hidden', 'true')).prepend(slider.slides.last().clone().addClass('clone').attr('aria-hidden', 'true'));
870        }
871        slider.newSlides = $(slider.vars.selector, slider);
872
873        sliderOffset = (reverse) ? slider.count - 1 - slider.currentSlide + slider.cloneOffset : slider.currentSlide + slider.cloneOffset;
874        // VERTICAL:
875        if (vertical && !carousel) {
876          slider.container.height((slider.count + slider.cloneCount) * 200 + "%").css("position", "absolute").width("100%");
877          setTimeout(function(){
878            slider.newSlides.css({"display": "block"});
879            slider.doMath();
880            slider.viewport.height(slider.h);
881            slider.setProps(sliderOffset * slider.h, "init");
882          }, (type === "init") ? 100 : 0);
883        } else {
884          slider.container.width((slider.count + slider.cloneCount) * 200 + "%");
885          slider.setProps(sliderOffset * slider.computedW, "init");
886          setTimeout(function(){
887            slider.doMath();
888            slider.newSlides.css({"width": slider.computedW, "float": "left", "display": "block"});
889            // SMOOTH HEIGHT:
890            if (slider.vars.smoothHeight) methods.smoothHeight();
891          }, (type === "init") ? 100 : 0);
892        }
893      } else { // FADE:
894        slider.slides.css({"width": "100%", "float": "left", "marginRight": "-100%", "position": "relative"});
895        if (type === "init") {
896          if (!touch) {
897            //slider.slides.eq(slider.currentSlide).fadeIn(slider.vars.animationSpeed, slider.vars.easing);
898            slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).animate({"opacity": 1},slider.vars.animationSpeed,slider.vars.easing);
899          } else {
900            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});
901          }
902        }
903        // SMOOTH HEIGHT:
904        if (slider.vars.smoothHeight) methods.smoothHeight();
905      }
906      // !CAROUSEL:
907      // CANDIDATE: active slide
908      if (!carousel) slider.slides.removeClass(namespace + "active-slide").eq(slider.currentSlide).addClass(namespace + "active-slide");
909    }
910
911
912    slider.doMath = function() {
913      var slide = slider.slides.first(),
914          slideMargin = slider.vars.itemMargin,
915          minItems = slider.vars.minItems,
916          maxItems = slider.vars.maxItems;
917
918      slider.w = (slider.viewport===undefined) ? slider.width() : slider.viewport.width();
919      slider.h = slide.height();
920      slider.boxPadding = slide.outerWidth() - slide.width();
921
922      // CAROUSEL:
923      if (carousel) {
924        slider.itemT = slider.vars.itemWidth + slideMargin;
925        slider.minW = (minItems) ? minItems * slider.itemT : slider.w;
926        slider.maxW = (maxItems) ? (maxItems * slider.itemT) - slideMargin : slider.w;
927        slider.itemW = (slider.minW > slider.w) ? (slider.w - (slideMargin * (minItems - 1)))/minItems :
928                       (slider.maxW < slider.w) ? (slider.w - (slideMargin * (maxItems - 1)))/maxItems :
929                       (slider.vars.itemWidth > slider.w) ? slider.w : slider.vars.itemWidth;
930
931        slider.visible = Math.floor(slider.w/(slider.itemW));
932        slider.move = (slider.vars.move > 0 && slider.vars.move < slider.visible ) ? slider.vars.move : slider.visible;
933        slider.pagingCount = Math.ceil(((slider.count - slider.visible)/slider.move) + 1);
934        slider.last =  slider.pagingCount - 1;
935        slider.limit = (slider.pagingCount === 1) ? 0 :
936                       (slider.vars.itemWidth > slider.w) ? (slider.itemW * (slider.count - 1)) + (slideMargin * (slider.count - 1)) : ((slider.itemW + slideMargin) * slider.count) - slider.w - slideMargin;
937      } else {
938        slider.itemW = slider.w;
939        slider.pagingCount = slider.count;
940        slider.last = slider.count - 1;
941      }
942      slider.computedW = slider.itemW - slider.boxPadding;
943    }
944
945
946    slider.update = function(pos, action) {
947      slider.doMath();
948
949      // update currentSlide and slider.animatingTo if necessary
950      if (!carousel) {
951        if (pos < slider.currentSlide) {
952          slider.currentSlide += 1;
953        } else if (pos <= slider.currentSlide && pos !== 0) {
954          slider.currentSlide -= 1;
955        }
956        slider.animatingTo = slider.currentSlide;
957      }
958
959      // update controlNav
960      if (slider.vars.controlNav && !slider.manualControls) {
961        if ((action === "add" && !carousel) || slider.pagingCount > slider.controlNav.length) {
962          methods.controlNav.update("add");
963        } else if ((action === "remove" && !carousel) || slider.pagingCount < slider.controlNav.length) {
964          if (carousel && slider.currentSlide > slider.last) {
965            slider.currentSlide -= 1;
966            slider.animatingTo -= 1;
967          }
968          methods.controlNav.update("remove", slider.last);
969        }
970      }
971      // update directionNav
972      if (slider.vars.directionNav) methods.directionNav.update();
973
974    }
975
976    slider.addSlide = function(obj, pos) {
977      var $obj = $(obj);
978
979      slider.count += 1;
980      slider.last = slider.count - 1;
981
982      // append new slide
983      if (vertical && reverse) {
984        (pos !== undefined) ? slider.slides.eq(slider.count - pos).after($obj) : slider.container.prepend($obj);
985      } else {
986        (pos !== undefined) ? slider.slides.eq(pos).before($obj) : slider.container.append($obj);
987      }
988
989      // update currentSlide, animatingTo, controlNav, and directionNav
990      slider.update(pos, "add");
991
992      // update slider.slides
993      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
994      // re-setup the slider to accomdate new slide
995      slider.setup();
996
997      //FlexSlider: added() Callback
998      slider.vars.added(slider);
999    }
1000    slider.removeSlide = function(obj) {
1001      var pos = (isNaN(obj)) ? slider.slides.index($(obj)) : obj;
1002
1003      // update count
1004      slider.count -= 1;
1005      slider.last = slider.count - 1;
1006
1007      // remove slide
1008      if (isNaN(obj)) {
1009        $(obj, slider.slides).remove();
1010      } else {
1011        (vertical && reverse) ? slider.slides.eq(slider.last).remove() : slider.slides.eq(obj).remove();
1012      }
1013
1014      // update currentSlide, animatingTo, controlNav, and directionNav
1015      slider.doMath();
1016      slider.update(pos, "remove");
1017
1018      // update slider.slides
1019      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
1020      // re-setup the slider to accomdate new slide
1021      slider.setup();
1022
1023      // FlexSlider: removed() Callback
1024      slider.vars.removed(slider);
1025    }
1026
1027    //FlexSlider: Initialize
1028    methods.init();
1029  }
1030
1031  // Ensure the slider isn't focussed if the window loses focus.
1032  $( window ).blur( function ( e ) {
1033    focused = false;
1034  }).focus( function ( e ) {
1035    focused = true;
1036  });
1037
1038  //FlexSlider: Default Settings
1039  $.flexslider.defaults = {
1040    namespace: "flex-",             //{NEW} String: Prefix string attached to the class of every element generated by the plugin
1041    selector: ".slides > li",       //{NEW} Selector: Must match a simple pattern. '{container} > {slide}' -- Ignore pattern at your own peril
1042    animation: "fade",              //String: Select your animation type, "fade" or "slide"
1043    easing: "swing",                //{NEW} String: Determines the easing method used in jQuery transitions. jQuery easing plugin is supported!
1044    direction: "horizontal",        //String: Select the sliding direction, "horizontal" or "vertical"
1045    reverse: false,                 //{NEW} Boolean: Reverse the animation direction
1046    animationLoop: true,            //Boolean: Should the animation loop? If false, directionNav will received "disable" classes at either end
1047    smoothHeight: false,            //{NEW} Boolean: Allow height of the slider to animate smoothly in horizontal mode
1048    startAt: 0,                     //Integer: The slide that the slider should start on. Array notation (0 = first slide)
1049    slideshow: true,                //Boolean: Animate slider automatically
1050    slideshowSpeed: 7000,           //Integer: Set the speed of the slideshow cycling, in milliseconds
1051    animationSpeed: 600,            //Integer: Set the speed of animations, in milliseconds
1052    initDelay: 0,                   //{NEW} Integer: Set an initialization delay, in milliseconds
1053    randomize: false,               //Boolean: Randomize slide order
1054    thumbCaptions: false,           //Boolean: Whether or not to put captions on thumbnails when using the "thumbnails" controlNav.
1055
1056    // Usability features
1057    pauseOnAction: true,            //Boolean: Pause the slideshow when interacting with control elements, highly recommended.
1058    pauseOnHover: false,            //Boolean: Pause the slideshow when hovering over slider, then resume when no longer hovering
1059    pauseInvisible: true,   		//{NEW} Boolean: Pause the slideshow when tab is invisible, resume when visible. Provides better UX, lower CPU usage.
1060    useCSS: true,                   //{NEW} Boolean: Slider will use CSS3 transitions if available
1061    touch: true,                    //{NEW} Boolean: Allow touch swipe navigation of the slider on touch-enabled devices
1062    video: false,                   //{NEW} Boolean: If using video in the slider, will prevent CSS3 3D Transforms to avoid graphical glitches
1063
1064    // Primary Controls
1065    controlNav: true,               //Boolean: Create navigation for paging control of each clide? Note: Leave true for manualControls usage
1066    directionNav: true,             //Boolean: Create navigation for previous/next navigation? (true/false)
1067    prevText: "Previous",           //String: Set the text for the "previous" directionNav item
1068    nextText: "Next",               //String: Set the text for the "next" directionNav item
1069
1070    // Secondary Navigation
1071    keyboard: true,                 //Boolean: Allow slider navigating via keyboard left/right keys
1072    multipleKeyboard: false,        //{NEW} Boolean: Allow keyboard navigation to affect multiple sliders. Default behavior cuts out keyboard navigation with more than one slider present.
1073    mousewheel: false,              //{UPDATED} Boolean: Requires jquery.mousewheel.js (https://github.com/brandonaaron/jquery-mousewheel) - Allows slider navigating via mousewheel
1074    pausePlay: false,               //Boolean: Create pause/play dynamic element
1075    pauseText: "Pause",             //String: Set the text for the "pause" pausePlay item
1076    playText: "Play",               //String: Set the text for the "play" pausePlay item
1077
1078    // Special properties
1079    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.
1080    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.
1081    sync: "",                       //{NEW} Selector: Mirror the actions performed on this slider with another slider. Use with care.
1082    asNavFor: "",                   //{NEW} Selector: Internal property exposed for turning the slider into a thumbnail navigation for another slider
1083
1084    // Carousel Options
1085    itemWidth: 0,                   //{NEW} Integer: Box-model width of individual carousel items, including horizontal borders and padding.
1086    itemMargin: 0,                  //{NEW} Integer: Margin between carousel items.
1087    minItems: 1,                    //{NEW} Integer: Minimum number of carousel items that should be visible. Items will resize fluidly when below this.
1088    maxItems: 0,                    //{NEW} Integer: Maxmimum number of carousel items that should be visible. Items will resize fluidly when above this limit.
1089    move: 0,                        //{NEW} Integer: Number of carousel items that should move on animation. If 0, slider will move all visible items.
1090    allowOneSlide: true,           //{NEW} Boolean: Whether or not to allow a slider comprised of a single slide
1091
1092    // Callback API
1093    start: function(){},            //Callback: function(slider) - Fires when the slider loads the first slide
1094    before: function(){},           //Callback: function(slider) - Fires asynchronously with each slider animation
1095    after: function(){},            //Callback: function(slider) - Fires after each slider animation completes
1096    end: function(){},              //Callback: function(slider) - Fires when the slider reaches the last slide (asynchronous)
1097    added: function(){},            //{NEW} Callback: function(slider) - Fires after a slide is added
1098    removed: function(){}           //{NEW} Callback: function(slider) - Fires after a slide is removed
1099  }
1100
1101
1102  //FlexSlider: Plugin Function
1103  $.fn.flexslider = function(options) {
1104    if (options === undefined) options = {};
1105
1106    if (typeof options === "object") {
1107      return this.each(function() {
1108        var $this = $(this),
1109            selector = (options.selector) ? options.selector : ".slides > li",
1110            $slides = $this.find(selector);
1111
1112      if ( ( $slides.length === 1 && options.allowOneSlide === true ) || $slides.length === 0 ) {
1113          $slides.fadeIn(400);
1114          if (options.start) options.start($this);
1115        } else if ($this.data('flexslider') === undefined) {
1116          new $.flexslider(this, options);
1117        }
1118      });
1119    } else {
1120      // Helper strings to quickly perform functions on the slider
1121      var $slider = $(this).data('flexslider');
1122      switch (options) {
1123        case "play": $slider.play(); break;
1124        case "pause": $slider.pause(); break;
1125        case "stop": $slider.stop(); break;
1126        case "next": $slider.flexAnimate($slider.getTarget("next"), true); break;
1127        case "prev":
1128        case "previous": $slider.flexAnimate($slider.getTarget("prev"), true); break;
1129        default: if (typeof options === "number") $slider.flexAnimate(options, true);
1130      }
1131    }
1132  }
1133})(jQuery);
1134
1135/**
1136 * jQuery flexVSlider, fixed vertical carousel of flexslider
1137 */
1138(function( $ ) {
1139    $.fn.flexVSlider = function( settings ) {
1140        $( this ).each(function() {
1141            var $this = $( this );
1142
1143            $this.flexslider($.extend( {}, settings, {
1144                direction: "vertical",
1145                animationLoop: false,
1146                start: function( slider ) {
1147                    var $wrapper = $( ".flex-viewport", $this),
1148                        height, setVisible;
1149
1150                    if ( $wrapper.length && settings && settings.visible && settings.visible > 1 ) {
1151                        height = parseInt( $wrapper.get( 0 ).style.height );
1152                        $wrapper.get( 0 ).style.setProperty( "height", height * settings.visible + "px", "important" );
1153                    }
1153 else if ( $wrapper.length && ( !settings || !settings.visible ) ) {
1154                        height = parseInt( $wrapper.get( 0 ).style.height );
1155                        setVisible = Math.round( $wrapper.height() / height );
1156                    }
1157
1158                    if ( settings && settings.move && settings.move > 1 ) {
1159                        var $nav = $( ".flex-direction-nav", $this );
1160
1161                        $nav = $nav.clone().insertAfter( $nav.hide() );
1162
1163                        var $next = $( ".flex-next", $nav ).unbind( "click" ),
1164                            $prev = $( ".flex-prev", $nav ).unbind( "click" ),
1165                            count = slider.count,
1166                            move = settings.move,
1167                            visible = settings && settings.visible || setVisible;
1168
1169                        if ( !slider.transitions ) {
1170                            move = 1;
1171                        }
1172
1173                        if ( ( count - slider.currentSlide - visible ) < 1 ) {
1174                            $next.addClass( "flex-disabled" );
1175                        } else {
1176                            $next.removeClass( "flex-disabled" );
1177                        }
1178
1179                        if ( slider.currentSlide < 1 ) {
1180                            $prev.addClass( "flex-disabled" );
1181                        } else {
1182                            $prev.removeClass( "flex-disabled" );
1183                        }
1184
1185                        $next.click(function( e ) {
1186                            e.preventDefault();
1187
1188                            if ( $next.hasClass( "flex-disabled" ) ) {
1189                                return true;
1190                            }
1191
1192                            var total = count - slider.currentSlide - visible,
1193                                cycles = Math.min( total, move );
1194
1195                            if ( move >= total ) {
1196                                $next.addClass( "flex-disabled" );
1197                            }
1198
1199                            for ( var i = 0; i < cycles; i++ ) {
1200                                $this.flexslider( "next" );
1201                            }
1202
1203                            $prev.removeClass( "flex-disabled" );
1204
1205                            return true;
1206                        });
1207
1208                        $prev.click(function( e ) {
1209                            e.preventDefault();
1210
1211                            if ( $prev.hasClass( "flex-disabled" ) ) {
1212                                return true;
1213                            }
1214
1215                            var total = slider.currentSlide,
1216                                cycles = Math.min( total, move );
1217
1218                            if ( move >= total ) {
1219                                $prev.addClass( "flex-disabled" );
1220                            }
1221
1222                            for ( var i = 0; i < cycles; i++ ) {
1223                                $this.flexslider( "prev" );
1224                            }
1225
1226                            $next.removeClass( "flex-disabled" );
1227
1228                            return true;
1229                        });
1230
1231                    }
1232
1233                    if ( settings.start ) {
1234                        settings.start.apply( this, arguments );
1235                    }
1236                }
1237            }));
1238        });
1239    };
1240})( jQuery );

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.