jquery-slick-rails 1.3.7 → 1.3.9

Sign up to get free protection for your applications and to get access to all the features.
Files changed (5) hide show
  1. checksums.yaml +4 -4
  2. data/lib/jquery-slick-rails/version.rb +1 -1
  3. data/vendor/assets/javascripts/jquery.slick.js +1430 -1320
  4. data/vendor/assets/stylesheets/slick.css +3 -3
  5. metadata +3 -3
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 9555d9863b00347bbbfd4df4bd07eadefcb81823
4
- data.tar.gz: 064c1bf51457ca7515d4515e8fa8d27143bd9a89
3
+ metadata.gz: c5ea182f7fd006fa3c482f88faa77ed43eca0a49
4
+ data.tar.gz: 08f842f98e90aac665f8775dbc77cf2563b386c0
5
5
  SHA512:
6
- metadata.gz: f99d97538b03f3ec94c0b07d2aad66dfdde314692c8ef0ce0f9f3543393ead7334ddb77276adad11161e4017cd581d53e52902df4bebe56082978b29bf6f5c74
7
- data.tar.gz: cac4de35e7b199b7dec8044546a62dd3d994441dbeb0f603481fa5d9c30978def35e5115c723d6f8eda58788edf1d52ed959e4c2d01b3dbf8c000b8823ecb44a
6
+ metadata.gz: 3e6ece8162c9fa2e996b60fe76961a7fcae4daa933d333c1897459027944bde577cbeb1c4475decb5a40548a11b2ba14bce03ecd57c410daef33832f3524c166
7
+ data.tar.gz: 6b2eff5031fc67940fa84af78e095bec28101b99cc94eecfbcee08617771e5db76320b659b26c28f6ddb25bee81593f1386cef40bff9cf9ef809c9bffdca54ef
data/lib/jquery-slick-rails/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module JquerySlickRails
2
- VERSION = "1.3.7"
2
+ VERSION = "1.3.9"
3
3
  end
data/vendor/assets/javascripts/jquery.slick.js CHANGED
@@ -6,7 +6,7 @@
6
6
  |___/_|_|\___|_|\_(_)/ |___/
7
7
  |__/
8
8
 
9
- Version: 1.3.7
9
+ Version: 1.3.9
10
10
  Author: Ken Wheeler
11
11
  Website: http://kenwheeler.github.io
12
12
  Docs: http://kenwheeler.github.io/slick
@@ -18,1815 +18,1925 @@
18
18
  /* global window, document, define, jQuery, setInterval, clearInterval */
19
19
 
20
20
  (function(factory) {
21
- 'use strict';
22
- if (typeof define === 'function' && define.amd) {
23
- define(['jquery'], factory);
24
- } else {
25
- factory(jQuery);
26
- }
21
+ 'use strict';
22
+ if (typeof define === 'function' && define.amd) {
23
+ define(['jquery'], factory);
24
+ } else if (typeof exports !== 'undefined') {
25
+ module.exports = factory(require('jquery'));
26
+ } else {
27
+ factory(jQuery);
28
+ }
27
29
 
28
30
  }(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,
39
- responsiveSettings, breakpoint;
40
-
41
- _.defaults = {
42
- accessibility: true,
43
- appendArrows: $(element),
44
- arrows: true,
45
- asNavFor: null,
46
- prevArrow: '<button type="button" data-role="none" class="slick-prev">Previous</button>',
47
- nextArrow: '<button type="button" data-role="none" class="slick-next">Next</button>',
48
- autoplay: false,
49
- autoplaySpeed: 3000,
50
- centerMode: false,
51
- centerPadding: '50px',
52
- cssEase: 'ease',
53
- customPaging: function(slider, i) {
54
- return '<button type="button" data-role="none">' + (i + 1) + '</button>';
55
- },
56
- dots: false,
57
- dotsClass: 'slick-dots',
58
- draggable: true,
59
- easing: 'linear',
60
- fade: false,
61
- focusOnSelect: false,
62
- infinite: true,
63
- lazyLoad: 'ondemand',
64
- onBeforeChange: null,
65
- onAfterChange: null,
66
- onInit: null,
67
- onReInit: null,
68
- pauseOnHover: true,
69
- pauseOnDotsHover: false,
70
- responsive: null,
71
- rtl: false,
72
- slide: 'div',
73
- slidesToShow: 1,
74
- slidesToScroll: 1,
75
- speed: 300,
76
- swipe: true,
77
- touchMove: true,
78
- touchThreshold: 5,
79
- useCSS: true,
80
- vertical: false
81
- };
82
-
83
- _.initials = {
84
- animating: false,
85
- dragging: false,
86
- autoPlayTimer: null,
87
- currentSlide: 0,
88
- currentLeft: null,
89
- direction: 1,
90
- $dots: null,
91
- listWidth: null,
92
- listHeight: null,
93
- loadIndex: 0,
94
- $nextArrow: null,
95
- $prevArrow: null,
96
- slideCount: null,
97
- slideWidth: null,
98
- $slideTrack: null,
99
- $slides: null,
100
- sliding: false,
101
- slideOffset: 0,
102
- swipeLeft: null,
103
- $list: null,
104
- touchObject: {},
105
- transformsEnabled: false
106
- };
107
-
108
- $.extend(_, _.initials);
109
-
110
- _.activeBreakpoint = null;
111
- _.animType = null;
112
- _.animProp = null;
113
- _.breakpoints = [];
114
- _.breakpointSettings = [];
115
- _.cssTransitions = false;
116
- _.paused = false;
117
- _.positionProp = null;
118
- _.$slider = $(element);
119
- _.$slidesCache = null;
120
- _.transformType = null;
121
- _.transitionType = null;
122
- _.windowWidth = 0;
123
- _.windowTimer = null;
124
-
125
- _.options = $.extend({}, _.defaults, settings);
126
-
127
- _.originalSettings = _.options;
128
- responsiveSettings = _.options.responsive || null;
129
-
130
- if (responsiveSettings && responsiveSettings.length > -1) {
131
- for (breakpoint in responsiveSettings) {
132
- if (responsiveSettings.hasOwnProperty(breakpoint)) {
133
- _.breakpoints.push(responsiveSettings[
134
- breakpoint].breakpoint);
135
- _.breakpointSettings[responsiveSettings[
136
- breakpoint].breakpoint] =
137
- responsiveSettings[breakpoint].settings;
138
- }
139
- }
140
- _.breakpoints.sort(function(a, b) {
141
- return b - a;
142
- });
143
- }
144
-
145
- _.autoPlay = $.proxy(_.autoPlay, _);
146
- _.autoPlayClear = $.proxy(_.autoPlayClear, _);
147
- _.changeSlide = $.proxy(_.changeSlide, _);
148
- _.selectHandler = $.proxy(_.selectHandler, _);
149
- _.setPosition = $.proxy(_.setPosition, _);
150
- _.swipeHandler = $.proxy(_.swipeHandler, _);
151
- _.dragHandler = $.proxy(_.dragHandler, _);
152
- _.keyHandler = $.proxy(_.keyHandler, _);
153
- _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
154
-
155
- _.instanceUid = instanceUid++;
31
+ 'use strict';
32
+ var Slick = window.Slick || {};
33
+
34
+ Slick = (function() {
35
+
36
+ var instanceUid = 0;
37
+
38
+ function Slick(element, settings) {
39
+
40
+ var _ = this,
41
+ responsiveSettings, breakpoint;
42
+
43
+ _.defaults = {
44
+ accessibility: true,
45
+ adaptiveHeight: false,
46
+ appendArrows: $(element),
47
+ appendDots: $(element),
48
+ arrows: true,
49
+ asNavFor: null,
50
+ prevArrow: '<button type="button" data-role="none" class="slick-prev">Previous</button>',
51
+ nextArrow: '<button type="button" data-role="none" class="slick-next">Next</button>',
52
+ autoplay: false,
53
+ autoplaySpeed: 3000,
54
+ centerMode: false,
55
+ centerPadding: '50px',
56
+ cssEase: 'ease',
57
+ customPaging: function(slider, i) {
58
+ return '<button type="button" data-role="none">' + (i + 1) + '</button>';
59
+ },
60
+ dots: false,
61
+ dotsClass: 'slick-dots',
62
+ draggable: true,
63
+ easing: 'linear',
64
+ fade: false,
65
+ focusOnSelect: false,
66
+ infinite: true,
67
+ lazyLoad: 'ondemand',
68
+ onBeforeChange: null,
69
+ onAfterChange: null,
70
+ onInit: null,
71
+ onReInit: null,
72
+ pauseOnHover: true,
73
+ pauseOnDotsHover: false,
74
+ responsive: null,
75
+ rtl: false,
76
+ slide: 'div',
77
+ slidesToShow: 1,
78
+ slidesToScroll: 1,
79
+ speed: 300,
80
+ swipe: true,
81
+ swipeToSlide: false,
82
+ touchMove: true,
83
+ touchThreshold: 5,
84
+ useCSS: true,
85
+ variableWidth: false,
86
+ vertical: false,
87
+ waitForAnimate: true
88
+ };
89
+
90
+ _.initials = {
91
+ animating: false,
92
+ dragging: false,
93
+ autoPlayTimer: null,
94
+ currentSlide: 0,
95
+ currentLeft: null,
96
+ direction: 1,
97
+ $dots: null,
98
+ listWidth: null,
99
+ listHeight: null,
100
+ loadIndex: 0,
101
+ $nextArrow: null,
102
+ $prevArrow: null,
103
+ slideCount: null,
104
+ slideWidth: null,
105
+ $slideTrack: null,
106
+ $slides: null,
107
+ sliding: false,
108
+ slideOffset: 0,
109
+ swipeLeft: null,
110
+ $list: null,
111
+ touchObject: {},
112
+ transformsEnabled: false
113
+ };
114
+
115
+ $.extend(_, _.initials);
116
+
117
+ _.activeBreakpoint = null;
118
+ _.animType = null;
119
+ _.animProp = null;
120
+ _.breakpoints = [];
121
+ _.breakpointSettings = [];
122
+ _.cssTransitions = false;
123
+ _.paused = false;
124
+ _.positionProp = null;
125
+ _.$slider = $(element);
126
+ _.$slidesCache = null;
127
+ _.transformType = null;
128
+ _.transitionType = null;
129
+ _.windowWidth = 0;
130
+ _.windowTimer = null;
131
+
132
+ _.options = $.extend({}, _.defaults, settings);
133
+
134
+ _.originalSettings = _.options;
135
+ responsiveSettings = _.options.responsive || null;
136
+
137
+ if (responsiveSettings && responsiveSettings.length > -1) {
138
+ for (breakpoint in responsiveSettings) {
139
+ if (responsiveSettings.hasOwnProperty(breakpoint)) {
140
+ _.breakpoints.push(responsiveSettings[
141
+ breakpoint].breakpoint);
142
+ _.breakpointSettings[responsiveSettings[
143
+ breakpoint].breakpoint] =
144
+ responsiveSettings[breakpoint].settings;
145
+ }
146
+ }
147
+ _.breakpoints.sort(function(a, b) {
148
+ return b - a;
149
+ });
150
+ }
156
151
 
157
- // A simple way to check for HTML strings
158
- // Strict HTML recognition (must start with <)
159
- // Extracted from jQuery v1.11 source
160
- _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
152
+ _.autoPlay = $.proxy(_.autoPlay, _);
153
+ _.autoPlayClear = $.proxy(_.autoPlayClear, _);
154
+ _.changeSlide = $.proxy(_.changeSlide, _);
155
+ _.selectHandler = $.proxy(_.selectHandler, _);
156
+ _.setPosition = $.proxy(_.setPosition, _);
157
+ _.swipeHandler = $.proxy(_.swipeHandler, _);
158
+ _.dragHandler = $.proxy(_.dragHandler, _);
159
+ _.keyHandler = $.proxy(_.keyHandler, _);
160
+ _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
161
161
 
162
- _.init();
162
+ _.instanceUid = instanceUid++;
163
163
 
164
- }
164
+ // A simple way to check for HTML strings
165
+ // Strict HTML recognition (must start with <)
166
+ // Extracted from jQuery v1.11 source
167
+ _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
165
168
 
166
- return Slick;
169
+ _.init();
167
170
 
168
- }());
171
+ }
169
172
 
170
- Slick.prototype.addSlide = function(markup, index, addBefore) {
173
+ return Slick;
171
174
 
172
- var _ = this;
175
+ }());
173
176
 
174
- if (typeof(index) === 'boolean') {
175
- addBefore = index;
176
- index = null;
177
- } else if (index < 0 || (index >= _.slideCount)) {
178
- return false;
179
- }
177
+ Slick.prototype.addSlide = function(markup, index, addBefore) {
180
178
 
181
- _.unload();
179
+ var _ = this;
182
180
 
183
- if (typeof(index) === 'number') {
184
- if (index === 0 && _.$slides.length === 0) {
185
- $(markup).appendTo(_.$slideTrack);
186
- } else if (addBefore) {
187
- $(markup).insertBefore(_.$slides.eq(index));
188
- } else {
189
- $(markup).insertAfter(_.$slides.eq(index));
190
- }
191
- } else {
192
- if (addBefore === true) {
193
- $(markup).prependTo(_.$slideTrack);
194
- } else {
195
- $(markup).appendTo(_.$slideTrack);
196
- }
197
- }
181
+ if (typeof(index) === 'boolean') {
182
+ addBefore = index;
183
+ index = null;
184
+ } else if (index < 0 || (index >= _.slideCount)) {
185
+ return false;
186
+ }
198
187
 
199
- _.$slides = _.$slideTrack.children(this.options.slide);
188
+ _.unload();
200
189
 
201
- _.$slideTrack.children(this.options.slide).detach();
190
+ if (typeof(index) === 'number') {
191
+ if (index === 0 && _.$slides.length === 0) {
192
+ $(markup).appendTo(_.$slideTrack);
193
+ } else if (addBefore) {
194
+ $(markup).insertBefore(_.$slides.eq(index));
195
+ } else {
196
+ $(markup).insertAfter(_.$slides.eq(index));
197
+ }
198
+ } else {
199
+ if (addBefore === true) {
200
+ $(markup).prependTo(_.$slideTrack);
201
+ } else {
202
+ $(markup).appendTo(_.$slideTrack);
203
+ }
204
+ }
202
205
 
203
- _.$slideTrack.append(_.$slides);
206
+ _.$slides = _.$slideTrack.children(this.options.slide);
204
207
 
205
- _.$slides.each(function(index, element) {
206
- $(element).attr("index",index);
207
- });
208
+ _.$slideTrack.children(this.options.slide).detach();
208
209
 
209
- _.$slidesCache = _.$slides;
210
+ _.$slideTrack.append(_.$slides);
210
211
 
211
- _.reinit();
212
+ _.$slides.each(function(index, element) {
213
+ $(element).attr("index",index);
214
+ });
212
215
 
213
- };
216
+ _.$slidesCache = _.$slides;
214
217
 
