https://m5m7.ru/bitrix/cache/js/s1/makoto/template_ed20b095d14b482…482a7bd2d28b669ff924_v1.js?1785742516241255

122                unslicked: false
123            };
124
125            $.extend(_, _.initials);
126
127            _.activeBreakpoint = null;
128            _.animType = null;
129            _.animProp = null;
130            _.breakpoints = [];
131            _.breakpointSettings = [];
132            _.cssTransitions = false;
133            _.focussed = false;
134            _.interrupted = false;
135            _.hidden = 'hidden';
136            _.paused = true;
137            _.positionProp = null;
138            _.respondTo = null;
139            _.rowCount = 1;
140            _.shouldClick = true;
141            _.$slider = $(element);
142            _.$slidesCache = null;
143            _.transformType = null;
144            _.transitionType = null;
145            _.visibilityChange = 'visibilitychange';
146            _.windowWidth = 0;
147            _.windowTimer = null;
148
149            dataSettings = $(element).data('slick') || {};
150
151            _.options = $.extend({}, _.defaults, settings, dataSettings);
152
153            _.currentSlide = _.options.initialSlide;
154
155            _.originalSettings = _.options;
156
157            if (typeof document.mozHidden !== 'undefined') {
158                _.hidden = 'mozHidden';
159                _.visibilityChange = 'mozvisibilitychange';
160            } else if (typeof document.webkitHidden !== 'undefined') {
161                _.hidden = 'webkitHidden';
162                _.visibilityChange = 'webkitvisibilitychange';
163            }
164
165            _.autoPlay = $.proxy(_.autoPlay, _);
166            _.autoPlayClear = $.proxy(_.autoPlayClear, _);
167            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
168            _.changeSlide = $.proxy(_.changeSlide, _);
169            _.clickHandler = $.proxy(_.clickHandler, _);
170            _.selectHandler = $.proxy(_.selectHandler, _);
171            _.setPosition = $.proxy(_.setPosition, _);
172            _.swipeHandler = $.proxy(_.swipeHandler, _);
173            _.dragHandler = $.proxy(_.dragHandler, _);
174            _.keyHandler = $.proxy(_.keyHandler, _);
175
176            _.instanceUid = instanceUid++;
177
178            // A simple way to check for HTML strings
179            // Strict HTML recognition (must start with <)
180            // Extracted from jQuery v1.11 source
181            _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
182
183
184            _.registerBreakpoints();
185            _.init(true);
186
187        }
188
189        return Slick;
190
191    }());
192
193    Slick.prototype.activateADA = function() {
194        var _ = this;
195
196        _.$slideTrack.find('.slick-active').attr({
197            'aria-hidden': 'false'
198        }).find('a, input, button, select').attr({
199            'tabindex': '0'
200        });
201
202    };
203
204    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
205
206        var _ = this;
207
208        if (typeof(index) === 'boolean') {
209            addBefore = index;
210            index = null;
211        } else if (index < 0 || (index >= _.slideCount)) {
212            return false;
213        }
214
215        _.unload();
216
217        if (typeof(index) === 'number') {
218            if (index === 0 && _.$slides.length === 0) {
219                $(markup).appendTo(_.$slideTrack);
220            } else if (addBefore) {
221                $(markup).insertBefore(_.$slides.eq(index));
222            } else {
223                $(markup).insertAfter(_.$slides.eq(index));
224            }
225        } else {
226            if (addBefore === true) {
227                $(markup).prependTo(_.$slideTrack);
228            } else {
229                $(markup).appendTo(_.$slideTrack);
230            }
231        }
232
233        _.$slides = _.$slideTrack.children(this.options.slide);
234
235        _.$slideTrack.children(this.options.slide).detach();
236
237        _.$slideTrack.append(_.$slides);
238
239        _.$slides.each(function(index, element) {
240            $(element).attr('data-slick-index', index);
241        });
242
243        _.$slidesCache = _.$slides;
244
245        _.reinit();
246
247    };
248
249    Slick.prototype.animateHeight = function() {
250        var _ = this;
251        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
252            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
253            _.$list.animate({
254                height: targetHeight
255            }, _.options.speed);
256        }
257    };
258
259    Slick.prototype.animateSlide = function(targetLeft, callback) {
260
261        var animProps = {},
262            _ = this;
263
264        _.animateHeight();
265
266        if (_.options.rtl === true && _.options.vertical === false) {
267            targetLeft = -targetLeft;
268        }
269        if (_.transformsEnabled === false) {
270            if (_.options.vertical === false) {
271                _.$slideTrack.animate({
272                    left: targetLeft
273                }, _.options.speed, _.options.easing, callback);
274            } else {
275                _.$slideTrack.animate({
276                    top: targetLeft
277                }, _.options.speed, _.options.easing, callback);
278            }
279
280        } else {
281
282            if (_.cssTransitions === false) {
283                if (_.options.rtl === true) {
284                    _.currentLeft = -(_.currentLeft);
285                }
286                $({
287                    animStart: _.currentLeft
288                }).animate({
289                    animStart: targetLeft
290                }, {
291                    duration: _.options.speed,
292                    easing: _.options.easing,
293                    step: function(now) {
294                        now = Math.ceil(now);
295                        if (_.options.vertical === false) {
296                            animProps[_.animType] = 'translate(' +
297                                now + 'px, 0px)';
298                            _.$slideTrack.css(animProps);
299                        } else {
300                            animProps[_.animType] = 'translate(0px,' +
301                                now + 'px)';
302                            _.$slideTrack.css(animProps);
303                        }
304                    },
305                    complete: function() {
306                        if (callback) {
307                            callback.call();
308                        }
309                    }
310                });
311
312            } else {
313
314                _.applyTransition();
315                targetLeft = Math.ceil(targetLeft);
316
317                if (_.options.vertical === false) {
318                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
319                } else {
320                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
321                }
322                _.$slideTrack.css(animProps);
323
324                if (callback) {
325                    setTimeout(function() {
326
327                        _.disableTransition();
328
329                        callback.call();
330                    }, _.options.speed);
331                }
332
333            }
334
335        }
336
337    };
338
339    Slick.prototype.getNavTarget = function() {
340
341        var _ = this,
342            asNavFor = _.options.asNavFor;
343
344        if ( asNavFor && asNavFor !== null ) {
345            asNavFor = $(asNavFor).not(_.$slider);
346        }
347
348        return asNavFor;
349
350    };
351
352    Slick.prototype.asNavFor = function(index) {
353
354        var _ = this,
355            asNavFor = _.getNavTarget();
356
357        if ( asNavFor !== null && typeof asNavFor === 'object' ) {
358            asNavFor.each(function() {
359                var target = $(this).slick('getSlick');
360                if(!target.unslicked) {
361                    target.slideHandler(index, true);
362                }
363            });
364        }
365
366    };
367
368    Slick.prototype.applyTransition = function(slide) {
369
370        var _ = this,
371            transition = {};
372
373        if (_.options.fade === false) {
374            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
375        } else {
376            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
377        }
378
379        if (_.options.fade === false) {
380            _.$slideTrack.css(transition);
381        } else {
382            _.$slides.eq(slide).css(transition);
383        }
384
385    };
386
387    Slick.prototype.autoPlay = function() {
388
389        var _ = this;
390
391        _.autoPlayClear();
392
393        if ( _.slideCount > _.options.slidesToShow ) {
394            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
395        }
396
397    };
398
399    Slick.prototype.autoPlayClear = function() {
400
401        var _ = this;
402
403        if (_.autoPlayTimer) {
404            clearInterval(_.autoPlayTimer);
405        }
406
407    };
408
409    Slick.prototype.autoPlayIterator = function() {
410
411        var _ = this,
412            slideTo = _.currentSlide + _.options.slidesToScroll;
413
414        if ( !_.paused && !_.interrupted && !_.focussed ) {
415
416            if ( _.options.infinite === false ) {
417
418                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
419                    _.direction = 0;
420                }
421
422                else if ( _.direction === 0 ) {
423
424                    slideTo = _.currentSlide - _.options.slidesToScroll;
425
426                    if ( _.currentSlide - 1 === 0 ) {
427                        _.direction = 1;
428                    }
429
430                }
431
432            }
433
434            _.slideHandler( slideTo );
435
436        }
437
438    };
439
440    Slick.prototype.buildArrows = function() {
441
442        var _ = this;
443
444        if (_.options.arrows === true ) {
445
446            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
447            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
448
449            if( _.slideCount > _.options.slidesToShow ) {
450
451                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
452                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
453
454                if (_.htmlExpr.test(_.options.prevArrow)) {
455                    _.$prevArrow.prependTo(_.options.appendArrows);
456                }
457
458                if (_.htmlExpr.test(_.options.nextArrow)) {
459                    _.$nextArrow.appendTo(_.options.appendArrows);
460                }
461
462                if (_.options.infinite !== true) {
463                    _.$prevArrow
464                        .addClass('slick-disabled')
465                        .attr('aria-disabled', 'true');
466                }
467
468            } else {
469
470                _.$prevArrow.add( _.$nextArrow )
471
472                    .addClass('slick-hidden')
473                    .attr({
474                        'aria-disabled': 'true',
475                        'tabindex': '-1'
476                    });
477
478            }
479
480        }
481
482    };
483
484    Slick.prototype.buildDots = function() {
485
486        var _ = this,
487            i, dot;
488
489        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
490
491            _.$slider.addClass('slick-dotted');
492
493            dot = $('<ul />').addClass(_.options.dotsClass);
494
495            for (i = 0; i <= _.getDotCount(); i += 1) {
496                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
497            }
498
499            _.$dots = dot.appendTo(_.options.appendDots);
500
501            _.$dots.find('li').first().addClass('slick-active');
502
503        }
504
505    };
506
507    Slick.prototype.buildOut = function() {
508
509        var _ = this;
510
511        _.$slides =
512            _.$slider
513                .children( _.options.slide + ':not(.slick-cloned)')
514                .addClass('slick-slide');
515
516        _.slideCount = _.$slides.length;
517
518        _.$slides.each(function(index, element) {
519            $(element)
520                .attr('data-slick-index', index)
521                .data('originalStyling', $(element).attr('style') || '');
522        });
523
524        _.$slider.addClass('slick-slider');
525
526        _.$slideTrack = (_.slideCount === 0) ?
527            $('<div class="slick-track"/>').appendTo(_.$slider) :
528            _.$slides.wrapAll('<div class="slick-track"/>').parent();
529
530        _.$list = _.$slideTrack.wrap(
531            '<div class="slick-list"/>').parent();
532        _.$slideTrack.css('opacity', 0);
533
534        if (_.options.centerMode === true || _.options.swipeToSlide === true) {
535            _.options.slidesToScroll = 1;
536        }
537
538        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
539
540        _.setupInfinite();
541
542        _.buildArrows();
543
544        _.buildDots();
545
546        _.updateDots();
547
548
549        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
550
551        if (_.options.draggable === true) {
552            _.$list.addClass('draggable');
553        }
554
555    };
556
557    Slick.prototype.buildRows = function() {
558
559        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
560
561        newSlides = document.createDocumentFragment();
562        originalSlides = _.$slider.children();
563
564        if(_.options.rows > 0) {
565
566            slidesPerSection = _.options.slidesPerRow * _.options.rows;
567            numOfSlides = Math.ceil(
568                originalSlides.length / slidesPerSection
569            );
570
571            for(a = 0; a < numOfSlides; a++){
572                var slide = document.createElement('div');
573                for(b = 0; b < _.options.rows; b++) {
574                    var row = document.createElement('div');
575                    for(c = 0; c < _.options.slidesPerRow; c++) {
576                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
577                        if (originalSlides.get(target)) {
578                            row.appendChild(originalSlides.get(target));
579                        }
580                    }
581                    slide.appendChild(row);
582                }
583                newSlides.appendChild(slide);
584            }
585
586            _.$slider.empty().append(newSlides);
587            _.$slider.children().children().children()
588                .css({
589                    'width':(100 / _.options.slidesPerRow) + '%',
590                    'display': 'inline-block'
591                });
592
593        }
594
595    };
596
597    Slick.prototype.checkResponsive = function(initial, forceUpdate) {
598
599        var _ = this,
600            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
601        var sliderWidth = _.$slider.width();
602        var windowWidth = window.innerWidth || $(window).width();
603
604        if (_.respondTo === 'window') {
605            respondToWidth = windowWidth;
606        } else if (_.respondTo === 'slider') {
607            respondToWidth = sliderWidth;
608        } else if (_.respondTo === 'min') {
609            respondToWidth = Math.min(windowWidth, sliderWidth);
610        }
611
612        if ( _.options.responsive &&
613            _.options.responsive.length &&
614            _.options.responsive !== null) {
615
616            targetBreakpoint = null;
617
618            for (breakpoint in _.breakpoints) {
619                if (_.breakpoints.hasOwnProperty(breakpoint)) {
620                    if (_.originalSettings.mobileFirst === false) {
621                        if (respondToWidth < _.breakpoints[breakpoint]) {
622                            targetBreakpoint = _.breakpoints[breakpoint];
623                        }
624                    } else {
625                        if (respondToWidth > _.breakpoints[breakpoint]) {
626                            targetBreakpoint = _.breakpoints[breakpoint];
627                        }
628                    }
629                }
630            }
631
632            if (targetBreakpoint !== null) {
633                if (_.activeBreakpoint !== null) {
634                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
635                        _.activeBreakpoint =
636                            targetBreakpoint;
637                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
638                            _.unslick(targetBreakpoint);
639                        } else {
640                            _.options = $.extend({}, _.originalSettings,
641                                _.breakpointSettings[
642                                    targetBreakpoint]);
643                            if (initial === true) {
644                                _.currentSlide = _.options.initialSlide;
645                            }
646                            _.refresh(initial);
647                        }
648                        triggerBreakpoint = targetBreakpoint;
649                    }
650                } else {
651                    _.activeBreakpoint = targetBreakpoint;
652                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
653                        _.unslick(targetBreakpoint);
654                    } else {
655                        _.options = $.extend({}, _.originalSettings,
656                            _.breakpointSettings[
657                                targetBreakpoint]);
658                        if (initial === true) {
659                            _.currentSlide = _.options.initialSlide;
660                        }
661                        _.refresh(initial);
662                    }
663                    triggerBreakpoint = targetBreakpoint;
664                }
665            } else {
666                if (_.activeBreakpoint !== null) {
667                    _.activeBreakpoint = null;
668                    _.options = _.originalSettings;
669                    if (initial === true) {
670                        _.currentSlide = _.options.initialSlide;
671                    }
672                    _.refresh(initial);
673                    triggerBreakpoint = targetBreakpoint;
674                }
675            }
676
677            // only trigger breakpoints during an actual break. not on initialize.
678            if( !initial && triggerBreakpoint !== false ) {
679                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
680            }
681        }
682
683    };
684
685    Slick.prototype.changeSlide = function(event, dontAnimate) {
686
687        var _ = this,
688            $target = $(event.currentTarget),
689            indexOffset, slideOffset, unevenOffset;
690
691        // If target is a link, prevent default action.
692        if($target.is('a')) {
693            event.preventDefault();
694        }
695
696        // If target is not the <li> element (ie: a child), find the <li>.
697        if(!$target.is('li')) {
698            $target = $target.closest('li');
699        }
700
701        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
702        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
703
704        switch (event.data.message) {
705
706            case 'previous':
707                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
708                if (_.slideCount > _.options.slidesToShow) {
709                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
710                }
711                break;
712
713            case 'next':
714                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
715                if (_.slideCount > _.options.slidesToShow) {
716                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
717                }
718                break;
719
720            case 'index':
721                var index = event.data.index === 0 ? 0 :
722                    event.data.index || $target.index() * _.options.slidesToScroll;
723
724                _.slideHandler(_.checkNavigable(index), false, dontAnimate);
725                $target.children().trigger('focus');
726                break;
727
728            default:
729                return;
730        }
731
732    };
733
734    Slick.prototype.checkNavigable = function(index) {
735
736        var _ = this,
737            navigables, prevNavigable;
738
739        navigables = _.getNavigableIndexes();
740        prevNavigable = 0;
741        if (index > navigables[navigables.length - 1]) {
742            index = navigables[navigables.length - 1];
743        } else {
744            for (var n in navigables) {
745                if (index < navigables[n]) {
746                    index = prevNavigable;
747                    break;
748                }
749                prevNavigable = navigables[n];
750            }
751        }
752
753        return index;
754    };
755
756    Slick.prototype.cleanUpEvents = function() {
757
758        var _ = this;
759
760        if (_.options.dots && _.$dots !== null) {
761
762            $('li', _.$dots)
763                .off('click.slick', _.changeSlide)
764                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
765                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
766
767            if (_.options.accessibility === true) {
768                _.$dots.off('keydown.slick', _.keyHandler);
769            }
770        }
771
772        _.$slider.off('focus.slick blur.slick');
773
774        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
775            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
776            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
777
778            if (_.options.accessibility === true) {
779                _.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler);
780                _.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler);
781            }
782        }
783
784        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
785        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
786        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
787        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
788
789        _.$list.off('click.slick', _.clickHandler);
790
791        $(document).off(_.visibilityChange, _.visibility);
792
793        _.cleanUpSlideEvents();
794
795        if (_.options.accessibility === true) {
796            _.$list.off('keydown.slick', _.keyHandler);
797        }
798
799        if (_.options.focusOnSelect === true) {
800            $(_.$slideTrack).children().off('click.slick', _.selectHandler);
801        }
802
803        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
804
805        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
806
807        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
808
809        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
810
811    };
812
813    Slick.prototype.cleanUpSlideEvents = function() {
814
815        var _ = this;
816
817        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
818        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
819
820    };
821
822    Slick.prototype.cleanUpRows = function() {
823
824        var _ = this, originalSlides;
825
826        if(_.options.rows > 0) {
827            originalSlides = _.$slides.children().children();
828            originalSlides.removeAttr('style');
829            _.$slider.empty().append(originalSlides);
830        }
831
832    };
833
834    Slick.prototype.clickHandler = function(event) {
835
836        var _ = this;
837
838        if (_.shouldClick === false) {
839            event.stopImmediatePropagation();
840            event.stopPropagation();
841            event.preventDefault();
842        }
843
844    };
845
846    Slick.prototype.destroy = function(refresh) {
847
848        var _ = this;
849
850        _.autoPlayClear();
851
852        _.touchObject = {};
853
854        _.cleanUpEvents();
855
856        $('.slick-cloned', _.$slider).detach();
857
858        if (_.$dots) {
859            _.$dots.remove();
860        }
861
862        if ( _.$prevArrow && _.$prevArrow.length ) {
863
864            _.$prevArrow
865                .removeClass('slick-disabled slick-arrow slick-hidden')
866                .removeAttr('aria-hidden aria-disabled tabindex')
867                .css('display','');
868
869            if ( _.htmlExpr.test( _.options.prevArrow )) {
870                _.$prevArrow.remove();
871            }
872        }
873
874        if ( _.$nextArrow && _.$nextArrow.length ) {
875
876            _.$nextArrow
877                .removeClass('slick-disabled slick-arrow slick-hidden')
878                .removeAttr('aria-hidden aria-disabled tabindex')
879                .css('display','');
880
881            if ( _.htmlExpr.test( _.options.nextArrow )) {
882                _.$nextArrow.remove();
883            }
884        }
885
886
887        if (_.$slides) {
888
889            _.$slides
890                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
891                .removeAttr('aria-hidden')
892                .removeAttr('data-slick-index')
893                .each(function(){
894                    $(this).attr('style', $(this).data('originalStyling'));
895                });
896
897            _.$slideTrack.children(this.options.slide).detach();
898
899            _.$slideTrack.detach();
900
901            _.$list.detach();
902
903            _.$slider.append(_.$slides);
904        }
905

1080            pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);
1081        }else {
1082            while (breakPoint < _.slideCount) {
1083                ++pagerQty;
1084                breakPoint = counter + _.options.slidesToScroll;
1085                counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1086            }
1087        }
1088
1089        return pagerQty - 1;
1090
1091    };
1092
1093    Slick.prototype.getLeft = function(slideIndex) {
1094
1095        var _ = this,
1096            targetLeft,
1097            verticalHeight,
1098            verticalOffset = 0,
1099            targetSlide,
1100            coef;
1101
1102        _.slideOffset = 0;
1103        verticalHeight = _.$slides.first().outerHeight(true);
1104
1105        if (_.options.infinite === true) {
1106            if (_.slideCount > _.options.slidesToShow) {
1107                _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
1108                coef = -1
1109
1110                if (_.options.vertical === true && _.options.centerMode === true) {
1111                    if (_.options.slidesToShow === 2) {
1112                        coef = -1.5;
1113                    } else if (_.options.slidesToShow === 1) {
1114                        coef = -2
1115                    }
1116                }
1117                verticalOffset = (verticalHeight * _.options.slidesToShow) * coef;
1118            }
1119            if (_.slideCount % _.options.slidesToScroll !== 0) {
1120                if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
1121                    if (slideIndex > _.slideCount) {
1122                        _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
1123                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
1124                    } else {
1125                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
1126                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
1127                    }
1128                }
1129            }
1130        } else {
1131            if (slideIndex + _.options.slidesToShow > _.slideCount) {
1132                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
1133                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
1134            }
1135        }
1136
1137        if (_.slideCount <= _.options.slidesToShow) {
1138            _.slideOffset = 0;
1139            verticalOffset = 0;
1140        }
1141
1142        if (_.options.centerMode === true && _.slideCount <= _.options.slidesToShow) {
1143            _.slideOffset = ((_.slideWidth * Math.floor(_.options.slidesToShow)) / 2) - ((_.slideWidth * _.slideCount) / 2);
1144        } else if (_.options.centerMode === true && _.options.infinite === true) {
1145            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
1146        } else if (_.options.centerMode === true) {
1147            _.slideOffset = 0;
1148            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
1149        }
1150
1151        if (_.options.vertical === false) {
1152            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
1153        } else {
1154            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
1155        }
1156
1157        if (_.options.variableWidth === true) {
1158

1331                tabControlIndexes = _.getNavigableIndexes().filter(function(val) {
1332                    return (val >= 0) && (val < _.slideCount);
1333                });
1334
1335        _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({
1336            'aria-hidden': 'true',
1337            'tabindex': '-1'
1338        }).find('a, input, button, select').attr({
1339            'tabindex': '-1'
1340        });
1341
1342        if (_.$dots !== null) {
1343            _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {
1344                var slideControlIndex = tabControlIndexes.indexOf(i);
1345
1346                $(this).attr({
1347                    'role': 'tabpanel',
1348                    'id': 'slick-slide' + _.instanceUid + i,
1349                    'tabindex': -1
1350                });
1351
1352                if (slideControlIndex !== -1) {
1353                   var ariaButtonControl = 'slick-slide-control' + _.instanceUid + slideControlIndex
1354                   if ($('#' + ariaButtonControl).length) {
1355                     $(this).attr({
1356                         'aria-describedby': ariaButtonControl
1357                     });
1358                   }
1359                }
1360            });
1361
1362            _.$dots.attr('role', 'tablist').find('li').each(function(i) {
1363                var mappedSlideIndex = tabControlIndexes[i];
1364
1365                $(this).attr({
1366                    'role': 'presentation'
1367                });
1368
1369                $(this).find('button').first().attr({
1370                    'role': 'tab',
1371                    'id': 'slick-slide-control' + _.instanceUid + i,
1372                    'aria-controls': 'slick-slide' + _.instanceUid + mappedSlideIndex,
1373                    'aria-label': (i + 1) + ' of ' + numDotGroups,
1374                    'aria-selected': null,
1375                    'tabindex': '-1'
1376                });
1377
1378            }).eq(_.currentSlide).find('button').attr({
1379                'aria-selected': 'true',
1380                'tabindex': '0'
1381            }).end();
1382        }
1383
1384        for (var i=_.currentSlide, max=i+_.options.slidesToShow; i < max; i++) {
1385          if (_.options.focusOnChange) {
1386            _.$slides.eq(i).attr({'tabindex': '0'});
1387          } else {
1388            _.$slides.eq(i).removeAttr('tabindex');
1389          }
1390        }
1391
1392        _.activateADA();
1393
1394    };
1395
1396    Slick.prototype.initArrowEvents = function() {
1397
1398        var _ = this;
1399
1400        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1401            _.$prevArrow
1402               .off('click.slick')
1403               .on('click.slick', {
1404                    message: 'previous'
1405               }, _.changeSlide);
1406            _.$nextArrow
1407               .off('click.slick')
1408               .on('click.slick', {
1409                    message: 'next'
1410               }, _.changeSlide);
1411
1412            if (_.options.accessibility === true) {
1413                _.$prevArrow.on('keydown.slick', _.keyHandler);
1414                _.$nextArrow.on('keydown.slick', _.keyHandler);
1415            }
1416        }
1417
1418    };
1419
1420    Slick.prototype.initDotEvents = function() {
1421
1422        var _ = this;
1423
1424        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1425            $('li', _.$dots).on('click.slick', {
1426                message: 'index'
1427            }, _.changeSlide);
1428
1429            if (_.options.accessibility === true) {
1430                _.$dots.on('keydown.slick', _.keyHandler);
1431            }
1432        }
1433
1434        if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.slideCount > _.options.slidesToShow) {
1435
1436            $('li', _.$dots)
1437                .on('mouseenter.slick', $.proxy(_.interrupt, _, true))
1438                .on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1439
1440        }
1441
1442    };
1443
1444    Slick.prototype.initSlideEvents = function() {
1445
1446        var _ = this;
1447
1448        if ( _.options.pauseOnHover ) {
1449
1450            _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));
1451            _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1452
1453        }
1454
1455    };
1456
1457    Slick.prototype.initializeEvents = function() {
1458
1459        var _ = this;
1460
1461        _.initArrowEvents();
1462
1463        _.initDotEvents();
1464        _.initSlideEvents();
1465
1466        _.$list.on('touchstart.slick mousedown.slick', {
1467            action: 'start'
1468        }, _.swipeHandler);
1469        _.$list.on('touchmove.slick mousemove.slick', {
1470            action: 'move'
1471        }, _.swipeHandler);
1472        _.$list.on('touchend.slick mouseup.slick', {
1473            action: 'end'
1474        }, _.swipeHandler);
1475        _.$list.on('touchcancel.slick mouseleave.slick', {
1476            action: 'end'
1477        }, _.swipeHandler);
1478
1479        _.$list.on('click.slick', _.clickHandler);
1480
1481        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
1482
1483        if (_.options.accessibility === true) {
1484            _.$list.on('keydown.slick', _.keyHandler);
1485        }
1486
1487        if (_.options.focusOnSelect === true) {
1488            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1489        }
1490
1491        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
1492
1493        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
1494
1495        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
1496
1497        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
1498        $(_.setPosition);
1499
1500    };
1501
1502    Slick.prototype.initUI = function() {
1503
1504        var _ = this;
1505
1506        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1507
1508            _.$prevArrow.show();
1509            _.$nextArrow.show();
1510
1511        }
1512
1513        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1514
1515            _.$dots.show();
1516
1517        }
1518
1519    };
1520
1521    Slick.prototype.keyHandler = function(event) {
1522
1523        var _ = this;
1524         //Dont slide if the cursor is inside the form fields and arrow keys are pressed
1525        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
1526            if (event.keyCode === 37 && _.options.accessibility === true) {
1527                _.changeSlide({
1528                    data: {
1529                        message: _.options.rtl === true ? 'next' :  'previous'
1530                    }
1531                });
1532            } else if (event.keyCode === 39 && _.options.accessibility === true) {
1533                _.changeSlide({
1534                    data: {
1535                        message: _.options.rtl === true ? 'previous' : 'next'
1536                    }
1537                });
1538            }
1539        }
1540
1541    };
1542
1543    Slick.prototype.lazyLoad = function() {
1544
1545        var _ = this,
1546            loadRange, cloneRange, rangeStart, rangeEnd;
1547
1548        function loadImages(imagesScope) {
1549
1550            $('img[data-lazy]', imagesScope).each(function() {
1551
1552                var image = $(this),
1553                    imageSource = $(this).attr('data-lazy'),
1554                    imageSrcSet = $(this).attr('data-srcset'),
1555                    imageSizes  = $(this).attr('data-sizes') || _.$slider.attr('data-sizes'),
1556                    imageToLoad = document.createElement('img');
1557
1558                imageToLoad.onload = function() {
1559
1560                    image
1561                        .animate({ opacity: 0 }, 100, function() {
1562
1563                            if (imageSrcSet) {
1564                                image
1565                                    .attr('srcset', imageSrcSet );
1566
1567                                if (imageSizes) {
1568                                    image
1569                                        .attr('sizes', imageSizes );
1570                                }
1571                            }
1572
1573                            image
1574                                .attr('src', imageSource)
1575                                .animate({ opacity: 1 }, 200, function() {
1576                                    image
1577                                        .removeAttr('data-lazy data-srcset data-sizes')
1578                                        .removeClass('slick-loading');
1579                                });
1580                            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
1581                        });
1582
1583                };
1584
1585                imageToLoad.onerror = function() {
1586
1587                    image
1588                        .removeAttr( 'data-lazy' )
1589                        .removeClass( 'slick-loading' )
1590                        .addClass( 'slick-lazyload-error' );
1591
1592                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1593
1594                };
1595
1596                imageToLoad.src = imageSource;
1597
1598            });
1599
1600        }
1601
1602        if (_.options.centerMode === true) {
1603            if (_.options.infinite === true) {
1604                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
1605                rangeEnd = rangeStart + _.options.slidesToShow + 2;
1606            } else {
1607                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
1608                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
1609            }
1610        } else {
1611            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
1612            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
1613            if (_.options.fade === true) {
1614                if (rangeStart > 0) rangeStart--;
1615                if (rangeEnd <= _.slideCount) rangeEnd++;
1616            }
1617        }
1618
1619        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
1620
1621        if (_.options.lazyLoad === 'anticipated') {
1622            var prevSlide = rangeStart - 1,
1623                nextSlide = rangeEnd,
1624                $slides = _.$slider.find('.slick-slide');
1625
1626            for (var i = 0; i < _.options.slidesToScroll; i++) {
1627                if (prevSlide < 0) prevSlide = _.slideCount - 1;
1628                loadRange = loadRange.add($slides.eq(prevSlide));
1629                loadRange = loadRange.add($slides.eq(nextSlide));
1630                prevSlide--;
1631                nextSlide++;
1632            }
1633        }
1634
1635        loadImages(loadRange);
1636
1637        if (_.slideCount <= _.options.slidesToShow) {
1638            cloneRange = _.$slider.find('.slick-slide');
1639            loadImages(cloneRange);
1640        } else
1641        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1642            cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
1643            loadImages(cloneRange);
1644        } else if (_.currentSlide === 0) {
1645            cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
1646            loadImages(cloneRange);
1647        }
1648
1649    };
1650
1651    Slick.prototype.loadSlider = function() {
1652
1653        var _ = this;
1654
1655        _.setPosition();
1656
1657        _.$slideTrack.css({
1658            opacity: 1
1659        });
1660
1661        _.$slider.removeClass('slick-loading');
1662
1663        _.initUI();
1664
1665        if (_.options.lazyLoad === 'progressive') {
1666            _.progressiveLazyLoad();
1667        }
1668
1669    };
1670
1671    Slick.prototype.next = Slick.prototype.slickNext = function() {
1672
1673        var _ = this;
1674
1675        _.changeSlide({
1676            data: {
1677                message: 'next'
1678            }
1679        });
1680
1681    };
1682
1683    Slick.prototype.orientationChange = function() {
1684
1685        var _ = this;
1686
1687        _.checkResponsive();
1688        _.setPosition();
1689
1690    };
1691
1692    Slick.prototype.pause = Slick.prototype.slickPause = function() {
1693
1694        var _ = this;
1695
1696        _.autoPlayClear();
1697        _.paused = true;
1698
1699    };
1700
1701    Slick.prototype.play = Slick.prototype.slickPlay = function() {
1702
1703        var _ = this;
1704
1705        _.autoPlay();
1706        _.options.autoplay = true;
1707        _.paused = false;
1708        _.focussed = false;
1709        _.interrupted = false;
1710
1711    };
1712
1713    Slick.prototype.postSlide = function(index) {
1714
1715        var _ = this;
1716
1717        if( !_.unslicked ) {
1718
1719            _.$slider.trigger('afterChange', [_, index]);
1720
1721            _.animating = false;
1722
1723            if (_.slideCount > _.options.slidesToShow) {
1724                _.setPosition();
1725            }
1726
1727            _.swipeLeft = null;
1728
1729            if ( _.options.autoplay ) {
1730                _.autoPlay();
1731            }
1732
1733            if (_.options.accessibility === true) {
1734                _.initADA();
1735
1736                if (_.options.focusOnChange) {
1737                    var $currentSlide = $(_.$slides.get(_.currentSlide));
1738                    $currentSlide.attr('tabindex', 0).focus();
1739                }
1740            }
1741
1742        }
1743
1744    };
1745
1746    Slick.prototype.prev = Slick.prototype.slickPrev = function() {
1747
1748        var _ = this;
1749
1750        _.changeSlide({
1751            data: {
1752                message: 'previous'
1753            }
1754        });
1755
1756    };
1757
1758    Slick.prototype.preventDefault = function(event) {
1759
1760        event.preventDefault();
1761
1762    };
1763
1764    Slick.prototype.progressiveLazyLoad = function( tryCount ) {
1765
1766        tryCount = tryCount || 1;
1767
1768        var _ = this,
1769            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
1770            image,
1771            imageSource,
1772            imageSrcSet,
1773            imageSizes,
1774            imageToLoad;
1775
1776        if ( $imgsToLoad.length ) {
1777
1778            image = $imgsToLoad.first();
1779            imageSource = image.attr('data-lazy');
1780            imageSrcSet = image.attr('data-srcset');
1781            imageSizes  = image.attr('data-sizes') || _.$slider.attr('data-sizes');
1782            imageToLoad = document.createElement('img');
1783
1784            imageToLoad.onload = function() {
1785
1786                if (imageSrcSet) {
1787                    image
1788                        .attr('srcset', imageSrcSet );
1789
1790                    if (imageSizes) {
1791                        image
1792                            .attr('sizes', imageSizes );
1793                    }
1794                }
1795
1796                image
1797                    .attr( 'src', imageSource )
1798                    .removeAttr('data-lazy data-srcset data-sizes')
1799                    .removeClass('slick-loading');
1800
1801                if ( _.options.adaptiveHeight === true ) {
1802                    _.setPosition();
1803                }
1804
1805                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
1806                _.progressiveLazyLoad();
1807
1808            };
1809
1810            imageToLoad.onerror = function() {
1811
1812                if ( tryCount < 3 ) {
1813
1814                    /**
1815                     * try to load the image 3 times,
1816                     * leave a slight delay so we don't get
1817                     * servers blocking the request.
1818                     */
1819                    setTimeout( function() {
1820                        _.progressiveLazyLoad( tryCount + 1 );
1821                    }, 500 );
1822
1823                } else {
1824
1825                    image
1826                        .removeAttr( 'data-lazy' )
1827                        .removeClass( 'slick-loading' )
1828                        .addClass( 'slick-lazyload-error' );
1829
1830                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1831
1832                    _.progressiveLazyLoad();
1833
1834                }
1835
1836            };
1837
1838            imageToLoad.src = imageSource;
1839
1840        } else {
1841
1842            _.$slider.trigger('allImagesLoaded', [ _ ]);
1843
1844        }
1845
1846    };
1847
1848    Slick.prototype.refresh = function( initializing ) {
1849
1850        var _ = this, currentSlide, lastVisibleIndex;
1851
1852        lastVisibleIndex = _.slideCount - _.options.slidesToShow;
1853
1854        // in non-infinite sliders, we don't want to go past the
1855        // last visible index.
1856        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
1857            _.currentSlide = lastVisibleIndex;
1858        }
1859
1860        // if less slides than to show, go to start.
1861        if ( _.slideCount <= _.options.slidesToShow ) {
1862            _.currentSlide = 0;
1863
1864        }
1865
1866        currentSlide = _.currentSlide;
1867
1868        _.destroy(true);
1869
1870        $.extend(_, _.initials, { currentSlide: currentSlide });
1871
1872        _.init();
1873
1874        if( !initializing ) {
1875
1876            _.changeSlide({
1877                data: {
1878                    message: 'index',
1879                    index: currentSlide
1880                }
1881            }, false);
1882
1883        }
1884
1885    };
1886
1887    Slick.prototype.registerBreakpoints = function() {
1888
1889        var _ = this, breakpoint, currentBreakpoint, l,
1890            responsiveSettings = _.options.responsive || null;
1891
1892        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
1893
1894            _.respondTo = _.options.respondTo || 'window';
1895
1896            for ( breakpoint in responsiveSettings ) {
1897
1898                l = _.breakpoints.length-1;
1899
1900                if (responsiveSettings.hasOwnProperty(breakpoint)) {
1901                    currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
1902
1903                    // loop through the breakpoints and cut out any existing
1904                    // ones with the same breakpoint number, we don't want dupes.
1905                    while( l >= 0 ) {
1906                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
1907                            _.breakpoints.splice(l,1);
1908                        }
1909                        l--;
1910                    }
1911
1912                    _.breakpoints.push(currentBreakpoint);
1913                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
1914
1915                }
1916
1917            }
1918
1919            _.breakpoints.sort(function(a, b) {
1920                return ( _.options.mobileFirst ) ? a-b : b-a;
1921            });
1922
1923        }
1924
1925    };
1926
1927    Slick.prototype.reinit = function() {
1928
1929        var _ = this;
1930
1931        _.$slides =
1932            _.$slideTrack
1933                .children(_.options.slide)
1934                .addClass('slick-slide');
1935
1936        _.slideCount = _.$slides.length;
1937
1938        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1939            _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1940        }
1941
1942        if (_.slideCount <= _.options.slidesToShow) {
1943            _.currentSlide = 0;
1944        }
1945
1946        _.registerBreakpoints();
1947
1948        _.setProps();
1949        _.setupInfinite();
1950        _.buildArrows();
1951        _.updateArrows();
1952        _.initArrowEvents();
1953        _.buildDots();
1954        _.updateDots();
1955        _.initDotEvents();
1956        _.cleanUpSlideEvents();
1957        _.initSlideEvents();
1958
1959        _.checkResponsive(false, true);
1960
1961        if (_.options.focusOnSelect === true) {
1962            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1963        }
1964
1965        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1966
1967        _.setPosition();
1968        _.focusHandler();
1969
1970        _.paused = !_.options.autoplay;
1971        _.autoPlay();
1972
1973        _.$slider.trigger('reInit', [_]);
1974
1975    };
1976
1977    Slick.prototype.resize = function() {
1978
1979        var _ = this;
1980
1981        if ($(window).width() !== _.windowWidth) {
1982            clearTimeout(_.windowDelay);
1983            _.windowDelay = window.setTimeout(function() {
1984                _.windowWidth = $(window).width();
1985                _.checkResponsive();
1986                if( !_.unslicked ) { _.setPosition(); }
1987            }, 50);
1988        }
1989    };
1990
1991    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
1992
1993        var _ = this;
1994
1995        if (typeof(index) === 'boolean') {
1996            removeBefore = index;
1997            index = removeBefore === true ? 0 : _.slideCount - 1;
1998        } else {
1999            index = removeBefore === true ? --index : index;
2000        }
2001
2002        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
2003            return false;
2004        }
2005
2006        _.unload();
2007
2008        if (removeAll === true) {
2009            _.$slideTrack.children().remove();
2010        } else {
2011            _.$slideTrack.children(this.options.slide).eq(index).remove();
2012        }
2013
2014        _.$slides = _.$slideTrack.children(this.options.slide);
2015
2016        _.$slideTrack.children(this.options.slide).detach();
2017
2018        _.$slideTrack.append(_.$slides);
2019
2020        _.$slidesCache = _.$slides;
2021
2022        _.reinit();
2023
2024    };
2025
2026    Slick.prototype.setCSS = function(position) {
2027
2028        var _ = this,
2029            positionProps = {},
2030            x, y;
2031
2032        if (_.options.rtl === true) {
2033            position = -position;
2034        }
2035        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
2036        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
2037
2038        positionProps[_.positionProp] = position;
2039
2040        if (_.transformsEnabled === false) {
2041            _.$slideTrack.css(positionProps);
2042        } else {
2043            positionProps = {};
2044            if (_.cssTransitions === false) {
2045                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
2046                _.$slideTrack.css(positionProps);
2047            } else {
2048                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
2049                _.$slideTrack.css(positionProps);
2050            }
2051        }
2052
2053    };
2054
2055    Slick.prototype.setDimensions = function() {
2056
2057        var _ = this;
2058
2059        if (_.options.vertical === false) {
2060            if (_.options.centerMode === true) {
2061                _.$list.css({
2062                    padding: ('0px ' + _.options.centerPadding)
2063                });
2064            }
2065        } else {
2066            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
2067            if (_.options.centerMode === true) {
2068                _.$list.css({
2069                    padding: (_.options.centerPadding + ' 0px')
2070                });
2071            }
2072        }
2073
2074        _.listWidth = _.$list.width();
2075        _.listHeight = _.$list.height();
2076
2077
2078        if (_.options.vertical === false && _.options.variableWidth === false) {
2079            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
2080            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
2081
2082        } else if (_.options.variableWidth === true) {
2083            _.$slideTrack.width(5000 * _.slideCount);
2084        } else {
2085            _.slideWidth = Math.ceil(_.listWidth);
2086            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
2087        }
2088
2089        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
2090        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
2091
2092    };
2093
2094    Slick.prototype.setFade = function() {
2095
2096        var _ = this,
2097            targetLeft;
2098
2099        _.$slides.each(function(index, element) {
2100            targetLeft = (_.slideWidth * index) * -1;
2101            if (_.options.rtl === true) {
2102                $(element).css({
2103                    position: 'relative',
2104                    right: targetLeft,
2105                    top: 0,
2106                    zIndex: _.options.zIndex - 2,
2107                    opacity: 0
2108                });
2109            } else {
2110                $(element).css({
2111                    position: 'relative',
2112                    left: targetLeft,
2113                    top: 0,
2114                    zIndex: _.options.zIndex - 2,
2115                    opacity: 0
2116                });
2117            }
2118        });
2119
2120        _.$slides.eq(_.currentSlide).css({
2121            zIndex: _.options.zIndex - 1,
2122            opacity: 1
2123        });
2124
2125    };
2126
2127    Slick.prototype.setHeight = function() {
2128
2129        var _ = this;
2130
2131        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
2132            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
2133            _.$list.css('height', targetHeight);
2134        }
2135
2136    };
2137
2138    Slick.prototype.setOption =
2139    Slick.prototype.slickSetOption = function() {
2140
2141        /**
2142         * accepts arguments in format of:
2143         *
2144         *  - for changing a single option's value:
2145         *     .slick("setOption", option, value, refresh )
2146         *
2147         *  - for changing a set of responsive options:
2148         *     .slick("setOption", 'responsive', [{}, ...], refresh )
2149         *
2150         *  - for updating multiple values at once (not responsive)
2151         *     .slick("setOption", { 'option': value, ... }, refresh )
2152         */
2153
2154        var _ = this, l, item, option, value, refresh = false, type;
2155
2156        if( $.type( arguments[0] ) === 'object' ) {
2157
2158            option =  arguments[0];
2159            refresh = arguments[1];
2160            type = 'multiple';
2161
2162        } else if ( $.type( arguments[0] ) === 'string' ) {
2163
2164            option =  arguments[0];
2165            value = arguments[1];
2166            refresh = arguments[2];
2167
2168            if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
2169
2170                type = 'responsive';
2171
2172            } else if ( typeof arguments[1] !== 'undefined' ) {
2173
2174                type = 'single';
2175
2176            }
2177
2178        }
2179
2180        if ( type === 'single' ) {
2181
2182            _.options[option] = value;
2183
2184
2185        } else if ( type === 'multiple' ) {
2186
2187            $.each( option , function( opt, val ) {
2188
2189                _.options[opt] = val;
2190
2191            });
2192
2193
2194        } else if ( type === 'responsive' ) {
2195
2196            for ( item in value ) {
2197
2198                if( $.type( _.options.responsive ) !== 'array' ) {
2199
2200                    _.options.responsive = [ value[item] ];
2201
2202                } else {
2203
2204                    l = _.options.responsive.length-1;
2205
2206                    // loop through the responsive object and splice out duplicates.
2207                    while( l >= 0 ) {
2208
2209                        if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
2210
2211                            _.options.responsive.splice(l,1);
2212
2213                        }
2214
2215                        l--;
2216
2217                    }
2218
2219                    _.options.responsive.push( value[item] );
2220
2221                }
2222
2223            }
2224
2225        }
2226
2227        if ( refresh ) {
2228
2229            _.unload();
2230            _.reinit();
2231
2232        }
2233
2234    };
2235
2236    Slick.prototype.setPosition = function() {
2237
2238        var _ = this;
2239
2240        _.setDimensions();
2241
2242        _.setHeight();
2243
2244        if (_.options.fade === false) {
2245            _.setCSS(_.getLeft(_.currentSlide));
2246        } else {
2247            _.setFade();
2248        }
2249
2250        _.$slider.trigger('setPosition', [_]);
2251
2252    };
2253
2254    Slick.prototype.setProps = function() {
2255
2256        var _ = this,
2257            bodyStyle = document.body.style;
2258
2259        _.positionProp = _.options.vertical === true ? 'top' : 'left';
2260
2261        if (_.positionProp === 'top') {
2262            _.$slider.addClass('slick-vertical');
2263        } else {
2264            _.$slider.removeClass('slick-vertical');
2265        }
2266
2267        if (bodyStyle.WebkitTransition !== undefined ||
2268            bodyStyle.MozTransition !== undefined ||
2269            bodyStyle.msTransition !== undefined) {
2270            if (_.options.useCSS === true) {
2271                _.cssTransitions = true;
2272            }
2273        }
2274
2275        if ( _.options.fade ) {
2276            if ( typeof _.options.zIndex === 'number' ) {
2277                if( _.options.zIndex < 3 ) {
2278                    _.options.zIndex = 3;
2279                }
2280            } else {
2281                _.options.zIndex = _.defaults.zIndex;
2282            }
2283        }
2284
2285        if (bodyStyle.OTransform !== undefined) {
2286            _.animType = 'OTransform';
2287            _.transformType = '-o-transform';
2288            _.transitionType = 'OTransition';
2289            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2290        }
2291        if (bodyStyle.MozTransform !== undefined) {
2292            _.animType = 'MozTransform';
2293            _.transformType = '-moz-transform';
2294            _.transitionType = 'MozTransition';
2295            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
2296        }
2297        if (bodyStyle.webkitTransform !== undefined) {
2298            _.animType = 'webkitTransform';
2299            _.transformType = '-webkit-transform';
2300            _.transitionType = 'webkitTransition';
2301            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2302        }
2303        if (bodyStyle.msTransform !== undefined) {
2304            _.animType = 'msTransform';
2305            _.transformType = '-ms-transform';
2306            _.transitionType = 'msTransition';
2307            if (bodyStyle.msTransform === undefined) _.animType = false;
2308        }
2309        if (bodyStyle.transform !== undefined && _.animType !== false) {
2310            _.animType = 'transform';
2311            _.transformType = 'transform';
2312            _.transitionType = 'transition';
2313        }
2314        _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
2315    };
2316
2317
2318    Slick.prototype.setSlideClasses = function(index) {
2319
2320        var _ = this,
2321            centerOffset, allSlides, indexOffset, remainder;
2322
2323        allSlides = _.$slider
2324            .find('.slick-slide')
2325            .removeClass('slick-active slick-center slick-current')
2326            .attr('aria-hidden', 'true');
2327
2328        _.$slides
2329            .eq(index)
2330            .addClass('slick-current');
2331
2332        if (_.options.centerMode === true) {
2333
2334            var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0;
2335
2336            centerOffset = Math.floor(_.options.slidesToShow / 2);
2337
2338            if (_.options.infinite === true) {
2339
2340                if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
2341                    _.$slides
2342                        .slice(index - centerOffset + evenCoef, index + centerOffset + 1)
2343                        .addClass('slick-active')
2344                        .attr('aria-hidden', 'false');
2345
2346                } else {
2347
2348                    indexOffset = _.options.slidesToShow + index;
2349                    allSlides
2350                        .slice(indexOffset - centerOffset + 1 + evenCoef, indexOffset + centerOffset + 2)
2351                        .addClass('slick-active')
2352                        .attr('aria-hidden', 'false');
2353
2354                }
2355
2356                if (index === 0) {
2357
2358                    allSlides
2359                        .eq( _.options.slidesToShow + _.slideCount + 1 )
2360                        .addClass('slick-center');
2361
2362                } else if (index === _.slideCount - 1) {
2363
2364                    allSlides
2365                        .eq(_.options.slidesToShow)
2366                        .addClass('slick-center');
2367
2368                }
2369
2370            }
2371
2372            _.$slides
2373                .eq(index)
2374                .addClass('slick-center');
2375
2376        } else {
2377
2378            if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
2379
2380                _.$slides
2381                    .slice(index, index + _.options.slidesToShow)
2382                    .addClass('slick-active')
2383                    .attr('aria-hidden', 'false');
2384
2385            } else if (allSlides.length <= _.options.slidesToShow) {
2386
2387                allSlides
2388                    .addClass('slick-active')
2389                    .attr('aria-hidden', 'false');
2390
2391            } else {
2392
2393                remainder = _.slideCount % _.options.slidesToShow;
2394                indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
2395
2396                if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
2397
2398                    allSlides
2399                        .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)
2400                        .addClass('slick-active')
2401                        .attr('aria-hidden', 'false');
2402
2403                } else {
2404
2405                    allSlides
2406                        .slice(indexOffset, indexOffset + _.options.slidesToShow)
2407                        .addClass('slick-active')
2408                        .attr('aria-hidden', 'false');
2409
2410                }
2411
2412            }
2413
2414        }
2415
2416        if (_.options.lazyLoad === 'ondemand' || _.options.lazyLoad === 'anticipated') {
2417            _.lazyLoad();
2418        }
2419    };
2420
2421    Slick.prototype.setupInfinite = function() {
2422
2423        var _ = this,
2424            i, slideIndex, infiniteCount;
2425
2426        if (_.options.fade === true) {
2427            _.options.centerMode = false;
2428        }
2429
2430        if (_.options.infinite === true && _.options.fade === false) {
2431
2432            slideIndex = null;
2433
2434            if (_.slideCount > _.options.slidesToShow) {
2435
2436                if (_.options.centerMode === true) {
2437                    infiniteCount = _.options.slidesToShow + 1;
2438                } else {
2439                    infiniteCount = _.options.slidesToShow;
2440                }
2441
2442                for (i = _.slideCount; i > (_.slideCount -
2443                        infiniteCount); i -= 1) {
2444                    slideIndex = i - 1;
2445                    $(_.$slides[slideIndex]).clone(true).attr('id', '')
2446                        .attr('data-slick-index', slideIndex - _.slideCount)
2447                        .prependTo(_.$slideTrack).addClass('slick-cloned');
2448                }
2449                for (i = 0; i < infiniteCount; i += 1) {
2450                    slideIndex = i;
2451                    $(_.$slides[slideIndex]).clone(true).attr('id', '')
2452                        .attr('data-slick-index', slideIndex + _.slideCount)
2453                        .appendTo(_.$slideTrack).addClass('slick-cloned');
2454                }
2455                _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
2456                    $(this).attr('id', '');
2457                });
2458
2459            }
2460
2461        }
2462
2463    };
2464
2465    Slick.prototype.interrupt = function( toggle ) {
2466
2467        var _ = this;
2468
2469        if( !toggle ) {
2470            _.autoPlay();
2471        }
2472        _.interrupted = toggle;
2473
2474    };
2475
2476    Slick.prototype.selectHandler = function(event) {
2477
2478        var _ = this;
2479
2480        var targetElement =
2481            $(event.target).is('.slick-slide') ?
2482                $(event.target) :
2483                $(event.target).parents('.slick-slide');
2484
2485        var index = parseInt(targetElement.attr('data-slick-index'));
2486
2487        if (!index) index = 0;
2488
2489        if (_.slideCount <= _.options.slidesToShow) {
2490
2491            _.slideHandler(index, false, true);
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 (sync === false) {
2516            _.asNavFor(index);
2517        }
2518
2519        targetSlide = index;
2520        targetLeft = _.getLeft(targetSlide);
2521        slideLeft = _.getLeft(_.currentSlide);
2522
2523        _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
2524
2525        if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
2526            if (_.options.fade === false) {
2527                targetSlide = _.currentSlide;
2528                if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
2529                    _.animateSlide(slideLeft, function() {
2530                        _.postSlide(targetSlide);
2531                    });
2532                } else {
2533                    _.postSlide(targetSlide);
2534                }
2535            }
2536            return;
2537        } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
2538            if (_.options.fade === false) {
2539                targetSlide = _.currentSlide;
2540                if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
2541                    _.animateSlide(slideLeft, function() {
2542                        _.postSlide(targetSlide);
2543                    });
2544                } else {
2545                    _.postSlide(targetSlide);
2546                }
2547            }
2548            return;
2549        }
2550
2551        if ( _.options.autoplay ) {
2552            clearInterval(_.autoPlayTimer);
2553        }
2554
2555        if (targetSlide < 0) {
2556            if (_.slideCount % _.options.slidesToScroll !== 0) {
2557                animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
2558            } else {
2559                animSlide = _.slideCount + targetSlide;
2560            }
2561        } else if (targetSlide >= _.slideCount) {
2562            if (_.slideCount % _.options.slidesToScroll !== 0) {
2563                animSlide = 0;
2564            } else {
2565                animSlide = targetSlide - _.slideCount;
2566            }
2567        } else {
2568            animSlide = targetSlide;
2569        }
2570
2571        _.animating = true;
2572
2573        _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);
2574
2575        oldSlide = _.currentSlide;
2576        _.currentSlide = animSlide;
2577
2578        _.setSlideClasses(_.currentSlide);
2579
2580        if ( _.options.asNavFor ) {
2581
2582            navTarget = _.getNavTarget();
2583            navTarget = navTarget.slick('getSlick');
2584
2585            if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {
2586                navTarget.setSlideClasses(_.currentSlide);
2587            }
2588
2589        }
2590
2591        _.updateDots();
2592        _.updateArrows();
2593
2594        if (_.options.fade === true) {
2595            if (dontAnimate !== true) {
2596
2597                _.fadeSlideOut(oldSlide);
2598
2599                _.fadeSlide(animSlide, function() {
2600                    _.postSlide(animSlide);
2601                });
2602
2603            } else {
2604                _.postSlide(animSlide);
2605            }
2606            _.animateHeight();
2607            return;
2608        }
2609
2610        if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
2611            _.animateSlide(targetLeft, function() {
2612                _.postSlide(animSlide);
2613            });
2614        } else {
2615            _.postSlide(animSlide);
2616        }
2617
2618    };
2619
2620    Slick.prototype.startLoad = function() {
2621
2622        var _ = this;
2623
2624        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2625
2626            _.$prevArrow.hide();
2627            _.$nextArrow.hide();
2628
2629        }
2630
2631        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2632
2633            _.$dots.hide();
2634
2635        }
2636
2637        _.$slider.addClass('slick-loading');
2638
2639    };
2640
2641    Slick.prototype.swipeDirection = function() {
2642
2643        var xDist, yDist, r, swipeAngle, _ = this;
2644
2645        xDist = _.touchObject.startX - _.touchObject.curX;
2646        yDist = _.touchObject.startY - _.touchObject.curY;
2647        r = Math.atan2(yDist, xDist);
2648
2649        swipeAngle = Math.round(r * 180 / Math.PI);
2650        if (swipeAngle < 0) {
2651            swipeAngle = 360 - Math.abs(swipeAngle);
2652        }
2653
2654        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
2655            return (_.options.rtl === false ? 'left' : 'right');
2656        }
2657        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
2658            return (_.options.rtl === false ? 'left' : 'right');
2659        }
2660        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
2661            return (_.options.rtl === false ? 'right' : 'left');
2662        }
2663        if (_.options.verticalSwiping === true) {
2664            if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
2665                return 'down';
2666            } else {
2667                return 'up';
2668            }
2669        }
2670
2671        return 'vertical';
2672
2673    };
2674
2675    Slick.prototype.swipeEnd = function(event) {
2676
2677        var _ = this,
2678            slideCount,
2679            direction;
2680
2681        _.dragging = false;
2682        _.swiping = false;
2683
2684        if (_.scrolling) {
2685            _.scrolling = false;
2686            return false;
2687        }
2688
2689        _.interrupted = false;
2690        _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;
2691
2692        if ( _.touchObject.curX === undefined ) {
2693            return false;
2694        }
2695
2696        if ( _.touchObject.edgeHit === true ) {
2697            _.$slider.trigger('edge', [_, _.swipeDirection() ]);
2698        }
2699
2700        if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
2701
2702            direction = _.swipeDirection();
2703
2704            switch ( direction ) {
2705
2706                case 'left':
2707                case 'down':
2708
2709                    slideCount =
2710                        _.options.swipeToSlide ?
2711                            _.checkNavigable( _.currentSlide + _.getSlideCount() ) :
2712                            _.currentSlide + _.getSlideCount();
2713
2714                    _.currentDirection = 0;
2715
2716                    break;
2717
2718                case 'right':
2719                case 'up':
2720
2721                    slideCount =
2722                        _.options.swipeToSlide ?
2723                            _.checkNavigable( _.currentSlide - _.getSlideCount() ) :
2724                            _.currentSlide - _.getSlideCount();
2725
2726                    _.currentDirection = 1;
2727
2728                    break;
2729
2730                default:
2731
2732
2733            }
2734
2735            if( direction != 'vertical' ) {
2736
2737                _.slideHandler( slideCount );
2738                _.touchObject = {};
2739                _.$slider.trigger('swipe', [_, direction ]);
2740
2741            }
2742
2743        } else {
2744
2745            if ( _.touchObject.startX !== _.touchObject.curX ) {
2746
2747                _.slideHandler( _.currentSlide );
2748                _.touchObject = {};
2749
2750            }
2751
2752        }
2753
2754    };
2755
2756    Slick.prototype.swipeHandler = function(event) {
2757
2758        var _ = this;
2759
2760        if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
2761            return;
2762        } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
2763            return;
2764        }
2765
2766        _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
2767            event.originalEvent.touches.length : 1;
2768
2769        _.touchObject.minSwipe = _.listWidth / _.options
2770            .touchThreshold;
2771
2772        if (_.options.verticalSwiping === true) {
2773            _.touchObject.minSwipe = _.listHeight / _.options
2774                .touchThreshold;
2775        }
2776
2777        switch (event.data.action) {
2778
2779            case 'start':
2780                _.swipeStart(event);
2781                break;
2782
2783            case 'move':
2784                _.swipeMove(event);
2785                break;
2786
2787            case 'end':
2788                _.swipeEnd(event);
2789                break;
2790
2791        }
2792
2793    };
2794
2795    Slick.prototype.swipeMove = function(event) {
2796
2797        var _ = this,
2798            edgeWasHit = false,
2799            curLeft, swipeDirection, swipeLength, positionOffset, touches, verticalSwipeLength;
2800
2801        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
2802
2803        if (!_.dragging || _.scrolling || touches && touches.length !== 1) {
2804            return false;
2805        }
2806
2807        curLeft = _.getLeft(_.currentSlide);
2808
2809        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
2810        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
2811
2812        _.touchObject.swipeLength = Math.round(Math.sqrt(
2813            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
2814
2815        verticalSwipeLength = Math.round(Math.sqrt(
2816            Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
2817
2818        if (!_.options.verticalSwiping && !_.swiping && verticalSwipeLength > 4) {
2819            _.scrolling = true;
2820            return false;
2821        }
2822
2823        if (_.options.verticalSwiping === true) {
2824            _.touchObject.swipeLength = verticalSwipeLength;
2825        }
2826
2827        swipeDirection = _.swipeDirection();
2828
2829        if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
2830            _.swiping = true;
2831            event.preventDefault();
2832        }
2833
2834        positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
2835        if (_.options.verticalSwiping === true) {
2836            positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
2837        }
2838
2839
2840        swipeLength = _.touchObject.swipeLength;
2841
2842        _.touchObject.edgeHit = false;
2843
2844        if (_.options.infinite === false) {
2845            if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
2846                swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
2847                _.touchObject.edgeHit = true;
2848            }
2849        }
2850
2851        if (_.options.vertical === false) {
2852            _.swipeLeft = curLeft + swipeLength * positionOffset;
2853        } else {
2854            _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
2855        }
2856        if (_.options.verticalSwiping === true) {
2857            _.swipeLeft = curLeft + swipeLength * positionOffset;
2858        }
2859
2860        if (_.options.fade === true || _.options.touchMove === false) {
2861            return false;
2862        }
2863
2864        if (_.animating === true) {
2865            _.swipeLeft = null;
2866            return false;
2867        }
2868
2869        _.setCSS(_.swipeLeft);
2870
2871    };
2872
2873    Slick.prototype.swipeStart = function(event) {
2874
2875        var _ = this,
2876            touches;
2877
2878        _.interrupted = true;
2879
2880        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
2881            _.touchObject = {};
2882            return false;
2883        }
2884
2885        if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
2886            touches = event.originalEvent.touches[0];
2887        }
2888
2889        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
2890        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
2891
2892        _.dragging = true;
2893
2894    };
2895
2896    Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
2897
2898        var _ = this;
2899
2900        if (_.$slidesCache !== null) {
2901
2902            _.unload();
2903
2904            _.$slideTrack.children(this.options.slide).detach();
2905
2906            _.$slidesCache.appendTo(_.$slideTrack);
2907
2908            _.reinit();
2909
2910        }
2911
2912    };
2913
2914    Slick.prototype.unload = function() {
2915
2916        var _ = this;
2917
2918        $('.slick-cloned', _.$slider).remove();
2919
2920        if (_.$dots) {
2921            _.$dots.remove();
2922        }
2923
2924        if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
2925            _.$prevArrow.remove();
2926        }
2927
2928        if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
2929            _.$nextArrow.remove();
2930        }
2931
2932        _.$slides
2933            .removeClass('slick-slide slick-active slick-visible slick-current')
2934            .attr('aria-hidden', 'true')
2935            .css('width', '');
2936
2937    };
2938