3 ___| (_) ___| | __ (_)___
4 / __| | |/ __| |/ / | / __|
5 \__ \ | | (__| < _ | \__ \
6 |___/_|_|\___|_|\_(_)/ |___/
11 Website: http://kenwheeler.github.io
12 Docs: http://kenwheeler.github.io/slick
13 Repo: http://github.com/kenwheeler/slick
14 Issues: http://github.com/kenwheeler/slick/issues
18 /* global window, document, define, jQuery, setInterval, clearInterval */
22 if (typeof define === 'function' && define.amd) {
23 define(['jquery'], factory);
24 } else if (typeof exports !== 'undefined') {
25 module.exports = factory(require('jquery'));
32 var Slick = window.Slick || {};
38 function Slick(element, settings) {
41 responsiveSettings, breakpoint;
45 adaptiveHeight: false,
46 appendArrows: $(element),
47 appendDots: $(element),
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>',
55 centerPadding: '50px',
57 customPaging: function(slider, i) {
58 return '<button type="button" data-role="none">' + (i + 1) + '</button>';
61 dotsClass: 'slick-dots',
75 pauseOnDotsHover: false,
116 transformsEnabled: false
119 $.extend(_, _.initials);
121 _.activeBreakpoint = null;
125 _.breakpointSettings = [];
126 _.cssTransitions = false;
128 _.positionProp = null;
130 _.shouldClick = true;
131 _.$slider = $(element);
132 _.$slidesCache = null;
133 _.transformType = null;
134 _.transitionType = null;
136 _.windowTimer = null;
138 _.options = $.extend({}, _.defaults, settings);
140 _.currentSlide = _.options.initialSlide;
142 _.originalSettings = _.options;
143 responsiveSettings = _.options.responsive || null;
145 if (responsiveSettings && responsiveSettings.length > -1) {
146 _.respondTo = _.options.respondTo || "window";
147 for (breakpoint in responsiveSettings) {
148 if (responsiveSettings.hasOwnProperty(breakpoint)) {
149 _.breakpoints.push(responsiveSettings[
150 breakpoint].breakpoint);
151 _.breakpointSettings[responsiveSettings[
152 breakpoint].breakpoint] =
153 responsiveSettings[breakpoint].settings;
156 _.breakpoints.sort(function(a, b) {
161 _.autoPlay = $.proxy(_.autoPlay, _);
162 _.autoPlayClear = $.proxy(_.autoPlayClear, _);
163 _.changeSlide = $.proxy(_.changeSlide, _);
164 _.clickHandler = $.proxy(_.clickHandler, _);
165 _.selectHandler = $.proxy(_.selectHandler, _);
166 _.setPosition = $.proxy(_.setPosition, _);
167 _.swipeHandler = $.proxy(_.swipeHandler, _);
168 _.dragHandler = $.proxy(_.dragHandler, _);
169 _.keyHandler = $.proxy(_.keyHandler, _);
170 _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
172 _.instanceUid = instanceUid++;
174 // A simple way to check for HTML strings
175 // Strict HTML recognition (must start with <)
176 // Extracted from jQuery v1.11 source
177 _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
189 Slick.prototype.addSlide = function(markup, index, addBefore) {
193 if (typeof(index) === 'boolean') {
196 } else if (index < 0 || (index >= _.slideCount)) {
202 if (typeof(index) === 'number') {
203 if (index === 0 && _.$slides.length === 0) {
204 $(markup).appendTo(_.$slideTrack);
205 } else if (addBefore) {
206 $(markup).insertBefore(_.$slides.eq(index));
208 $(markup).insertAfter(_.$slides.eq(index));
211 if (addBefore === true) {
212 $(markup).prependTo(_.$slideTrack);
214 $(markup).appendTo(_.$slideTrack);
218 _.$slides = _.$slideTrack.children(this.options.slide);
220 _.$slideTrack.children(this.options.slide).detach();
222 _.$slideTrack.append(_.$slides);
224 _.$slides.each(function(index, element) {
225 $(element).attr("index",index);
228 _.$slidesCache = _.$slides;
234 Slick.prototype.animateSlide = function(targetLeft, callback) {
236 var animProps = {}, _ = this;
238 if(_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
239 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
240 _.$list.animate({height: targetHeight},_.options.speed);
243 if (_.options.rtl === true && _.options.vertical === false) {
244 targetLeft = -targetLeft;
246 if (_.transformsEnabled === false) {
247 if (_.options.vertical === false) {
248 _.$slideTrack.animate({
250 }, _.options.speed, _.options.easing, callback);
252 _.$slideTrack.animate({
254 }, _.options.speed, _.options.easing, callback);
259 if (_.cssTransitions === false) {
262 animStart: _.currentLeft
264 animStart: targetLeft
266 duration: _.options.speed,
267 easing: _.options.easing,
268 step: function(now) {
269 if (_.options.vertical === false) {
270 animProps[_.animType] = 'translate(' +
272 _.$slideTrack.css(animProps);
274 animProps[_.animType] = 'translate(0px,' +
276 _.$slideTrack.css(animProps);
279 complete: function() {
290 if (_.options.vertical === false) {
291 animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
293 animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
295 _.$slideTrack.css(animProps);
298 setTimeout(function() {
300 _.disableTransition();
312 Slick.prototype.asNavFor = function(index) {
313 var _ = this, asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
314 if(asNavFor != null) asNavFor.slideHandler(index, true);
317 Slick.prototype.applyTransition = function(slide) {
322 if (_.options.fade === false) {
323 transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
325 transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
328 if (_.options.fade === false) {
329 _.$slideTrack.css(transition);
331 _.$slides.eq(slide).css(transition);
336 Slick.prototype.autoPlay = function() {
340 if (_.autoPlayTimer) {
341 clearInterval(_.autoPlayTimer);
344 if (_.slideCount > _.options.slidesToShow && _.paused !== true) {
345 _.autoPlayTimer = setInterval(_.autoPlayIterator,
346 _.options.autoplaySpeed);
351 Slick.prototype.autoPlayClear = function() {
354 if (_.autoPlayTimer) {
355 clearInterval(_.autoPlayTimer);
360 Slick.prototype.autoPlayIterator = function() {
364 if (_.options.infinite === false) {
366 if (_.direction === 1) {
368 if ((_.currentSlide + 1) === _.slideCount -
373 _.slideHandler(_.currentSlide + _.options.slidesToScroll);
377 if ((_.currentSlide - 1 === 0)) {
383 _.slideHandler(_.currentSlide - _.options.slidesToScroll);
389 _.slideHandler(_.currentSlide + _.options.slidesToScroll);
395 Slick.prototype.buildArrows = function() {
399 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
401 _.$prevArrow = $(_.options.prevArrow);
402 _.$nextArrow = $(_.options.nextArrow);
404 if (_.htmlExpr.test(_.options.prevArrow)) {
405 _.$prevArrow.appendTo(_.options.appendArrows);
408 if (_.htmlExpr.test(_.options.nextArrow)) {
409 _.$nextArrow.appendTo(_.options.appendArrows);
412 if (_.options.infinite !== true) {
413 _.$prevArrow.addClass('slick-disabled');
420 Slick.prototype.buildDots = function() {
425 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
427 dotString = '<ul class="' + _.options.dotsClass + '">';
429 for (i = 0; i <= _.getDotCount(); i += 1) {
430 dotString += '<li>' + _.options.customPaging.call(this, _, i) + '</li>';
433 dotString += '</ul>';
435 _.$dots = $(dotString).appendTo(
436 _.options.appendDots);
438 _.$dots.find('li').first().addClass(
445 Slick.prototype.buildOut = function() {
449 _.$slides = _.$slider.children(_.options.slide +
450 ':not(.slick-cloned)').addClass(
452 _.slideCount = _.$slides.length;
454 _.$slides.each(function(index, element) {
455 $(element).attr("index",index);
458 _.$slidesCache = _.$slides;
460 _.$slider.addClass('slick-slider');
462 _.$slideTrack = (_.slideCount === 0) ?
463 $('<div class="slick-track"/>').appendTo(_.$slider) :
464 _.$slides.wrapAll('<div class="slick-track"/>').parent();
466 _.$list = _.$slideTrack.wrap(
467 '<div class="slick-list"/>').parent();
468 _.$slideTrack.css('opacity', 0);
470 if (_.options.centerMode === true) {
471 _.options.slidesToScroll = 1;
474 $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
484 if (_.options.accessibility === true) {
485 _.$list.prop('tabIndex', 0);
488 _.setSlideClasses(typeof this.currentSlide === 'number' ? this.currentSlide : 0);
490 if (_.options.draggable === true) {
491 _.$list.addClass('draggable');
496 Slick.prototype.checkResponsive = function() {
499 breakpoint, targetBreakpoint, respondToWidth;
500 var sliderWidth = _.$slider.width();
501 var windowWidth = window.innerWidth || $(window).width();
502 if (_.respondTo === "window") {
503 respondToWidth = windowWidth;
504 } else if (_.respondTo === "slider") {
505 respondToWidth = sliderWidth;
506 } else if (_.respondTo === "min") {
507 respondToWidth = Math.min(windowWidth, sliderWidth);
510 if (_.originalSettings.responsive && _.originalSettings
511 .responsive.length > -1 && _.originalSettings.responsive !== null) {
513 targetBreakpoint = null;
515 for (breakpoint in _.breakpoints) {
516 if (_.breakpoints.hasOwnProperty(breakpoint)) {
517 if (respondToWidth < _.breakpoints[breakpoint]) {
518 targetBreakpoint = _.breakpoints[breakpoint];
523 if (targetBreakpoint !== null) {
524 if (_.activeBreakpoint !== null) {
525 if (targetBreakpoint !== _.activeBreakpoint) {
528 _.options = $.extend({}, _.originalSettings,
529 _.breakpointSettings[
534 _.activeBreakpoint = targetBreakpoint;
535 _.options = $.extend({}, _.originalSettings,
536 _.breakpointSettings[
541 if (_.activeBreakpoint !== null) {
542 _.activeBreakpoint = null;
543 _.options = _.originalSettings;
552 Slick.prototype.changeSlide = function(event, dontAnimate) {
555 $target = $(event.target),
556 indexOffset, slideOffset, unevenOffset,navigables, prevNavigable;
558 // If target is a link, prevent default action.
559 $target.is('a') && event.preventDefault();
561 unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
562 indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
564 switch (event.data.message) {
567 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
568 if (_.slideCount > _.options.slidesToShow) {
569 _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
574 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
575 if (_.slideCount > _.options.slidesToShow) {
576 _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
581 var index = event.data.index === 0 ? 0 :
582 event.data.index || $(event.target).parent().index() * _.options.slidesToScroll;
584 navigables = _.getNavigableIndexes();
586 if(navigables[index] && navigables[index] === index) {
587 if(index > navigables[navigables.length -1]){
588 index = navigables[navigables.length -1];
590 for(var n in navigables) {
591 if(index < navigables[n]) {
592 index = prevNavigable;
595 prevNavigable = navigables[n];
599 _.slideHandler(index, false, dontAnimate);
607 Slick.prototype.clickHandler = function(event) {
611 if(_.shouldClick === false) {
612 event.stopImmediatePropagation();
613 event.stopPropagation();
614 event.preventDefault();
619 Slick.prototype.destroy = function() {
627 $('.slick-cloned', _.$slider).remove();
631 if (_.$prevArrow && (typeof _.options.prevArrow !== 'object')) {
632 _.$prevArrow.remove();
634 if (_.$nextArrow && (typeof _.options.nextArrow !== 'object')) {
635 _.$nextArrow.remove();
637 if (_.$slides.parent().hasClass('slick-track')) {
638 _.$slides.unwrap().unwrap();
641 _.$slides.removeClass(
642 'slick-slide slick-active slick-center slick-visible')
653 _.$slider.removeClass('slick-slider');
654 _.$slider.removeClass('slick-initialized');
656 _.$list.off('.slick');
657 $(window).off('.slick-' + _.instanceUid);
658 $(document).off('.slick-' + _.instanceUid);
662 Slick.prototype.disableTransition = function(slide) {
667 transition[_.transitionType] = "";
669 if (_.options.fade === false) {
670 _.$slideTrack.css(transition);
672 _.$slides.eq(slide).css(transition);
677 Slick.prototype.fadeSlide = function(oldSlide, slideIndex, callback) {
681 if (_.cssTransitions === false) {
683 _.$slides.eq(slideIndex).css({
687 _.$slides.eq(slideIndex).animate({
689 }, _.options.speed, _.options.easing, callback);
691 _.$slides.eq(oldSlide).animate({
693 }, _.options.speed, _.options.easing);
697 _.applyTransition(slideIndex);
698 _.applyTransition(oldSlide);
700 _.$slides.eq(slideIndex).css({
705 _.$slides.eq(oldSlide).css({
710 setTimeout(function() {
712 _.disableTransition(slideIndex);
713 _.disableTransition(oldSlide);
723 Slick.prototype.filterSlides = function(filter) {
727 if (filter !== null) {
731 _.$slideTrack.children(this.options.slide).detach();
733 _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
741 Slick.prototype.getCurrent = function() {
745 return _.currentSlide;
749 Slick.prototype.getDotCount = function() {
757 if(_.options.infinite === true) {
758 pagerQty = Math.ceil(_.slideCount / _.options.slidesToScroll);
760 while (breakPoint < _.slideCount){
762 breakPoint = counter + _.options.slidesToShow;
763 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
771 Slick.prototype.getLeft = function(slideIndex) {
781 verticalHeight = _.$slides.first().outerHeight();
783 if (_.options.infinite === true) {
784 if (_.slideCount > _.options.slidesToShow) {
785 _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
786 verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
788 if (_.slideCount % _.options.slidesToScroll !== 0) {
789 if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
790 if(slideIndex > _.slideCount) {
791 _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
792 verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
794 _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
795 verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
800 if(slideIndex + _.options.slidesToShow > _.slideCount) {
801 _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
802 verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
806 if (_.slideCount <= _.options.slidesToShow){
811 if (_.options.centerMode === true && _.options.infinite === true) {
812 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
813 } else if (_.options.centerMode === true) {
815 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
818 if (_.options.vertical === false) {
819 targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
821 targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
824 if (_.options.variableWidth === true) {
826 if(_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
827 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
829 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
831 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
832 if (_.options.centerMode === true) {
833 if(_.options.infinite === false) {
834 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
836 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
838 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
839 targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
849 Slick.prototype.getNavigableIndexes = function() {
857 while (breakPoint < _.slideCount){
858 indexes.push(breakPoint);
859 breakPoint = counter + _.options.slidesToScroll;
860 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
867 Slick.prototype.getSlideCount = function() {
869 var _ = this, slidesTraversed;
871 if(_.options.swipeToSlide === true) {
872 var swipedSlide = null;
873 _.$slideTrack.find('.slick-slide').each(function(index, slide){
874 if (slide.offsetLeft + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
879 slidesTraversed = Math.abs($(swipedSlide).attr('index') - _.currentSlide);
880 return slidesTraversed;
882 return _.options.slidesToScroll;
887 Slick.prototype.init = function() {
891 if (!$(_.$slider).hasClass('slick-initialized')) {
893 $(_.$slider).addClass('slick-initialized');
898 _.initializeEvents();
903 if (_.options.onInit !== null) {
904 _.options.onInit.call(this, _);
909 Slick.prototype.initArrowEvents = function() {
913 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
914 _.$prevArrow.on('click.slick', {
917 _.$nextArrow.on('click.slick', {
924 Slick.prototype.initDotEvents = function() {
928 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
929 $('li', _.$dots).on('click.slick', {
934 if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.options.autoplay === true) {
936 .on('mouseenter.slick', function(){
940 .on('mouseleave.slick', function(){
948 Slick.prototype.initializeEvents = function() {
956 _.$list.on('touchstart.slick mousedown.slick', {
959 _.$list.on('touchmove.slick mousemove.slick', {
962 _.$list.on('touchend.slick mouseup.slick', {
965 _.$list.on('touchcancel.slick mouseleave.slick', {
969 _.$list.on('click.slick', _.clickHandler);
971 if (_.options.pauseOnHover === true && _.options.autoplay === true) {
972 _.$list.on('mouseenter.slick', function(){
976 _.$list.on('mouseleave.slick', function(){
982 if(_.options.accessibility === true) {
983 _.$list.on('keydown.slick', _.keyHandler);
986 if(_.options.focusOnSelect === true) {
987 $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
990 $(window).on('orientationchange.slick.slick-' + _.instanceUid, function() {
995 $(window).on('resize.slick.slick-' + _.instanceUid, function() {
996 if ($(window).width() !== _.windowWidth) {
997 clearTimeout(_.windowDelay);
998 _.windowDelay = window.setTimeout(function() {
999 _.windowWidth = $(window).width();
1000 _.checkResponsive();
1006 $('*[draggable!=true]', _.$slideTrack).on('dragstart', function(e){ e.preventDefault(); })
1008 $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
1009 $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
1013 Slick.prototype.initUI = function() {
1017 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1019 _.$prevArrow.show();
1020 _.$nextArrow.show();
1024 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1030 if (_.options.autoplay === true) {
1038 Slick.prototype.keyHandler = function(event) {
1042 if (event.keyCode === 37 && _.options.accessibility === true) {
1048 } else if (event.keyCode === 39 && _.options.accessibility === true) {
1058 Slick.prototype.lazyLoad = function() {
1061 loadRange, cloneRange, rangeStart, rangeEnd;
1063 function loadImages(imagesScope) {
1064 $('img[data-lazy]', imagesScope).each(function() {
1065 var image = $(this),
1066 imageSource = $(this).attr('data-lazy');
1069 .load(function() { image.animate({ opacity: 1 }, 200); })
1070 .css({ opacity: 0 })
1071 .attr('src', imageSource)
1072 .removeAttr('data-lazy')
1073 .removeClass('slick-loading');
1077 if (_.options.centerMode === true) {
1078 if (_.options.infinite === true) {
1079 rangeStart = _.currentSlide + (_.options.slidesToShow/2 + 1);
1080 rangeEnd = rangeStart + _.options.slidesToShow + 2;
1082 rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow/2 + 1));
1083 rangeEnd = 2 + (_.options.slidesToShow/2 + 1) + _.currentSlide;
1086 rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
1087 rangeEnd = rangeStart + _.options.slidesToShow;
1088 if (_.options.fade === true ) {
1089 if(rangeStart > 0) rangeStart--;
1090 if(rangeEnd <= _.slideCount) rangeEnd++;
1094 loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
1095 loadImages(loadRange);
1097 if (_.slideCount <= _.options.slidesToShow){
1098 cloneRange = _.$slider.find('.slick-slide')
1099 loadImages(cloneRange)
1101 if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1102 cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
1103 loadImages(cloneRange)
1104 } else if (_.currentSlide === 0) {
1105 cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
1106 loadImages(cloneRange);
1111 Slick.prototype.loadSlider = function() {
1121 _.$slider.removeClass('slick-loading');
1125 if (_.options.lazyLoad === 'progressive') {
1126 _.progressiveLazyLoad();
1131 Slick.prototype.postSlide = function(index) {
1135 if (_.options.onAfterChange !== null) {
1136 _.options.onAfterChange.call(this, _, index);
1139 _.animating = false;
1145 if (_.options.autoplay === true && _.paused === false) {
1151 Slick.prototype.progressiveLazyLoad = function() {
1154 imgCount, targetImage;
1156 imgCount = $('img[data-lazy]', _.$slider).length;
1159 targetImage = $('img[data-lazy]', _.$slider).first();
1160 targetImage.attr('src', targetImage.attr('data-lazy')).removeClass('slick-loading').load(function() {
1161 targetImage.removeAttr('data-lazy');
1162 _.progressiveLazyLoad();
1164 .error(function () {
1165 targetImage.removeAttr('data-lazy');
1166 _.progressiveLazyLoad();
1172 Slick.prototype.refresh = function() {
1175 currentSlide = _.currentSlide;
1179 $.extend(_, _.initials);
1186 index: currentSlide,
1192 Slick.prototype.reinit = function() {
1196 _.$slides = _.$slideTrack.children(_.options.slide).addClass(
1199 _.slideCount = _.$slides.length;
1201 if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1202 _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1205 if (_.slideCount <= _.options.slidesToShow) {
1217 _.initArrowEvents();
1225 if(_.options.focusOnSelect === true) {
1226 $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
1229 _.setSlideClasses(0);
1233 if (_.options.onReInit !== null) {
1234 _.options.onReInit.call(this, _);
1239 Slick.prototype.removeSlide = function(index, removeBefore, removeAll) {
1243 if (typeof(index) === 'boolean') {
1244 removeBefore = index;
1245 index = removeBefore === true ? 0 : _.slideCount - 1;
1247 index = removeBefore === true ? --index : index;
1250 if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
1256 if(removeAll === true) {
1257 _.$slideTrack.children().remove();
1259 _.$slideTrack.children(this.options.slide).eq(index).remove();
1262 _.$slides = _.$slideTrack.children(this.options.slide);
1264 _.$slideTrack.children(this.options.slide).detach();
1266 _.$slideTrack.append(_.$slides);
1268 _.$slidesCache = _.$slides;
1274 Slick.prototype.setCSS = function(position) {
1277 positionProps = {}, x, y;
1279 if (_.options.rtl === true) {
1280 position = -position;
1282 x = _.positionProp == 'left' ? position + 'px' : '0px';
1283 y = _.positionProp == 'top' ? position + 'px' : '0px';
1285 positionProps[_.positionProp] = position;
1287 if (_.transformsEnabled === false) {
1288 _.$slideTrack.css(positionProps);
1291 if (_.cssTransitions === false) {
1292 positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
1293 _.$slideTrack.css(positionProps);
1295 positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
1296 _.$slideTrack.css(positionProps);
1302 Slick.prototype.setDimensions = function() {
1306 if (_.options.vertical === false) {
1307 if (_.options.centerMode === true) {
1309 padding: ('0px ' + _.options.centerPadding)
1313 _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
1314 if (_.options.centerMode === true) {
1316 padding: (_.options.centerPadding + ' 0px')
1321 _.listWidth = _.$list.width();
1322 _.listHeight = _.$list.height();
1325 if(_.options.vertical === false && _.options.variableWidth === false) {
1326 _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
1327 _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
1329 } else if (_.options.variableWidth === true) {
1331 _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
1332 _.$slideTrack.children('.slick-slide').each(function(){
1333 trackWidth += Math.ceil($(this).outerWidth(true));
1335 _.$slideTrack.width(Math.ceil(trackWidth) + 1);
1337 _.slideWidth = Math.ceil(_.listWidth);
1338 _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
1341 var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
1342 if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
1346 Slick.prototype.setFade = function() {
1351 _.$slides.each(function(index, element) {
1352 targetLeft = (_.slideWidth * index) * -1;
1353 if (_.options.rtl === true) {
1355 position: 'relative',
1363 position: 'relative',
1372 _.$slides.eq(_.currentSlide).css({
1379 Slick.prototype.setHeight = function() {
1383 if(_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
1384 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
1385 _.$list.css('height', targetHeight);
1390 Slick.prototype.setPosition = function() {
1398 if (_.options.fade === false) {
1399 _.setCSS(_.getLeft(_.currentSlide));
1404 if (_.options.onSetPosition !== null) {
1405 _.options.onSetPosition.call(this, _);
1410 Slick.prototype.setProps = function() {
1413 bodyStyle = document.body.style;
1415 _.positionProp = _.options.vertical === true ? 'top' : 'left';
1417 if (_.positionProp === 'top') {
1418 _.$slider.addClass('slick-vertical');
1420 _.$slider.removeClass('slick-vertical');
1423 if (bodyStyle.WebkitTransition !== undefined ||
1424 bodyStyle.MozTransition !== undefined ||
1425 bodyStyle.msTransition !== undefined) {
1426 if(_.options.useCSS === true) {
1427 _.cssTransitions = true;
1431 if (bodyStyle.OTransform !== undefined) {
1432 _.animType = 'OTransform';
1433 _.transformType = "-o-transform";
1434 _.transitionType = 'OTransition';
1435 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
1437 if (bodyStyle.MozTransform !== undefined) {
1438 _.animType = 'MozTransform';
1439 _.transformType = "-moz-transform";
1440 _.transitionType = 'MozTransition';
1441 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
1443 if (bodyStyle.webkitTransform !== undefined) {
1444 _.animType = 'webkitTransform';
1445 _.transformType = "-webkit-transform";
1446 _.transitionType = 'webkitTransition';
1447 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
1449 if (bodyStyle.msTransform !== undefined) {
1450 _.animType = 'msTransform';
1451 _.transformType = "-ms-transform";
1452 _.transitionType = 'msTransition';
1453 if (bodyStyle.msTransform === undefined) _.animType = false;
1455 if (bodyStyle.transform !== undefined && _.animType !== false) {
1456 _.animType = 'transform';
1457 _.transformType = "transform";
1458 _.transitionType = 'transition';
1460 _.transformsEnabled = (_.animType !== null && _.animType !== false);
1465 Slick.prototype.setSlideClasses = function(index) {
1468 centerOffset, allSlides, indexOffset, remainder;
1470 _.$slider.find('.slick-slide').removeClass('slick-active').removeClass('slick-center');
1471 allSlides = _.$slider.find('.slick-slide');
1473 if (_.options.centerMode === true) {
1475 centerOffset = Math.floor(_.options.slidesToShow / 2);
1477 if(_.options.infinite === true) {
1479 if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
1480 _.$slides.slice(index - centerOffset, index + centerOffset + 1).addClass('slick-active');
1482 indexOffset = _.options.slidesToShow + index;
1483 allSlides.slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2).addClass('slick-active');
1487 allSlides.eq(allSlides.length - 1 - _.options.slidesToShow).addClass('slick-center');
1488 } else if (index === _.slideCount - 1) {
1489 allSlides.eq(_.options.slidesToShow).addClass('slick-center');
1494 _.$slides.eq(index).addClass('slick-center');
1498 if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
1499 _.$slides.slice(index, index + _.options.slidesToShow).addClass('slick-active');
1500 } else if ( allSlides.length <= _.options.slidesToShow ) {
1501 allSlides.addClass('slick-active');
1503 remainder = _.slideCount%_.options.slidesToShow;
1504 indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
1505 if(_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
1506 allSlides.slice(indexOffset-(_.options.slidesToShow-remainder), indexOffset + remainder).addClass('slick-active');
1508 allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active');
1514 if (_.options.lazyLoad === 'ondemand') {
1520 Slick.prototype.setupInfinite = function() {
1523 i, slideIndex, infiniteCount;
1525 if (_.options.fade === true) {
1526 _.options.centerMode = false;
1529 if (_.options.infinite === true && _.options.fade === false) {
1533 if (_.slideCount > _.options.slidesToShow) {
1535 if (_.options.centerMode === true) {
1536 infiniteCount = _.options.slidesToShow + 1;
1538 infiniteCount = _.options.slidesToShow;
1541 for (i = _.slideCount; i > (_.slideCount -
1542 infiniteCount); i -= 1) {
1544 $(_.$slides[slideIndex]).clone(true).attr('id', '')
1545 .attr('index', slideIndex-_.slideCount)
1546 .prependTo(_.$slideTrack).addClass('slick-cloned');
1548 for (i = 0; i < infiniteCount; i += 1) {
1550 $(_.$slides[slideIndex]).clone(true).attr('id', '')
1551 .attr('index', slideIndex+_.slideCount)
1552 .appendTo(_.$slideTrack).addClass('slick-cloned');
1554 _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
1555 $(this).attr('id', '');
1564 Slick.prototype.selectHandler = function(event) {
1567 var index = parseInt($(event.target).parents('.slick-slide').attr("index"));
1568 if(!index) index = 0;
1570 if(_.slideCount <= _.options.slidesToShow){
1571 _.$slider.find('.slick-slide').removeClass('slick-active');
1572 _.$slides.eq(index).addClass('slick-active');
1573 if(_.options.centerMode === true) {
1574 _.$slider.find('.slick-slide').removeClass('slick-center');
1575 _.$slides.eq(index).addClass('slick-center');
1580 _.slideHandler(index);
1584 Slick.prototype.slideHandler = function(index,sync,dontAnimate) {
1586 var targetSlide, animSlide, oldSlide, slideLeft, unevenOffset, targetLeft = null,
1589 sync = sync || false;
1591 if (_.animating === true && _.options.waitForAnimate === true) {
1595 if (_.options.fade === true && _.currentSlide === index) {
1599 if (_.slideCount <= _.options.slidesToShow) {
1603 if (sync === false) {
1607 targetSlide = index;
1608 targetLeft = _.getLeft(targetSlide);
1609 slideLeft = _.getLeft(_.currentSlide);
1611 _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
1613 if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
1614 if(_.options.fade === false) {
1615 targetSlide = _.currentSlide;
1616 if(dontAnimate!==true) {
1617 _.animateSlide(slideLeft, function() {
1618 _.postSlide(targetSlide);
1621 _.postSlide(targetSlide);
1625 } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
1626 if(_.options.fade === false) {
1627 targetSlide = _.currentSlide;
1628 if(dontAnimate!==true) {
1629 _.animateSlide(slideLeft, function() {
1630 _.postSlide(targetSlide);
1633 _.postSlide(targetSlide);
1639 if (_.options.autoplay === true) {
1640 clearInterval(_.autoPlayTimer);
1643 if (targetSlide < 0) {
1644 if (_.slideCount % _.options.slidesToScroll !== 0) {
1645 animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
1647 animSlide = _.slideCount + targetSlide;
1649 } else if (targetSlide >= _.slideCount) {
1650 if (_.slideCount % _.options.slidesToScroll !== 0) {
1653 animSlide = targetSlide - _.slideCount;
1656 animSlide = targetSlide;
1661 if (_.options.onBeforeChange !== null && index !== _.currentSlide) {
1662 _.options.onBeforeChange.call(this, _, _.currentSlide, animSlide);
1665 oldSlide = _.currentSlide;
1666 _.currentSlide = animSlide;
1668 _.setSlideClasses(_.currentSlide);
1673 if (_.options.fade === true) {
1674 if(dontAnimate!==true) {
1675 _.fadeSlide(oldSlide,animSlide, function() {
1676 _.postSlide(animSlide);
1679 _.postSlide(animSlide);
1684 if(dontAnimate!==true) {
1685 _.animateSlide(targetLeft, function() {
1686 _.postSlide(animSlide);
1689 _.postSlide(animSlide);
1694 Slick.prototype.startLoad = function() {
1698 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1700 _.$prevArrow.hide();
1701 _.$nextArrow.hide();
1705 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1711 _.$slider.addClass('slick-loading');
1715 Slick.prototype.swipeDirection = function() {
1717 var xDist, yDist, r, swipeAngle, _ = this;
1719 xDist = _.touchObject.startX - _.touchObject.curX;
1720 yDist = _.touchObject.startY - _.touchObject.curY;
1721 r = Math.atan2(yDist, xDist);
1723 swipeAngle = Math.round(r * 180 / Math.PI);
1724 if (swipeAngle < 0) {
1725 swipeAngle = 360 - Math.abs(swipeAngle);
1728 if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
1729 return (_.options.rtl === false ? 'left' : 'right');
1731 if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
1732 return (_.options.rtl === false ? 'left' : 'right');
1734 if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
1735 return (_.options.rtl === false ? 'right' : 'left');
1742 Slick.prototype.swipeEnd = function(event) {
1744 var _ = this, slideCount;
1748 _.shouldClick = (_.touchObject.swipeLength > 10) ? false : true;
1750 if (_.touchObject.curX === undefined) {
1754 if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
1756 switch (_.swipeDirection()) {
1758 _.slideHandler(_.currentSlide + _.getSlideCount());
1759 _.currentDirection = 0;
1764 _.slideHandler(_.currentSlide - _.getSlideCount());
1765 _.currentDirection = 1;
1770 if(_.touchObject.startX !== _.touchObject.curX) {
1771 _.slideHandler(_.currentSlide);
1778 Slick.prototype.swipeHandler = function(event) {
1782 if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
1784 } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
1788 _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
1789 event.originalEvent.touches.length : 1;
1791 _.touchObject.minSwipe = _.listWidth / _.options
1794 switch (event.data.action) {
1797 _.swipeStart(event);
1812 Slick.prototype.swipeMove = function(event) {
1815 curLeft, swipeDirection, positionOffset, touches;
1817 touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
1819 if (!_.dragging || touches && touches.length !== 1) {
1823 curLeft = _.getLeft(_.currentSlide);
1825 _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
1826 _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
1828 _.touchObject.swipeLength = Math.round(Math.sqrt(
1829 Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
1831 swipeDirection = _.swipeDirection();
1833 if (swipeDirection === 'vertical') {
1837 if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
1838 event.preventDefault();
1841 positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
1843 if (_.options.vertical === false) {
1844 _.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
1846 _.swipeLeft = curLeft + (_.touchObject
1847 .swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
1850 if (_.options.fade === true || _.options.touchMove === false) {
1854 if (_.animating === true) {
1859 _.setCSS(_.swipeLeft);
1863 Slick.prototype.swipeStart = function(event) {
1868 if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
1873 if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
1874 touches = event.originalEvent.touches[0];
1877 _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
1878 _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
1884 Slick.prototype.unfilterSlides = function() {
1888 if (_.$slidesCache !== null) {
1892 _.$slideTrack.children(this.options.slide).detach();
1894 _.$slidesCache.appendTo(_.$slideTrack);
1902 Slick.prototype.unload = function() {
1906 $('.slick-cloned', _.$slider).remove();
1910 if (_.$prevArrow && (typeof _.options.prevArrow !== 'object')) {
1911 _.$prevArrow.remove();
1913 if (_.$nextArrow && (typeof _.options.nextArrow !== 'object')) {
1914 _.$nextArrow.remove();
1916 _.$slides.removeClass(
1917 'slick-slide slick-active slick-visible').css('width', '');
1921 Slick.prototype.updateArrows = function() {
1923 var _ = this, centerOffset;
1925 centerOffset = Math.floor(_.options.slidesToShow / 2)
1927 if (_.options.arrows === true && _.options.infinite !==
1928 true && _.slideCount > _.options.slidesToShow) {
1929 _.$prevArrow.removeClass('slick-disabled');
1930 _.$nextArrow.removeClass('slick-disabled');
1931 if (_.currentSlide === 0) {
1932 _.$prevArrow.addClass('slick-disabled');
1933 _.$nextArrow.removeClass('slick-disabled');
1934 } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {
1935 _.$nextArrow.addClass('slick-disabled');
1936 _.$prevArrow.removeClass('slick-disabled');
1937 } else if (_.currentSlide > _.slideCount - _.options.slidesToShow + centerOffset && _.options.centerMode === true) {
1938 _.$nextArrow.addClass('slick-disabled');
1939 _.$prevArrow.removeClass('slick-disabled');
1945 Slick.prototype.updateDots = function() {
1949 if (_.$dots !== null) {
1951 _.$dots.find('li').removeClass('slick-active');
1952 _.$dots.find('li').eq(Math.floor(_.currentSlide / _.options.slidesToScroll)).addClass('slick-active');
1958 $.fn.slick = function(options) {
1960 return _.each(function(index, element) {
1962 element.slick = new Slick(element, options);
1967 $.fn.slickAdd = function(slide, slideIndex, addBefore) {
1969 return _.each(function(index, element) {
1971 element.slick.addSlide(slide, slideIndex, addBefore);
1976 $.fn.slickCurrentSlide = function() {
1978 return _.get(0).slick.getCurrent();
1981 $.fn.slickFilter = function(filter) {
1983 return _.each(function(index, element) {
1985 element.slick.filterSlides(filter);
1990 $.fn.slickGoTo = function(slide, dontAnimate) {
1992 return _.each(function(index, element) {
1994 element.slick.changeSlide({
1997 index: parseInt(slide)
2004 $.fn.slickNext = function() {
2006 return _.each(function(index, element) {
2008 element.slick.changeSlide({
2017 $.fn.slickPause = function() {
2019 return _.each(function(index, element) {
2021 element.slick.autoPlayClear();
2022 element.slick.paused = true;
2027 $.fn.slickPlay = function() {
2029 return _.each(function(index, element) {
2031 element.slick.paused = false;
2032 element.slick.autoPlay();
2037 $.fn.slickPrev = function() {
2039 return _.each(function(index, element) {
2041 element.slick.changeSlide({
2050 $.fn.slickRemove = function(slideIndex, removeBefore) {
2052 return _.each(function(index, element) {
2054 element.slick.removeSlide(slideIndex, removeBefore);
2059 $.fn.slickRemoveAll = function() {
2061 return _.each(function(index, element) {
2063 element.slick.removeSlide(null, null, true);
2068 $.fn.slickGetOption = function(option) {
2070 return _.get(0).slick.options[option];
2073 $.fn.slickSetOption = function(option, value, refresh) {
2075 return _.each(function(index, element) {
2077 element.slick.options[option] = value;
2079 if (refresh === true) {
2080 element.slick.unload();
2081 element.slick.reinit();
2087 $.fn.slickUnfilter = function() {
2089 return _.each(function(index, element) {
2091 element.slick.unfilterSlides();
2096 $.fn.unslick = function() {
2098 return _.each(function(index, element) {
2100 if (element.slick) {
2101 element.slick.destroy();
2107 $.fn.getSlick = function() {
2110 _.each(function(index, element) {