PageSourceSearch

https://www.worldwidefittings.com/cms/includes/js/plugins/jquery.c…V%2F%2BX401xKQR0Bfs5vh%2BtR7ptYfEGtbesJqRAR

js worldwidefittings.com collected 2026-10-04 13:24:23 UTC 52,781 bytes, 1,507 lines download raw bytes

1/*!
2 * jQuery Cycle2 - Version: 20130709
3 * http://malsup.com/jquery/cycle2/
4 * Copyright (c) 2012 M. Alsup; Dual licensed: MIT/GPL
5 * Requires: jQuery v1.7 or later
6 */
7; (function ($) {
8    "use strict";
9
10    var version = '20130709';
11
12    $.fn.cycle = function (options) {
13        // fix mistakes with the ready state
14        var o;
15        if (this.length === 0 && !$.isReady) {
16            o = { s: this.selector, c: this.context };
17            $.fn.cycle.log('requeuing slideshow (dom not ready)');
18            $(function () {
19                $(o.s, o.c).cycle(options);
20            });
21            return this;
22        }
23
24        return this.each(function () {
25            var data, opts, shortName, val;
26            var container = $(this);
27            var log = $.fn.cycle.log;
28
29            if (container.data('cycle.opts'))
30                return; // already initialized
31
32            if (container.data('cycle-log') === false ||
33                (options && options.log === false) ||
34                (opts && opts.log === false)) {
35                log = $.noop;
36            }
37
38            log('--c2 init--');
39            data = container.data();
40            for (var p in data) {
41                // allow props to be accessed sans 'cycle' prefix and log the overrides
42                if (data.hasOwnProperty(p) && /^cycle[A-Z]+/.test(p)) {
43                    val = data[p];
44                    shortName = p.match(/^cycle(.*)/)[1].replace(/^[A-Z]/, lowerCase);
45                    log(shortName + ':', val, '(' + typeof val + ')');
46                    data[shortName] = val;
47                }
48            }
49
50            opts = $.extend({}, $.fn.cycle.defaults, data, options || {});
51
52            opts.timeoutId = 0;
53            opts.paused = opts.paused || false; // #57
54            opts.container = container;
55            opts._maxZ = opts.maxZ;
56
57            opts.API = $.extend({ _container: container }, $.fn.cycle.API);
58            opts.API.log = log;
59            opts.API.trigger = function (eventName, args) {
60                opts.container.trigger(eventName, args);
61                return opts.API;
62            };
63
64            container.data('cycle.opts', opts);
65            container.data('cycle.API', opts.API);
66
67            // opportunity for plugins to modify opts and API
68            opts.API.trigger('cycle-bootstrap', [opts, opts.API]);
69
70            opts.API.addInitialSlides();
71            opts.API.preInitSlideshow();
72
73            if (opts.slides.length)
74                opts.API.initSlideshow();
75        });
76    };
77
78    $.fn.cycle.API = {
79        opts: function () {
80            return this._container.data('cycle.opts');
81        },
82        addInitialSlides: function () {
83            var opts = this.opts();
84            var slides = opts.slides;
85            opts.slideCount = 0;
86            opts.slides = $(); // empty set
87
88            // add slides that already exist
89            slides = slides.jquery ? slides : opts.container.find(slides);
90
91            if (opts.random) {
92                slides.sort(function () { return Math.random() - 0.5; });
93            }
94
95            opts.API.add(slides);
96        },
97
98        preInitSlideshow: function () {
99            var opts = this.opts();
100            opts.API.trigger('cycle-pre-initialize', [opts]);
101            var tx = $.fn.cycle.transitions[opts.fx];
102            if (tx && $.isFunction(tx.preInit))
103                tx.preInit(opts);
104            opts._preInitialized = true;
105        },
106
107        postInitSlideshow: function () {
108            var opts = this.opts();
109            opts.API.trigger('cycle-post-initialize', [opts]);
110            var tx = $.fn.cycle.transitions[opts.fx];
111            if (tx && $.isFunction(tx.postInit))
112                tx.postInit(opts);
113        },
114
115        initSlideshow: function () {
116            var opts = this.opts();
117            var pauseObj = opts.container;
118            var slideOpts;
119            opts.API.calcFirstSlide();
120
121            if (opts.container.css('position') == 'static')
122                opts.container.css('position', 'relative');
123
124            $(opts.slides[opts.currSlide]).css('opacity', 1).show();
125            opts.API.stackSlides(opts.slides[opts.currSlide], opts.slides[opts.nextSlide], !opts.reverse);
126
127            if (opts.pauseOnHover) {
128                // allow pauseOnHover to specify an element
129                if (opts.pauseOnHover !== true)
130                    pauseObj = $(opts.pauseOnHover);
131
132                pauseObj.hover(
133                    function () { opts.API.pause(true); },
134                    function () { opts.API.resume(true); }
135                );
136            }
137
138            // stage initial transition
139            if (opts.timeout) {
140                slideOpts = opts.API.getSlideOpts(opts.nextSlide);
141                opts.API.queueTransition(slideOpts, slideOpts.timeout + opts.delay);
142            }
143
144            opts._initialized = true;
145            opts.API.updateView(true);
146            opts.API.trigger('cycle-initialized', [opts]);
147            opts.API.postInitSlideshow();
148        },
149
150        pause: function (hover) {
151            var opts = this.opts(),
152                slideOpts = opts.API.getSlideOpts(),
153                alreadyPaused = opts.hoverPaused || opts.paused;
154
155            if (hover)
156                opts.hoverPaused = true;
157            else
158                opts.paused = true;
159
160            if (!alreadyPaused) {
161                opts.container.addClass('cycle-paused');
162                opts.API.trigger('cycle-paused', [opts]).log('cycle-paused');
163
164                if (slideOpts.timeout) {
165                    clearTimeout(opts.timeoutId);
166                    opts.timeoutId = 0;
167
168                    // determine how much time is left for the current slide
169                    opts._remainingTimeout -= ($.now() - opts._lastQueue);
170                    if (opts._remainingTimeout < 0 || isNaN(opts._remainingTimeout))
171                        opts._remainingTimeout = undefined;
172                }
173            }
174        },
175
176        resume: function (hover) {
177            var opts = this.opts(),
178                alreadyResumed = !opts.hoverPaused && !opts.paused,
179                remaining;
180
181            if (hover)
182                opts.hoverPaused = false;
183            else
184                opts.paused = false;
185
186
187            if (!alreadyResumed) {
188                opts.container.removeClass('cycle-paused');
189                // #gh-230; if an animation is in progress then don't queue a new transition; it will
190                // happen naturally
191                if (opts.slides.filter(':animated').length === 0)
192                    opts.API.queueTransition(opts.API.getSlideOpts(), opts._remainingTimeout);
193                opts.API.trigger('cycle-resumed', [opts, opts._remainingTimeout]).log('cycle-resumed');
194            }
195        },
196
197        add: function (slides, prepend) {
198            var opts = this.opts();
199            var oldSlideCount = opts.slideCount;
200            var startSlideshow = false;
201            var len;
202
203            if ($.type(slides) == 'string')
204                slides = $.trim(slides);
205
206            $(slides).each(function (i) {
207                var slideOpts;
208                var slide = $(this);
209
210                if (prepend)
211                    opts.container.prepend(slide);
212                else
213                    opts.container.append(slide);
214
215                opts.slideCount++;
216                slideOpts = opts.API.buildSlideOpts(slide);
217
218                if (prepend)
219                    opts.slides = $(slide).add(opts.slides);
220                else
221                    opts.slides = opts.slides.add(slide);
222
223                opts.API.initSlide(slideOpts, slide, --opts._maxZ);
224
225                slide.data('cycle.opts', slideOpts);
226                opts.API.trigger('cycle-slide-added', [opts, slideOpts, slide]);
227            });
228
229            opts.API.updateView(true);
230
231            startSlideshow = opts._preInitialized && (oldSlideCount < 2 && opts.slideCount >= 1);
232            if (startSlideshow) {
233                if (!opts._initialized)
234                    opts.API.initSlideshow();
235                else if (opts.timeout) {
236                    len = opts.slides.length;
237                    opts.nextSlide = opts.reverse ? len - 1 : 1;
238                    if (!opts.timeoutId) {
239                        opts.API.queueTransition(opts);
240                    }
241                }
242            }
243        },
244
245        calcFirstSlide: function () {
246            var opts = this.opts();
247            var firstSlideIndex;
248            firstSlideIndex = parseInt(opts.startingSlide || 0, 10);
249            if (firstSlideIndex >= opts.slides.length || firstSlideIndex < 0)
250                firstSlideIndex = 0;
251
252            opts.currSlide = firstSlideIndex;
253            if (opts.reverse) {
254                opts.nextSlide = firstSlideIndex - 1;
255                if (opts.nextSlide < 0)
256                    opts.nextSlide = opts.slides.length - 1;
257            }
258            else {
259                opts.nextSlide = firstSlideIndex + 1;
260                if (opts.nextSlide == opts.slides.length)
261                    opts.nextSlide = 0;
262            }
263        },
264
265        calcNextSlide: function () {
266            var opts = this.opts();
267            var roll;
268            if (opts.reverse) {
269                roll = (opts.nextSlide - 1) < 0;
270                opts.nextSlide = roll ? opts.slideCount - 1 : opts.nextSlide - 1;
271                opts.currSlide = roll ? 0 : opts.nextSlide + 1;
272            }
273            else {
274                roll = (opts.nextSlide + 1) == opts.slides.length;
275                opts.nextSlide = roll ? 0 : opts.nextSlide + 1;
276                opts.currSlide = roll ? opts.slides.length - 1 : opts.nextSlide - 1;
277            }
278        },
279
280        calcTx: function (slideOpts, manual) {
281            var opts = slideOpts;
282            var tx;
283            if (manual && opts.manualFx)
284                tx = $.fn.cycle.transitions[opts.manualFx];
285            if (!tx)
286                tx = $.fn.cycle.transitions[opts.fx];
287
288            if (!tx) {
289                tx = $.fn.cycle.transitions.fade;
290                opts.API.log('Transition "' + opts.fx + '" not found.  Using fade.');
291            }
292            return tx;
293        },
294
295        prepareTx: function (manual, fwd) {
296            var opts = this.opts();
297            var after, curr, next, slideOpts, tx;
298
299            if (opts.slideCount < 2) {
300                opts.timeoutId = 0;
301                return;
302            }
303            if (manual && (!opts.busy || opts.manualTrump)) {
304                opts.API.stopTransition();
305                opts.busy = false;
306                clearTimeout(opts.timeoutId);
307                opts.timeoutId = 0;
308            }
309            if (opts.busy)
310                return;
311            if (opts.timeoutId === 0 && !manual)
312                return;
313
314            curr = opts.slides[opts.currSlide];
315            next = opts.slides[opts.nextSlide];
316            slideOpts = opts.API.getSlideOpts(opts.nextSlide);
317            tx = opts.API.calcTx(slideOpts, manual);
318
319            opts._tx = tx;
320
321            if (manual && slideOpts.manualSpeed !== undefined)
322                slideOpts.speed = slideOpts.manualSpeed;
323
324            // if ( opts.nextSlide === opts.currSlide )
325            //     opts.API.calcNextSlide();
326
327            // ensure that:
328            //      1. advancing to a different slide
329            //      2. this is either a manual event (prev/next, pager, cmd) or 
330            //              a timer event and slideshow is not paused
331            if (opts.nextSlide != opts.currSlide &&
332                (manual || (!opts.paused && !opts.hoverPaused && opts.timeout))) { // #62
333
334                opts.API.trigger('cycle-before', [slideOpts, curr, next, fwd]);
335                if (tx.before)
336                    tx.before(slideOpts, curr, next, fwd);
337
338                after = function () {
339                    opts.busy = false;
340                    // #76; bail if slideshow has been destroyed
341                    if (!opts.container.data('cycle.opts'))
342                        return;
343
344                    if (tx.after)
345                        tx.after(slideOpts, curr, next, fwd);
346                    opts.API.trigger('cycle-after', [slideOpts, curr, next, fwd]);
347                    opts.API.queueTransition(slideOpts);
348                    opts.API.updateView(true);
349                };
350
351                opts.busy = true;
352                if (tx.transition)
353                    tx.transition(slideOpts, curr, next, fwd, after);
354                else
355                    opts.API.doTransition(slideOpts, curr, next, fwd, after);
356
357                opts.API.calcNextSlide();
358                opts.API.updateView();
359            } else {
360                opts.API.queueTransition(slideOpts);
361            }
362        },
363
364        // perform the actual animation
365        doTransition: function (slideOpts, currEl, nextEl, fwd, callback) {
366            var opts = slideOpts;
367            var curr = $(currEl), next = $(nextEl);
368            var fn = function () {
369                // make sure animIn has something so that callback doesn't trigger immediately
370                next.animate(opts.animIn || { opacity: 1 }, opts.speed, opts.easeIn || opts.easing, callback);
371            };
372
373            next.css(opts.cssBefore || {});
374            curr.animate(opts.animOut || {}, opts.speed, opts.easeOut || opts.easing, function () {
375                curr.css(opts.cssAfter || {});
376                if (!opts.sync) {
377                    fn();
378                }
379            });
380            if (opts.sync) {
381                fn();
382            }
383        },
384
385        queueTransition: function (slideOpts, specificTimeout) {
386            var opts = this.opts();
387            var timeout = specificTimeout !== undefined ? specificTimeout : slideOpts.timeout;
388            if (opts.nextSlide === 0 && --opts.loop === 0) {
389                opts.API.log('terminating; loop=0');
390                opts.timeout = 0;
391                if (timeout) {
392                    setTimeout(function () {
393                        opts.API.trigger('cycle-finished', [opts]);
394                    }, timeout);
395                }
396                else {
397                    opts.API.trigger('cycle-finished', [opts]);
398                }
399                // reset nextSlide
400                opts.nextSlide = opts.currSlide;
401                return;
402            }
403            if (timeout) {
404                opts._lastQueue = $.now();
405                if (specificTimeout === undefined)
406                    opts._remainingTimeout = slideOpts.timeout;
407
408                if (!opts.paused && !opts.hoverPaused) {
409                    opts.timeoutId = setTimeout(function () {
410                        opts.API.prepareTx(false, !opts.reverse);
411                    }, timeout);
412                }
413            }
414        },
415
416        stopTransition: function () {
417            var opts = this.opts();
418            if (opts.slides.filter(':animated').length) {
419                opts.slides.stop(false, true);
420                opts.API.trigger('cycle-transition-stopped', [opts]);
421            }
422
423            if (opts._tx && opts._tx.stopTransition)
424                opts._tx.stopTransition(opts);
425        },
426
427        // advance slide forward or back
428        advanceSlide: function (val) {
429            var opts = this.opts();
430            clearTimeout(opts.timeoutId);
431            opts.timeoutId = 0;
432            opts.nextSlide = opts.currSlide + val;
433
434            if (opts.nextSlide < 0)
435                opts.nextSlide = opts.slides.length - 1;
436            else if (opts.nextSlide >= opts.slides.length)
437                opts.nextSlide = 0;
438
439            opts.API.prepareTx(true, val >= 0);
440            return false;
441        },
442
443        buildSlideOpts: function (slide) {
444            var opts = this.opts();
445            var val, shortName;
446            var slideOpts = slide.data() || {};
447            for (var p in slideOpts) {
448                // allow props to be accessed sans 'cycle' prefix and log the overrides
449                if (slideOpts.hasOwnProperty(p) && /^cycle[A-Z]+/.test(p)) {
450                    val = slideOpts[p];
451                    shortName = p.match(/^cycle(.*)/)[1].replace(/^[A-Z]/, lowerCase);
452                    opts.API.log('[' + (opts.slideCount - 1) + ']', short
452Name + ':', val, '(' + typeof val + ')');
453                    slideOpts[shortName] = val;
454                }
455            }
456
457            slideOpts = $.extend({}, $.fn.cycle.defaults, opts, slideOpts);
458            slideOpts.slideNum = opts.slideCount;
459
460            try {
461                // these props should always be read from the master state object
462                delete slideOpts.API;
463                delete slideOpts.slideCount;
464                delete slideOpts.currSlide;
465                delete slideOpts.nextSlide;
466                delete slideOpts.slides;
467            } catch (e) {
468                // no op
469            }
470            return slideOpts;
471        },
472
473        getSlideOpts: function (index) {
474            var opts = this.opts();
475            if (index === undefined)
476                index = opts.currSlide;
477
478            var slide = opts.slides[index];
479            var slideOpts = $(slide).data('cycle.opts');
480            return $.extend({}, opts, slideOpts);
481        },
482
483        initSlide: function (slideOpts, slide, suggestedZindex) {
484            var opts = this.opts();
485            slide.css(slideOpts.slideCss || {});
486            if (suggestedZindex > 0)
487                slide.css('zIndex', suggestedZindex);
488
489            // ensure that speed settings are sane
490            if (isNaN(slideOpts.speed))
491                slideOpts.speed = $.fx.speeds[slideOpts.speed] || $.fx.speeds._default;
492            if (!slideOpts.sync)
493                slideOpts.speed = slideOpts.speed / 2;
494
495            slide.addClass(opts.slideClass);
496        },
497
498        updateView: function (isAfter) {
499            var opts = this.opts();
500            if (!opts._initialized)
501                return;
502            var slideOpts = opts.API.getSlideOpts();
503            var currSlide = opts.slides[opts.currSlide];
504
505            if (!isAfter) {
506                opts.API.trigger('cycle-update-view-before', [opts, slideOpts, currSlide]);
507                if (opts.updateView < 0)
508                    return;
509            }
510
511            if (opts.slideActiveClass) {
512                opts.slides.removeClass(opts.slideActiveClass)
513                    .eq(opts.currSlide).addClass(opts.slideActiveClass);
514            }
515
516            if (isAfter && opts.hideNonActive)
517                opts.slides.filter(':not(.' + opts.slideActiveClass + ')').hide();
518
519            opts.API.trigger('cycle-update-view', [opts, slideOpts, currSlide, isAfter]);
520            opts.API.trigger('cycle-update-view-after', [opts, slideOpts, currSlide]);
521        },
522
523        getComponent: function (name) {
524            var opts = this.opts();
525            var selector = opts[name];
526            if (typeof selector === 'string') {
527                // if selector is a child, sibling combinator, adjancent selector then use find, otherwise query full dom
528                return (/^\s*[\>|\+|~]/).test(selector) ? opts.container.find(selector) : $(selector);
529            }
530            if (selector.jquery)
531                return selector;
532
533            return $(selector);
534        },
535
536        stackSlides: function (curr, next, fwd) {
537            var opts = this.opts();
538            if (!curr) {
539                curr = opts.slides[opts.currSlide];
540                next = opts.slides[opts.nextSlide];
541                fwd = !opts.reverse;
542            }
543
544            // reset the zIndex for the common case:
545            // curr slide on top,  next slide beneath, and the rest in order to be shown
546            $(curr).css('zIndex', opts.maxZ);
547
548            var i;
549            var z = opts.maxZ - 2;
550            var len = opts.slideCount;
551            if (fwd) {
552                for (i = opts.currSlide + 1; i < len; i++)
553                    $(opts.slides[i]).css('zIndex', z--);
554                for (i = 0; i < opts.currSlide; i++)
555                    $(opts.slides[i]).css('zIndex', z--);
556            }
557            else {
558                for (i = opts.currSlide - 1; i >= 0; i--)
559                    $(opts.slides[i]).css('zIndex', z--);
560                for (i = len - 1; i > opts.currSlide; i--)
561                    $(opts.slides[i]).css('zIndex', z--);
562            }
563
564            $(next).css('zIndex', opts.maxZ - 1);
565        },
566
567        getSlideIndex: function (el) {
568            return this.opts().slides.index(el);
569        }
570
571    }; // API
572
573    // default logger
574    $.fn.cycle.log = function log() {
575        /*global console:true */
576        if (window.console && console.log)
577            console.log('[cycle2] ' + Array.prototype.join.call(arguments, ' '));
578    };
579
580    $.fn.cycle.version = function () { return 'Cycle2: ' + version; };
581
582    // helper functions
583
584    function lowerCase(s) {
585        return (s || '').toLowerCase();
586    }
587
588    // expose transition object
589    $.fn.cycle.transitions = {
590        custom: {
591        },
592        none: {
593            before: function (opts, curr, next, fwd) {
594                opts.API.stackSlides(next, curr, fwd);
595                opts.cssBefore = { opacity: 1, display: 'block' };
596            }
597        },
598        fade: {
599            before: function (opts, curr, next, fwd) {
600                var css = opts.API.getSlideOpts(opts.nextSlide).slideCss || {};
601                opts.API.stackSlides(curr, next, fwd);
602                opts.cssBefore = $.extend(css, { opacity: 0, display: 'block' });
603                opts.animIn = { opacity: 1 };
604                opts.animOut = { opacity: 0 };
605            }
606        },
607        fadeout: {
608            before: function (opts, curr, next, fwd) {
609                var css = opts.API.getSlideOpts(opts.nextSlide).slideCss || {};
610                opts.API.stackSlides(curr, next, fwd);
611                opts.cssBefore = $.extend(css, { opacity: 1, display: 'block' });
612                opts.animOut = { opacity: 0 };
613            }
614        },
615        scrollHorz: {
616            before: function (opts, curr, next, fwd) {
617                opts.API.stackSlides(curr, next, fwd);
618                var w = opts.container.css('overflow', 'hidden').width();
619                opts.cssBefore = { left: fwd ? w : -w, top: 0, opacity: 1, display: 'block' };
620                opts.cssAfter = { zIndex: opts._maxZ - 2, left: 0 };
621                opts.animIn = { left: 0 };
622                opts.animOut = { left: fwd ? -w : w };
623            }
624        }
625    };
626
627    // @see: http://jquery.malsup.com/cycle2/api
628    $.fn.cycle.defaults = {
629        allowWrap: true,
630        autoSelector: '.cycle-slideshow[data-cycle-auto-init!=false]',
631        delay: 0,
632        easing: null,
633        fx: 'fade',
634        hideNonActive: true,
635        loop: 0,
636        manualFx: undefined,
637        manualSpeed: undefined,
638        manualTrump: true,
639        maxZ: 100,
640        pauseOnHover: false,
641        reverse: false,
642        slideActiveClass: 'cycle-slide-active',
643        slideClass: 'cycle-slide',
644        slideCss: { position: 'absolute', top: 0, left: 0 },
645        slides: '> img',
646        speed: 500,
647        startingSlide: 0,
648        sync: true,
649        timeout: 4000,
650        updateView: -1
651    };
652
653    // automatically find and run slideshows
654    $(document).ready(function () {
655        $($.fn.cycle.defaults.autoSelector).cycle();
656    });
657
658})(jQuery);
659
660/*! Cycle2 autoheight plugin; Copyright (c) M.Alsup, 2012; version: 20130304 */
661(function ($) {
662    "use strict";
663
664    $.extend($.fn.cycle.defaults, {
665        autoHeight: 0 // setting this option to false disables autoHeight logic
666    });
667
668    $(document).on('cycle-initialized', function (e, opts) {
669        var autoHeight = opts.autoHeight;
670        var t = $.type(autoHeight);
671        var resizeThrottle = null;
672        var ratio;
673
674        if (t !== 'string' && t !== 'number')
675            return;
676
677        // bind events
678        opts.container.on('cycle-slide-added cycle-slide-removed', initAutoHeight);
679        opts.container.on('cycle-destroyed', onDestroy);
680
681        if (autoHeight == 'container') {
682            opts.container.on('cycle-before', onBefore);
683        }
684        else if (t === 'string' && /\d+\:\d+/.test(autoHeight)) {
685            // use ratio
686            ratio = autoHeight.match(/(\d+)\:(\d+)/);
687            ratio = ratio[1] / ratio[2];
688            opts._autoHeightRatio = ratio;
689        }
690
691        // if autoHeight is a number then we don't need to recalculate the sentinel
692        // index on resize
693        if (t !== 'number') {
694            // bind unique resize handler per slideshow (so it can be 'off-ed' in onDestroy)
695            opts._autoHeightOnResize = function () {
696                clearTimeout(resizeThrottle);
697                resizeThrottle = setTimeout(onResize, 50);
698            };
699
700            $(window).on('resize orientationchange', opts._autoHeightOnResize);
701        }
702
703        setTimeout(onResize, 30);
704
705        function onResize() {
706            initAutoHeight(e, opts);
707        }
708    });
709
710    function initAutoHeight(e, opts) {
711        var clone, height, sentinelIndex;
712        var autoHeight = opts.autoHeight;
713
714        if (autoHeight == 'container') {
715            height = $(opts.slides[opts.currSlide]).outerHeight();
716            opts.container.height(height);
717        }
718        else if (opts._autoHeightRatio) {
719            opts.container.height(opts.container.width() / opts._autoHeightRatio);
720        }
721        else if (autoHeight === 'calc' || ($.type(autoHeight) == 'number' && autoHeight >= 0)) {
722            if (autoHeight === 'calc')
723                sentinelIndex = calcSentinelIndex(e, opts);
724            else if (autoHeight >= opts.slides.length)
725                sentinelIndex = 0;
726            else
727                sentinelIndex = autoHeight;
728
729            // only recreate sentinel if index is different
730            if (sentinelIndex == opts._sentinelIndex)
731                return;
732
733            opts._sentinelIndex = sentinelIndex;
734            if (opts._sentinel)
735                opts._sentinel.remove();
736
737            // clone existing slide as sentinel
738            clone = $(opts.slides[sentinelIndex].cloneNode(true));
739
740            // #50; remove special attributes from cloned content
741            clone.removeAttr('id name rel').find('[id],[name],[rel]').removeAttr('id name rel');
742
743            clone.css({
744                position: 'static',
745                visibility: 'hidden',
746                display: 'block'
747            }).prependTo(opts.container).addClass('cycle-sentinel cycle-slide').removeClass('cycle-slide-active');
748            clone.find('*').css('visibility', 'hidden');
749
750            opts._sentinel = clone;
751        }
752    }
753
754    function calcSentinelIndex(e, opts) {
755        var index = 0, max = -1;
756
757        // calculate tallest slide index
758        opts.slides.each(function (i) {
759            var h = $(this).height();
760            if (h > max) {
761                max = h;
762                index = i;
763            }
764        });
765        return index;
766    }
767
768    function onBefore(e, opts, outgoing, incoming, forward) {
769        var h = $(incoming).outerHeight();
770        var duration = opts.sync ? opts.speed / 2 : opts.speed;
771        opts.container.animate({ height: h }, duration);
772    }
773
774    function onDestroy(e, opts) {
775        if (opts._autoHeightOnResize) {
776            $(window).off('resize orientationchange', opts._autoHeightOnResize);
777            opts._autoHeightOnResize = null;
778        }
779        opts.container.off('cycle-slide-added cycle-slide-removed', initAutoHeight);
780        opts.container.off('cycle-destroyed', onDestroy);
781        opts.container.off('cycle-before', onBefore);
782
783        if (opts._sentinel) {
784            opts._sentinel.remove();
785            opts._sentinel = null;
786        }
787    }
788
789})(jQuery);
790
791/*! caption plugin for Cycle2;  version: 20130306 */
792(function ($) {
793    "use strict";
794
795    $.extend($.fn.cycle.defaults, {
796        caption: '> .cycle-caption',
797        captionTemplate: '{{slideNum}} / {{slideCount}}',
798        overlay: '> .cycle-overlay',
799        overlayTemplate: '<div>{{title}}</div><div>{{desc}}</div>',
800        captionModule: 'caption'
801    });
802
803    $(document).on('cycle-update-view', function (e, opts, slideOpts, currSlide) {
804        if (opts.captionModule !== 'caption')
805            return;
806        var el;
807        $.each(['caption', 'overlay'], function () {
808            var name = this;
809            var template = slideOpts[name + 'Template'];
810            var el = opts.API.getComponent(name);
811            if (el.length && template) {
812                el.html(opts.API.tmpl(template, slideOpts, opts, currSlide));
813                el.show();
814            }
815            else {
816                el.hide();
817            }
818        });
819    });
820
821    $(document).on('cycle-destroyed', function (e, opts) {
822        var el;
823        $.each(['caption', 'overlay'], function () {
824            var name = this, template = opts[name + 'Template'];
825            if (opts[name] && template) {
826                el = opts.API.getComponent('caption');
827                el.empty();
828            }
829        });
830    });
831
832})(jQuery);
833
834/*! command plugin for Cycle2;  version: 20130707 */
835(function ($) {
836    "use strict";
837
838    var c2 = $.fn.cycle;
839
840    $.fn.cycle = function (options) {
841        var cmd, cmdFn, opts;
842        var args = $.makeArray(arguments);
843
844        if ($.type(options) == 'number') {
845            return this.cycle('goto', options);
846        }
847
848        if ($.type(options) == 'string') {
849            return this.each(function () {
850                var cmdArgs;
851                cmd = options;
852                opts = $(this).data('cycle.opts');
853
854                if (opts === undefined) {
855                    c2.log('slideshow must be initialized before sending commands; "' + cmd + '" ignored');
856                    return;
857                }
858                else {
859                    cmd = cmd == 'goto' ? 'jump' : cmd; // issue #3; change 'goto' to 'jump' internally
860                    cmdFn = opts.API[cmd];
861                    if ($.isFunction(cmdFn)) {
862                        cmdArgs = $.makeArray(args);
863                        cmdArgs.shift();
864                        return cmdFn.apply(opts.API, cmdArgs);
865                    }
866                    else {
867                        c2.log('unknown command: ', cmd);
868                    }
869                }
870            });
871        }
872        else {
873            return c2.apply(this, arguments);
874        }
875    };
876
877    // copy props
878    $.extend($.fn.cycle, c2);
879
880    $.extend(c2.API, {
881        next: function () {
882            var opts = this.opts();
883            if (opts.busy && !opts.manualTrump)
884                return;
885
886            var count = opts.reverse ? -1 : 1;
887            if (opts.allowWrap === false && (opts.currSlide + count) >= opts.slideCount)
888                return;
889
890            opts.API.advanceSlide(count);
891            opts.API.trigger('cycle-next', [opts]).log('cycle-next');
892        },
893
894        prev: function () {
895            var opts = this.opts();
896            if (opts.busy && !opts.manualTrump)
897                return;
898            var count = opts.reverse ? 1 : -1;
899            if (opts.allowWrap === false && (opts.currSlide + count) < 0)
900                return;
901
902            opts.API.advanceSlide(count);
903            opts.API.trigger('cycle-prev', [opts]).log('cycle-prev');
904        },
905
906        destroy: function () {
907            this.stop(); //#204
908
909            var opts = this.opts();
910            var clean = $.isFunction($._data) ? $._data : $.noop;  // hack for #184 and #201
911            clearTimeout(opts.timeoutId);
912            opts.timeoutId = 0;
913            opts.API.stop();
914            opts.API.trigger('cycle-destroyed', [opts]).log('cycle-destroyed');
915            opts.container.removeData();
916            clean(opts.container[0], 'parsedAttrs', false);
917
918            // #75; remove inline styles
919            if (!opts.retainStylesOnDestroy) {
920                opts.container.removeAttr('style');
921                opts.slides.removeAttr('style');
922                opts.slides.removeClass(opts.slideActiveClass);
923            }
924            opts.slides.each(function () {
925                $(this).removeData();
926                clean(this, 'parsedAttrs', false);
927            });
928        },
929
930        jump: function (index) {
931            // go to the requested slide
932            var fwd;
933            var opts = this.opts();
934            if (opts.busy && !opts.manualTrump)
935                return;
936            var num = parseInt(index, 10);
937            if (isNaN(num) || num < 0 || num >= opts.slides.length) {
938                opts.API.log('goto: invalid slide index: ' + num);
939                return;
940            }
941            if (num == opts.currSlide) {
942                opts.API.log('goto: skipping, already on slide', num);
943                return;
944            }
945            opts.nextSlide = num;
946            clearTimeout(opts.timeoutId);
947            opts.timeoutId = 0;
948            opts.API.log('goto: ', num, ' (zero-index)');
949            fwd = opts.currSlide < opts.nextSlide;
950            opts.API.prepareTx(true, fwd);
951        },
952
953        stop: function () {
954            var opts = this.opts();
955            var pauseObj = opts.container;
956            clearTimeout(opts.timeoutId);
957            opts.timeoutId = 0;
958            opts.API.stopTransition();
959            if (opts.pauseOnHover) {
960                if (opts.pauseOnHover !== true)
961                    pauseObj = $(opts.pauseOnHover);
962                pauseObj.off('mouseenter mouseleave');
963            }
964            opts.API.trigger('cycle-stopped', [opts]).log('cycle-stopped');
965        },
966
967        reinit: function () {
968            var opts = this.opts();
969            opts.API.destroy();
970            opts.container.cycle();
971        },
972
973        remove: function (index) {
974            var opts = this.opts();
975            var slide, slideToRemove, slides = [], slideNum = 1;
976            for (var i = 0; i < opts.slides.length; i++) {
977                slide = opts.slides[i];
978                if (i == index) {
979                    slideToRemove = slide;
980                }
981                else {
982                    slides.push(slide);
983                    $(slide).data('cycle.opts').slideNum = slideNum;
984                    slideNum++;
985                }
986            }
987            if (slideToRemove) {
988                opts.slides = $(slides);
989                opts.slideCount--;
990                $(slideToRemove).remove();
991                if (index == opts.currSlide)
992                    opts.API.advanceSlide(1);
993                else if (index < opts.currSlide)
994                    opts.currSlide--;
995                else
996                    opts.currSlide++;
997
998                opts.API.trigger('cycle-slide-removed', [opts, index, slideToRemove]).log('cycle-slide-removed');
999                opts.API.updateView();
1000            }
1001        }
1002
1003    });
1004
1005    // listen for clicks on elements with data-cycle-cmd attribute
1006    $(document).on('click.cycle', '[data-cycle-cmd]', function (e) {
1007        // issue cycle command
1008        e.preventDefault();
1009        var el = $(this);
1010        var command = el.data('cycle-cmd');
1011        var context = el.data('cycle-context') || '.cycle-slideshow';
1012        $(context).cycle(command, el.data('cycle-arg'));
1013    });
1014
1015
1016})(jQuery);
1017
1018/*! hash plugin for Cycle2;  version: 20121120 */
1019(function ($) {
1020    "use strict";
1021
1022    $(document).on('cycle-pre-initialize', function (e, opts) {
1023        onHashChange(opts, true);
1024
1025        opts._onHashChange = function () {
1026            onHashChange(opts, false);
1027        };
1028
1029        $(window).on('hashchange', opts._onHashChange);
1030    });
1031
1032    $(document).on('cycle-update-view', function (e, opts, slideOpts) {
1033        if (slideOpts.hash) {
1034            opts._hashFence = true;
1035            window.location.hash = slideOpts.hash;
1036        }
1037    });
1038
1039    $(document).on('cycle-destroyed', function (e, opts) {
1040        if (opts._onHashChange) {
1041            $(window).off('hashchange', opts._onHashChange);
1042        }
1043    });
1044
1045    function onHashChange(opts, setStartingSlide) {
1046        var hash;
1047        if (opts._hashFence) {
1048            opts._hashFence = false;
1049            return;
1050        }
1051
1052        hash = window.location.hash.substring(1);
1053
1054        opts.slides.each(function (i) {
1055            if ($(this).data('cycle-hash') == hash) {
1056                if (setStartingSlide === true) {
1057                    opts.startingSlide = i;
1058                }
1059                else {
1060                    opts.nextSlide = i;
1061                    opts.API.prepareTx(true, false);
1062                }
1063                return false;
1064            }
1065        });
1066    }
1067
1068})(jQuery);
1069
1070/*! loader plugin for Cycle2;  version: 20130307 */
1071(function ($) {
1072    "use strict";
1073
1074    $.extend($.fn.cycle.defaults, {
1075        loader: false
1076    });
1077
1078    $(document).on('cycle-bootstrap', function (e, opts) {
1079        var addFn;
1080
1081        if (!opts.loader)
1082            return;
1083
1084        // override API.add for this slideshow
1085        addFn = opts.API.add;
1086        opts.API.add = add;
1087
1088        function add(slides, prepend) {
1089            var slideArr = [];
1090            if ($.type(slides) == 'string')
1091                slides = $.trim(slides);
1092            else if ($.type(slides) === 'array') {
1093                for (var i = 0; i < slides.length; i++)
1094                    slides[i] = $(slides[i])[0];
1095            }
1096
1097            slides = $(slides);
1098            var slideCount = slides.length;
1099
1100            if (!slideCount)
1101                return;
1102
1103            slides.hide().appendTo('body').each(function (i) { // appendTo fixes #56
1104                var count = 0;
1105                var slide = $(this);
1106                var images = slide.is('img') ? slide : slide.find('img');
1107                slide.data('index', i);
1108                // allow some images to be marked as unimportant (and filter out images w/o src value)
1109                images = images.filter(':not(.cycle-loader-ignore)').filter(':not([src=""])');
1110                if (!images.length) {
1111                    --slideCount;
1112                    slideArr.push(slide);
1113                    return;
1114                }
1115
1116                count = images.length;
1117                images.each(function () {
1118                    // add images that are already loaded
1119                    if (this.complete) {
1120                        imageLoaded();
1121                    }
1122                    else {
1123                        $(this).load(function () {
1124                            imageLoaded();
1125                        }).error(function () {
1126                            if (--count === 0) {
1127                                // ignore this slide
1128                                opts.API.log('slide skipped; img not loaded:', this.src);
1129                                if (--slideCount === 0 && opts.loader == 'wait') {
1130                                    addFn.apply(opts.API, [slideArr, prepend]);
1131                                }
1132                            }
1133                        });
1134                    }
1135                });
1136
1137                function imageLoaded() {
1138                    if (--count === 0) {
1139                        --slideCount;
1140                        addSlide(slide);
1141                    }
1142                }
1143            });
1144
1145            if (slideCount)
1146                opts.container.addClass('cycle-loading');
1147
1148
1149            function addSlide(slide) {
1150                var curr;
1151                if (opts.loader == 'wait') {
1152                    slideArr.push(slide);
1153                    if (slideCount === 0) {
1154                        // #59; sort slides into original markup order
1155                        slideArr.sort(sorter);
1156                        addFn.apply(opts.API, [slideArr, prepend]);
1157                        opts.container.removeClass('cycle-loading');
1158                    }
1159                }
1160                else {
1161                    curr = $(opts.slides[opts.currSlide]);
1162                    addFn.apply(opts.API, [slide, prepend]);
1163                    curr.show();
1164                    opts.container.removeClass('cycle-loading');
1165                }
1166            }
1167
1168            function sorter(a, b) {
1169                return a.data('index') - b.data('index');
1170            }
1171        }
1172    });
1173
1174})(jQuery);
1175
1176/*! pager plugin for Cycle2;  version: 20130525 */
1177(function ($) {
1178    "use strict";
1179
1180    $.extend($.fn.cycle.defaults, {
1181        pager: '> .cycle-pager',
1182        pagerActiveClass: 'cycle-pager-active',
1183        pagerEvent: 'click.cycle',
1184        pagerTemplate: '<span>&bull;</span>'
1185    });
1186
1187    $(document).on('cycle-bootstrap', function (e, opts, API) {
1188        // add method to API
1189        API.buildPagerLink = buildPagerLink;
1190    });
1191
1192    $(document).on('cycle-slide-added', function (e, opts, slideOpts, slideAdded) {
1193        if (opts.pager) {
1194            opts.API.buildPagerLink(opts, slideOpts, slideAdded);
1195            opts.API.page = page;
1196        }
1197    });
1198
1199    $(document).on('cycle-slide-removed', function (e, opts, index, slideRemoved) {
1200        if (opts.pager) {
1201            var pagers = opts.API.getComponent('pager');
1202            pagers.each(function () {
1203                var pager = $(this);
1204                $(pager.children()[index]).remove();
1205            });
1206        }
1207    });
1208
1209    $(document).on('cycle-update-view', function (e, opts, slideOpts) {
1210        var pagers;
1211
1212        if (opts.pager) {
1213            pagers = opts.API.getComponent('pager');
1214            pagers.each(function () {
1215                $(this).children().removeClass(opts.pagerActiveClass)
1216                 .eq(opts.currSlide).addClass(opts.pagerActiveClass);
1217            });
1218        }
1219    });
1220
1221    $(document).on('cycle-destroyed', function (e, opts) {
1222        var pager = opts.API.getComponent('pager');
1223
1224        if (pager) {
1225            pager.children().off(opts.pagerEvent); // #202
1226            if (opts.pagerTemplate)
1227                pager.empty();
1228        }
1229    });
1230
1231    function buildPagerLink(opts, slideOpts, slide) {
1232        var pagerLink;
1233        var pagers = opts.API.getComponent('pager');
1234        pagers.each(function () {
1235            var pager = $(this);
1236            if (slideOpts.pagerTemplate) {
1237                var markup = opts.API.tmpl(slideOpts.pagerTemplate, slideOpts, opts, slide[0]);
1238                pagerLink = $(markup).appendTo(pager);
1239            }
1240            else {
1241                pagerLink = pager.children().eq(opts.slideCount - 1);
1242            }
1243            pagerLink.on(opts.pagerEvent, function (e) {
1244                e.preventDefault();
1245                opts.API.page(pager, e.currentTarget);
1246            });
1247        });
1248    }
1249
1250    function page(pager, target) {
1251        /*jshint validthis:true */
1252        var opts = this.opts();
1253        if (opts.busy && !opts.manualTrump)
1254            return;
1255
1256        var index = pager.children().index(target);
1257        var nextSlide = index;
1258        var fwd = opts.currSlide < nextSlide;
1259        if (opts.currSlide == nextSlide) {
1260            return; // no op, clicked pager for the currently displayed slide
1261        }
1262        opts.nextSlide = nextSlide;
1263        opts.API.prepareTx(true, fwd);
1264        opts.API.trigger('cycle-pager-activated', [opts, pager, target]);
1265    }
1266
1267})(jQuery);
1268
1269
1270/*! prevnext plugin for Cycle2;  version: 20130709 */
1271(function ($) {
1272    "use strict";
1273
1274    $.extend($.fn.cycle.defaults, {
1275        next: '> .cycle-next',
1276        nextEvent: 'click.cycle',
1277        disabledClass: 'disabled',
1278        prev: '> .cycle-prev',
1279        prevEvent: 'click.cycle',
1280        swipe: false
1281    });
1282
1283    $(document).on('cycle-initialized', function (e, opts) {
1284        opts.API.getComponent('next').on(opts.nextEvent, function (e) {
1285            e.preventDefault();
1286            opts.API.next();
1287        });
1288
1289        opts.API.getComponent('prev').on(opts.prevEvent, function (e) {
1290            e.preventDefault();
1291            opts.API.prev();
1292        });
1293
1294        if (opts.swipe) {
1295            var nextEvent = opts.swipeVert ? 'swipeUp.cycle' : 'swipeLeft.cycle swipeleft.cycle';
1296            var prevEvent = opts.swipeVert ? 'swipeDown.cycle' : 'swipeRight.cycle swiperight.cycle';
1297            opts.container.on(nextEvent, function (e) {
1298                opts.API.next();
1299            });
1300            opts.container.on(prevEvent, function () {
1301                opts.API.prev();
1302            });
1303        }
1304    });
1305
1306    $(document).on('cycle-update-view', function (e, opts, slideOpts, currSlide) {
1307        if (opts.allowWrap)
1308            return;
1309
1310        var cls = opts.disabledClass;
1311        var next = opts.API.getComponent('next');
1312        var prev = opts.API.getComponent('prev');
1313        var prevBoundry = opts._prevBoundry || 0;
1314        var nextBoundry = (opts._nextBoundry !== undefined) ? opts._nextBoundry : opts.slideCount - 1;
1315
1316        if (opts.currSlide == nextBoundry)
1317            next.addClass(cls).prop('disabled', true);
1318        else
1319            next.removeClass(cls).prop('disabled', false);
1320
1321        if (opts.currSlide === prevBoundry)
1322            prev.addClass(cls).prop('disabled', true);
1323        else
1324            prev.removeClass(cls).prop('disabled', false);
1325    });
1326
1327
1328    $(document).on('cycle-destroyed', function (e, opts) {
1329        opts.API.getComponent('prev').off(opts.nextEvent);
1330        opts.API.getComponent('next').off(opts.prevEvent);
1331        opts.container.off('swipeleft.cycle swiperight.cycle swipeLeft.cycle swipeRight.cycle swipeUp.cycle swipeDown.cycle');
1332    });
1333
1334})(jQuery);
1335
1336/*! progressive loader plugin for Cycle2;  version: 20130315 */
1337(function ($) {
1338    "use strict";
1339
1340    $.extend($.fn.cycle.defaults, {
1341        progressive: false
1342    });
1343
1344    $(document).on('cycle-pre-initialize', function (e, opts) {
1345        if (!opts.progressive)
1346            return;
1347
1348        var API = opts.API;
1349        var nextFn = API.next;
1350        var prevFn = API.prev;
1351        var prepareTxFn = API.prepareTx;
1352        var type = $.type(opts.progressive);
1353        var slides, scriptEl;
1354
1355        if (type == 'array') {
1356            slides = opts.progressive;
1357        }
1358        else if ($.isFunction(opts.progressive)) {
1359            slides = opts.progressive(opts);
1360        }
1361        else if (type == 'string') {
1362            scriptEl = $(opts.progressive);
1363            slides = $.trim(scriptEl.html());
1364            if (!slides)
1365                return;
1366            // is it json array?
1367            if (/^(\[)/.test(slides)) {
1368                try {
1369                    slides = $.parseJSON(slides);
1370                }
1371                catch (err) {
1372                    API.log('error parsing progressive slides', err);
1373                    return;
1374                }
1375            }
1376            else {
1377                // plain text, split on delimeter
1378                slides = slides.split(new RegExp(scriptEl.data('cycle-split') || '\n'));
1379
1380                // #95; look for empty slide
1381                if (!slides[slides.length - 1])
1382                    slides.pop();
1383            }
1384        }
1385
1386
1387
1388        if (prepareTxFn) {
1389            API.prepareTx = function (manual, fwd) {
1390                var index, slide;
1391
1392                if (manual || slides.length === 0) {
1393                    prepareTxFn.apply(opts.API, [manual, fwd]);
1394                    return;
1395                }
1396
1397                if (fwd && opts.currSlide == (opts.slideCount - 1)) {
1398                    slide = slides[0];
1399                    slides = slides.slice(1);
1400                    opts.container.one('cycle-slide-added', function (e, opts) {
1401                        setTimeout(function () {
1402                            opts.API.advanceSlide(1);
1403                        }, 50);
1404                    });
1405                    opts.API.add(slide);
1406                }
1407                else if (!fwd && opts.currSlide === 0) {
1408                    index = slides.length - 1;
1409                    slide = slides[index];
1410                    slides = slides.slice(0, index);
1411                    opts.container.one('cycle-slide-added', function (e, opts) {
1412                        setTimeout(function () {
1413                            opts.currSlide = 1;
1414                            opts.API.advanceSlide(-1);
1415                        }, 50);
1416                    });
1417                    opts.API.add(slide, true);
1418                }
1419                else {
1420                    prepareTxFn.apply(opts.API, [manual, fwd]);
1421                }
1422            };
1423        }
1424
1425        if (nextFn) {
1426            API.next = function () {
1427                var opts = this.opts();
1428                if (slides.length && opts.currSlide == (opts.slideCount - 1)) {
1429                    var slide = slides[0];
1430                    slides = slides.slice(1);
1431                    opts.container.one('cycle-slide-added', function (e, opts) {
1432                        nextFn.apply(opts.API);
1433                        opts.container.removeClass('cycle-loading');
1434                    });
1435                    opts.container.addClass('cycle-loading');
1436                    opts.API.add(slide);
1437                }
1438                else {
1439                    nextFn.apply(opts.API);
1440                }
1441            };
1442        }
1443
1444        if (prevFn) {
1445            API.prev = function () {
1446                var opts = this.opts();
1447                if (slides.length && opts.currSlide === 0) {
1448                    var index = slides.length - 1;
1449                    var slide = slides[index];
1450                    slides = slides.slice(0, index);
1451                    opts.container.one('cycle-slide-added', function (e, opts) {
1452                        opts.currSlide = 1;
1453                        opts.API.advanceSlide(-1);
1454                        opts.container.removeClass('cycle-loading');
1455                    });
1456                    opts.container.addClass('cycle-loading');
1457                    opts.API.add(slide, true);
1458                }
1459                else {
1460                    prevFn.apply(opts.API);
1461                }
1462            };
1463        }
1464    });
1465
1466})(jQuery);
1467
1468/*! tmpl plugin for Cycle2;  version: 20121227 */
1469(function ($) {
1470    "use strict";
1471
1472    $.extend($.fn.cycle.defaults, {
1473        tmplRegex: '{{((.)?.*?)}}'
1474    });
1475
1476    $.extend($.fn.cycle.API, {
1477        tmpl: function (str, opts /*, ... */) {
1478            var regex = new RegExp(opts.tmplRegex || $.fn.cycle.defaults.tmplRegex, 'g');
1479            var args = $.makeArray(arguments);
1480            args.shift();
1481            return str.replace(regex, function (_, str) {
1482                var i, j, obj, prop, names = str.split('.');
1483                for (i = 0; i < args.length; i++) {
1484                    obj = args[i];
1485                    if (!obj)
1486                        continue;
1487                    if (names.length > 1) {
1488                        prop = obj;
1489                        for (j = 0; j < names.length; j++) {
1490                            obj = prop;
1491                            prop = prop[names[j]] || str;
1492                        }
1493                    } else {
1494                        prop = obj[str];
1495                    }
1496
1497                    if ($.isFunction(prop))
1498                        return prop.apply(obj, args);
1499                    if (prop !== undefined && prop !== null && prop != str)
1500                        return prop;
1501                }
1502                return str;
1503            });
1504        }
1505    });
1506
1507})(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.