PluginProbe
BlockSpare – Gutenberg Blocks for News, Magazine, Blog & Business Websites / 3.1.4
BlockSpare – Gutenberg Blocks for News, Magazine, Blog & Business Websites v3.1.4
4.1.0 trunk 1.0.0 1.0.1 1.0.2 1.0.3 1.0.4 1.0.5 1.1.0 1.1.1 1.1.2 1.2.0 1.2.1 1.2.2 1.2.3 1.3.0 1.3.1 1.3.2 1.3.3 1.3.4 1.3.5 2.1.2 2.5.0 2.5.3 2.6.1 All 38 releases
blockspare / assets / slick / js / slick.js

slick.js in BlockSpare – Gutenberg Blocks for News, Magazine, Blog & Business Websites 3.1.4, at assets/slick/js/slick.js

2,893 lines 82.3 KB
No matching file
Up and down to move Enter to open Esc to close
Raw Download Zip
1 /*
2 _ _ _ _
3 ___| (_) ___| | __ (_)___
4 / __| | |/ __| |/ / | / __|
5 \__ \ | | (__| < _ | \__ \
6 |___/_|_|\___|_|\_(_)/ |___/
7 |__/
8
9 Version: 1.6.0
10 Author: Ken Wheeler
11 Website: http://kenwheeler.github.io
12 Docs: http://kenwheeler.github.io/slick
13 Repo: http://github.com/kenwheeler/slick
14 Issues: http://github.com/kenwheeler/slick/issues
15
16 */
17 /* global window, document, define, jQuery, setInterval, clearInterval */
18 (function(factory) {
19 'use strict';
20 if (typeof define === 'function' && define.amd) {
21 define(['jquery'], factory);
22 } else if (typeof exports !== 'undefined') {
23 module.exports = factory(require('jquery'));
24 } else {
25 factory(jQuery);
26 }
27
28 }(function($) {
29 'use strict';
30 var Slick = window.Slick || {};
31
32 Slick = (function() {
33
34 var instanceUid = 0;
35
36 function Slick(element, settings) {
37
38 var _ = this, dataSettings;
39
40 _.defaults = {
41 accessibility: true,
42 adaptiveHeight: false,
43 appendArrows: $(element),
44 appendDots: $(element),
45 arrows: true,
46 asNavFor: null,
47 prevArrow: '<button type="button" data-role="none" class="slick-prev" aria-label="Previous" tabindex="0" role="button">Previous</button>',
48 nextArrow: '<button type="button" data-role="none" class="slick-next" aria-label="Next" tabindex="0" role="button">Next</button>',
49 autoplay: false,
50 autoplaySpeed: 3000,
51 centerMode: false,
52 centerPadding: '50px',
53 cssEase: 'ease',
54 customPaging: function(slider, i) {
55 return $('<button type="button" data-role="none" role="button" tabindex="0" />').text(i + 1);
56 },
57 dots: false,
58 dotsClass: 'slick-dots',
59 draggable: true,
60 easing: 'linear',
61 edgeFriction: 0.35,
62 fade: false,
63 focusOnSelect: false,
64 infinite: true,
65 initialSlide: 0,
66 lazyLoad: 'ondemand',
67 mobileFirst: false,
68 pauseOnHover: true,
69 pauseOnFocus: true,
70 pauseOnDotsHover: false,
71 respondTo: 'window',
72 responsive: null,
73 rows: 1,
74 rtl: false,
75 slide: '',
76 slidesPerRow: 1,
77 slidesToShow: 1,
78 slidesToScroll: 1,
79 speed: 500,
80 swipe: true,
81 swipeToSlide: false,
82 touchMove: true,
83 touchThreshold: 5,
84 useCSS: true,
85 useTransform: true,
86 variableWidth: false,
87 vertical: false,
88 verticalSwiping: false,
89 waitForAnimate: true,
90 zIndex: 1000
91 };
92
93 _.initials = {
94 animating: false,
95 dragging: false,
96 autoPlayTimer: null,
97 currentDirection: 0,
98 currentLeft: null,
99 currentSlide: 0,
100 direction: 1,
101 $dots: null,
102 listWidth: null,
103 listHeight: null,
104 loadIndex: 0,
105 $nextArrow: null,
106 $prevArrow: null,
107 slideCount: null,
108 slideWidth: null,
109 $slideTrack: null,
110 $slides: null,
111 sliding: false,
112 slideOffset: 0,
113 swipeLeft: null,
114 $list: null,
115 touchObject: {},
116 transformsEnabled: false,
117 unslicked: false
118 };
119
120 $.extend(_, _.initials);
121
122 _.activeBreakpoint = null;
123 _.animType = null;
124 _.animProp = null;
125 _.breakpoints = [];
126 _.breakpointSettings = [];
127 _.cssTransitions = false;
128 _.focussed = false;
129 _.interrupted = false;
130 _.hidden = 'hidden';
131 _.paused = true;
132 _.positionProp = null;
133 _.respondTo = null;
134 _.rowCount = 1;
135 _.shouldClick = true;
136 _.$slider = $(element);
137 _.$slidesCache = null;
138 _.transformType = null;
139 _.transitionType = null;
140 _.visibilityChange = 'visibilitychange';
141 _.windowWidth = 0;
142 _.windowTimer = null;
143
144 dataSettings = $(element).data('slick') || {};
145
146 _.options = $.extend({}, _.defaults, settings, dataSettings);
147
148 _.currentSlide = _.options.initialSlide;
149
150 _.originalSettings = _.options;
151
152 if (typeof document.mozHidden !== 'undefined') {
153 _.hidden = 'mozHidden';
154 _.visibilityChange = 'mozvisibilitychange';
155 } else if (typeof document.webkitHidden !== 'undefined') {
156 _.hidden = 'webkitHidden';
157 _.visibilityChange = 'webkitvisibilitychange';
158 }
159
160 _.autoPlay = $.proxy(_.autoPlay, _);
161 _.autoPlayClear = $.proxy(_.autoPlayClear, _);
162 _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
163 _.changeSlide = $.proxy(_.changeSlide, _);
164 _.clickHandler = $.proxy(_.clickHandler, _);
165 _.selectHandler = $.proxy(_.selectHandler, _);
166 _.setPosition = $.proxy(_.setPosition, _);
167 _.swipeHandler = $.proxy(_.swipeHandler, _);
168 _.dragHandler = $.proxy(_.dragHandler, _);
169 _.keyHandler = $.proxy(_.keyHandler, _);
170
171 _.instanceUid = instanceUid++;
172
173 // A simple way to check for HTML strings
174 // Strict HTML recognition (must start with <)
175 // Extracted from jQuery v1.11 source
176 _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
177
178
179 _.registerBreakpoints();
180 _.init(true);
181
182 }
183
184 return Slick;
185
186 }());
187
188 Slick.prototype.activateADA = function() {
189 var _ = this;
190
191 _.$slideTrack.find('.slick-active').attr({
192 'aria-hidden': 'false'
193 }).find('a, input, button, select').attr({
194 'tabindex': '0'
195 });
196
197 };
198
199 Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
200
201 var _ = this;
202
203 if (typeof(index) === 'boolean') {
204 addBefore = index;
205 index = null;
206 } else if (index < 0 || (index >= _.slideCount)) {
207 return false;
208 }
209
210 _.unload();
211
212 if (typeof(index) === 'number') {
213 if (index === 0 && _.$slides.length === 0) {
214 $(markup).appendTo(_.$slideTrack);
215 } else if (addBefore) {
216 $(markup).insertBefore(_.$slides.eq(index));
217 } else {
218 $(markup).insertAfter(_.$slides.eq(index));
219 }
220 } else {
221 if (addBefore === true) {
222 $(markup).prependTo(_.$slideTrack);
223 } else {
224 $(markup).appendTo(_.$slideTrack);
225 }
226 }
227
228 _.$slides = _.$slideTrack.children(this.options.slide);
229
230 _.$slideTrack.children(this.options.slide).detach();
231
232 _.$slideTrack.append(_.$slides);
233
234 _.$slides.each(function(index, element) {
235 $(element).attr('data-slick-index', index);
236 });
237
238 _.$slidesCache = _.$slides;
239
240 _.reinit();
241
242 };
243
244 Slick.prototype.animateHeight = function() {
245 var _ = this;
246 if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
247 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
248 _.$list.animate({
249 height: targetHeight
250 }, _.options.speed);
251 }
252 };
253
254 Slick.prototype.animateSlide = function(targetLeft, callback) {
255
256 var animProps = {},
257 _ = this;
258
259 _.animateHeight();
260
261 if (_.options.rtl === true && _.options.vertical === false) {
262 targetLeft = -targetLeft;
263 }
264 if (_.transformsEnabled === false) {
265 if (_.options.vertical === false) {
266 _.$slideTrack.animate({
267 left: targetLeft
268 }, _.options.speed, _.options.easing, callback);
269 } else {
270 _.$slideTrack.animate({
271 top: targetLeft
272 }, _.options.speed, _.options.easing, callback);
273 }
274
275 } else {
276
277 if (_.cssTransitions === false) {
278 if (_.options.rtl === true) {
279 _.currentLeft = -(_.currentLeft);
280 }
281 $({
282 animStart: _.currentLeft
283 }).animate({
284 animStart: targetLeft
285 }, {
286 duration: _.options.speed,
287 easing: _.options.easing,
288 step: function(now) {
289 now = Math.ceil(now);
290 if (_.options.vertical === false) {
291 animProps[_.animType] = 'translate(' +
292 now + 'px, 0px)';
293 _.$slideTrack.css(animProps);
294 } else {
295 animProps[_.animType] = 'translate(0px,' +
296 now + 'px)';
297 _.$slideTrack.css(animProps);
298 }
299 },
300 complete: function() {
301 if (callback) {
302 callback.call();
303 }
304 }
305 });
306
307 } else {
308
309 _.applyTransition();
310 targetLeft = Math.ceil(targetLeft);
311
312 if (_.options.vertical === false) {
313 animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
314 } else {
315 animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
316 }
317 _.$slideTrack.css(animProps);
318
319 if (callback) {
320 setTimeout(function() {
321
322 _.disableTransition();
323
324 callback.call();
325 }, _.options.speed);
326 }
327
328 }
329
330 }
331
332 };
333
334 Slick.prototype.getNavTarget = function() {
335
336 var _ = this,
337 asNavFor = _.options.asNavFor;
338
339 if ( asNavFor && asNavFor !== null ) {
340 asNavFor = $(asNavFor).not(_.$slider);
341 }
342
343 return asNavFor;
344
345 };
346
347 Slick.prototype.asNavFor = function(index) {
348
349 var _ = this,
350 asNavFor = _.getNavTarget();
351
352 if ( asNavFor !== null && typeof asNavFor === 'object' ) {
353 asNavFor.each(function() {
354 var target = $(this).slick('getSlick');
355 if(!target.unslicked) {
356 target.slideHandler(index, true);
357 }
358 });
359 }
360
361 };
362
363 Slick.prototype.applyTransition = function(slide) {
364
365 var _ = this,
366 transition = {};
367
368 if (_.options.fade === false) {
369 transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
370 } else {
371 transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
372 }
373
374 if (_.options.fade === false) {
375 _.$slideTrack.css(transition);
376 } else {
377 _.$slides.eq(slide).css(transition);
378 }
379
380 };
381
382 Slick.prototype.autoPlay = function() {
383
384 var _ = this;
385
386 _.autoPlayClear();
387
388 if ( _.slideCount > _.options.slidesToShow ) {
389 _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
390 }
391
392 };
393
394 Slick.prototype.autoPlayClear = function() {
395
396 var _ = this;
397
398 if (_.autoPlayTimer) {
399 clearInterval(_.autoPlayTimer);
400 }
401
402 };
403
404 Slick.prototype.autoPlayIterator = function() {
405
406 var _ = this,
407 slideTo = _.currentSlide + _.options.slidesToScroll;
408
409 if ( !_.paused && !_.interrupted && !_.focussed ) {
410
411 if ( _.options.infinite === false ) {
412
413 if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
414 _.direction = 0;
415 }
416
417 else if ( _.direction === 0 ) {
418
419 slideTo = _.currentSlide - _.options.slidesToScroll;
420
421 if ( _.currentSlide - 1 === 0 ) {
422 _.direction = 1;
423 }
424
425 }
426
427 }
428
429 _.slideHandler( slideTo );
430
431 }
432
433 };
434
435 Slick.prototype.buildArrows = function() {
436
437 var _ = this;
438
439 if (_.options.arrows === true ) {
440
441 _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
442 _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
443
444 if( _.slideCount > _.options.slidesToShow ) {
445
446 _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
447 _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
448
449 if (_.htmlExpr.test(_.options.prevArrow)) {
450 _.$prevArrow.prependTo(_.options.appendArrows);
451 }
452
453 if (_.htmlExpr.test(_.options.nextArrow)) {
454 _.$nextArrow.appendTo(_.options.appendArrows);
455 }
456
457 if (_.options.infinite !== true) {
458 _.$prevArrow
459 .addClass('slick-disabled')
460 .attr('aria-disabled', 'true');
461 }
462
463 } else {
464
465 _.$prevArrow.add( _.$nextArrow )
466
467 .addClass('slick-hidden')
468 .attr({
469 'aria-disabled': 'true',
470 'tabindex': '-1'
471 });
472
473 }
474
475 }
476
477 };
478
479 Slick.prototype.buildDots = function() {
480
481 var _ = this,
482 i, dot;
483
484 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
485
486 _.$slider.addClass('slick-dotted');
487
488 dot = $('<ul />').addClass(_.options.dotsClass);
489
490 for (i = 0; i <= _.getDotCount(); i += 1) {
491 dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
492 }
493
494 _.$dots = dot.appendTo(_.options.appendDots);
495
496 _.$dots.find('li').first().addClass('slick-active').attr('aria-hidden', 'false');
497
498 }
499
500 };
501
502 Slick.prototype.buildOut = function() {
503
504 var _ = this;
505
506 _.$slides =
507 _.$slider
508 .children( _.options.slide + ':not(.slick-cloned)')
509 .addClass('slick-slide');
510
511 _.slideCount = _.$slides.length;
512
513 _.$slides.each(function(index, element) {
514 $(element)
515 .attr('data-slick-index', index)
516 .data('originalStyling', $(element).attr('style') || '');
517 });
518
519 _.$slider.addClass('slick-slider');
520
521 _.$slideTrack = (_.slideCount === 0) ?
522 $('<div class="slick-track"/>').appendTo(_.$slider) :
523 _.$slides.wrapAll('<div class="slick-track"/>').parent();
524
525 _.$list = _.$slideTrack.wrap(
526 '<div aria-live="polite" class="slick-list"/>').parent();
527 _.$slideTrack.css('opacity', 0);
528
529 if (_.options.centerMode === true || _.options.swipeToSlide === true) {
530 _.options.slidesToScroll = 1;
531 }
532
533 $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
534
535 _.setupInfinite();
536
537 _.buildArrows();
538
539 _.buildDots();
540
541 _.updateDots();
542
543
544 _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
545
546 if (_.options.draggable === true) {
547 _.$list.addClass('draggable');
548 }
549
550 };
551
552 Slick.prototype.buildRows = function() {
553
554 var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
555
556 newSlides = document.createDocumentFragment();
557 originalSlides = _.$slider.children();
558
559 if(_.options.rows > 1) {
560
561 slidesPerSection = _.options.slidesPerRow * _.options.rows;
562 numOfSlides = Math.ceil(
563 originalSlides.length / slidesPerSection
564 );
565
566 for(a = 0; a < numOfSlides; a++){
567 var slide = document.createElement('div');
568 for(b = 0; b < _.options.rows; b++) {
569 var row = document.createElement('div');
570 for(c = 0; c < _.options.slidesPerRow; c++) {
571 var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
572 if (originalSlides.get(target)) {
573 row.appendChild(originalSlides.get(target));
574 }
575 }
576 slide.appendChild(row);
577 }
578 newSlides.appendChild(slide);
579 }
580
581 _.$slider.empty().append(newSlides);
582 _.$slider.children().children().children()
583 .css({
584 'width':(100 / _.options.slidesPerRow) + '%',
585 'display': 'inline-block'
586 });
587
588 }
589
590 };
591
592 Slick.prototype.checkResponsive = function(initial, forceUpdate) {
593
594 var _ = this,
595 breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
596 var sliderWidth = _.$slider.width();
597 var windowWidth = window.innerWidth || $(window).width();
598
599 if (_.respondTo === 'window') {
600 respondToWidth = windowWidth;
601 } else if (_.respondTo === 'slider') {
602 respondToWidth = sliderWidth;
603 } else if (_.respondTo === 'min') {
604 respondToWidth = Math.min(windowWidth, sliderWidth);
605 }
606
607 if ( _.options.responsive &&
608 _.options.responsive.length &&
609 _.options.responsive !== null) {
610
611 targetBreakpoint = null;
612
613 for (breakpoint in _.breakpoints) {
614 if (_.breakpoints.hasOwnProperty(breakpoint)) {
615 if (_.originalSettings.mobileFirst === false) {
616 if (respondToWidth < _.breakpoints[breakpoint]) {
617 targetBreakpoint = _.breakpoints[breakpoint];
618 }
619 } else {
620 if (respondToWidth > _.breakpoints[breakpoint]) {
621 targetBreakpoint = _.breakpoints[breakpoint];
622 }
623 }
624 }
625 }
626
627 if (targetBreakpoint !== null) {
628 if (_.activeBreakpoint !== null) {
629 if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
630 _.activeBreakpoint =
631 targetBreakpoint;
632 if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
633 _.unslick(targetBreakpoint);
634 } else {
635 _.options = $.extend({}, _.originalSettings,
636 _.breakpointSettings[
637 targetBreakpoint]);
638 if (initial === true) {
639 _.currentSlide = _.options.initialSlide;
640 }
641 _.refresh(initial);
642 }
643 triggerBreakpoint = targetBreakpoint;
644 }
645 } else {
646 _.activeBreakpoint = targetBreakpoint;
647 if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
648 _.unslick(targetBreakpoint);
649 } else {
650 _.options = $.extend({}, _.originalSettings,
651 _.breakpointSettings[
652 targetBreakpoint]);
653 if (initial === true) {
654 _.currentSlide = _.options.initialSlide;
655 }
656 _.refresh(initial);
657 }
658 triggerBreakpoint = targetBreakpoint;
659 }
660 } else {
661 if (_.activeBreakpoint !== null) {
662 _.activeBreakpoint = null;
663 _.options = _.originalSettings;
664 if (initial === true) {
665 _.currentSlide = _.options.initialSlide;
666 }
667 _.refresh(initial);
668 triggerBreakpoint = targetBreakpoint;
669 }
670 }
671
672 // only trigger breakpoints during an actual break. not on initialize.
673 if( !initial && triggerBreakpoint !== false ) {
674 _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
675 }
676 }
677
678 };
679
680 Slick.prototype.changeSlide = function(event, dontAnimate) {
681
682 var _ = this,
683 $target = $(event.currentTarget),
684 indexOffset, slideOffset, unevenOffset;
685
686 // If target is a link, prevent default action.
687 if($target.is('a')) {
688 event.preventDefault();
689 }
690
691 // If target is not the <li> element (ie: a child), find the <li>.
692 if(!$target.is('li')) {
693 $target = $target.closest('li');
694 }
695
696 unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
697 indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
698
699 switch (event.data.message) {
700
701 case 'previous':
702 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
703 if (_.slideCount > _.options.slidesToShow) {
704 _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
705 }
706 break;
707
708 case 'next':
709 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
710 if (_.slideCount > _.options.slidesToShow) {
711 _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
712 }
713 break;
714
715 case 'index':
716 var index = event.data.index === 0 ? 0 :
717 event.data.index || $target.index() * _.options.slidesToScroll;
718
719 _.slideHandler(_.checkNavigable(index), false, dontAnimate);
720 $target.children().trigger('focus');
721 break;
722
723 default:
724 return;
725 }
726
727 };
728
729 Slick.prototype.checkNavigable = function(index) {
730
731 var _ = this,
732 navigables, prevNavigable;
733
734 navigables = _.getNavigableIndexes();
735 prevNavigable = 0;
736 if (index > navigables[navigables.length - 1]) {
737 index = navigables[navigables.length - 1];
738 } else {
739 for (var n in navigables) {
740 if (index < navigables[n]) {
741 index = prevNavigable;
742 break;
743 }
744 prevNavigable = navigables[n];
745 }
746 }
747
748 return index;
749 };
750
751 Slick.prototype.cleanUpEvents = function() {
752
753 var _ = this;
754
755 if (_.options.dots && _.$dots !== null) {
756
757 $('li', _.$dots)
758 .off('click.slick', _.changeSlide)
759 .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
760 .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
761
762 }
763
764 _.$slider.off('focus.slick blur.slick');
765
766 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
767 _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
768 _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
769 }
770
771 _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
772 _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
773 _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
774 _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
775
776 _.$list.off('click.slick', _.clickHandler);
777
778 $(document).off(_.visibilityChange, _.visibility);
779
780 _.cleanUpSlideEvents();
781
782 if (_.options.accessibility === true) {
783 _.$list.off('keydown.slick', _.keyHandler);
784 }
785
786 if (_.options.focusOnSelect === true) {
787 $(_.$slideTrack).children().off('click.slick', _.selectHandler);
788 }
789
790 $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
791
792 $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
793
794 $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
795
796 $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
797 $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);
798
799 };
800
801 Slick.prototype.cleanUpSlideEvents = function() {
802
803 var _ = this;
804
805 _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
806 _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
807
808 };
809
810 Slick.prototype.cleanUpRows = function() {
811
812 var _ = this, originalSlides;
813
814 if(_.options.rows > 1) {
815 originalSlides = _.$slides.children().children();
816 originalSlides.removeAttr('style');
817 _.$slider.empty().append(originalSlides);
818 }
819
820 };
821
822 Slick.prototype.clickHandler = function(event) {
823
824 var _ = this;
825
826 if (_.shouldClick === false) {
827 event.stopImmediatePropagation();
828 event.stopPropagation();
829 event.preventDefault();
830 }
831
832 };
833
834 Slick.prototype.destroy = function(refresh) {
835
836 var _ = this;
837
838 _.autoPlayClear();
839
840 _.touchObject = {};
841
842 _.cleanUpEvents();
843
844 $('.slick-cloned', _.$slider).detach();
845
846 if (_.$dots) {
847 _.$dots.remove();
848 }
849
850
851 if ( _.$prevArrow && _.$prevArrow.length ) {
852
853 _.$prevArrow
854 .removeClass('slick-disabled slick-arrow slick-hidden')
855 .removeAttr('aria-hidden aria-disabled tabindex')
856 .css('display','');
857
858 if ( _.htmlExpr.test( _.options.prevArrow )) {
859 _.$prevArrow.remove();
860 }
861 }
862
863 if ( _.$nextArrow && _.$nextArrow.length ) {
864
865 _.$nextArrow
866 .removeClass('slick-disabled slick-arrow slick-hidden')
867 .removeAttr('aria-hidden aria-disabled tabindex')
868 .css('display','');
869
870 if ( _.htmlExpr.test( _.options.nextArrow )) {
871 _.$nextArrow.remove();
872 }
873
874 }
875
876
877 if (_.$slides) {
878
879 _.$slides
880 .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
881 .removeAttr('aria-hidden')
882 .removeAttr('data-slick-index')
883 .each(function(){
884 $(this).attr('style', $(this).data('originalStyling'));
885 });
886
887 _.$slideTrack.children(this.options.slide).detach();
888
889 _.$slideTrack.detach();
890
891 _.$list.detach();
892
893 _.$slider.append(_.$slides);
894 }
895
896 _.cleanUpRows();
897
898 _.$slider.removeClass('slick-slider');
899 _.$slider.removeClass('slick-initialized');
900 _.$slider.removeClass('slick-dotted');
901
902 _.unslicked = true;
903
904 if(!refresh) {
905 _.$slider.trigger('destroy', [_]);
906 }
907
908 };
909
910 Slick.prototype.disableTransition = function(slide) {
911
912 var _ = this,
913 transition = {};
914
915 transition[_.transitionType] = '';
916
917 if (_.options.fade === false) {
918 _.$slideTrack.css(transition);
919 } else {
920 _.$slides.eq(slide).css(transition);
921 }
922
923 };
924
925 Slick.prototype.fadeSlide = function(slideIndex, callback) {
926
927 var _ = this;
928
929 if (_.cssTransitions === false) {
930
931 _.$slides.eq(slideIndex).css({
932 zIndex: _.options.zIndex
933 });
934
935 _.$slides.eq(slideIndex).animate({
936 opacity: 1
937 }, _.options.speed, _.options.easing, callback);
938
939 } else {
940
941 _.applyTransition(slideIndex);
942
943 _.$slides.eq(slideIndex).css({
944 opacity: 1,
945 zIndex: _.options.zIndex
946 });
947
948 if (callback) {
949 setTimeout(function() {
950
951 _.disableTransition(slideIndex);
952
953 callback.call();
954 }, _.options.speed);
955 }
956
957 }
958
959 };
960
961 Slick.prototype.fadeSlideOut = function(slideIndex) {
962
963 var _ = this;
964
965 if (_.cssTransitions === false) {
966
967 _.$slides.eq(slideIndex).animate({
968 opacity: 0,
969 zIndex: _.options.zIndex - 2
970 }, _.options.speed, _.options.easing);
971
972 } else {
973
974 _.applyTransition(slideIndex);
975
976 _.$slides.eq(slideIndex).css({
977 opacity: 0,
978 zIndex: _.options.zIndex - 2
979 });
980
981 }
982
983 };
984
985 Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {
986
987 var _ = this;
988
989 if (filter !== null) {
990
991 _.$slidesCache = _.$slides;
992
993 _.unload();
994
995 _.$slideTrack.children(this.options.slide).detach();
996
997 _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
998
999 _.reinit();
1000
1001 }
1002
1003 };
1004
1005 Slick.prototype.focusHandler = function() {
1006
1007 var _ = this;
1008
1009 _.$slider
1010 .off('focus.slick blur.slick')
1011 .on('focus.slick blur.slick',
1012 '*:not(.slick-arrow)', function(event) {
1013
1014 event.stopImmediatePropagation();
1015 var $sf = $(this);
1016
1017 setTimeout(function() {
1018
1019 if( _.options.pauseOnFocus ) {
1020 _.focussed = $sf.is(':focus');
1021 _.autoPlay();
1022 }
1023
1024 }, 0);
1025
1026 });
1027 };
1028
1029 Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {
1030
1031 var _ = this;
1032 return _.currentSlide;
1033
1034 };
1035
1036 Slick.prototype.getDotCount = function() {
1037
1038 var _ = this;
1039
1040 var breakPoint = 0;
1041 var counter = 0;
1042 var pagerQty = 0;
1043
1044 if (_.options.infinite === true) {
1045 while (breakPoint < _.slideCount) {
1046 ++pagerQty;
1047 breakPoint = counter + _.options.slidesToScroll;
1048 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1049 }
1050 } else if (_.options.centerMode === true) {
1051 pagerQty = _.slideCount;
1052 } else if(!_.options.asNavFor) {
1053 pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);
1054 }else {
1055 while (breakPoint < _.slideCount) {
1056 ++pagerQty;
1057 breakPoint = counter + _.options.slidesToScroll;
1058 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1059 }
1060 }
1061
1062 return pagerQty - 1;
1063
1064 };
1065
1066 Slick.prototype.getLeft = function(slideIndex) {
1067
1068 var _ = this,
1069 targetLeft,
1070 verticalHeight,
1071 verticalOffset = 0,
1072 targetSlide;
1073
1074 _.slideOffset = 0;
1075 verticalHeight = _.$slides.first().outerHeight(true);
1076
1077 if (_.options.infinite === true) {
1078 if (_.slideCount > _.options.slidesToShow) {
1079 _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
1080 verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
1081 }
1082 if (_.slideCount % _.options.slidesToScroll !== 0) {
1083 if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
1084 if (slideIndex > _.slideCount) {
1085 _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
1086 verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
1087 } else {
1088 _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
1089 verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
1090 }
1091 }
1092 }
1093 } else {
1094 if (slideIndex + _.options.slidesToShow > _.slideCount) {
1095 _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
1096 verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
1097 }
1098 }
1099
1100 if (_.slideCount <= _.options.slidesToShow) {
1101 _.slideOffset = 0;
1102 verticalOffset = 0;
1103 }
1104
1105 if (_.options.centerMode === true && _.options.infinite === true) {
1106 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
1107 } else if (_.options.centerMode === true) {
1108 _.slideOffset = 0;
1109 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
1110 }
1111
1112 if (_.options.vertical === false) {
1113 targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
1114 } else {
1115 targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
1116 }
1117
1118 if (_.options.variableWidth === true) {
1119
1120 if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1121 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1122 } else {
1123 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
1124 }
1125
1126 if (_.options.rtl === true) {
1127 if (targetSlide[0]) {
1128 targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1129 } else {
1130 targetLeft = 0;
1131 }
1132 } else {
1133 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1134 }
1135
1136 if (_.options.centerMode === true) {
1137 if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1138 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1139 } else {
1140 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
1141 }
1142
1143 if (_.options.rtl === true) {
1144 if (targetSlide[0]) {
1145 targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1146 } else {
1147 targetLeft = 0;
1148 }
1149 } else {
1150 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1151 }
1152
1153 targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
1154 }
1155 }
1156
1157 return targetLeft;
1158
1159 };
1160
1161 Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
1162
1163 var _ = this;
1164
1165 return _.options[option];
1166
1167 };
1168
1169 Slick.prototype.getNavigableIndexes = function() {
1170
1171 var _ = this,
1172 breakPoint = 0,
1173 counter = 0,
1174 indexes = [],
1175 max;
1176
1177 if (_.options.infinite === false) {
1178 max = _.slideCount;
1179 } else {
1180 breakPoint = _.options.slidesToScroll * -1;
1181 counter = _.options.slidesToScroll * -1;
1182 max = _.slideCount * 2;
1183 }
1184
1185 while (breakPoint < max) {
1186 indexes.push(breakPoint);
1187 breakPoint = counter + _.options.slidesToScroll;
1188 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1189 }
1190
1191 return indexes;
1192
1193 };
1194
1195 Slick.prototype.getSlick = function() {
1196
1197 return this;
1198
1199 };
1200
1201 Slick.prototype.getSlideCount = function() {
1202
1203 var _ = this,
1204 slidesTraversed, swipedSlide, centerOffset;
1205
1206 centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
1207
1208 if (_.options.swipeToSlide === true) {
1209 _.$slideTrack.find('.slick-slide').each(function(index, slide) {
1210 if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
1211 swipedSlide = slide;
1212 return false;
1213 }
1214 });
1215
1216 slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
1217
1218 return slidesTraversed;
1219
1220 } else {
1221 return _.options.slidesToScroll;
1222 }
1223
1224 };
1225
1226 Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
1227
1228 var _ = this;
1229
1230 _.changeSlide({
1231 data: {
1232 message: 'index',
1233 index: parseInt(slide)
1234 }
1235 }, dontAnimate);
1236
1237 };
1238
1239 Slick.prototype.init = function(creation) {
1240
1241 var _ = this;
1242
1243 if (!$(_.$slider).hasClass('slick-initialized')) {
1244
1245 $(_.$slider).addClass('slick-initialized');
1246
1247 _.buildRows();
1248 _.buildOut();
1249 _.setProps();
1250 _.startLoad();
1251 _.loadSlider();
1252 _.initializeEvents();
1253 _.updateArrows();
1254 _.updateDots();
1255 _.checkResponsive(true);
1256 _.focusHandler();
1257
1258 }
1259
1260 if (creation) {
1261 _.$slider.trigger('init', [_]);
1262 }
1263
1264 if (_.options.accessibility === true) {
1265 _.initADA();
1266 }
1267
1268 if ( _.options.autoplay ) {
1269
1270 _.paused = false;
1271 _.autoPlay();
1272
1273 }
1274
1275 };
1276
1277 Slick.prototype.initADA = function() {
1278 var _ = this;
1279 _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({
1280 'aria-hidden': 'true',
1281 'tabindex': '-1'
1282 }).find('a, input, button, select').attr({
1283 'tabindex': '-1'
1284 });
1285
1286 _.$slideTrack.attr('role', 'listbox');
1287
1288 _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {
1289 $(this).attr({
1290 'role': 'option',
1291 'aria-describedby': 'slick-slide' + _.instanceUid + i + ''
1292 });
1293 });
1294
1295 if (_.$dots !== null) {
1296 _.$dots.attr('role', 'tablist').find('li').each(function(i) {
1297 $(this).attr({
1298 'role': 'presentation',
1299 'aria-selected': 'false',
1300 'aria-controls': 'navigation' + _.instanceUid + i + '',
1301 'id': 'slick-slide' + _.instanceUid + i + ''
1302 });
1303 })
1304 .first().attr('aria-selected', 'true').end()
1305 .find('button').attr('role', 'button').end()
1306 .closest('div').attr('role', 'toolbar');
1307 }
1308 _.activateADA();
1309
1310 };
1311
1312 Slick.prototype.initArrowEvents = function() {
1313
1314 var _ = this;
1315
1316 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1317 _.$prevArrow
1318 .off('click.slick')
1319 .on('click.slick', {
1320 message: 'previous'
1321 }, _.changeSlide);
1322 _.$nextArrow
1323 .off('click.slick')
1324 .on('click.slick', {
1325 message: 'next'
1326 }, _.changeSlide);
1327 }
1328
1329 };
1330
1331 Slick.prototype.initDotEvents = function() {
1332
1333 var _ = this;
1334
1335 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1336 $('li', _.$dots).on('click.slick', {
1337 message: 'index'
1338 }, _.changeSlide);
1339 }
1340
1341 if ( _.options.dots === true && _.options.pauseOnDotsHover === true ) {
1342
1343 $('li', _.$dots)
1344 .on('mouseenter.slick', $.proxy(_.interrupt, _, true))
1345 .on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1346
1347 }
1348
1349 };
1350
1351 Slick.prototype.initSlideEvents = function() {
1352
1353 var _ = this;
1354
1355 if ( _.options.pauseOnHover ) {
1356
1357 _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));
1358 _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1359
1360 }
1361
1362 };
1363
1364 Slick.prototype.initializeEvents = function() {
1365
1366 var _ = this;
1367
1368 _.initArrowEvents();
1369
1370 _.initDotEvents();
1371 _.initSlideEvents();
1372
1373 _.$list.on('touchstart.slick mousedown.slick', {
1374 action: 'start'
1375 }, _.swipeHandler);
1376 _.$list.on('touchmove.slick mousemove.slick', {
1377 action: 'move'
1378 }, _.swipeHandler);
1379 _.$list.on('touchend.slick mouseup.slick', {
1380 action: 'end'
1381 }, _.swipeHandler);
1382 _.$list.on('touchcancel.slick mouseleave.slick', {
1383 action: 'end'
1384 }, _.swipeHandler);
1385
1386 _.$list.on('click.slick', _.clickHandler);
1387
1388 $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
1389
1390 if (_.options.accessibility === true) {
1391 _.$list.on('keydown.slick', _.keyHandler);
1392 }
1393
1394 if (_.options.focusOnSelect === true) {
1395 $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1396 }
1397
1398 $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
1399
1400 $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
1401
1402 $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
1403
1404 $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
1405 $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
1406
1407 };
1408
1409 Slick.prototype.initUI = function() {
1410
1411 var _ = this;
1412
1413 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1414
1415 _.$prevArrow.show();
1416 _.$nextArrow.show();
1417
1418 }
1419
1420 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1421
1422 _.$dots.show();
1423
1424 }
1425
1426 };
1427
1428 Slick.prototype.keyHandler = function(event) {
1429
1430 var _ = this;
1431 //Dont slide if the cursor is inside the form fields and arrow keys are pressed
1432 if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
1433 if (event.keyCode === 37 && _.options.accessibility === true) {
1434 _.changeSlide({
1435 data: {
1436 message: _.options.rtl === true ? 'next' : 'previous'
1437 }
1438 });
1439 } else if (event.keyCode === 39 && _.options.accessibility === true) {
1440 _.changeSlide({
1441 data: {
1442 message: _.options.rtl === true ? 'previous' : 'next'
1443 }
1444 });
1445 }
1446 }
1447
1448 };
1449
1450 Slick.prototype.lazyLoad = function() {
1451
1452 var _ = this,
1453 loadRange, cloneRange, rangeStart, rangeEnd;
1454
1455 function loadImages(imagesScope) {
1456
1457 $('img[data-lazy]', imagesScope).each(function() {
1458
1459 var image = $(this),
1460 imageSource = $(this).attr('data-lazy'),
1461 imageToLoad = document.createElement('img');
1462
1463 imageToLoad.onload = function() {
1464
1465 image
1466 .animate({ opacity: 0 }, 100, function() {
1467 image
1468 .attr('src', imageSource)
1469 .animate({ opacity: 1 }, 200, function() {
1470 image
1471 .removeAttr('data-lazy')
1472 .removeClass('slick-loading');
1473 });
1474 _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
1475 });
1476
1477 };
1478
1479 imageToLoad.onerror = function() {
1480
1481 image
1482 .removeAttr( 'data-lazy' )
1483 .removeClass( 'slick-loading' )
1484 .addClass( 'slick-lazyload-error' );
1485
1486 _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1487
1488 };
1489
1490 imageToLoad.src = imageSource;
1491
1492 });
1493
1494 }
1495
1496 if (_.options.centerMode === true) {
1497 if (_.options.infinite === true) {
1498 rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
1499 rangeEnd = rangeStart + _.options.slidesToShow + 2;
1500 } else {
1501 rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
1502 rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
1503 }
1504 } else {
1505 rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
1506 rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
1507 if (_.options.fade === true) {
1508 if (rangeStart > 0) rangeStart--;
1509 if (rangeEnd <= _.slideCount) rangeEnd++;
1510 }
1511 }
1512
1513 loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
1514 loadImages(loadRange);
1515
1516 if (_.slideCount <= _.options.slidesToShow) {
1517 cloneRange = _.$slider.find('.slick-slide');
1518 loadImages(cloneRange);
1519 } else
1520 if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1521 cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
1522 loadImages(cloneRange);
1523 } else if (_.currentSlide === 0) {
1524 cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
1525 loadImages(cloneRange);
1526 }
1527
1528 };
1529
1530 Slick.prototype.loadSlider = function() {
1531
1532 var _ = this;
1533
1534 _.setPosition();
1535
1536 _.$slideTrack.css({
1537 opacity: 1
1538 });
1539
1540 _.$slider.removeClass('slick-loading');
1541
1542 _.initUI();
1543
1544 if (_.options.lazyLoad === 'progressive') {
1545 _.progressiveLazyLoad();
1546 }
1547
1548 };
1549
1550 Slick.prototype.next = Slick.prototype.slickNext = function() {
1551
1552 var _ = this;
1553
1554 _.changeSlide({
1555 data: {
1556 message: 'next'
1557 }
1558 });
1559
1560 };
1561
1562 Slick.prototype.orientationChange = function() {
1563
1564 var _ = this;
1565
1566 _.checkResponsive();
1567 _.setPosition();
1568
1569 };
1570
1571 Slick.prototype.pause = Slick.prototype.slickPause = function() {
1572
1573 var _ = this;
1574
1575 _.autoPlayClear();
1576 _.paused = true;
1577
1578 };
1579
1580 Slick.prototype.play = Slick.prototype.slickPlay = function() {
1581
1582 var _ = this;
1583
1584 _.autoPlay();
1585 _.options.autoplay = true;
1586 _.paused = false;
1587 _.focussed = false;
1588 _.interrupted = false;
1589
1590 };
1591
1592 Slick.prototype.postSlide = function(index) {
1593
1594 var _ = this;
1595
1596 if( !_.unslicked ) {
1597
1598 _.$slider.trigger('afterChange', [_, index]);
1599
1600 _.animating = false;
1601
1602 _.setPosition();
1603
1604 _.swipeLeft = null;
1605
1606 if ( _.options.autoplay ) {
1607 _.autoPlay();
1608 }
1609
1610 if (_.options.accessibility === true) {
1611 _.initADA();
1612 }
1613
1614 }
1615
1616 };
1617
1618 Slick.prototype.prev = Slick.prototype.slickPrev = function() {
1619
1620 var _ = this;
1621
1622 _.changeSlide({
1623 data: {
1624 message: 'previous'
1625 }
1626 });
1627
1628 };
1629
1630 Slick.prototype.preventDefault = function(event) {
1631
1632 event.preventDefault();
1633
1634 };
1635
1636 Slick.prototype.progressiveLazyLoad = function( tryCount ) {
1637
1638 tryCount = tryCount || 1;
1639
1640 var _ = this,
1641 $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
1642 image,
1643 imageSource,
1644 imageToLoad;
1645
1646 if ( $imgsToLoad.length ) {
1647
1648 image = $imgsToLoad.first();
1649 imageSource = image.attr('data-lazy');
1650 imageToLoad = document.createElement('img');
1651
1652 imageToLoad.onload = function() {
1653
1654 image
1655 .attr( 'src', imageSource )
1656 .removeAttr('data-lazy')
1657 .removeClass('slick-loading');
1658
1659 if ( _.options.adaptiveHeight === true ) {
1660 _.setPosition();
1661 }
1662
1663 _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
1664 _.progressiveLazyLoad();
1665
1666 };
1667
1668 imageToLoad.onerror = function() {
1669
1670 if ( tryCount < 3 ) {
1671
1672 /**
1673 * try to load the image 3 times,
1674 * leave a slight delay so we don't get
1675 * servers blocking the request.
1676 */
1677 setTimeout( function() {
1678 _.progressiveLazyLoad( tryCount + 1 );
1679 }, 500 );
1680
1681 } else {
1682
1683 image
1684 .removeAttr( 'data-lazy' )
1685 .removeClass( 'slick-loading' )
1686 .addClass( 'slick-lazyload-error' );
1687
1688 _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1689
1690 _.progressiveLazyLoad();
1691
1692 }
1693
1694 };
1695
1696 imageToLoad.src = imageSource;
1697
1698 } else {
1699
1700 _.$slider.trigger('allImagesLoaded', [ _ ]);
1701
1702 }
1703
1704 };
1705
1706 Slick.prototype.refresh = function( initializing ) {
1707
1708 var _ = this, currentSlide, lastVisibleIndex;
1709
1710 lastVisibleIndex = _.slideCount - _.options.slidesToShow;
1711
1712 // in non-infinite sliders, we don't want to go past the
1713 // last visible index.
1714 if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
1715 _.currentSlide = lastVisibleIndex;
1716 }
1717
1718 // if less slides than to show, go to start.
1719 if ( _.slideCount <= _.options.slidesToShow ) {
1720 _.currentSlide = 0;
1721
1722 }
1723
1724 currentSlide = _.currentSlide;
1725
1726 _.destroy(true);
1727
1728 $.extend(_, _.initials, { currentSlide: currentSlide });
1729
1730 _.init();
1731
1732 if( !initializing ) {
1733
1734 _.changeSlide({
1735 data: {
1736 message: 'index',
1737 index: currentSlide
1738 }
1739 }, false);
1740
1741 }
1742
1743 };
1744
1745 Slick.prototype.registerBreakpoints = function() {
1746
1747 var _ = this, breakpoint, currentBreakpoint, l,
1748 responsiveSettings = _.options.responsive || null;
1749
1750 if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
1751
1752 _.respondTo = _.options.respondTo || 'window';
1753
1754 for ( breakpoint in responsiveSettings ) {
1755
1756 l = _.breakpoints.length-1;
1757 currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
1758
1759 if (responsiveSettings.hasOwnProperty(breakpoint)) {
1760
1761 // loop through the breakpoints and cut out any existing
1762 // ones with the same breakpoint number, we don't want dupes.
1763 while( l >= 0 ) {
1764 if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
1765 _.breakpoints.splice(l,1);
1766 }
1767 l--;
1768 }
1769
1770 _.breakpoints.push(currentBreakpoint);
1771 _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
1772
1773 }
1774
1775 }
1776
1777 _.breakpoints.sort(function(a, b) {
1778 return ( _.options.mobileFirst ) ? a-b : b-a;
1779 });
1780
1781 }
1782
1783 };
1784
1785 Slick.prototype.reinit = function() {
1786
1787 var _ = this;
1788
1789 _.$slides =
1790 _.$slideTrack
1791 .children(_.options.slide)
1792 .addClass('slick-slide');
1793
1794 _.slideCount = _.$slides.length;
1795
1796 if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1797 _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1798 }
1799
1800 if (_.slideCount <= _.options.slidesToShow) {
1801 _.currentSlide = 0;
1802 }
1803
1804 _.registerBreakpoints();
1805
1806 _.setProps();
1807 _.setupInfinite();
1808 _.buildArrows();
1809 _.updateArrows();
1810 _.initArrowEvents();
1811 _.buildDots();
1812 _.updateDots();
1813 _.initDotEvents();
1814 _.cleanUpSlideEvents();
1815 _.initSlideEvents();
1816
1817 _.checkResponsive(false, true);
1818
1819 if (_.options.focusOnSelect === true) {
1820 $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1821 }
1822
1823 _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1824
1825 _.setPosition();
1826 _.focusHandler();
1827
1828 _.paused = !_.options.autoplay;
1829 _.autoPlay();
1830
1831 _.$slider.trigger('reInit', [_]);
1832
1833 };
1834
1835 Slick.prototype.resize = function() {
1836
1837 var _ = this;
1838
1839 if ($(window).width() !== _.windowWidth) {
1840 clearTimeout(_.windowDelay);
1841 _.windowDelay = window.setTimeout(function() {
1842 _.windowWidth = $(window).width();
1843 _.checkResponsive();
1844 if( !_.unslicked ) { _.setPosition(); }
1845 }, 50);
1846 }
1847 };
1848
1849 Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
1850
1851 var _ = this;
1852
1853 if (typeof(index) === 'boolean') {
1854 removeBefore = index;
1855 index = removeBefore === true ? 0 : _.slideCount - 1;
1856 } else {
1857 index = removeBefore === true ? --index : index;
1858 }
1859
1860 if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
1861 return false;
1862 }
1863
1864 _.unload();
1865
1866 if (removeAll === true) {
1867 _.$slideTrack.children().remove();
1868 } else {
1869 _.$slideTrack.children(this.options.slide).eq(index).remove();
1870 }
1871
1872 _.$slides = _.$slideTrack.children(this.options.slide);
1873
1874 _.$slideTrack.children(this.options.slide).detach();
1875
1876 _.$slideTrack.append(_.$slides);
1877
1878 _.$slidesCache = _.$slides;
1879
1880 _.reinit();
1881
1882 };
1883
1884 Slick.prototype.setCSS = function(position) {
1885
1886 var _ = this,
1887 positionProps = {},
1888 x, y;
1889
1890 if (_.options.rtl === true) {
1891 position = -position;
1892 }
1893 x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
1894 y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
1895
1896 positionProps[_.positionProp] = position;
1897
1898 if (_.transformsEnabled === false) {
1899 _.$slideTrack.css(positionProps);
1900 } else {
1901 positionProps = {};
1902 if (_.cssTransitions === false) {
1903 positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
1904 _.$slideTrack.css(positionProps);
1905 } else {
1906 positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
1907 _.$slideTrack.css(positionProps);
1908 }
1909 }
1910
1911 };
1912
1913 Slick.prototype.setDimensions = function() {
1914
1915 var _ = this;
1916
1917 if (_.options.vertical === false) {
1918 if (_.options.centerMode === true) {
1919 _.$list.css({
1920 padding: ('0px ' + _.options.centerPadding)
1921 });
1922 }
1923 } else {
1924 _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
1925 if (_.options.centerMode === true) {
1926 _.$list.css({
1927 padding: (_.options.centerPadding + ' 0px')
1928 });
1929 }
1930 }
1931
1932 _.listWidth = _.$list.width();
1933 _.listHeight = _.$list.height();
1934
1935
1936 if (_.options.vertical === false && _.options.variableWidth === false) {
1937 _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
1938 _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
1939
1940 } else if (_.options.variableWidth === true) {
1941 _.$slideTrack.width(5000 * _.slideCount);
1942 } else {
1943 _.slideWidth = Math.ceil(_.listWidth);
1944 _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
1945 }
1946
1947 var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
1948 if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
1949
1950 };
1951
1952 Slick.prototype.setFade = function() {
1953
1954 var _ = this,
1955 targetLeft;
1956
1957 _.$slides.each(function(index, element) {
1958 targetLeft = (_.slideWidth * index) * -1;
1959 if (_.options.rtl === true) {
1960 $(element).css({
1961 position: 'relative',
1962 right: targetLeft,
1963 top: 0,
1964 zIndex: _.options.zIndex - 2,
1965 opacity: 0
1966 });
1967 } else {
1968 $(element).css({
1969 position: 'relative',
1970 left: targetLeft,
1971 top: 0,
1972 zIndex: _.options.zIndex - 2,
1973 opacity: 0
1974 });
1975 }
1976 });
1977
1978 _.$slides.eq(_.currentSlide).css({
1979 zIndex: _.options.zIndex - 1,
1980 opacity: 1
1981 });
1982
1983 };
1984
1985 Slick.prototype.setHeight = function() {
1986
1987 var _ = this;
1988
1989 if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
1990 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
1991 _.$list.css('height', targetHeight);
1992 }
1993
1994 };
1995
1996 Slick.prototype.setOption =
1997 Slick.prototype.slickSetOption = function() {
1998
1999 /**
2000 * accepts arguments in format of:
2001 *
2002 * - for changing a single option's value:
2003 * .slick("setOption", option, value, refresh )
2004 *
2005 * - for changing a set of responsive options:
2006 * .slick("setOption", 'responsive', [{}, ...], refresh )
2007 *
2008 * - for updating multiple values at once (not responsive)
2009 * .slick("setOption", { 'option': value, ... }, refresh )
2010 */
2011
2012 var _ = this, l, item, option, value, refresh = false, type;
2013
2014 if( $.type( arguments[0] ) === 'object' ) {
2015
2016 option = arguments[0];
2017 refresh = arguments[1];
2018 type = 'multiple';
2019
2020 } else if ( $.type( arguments[0] ) === 'string' ) {
2021
2022 option = arguments[0];
2023 value = arguments[1];
2024 refresh = arguments[2];
2025
2026 if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
2027
2028 type = 'responsive';
2029
2030 } else if ( typeof arguments[1] !== 'undefined' ) {
2031
2032 type = 'single';
2033
2034 }
2035
2036 }
2037
2038 if ( type === 'single' ) {
2039
2040 _.options[option] = value;
2041
2042
2043 } else if ( type === 'multiple' ) {
2044
2045 $.each( option , function( opt, val ) {
2046
2047 _.options[opt] = val;
2048
2049 });
2050
2051
2052 } else if ( type === 'responsive' ) {
2053
2054 for ( item in value ) {
2055
2056 if( $.type( _.options.responsive ) !== 'array' ) {
2057
2058 _.options.responsive = [ value[item] ];
2059
2060 } else {
2061
2062 l = _.options.responsive.length-1;
2063
2064 // loop through the responsive object and splice out duplicates.
2065 while( l >= 0 ) {
2066
2067 if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
2068
2069 _.options.responsive.splice(l,1);
2070
2071 }
2072
2073 l--;
2074
2075 }
2076
2077 _.options.responsive.push( value[item] );
2078
2079 }
2080
2081 }
2082
2083 }
2084
2085 if ( refresh ) {
2086
2087 _.unload();
2088 _.reinit();
2089
2090 }
2091
2092 };
2093
2094 Slick.prototype.setPosition = function() {
2095
2096 var _ = this;
2097
2098 _.setDimensions();
2099
2100 _.setHeight();
2101
2102 if (_.options.fade === false) {
2103 _.setCSS(_.getLeft(_.currentSlide));
2104 } else {
2105 _.setFade();
2106 }
2107
2108 _.$slider.trigger('setPosition', [_]);
2109
2110 };
2111
2112 Slick.prototype.setProps = function() {
2113
2114 var _ = this,
2115 bodyStyle = document.body.style;
2116
2117 _.positionProp = _.options.vertical === true ? 'top' : 'left';
2118
2119 if (_.positionProp === 'top') {
2120 _.$slider.addClass('slick-vertical');
2121 } else {
2122 _.$slider.removeClass('slick-vertical');
2123 }
2124
2125 if (bodyStyle.WebkitTransition !== undefined ||
2126 bodyStyle.MozTransition !== undefined ||
2127 bodyStyle.msTransition !== undefined) {
2128 if (_.options.useCSS === true) {
2129 _.cssTransitions = true;
2130 }
2131 }
2132
2133 if ( _.options.fade ) {
2134 if ( typeof _.options.zIndex === 'number' ) {
2135 if( _.options.zIndex < 3 ) {
2136 _.options.zIndex = 3;
2137 }
2138 } else {
2139 _.options.zIndex = _.defaults.zIndex;
2140 }
2141 }
2142
2143 if (bodyStyle.OTransform !== undefined) {
2144 _.animType = 'OTransform';
2145 _.transformType = '-o-transform';
2146 _.transitionType = 'OTransition';
2147 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2148 }
2149 if (bodyStyle.MozTransform !== undefined) {
2150 _.animType = 'MozTransform';
2151 _.transformType = '-moz-transform';
2152 _.transitionType = 'MozTransition';
2153 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
2154 }
2155 if (bodyStyle.webkitTransform !== undefined) {
2156 _.animType = 'webkitTransform';
2157 _.transformType = '-webkit-transform';
2158 _.transitionType = 'webkitTransition';
2159 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2160 }
2161 if (bodyStyle.msTransform !== undefined) {
2162 _.animType = 'msTransform';
2163 _.transformType = '-ms-transform';
2164 _.transitionType = 'msTransition';
2165 if (bodyStyle.msTransform === undefined) _.animType = false;
2166 }
2167 if (bodyStyle.transform !== undefined && _.animType !== false) {
2168 _.animType = 'transform';
2169 _.transformType = 'transform';
2170 _.transitionType = 'transition';
2171 }
2172 _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
2173 };
2174
2175
2176 Slick.prototype.setSlideClasses = function(index) {
2177
2178 var _ = this,
2179 centerOffset, allSlides, indexOffset, remainder;
2180
2181 allSlides = _.$slider
2182 .find('.slick-slide')
2183 .removeClass('slick-active slick-center slick-current')
2184 .attr('aria-hidden', 'true');
2185
2186 _.$slides
2187 .eq(index)
2188 .addClass('slick-current');
2189
2190 if (_.options.centerMode === true) {
2191
2192 centerOffset = Math.floor(_.options.slidesToShow / 2);
2193
2194 if (_.options.infinite === true) {
2195
2196 if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
2197
2198 _.$slides
2199 .slice(index - centerOffset, index + centerOffset + 1)
2200 .addClass('slick-active')
2201 .attr('aria-hidden', 'false');
2202
2203 } else {
2204
2205 indexOffset = _.options.slidesToShow + index;
2206 allSlides
2207 .slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2)
2208 .addClass('slick-active')
2209 .attr('aria-hidden', 'false');
2210
2211 }
2212
2213 if (index === 0) {
2214
2215 allSlides
2216 .eq(allSlides.length - 1 - _.options.slidesToShow)
2217 .addClass('slick-center');
2218
2219 } else if (index === _.slideCount - 1) {
2220
2221 allSlides
2222 .eq(_.options.slidesToShow)
2223 .addClass('slick-center');
2224
2225 }
2226
2227 }
2228
2229 _.$slides
2230 .eq(index)
2231 .addClass('slick-center');
2232
2233 } else {
2234
2235 if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
2236
2237 _.$slides
2238 .slice(index, index + _.options.slidesToShow)
2239 .addClass('slick-active')
2240 .attr('aria-hidden', 'false');
2241
2242 } else if (allSlides.length <= _.options.slidesToShow) {
2243
2244 allSlides
2245 .addClass('slick-active')
2246 .attr('aria-hidden', 'false');
2247
2248 } else {
2249
2250 remainder = _.slideCount % _.options.slidesToShow;
2251 indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
2252
2253 if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
2254
2255 allSlides
2256 .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)
2257 .addClass('slick-active')
2258 .attr('aria-hidden', 'false');
2259
2260 } else {
2261
2262 allSlides
2263 .slice(indexOffset, indexOffset + _.options.slidesToShow)
2264 .addClass('slick-active')
2265 .attr('aria-hidden', 'false');
2266
2267 }
2268
2269 }
2270
2271 }
2272
2273 if (_.options.lazyLoad === 'ondemand') {
2274 _.lazyLoad();
2275 }
2276
2277 };
2278
2279 Slick.prototype.setupInfinite = function() {
2280
2281 var _ = this,
2282 i, slideIndex, infiniteCount;
2283
2284 if (_.options.fade === true) {
2285 _.options.centerMode = false;
2286 }
2287
2288 if (_.options.infinite === true && _.options.fade === false) {
2289
2290 slideIndex = null;
2291
2292 if (_.slideCount > _.options.slidesToShow) {
2293
2294 if (_.options.centerMode === true) {
2295 infiniteCount = _.options.slidesToShow + 1;
2296 } else {
2297 infiniteCount = _.options.slidesToShow;
2298 }
2299
2300 for (i = _.slideCount; i > (_.slideCount -
2301 infiniteCount); i -= 1) {
2302 slideIndex = i - 1;
2303 $(_.$slides[slideIndex]).clone(true).attr('id', '')
2304 .attr('data-slick-index', slideIndex - _.slideCount)
2305 .prependTo(_.$slideTrack).addClass('slick-cloned');
2306 }
2307 for (i = 0; i < infiniteCount; i += 1) {
2308 slideIndex = i;
2309 $(_.$slides[slideIndex]).clone(true).attr('id', '')
2310 .attr('data-slick-index', slideIndex + _.slideCount)
2311 .appendTo(_.$slideTrack).addClass('slick-cloned');
2312 }
2313 _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
2314 $(this).attr('id', '');
2315 });
2316
2317 }
2318
2319 }
2320
2321 };
2322
2323 Slick.prototype.interrupt = function( toggle ) {
2324
2325 var _ = this;
2326
2327 if( !toggle ) {
2328 _.autoPlay();
2329 }
2330 _.interrupted = toggle;
2331
2332 };
2333
2334 Slick.prototype.selectHandler = function(event) {
2335
2336 var _ = this;
2337
2338 var targetElement =
2339 $(event.target).is('.slick-slide') ?
2340 $(event.target) :
2341 $(event.target).parents('.slick-slide');
2342
2343 var index = parseInt(targetElement.attr('data-slick-index'));
2344
2345 if (!index) index = 0;
2346
2347 if (_.slideCount <= _.options.slidesToShow) {
2348
2349 _.setSlideClasses(index);
2350 _.asNavFor(index);
2351 return;
2352
2353 }
2354
2355 _.slideHandler(index);
2356
2357 };
2358
2359 Slick.prototype.slideHandler = function(index, sync, dontAnimate) {
2360
2361 var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
2362 _ = this, navTarget;
2363
2364 sync = sync || false;
2365
2366 if (_.animating === true && _.options.waitForAnimate === true) {
2367 return;
2368 }
2369
2370 if (_.options.fade === true && _.currentSlide === index) {
2371 return;
2372 }
2373
2374 if (_.slideCount <= _.options.slidesToShow) {
2375 return;
2376 }
2377
2378 if (sync === false) {
2379 _.asNavFor(index);
2380 }
2381
2382 targetSlide = index;
2383 targetLeft = _.getLeft(targetSlide);
2384 slideLeft = _.getLeft(_.currentSlide);
2385
2386 _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
2387
2388 if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
2389 if (_.options.fade === false) {
2390 targetSlide = _.currentSlide;
2391 if (dontAnimate !== true) {
2392 _.animateSlide(slideLeft, function() {
2393 _.postSlide(targetSlide);
2394 });
2395 } else {
2396 _.postSlide(targetSlide);
2397 }
2398 }
2399 return;
2400 } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
2401 if (_.options.fade === false) {
2402 targetSlide = _.currentSlide;
2403 if (dontAnimate !== true) {
2404 _.animateSlide(slideLeft, function() {
2405 _.postSlide(targetSlide);
2406 });
2407 } else {
2408 _.postSlide(targetSlide);
2409 }
2410 }
2411 return;
2412 }
2413
2414 if ( _.options.autoplay ) {
2415 clearInterval(_.autoPlayTimer);
2416 }
2417
2418 if (targetSlide < 0) {
2419 if (_.slideCount % _.options.slidesToScroll !== 0) {
2420 animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
2421 } else {
2422 animSlide = _.slideCount + targetSlide;
2423 }
2424 } else if (targetSlide >= _.slideCount) {
2425 if (_.slideCount % _.options.slidesToScroll !== 0) {
2426 animSlide = 0;
2427 } else {
2428 animSlide = targetSlide - _.slideCount;
2429 }
2430 } else {
2431 animSlide = targetSlide;
2432 }
2433
2434 _.animating = true;
2435
2436 _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);
2437
2438 oldSlide = _.currentSlide;
2439 _.currentSlide = animSlide;
2440
2441 _.setSlideClasses(_.currentSlide);
2442
2443 if ( _.options.asNavFor ) {
2444
2445 navTarget = _.getNavTarget();
2446 navTarget = navTarget.slick('getSlick');
2447
2448 if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {
2449 navTarget.setSlideClasses(_.currentSlide);
2450 }
2451
2452 }
2453
2454 _.updateDots();
2455 _.updateArrows();
2456
2457 if (_.options.fade === true) {
2458 if (dontAnimate !== true) {
2459
2460 _.fadeSlideOut(oldSlide);
2461
2462 _.fadeSlide(animSlide, function() {
2463 _.postSlide(animSlide);
2464 });
2465
2466 } else {
2467 _.postSlide(animSlide);
2468 }
2469 _.animateHeight();
2470 return;
2471 }
2472
2473 if (dontAnimate !== true) {
2474 _.animateSlide(targetLeft, function() {
2475 _.postSlide(animSlide);
2476 });
2477 } else {
2478 _.postSlide(animSlide);
2479 }
2480
2481 };
2482
2483 Slick.prototype.startLoad = function() {
2484
2485 var _ = this;
2486
2487 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2488
2489 _.$prevArrow.hide();
2490 _.$nextArrow.hide();
2491
2492 }
2493
2494 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2495
2496 _.$dots.hide();
2497
2498 }
2499
2500 _.$slider.addClass('slick-loading');
2501
2502 };
2503
2504 Slick.prototype.swipeDirection = function() {
2505
2506 var xDist, yDist, r, swipeAngle, _ = this;
2507
2508 xDist = _.touchObject.startX - _.touchObject.curX;
2509 yDist = _.touchObject.startY - _.touchObject.curY;
2510 r = Math.atan2(yDist, xDist);
2511
2512 swipeAngle = Math.round(r * 180 / Math.PI);
2513 if (swipeAngle < 0) {
2514 swipeAngle = 360 - Math.abs(swipeAngle);
2515 }
2516
2517 if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
2518 return (_.options.rtl === false ? 'left' : 'right');
2519 }
2520 if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
2521 return (_.options.rtl === false ? 'left' : 'right');
2522 }
2523 if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
2524 return (_.options.rtl === false ? 'right' : 'left');
2525 }
2526 if (_.options.verticalSwiping === true) {
2527 if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
2528 return 'down';
2529 } else {
2530 return 'up';
2531 }
2532 }
2533
2534 return 'vertical';
2535
2536 };
2537
2538 Slick.prototype.swipeEnd = function(event) {
2539
2540 var _ = this,
2541 slideCount,
2542 direction;
2543
2544 _.dragging = false;
2545 _.interrupted = false;
2546 _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;
2547
2548 if ( _.touchObject.curX === undefined ) {
2549 return false;
2550 }
2551
2552 if ( _.touchObject.edgeHit === true ) {
2553 _.$slider.trigger('edge', [_, _.swipeDirection() ]);
2554 }
2555
2556 if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
2557
2558 direction = _.swipeDirection();
2559
2560 switch ( direction ) {
2561
2562 case 'left':
2563 case 'down':
2564
2565 slideCount =
2566 _.options.swipeToSlide ?
2567 _.checkNavigable( _.currentSlide + _.getSlideCount() ) :
2568 _.currentSlide + _.getSlideCount();
2569
2570 _.currentDirection = 0;
2571
2572 break;
2573
2574 case 'right':
2575 case 'up':
2576
2577 slideCount =
2578 _.options.swipeToSlide ?
2579 _.checkNavigable( _.currentSlide - _.getSlideCount() ) :
2580 _.currentSlide - _.getSlideCount();
2581
2582 _.currentDirection = 1;
2583
2584 break;
2585
2586 default:
2587
2588
2589 }
2590
2591 if( direction != 'vertical' ) {
2592
2593 _.slideHandler( slideCount );
2594 _.touchObject = {};
2595 _.$slider.trigger('swipe', [_, direction ]);
2596
2597 }
2598
2599 } else {
2600
2601 if ( _.touchObject.startX !== _.touchObject.curX ) {
2602
2603 _.slideHandler( _.currentSlide );
2604 _.touchObject = {};
2605
2606 }
2607
2608 }
2609
2610 };
2611
2612 Slick.prototype.swipeHandler = function(event) {
2613
2614 var _ = this;
2615
2616 if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
2617 return;
2618 } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
2619 return;
2620 }
2621
2622 _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
2623 event.originalEvent.touches.length : 1;
2624
2625 _.touchObject.minSwipe = _.listWidth / _.options
2626 .touchThreshold;
2627
2628 if (_.options.verticalSwiping === true) {
2629 _.touchObject.minSwipe = _.listHeight / _.options
2630 .touchThreshold;
2631 }
2632
2633 switch (event.data.action) {
2634
2635 case 'start':
2636 _.swipeStart(event);
2637 break;
2638
2639 case 'move':
2640 _.swipeMove(event);
2641 break;
2642
2643 case 'end':
2644 _.swipeEnd(event);
2645 break;
2646
2647 }
2648
2649 };
2650
2651 Slick.prototype.swipeMove = function(event) {
2652
2653 var _ = this,
2654 edgeWasHit = false,
2655 curLeft, swipeDirection, swipeLength, positionOffset, touches;
2656
2657 touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
2658
2659 if (!_.dragging || touches && touches.length !== 1) {
2660 return false;
2661 }
2662
2663 curLeft = _.getLeft(_.currentSlide);
2664
2665 _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
2666 _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
2667
2668 _.touchObject.swipeLength = Math.round(Math.sqrt(
2669 Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
2670
2671 if (_.options.verticalSwiping === true) {
2672 _.touchObject.swipeLength = Math.round(Math.sqrt(
2673 Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
2674 }
2675
2676 swipeDirection = _.swipeDirection();
2677
2678 if (swipeDirection === 'vertical') {
2679 return;
2680 }
2681
2682 if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
2683 event.preventDefault();
2684 }
2685
2686 positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
2687 if (_.options.verticalSwiping === true) {
2688 positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
2689 }
2690
2691
2692 swipeLength = _.touchObject.swipeLength;
2693
2694 _.touchObject.edgeHit = false;
2695
2696 if (_.options.infinite === false) {
2697 if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
2698 swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
2699 _.touchObject.edgeHit = true;
2700 }
2701 }
2702
2703 if (_.options.vertical === false) {
2704 _.swipeLeft = curLeft + swipeLength * positionOffset;
2705 } else {
2706 _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
2707 }
2708 if (_.options.verticalSwiping === true) {
2709 _.swipeLeft = curLeft + swipeLength * positionOffset;
2710 }
2711
2712 if (_.options.fade === true || _.options.touchMove === false) {
2713 return false;
2714 }
2715
2716 if (_.animating === true) {
2717 _.swipeLeft = null;
2718 return false;
2719 }
2720
2721 _.setCSS(_.swipeLeft);
2722
2723 };
2724
2725 Slick.prototype.swipeStart = function(event) {
2726
2727 var _ = this,
2728 touches;
2729
2730 _.interrupted = true;
2731
2732 if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
2733 _.touchObject = {};
2734 return false;
2735 }
2736
2737 if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
2738 touches = event.originalEvent.touches[0];
2739 }
2740
2741 _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
2742 _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
2743
2744 _.dragging = true;
2745
2746 };
2747
2748 Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
2749
2750 var _ = this;
2751
2752 if (_.$slidesCache !== null) {
2753
2754 _.unload();
2755
2756 _.$slideTrack.children(this.options.slide).detach();
2757
2758 _.$slidesCache.appendTo(_.$slideTrack);
2759
2760 _.reinit();
2761
2762 }
2763
2764 };
2765
2766 Slick.prototype.unload = function() {
2767
2768 var _ = this;
2769
2770 $('.slick-cloned', _.$slider).remove();
2771
2772 if (_.$dots) {
2773 _.$dots.remove();
2774 }
2775
2776 if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
2777 _.$prevArrow.remove();
2778 }
2779
2780 if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
2781 _.$nextArrow.remove();
2782 }
2783
2784 _.$slides
2785 .removeClass('slick-slide slick-active slick-visible slick-current')
2786 .attr('aria-hidden', 'true')
2787 .css('width', '');
2788
2789 };
2790
2791 Slick.prototype.unslick = function(fromBreakpoint) {
2792
2793 var _ = this;
2794 _.$slider.trigger('unslick', [_, fromBreakpoint]);
2795 _.destroy();
2796
2797 };
2798
2799 Slick.prototype.updateArrows = function() {
2800
2801 var _ = this,
2802 centerOffset;
2803
2804 centerOffset = Math.floor(_.options.slidesToShow / 2);
2805
2806 if ( _.options.arrows === true &&
2807 _.slideCount > _.options.slidesToShow &&
2808 !_.options.infinite ) {
2809
2810 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2811 _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2812
2813 if (_.currentSlide === 0) {
2814
2815 _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2816 _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2817
2818 } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {
2819
2820 _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2821 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2822
2823 } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {
2824
2825 _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2826 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2827
2828 }
2829
2830 }
2831
2832 };
2833
2834 Slick.prototype.updateDots = function() {
2835
2836 var _ = this;
2837
2838 if (_.$dots !== null) {
2839
2840 _.$dots
2841 .find('li')
2842 .removeClass('slick-active')
2843 .attr('aria-hidden', 'true');
2844
2845 _.$dots
2846 .find('li')
2847 .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))
2848 .addClass('slick-active')
2849 .attr('aria-hidden', 'false');
2850
2851 }
2852
2853 };
2854
2855 Slick.prototype.visibility = function() {
2856
2857 var _ = this;
2858
2859 if ( _.options.autoplay ) {
2860
2861 if ( document[_.hidden] ) {
2862
2863 _.interrupted = true;
2864
2865 } else {
2866
2867 _.interrupted = false;
2868
2869 }
2870
2871 }
2872
2873 };
2874
2875 $.fn.slick = function() {
2876 var _ = this,
2877 opt = arguments[0],
2878 args = Array.prototype.slice.call(arguments, 1),
2879 l = _.length,
2880 i,
2881 ret;
2882 for (i = 0; i < l; i++) {
2883 if (typeof opt == 'object' || typeof opt == 'undefined')
2884 _[i].slick = new Slick(_[i], opt);
2885 else
2886 ret = _[i].slick[opt].apply(_[i].slick, args);
2887 if (typeof ret != 'undefined') return ret;
2888 }
2889 return _;
2890 };
2891
2892 }));
2893