phcthemes_admin_panel_pack 1.6.1 → 1.7.0

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