slick_rails 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fea7a560b5eaa6dc15b7335bb99697f99876f160
-  data.tar.gz: 6a24ac67e2f04271c5acd72e61d3f10a9bfc2cf5
+  metadata.gz: 04d771922c1d4cc6172abf21cd67cf605411e294
+  data.tar.gz: aaee393756949b9ad5b68dc714596003eac732b5
 SHA512:
-  metadata.gz: 349a37b177339c55f5f1dfc99ab518e77314a0108f6fc46ecf9b8864439bfb7421b270ce98e45d0badb13435495b4fe9a112d2922bca7704d3ac67535d178fca
-  data.tar.gz: 27f8c76d054e7a8933fa69e272e7fcfe6c131ba221549a433869c7795aa667aa99a8c5dd57833849a81ae07f18f73b8aa868e056adf7d1fcb9fb51d4594b6cb2
+  metadata.gz: eab191db4b03b623fbdaec1e61a34943c39d8eda58470737fc2cfd083f62595121c6268d021aa7301099ac53eb7f8484eae3da102503077ef136b2618613e784
+  data.tar.gz: dd91dc302f8a0d6b486e66139ad0e1c96837d9ec30ff0c75b23469c73f99aa3e74eda6257a2017f14b192e163d83c47bab7bb0c4bcbdec5067d4bbc2b71d31bd

data/app/assets/javascripts/slick.js

@@ -8,7 +8,6 @@
 
   Author: Ken Wheeler
  Website: http://kenwheeler.github.io
-    Date: 04/02/14
     Docs: http://kenwheeler.github.io/slick
     Repo: http://github.com/kenwheeler/slick
   Issues: http://github.com/kenwheeler/slick/issues
