https://bigother.com/_static/??-eJyVkdFOwzAMRX8ILwWJMR4Qn4K81O3cJk…B4E7DGnGldYe7AKfyl9xo/nt/du+9q9dLsf0YzVRw==

254,
255                $list: null,
256                touchObject: {},
257                transformsEnabled: false,
258                unslicked: false
259            };
260
261            $.extend(_, _.initials);
262
263            _.activeBreakpoint = null;
264            _.animType = null;
265            _.animProp = null;
266            _.breakpoints = [];
267            _.breakpointSettings = [];
268            _.cssTransitions = false;
269            _.focussed = false;
270            _.interrupted = false;
271            _.hidden = 'hidden';
272            _.paused = true;
273            _.positionProp = null;
274            _.respondTo = null;
275            _.rowCount = 1;
276            _.shouldClick = true;
277            _.$slider = $(element);
278            _.$slidesCache = null;
279            _.transformType = null;
280            _.transitionType = null;
281            _.visibilityChange = 'visibilitychange';
282            _.windowWidth = 0;
283            _.windowTimer = null;
284
285            dataSettings = $(element).data('slick') || {};
286
287            _.options = $.extend({}, _.defaults, settings, dataSettings);
288
289            _.currentSlide = _.options.initialSlide;
290
291            _.originalSettings = _.options;
292
293            if (typeof document.mozHidden !== 'undefined') {
294                _.hidden = 'mozHidden';
295                _.visibilityChange = 'mozvisibilitychange';
296            } else if (typeof document.webkitHidden !== 'undefined') {
297                _.hidden = 'webkitHidden';
298                _.visibilityChange = 'webkitvisibilitychange';
299            }
300
301            _.autoPlay = $.proxy(_.autoPlay, _);
302            _.autoPlayClear = $.proxy(_.autoPlayClear, _);
303            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
304            _.changeSlide = $.proxy(_.changeSlide, _);
305            _.clickHandler = $.proxy(_.clickHandler, _);
306            _.selectHandler = $.proxy(_.selectHandler, _);
307            _.setPosition = $.proxy(_.setPosition, _);
308            _.swipeHandler = $.proxy(_.swipeHandler, _);
309            _.dragHandler = $.proxy(_.dragHandler, _);
310            _.keyHandler = $.proxy(_.keyHandler, _);
311
312            _.instanceUid = instanceUid++;
313
314            // A simple way to check for HTML strings
315            // Strict HTML recognition (must start with <)
316            // Extracted from jQuery v1.11 source
317            _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
318
319
320            _.registerBreakpoints();
321            _.init(true);
322
323        }
324
325        return Slick;
326
327    }());
328
329    Slick.prototype.activateADA = function() {
330        var _ = this;
331
332        _.$slideTrack.find('.slick-active').attr({
333            'aria-hidden': 'false'
334        }).find('a, input, button, select').attr({
335            'tabindex': '0'
336        });
337
338    };
339
340    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
341
342        var _ = this;
343
344        if (typeof(index) === 'boolean') {
345            addBefore = index;
346            index = null;
347        } else if (index < 0 || (index >= _.slideCount)) {
348            return false;
349        }
350
351        _.unload();
352
353        if (typeof(index) === 'number') {
354            if (index === 0 && _.$slides.length === 0) {
355                $(markup).appendTo(_.$slideTrack);
356            } else if (addBefore) {
357                $(markup).insertBefore(_.$slides.eq(index));
358            } else {
359                $(markup).insertAfter(_.$slides.eq(index));
360            }
361        } else {
362            if (addBefore === true) {
363                $(markup).prependTo(_.$slideTrack);
364            } else {
365                $(markup).appendTo(_.$slideTrack);
366            }
367        }
368
369        _.$slides = _.$slideTrack.children(this.options.slide);
370
371        _.$slideTrack.children(this.options.slide).detach();
372
373        _.$slideTrack.append(_.$slides);
374
375        _.$slides.each(function(index, element) {
376            $(element).attr('data-slick-index', index);
377        });
378
379        _.$slidesCache = _.$slides;
380
381        _.reinit();
382
383    };
384
385    Slick.prototype.animateHeight = function() {
386        var _ = this;
387        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
388            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
389            _.$list.animate({
390                height: targetHeight
391            }, _.options.speed);
392        }
393    };
394
395    Slick.prototype.animateSlide = function(targetLeft, callback) {
396
397        var animProps = {},
398            _ = this;
399
400        _.animateHeight();
401
402        if (_.options.rtl === true && _.options.vertical === false) {
403            targetLeft = -targetLeft;
404        }
405        if (_.transformsEnabled === false) {
406            if (_.options.vertical === false) {
407                _.$slideTrack.animate({
408                    left: targetLeft
409                }, _.options.speed, _.options.easing, callback);
410            } else {
411                _.$slideTrack.animate({
412                    top: targetLeft
413                }, _.options.speed, _.options.easing, callback);
414            }
415
416        } else {
417
418            if (_.cssTransitions === false) {
419                if (_.options.rtl === true) {
420                    _.currentLeft = -(_.currentLeft);
421                }
422                $({
423                    animStart: _.currentLeft
424                }).animate({
425                    animStart: targetLeft
426                }, {
427                    duration: _.options.speed,
428                    easing: _.options.easing,
429                    step: function(now) {
430                        now = Math.ceil(now);
431                        if (_.options.vertical === false) {
432                            animProps[_.animType] = 'translate(' +
433                                now + 'px, 0px)';
434                            _.$slideTrack.css(animProps);
435                        } else {
436                            animProps[_.animType] = 'translate(0px,' +
437                                now + 'px)';
438                            _.$slideTrack.css(animProps);
439                        }
440                    },
441                    complete: function() {
442                        if (callback) {
443                            callback.call();
444                        }
445                    }
446                });
447
448            } else {
449
450                _.applyTransition();
451                targetLeft = Math.ceil(targetLeft);
452
453                if (_.options.vertical === false) {
454                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
455                } else {
456                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
457                }
458                _.$slideTrack.css(animProps);
459
460                if (callback) {
461                    setTimeout(function() {
462
463                        _.disableTransition();
464
465                        callback.call();
466                    }, _.options.speed);
467                }
468
469            }
470
471        }
472
473    };
474
475    Slick.prototype.getNavTarget = function() {
476
477        var _ = this,
478            asNavFor = _.options.asNavFor;
479
480        if ( asNavFor && asNavFor !== null ) {
481            asNavFor = $(asNavFor).not(_.$slider);
482        }
483
484        return asNavFor;
485
486    };
487
488    Slick.prototype.asNavFor = function(index) {
489
490        var _ = this,
491            asNavFor = _.getNavTarget();
492
493        if ( asNavFor !== null && typeof asNavFor === 'object' ) {
494            asNavFor.each(function() {
495                var target = $(this).slick('getSlick');
496                if(!target.unslicked) {
497                    target.slideHandler(index, true);
498                }
499            });
500        }
501
502    };
503
504    Slick.prototype.applyTransition = function(slide) {
505
506        var _ = this,
507            transition = {};
508
509        if (_.options.fade === false) {
510            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
511        } else {
512            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
513        }
514
515        if (_.options.fade === false) {
516            _.$slideTrack.css(transition);
517        } else {
518            _.$slides.eq(slide).css(transition);
519        }
520
521    };
522
523    Slick.prototype.autoPlay = function() {
524
525        var _ = this;
526
527        _.autoPlayClear();
528
529        if ( _.slideCount > _.options.slidesToShow ) {
530            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
531        }
532
533    };
534
535    Slick.prototype.autoPlayClear = function() {
536
537        var _ = this;
538
539        if (_.autoPlayTimer) {
540            clearInterval(_.autoPlayTimer);
541        }
542
543    };
544
545    Slick.prototype.autoPlayIterator = function() {
546
547        var _ = this,
548            slideTo = _.currentSlide + _.options.slidesToScroll;
549
550        if ( !_.paused && !_.interrupted && !_.focussed ) {
551
552            if ( _.options.infinite === false ) {
553
554                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
555                    _.direction = 0;
556                }
557
558                else if ( _.direction === 0 ) {
559
560                    slideTo = _.currentSlide - _.options.slidesToScroll;
561
562                    if ( _.currentSlide - 1 === 0 ) {
563                        _.direction = 1;
564                    }
565
566                }
567
568            }
569
570            _.slideHandler( slideTo );
571
572        }
573
574    };
575
576    Slick.prototype.buildArrows = function() {
577
578        var _ = this;
579
580        if (_.options.arrows === true ) {
581
582            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
583            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
584
585            if( _.slideCount > _.options.slidesToShow ) {
586
587                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
588                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
589
590                if (_.htmlExpr.test(_.options.prevArrow)) {
591                    _.$prevArrow.prependTo(_.options.appendArrows);
592                }
593
594                if (_.htmlExpr.test(_.options.nextArrow)) {
595                    _.$nextArrow.appendTo(_.options.appendArrows);
596                }
597
598                if (_.options.infinite !== true) {
599                    _.$prevArrow
600                        .addClass('slick-disabled')
601                        .attr('aria-disabled', 'true');
602                }
603
604            } else {
605
606                _.$prevArrow.add( _.$nextArrow )
607
608                    .addClass('slick-hidden')
609                    .attr({
610                        'aria-disabled': 'true',
611                        'tabindex': '-1'
612                    });
613
614            }
615
616        }
617
618    };
619
620    Slick.prototype.buildDots = function() {
621
622        var _ = this,
623            i, dot;
624
625        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
626
627            _.$slider.addClass('slick-dotted');
628
629            dot = $('<ul />').addClass(_.options.dotsClass);
630
631            for (i = 0; i <= _.getDotCount(); i += 1) {
632                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
633            }
634
635            _.$dots = dot.appendTo(_.options.appendDots);
636
637            _.$dots.find('li').first().addClass('slick-active')

637.attr('aria-hidden', 'false');
638
639        }
640
641    };
642
643    Slick.prototype.buildOut = function() {
644
645        var _ = this;
646
647        _.$slides =
648            _.$slider
649                .children( _.options.slide + ':not(.slick-cloned)')
650                .addClass('slick-slide');
651
652        _.slideCount = _.$slides.length;
653
654        _.$slides.each(function(index, element) {
655            $(element)
656                .attr('data-slick-index', index)
657                .data('originalStyling', $(element).attr('style') || '');
658        });
659
660        _.$slider.addClass('slick-slider');
661
662        _.$slideTrack = (_.slideCount === 0) ?
663            $('<div class="slick-track"/>').appendTo(_.$slider) :
664            _.$slides.wrapAll('<div class="slick-track"/>').parent();
665
666        _.$list = _.$slideTrack.wrap(
667            '<div aria-live="polite" class="slick-list"/>').parent();
668        _.$slideTrack.css('opacity', 0);
669
670        if (_.options.centerMode === true || _.options.swipeToSlide === true) {
671            _.options.slidesToScroll = 1;
672        }
673
674        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
675
676        _.setupInfinite();
677
678        _.buildArrows();
679
680        _.buildDots();
681
682        _.updateDots();
683
684
685        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
686
687        if (_.options.draggable === true) {
688            _.$list.addClass('draggable');
689        }
690
691    };
692
693    Slick.prototype.buildRows = function() {
694
695        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
696
697        newSlides = document.createDocumentFragment();
698        originalSlides = _.$slider.children();
699
700        if(_.options.rows > 1) {
701
702            slidesPerSection = _.options.slidesPerRow * _.options.rows;
703            numOfSlides = Math.ceil(
704                originalSlides.length / slidesPerSection
705            );
706
707            for(a = 0; a < numOfSlides; a++){
708                var slide = document.createElement('div');
709                for(b = 0; b < _.options.rows; b++) {
710                    var row = document.createElement('div');
711                    for(c = 0; c < _.options.slidesPerRow; c++) {
712                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
713                        if (originalSlides.get(target)) {
714                            row.appendChild(originalSlides.get(target));
715                        }
716                    }
717                    slide.appendChild(row);
718                }
719                newSlides.appendChild(slide);
720            }
721
722            _.$slider.empty().append(newSlides);
723            _.$slider.children().children().children()
724                .css({
725                    'width':(100 / _.options.slidesPerRow) + '%',
726                    'display': 'inline-block'
727                });
728
729        }
730
731    };
732
733    Slick.prototype.checkResponsive = function(initial, forceUpdate) {
734
735        var _ = this,
736            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
737        var sliderWidth = _.$slider.width();
738        var windowWidth = window.innerWidth || $(window).width();
739
740        if (_.respondTo === 'window') {
741            respondToWidth = windowWidth;
742        } else if (_.respondTo === 'slider') {
743            respondToWidth = sliderWidth;
744        } else if (_.respondTo === 'min') {
745            respondToWidth = Math.min(windowWidth, sliderWidth);
746        }
747
748        if ( _.options.responsive &&
749            _.options.responsive.length &&
750            _.options.responsive !== null) {
751
752            targetBreakpoint = null;
753
754            for (breakpoint in _.breakpoints) {
755                if (_.breakpoints.hasOwnProperty(breakpoint)) {
756                    if (_.originalSettings.mobileFirst === false) {
757                        if (respondToWidth < _.breakpoints[breakpoint]) {
758                            targetBreakpoint = _.breakpoints[breakpoint];
759                        }
760                    } else {
761                        if (respondToWidth > _.breakpoints[breakpoint]) {
762                            targetBreakpoint = _.breakpoints[breakpoint];
763                        }
764                    }
765                }
766            }
767
768            if (targetBreakpoint !== null) {
769                if (_.activeBreakpoint !== null) {
770                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
771                        _.activeBreakpoint =
772                            targetBreakpoint;
773                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
774                            _.unslick(targetBreakpoint);
775                        } else {
776                            _.options = $.extend({}, _.originalSettings,
777                                _.breakpointSettings[
778                                    targetBreakpoint]);
779                            if (initial === true) {
780                                _.currentSlide = _.options.initialSlide;
781                            }
782                            _.refresh(initial);
783                        }
784                        triggerBreakpoint = targetBreakpoint;
785                    }
786                } else {
787                    _.activeBreakpoint = targetBreakpoint;
788                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
789                        _.unslick(targetBreakpoint);
790                    } else {
791                        _.options = $.extend({}, _.originalSettings,
792                            _.breakpointSettings[
793                                targetBreakpoint]);
794                        if (initial === true) {
795                            _.currentSlide = _.options.initialSlide;
796                        }
797                        _.refresh(initial);
798                    }
799                    triggerBreakpoint = targetBreakpoint;
800                }
801            } else {
802                if (_.activeBreakpoint !== null) {
803                    _.activeBreakpoint = null;
804                    _.options = _.originalSettings;
805                    if (initial === true) {
806                        _.currentSlide = _.options.initialSlide;
807                    }
808                    _.refresh(initial);
809                    triggerBreakpoint = targetBreakpoint;
810                }
811            }
812
813            // only trigger breakpoints during an actual break. not on initialize.
814            if( !initial && triggerBreakpoint !== false ) {
815                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
816            }
817        }
818
819    };
820
821    Slick.prototype.changeSlide = function(event, dontAnimate) {
822
823        var _ = this,
824            $target = $(event.currentTarget),
825            indexOffset, slideOffset, unevenOffset;
826
827        // If target is a link, prevent default action.
828        if($target.is('a')) {
829            event.preventDefault();
830        }
831
832        // If target is not the <li> element (ie: a child), find the <li>.
833        if(!$target.is('li')) {
834            $target = $target.closest('li');
835        }
836
837        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
838        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
839
840        switch (event.data.message) {
841
842            case 'previous':
843                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
844                if (_.slideCount > _.options.slidesToShow) {
845                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
846                }
847                break;
848
849            case 'next':
850                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
851                if (_.slideCount > _.options.slidesToShow) {
852                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
853                }
854                break;
855
856            case 'index':
857                var index = event.data.index === 0 ? 0 :
858                    event.data.index || $target.index() * _.options.slidesToScroll;
859
860                _.slideHandler(_.checkNavigable(index), false, dontAnimate);
861                $target.children().trigger('focus');
862                break;
863
864            default:
865                return;
866        }
867
868    };
869
870    Slick.prototype.checkNavigable = function(index) {
871
872        var _ = this,
873            navigables, prevNavigable;
874
875        navigables = _.getNavigableIndexes();
876        prevNavigable = 0;
877        if (index > navigables[navigables.length - 1]) {
878            index = navigables[navigables.length - 1];
879        } else {
880            for (var n in navigables) {
881                if (index < navigables[n]) {
882                    index = prevNavigable;
883                    break;
884                }
885                prevNavigable = navigables[n];
886            }
887        }
888
889        return index;
890    };
891
892    Slick.prototype.cleanUpEvents = function() {
893
894        var _ = this;
895
896        if (_.options.dots && _.$dots !== null) {
897
898            $('li', _.$dots)
899                .off('click.slick', _.changeSlide)
900                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
901                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
902
903        }
904
905        _.$slider.off('focus.slick blur.slick');
906
907        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
908            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
909            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
910        }
911
912        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
913        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
914        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
915        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
916
917        _.$list.off('click.slick', _.clickHandler);
918
919        $(document).off(_.visibilityChange, _.visibility);
920
921        _.cleanUpSlideEvents();
922
923        if (_.options.accessibility === true) {
924            _.$list.off('keydown.slick', _.keyHandler);
925        }
926
927        if (_.options.focusOnSelect === true) {
928            $(_.$slideTrack).children().off('click.slick', _.selectHandler);
929        }
930
931        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
932
933        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
934
935        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
936
937        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
938        $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);
939
940    };
941
942    Slick.prototype.cleanUpSlideEvents = function() {
943
944        var _ = this;
945
946        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
947        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
948
949    };
950
951    Slick.prototype.cleanUpRows = function() {
952
953        var _ = this, originalSlides;
954
955        if(_.options.rows > 1) {
956            originalSlides = _.$slides.children().children();
957            originalSlides.removeAttr('style');
958            _.$slider.empty().append(originalSlides);
959        }
960
961    };
962
963    Slick.prototype.clickHandler = function(event) {
964
965        var _ = this;
966
967        if (_.shouldClick === false) {
968            event.stopImmediatePropagation();
969            event.stopPropagation();
970            event.preventDefault();
971        }
972
973    };
974
975    Slick.prototype.destroy = function(refresh) {
976
977        var _ = this;
978
979        _.autoPlayClear();
980
981        _.touchObject = {};
982
983        _.cleanUpEvents();
984
985        $('.slick-cloned', _.$slider).detach();
986
987        if (_.$dots) {
988            _.$dots.remove();
989        }
990
991
992        if ( _.$prevArrow && _.$prevArrow.length ) {
993
994            _.$prevArrow
995                .removeClass('slick-disabled slick-arrow slick-hidden')
996                .removeAttr('aria-hidden aria-disabled tabindex')
997                .css('display','');
998
999            if ( _.htmlExpr.test( _.options.prevArrow )) {
1000                _.$prevArrow.remove();
1001            }
1002        }
1003
1004        if ( _.$nextArrow && _.$nextArrow.length ) {
1005
1006            _.$nextArrow
1007                .removeClass('slick-disabled slick-arrow slick-hidden')
1008                .removeAttr('aria-hidden aria-disabled tabindex')
1009                .css('display','');
1010
1011            if ( _.htmlExpr.test( _.options.nextArrow )) {
1012                _.$nextArrow.remove();
1013            }
1014
1015        }
1016
1017
1018        if (_.$slides) {
1019
1020            _.$slides
1021                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
1022                .removeAttr('aria-hidden')
1023                .removeAttr('data-slick-index')
1024                .each(function(){
1025                    $(this).attr('style', $(this).data('originalStyling'));
1026                });
1027
1028            _.$slideTrack.children(this.options.slide).detach();
1029
1030            _.$slideTrack.detach();
1031
1032            _.$list.detach();
1033
1034            _.$slider.append(_.$slides);
1035        }
1036
1037        _.cleanUpRows();
1038
1039        _.$slider.removeClass('slick-slider');
1040        _.$slider.removeClass('slick-initialized');
1041        _.$slider.removeClass('slick-dotted');
1042
1043        _.unslicked = true;
1044
1045        if(!refresh) {
1046            _.$slider.trigger('destroy', [_]);
1047        }
1048
1049    };
1050
1051    Slick.prototype.disableTransition = function(slide) {
1052
1053        var _ = this,
1054            transition = {};
1055
1056        transition[_.transitionType] = '';
1057
1058        if (_.options.fade === false) {
1059            _.$slideTrack.css(transition);
1060        } else {
1061            _.$slides.eq(slide).css(transition);
1062        }
1063
1064    };
1065
1066    Slick.prototype.fadeSlide = function(slideIndex, callback) {
1067
1068        var _ = this;
1069
1070        if (_.cssTransitions === false) {
1071
1072            _.$slides.eq(slideIndex).css({
1073                zIndex: _.options.zIndex
1074            });
1075
1076            _.$slides.eq(slideIndex).animate({
1077                opacity: 1
1078            }, _.options.speed, _.options.easing, callback);
1079
1080        } else {
1081
1082            _.applyTransition(slideIndex);
1083
1084            _.$slides.eq(slideIndex).css({
1085                opacity: 1,
1086                zIndex: _.options.zIndex
1087            });
1088
1089            if (callback) {
1090                setTimeout(function() {
1091
1092                    _.disableTransition(slideIndex);
1093
1094                    callback.call();
1095                }, _.options.speed);
1096            }
1097
1098        }
1099
1100    };
1101
1102    Slick.prototype.fadeSlideOut = function(slideIndex) {
1103
1104        var _ = this;
1105
1106        if (_.cssTransitions === false) {
1107
1108            _.$slides.eq(slideIndex).animate({
1109                opacity: 0,
1110                zIndex: _.options.zIndex - 2
1111            }, _.options.speed, _.options.easing);
1112
1113        } else {
1114
1115            _.applyTransition(slideIndex);
1116
1117            _.$slides.eq(slideIndex).css({
1118                opacity: 0,
1119                zIndex: _.options.zIndex - 2
1120            });
1121
1122        }
1123
1124    };
1125

