https://dbbooks.co.kr/ind-script/optimizer_user.php?filename=jc_LD…8a835d47475e9b9ddd9660e&t=1756948705&user=T

472,
473                $list: null,
474                touchObject: {},
475                transformsEnabled: false,
476                unslicked: false
477            };
478
479            $.extend(_, _.initials);
480
481            _.activeBreakpoint = null;
482            _.animType = null;
483            _.animProp = null;
484            _.breakpoints = [];
485            _.breakpointSettings = [];
486            _.cssTransitions = false;
487            _.focussed = false;
488            _.interrupted = false;
489            _.hidden = 'hidden';
490            _.paused = true;
491            _.positionProp = null;
492            _.respondTo = null;
493            _.rowCount = 1;
494            _.shouldClick = true;
495            _.$slider = $(element);
496            _.$slidesCache = null;
497            _.transformType = null;
498            _.transitionType = null;
499            _.visibilityChange = 'visibilitychange';
500            _.windowWidth = 0;
501            _.windowTimer = null;
502
503            dataSettings = $(element).data('slick') || {};
504
505            _.options = $.extend({}, _.defaults, settings, dataSettings);
506
507            _.currentSlide = _.options.initialSlide;
508
509            _.originalSettings = _.options;
510
511            if (typeof document.mozHidden !== 'undefined') {
512                _.hidden = 'mozHidden';
513                _.visibilityChange = 'mozvisibilitychange';
514            } else if (typeof document.webkitHidden !== 'undefined') {
515                _.hidden = 'webkitHidden';
516                _.visibilityChange = 'webkitvisibilitychange';
517            }
518
519            _.autoPlay = $.proxy(_.autoPlay, _);
520            _.autoPlayClear = $.proxy(_.autoPlayClear, _);
521            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
522            _.changeSlide = $.proxy(_.changeSlide, _);
523            _.clickHandler = $.proxy(_.clickHandler, _);
524            _.selectHandler = $.proxy(_.selectHandler, _);
525            _.setPosition = $.proxy(_.setPosition, _);
526            _.swipeHandler = $.proxy(_.swipeHandler, _);
527            _.dragHandler = $.proxy(_.dragHandler, _);
528            _.keyHandler = $.proxy(_.keyHandler, _);
529
530            _.instanceUid = instanceUid++;
531
532            // A simple way to check for HTML strings
533            // Strict HTML recognition (must start with <)
534            // Extracted from jQuery v1.11 source
535            _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
536
537
538            _.registerBreakpoints();
539            _.init(true);
540
541        }
542
543        return Slick;
544
545    }());
546
547    Slick.prototype.activateADA = function() {
548        var _ = this;
549
550        _.$slideTrack.find('.slick-active').attr({
551            'aria-hidden': 'false'
552        }).find('a, input, button, select').attr({
553            'tabindex': '0'
554        });
555
556    };
557
558    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
559
560        var _ = this;
561
562        if (typeof(index) === 'boolean') {
563            addBefore = index;
564            index = null;
565        } else if (index < 0 || (index >= _.slideCount)) {
566            return false;
567        }
568
569        _.unload();
570
571        if (typeof(index) === 'number') {
572            if (index === 0 && _.$slides.length === 0) {
573                $(markup).appendTo(_.$slideTrack);
574            } else if (addBefore) {
575                $(markup).insertBefore(_.$slides.eq(index));
576            } else {
577                $(markup).insertAfter(_.$slides.eq(index));
578            }
579        } else {
580            if (addBefore === true) {
581                $(markup).prependTo(_.$slideTrack);
582            } else {
583                $(markup).appendTo(_.$slideTrack);
584            }
585        }
586
587        _.$slides = _.$slideTrack.children(this.options.slide);
588
589        _.$slideTrack.children(this.options.slide).detach();
590
591        _.$slideTrack.append(_.$slides);
592
593        _.$slides.each(function(index, element) {
594            $(element).attr('data-slick-index', index);
595        });
596
597        _.$slidesCache = _.$slides;
598
599        _.reinit();
600
601    };
602
603    Slick.prototype.animateHeight = function() {
604        var _ = this;
605        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
606            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
607            _.$list.animate({
608                height: targetHeight
609            }, _.options.speed);
610        }
611    };
612
613    Slick.prototype.animateSlide = function(targetLeft, callback) {
614
615        var animProps = {},
616            _ = this;
617
618        _.animateHeight();
619
620        if (_.options.rtl === true && _.options.vertical === false) {
621            targetLeft = -targetLeft;
622        }
623        if (_.transformsEnabled === false) {
624            if (_.options.vertical === false) {
625                _.$slideTrack.animate({
626                    left: targetLeft
627                }, _.options.speed, _.options.easing, callback);
628            } else {
629                _.$slideTrack.animate({
630                    top: targetLeft
631                }, _.options.speed, _.options.easing, callback);
632            }
633
634        } else {
635
636            if (_.cssTransitions === false) {
637                if (_.options.rtl === true) {
638                    _.currentLeft = -(_.currentLeft);
639                }
640                $({
641                    animStart: _.currentLeft
642                }).animate({
643                    animStart: targetLeft
644                }, {
645                    duration: _.options.speed,
646                    easing: _.options.easing,
647                    step: function(now) {
648                        now = Math.ceil(now);
649                        if (_.options.vertical === false) {
650                            animProps[_.animType] = 'translate(' +
651                                now + 'px, 0px)';
652                            _.$slideTrack.css(animProps);
653                        } else {
654                            animProps[_.animType] = 'translate(0px,' +
655                                now + 'px)';
656                            _.$slideTrack.css(animProps);
657                        }
658                    },
659                    complete: function() {
660                        if (callback) {
661                            callback.call();
662                        }
663                    }
664                });
665
666            } else {
667
668                _.applyTransition();
669                targetLeft = Math.ceil(targetLeft);
670
671                if (_.options.vertical === false) {
672                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
673                } else {
674                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
675                }
676                _.$slideTrack.css(animProps);
677
678                if (callback) {
679                    setTimeout(function() {
680
681                        _.disableTransition();
682
683                        callback.call();
684                    }, _.options.speed);
685                }
686
687            }
688
689        }
690
691    };
692
693    Slick.prototype.getNavTarget = function() {
694
695        var _ = this,
696            asNavFor = _.options.asNavFor;
697
698        if ( asNavFor && asNavFor !== null ) {
699            asNavFor = $(asNavFor).not(_.$slider);
700        }
701
702        return asNavFor;
703
704    };
705
706    Slick.prototype.asNavFor = function(index) {
707
708        var _ = this,
709            asNavFor = _.getNavTarget();
710
711        if ( asNavFor !== null && typeof asNavFor === 'object' ) {
712            asNavFor.each(function() {
713                var target = $(this).slick('getSlick');
714                if(!target.unslicked) {
715                    target.slideHandler(index, true);
716                }
717            });
718        }
719
720    };
721
722    Slick.prototype.applyTransition = function(slide) {
723
724        var _ = this,
725            transition = {};
726
727        if (_.options.fade === false) {
728            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
729        } else {
730            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
731        }
732
733        if (_.options.fade === false) {
734            _.$slideTrack.css(transition);
735        } else {
736            _.$slides.eq(slide).css(transition);
737        }
738
739    };
740
741    Slick.prototype.autoPlay = function() {
742
743        var _ = this;
744
745        _.autoPlayClear();
746
747        if ( _.slideCount > _.options.slidesToShow ) {
748            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
749        }
750
751    };
752
753    Slick.prototype.autoPlayClear = function() {
754
755        var _ = this;
756
757        if (_.autoPlayTimer) {
758            clearInterval(_.autoPlayTimer);
759        }
760
761    };
762
763    Slick.prototype.autoPlayIterator = function() {
764
765        var _ = this,
766            slideTo = _.currentSlide + _.options.slidesToScroll;
767
768        if ( !_.paused && !_.interrupted && !_.focussed ) {
769
770            if ( _.options.infinite === false ) {
771
772                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
773                    _.direction = 0;
774                }
775
776                else if ( _.direction === 0 ) {
777
778                    slideTo = _.currentSlide - _.options.slidesToScroll;
779
780                    if ( _.currentSlide - 1 === 0 ) {
781                        _.direction = 1;
782                    }
783
784                }
785
786            }
787
788            _.slideHandler( slideTo );
789
790        }
791
792    };
793
794    Slick.prototype.buildArrows = function() {
795
796        var _ = this;
797
798        if (_.options.arrows === true ) {
799
800            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
801            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
802
803            if( _.slideCount > _.options.slidesToShow ) {
804
805                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
806                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
807
808                if (_.htmlExpr.test(_.options.prevArrow)) {
809                    _.$prevArrow.prependTo(_.options.appendArrows);
810                }
811
812                if (_.htmlExpr.test(_.options.nextArrow)) {
813                    _.$nextArrow.appendTo(_.options.appendArrows);
814                }
815
816                if (_.options.infinite !== true) {
817                    _.$prevArrow
818                        .addClass('slick-disabled')
819                        .attr('aria-disabled', 'true');
820                }
821
822            } else {
823
824                _.$prevArrow.add( _.$nextArrow )
825
826                    .addClass('slick-hidden')
827                    .attr({
828                        'aria-disabled': 'true',
829                        'tabindex': '-1'
830                    });
831
832            }
833
834        }
835
836    };
837
838    Slick.prototype.buildDots = function() {
839
840        var _ = this,
841            i, dot;
842
843        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
844
845            _.$slider.addClass('slick-dotted');
846
847            dot = $('<ul />').addClass(_.options.dotsClass);
848
849            for (i = 0; i <= _.getDotCount(); i += 1) {
850                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
851            }
852
853            _.$dots = dot.appendTo(_.options.appendDots);
854
855            _.$dots.find('li').first().addClass('slick-active')

855.attr('aria-hidden', 'false');
856
857        }
858
859    };
860
861    Slick.prototype.buildOut = function() {
862
863        var _ = this;
864
865        _.$slides =
866            _.$slider
867                .children( _.options.slide + ':not(.slick-cloned)')
868                .addClass('slick-slide');
869
870        _.slideCount = _.$slides.length;
871
872        _.$slides.each(function(index, element) {
873            $(element)
874                .attr('data-slick-index', index)
875                .data('originalStyling', $(element).attr('style') || '');
876        });
877
878        _.$slider.addClass('slick-slider');
879
880        _.$slideTrack = (_.slideCount === 0) ?
881            $('<div class="slick-track"/>').appendTo(_.$slider) :
882            _.$slides.wrapAll('<div class="slick-track"/>').parent();
883
884        _.$list = _.$slideTrack.wrap(
885            '<div aria-live="polite" class="slick-list"/>').parent();
886        _.$slideTrack.css('opacity', 0);
887
888        if (_.options.centerMode === true || _.options.swipeToSlide === true) {
889            _.options.slidesToScroll = 1;
890        }
891
892        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
893
894        _.setupInfinite();
895
896        _.buildArrows();
897
898        _.buildDots();
899
900        _.updateDots();
901
902
903        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
904
905        if (_.options.draggable === true) {
906            _.$list.addClass('draggable');
907        }
908
909    };
910
911    Slick.prototype.buildRows = function() {
912
913        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
914
915        newSlides = document.createDocumentFragment();
916        originalSlides = _.$slider.children();
917
918        if(_.options.rows > 1) {
919
920            slidesPerSection = _.options.slidesPerRow * _.options.rows;
921            numOfSlides = Math.ceil(
922                originalSlides.length / slidesPerSection
923            );
924
925            for(a = 0; a < numOfSlides; a++){
926                var slide = document.createElement('div');
927                for(b = 0; b < _.options.rows; b++) {
928                    var row = document.createElement('div');
929                    for(c = 0; c < _.options.slidesPerRow; c++) {
930                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
931                        if (originalSlides.get(target)) {
932                            row.appendChild(originalSlides.get(target));
933                        }
934                    }
935                    slide.appendChild(row);
936                }
937                newSlides.appendChild(slide);
938            }
939
940            _.$slider.empty().append(newSlides);
941            _.$slider.children().children().children()
942                .css({
943                    'width':(100 / _.options.slidesPerRow) + '%',
944                    'display': 'inline-block'
945                });
946
947        }
948
949    };
950
951    Slick.prototype.checkResponsive = function(initial, forceUpdate) {
952
953        var _ = this,
954            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
955        var sliderWidth = _.$slider.width();
956        var windowWidth = window.innerWidth || $(window).width();
957
958        if (_.respondTo === 'window') {
959            respondToWidth = windowWidth;
960        } else if (_.respondTo === 'slider') {
961            respondToWidth = sliderWidth;
962        } else if (_.respondTo === 'min') {
963            respondToWidth = Math.min(windowWidth, sliderWidth);
964        }
965
966        if ( _.options.responsive &&
967            _.options.responsive.length &&
968            _.options.responsive !== null) {
969
970            targetBreakpoint = null;
971
972            for (breakpoint in _.breakpoints) {
973                if (_.breakpoints.hasOwnProperty(breakpoint)) {
974                    if (_.originalSettings.mobileFirst === false) {
975                        if (respondToWidth < _.breakpoints[breakpoint]) {
976                            targetBreakpoint = _.breakpoints[breakpoint];
977                        }
978                    } else {
979                        if (respondToWidth > _.breakpoints[breakpoint]) {
980                            targetBreakpoint = _.breakpoints[breakpoint];
981                        }
982                    }
983                }
984            }
985
986            if (targetBreakpoint !== null) {
987                if (_.activeBreakpoint !== null) {
988                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
989                        _.activeBreakpoint =
990                            targetBreakpoint;
991                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
992                            _.unslick(targetBreakpoint);
993                        } else {
994                            _.options = $.extend({}, _.originalSettings,
995                                _.breakpointSettings[
996                                    targetBreakpoint]);
997                            if (initial === true) {
998                                _.currentSlide = _.options.initialSlide;
999                            }
1000                            _.refresh(initial);
1001                        }
1002                        triggerBreakpoint = targetBreakpoint;
1003                    }
1004                } else {
1005                    _.activeBreakpoint = targetBreakpoint;
1006                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
1007                        _.unslick(targetBreakpoint);
1008                    } else {
1009                        _.options = $.extend({}, _.originalSettings,
1010                            _.breakpointSettings[
1011                                targetBreakpoint]);
1012                        if (initial === true) {
1013                            _.currentSlide = _.options.initialSlide;
1014                        }
1015                        _.refresh(initial);
1016                    }
1017                    triggerBreakpoint = targetBreakpoint;
1018                }
1019            } else {
1020                if (_.activeBreakpoint !== null) {
1021                    _.activeBreakpoint = null;
1022                    _.options = _.originalSettings;
1023                    if (initial === true) {
1024                        _.currentSlide = _.options.initialSlide;
1025                    }
1026                    _.refresh(initial);
1027                    triggerBreakpoint = targetBreakpoint;
1028                }
1029            }
1030
1031            // only trigger breakpoints during an actual break. not on initialize.
1032            if( !initial && triggerBreakpoint !== false ) {
1033                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
1034            }
1035        }
1036
1037    };
1038
1039    Slick.prototype.changeSlide = function(event, dontAnimate) {
1040
1041        var _ = this,
1042            $target = $(event.currentTarget),
1043            indexOffset, slideOffset, unevenOffset;
1044
1045        // If target is a link, prevent default action.
1046        if($target.is('a')) {
1047            event.preventDefault();
1048        }
1049
1050        // If target is not the <li> element (ie: a child), find the <li>.
1051        if(!$target.is('li')) {
1052            $target = $target.closest('li');
1053        }
1054
1055        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
1056        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
1057
1058        switch (event.data.message) {
1059
1060            case 'previous':
1061                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
1062                if (_.slideCount > _.options.slidesToShow) {
1063                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
1064                }
1065                break;
1066
1067            case 'next':
1068                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
1069                if (_.slideCount > _.options.slidesToShow) {
1070                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
1071                }
1072                break;
1073
1074            case 'index':
1075                var index = event.data.index === 0 ? 0 :
1076                    event.data.index || $target.index() * _.options.slidesToScroll;
1077
1078                _.slideHandler(_.checkNavigable(index), false, dontAnimate);
1079                $target.children().trigger('focus');
1080                break;
1081
1082            default:
1083                return;
1084        }
1085
1086    };
1087
1088    Slick.prototype.checkNavigable = function(index) {
1089
1090        var _ = this,
1091            navigables, prevNavigable;
1092
1093        navigables = _.getNavigableIndexes();
1094        prevNavigable = 0;
1095        if (index > navigables[navigables.length - 1]) {
1096            index = navigables[navigables.length - 1];
1097        } else {
1098            for (var n in navigables) {
1099                if (index < navigables[n]) {
1100                    index = prevNavigable;
1101                    break;
1102                }
1103                prevNavigable = navigables[n];
1104            }
1105        }
1106
1107        return index;
1108    };
1109
1110    Slick.prototype.cleanUpEvents = function() {
1111
1112        var _ = this;
1113
1114        if (_.options.dots && _.$dots !== null) {
1115
1116            $('li', _.$dots)
1117                .off('click.slick', _.changeSlide)
1118                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
1119                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
1120
1121        }
1122
1123        _.$slider.off('focus.slick blur.slick');
1124
1125        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1126            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
1127            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
1128        }
1129
1130        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
1131        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
1132        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
1133        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
1134
1135        _.$list.off('click.slick', _.clickHandler);
1136
1137        $(document).off(_.visibilityChange, _.visibility);
1138
1139        _.cleanUpSlideEvents();
1140
1141        if (_.options.accessibility === true) {
1142            _.$list.off('keydown.slick', _.keyHandler);
1143        }
1144
1145        if (_.options.focusOnSelect === true) {
1146            $(_.$slideTrack).children().off('click.slick', _.selectHandler);
1147        }
1148
1149        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
1150
1151        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
1152
1153        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
1154
1155        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
1156        $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);
1157
1158    };
1159
1160    Slick.prototype.cleanUpSlideEvents = function() {
1161
1162        var _ = this;
1163
1164        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
1165        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
1166
1167    };
1168
1169    Slick.prototype.cleanUpRows = function() {
1170
1171        var _ = this, originalSlides;
1172
1173        if(_.options.rows > 1) {
1174            originalSlides = _.$slides.children().children();
1175            originalSlides.removeAttr('style');
1176            _.$slider.empty().append(originalSlides);
1177        }
1178
1179    };
1180
1181    Slick.prototype.clickHandler = function(event) {
1182
1183        var _ = this;
1184
1185        if (_.shouldClick === false) {
1186            event.stopImmediatePropagation();
1187            event.stopPropagation();
1188            event.preventDefault();
1189        }
1190
1191    };
1192
1193    Slick.prototype.destroy = function(refresh) {
1194
1195        var _ = this;
1196
1197        _.autoPlayClear();
1198
1199        _.touchObject = {};
1200
1201        _.cleanUpEvents();
1202
1203        $('.slick-cloned', _.$slider).detach();
1204
1205        if (_.$dots) {
1206            _.$dots.remove();
1207        }
1208
1209
1210        if ( _.$prevArrow && _.$prevArrow.length ) {
1211
1212            _.$prevArrow
1213                .removeClass('slick-disabled slick-arrow slick-hidden')
1214                .removeAttr('aria-hidden aria-disabled tabindex')
1215                .css('display','');
1216
1217            if ( _.htmlExpr.test( _.options.prevArrow )) {
1218                _.$prevArrow.remove();
1219            }
1220        }
1221
1222        if ( _.$nextArrow && _.$nextArrow.length ) {
1223
1224            _.$nextArrow
1225                .removeClass('slick-disabled slick-arrow slick-hidden')
1226                .removeAttr('aria-hidden aria-disabled tabindex')
1227                .css('display','');
1228
1229            if ( _.htmlExpr.test( _.options.nextArrow )) {
1230                _.$nextArrow.remove();
1231            }
1232
1233        }
1234
1235
1236        if (_.$slides) {
1237
1238            _.$slides
1239                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
1240                .removeAttr('aria-hidden')
1241                .removeAttr('data-slick-index')
1242                .each(function(){
1243                    $(this).attr('style', $(this).data('originalStyling'));
1244                });
1245
1246            _.$slideTrack.children(this.options.slide).detach();
1247
1248            _.$slideTrack.detach();
1249
1250            _.$list.detach();
1251
1252            _.$slider.append(_.$slides);
1253        }
1254
1255        _.cleanUpRows();
1256
1257        _.$slider.removeClass('slick-slider');
1258        _.$slider.removeClass('slick-initialized');
1259        _.$slider.removeClass('slick-dotted');
1260
1261        _.unslicked = true;
1262
1263        if(!refresh) {
1264            _.$slider.trigger('destroy', [_]);
1265        }
1266
1267    };
1268
1269    Slick.prototype.disableTransition = function(slide) {
1270
1271        var _ = this,
1272            transition = {};
1273
1274        transition[_.transitionType] = '';
1275
1276        if (_.options.fade === false) {
1277            _.$slideTrack.css(transition);
1278        } else {
1279            _.$slides.eq(slide).css(transition);
1280        }
1281
1282    };
1283
1284    Slick.prototype.fadeSlide = function(slideIndex, callback) {
1285
1286        var _ = this;
1287
1288        if (_.cssTransitions === false) {
1289
1290            _.$slides.eq(slideIndex).css({
1291                zIndex: _.options.zIndex
1292            });
1293
1294            _.$slides.eq(slideIndex).animate({
1295                opacity: 1
1296            }, _.options.speed, _.options.easing, callback);
1297
1298        } else {
1299
1300            _.applyTransition(slideIndex);
1301
1302            _.$slides.eq(slideIndex).css({
1303                opacity: 1,
1304                zIndex: _.options.zIndex
1305            });
1306
1307            if (callback) {
1308                setTimeout(function() {
1309
1310                    _.disableTransition(slideIndex);
1311
1312                    callback.call();
1313                }, _.options.speed);
1314            }
1315
1316        }
1317
1318    };
1319
1320    Slick.prototype.fadeSlideOut = function(slideIndex) {
1321
1322        var _ = this;
1323
1324        if (_.cssTransitions === false) {
1325
1326            _.$slides.eq(slideIndex).animate({
1327                opacity: 0,
1328                zIndex: _.options.zIndex - 2
1329            }, _.options.speed, _.options.easing);
1330
1331        } else {
1332
1333            _.applyTransition(slideIndex);
1334
1335            _.$slides.eq(slideIndex).css({
1336                opacity: 0,
1337                zIndex: _.options.zIndex - 2
1338            });
1339
1340        }
1341
1342    };
1343