215
- Slick.prototype.animateSlide = function(targetLeft, callback) {
218
+ _.reinit();
216
219
 
217
- var animProps = {}, _ = this;
220
+ };
218
221
 
219
- if (_.options.rtl === true && _.options.vertical === false) {
220
- targetLeft = -targetLeft;
221
- }
222
- if (_.transformsEnabled === false) {
223
- if (_.options.vertical === false) {
224
- _.$slideTrack.animate({
225
- left: targetLeft
226
- }, _.options.speed, _.options.easing, callback);
227
- } else {
228
- _.$slideTrack.animate({
229
- top: targetLeft
230
- }, _.options.speed, _.options.easing, callback);
231
- }
222
+ Slick.prototype.animateSlide = function(targetLeft, callback) {
232
223
 
233
- } else {
224
+ var animProps = {}, _ = this;
234
225
 
235
- if (_.cssTransitions === false) {
226
+ if(_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
227
+ var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
228
+ _.$list.animate({height: targetHeight},_.options.speed);
229
+ }
236
230
 
237
- $({
238
- animStart: _.currentLeft
239
- }).animate({
240
- animStart: targetLeft
241
- }, {
242
- duration: _.options.speed,
243
- easing: _.options.easing,
244
- step: function(now) {
231
+ if (_.options.rtl === true && _.options.vertical === false) {
232
+ targetLeft = -targetLeft;
233
+ }
234
+ if (_.transformsEnabled === false) {
245
235
  if (_.options.vertical === false) {
246
- animProps[_.animType] = 'translate(' +
247
- now + 'px, 0px)';
248
- _.$slideTrack.css(animProps);
236
+ _.$slideTrack.animate({
237
+ left: targetLeft
238
+ }, _.options.speed, _.options.easing, callback);
249
239
  } else {
250
- animProps[_.animType] = 'translate(0px,' +
251
- now + 'px)';
252
- _.$slideTrack.css(animProps);
240
+ _.$slideTrack.animate({
241
+ top: targetLeft
242
+ }, _.options.speed, _.options.easing, callback);
253
243
  }
254
- },
255
- complete: function() {
256
- if (callback) {
257
- callback.call();
258
- }
259
- }
260
- });
261
244
 
262
- } else {
245
+ } else {
263
246
 
264
- _.applyTransition();
247
+ if (_.cssTransitions === false) {
248
+
249
+ $({
250
+ animStart: _.currentLeft
251
+ }).animate({
252
+ animStart: targetLeft
253
+ }, {
254
+ duration: _.options.speed,
255
+ easing: _.options.easing,
256
+ step: function(now) {
257
+ if (_.options.vertical === false) {
258
+ animProps[_.animType] = 'translate(' +
259
+ now + 'px, 0px)';
260
+ _.$slideTrack.css(animProps);
261
+ } else {
262
+ animProps[_.animType] = 'translate(0px,' +
263
+ now + 'px)';
264
+ _.$slideTrack.css(animProps);
265
+ }
266
+ },
267
+ complete: function() {
268
+ if (callback) {
269
+ callback.call();
270
+ }
271
+ }
272
+ });
265
273
 
266
- if (_.options.vertical === false) {
267
- animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
268
- } else {
269
- animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
270
- }
271
- _.$slideTrack.css(animProps);
274
+ } else {
272
275
 
273
- if (callback) {
274
- setTimeout(function() {
276
+ _.applyTransition();
275
277
 
276
- _.disableTransition();
278
+ if (_.options.vertical === false) {
279
+ animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
280
+ } else {
281
+ animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
282
+ }
283
+ _.$slideTrack.css(animProps);
277
284
 
278
- callback.call();
279
- }, _.options.speed);
280
- }
285
+ if (callback) {
286
+ setTimeout(function() {
281
287
 
282
- }
288
+ _.disableTransition();
283
289
 
284
- }
290
+ callback.call();
291
+ }, _.options.speed);
292
+ }
285
293
 
286
- };
294
+ }
287
295
 
288
- Slick.prototype.applyTransition = function(slide) {
296
+ }
289
297
 
290
- var _ = this,
291
- transition = {};
298
+ };
292
299
 
293
- if (_.options.fade === false) {
294
- transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
295
- } else {
296
- transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
297
- }
300
+ Slick.prototype.asNavFor = function(index) {
301
+ var _ = this, asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
302
+ if(asNavFor != null) asNavFor.slideHandler(index, true);
303
+ };
298
304
 
299
- if (_.options.fade === false) {
300
- _.$slideTrack.css(transition);
301
- } else {
302
- _.$slides.eq(slide).css(transition);
303
- }
305
+ Slick.prototype.applyTransition = function(slide) {
304
306
 
305
- };
307
+ var _ = this,
308
+ transition = {};
306
309
 
307
- Slick.prototype.autoPlay = function() {
310
+ if (_.options.fade === false) {
311
+ transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
312
+ } else {
313
+ transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
314
+ }
308
315
 
309
- var _ = this;
316
+ if (_.options.fade === false) {
317
+ _.$slideTrack.css(transition);
318
+ } else {
319
+ _.$slides.eq(slide).css(transition);
320
+ }
310
321
 
311
- if (_.autoPlayTimer) {
312
- clearInterval(_.autoPlayTimer);
313
- }
322
+ };
314
323
 
315
- if (_.slideCount > _.options.slidesToShow && _.paused !== true) {
316
- _.autoPlayTimer = setInterval(_.autoPlayIterator,
317
- _.options.autoplaySpeed);
318
- }
324
+ Slick.prototype.autoPlay = function() {
325
+
326
+ var _ = this;
319
327
 
320
- };
328
+ if (_.autoPlayTimer) {
329
+ clearInterval(_.autoPlayTimer);
330
+ }
321
331
 
322
- Slick.prototype.autoPlayClear = function() {
332
+ if (_.slideCount > _.options.slidesToShow && _.paused !== true) {
333
+ _.autoPlayTimer = setInterval(_.autoPlayIterator,
334
+ _.options.autoplaySpeed);
335
+ }
323
336
 
324
- var _ = this;
337
+ };
325
338
 
326
- if (_.autoPlayTimer) {
327
- clearInterval(_.autoPlayTimer);
328
- }
339
+ Slick.prototype.autoPlayClear = function() {
329
340
 
330
- };
341
+ var _ = this;
331
342
 
332
- Slick.prototype.autoPlayIterator = function() {
343
+ if (_.autoPlayTimer) {
344
+ clearInterval(_.autoPlayTimer);
345
+ }
333
346
 
334
- var _ = this;
335
- var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
347
+ };
336
348
 
337
- if (_.options.infinite === false) {
349
+ Slick.prototype.autoPlayIterator = function() {
338
350
 
339
- if (_.direction === 1) {
351
+ var _ = this;
340
352
 
341
- if ((_.currentSlide + 1) === _.slideCount -
342
- 1) {
343
- _.direction = 0;
344
- }
353
+ if (_.options.infinite === false) {
345
354
 
346
- _.slideHandler(_.currentSlide + _.options.slidesToScroll);
347
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
355
+ if (_.direction === 1) {
348
356
 
349
- } else {
357
+ if ((_.currentSlide + 1) === _.slideCount -
358
+ 1) {
359
+ _.direction = 0;
360
+ }
350
361
 
351
- if ((_.currentSlide - 1 === 0)) {
362
+ _.slideHandler(_.currentSlide + _.options.slidesToScroll);
352
363
 
353
- _.direction = 1;
364
+ } else {
354
365
 
355
- }
366
+ if ((_.currentSlide - 1 === 0)) {
356
367
 
357
- _.slideHandler(_.currentSlide - _.options.slidesToScroll);
358
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide - asNavFor.options.slidesToScroll);
368
+ _.direction = 1;
359
369
 
360
- }
370
+ }
361
371
 
362
- } else {
372
+ _.slideHandler(_.currentSlide - _.options.slidesToScroll);
363
373
 
364
- _.slideHandler(_.currentSlide + _.options.slidesToScroll);
365
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
374
+ }
366
375
 
367
- }
376
+ } else {
368
377
 
369
- };
378
+ _.slideHandler(_.currentSlide + _.options.slidesToScroll);
370
379
 
371
- Slick.prototype.buildArrows = function() {
380
+ }
372
381
 
373
- var _ = this;
382
+ };
374
383
 
375
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
384
+ Slick.prototype.buildArrows = function() {
376
385
 
377
- _.$prevArrow = $(_.options.prevArrow);
378
- _.$nextArrow = $(_.options.nextArrow);
386
+ var _ = this;
379
387
 
380
- if (_.htmlExpr.test(_.options.prevArrow)) {
381
- _.$prevArrow.appendTo(_.options.appendArrows);
382
- }
388
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
383
389
 
384
- if (_.htmlExpr.test(_.options.nextArrow)) {
385
- _.$nextArrow.appendTo(_.options.appendArrows);
386
- }
390
+ _.$prevArrow = $(_.options.prevArrow);
391
+ _.$nextArrow = $(_.options.nextArrow);
387
392
 
388
- if (_.options.infinite !== true) {
389
- _.$prevArrow.addClass('slick-disabled');
390
- }
393
+ if (_.htmlExpr.test(_.options.prevArrow)) {
394
+ _.$prevArrow.appendTo(_.options.appendArrows);
395
+ }
391
396
 
392
- }
397
+ if (_.htmlExpr.test(_.options.nextArrow)) {
398
+ _.$nextArrow.appendTo(_.options.appendArrows);
399
+ }
393
400
 
394
- };
401
+ if (_.options.infinite !== true) {
402
+ _.$prevArrow.addClass('slick-disabled');
403
+ }
395
404
 
396
- Slick.prototype.buildDots = function() {
405
+ }
397
406
 
398
- var _ = this,
399
- i, dotString;
407
+ };
400
408
 
401
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
409
+ Slick.prototype.buildDots = function() {
402
410
 
403
- dotString = '<ul class="' + _.options.dotsClass + '">';
411
+ var _ = this,
412
+ i, dotString;
404
413
 
405
- for (i = 0; i <= _.getDotCount(); i += 1) {
406
- dotString += '<li>' + _.options.customPaging.call(this, _, i) + '</li>';
407
- }
414
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
408
415
 
409
- dotString += '</ul>';
416
+ dotString = '<ul class="' + _.options.dotsClass + '">';
410
417
 
411
- _.$dots = $(dotString).appendTo(
412
- _.$slider);
418
+ for (i = 0; i <= _.getDotCount(); i += 1) {
419
+ dotString += '<li>' + _.options.customPaging.call(this, _, i) + '</li>';
420
+ }
413
421
 
414
- _.$dots.find('li').first().addClass(
415
- 'slick-active');
422
+ dotString += '</ul>';
416
423
 
417
- }
424
+ _.$dots = $(dotString).appendTo(
425
+ _.options.appendDots);
426
+
427
+ _.$dots.find('li').first().addClass(
428
+ 'slick-active');
418
429
 
419
- };
430
+ }
420
431
 
421
- Slick.prototype.buildOut = function() {
432
+ };
422
433
 
