github.com/wanliu/go-oauth2-server@v0.0.0-20180817021415-f928fa1580df/public/slick/slick.js (about)

     1  /*
     2       _ _      _       _
     3   ___| (_) ___| | __  (_)___
     4  / __| | |/ __| |/ /  | / __|
     5  \__ \ | | (__|   < _ | \__ \
     6  |___/_|_|\___|_|\_(_)/ |___/
     7                     |__/
     8  
     9   Version: 1.8.0
    10    Author: Ken Wheeler
    11   Website: http://kenwheeler.github.io
    12      Docs: http://kenwheeler.github.io/slick
    13      Repo: http://github.com/kenwheeler/slick
    14    Issues: http://github.com/kenwheeler/slick/issues
    15  
    16   */
    17  /* global window, document, define, jQuery, setInterval, clearInterval */
    18  ;(function(factory) {
    19      'use strict';
    20      if (typeof define === 'function' && define.amd) {
    21          define(['jquery'], factory);
    22      } else if (typeof exports !== 'undefined') {
    23          module.exports = factory(require('jquery'));
    24      } else {
    25          factory(jQuery);
    26      }
    27  
    28  }(function($) {
    29      'use strict';
    30      var Slick = window.Slick || {};
    31  
    32      Slick = (function() {
    33  
    34          var instanceUid = 0;
    35  
    36          function Slick(element, settings) {
    37  
    38              var _ = this, dataSettings;
    39  
    40              _.defaults = {
    41                  accessibility: true,
    42                  adaptiveHeight: false,
    43                  appendArrows: $(element),
    44                  appendDots: $(element),
    45                  arrows: true,
    46                  asNavFor: null,
    47                  prevArrow: '<button class="slick-prev" aria-label="Previous" type="button">Previous</button>',
    48                  nextArrow: '<button class="slick-next" aria-label="Next" type="button">Next</button>',
    49                  autoplay: false,
    50                  autoplaySpeed: 3000,
    51                  centerMode: false,
    52                  centerPadding: '50px',
    53                  cssEase: 'ease',
    54                  customPaging: function(slider, i) {
    55                      return $('<button type="button" />').text(i + 1);
    56                  },
    57                  dots: false,
    58                  dotsClass: 'slick-dots',
    59                  draggable: true,
    60                  easing: 'linear',
    61                  edgeFriction: 0.35,
    62                  fade: false,
    63                  focusOnSelect: false,
    64                  focusOnChange: false,
    65                  infinite: true,
    66                  initialSlide: 0,
    67                  lazyLoad: 'ondemand',
    68                  mobileFirst: false,
    69                  pauseOnHover: true,
    70                  pauseOnFocus: true,
    71                  pauseOnDotsHover: false,
    72                  respondTo: 'window',
    73                  responsive: null,
    74                  rows: 1,
    75                  rtl: false,
    76                  slide: '',
    77                  slidesPerRow: 1,
    78                  slidesToShow: 1,
    79                  slidesToScroll: 1,
    80                  speed: 500,
    81                  swipe: true,
    82                  swipeToSlide: false,
    83                  touchMove: true,
    84                  touchThreshold: 5,
    85                  useCSS: true,
    86                  useTransform: true,
    87                  variableWidth: false,
    88                  vertical: false,
    89                  verticalSwiping: false,
    90                  waitForAnimate: true,
    91                  zIndex: 1000
    92              };
    93  
    94              _.initials = {
    95                  animating: false,
    96                  dragging: false,
    97                  autoPlayTimer: null,
    98                  currentDirection: 0,
    99                  currentLeft: null,
   100                  currentSlide: 0,
   101                  direction: 1,
   102                  $dots: null,
   103                  listWidth: null,
   104                  listHeight: null,
   105                  loadIndex: 0,
   106                  $nextArrow: null,
   107                  $prevArrow: null,
   108                  scrolling: false,
   109                  slideCount: null,
   110                  slideWidth: null,
   111                  $slideTrack: null,
   112                  $slides: null,
   113                  sliding: false,
   114                  slideOffset: 0,
   115                  swipeLeft: null,
   116                  swiping: false,
   117                  $list: null,
   118                  touchObject: {},
   119                  transformsEnabled: false,
   120                  unslicked: false
   121              };
   122  
   123              $.extend(_, _.initials);
   124  
   125              _.activeBreakpoint = null;
   126              _.animType = null;
   127              _.animProp = null;
   128              _.breakpoints = [];
   129              _.breakpointSettings = [];
   130              _.cssTransitions = false;
   131              _.focussed = false;
   132              _.interrupted = false;
   133              _.hidden = 'hidden';
   134              _.paused = true;
   135              _.positionProp = null;
   136              _.respondTo = null;
   137              _.rowCount = 1;
   138              _.shouldClick = true;
   139              _.$slider = $(element);
   140              _.$slidesCache = null;
   141              _.transformType = null;
   142              _.transitionType = null;
   143              _.visibilityChange = 'visibilitychange';
   144              _.windowWidth = 0;
   145              _.windowTimer = null;
   146  
   147              dataSettings = $(element).data('slick') || {};
   148  
   149              _.options = $.extend({}, _.defaults, settings, dataSettings);
   150  
   151              _.currentSlide = _.options.initialSlide;
   152  
   153              _.originalSettings = _.options;
   154  
   155              if (typeof document.mozHidden !== 'undefined') {
   156                  _.hidden = 'mozHidden';
   157                  _.visibilityChange = 'mozvisibilitychange';
   158              } else if (typeof document.webkitHidden !== 'undefined') {
   159                  _.hidden = 'webkitHidden';
   160                  _.visibilityChange = 'webkitvisibilitychange';
   161              }
   162  
   163              _.autoPlay = $.proxy(_.autoPlay, _);
   164              _.autoPlayClear = $.proxy(_.autoPlayClear, _);
   165              _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
   166              _.changeSlide = $.proxy(_.changeSlide, _);
   167              _.clickHandler = $.proxy(_.clickHandler, _);
   168              _.selectHandler = $.proxy(_.selectHandler, _);
   169              _.setPosition = $.proxy(_.setPosition, _);
   170              _.swipeHandler = $.proxy(_.swipeHandler, _);
   171              _.dragHandler = $.proxy(_.dragHandler, _);
   172              _.keyHandler = $.proxy(_.keyHandler, _);
   173  
   174              _.instanceUid = instanceUid++;
   175  
   176              // A simple way to check for HTML strings
   177              // Strict HTML recognition (must start with <)
   178              // Extracted from jQuery v1.11 source
   179              _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
   180  
   181  
   182              _.registerBreakpoints();
   183              _.init(true);
   184  
   185          }
   186  
   187          return Slick;
   188  
   189      }());
   190  
   191      Slick.prototype.activateADA = function() {
   192          var _ = this;
   193  
   194          _.$slideTrack.find('.slick-active').attr({
   195              'aria-hidden': 'false'
   196          }).find('a, input, button, select').attr({
   197              'tabindex': '0'
   198          });
   199  
   200      };
   201  
   202      Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
   203  
   204          var _ = this;
   205  
   206          if (typeof(index) === 'boolean') {
   207              addBefore = index;
   208              index = null;
   209          } else if (index < 0 || (index >= _.slideCount)) {
   210              return false;
   211          }
   212  
   213          _.unload();
   214  
   215          if (typeof(index) === 'number') {
   216              if (index === 0 && _.$slides.length === 0) {
   217                  $(markup).appendTo(_.$slideTrack);
   218              } else if (addBefore) {
   219                  $(markup).insertBefore(_.$slides.eq(index));
   220              } else {
   221                  $(markup).insertAfter(_.$slides.eq(index));
   222              }
   223          } else {
   224              if (addBefore === true) {
   225                  $(markup).prependTo(_.$slideTrack);
   226              } else {
   227                  $(markup).appendTo(_.$slideTrack);
   228              }
   229          }
   230  
   231          _.$slides = _.$slideTrack.children(this.options.slide);
   232  
   233          _.$slideTrack.children(this.options.slide).detach();
   234  
   235          _.$slideTrack.append(_.$slides);
   236  
   237          _.$slides.each(function(index, element) {
   238              $(element).attr('data-slick-index', index);
   239          });
   240  
   241          _.$slidesCache = _.$slides;
   242  
   243          _.reinit();
   244  
   245      };
   246  
   247      Slick.prototype.animateHeight = function() {
   248          var _ = this;
   249          if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
   250              var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
   251              _.$list.animate({
   252                  height: targetHeight
   253              }, _.options.speed);
   254          }
   255      };
   256  
   257      Slick.prototype.animateSlide = function(targetLeft, callback) {
   258  
   259          var animProps = {},
   260              _ = this;
   261  
   262          _.animateHeight();
   263  
   264          if (_.options.rtl === true && _.options.vertical === false) {
   265              targetLeft = -targetLeft;
   266          }
   267          if (_.transformsEnabled === false) {
   268              if (_.options.vertical === false) {
   269                  _.$slideTrack.animate({
   270                      left: targetLeft
   271                  }, _.options.speed, _.options.easing, callback);
   272              } else {
   273                  _.$slideTrack.animate({
   274                      top: targetLeft
   275                  }, _.options.speed, _.options.easing, callback);
   276              }
   277  
   278          } else {
   279  
   280              if (_.cssTransitions === false) {
   281                  if (_.options.rtl === true) {
   282                      _.currentLeft = -(_.currentLeft);
   283                  }
   284                  $({
   285                      animStart: _.currentLeft
   286                  }).animate({
   287                      animStart: targetLeft
   288                  }, {
   289                      duration: _.options.speed,
   290                      easing: _.options.easing,
   291                      step: function(now) {
   292                          now = Math.ceil(now);
   293                          if (_.options.vertical === false) {
   294                              animProps[_.animType] = 'translate(' +
   295                                  now + 'px, 0px)';
   296                              _.$slideTrack.css(animProps);
   297                          } else {
   298                              animProps[_.animType] = 'translate(0px,' +
   299                                  now + 'px)';
   300                              _.$slideTrack.css(animProps);
   301                          }
   302                      },
   303                      complete: function() {
   304                          if (callback) {
   305                              callback.call();
   306                          }
   307                      }
   308                  });
   309  
   310              } else {
   311  
   312                  _.applyTransition();
   313                  targetLeft = Math.ceil(targetLeft);
   314  
   315                  if (_.options.vertical === false) {
   316                      animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
   317                  } else {
   318                      animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
   319                  }
   320                  _.$slideTrack.css(animProps);
   321  
   322                  if (callback) {
   323                      setTimeout(function() {
   324  
   325                          _.disableTransition();
   326  
   327                          callback.call();
   328                      }, _.options.speed);
   329                  }
   330  
   331              }
   332  
   333          }
   334  
   335      };
   336  
   337      Slick.prototype.getNavTarget = function() {
   338  
   339          var _ = this,
   340              asNavFor = _.options.asNavFor;
   341  
   342          if ( asNavFor && asNavFor !== null ) {
   343              asNavFor = $(asNavFor).not(_.$slider);
   344          }
   345  
   346          return asNavFor;
   347  
   348      };
   349  
   350      Slick.prototype.asNavFor = function(index) {
   351  
   352          var _ = this,
   353              asNavFor = _.getNavTarget();
   354  
   355          if ( asNavFor !== null && typeof asNavFor === 'object' ) {
   356              asNavFor.each(function() {
   357                  var target = $(this).slick('getSlick');
   358                  if(!target.unslicked) {
   359                      target.slideHandler(index, true);
   360                  }
   361              });
   362          }
   363  
   364      };
   365  
   366      Slick.prototype.applyTransition = function(slide) {
   367  
   368          var _ = this,
   369              transition = {};
   370  
   371          if (_.options.fade === false) {
   372              transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
   373          } else {
   374              transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
   375          }
   376  
   377          if (_.options.fade === false) {
   378              _.$slideTrack.css(transition);
   379          } else {
   380              _.$slides.eq(slide).css(transition);
   381          }
   382  
   383      };
   384  
   385      Slick.prototype.autoPlay = function() {
   386  
   387          var _ = this;
   388  
   389          _.autoPlayClear();
   390  
   391          if ( _.slideCount > _.options.slidesToShow ) {
   392              _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
   393          }
   394  
   395      };
   396  
   397      Slick.prototype.autoPlayClear = function() {
   398  
   399          var _ = this;
   400  
   401          if (_.autoPlayTimer) {
   402              clearInterval(_.autoPlayTimer);
   403          }
   404  
   405      };
   406  
   407      Slick.prototype.autoPlayIterator = function() {
   408  
   409          var _ = this,
   410              slideTo = _.currentSlide + _.options.slidesToScroll;
   411  
   412          if ( !_.paused && !_.interrupted && !_.focussed ) {
   413  
   414              if ( _.options.infinite === false ) {
   415  
   416                  if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
   417                      _.direction = 0;
   418                  }
   419  
   420                  else if ( _.direction === 0 ) {
   421  
   422                      slideTo = _.currentSlide - _.options.slidesToScroll;
   423  
   424                      if ( _.currentSlide - 1 === 0 ) {
   425                          _.direction = 1;
   426                      }
   427  
   428                  }
   429  
   430              }
   431  
   432              _.slideHandler( slideTo );
   433  
   434          }
   435  
   436      };
   437  
   438      Slick.prototype.buildArrows = function() {
   439  
   440          var _ = this;
   441  
   442          if (_.options.arrows === true ) {
   443  
   444              _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
   445              _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
   446  
   447              if( _.slideCount > _.options.slidesToShow ) {
   448  
   449                  _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
   450                  _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
   451  
   452                  if (_.htmlExpr.test(_.options.prevArrow)) {
   453                      _.$prevArrow.prependTo(_.options.appendArrows);
   454                  }
   455  
   456                  if (_.htmlExpr.test(_.options.nextArrow)) {
   457                      _.$nextArrow.appendTo(_.options.appendArrows);
   458                  }
   459  
   460                  if (_.options.infinite !== true) {
   461                      _.$prevArrow
   462                          .addClass('slick-disabled')
   463                          .attr('aria-disabled', 'true');
   464                  }
   465  
   466              } else {
   467  
   468                  _.$prevArrow.add( _.$nextArrow )
   469  
   470                      .addClass('slick-hidden')
   471                      .attr({
   472                          'aria-disabled': 'true',
   473                          'tabindex': '-1'
   474                      });
   475  
   476              }
   477  
   478          }
   479  
   480      };
   481  
   482      Slick.prototype.buildDots = function() {
   483  
   484          var _ = this,
   485              i, dot;
   486  
   487          if (_.options.dots === true) {
   488  
   489              _.$slider.addClass('slick-dotted');
   490  
   491              dot = $('<ul />').addClass(_.options.dotsClass);
   492  
   493              for (i = 0; i <= _.getDotCount(); i += 1) {
   494                  dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
   495              }
   496  
   497              _.$dots = dot.appendTo(_.options.appendDots);
   498  
   499              _.$dots.find('li').first().addClass('slick-active');
   500  
   501          }
   502  
   503      };
   504  
   505      Slick.prototype.buildOut = function() {
   506  
   507          var _ = this;
   508  
   509          _.$slides =
   510              _.$slider
   511                  .children( _.options.slide + ':not(.slick-cloned)')
   512                  .addClass('slick-slide');
   513  
   514          _.slideCount = _.$slides.length;
   515  
   516          _.$slides.each(function(index, element) {
   517              $(element)
   518                  .attr('data-slick-index', index)
   519                  .data('originalStyling', $(element).attr('style') || '');
   520          });
   521  
   522          _.$slider.addClass('slick-slider');
   523  
   524          _.$slideTrack = (_.slideCount === 0) ?
   525              $('<div class="slick-track"/>').appendTo(_.$slider) :
   526              _.$slides.wrapAll('<div class="slick-track"/>').parent();
   527  
   528          _.$list = _.$slideTrack.wrap(
   529              '<div class="slick-list"/>').parent();
   530          _.$slideTrack.css('opacity', 0);
   531  
   532          if (_.options.centerMode === true || _.options.swipeToSlide === true) {
   533              _.options.slidesToScroll = 1;
   534          }
   535  
   536          $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
   537  
   538          _.setupInfinite();
   539  
   540          _.buildArrows();
   541  
   542          _.buildDots();
   543  
   544          _.updateDots();
   545  
   546  
   547          _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
   548  
   549          if (_.options.draggable === true) {
   550              _.$list.addClass('draggable');
   551          }
   552  
   553      };
   554  
   555      Slick.prototype.buildRows = function() {
   556  
   557          var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
   558  
   559          newSlides = document.createDocumentFragment();
   560          originalSlides = _.$slider.children();
   561  
   562          if(_.options.rows > 1) {
   563  
   564              slidesPerSection = _.options.slidesPerRow * _.options.rows;
   565              numOfSlides = Math.ceil(
   566                  originalSlides.length / slidesPerSection
   567              );
   568  
   569              for(a = 0; a < numOfSlides; a++){
   570                  var slide = document.createElement('div');
   571                  for(b = 0; b < _.options.rows; b++) {
   572                      var row = document.createElement('div');
   573                      for(c = 0; c < _.options.slidesPerRow; c++) {
   574                          var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
   575                          if (originalSlides.get(target)) {
   576                              row.appendChild(originalSlides.get(target));
   577                          }
   578                      }
   579                      slide.appendChild(row);
   580                  }
   581                  newSlides.appendChild(slide);
   582              }
   583  
   584              _.$slider.empty().append(newSlides);
   585              _.$slider.children().children().children()
   586                  .css({
   587                      'width':(100 / _.options.slidesPerRow) + '%',
   588                      'display': 'inline-block'
   589                  });
   590  
   591          }
   592  
   593      };
   594  
   595      Slick.prototype.checkResponsive = function(initial, forceUpdate) {
   596  
   597          var _ = this,
   598              breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
   599          var sliderWidth = _.$slider.width();
   600          var windowWidth = window.innerWidth || $(window).width();
   601  
   602          if (_.respondTo === 'window') {
   603              respondToWidth = windowWidth;
   604          } else if (_.respondTo === 'slider') {
   605              respondToWidth = sliderWidth;
   606          } else if (_.respondTo === 'min') {
   607              respondToWidth = Math.min(windowWidth, sliderWidth);
   608          }
   609  
   610          if ( _.options.responsive &&
   611              _.options.responsive.length &&
   612              _.options.responsive !== null) {
   613  
   614              targetBreakpoint = null;
   615  
   616              for (breakpoint in _.breakpoints) {
   617                  if (_.breakpoints.hasOwnProperty(breakpoint)) {
   618                      if (_.originalSettings.mobileFirst === false) {
   619                          if (respondToWidth < _.breakpoints[breakpoint]) {
   620                              targetBreakpoint = _.breakpoints[breakpoint];
   621                          }
   622                      } else {
   623                          if (respondToWidth > _.breakpoints[breakpoint]) {
   624                              targetBreakpoint = _.breakpoints[breakpoint];
   625                          }
   626                      }
   627                  }
   628              }
   629  
   630              if (targetBreakpoint !== null) {
   631                  if (_.activeBreakpoint !== null) {
   632                      if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
   633                          _.activeBreakpoint =
   634                              targetBreakpoint;
   635                          if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
   636                              _.unslick(targetBreakpoint);
   637                          } else {
   638                              _.options = $.extend({}, _.originalSettings,
   639                                  _.breakpointSettings[
   640                                      targetBreakpoint]);
   641                              if (initial === true) {
   642                                  _.currentSlide = _.options.initialSlide;
   643                              }
   644                              _.refresh(initial);
   645                          }
   646                          triggerBreakpoint = targetBreakpoint;
   647                      }
   648                  } else {
   649                      _.activeBreakpoint = targetBreakpoint;
   650                      if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
   651                          _.unslick(targetBreakpoint);
   652                      } else {
   653                          _.options = $.extend({}, _.originalSettings,
   654                              _.breakpointSettings[
   655                                  targetBreakpoint]);
   656                          if (initial === true) {
   657                              _.currentSlide = _.options.initialSlide;
   658                          }
   659                          _.refresh(initial);
   660                      }
   661                      triggerBreakpoint = targetBreakpoint;
   662                  }
   663              } else {
   664                  if (_.activeBreakpoint !== null) {
   665                      _.activeBreakpoint = null;
   666                      _.options = _.originalSettings;
   667                      if (initial === true) {
   668                          _.currentSlide = _.options.initialSlide;
   669                      }
   670                      _.refresh(initial);
   671                      triggerBreakpoint = targetBreakpoint;
   672                  }
   673              }
   674  
   675              // only trigger breakpoints during an actual break. not on initialize.
   676              if( !initial && triggerBreakpoint !== false ) {
   677                  _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
   678              }
   679          }
   680  
   681      };
   682  
   683      Slick.prototype.changeSlide = function(event, dontAnimate) {
   684  
   685          var _ = this,
   686              $target = $(event.currentTarget),
   687              indexOffset, slideOffset, unevenOffset;
   688  
   689          // If target is a link, prevent default action.
   690          if($target.is('a')) {
   691              event.preventDefault();
   692          }
   693  
   694          // If target is not the <li> element (ie: a child), find the <li>.
   695          if(!$target.is('li')) {
   696              $target = $target.closest('li');
   697          }
   698  
   699          unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
   700          indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
   701  
   702          switch (event.data.message) {
   703  
   704              case 'previous':
   705                  slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
   706                  if (_.slideCount > _.options.slidesToShow) {
   707                      _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
   708                  }
   709                  break;
   710  
   711              case 'next':
   712                  slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
   713                  if (_.slideCount > _.options.slidesToShow) {
   714                      _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
   715                  }
   716                  break;
   717  
   718              case 'index':
   719                  var index = event.data.index === 0 ? 0 :
   720                      event.data.index || $target.index() * _.options.slidesToScroll;
   721  
   722                  _.slideHandler(_.checkNavigable(index), false, dontAnimate);
   723                  $target.children().trigger('focus');
   724                  break;
   725  
   726              default:
   727                  return;
   728          }
   729  
   730      };
   731  
   732      Slick.prototype.checkNavigable = function(index) {
   733  
   734          var _ = this,
   735              navigables, prevNavigable;
   736  
   737          navigables = _.getNavigableIndexes();
   738          prevNavigable = 0;
   739          if (index > navigables[navigables.length - 1]) {
   740              index = navigables[navigables.length - 1];
   741          } else {
   742              for (var n in navigables) {
   743                  if (index < navigables[n]) {
   744                      index = prevNavigable;
   745                      break;
   746                  }
   747                  prevNavigable = navigables[n];
   748              }
   749          }
   750  
   751          return index;
   752      };
   753  
   754      Slick.prototype.cleanUpEvents = function() {
   755  
   756          var _ = this;
   757  
   758          if (_.options.dots && _.$dots !== null) {
   759  
   760              $('li', _.$dots)
   761                  .off('click.slick', _.changeSlide)
   762                  .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
   763                  .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
   764  
   765              if (_.options.accessibility === true) {
   766                  _.$dots.off('keydown.slick', _.keyHandler);
   767              }
   768          }
   769  
   770          _.$slider.off('focus.slick blur.slick');
   771  
   772          if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
   773              _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
   774              _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
   775  
   776              if (_.options.accessibility === true) {
   777                  _.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler);
   778                  _.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler);
   779              }
   780          }
   781  
   782          _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
   783          _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
   784          _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
   785          _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
   786  
   787          _.$list.off('click.slick', _.clickHandler);
   788  
   789          $(document).off(_.visibilityChange, _.visibility);
   790  
   791          _.cleanUpSlideEvents();
   792  
   793          if (_.options.accessibility === true) {
   794              _.$list.off('keydown.slick', _.keyHandler);
   795          }
   796  
   797          if (_.options.focusOnSelect === true) {
   798              $(_.$slideTrack).children().off('click.slick', _.selectHandler);
   799          }
   800  
   801          $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
   802  
   803          $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
   804  
   805          $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
   806  
   807          $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
   808  
   809      };
   810  
   811      Slick.prototype.cleanUpSlideEvents = function() {
   812  
   813          var _ = this;
   814  
   815          _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
   816          _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
   817  
   818      };
   819  
   820      Slick.prototype.cleanUpRows = function() {
   821  
   822          var _ = this, originalSlides;
   823  
   824          if(_.options.rows > 1) {
   825              originalSlides = _.$slides.children().children();
   826              originalSlides.removeAttr('style');
   827              _.$slider.empty().append(originalSlides);
   828          }
   829  
   830      };
   831  
   832      Slick.prototype.clickHandler = function(event) {
   833  
   834          var _ = this;
   835  
   836          if (_.shouldClick === false) {
   837              event.stopImmediatePropagation();
   838              event.stopPropagation();
   839              event.preventDefault();
   840          }
   841  
   842      };
   843  
   844      Slick.prototype.destroy = function(refresh) {
   845  
   846          var _ = this;
   847  
   848          _.autoPlayClear();
   849  
   850          _.touchObject = {};
   851  
   852          _.cleanUpEvents();
   853  
   854          $('.slick-cloned', _.$slider).detach();
   855  
   856          if (_.$dots) {
   857              _.$dots.remove();
   858          }
   859  
   860          if ( _.$prevArrow && _.$prevArrow.length ) {
   861  
   862              _.$prevArrow
   863                  .removeClass('slick-disabled slick-arrow slick-hidden')
   864                  .removeAttr('aria-hidden aria-disabled tabindex')
   865                  .css('display','');
   866  
   867              if ( _.htmlExpr.test( _.options.prevArrow )) {
   868                  _.$prevArrow.remove();
   869              }
   870          }
   871  
   872          if ( _.$nextArrow && _.$nextArrow.length ) {
   873  
   874              _.$nextArrow
   875                  .removeClass('slick-disabled slick-arrow slick-hidden')
   876                  .removeAttr('aria-hidden aria-disabled tabindex')
   877                  .css('display','');
   878  
   879              if ( _.htmlExpr.test( _.options.nextArrow )) {
   880                  _.$nextArrow.remove();
   881              }
   882          }
   883  
   884  
   885          if (_.$slides) {
   886  
   887              _.$slides
   888                  .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
   889                  .removeAttr('aria-hidden')
   890                  .removeAttr('data-slick-index')
   891                  .each(function(){
   892                      $(this).attr('style', $(this).data('originalStyling'));
   893                  });
   894  
   895              _.$slideTrack.children(this.options.slide).detach();
   896  
   897              _.$slideTrack.detach();
   898  
   899              _.$list.detach();
   900  
   901              _.$slider.append(_.$slides);
   902          }
   903  
   904          _.cleanUpRows();
   905  
   906          _.$slider.removeClass('slick-slider');
   907          _.$slider.removeClass('slick-initialized');
   908          _.$slider.removeClass('slick-dotted');
   909  
   910          _.unslicked = true;
   911  
   912          if(!refresh) {
   913              _.$slider.trigger('destroy', [_]);
   914          }
   915  
   916      };
   917  
   918      Slick.prototype.disableTransition = function(slide) {
   919  
   920          var _ = this,
   921              transition = {};
   922  
   923          transition[_.transitionType] = '';
   924  
   925          if (_.options.fade === false) {
   926              _.$slideTrack.css(transition);
   927          } else {
   928              _.$slides.eq(slide).css(transition);
   929          }
   930  
   931      };
   932  
   933      Slick.prototype.fadeSlide = function(slideIndex, callback) {
   934  
   935          var _ = this;
   936  
   937          if (_.cssTransitions === false) {
   938  
   939              _.$slides.eq(slideIndex).css({
   940                  zIndex: _.options.zIndex
   941              });
   942  
   943              _.$slides.eq(slideIndex).animate({
   944                  opacity: 1
   945              }, _.options.speed, _.options.easing, callback);
   946  
   947          } else {
   948  
   949              _.applyTransition(slideIndex);
   950  
   951              _.$slides.eq(slideIndex).css({
   952                  opacity: 1,
   953                  zIndex: _.options.zIndex
   954              });
   955  
   956              if (callback) {
   957                  setTimeout(function() {
   958  
   959                      _.disableTransition(slideIndex);
   960  
   961                      callback.call();
   962                  }, _.options.speed);
   963              }
   964  
   965          }
   966  
   967      };
   968  
   969      Slick.prototype.fadeSlideOut = function(slideIndex) {
   970  
   971          var _ = this;
   972  
   973          if (_.cssTransitions === false) {
   974  
   975              _.$slides.eq(slideIndex).animate({
   976                  opacity: 0,
   977                  zIndex: _.options.zIndex - 2
   978              }, _.options.speed, _.options.easing);
   979  
   980          } else {
   981  
   982              _.applyTransition(slideIndex);
   983  
   984              _.$slides.eq(slideIndex).css({
   985                  opacity: 0,
   986                  zIndex: _.options.zIndex - 2
   987              });
   988  
   989          }
   990  
   991      };
   992  
   993      Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {
   994  
   995          var _ = this;
   996  
   997          if (filter !== null) {
   998  
   999              _.$slidesCache = _.$slides;
  1000  
  1001              _.unload();
  1002  
  1003              _.$slideTrack.children(this.options.slide).detach();
  1004  
  1005              _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
  1006  
  1007              _.reinit();
  1008  
  1009          }
  1010  
  1011      };
  1012  
  1013      Slick.prototype.focusHandler = function() {
  1014  
  1015          var _ = this;
  1016  
  1017          _.$slider
  1018              .off('focus.slick blur.slick')
  1019              .on('focus.slick blur.slick', '*', function(event) {
  1020  
  1021              event.stopImmediatePropagation();
  1022              var $sf = $(this);
  1023  
  1024              setTimeout(function() {
  1025  
  1026                  if( _.options.pauseOnFocus ) {
  1027                      _.focussed = $sf.is(':focus');
  1028                      _.autoPlay();
  1029                  }
  1030  
  1031              }, 0);
  1032  
  1033          });
  1034      };
  1035  
  1036      Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {
  1037  
  1038          var _ = this;
  1039          return _.currentSlide;
  1040  
  1041      };
  1042  
  1043      Slick.prototype.getDotCount = function() {
  1044  
  1045          var _ = this;
  1046  
  1047          var breakPoint = 0;
  1048          var counter = 0;
  1049          var pagerQty = 0;
  1050  
  1051          if (_.options.infinite === true) {
  1052              if (_.slideCount <= _.options.slidesToShow) {
  1053                   ++pagerQty;
  1054              } else {
  1055                  while (breakPoint < _.slideCount) {
  1056                      ++pagerQty;
  1057                      breakPoint = counter + _.options.slidesToScroll;
  1058                      counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
  1059                  }
  1060              }
  1061          } else if (_.options.centerMode === true) {
  1062              pagerQty = _.slideCount;
  1063          } else if(!_.options.asNavFor) {
  1064              pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);
  1065          }else {
  1066              while (breakPoint < _.slideCount) {
  1067                  ++pagerQty;
  1068                  breakPoint = counter + _.options.slidesToScroll;
  1069                  counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
  1070              }
  1071          }
  1072  
  1073          return pagerQty - 1;
  1074  
  1075      };
  1076  
  1077      Slick.prototype.getLeft = function(slideIndex) {
  1078  
  1079          var _ = this,
  1080              targetLeft,
  1081              verticalHeight,
  1082              verticalOffset = 0,
  1083              targetSlide,
  1084              coef;
  1085  
  1086          _.slideOffset = 0;
  1087          verticalHeight = _.$slides.first().outerHeight(true);
  1088  
  1089          if (_.options.infinite === true) {
  1090              if (_.slideCount > _.options.slidesToShow) {
  1091                  _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
  1092                  coef = -1
  1093  
  1094                  if (_.options.vertical === true && _.options.centerMode === true) {
  1095                      if (_.options.slidesToShow === 2) {
  1096                          coef = -1.5;
  1097                      } else if (_.options.slidesToShow === 1) {
  1098                          coef = -2
  1099                      }
  1100                  }
  1101                  verticalOffset = (verticalHeight * _.options.slidesToShow) * coef;
  1102              }
  1103              if (_.slideCount % _.options.slidesToScroll !== 0) {
  1104                  if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
  1105                      if (slideIndex > _.slideCount) {
  1106                          _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
  1107                          verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
  1108                      } else {
  1109                          _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
  1110                          verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
  1111                      }
  1112                  }
  1113              }
  1114          } else {
  1115              if (slideIndex + _.options.slidesToShow > _.slideCount) {
  1116                  _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
  1117                  verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
  1118              }
  1119          }
  1120  
  1121          if (_.slideCount <= _.options.slidesToShow) {
  1122              _.slideOffset = 0;
  1123              verticalOffset = 0;
  1124          }
  1125  
  1126          if (_.options.centerMode === true && _.slideCount <= _.options.slidesToShow) {
  1127              _.slideOffset = ((_.slideWidth * Math.floor(_.options.slidesToShow)) / 2) - ((_.slideWidth * _.slideCount) / 2);
  1128          } else if (_.options.centerMode === true && _.options.infinite === true) {
  1129              _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
  1130          } else if (_.options.centerMode === true) {
  1131              _.slideOffset = 0;
  1132              _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
  1133          }
  1134  
  1135          if (_.options.vertical === false) {
  1136              targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
  1137          } else {
  1138              targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
  1139          }
  1140  
  1141          if (_.options.variableWidth === true) {
  1142  
  1143              if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
  1144                  targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
  1145              } else {
  1146                  targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
  1147              }
  1148  
  1149              if (_.options.rtl === true) {
  1150                  if (targetSlide[0]) {
  1151                      targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
  1152                  } else {
  1153                      targetLeft =  0;
  1154                  }
  1155              } else {
  1156                  targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
  1157              }
  1158  
  1159              if (_.options.centerMode === true) {
  1160                  if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
  1161                      targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
  1162                  } else {
  1163                      targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
  1164                  }
  1165  
  1166                  if (_.options.rtl === true) {
  1167                      if (targetSlide[0]) {
  1168                          targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
  1169                      } else {
  1170                          targetLeft =  0;
  1171                      }
  1172                  } else {
  1173                      targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
  1174                  }
  1175  
  1176                  targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
  1177              }
  1178          }
  1179  
  1180          return targetLeft;
  1181  
  1182      };
  1183  
  1184      Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
  1185  
  1186          var _ = this;
  1187  
  1188          return _.options[option];
  1189  
  1190      };
  1191  
  1192      Slick.prototype.getNavigableIndexes = function() {
  1193  
  1194          var _ = this,
  1195              breakPoint = 0,
  1196              counter = 0,
  1197              indexes = [],
  1198              max;
  1199  
  1200          if (_.options.infinite === false) {
  1201              max = _.slideCount;
  1202          } else {
  1203              breakPoint = _.options.slidesToScroll * -1;
  1204              counter = _.options.slidesToScroll * -1;
  1205              max = _.slideCount * 2;
  1206          }
  1207  
  1208          while (breakPoint < max) {
  1209              indexes.push(breakPoint);
  1210              breakPoint = counter + _.options.slidesToScroll;
  1211              counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
  1212          }
  1213  
  1214          return indexes;
  1215  
  1216      };
  1217  
  1218      Slick.prototype.getSlick = function() {
  1219  
  1220          return this;
  1221  
  1222      };
  1223  
  1224      Slick.prototype.getSlideCount = function() {
  1225  
  1226          var _ = this,
  1227              slidesTraversed, swipedSlide, centerOffset;
  1228  
  1229          centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
  1230  
  1231          if (_.options.swipeToSlide === true) {
  1232              _.$slideTrack.find('.slick-slide').each(function(index, slide) {
  1233                  if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
  1234                      swipedSlide = slide;
  1235                      return false;
  1236                  }
  1237              });
  1238  
  1239              slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
  1240  
  1241              return slidesTraversed;
  1242  
  1243          } else {
  1244              return _.options.slidesToScroll;
  1245          }
  1246  
  1247      };
  1248  
  1249      Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
  1250  
  1251          var _ = this;
  1252  
  1253          _.changeSlide({
  1254              data: {
  1255                  message: 'index',
  1256                  index: parseInt(slide)
  1257              }
  1258          }, dontAnimate);
  1259  
  1260      };
  1261  
  1262      Slick.prototype.init = function(creation) {
  1263  
  1264          var _ = this;
  1265  
  1266          if (!$(_.$slider).hasClass('slick-initialized')) {
  1267  
  1268              $(_.$slider).addClass('slick-initialized');
  1269  
  1270              _.buildRows();
  1271              _.buildOut();
  1272              _.setProps();
  1273              _.startLoad();
  1274              _.loadSlider();
  1275              _.initializeEvents();
  1276              _.updateArrows();
  1277              _.updateDots();
  1278              _.checkResponsive(true);
  1279              _.focusHandler();
  1280  
  1281          }
  1282  
  1283          if (creation) {
  1284              _.$slider.trigger('init', [_]);
  1285          }
  1286  
  1287          if (_.options.accessibility === true) {
  1288              _.initADA();
  1289          }
  1290  
  1291          if ( _.options.autoplay ) {
  1292  
  1293              _.paused = false;
  1294              _.autoPlay();
  1295  
  1296          }
  1297  
  1298      };
  1299  
  1300      Slick.prototype.initADA = function() {
  1301          var _ = this,
  1302                  numDotGroups = Math.ceil(_.slideCount / _.options.slidesToShow),
  1303                  tabControlIndexes = _.getNavigableIndexes().filter(function(val) {
  1304                      return (val >= 0) && (val < _.slideCount);
  1305                  });
  1306  
  1307          _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({
  1308              'aria-hidden': 'true',
  1309              'tabindex': '-1'
  1310          }).find('a, input, button, select').attr({
  1311              'tabindex': '-1'
  1312          });
  1313  
  1314          if (_.$dots !== null) {
  1315              _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {
  1316                  var slideControlIndex = tabControlIndexes.indexOf(i);
  1317  
  1318                  $(this).attr({
  1319                      'role': 'tabpanel',
  1320                      'id': 'slick-slide' + _.instanceUid + i,
  1321                      'tabindex': -1
  1322                  });
  1323  
  1324                  if (slideControlIndex !== -1) {
  1325                      $(this).attr({
  1326                          'aria-describedby': 'slick-slide-control' + _.instanceUid + slideControlIndex
  1327                      });
  1328                  }
  1329              });
  1330  
  1331              _.$dots.attr('role', 'tablist').find('li').each(function(i) {
  1332                  var mappedSlideIndex = tabControlIndexes[i];
  1333  
  1334                  $(this).attr({
  1335                      'role': 'presentation'
  1336                  });
  1337  
  1338                  $(this).find('button').first().attr({
  1339                      'role': 'tab',
  1340                      'id': 'slick-slide-control' + _.instanceUid + i,
  1341                      'aria-controls': 'slick-slide' + _.instanceUid + mappedSlideIndex,
  1342                      'aria-label': (i + 1) + ' of ' + numDotGroups,
  1343                      'aria-selected': null,
  1344                      'tabindex': '-1'
  1345                  });
  1346  
  1347              }).eq(_.currentSlide).find('button').attr({
  1348                  'aria-selected': 'true',
  1349                  'tabindex': '0'
  1350              }).end();
  1351          }
  1352  
  1353          for (var i=_.currentSlide, max=i+_.options.slidesToShow; i < max; i++) {
  1354              _.$slides.eq(i).attr('tabindex', 0);
  1355          }
  1356  
  1357          _.activateADA();
  1358  
  1359      };
  1360  
  1361      Slick.prototype.initArrowEvents = function() {
  1362  
  1363          var _ = this;
  1364  
  1365          if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
  1366              _.$prevArrow
  1367                 .off('click.slick')
  1368                 .on('click.slick', {
  1369                      message: 'previous'
  1370                 }, _.changeSlide);
  1371              _.$nextArrow
  1372                 .off('click.slick')
  1373                 .on('click.slick', {
  1374                      message: 'next'
  1375                 }, _.changeSlide);
  1376  
  1377              if (_.options.accessibility === true) {
  1378                  _.$prevArrow.on('keydown.slick', _.keyHandler);
  1379                  _.$nextArrow.on('keydown.slick', _.keyHandler);
  1380              }
  1381          }
  1382  
  1383      };
  1384  
  1385      Slick.prototype.initDotEvents = function() {
  1386  
  1387          var _ = this;
  1388  
  1389          if (_.options.dots === true) {
  1390              $('li', _.$dots).on('click.slick', {
  1391                  message: 'index'
  1392              }, _.changeSlide);
  1393  
  1394              if (_.options.accessibility === true) {
  1395                  _.$dots.on('keydown.slick', _.keyHandler);
  1396              }
  1397          }
  1398  
  1399          if ( _.options.dots === true && _.options.pauseOnDotsHover === true ) {
  1400  
  1401              $('li', _.$dots)
  1402                  .on('mouseenter.slick', $.proxy(_.interrupt, _, true))
  1403                  .on('mouseleave.slick', $.proxy(_.interrupt, _, false));
  1404  
  1405          }
  1406  
  1407      };
  1408  
  1409      Slick.prototype.initSlideEvents = function() {
  1410  
  1411          var _ = this;
  1412  
  1413          if ( _.options.pauseOnHover ) {
  1414  
  1415              _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));
  1416              _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));
  1417  
  1418          }
  1419  
  1420      };
  1421  
  1422      Slick.prototype.initializeEvents = function() {
  1423  
  1424          var _ = this;
  1425  
  1426          _.initArrowEvents();
  1427  
  1428          _.initDotEvents();
  1429          _.initSlideEvents();
  1430  
  1431          _.$list.on('touchstart.slick mousedown.slick', {
  1432              action: 'start'
  1433          }, _.swipeHandler);
  1434          _.$list.on('touchmove.slick mousemove.slick', {
  1435              action: 'move'
  1436          }, _.swipeHandler);
  1437          _.$list.on('touchend.slick mouseup.slick', {
  1438              action: 'end'
  1439          }, _.swipeHandler);
  1440          _.$list.on('touchcancel.slick mouseleave.slick', {
  1441              action: 'end'
  1442          }, _.swipeHandler);
  1443  
  1444          _.$list.on('click.slick', _.clickHandler);
  1445  
  1446          $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
  1447  
  1448          if (_.options.accessibility === true) {
  1449              _.$list.on('keydown.slick', _.keyHandler);
  1450          }
  1451  
  1452          if (_.options.focusOnSelect === true) {
  1453              $(_.$slideTrack).children().on('click.slick', _.selectHandler);
  1454          }
  1455  
  1456          $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
  1457  
  1458          $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
  1459  
  1460          $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
  1461  
  1462          $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
  1463          $(_.setPosition);
  1464  
  1465      };
  1466  
  1467      Slick.prototype.initUI = function() {
  1468  
  1469          var _ = this;
  1470  
  1471          if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
  1472  
  1473              _.$prevArrow.show();
  1474              _.$nextArrow.show();
  1475  
  1476          }
  1477  
  1478          if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
  1479  
  1480              _.$dots.show();
  1481  
  1482          }
  1483  
  1484      };
  1485  
  1486      Slick.prototype.keyHandler = function(event) {
  1487  
  1488          var _ = this;
  1489           //Dont slide if the cursor is inside the form fields and arrow keys are pressed
  1490          if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
  1491              if (event.keyCode === 37 && _.options.accessibility === true) {
  1492                  _.changeSlide({
  1493                      data: {
  1494                          message: _.options.rtl === true ? 'next' :  'previous'
  1495                      }
  1496                  });
  1497              } else if (event.keyCode === 39 && _.options.accessibility === true) {
  1498                  _.changeSlide({
  1499                      data: {
  1500                          message: _.options.rtl === true ? 'previous' : 'next'
  1501                      }
  1502                  });
  1503              }
  1504          }
  1505  
  1506      };
  1507  
  1508      Slick.prototype.lazyLoad = function() {
  1509  
  1510          var _ = this,
  1511              loadRange, cloneRange, rangeStart, rangeEnd;
  1512  
  1513          function loadImages(imagesScope) {
  1514  
  1515              $('img[data-lazy]', imagesScope).each(function() {
  1516  
  1517                  var image = $(this),
  1518                      imageSource = $(this).attr('data-lazy'),
  1519                      imageSrcSet = $(this).attr('data-srcset'),
  1520                      imageSizes  = $(this).attr('data-sizes') || _.$slider.attr('data-sizes'),
  1521                      imageToLoad = document.createElement('img');
  1522  
  1523                  imageToLoad.onload = function() {
  1524  
  1525                      image
  1526                          .animate({ opacity: 0 }, 100, function() {
  1527  
  1528                              if (imageSrcSet) {
  1529                                  image
  1530                                      .attr('srcset', imageSrcSet );
  1531  
  1532                                  if (imageSizes) {
  1533                                      image
  1534                                          .attr('sizes', imageSizes );
  1535                                  }
  1536                              }
  1537  
  1538                              image
  1539                                  .attr('src', imageSource)
  1540                                  .animate({ opacity: 1 }, 200, function() {
  1541                                      image
  1542                                          .removeAttr('data-lazy data-srcset data-sizes')
  1543                                          .removeClass('slick-loading');
  1544                                  });
  1545                              _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
  1546                          });
  1547  
  1548                  };
  1549  
  1550                  imageToLoad.onerror = function() {
  1551  
  1552                      image
  1553                          .removeAttr( 'data-lazy' )
  1554                          .removeClass( 'slick-loading' )
  1555                          .addClass( 'slick-lazyload-error' );
  1556  
  1557                      _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
  1558  
  1559                  };
  1560  
  1561                  imageToLoad.src = imageSource;
  1562  
  1563              });
  1564  
  1565          }
  1566  
  1567          if (_.options.centerMode === true) {
  1568              if (_.options.infinite === true) {
  1569                  rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
  1570                  rangeEnd = rangeStart + _.options.slidesToShow + 2;
  1571              } else {
  1572                  rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
  1573                  rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
  1574              }
  1575          } else {
  1576              rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
  1577              rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
  1578              if (_.options.fade === true) {
  1579                  if (rangeStart > 0) rangeStart--;
  1580                  if (rangeEnd <= _.slideCount) rangeEnd++;
  1581              }
  1582          }
  1583  
  1584          loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
  1585  
  1586          if (_.options.lazyLoad === 'anticipated') {
  1587              var prevSlide = rangeStart - 1,
  1588                  nextSlide = rangeEnd,
  1589                  $slides = _.$slider.find('.slick-slide');
  1590  
  1591              for (var i = 0; i < _.options.slidesToScroll; i++) {
  1592                  if (prevSlide < 0) prevSlide = _.slideCount - 1;
  1593                  loadRange = loadRange.add($slides.eq(prevSlide));
  1594                  loadRange = loadRange.add($slides.eq(nextSlide));
  1595                  prevSlide--;
  1596                  nextSlide++;
  1597              }
  1598          }
  1599  
  1600          loadImages(loadRange);
  1601  
  1602          if (_.slideCount <= _.options.slidesToShow) {
  1603              cloneRange = _.$slider.find('.slick-slide');
  1604              loadImages(cloneRange);
  1605          } else
  1606          if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
  1607              cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
  1608              loadImages(cloneRange);
  1609          } else if (_.currentSlide === 0) {
  1610              cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
  1611              loadImages(cloneRange);
  1612          }
  1613  
  1614      };
  1615  
  1616      Slick.prototype.loadSlider = function() {
  1617  
  1618          var _ = this;
  1619  
  1620          _.setPosition();
  1621  
  1622          _.$slideTrack.css({
  1623              opacity: 1
  1624          });
  1625  
  1626          _.$slider.removeClass('slick-loading');
  1627  
  1628          _.initUI();
  1629  
  1630          if (_.options.lazyLoad === 'progressive') {
  1631              _.progressiveLazyLoad();
  1632          }
  1633  
  1634      };
  1635  
  1636      Slick.prototype.next = Slick.prototype.slickNext = function() {
  1637  
  1638          var _ = this;
  1639  
  1640          _.changeSlide({
  1641              data: {
  1642                  message: 'next'
  1643              }
  1644          });
  1645  
  1646      };
  1647  
  1648      Slick.prototype.orientationChange = function() {
  1649  
  1650          var _ = this;
  1651  
  1652          _.checkResponsive();
  1653          _.setPosition();
  1654  
  1655      };
  1656  
  1657      Slick.prototype.pause = Slick.prototype.slickPause = function() {
  1658  
  1659          var _ = this;
  1660  
  1661          _.autoPlayClear();
  1662          _.paused = true;
  1663  
  1664      };
  1665  
  1666      Slick.prototype.play = Slick.prototype.slickPlay = function() {
  1667  
  1668          var _ = this;
  1669  
  1670          _.autoPlay();
  1671          _.options.autoplay = true;
  1672          _.paused = false;
  1673          _.focussed = false;
  1674          _.interrupted = false;
  1675  
  1676      };
  1677  
  1678      Slick.prototype.postSlide = function(index) {
  1679  
  1680          var _ = this;
  1681  
  1682          if( !_.unslicked ) {
  1683  
  1684              _.$slider.trigger('afterChange', [_, index]);
  1685  
  1686              _.animating = false;
  1687  
  1688              if (_.slideCount > _.options.slidesToShow) {
  1689                  _.setPosition();
  1690              }
  1691  
  1692              _.swipeLeft = null;
  1693  
  1694              if ( _.options.autoplay ) {
  1695                  _.autoPlay();
  1696              }
  1697  
  1698              if (_.options.accessibility === true) {
  1699                  _.initADA();
  1700                  
  1701                  if (_.options.focusOnChange) {
  1702                      var $currentSlide = $(_.$slides.get(_.currentSlide));
  1703                      $currentSlide.attr('tabindex', 0).focus();
  1704                  }
  1705              }
  1706  
  1707          }
  1708  
  1709      };
  1710  
  1711      Slick.prototype.prev = Slick.prototype.slickPrev = function() {
  1712  
  1713          var _ = this;
  1714  
  1715          _.changeSlide({
  1716              data: {
  1717                  message: 'previous'
  1718              }
  1719          });
  1720  
  1721      };
  1722  
  1723      Slick.prototype.preventDefault = function(event) {
  1724  
  1725          event.preventDefault();
  1726  
  1727      };
  1728  
  1729      Slick.prototype.progressiveLazyLoad = function( tryCount ) {
  1730  
  1731          tryCount = tryCount || 1;
  1732  
  1733          var _ = this,
  1734              $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
  1735              image,
  1736              imageSource,
  1737              imageSrcSet,
  1738              imageSizes,
  1739              imageToLoad;
  1740  
  1741          if ( $imgsToLoad.length ) {
  1742  
  1743              image = $imgsToLoad.first();
  1744              imageSource = image.attr('data-lazy');
  1745              imageSrcSet = image.attr('data-srcset');
  1746              imageSizes  = image.attr('data-sizes') || _.$slider.attr('data-sizes');
  1747              imageToLoad = document.createElement('img');
  1748  
  1749              imageToLoad.onload = function() {
  1750  
  1751                  if (imageSrcSet) {
  1752                      image
  1753                          .attr('srcset', imageSrcSet );
  1754  
  1755                      if (imageSizes) {
  1756                          image
  1757                              .attr('sizes', imageSizes );
  1758                      }
  1759                  }
  1760  
  1761                  image
  1762                      .attr( 'src', imageSource )
  1763                      .removeAttr('data-lazy data-srcset data-sizes')
  1764                      .removeClass('slick-loading');
  1765  
  1766                  if ( _.options.adaptiveHeight === true ) {
  1767                      _.setPosition();
  1768                  }
  1769  
  1770                  _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
  1771                  _.progressiveLazyLoad();
  1772  
  1773              };
  1774  
  1775              imageToLoad.onerror = function() {
  1776  
  1777                  if ( tryCount < 3 ) {
  1778  
  1779                      /**
  1780                       * try to load the image 3 times,
  1781                       * leave a slight delay so we don't get
  1782                       * servers blocking the request.
  1783                       */
  1784                      setTimeout( function() {
  1785                          _.progressiveLazyLoad( tryCount + 1 );
  1786                      }, 500 );
  1787  
  1788                  } else {
  1789  
  1790                      image
  1791                          .removeAttr( 'data-lazy' )
  1792                          .removeClass( 'slick-loading' )
  1793                          .addClass( 'slick-lazyload-error' );
  1794  
  1795                      _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
  1796  
  1797                      _.progressiveLazyLoad();
  1798  
  1799                  }
  1800  
  1801              };
  1802  
  1803              imageToLoad.src = imageSource;
  1804  
  1805          } else {
  1806  
  1807              _.$slider.trigger('allImagesLoaded', [ _ ]);
  1808  
  1809          }
  1810  
  1811      };
  1812  
  1813      Slick.prototype.refresh = function( initializing ) {
  1814  
  1815          var _ = this, currentSlide, lastVisibleIndex;
  1816  
  1817          lastVisibleIndex = _.slideCount - _.options.slidesToShow;
  1818  
  1819          // in non-infinite sliders, we don't want to go past the
  1820          // last visible index.
  1821          if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
  1822              _.currentSlide = lastVisibleIndex;
  1823          }
  1824  
  1825          // if less slides than to show, go to start.
  1826          if ( _.slideCount <= _.options.slidesToShow ) {
  1827              _.currentSlide = 0;
  1828  
  1829          }
  1830  
  1831          currentSlide = _.currentSlide;
  1832  
  1833          _.destroy(true);
  1834  
  1835          $.extend(_, _.initials, { currentSlide: currentSlide });
  1836  
  1837          _.init();
  1838  
  1839          if( !initializing ) {
  1840  
  1841              _.changeSlide({
  1842                  data: {
  1843                      message: 'index',
  1844                      index: currentSlide
  1845                  }
  1846              }, false);
  1847  
  1848          }
  1849  
  1850      };
  1851  
  1852      Slick.prototype.registerBreakpoints = function() {
  1853  
  1854          var _ = this, breakpoint, currentBreakpoint, l,
  1855              responsiveSettings = _.options.responsive || null;
  1856  
  1857          if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
  1858  
  1859              _.respondTo = _.options.respondTo || 'window';
  1860  
  1861              for ( breakpoint in responsiveSettings ) {
  1862  
  1863                  l = _.breakpoints.length-1;
  1864  
  1865                  if (responsiveSettings.hasOwnProperty(breakpoint)) {
  1866                      currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
  1867  
  1868                      // loop through the breakpoints and cut out any existing
  1869                      // ones with the same breakpoint number, we don't want dupes.
  1870                      while( l >= 0 ) {
  1871                          if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
  1872                              _.breakpoints.splice(l,1);
  1873                          }
  1874                          l--;
  1875                      }
  1876  
  1877                      _.breakpoints.push(currentBreakpoint);
  1878                      _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
  1879  
  1880                  }
  1881  
  1882              }
  1883  
  1884              _.breakpoints.sort(function(a, b) {
  1885                  return ( _.options.mobileFirst ) ? a-b : b-a;
  1886              });
  1887  
  1888          }
  1889  
  1890      };
  1891  
  1892      Slick.prototype.reinit = function() {
  1893  
  1894          var _ = this;
  1895  
  1896          _.$slides =
  1897              _.$slideTrack
  1898                  .children(_.options.slide)
  1899                  .addClass('slick-slide');
  1900  
  1901          _.slideCount = _.$slides.length;
  1902  
  1903          if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
  1904              _.currentSlide = _.currentSlide - _.options.slidesToScroll;
  1905          }
  1906  
  1907          if (_.slideCount <= _.options.slidesToShow) {
  1908              _.currentSlide = 0;
  1909          }
  1910  
  1911          _.registerBreakpoints();
  1912  
  1913          _.setProps();
  1914          _.setupInfinite();
  1915          _.buildArrows();
  1916          _.updateArrows();
  1917          _.initArrowEvents();
  1918          _.buildDots();
  1919          _.updateDots();
  1920          _.initDotEvents();
  1921          _.cleanUpSlideEvents();
  1922          _.initSlideEvents();
  1923  
  1924          _.checkResponsive(false, true);
  1925  
  1926          if (_.options.focusOnSelect === true) {
  1927              $(_.$slideTrack).children().on('click.slick', _.selectHandler);
  1928          }
  1929  
  1930          _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
  1931  
  1932          _.setPosition();
  1933          _.focusHandler();
  1934  
  1935          _.paused = !_.options.autoplay;
  1936          _.autoPlay();
  1937  
  1938          _.$slider.trigger('reInit', [_]);
  1939  
  1940      };
  1941  
  1942      Slick.prototype.resize = function() {
  1943  
  1944          var _ = this;
  1945  
  1946          if ($(window).width() !== _.windowWidth) {
  1947              clearTimeout(_.windowDelay);
  1948              _.windowDelay = window.setTimeout(function() {
  1949                  _.windowWidth = $(window).width();
  1950                  _.checkResponsive();
  1951                  if( !_.unslicked ) { _.setPosition(); }
  1952              }, 50);
  1953          }
  1954      };
  1955  
  1956      Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
  1957  
  1958          var _ = this;
  1959  
  1960          if (typeof(index) === 'boolean') {
  1961              removeBefore = index;
  1962              index = removeBefore === true ? 0 : _.slideCount - 1;
  1963          } else {
  1964              index = removeBefore === true ? --index : index;
  1965          }
  1966  
  1967          if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
  1968              return false;
  1969          }
  1970  
  1971          _.unload();
  1972  
  1973          if (removeAll === true) {
  1974              _.$slideTrack.children().remove();
  1975          } else {
  1976              _.$slideTrack.children(this.options.slide).eq(index).remove();
  1977          }
  1978  
  1979          _.$slides = _.$slideTrack.children(this.options.slide);
  1980  
  1981          _.$slideTrack.children(this.options.slide).detach();
  1982  
  1983          _.$slideTrack.append(_.$slides);
  1984  
  1985          _.$slidesCache = _.$slides;
  1986  
  1987          _.reinit();
  1988  
  1989      };
  1990  
  1991      Slick.prototype.setCSS = function(position) {
  1992  
  1993          var _ = this,
  1994              positionProps = {},
  1995              x, y;
  1996  
  1997          if (_.options.rtl === true) {
  1998              position = -position;
  1999          }
  2000          x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
  2001          y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
  2002  
  2003          positionProps[_.positionProp] = position;
  2004  
  2005          if (_.transformsEnabled === false) {
  2006              _.$slideTrack.css(positionProps);
  2007          } else {
  2008              positionProps = {};
  2009              if (_.cssTransitions === false) {
  2010                  positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
  2011                  _.$slideTrack.css(positionProps);
  2012              } else {
  2013                  positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
  2014                  _.$slideTrack.css(positionProps);
  2015              }
  2016          }
  2017  
  2018      };
  2019  
  2020      Slick.prototype.setDimensions = function() {
  2021  
  2022          var _ = this;
  2023  
  2024          if (_.options.vertical === false) {
  2025              if (_.options.centerMode === true) {
  2026                  _.$list.css({
  2027                      padding: ('0px ' + _.options.centerPadding)
  2028                  });
  2029              }
  2030          } else {
  2031              _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
  2032              if (_.options.centerMode === true) {
  2033                  _.$list.css({
  2034                      padding: (_.options.centerPadding + ' 0px')
  2035                  });
  2036              }
  2037          }
  2038  
  2039          _.listWidth = _.$list.width();
  2040          _.listHeight = _.$list.height();
  2041  
  2042  
  2043          if (_.options.vertical === false && _.options.variableWidth === false) {
  2044              _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
  2045              _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
  2046  
  2047          } else if (_.options.variableWidth === true) {
  2048              _.$slideTrack.width(5000 * _.slideCount);
  2049          } else {
  2050              _.slideWidth = Math.ceil(_.listWidth);
  2051              _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
  2052          }
  2053  
  2054          var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
  2055          if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
  2056  
  2057      };
  2058  
  2059      Slick.prototype.setFade = function() {
  2060  
  2061          var _ = this,
  2062              targetLeft;
  2063  
  2064          _.$slides.each(function(index, element) {
  2065              targetLeft = (_.slideWidth * index) * -1;
  2066              if (_.options.rtl === true) {
  2067                  $(element).css({
  2068                      position: 'relative',
  2069                      right: targetLeft,
  2070                      top: 0,
  2071                      zIndex: _.options.zIndex - 2,
  2072                      opacity: 0
  2073                  });
  2074              } else {
  2075                  $(element).css({
  2076                      position: 'relative',
  2077                      left: targetLeft,
  2078                      top: 0,
  2079                      zIndex: _.options.zIndex - 2,
  2080                      opacity: 0
  2081                  });
  2082              }
  2083          });
  2084  
  2085          _.$slides.eq(_.currentSlide).css({
  2086              zIndex: _.options.zIndex - 1,
  2087              opacity: 1
  2088          });
  2089  
  2090      };
  2091  
  2092      Slick.prototype.setHeight = function() {
  2093  
  2094          var _ = this;
  2095  
  2096          if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
  2097              var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
  2098              _.$list.css('height', targetHeight);
  2099          }
  2100  
  2101      };
  2102  
  2103      Slick.prototype.setOption =
  2104      Slick.prototype.slickSetOption = function() {
  2105  
  2106          /**
  2107           * accepts arguments in format of:
  2108           *
  2109           *  - for changing a single option's value:
  2110           *     .slick("setOption", option, value, refresh )
  2111           *
  2112           *  - for changing a set of responsive options:
  2113           *     .slick("setOption", 'responsive', [{}, ...], refresh )
  2114           *
  2115           *  - for updating multiple values at once (not responsive)
  2116           *     .slick("setOption", { 'option': value, ... }, refresh )
  2117           */
  2118  
  2119          var _ = this, l, item, option, value, refresh = false, type;
  2120  
  2121          if( $.type( arguments[0] ) === 'object' ) {
  2122  
  2123              option =  arguments[0];
  2124              refresh = arguments[1];
  2125              type = 'multiple';
  2126  
  2127          } else if ( $.type( arguments[0] ) === 'string' ) {
  2128  
  2129              option =  arguments[0];
  2130              value = arguments[1];
  2131              refresh = arguments[2];
  2132  
  2133              if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
  2134  
  2135                  type = 'responsive';
  2136  
  2137              } else if ( typeof arguments[1] !== 'undefined' ) {
  2138  
  2139                  type = 'single';
  2140  
  2141              }
  2142  
  2143          }
  2144  
  2145          if ( type === 'single' ) {
  2146  
  2147              _.options[option] = value;
  2148  
  2149  
  2150          } else if ( type === 'multiple' ) {
  2151  
  2152              $.each( option , function( opt, val ) {
  2153  
  2154                  _.options[opt] = val;
  2155  
  2156              });
  2157  
  2158  
  2159          } else if ( type === 'responsive' ) {
  2160  
  2161              for ( item in value ) {
  2162  
  2163                  if( $.type( _.options.responsive ) !== 'array' ) {
  2164  
  2165                      _.options.responsive = [ value[item] ];
  2166  
  2167                  } else {
  2168  
  2169                      l = _.options.responsive.length-1;
  2170  
  2171                      // loop through the responsive object and splice out duplicates.
  2172                      while( l >= 0 ) {
  2173  
  2174                          if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
  2175  
  2176                              _.options.responsive.splice(l,1);
  2177  
  2178                          }
  2179  
  2180                          l--;
  2181  
  2182                      }
  2183  
  2184                      _.options.responsive.push( value[item] );
  2185  
  2186                  }
  2187  
  2188              }
  2189  
  2190          }
  2191  
  2192          if ( refresh ) {
  2193  
  2194              _.unload();
  2195              _.reinit();
  2196  
  2197          }
  2198  
  2199      };
  2200  
  2201      Slick.prototype.setPosition = function() {
  2202  
  2203          var _ = this;
  2204  
  2205          _.setDimensions();
  2206  
  2207          _.setHeight();
  2208  
  2209          if (_.options.fade === false) {
  2210              _.setCSS(_.getLeft(_.currentSlide));
  2211          } else {
  2212              _.setFade();
  2213          }
  2214  
  2215          _.$slider.trigger('setPosition', [_]);
  2216  
  2217      };
  2218  
  2219      Slick.prototype.setProps = function() {
  2220  
  2221          var _ = this,
  2222              bodyStyle = document.body.style;
  2223  
  2224          _.positionProp = _.options.vertical === true ? 'top' : 'left';
  2225  
  2226          if (_.positionProp === 'top') {
  2227              _.$slider.addClass('slick-vertical');
  2228          } else {
  2229              _.$slider.removeClass('slick-vertical');
  2230          }
  2231  
  2232          if (bodyStyle.WebkitTransition !== undefined ||
  2233              bodyStyle.MozTransition !== undefined ||
  2234              bodyStyle.msTransition !== undefined) {
  2235              if (_.options.useCSS === true) {
  2236                  _.cssTransitions = true;
  2237              }
  2238          }
  2239  
  2240          if ( _.options.fade ) {
  2241              if ( typeof _.options.zIndex === 'number' ) {
  2242                  if( _.options.zIndex < 3 ) {
  2243                      _.options.zIndex = 3;
  2244                  }
  2245              } else {
  2246                  _.options.zIndex = _.defaults.zIndex;
  2247              }
  2248          }
  2249  
  2250          if (bodyStyle.OTransform !== undefined) {
  2251              _.animType = 'OTransform';
  2252              _.transformType = '-o-transform';
  2253              _.transitionType = 'OTransition';
  2254              if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
  2255          }
  2256          if (bodyStyle.MozTransform !== undefined) {
  2257              _.animType = 'MozTransform';
  2258              _.transformType = '-moz-transform';
  2259              _.transitionType = 'MozTransition';
  2260              if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
  2261          }
  2262          if (bodyStyle.webkitTransform !== undefined) {
  2263              _.animType = 'webkitTransform';
  2264              _.transformType = '-webkit-transform';
  2265              _.transitionType = 'webkitTransition';
  2266              if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
  2267          }
  2268          if (bodyStyle.msTransform !== undefined) {
  2269              _.animType = 'msTransform';
  2270              _.transformType = '-ms-transform';
  2271              _.transitionType = 'msTransition';
  2272              if (bodyStyle.msTransform === undefined) _.animType = false;
  2273          }
  2274          if (bodyStyle.transform !== undefined && _.animType !== false) {
  2275              _.animType = 'transform';
  2276              _.transformType = 'transform';
  2277              _.transitionType = 'transition';
  2278          }
  2279          _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
  2280      };
  2281  
  2282  
  2283      Slick.prototype.setSlideClasses = function(index) {
  2284  
  2285          var _ = this,
  2286              centerOffset, allSlides, indexOffset, remainder;
  2287  
  2288          allSlides = _.$slider
  2289              .find('.slick-slide')
  2290              .removeClass('slick-active slick-center slick-current')
  2291              .attr('aria-hidden', 'true');
  2292  
  2293          _.$slides
  2294              .eq(index)
  2295              .addClass('slick-current');
  2296  
  2297          if (_.options.centerMode === true) {
  2298  
  2299              var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0;
  2300  
  2301              centerOffset = Math.floor(_.options.slidesToShow / 2);
  2302  
  2303              if (_.options.infinite === true) {
  2304  
  2305                  if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
  2306                      _.$slides
  2307                          .slice(index - centerOffset + evenCoef, index + centerOffset + 1)
  2308                          .addClass('slick-active')
  2309                          .attr('aria-hidden', 'false');
  2310  
  2311                  } else {
  2312  
  2313                      indexOffset = _.options.slidesToShow + index;
  2314                      allSlides
  2315                          .slice(indexOffset - centerOffset + 1 + evenCoef, indexOffset + centerOffset + 2)
  2316                          .addClass('slick-active')
  2317                          .attr('aria-hidden', 'false');
  2318  
  2319                  }
  2320  
  2321                  if (index === 0) {
  2322  
  2323                      allSlides
  2324                          .eq(allSlides.length - 1 - _.options.slidesToShow)
  2325                          .addClass('slick-center');
  2326  
  2327                  } else if (index === _.slideCount - 1) {
  2328  
  2329                      allSlides
  2330                          .eq(_.options.slidesToShow)
  2331                          .addClass('slick-center');
  2332  
  2333                  }
  2334  
  2335              }
  2336  
  2337              _.$slides
  2338                  .eq(index)
  2339                  .addClass('slick-center');
  2340  
  2341          } else {
  2342  
  2343              if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
  2344  
  2345                  _.$slides
  2346                      .slice(index, index + _.options.slidesToShow)
  2347                      .addClass('slick-active')
  2348                      .attr('aria-hidden', 'false');
  2349  
  2350              } else if (allSlides.length <= _.options.slidesToShow) {
  2351  
  2352                  allSlides
  2353                      .addClass('slick-active')
  2354                      .attr('aria-hidden', 'false');
  2355  
  2356              } else {
  2357  
  2358                  remainder = _.slideCount % _.options.slidesToShow;
  2359                  indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
  2360  
  2361                  if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
  2362  
  2363                      allSlides
  2364                          .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)
  2365                          .addClass('slick-active')
  2366                          .attr('aria-hidden', 'false');
  2367  
  2368                  } else {
  2369  
  2370                      allSlides
  2371                          .slice(indexOffset, indexOffset + _.options.slidesToShow)
  2372                          .addClass('slick-active')
  2373                          .attr('aria-hidden', 'false');
  2374  
  2375                  }
  2376  
  2377              }
  2378  
  2379          }
  2380  
  2381          if (_.options.lazyLoad === 'ondemand' || _.options.lazyLoad === 'anticipated') {
  2382              _.lazyLoad();
  2383          }
  2384      };
  2385  
  2386      Slick.prototype.setupInfinite = function() {
  2387  
  2388          var _ = this,
  2389              i, slideIndex, infiniteCount;
  2390  
  2391          if (_.options.fade === true) {
  2392              _.options.centerMode = false;
  2393          }
  2394  
  2395          if (_.options.infinite === true && _.options.fade === false) {
  2396  
  2397              slideIndex = null;
  2398  
  2399              if (_.slideCount > _.options.slidesToShow) {
  2400  
  2401                  if (_.options.centerMode === true) {
  2402                      infiniteCount = _.options.slidesToShow + 1;
  2403                  } else {
  2404                      infiniteCount = _.options.slidesToShow;
  2405                  }
  2406  
  2407                  for (i = _.slideCount; i > (_.slideCount -
  2408                          infiniteCount); i -= 1) {
  2409                      slideIndex = i - 1;
  2410                      $(_.$slides[slideIndex]).clone(true).attr('id', '')
  2411                          .attr('data-slick-index', slideIndex - _.slideCount)
  2412                          .prependTo(_.$slideTrack).addClass('slick-cloned');
  2413                  }
  2414                  for (i = 0; i < infiniteCount  + _.slideCount; i += 1) {
  2415                      slideIndex = i;
  2416                      $(_.$slides[slideIndex]).clone(true).attr('id', '')
  2417                          .attr('data-slick-index', slideIndex + _.slideCount)
  2418                          .appendTo(_.$slideTrack).addClass('slick-cloned');
  2419                  }
  2420                  _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
  2421                      $(this).attr('id', '');
  2422                  });
  2423  
  2424              }
  2425  
  2426          }
  2427  
  2428      };
  2429  
  2430      Slick.prototype.interrupt = function( toggle ) {
  2431  
  2432          var _ = this;
  2433  
  2434          if( !toggle ) {
  2435              _.autoPlay();
  2436          }
  2437          _.interrupted = toggle;
  2438  
  2439      };
  2440  
  2441      Slick.prototype.selectHandler = function(event) {
  2442  
  2443          var _ = this;
  2444  
  2445          var targetElement =
  2446              $(event.target).is('.slick-slide') ?
  2447                  $(event.target) :
  2448                  $(event.target).parents('.slick-slide');
  2449  
  2450          var index = parseInt(targetElement.attr('data-slick-index'));
  2451  
  2452          if (!index) index = 0;
  2453  
  2454          if (_.slideCount <= _.options.slidesToShow) {
  2455  
  2456              _.slideHandler(index, false, true);
  2457              return;
  2458  
  2459          }
  2460  
  2461          _.slideHandler(index);
  2462  
  2463      };
  2464  
  2465      Slick.prototype.slideHandler = function(index, sync, dontAnimate) {
  2466  
  2467          var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
  2468              _ = this, navTarget;
  2469  
  2470          sync = sync || false;
  2471  
  2472          if (_.animating === true && _.options.waitForAnimate === true) {
  2473              return;
  2474          }
  2475  
  2476          if (_.options.fade === true && _.currentSlide === index) {
  2477              return;
  2478          }
  2479  
  2480          if (sync === false) {
  2481              _.asNavFor(index);
  2482          }
  2483  
  2484          targetSlide = index;
  2485          targetLeft = _.getLeft(targetSlide);
  2486          slideLeft = _.getLeft(_.currentSlide);
  2487  
  2488          _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
  2489  
  2490          if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
  2491              if (_.options.fade === false) {
  2492                  targetSlide = _.currentSlide;
  2493                  if (dontAnimate !== true) {
  2494                      _.animateSlide(slideLeft, function() {
  2495                          _.postSlide(targetSlide);
  2496                      });
  2497                  } else {
  2498                      _.postSlide(targetSlide);
  2499                  }
  2500              }
  2501              return;
  2502          } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
  2503              if (_.options.fade === false) {
  2504                  targetSlide = _.currentSlide;
  2505                  if (dontAnimate !== true) {
  2506                      _.animateSlide(slideLeft, function() {
  2507                          _.postSlide(targetSlide);
  2508                      });
  2509                  } else {
  2510                      _.postSlide(targetSlide);
  2511                  }
  2512              }
  2513              return;
  2514          }
  2515  
  2516          if ( _.options.autoplay ) {
  2517              clearInterval(_.autoPlayTimer);
  2518          }
  2519  
  2520          if (targetSlide < 0) {
  2521              if (_.slideCount % _.options.slidesToScroll !== 0) {
  2522                  animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
  2523              } else {
  2524                  animSlide = _.slideCount + targetSlide;
  2525              }
  2526          } else if (targetSlide >= _.slideCount) {
  2527              if (_.slideCount % _.options.slidesToScroll !== 0) {
  2528                  animSlide = 0;
  2529              } else {
  2530                  animSlide = targetSlide - _.slideCount;
  2531              }
  2532          } else {
  2533              animSlide = targetSlide;
  2534          }
  2535  
  2536          _.animating = true;
  2537  
  2538          _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);
  2539  
  2540          oldSlide = _.currentSlide;
  2541          _.currentSlide = animSlide;
  2542  
  2543          _.setSlideClasses(_.currentSlide);
  2544  
  2545          if ( _.options.asNavFor ) {
  2546  
  2547              navTarget = _.getNavTarget();
  2548              navTarget = navTarget.slick('getSlick');
  2549  
  2550              if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {
  2551                  navTarget.setSlideClasses(_.currentSlide);
  2552              }
  2553  
  2554          }
  2555  
  2556          _.updateDots();
  2557          _.updateArrows();
  2558  
  2559          if (_.options.fade === true) {
  2560              if (dontAnimate !== true) {
  2561  
  2562                  _.fadeSlideOut(oldSlide);
  2563  
  2564                  _.fadeSlide(animSlide, function() {
  2565                      _.postSlide(animSlide);
  2566                  });
  2567  
  2568              } else {
  2569                  _.postSlide(animSlide);
  2570              }
  2571              _.animateHeight();
  2572              return;
  2573          }
  2574  
  2575          if (dontAnimate !== true) {
  2576              _.animateSlide(targetLeft, function() {
  2577                  _.postSlide(animSlide);
  2578              });
  2579          } else {
  2580              _.postSlide(animSlide);
  2581          }
  2582  
  2583      };
  2584  
  2585      Slick.prototype.startLoad = function() {
  2586  
  2587          var _ = this;
  2588  
  2589          if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
  2590  
  2591              _.$prevArrow.hide();
  2592              _.$nextArrow.hide();
  2593  
  2594          }
  2595  
  2596          if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
  2597  
  2598              _.$dots.hide();
  2599  
  2600          }
  2601  
  2602          _.$slider.addClass('slick-loading');
  2603  
  2604      };
  2605  
  2606      Slick.prototype.swipeDirection = function() {
  2607  
  2608          var xDist, yDist, r, swipeAngle, _ = this;
  2609  
  2610          xDist = _.touchObject.startX - _.touchObject.curX;
  2611          yDist = _.touchObject.startY - _.touchObject.curY;
  2612          r = Math.atan2(yDist, xDist);
  2613  
  2614          swipeAngle = Math.round(r * 180 / Math.PI);
  2615          if (swipeAngle < 0) {
  2616              swipeAngle = 360 - Math.abs(swipeAngle);
  2617          }
  2618  
  2619          if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
  2620              return (_.options.rtl === false ? 'left' : 'right');
  2621          }
  2622          if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
  2623              return (_.options.rtl === false ? 'left' : 'right');
  2624          }
  2625          if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
  2626              return (_.options.rtl === false ? 'right' : 'left');
  2627          }
  2628          if (_.options.verticalSwiping === true) {
  2629              if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
  2630                  return 'down';
  2631              } else {
  2632                  return 'up';
  2633              }
  2634          }
  2635  
  2636          return 'vertical';
  2637  
  2638      };
  2639  
  2640      Slick.prototype.swipeEnd = function(event) {
  2641  
  2642          var _ = this,
  2643              slideCount,
  2644              direction;
  2645  
  2646          _.dragging = false;
  2647          _.swiping = false;
  2648  
  2649          if (_.scrolling) {
  2650              _.scrolling = false;
  2651              return false;
  2652          }
  2653  
  2654          _.interrupted = false;
  2655          _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;
  2656  
  2657          if ( _.touchObject.curX === undefined ) {
  2658              return false;
  2659          }
  2660  
  2661          if ( _.touchObject.edgeHit === true ) {
  2662              _.$slider.trigger('edge', [_, _.swipeDirection() ]);
  2663          }
  2664  
  2665          if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
  2666  
  2667              direction = _.swipeDirection();
  2668  
  2669              switch ( direction ) {
  2670  
  2671                  case 'left':
  2672                  case 'down':
  2673  
  2674                      slideCount =
  2675                          _.options.swipeToSlide ?
  2676                              _.checkNavigable( _.currentSlide + _.getSlideCount() ) :
  2677                              _.currentSlide + _.getSlideCount();
  2678  
  2679                      _.currentDirection = 0;
  2680  
  2681                      break;
  2682  
  2683                  case 'right':
  2684                  case 'up':
  2685  
  2686                      slideCount =
  2687                          _.options.swipeToSlide ?
  2688                              _.checkNavigable( _.currentSlide - _.getSlideCount() ) :
  2689                              _.currentSlide - _.getSlideCount();
  2690  
  2691                      _.currentDirection = 1;
  2692  
  2693                      break;
  2694  
  2695                  default:
  2696  
  2697  
  2698              }
  2699  
  2700              if( direction != 'vertical' ) {
  2701  
  2702                  _.slideHandler( slideCount );
  2703                  _.touchObject = {};
  2704                  _.$slider.trigger('swipe', [_, direction ]);
  2705  
  2706              }
  2707  
  2708          } else {
  2709  
  2710              if ( _.touchObject.startX !== _.touchObject.curX ) {
  2711  
  2712                  _.slideHandler( _.currentSlide );
  2713                  _.touchObject = {};
  2714  
  2715              }
  2716  
  2717          }
  2718  
  2719      };
  2720  
  2721      Slick.prototype.swipeHandler = function(event) {
  2722  
  2723          var _ = this;
  2724  
  2725          if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
  2726              return;
  2727          } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
  2728              return;
  2729          }
  2730  
  2731          _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
  2732              event.originalEvent.touches.length : 1;
  2733  
  2734          _.touchObject.minSwipe = _.listWidth / _.options
  2735              .touchThreshold;
  2736  
  2737          if (_.options.verticalSwiping === true) {
  2738              _.touchObject.minSwipe = _.listHeight / _.options
  2739                  .touchThreshold;
  2740          }
  2741  
  2742          switch (event.data.action) {
  2743  
  2744              case 'start':
  2745                  _.swipeStart(event);
  2746                  break;
  2747  
  2748              case 'move':
  2749                  _.swipeMove(event);
  2750                  break;
  2751  
  2752              case 'end':
  2753                  _.swipeEnd(event);
  2754                  break;
  2755  
  2756          }
  2757  
  2758      };
  2759  
  2760      Slick.prototype.swipeMove = function(event) {
  2761  
  2762          var _ = this,
  2763              edgeWasHit = false,
  2764              curLeft, swipeDirection, swipeLength, positionOffset, touches, verticalSwipeLength;
  2765  
  2766          touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
  2767  
  2768          if (!_.dragging || _.scrolling || touches && touches.length !== 1) {
  2769              return false;
  2770          }
  2771  
  2772          curLeft = _.getLeft(_.currentSlide);
  2773  
  2774          _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
  2775          _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
  2776  
  2777          _.touchObject.swipeLength = Math.round(Math.sqrt(
  2778              Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
  2779  
  2780          verticalSwipeLength = Math.round(Math.sqrt(
  2781              Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
  2782  
  2783          if (!_.options.verticalSwiping && !_.swiping && verticalSwipeLength > 4) {
  2784              _.scrolling = true;
  2785              return false;
  2786          }
  2787  
  2788          if (_.options.verticalSwiping === true) {
  2789              _.touchObject.swipeLength = verticalSwipeLength;
  2790          }
  2791  
  2792          swipeDirection = _.swipeDirection();
  2793  
  2794          if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
  2795              _.swiping = true;
  2796              event.preventDefault();
  2797          }
  2798  
  2799          positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
  2800          if (_.options.verticalSwiping === true) {
  2801              positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
  2802          }
  2803  
  2804  
  2805          swipeLength = _.touchObject.swipeLength;
  2806  
  2807          _.touchObject.edgeHit = false;
  2808  
  2809          if (_.options.infinite === false) {
  2810              if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
  2811                  swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
  2812                  _.touchObject.edgeHit = true;
  2813              }
  2814          }
  2815  
  2816          if (_.options.vertical === false) {
  2817              _.swipeLeft = curLeft + swipeLength * positionOffset;
  2818          } else {
  2819              _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
  2820          }
  2821          if (_.options.verticalSwiping === true) {
  2822              _.swipeLeft = curLeft + swipeLength * positionOffset;
  2823          }
  2824  
  2825          if (_.options.fade === true || _.options.touchMove === false) {
  2826              return false;
  2827          }
  2828  
  2829          if (_.animating === true) {
  2830              _.swipeLeft = null;
  2831              return false;
  2832          }
  2833  
  2834          _.setCSS(_.swipeLeft);
  2835  
  2836      };
  2837  
  2838      Slick.prototype.swipeStart = function(event) {
  2839  
  2840          var _ = this,
  2841              touches;
  2842  
  2843          _.interrupted = true;
  2844  
  2845          if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
  2846              _.touchObject = {};
  2847              return false;
  2848          }
  2849  
  2850          if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
  2851              touches = event.originalEvent.touches[0];
  2852          }
  2853  
  2854          _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
  2855          _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
  2856  
  2857          _.dragging = true;
  2858  
  2859      };
  2860  
  2861      Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
  2862  
  2863          var _ = this;
  2864  
  2865          if (_.$slidesCache !== null) {
  2866  
  2867              _.unload();
  2868  
  2869              _.$slideTrack.children(this.options.slide).detach();
  2870  
  2871              _.$slidesCache.appendTo(_.$slideTrack);
  2872  
  2873              _.reinit();
  2874  
  2875          }
  2876  
  2877      };
  2878  
  2879      Slick.prototype.unload = function() {
  2880  
  2881          var _ = this;
  2882  
  2883          $('.slick-cloned', _.$slider).remove();
  2884  
  2885          if (_.$dots) {
  2886              _.$dots.remove();
  2887          }
  2888  
  2889          if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
  2890              _.$prevArrow.remove();
  2891          }
  2892  
  2893          if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
  2894              _.$nextArrow.remove();
  2895          }
  2896  
  2897          _.$slides
  2898              .removeClass('slick-slide slick-active slick-visible slick-current')
  2899              .attr('aria-hidden', 'true')
  2900              .css('width', '');
  2901  
  2902      };
  2903  
  2904      Slick.prototype.unslick = function(fromBreakpoint) {
  2905  
  2906          var _ = this;
  2907          _.$slider.trigger('unslick', [_, fromBreakpoint]);
  2908          _.destroy();
  2909  
  2910      };
  2911  
  2912      Slick.prototype.updateArrows = function() {
  2913  
  2914          var _ = this,
  2915              centerOffset;
  2916  
  2917          centerOffset = Math.floor(_.options.slidesToShow / 2);
  2918  
  2919          if ( _.options.arrows === true &&
  2920              _.slideCount > _.options.slidesToShow &&
  2921              !_.options.infinite ) {
  2922  
  2923              _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
  2924              _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
  2925  
  2926              if (_.currentSlide === 0) {
  2927  
  2928                  _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
  2929                  _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
  2930  
  2931              } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {
  2932  
  2933                  _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
  2934                  _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
  2935  
  2936              } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {
  2937  
  2938                  _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
  2939                  _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
  2940  
  2941              }
  2942  
  2943          }
  2944  
  2945      };
  2946  
  2947      Slick.prototype.updateDots = function() {
  2948  
  2949          var _ = this;
  2950  
  2951          if (_.$dots !== null) {
  2952  
  2953              _.$dots
  2954                  .find('li')
  2955                      .removeClass('slick-active')
  2956                      .end();
  2957  
  2958              _.$dots
  2959                  .find('li')
  2960                  .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))
  2961                  .addClass('slick-active');
  2962  
  2963          }
  2964  
  2965      };
  2966  
  2967      Slick.prototype.visibility = function() {
  2968  
  2969          var _ = this;
  2970  
  2971          if ( _.options.autoplay ) {
  2972  
  2973              if ( document[_.hidden] ) {
  2974  
  2975                  _.interrupted = true;
  2976  
  2977              } else {
  2978  
  2979                  _.interrupted = false;
  2980  
  2981              }
  2982  
  2983          }
  2984  
  2985      };
  2986  
  2987      $.fn.slick = function() {
  2988          var _ = this,
  2989              opt = arguments[0],
  2990              args = Array.prototype.slice.call(arguments, 1),
  2991              l = _.length,
  2992              i,
  2993              ret;
  2994          for (i = 0; i < l; i++) {
  2995              if (typeof opt == 'object' || typeof opt == 'undefined')
  2996                  _[i].slick = new Slick(_[i], opt);
  2997              else
  2998                  ret = _[i].slick[opt].apply(_[i].slick, args);
  2999              if (typeof ret != 'undefined') return ret;
  3000          }
  3001          return _;
  3002      };
  3003  
  3004  }));