slabs-rails 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (69) hide show
  1. checksums.yaml +7 -0
  2. data/.gitignore +5 -0
  3. data/LICENSE.txt +21 -0
  4. data/README.md +32 -0
  5. data/assets/images/ajax-loader.gif +0 -0
  6. data/assets/images/arrow1-blue.png +0 -0
  7. data/assets/images/arrow1.png +0 -0
  8. data/assets/images/arrow2-blue.png +0 -0
  9. data/assets/images/arrow2.png +0 -0
  10. data/assets/images/arrow3-blue.png +0 -0
  11. data/assets/images/arrow3.png +0 -0
  12. data/assets/images/arrow4-blue.png +0 -0
  13. data/assets/images/arrow4.png +0 -0
  14. data/assets/images/btn-play.png +0 -0
  15. data/assets/images/circle1-blue.png +0 -0
  16. data/assets/images/circle1.png +0 -0
  17. data/assets/images/circle2-blue.png +0 -0
  18. data/assets/images/circle2.png +0 -0
  19. data/assets/images/circle3-blue.png +0 -0
  20. data/assets/images/circle3.png +0 -0
  21. data/assets/images/circle4-blue.png +0 -0
  22. data/assets/images/circle4.png +0 -0
  23. data/assets/javascripts/slabs-sprockets.js +4 -0
  24. data/assets/javascripts/slabs.js +3401 -0
  25. data/assets/javascripts/slabs.min.js +7 -0
  26. data/assets/javascripts/slabs/ekko-lightbox.js +446 -0
  27. data/assets/javascripts/slabs/slabs.headers.js +51 -0
  28. data/assets/javascripts/slabs/slabs.js +4 -0
  29. data/assets/javascripts/slabs/slick.js +2892 -0
  30. data/assets/stylesheets/_slabs-mincer.scss +18 -0
  31. data/assets/stylesheets/_slabs-sprockets.scss +5 -0
  32. data/assets/stylesheets/_slabs.scss +40 -0
  33. data/assets/stylesheets/slabs/_backgrounds.scss +5 -0
  34. data/assets/stylesheets/slabs/_buttons.scss +25 -0
  35. data/assets/stylesheets/slabs/_mixins.scss +7 -0
  36. data/assets/stylesheets/slabs/_sweet_hacks.scss +19 -0
  37. data/assets/stylesheets/slabs/_typo.scss +27 -0
  38. data/assets/stylesheets/slabs/_variables.scss +114 -0
  39. data/assets/stylesheets/slabs/_wells.scss +9 -0
  40. data/assets/stylesheets/slabs/commons/_headers.scss +37 -0
  41. data/assets/stylesheets/slabs/commons/ekko-lightbox.scss +127 -0
  42. data/assets/stylesheets/slabs/commons/slick.scss +312 -0
  43. data/assets/stylesheets/slabs/contents/_content-1.scss +45 -0
  44. data/assets/stylesheets/slabs/contents/_content-10.scss +18 -0
  45. data/assets/stylesheets/slabs/contents/_content-11.scss +18 -0
  46. data/assets/stylesheets/slabs/contents/_content-12.scss +42 -0
  47. data/assets/stylesheets/slabs/contents/_content-13.scss +64 -0
  48. data/assets/stylesheets/slabs/contents/_content-2.scss +11 -0
  49. data/assets/stylesheets/slabs/contents/_content-3.scss +23 -0
  50. data/assets/stylesheets/slabs/contents/_content-4.scss +54 -0
  51. data/assets/stylesheets/slabs/contents/_content-5.scss +27 -0
  52. data/assets/stylesheets/slabs/contents/_content-6.scss +63 -0
  53. data/assets/stylesheets/slabs/contents/_content-7.scss +71 -0
  54. data/assets/stylesheets/slabs/contents/_content-8.scss +22 -0
  55. data/assets/stylesheets/slabs/contents/_content-9.scss +46 -0
  56. data/assets/stylesheets/slabs/footers/_footer-1.scss +60 -0
  57. data/assets/stylesheets/slabs/footers/_footer-2.scss +29 -0
  58. data/assets/stylesheets/slabs/headers/_header-1.scss +97 -0
  59. data/assets/stylesheets/slabs/headers/_header-2.scss +134 -0
  60. data/assets/stylesheets/slabs/mixins/_backgrounds.scss +12 -0
  61. data/assets/stylesheets/slabs/mixins/_breakpoints.scss +108 -0
  62. data/assets/stylesheets/slabs/mixins/_buttons.scss +28 -0
  63. data/assets/stylesheets/slabs/mixins/_transitions.scss +128 -0
  64. data/assets/stylesheets/slabs/people/_people-1.scss +52 -0
  65. data/assets/stylesheets/slabs/people/_people-2.scss +51 -0
  66. data/lib/slabs-rails.rb +51 -0
  67. data/lib/slabs-rails/engine.rb +11 -0
  68. data/slabs-rails.gemspec +20 -0
  69. metadata +139 -0
@@ -0,0 +1,51 @@
1
+ var checkNavScroll;
2
+
3
+ slabs.headers = slabs.headers || {};
4
+
5
+ slabs.headers.header2 = function() {
6
+ return $('.header-2').slick({
7
+ dots: true,
8
+ infinite: true,
9
+ autoplaySpeed: 8000,
10
+ speed: 500,
11
+ prevArrow: '<i class="slick_prev fa fa-angle-left"></i>',
12
+ nextArrow: '<i class="slick_next fa fa-angle-right"></i>',
13
+ autoplay: true,
14
+ fade: true
15
+ });
16
+ };
17
+
18
+ (function($) {
19
+ return $(function() {
20
+
21
+ /* implementing headers */
22
+ var header, headerNumber;
23
+ for (header in slabs.headers) {
24
+ header = header;
25
+ headerNumber = header.slice(6);
26
+ if (jQuery('.header-' + headerNumber).length !== 0) {
27
+ slabs.headers[header]();
28
+ }
29
+ return;
30
+ }
31
+ });
32
+ })(jQuery);
33
+
34
+ checkNavScroll = function() {
35
+ var startY;
36
+ startY = $('.navbar-transparent').height() * 2;
37
+ if ($(window).scrollTop() > startY) {
38
+ $('.navbar-transparent').addClass('scrolled');
39
+ } else {
40
+ $('.navbar-transparent').removeClass('scrolled');
41
+ }
42
+ };
43
+
44
+ $(function() {
45
+ if ($('.navbar-transparent').length > 0) {
46
+ console.log("Starting!!!");
47
+ return $(window).on('scroll load resize', function() {
48
+ checkNavScroll();
49
+ });
50
+ }
51
+ });
@@ -0,0 +1,4 @@
1
+ window.slabs = {
2
+ name: 'Slabs',
3
+ version: '1.0.0'
4
+ };
@@ -0,0 +1,2892 @@
1
+ /*
2
+ _ _ _ _
3
+ ___| (_) ___| | __ (_)___
4
+ / __| | |/ __| |/ / | / __|
5
+ \__ \ | | (__| < _ | \__ \
6
+ |___/_|_|\___|_|\_(_)/ |___/
7
+ |__/
8
+
9
+ Version: 1.5.9
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
+ }));