423
- var _ = this;
434
+ Slick.prototype.buildOut = function() {
424
435
 
425
- _.$slides = _.$slider.children(_.options.slide +
436
+ var _ = this;
437
+
438
+ _.$slides = _.$slider.children(_.options.slide +
426
439
  ':not(.slick-cloned)').addClass(
427
440
  'slick-slide');
428
- _.slideCount = _.$slides.length;
441
+ _.slideCount = _.$slides.length;
442
+
443
+ _.$slides.each(function(index, element) {
444
+ $(element).attr("index",index);
445
+ });
429
446
 
430
- _.$slides.each(function(index, element) {
431
- $(element).attr("index",index);
432
- });
447
+ _.$slidesCache = _.$slides;
433
448
 
434
- _.$slidesCache = _.$slides;
449
+ _.$slider.addClass('slick-slider');
435
450
 
436
- _.$slider.addClass('slick-slider');
451
+ _.$slideTrack = (_.slideCount === 0) ?
452
+ $('<div class="slick-track"/>').appendTo(_.$slider) :
453
+ _.$slides.wrapAll('<div class="slick-track"/>').parent();
437
454
 
438
- _.$slideTrack = (_.slideCount === 0) ?
439
- $('<div class="slick-track"/>').appendTo(_.$slider) :
440
- _.$slides.wrapAll('<div class="slick-track"/>').parent();
455
+ _.$list = _.$slideTrack.wrap(
456
+ '<div class="slick-list"/>').parent();
457
+ _.$slideTrack.css('opacity', 0);
441
458
 
442
- _.$list = _.$slideTrack.wrap(
443
- '<div class="slick-list"/>').parent();
444
- _.$slideTrack.css('opacity', 0);
459
+ if (_.options.centerMode === true) {
460
+ _.options.slidesToScroll = 1;
461
+ if (_.options.slidesToShow % 2 === 0) {
462
+ _.options.slidesToShow = 3;
463
+ }
464
+ }
445
465
 
446
- if (_.options.centerMode === true) {
447
- _.options.slidesToScroll = 1;
448
- if (_.options.slidesToShow % 2 === 0) {
449
- _.options.slidesToShow = 3;
450
- }
451
- }
466
+ $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
452
467
 
453
- $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
468
+ _.setupInfinite();
454
469
 
455
- _.setupInfinite();
470
+ _.buildArrows();
456
471
 
457
- _.buildArrows();
472
+ _.buildDots();
458
473
 
459
- _.buildDots();
474
+ _.updateDots();
460
475
 
461
- _.updateDots();
476
+ if (_.options.accessibility === true) {
477
+ _.$list.prop('tabIndex', 0);
478
+ }
462
479
 
463
- if (_.options.accessibility === true) {
464
- _.$list.prop('tabIndex', 0);
465
- }
480
+ _.setSlideClasses(typeof this.currentSlide === 'number' ? this.currentSlide : 0);
466
481
 
467
- _.setSlideClasses(typeof this.currentSlide === 'number' ? this.currentSlide : 0);
482
+ if (_.options.draggable === true) {
483
+ _.$list.addClass('draggable');
484
+ }
468
485
 
469
- if (_.options.draggable === true) {
470
- _.$list.addClass('draggable');
471
- }
486
+ };
472
487
 
473
- };
488
+ Slick.prototype.checkResponsive = function() {
474
489
 
475
- Slick.prototype.checkResponsive = function() {
490
+ var _ = this,
491
+ breakpoint, targetBreakpoint;
476
492
 
477
- var _ = this,
478
- breakpoint, targetBreakpoint;
493
+ if (_.originalSettings.responsive && _.originalSettings
494
+ .responsive.length > -1 && _.originalSettings.responsive !== null) {
479
495
 
480
- if (_.originalSettings.responsive && _.originalSettings
481
- .responsive.length > -1 && _.originalSettings.responsive !== null) {
496
+ targetBreakpoint = null;
482
497
 
483
- targetBreakpoint = null;
498
+ for (breakpoint in _.breakpoints) {
499
+ if (_.breakpoints.hasOwnProperty(breakpoint)) {
500
+ if ($(window).width() < _.breakpoints[
501
+ breakpoint]) {
502
+ targetBreakpoint = _.breakpoints[
503
+ breakpoint];
504
+ }
505
+ }
506
+ }
484
507
 
485
- for (breakpoint in _.breakpoints) {
486
- if (_.breakpoints.hasOwnProperty(breakpoint)) {
487
- if ($(window).width() < _.breakpoints[
488
- breakpoint]) {
489
- targetBreakpoint = _.breakpoints[
490
- breakpoint];
491
- }
492
- }
493
- }
508
+ if (targetBreakpoint !== null) {
509
+ if (_.activeBreakpoint !== null) {
510
+ if (targetBreakpoint !== _.activeBreakpoint) {
511
+ _.activeBreakpoint =
512
+ targetBreakpoint;
513
+ _.options = $.extend({}, _.options,
514
+ _.breakpointSettings[
515
+ targetBreakpoint]);
516
+ _.refresh();
517
+ }
518
+ } else {
519
+ _.activeBreakpoint = targetBreakpoint;
520
+ _.options = $.extend({}, _.options,
521
+ _.breakpointSettings[
522
+ targetBreakpoint]);
523
+ _.refresh();
524
+ }
525
+ } else {
526
+ if (_.activeBreakpoint !== null) {
527
+ _.activeBreakpoint = null;
528
+ _.options = $.extend({}, _.options,
529
+ _.originalSettings);
530
+ _.refresh();
531
+ }
532
+ }
494
533
 
495
- if (targetBreakpoint !== null) {
496
- if (_.activeBreakpoint !== null) {
497
- if (targetBreakpoint !== _.activeBreakpoint) {
498
- _.activeBreakpoint =
499
- targetBreakpoint;
500
- _.options = $.extend({}, _.options,
501
- _.breakpointSettings[
502
- targetBreakpoint]);
503
- _.refresh();
504
- }
505
- } else {
506
- _.activeBreakpoint = targetBreakpoint;
507
- _.options = $.extend({}, _.options,
508
- _.breakpointSettings[
509
- targetBreakpoint]);
510
- _.refresh();
511
- }
512
- } else {
513
- if (_.activeBreakpoint !== null) {
514
- _.activeBreakpoint = null;
515
- _.options = $.extend({}, _.options,
516
- _.originalSettings);
517
- _.refresh();
518
534
  }
519
- }
520
535
 
521
- }
536
+ };
522
537
 
523
- };
538
+ Slick.prototype.changeSlide = function(event) {
524
539
 
525
- Slick.prototype.changeSlide = function(event) {
540
+ var _ = this,
541
+ $target = $(event.target),
542
+ indexOffset, slideOffset, unevenOffset;
526
543
 
527
- var _ = this,
528
- $target = $(event.target);
529
- var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
544
+ // If target is a link, prevent default action.
545
+ $target.is('a') && event.preventDefault();
530
546
 
531
- // If target is a link, prevent default action.
532
- $target.is('a') && event.preventDefault();
547
+ unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
548
+ indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
533
549
 
534
- switch (event.data.message) {
550
+ switch (event.data.message) {
535
551
 
536
- case 'previous':
537
- if (_.slideCount > _.options.slidesToShow) {
538
- _.slideHandler(_.currentSlide - _.options
539
- .slidesToScroll);
540
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide - asNavFor.options.slidesToScroll);
541
- }
542
- break;
552
+ case 'previous':
553
+ slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
554
+ if (_.slideCount > _.options.slidesToShow) {
555
+ _.slideHandler(_.currentSlide - slideOffset);
556
+ }
557
+ break;
558
+
559
+ case 'next':
560
+ slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
561
+ if (_.slideCount > _.options.slidesToShow) {
562
+ _.slideHandler(_.currentSlide + slideOffset);
563
+ }
564
+ break;
543
565
 
544
- case 'next':
545
- if (_.slideCount > _.options.slidesToShow) {
546
- _.slideHandler(_.currentSlide + _.options
547
- .slidesToScroll);
548
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
566
+ case 'index':
567
+ var index = event.data.index === 0 ? 0 :
568
+ event.data.index || $(event.target).parent().index() * _.options.slidesToScroll;
569
+ _.slideHandler(index);
570
+
571
+ default:
572
+ return false;
549
573
  }
550
- break;
551
574
 
552
- case 'index':
553
- var index = $(event.target).parent().index() * _.options.slidesToScroll;
554
- _.slideHandler(index);
555
- if(asNavFor != null) asNavFor.slideHandler(index); break;
575
+ };
556
576
 
557
- default:
558
- return false;
559
- }
577
+ Slick.prototype.destroy = function() {
560
578
 
561
- };
579
+ var _ = this;
562
580
 
563
- Slick.prototype.destroy = function() {
581
+ _.autoPlayClear();
564
582
 
565
- var _ = this;
583
+ _.touchObject = {};
566
584
 
567
- _.autoPlayClear();
585
+ $('.slick-cloned', _.$slider).remove();
586
+ if (_.$dots) {
587
+ _.$dots.remove();
588
+ }
589
+ if (_.$prevArrow) {
590
+ _.$prevArrow.remove();
591
+ _.$nextArrow.remove();
592
+ }
593
+ if (_.$slides.parent().hasClass('slick-track')) {
594
+ _.$slides.unwrap().unwrap();
595
+ }
596
+ _.$slides.removeClass(
597
+ 'slick-slide slick-active slick-visible').css('width', '');
598
+ _.$slider.removeClass('slick-slider');
599
+ _.$slider.removeClass('slick-initialized');
568
600
 
569
- _.touchObject = {};
601
+ _.$list.off('.slick');
602
+ $(window).off('.slick-' + _.instanceUid);
603
+ $(document).off('.slick-' + _.instanceUid);
570
604
 
571
- $('.slick-cloned', _.$slider).remove();
572
- if (_.$dots) {
573
- _.$dots.remove();
574
- }
575
- if (_.$prevArrow) {
576
- _.$prevArrow.remove();
577
- _.$nextArrow.remove();
578
- }
579
- if (_.$slides.parent().hasClass('slick-track')) {
580
- _.$slides.unwrap().unwrap();
581
- }
582
- _.$slides.removeClass(
583
- 'slick-slide slick-active slick-visible').removeAttr('style');
584
- _.$slider.removeClass('slick-slider');
585
- _.$slider.removeClass('slick-initialized');
605
+ };
586
606
 
587
- _.$list.off('.slick');
588
- $(window).off('.slick-' + _.instanceUid);
589
- $(document).off('.slick-' + _.instanceUid);
607
+ Slick.prototype.disableTransition = function(slide) {
590
608
 
591
- };
609
+ var _ = this,
610
+ transition = {};
592
611
 
593
- Slick.prototype.disableTransition = function(slide) {
612
+ transition[_.transitionType] = "";
594
613
 
595
- var _ = this,
596
- transition = {};
614
+ if (_.options.fade === false) {
615
+ _.$slideTrack.css(transition);
616
+ } else {
617
+ _.$slides.eq(slide).css(transition);
618
+ }
597
619
 
598
- transition[_.transitionType] = "";
620
+ };
599
621
 
600
- if (_.options.fade === false) {
601
- _.$slideTrack.css(transition);
602
- } else {
603
- _.$slides.eq(slide).css(transition);
604
- }
622
+ Slick.prototype.fadeSlide = function(oldSlide, slideIndex, callback) {
605
623
 
606
- };
624
+ var _ = this;
607
625
 
608
- Slick.prototype.fadeSlide = function(slideIndex, callback) {
626
+ if (_.cssTransitions === false) {
609
627
 
610
- var _ = this;
628
+ _.$slides.eq(slideIndex).css({
629
+ zIndex: 1000
630
+ });
611
631
 
612
- if (_.cssTransitions === false) {
632
+ _.$slides.eq(slideIndex).animate({
633
+ opacity: 1
634
+ }, _.options.speed, _.options.easing, callback);
613
635
 
614
- _.$slides.eq(slideIndex).css({
615
- zIndex: 1000
616
- });
636
+ _.$slides.eq(oldSlide).animate({
637
+ opacity: 0
638
+ }, _.options.speed, _.options.easing);
617
639
 
618
- _.$slides.eq(slideIndex).animate({
619
- opacity: 1
620
- }, _.options.speed, _.options.easing, callback);
640
+ } else {
621
641
 
622
- } else {
642
+ _.applyTransition(slideIndex);
643
+ _.applyTransition(oldSlide);
623
644
 
624
- _.applyTransition(slideIndex);
645
+ _.$slides.eq(slideIndex).css({
646
+ opacity: 1,
647
+ zIndex: 1000
648
+ });
625
649
 
626
- _.$slides.eq(slideIndex).css({
627
- opacity: 1,
628
- zIndex: 1000
629
- });
650
+ _.$slides.eq(oldSlide).css({
651
+ opacity: 0
652
+ });
630
653
 
631
- if (callback) {
632
- setTimeout(function() {
654
+ if (callback) {
655
+ setTimeout(function() {
633
656
 
634
- _.disableTransition(slideIndex);
657
+ _.disableTransition(slideIndex);
658
+ _.disableTransition(oldSlide);
635
659
 
636
- callback.call();
637
- }, _.options.speed);
638
- }
660
+ callback.call();
661
+ }, _.options.speed);
662
+ }
639
663
 
640
- }
664
+ }
641
665
 
642
- };
666
+ };
643
667
 
644
- Slick.prototype.filterSlides = function(filter) {
668
+ Slick.prototype.filterSlides = function(filter) {
645
669
 
646
- var _ = this;
670
+ var _ = this;
647
671
 
648
- if (filter !== null) {
672
+ if (filter !== null) {
649
673
 
650
- _.unload();
674
+ _.unload();
651
675
 
652
- _.$slideTrack.children(this.options.slide).detach();
676
+ _.$slideTrack.children(this.options.slide).detach();
653
677
 
654
- _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
678
+ _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
655
679
 
656
- _.reinit();
680
+ _.reinit();
657
681
 
658
- }
682
+ }
659
683
 
660
- };
684
+ };
661
685
 
662
- Slick.prototype.getCurrent = function() {
686
+ Slick.prototype.getCurrent = function() {
663
687
 
664
- var _ = this;
688
+ var _ = this;
665
689
 
666
- return _.currentSlide;
690
+ return _.currentSlide;
667
691
 
668
- };
692
+ };
669
693
 
670
- Slick.prototype.getDotCount = function() {
694
+ Slick.prototype.getDotCount = function() {
671
695
 
672
- var _ = this,
673
- breaker = 0,
674
- dotCounter = 0,
675
- dotCount = 0,
676
- dotLimit;
696
+ var _ = this,
697
+ breaker = 0,
698
+ dotCounter = 0,
699
+ dotCount = 0,
700
+ dotLimit;
677
701
 
678
- dotLimit = _.options.infinite === true ? _.slideCount + _.options.slidesToShow - _.options.slidesToScroll : _.slideCount;
702
+ dotLimit = _.options.infinite === true ? _.slideCount + _.options.slidesToShow - _.options.slidesToScroll : _.slideCount;
679
703
 
680
- while (breaker < dotLimit) {
681
- dotCount++;
682
- dotCounter += _.options.slidesToScroll;
683
- breaker = dotCounter + _.options.slidesToShow;
684
- }
704
+ while (breaker < dotLimit) {
705
+ dotCount++;
706
+ dotCounter += _.options.slidesToScroll;
707
+ breaker = dotCounter + _.options.slidesToShow;
708
+ }
685
709
 
686
- return dotCount;
710
+ return dotCount;
687
711
 
688
- };
712
+ };
689
713
 
690
- Slick.prototype.getLeft = function(slideIndex) {
714
+ Slick.prototype.getLeft = function(slideIndex) {
691
715
 
692
- var _ = this,
693
- targetLeft,
694
- verticalHeight,
695
- verticalOffset = 0;
716
+ var _ = this,
717
+ targetLeft,
718
+ verticalHeight,
719
+ verticalOffset = 0,
720
+ slideWidth,
721
+ targetSlide;
696
722
 
697
- _.slideOffset = 0;
698
- verticalHeight = _.$slides.first().outerHeight();
723
+ _.slideOffset = 0;
724
+ verticalHeight = _.$slides.first().outerHeight();
699
725
 
700
- if (_.options.infinite === true) {
701
- if (_.slideCount > _.options.slidesToShow) {
702
- _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
703
- verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
704
- }
705
- if (_.slideCount % _.options.slidesToScroll !== 0) {
706
- if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
707
- _.slideOffset = ((_.slideCount % _.options.slidesToShow) * _.slideWidth) * -1;
708
- verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight) * -1;
726
+ if (_.options.infinite === true) {
727
+ if (_.slideCount > _.options.slidesToShow) {
728
+ _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
729
+ verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
730
+ }
731
+ if (_.slideCount % _.options.slidesToScroll !== 0) {
732
+ if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
733
+ _.slideOffset = ((_.slideCount % _.options.slidesToShow) * _.slideWidth) * -1;
734
+ verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight) * -1;
735
+ }
736
+ }
737
+ } else {
738
+ if (_.slideCount % _.options.slidesToShow !== 0) {
739
+ if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
740
+ _.slideOffset = (_.options.slidesToShow * _.slideWidth) - ((_.slideCount % _.options.slidesToShow) * _.slideWidth);
741
+ verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight);
742
+ }
743
+ }
709
744
  }
