jquery-slick-rails 1.3.7 → 1.3.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (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
  }));