PageSourceSearch

https://laveujovetv.cat/wp-content/themes/evolve/library/media/js/jquery.flexslider.js?ver=4.9.26

js laveujovetv.cat collected 2026-09-27 04:02:36 UTC 65,948 bytes, 1,232 lines download raw bytes

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