710
- }
711
- } else {
712
- if (_.slideCount % _.options.slidesToShow !== 0) {
713
- if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
714
- _.slideOffset = (_.options.slidesToShow * _.slideWidth) - ((_.slideCount % _.options.slidesToShow) * _.slideWidth);
715
- verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight);
745
+
746
+ if (_.slideCount <= _.options.slidesToShow){
747
+ _.slideOffset = 0;
748
+ verticalOffset = 0;
716
749
  }
717
- }
718
- }
719
750
 
720
- if (_.options.centerMode === true && _.options.infinite === true) {
721
- _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
722
- } else if (_.options.centerMode === true) {
723
- _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
724
- }
751
+ if (_.options.centerMode === true && _.options.infinite === true) {
752
+ _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
753
+ } else if (_.options.centerMode === true) {
754
+ _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
755
+ }
725
756
 
726
- if (_.options.vertical === false) {
727
- targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
728
- } else {
729
- targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
730
- }
757
+ if (_.options.vertical === false) {
758
+ targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
759
+ } else {
760
+ targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
761
+ }
731
762
 
732
- return targetLeft;
763
+ if (_.options.variableWidth === true) {
733
764
 
734
- };
765
+ if(_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
766
+ targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
767
+ } else {
768
+ targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
769
+ }
770
+ targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
771
+ if (_.options.centerMode === true) {
772
+ if(_.options.infinite === false) {
773
+ targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
774
+ } else {
775
+ targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
776
+ }
777
+ targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
778
+ targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
779
+ }
780
+ }
735
781
 
736
- Slick.prototype.init = function() {
782
+ return targetLeft;
737
783
 
738
- var _ = this;
784
+ };
739
785
 
740
- if (!$(_.$slider).hasClass('slick-initialized')) {
786
+ Slick.prototype.init = function() {
741
787
 
742
- $(_.$slider).addClass('slick-initialized');
743
- _.buildOut();
744
- _.setProps();
745
- _.startLoad();
746
- _.loadSlider();
747
- _.initializeEvents();
748
- _.checkResponsive();
749
- }
788
+ var _ = this;
750
789
 
751
- if (_.options.onInit !== null) {
752
- _.options.onInit.call(this, _);
753
- }
790
+ if (!$(_.$slider).hasClass('slick-initialized')) {
754
791
 
755
- };
792
+ $(_.$slider).addClass('slick-initialized');
793
+ _.buildOut();
794
+ _.setProps();
795
+ _.startLoad();
796
+ _.loadSlider();
797
+ _.initializeEvents();
798
+ _.checkResponsive();
799
+ }
756
800
 
757
- Slick.prototype.initArrowEvents = function() {
801
+ if (_.options.onInit !== null) {
802
+ _.options.onInit.call(this, _);
803
+ }
758
804
 
759
- var _ = this;
805
+ };
760
806
 
761
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
762
- _.$prevArrow.on('click.slick', {
763
- message: 'previous'
764
- }, _.changeSlide);
765
- _.$nextArrow.on('click.slick', {
766
- message: 'next'
767
- }, _.changeSlide);
768
- }
807
+ Slick.prototype.initArrowEvents = function() {
769
808
 
770
- };
809
+ var _ = this;
771
810
 
772
- Slick.prototype.initDotEvents = function() {
811
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
812
+ _.$prevArrow.on('click.slick', {
813
+ message: 'previous'
814
+ }, _.changeSlide);
815
+ _.$nextArrow.on('click.slick', {
816
+ message: 'next'
817
+ }, _.changeSlide);
818
+ }
773
819
 
774
- var _ = this;
820
+ };
775
821
 
776
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
777
- $('li', _.$dots).on('click.slick', {
778
- message: 'index'
779
- }, _.changeSlide);
780
- }
822
+ Slick.prototype.initDotEvents = function() {
781
823
 
782
- if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.options.autoplay === true) {
783
- $('li', _.$dots)
784
- .on('mouseenter.slick', _.autoPlayClear)
785
- .on('mouseleave.slick', _.autoPlay);
786
- }
824
+ var _ = this;
787
825
 
788
- };
826
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
827
+ $('li', _.$dots).on('click.slick', {
828
+ message: 'index'
829
+ }, _.changeSlide);
830
+ }
789
831
 
790
- Slick.prototype.initializeEvents = function() {
832
+ if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.options.autoplay === true) {
833
+ $('li', _.$dots)
834
+ .on('mouseenter.slick', _.autoPlayClear)
835
+ .on('mouseleave.slick', _.autoPlay);
836
+ }
791
837
 
792
- var _ = this;
838
+ };
793
839
 
794
- _.initArrowEvents();
840
+ Slick.prototype.initializeEvents = function() {
795
841
 
796
- _.initDotEvents();
842
+ var _ = this;
797
843
 
798
- _.$list.on('touchstart.slick mousedown.slick', {
799
- action: 'start'
800
- }, _.swipeHandler);
801
- _.$list.on('touchmove.slick mousemove.slick', {
802
- action: 'move'
803
- }, _.swipeHandler);
804
- _.$list.on('touchend.slick mouseup.slick', {
805
- action: 'end'
806
- }, _.swipeHandler);
807
- _.$list.on('touchcancel.slick mouseleave.slick', {
808
- action: 'end'
809
- }, _.swipeHandler);
844
+ _.initArrowEvents();
810
845
 
811
- if (_.options.pauseOnHover === true && _.options.autoplay === true) {
812
- _.$list.on('mouseenter.slick', _.autoPlayClear);
813
- _.$list.on('mouseleave.slick', _.autoPlay);
814
- }
846
+ _.initDotEvents();
815
847
 
816
- if(_.options.accessibility === true) {
817
- _.$list.on('keydown.slick', _.keyHandler);
818
- }
848
+ _.$list.on('touchstart.slick mousedown.slick', {
849
+ action: 'start'
850
+ }, _.swipeHandler);
851
+ _.$list.on('touchmove.slick mousemove.slick', {
852
+ action: 'move'
853
+ }, _.swipeHandler);
854
+ _.$list.on('touchend.slick mouseup.slick', {
855
+ action: 'end'
856
+ }, _.swipeHandler);
857
+ _.$list.on('touchcancel.slick mouseleave.slick', {
858
+ action: 'end'
859
+ }, _.swipeHandler);
819
860
 
820
- if(_.options.focusOnSelect === true) {
821
- $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
822
- }
861
+ if (_.options.pauseOnHover === true && _.options.autoplay === true) {
862
+ _.$list.on('mouseenter.slick', _.autoPlayClear);
863
+ _.$list.on('mouseleave.slick', _.autoPlay);
864
+ }
823
865
 
824
- $(window).on('orientationchange.slick.slick-' + _.instanceUid, function() {
825
- _.checkResponsive();
826
- _.setPosition();
827
- });
866
+ if(_.options.accessibility === true) {
867
+ _.$list.on('keydown.slick', _.keyHandler);
868
+ }
828
869
 
829
- $(window).on('resize.slick.slick-' + _.instanceUid, function() {
830
- if ($(window).width() !== _.windowWidth) {
831
- clearTimeout(_.windowDelay);
832
- _.windowDelay = window.setTimeout(function() {
833
- _.windowWidth = $(window).width();
834
- _.checkResponsive();
835
- _.setPosition();
836
- }, 50);
837
- }
838
- });
870
+ if(_.options.focusOnSelect === true) {
871
+ $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
872
+ }
839
873
 
840
- $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
841
- $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
874
+ $(window).on('orientationchange.slick.slick-' + _.instanceUid, function() {
875
+ _.checkResponsive();
876
+ _.setPosition();
877
+ });
842
878
 
843
- };
879
+ $(window).on('resize.slick.slick-' + _.instanceUid, function() {
880
+ if ($(window).width() !== _.windowWidth) {
881
+ clearTimeout(_.windowDelay);
882
+ _.windowDelay = window.setTimeout(function() {
883
+ _.windowWidth = $(window).width();
884
+ _.checkResponsive();
885
+ _.setPosition();
886
+ }, 50);
887
+ }
888
+ });
844
889
 
845
- Slick.prototype.initUI = function() {
890
+ $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
891
+ $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
846
892
 
847
- var _ = this;
893
+ };
848
894
 
849
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
895
+ Slick.prototype.initUI = function() {
850
896
 
851
- _.$prevArrow.show();
852
- _.$nextArrow.show();
897
+ var _ = this;
853
898
 
854
- }
899
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
855
900
 
856
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
901
+ _.$prevArrow.show();
902
+ _.$nextArrow.show();
857
903
 
858
- _.$dots.show();
904
+ }
859
905
 
860
- }
906
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
861
907
 
862
- if (_.options.autoplay === true) {
908
+ _.$dots.show();
863
909
 
864
- _.autoPlay();
910
+ }
865
911
 
866
- }
912
+ if (_.options.autoplay === true) {
913
+
914
+ _.autoPlay();
915
+
916
+ }
867
917
 
868
- };
918
+ };
869
919
 
870
- Slick.prototype.keyHandler = function(event) {
920
+ Slick.prototype.keyHandler = function(event) {
871
921
 
872
- var _ = this;
922
+ var _ = this;
873
923
 
874
- if (event.keyCode === 37) {
875
- _.changeSlide({
876
- data: {
877
- message: 'previous'
924
+ if (event.keyCode === 37) {
925
+ _.changeSlide({
926
+ data: {
927
+ message: 'previous'
928
+ }
929
+ });
930
+ } else if (event.keyCode === 39) {
931
+ _.changeSlide({
932
+ data: {
933
+ message: 'next'
934
+ }
935
+ });
878
936
  }
879
- });
880
- } else if (event.keyCode === 39) {
881
- _.changeSlide({
882
- data: {
883
- message: 'next'
937
+
938
+ };
939
+
940
+ Slick.prototype.lazyLoad = function() {
941
+
942
+ var _ = this,
943
+ loadRange, cloneRange, rangeStart, rangeEnd;
944
+
945
+ function loadImages(imagesScope) {
946
+ $('img[data-lazy]', imagesScope).each(function() {
947
+ var image = $(this),
948
+ imageSource = $(this).attr('data-lazy');
949
+
950
+ image
951
+ .load(function() { image.animate({ opacity: 1 }, 200); })
952
+ .css({ opacity: 0 })
953
+ .attr('src', imageSource)
954
+ .removeAttr('data-lazy')
955
+ .removeClass('slick-loading');
956
+ });
884
957
  }
885
- });
886
- }
887
958
 
888
- };
959
+ if (_.options.centerMode === true) {
960
+ if (_.options.infinite === true) {
961
+ rangeStart = _.currentSlide + (_.options.slidesToShow/2 + 1);
962
+ rangeEnd = rangeStart + _.options.slidesToShow + 2;
963
+ } else {
964
+ rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow/2 + 1));
965
+ rangeEnd = 2 + (_.options.slidesToShow/2 + 1) + _.currentSlide;
966
+ }
967
+ } else {
968
+ rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
969
+ rangeEnd = rangeStart + _.options.slidesToShow;
970
+ if (_.options.fade === true ) {
971
+ if(rangeStart > 0) rangeStart--;
972
+ if(rangeEnd <= _.slideCount) rangeEnd++;
973
+ }
974
+ }
889
975
 
890
- Slick.prototype.lazyLoad = function() {
976
+ loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
977
+ loadImages(loadRange);
978
+
979
+ if (_.slideCount <= _.options.slidesToShow){
980
+ cloneRange = _.$slider.find('.slick-slide')
981
+ loadImages(cloneRange)
982
+ }else
983
+ if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
984
+ cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
985
+ loadImages(cloneRange)
986
+ } else if (_.currentSlide === 0) {
987
+ cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
988
+ loadImages(cloneRange);
989
+ }
891
990
 
892
- var _ = this,
893
- loadRange, cloneRange, rangeStart, rangeEnd;
991
+ };
894
992
 
