https://tangentwines.com/wp-content/themes/affinity-custom-webpack/public/bundle.js?ver=1724718361

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// install a JSONP callback for chunk loading
3/******/ 	function webpackJsonpCallback(data) {
4/******/ 		var chunkIds = data[0];
5/******/ 		var moreModules = data[1];
6/******/ 		var executeModules = data[2];
7/******/
8/******/ 		// add "moreModules" to the modules object,
9/******/ 		// then flag all "chunkIds" as loaded and fire callback
10/******/ 		var moduleId, chunkId, i = 0, resolves = [];
11/******/ 		for(;i < chunkIds.length; i++) {
12/******/ 			chunkId = chunkIds[i];
13/******/ 			if(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {
14/******/ 				resolves.push(installedChunks[chunkId][0]);
15/******/ 			}
16/******/ 			installedChunks[chunkId] = 0;
17/******/ 		}
18/******/ 		for(moduleId in moreModules) {
19/******/ 			if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
20/******/ 				modules[moduleId] = moreModules[moduleId];
21/******/ 			}
22/******/ 		}
23/******/ 		if(parentJsonpFunction) parentJsonpFunction(data);
24/******/
25/******/ 		while(resolves.length) {
26/******/ 			resolves.shift()();
27/******/ 		}
28/******/
29/******/ 		// add entry modules from loaded chunk to deferred list
30/******/ 		deferredModules.push.apply(deferredModules, executeModules || []);
31/******/
32/******/ 		// run deferred modules when all chunks ready
33/******/ 		return checkDeferredModules();
34/******/ 	};
35/******/ 	function checkDeferredModules() {
36/******/ 		var result;
37/******/ 		for(var i = 0; i < deferredModules.length; i++) {
38/******/ 			var deferredModule = deferredModules[i];
39/******/ 			var fulfilled = true;
40/******/ 			for(var j = 1; j < deferredModule.length; j++) {
41/******/ 				var depId = deferredModule[j];
42/******/ 				if(installedChunks[depId] !== 0) fulfilled = false;
43/******/ 			}
44/******/ 			if(fulfilled) {
45/******/ 				deferredModules.splice(i--, 1);
46/******/ 				result = __webpack_require__(__webpack_require__.s = deferredModule[0]);
47/******/ 			}
48/******/ 		}
49/******/
50/******/ 		return result;
51/******/ 	}
52/******/
53/******/ 	// The module cache
54/******/ 	var installedModules = {};
55/******/
56/******/ 	// object to store loaded and loading chunks
57/******/ 	// undefined = chunk not loaded, null = chunk preloaded/prefetched
58/******/ 	// Promise = chunk loading, 0 = chunk loaded
59/******/ 	var installedChunks = {
60/******/ 		"bundle": 0
61/******/ 	};
62/******/
63/******/ 	var deferredModules = [];
64/******/
65/******/ 	// The require function
66/******/ 	function __webpack_require__(moduleId) {
67/******/
68/******/ 		// Check if module is in cache
69/******/ 		if(installedModules[moduleId]) {
70/******/ 			return installedModules[moduleId].exports;
71/******/ 		}
72/******/ 		// Create a new module (and put it into the cache)
73/******/ 		var module = installedModules[moduleId] = {
74/******/ 			i: moduleId,
75/******/ 			l: false,
76/******/ 			exports: {}
77/******/ 		};
78/******/
79/******/ 		// Execute the module function
80/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
81/******/
82/******/ 		// Flag the module as loaded
83/******/ 		module.l = true;
84/******/
85/******/ 		// Return the exports of the module
86/******/ 		return module.exports;
87/******/ 	}
88/******/
89/******/
90/******/ 	// expose the modules object (__webpack_modules__)
91/******/ 	__webpack_require__.m = modules;
92/******/
93/******/ 	// expose the module cache
94/******/ 	__webpack_require__.c = installedModules;
95/******/
96/******/ 	// define getter function for harmony exports
97/******/ 	__webpack_require__.d = function(exports, name, getter) {
98/******/ 		if(!__webpack_require__.o(exports, name)) {
99/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
100/******/ 		}
101/******/ 	};
102/******/
103/******/ 	// define __esModule on exports
104/******/ 	__webpack_require__.r = function(exports) {
105/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
106/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
107/******/ 		}
108/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
109/******/ 	};
110/******/
111/******/ 	// create a fake namespace object
112/******/ 	// mode & 1: value is a module id, require it
113/******/ 	// mode & 2: merge all properties of value into the ns
114/******/ 	// mode & 4: return value when already ns object
115/******/ 	// mode & 8|1: behave like require
116/******/ 	__webpack_require__.t = function(value, mode) {
117/******/ 		if(mode & 1) value = __webpack_require__(value);
118/******/ 		if(mode & 8) return value;
119/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
120/******/ 		var ns = Object.create(null);
121/******/ 		__webpack_require__.r(ns);
122/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
123/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
124/******/ 		return ns;
125/******/ 	};
126/******/
127/******/ 	// getDefaultExport function for compatibility with non-harmony modules
128/******/ 	__webpack_require__.n = function(module) {
129/******/ 		var getter = module && module.__esModule ?
130/******/ 			function getDefault() { return module['default']; } :
131/******/ 			function getModuleExports() { return module; };
132/******/ 		__webpack_require__.d(getter, 'a', getter);
133/******/ 		return getter;
134/******/ 	};
135/******/
136/******/ 	// Object.prototype.hasOwnProperty.call
137/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
138/******/
139/******/ 	// __webpack_public_path__
140/******/ 	__webpack_require__.p = "";
141/******/
142/******/ 	var jsonpArray = window["webpackJsonp"] = window["webpackJsonp"] || [];
143/******/ 	var oldJsonpFunction = jsonpArray.push.bind(jsonpArray);
144/******/ 	jsonpArray.push = webpackJsonpCallback;
145/******/ 	jsonpArray = jsonpArray.slice();
146/******/ 	for(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);
147/******/ 	var parentJsonpFunction = oldJsonpFunction;
148/******/
149/******/
150/******/ 	// add entry module to deferred list
151/******/ 	deferredModules.push([0,"vendors~bundle"]);
152/******/ 	// run deferred modules when ready
153/******/ 	return checkDeferredModules();
154/******/ })
155/************************************************************************/
156/******/ ({
157

1407        unslicked: false
1408      };
1409      $.extend(_, _.initials);
1410      _.activeBreakpoint = null;
1411      _.animType = null;
1412      _.animProp = null;
1413      _.breakpoints = [];
1414      _.breakpointSettings = [];
1415      _.cssTransitions = false;
1416      _.focussed = false;
1417      _.interrupted = false;
1418      _.hidden = 'hidden';
1419      _.paused = true;
1420      _.positionProp = null;
1421      _.respondTo = null;
1422      _.rowCount = 1;
1423      _.shouldClick = true;
1424      _.$slider = $(element);
1425      _.$slidesCache = null;
1426      _.transformType = null;
1427      _.transitionType = null;
1428      _.visibilityChange = 'visibilitychange';
1429      _.windowWidth = 0;
1430      _.windowTimer = null;
1431      dataSettings = $(element).data('slick') || {};
1432      _.options = $.extend({}, _.defaults, settings, dataSettings);
1433      _.currentSlide = _.options.initialSlide;
1434      _.originalSettings = _.options;
1435
1436      if (typeof document.mozHidden !== 'undefined') {
1437        _.hidden = 'mozHidden';
1438        _.visibilityChange = 'mozvisibilitychange';
1439      } else if (typeof document.webkitHidden !== 'undefined') {
1440        _.hidden = 'webkitHidden';
1441        _.visibilityChange = 'webkitvisibilitychange';
1442      }
1443
1444      _.autoPlay = $.proxy(_.autoPlay, _);
1445      _.autoPlayClear = $.proxy(_.autoPlayClear, _);
1446      _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
1447      _.changeSlide = $.proxy(_.changeSlide, _);
1448      _.clickHandler = $.proxy(_.clickHandler, _);
1449      _.selectHandler = $.proxy(_.selectHandler, _);
1450      _.setPosition = $.proxy(_.setPosition, _);
1451      _.swipeHandler = $.proxy(_.swipeHandler, _);
1452      _.dragHandler = $.proxy(_.dragHandler, _);
1453      _.keyHandler = $.proxy(_.keyHandler, _);
1454      _.instanceUid = instanceUid++; // A simple way to check for HTML strings
1455      // Strict HTML recognition (must start with <)
1456      // Extracted from jQuery v1.11 source
1457
1458      _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
1459
1460      _.registerBreakpoints();
1461
1462      _.init(true);
1463    }
1464
1465    return Slick;
1466  }();
1467
1468  Slick.prototype.activateADA = function () {
1469    var _ = this;
1470
1471    _.$slideTrack.find('.slick-active').attr({
1472      'aria-hidden': 'false'
1473    }).find('a, input, button, select').attr({
1474      'tabindex': '0'
1475    });
1476  };
1477
1478  Slick.prototype.addSlide = Slick.prototype.slickAdd = function (markup, index, addBefore) {
1479    var _ = this;
1480
1481    if (typeof index === 'boolean') {
1482      addBefore = index;
1483      index = null;
1484    } else if (index < 0 || index >= _.slideCount) {
1485      return false;
1486    }
1487
1488    _.unload();
1489
1490    if (typeof index === 'number') {
1491      if (index === 0 && _.$slides.length === 0) {
1492        $(markup).appendTo(_.$slideTrack);
1493      } else if (addBefore) {
1494        $(markup).insertBefore(_.$slides.eq(index));
1495      } else {
1496        $(markup).insertAfter(_.$slides.eq(index));
1497      }
1498    } else {
1499      if (addBefore === true) {
1500        $(markup).prependTo(_.$slideTrack);
1501      } else {
1502        $(markup).appendTo(_.$slideTrack);
1503      }
1504    }
1505
1506    _.$slides = _.$slideTrack.children(this.options.slide);
1507
1508    _.$slideTrack.children(this.options.slide).detach();
1509
1510    _.$slideTrack.append(_.$slides);
1511
1512    _.$slides.each(function (index, element) {
1513      $(element).attr('data-slick-index', index);
1514    });
1515
1516    _.$slidesCache = _.$slides;
1517
1518    _.reinit();
1519  };
1520
1521  Slick.prototype.animateHeight = function () {
1522    var _ = this;
1523
1524    if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
1525      var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
1526
1527      _.$list.animate({
1528        height: targetHeight
1529      }, _.options.speed);
1530    }
1531  };
1532
1533  Slick.prototype.animateSlide = function (targetLeft, callback) {
1534    var animProps = {},
1535        _ = this;
1536
1537    _.animateHeight();
1538
1539    if (_.options.rtl === true && _.options.vertical === false) {
1540      targetLeft = -targetLeft;
1541    }
1542
1543    if (_.transformsEnabled === false) {
1544      if (_.options.vertical === false) {
1545        _.$slideTrack.animate({
1546          left: targetLeft
1547        }, _.options.speed, _.options.easing, callback);
1548      } else {
1549        _.$slideTrack.animate({
1550          top: targetLeft
1551        }, _.options.speed, _.options.easing, callback);
1552      }
1553    } else {
1554      if (_.cssTransitions === false) {
1555        if (_.options.rtl === true) {
1556          _.currentLeft = -_.currentLeft;
1557        }
1558
1559        $({
1560          animStart: _.currentLeft
1561        }).animate({
1562          animStart: targetLeft
1563        }, {
1564          duration: _.options.speed,
1565          easing: _.options.easing,
1566          step: function step(now) {
1567            now = Math.ceil(now);
1568
1569            if (_.options.vertical === false) {
1570              animProps[_.animType] = 'translate(' + now + 'px, 0px)';
1571
1572              _.$slideTrack.css(animProps);
1573            } else {
1574              animProps[_.animType] = 'translate(0px,' + now + 'px)';
1575
1576              _.$slideTrack.css(animProps);
1577            }
1578          },
1579          complete: function complete() {
1580            if (callback) {
1581              callback.call();
1582            }
1583          }
1584        });
1585      } else {
1586        _.applyTransition();
1587
1588        targetLeft = Math.ceil(targetLeft);
1589
1590        if (_.options.vertical === false) {
1591          animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
1592        } else {
1593          animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
1594        }
1595
1596        _.$slideTrack.css(animProps);
1597
1598        if (callback) {
1599          setTimeout(function () {
1600            _.disableTransition();
1601
1602            callback.call();
1603          }, _.options.speed);
1604        }
1605      }
1606    }
1607  };
1608
1609  Slick.prototype.getNavTarget = function () {
1610    var _ = this,
1611        asNavFor = _.options.asNavFor;
1612
1613    if (asNavFor && asNavFor !== null) {
1614      asNavFor = $(asNavFor).not(_.$slider);
1615    }
1616
1617    return asNavFor;
1618  };
1619
1620  Slick.prototype.asNavFor = function (index) {
1621    var _ = this,
1622        asNavFor = _.getNavTarget();
1623
1624    if (asNavFor !== null && _typeof(asNavFor) === 'object') {
1625      asNavFor.each(function () {
1626        var target = $(this).slick('getSlick');
1627
1628        if (!target.unslicked) {
1629          target.slideHandler(index, true);
1630        }
1631      });
1632    }
1633  };
1634
1635  Slick.prototype.applyTransition = function (slide) {
1636    var _ = this,
1637        transition = {};
1638
1639    if (_.options.fade === false) {
1640      transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
1641    } else {
1642      transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
1643    }
1644
1645    if (_.options.fade === false) {
1646      _.$slideTrack.css(transition);
1647    } else {
1648      _.$slides.eq(slide).css(transition);
1649    }
1650  };
1651
1652  Slick.prototype.autoPlay = function () {
1653    var _ = this;
1654
1655    _.autoPlayClear();
1656
1657    if (_.slideCount > _.options.slidesToShow) {
1658      _.autoPlayTimer = setInterval(_.autoPlayIterator, _.options.autoplaySpeed);
1659    }
1660  };
1661
1662  Slick.prototype.autoPlayClear = function () {
1663    var _ = this;
1664
1665    if (_.autoPlayTimer) {
1666      clearInterval(_.autoPlayTimer);
1667    }
1668  };
1669
1670  Slick.prototype.autoPlayIterator = function () {
1671    var _ = this,
1672        slideTo = _.currentSlide + _.options.slidesToScroll;
1673
1674    if (!_.paused && !_.interrupted && !_.focussed) {
1675      if (_.options.infinite === false) {
1676        if (_.direction === 1 && _.currentSlide + 1 === _.slideCount - 1) {
1677          _.direction = 0;
1678        } else if (_.direction === 0) {
1679          slideTo = _.currentSlide - _.options.slidesToScroll;
1680
1681          if (_.currentSlide - 1 === 0) {
1682            _.direction = 1;
1683          }
1684        }
1685      }
1686
1687      _.slideHandler(slideTo);
1688    }
1689  };
1690
1691  Slick.prototype.buildArrows = function () {
1692    var _ = this;
1693
1694    if (_.options.arrows === true) {
1695      _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
1696      _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
1697
1698      if (_.slideCount > _.options.slidesToShow) {
1699        _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
1700
1701        _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
1702
1703        if (_.htmlExpr.test(_.options.prevArrow)) {
1704          _.$prevArrow.prependTo(_.options.appendArrows);
1705        }
1706
1707        if (_.htmlExpr.test(_.options.nextArrow)) {
1708          _.$nextArrow.appendTo(_.options.appendArrows);
1709        }
1710
1711        if (_.options.infinite !== true) {
1712          _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
1713        }
1714      } else {
1715        _.$prevArrow.add(_.$nextArrow).addClass('slick-hidden').attr({
1716          'aria-disabled': 'true',
1717          'tabindex': '-1'
1718        });
1719      }
1720    }
1721  };
1722
1723  Slick.prototype.buildDots = function () {
1724    var _ = this,
1725        i,
1726        dot;
1727
1728    if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1729      _.$slider.addClass('slick-dotted');
1730
1731      dot = $('<ul />').addClass(_.options.dotsClass);
1732
1733      for (i = 0; i <= _.getDotCount(); i += 1) {
1734        dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
1735      }
1736
1737      _.$dots = dot.appendTo(_.options.appendDots);
1738
1739      _.$dots.find('li').first().addClass('slick-active');
1740    }
1741  };
1742
1743  Slick.prototype.buildOut = function () {
1744    var _ = this;
1745
1746    _.$slides = _.$slider.children(_.options.slide + ':not(.slick-cloned)').addClass('slick-slide');
1747    _.slideCount = _.$slides.length;
1748
1749    _.$slides.each(function (index, element) {
1750      $(element).attr('data-slick-index', index).data('originalStyling', $(element).attr('style') || '');
1751    });
1752
1753    _.$slider.addClass('slick-slider');
1754
1755    _.$slideTrack = _.slideCount === 0 ? $('<div class="slick-track"/>').appendTo(_.$slider) : _.$slides.wrapAll('<div class="slick-track"/>').parent();
1756    _.$list = _.$slideTrack.wrap('<div class="slick-list"/>').parent();
1757
1758    _.$slideTrack.css('opacity', 0);
1759
1760    if (_.options.centerMode === true || _.options.swipeToSlide === true) {
1761      _.options.slidesToScroll = 1;
1762    }
1763
1764    $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
1765
1766    _.setupInfinite();
1767
1768    _.buildArrows();
1769
1770    _.buildDots();
1771
1772    _.updateDots();
1773
1774    _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1775
1776    if (_.options.draggable === true) {
1777      _.$list.addClass('draggable');
1778    }
1779  };
1780
1781  Slick.prototype.buildRows = function () {
1782    var _ = this,
1783        a,
1784        b,
1785        c,
1786        newSlides,
1787        numOfSlides,
1788        originalSlides,
1789        slidesPerSection;
1790
1791    newSlides = document.createDocumentFragment();
1792    originalSlides = _.$slider.children();
1793
1794    if (_.options.rows > 0) {
1795      slidesPerSection = _.options.slidesPerRow * _.options.rows;
1796      numOfSlides = Math.ceil(originalSlides.length / slidesPerSection);
1797
1798      for (a = 0; a < numOfSlides; a++) {
1799        var slide = document.createElement('div');
1800
1801        for (b = 0; b < _.options.rows; b++) {
1802          var row = document.createElement('div');
1803
1804          for (c = 0; c < _.options.slidesPerRow; c++) {
1805            var target = a * slidesPerSection + (b * _.options.slidesPerRow + c);
1806
1807            if (originalSlides.get(target)) {
1808              row.appendChild(originalSlides.get(target));
1809            }
1810          }
1811
1812          slide.appendChild(row);
1813        }
1814
1815        newSlides.appendChild(slide);
1816      }
1817
1818      _.$slider.empty().append(newSlides);
1819
1820      _.$slider.children().children().children().css({
1821        'width': 100 / _.options.slidesPerRow + '%',
1822        'display': 'inline-block'
1823      });
1824    }
1825  };
1826
1827  Slick.prototype.checkResponsive = function (initial, forceUpdate) {
1828    var _ = this,
1829        breakpoint,
1830        targetBreakpoint,
1831        respondToWidth,
1832        triggerBreakpoint = false;
1833
1834    var sliderWidth = _.$slider.width();
1835
1836    var windowWidth = window.innerWidth || $(window).width();
1837
1838    if (_.respondTo === 'window') {
1839      respondToWidth = windowWidth;
1840    } else if (_.respondTo === 'slider') {
1841      respondToWidth = sliderWidth;
1842    } else if (_.respondTo === 'min') {
1843      respondToWidth = Math.min(windowWidth, sliderWidth);
1844    }
1845
1846    if (_.options.responsive && _.options.responsive.length && _.options.responsive !== null) {
1847      targetBreakpoint = null;
1848
1849      for (breakpoint in _.breakpoints) {
1850        if (_.breakpoints.hasOwnProperty(breakpoint)) {
1851          if (_.originalSettings.mobileFirst === false) {
1852            if (respondToWidth < _.breakpoints[breakpoint]) {
1853              targetBreakpoint = _.breakpoints[breakpoint];
1854            }
1855          } else {
1856            if (respondToWidth > _.breakpoints[breakpoint]) {
1857              targetBreakpoint = _.breakpoints[breakpoint];
1858            }
1859          }
1860        }
1861      }
1862
1863      if (targetBreakpoint !== null) {
1864        if (_.activeBreakpoint !== null) {
1865          if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
1866            _.activeBreakpoint = targetBreakpoint;
1867
1868            if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
1869              _.unslick(targetBreakpoint);
1870            } else {
1871              _.options = $.extend({}, _.originalSettings, _.breakpointSettings[targetBreakpoint]);
1872
1873              if (initial === true) {
1874                _.currentSlide = _.options.initialSlide;
1875              }
1876
1877              _.refresh(initial);
1878            }
1879
1880            triggerBreakpoint = targetBreakpoint;
1881          }
1882        } else {
1883          _.activeBreakpoint = targetBreakpoint;
1884
1885          if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
1886            _.unslick(targetBreakpoint);
1887          } else {
1888            _.options = $.extend({}, _.originalSettings, _.breakpointSettings[targetBreakpoint]);
1889
1890            if (initial === true) {
1891              _.currentSlide = _.options.initialSlide;
1892            }
1893
1894            _.refresh(initial);
1895          }
1896
1897          triggerBreakpoint = targetBreakpoint;
1898        }
1899      } else {
1900        if (_.activeBreakpoint !== null) {
1901          _.activeBreakpoint = null;
1902          _.options = _.originalSettings;
1903
1904          if (initial === true) {
1905            _.currentSlide = _.options.initialSlide;
1906          }
1907
1908          _.refresh(initial);
1909
1910          triggerBreakpoint = targetBreakpoint;
1911        }
1912      } // only trigger breakpoints during an actual break. not on initialize.
1913
1914
1915      if (!initial && triggerBreakpoint !== false) {
1916        _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
1917      }
1918    }
1919  };
1920
1921  Slick.prototype.changeSlide = function (event, dontAnimate) {
1922    var _ = this,
1923        $target = $(event.currentTarget),
1924        indexOffset,
1925        slideOffset,
1926        unevenOffset; // If target is a link, prevent default action.
1927
1928
1929    if ($target.is('a')) {
1930      event.preventDefault();
1931    } // If target is not the <li> element (ie: a child), find the <li>.
1932
1933
1934    if (!$target.is('li')) {
1935      $target = $target.closest('li');
1936    }
1937
1938    unevenOffset = _.slideCount % _.options.slidesToScroll !== 0;
1939    indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
1940
1941    switch (event.data.message) {
1942      case 'previous':
1943        slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
1944
1945        if (_.slideCount > _.options.slidesToShow) {
1946          _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
1947        }
1948
1949        break;
1950
1951      case 'next':
1952        slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
1953
1954        if (_.slideCount > _.options.slidesToShow) {
1955          _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
1956        }
1957
1958        break;
1959
1960      case 'index':
1961        var index = event.data.index === 0 ? 0 : event.data.index || $target.index() * _.options.slidesToScroll;
1962
1963        _.slideHandler(_.checkNavigable(index), false, dontAnimate);
1964
1965        $target.children().trigger('focus');
1966        break;
1967
1968      default:
1969        return;
1970    }
1971  };
1972
1973  Slick.prototype.checkNavigable = function (index) {
1974    var _ = this,
1975        navigables,
1976        prevNavigable;
1977
1978    navigables = _.getNavigableIndexes();
1979    prevNavigable = 0;
1980
1981    if (index > navigables[navigables.length - 1]) {
1982      index = navigables[navigables.length - 1];
1983    } else {
1984      for (var n in navigables) {
1985        if (index < navigables[n]) {
1986          index = prevNavigable;
1987          break;
1988        }
1989
1990        prevNavigable = navigables[n];
1991      }
1992    }
1993
1994    return index;
1995  };
1996
1997  Slick.prototype.cleanUpEvents = function () {
1998    var _ = this;
1999
2000    if (_.options.dots && _.$dots !== null) {
2001      $('li', _.$dots).off('click.slick', _.changeSlide).off('mouseenter.slick', $.proxy(_.interrupt, _, true)).off('mouseleave.slick', $.proxy(_.interrupt, _, false));
2002
2003      if (_.options.accessibility === true) {
2004        _.$dots.off('keydown.slick', _.keyHandler);
2005      }
2006    }
2007
2008    _.$slider.off('focus.slick blur.slick');
2009
2010    if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2011      _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
2012      _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
2013
2014      if (_.options.accessibility === true) {
2015        _.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler);
2016        _.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler);
2017      }
2018    }
2019
2020    _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
2021
2022    _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
2023
2024    _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
2025
2026    _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
2027
2028    _.$list.off('click.slick', _.clickHandler);
2029
2030    $(document).off(_.visibilityChange, _.visibility);
2031
2032    _.cleanUpSlideEvents();
2033
2034    if (_.options.accessibility === true) {
2035      _.$list.off('keydown.slick', _.keyHandler);
2036    }
2037
2038    if (_.options.focusOnSelect === true) {
2039      $(_.$slideTrack).children().off('click.slick', _.selectHandler);
2040    }
2041
2042    $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
2043    $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
2044    $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
2045    $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
2046  };
2047
2048  Slick.prototype.cleanUpSlideEvents = function () {
2049    var _ = this;
2050
2051    _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
2052
2053    _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
2054  };
2055
2056  Slick.prototype.cleanUpRows = function () {
2057    var _ = this,
2058        originalSlides;
2059
2060    if (_.options.rows > 0) {
2061      originalSlides = _.$slides.children().children();
2062      originalSlides.removeAttr('style');
2063
2064      _.$slider.empty().append(originalSlides);
2065    }
2066  };
2067
2068  Slick.prototype.clickHandler = function (event) {
2069    var _ = this;
2070
2071    if (_.shouldClick === false) {
2072      event.stopImmediatePropagation();
2073      event.stopPropagation();
2074      event.preventDefault();
2075    }
2076  };
2077
2078  Slick.prototype.destroy = function (refresh) {
2079    var _ = this;
2080
2081    _.autoPlayClear();
2082
2083    _.touchObject = {};
2084
2085    _.cleanUpEvents();
2086
2087    $('.slick-cloned', _.$slider).detach();
2088
2089    if (_.$dots) {
2090      _.$dots.remove();
2091    }
2092
2093    if (_.$prevArrow && _.$prevArrow.length) {
2094      _.$prevArrow.removeClass('slick-disabled slick-arrow slick-hidden').removeAttr('aria-hidden aria-disabled tabindex').css('display', '');
2095
2096      if (_.htmlExpr.test(_.options.prevArrow)) {
2097        _.$prevArrow.remove();
2098      }
2099    }
2100
2101    if (_.$nextArrow && _.$nextArrow.length) {
2102      _.$nextArrow.removeClass('slick-disabled slick-arrow slick-hidden').removeAttr('aria-hidden aria-disabled tabindex').css('display', '');
2103
2104      if (_.htmlExpr.test(_.options.nextArrow)) {
2105        _.$nextArrow.remove();
2106      }
2107    }
2108
2109    if (_.$slides) {
2110      _.$slides.removeClass('slick-slide slick-active slick-center slick-visible slick-current').removeAttr('aria-hidden').removeAttr('data-slick-index').each(function () {
2111        $(this).attr('style', $(this).data('originalStyling'));
2112      });
2113
2114      _.$slideTrack.children(this.options.slide).detach();
2115
2116      _.$slideTrack.detach();
2117
2118      _.$list.detach();
2119
2120      _.$slider.append(_.$slides);
2121    }
2122
2123    _.cleanUpRows();
2124
2125    _.$slider.removeClass('slick-slider');
2126
2127    _.$slider.removeClass('slick-initialized');
2128
2129    _.$slider.removeClass('slick-dotted');
2130
2131    _.unslicked = true;
2132
2133    if (!refresh) {
2134      _.$slider.trigger('destroy', [_]);
2135    }
2136  };
2137
2138  Slick.prototype.disableTransition = function (slide) {
2139    var _ = this,
2140        transition = {};
2141
2142    transition[_.transitionType] = '';
2143
2144    if (_.options.fade === false) {
2145      _.$slideTrack.css(transition);
2146    } else {
2147      _.$slides.eq(slide).css(transition);
2148    }
2149  };
2150
2151  Slick.prototype.fadeSlide = function (slideIndex, callback) {
2152    var _ = this;
2153
2154    if (_.cssTransitions === false) {
2155      _.$slides.eq(slideIndex).css({
2156        zIndex: _.options.zIndex
2157      });
2158
2159      _.$slides.eq(slideIndex).animate({
2160        opacity: 1
2161      }, _.options.speed, _.options.easing, callback);
2162    } else {
2163      _.applyTransition(slideIndex);
2164
2165      _.$slides.eq(slideIndex).css({
2166        opacity: 1,
2167        zIndex: _.options.zIndex
2168      });
2169
2170      if (callback) {
2171        setTimeout(function () {
2172          _.disableTransition(slideIndex);
2173
2174          callback.call();
2175        }, _.options.speed);
2176      }
2177    }
2178  };
2179
2180  Slick.prototype.fadeSlideOut = function (slideIndex) {
2181    var _ = this;
2182
2183    if (_.cssTransitions === false) {
2184      _.$slides.eq(slideIndex).animate({
2185        opacity: 0,
2186        zIndex: _.options.zIndex - 2
2187      }, _.options.speed, _.options.easing);
2188    } else {
2189      _.applyTransition(slideIndex);
2190
2191      _.$slides.eq(slideIndex).css({
2192        opacity: 0,
2193        zIndex: _.options.zIndex - 2
2194      });
2195    }
2196  };
2197
2198  Slick.prototype.filterSlides = Slick.prototype.slickFilter = function (filter) {
2199    var _ = this;
2200
2201    if (filter !== null) {
2202      _.$slidesCache = _.$slides;
2203
2204      _.unload();
2205
2206      _.$slideTrack.children(this.options.slide).detach();
2207
2208      _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
2209
2210      _.reinit();
2211    }
2212  };
2213
2214  Slick.prototype.focusHandler = function () {
2215    var _ = this; // If any child element receives focus within the slider we need to pause the autoplay
2216
2217
2218    _.$slider.off('focus.slick blur.slick').on('focus.slick', '*', function (event) {
2219      var $sf = $(this);
2220      setTimeout(function () {
2221        if (_.options.pauseOnFocus) {
2222          if ($sf.is(':focus')) {
2223            _.focussed = true;
2224
2225            _.autoPlay();
2226          }
2227        }
2228      }, 0);
2229    }).on('blur.slick', '*', function (event) {
2230      var $sf = $(this); // When a blur occurs on any elements within the slider we become unfocused
2231
2232      if (_.options.pauseOnFocus) {
2233        _.focussed = false;
2234
2235        _.autoPlay();
2236      }
2237    });
2238  };
2239
2240  Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function () {
2241    var _ = this;
2242
2243    return _.currentSlide;
2244  };
2245
2246  Slick.prototype.getDotCount = function () {
2247    var _ = this;
2248
2249    var breakPoint = 0;
2250    var counter = 0;
2251    var pagerQty = 0;
2252
2253    if (_.options.infinite === true) {
2254      if (_.slideCount <= _.options.slidesToShow) {
2255        ++pagerQty;
2256      } else {
2257        while (breakPoint < _.slideCount) {
2258          ++pagerQty;
2259          breakPoint = counter + _.options.slidesToScroll;
2260          counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
2261        }
2262      }
2263    } else if (_.options.centerMode === true) {
2264      pagerQty = _.slideCount;
2265    } else if (!_.options.asNavFor) {
2266      pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);
2267    } else {
2268      while (breakPoint < _.slideCount) {
2269        ++pagerQty;
2270        breakPoint = counter + _.options.slidesToScroll;
2271        counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
2272      }
2273    }
2274
2275    return pagerQty - 1;
2276  };
2277
2278  Slick.prototype.getLeft = function (slideIndex) {
2279    var _ = this,
2280        targetLeft,
2281        verticalHeight,
2282        verticalOffset = 0,
2283        targetSlide,
2284        coef;
2285
2286    _.slideOffset = 0;
2287    verticalHeight = _.$slides.first().outerHeight(true);
2288
2289    if (_.options.infinite === true) {
2290      if (_.slideCount > _.options.slidesToShow) {
2291        _.slideOffset = _.slideWidth * _.options.slidesToShow * -1;
2292        coef = -1;
2293
2294        if (_.options.vertical === true && _.options.centerMode === true) {
2295          if (_.options.slidesToShow === 2) {
2296            coef = -1.5;
2297          } else if (_.options.slidesToShow === 1) {
2298            coef = -2;
2299          }
2300        }
2301
2302        verticalOffset = verticalHeight * _.options.slidesToShow * coef;
2303      }
2304
2305      if (_.slideCount % _.options.slidesToScroll !== 0) {
2306        if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
2307          if (slideIndex > _.slideCount) {

2344      if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
2345        targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
2346      } else {
2347        targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
2348      }
2349
2350      if (_.options.rtl === true) {
2351        if (targetSlide[0]) {
2352          targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
2353        } else {
2354          targetLeft = 0;
2355        }
2356      } else {
2357        targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
2358      }
2359
2360      if (_.options.centerMode === true) {
2361        if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
2362          targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
2363        } else {
2364          targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
2365        }
2366
2367        if (_.options.rtl === true) {
2368          if (targetSlide[0]) {
2369            targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
2370          } else {
2371            targetLeft = 0;
2372          }
2373        } else {
2374          targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
2375        }
2376
2377        targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
2378      }
2379    }
2380
2381    return targetLeft;
2382  };
2383
2384  Slick.prototype.getOption = Slick.prototype.slickGetOption = function (option) {
2385    var _ = this;
2386
2387    return _.options[option];
2388  };
2389
2390  Slick.prototype.getNavigableIndexes = function () {
2391    var _ = this,
2392        breakPoint = 0,
2393        counter = 0,
2394        indexes = [],
2395        max;
2396
2397    if (_.options.infinite === false) {
2398      max = _.slideCount;
2399    } else {
2400      breakPoint = _.options.slidesToScroll * -1;
2401      counter = _.options.slidesToScroll * -1;
2402      max = _.slideCount * 2;
2403    }
2404
2405    while (breakPoint < max) {
2406      indexes.push(breakPoint);
2407      breakPoint = counter + _.options.slidesToScroll;
2408      counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
2409    }
2410
2411    return indexes;
2412  };
2413
2414  Slick.prototype.getSlick = function () {
2415    return this;
2416  };
2417
2418  Slick.prototype.getSlideCount = function () {
2419    var _ = this,
2420        slidesTraversed,
2421        swipedSlide,
2422        swipeTarget,
2423        centerOffset;
2424
2425    centerOffset = _.options.centerMode === true ? Math.floor(_.$list.width() / 2) : 0;
2426    swipeTarget = _.swipeLeft * -1 + centerOffset;
2427
2428    if (_.options.swipeToSlide === true) {
2429      _.$slideTrack.find('.slick-slide').each(function (index, slide) {
2430        var slideOuterWidth, slideOffset, slideRightBoundary;
2431        slideOuterWidth = $(slide).outerWidth();
2432        slideOffset = slide.offsetLeft;
2433
2434        if (_.options.centerMode !== true) {
2435          slideOffset += slideOuterWidth / 2;
2436        }
2437
2438        slideRightBoundary = slideOffset + slideOuterWidth;
2439
2440        if (swipeTarget < slideRightBoundary) {
2441          swipedSlide = slide;
2442          return false;
2443        }
2444      });
2445
2446      slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
2447      return slidesTraversed;
2448    } else {
2449      return _.options.slidesToScroll;
2450    }
2451  };
2452
2453  Slick.prototype.goTo = Slick.prototype.slickGoTo = function (slide, dontAnimate) {
2454    var _ = this;
2455
2456    _.changeSlide({
2457      data: {
2458        message: 'index',
2459        index: parseInt(slide)
2460      }
2461    }, dontAnimate);
2462  };
2463
2464  Slick.prototype.init = function (creation) {
2465    var _ = this;
2466
2467    if (!$(_.$slider).hasClass('slick-initialized')) {
2468      $(_.$slider).addClass('slick-initialized');
2469
2470      _.buildRows();
2471
2472      _.buildOut();
2473
2474      _.setProps();
2475
2476      _.startLoad();
2477
2478      _.loadSlider();
2479
2480      _.initializeEvents();
2481
2482      _.updateArrows();
2483
2484      _.updateDots();
2485
2486      _.checkResponsive(true);
2487
2488      _.focusHandler();
2489    }
2490
2491    if (creation) {
2492      _.$slider.trigger('init', [_]);
2493    }
2494
2495    if (_.options.accessibility === true) {
2496      _.initADA();
2497    }
2498
2499    if (_.options.autoplay) {
2500      _.paused = false;
2501
2502      _.autoPlay();
2503    }
2504  };
2505
2506  Slick.prototype.initADA = function () {
2507    var _ = this,
2508        numDotGroups = Math.ceil(_.slideCount / _.options.slidesToShow),
2509        tabControlIndexes = _.getNavigableIndexes().filter(function (val) {
2510      return val >= 0 && val < _.slideCount;
2511    });
2512
2513    _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({
2514      'aria-hidden': 'true',
2515      'tabindex': '-1'
2516    }).find('a, input, button, select').attr({
2517      'tabindex': '-1'
2518    });
2519
2520    if (_.$dots !== null) {
2521      _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function (i) {
2522        var slideControlIndex = tabControlIndexes.indexOf(i);
2523        $(this).attr({
2524          'role': 'tabpanel',
2525          'id': 'slick-slide' + _.instanceUid + i,
2526          'tabindex': -1
2527        });
2528
2529        if (slideControlIndex !== -1) {
2530          var ariaButtonControl = 'slick-slide-control' + _.instanceUid + slideControlIndex;
2531
2532          if ($('#' + ariaButtonControl).length) {
2533            $(this).attr({
2534              'aria-describedby': ariaButtonControl
2535            });
2536          }
2537        }
2538      });
2539
2540      _.$dots.attr('role', 'tablist').find('li').each(function (i) {
2541        var mappedSlideIndex = tabControlIndexes[i];
2542        $(this).attr({
2543          'role': 'presentation'
2544        });
2545        $(this).find('button').first().attr({
2546          'role': 'tab',
2547          'id': 'slick-slide-control' + _.instanceUid + i,
2548          'aria-controls': 'slick-slide' + _.instanceUid + mappedSlideIndex,
2549          'aria-label': i + 1 + ' of ' + numDotGroups,
2550          'aria-selected': null,
2551          'tabindex': '-1'
2552        });
2553      }).eq(_.currentSlide).find('button').attr({
2554        'aria-selected': 'true',
2555        'tabindex': '0'
2556      }).end();
2557    }
2558
2559    for (var i = _.currentSlide, max = i + _.options.slidesToShow; i < max; i++) {
2560      if (_.options.focusOnChange) {
2561        _.$slides.eq(i).attr({
2562          'tabindex': '0'
2563        });
2564      } else {
2565        _.$slides.eq(i).removeAttr('tabindex');
2566      }
2567    }
2568
2569    _.activateADA();
2570  };
2571
2572  Slick.prototype.initArrowEvents = function () {
2573    var _ = this;
2574
2575    if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2576      _.$prevArrow.off('click.slick').on('click.slick', {
2577        message: 'previous'
2578      }, _.changeSlide);
2579
2580      _.$nextArrow.off('click.slick').on('click.slick', {
2581        message: 'next'
2582      }, _.changeSlide);
2583
2584      if (_.options.accessibility === true) {
2585        _.$prevArrow.on('keydown.slick', _.keyHandler);
2586
2587        _.$nextArrow.on('keydown.slick', _.keyHandler);
2588      }
2589    }
2590  };
2591
2592  Slick.prototype.initDotEvents = function () {
2593    var _ = this;
2594
2595    if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2596      $('li', _.$dots).on('click.slick', {
2597        message: 'index'
2598      }, _.changeSlide);
2599
2600      if (_.options.accessibility === true) {
2601        _.$dots.on('keydown.slick', _.keyHandler);
2602      }
2603    }
2604
2605    if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.slideCount > _.options.slidesToShow) {
2606      $('li', _.$dots).on('mouseenter.slick', $.proxy(_.interrupt, _, true)).on('mouseleave.slick', $.proxy(_.interrupt, _, false));
2607    }
2608  };
2609
2610  Slick.prototype.initSlideEvents = function () {
2611    var _ = this;
2612
2613    if (_.options.pauseOnHover) {
2614      _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));
2615
2616      _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));
2617    }
2618  };
2619
2620  Slick.prototype.initializeEvents = function () {
2621    var _ = this;
2622
2623    _.initArrowEvents();
2624
2625    _.initDotEvents();
2626
2627    _.initSlideEvents();
2628
2629    _.$list.on('touchstart.slick mousedown.slick', {
2630      action: 'start'
2631    }, _.swipeHandler);
2632
2633    _.$list.on('touchmove.slick mousemove.slick', {
2634      action: 'move'
2635    }, _.swipeHandler);
2636
2637    _.$list.on('touchend.slick mouseup.slick', {
2638      action: 'end'
2639    }, _.swipeHandler);
2640
2641    _.$list.on('touchcancel.slick mouseleave.slick', {
2642      action: 'end'
2643    }, _.swipeHandler);
2644
2645    _.$list.on('click.slick', _.clickHandler);
2646
2647    $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
2648
2649    if (_.options.accessibility === true) {
2650      _.$list.on('keydown.slick', _.keyHandler);
2651    }
2652
2653    if (_.options.focusOnSelect === true) {
2654      $(_.$slideTrack).children().on('click.slick', _.selectHandler);
2655    }
2656
2657    $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
2658    $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
2659    $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
2660    $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
2661    $(_.setPosition);
2662  };
2663
2664  Slick.prototype.initUI = function () {
2665    var _ = this;
2666
2667    if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2668      _.$prevArrow.show();
2669
2670      _.$nextArrow.show();
2671    }
2672
2673    if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2674      _.$dots.show();
2675    }
2676  };
2677
2678  Slick.prototype.keyHandler = function (event) {
2679    var _ = this; //Dont slide if the cursor is inside the form fields and arrow keys are pressed
2680
2681
2682    if (!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
2683      if (event.keyCode === 37 && _.options.accessibility === true) {
2684        _.changeSlide({
2685          data: {
2686            message: _.options.rtl === true ? 'next' : 'previous'
2687          }
2688        });
2689      } else if (event.keyCode === 39 && _.options.accessibility === true) {
2690        _.changeSlide({
2691          data: {
2692            message: _.options.rtl === true ? 'previous' : 'next'
2693          }
2694        });
2695      }
2696    }
2697  };
2698
2699  Slick.prototype.lazyLoad = function () {
2700    var _ = this,
2701        loadRange,
2702        cloneRange,
2703        rangeStart,
2704        rangeEnd;
2705
2706    function loadImages(imagesScope) {
2707      $('img[data-lazy]', imagesScope).each(function () {
2708        var image = $(this),
2709            imageSource = $(this).attr('data-lazy'),
2710            imageSrcSet = $(this).attr('data-srcset'),
2711            imageSizes = $(this).attr('data-sizes') || _.$slider.attr('data-sizes'),
2712            imageToLoad = document.createElement('img');
2713
2714        imageToLoad.onload = function () {
2715          image.animate({
2716            opacity: 0
2717          }, 100, function () {
2718            if (imageSrcSet) {
2719              image.attr('srcset', imageSrcSet);
2720
2721              if (imageSizes) {
2722                image.attr('sizes', imageSizes);
2723              }
2724            }
2725
2726            image.attr('src', imageSource).animate({
2727              opacity: 1
2728            }, 200, function () {
2729              image.removeAttr('data-lazy data-srcset data-sizes').removeClass('slick-loading');
2730            });
2731
2732            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
2733          });
2734        };
2735
2736        imageToLoad.onerror = function () {
2737          image.removeAttr('data-lazy').removeClass('slick-loading').addClass('slick-lazyload-error');
2738
2739          _.$slider.trigger('lazyLoadError', [_, image, imageSource]);
2740        };
2741
2742        imageToLoad.src = imageSource;
2743      });
2744    }
2745
2746    if (_.options.centerMode === true) {
2747      if (_.options.infinite === true) {
2748        rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
2749        rangeEnd = rangeStart + _.options.slidesToShow + 2;
2750      } else {
2751        rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
2752        rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
2753      }
2754    } else {
2755      rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
2756      rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
2757
2758      if (_.options.fade === true) {
2759        if (rangeStart > 0) rangeStart--;
2760        if (rangeEnd <= _.slideCount) rangeEnd++;
2761      }
2762    }
2763
2764    loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
2765
2766    if (_.options.lazyLoad === 'anticipated') {
2767      var prevSlide = rangeStart - 1,
2768          nextSlide = rangeEnd,
2769          $slides = _.$slider.find('.slick-slide');
2770
2771      for (var i = 0; i < _.options.slidesToScroll; i++) {
2772        if (prevSlide < 0) prevSlide = _.slideCount - 1;
2773        loadRange = loadRange.add($slides.eq(prevSlide));
2774        loadRange = loadRange.add($slides.eq(nextSlide));
2775        prevSlide--;
2776        nextSlide++;
2777      }
2778    }
2779
2780    loadImages(loadRange);
2781
2782    if (_.slideCount <= _.options.slidesToShow) {
2783      cloneRange = _.$slider.find('.slick-slide');
2784      loadImages(cloneRange);
2785    } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
2786      cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
2787      loadImages(cloneRange);
2788    } else if (_.currentSlide === 0) {
2789      cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
2790      loadImages(cloneRange);
2791    }
2792  };
2793
2794  Slick.prototype.loadSlider = function () {
2795    var _ = this;
2796
2797    _.setPosition();
2798
2799    _.$slideTrack.css({
2800      opacity: 1
2801    });
2802
2803    _.$slider.removeClass('slick-loading');
2804
2805    _.initUI();
2806
2807    if (_.options.lazyLoad === 'progressive') {
2808      _.progressiveLazyLoad();
2809    }
2810  };
2811
2812  Slick.prototype.next = Slick.prototype.slickNext = function () {
2813    var _ = this;
2814
2815    _.changeSlide({
2816      data: {
2817        message: 'next'
2818      }
2819    });
2820  };
2821
2822  Slick.prototype.orientationChange = function () {
2823    var _ = this;
2824
2825    _.checkResponsive();
2826
2827    _.setPosition();
2828  };
2829
2830  Slick.prototype.pause = Slick.prototype.slickPause = function () {
2831    var _ = this;
2832
2833    _.autoPlayClear();
2834
2835    _.paused = true;
2836  };
2837
2838  Slick.prototype.play = Slick.prototype.slickPlay = function () {
2839    var _ = this;
2840
2841    _.autoPlay();
2842
2843    _.options.autoplay = true;
2844    _.paused = false;
2845    _.focussed = false;
2846    _.interrupted = false;
2847  };
2848
2849  Slick.prototype.postSlide = function (index) {
2850    var _ = this;
2851
2852    if (!_.unslicked) {
2853      _.$slider.trigger('afterChange', [_, index]);
2854
2855      _.animating = false;
2856
2857      if (_.slideCount > _.options.slidesToShow) {
2858        _.setPosition();
2859      }
2860
2861      _.swipeLeft = null;
2862
2863      if (_.options.autoplay) {
2864        _.autoPlay();
2865      }
2866
2867      if (_.options.accessibility === true) {
2868        _.initADA();
2869
2870        if (_.options.focusOnChange) {
2871          var $currentSlide = $(_.$slides.get(_.currentSlide));
2872          $currentSlide.attr('tabindex', 0).focus();
2873        }
2874      }
2875    }
2876  };
2877
2878  Slick.prototype.prev = Slick.prototype.slickPrev = function () {
2879    var _ = this;
2880
2881    _.changeSlide({
2882      data: {
2883        message: 'previous'
2884      }
2885    });
2886  };
2887
2888  Slick.prototype.preventDefault = function (event) {
2889    event.preventDefault();
2890  };
2891
2892  Slick.prototype.progressiveLazyLoad = function (tryCount) {
2893    tryCount = tryCount || 1;
2894
2895    var _ = this,
2896        $imgsToLoad = $('img[data-lazy]', _.$slider),
2897        image,
2898        imageSource,
2899        imageSrcSet,
2900        imageSizes,
2901        imageToLoad;
2902
2903    if ($imgsToLoad.length) {
2904      image = $imgsToLoad.first();
2905      imageSource = image.attr('data-lazy');
2906      imageSrcSet = image.attr('data-srcset');
2907      imageSizes = image.attr('data-sizes') || _.$slider.attr('data-sizes');
2908      imageToLoad = document.createElement('img');
2909
2910      imageToLoad.onload = function () {
2911        if (imageSrcSet) {
2912          image.attr('srcset', imageSrcSet);
2913
2914          if (imageSizes) {
2915            image.attr('sizes', imageSizes);
2916          }
2917        }
2918
2919        image.attr('src', imageSource).removeAttr('data-lazy data-srcset data-sizes').removeClass('slick-loading');
2920
2921        if (_.options.adaptiveHeight === true) {
2922          _.setPosition();
2923        }
2924
2925        _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
2926
2927        _.progressiveLazyLoad();
2928      };
2929
2930      imageToLoad.onerror = function () {
2931        if (tryCount < 3) {
2932          /**
2933           * try to load the image 3 times,
2934           * leave a slight delay so we don't get
2935           * servers blocking the request.
2936           */
2937          setTimeout(function () {
2938            _.progressiveLazyLoad(tryCount + 1);
2939          }, 500);
2940        } else {
2941          image.removeAttr('data-lazy').removeClass('slick-loading').addClass('slick-lazyload-error');
2942
2943          _.$slider.trigger('lazyLoadError', [_, image, imageSource]);
2944
2945          _.progressiveLazyLoad();
2946        }
2947      };
2948
2949      imageToLoad.src = imageSource;
2950    } else {
2951      _.$slider.trigger('allImagesLoaded', [_]);
2952    }
2953  };
2954
2955  Slick.prototype.refresh = function (initializing) {
2956    var _ = this,
2957        currentSlide,
2958        lastVisibleIndex;
2959
2960    lastVisibleIndex = _.slideCount - _.options.slidesToShow; // in non-infinite sliders, we don't want to go past the
2961    // last visible index.
2962
2963    if (!_.options.infinite && _.currentSlide > lastVisibleIndex) {
2964      _.currentSlide = lastVisibleIndex;
2965    } // if less slides than to show, go to start.
2966
2967
2968    if (_.slideCount <= _.options.slidesToShow) {
2969      _.currentSlide = 0;
2970    }
2971
2972    currentSlide = _.currentSlide;
2973
2974    _.destroy(true);
2975
2976    $.extend(_, _.initials, {
2977      currentSlide: currentSlide
2978    });
2979
2980    _.init();
2981
2982    if (!initializing) {
2983      _.changeSlide({
2984        data: {
2985          message: 'index',
2986          index: currentSlide
2987        }
2988      }, false);
2989    }
2990  };
2991
2992  Slick.prototype.registerBreakpoints = function () {
2993    var _ = this,
2994        breakpoint,
2995        currentBreakpoint,
2996        l,
2997        responsiveSettings = _.options.responsive || null;
2998
2999    if ($.type(responsiveSettings) === 'array' && responsiveSettings.length) {
3000      _.respondTo = _.options.respondTo || 'window';
3001
3002      for (breakpoint in responsiveSettings) {
3003        l = _.breakpoints.length - 1;
3004
3005        if (responsiveSettings.hasOwnProperty(breakpoint)) {
3006          currentBreakpoint = responsiveSettings[breakpoint].breakpoint; // loop through the breakpoints and cut out any existing
3007          // ones with the same breakpoint number, we don't want dupes.
3008
3009          while (l >= 0) {
3010            if (_.breakpoints[l] && _.breakpoints[l] === currentBreakpoint) {
3011              _.breakpoints.splice(l, 1);
3012            }
3013
3014            l--;
3015          }
3016
3017          _.breakpoints.push(currentBreakpoint);
3018
3019          _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
3020        }
3021      }
3022
3023      _.breakpoints.sort(function (a, b) {
3024        return _.options.mobileFirst ? a - b : b - a;
3025      });
3026    }
3027  };
3028
3029  Slick.prototype.reinit = function () {
3030    var _ = this;
3031
3032    _.$slides = _.$slideTrack.children(_.options.slide).addClass('slick-slide');
3033    _.slideCount = _.$slides.length;
3034
3035    if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
3036      _.currentSlide = _.currentSlide - _.options.slidesToScroll;
3037    }
3038
3039    if (_.slideCount <= _.options.slidesToShow) {
3040      _.currentSlide = 0;
3041    }
3042
3043    _.registerBreakpoints();
3044
3045    _.setProps();
3046
3047    _.setupInfinite();
3048
3049    _.buildArrows();
3050
3051    _.updateArrows();
3052
3053    _.initArrowEvents();
3054
3055    _.buildDots();
3056
3057    _.updateDots();
3058
3059    _.initDotEvents();
3060
3061    _.cleanUpSlideEvents();
3062
3063    _.initSlideEvents();
3064
3065    _.checkResponsive(false, true);
3066
3067    if (_.options.focusOnSelect === true) {
3068      $(_.$slideTrack).children().on('click.slick', _.selectHandler);
3069    }
3070
3071    _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
3072
3073    _.setPosition();
3074
3075    _.focusHandler();
3076
3077    _.paused = !_.options.autoplay;
3078
3079    _.autoPlay();
3080
3081    _.$slider.trigger('reInit', [_]);
3082  };
3083
3084  Slick.prototype.resize = function () {
3085    var _ = this;
3086
3087    if ($(window).width() !== _.windowWidth) {
3088      clearTimeout(_.windowDelay);
3089      _.windowDelay = window.setTimeout(function () {
3090        _.windowWidth = $(window).width();
3091
3092        _.checkResponsive();
3093
3094        if (!_.unslicked) {
3095          _.setPosition();
3096        }
3097      }, 50);
3098    }
3099  };
3100
3101  Slick.prototype.removeSlide = Slick.prototype.slickRemove = function (index, removeBefore, removeAll) {
3102    var _ = this;
3103
3104    if (typeof index === 'boolean') {
3105      removeBefore = index;
3106      index = removeBefore === true ? 0 : _.slideCount - 1;
3107    } else {
3108      index = removeBefore === true ? --index : index;
3109    }
3110
3111    if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
3112      return false;
3113    }
3114
3115    _.unload();
3116
3117    if (removeAll === true) {
3118      _.$slideTrack.children().remove();
3119    } else {
3120      _.$slideTrack.children(this.options.slide).eq(index).remove();
3121    }
3122
3123    _.$slides = _.$slideTrack.children(this.options.slide);
3124
3125    _.$slideTrack.children(this.options.slide).detach();
3126
3127    _.$slideTrack.append(_.$slides);
3128
3129    _.$slidesCache = _.$slides;
3130
3131    _.reinit();
3132  };
3133
3134  Slick.prototype.setCSS = function (position) {
3135    var _ = this,
3136        positionProps = {},
3137        x,
3138        y;
3139
3140    if (_.options.rtl === true) {
3141      position = -position;
3142    }
3143
3144    x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
3145    y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
3146    positionProps[_.positionProp] = position;
3147
3148    if (_.transformsEnabled === false) {
3149      _.$slideTrack.css(positionProps);
3150    } else {
3151      positionProps = {};
3152
3153      if (_.cssTransitions === false) {
3154        positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
3155
3156        _.$slideTrack.css(positionProps);
3157      } else {
3158        positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
3159
3160        _.$slideTrack.css(positionProps);
3161      }
3162    }
3163  };
3164
3165  Slick.prototype.setDimensions = function () {
3166    var _ = this;
3167
3168    if (_.options.vertical === false) {
3169      if (_.options.centerMode === true) {
3170        _.$list.css({
3171          padding: '0px ' + _.options.centerPadding
3172        });
3173      }
3174    } else {
3175      _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
3176
3177      if (_.options.centerMode === true) {
3178        _.$list.css({
3179          padding: _.options.centerPadding + ' 0px'
3180        });
3181      }
3182    }
3183
3184    _.listWidth = _.$list.width();
3185    _.listHeight = _.$list.height();
3186
3187    if (_.options.vertical === false && _.options.variableWidth === false) {
3188      _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
3189
3190      _.$slideTrack.width(Math.ceil(_.slideWidth * _.$slideTrack.children('.slick-slide').length));
3191    } else if (_.options.variableWidth === true) {
3192      _.$slideTrack.width(5000 * _.slideCount);
3193    } else {
3194      _.slideWidth = Math.ceil(_.listWidth);
3195
3196      _.$slideTrack.height(Math.ceil(_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length));
3197    }
3198
3199    var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
3200
3201    if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
3202  };
3203
3204  Slick.prototype.setFade = function () {
3205    var _ = this,
3206        targetLeft;
3207
3208    _.$slides.each(function (index, element) {
3209      targetLeft = _.slideWidth * index * -1;
3210
3211      if (_.options.rtl === true) {
3212        $(element).css({
3213          position: 'relative',
3214          right: targetLeft,
3215          top: 0,
3216          zIndex: _.options.zIndex - 2,
3217          opacity: 0
3218        });
3219      } else {
3220        $(element).css({
3221          position: 'relative',
3222          left: targetLeft,
3223          top: 0,
3224          zIndex: _.options.zIndex - 2,
3225          opacity: 0
3226        });
3227      }
3228    });
3229
3230    _.$slides.eq(_.currentSlide).css({
3231      zIndex: _.options.zIndex - 1,
3232      opacity: 1
3233    });
3234  };
3235
3236  Slick.prototype.setHeight = function () {
3237    var _ = this;
3238
3239    if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
3240      var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
3241
3242      _.$list.css('height', targetHeight);
3243    }
3244  };
3245
3246  Slick.prototype.setOption = Slick.prototype.slickSetOption = function () {
3247    /**
3248     * accepts arguments in format of:
3249     *
3250     *  - for changing a single option's value:
3251     *     .slick("setOption", option, value, refresh )
3252     *
3253     *  - for changing a set of responsive options:
3254     *     .slick("setOption", 'responsive', [{}, ...], refresh )
3255     *
3256     *  - for updating multiple values at once (not responsive)
3257     *     .slick("setOption", { 'option': value, ... }, refresh )
3258     */
3259    var _ = this,
3260        l,
3261        item,
3262        option,
3263        value,
3264        refresh = false,
3265        type;
3266
3267    if ($.type(arguments[0]) === 'object') {
3268      option = arguments[0];
3269      refresh = arguments[1];
3270      type = 'multiple';
3271    } else if ($.type(arguments[0]) === 'string') {
3272      option = arguments[0];
3273      value = arguments[1];
3274      refresh = arguments[2];
3275
3276      if (arguments[0] === 'responsive' && $.type(arguments[1]) === 'array') {
3277        type = 'responsive';
3278      } else if (typeof arguments[1] !== 'undefined') {
3279        type = 'single';
3280      }
3281    }
3282
3283    if (type === 'single') {
3284      _.options[option] = value;
3285    } else if (type === 'multiple') {
3286      $.each(option, function (opt, val) {
3287        _.options[opt] = val;
3288      });
3289    } else if (type === 'responsive') {
3290      for (item in value) {
3291        if ($.type(_.options.responsive) !== 'array') {
3292          _.options.responsive = [value[item]];
3293        } else {
3294          l = _.options.responsive.length - 1; // loop through the responsive object and splice out duplicates.
3295
3296          while (l >= 0) {
3297            if (_.options.responsive[l].breakpoint === value[item].breakpoint) {
3298              _.options.responsive.splice(l, 1);
3299            }
3300
3301            l--;
3302          }
3303
3304          _.options.responsive.push(value[item]);
3305        }
3306      }
3307    }
3308
3309    if (refresh) {
3310      _.unload();
3311
3312      _.reinit();
3313    }
3314  };
3315
3316  Slick.prototype.setPosition = function () {
3317    var _ = this;
3318
3319    _.setDimensions();
3320
3321    _.setHeight();
3322
3323    if (_.options.fade === false) {
3324      _.setCSS(_.getLeft(_.currentSlide));
3325    } else {
3326      _.setFade();
3327    }
3328
3329    _.$slider.trigger('setPosition', [_]);
3330  };
3331
3332  Slick.prototype.setProps = function () {
3333    var _ = this,
3334        bodyStyle = document.body.style;
3335
3336    _.positionProp = _.options.vertical === true ? 'top' : 'left';
3337
3338    if (_.positionProp === 'top') {
3339      _.$slider.addClass('slick-vertical');
3340    } else {
3341      _.$slider.removeClass('slick-vertical');
3342    }
3343
3344    if (bodyStyle.WebkitTransition !== undefined || bodyStyle.MozTransition !== undefined || bodyStyle.msTransition !== undefined) {
3345      if (_.options.useCSS === true) {
3346        _.cssTransitions = true;
3347      }
3348    }
3349
3350    if (_.options.fade) {
3351      if (typeof _.options.zIndex === 'number') {
3352        if (_.options.zIndex < 3) {
3353          _.options.zIndex = 3;
3354        }
3355      } else {
3356        _.options.zIndex = _.defaults.zIndex;
3357      }
3358    }
3359
3360    if (bodyStyle.OTransform !== undefined) {
3361      _.animType = 'OTransform';
3362      _.transformType = '-o-transform';
3363      _.transitionType = 'OTransition';
3364      if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
3365    }
3366
3367    if (bodyStyle.MozTransform !== undefined) {
3368      _.animType = 'MozTransform';
3369      _.transformType = '-moz-transform';
3370      _.transitionType = 'MozTransition';
3371      if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
3372    }
3373
3374    if (bodyStyle.webkitTransform !== undefined) {
3375      _.animType = 'webkitTransform';
3376      _.transformType = '-webkit-transform';
3377      _.transitionType = 'webkitTransition';
3378      if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
3379    }
3380
3381    if (bodyStyle.msTransform !== undefined) {
3382      _.animType = 'msTransform';
3383      _.transformType = '-ms-transform';
3384      _.transitionType = 'msTransition';
3385      if (bodyStyle.msTransform === undefined) _.animType = false;
3386    }
3387
3388    if (bodyStyle.transform !== undefined && _.animType !== false) {
3389      _.animType = 'transform';
3390      _.transformType = 'transform';
3391      _.transitionType = 'transition';
3392    }
3393
3394    _.transformsEnabled = _.options.useTransform && _.animType !== null && _.animType !== false;
3395  };
3396
3397  Slick.prototype.setSlideClasses = function (index) {
3398    var _ = this,
3399        centerOffset,
3400        allSlides,
3401        indexOffset,
3402        remainder;
3403
3404    allSlides = _.$slider.find('.slick-slide').removeClass('slick-active slick-center slick-current').attr('aria-hidden', 'true');
3405
3406    _.$slides.eq(index).addClass('slick-current');
3407
3408    if (_.options.centerMode === true) {
3409      var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0;
3410      centerOffset = Math.floor(_.options.slidesToShow / 2);
3411
3412      if (_.options.infinite === true) {
3413        if (index >= centerOffset && index <= _.slideCount - 1 - centerOffset) {
3414          _.$slides.slice(index - centerOffset + evenCoef, index + centerOffset + 1).addClass('slick-active').attr('aria-hidden', 'false');
3415        } else {
3416          indexOffset = _.options.slidesToShow + index;
3417          allSlides.slice(indexOffset - centerOffset + 1 + evenCoef, indexOffset + centerOffset + 2).addClass('slick-active').attr('aria-hidden', 'false');
3418        }
3419
3420        if (index === 0) {
3421          allSlides.eq(_.options.slidesToShow + _.slideCount + 1).addClass('slick-center');
3422        } else if (index === _.slideCount - 1) {
3423          allSlides.eq(_.options.slidesToShow).addClass('slick-center');
3424        }
3425      }
3426
3427      _.$slides.eq(index).addClass('slick-center');
3428    } else {
3429      if (index >= 0 && index <= _.slideCount - _.options.slidesToShow) {
3430        _.$slides.slice(index, index + _.options.slidesToShow).addClass('slick-active').attr('aria-hidden', 'false');
3431      } else if (allSlides.length <= _.options.slidesToShow) {
3432        allSlides.addClass('slick-active').attr('aria-hidden', 'false');
3433      } else {
3434        remainder = _.slideCount % _.options.slidesToShow;
3435        indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
3436
3437        if (_.options.slidesToShow == _.options.slidesToScroll && _.slideCount - index < _.options.slidesToShow) {
3438          allSlides.slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder).addClass('slick-active').attr('aria-hidden', 'false');
3439        } else {
3440          allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active').attr('aria-hidden', 'false');
3441        }
3442      }
3443    }
3444
3445    if (_.options.lazyLoad === 'ondemand' || _.options.lazyLoad === 'anticipated') {
3446      _.lazyLoad();
3447    }
3448  };
3449
3450  Slick.prototype.setupInfinite = function () {
3451    var _ = this,
3452        i,
3453        slideIndex,
3454        infiniteCount;
3455
3456    if (_.options.fade === true) {
3457      _.options.centerMode = false;
3458    }
3459
3460    if (_.options.infinite === true && _.options.fade === false) {
3461      slideIndex = null;
3462
3463      if (_.slideCount > _.options.slidesToShow) {
3464        if (_.options.centerMode === true) {
3465          infiniteCount = _.options.slidesToShow + 1;
3466        } else {
3467          infiniteCount = _.options.slidesToShow;
3468        }
3469
3470        for (i = _.slideCount; i > _.slideCount - infiniteCount; i -= 1) {
3471          slideIndex = i - 1;
3472          $(_.$slides[slideIndex]).clone(true).attr('id', '').attr('data-slick-index', slideIndex - _.slideCount).prependTo(_.$slideTrack).addClass('slick-cloned');
3473        }
3474
3475        for (i = 0; i < infiniteCount + _.slideCount; i += 1) {
3476          slideIndex = i;
3477          $(_.$slides[slideIndex]).clone(true).attr('id', '').attr('data-slick-index', slideIndex + _.slideCount).appendTo(_.$slideTrack).addClass('slick-cloned');
3478        }
3479
3480        _.$slideTrack.find('.slick-cloned').find('[id]').each(function () {
3481          $(this).attr('id', '');
3482        });
3483      }
3484    }
3485  };
3486
3487  Slick.prototype.interrupt = function (toggle) {
3488    var _ = this;
3489
3490    if (!toggle) {
3491      _.autoPlay();
3492    }
3493
3494    _.interrupted = toggle;
3495  };
3496
3497  Slick.prototype.selectHandler = function (event) {
3498    var _ = this;
3499
3500    var targetElement = $(event.target).is('.slick-slide') ? $(event.target) : $(event.target).parents('.slick-slide');
3501    var index = parseInt(targetElement.attr('data-slick-index'));
3502    if (!index) index = 0;
3503
3504    if (_.slideCount <= _.options.slidesToShow) {
3505      _.slideHandler(index, false, true);
3506
3507      return;
3508    }
3509
3510    _.slideHandler(index);
3511  };
3512
3513  Slick.prototype.slideHandler = function (index, sync, dontAnimate) {
3514    var targetSlide,
3515        animSlide,
3516        oldSlide,
3517        slideLeft,
3518        targetLeft = null,
3519        _ = this,
3520        navTarget;
3521
3522    sync = sync || false;
3523
3524    if (_.animating === true && _.options.waitForAnimate === true) {
3525      return;
3526    }
3527
3528    if (_.options.fade === true && _.currentSlide === index) {
3529      return;
3530    }
3531
3532    if (sync === false) {
3533      _.asNavFor(index);
3534    }
3535
3536    targetSlide = index;
3537    targetLeft = _.getLeft(targetSlide);
3538    slideLeft = _.getLeft(_.currentSlide);
3539    _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
3540
3541    if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
3542      if (_.options.fade === false) {
3543        targetSlide = _.currentSlide;
3544
3545        if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
3546          _.animateSlide(slideLeft, function () {
3547            _.postSlide(targetSlide);
3548          });
3549        } else {
3550          _.postSlide(targetSlide);
3551        }
3552      }
3553
3554      return;
3555    } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > _.slideCount - _.options.slidesToScroll)) {
3556      if (_.options.fade === false) {
3557        targetSlide = _.currentSlide;
3558
3559        if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
3560          _.animateSlide(slideLeft, function () {
3561            _.postSlide(targetSlide);
3562          });
3563        } else {
3564          _.postSlide(targetSlide);
3565        }
3566      }
3567
3568      return;
3569    }
3570
3571    if (_.options.autoplay) {
3572      clearInterval(_.autoPlayTimer);
3573    }
3574