PageSourceSearch

https://www.boots-uk.com/sb/site-js-bundle.js.v639258741000000000

js boots-uk.com collected 2026-09-24 19:15:18 UTC 59,733 bytes, 1,494 lines download raw bytes

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

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.