895
- function loadImages(imagesScope) {
896
- $('img[data-lazy]', imagesScope).each(function() {
897
- var image = $(this),
898
- imageSource = $(this).attr('data-lazy') + "?" + new Date().getTime();
993
+ Slick.prototype.loadSlider = function() {
899
994
 
900
- image
901
- .load(function() { image.animate({ opacity: 1 }, 200); })
902
- .css({ opacity: 0 })
903
- .attr('src', imageSource)
904
- .removeAttr('data-lazy')
905
- .removeClass('slick-loading');
906
- });
907
- }
995
+ var _ = this;
908
996
 
909
- if (_.options.centerMode === true || _.options.fade === true ) {
910
- rangeStart = _.options.slidesToShow + _.currentSlide - 1;
911
- rangeEnd = rangeStart + _.options.slidesToShow + 2;
912
- } else {
913
- rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
914
- rangeEnd = rangeStart + _.options.slidesToShow;
915
- }
997
+ _.setPosition();
916
998
 
917
- loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
918
- loadImages(loadRange);
919
-
920
- if (_.slideCount == 1){
921
- cloneRange = _.$slider.find('.slick-slide')
922
- loadImages(cloneRange)
923
- }else
924
- if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
925
- cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
926
- loadImages(cloneRange)
927
- } else if (_.currentSlide === 0) {
928
- cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
929
- loadImages(cloneRange);
930
- }
999
+ _.$slideTrack.css({
1000
+ opacity: 1
1001
+ });
931
1002
 
932
- };
1003
+ _.$slider.removeClass('slick-loading');
933
1004
 
934
- Slick.prototype.loadSlider = function() {
1005
+ _.initUI();
935
1006
 
936
- var _ = this;
1007
+ if (_.options.lazyLoad === 'progressive') {
1008
+ _.progressiveLazyLoad();
1009
+ }
937
1010
 
938
- _.setPosition();
1011
+ };
939
1012
 
940
- _.$slideTrack.css({
941
- opacity: 1
942
- });
1013
+ Slick.prototype.postSlide = function(index) {
943
1014
 
944
- _.$slider.removeClass('slick-loading');
1015
+ var _ = this;
945
1016
 
946
- _.initUI();
1017
+ if (_.options.onAfterChange !== null) {
1018
+ _.options.onAfterChange.call(this, _, index);
1019
+ }
947
1020
 
948
- if (_.options.lazyLoad === 'progressive') {
949
- _.progressiveLazyLoad();
950
- }
1021
+ _.animating = false;
951
1022
 
952
- };
1023
+ _.setPosition();
953
1024
 
954
- Slick.prototype.postSlide = function(index) {
1025
+ _.swipeLeft = null;
955
1026
 
956
- var _ = this;
1027
+ if (_.options.autoplay === true && _.paused === false) {
1028
+ _.autoPlay();
1029
+ }
957
1030
 
958
- if (_.options.onAfterChange !== null) {
959
- _.options.onAfterChange.call(this, _, index);
960
- }
1031
+ };
961
1032
 
962
- _.animating = false;
1033
+ Slick.prototype.progressiveLazyLoad = function() {
963
1034
 
964
- _.setPosition();
1035
+ var _ = this,
1036
+ imgCount, targetImage;
965
1037
 
966
- _.swipeLeft = null;
1038
+ imgCount = $('img[data-lazy]').length;
967
1039
 
968
- if (_.options.autoplay === true && _.paused === false) {
969
- _.autoPlay();
970
- }
1040
+ if (imgCount > 0) {
1041
+ targetImage = $('img[data-lazy]', _.$slider).first();
1042
+ targetImage.attr('src', targetImage.attr('data-lazy')).removeClass('slick-loading').load(function() {
1043
+ targetImage.removeAttr('data-lazy');
1044
+ _.progressiveLazyLoad();
1045
+ })
1046
+ .error(function () {
1047
+ targetImage.removeAttr('data-lazy');
1048
+ _.progressiveLazyLoad();
1049
+ });
1050
+ }
971
1051
 
972
- };
1052
+ };
973
1053
 
974
- Slick.prototype.progressiveLazyLoad = function() {
1054
+ Slick.prototype.refresh = function() {
975
1055
 
976
- var _ = this,
977
- imgCount, targetImage;
1056
+ var _ = this,
1057
+ currentSlide = _.currentSlide;
978
1058
 
979
- imgCount = $('img[data-lazy]').length;
1059
+ _.destroy();
980
1060
 
981
- if (imgCount > 0) {
982
- targetImage = $('img[data-lazy]', _.$slider).first();
983
- targetImage.attr('src', targetImage.attr('data-lazy')).removeClass('slick-loading').load(function() {
984
- targetImage.removeAttr('data-lazy');
985
- _.progressiveLazyLoad();
986
- });
987
- }
1061
+ $.extend(_, _.initials);
988
1062
 
989
- };
1063
+ _.currentSlide = currentSlide;
1064
+ _.init();
990
1065
 
991
- Slick.prototype.refresh = function() {
1066
+ };
992
1067
 
993
- var _ = this,
994
- currentSlide = _.currentSlide;
1068
+ Slick.prototype.reinit = function() {
995
1069
 
996
- _.destroy();
1070
+ var _ = this;
997
1071
 
998
- $.extend(_, _.initials);
1072
+ _.$slides = _.$slideTrack.children(_.options.slide).addClass(
1073
+ 'slick-slide');
999
1074
 
1000
- _.currentSlide = currentSlide;
1001
- _.init();
1075
+ _.slideCount = _.$slides.length;
1002
1076
 
1003
- };
1077
+ if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1078
+ _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1079
+ }
1004
1080
 
1005
- Slick.prototype.reinit = function() {
1081
+ if (_.slideCount <= _.options.slidesToShow) {
1082
+ _.currentSlide = 0;
1083
+ }
1006
1084
 
1007
- var _ = this;
1085
+ _.setProps();
1008
1086
 
1009
- _.$slides = _.$slideTrack.children(_.options.slide).addClass(
1010
- 'slick-slide');
1087
+ _.setupInfinite();
1011
1088
 
1012
- _.slideCount = _.$slides.length;
1089
+ _.buildArrows();
1013
1090
 
1014
- if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1015
- _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1016
- }
1091
+ _.updateArrows();
1017
1092
 
1018
- _.setProps();
1093
+ _.initArrowEvents();
1019
1094
 
1020
- _.setupInfinite();
1095
+ _.buildDots();
1021
1096
 
1022
- _.buildArrows();
1097
+ _.updateDots();
1023
1098
 
1024
- _.updateArrows();
1099
+ _.initDotEvents();
1025
1100
 
1026
- _.initArrowEvents();
1101
+ if(_.options.focusOnSelect === true) {
1102
+ $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
1103
+ }
1027
1104
 
1028
- _.buildDots();
1105
+ _.setSlideClasses(0);
1029
1106
 
1030
- _.updateDots();
1107
+ _.setPosition();
1031
1108
 
1032
- _.initDotEvents();
1109
+ if (_.options.onReInit !== null) {
1110
+ _.options.onReInit.call(this, _);
1111
+ }
1033
1112
 
1034
- if(_.options.focusOnSelect === true) {
1035
- $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
1036
- }
1113
+ };
1037
1114
 
1038
- _.setSlideClasses(0);
1115
+ Slick.prototype.removeSlide = function(index, removeBefore) {
1039
1116
 
1040
- _.setPosition();
1117
+ var _ = this;
1041
1118
 
1042
- if (_.options.onReInit !== null) {
1043
- _.options.onReInit.call(this, _);
1044
- }
1119
+ if (typeof(index) === 'boolean') {
1120
+ removeBefore = index;
1121
+ index = removeBefore === true ? 0 : _.slideCount - 1;
1122
+ } else {
1123
+ index = removeBefore === true ? --index : index;
1124
+ }
1045
1125
 
1046
- };
1126
+ if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
1127
+ return false;
1128
+ }
1047
1129
 
1048
- Slick.prototype.removeSlide = function(index, removeBefore) {
1130
+ _.unload();
1049
1131
 
1050
- var _ = this;
1132
+ _.$slideTrack.children(this.options.slide).eq(index).remove();
1051
1133
 
1052
- if (typeof(index) === 'boolean') {
1053
- removeBefore = index;
1054
- index = removeBefore === true ? 0 : _.slideCount - 1;
1055
- } else {
1056
- index = removeBefore === true ? --index : index;
1057
- }
1134
+ _.$slides = _.$slideTrack.children(this.options.slide);
1058
1135
 
1059
- if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
1060
- return false;
1061
- }
1136
+ _.$slideTrack.children(this.options.slide).detach();
1062
1137
 
1063
- _.unload();
1138
+ _.$slideTrack.append(_.$slides);
1064
1139
 
1065
- _.$slideTrack.children(this.options.slide).eq(index).remove();
1140
+ _.$slidesCache = _.$slides;
1066
1141
 
1067
- _.$slides = _.$slideTrack.children(this.options.slide);
1142
+ _.reinit();
1068
1143
 
1069
- _.$slideTrack.children(this.options.slide).detach();
1144
+ };
1070
1145
 
1071
- _.$slideTrack.append(_.$slides);
1146
+ Slick.prototype.setCSS = function(position) {
1072
1147
 
1073
- _.$slidesCache = _.$slides;
1148
+ var _ = this,
1149
+ positionProps = {}, x, y;
1074
1150
 
1075
- _.reinit();
1151
+ if (_.options.rtl === true) {
1152
+ position = -position;
1153
+ }
1154
+ x = _.positionProp == 'left' ? position + 'px' : '0px';
1155
+ y = _.positionProp == 'top' ? position + 'px' : '0px';
1076
1156
 
1077
- };
1157
+ positionProps[_.positionProp] = position;
1078
1158
 
1079
- Slick.prototype.setCSS = function(position) {
1159
+ if (_.transformsEnabled === false) {
1160
+ _.$slideTrack.css(positionProps);
1161
+ } else {
1162
+ positionProps = {};
1163
+ if (_.cssTransitions === false) {
1164
+ positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
1165
+ _.$slideTrack.css(positionProps);
1166
+ } else {
1167
+ positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
1168
+ _.$slideTrack.css(positionProps);
1169
+ }
1170
+ }
1080
1171
 
1081
- var _ = this,
1082
- positionProps = {}, x, y;
1172
+ };
1083
1173
 
1084
- if (_.options.rtl === true) {
1085
- position = -position;
1086
- }
1087
- x = _.positionProp == 'left' ? position + 'px' : '0px';
1088
- y = _.positionProp == 'top' ? position + 'px' : '0px';
1174
+ Slick.prototype.setDimensions = function() {
1089
1175
 
1090
- positionProps[_.positionProp] = position;
1176
+ var _ = this;
1091
1177
 
1092
- if (_.transformsEnabled === false) {
1093
- _.$slideTrack.css(positionProps);
1094
- } else {
1095
- positionProps = {};
1096
- if (_.cssTransitions === false) {
1097
- positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
1098
- _.$slideTrack.css(positionProps);
1099
- } else {
1100
- positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
1101
- _.$slideTrack.css(positionProps);
1102
- }
1103
- }
1178
+ if (_.options.vertical === false) {
1179
+ if (_.options.centerMode === true) {
1180
+ _.$list.css({
1181
+ padding: ('0px ' + _.options.centerPadding)
1182
+ });
1183
+ }
1184
+ } else {
1185
+ _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
1186
+ if (_.options.centerMode === true) {
1187
+ _.$list.css({
1188
+ padding: (_.options.centerPadding + ' 0px')
1189
+ });
1190
+ }
1191
+ }
1104
1192
 
1105
- };
1193
+ _.listWidth = _.$list.width();
1194
+ _.listHeight = _.$list.height();
1106
1195
 
1107
- Slick.prototype.setDimensions = function() {
1108
1196
 
1109
- var _ = this;
1197
+ if(_.options.vertical === false && _.options.variableWidth === false) {
1198
+ _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
1199
+ _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
1110
1200
 
1111
- if (_.options.vertical === false) {
1112
- if (_.options.centerMode === true) {
1113
- _.$list.css({
1114
- padding: ('0px ' + _.options.centerPadding)
1115
- });
1116
- }
1117
- } else {
1118
- _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
1119
- if (_.options.centerMode === true) {
1120
- _.$list.css({
1121
- padding: (_.options.centerPadding + ' 0px')
1122
- });
1123
- }
1124
- }
1201
+ } else if (_.options.variableWidth === true) {
1202
+ _.slideWidth = 0;
1203
+ _.$slideTrack.children('.slick-slide').each(function(){
1204
+ _.slideWidth += Math.ceil($(this).outerWidth(true));
1205
+ });
1206
+ _.$slideTrack.width(Math.ceil(_.slideWidth) + 1);
1207
+ } else {
1208
+ _.slideWidth = Math.ceil(_.listWidth);
1209
+ _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
1210
+ }
1125
1211
 
1126
- _.listWidth = _.$list.width();
1127
- _.listHeight = _.$list.height();
1212
+ var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
1213
+ if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
1128
1214
 
1215
+ };
1129
1216
 
1130
- if(_.options.vertical === false) {
1131
- _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
1132
- _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
1217
+ Slick.prototype.setFade = function() {
1133
1218
 
1134
- } else {
1135
- _.slideWidth = Math.ceil(_.listWidth);
1136
- _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
1219
+ var _ = this,
1220
+ targetLeft;
1137
1221
 
1138
- }
1222
+ _.$slides.each(function(index, element) {
1223
+ targetLeft = (_.slideWidth * index) * -1;
1224
+ $(element).css({
1225
+ position: 'relative',
1226
+ left: targetLeft,
1227
+ top: 0,
1228
+ zIndex: 800,
1229
+ opacity: 0
1230
+ });
1231
+ });
1139
1232
 
1140
- var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
1141
- _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
1233
+ _.$slides.eq(_.currentSlide).css({
1234
+ zIndex: 900,
1235
+ opacity: 1
1236
+ });
1142
1237
 
1143
- };
1238
+ };
1144
1239
 