1226ideIndex - _.slideCount)) * _.slideWidth) * -1;
1227                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
1228                    } else {
1229                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
1230                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
1231                    }
1232                }
1233            }
1234        } else {
1235            if (slideIndex + _.options.slidesToShow > _.slideCount) {
1236                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
1237                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
1238            }
1239        }
1240
1241        if (_.slideCount <= _.options.slidesToShow) {
1242            _.slideOffset = 0;
1243            verticalOffset = 0;
1244        }
1245
1246       

1246 if (_.options.centerMode === true && _.options.infinite === true) {
1247            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
1248        } else if (_.options.centerMode === true) {
1249            _.slideOffset = 0;
1250            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
1251        }
1252
1253        if (_.options.vertical === false) {
1254            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
1255        } else {
1256            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
1257        }
1258
1259        if (_.options.variableWidth === true) {
1260
1261            if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1262                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1263            } else {
1264                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
1265            }
1266
1267            if (_.options.rtl === true) {
1268                if (targetSlide[0]) {
1269                    targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1270                } else {
1271                    targetLeft =  0;
1272                }
1273            } else {
1274                targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1275            }
1276
1277            if (_.options.centerMode === true) {
1278                if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1279                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1280                } else {
1281                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
1282                }
1283
1284                if (_.options.rtl === true) {
1285                    if (targetSlide[0]) {
1286                        targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1287                    } else {
1288                        targetLeft =  0;
1289                    }
1290                } else {
1291                    targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1292                }
1293
1294                targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
1295            }
1296        }
1297
1298        return targetLeft;
1299
1300    };
1301
1302    Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
1303
1304        var _ = this;
1305
1306        return _.options[option];
1307
1308    };
1309
1310    Slick.prototype.getNavigableIndexes = function() {
1311
1312        var _ = this,
1313            breakPoint = 0,
1314            counter = 0,
1315            indexes = [],
1316            max;
1317
1318        if (_.options.infinite === false) {
1319            max = _.slideCount;
1320        } else {
1321            breakPoint = _.options.slidesToScroll * -1;
1322            counter = _.options.slidesToScroll * -1;
1323            max = _.slideCount * 2;
1324        }
1325
1326        while (breakPoint < max) {
1327            indexes.push(breakPoint);
1328            breakPoint = counter + _.options.slidesToScroll;
1329            counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1330        }
1331
1332        return indexes;
1333
1334    };
1335
1336    Slick.prototype.getSlick = function() {
1337
1338        return this;
1339
1340    };
1341
1342    Slick.prototype.getSlideCount = function() {
1343
1344        var _ = this,
1345            slidesTraversed, swipedSlide, centerOffset;
1346
1347        centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
1348
1349        if (_.options.swipeToSlide === true) {
1350            _.$slideTrack.find('.slick-slide').each(function(index, slide) {
1351                if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
1352                    swipedSlide = slide;
1353                    return false;
1354                }
1355            });
1356
1357            slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
1358
1359            return slidesTraversed;
1360
1361        } else {
1362            return _.options.slidesToScroll;
1363        }
1364
1365    };
1366
1367    Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
1368
1369        var _ = this;
1370
1371        _.changeSlide({
1372            data: {
1373                message: 'index',
1374                index: parseInt(slide)
1375            }
1376        }, dontAnimate);
1377
1378    };
1379
1380    Slick.prototype.init = function(creation) {
1381
1382        var _ = this;
1383
1384        if (!$(_.$slider).hasClass('slick-initialized')) {
1385
1386            $(_.$slider).addClass('slick-initialized');
1387
1388            _.buildRows();
1389            _.buildOut();
1390            _.setProps();
1391            _.startLoad();
1392            _.loadSlider();
1393            _.initializeEvents();
1394            _.updateArrows();
1395            _.updateDots();
1396            _.checkResponsive(true);
1397            _.focusHandler();
1398
1399        }
1400
1401        if (creation) {
1402            _.$slider.trigger('init', [_]);
1403        }
1404
1405        if (_.options.accessibility === true) {
1406            _.initADA();
1407        }
1408
1409        if ( _.options.autoplay ) {
1410
1411            _.paused = false;
1412            _.autoPlay();
1413
1414        }
1415
1416    };
1417
1418    Slick.prototype.initADA = function() {
1419        var _ = this

1523        _.$list.on('touchcancel.slick mouseleave.slick', {
1524            action: 'end'
1525        }, _.swipeHandler);
1526
1527        _.$list.on('click.slick', _.clickHandler);
1528
1529        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
1530
1531        if (_.options.accessibility === true) {
1532            _.$list.on('keydown.slick', _.keyHandler);
1533        }
1534
1535        if (_.options.focusOnSelect === true) {
1536            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1537        }
1538
1539        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
1540
1541        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
1542
1543        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
1544
1545        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
1546        $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
1547
1548    };
1549
1550    Slick.prototype.initUI = function() {
1551
1552        var _ = this;
1553
1554        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1555
1556            _.$prevArrow.show();
1557            _.$nextArrow.show();
1558
1559        }
1560
1561        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1562
1563            _.$dots.show();
1564
1565        }
1566
1567    };
1568
1569    Slick.prototype.keyHandler = function(event) {
1570
1571        var _ = this;
1572         //Dont slide if the cursor is inside the form fields and arrow keys are pressed
1573        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
1574            if (event.keyCode === 37 && _.options.accessibility === true) {
1575                _.changeSlide({
1576                    data: {
1577                        message: _.options.rtl === true ? 'next' :  'previous'
1578                    }
1579                });
1580            } else if (event.keyCode === 39 && _.options.accessibility === true) {
1581                _.changeSlide({
1582                    data: {
1583                        message: _.options.rtl === true ? 'previous' : 'next'
1584                    }
1585                });
1586            }
1587        }
1588
1589    };
1590
1591    Slick.prototype.lazyLoad = function() {
1592
1593        var _ = this,
1594            loadRange, cloneRange, rangeStart, rangeEnd;
1595
1596        function loadImages(imagesScope) {
1597
1598            $('img[data-lazy]', imagesScope).each(function() {
1599
1600                var image = $(this),
1601                    imageSource = $(this).attr('data-lazy'),
1602                    imageToLoad = document.createElement('img');
1603
1604                imageToLoad.onload = function() {
1605
1606                    image
1607                        .animate({ opacity: 0 }, 100, function() {
1608                            image
1609                                .attr('src', imageSource)
1610                                .animate({ opacity: 1 }, 200, function() {
1611                                    image
1612                                        .removeAttr('data-lazy')
1613                                        .removeClass('slick-loading');
1614                                });
1615                            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
1616                        });
1617
1618                };
1619
1620                imageToLoad.onerror = function() {
1621
1622                    image
1623                        .removeAttr( 'data-lazy' )
1624                        .removeClass( 'slick-loading' )
1625                        .addClass( 'slick-lazyload-error' );
1626
1627                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1628
1629                };
1630
1631                imageToLoad.src = imageSource;
1632
1633            });
1634
1635        }
1636
1637        if (_.options.centerMode === true) {
1638            if (_.options.infinite === true) {
1639                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
1640                rangeEnd = rangeStart + _.options.slidesToShow + 2;
1641            } else {
1642                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
1643                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
1644            }
1645        } else {
1646            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
1647            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
1648            if (_.options.fade === true) {
1649                if (rangeStart > 0) rangeStart--;
1650                if (rangeEnd <= _.slideCount) rangeEnd++;
1651            }
1652        }
1653
1654        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
1655        loadImages(loadRange);
1656
1657        if (_.slideCount <= _.options.slidesToShow) {
1658            cloneRange = _.$slider.find('.slick-slide');
1659            loadImages(cloneRange);
1660        } else
1661        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1662            cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
1663            loadImages(cloneRange);
1664        } else if (_.currentSlide === 0) {
1665            cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
1666            loadImages(cloneRange);
1667        }
1668
1669    };
1670
1671    Slick.prototype.loadSlider = function() {
1672
1673        var _ = this;
1674
1675        _.setPosition();
1676
1677        _.$slideTrack.css({
1678            opacity: 1
1679        });
1680
1681        _.$slider.removeClass('slick-loading');
1682
1683        _.initUI();
1684
1685        if (_.options.lazyLoad === 'progressive') {
1686            _.progressiveLazyLoad();
1687        }
1688
1689    };
1690
1691    Slick.prototype.next = Slick.prototype.slickNext = function() {
1692
1693        var _ = this;
1694
1695        _.changeSlide({
1696            data: {
1697                message: 'next'
1698            }
1699        });
1700
1701    };
1702
1703    Slick.prototype.orientationChange = function() {
1704
1705        var _ = this;
1706
1707        _.checkResponsive();
1708        _.setPosition();
1709
1710    };
1711
1712    Slick.prototype.pause = Slick.prototype.slickPause = function() {
1713
1714        var _ = this;
1715
1716        _.autoPlayClear();
1717        _.paused = true;
1718
1719    };
1720
1721    Slick.prototype.play = Slick.prototype.slickPlay = function() {
1722
1723        var _ = this;
1724
1725        _.autoPlay();
1726        _.options.autoplay = true;
1727        _.paused = false;
1728        _.focussed = false;
1729        _.interrupted = false;
1730
1731    };
1732
1733    Slick.prototype.postSlide = function(index) {
1734
1735        var _ = this;
1736
1737        if( !_.unslicked ) {
1738
1739            _.$slider.trigger('afterChange', [_, index]);
1740
1741            _.animating = false;
1742
1743            _.setPosition();
1744
1745            _.swipeLeft = null;
1746
1747            if ( _.options.autoplay ) {
1748                _.autoPlay();
1749            }
1750
1751            if (_.options.accessibility === true) {
1752                _.initADA();
1753            }
1754
1755        }
1756
1757    };
1758
1759    Slick.prototype.prev = Slick.prototype.slickPrev = function() {
1760
1761        var _ = this;
1762
1763        _.changeSlide({
1764            data: {
1765                message: 'previous'
1766            }
1767        });
1768
1769    };
1770
1771    Slick.prototype.preventDefault = function(event) {
1772
1773        event.preventDefault();
1774
1775    };
1776
1777    Slick.prototype.progressiveLazyLoad = function( tryCount ) {
1778
1779        tryCount = tryCount || 1;
1780
1781        var _ = this,
1782            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
1783            image,
1784            imageSource,
1785            imageToLoad;
1786
1787        if ( $imgsToLoad.length ) {
1788
1789            image = $imgsToLoad.first();
1790            imageSource = image.attr('data-lazy');
1791            imageToLoad = document.createElement('img');
1792
1793            imageToLoad.onload = function() {
1794
1795                image
1796                    .attr( 'src', imageSource )
1797                    .removeAttr('data-lazy')
1798                    .removeClass('slick-loading');
1799
1800                if ( _.options.adaptiveHeight === true ) {
1801                    _.setPosition();
1802                }
1803
1804                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
1805                _.progressiveLazyLoad();
1806
1807            };
1808
1809            imageToLoad.onerror = function() {
1810
1811                if ( tryCount < 3 ) {
1812
1813                    /**
1814                     * try to load the image 3 times,
1815                     * leave a slight delay so we don't get
1816                     * servers blocking the request.
1817                     */
1818                    setTimeout( function() {
1819                        _.progressiveLazyLoad( tryCount + 1 );
1820                    }, 500 );
1821
1822                } else {
1823
1824                    image
1825                        .removeAttr( 'data-lazy' )
1826                        .removeClass( 'slick-loading' )
1827                        .addClass( 'slick-lazyload-error' );
1828
1829                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1830
1831                    _.progressiveLazyLoad();
1832
1833                }
1834
1835            };
1836
1837            imageToLoad.src = imageSource;
1838
1839        } else {
1840
1841            _.$slider.trigger('allImagesLoaded', [ _ ]);
1842
1843        }
1844
1845    };
1846
1847    Slick.prototype.refresh = function( initializing ) {
1848
1849        var _ = this, currentSlide, lastVisibleIndex;
1850
1851        lastVisibleIndex = _.slideCount - _.options.slidesToShow;
1852
1853        // in non-infinite sliders, we don't want to go past the
1854        // last visible index.
1855        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
1856            _.currentSlide = lastVisibleIndex;
1857        }
1858
1859        // if less slides than to show, go to start.
1860        if ( _.slideCount <= _.options.slidesToShow ) {
1861            _.currentSlide = 0;
1862
1863        }
1864
1865        currentSlide = _.currentSlide;
1866
1867        _.destroy(true);
1868
1869        $.extend(_, _.initials, { currentSlide: currentSlide });
1870
1871        _.init();
1872
1873        if( !initializing ) {
1874
1875            _.changeSlide({
1876                data: {
1877                    message: 'index',
1878                    index: currentSlide
1879                }
1880            }, false);
1881
1882        }
1883
1884    };
1885
1886    Slick.prototype.registerBreakpoints = function() {
1887
1888        var _ = this, breakpoint, currentBreakpoint, l,
1889            responsiveSettings = _.options.responsive || null;
1890
1891        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
1892
1893            _.respondTo = _.options.respondTo || 'window';
1894
1895            for ( breakpoint in responsiveSettings ) {
1896
1897                l = _.breakpoints.length-1;
1898                currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
1899
1900                if (responsiveSettings.hasOwnProperty(breakpoint)) {

1900
1901
1902                    // loop through the breakpoints and cut out any existing
1903                    // ones with the same breakpoint number, we don't want dupes.
1904                    while( l >= 0 ) {
1905                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
1906                            _.breakpoints.splice(l,1);
1907                        }
1908                        l--;
1909                    }
1910
1911                    _.breakpoints.push(currentBreakpoint);
1912                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
1913
1914                }
1915
1916            }
1917
1918            _.breakpoints.sort(function(a, b) {
1919                return ( _.options.mobileFirst ) ? a-b : b-a;
1920            });
1921
1922        }
1923
1924    };
1925
1926    Slick.prototype.reinit = function() {
1927
1928        var _ = this;
1929
1930        _.$slides =
1931            _.$slideTrack
1932                .children(_.options.slide)
1933                .addClass('slick-slide');
1934
1935        _.slideCount = _.$slides.length;
1936
1937        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1938            _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1939        }
1940
1941        if (_.slideCount <= _.options.slidesToShow) {
1942            _.currentSlide = 0;
1943        }
1944
1945        _.registerBreakpoints();
1946
1947        _.setProps();
1948        _.setupInfinite();
1949        _.buildArrows();
1950        _.updateArrows();
1951        _.initArrowEvents();
1952        _.buildDots();
1953        _.updateDots();
1954        _.initDotEvents();
1955        _.cleanUpSlideEvents();
1956        _.initSlideEvents();
1957
1958        _.checkResponsive(false, true);
1959
1960        if (_.options.focusOnSelect === true) {
1961            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1962        }
1963
1964        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1965
1966        _.setPosition();
1967        _.focusHandler();
1968
1969        _.paused = !_.options.autoplay;
1970        _.autoPlay();
1971
1972        _.$slider.trigger('reInit', [_]);
1973
1974    };
1975
1976    Slick.prototype.resize = function() {
1977
1978        var _ = this;
1979
1980        if ($(window).width() !== _.windowWidth) {
1981            clearTimeout(_.windowDelay);
1982            _.windowDelay = window.setTimeout(function() {
1983                _.windowWidth = $(window).width();
1984                _.checkResponsive();
1985                if( !_.unslicked ) { _.setPosition(); }
1986            }, 50);
1987        }
1988    };
1989
1990    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
1991
1992        var _ = this;
1993
1994        if (typeof(index) === 'boolean') {
1995            removeBefore = index;
1996            index = removeBefore === true ? 0 : _.slideCount - 1;
1997        } else {
1998            index = removeBefore === true ? --index : index;
1999        }
2000
2001        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
2002            return false;
2003        }
2004
2005        _.unload();
2006
2007        if (removeAll === true) {
2008            _.$slideTrack.children().remove();
2009        } else {
2010            _.$slideTrack.children(this.options.slide).eq(index).remove();
2011        }
2012
2013        _.$slides = _.$slideTrack.children(this.options.slide);
2014
2015        _.$slideTrack.children(this.options.slide).detach();
2016
2017        _.$slideTrack.append(_.$slides);
2018
2019        _.$slidesCache = _.$slides;
2020
2021        _.reinit();
2022
2023    };
2024
2025    Slick.prototype.setCSS = function(position) {
2026
2027        var _ = this,
2028            positionProps = {},
2029            x, y;
2030
2031        if (_.options.rtl === true) {
2032            position = -position;
2033        }
2034        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
2035        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
2036
2037        positionProps[_.positionProp] = position;
2038
2039        if (_.transformsEnabled === false) {
2040            _.$slideTrack.css(positionProps);
2041        } else {
2042            positionProps = {};
2043            if (_.cssTransitions === false) {
2044                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
2045                _.$slideTrack.css(positionProps);
2046            } else {
2047                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
2048                _.$slideTrack.css(positionProps);
2049            }
2050        }
2051
2052    };
2053
2054    Slick.prototype.setDimensions = function() {
2055
2056        var _ = this;
2057
2058        if (_.options.vertical === false) {
2059            if (_.options.centerMode === true) {
2060                _.$list.css({
2061                    padding: ('0px ' + _.options.centerPadding)
2062                });
2063            }
2064        } else {
2065            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
2066            if (_.options.centerMode === true) {
2067                _.$list.css({
2068                    padding: (_.options.centerPadding + ' 0px')
2069                });
2070            }
2071        }
2072
2073        _.listWidth = _.$list.width();
2074        _.listHeight = _.$list.height();
2075
2076
2077        if (_.options.vertical === false && _.options.variableWidth === false) {
2078            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
2079            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
2080
2081        } else if (_.options.variableWidth === true) {
2082            _.$slideTrack.width(5000 * _.slideCount);
2083        } else {
2084            _.slideWidth = Math.ceil(_.listWidth);
2085            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
2086        }
2087
2088        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
2089        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
2090
2091    };
2092
2093    Slick.prototype.setFade = function() {
2094
2095        var _ = this,
2096            targetLeft;
2097
2098        _.$slides.each(function(index, element) {
2099            targetLeft = (_.slideWidth * index) * -1;
2100            if (_.options.rtl === true) {
2101                $(element).css({
2102                    position: 'relative',
2103                    right: targetLeft,
2104                    top: 0,
2105                    zIndex: _.options.zIndex - 2,
2106                    opacity: 0
2107                });
2108            } else {
2109                $(element).css({
2110                    position: 'relative',
2111                    left: targetLeft,
2112                    top: 0,
2113                    zIndex: _.options.zIndex - 2,
2114                    opacity: 0
2115                });
2116            }
2117        });
2118
2119        _.$slides.eq(_.currentSlide).css({
2120            zIndex: _.options.zIndex - 1,
2121            opacity: 1
2122        });
2123
2124    };
2125
2126    Slick.prototype.setHeight = function() {
2127
2128        var _ = this;
2129
2130        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
2131            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
2132            _.$list.css('height', targetHeight);
2133        }
2134
2135    };
2136
2137    Slick.prototype.setOption =
2138    Slick.prototype.slickSetOption = function() {
2139
2140        /**
2141         * accepts arguments in format of:
2142         *
2143         *  - for changing a single option's value:
2144         *     .slick("setOption", option, value, refresh )
2145         *
2146         *  - for changing a set of responsive options:
2147         *     .slick("setOption", 'responsive', [{}, ...], refresh )
2148         *
2149         *  - for updating multiple values at once (not responsive)
2150         *     .slick("setOption", { 'option': value, ... }, refresh )
2151         */
2152
2153        var _ = this, l, item, option, value, refresh = false, type;
2154
2155        if( $.type( arguments[0] ) === 'object' ) {
2156
2157            option =  arguments[0];
2158            refresh = arguments[1];
2159            type = 'multiple';
2160
2161        } else if ( $.type( arguments[0] ) === 'string' ) {
2162
2163            option =  arguments[0];
2164            value = arguments[1];
2165            refresh = arguments[2];
2166
2167            if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
2168
2169                type = 'responsive';
2170
2171            } else if ( typeof arguments[1] !== 'undefined' ) {
2172
2173                type = 'single';
2174
2175            }
2176
2177        }
2178
2179        if ( type === 'single' ) {
2180
2181            _.options[option] = value;
2182
2183
2184        } else if ( type === 'multiple' ) {
2185
2186            $.each( option , function( opt, val ) {
2187
2188                _.options[opt] = val;
2189
2190            });
2191
2192
2193        } else if ( type === 'responsive' ) {
2194
2195            for ( item in value ) {
2196
2197                if( $.type( _.options.responsive ) !== 'array' ) {
2198
2199                    _.options.responsive = [ value[item] ];
2200
2201                } else {
2202
2203                    l = _.options.responsive.length-1;
2204
2205                    // loop through the responsive object and splice out duplicates.
2206                    while( l >= 0 ) {
2207
2208                        if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
2209
2210                            _.options.responsive.splice(l,1);
2211
2212                        }
2213
2214                        l--;
2215
2216                    }
2217
2218                    _.options.responsive.push( value[item] );
2219
2220                }
2221
2222            }
2223
2224        }
2225
2226        if ( refresh ) {
2227
2228            _.unload();
2229            _.reinit();
2230
2231        }
2232
2233    };
2234
2235    Slick.prototype.setPosition = function() {
2236
2237        var _ = this;
2238
2239        _.setDimensions();
2240
2241        _.setHeight();
2242
2243        if (_.options.fade === false) {
2244            _.setCSS(_.getLeft(_.currentSlide));
2245        } else {
2246            _.setFade();
2247        }
2248
2249        _.$slider.trigger('setPosition', [_]);
2250
2251    };
2252
2253    Slick.prototype.setProps = function() {
2254
2255        var _ = this,
2256            bodyStyle = document.body.style;
2257
2258        _.positionProp = _.options.vertical === true ? 'top' : 'left';
2259
2260        if (_.positionProp === 'top') {
2261            _.$slider.addClass('slick-vertical');
2262        } else {
2263            _.$slider.removeClass('slick-vertical');
2264        }
2265
2266        if (bodyStyle.WebkitTransition !== undefined ||
2267            bodyStyle.MozTransition !== undefined ||
2268            bodyStyle.msTransition !== undefined) {
2269            if (_.options.useCSS === true) {
2270                _.cssTransitions = true;
2271            }
2272        }
2273
2274        if ( _.options.fade ) {
2275            if ( typeof _.options.zIndex === 'number' ) {
2276                if( _.options.zIndex < 3 ) {
2277                    _.options.zIndex = 3;
2278                }
2279            } else {
2280                _.options.zIndex = _.defaults.zIndex;
2281            }
2282        }
2283
2284        if (bodyStyle.OTransform !== undefined) {
2285            _.animType = 'OTransform';
2286            _.transformType = '-o-transform';
2287            _.transitionType = 'OTransition';
2288            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2289        }
2290        if (bodyStyle.MozTransform !== undefined) {
2291            _.animType = 'MozTransform';
2292            _.transformType = '-moz-transform';
2293            _.transitionType = 'MozTransition';
2294            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
2295        }
2296        if (bodyStyle.webkitTransform !== undefined) {
2297            _.animType = 'webkitTransform';
2298            _.transformType = '-webkit-transform';
2299            _.transitionType = 'webkitTransition';
2300            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2301        }
2302        if (bodyStyle.msTransform !== undefined) {
2303            _.animType = 'msTransform';
2304            _.transformType = '-ms-transform';
2305            _.transitionType = 'msTransition';
2306            if (bodyStyle.msTransform === undefined) _.animType = false;
2307        }
2308        if (bodyStyle.transform !== undefined && _.animType !== false) {
2309            _.animType = 'transform';
2310            _.transformType = 'transform';
2311            _.transitionType = 'transition';
2312        }
2313        _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
2314    };
2315
2316
2317    Slick.prototype.setSlideClasses = function(index) {
2318
2319        var _ = this,
2320            centerOffset, allSlides, indexOffset, remainder;
2321
2322        allSlides = _.$slider
2323            .find('.slick-slide')
2324            .removeClass('slick-active slick-center slick-current')
2325            .attr('aria-hidden', 'true');
2326
2327        _.$slides
2328            .eq(index)
2329            .addClass('slick-current');
2330
2331        if (_.options.centerMode === true) {
2332
2333            

2426            _.options.centerMode = false;
2427        }
2428
2429        if (_.options.infinite === true && _.options.fade === false) {
2430
2431            slideIndex = null;
2432
2433            if (_.slideCount > _.options.slidesToShow) {
2434
2435                if (_.options.centerMode === true) {
2436                    infiniteCount = _.options.slidesToShow + 1;
2437                } else {
2438                    infiniteCount = _.options.slidesToShow;
2439                }
2440
2441                for (i = _.slideCount; i > (_.slideCount -
2442                        infiniteCount); i -= 1) {
2443                    slideIndex = i - 1;
2444                    $(_.$slides[slideIndex]).clone(true).attr('id', '')
2445                        .attr('data-slick-index', slideIndex - _.slideCount)
2446                        .prependTo(_.$slideTrack).addClass('slick-cloned');
2447                }
2448                for (i = 0; i < infiniteCount; i += 1) {
2449                    slideIndex = i;
2450                    $(_.$slides[slideIndex]).clone(true).attr('id', '')
2451                        .attr('data-slick-index', slideIndex + _.slideCount)
2452                        .appendTo(_.$slideTrack).addClass('slick-cloned');
2453                }
2454                _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
2455                    $(this).attr('id', '');
2456                });
2457
2458            }
2459
2460        }
2461
2462    };
2463
2464    Slick.prototype.interrupt = function( toggle ) {
2465
2466        var _ = this;
2467
2468        if( !toggle ) {
2469            _.autoPlay();
2470        }
2471        _.interrupted = toggle;
2472
2473    };
2474
2475    Slick.prototype.selectHandler = function(event) {
2476
2477        var _ = this;
2478
2479        var targetElement =
2480            $(event.target).is('.slick-slide') ?
2481                $(event.target) :
2482                $(event.target).parents('.slick-slide');
2483
2484        var index = parseInt(targetElement.attr('data-slick-index'));
2485
2486        if (!index) index = 0;
2487
2488        if (_.slideCount <= _.options.slidesToShow) {
2489
2490            _.setSlideClasses(index);
2491            _.asNavFor(index);
2492            return;
2493
2494        }
2495
2496        _.slideHandler(index);
2497
2498    };
2499
2500    Slick.prototype.slideHandler = function(index, sync, dontAnimate) {
2501
2502        var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
2503            _ = this, navTarget;
2504
2505        sync = sync || false;
2506
2507        if (_.animating === true && _.options.waitForAnimate === true) {
2508            return;
2509        }
2510
2511        if (_.options.fade === true && _.currentSlide === index) {
2512            return;
2513        }
2514
2515        if (_.slideCount <= _.options.slidesToShow) {
2516            return;
2517        }
2518
2519        if (sync === false) {
2520            _.asNavFor(index);
2521        }
2522
2523        targetSlide = index;
2524        targetLeft = _.getLeft(targetSlide);
2525        slideLeft = _.getLeft(_.currentSlide);
2526
2527        _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
2528
2529        if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
2530            if (_.options.fade === false) {
2531                targetSlide = _.currentSlide;
2532                if (dontAnimate !== true) {
2533                    _.animateSlide(slideLeft, function() {
2534                        _.postSlide(targetSlide);
2535                    });
2536                } else {
2537                    _.postSlide(targetSlide);
2538                }
2539            }
2540            return;
2541        } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
2542            if (_.options.fade === false) {
2543                targetSlide = _.currentSlide;
2544                if (dontAnimate !== true) {
2545                    _.animateSlide(slideLeft, function() {
2546                        _.postSlide(targetSlide);
2547                    });
2548                } else {
2549                    _.postSlide(targetSlide);
2550                }
2551            }
2552            return;
2553        }
2554
2555        if ( _.options.autoplay ) {
2556            clearInterval(_.autoPlayTimer);
2557        }
2558
2559        if (targetSlide < 0) {
2560            if (_.slideCount % _.options.slidesToScroll !== 0) {
2561                animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
2562            } else {
2563                animSlide = _.slideCount + targetSlide;
2564            }
2565        } else if (targetSlide >= _.slideCount) {
2566            if (_.slideCount % _.options.slidesToScroll !== 0) {
2567                animSlide = 0;
2568            } else {
2569                animSlide = targetSlide - _.slideCount;
2570            }
2571        } else {
2572            animSlide = targetSlide;
2573        }
2574
2575        _.animating = true;
2576
2577        _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);
2578
2579        oldSlide = _.currentSlide;
2580        _.currentSlide = animSlide;
2581
2582        _.setSlideClasses(_.currentSlide);
2583
2584        if ( _.options.asNavFor ) {
2585
2586            navTarget = _.getNavTarget();
2587            navTarget = navTarget.slick('getSlick');
2588
2589            if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {
2590                navTarget.setSlideClasses(_.currentSlide);
2591            }
2592
2593        }
2594
2595        _.updateDots();
2596        _.updateArrows();
2597
2598        if (_.options.fade === true) {
2599            if (dontAnimate !== true) {
2600
2601                _.fadeSlideOut(oldSlide);
2602
2603                _.fadeSlide(animSlide, function() {
2604                    _.postSlide(animSlide);
2605                });
2606
2607            } else {
2608                _.postSlide(animSlide);
2609            }
2610            _.animateHeight();
2611            return;
2612        }
2613
2614        if (dontAnimate !== true) {
2615            _.animateSlide(targetLeft, function() {
2616                _.postSlide(animSlide);
2617            });
2618        } else {
2619            _.postSlide(animSlide);
2620        }
2621
2622    };
2623
2624    Slick.prototype.startLoad = function() {
2625
2626        var _ = this;
2627
2628        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2629
2630            _.$prevArrow.hide();
2631            _.$nextArrow.hide();
2632
2633        }
2634
2635        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2636
2637            _.$dots.hide();
2638
2639        }
2640
2641        _.$slider.addClass('slick-loading');
2642
2643    };
2644
2645    Slick.prototype.swipeDirection = function() {
2646
2647        var xDist, yDist, r, swipeAngle, _ = this;
2648
2649        xDist = _.touchObject.startX - _.touchObject.curX;
2650        yDist = _.touchObject.startY - _.touchObject.curY;
2651        r = Math.atan2(yDist, xDist);
2652
2653        swipeAngle = Math.round(r * 180 / Math.PI);
2654        if (swipeAngle < 0) {
2655            swipeAngle = 360 - Math.abs(swipeAngle);
2656        }
2657
2658        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
2659            return (_.options.rtl === false ? 'left' : 'right');
2660        }
2661        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
2662            return (_.options.rtl === false ? 'left' : 'right');
2663        }
2664        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
2665            return (_.options.rtl === false ? 'right' : 'left');
2666        }
2667        if (_.options.verticalSwiping === true) {
2668            if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
2669                return 'down';
2670            } else {
2671                return 'up';
2672            }
2673        }
2674
2675        return 'vertical';
2676
2677    };
2678
2679    Slick.prototype.swipeEnd = function(event) {
2680
2681        var _ = this,
2682            slideCount,
2683            direction;
2684
2685        _.dragging = false;
2686        _.interrupted = false;
2687        _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;
2688
2689        if ( _.touchObject.curX === undefined ) {
2690            return false;
2691        }
2692
2693        if ( _.touchObject.edgeHit === true ) {
2694            _.$slider.trigger('edge', [_, _.swipeDirection() ]);
2695        }
2696
2697        if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
2698
2699            direction = _.swipeDirection();
2700
2701            switch ( direction ) {
2702
2703                case 'left':
2704                case 'down':
2705
2706                    slideCount =
2707                        _.options.swipeToSlide ?
2708                            _.checkNavigable( _.currentSlide + _.getSlideCount() ) :
2709                            _.currentSlide + _.getSlideCount();
2710
2711                    _.currentDirection = 0;
2712
2713                    break;
2714
2715                case 'right':
2716                case 'up':
2717
2718                    slideCount =
2719                        _.options.swipeToSlide ?
2720                            _.checkNavigable( _.currentSlide - _.getSlideCount() ) :
2721                            _.currentSlide - _.getSlideCount();
2722
2723                    _.currentDirection = 1;
2724
2725                    break;
2726
2727                default:
2728
2729
2730            }
2731
2732            if( direction != 'vertical' ) {
2733
2734                _.slideHandler( slideCount );
2735                _.touchObject = {};
2736                _.$slider.trigger('swipe', [_, direction ]);
2737
2738            }
2739
2740        } else {
2741
2742            if ( _.touchObject.startX !== _.touchObject.curX ) {
2743
2744                _.slideHandler( _.currentSlide );
2745                _.touchObject = {};
2746
2747            }
2748
2749        }
2750
2751    };
2752
2753    Slick.prototype.swipeHandler = function(event) {
2754
2755        var _ = this;
2756
2757        if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
2758            return;
2759        } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
2760            return;
2761        }
2762
2763        _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
2764            event.originalEvent.touches.length : 1;
2765
2766        _.touchObject.minSwipe = _.listWidth / _.options
2767            .touchThreshold;
2768
2769        if (_.options.verticalSwiping === true) {
2770            _.touchObject.minSwipe = _.listHeight / _.options
2771                .touchThreshold;
2772        }
2773
2774        switch (event.data.action) {
2775
2776            case 'start':
2777                _.swipeStart(event);
2778                break;
2779
2780            case 'move':
2781                _.swipeMove(event);
2782                break;
2783
2784            case 'end':
2785                _.swipeEnd(event);
2786                break;
2787
2788        }
2789
2790    };
2791
2792    Slick.prototype.swipeMove = function(event) {
2793
2794        var _ = this,
2795            edgeWasHit = false,
2796            curLeft, swipeDirection, swipeLength, positionOffset, touches;
2797
2798        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
2799
2800        if (!_.dragging || touches && touches.length !== 1) {
2801            return false;
2802        }
2803
2804        curLeft = _.getLeft(_.currentSlide);
2805
2806        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
2807        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
2808
2809        _.touchObject.swipeLength = Math.round(Math.sqrt(
2810            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
2811
2812        if (_.options.verticalSwiping === true) {
2813            _.touchObject.swipeLength = Math.round(Math.sqrt(
2814                Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
2815        }
2816
2817        swipeDirection = _.swipeDirection();
2818
2819        if (swipeDirection === 'vertical') {
2820            return;
2821        }
2822
2823        if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
2824            event.preventDefault();
2825        }
2826
2827        positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
2828        if (_.options.verticalSwiping === true) {
2829            positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
2830        }
2831
2832
2833        swipeLength = _.touchObject.swipeLength;
2834
2835        _.touchObject.edgeHit = false;
2836
2837        if (_.options.infinite === false) {
2838            if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
2839                swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
2840                _.touchObject.edgeHit = true;
2841            }
2842        }
2843
2844        if (_.options.vertical === false) {
2845            _.swipeLeft = curLeft + swipeLength * positionOffset;
2846        } else {
2847            _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
2848        }
2849        if (_.options.verticalSwiping === true) {
2850            _.swipeLeft = curLeft + swipeLength * positionOffset;
2851        }
2852
2853        if (_.options.fade === true || _.options.touchMove === false) {
2854            return false;
2855        }
2856
2857        if (_.animating === true) {
2858            _.swipeLeft = null;
2859            return false;
2860        }
2861
2862        _.setCSS(_.swipeLeft);
2863
2864    };
2865
2866    Slick.prototype.swipeStart = function(event) {
2867
2868        var _ = this,
2869            touches;
2870
2871        _.interrupted = true;
2872
2873        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
2874            _.touchObject = {};
2875            return false;
2876        }
2877
2878        if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
2879            touches = event.originalEvent.touches[0];
2880        }
2881
2882        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
2883        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
2884
2885        _.dragging = true;
2886
2887    };
2888
2889    Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
2890
2891        var _ = this;
2892
2893        if (_.$slidesCache !== null) {
2894
2895            _.unload();
2896
2897            _.$slideTrack.children(this.options.slide).detach();
2898
2899            _.$slidesCache.appendTo(_.$slideTrack);
2900
2901            _.reinit();
2902
2903        }
2904
2905    };
2906
2907    Slick.prototype.unload = function() {
2908
2909        var _ = this;
2910
2911        $('.slick-cloned', _.$slider).remove();
2912
2913        if (_.$dots) {
2914            _.$dots.remove();
2915        }
2916
2917        if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
2918            _.$prevArrow.remove();
2919        }
2920
2921        if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
2922            _.$nextArrow.remove();
2923        }
2924
2925        _.$slides
2926            .removeClass('slick-slide slick-active slick-visible slick-current')
2927            .attr('aria-hidden', 'true')
2928            .css('width', '');
2929
2930    };
2931
2932    Slick.prototype.unslick = function(fromBreakpoint) {
2933
2934        var _ = this;
2935        _.$slider.trigger('unslick', [_, fromBreakpoint]);
2936        _.destroy();
2937
2938    };
2939
2940    Slick.prototype.updateArrows = function() {
2941
2942        var _ = this,
2943            centerOffset;
2944
2945        centerOffset = Math.floor(_.options.slidesToShow / 2);
2946
2947        if ( _.options.arrows === true &&
2948            _.slideCount > _.options.slidesToShow &&
2949            !_.options.infinite ) {
2950
2951            _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2952            _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2953
2954            if (_.currentSlide === 0) {
2955
2956                _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2957                _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2958
2959            } else if (_.currentSlide >