@@ -30,6 +29,7 @@
     var Slick = window.Slick || {};
 
     Slick = (function () {
+        var instanceUid = 0;
 
         function Slick(element, settings) {
 
@@ -37,17 +37,22 @@
 
             _.defaults = {
                 accessibility: true,
+                arrows: true,
                 autoplay: false,
                 autoplaySpeed: 3000,
+                centerMode: false,
+                centerPadding: 50,
                 cssEase: 'ease',
                 dots: false,
                 draggable: true,
-                fade: false,
                 easing: 'linear',
-                arrows: true,
+                fade: false,
                 infinite: true,
+                lazyLoad: 'ondemand',
                 onBeforeChange: null,
                 onAfterChange: null,
+                onInit : null,
+                onReInit : null,
                 pauseOnHover: true,
                 placeholders: true,
                 responsive: null,
@@ -79,6 +84,7 @@
                 slides : null,
                 sliding : false,
                 slideOffset : 0,
+                placeholderOffset : 0,
                 swipeLeft : null,
                 list : null,
                 touchObject : {},
@@ -138,6 +144,7 @@
             _.autoPlayIterator = $.proxy(_.autoPlayIterator,
                 _);
 
+            _.instanceUid = instanceUid++;
             _.init();
 
         }
@@ -146,53 +153,39 @@
 
     }());
 
-    Slick.prototype.init = function () {
-
-        var _ = this;
+    Slick.prototype.addSlide = function (markup, index, addBefore) {
 
-        if (!$(_.slider).hasClass('slick-initialized')) {
+        var _ = this,
+            slideTrackChildren;
 
-            $(_.slider).addClass('slick-initialized');
-            _.buildOut();
-            _.setProps();
-            _.startLoad();
-            _.loadSlider();
-            _.initializeEvents();
-            _.checkResponsive();
+        if (typeof(index) === "boolean") {
+            addBefore = index;
+            index = null;
         }
 
-    };
-
-    Slick.prototype.addSlide = function (markup) {
-
-        var _ = this;
-
         _.unload();
 
-        $(markup).appendTo(_.slideTrack);
-
-        _.slides = _.slideTrack.children(this.options.slide);
-
-        _.slideTrack.children(this.options.slide).remove();
-
-        _.slideTrack.append(_.slides);
-
-        _.reinit();
-
-    };
-
-    Slick.prototype.removeSlide = function (index) {
-
-        var _ = this;
-
-        _.unload();
+        slideTrackChildren = _.slideTrack.children(this.options.slide);
 
-        if(_.slideCount < 1) {
-            return false;
+        if (typeof(index) === "number") {
+            if (index === 0 && $(slideTrackChildren).length === 0) {
+                $(markup).appendTo(_.slideTrack);
+            } else if (index < 0 || (index >= $(slideTrackChildren).length && $(slideTrackChildren).length !== 0) ) {
+                _.reinit();
+                return false;
+            } else if (addBefore) {
+                $(markup).insertBefore($(slideTrackChildren.get(index)));
+            } else {
+                $(markup).insertAfter($(slideTrackChildren.get(index)));
+            }
+        } else {
+            if (addBefore === true) {
+                $(markup).prependTo(_.slideTrack);
+            } else {
+                $(markup).appendTo(_.slideTrack);
+            }
         }
 
-        $(_.slideTrack.children(this.options.slide).get(index)).remove();
-
         _.slides = _.slideTrack.children(this.options.slide);
 
         _.slideTrack.children(this.options.slide).remove();
@@ -203,37 +196,72 @@
 
     };
 
-    Slick.prototype.filterSlides = function (filter) {
-
-        var _ = this;
-
-        if(filter !== null) {
-
-            _.unload();
+    Slick.prototype.animateSlide = function (targetLeft,
+        callback) {
 
-            _.slideTrack.children(this.options.slide).remove();
+        var animProps = {}, _ = this;
 
-            _.slidesCache.filter(filter).appendTo(_.slideTrack);
+        if (_.transformsEnabled === false) {
+            if (_.options.vertical === false) {
+                _.slideTrack.animate({
+                    left: targetLeft
+                }, _.options.speed,_.options.easing, callback);
+            } else {
+                _.slideTrack.animate({
+                    top: targetLeft
+                }, _.options.speed,_.options.easing, callback);
+            }
 
-            _.reinit();
+        } else {
 
-        }
+            if(_.cssTransitions === false) {
 
-    };
+                $({
+                    animStart: _.currentLeft
+                }).animate({
+                    animStart: targetLeft
+                }, {
+                    duration: _.options.speed,
+                    easing: _.options.easing,
+                    step: function (now) {
+                        if (_.options.vertical === false) {
+                            animProps[_.animType] = "translate(" +
+                                now + "px, 0px)";
+                            _.slideTrack.css(animProps);
+                        } else {
+                            animProps[_.animType] = "translate(0px," +
+                                now + "px,0px)";
+                            _.slideTrack.css(animProps);
+                        }
+                    },
+                    complete: function () {
+                        if (callback) {
+                            callback.call();
+                        }
+                    }
+                });
 
-    Slick.prototype.unfilterSlides = function () {
+            } else {
 
-        var _ = this;
+                _.applyTransition();
 
-        if(_.slidesCache !== null) {
+                if (_.options.vertical === false) {
+                    animProps[_.animType] = "translate3d(" + targetLeft + "px, 0px, 0px)";
+                } else {
+                    animProps[_.animType] = "translate3d(0px," + targetLeft + "px, 0px)";
+                }
+                _.slideTrack.css(animProps);
 
-            _.unload();
+                if(callback) {
+                    setTimeout(function(){
 
-            _.slideTrack.children(this.options.slide).remove();
+                    _.disableTransition();
 
-            _.slidesCache.appendTo(_.slideTrack);
+                    callback.call();
+                    }, _.options.speed);
+                }
 
-            _.reinit();
+            }
 
         }
 
@@ -263,23 +291,6 @@
 
     };
 
-    Slick.prototype.disableTransition = function (slide) {
-
-        var _ = this;
-
-        if (_.options.fade === false) {
-            _.slideTrack.css({
-                transition: '',
-                transformOrigin: ''
-            });
-        } else {
-            $(_.slides.get(slide)).css({
-                transition: ''
-            });
-        }
-
-    };
-
     Slick.prototype.autoPlay = function () {
 
         var _ = this;
@@ -342,7 +353,118 @@
 
     };
 
+    Slick.prototype.buildArrows = function () {
+
+        var _ = this;
+
+        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+
+            _.prevArrow = $(
+                '<button type="button" tabIndex="-1">Previous</button>').appendTo(
+                _.slider).addClass('slick-prev');
+            _.nextArrow = $(
+                '<button type="button" tabIndex="-1">Next</button>').appendTo(
+                _.slider).addClass('slick-next');
+
+            if (_.options.infinite !== true) {
+                _.prevArrow.addClass('slick-disabled');
+            }
+
+        }
+
+    };
+
+    Slick.prototype.buildDots = function () {
+
+        var _ = this, i, dotString;
+
+        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
+
+            dotString = '<ul class="slick-dots">';
+
+            for (i = 1; i <= _.slideCount; i += 1) {
+
+                dotString += '<li><a href="javascript:void(0)" tabIndex="-1">' + i +
+                    '</a></li>';
+                if (_.options.placeholders === false && i +
+                _.options.slidesToShow - (_.options.slidesToScroll - 1) > _.slideCount) {
+                    break;
+                }
+            }
+
+            dotString += "</ul>";
+
+            _.dots = $(dotString).appendTo(
+                _.slider);
+
+            if (_.options.slidesToScroll > 1) {
+                _.dots.find('li').hide();
+                i = 0;
+                while (i < _.slideCount) {
+                    $(_.dots.find('li').get(i)).show();
+                    i = i + _.options.slidesToScroll;
+                }
+            }
+
+            _.dots.find('li').first().addClass(
+                'slick-active');
+
+        }
+
+    };
+
+    Slick.prototype.buildOut = function () {
+
+        var _ = this;
+
+        _.slides = _.slider.children(_.options.slide +
+            ':not(.slick-cloned)').addClass(
+            'slick-slide');
+        _.slideCount = _.slides.length;
+        _.slidesCache = _.slides;
+
+        _.slider.addClass("slick-slider");
+
+        _.slideTrack = (_.slideCount === 0) ?
+            $('<div class="slick-track"/>').appendTo(_.slider) :
+            _.slides.wrapAll('<div class="slick-track"/>').parent();
+
+        _.list = _.slideTrack.wrap(
+            '<div class="slick-list"/>').parent();
+        _.slideTrack.css('opacity', 0);
+
+        if(_.options.accessibility === true) {
+            _.list.prop('tabIndex',0);
+        }
+
+        if(_.options.centerMode === true) {
+            _.options.infinite = true;
+            _.options.slidesToScroll = 1;
+            if(_.options.slidesToShow % 2 === 0) {
+                _.options.slidesToShow = 3;
+            }
+        }
+
+        $('img[data-lazy]',_.slider).not('[src]').addClass('slick-loading');
+
+        _.setupPlaceholders();
+
+        _.setupInfinite();
+
+        _.buildArrows();
+
+        _.buildDots();
+
+        _.setSlideClasses(0);
+
+        if (_.options.draggable === true) {
+            _.list.addClass('draggable');
+        }
+
+    };
+
     Slick.prototype.checkResponsive = function () {
+
         var _ = this, breakpoint, targetBreakpoint;
 
         if (_.originalSettings.responsive && _.originalSettings
@@ -387,684 +509,795 @@
             }
 
         }
+
     };
 
-    Slick.prototype.startLoad = function () {
+    Slick.prototype.changeSlide = function (event) {
 
         var _ = this;
 
-        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+        switch (event.data.message) {
 
-            _.prevArrow.hide();
-            _.nextArrow.hide();
+        case 'previous':
+            _.slideHandler(_.currentSlide - _.options
+                .slidesToScroll);
+            break;
 
-        }
+        case 'next':
+            _.slideHandler(_.currentSlide + _.options
+            .slidesToScroll);
+            break;
 
-        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
-
-            _.dots.hide();
+        case 'index':
+            _.slideHandler($(event.target).parent().index());
+            break;
 
+        default:
+            return false;
         }
 
-        _.slider.addClass('slick-loading');
-
     };
 
-    Slick.prototype.initUI = function () {
+    Slick.prototype.destroy = function () {
 
         var _ = this;
 
-        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+        _.autoPlayClear();
 
-            _.prevArrow.show();
-            _.nextArrow.show();
+        _.touchObject = {};
 
+        $('.slick-cloned', _.slider).remove();
+        $('.slick-placeholder', _.slider).remove();
+        if (_.dots) {
+            _.dots.remove();
         }
-
-        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
-
-            _.dots.show();
-
+        if (_.prevArrow) {
+            _.prevArrow.remove();
+            _.nextArrow.remove();
         }
+        _.slides.unwrap().unwrap();
+        _.slides.removeClass(
+            'slick-slide slick-active slick-visible').removeAttr('style');
+        _.slider.removeClass('slick-slider');
+        _.slider.removeClass('slick-initialized');
 
-        if (_.options.autoplay === true) {
+        _.list.off('.slick');
+        $(window).off('.slick'+_.instanceUid);
+    };
 
-            _.autoPlay();
+    Slick.prototype.disableTransition = function (slide) {
+
+        var _ = this;
 
+        if (_.options.fade === false) {
+            _.slideTrack.css({
+                transition: '',
+                transformOrigin: ''
+            });
+        } else {
+            $(_.slides.get(slide)).css({
+                transition: ''
+            });
         }
 
     };
 
-    Slick.prototype.loadSlider = function () {
+    Slick.prototype.fadeSlide = function (slideIndex, callback) {
 
         var _ = this;
 
-        _.setPosition();
-
-        _.slideTrack.css({
-            opacity: 1
-        });
+        if(_.cssTransitions === false) {
 
-        if (document.readyState !== "complete") {
+            $(_.slides.get(slideIndex)).css({zIndex: 1000});
 
-            $(window).load(function () {
+            $(_.slides.get(slideIndex)).animate({
+                opacity: 1
+            }, _.options.speed,_.options.easing, callback);
 
-                _.slider.removeClass('slick-loading');
+        } else {
 
-                _.initUI();
+            _.applyTransition(slideIndex);
 
+            $(_.slides.get(slideIndex)).css({
+                opacity: 1,
+                zIndex: 1000
             });
 
-        } else {
+            if(callback) {
+                setTimeout(function(){
 
-            _.slider.removeClass('slick-loading');
+                _.disableTransition(slideIndex);
 
-            _.initUI();
+                callback.call();
+                }, _.options.speed);
+            }
 
         }
 
     };
 
-    Slick.prototype.setValues = function () {
+    Slick.prototype.filterSlides = function (filter) {
 
         var _ = this;
 
-        _.listWidth = _.list.width();
-        _.listHeight = _.list.height();
-        _.slideWidth = Math.ceil(_.listWidth / _.options
-            .slidesToShow);
+        if(filter !== null) {
+
+            _.unload();
+
+            _.slideTrack.children(this.options.slide).remove();
+
+            _.slidesCache.filter(filter).appendTo(_.slideTrack);
+
+            _.reinit();
+
+        }
 
     };
 
-    Slick.prototype.buildArrows = function () {
+    Slick.prototype.init = function () {
 
         var _ = this;
 
-        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+        if (!$(_.slider).hasClass('slick-initialized')) {
 
-            _.prevArrow = $(
-                '<button type="button" tabIndex="-1">Previous</button>').appendTo(
-                _.slider).addClass('slick-prev');
-            _.nextArrow = $(
-                '<button type="button" tabIndex="-1">Next</button>').appendTo(
-                _.slider).addClass('slick-next');
+            $(_.slider).addClass('slick-initialized');
+            _.buildOut();
+            _.setProps();
+            _.startLoad();
+            _.loadSlider();
+            _.initializeEvents();
+            _.checkResponsive();
+        }
 
-            if (_.options.infinite !== true) {
-                _.prevArrow.addClass('slick-disabled');
-            }
+        if (_.options.onInit !== null) {
+            _.options.onInit.call(this, _);
+        }
+
+    };
+
+    Slick.prototype.initArrowEvents = function () {
+
+        var _ = this;
 
+        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+            _.prevArrow.on('click.slick', {
+                message: 'previous'
+            }, _.changeSlide);
+            _.nextArrow.on('click.slick', {
+                message: 'next'
+            }, _.changeSlide);
         }
 
     };
 
-    Slick.prototype.buildDots = function () {
+    Slick.prototype.initDotEvents = function () {
 
-        var _ = this, i, dotString;
+        var _ = this;
 
         if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
+            $('li a', _.dots).on('click.slick', {
+                message: 'index'
+            }, _.changeSlide);
+        }
 
-            dotString = '<ul class="slick-dots">';
+    };
 
-            for (i = 1; i <= _.slideCount; i += 1) {
+    Slick.prototype.initializeEvents = function () {
 
-                dotString += '<li><a href="javascript:void(0)" tabIndex="-1">' + i +
-                    '</a></li>';
-                if (_.options.placeholders === false && i +
-                _.options.slidesToShow - (_.options.slidesToScroll - 1) > _.slideCount) {
-                    break;
-                }
-            }
+        var _ = this;
 
-            dotString += "</ul>";
+        _.initArrowEvents();
 
-            _.dots = $(dotString).appendTo(
-                _.slider);
+        _.initDotEvents();
 
-            if (_.options.slidesToScroll > 1) {
-                _.dots.find('li').hide();
-                i = 0;
-                while (i < _.slideCount) {
-                    $(_.dots.find('li').get(i)).show();
-                    i = i + _.options.slidesToScroll;
-                }
-            }
+        if (_.options.swipe === true) {
+            _.list.on('touchstart.slick', {
+                action: 'start',
+                kind: 'touch'
+            }, _.swipeHandler);
+            _.list.on('touchmove.slick', {
+                action: 'move',
+                kind: 'touch'
+            }, _.swipeHandler);
+            _.list.on('touchend.slick', {
+                action: 'end',
+                kind: 'touch'
+            }, _.swipeHandler);
+            _.list.on('touchcancel.slick', {
+                action: 'end',
+                kind: 'touch'
+            }, _.swipeHandler);
+        }
 
-            _.dots.find('li').first().addClass(
-                'slick-active');
+        if (_.options.draggable === true) {
+            _.list.on('mousedown.slick', {
+                action: 'start',
+                kind: 'drag'
+            }, _.swipeHandler);
+            _.list.on('mousemove.slick', {
+                action: 'move',
+                kind: 'drag'
+            }, _.swipeHandler);
+            _.list.on('mouseup.slick', {
+                action: 'end',
+                kind: 'drag'
+            }, _.swipeHandler);
+            _.list.on('mouseleave.slick', {
+                action: 'end',
+                kind: 'drag'
+            }, _.swipeHandler);
+        }
 
+        if (_.options.pauseOnHover === true && _.options.autoplay === true) {
+            _.list.on('mouseenter.slick', _.autoPlayClear);
+            _.list.on('mouseleave.slick', _.autoPlay);
         }
 
-    };
+        _.list.on('keydown.slick', _.keyHandler);
 
-    Slick.prototype.setupInfinite = function () {
+        $(window).on('orientationchange.slick.slick'+_.instanceUid, function(){
+            _.checkResponsive();
+            _.setPosition();
+        });
 
-        var _ = this, i, slideIndex;
+        $(window).on('resize.slick.slick'+_.instanceUid, function () {
+            if ($(window).width !== _.windowWidth) {
+                clearTimeout(_.windowDelay);
+                _.windowDelay = window.setTimeout(function () {
+                    _.windowWidth = $(window).width();
+                    _.checkResponsive();
+                    _.setPosition();
+                }, 50);
+            }
+        });
 
-        if (_.options.infinite === true && _.options.fade === false) {
+        $(window).on('load.slick.slick'+_.instanceUid, _.setPosition);
+    };
 
-            slideIndex = null;
+    Slick.prototype.initUI = function () {
 
-            if (_.slideCount > _.options.slidesToShow) {
+        var _ = this;
 
-                for (i = _.slideCount; i > (_.slideCount -
-                    _.options.slidesToShow); i -= 1) {
-                    slideIndex = i - 1;
-                    $(_.slides[slideIndex]).clone().prependTo(
-                        _.slideTrack).addClass('slick-cloned');
-                }
-                for (i = 0; i < _.options.slidesToShow; i += 1) {
-                    slideIndex = i;
-                    $(_.slides[slideIndex]).clone().appendTo(
-                        _.slideTrack).addClass('slick-cloned');
-                }
+        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
 
-            }
+            _.prevArrow.show();
+            _.nextArrow.show();
 
         }
 
-    };
-
-    Slick.prototype.setupPlaceholders = function () {
+        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
 
-        var _ = this, i, placeholders;
+            _.dots.show();
 
-        if(_.options.fade === true || _.options.vertical === true) {
-            _.options.slidesToShow = 1;
-            _.options.slidesToScroll = 1;
         }
 
-        if(_.options.placeholders === false) {
-            _.options.infinite === false;
-            return false;
-        }
+        if (_.options.autoplay === true) {
 
-        if ((_.slideCount % _.options.slidesToScroll) !==
-            0 && _.slideCount > _.options.slidesToShow) {
+            _.autoPlay();
 
-            placeholders = Math.abs(_.options.slidesToScroll -
-                (_.slideCount % _.options.slidesToScroll)
-            );
-            for (i = 0; i < placeholders; i += 1) {
-                $('<div/>').appendTo(_.slideTrack).addClass(
-                    'slick-slide slick-placeholder');
-            }
-            _.slides = $('.slick-slide:not(.slick-cloned)',
-                _.slider);
-            _.slideCount = _.slides.length;
         }
 
     };
 
-    Slick.prototype.buildOut = function () {
+    Slick.prototype.keyHandler = function (event) {
 
         var _ = this;
 
-        _.slides = $(_.options.slide +
-            ':not(.slick-cloned)', _.slider).addClass(
-            'slick-slide');
-        _.slideCount = _.slides.length;
-        _.slidesCache = _.slides;
-
-        _.slider.addClass("slick-slider");
-        _.slideTrack = _.slides.wrapAll(
-            '<div class="slick-track"/>').parent();
-        _.list = _.slideTrack.wrap(
-            '<div class="slick-list"/>').parent();
-        _.slideTrack.css('opacity', 0);
-
-        if(_.options.accessibility === true) {
-            _.list.prop('tabIndex',0);
+        if (event.keyCode === 37) {
+            _.changeSlide({data: {message: 'previous'}});
+        } else if (event.keyCode === 39) {
+            _.changeSlide({data: {message: 'next'}});
         }
 
-        _.setupPlaceholders();
+    };
 
-        _.setupInfinite();
+    Slick.prototype.lazyLoad = function (){
 
-        _.buildArrows();
+        var _ = this, loadRange, cloneRange, rangeStart, rangeEnd;
 
-        _.buildDots();
+        if (_.options.centerMode === true) {
+            rangeStart = _.options.slidesToShow + _.currentSlide - 1;
+            rangeEnd = rangeStart + _.options.slidesToShow + 2;
+        } else {
+            rangeStart = _.options.slidesToShow + _.currentSlide;
+            rangeEnd = rangeStart + _.options.slidesToShow;
+        }
 
-        _.setSlideClasses(0);
+        loadRange = _.slider.find('.slick-slide').slice(rangeStart,rangeEnd);
 
-        if (_.options.draggable === true) {
-            _.list.addClass('draggable');
+        $('img[data-lazy]',loadRange).not('[src]').each(function(){
+            $(this).attr('src', $(this).attr('data-lazy')).removeClass('slick-loading');
+        });
+
+        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
+            cloneRange = _.slider.find('.slick-cloned').slice(0,_.options.slidesToShow);
+            $('img[data-lazy]',cloneRange).not('[src]').each(function(){
+                $(this).attr('src', $(this).attr('data-lazy')).removeClass('slick-loading');
+            });
+        } else if (_.currentSlide === 0) {
+            cloneRange = _.slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
+            $('img[data-lazy]',cloneRange).not('[src]').each(function(){
+                $(this).attr('src', $(this).attr('data-lazy')).removeClass('slick-loading');
+            });
         }
 
     };
 
-    Slick.prototype.setDimensions = function () {
+    Slick.prototype.loadSlider = function () {
 
         var _ = this;
 
-        _.list.find('.slick-slide').width(_.slideWidth);
-        if (_.options.vertical === false) {
-            _.slideTrack.width(Math.ceil((_.slideWidth * _
-                .slider.find('.slick-slide').length)));
-        } else {
-            _.list.height(_.slides.first().outerHeight());
-            _.slideTrack.height(Math.ceil((_.listHeight * _
-                .slider.find('.slick-slide').length)));
-        }
+        _.setPosition();
 
-    };
+        _.slideTrack.css({
+            opacity: 1
+        });
 
-    Slick.prototype.setPosition = function () {
+        if (document.readyState !== "complete") {
 
-        var _ = this, targetPosition, targetSlide;
+            $(window).load(function () {
 
-        targetSlide = _.currentSlide;
+                _.slider.removeClass('slick-loading');
 
-        _.setValues();
-        _.setDimensions();
+                _.initUI();
 
-        _.slideOffset = 0;
+                if (_.options.lazyLoad === 'progressive') {
+                    _.progressiveLazyLoad();
+                }
 
-        if (_.options.infinite === true) {
-            if(_.slideCount > _.options.slidesToShow) {
-                _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
-            }
-        }
+            });
 
-        if (_.options.placeholders === false && _.currentSlide +
-            _.options.slidesToScroll >= _.slideCount) {
-            targetSlide = _.slideCount - _.options.slidesToShow;
-        }
+        } else {
 
-        if (_.options.fade === false) {
-            if (_.options.vertical === false) {
-                targetPosition = ((targetSlide *
-                        _.slideWidth) * -1) + _.slideOffset;
-            } else {
-                targetPosition = ((targetSlide *
-                        _.listHeight) * -1) - _.listHeight;
+            _.slider.removeClass('slick-loading');
+
+            _.initUI();
+
+            if (_.options.lazyLoad === 'progressive') {
+                _.progressiveLazyLoad();
             }
-            _.setCSS(targetPosition);
-        } else {
-            _.setFade();
+
         }
+
     };
 
-    Slick.prototype.setProps = function () {
+    Slick.prototype.postSlide = function (index) {
 
         var _ = this;
 
-        _.positionProp = _.options.vertical === true ? 'top' : 'left';
-
-        if (_.positionProp === 'top') {
-            _.slider.addClass('slick-vertical');
-        } else {
-            _.slider.removeClass('slick-vertical');
+        if (_.options.onAfterChange !== null && index !== _.currentSlide) {
+            _.options.onAfterChange.call(this, _, index);
         }
 
-        if ( document.body.style.WebkitTransition !== undefined ||
-             document.body.style.MozTransition !== undefined ||
-             document.body.style.msTransition !== undefined ) {
-                _.cssTransitions = true;
-        }
+        _.animating = false;
 
-        if (document.body.style.MozTransform !== undefined) _.animType = 'MozTransform';
-        if (document.body.style.webkitTransform !== undefined) _.animType = 'webkitTransform';
-        if (document.body.style.msTransform !== undefined) _.animType = 'msTransform';
+        _.currentSlide = index;
 
-        _.transformsEnabled = (_.animType !== null);
+        _.setPosition();
 
-    };
+        _.swipeLeft = null;
 
-    Slick.prototype.setFade = function () {
+        _.updateDots();
 
-        var _ = this, targetLeft;
+        _.updateArrows();
 
-        _.slides.each(function (index,element) {
-            targetLeft = (_.slideWidth * index) * -1;
-            $(element).css({
-                position: 'relative',
-                left: targetLeft,
-                top: 0,
-                zIndex: 800,
-                opacity: 0
-            });
-        });
+        if (_.options.autoplay === true && _.paused === false) {
+            _.autoPlay();
+        }
 
-        $(_.slides.get(_.currentSlide)).css({
-            zIndex: 900,
-            opacity: 1
-        });
+        _.setSlideClasses(_.currentSlide);
 
     };
 
-    Slick.prototype.initArrowEvents = function () {
+    Slick.prototype.progressiveLazyLoad = function () {
 
-        var _ = this;
+        var _ = this, imgCount, targetImage;
 
-        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
-            _.prevArrow.on('click.slick', {
-                message: 'previous'
-            }, _.changeSlide);
-            _.nextArrow.on('click.slick', {
-                message: 'next'
-            }, _.changeSlide);
+        imgCount = $('img[data-lazy]').not('[src]').length;
+
+        if(imgCount > 0) {
+            targetImage = $($('img[data-lazy]', _.slider).not('[src]').get(0));
+            targetImage.attr('src', targetImage.attr('data-lazy')).removeClass('slick-loading').load(function(){
+                _.progressiveLazyLoad();
+            });
         }
 
     };
 
-    Slick.prototype.initDotEvents = function () {
+    Slick.prototype.refresh = function () {
 
         var _ = this;
 
-        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
-            $('li a', _.dots).on('click.slick', {
-                message: 'index'
-            }, _.changeSlide);
-        }
+        _.destroy();
+
+        $.extend(_, _.initials);
+
+        _.init();
 
     };
 
-    Slick.prototype.initializeEvents = function () {
+    Slick.prototype.reinit = function () {
 
         var _ = this;
 
+        _.slides = $(_.options.slide +
+            ':not(.slick-cloned)', _.slideTrack).addClass(
+            'slick-slide');
+
+        _.slideCount = _.slides.length;
+
+        if(_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
+            _.currentSlide = _.currentSlide - _.options.slidesToScroll;
+        }
+
+        _.setProps();
+
+        _.setupPlaceholders();
+
+        _.setupInfinite();
+
+        _.buildArrows();
+
+        _.updateArrows();
+
         _.initArrowEvents();
 
+        _.buildDots();
+
+        _.updateDots();
+
         _.initDotEvents();
 
-        if (_.options.swipe === true) {
-            _.list.on('touchstart.slick', {
-                action: 'start',
-                kind: 'touch'
-            }, _.swipeHandler);
-            _.list.on('touchmove.slick', {
-                action: 'move',
-                kind: 'touch'
-            }, _.swipeHandler);
-            _.list.on('touchend.slick', {
-                action: 'end',
-                kind: 'touch'
-            }, _.swipeHandler);
-            _.list.on('touchcancel.slick', {
-                action: 'end',
-                kind: 'touch'
-            }, _.swipeHandler);
+        _.setSlideClasses(0);
+
+        _.setPosition();
+
+        if (_.options.onReInit !== null) {
+            _.options.onReInit.call(this, _);
         }
 
-        if (_.options.draggable === true) {
-            _.list.on('mousedown.slick', {
-                action: 'start',
-                kind: 'drag'
-            }, _.swipeHandler);
-            _.list.on('mousemove.slick', {
-                action: 'move',
-                kind: 'drag'
-            }, _.swipeHandler);
-            _.list.on('mouseup.slick', {
-                action: 'end',
-                kind: 'drag'
-            }, _.swipeHandler);
-            _.list.on('mouseleave.slick', {
-                action: 'end',
-                kind: 'drag'
-            }, _.swipeHandler);
+    };
+
+    Slick.prototype.removeSlide = function (index, removeBefore) {
+
+        var _ = this;
+
+        if (typeof(index) === "boolean") {
+            removeBefore = index;
+            index = null;
         }
 
-        if (_.options.pauseOnHover === true && _.options.autoplay === true) {
-            _.list.on('mouseenter.slick', _.autoPlayClear);
-            _.list.on('mouseleave.slick', _.autoPlay);
+        _.unload();
+
+        if (_.slideCount < 1) {
+            return false;
         }
 
-        _.list.on('keydown.slick', _.keyHandler);
+        if (typeof(index) === "number") {
+            if (removeBefore === true) {
+                --index;
+            } else if (removeBefore === false) {
+               ++index;
+            }
+        } else {
+            if (removeBefore === true) {
+                index = 0;
+            } else {
+                index = $(_.slideTrack.children(this.options.slide)).length - 1;
+            }
+        }
 
-        $(window).on('orientationchange.slick', function(){
-            _.checkResponsive();
-            _.setPosition();
-        });
+        if (index < 0 || index >= $(_.slideTrack.children(this.options.slide)).length) {
+            _.reinit();
+            return false;
+        }
 
-        $(window).resize(function () {
-                if ($(window).width !== _.windowWidth) {
-                    clearTimeout(_.windowDelay);
-                    _.windowDelay = window.setTimeout(function () {
-                        _.windowWidth = $(window).width();
-                        _.checkResponsive();
-                        _.setPosition();
-                    }, 50);
-                }
-        });
+        $(_.slideTrack.children(this.options.slide).get(index)).remove();
 
-        $(window).on('load.slick', _.setPosition);
+        _.slides = _.slideTrack.children(this.options.slide);
 
-    };
+        _.slideTrack.children(this.options.slide).remove();
 
-    Slick.prototype.changeSlide = function (event) {
+        _.slideTrack.append(_.slides);
 
-        var _ = this;
+        _.reinit();
 
-        switch (event.data.message) {
+    };
 
-        case 'previous':
-            _.slideHandler(_.currentSlide - _.options
-                .slidesToScroll);
-            break;
+    Slick.prototype.setCSS = function (position) {
 
-        case 'next':
-            if ((_.options.placeholders === false && _.currentSlide +
-                _.options.slidesToShow >= _.slideCount)) {
-                return false;
-            }
-            _.slideHandler(_.currentSlide + _.options
-            .slidesToScroll);
-            break;
+        var _ = this, positionProps = {}, x, y;
 
-        case 'index':
-            _.slideHandler($(event.target).parent().index());
-            break;
+        x = _.positionProp == 'left' ? position + 'px' : '0px';
+        y = _.positionProp == 'top' ? position + 'px' : '0px';
 
-        default:
-            return false;
+        positionProps[_.positionProp] = position;
+
+        if (_.transformsEnabled === false) {
+            _.slideTrack.css(positionProps);
+        } else {
+            positionProps = {};
+            if(_.cssTransitions === false) {
+                positionProps[_.animType] = "translate(" + x + ", " + y + ")";
+                _.slideTrack.css(positionProps);
+            } else {
+                positionProps[_.animType] = "translate3d(" + x + ", " + y + ", 0px)";
+                _.slideTrack.css(positionProps);
+            }
         }
 
     };
 
-    Slick.prototype.updateDots = function () {
+    Slick.prototype.setDimensions = function () {
 
         var _ = this;
 
-        if(_.dots !== null) {
+        if(_.options.centerMode === true) {
+            _.list.find('.slick-slide').width(_.slideWidth);
+        } else {
+            _.list.find('.slick-slide').width(_.slideWidth);
+        }
 
-            _.dots.find('li').removeClass('slick-active');
-            $(_.dots.find('li').get(_.currentSlide)).addClass(
-                'slick-active');
 
+        if (_.options.vertical === false) {
+            _.slideTrack.width(Math.ceil((_.slideWidth * _
+                .slider.find('.slick-slide').length)));
+            if(_.options.centerMode ===  true) {
+                _.list.css({padding: ('0px ' + _.options.centerPadding + 'px')});
+            }
+        } else {
+            _.list.height(_.slides.first().outerHeight());
+            _.slideTrack.height(Math.ceil((_.listHeight * _
+                .slider.find('.slick-slide').length)));
+                if(_.options.centerMode ===  true) {
+                _.list.css({padding: (_.options.centerPadding + 'px 0px')});
+            }
         }
 
     };
 
-    Slick.prototype.updateArrows = function () {
+    Slick.prototype.setFade = function () {
 
-        var _ = this;
+        var _ = this, targetLeft;
 
-        if (_.options.arrows === true && _.options.infinite !==
-            true && _.slideCount > _.options.slidesToShow) {
-            if (_.currentSlide === 0) {
-                _.prevArrow.addClass('slick-disabled');
-                _.nextArrow.removeClass('slick-disabled');
-            } else if (_.currentSlide >= (_.slideCount /
-                _.options.slidesToScroll * _.options.slidesToShow
-            ) - _.options.slidesToScroll) {
-                _.nextArrow.addClass('slick-disabled');
-                _.prevArrow.removeClass('slick-disabled');
-            } else if (_.options.placeholders === false && _.currentSlide +
-                _.options.slidesToShow >= _.slideCount) {
-                _.nextArrow.addClass('slick-disabled');
-                _.prevArrow.removeClass('slick-disabled');
+        _.slides.each(function (index,element) {
+            targetLeft = (_.slideWidth * index) * -1;
+            $(element).css({
+                position: 'relative',
+                left: targetLeft,
+                top: 0,
+                zIndex: 800,
+                opacity: 0
+            });
+        });
+
+        $(_.slides.get(_.currentSlide)).css({
+            zIndex: 900,
+            opacity: 1
+        });
+
+    };
+
+    Slick.prototype.setPosition = function () {
+
+        var _ = this, targetPosition, targetSlide;
+
+        targetSlide = _.currentSlide;
+
+        _.setValues();
+        _.setDimensions();
+
+        _.slideOffset = 0;
+
+        if (_.options.infinite === true) {
+            if(_.slideCount > _.options.slidesToShow) {
+                _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
+            }
+        }
+
+        if (_.options.centerMode === true) {
+            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
+        }
+
+        if (_.options.placeholders === false) {
+            if(_.currentSlide + _.options.slidesToScroll >= _.slideCount - _.options.slidesToScroll) {
+                _.slideOffset = _.slideOffset - ((_.slideWidth * _.placeholderOffset) * -1);
+            }
+        }
+
+        if (_.options.fade === false) {
+            if (_.options.vertical === false) {
+                targetPosition = ((targetSlide *
+                        _.slideWidth) * -1) + _.slideOffset;
             } else {
-                _.prevArrow.removeClass('slick-disabled');
-                _.nextArrow.removeClass('slick-disabled');
+                targetPosition = ((targetSlide *
+                        _.listHeight) * -1) - _.listHeight;
             }
+            _.setCSS(targetPosition);
+        } else {
+            _.setFade();
         }
 
     };
 
-    Slick.prototype.fadeSlide = function (slideIndex, callback) {
+    Slick.prototype.setProps = function () {
 
         var _ = this;
 
-        if(_.cssTransitions === false) {
-
-            $(_.slides.get(slideIndex)).css({zIndex: 1000});
-
-            $(_.slides.get(slideIndex)).animate({
-                opacity: 1
-            }, _.options.speed,_.options.easing, callback);
+        _.positionProp = _.options.vertical === true ? 'top' : 'left';
 
+        if (_.positionProp === 'top') {
+            _.slider.addClass('slick-vertical');
         } else {
+            _.slider.removeClass('slick-vertical');
+        }
 
-            _.applyTransition(slideIndex);
+        if ( document.body.style.WebkitTransition !== undefined ||
+             document.body.style.MozTransition !== undefined ||
+             document.body.style.msTransition !== undefined ) {
+                _.cssTransitions = true;
+        }
 
-            $(_.slides.get(slideIndex)).css({
-                opacity: 1,
-                zIndex: 1000
-            });
+        if (document.body.style.MozTransform !== undefined) _.animType = 'MozTransform';
+        if (document.body.style.webkitTransform !== undefined) _.animType = 'webkitTransform';
+        if (document.body.style.msTransform !== undefined) _.animType = 'msTransform';
 
-            if(callback) {
-                setTimeout(function(){
+        _.transformsEnabled = (_.animType !== null);
 
-                _.disableTransition(slideIndex);
+    };
 
-                callback.call();
-                }, _.options.speed);
-            }
+    Slick.prototype.setValues = function () {
 
-        }
+        var _ = this;
+
+        _.listWidth = _.list.width();
+        _.listHeight = _.list.height();
+        _.slideWidth = Math.ceil(_.listWidth / _.options
+            .slidesToShow);
 
     };
 
-    Slick.prototype.animateSlide = function (targetLeft,
-        callback) {
+    Slick.prototype.setSlideClasses = function (index) {
 
-        var animProps = {}, _ = this;
+        var _ = this, centerOffset, allSlides, indexOffset;
 
-        if (_.transformsEnabled === false) {
-            if (_.options.vertical === false) {
-                _.slideTrack.animate({
-                    left: targetLeft
-                }, _.options.speed,_.options.easing, callback);
+        _.slider.find('.slick-slide').removeClass('slick-active').removeClass('slick-center');
+        allSlides = _.slider.find('.slick-slide');
+
+        if (_.options.centerMode === true) {
+
+            centerOffset = Math.floor(_.options.slidesToShow / 2);
+
+            if(index >= centerOffset && index <= (_.slideCount - 1) -  centerOffset) {
+                _.slides.slice(index - centerOffset, index + centerOffset + 1).addClass('slick-active');
             } else {
-                _.slideTrack.animate({
-                    top: targetLeft
-                }, _.options.speed,_.options.easing, callback);
+                indexOffset = _.options.slidesToShow + index;
+                allSlides.slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2).addClass('slick-active');
             }
 
-        } else {
+            if(index === 0) {
+                $(allSlides.get(allSlides.length - 1 - _.options.slidesToShow)).addClass('slick-center');
+            } else if (index === _.slideCount - 1) {
+                $(allSlides.get(_.options.slidesToShow)).addClass('slick-center');
+            }
 
-            if(_.cssTransitions === false) {
+            $(_.slides.get(index)).addClass('slick-center');
 
-                $({
-                    animStart: _.currentLeft
-                }).animate({
-                    animStart: targetLeft
-                }, {
-                    duration: _.options.speed,
-                    easing: _.options.easing,
-                    step: function (now) {
-                        if (_.options.vertical === false) {
-                            animProps[_.animType] = "translate(" +
-                                now + "px, 0px)";
-                            _.slideTrack.css(animProps);
-                        } else {
-                            animProps[_.animType] = "translate(0px," +
-                                now + "px,0px)";
-                            _.slideTrack.css(animProps);
-                        }
-                    },
-                    complete: function () {
-                        if (callback) {
-                            callback.call();
-                        }
-                    }
-                });
+        } else {
 
+            if(index > 0 && index < (_.slideCount - _.options.slidesToShow)) {
+                _.slides.slice(index, index + _.options.slidesToShow).addClass('slick-active');
             } else {
+                indexOffset = _.options.slidesToShow + index;
+                allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active');
+            }
 
-                _.applyTransition();
+        }
 
-                if (_.options.vertical === false) {
-                    animProps[_.animType] = "translate3d(" + targetLeft + "px, 0px, 0px)";
-                } else {
-                    animProps[_.animType] = "translate3d(0px," + targetLeft + "px, 0px)";
-                }
-                _.slideTrack.css(animProps);
+        if (_.options.lazyLoad === 'ondemand') {
+            _.lazyLoad();
+        }
 
-                if(callback) {
-                    setTimeout(function(){
+    };
 
-                    _.disableTransition();
+    Slick.prototype.setupInfinite = function () {
 
-                    callback.call();
-                    }, _.options.speed);
-                }
+        var _ = this, i, slideIndex, infiniteCount;
 
-            }
+        if (_.options.infinite === true && _.options.fade === false) {
 
-        }
+            slideIndex = null;
 
-    };
+            if (_.slideCount > _.options.slidesToShow) {
 
-    Slick.prototype.setSlideClasses = function (index) {
-        var _ = this;
-        _.slides.removeClass('slick-active');
-        $(_.slides.get(index)).addClass('slick-active');
-    };
+                if(_.options.centerMode === true) {
+                    infiniteCount = _.options.slidesToShow + 1;
+                } else {
+                    infiniteCount = _.options.slidesToShow;
+                }
 
-    Slick.prototype.postSlide = function (index) {
+                for (i = _.slideCount; i > (_.slideCount -
+                    infiniteCount); i -= 1) {
+                    slideIndex = i - 1;
+                    $(_.slides[slideIndex]).clone().prependTo(
+                        _.slideTrack).addClass('slick-cloned');
+                }
+                for (i = 0; i < infiniteCount; i += 1) {
+                    slideIndex = i;
+                    $(_.slides[slideIndex]).clone().appendTo(
+                        _.slideTrack).addClass('slick-cloned');
+                }
 
-        var _ = this;
+            }
 
-        if (_.options.onAfterChange !== null && index !== _.currentSlide) {
-            _.options.onAfterChange.call(_, index);
         }
 
-        _.animating = false;
+    };
 
-        _.currentSlide = index;
+    Slick.prototype.setupPlaceholders = function () {
 
-        _.setPosition();
+        var _ = this, i, placeholders;
 
-        _.swipeLeft = null;
+        if(_.options.fade === true || _.options.vertical === true) {
+            _.options.slidesToShow = 1;
+            _.options.slidesToScroll = 1;
+            _.options.centerMode = false;
+        }
 
-        _.updateDots();
+        if(_.options.placeholders === false) {
+            _.options.infinite = false;
+            _.placeholderOffset = _.slideCount % _.options.slidesToScroll;
+            return false;
+        }
 
-        _.updateArrows();
+        if ((_.slideCount % _.options.slidesToScroll) !==
+            0 && _.slideCount > _.options.slidesToShow) {
 
-        if (_.options.autoplay === true && _.paused === false) {
-            _.autoPlay();
+            placeholders = Math.abs(_.options.slidesToScroll -
+                (_.slideCount % _.options.slidesToScroll)
+            );
+            for (i = 0; i < placeholders; i += 1) {
+                $('<div/>').appendTo(_.slideTrack).addClass(
+                    'slick-slide slick-placeholder');
+            }
+            _.slides = $('.slick-slide:not(.slick-cloned)',
+                _.slider);
+            _.slideCount = _.slides.length;
         }
 
-        _.setSlideClasses(_.currentSlide);
-
     };
 
     Slick.prototype.slideHandler = function (index) {
 
-        var targetSlide, animSlide, slideLeft, targetLeft = null, _ = this;
+        var targetSlide, animSlide, slideLeft, targetLeft = null,
+            targetOffset, _ = this;
 
         if(_.animating === true) {
             return false;
         }
 
         targetSlide = index;
+        targetOffset = _.slideOffset;
 
-        if(_.options.vertical === false) {
-            targetLeft = ((targetSlide * _.slideWidth) * -1) + _.slideOffset;
-            slideLeft = ((_.currentSlide * _.slideWidth) * -1) + _.slideOffset;
-            if (_.options.placeholders === false && targetSlide +
-            _.options.slidesToShow >= _.slideCount) {
-            targetLeft = (((_.slideCount - _.options.slidesToShow) * _.slideWidth) * -1) + _.slideOffset;
+        if(_.options.placeholders === false) {
+            if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
+                if (targetSlide >= _.slideCount - _.options.slidesToShow) {
+                    targetSlide = _.currentSlide;
+                } else {
+                    targetOffset = 0;
+                }
+            } else if (targetSlide + _.options.slidesToScroll >= _.slideCount -
+                _.options.slidesToScroll) {
+                targetOffset = ((_.placeholderOffset * _.slideWidth));
             }
+        }
+
+        if(_.options.vertical === false) {
+            targetLeft = ((targetSlide * _.slideWidth) * -1) + targetOffset;
+            slideLeft = ((_.currentSlide * _.slideWidth) * -1) + targetOffset;
         } else {
             targetLeft = ((targetSlide * _.listHeight) * -1) - _.listHeight;
             slideLeft = ((_.currentSlide * _.listHeight) * -1) - _.listHeight;
-            if (_.options.placeholders === false && targetSlide +
-            _.options.slidesToShow >= _.slideCount) {
-            targetLeft = (((_.slideCount - _.options.slidesToShow) * _.listHeight) * -1) - _.listHeight;
-            }
         }
 
         if (_.options.infinite === false && (index < 0 || index > (_.slideCount -1))) {
@@ -1085,9 +1318,6 @@
             animSlide = _.slideCount - _.options.slidesToScroll;
         } else if (targetSlide > (_.slideCount - 1)) {
             animSlide = 0;
-        } else if (_.options.placeholders === false && targetSlide +
-            _.options.slidesToShow >= _.slideCount) {
-            animSlide = _.slideCount - _.options.slidesToShow;
         } else {
             animSlide = targetSlide;
         }
@@ -1095,7 +1325,7 @@
         _.animating = true;
 
         if (_.options.onBeforeChange !== null && index !== _.currentSlide) {
-            _.options.onBeforeChange.call(_, animSlide);
+            _.options.onBeforeChange.call(this, _, _.currentSlide);
         }
 
         if (_.options.fade === true) {
@@ -1110,106 +1340,51 @@
 
     };
 
-    Slick.prototype.setCSS = function (position) {
-
-        var _ = this, positionProps = {}, x, y;
-
-        x = _.positionProp == 'left' ? position + 'px' : '0px';
-        y = _.positionProp == 'top' ? position + 'px' : '0px';
-
-        positionProps[_.positionProp] = position;
-
-        if (_.transformsEnabled === false) {
-            _.slideTrack.css(positionProps);
-        } else {
-            positionProps = {};
-            if(_.cssTransitions === false) {
-                positionProps[_.animType] = "translate(" + x + ", " + y + ")";
-                _.slideTrack.css(positionProps);
-            } else {
-                positionProps[_.animType] = "translate3d(" + x + ", " + y + ", 0px)";
-                _.slideTrack.css(positionProps);
-            }
-        }
-
-    };
-
-    Slick.prototype.swipeStart = function (event) {
-
-        var _ = this, touches;
-
-
-        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
-            _.touchObject = {};
-            return false;
-        }
-
-        if(event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
-            touches = event.originalEvent.touches[0];
-        }
-
-        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
-        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
-
-        _.list.addClass('dragging');
-
-    };
-
-    Slick.prototype.swipeMove = function (event) {
-
-        var _ = this, curLeft, swipeDirection, positionOffset, touches;
+    Slick.prototype.startLoad = function () {
 
-        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
+        var _ = this;
 
-        curLeft = _.options.vertical === false ? ((_.currentSlide * _.slideWidth) * -1) +
-                _.slideOffset : ((_.currentSlide * _.listHeight) * -1) -
-                _.listHeight;
+        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
 
-        if (_.options.placeholders === false && _.currentSlide +
-            _.options.slidesToShow >= _.slideCount) {
-            curLeft = (((_.slideCount - _.options.slidesToShow) * _.slideWidth) * -1) + _.slideOffset;
-        }
+            _.prevArrow.hide();
+            _.nextArrow.hide();
 
-        if((!_.list.hasClass('dragging') && event.data.kind === 'drag') ||
-            touches && touches.length !== 1){
-            return false;
         }
 
-        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
-        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
-
-        _.touchObject.swipeLength = Math.round(Math.sqrt(
-            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
+        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
 
-        swipeDirection = _.swipeDirection();
+            _.dots.hide();
 
-        if (swipeDirection === 'vertical') {
-            return false;
         }
 
-        if(event.originalEvent !== undefined) {
-            event.preventDefault();
-        }
+        _.slider.addClass('slick-loading');
 
-        positionOffset = _.touchObject.curX > _.touchObject.startX ? 1 : -1;
+    };
 
-        if(_.options.vertical === false) {
-            _.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
-        } else {
-            _.swipeLeft = curLeft + (_.touchObject
-                    .swipeLength * (_.listHeight / _.listWidth)) * positionOffset;
-        }
+    Slick.prototype.swipeDirection = function () {
 
-        if(_.options.fade === true || _.options.touchMove === false) {
-            return false;
+        var xDist, yDist, r, swipeAngle, _ = this;
+
+        xDist = _.touchObject.startX - _.touchObject.curX;
+        yDist = _.touchObject.startY - _.touchObject.curY;
+        r = Math.atan2(yDist, xDist);
+
+        swipeAngle = Math.round(r * 180 / Math.PI);
+        if (swipeAngle < 0) {
+            swipeAngle = 360 - Math.abs(swipeAngle);
         }
 
-        if (_.animating === true) {
-            _.swipeLeft = null;
-            return false;
+        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
+            return 'left';
+        }
+        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
+            return 'left';
+        }
+        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
+            return 'right';
         }
 
-        _.setCSS(_.swipeLeft);
+        return 'vertical';
 
     };
 
@@ -1219,6 +1394,10 @@
 
         _.list.removeClass('dragging');
 
+        if(_.touchObject.curX === undefined) {
+            return false;
+        }
+
         if ((_.touchObject.fingerCount !== 0) && event.data.kind !== 'drag') {
             _.touchObject = {};
             return false;
@@ -1226,6 +1405,13 @@
 
         if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
 
+            $(event.target).on("click.slick", function (event) {
+                event.stopImmediatePropagation();
+                event.stopPropagation();
+                event.preventDefault();
+                $(event.target).off("click.slick");
+            });
+
             switch (_.swipeDirection()) {
                 case 'left':
                     _.slideHandler(_.currentSlide + _.options.slidesToScroll);
@@ -1245,18 +1431,6 @@
 
     };
 
-    Slick.prototype.keyHandler = function (event) {
-
-        var _ = this;
-
-        if (event.keyCode === 37) {
-            _.changeSlide({data: {message: 'previous'}});
-        } else if (event.keyCode === 39) {
-            _.changeSlide({data: {message: 'next'}});
-        }
-
-    };
-
     Slick.prototype.swipeHandler = function (event) {
 
         var _ = this;
@@ -1287,106 +1461,106 @@
 
     };
 
-    Slick.prototype.swipeDirection = function () {
+    Slick.prototype.swipeMove = function (event) {
 
-        var xDist, yDist, r, swipeAngle, _ = this;
+        var _ = this, curLeft, swipeDirection, positionOffset, touches;
 
-        xDist = _.touchObject.startX - _.touchObject.curX;
-        yDist = _.touchObject.startY - _.touchObject.curY;
-        r = Math.atan2(yDist, xDist);
+        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
 
-        swipeAngle = Math.round(r * 180 / Math.PI);
-        if (swipeAngle < 0) {
-            swipeAngle = 360 - Math.abs(swipeAngle);
-        }
+        curLeft = _.options.vertical === false ? ((_.currentSlide * _.slideWidth) * -1) +
+                _.slideOffset : ((_.currentSlide * _.listHeight) * -1) -
+                _.listHeight;
 
-        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
-            return 'left';
-        }
-        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
-            return 'left';
-        }
-        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
-            return 'right';
+        if (_.options.placeholders === false && _.currentSlide +
+            _.options.slidesToShow >= _.slideCount) {
+            curLeft = ((_.currentSlide * _.slideWidth) * -1) + _.slideOffset;
         }
 
-        return 'vertical';
+        if((!_.list.hasClass('dragging') && event.data.kind === 'drag') ||
+            touches && touches.length !== 1){
+            return false;
+        }
 
-    };
+        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
+        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
 
-    Slick.prototype.refresh = function () {
+        _.touchObject.swipeLength = Math.round(Math.sqrt(
+            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
 
-        var _ = this;
+        swipeDirection = _.swipeDirection();
 
-        _.destroy();
+        if (swipeDirection === 'vertical') {
+            return false;
+        }
 
-        $.extend(_, _.initials);
+        if(event.originalEvent !== undefined) {
+            event.preventDefault();
+        }
 
-        _.init();
+        positionOffset = _.touchObject.curX > _.touchObject.startX ? 1 : -1;
 
-    };
+        if(_.options.vertical === false) {
+            _.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
+        } else {
+            _.swipeLeft = curLeft + (_.touchObject
+                    .swipeLength * (_.listHeight / _.listWidth)) * positionOffset;
+        }
 
-    Slick.prototype.unload = function () {
-        var _ = this;
-        $('.slick-cloned', _.slider).remove();
-        $('.slick-placeholder', _.slider).remove();
-        if (_.dots) {
-            _.dots.remove();
+        if(_.options.fade === true || _.options.touchMove === false) {
+            return false;
         }
-        if (_.prevArrow) {
-            _.prevArrow.remove();
-            _.nextArrow.remove();
+
+        if (_.animating === true) {
+            _.swipeLeft = null;
+            return false;
         }
-        _.slides.removeClass(
-            'slick-slide slick-active slick-visible').removeAttr('style');
-    };
 
-    Slick.prototype.reinit = function () {
+        _.setCSS(_.swipeLeft);
 
-        var _ = this;
+    };
 
-        _.slides = $(_.options.slide +
-            ':not(.slick-cloned)', _.slideTrack).addClass(
-            'slick-slide');
+    Slick.prototype.swipeStart = function (event) {
 
-        _.slideCount = _.slides.length;
+        var _ = this, touches;
 
-        if(_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
-            _.currentSlide = _.currentSlide - _.options.slidesToScroll;
+        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
+            _.touchObject = {};
+            return false;
         }
 
-        _.setProps();
+        if(event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
+            touches = event.originalEvent.touches[0];
+        }
 
-        _.setupPlaceholders();
+        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
+        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
 
-        _.setupInfinite();
+        _.list.addClass('dragging');
 
-        _.buildArrows();
+    };
 
-        _.updateArrows();
+    Slick.prototype.unfilterSlides = function () {
 
-        _.initArrowEvents();
+        var _ = this;
 
-        _.buildDots();
+        if(_.slidesCache !== null) {
 
-        _.updateDots();
+            _.unload();
 
-        _.initDotEvents();
+            _.slideTrack.children(this.options.slide).remove();
 
-        _.setSlideClasses(0);
+            _.slidesCache.appendTo(_.slideTrack);
 
-        _.setPosition();
+            _.reinit();
+
+        }
 
     };
 
-    Slick.prototype.destroy = function () {
+    Slick.prototype.unload = function () {
 
         var _ = this;
 
-        _.autoPlayClear();
-
-        _.touchObject = {};
-
         $('.slick-cloned', _.slider).remove();
         $('.slick-placeholder', _.slider).remove();
         if (_.dots) {
@@ -1396,55 +1570,74 @@
             _.prevArrow.remove();
             _.nextArrow.remove();
         }
-        _.slides.unwrap().unwrap();
         _.slides.removeClass(
             'slick-slide slick-active slick-visible').removeAttr('style');
-        _.slider.removeClass('slick-slider');
-        _.slider.removeClass('slick-initialized');
 
     };
 
-    $.fn.slick = function (options) {
+    Slick.prototype.updateArrows = function () {
+
         var _ = this;
-        return _.each(function (index, element) {
 
-            element.slick = new Slick(element, options);
+        if (_.options.arrows === true && _.options.infinite !==
+            true && _.slideCount > _.options.slidesToShow) {
+            if (_.currentSlide === 0) {
+                _.prevArrow.addClass('slick-disabled');
+                _.nextArrow.removeClass('slick-disabled');
+            } else if (_.currentSlide >= (_.slideCount /
+                _.options.slidesToScroll * _.options.slidesToShow
+            ) - _.options.slidesToScroll) {
+                _.nextArrow.addClass('slick-disabled');
+                _.prevArrow.removeClass('slick-disabled');
+            } else if (_.options.placeholders === false && _.currentSlide +
+                _.options.slidesToShow >= _.slideCount) {
+                _.nextArrow.addClass('slick-disabled');
+                _.prevArrow.removeClass('slick-disabled');
+            } else {
+                _.prevArrow.removeClass('slick-disabled');
+                _.nextArrow.removeClass('slick-disabled');
+            }
+        }
 
-        });
     };
 
-    $.fn.slickAdd = function (slide) {
+    Slick.prototype.updateDots = function () {
+
         var _ = this;
-        return _.each(function (index, element) {
 
-           element.slick.addSlide(slide);
+        if(_.dots !== null) {
+
+            _.dots.find('li').removeClass('slick-active');
+            $(_.dots.find('li').get(_.currentSlide)).addClass(
+                'slick-active');
+
+        }
 
-        });
     };
 
-    $.fn.slickRemove = function (slide) {
+    $.fn.slick = function (options) {
         var _ = this;
         return _.each(function (index, element) {
 
-           element.slick.removeSlide(slide);
+            element.slick = new Slick(element, options);
 
         });
     };
 
-    $.fn.slickFilter = function (filter) {
+    $.fn.slickAdd = function (slide, slideIndex, addBefore) {
         var _ = this;
         return _.each(function (index, element) {
 
-           element.slick.filterSlides(filter);
+           element.slick.addSlide(slide, slideIndex, addBefore);
 
         });
     };
 
-    $.fn.slickUnfilter = function () {
+    $.fn.slickFilter = function (filter) {
         var _ = this;
         return _.each(function (index, element) {
 
-           element.slick.unfilterSlides();
+           element.slick.filterSlides(filter);
 
         });
     };
@@ -1467,31 +1660,40 @@
         });
     };
 
-    $.fn.slickPrev = function () {
+    $.fn.slickPause = function () {
         var _ = this;
         return _.each(function (index, element) {
 
-           element.slick.changeSlide({data: {message: 'previous'}});
+           element.slick.autoPlayClear();
+           element.slick.paused = true;
 
         });
     };
 
-    $.fn.slickPause = function () {
+    $.fn.slickPlay = function () {
         var _ = this;
         return _.each(function (index, element) {
 
-           element.slick.autoPlayClear();
-           element.slick.paused = true;
+           element.slick.paused = false;
+           element.slick.autoPlay();
 
         });
     };
 
-    $.fn.slickPlay = function () {
+    $.fn.slickPrev = function () {
         var _ = this;
         return _.each(function (index, element) {
 
-           element.slick.paused = false;
-           element.slick.autoPlay();
+           element.slick.changeSlide({data: {message: 'previous'}});
+
+        });
+    };
+
+    $.fn.slickRemove = function (slideIndex, removeBefore) {
+        var _ = this;
+        return _.each(function (index, element) {
+
+           element.slick.removeSlide(slideIndex, removeBefore);
 
         });
     };
@@ -1510,6 +1712,15 @@
         });
     };
 
+    $.fn.slickUnfilter = function () {
+        var _ = this;
+        return _.each(function (index, element) {
+
+           element.slick.unfilterSlides();
+
+        });
+    };
+
     $.fn.unslick = function () {
         var _ = this;
         return _.each(function (index, element) {