1145
- Slick.prototype.setFade = function() {
1240
+ Slick.prototype.setHeight = function() {
1146
1241
 
1147
- var _ = this,
1148
- targetLeft;
1242
+ var _ = this;
1149
1243
 
1150
- _.$slides.each(function(index, element) {
1151
- targetLeft = (_.slideWidth * index) * -1;
1152
- $(element).css({
1153
- position: 'relative',
1154
- left: targetLeft,
1155
- top: 0,
1156
- zIndex: 800,
1157
- opacity: 0
1158
- });
1159
- });
1244
+ if(_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
1245
+ var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
1246
+ _.$list.css('height', targetHeight);
1247
+ }
1160
1248
 
1161
- _.$slides.eq(_.currentSlide).css({
1162
- zIndex: 900,
1163
- opacity: 1
1164
- });
1249
+ };
1165
1250
 
1166
- };
1251
+ Slick.prototype.setPosition = function() {
1167
1252
 
1168
- Slick.prototype.setPosition = function() {
1253
+ var _ = this;
1169
1254
 
1170
- var _ = this;
1255
+ _.setDimensions();
1171
1256
 
1172
- _.setDimensions();
1257
+ _.setHeight();
1173
1258
 
1174
- if (_.options.fade === false) {
1175
- _.setCSS(_.getLeft(_.currentSlide));
1176
- } else {
1177
- _.setFade();
1178
- }
1259
+ if (_.options.fade === false) {
1260
+ _.setCSS(_.getLeft(_.currentSlide));
1261
+ } else {
1262
+ _.setFade();
1263
+ }
1179
1264
 
1180
- };
1265
+ };
1181
1266
 
1182
- Slick.prototype.setProps = function() {
1267
+ Slick.prototype.setProps = function() {
1183
1268
 
1184
- var _ = this;
1269
+ var _ = this,
1270
+ bodyStyle = document.body.style;
1185
1271
 
1186
- _.positionProp = _.options.vertical === true ? 'top' : 'left';
1272
+ _.positionProp = _.options.vertical === true ? 'top' : 'left';
1187
1273
 
1188
- if (_.positionProp === 'top') {
1189
- _.$slider.addClass('slick-vertical');
1190
- } else {
1191
- _.$slider.removeClass('slick-vertical');
1192
- }
1274
+ if (_.positionProp === 'top') {
1275
+ _.$slider.addClass('slick-vertical');
1276
+ } else {
1277
+ _.$slider.removeClass('slick-vertical');
1278
+ }
1193
1279
 
1194
- if (document.body.style.WebkitTransition !== undefined ||
1195
- document.body.style.MozTransition !== undefined ||
1196
- document.body.style.msTransition !== undefined) {
1197
- if(_.options.useCSS === true) {
1198
- _.cssTransitions = true;
1199
- }
1200
- }
1280
+ if (bodyStyle.WebkitTransition !== undefined ||
1281
+ bodyStyle.MozTransition !== undefined ||
1282
+ bodyStyle.msTransition !== undefined) {
1283
+ if(_.options.useCSS === true) {
1284
+ _.cssTransitions = true;
1285
+ }
1286
+ }
1201
1287
 
1202
- if (document.body.style.MozTransform !== undefined) {
1203
- _.animType = 'MozTransform';
1204
- _.transformType = "-moz-transform";
1205
- _.transitionType = 'MozTransition';
1206
- }
1207
- if (document.body.style.webkitTransform !== undefined) {
1208
- _.animType = 'webkitTransform';
1209
- _.transformType = "-webkit-transform";
1210
- _.transitionType = 'webkitTransition';
1211
- }
1212
- if (document.body.style.msTransform !== undefined) {
1213
- _.animType = 'msTransform';
1214
- _.transformType = "-ms-transform";
1215
- _.transitionType = 'msTransition';
1216
- }
1217
- if (document.body.style.transform !== undefined) {
1218
- _.animType = 'transform';
1219
- _.transformType = "transform";
1220
- _.transitionType = 'transition';
1221
- }
1288
+ if (bodyStyle.OTransform !== undefined) {
1289
+ _.animType = 'OTransform';
1290
+ _.transformType = "-o-transform";
1291
+ _.transitionType = 'OTransition';
1292
+ if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
1293
+ }
1294
+ if (bodyStyle.MozTransform !== undefined) {
1295
+ _.animType = 'MozTransform';
1296
+ _.transformType = "-moz-transform";
1297
+ _.transitionType = 'MozTransition';
1298
+ if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
1299
+ }
1300
+ if (bodyStyle.webkitTransform !== undefined) {
1301
+ _.animType = 'webkitTransform';
1302
+ _.transformType = "-webkit-transform";
1303
+ _.transitionType = 'webkitTransition';
1304
+ if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
1305
+ }
1306
+ if (bodyStyle.msTransform !== undefined) {
1307
+ _.animType = 'msTransform';
1308
+ _.transformType = "-ms-transform";
1309
+ _.transitionType = 'msTransition';
1310
+ if (bodyStyle.msTransform === undefined) _.animType = false;
1311
+ }
1312
+ if (bodyStyle.transform !== undefined && _.animType !== false) {
1313
+ _.animType = 'transform';
1314
+ _.transformType = "transform";
1315
+ _.transitionType = 'transition';
1316
+ }
1317
+ _.transformsEnabled = (_.animType !== null && _.animType !== false);
1222
1318
 
1223
- _.transformsEnabled = (_.animType !== null);
1319
+ };
1224
1320
 
1225
- };
1226
1321
 
1322
+ Slick.prototype.setSlideClasses = function(index) {
1227
1323
 
1228
- Slick.prototype.setSlideClasses = function(index) {
1324
+ var _ = this,
1325
+ centerOffset, allSlides, indexOffset, remainder;
1229
1326
 
1230
- var _ = this,
1231
- centerOffset, allSlides, indexOffset, remainder;
1327
+ _.$slider.find('.slick-slide').removeClass('slick-active').removeClass('slick-center');
1328
+ allSlides = _.$slider.find('.slick-slide');
1232
1329
 
1233
- _.$slider.find('.slick-slide').removeClass('slick-active').removeClass('slick-center');
1234
- allSlides = _.$slider.find('.slick-slide');
1330
+ if (_.options.centerMode === true) {
1235
1331
 
1236
- if (_.options.centerMode === true) {
1332
+ centerOffset = Math.floor(_.options.slidesToShow / 2);
1237
1333
 
1238
- centerOffset = Math.floor(_.options.slidesToShow / 2);
1334
+ if(_.options.infinite === true) {
1239
1335
 
1240
- if(_.options.infinite === true) {
1336
+ if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
1337
+ _.$slides.slice(index - centerOffset, index + centerOffset + 1).addClass('slick-active');
1338
+ } else {
1339
+ indexOffset = _.options.slidesToShow + index;
1340
+ allSlides.slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2).addClass('slick-active');
1341
+ }
1342
+
1343
+ if (index === 0) {
1344
+ allSlides.eq(allSlides.length - 1 - _.options.slidesToShow).addClass('slick-center');
1345
+ } else if (index === _.slideCount - 1) {
1346
+ allSlides.eq(_.options.slidesToShow).addClass('slick-center');
1347
+ }
1348
+
1349
+ }
1350
+
1351
+ _.$slides.eq(index).addClass('slick-center');
1241
1352
 
1242
- if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
1243
- _.$slides.slice(index - centerOffset, index + centerOffset + 1).addClass('slick-active');
1244
1353
  } else {
1245
- indexOffset = _.options.slidesToShow + index;
1246
- allSlides.slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2).addClass('slick-active');
1354
+
1355
+ if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
1356
+ _.$slides.slice(index, index + _.options.slidesToShow).addClass('slick-active');
1357
+ } else if ( allSlides.length <= _.options.slidesToShow ) {
1358
+ allSlides.addClass('slick-active');
1359
+ } else {
1360
+ remainder = _.slideCount%_.options.slidesToShow;
1361
+ indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
1362
+ if(_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
1363
+ allSlides.slice(indexOffset-(_.options.slidesToShow-remainder), indexOffset + remainder).addClass('slick-active');
1364
+ } else {
1365
+ allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active');
1366
+ }
1367
+ }
1368
+
1247
1369
  }
1248
1370
 
1249
- if (index === 0) {
1250
- allSlides.eq(allSlides.length - 1 - _.options.slidesToShow).addClass('slick-center');
1251
- } else if (index === _.slideCount - 1) {
1252
- allSlides.eq(_.options.slidesToShow).addClass('slick-center');
1371
+ if (_.options.lazyLoad === 'ondemand') {
1372
+ _.lazyLoad();
1253
1373
  }
1254
1374
 
1255
- }
1375
+ };
1256
1376
 
1257
- _.$slides.eq(index).addClass('slick-center');
1377
+ Slick.prototype.setupInfinite = function() {
1258
1378
 
1259
- } else {
1379
+ var _ = this,
1380
+ i, slideIndex, infiniteCount;
1260
1381
 
1261
- if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
1262
- _.$slides.slice(index, index + _.options.slidesToShow).addClass('slick-active');
1263
- } else if ( allSlides.length <= _.options.slidesToShow ) {
1264
- allSlides.addClass('slick-active');
1265
- } else {
1266
- remainder = _.slideCount%_.options.slidesToShow;
1267
- indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
1268
- if(_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
1269
- allSlides.slice(indexOffset-(_.options.slidesToShow-remainder), indexOffset + remainder).addClass('slick-active');
1270
- } else {
1271
- allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active');
1382
+ if (_.options.fade === true || _.options.vertical === true) {
1383
+ _.options.centerMode = false;
1272
1384
  }
1273
- }
1274
1385
 
1275
- }
1386
+ if (_.options.infinite === true && _.options.fade === false) {
1387
+
1388
+ slideIndex = null;
1389
+
1390
+ if (_.slideCount > _.options.slidesToShow) {
1391
+
1392
+ if (_.options.centerMode === true) {
1393
+ infiniteCount = _.options.slidesToShow + 1;
1394
+ } else {
1395
+ infiniteCount = _.options.slidesToShow;
1396
+ }
1397
+
1398
+ for (i = _.slideCount; i > (_.slideCount -
1399
+ infiniteCount); i -= 1) {
1400
+ slideIndex = i - 1;
1401
+ $(_.$slides[slideIndex]).clone(true).attr('id', '')
1402
+ .attr('index', slideIndex-_.slideCount)
1403
+ .prependTo(_.$slideTrack).addClass('slick-cloned');
1404
+ }
1405
+ for (i = 0; i < infiniteCount; i += 1) {
1406
+ slideIndex = i;
1407
+ $(_.$slides[slideIndex]).clone(true).attr('id', '')
1408
+ .attr('index', slideIndex+_.slideCount)
1409
+ .appendTo(_.$slideTrack).addClass('slick-cloned');
1410
+ }
1411
+ _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
1412
+ $(this).attr('id', '');
1413
+ });
1276
1414
 
1277
- if (_.options.lazyLoad === 'ondemand') {
1278
- _.lazyLoad();
1279
- }
1415
+ }
1280
1416
 
1281
- };
1417
+ }
1282
1418
 
1283
- Slick.prototype.setupInfinite = function() {
1419
+ };
1284
1420
 
1285
- var _ = this,
1286
- i, slideIndex, infiniteCount;
1421
+ Slick.prototype.selectHandler = function(event) {
1287
1422
 
1288
- if (_.options.fade === true || _.options.vertical === true) {
1289
- _.options.centerMode = false;
1290
- }
1423
+ var _ = this;
1424
+ var index = parseInt($(event.target).parents('.slick-slide').attr("index"));
1425
+ if(!index) index = 0;
1291
1426
 
1292
- if (_.options.infinite === true && _.options.fade === false) {
1427
+ if(_.slideCount <= _.options.slidesToShow){
1428
+ return;
1429
+ }
1430
+ _.slideHandler(index);
1293
1431
 
1294
- slideIndex = null;
1432
+ };
1295
1433
 
1296
- if (_.slideCount > _.options.slidesToShow) {
1434
+ Slick.prototype.slideHandler = function(index,sync) {
1297
1435
 
1298
- if (_.options.centerMode === true) {
1299
- infiniteCount = _.options.slidesToShow + 1;
1300
- } else {
1301
- infiniteCount = _.options.slidesToShow;
1302
- }
1436
+ var targetSlide, animSlide, oldSlide, slideLeft, unevenOffset, targetLeft = null,
1437
+ _ = this;
1303
1438
 
1304
- for (i = _.slideCount; i > (_.slideCount -
1305
- infiniteCount); i -= 1) {
1306
- slideIndex = i - 1;
1307
- $(_.$slides[slideIndex]).clone(true).attr('id', '').prependTo(
1308
- _.$slideTrack).addClass('slick-cloned');
1309
- }
1310
- for (i = 0; i < infiniteCount; i += 1) {
1311
- slideIndex = i;
1312
- $(_.$slides[slideIndex]).clone(true).attr('id', '').appendTo(
1313
- _.$slideTrack).addClass('slick-cloned');
1439
+ sync = sync || false;
1440
+
1441
+ if (_.animating === true && _.options.waitForAnimate === true) {
1442
+ return false;
1314
1443
  }
1315
- _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
1316
- $(this).attr('id', '');
1317
- });
1318
1444
 
1319
- }
1445
+ if (sync === false) {
1446
+ _.asNavFor(index);
1447
+ }
1320
1448
 
1321
- }
1449
+ targetSlide = index;
1450
+ targetLeft = _.getLeft(targetSlide);
1451
+ slideLeft = _.getLeft(_.currentSlide);
1322
1452
 
1323
- };
1453
+ unevenOffset = _.slideCount % _.options.slidesToScroll !== 0 ? _.options.slidesToScroll : 0;
1324
1454
 
1325
- Slick.prototype.selectHandler = function(event) {
1455
+ _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
1326
1456
 
1327
- var _ = this;
1328
- var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
1329
- var index = parseInt($(event.target).parent().attr("index"));
1330
- if(!index) index = 0;
1457
+ if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > (_.slideCount - _.options.slidesToShow + unevenOffset))) {
1458
+ if(_.options.fade === false) {
1459
+ targetSlide = _.currentSlide;
1460
+ _.animateSlide(slideLeft, function() {
1461
+ _.postSlide(targetSlide);
1462
+ });
1463
+ }
1464
+ return false;
1465
+ } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
1466
+ if(_.options.fade === false) {
1467
+ targetSlide = _.currentSlide;
1468
+ _.animateSlide(slideLeft, function() {
1469
+ _.postSlide(targetSlide);
1470
+ });
1471
+ }
1472
+ return false;
1473
+ }
1331
1474
 
