PageSourceSearch

https://carrtaxlaw.com/wp-content/plugins/themetrust-shortcode/js/jquery.flexslider.js?ver=1.8

js carrtaxlaw.com collected 2026-09-24 20:47:35 UTC 62,672 bytes, 1,222 lines download raw bytes

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

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.