1444ideIndex - _.slideCount)) * _.slideWidth) * -1;
1445                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
1446                    } else {
1447                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
1448                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
1449                    }
1450                }
1451            }
1452        } else {
1453            if (slideIndex + _.options.slidesToShow > _.slideCount) {
1454                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
1455                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
1456            }
1457        }
1458
1459        if (_.slideCount <= _.options.slidesToShow) {
1460            _.slideOffset = 0;
1461            verticalOffset = 0;
1462        }
1463
1464       

1464 if (_.options.centerMode === true && _.options.infinite === true) {
1465            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
1466        } else if (_.options.centerMode === true) {
1467            _.slideOffset = 0;
1468            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
1469        }
1470
1471        if (_.options.vertical === false) {
1472            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
1473        } else {
1474            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
1475        }
1476
1477        if (_.options.variableWidth === true) {
1478
1479            if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1480                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1481            } else {
1482                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
1483            }
1484
1485            if (_.options.rtl === true) {
1486                if (targetSlide[0]) {
1487                    targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1488                } else {
1489                    targetLeft =  0;
1490                }
1491            } else {
1492                targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1493            }
1494
1495            if (_.options.centerMode === true) {
1496                if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1497                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1498                } else {
1499                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
1500                }
1501
1502                if (_.options.rtl === true) {
1503                    if (targetSlide[0]) {
1504                        targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1505                    } else {
1506                        targetLeft =  0;
1507                    }
1508                } else {
1509                    targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1510                }
1511
1512                targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
1513            }
1514        }
1515
1516        return targetLeft;
1517
1518    };
1519
1520    Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
1521
1522        var _ = this;
1523
1524        return _.options[option];
1525
1526    };
1527
1528    Slick.prototype.getNavigableIndexes = function() {
1529
1530        var _ = this,
1531            breakPoint = 0,
1532            counter = 0,
1533            indexes = [],
1534            max;
1535
1536        if (_.options.infinite === false) {
1537            max = _.slideCount;
1538        } else {
1539            breakPoint = _.options.slidesToScroll * -1;
1540            counter = _.options.slidesToScroll * -1;
1541            max = _.slideCount * 2;
1542        }
1543
1544        while (breakPoint < max) {
1545            indexes.push(breakPoint);
1546            breakPoint = counter + _.options.slidesToScroll;
1547            counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1548        }
1549
1550        return indexes;
1551
1552    };
1553
1554    Slick.prototype.getSlick = function() {
1555
1556        return this;
1557
1558    };
1559
1560    Slick.prototype.getSlideCount = function() {
1561
1562        var _ = this,
1563            slidesTraversed, swipedSlide, centerOffset;
1564
1565        centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
1566
1567        if (_.options.swipeToSlide === true) {
1568            _.$slideTrack.find('.slick-slide').each(function(index, slide) {
1569                if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
1570                    swipedSlide = slide;
1571                    return false;
1572                }
1573            });
1574
1575            slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
1576
1577            return slidesTraversed;
1578
1579        } else {
1580            return _.options.slidesToScroll;
1581        }
1582
1583    };
1584
1585    Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
1586
1587        var _ = this;
1588
1589        _.changeSlide({
1590            data: {
1591                message: 'index',
1592                index: parseInt(slide)
1593            }
1594        }, dontAnimate);
1595
1596    };
1597
1598    Slick.prototype.init = function(creation) {
1599
1600        var _ = this;
1601
1602        if (!$(_.$slider).hasClass('slick-initialized')) {
1603
1604            $(_.$slider).addClass('slick-initialized');
1605
1606            _.buildRows();
1607            _.buildOut();
1608            _.setProps();
1609            _.startLoad();
1610            _.loadSlider();
1611            _.initializeEvents();
1612            _.updateArrows();
1613            _.updateDots();
1614            _.checkResponsive(true);
1615            _.focusHandler();
1616
1617        }
1618
1619        if (creation) {
1620            _.$slider.trigger('init', [_]);
1621        }
1622
1623        if (_.options.accessibility === true) {
1624            _.initADA();
1625        }
1626
1627        if ( _.options.autoplay ) {
1628
1629            _.paused = false;
1630            _.autoPlay();
1631
1632        }
1633
1634    };
1635
1636    Slick.prototype.initADA = function() {
1637        var _ = this

1741        _.$list.on('touchcancel.slick mouseleave.slick', {
1742            action: 'end'
1743        }, _.swipeHandler);
1744
1745        _.$list.on('click.slick', _.clickHandler);
1746
1747        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
1748
1749        if (_.options.accessibility === true) {
1750            _.$list.on('keydown.slick', _.keyHandler);
1751        }
1752
1753        if (_.options.focusOnSelect === true) {
1754            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1755        }
1756
1757        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
1758
1759        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
1760
1761        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
1762
1763        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
1764        $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
1765
1766    };
1767
1768    Slick.prototype.initUI = function() {
1769
1770        var _ = this;
1771
1772        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1773
1774            _.$prevArrow.show();
1775            _.$nextArrow.show();
1776
1777        }
1778
1779        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1780
1781            _.$dots.show();
1782
1783        }
1784
1785    };
1786
1787    Slick.prototype.keyHandler = function(event) {
1788
1789        var _ = this;
1790         //Dont slide if the cursor is inside the form fields and arrow keys are pressed
1791        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
1792            if (event.keyCode === 37 && _.options.accessibility === true) {
1793                _.changeSlide({
1794                    data: {
1795                        message: _.options.rtl === true ? 'next' :  'previous'
1796                    }
1797                });
1798            } else if (event.keyCode === 39 && _.options.accessibility === true) {
1799                _.changeSlide({
1800                    data: {
1801                        message: _.options.rtl === true ? 'previous' : 'next'
1802                    }
1803                });
1804            }
1805        }
1806
1807    };
1808
1809    Slick.prototype.lazyLoad = function() {
1810
1811        var _ = this,
1812            loadRange, cloneRange, rangeStart, rangeEnd;
1813
1814        function loadImages(imagesScope) {
1815
1816            $('img[data-lazy]', imagesScope).each(function() {
1817
1818                var image = $(this),
1819                    imageSource = $(this).attr('data-lazy'),
1820                    imageToLoad = document.createElement('img');
1821
1822                imageToLoad.onload = function() {
1823
1824                    image
1825                        .animate({ opacity: 0 }, 100, function() {
1826                            image
1827                                .attr('src', imageSource)
1828                                .animate({ opacity: 1 }, 200, function() {
1829                                    image
1830                                        .removeAttr('data-lazy')
1831                                        .removeClass('slick-loading');
1832                                });
1833                            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
1834                        });
1835
1836                };
1837
1838                imageToLoad.onerror = function() {
1839
1840                    image
1841                        .removeAttr( 'data-lazy' )
1842                        .removeClass( 'slick-loading' )
1843                        .addClass( 'slick-lazyload-error' );
1844
1845                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1846
1847                };
1848
1849                imageToLoad.src = imageSource;
1850
1851            });
1852
1853        }
1854
1855        if (_.options.centerMode === true) {
1856            if (_.options.infinite === true) {
1857                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
1858                rangeEnd = rangeStart + _.options.slidesToShow + 2;
1859            } else {
1860                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
1861                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
1862            }
1863        } else {
1864            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
1865            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
1866            if (_.options.fade === true) {
1867                if (rangeStart > 0) rangeStart--;
1868                if (rangeEnd <= _.slideCount) rangeEnd++;
1869            }
1870        }
1871
1872        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
1873        loadImages(loadRange);
1874
1875        if (_.slideCount <= _.options.slidesToShow) {
1876            cloneRange = _.$slider.find('.slick-slide');
1877            loadImages(cloneRange);
1878        } else
1879        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1880            cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
1881            loadImages(cloneRange);
1882        } else if (_.currentSlide === 0) {
1883            cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
1884            loadImages(cloneRange);
1885        }
1886
1887    };
1888
1889    Slick.prototype.loadSlider = function() {
1890
1891        var _ = this;
1892
1893        _.setPosition();
1894
1895        _.$slideTrack.css({
1896            opacity: 1
1897        });
1898
1899        _.$slider.removeClass('slick-loading');
1900
1901        _.initUI();
1902
1903        if (_.options.lazyLoad === 'progressive') {
1904            _.progressiveLazyLoad();
1905        }
1906
1907    };
1908
1909    Slick.prototype.next = Slick.prototype.slickNext = function() {
1910
1911        var _ = this;
1912
1913        _.changeSlide({
1914            data: {
1915                message: 'next'
1916            }
1917        });
1918
1919    };
1920
1921    Slick.prototype.orientationChange = function() {
1922
1923        var _ = this;
1924
1925        _.checkResponsive();
1926        _.setPosition();
1927
1928    };
1929
1930    Slick.prototype.pause = Slick.prototype.slickPause = function() {
1931
1932        var _ = this;
1933
1934        _.autoPlayClear();
1935        _.paused = true;
1936
1937    };
1938
1939    Slick.prototype.play = Slick.prototype.slickPlay = function() {
1940
1941        var _ = this;
1942
1943        _.autoPlay();
1944        _.options.autoplay = true;
1945        _.paused = false;
1946        _.focussed = false;
1947        _.interrupted = false;
1948
1949    };
1950
1951    Slick.prototype.postSlide = function(index) {
1952
1953        var _ = this;
1954
1955        if( !_.unslicked ) {
1956
1957            _.$slider.trigger('afterChange', [_, index]);
1958
1959            _.animating = false;
1960
1961            _.setPosition();
1962
1963            _.swipeLeft = null;
1964
1965            if ( _.options.autoplay ) {
1966                _.autoPlay();
1967            }
1968
1969            if (_.options.accessibility === true) {
1970                _.initADA();
1971            }
1972
1973        }
1974
1975    };
1976
1977    Slick.prototype.prev = Slick.prototype.slickPrev = function() {
1978
1979        var _ = this;
1980
1981        _.changeSlide({
1982            data: {
1983                message: 'previous'
1984            }
1985        });
1986
1987    };
1988
1989    Slick.prototype.preventDefault = function(event) {
1990
1991        event.preventDefault();
1992
1993    };
1994
1995    Slick.prototype.progressiveLazyLoad = function( tryCount ) {
1996
1997        tryCount = tryCount || 1;
1998
1999        var _ = this,
2000            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
2001            image,
2002            imageSource,
2003            imageToLoad;
2004
2005        if ( $imgsToLoad.length ) {
2006
2007            image = $imgsToLoad.first();
2008            imageSource = image.attr('data-lazy');
2009            imageToLoad = document.createElement('img');
2010
2011            imageToLoad.onload = function() {
2012
2013                image
2014                    .attr( 'src', imageSource )
2015                    .removeAttr('data-lazy')
2016                    .removeClass('slick-loading');
2017
2018                if ( _.options.adaptiveHeight === true ) {
2019                    _.setPosition();
2020                }
2021
2022                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
2023                _.progressiveLazyLoad();
2024
2025            };
2026
2027            imageToLoad.onerror = function() {
2028
2029                if ( tryCount < 3 ) {
2030
2031                    /**
2032                     * try to load the image 3 times,
2033                     * leave a slight delay so we don't get
2034                     * servers blocking the request.
2035                     */
2036                    setTimeout( function() {
2037                        _.progressiveLazyLoad( tryCount + 1 );
2038                    }, 500 );
2039
2040                } else {
2041
2042                    image
2043                        .removeAttr( 'data-lazy' )
2044                        .removeClass( 'slick-loading' )
2045                        .addClass( 'slick-lazyload-error' );
2046
2047                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
2048
2049                    _.progressiveLazyLoad();
2050
2051                }
2052
2053            };
2054
2055            imageToLoad.src = imageSource;
2056
2057        } else {
2058
2059            _.$slider.trigger('allImagesLoaded', [ _ ]);
2060
2061        }
2062
2063    };
2064
2065    Slick.prototype.refresh = function( initializing ) {
2066
2067        var _ = this, currentSlide, lastVisibleIndex;
2068
2069        lastVisibleIndex = _.slideCount - _.options.slidesToShow;
2070
2071        // in non-infinite sliders, we don't want to go past the
2072        // last visible index.
2073        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
2074            _.currentSlide = lastVisibleIndex;
2075        }
2076
2077        // if less slides than to show, go to start.
2078        if ( _.slideCount <= _.options.slidesToShow ) {
2079            _.currentSlide = 0;
2080
2081        }
2082
2083        currentSlide = _.currentSlide;
2084
2085        _.destroy(true);
2086
2087        $.extend(_, _.initials, { currentSlide: currentSlide });
2088
2089        _.init();
2090
2091        if( !initializing ) {
2092
2093            _.changeSlide({
2094                data: {
2095                    message: 'index',
2096                    index: currentSlide
2097                }
2098            }, false);
2099
2100        }
2101
2102    };
2103
2104    Slick.prototype.registerBreakpoints = function() {
2105
2106        var _ = this, breakpoint, currentBreakpoint, l,
2107            responsiveSettings = _.options.responsive || null;
2108
2109        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
2110
2111            _.respondTo = _.options.respondTo || 'window';
2112
2113            for ( breakpoint in responsiveSettings ) {
2114
2115                l = _.breakpoints.length-1;
2116                currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
2117
2118                if (responsiveSettings.hasOwnProperty(breakpoint)) {

2118
2119
2120                    // loop through the breakpoints and cut out any existing
2121                    // ones with the same breakpoint number, we don't want dupes.
2122                    while( l >= 0 ) {
2123                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
2124                            _.breakpoints.splice(l,1);
2125                        }
2126                        l--;
2127                    }
2128
2129                    _.breakpoints.push(currentBreakpoint);
2130                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
2131
2132                }
2133
2134            }
2135
2136            _.breakpoints.sort(function(a, b) {
2137                return ( _.options.mobileFirst ) ? a-b : b-a;
2138            });
2139
2140        }
2141
2142    };
2143
2144    Slick.prototype.reinit = function() {
2145
2146        var _ = this;
2147
2148        _.$slides =
2149            _.$slideTrack
2150                .children(_.options.slide)
2151                .addClass('slick-slide');
2152
2153        _.slideCount = _.$slides.length;
2154
2155        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
2156            _.currentSlide = _.currentSlide - _.options.slidesToScroll;
2157        }
2158
2159        if (_.slideCount <= _.options.slidesToShow) {
2160            _.currentSlide = 0;
2161        }
2162
2163        _.registerBreakpoints();
2164
2165        _.setProps();
2166        _.setupInfinite();
2167        _.buildArrows();
2168        _.updateArrows();
2169        _.initArrowEvents();
2170        _.buildDots();
2171        _.updateDots();
2172        _.initDotEvents();
2173        _.cleanUpSlideEvents();
2174        _.initSlideEvents();
2175
2176        _.checkResponsive(false, true);
2177
2178        if (_.options.focusOnSelect === true) {
2179            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
2180        }
2181
2182        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
2183
2184        _.setPosition();
2185        _.focusHandler();
2186
2187        _.paused = !_.options.autoplay;
2188        _.autoPlay();
2189
2190        _.$slider.trigger('reInit', [_]);
2191
2192    };
2193
2194    Slick.prototype.resize = function() {
2195
2196        var _ = this;
2197
2198        if ($(window).width() !== _.windowWidth) {
2199            clearTimeout(_.windowDelay);
2200            _.windowDelay = window.setTimeout(function() {
2201                _.windowWidth = $(window).width();
2202                _.checkResponsive();
2203                if( !_.unslicked ) { _.setPosition(); }
2204            }, 50);
2205        }
2206    };
2207
2208    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
2209
2210        var _ = this;
2211
2212        if (typeof(index) === 'boolean') {
2213            removeBefore = index;
2214            index = removeBefore === true ? 0 : _.slideCount - 1;
2215        } else {
2216            index = removeBefore === true ? --index : index;
2217        }
2218
2219        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
2220            return false;
2221        }
2222
2223        _.unload();
2224
2225        if (removeAll === true) {
2226            _.$slideTrack.children().remove();
2227        } else {
2228            _.$slideTrack.children(this.options.slide).eq(index).remove();
2229        }
2230
2231        _.$slides = _.$slideTrack.children(this.options.slide);
2232
2233        _.$slideTrack.children(this.options.slide).detach();
2234
2235        _.$slideTrack.append(_.$slides);
2236
2237        _.$slidesCache = _.$slides;
2238
2239        _.reinit();
2240
2241    };
2242
2243    Slick.prototype.setCSS = function(position) {
2244
2245        var _ = this,
2246            positionProps = {},
2247            x, y;
2248
2249        if (_.options.rtl === true) {
2250            position = -position;
2251        }
2252        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
2253        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
2254
2255        positionProps[_.positionProp] = position;
2256
2257        if (_.transformsEnabled === false) {
2258            _.$slideTrack.css(positionProps);
2259        } else {
2260            positionProps = {};
2261            if (_.cssTransitions === false) {
2262                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
2263                _.$slideTrack.css(positionProps);
2264            } else {
2265                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
2266                _.$slideTrack.css(positionProps);
2267            }
2268        }
2269
2270    };
2271
2272    Slick.prototype.setDimensions = function() {
2273
2274        var _ = this;
2275
2276        if (_.options.vertical === false) {
2277            if (_.options.centerMode === true) {
2278                _.$list.css({
2279                    padding: ('0px ' + _.options.centerPadding)
2280                });
2281            }
2282        } else {
2283            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
2284            if (_.options.centerMode === true) {
2285                _.$list.css({
2286                    padding: (_.options.centerPadding + ' 0px')
2287                });
2288            }
2289        }
2290
2291        _.listWidth = _.$list.width();
2292        _.listHeight = _.$list.height();
2293
2294
2295        if (_.options.vertical === false && _.options.variableWidth === false) {
2296            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
2297            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
2298
2299        } else if (_.options.variableWidth === true) {
2300            _.$slideTrack.width(5000 * _.slideCount);
2301        } else {
2302            _.slideWidth = Math.ceil(_.listWidth);
2303            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
2304        }
2305
2306        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
2307        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
2308
2309    };
2310
2311    Slick.prototype.setFade = function() {
2312
2313        var _ = this,
2314            targetLeft;
2315
2316        _.$slides.each(function(index, element) {
2317            targetLeft = (_.slideWidth * index) * -1;
2318            if (_.options.rtl === true) {
2319                $(element).css({
2320                    position: 'relative',
2321                    right: targetLeft,
2322                    top: 0,
2323                    zIndex: _.options.zIndex - 2,
2324                    opacity: 0
2325                });
2326            } else {
2327                $(element).css({
2328                    position: 'relative',
2329                    left: targetLeft,
2330                    top: 0,
2331                    zIndex: _.options.zIndex - 2,
2332                    opacity: 0
2333                });
2334            }
2335        });
2336
2337        _.$slides.eq(_.currentSlide).css({
2338            zIndex: _.options.zIndex - 1,
2339            opacity: 1
2340        });
2341
2342    };
2343
2344    Slick.prototype.setHeight = function() {
2345
2346        var _ = this;
2347
2348        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
2349            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
2350            _.$list.css('height', targetHeight);
2351        }
2352
2353    };
2354
2355    Slick.prototype.setOption =
2356    Slick.prototype.slickSetOption = function() {
2357
2358        /**
2359         * accepts arguments in format of:
2360         *
2361         *  - for changing a single option's value:
2362         *     .slick("setOption", option, value, refresh )
2363         *
2364         *  - for changing a set of responsive options:
2365         *     .slick("setOption", 'responsive', [{}, ...], refresh )
2366         *
2367         *  - for updating multiple values at once (not responsive)
2368         *     .slick("setOption", { 'option': value, ... }, refresh )
2369         */
2370
2371        var _ = this, l, item, option, value, refresh = false, type;
2372
2373        if( $.type( arguments[0] ) === 'object' ) {
2374
2375            option =  arguments[0];
2376            refresh = arguments[1];
2377            type = 'multiple';
2378
2379        } else if ( $.type( arguments[0] ) === 'string' ) {
2380
2381            option =  arguments[0];
2382            value = arguments[1];
2383            refresh = arguments[2];
2384
2385            if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
2386
2387                type = 'responsive';
2388
2389            } else if ( typeof arguments[1] !== 'undefined' ) {
2390
2391                type = 'single';
2392
2393            }
2394
2395        }
2396
2397        if ( type === 'single' ) {
2398
2399            _.options[option] = value;
2400
2401
2402        } else if ( type === 'multiple' ) {
2403
2404            $.each( option , function( opt, val ) {
2405
2406                _.options[opt] = val;
2407
2408            });
2409
2410
2411        } else if ( type === 'responsive' ) {
2412
2413            for ( item in value ) {
2414
2415                if( $.type( _.options.responsive ) !== 'array' ) {
2416
2417                    _.options.responsive = [ value[item] ];
2418
2419                } else {
2420
2421                    l = _.options.responsive.length-1;
2422
2423                    // loop through the responsive object and splice out duplicates.
2424                    while( l >= 0 ) {
2425
2426                        if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
2427
2428                            _.options.responsive.splice(l,1);
2429
2430                        }
2431
2432                        l--;
2433
2434                    }
2435
2436                    _.options.responsive.push( value[item] );
2437
2438                }
2439
2440            }
2441
2442        }
2443
2444        if ( refresh ) {
2445
2446            _.unload();
2447            _.reinit();
2448
2449        }
2450
2451    };
2452
2453    Slick.prototype.setPosition = function() {
2454
2455        var _ = this;
2456
2457        _.setDimensions();
2458
2459        _.setHeight();
2460
2461        if (_.options.fade === false) {
2462            _.setCSS(_.getLeft(_.currentSlide));
2463        } else {
2464            _.setFade();
2465        }
2466
2467        _.$slider.trigger('setPosition', [_]);
2468
2469    };
2470
2471    Slick.prototype.setProps = function() {
2472
2473        var _ = this,
2474            bodyStyle = document.body.style;
2475
2476        _.positionProp = _.options.vertical === true ? 'top' : 'left';
2477
2478        if (_.positionProp === 'top') {
2479            _.$slider.addClass('slick-vertical');
2480        } else {
2481            _.$slider.removeClass('slick-vertical');
2482        }
2483
2484        if (bodyStyle.WebkitTransition !== undefined ||
2485            bodyStyle.MozTransition !== undefined ||
2486            bodyStyle.msTransition !== undefined) {
2487            if (_.options.useCSS === true) {
2488                _.cssTransitions = true;
2489            }
2490        }
2491
2492        if ( _.options.fade ) {
2493            if ( typeof _.options.zIndex === 'number' ) {
2494                if( _.options.zIndex < 3 ) {
2495                    _.options.zIndex = 3;
2496                }
2497            } else {
2498                _.options.zIndex = _.defaults.zIndex;
2499            }
2500        }
2501
2502        if (bodyStyle.OTransform !== undefined) {
2503            _.animType = 'OTransform';
2504            _.transformType = '-o-transform';
2505            _.transitionType = 'OTransition';
2506            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2507        }
2508        if (bodyStyle.MozTransform !== undefined) {
2509            _.animType = 'MozTransform';
2510            _.transformType = '-moz-transform';
2511            _.transitionType = 'MozTransition';
2512            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
2513        }
2514        if (bodyStyle.webkitTransform !== undefined) {
2515            _.animType = 'webkitTransform';
2516            _.transformType = '-webkit-transform';
2517            _.transitionType = 'webkitTransition';
2518            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2519        }
2520        if (bodyStyle.msTransform !== undefined) {
2521            _.animType = 'msTransform';
2522            _.transformType = '-ms-transform';
2523            _.transitionType = 'msTransition';
2524            if (bodyStyle.msTransform === undefined) _.animType = false;
2525        }
2526        if (bodyStyle.transform !== undefined && _.animType !== false) {
2527            _.animType = 'transform';
2528            _.transformType = 'transform';
2529            _.transitionType = 'transition';
2530        }
2531        _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
2532    };
2533
2534
2535    Slick.prototype.setSlideClasses = function(index) {
2536
2537        var _ = this,
2538            centerOffset, allSlides, indexOffset, remainder;
2539
2540        allSlides = _.$slider
2541            .find('.slick-slide')
2542            .removeClass('slick-active slick-center slick-current')
2543            .attr('aria-hidden', 'true');
2544
2545        _.$slides
2546            .eq(index)
2547            .addClass('slick-current');
2548
2549        if (_.options.centerMode === true) {
2550
2551            

2644            _.options.centerMode = false;
2645        }
2646
2647        if (_.options.infinite === true && _.options.fade === false) {
2648
2649            slideIndex = null;
2650
2651            if (_.slideCount > _.options.slidesToShow) {
2652
2653                if (_.options.centerMode === true) {
2654                    infiniteCount = _.options.slidesToShow + 1;
2655                } else {
2656                    infiniteCount = _.options.slidesToShow;
2657                }
2658
2659                for (i = _.slideCount; i > (_.slideCount -
2660                        infiniteCount); i -= 1) {
2661                    slideIndex = i - 1;
2662                    $(_.$slides[slideIndex]).clone(true).attr('id', '')
2663                        .attr('data-slick-index', slideIndex - _.slideCount)
2664                        .prependTo(_.$slideTrack).addClass('slick-cloned');
2665                }
2666                for (i = 0; i < infiniteCount; i += 1) {
2667                    slideIndex = i;
2668                    $(_.$slides[slideIndex]).clone(true).attr('id', '')
2669                        .attr('data-slick-index', slideIndex + _.slideCount)
2670                        .appendTo(_.$slideTrack).addClass('slick-cloned');
2671                }
2672                _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
2673                    $(this).attr('id', '');
2674                });
2675
2676            }
2677
2678        }
2679
2680    };
2681
2682    Slick.prototype.interrupt = function( toggle ) {
2683
2684        var _ = this;
2685
2686        if( !toggle ) {
2687            _.autoPlay();
2688        }
2689        _.interrupted = toggle;
2690
2691    };
2692
2693    Slick.prototype.selectHandler = function(event) {
2694
2695        var _ = this;
2696
2697        var targetElement =
2698            $(event.target).is('.slick-slide') ?
2699                $(event.target) :
2700                $(event.target).parents('.slick-slide');
2701
2702        var index = parseInt(targetElement.attr('data-slick-index'));
2703
2704        if (!index) index = 0;
2705
2706        if (_.slideCount <= _.options.slidesToShow) {
2707
2708            _.setSlideClasses(index);
2709            _.asNavFor(index);
2710            return;
2711
2712        }
2713
2714        _.slideHandler(index);
2715
2716    };
2717
2718    Slick.prototype.slideHandler = function(index, sync, dontAnimate) {
2719
2720        var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
2721            _ = this, navTarget;
2722
2723        sync = sync || false;
2724
2725        if (_.animating === true && _.options.waitForAnimate === true) {
2726            return;
2727        }
2728
2729        if (_.options.fade === true && _.currentSlide === index) {
2730            return;
2731        }
2732
2733        if (_.slideCount <= _.options.slidesToShow) {
2734            return;
2735        }
2736
2737        if (sync === false) {
2738            _.asNavFor(index);
2739        }
2740
2741        targetSlide = index;
2742        targetLeft = _.getLeft(targetSlide);
2743        slideLeft = _.getLeft(_.currentSlide);
2744
2745        _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
2746
2747        if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
2748            if (_.options.fade === false) {
2749                targetSlide = _.currentSlide;
2750                if (dontAnimate !== true) {
2751                    _.animateSlide(slideLeft, function() {
2752                        _.postSlide(targetSlide);
2753                    });
2754                } else {
2755                    _.postSlide(targetSlide);
2756                }
2757            }
2758            return;
2759        } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
2760            if (_.options.fade === false) {
2761                targetSlide = _.currentSlide;
2762                if (dontAnimate !== true) {
2763                    _.animateSlide(slideLeft, function() {
2764                        _.postSlide(targetSlide);
2765                    });
2766                } else {
2767                    _.postSlide(targetSlide);
2768                }
2769            }
2770            return;
2771        }
2772
2773        if ( _.options.autoplay ) {
2774            clearInterval(_.autoPlayTimer);
2775        }
2776
2777        if (targetSlide < 0) {
2778            if (_.slideCount % _.options.slidesToScroll !== 0) {
2779                animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
2780            } else {
2781                animSlide = _.slideCount + targetSlide;
2782            }
2783        } else if (targetSlide >= _.slideCount) {
2784            if (_.slideCount % _.options.slidesToScroll !== 0) {
2785                animSlide = 0;
2786            } else {
2787                animSlide = targetSlide - _.slideCount;
2788            }
2789        } else {
2790            animSlide = targetSlide;
2791        }
2792
2793        _.animating = true;
2794
2795        _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);
2796
2797        oldSlide = _.currentSlide;
2798        _.currentSlide = animSlide;
2799
2800        _.setSlideClasses(_.currentSlide);
2801
2802        if ( _.options.asNavFor ) {
2803
2804            navTarget = _.getNavTarget();
2805            navTarget = navTarget.slick('getSlick');
2806
2807            if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {
2808                navTarget.setSlideClasses(_.currentSlide);
2809            }
2810
2811        }
2812
2813        _.updateDots();
2814        _.updateArrows();
2815
2816        if (_.options.fade === true) {
2817            if (dontAnimate !== true) {
2818
2819                _.fadeSlideOut(oldSlide);
2820
2821                _.fadeSlide(animSlide, function() {
2822                    _.postSlide(animSlide);
2823                });
2824
2825            } else {
2826                _.postSlide(animSlide);
2827            }
2828            _.animateHeight();
2829            return;
2830        }
2831
2832        if (dontAnimate !== true) {
2833            _.animateSlide(targetLeft, function() {
2834                _.postSlide(animSlide);
2835            });
2836        } else {
2837            _.postSlide(animSlide);
2838        }
2839
2840    };
2841
2842    Slick.prototype.startLoad = function() {
2843
2844        var _ = this;
2845
2846        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2847
2848            _.$prevArrow.hide();
2849            _.$nextArrow.hide();
2850
2851        }
2852
2853        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2854
2855            _.$dots.hide();
2856
2857        }
2858
2859        _.$slider.addClass('slick-loading');
2860
2861    };
2862
2863    Slick.prototype.swipeDirection = function() {
2864
2865        var xDist, yDist, r, swipeAngle, _ = this;
2866
2867        xDist = _.touchObject.startX - _.touchObject.curX;
2868        yDist = _.touchObject.startY - _.touchObject.curY;
2869        r = Math.atan2(yDist, xDist);
2870
2871        swipeAngle = Math.round(r * 180 / Math.PI);
2872        if (swipeAngle < 0) {
2873            swipeAngle = 360 - Math.abs(swipeAngle);
2874        }
2875
2876        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
2877            return (_.options.rtl === false ? 'left' : 'right');
2878        }
2879        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
2880            return (_.options.rtl === false ? 'left' : 'right');
2881        }
2882        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
2883            return (_.options.rtl === false ? 'right' : 'left');
2884        }
2885        if (_.options.verticalSwiping === true) {
2886            if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
2887                return 'down';
2888            } else {
2889                return 'up';
2890            }
2891        }
2892
2893        return 'vertical';
2894
2895    };
2896
2897    Slick.prototype.swipeEnd = function(event) {
2898
2899        var _ = this,
2900            slideCount,
2901            direction;
2902
2903        _.dragging = false;
2904        _.interrupted = false;
2905        _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;
2906
2907        if ( _.touchObject.curX === undefined ) {
2908            return false;
2909        }
2910
2911        if ( _.touchObject.edgeHit === true ) {
2912            _.$slider.trigger('edge', [_, _.swipeDirection() ]);
2913        }
2914
2915        if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
2916
2917            direction = _.swipeDirection();
2918
2919            switch ( direction ) {
2920
2921                case 'left':
2922                case 'down':
2923
2924                    slideCount =
2925                        _.options.swipeToSlide ?
2926                            _.checkNavigable( _.currentSlide + _.getSlideCount() ) :
2927                            _.currentSlide + _.getSlideCount();
2928
2929                    _.currentDirection = 0;
2930
2931                    break;
2932
2933                case 'right':
2934                case 'up':
2935
2936                    slideCount =
2937                        _.options.swipeToSlide ?
2938                            _.checkNavigable( _.currentSlide - _.getSlideCount() ) :
2939                            _.currentSlide - _.getSlideCount();
2940
2941                    _.currentDirection = 1;
2942
2943                    break;
2944
2945                default:
2946
2947
2948            }
2949
2950            if( direction != 'vertical' ) {
2951
2952                _.slideHandler( slideCount );
2953                _.touchObject = {};
2954                _.$slider.trigger('swipe', [_, direction ]);
2955
2956            }
2957
2958        } else {
2959
2960            if ( _.touchObject.startX !== _.touchObject.curX ) {
2961
2962                _.slideHandler( _.currentSlide );
2963                _.touchObject = {};
2964
2965            }
2966
2967        }
2968
2969    };
2970
2971    Slick.prototype.swipeHandler = function(event) {
2972
2973        var _ = this;
2974
2975        if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
2976            return;
2977        } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
2978            return;
2979        }
2980
2981        _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
2982            event.originalEvent.touches.length : 1;
2983
2984        _.touchObject.minSwipe = _.listWidth / _.options
2985            .touchThreshold;
2986
2987        if (_.options.verticalSwiping === true) {
2988            _.touchObject.minSwipe = _.listHeight / _.options
2989                .touchThreshold;
2990        }
2991
2992        switch (event.data.action) {
2993
2994            case 'start':
2995                _.swipeStart(event);
2996                break;
2997
2998            case 'move':
2999                _.swipeMove(event);
3000                break;
3001
3002            case 'end':
3003                _.swipeEnd(event);
3004                break;
3005
3006        }
3007
3008    };
3009
3010    Slick.prototype.swipeMove = function(event) {
3011
3012        var _ = this,
3013            edgeWasHit = false,
3014            curLeft, swipeDirection, swipeLength, positionOffset, touches;
3015
3016        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
3017
3018        if (!_.dragging || touches && touches.length !== 1) {
3019            return false;
3020        }
3021
3022        curLeft = _.getLeft(_.currentSlide);
3023
3024        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
3025        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
3026
3027        _.touchObject.swipeLength = Math.round(Math.sqrt(
3028            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
3029
3030        if (_.options.verticalSwiping === true) {
3031            _.touchObject.swipeLength = Math.round(Math.sqrt(
3032                Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
3033        }
3034
3035        swipeDirection = _.swipeDirection();
3036
3037        if (swipeDirection === 'vertical') {
3038            return;
3039        }
3040
3041        if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
3042            event.preventDefault();
3043        }
3044
3045        positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
3046        if (_.options.verticalSwiping === true) {
3047            positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
3048        }
3049
3050
3051        swipeLength = _.touchObject.swipeLength;
3052
3053        _.touchObject.edgeHit = false;
3054
3055        if (_.options.infinite === false) {
3056            if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
3057                swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
3058                _.touchObject.edgeHit = true;
3059            }
3060        }
3061
3062        if (_.options.vertical === false) {
3063            _.swipeLeft = curLeft + swipeLength * positionOffset;
3064        } else {
3065            _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
3066        }
3067        if (_.options.verticalSwiping === true) {
3068            _.swipeLeft = curLeft + swipeLength * positionOffset;
3069        }
3070
3071        if (_.options.fade === true || _.options.touchMove === false) {
3072            return false;
3073        }
3074
3075        if (_.animating === true) {
3076            _.swipeLeft = null;
3077            return false;
3078        }
3079
3080        _.setCSS(_.swipeLeft);
3081
3082    };
3083
3084    Slick.prototype.swipeStart = function(event) {
3085
3086        var _ = this,
3087            touches;
3088
3089        _.interrupted = true;
3090
3091        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
3092            _.touchObject = {};
3093            return false;
3094        }
3095
3096        if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
3097            touches = event.originalEvent.touches[0];
3098        }
3099
3100        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
3101        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
3102
3103        _.dragging = true;
3104
3105    };
3106
3107    Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
3108
3109        var _ = this;
3110
3111        if (_.$slidesCache !== null) {
3112
3113            _.unload();
3114
3115            _.$slideTrack.children(this.options.slide).detach();
3116
3117            _.$slidesCache.appendTo(_.$slideTrack);
3118
3119            _.reinit();
3120
3121        }
3122
3123    };
3124
3125    Slick.prototype.unload = function() {
3126
3127        var _ = this;
3128
3129        $('.slick-cloned', _.$slider).remove();
3130
3131        if (_.$dots) {
3132            _.$dots.remove();
3133        }
3134
3135        if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
3136            _.$prevArrow.remove();
3137        }
3138
3139        if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
3140            _.$nextArrow.remove();
3141        }
3142
3143        _.$slides
3144            .removeClass('slick-slide slick-active slick-visible slick-current')
3145            .attr('aria-hidden', 'true')
3146            .css('width', '');
3147
3148    };
3149
3150    Slick.prototype.unslick = function(fromBreakpoint) {
3151
3152        var _ = this;
3153        _.$slider.trigger('unslick', [_, fromBreakpoint]);
3154        _.destroy();
3155
3156    };
3157
3158    Slick.prototype.updateArrows = function() {
3159
3160        var _ = this,
3161            centerOffset;
3162
3163        centerOffset = Math.floor(_.options.slidesToShow / 2);
3164
3165        if ( _.options.arrows === true &&
3166            _.slideCount > _.options.slidesToShow &&
3167            !_.options.infinite ) {
3168
3169            _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
3170            _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
3171
3172            if (_.currentSlide === 0) {
3173
3174                _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
3175                _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
3176
3177            } else if (_.currentSlide >