1332
- if(_.slideCount <= _.options.slidesToShow){
1333
- return;
1334
- }
1335
- _.slideHandler(index);
1475
+ if (_.options.autoplay === true) {
1476
+ clearInterval(_.autoPlayTimer);
1477
+ }
1336
1478
 
1337
- if(asNavFor != null){
1338
- if(asNavFor.slideCount <= asNavFor.options.slidesToShow){
1339
- return;
1340
- }
1341
- asNavFor.slideHandler(index);
1342
- }
1343
- };
1479
+ if (targetSlide < 0) {
1480
+ if (_.slideCount % _.options.slidesToScroll !== 0) {
1481
+ animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
1482
+ } else {
1483
+ animSlide = _.slideCount + targetSlide;
1484
+ }
1485
+ } else if (targetSlide >= _.slideCount) {
1486
+ if (_.slideCount % _.options.slidesToScroll !== 0) {
1487
+ animSlide = 0;
1488
+ } else {
1489
+ animSlide = targetSlide - _.slideCount;
1490
+ }
1491
+ } else {
1492
+ animSlide = targetSlide;
1493
+ }
1344
1494
 
1345
- Slick.prototype.slideHandler = function(index) {
1495
+ _.animating = true;
1346
1496
 
1347
- var targetSlide, animSlide, slideLeft, unevenOffset, targetLeft = null,
1348
- _ = this;
1497
+ if (_.options.onBeforeChange !== null && index !== _.currentSlide) {
1498
+ _.options.onBeforeChange.call(this, _, _.currentSlide, animSlide);
1499
+ }
1349
1500
 
1350
- if (_.animating === true) {
1351
- return false;
1352
- }
1501
+ oldSlide = _.currentSlide;
1502
+ _.currentSlide = animSlide;
1353
1503
 
1354
- targetSlide = index;
1355
- targetLeft = _.getLeft(targetSlide);
1356
- slideLeft = _.getLeft(_.currentSlide);
1504
+ _.setSlideClasses(_.currentSlide);
1357
1505
 
1358
- unevenOffset = _.slideCount % _.options.slidesToScroll !== 0 ? _.options.slidesToScroll : 0;
1506
+ _.updateDots();
1507
+ _.updateArrows();
1359
1508
 
1360
- _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
1509
+ if (_.options.fade === true) {
1510
+ _.fadeSlide(oldSlide,animSlide, function() {
1511
+ _.postSlide(animSlide);
1512
+ });
1513
+ return false;
1514
+ }
1361
1515
 
1362
- if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > (_.slideCount - _.options.slidesToShow + unevenOffset))) {
1363
- if(_.options.fade === false) {
1364
- targetSlide = _.currentSlide;
1365
- _.animateSlide(slideLeft, function() {
1366
- _.postSlide(targetSlide);
1367
- });
1368
- }
1369
- return false;
1370
- } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
1371
- if(_.options.fade === false) {
1372
- targetSlide = _.currentSlide;
1373
- _.animateSlide(slideLeft, function() {
1374
- _.postSlide(targetSlide);
1516
+ _.animateSlide(targetLeft, function() {
1517
+ _.postSlide(animSlide);
1375
1518
  });
1376
- }
1377
- return false;
1378
- }
1379
1519
 
1380
- if (_.options.autoplay === true) {
1381
- clearInterval(_.autoPlayTimer);
1382
- }
1520
+ };
1383
1521
 
1384
- if (targetSlide < 0) {
1385
- if (_.slideCount % _.options.slidesToScroll !== 0) {
1386
- animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
1387
- } else {
1388
- animSlide = _.slideCount - _.options.slidesToScroll;
1389
- }
1390
- } else if (targetSlide > (_.slideCount - 1)) {
1391
- animSlide = 0;
1392
- } else {
1393
- animSlide = targetSlide;
1394
- }
1522
+ Slick.prototype.startLoad = function() {
1395
1523
 
1396
- _.animating = true;
1524
+ var _ = this;
1397
1525
 
1398
- if (_.options.onBeforeChange !== null && index !== _.currentSlide) {
1399
- _.options.onBeforeChange.call(this, _, _.currentSlide, animSlide);
1400
- }
1401
-
1402
- _.currentSlide = animSlide;
1526
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1403
1527
 
1404
- _.setSlideClasses(_.currentSlide);
1528
+ _.$prevArrow.hide();
1529
+ _.$nextArrow.hide();
1405
1530
 
1406
- _.updateDots();
1407
- _.updateArrows();
1531
+ }
1408
1532
 
1409
- if (_.options.fade === true) {
1410
- _.fadeSlide(animSlide, function() {
1411
- _.postSlide(animSlide);
1412
- });
1413
- return false;
1414
- }
1533
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1415
1534
 
1416
- _.animateSlide(targetLeft, function() {
1417
- _.postSlide(animSlide);
1418
- });
1535
+ _.$dots.hide();
1419
1536
 
1420
- };
1537
+ }
1421
1538
 
1422
- Slick.prototype.startLoad = function() {
1539
+ _.$slider.addClass('slick-loading');
1423
1540
 
1424
- var _ = this;
1541
+ };
1425
1542
 
1426
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1543
+ Slick.prototype.swipeDirection = function() {
1427
1544
 
1428
- _.$prevArrow.hide();
1429
- _.$nextArrow.hide();
1545
+ var xDist, yDist, r, swipeAngle, _ = this;
1430
1546
 
1431
- }
1547
+ xDist = _.touchObject.startX - _.touchObject.curX;
1548
+ yDist = _.touchObject.startY - _.touchObject.curY;
1549
+ r = Math.atan2(yDist, xDist);
1432
1550
 
1433
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1434
-
1435
- _.$dots.hide();
1551
+ swipeAngle = Math.round(r * 180 / Math.PI);
1552
+ if (swipeAngle < 0) {
1553
+ swipeAngle = 360 - Math.abs(swipeAngle);
1554
+ }
1436
1555
 
1437
- }
1556
+ if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
1557
+ return 'left';
1558
+ }
1559
+ if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
1560
+ return 'left';
1561
+ }
1562
+ if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
1563
+ return 'right';
1564
+ }
1438
1565
 
1439
- _.$slider.addClass('slick-loading');
1566
+ return 'vertical';
1440
1567
 
1441
- };
1568
+ };
1442
1569
 
1443
- Slick.prototype.swipeDirection = function() {
1570
+ Slick.prototype.swipeEnd = function(event) {
1444
1571
 
1445
- var xDist, yDist, r, swipeAngle, _ = this;
1572
+ var _ = this, slideCount, slidesTraversed, swipeDiff;
1446
1573
 
1447
- xDist = _.touchObject.startX - _.touchObject.curX;
1448
- yDist = _.touchObject.startY - _.touchObject.curY;
1449
- r = Math.atan2(yDist, xDist);
1574
+ _.dragging = false;
1450
1575
 
1451
- swipeAngle = Math.round(r * 180 / Math.PI);
1452
- if (swipeAngle < 0) {
1453
- swipeAngle = 360 - Math.abs(swipeAngle);
1454
- }
1576
+ if (_.touchObject.curX === undefined) {
1577
+ return false;
1578
+ }
1455
1579
 
1456
- if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
1457
- return 'left';
1458
- }
1459
- if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
1460
- return 'left';
1461
- }
1462
- if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
1463
- return 'right';
1464
- }
1580
+ if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
1581
+ $(event.target).on('click.slick', function(event) {
1582
+ event.stopImmediatePropagation();
1583
+ event.stopPropagation();
1584
+ event.preventDefault();
1585
+ $(event.target).off('click.slick');
1586
+ });
1587
+
1588
+ if(_.options.swipeToSlide === true) {
1589
+ slidesTraversed = Math.round(_.touchObject.swipeLength / _.slideWidth);
1590
+ slideCount = slidesTraversed
1591
+ } else {
1592
+ slideCount = _.options.slidesToScroll;
1593
+ }
1465
1594
 
1466
- return 'vertical';
1595
+ switch (_.swipeDirection()) {
1596
+ case 'left':
1597
+ _.slideHandler(_.currentSlide + slideCount);
1598
+ _.touchObject = {};
1599
+ break;
1467
1600
 
1468
- };
1601
+ case 'right':
1602
+ _.slideHandler(_.currentSlide - slideCount);
1603
+ _.touchObject = {};
1604
+ break;
1605
+ }
1606
+ } else {
1607
+ if(_.touchObject.startX !== _.touchObject.curX) {
1608
+ _.slideHandler(_.currentSlide);
1609
+ _.touchObject = {};
1610
+ }
1611
+ }
1469
1612
 
1470
- Slick.prototype.swipeEnd = function(event) {
1613
+ };
1471
1614
 
1472
- var _ = this;
1473
- var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
1615
+ Slick.prototype.swipeHandler = function(event) {
1474
1616
 
1475
- _.dragging = false;
1617
+ var _ = this;
1476
1618
 
1477
- if (_.touchObject.curX === undefined) {
1478
- return false;
1479
- }
1619
+ if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
1620
+ return;
1621
+ } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
1622
+ return;
1623
+ }
1480
1624
 
1481
- if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
1482
- $(event.target).on('click.slick', function(event) {
1483
- event.stopImmediatePropagation();
1484
- event.stopPropagation();
1485
- event.preventDefault();
1486
- $(event.target).off('click.slick');
1487
- });
1488
-
1489
- switch (_.swipeDirection()) {
1490
- case 'left':
1491
- _.slideHandler(_.currentSlide + _.options.slidesToScroll);
1492
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
1493
- _.touchObject = {};
1494
- break;
1495
-
1496
- case 'right':
1497
- _.slideHandler(_.currentSlide - _.options.slidesToScroll);
1498
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide - asNavFor.options.slidesToScroll);
1499
- _.touchObject = {};
1500
- break;
1501
- }
1502
- } else {
1503
- if(_.touchObject.startX !== _.touchObject.curX) {
1504
- _.slideHandler(_.currentSlide);
1505
- if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide);
1506
- _.touchObject = {};
1507
- }
1508
- }
1625
+ _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
1626
+ event.originalEvent.touches.length : 1;
1509
1627
 
1510
- };
1628
+ _.touchObject.minSwipe = _.listWidth / _.options
1629
+ .touchThreshold;
1511
1630
 
1512
- Slick.prototype.swipeHandler = function(event) {
1631
+ switch (event.data.action) {
1513
1632
 
1514
- var _ = this;
1633
+ case 'start':
1634
+ _.swipeStart(event);
1635
+ break;
1515
1636
 
1516
- if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
1517
- return;
1518
- } else if ((_.options.draggable === false) || (_.options.draggable === false && !event.originalEvent.touches)) {
1519
- return;
1520
- }
1637
+ case 'move':
1638
+ _.swipeMove(event);
1639
+ break;
1521
1640
 
1522
- _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
1523
- event.originalEvent.touches.length : 1;
1641
+ case 'end':
1642
+ _.swipeEnd(event);
1643
+ break;
1524
1644
 
1525
- _.touchObject.minSwipe = _.listWidth / _.options
1526
- .touchThreshold;
1645
+ }
1527
1646
 
1528
- switch (event.data.action) {
1647
+ };
1529
1648
 
1530
- case 'start':
1531
- _.swipeStart(event);
1532
- break;
1649
+ Slick.prototype.swipeMove = function(event) {
1533
1650
 
1534
- case 'move':
1535
- _.swipeMove(event);
1536
- break;
1651
+ var _ = this,
1652
+ curLeft, swipeDirection, positionOffset, touches;
1537
1653
 
1538
- case 'end':
1539
- _.swipeEnd(event);
1540
- break;
1654
+ touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
1541
1655
 
1542
- }
1656
+ curLeft = _.getLeft(_.currentSlide);
1543
1657
 
1544
- };
1658
+ if (!_.dragging || touches && touches.length !== 1) {
1659
+ return false;
1660
+ }
1545
1661
 
1546
- Slick.prototype.swipeMove = function(event) {
1662
+ _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
1663
+ _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
1547
1664
 
1548
- var _ = this,
1549
- curLeft, swipeDirection, positionOffset, touches;
1665
+ _.touchObject.swipeLength = Math.round(Math.sqrt(
1666
+ Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
1550
1667
 
1551
- touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
1668
+ swipeDirection = _.swipeDirection();
1552
1669
 
1553
- curLeft = _.getLeft(_.currentSlide);
1670
+ if (swipeDirection === 'vertical') {
1671
+ return;
1672
+ }
1554
1673
 
1555
- if (!_.dragging || touches && touches.length !== 1) {
1556
- return false;
1557
- }
1674
+ if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
1675
+ event.preventDefault();
1676
+ }
1558
1677
 
1559
- _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
1560
- _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
1678
+ positionOffset = _.touchObject.curX > _.touchObject.startX ? 1 : -1;
1561
1679
 
1562
- _.touchObject.swipeLength = Math.round(Math.sqrt(
1563
- Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
1680
+ if (_.options.vertical === false) {
1681
+ _.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
1682
+ } else {
1683
+ _.swipeLeft = curLeft + (_.touchObject
1684
+ .swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
1685
+ }
1564
1686
 
1565
- swipeDirection = _.swipeDirection();
1687
+ if (_.options.fade === true || _.options.touchMove === false) {
1688
+ return false;
1689
+ }
1566
1690
 
1567
- if (swipeDirection === 'vertical') {
1568
- return;
1569
- }
1691
+ if (_.animating === true) {
1692
+ _.swipeLeft = null;
1693
+ return false;
1694
+ }
1570
1695
 
1571
- if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
1572
- event.preventDefault();
1573
- }
1696
+ _.setCSS(_.swipeLeft);
1574
1697
 
1575
- positionOffset = _.touchObject.curX > _.touchObject.startX ? 1 : -1;
1698
+ };
1576
1699
 
1577
- if (_.options.vertical === false) {
1578
- _.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
1579
- } else {
1580
- _.swipeLeft = curLeft + (_.touchObject
1581
- .swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
1582
- }
1700
+ Slick.prototype.swipeStart = function(event) {
1583
1701
 
1584
- if (_.options.fade === true || _.options.touchMove === false) {
1585
- return false;
1586
- }
1702
+ var _ = this,
1703
+ touches;
1587
1704
 
1588
- if (_.animating === true) {
1589
- _.swipeLeft = null;
1590
- return false;
1591
- }
1705
+ if (event.target.nodeName === 'IMG') {
1706
+ event.preventDefault();
1707
+ }
1592
1708
 
1593
- _.setCSS(_.swipeLeft);
1709
+ if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
1710
+ _.touchObject = {};
1711
+ return false;
1712
+ }
1594
1713
 
1595
- };
1714
+ if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
1715
+ touches = event.originalEvent.touches[0];
1716
+ }
1596
1717
 
1597
- Slick.prototype.swipeStart = function(event) {
1718
+ _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
1719
+ _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
1598
1720
 
1599
- var _ = this,
1600
- touches;
1721
+ _.dragging = true;
1601
1722
 
1602
- if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
1603
- _.touchObject = {};
1604
- return false;
1605
- }
1723
+ };
1606
1724
 
1607
- if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
1608
- touches = event.originalEvent.touches[0];
1609
- }
1725
+ Slick.prototype.unfilterSlides = function() {
1610
1726
 
1611
- _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
1612
- _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
1727
+ var _ = this;
1613
1728
 
1614
- _.dragging = true;
1729
+ if (_.$slidesCache !== null) {
1615
1730
 
1616
- };
1731
+ _.unload();
1617
1732
 
1618
- Slick.prototype.unfilterSlides = function() {
1733
+ _.$slideTrack.children(this.options.slide).detach();
1619
1734
 
1620
- var _ = this;
1735
+ _.$slidesCache.appendTo(_.$slideTrack);
1621
1736
 
1622
- if (_.$slidesCache !== null) {
1737
+ _.reinit();
1623
1738
 
1624
- _.unload();
1739
+ }
1625
1740
 
1626
- _.$slideTrack.children(this.options.slide).detach();
1741
+ };
1627
1742
 
1628
- _.$slidesCache.appendTo(_.$slideTrack);
1743
+ Slick.prototype.unload = function() {
1629
1744
 
1630
- _.reinit();
1745
+ var _ = this;
1631
1746
 
1632
- }
1747
+ $('.slick-cloned', _.$slider).remove();
1748
+ if (_.$dots) {
1749
+ _.$dots.remove();
1750
+ }
1751
+ if (_.$prevArrow) {
1752
+ _.$prevArrow.remove();
1753
+ _.$nextArrow.remove();
1754
+ }
1755
+ _.$slides.removeClass(
1756
+ 'slick-slide slick-active slick-visible').css('width', '');
1633
1757
 
1634
- };
1758
+ };
1635
1759
 
1636
- Slick.prototype.unload = function() {
1760
+ Slick.prototype.updateArrows = function() {
1637
1761
 
1638
- var _ = this;
1762
+ var _ = this;
1639
1763
 
1640
- $('.slick-cloned', _.$slider).remove();
1641
- if (_.$dots) {
1642
- _.$dots.remove();
1643
- }
1644
- if (_.$prevArrow) {
1645
- _.$prevArrow.remove();
1646
- _.$nextArrow.remove();
1647
- }
1648
- _.$slides.removeClass(
1649
- 'slick-slide slick-active slick-visible').removeAttr('style');
1650
-
1651
- };
1652
-
1653
- Slick.prototype.updateArrows = function() {
1654
-
1655
- var _ = this;
1656
-
1657
- if (_.options.arrows === true && _.options.infinite !==
1658
- true && _.slideCount > _.options.slidesToShow) {
1659
- _.$prevArrow.removeClass('slick-disabled');
1660
- _.$nextArrow.removeClass('slick-disabled');
1661
- if (_.currentSlide === 0) {
1662
- _.$prevArrow.addClass('slick-disabled');
1663
- _.$nextArrow.removeClass('slick-disabled');
1664
- } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1665
- _.$nextArrow.addClass('slick-disabled');
1666
- _.$prevArrow.removeClass('slick-disabled');
1667
- }
1668
- }
1764
+ if (_.options.arrows === true && _.options.infinite !==
1765
+ true && _.slideCount > _.options.slidesToShow) {
1766
+ _.$prevArrow.removeClass('slick-disabled');
1767
+ _.$nextArrow.removeClass('slick-disabled');
1768
+ if (_.currentSlide === 0) {
1769
+ _.$prevArrow.addClass('slick-disabled');
1770
+ _.$nextArrow.removeClass('slick-disabled');
1771
+ } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1772
+ _.$nextArrow.addClass('slick-disabled');
1773
+ _.$prevArrow.removeClass('slick-disabled');
1774
+ }
1775
+ }
1669
1776
 
1670
- };
1777
+ };
1671
1778
 
1672
- Slick.prototype.updateDots = function() {
1779
+ Slick.prototype.updateDots = function() {
1673
1780
 
1674
- var _ = this;
1781
+ var _ = this;
1675
1782
 
1676
- if (_.$dots !== null) {
1783
+ if (_.$dots !== null) {
1677
1784
 
1678
- _.$dots.find('li').removeClass('slick-active');
1679
- _.$dots.find('li').eq(Math.floor(_.currentSlide / _.options.slidesToScroll)).addClass('slick-active');
1785
+ _.$dots.find('li').removeClass('slick-active');
1786
+ _.$dots.find('li').eq(Math.floor(_.currentSlide / _.options.slidesToScroll)).addClass('slick-active');
1680
1787
 
1681
- }
1788
+ }
1682
1789
 
1683
- };
1790
+ };
1684
1791
 
1685
- $.fn.slick = function(options) {
1686
- var _ = this;
1687
- return _.each(function(index, element) {
1792
+ $.fn.slick = function(options) {
1793
+ var _ = this;
1794
+ return _.each(function(index, element) {
1688
1795
 
1689
- element.slick = new Slick(element, options);
1796
+ element.slick = new Slick(element, options);
1690
1797
 
1691
- });
1692
- };
1798
+ });
1799
+ };
1693
1800
 
1694
- $.fn.slickAdd = function(slide, slideIndex, addBefore) {
1695
- var _ = this;
1696
- return _.each(function(index, element) {
1801
+ $.fn.slickAdd = function(slide, slideIndex, addBefore) {
1802
+ var _ = this;
1803
+ return _.each(function(index, element) {
1697
1804
 
1698
- element.slick.addSlide(slide, slideIndex, addBefore);
1805
+ element.slick.addSlide(slide, slideIndex, addBefore);
1699
1806
 
1700
- });
1701
- };
1807
+ });
1808
+ };
1702
1809
 
1703
- $.fn.slickCurrentSlide = function() {
1704
- var _ = this;
1705
- return _.get(0).slick.getCurrent();
1706
- };
1810
+ $.fn.slickCurrentSlide = function() {
1811
+ var _ = this;
1812
+ return _.get(0).slick.getCurrent();
1813
+ };
1707
1814
 
1708
- $.fn.slickFilter = function(filter) {
1709
- var _ = this;
1710
- return _.each(function(index, element) {
1815
+ $.fn.slickFilter = function(filter) {
1816
+ var _ = this;
1817
+ return _.each(function(index, element) {
1711
1818
 
1712
- element.slick.filterSlides(filter);
1819
+ element.slick.filterSlides(filter);
1713
1820
 
1714
- });
1715
- };
1821
+ });
1822
+ };
1716
1823
 
1717
- $.fn.slickGoTo = function(slide) {
1718
- var _ = this;
1719
- return _.each(function(index, element) {
1824
+ $.fn.slickGoTo = function(slide) {
1825
+ var _ = this;
1826
+ return _.each(function(index, element) {
1720
1827
 
1721
- var asNavFor = element.slick.options.asNavFor != null ? $(element.slick.options.asNavFor) : null;
1722
- if(asNavFor != null) asNavFor.slickGoTo(slide);
1723
- element.slick.slideHandler(slide);
1828
+ element.slick.changeSlide({
1829
+ data: {
1830
+ message: 'index',
1831
+ index: parseInt(slide)
1832
+ }
1833
+ });
1724
1834
 
1725
- });
1726
- };
1835
+ });
1836
+ };
1727
1837
 
1728
- $.fn.slickNext = function() {
1729
- var _ = this;
1730
- return _.each(function(index, element) {
1838
+ $.fn.slickNext = function() {
1839
+ var _ = this;
1840
+ return _.each(function(index, element) {
1731
1841
 
1732
- element.slick.changeSlide({
1733
- data: {
1734
- message: 'next'
1735
- }
1736
- });
1842
+ element.slick.changeSlide({
1843
+ data: {
1844
+ message: 'next'
1845
+ }
1846
+ });
1737
1847
 
1738
- });
1739
- };
1848
+ });
1849
+ };
1740
1850
 
1741
- $.fn.slickPause = function() {
1742
- var _ = this;
1743
- return _.each(function(index, element) {
1851
+ $.fn.slickPause = function() {
1852
+ var _ = this;
1853
+ return _.each(function(index, element) {
1744
1854
 
1745
- element.slick.autoPlayClear();
1746
- element.slick.paused = true;
1855
+ element.slick.autoPlayClear();
1856
+ element.slick.paused = true;
1747
1857
 
1748
- });
1749
- };
1858
+ });
1859
+ };
1750
1860
 
1751
- $.fn.slickPlay = function() {
1752
- var _ = this;
1753
- return _.each(function(index, element) {
1861
+ $.fn.slickPlay = function() {
1862
+ var _ = this;
1863
+ return _.each(function(index, element) {
1754
1864
 
1755
- element.slick.paused = false;
1756
- element.slick.autoPlay();
1865
+ element.slick.paused = false;
1866
+ element.slick.autoPlay();
1757
1867
 
1758
- });
1759
- };
1868
+ });
1869
+ };
1760
1870
 
1761
- $.fn.slickPrev = function() {
1762
- var _ = this;
1763
- return _.each(function(index, element) {
1871
+ $.fn.slickPrev = function() {
1872
+ var _ = this;
1873
+ return _.each(function(index, element) {
1764
1874
 
1765
- element.slick.changeSlide({
1766
- data: {
1767
- message: 'previous'
1768
- }
1769
- });
1875
+ element.slick.changeSlide({
1876
+ data: {
1877
+ message: 'previous'
1878
+ }
1879
+ });
1770
1880
 
1771
- });
1772
- };
1881
+ });
1882
+ };
1773
1883
 
1774
- $.fn.slickRemove = function(slideIndex, removeBefore) {
1775
- var _ = this;
1776
- return _.each(function(index, element) {
1884
+ $.fn.slickRemove = function(slideIndex, removeBefore) {
1885
+ var _ = this;
1886
+ return _.each(function(index, element) {
1777
1887
 
1778
- element.slick.removeSlide(slideIndex, removeBefore);
1888
+ element.slick.removeSlide(slideIndex, removeBefore);
1779
1889
 
1780
- });
1781
- };
1890
+ });
1891
+ };
1782
1892
 
1783
- $.fn.slickGetOption = function(option) {
1784
- var _ = this;
1785
- return _.get(0).slick.options[option];
1786
- };
1893
+ $.fn.slickGetOption = function(option) {
1894
+ var _ = this;
1895
+ return _.get(0).slick.options[option];
1896
+ };
1787
1897
 
1788
- $.fn.slickSetOption = function(option, value, refresh) {
1789
- var _ = this;
1790
- return _.each(function(index, element) {
1898
+ $.fn.slickSetOption = function(option, value, refresh) {
1899
+ var _ = this;
1900
+ return _.each(function(index, element) {
1791
1901
 
1792
- element.slick.options[option] = value;
1902
+ element.slick.options[option] = value;
1793
1903
 
1794
- if (refresh === true) {
1795
- element.slick.unload();
1796
- element.slick.reinit();
1797
- }
1904
+ if (refresh === true) {
1905
+ element.slick.unload();
1906
+ element.slick.reinit();
1907
+ }
1798
1908
 
1799
- });
1800
- };
1909
+ });
1910
+ };
1801
1911
 
1802
- $.fn.slickUnfilter = function() {
1803
- var _ = this;
1804
- return _.each(function(index, element) {
1912
+ $.fn.slickUnfilter = function() {
1913
+ var _ = this;
1914
+ return _.each(function(index, element) {
1805
1915
 
1806
- element.slick.unfilterSlides();
1916
+ element.slick.unfilterSlides();
1807
1917
 
1808
- });
1809
- };
1918
+ });
1919
+ };
1810
1920
 
1811
- $.fn.unslick = function() {
1812
- var _ = this;
1813
- return _.each(function(index, element) {
1921
+ $.fn.unslick = function() {
1922
+ var _ = this;
1923
+ return _.each(function(index, element) {
1814
1924
 
1815
- if (element.slick) {
1816
- element.slick.destroy();
1817
- }
1925
+ if (element.slick) {
1926
+ element.slick.destroy();
1927
+ }
1818
1928
 
1819
- });
1820
- };
1929
+ });
1930
+ };
1821
1931
 
1822
- $.fn.getSlick = function() {
1823
- var s = null;
1824
- var _ = this;
1825
- _.each(function(index, element) {
1826
- s = element.slick;
1827
- });
1932
+ $.fn.getSlick = function() {
1933
+ var s = null;
1934
+ var _ = this;
1935
+ _.each(function(index, element) {
1936
+ s = element.slick;
1937
+ });
1828
1938
 
1829
- return s;
1830
- };
1939
+ return s;
1940
+ };
1831
1941
 
1832
1942
  }));