https://www.asmodee.it/wp-content/themes/unboxnow-du/ui/build/old.DQ14k1v8.js?v=1790082574

1011
1012}
1013
1014/**
1015 * Checks if `value` is the
1016 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
1017 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
1018 *
1019 * @static
1020 * @memberOf _
1021 * @since 0.1.0
1022 * @category Lang
1023 * @param {*} value The value to check.
1024 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
1025 * @example
1026 *
1027 * _.isObject({});
1028 * // => true
1029 *
1030 * _.isObject([1, 2, 3]);
1031 * // => true
1032 *
1033 * _.isObject(_.noop);
1034 * // => true
1035 *
1036 * _.isObject(null);
1037 * // => false
1038 */
1039
1040var isObject_1;
1041var hasRequiredIsObject;
1042
1043function requireIsObject () {
1044	if (hasRequiredIsObject) return isObject_1;
1045	hasRequiredIsObject = 1;
1046	function isObject(value) {
1047	  var type = typeof value;
1048	  return value != null && (type == 'object' || type == 'function');
1049	}
1050
1051	isObject_1 = isObject;
1052	return isObject_1;
1053}
1054
1055/** Detect free variable `global` from Node.js. */
1056
1057var _freeGlobal;
1058var hasRequired_freeGlobal;
1059
1060function require_freeGlobal () {
1061	if (hasRequired_freeGlobal) return _freeGlobal;
1062	hasRequired_freeGlobal = 1;
1063	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
1064
1065	_freeGlobal = freeGlobal;
1066	return _freeGlobal;
1067}
1068
1069var _root;
1070var hasRequired_root;
1071
1072function require_root () {
1073	if (hasRequired_root) return _root;
1074	hasRequired_root = 1;
1075	var freeGlobal = require_freeGlobal();
1076
1077	/** Detect free variable `self`. */
1078	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
1079
1080	/** Used as a reference to the global object. */
1081	var root = freeGlobal || freeSelf || Function('return this')();
1082
1083	_root = root;
1084	return _root;
1085}
1086
1087var now_1;
1088var hasRequiredNow;
1089
1090function requireNow () {
1091	if (hasRequiredNow) return now_1;
1092	hasRequiredNow = 1;
1093	var root = require_root();
1094
1095	/**
1096	 * Gets the timestamp of the number of milliseconds that have elapsed since
1097	 * the Unix epoch (1 January 1970 00:00:00 UTC).
1098	 *
1099	 * @static
1100	 * @memberOf _
1101	 * @since 2.4.0
1102	 * @category Date
1103	 * @returns {number} Returns the timestamp.
1104	 * @example
1105	 *
1106	 * _.defer(function(stamp) {
1107	 *   console.log(_.now() - stamp);
1108	 * }, _.now());
1109	 * // => Logs the number of milliseconds it took for the deferred invocation.
1110	 */
1111	var now = function() {
1112	  return root.Date.now();
1113	};
1114
1115	now_1 = now;
1116	return now_1;
1117}
1118
1119/** Used to match a single whitespace character. */
1120
1121var _trimmedEndIndex;
1122var hasRequired_trimmedEndIndex;
1123
1124function require_trimmedEndIndex () {
1125	if (hasRequired_trimmedEndIndex) return _trimmedEndIndex;
1126	hasRequired_trimmedEndIndex = 1;
1127	var reWhitespace = /\s/;
1128
1129	/**
1130	 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
1131	 * character of `string`.
1132	 *
1133	 * @private
1134	 * @param {string} string The string to inspect.
1135	 * @returns {number} Returns the index of the last non-whitespace character.
1136	 */
1137	function trimmedEndIndex(string) {
1138	  var index = string.length;
1139
1140	  while (index-- && reWhitespace.test(string.charAt(index))) {}
1141	  return index;
1142	}
1143
1144	_trimmedEndIndex = trimmedEndIndex;
1145	return _trimmedEndIndex;
1146}
1147
1148var _baseTrim;
1149var hasRequired_baseTrim;
1150
1151function require_baseTrim () {
1152	if (hasRequired_baseTrim) return _baseTrim;
1153	hasRequired_baseTrim = 1;
1154	var trimmedEndIndex = require_trimmedEndIndex();
1155
1156	/** Used to match leading whitespace. */
1157	var reTrimStart = /^\s+/;
1158
1159	/**
1160	 * The base implementation of `_.trim`.
1161	 *
1162	 * @private
1163	 * @param {string} string The string to trim.
1164	 * @returns {string} Returns the trimmed string.
1165	 */
1166	function baseTrim(string) {
1167	  return string
1168	    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
1169	    : string;
1170	}
1171
1172	_baseTrim = baseTrim;
1173	return _baseTrim;
1174}
1175
1176var _Symbol;
1177var hasRequired_Symbol;
1178
1179function require_Symbol () {
1180	if (hasRequired_Symbol) return _Symbol;
1181	hasRequired_Symbol = 1;
1182	var root = require_root();
1183
1184	/** Built-in value references. */
1185	var Symbol = root.Symbol;
1186
1187	_Symbol = Symbol;
1188	return _Symbol;
1189}
1190
1191var _getRawTag;
1192var hasRequired_getRawTag;
1193
1194function require_getRawTag () {
1195	if (hasRequired_getRawTag) return _getRawTag;
1196	hasRequired_getRawTag = 1;
1197	var Symbol = require_Symbol();
1198
1199	/** Used for built-in method references. */
1200	var objectProto = Object.prototype;
1201
1202	/** Used to check objects for own properties. */
1203	var hasOwnProperty = objectProto.hasOwnProperty;
1204
1205	/**
1206	 * Used to resolve the
1207	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
1208	 * of values.
1209	 */
1210	var nativeObjectToString = objectProto.toString;
1211
1212	/** Built-in value references. */
1213	var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
1214
1215	/**
1216	 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
1217	 *
1218	 * @private
1219	 * @param {*} value The value to query.
1220	 * @returns {string} Returns the raw `toStringTag`.
1221	 */
1222	function getRawTag(value) {
1223	  var isOwn = hasOwnProperty.call(value, symToStringTag),
1224	      tag = value[symToStringTag];
1225
1226	  try {
1227	    value[symToStringTag] = undefined;
1228	    var unmasked = true;
1229	  } catch (e) {}
1230
1231	  var result = nativeObjectToString.call(value);
1232	  if (unmasked) {
1233	    if (isOwn) {
1234	      value[symToStringTag] = tag;
1235	    } else {
1236	      delete value[symToStringTag];
1237	    }
1238	  }
1239	  return result;
1240	}
1241
1242	_getRawTag = getRawTag;
1243	return _getRawTag;
1244}
1245
1246/** Used for built-in method references. */
1247
1248var _objectToString;
1249var hasRequired_objectToString;
1250
1251function require_objectToString () {
1252	if (hasRequired_objectToString) return _objectToString;
1253	hasRequired_objectToString = 1;
1254	var objectProto = Object.prototype;
1255
1256	/**
1257	 * Used to resolve the
1258	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
1259	 * of values.
1260	 */
1261	var nativeObjectToString = objectProto.toString;
1262
1263	/**
1264	 * Converts `value` to a string using `Object.prototype.toString`.
1265	 *
1266	 * @private
1267	 * @param {*} value The value to convert.
1268	 * @returns {string} Returns the converted string.
1269	 */
1270	function objectToString(value) {
1271	  return nativeObjectToString.call(value);
1272	}
1273
1274	_objectToString = objectToString;
1275	return _objectToString;
1276}
1277
1278var _baseGetTag;
1279var hasRequired_baseGetTag;
1280
1281function require_baseGetTag () {
1282	if (hasRequired_baseGetTag) return _baseGetTag;
1283	hasRequired_baseGetTag = 1;
1284	var Symbol = require_Symbol(),
1285	    getRawTag = require_getRawTag(),
1286	    objectToString = require_objectToString();
1287
1288	/** `Object#toString` result references. */
1289	var nullTag = '[object Null]',
1290	    undefinedTag = '[object Undefined]';
1291
1292	/** Built-in value references. */
1293	var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
1294
1295	/**
1296	 * The base implementation of `getTag` without fallbacks for buggy environments.
1297	 *
1298	 * @private
1299	 * @param {*} value The value to query.
1300	 * @returns {string} Returns the `toStringTag`.
1301	 */
1302	function baseGetTag(value) {
1303	  if (value == null) {
1304	    return value === undefined ? undefinedTag : nullTag;
1305	  }
1306	  return (symToStringTag && symToStringTag in Object(value))
1307	    ? getRawTag(value)
1308	    : objectToString(value);
1309	}
1310
1311	_baseGetTag = baseGetTag;
1312	return _baseGetTag;
1313}
1314
1315/**
1316 * Checks if `value` is object-like. A value is object-like if it's not `null`
1317 * and has a `typeof` result of "object".
1318 *
1319 * @static
1320 * @memberOf _
1321 * @since 4.0.0
1322 * @category Lang
1323 * @param {*} value The value to check.
1324 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
1325 * @example
1326 *
1327 * _.isObjectLike({});
1328 * // => true
1329 *
1330 * _.isObjectLike([1, 2, 3]);
1331 * // => true
1332 *
1333 * _.isObjectLike(_.noop);
1334 * // => false
1335 *
1336 * _.isObjectLike(null);
1337 * // => false
1338 */
1339
1340var isObjectLike_1;
1341var hasRequiredIsObjectLike;
1342
1343function requireIsObjectLike () {
1344	if (hasRequiredIsObjectLike) return isObjectLike_1;
1345	hasRequiredIsObjectLike = 1;
1346	function isObjectLike(value) {
1347	  return value != null && typeof value == 'object';
1348	}
1349
1350	isObjectLike_1 = isObjectLike;
1351	return isObjectLike_1;
1352}
1353
1354var isSymbol_1;
1355var hasRequiredIsSymbol;
1356
1357function requireIsSymbol () {
1358	if (hasRequiredIsSymbol) return isSymbol_1;
1359	hasRequiredIsSymbol = 1;
1360	var baseGetTag = require_baseGetTag(),
1361	    isObjectLike = requireIsObjectLike();
1362
1363	/** `Object#toString` result references. */
1364	var symbolTag = '[object Symbol]';
1365
1366	/**
1367	 * Checks if `value` is classified as a `Symbol` primitive or object.
1368	 *
1369	 * @static
1370	 * @memberOf _
1371	 * @since 4.0.0
1372	 * @category Lang
1373	 * @param {*} value The value to check.
1374	 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
1375	 * @example
1376	 *
1377	 * _.isSymbol(Symbol.iterator);
1378	 * // => true
1379	 *
1380	 * _.isSymbol('abc');
1381	 * // => false
1382	 */
1383	function isSymbol(value) {
1384	  return typeof value == 'symbol' ||
1385	    (isObjectLike(value) && baseGetTag(value) == symbolTag);
1386	}
1387
1388	isSymbol_1 = isSymbol;
1389	return isSymbol_1;
1390}
1391
1392var toNumber_1;
1393var hasRequiredToNumber;
1394
1395function requireToNumber () {
1396	if (hasRequiredToNumber) return toNumber_1;
1397	hasRequiredToNumber = 1;
1398	var baseTrim = require_baseTrim(),
1399	    isObject = requireIsObject(),
1400	    isSymbol = requireIsSymbol();
1401
1402	/** Used as references for various `Number` constants. */
1403	var NAN = 0 / 0;
1404
1405	/** Used to detect bad signed hexadecimal string values. */
1406	var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
1407
1408	/** Used to detect binary string values. */
1409	var reIsBinary = /^0b[01]+$/i;
1410
1411	/** Used to detect octal string values. */
1412	var reIsOctal = /^0o[0-7]+$/i;
1413
1414	/** Built-in method references without a dependency on `root`. */
1415	var freeParseInt = parseInt;
1416
1417	/**
1418	 * Converts `value` to a number.
1419	 *
1420	 * @static
1421	 * @memberOf _
1422	 * @since 4.0.0
1423	 * @category Lang
1424	 * @param {*} value The value to process.
1425	 * @returns {number} Returns the number.
1426	 * @example
1427	 *
1428	 * _.toNumber(3.2);
1429	 * // => 3.2
1430	 *
1431	 * _.toNumber(Number.MIN_VALUE);
1432	 * // => 5e-324
1433	 *
1434	 * _.toNumber(Infinity);
1435	 * // => Infinity
1436	 *
1437	 * _.toNumber('3.2');
1438	 * // => 3.2
1439	 */
1440	function toNumber(value) {
1441	  if (typeof value == 'number') {
1442	    return value;
1443	  }
1444	  if (isSymbol(value)) {
1445	    return NAN;
1446	  }
1447	  if (isObject(value)) {
1448	    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
1449	    value = isObject(other) ? (other + '') : other;
1450	  }
1451	  if (typeof value != 'string') {
1452	    return value === 0 ? value : +value;
1453	  }
1454	  value = baseTrim(value);
1455	  var isBinary = reIsBinary.test(value);
1456	  return (isBinary || reIsOctal.test(value))
1457	    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
1458	    : (reIsBadHex.test(value) ? NAN : +value);
1459	}
1460
1461	toNumber_1 = toNumber;
1462	return toNumber_1;
1463}
1464
1465var debounce_1;
1466var hasRequiredDebounce;
1467
1468function requireDebounce () {
1469	if (hasRequiredDebounce) return debounce_1;
1470	hasRequiredDebounce = 1;
1471	var isObject = requireIsObject(),
1472	    now = requireNow(),
1473	    toNumber = requireToNumber();
1474
1475	/** Error message constants. */
1476	var FUNC_ERROR_TEXT = 'Expected a function';
1477
1478	/* Built-in method references for those with the same name as other `lodash` methods. */
1479	var nativeMax = Math.max,
1480	    nativeMin = Math.min;
1481
1482	/**
1483	 * Creates a debounced function that delays invoking `func` until after `wait`
1484	 * milliseconds have elapsed since the last time the debounced function was
1485	 * invoked. The debounced function comes with a `cancel` method to cancel
1486	 * delayed `func` invocations and a `flush` method to immediately invoke them.
1487	 * Provide `options` to indicate whether `func` should be invoked on the
1488	 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
1489	 * with the last arguments provided to the debounced function. Subsequent
1490	 * calls to the debounced function return the result of the last `func`
1491	 * invocation.
1492	 *
1493	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
1494	 * invoked on the trailing edge of the timeout only if the debounced function
1495	 * is invoked more than once during the `wait` timeout.
1496	 *
1497	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
1498	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
1499	 *
1500	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
1501	 * for details over the differences between `_.debounce` and `_.throttle`.
1502	 *
1503	 * @static
1504	 * @memberOf _
1505	 * @since 0.1.0
1506	 * @category Function
1507	 * @param {Function} func The function to debounce.
1508	 * @param {number} [wait=0] The number of milliseconds to delay.
1509	 * @param {Object} [options={}] The options object.
1510	 * @param {boolean} [options.leading=false]
1511	 *  Specify invoking on the leading edge of the timeout.
1512	 * @param {number} [options.maxWait]
1513	 *  The maximum time `func` is allowed to be delayed before it's invoked.
1514	 * @param {boolean} [options.trailing=true]
1515	 *  Specify invoking on the trailing edge of the timeout.
1516	 * @returns {Function} Returns the new debounced function.
1517	 * @example
1518	 *
1519	 * // Avoid costly calculations while the window size is in flux.
1520	 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
1521	 *
1522	 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
1523	 * jQuery(element).on('click', _.debounce(sendMail, 300, {
1524	 *   'leading': true,
1525	 *   'trailing': false
1526	 * }));
1527	 *
1528	 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
1529	 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
1530	 * var source = new EventSource('/stream');
1531	 * jQuery(source).on('message', debounced);
1532	 *
1533	 * // Cancel the trailing debounced invocation.
1534	 * jQuery(window).on('popstate', debounced.cancel);
1535	 */
1536	function debounce(func, wait, options) {
1537	  var lastArgs,
1538	      lastThis,
1539	      maxWait,
1540	      result,
1541	      timerId,
1542	      lastCallTime,
1543	      lastInvokeTime = 0,
1544	      leading = false,
1545	      maxing = false,
1546	      trailing = true;
1547
1548	  if (typeof func != 'function') {
1549	    throw new TypeError(FUNC_ERROR_TEXT);
1550	  }
1551	  wait = toNumber(wait) || 0;
1552	  if (isObject(options)) {
1553	    leading = !!options.leading;
1554	    maxing = 'maxWait' in options;
1555	    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
1556	    trailing = 'trailing' in options ? !!options.trailing : trailing;
1557	  }
1558
1559	  function invokeFunc(time) {
1560	    var args = lastArgs,
1561	        thisArg = lastThis;
1562
1563	    lastArgs = lastThis = undefined;
1564	    lastInvokeTime = time;
1565	    result = func.apply(thisArg, args);
1566	    return result;
1567	  }
1568
1569	  function leadingEdge(time) {
1570	    // Reset any `maxWait` timer.
1571	    lastInvokeTime = time;
1572	    // Start the timer for the trailing edge.
1573	    timerId = setTimeout(timerExpired, wait);
1574	    // Invoke the leading edge.
1575	    return leading ? invokeFunc(time) : result;
1576	  }
1577
1578	  function remainingWait(time) {
1579	    var timeSinceLastCall = time - lastCallTime,
1580	        timeSinceLastInvoke = time - lastInvokeTime,
1581	        timeWaiting = wait - timeSinceLastCall;
1582
1583	    return maxing
1584	      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
1585	      : timeWaiting;
1586	  }
1587
1588	  function shouldInvoke(time) {
1589	    var timeSinceLastCall = time - lastCallTime,
1590	        timeSinceLastInvoke = time - lastInvokeTime;
1591
1592	    // Either this is the first call, activity has stopped and we're at the
1593	    // trailing edge, the system time has gone backwards and we're treating
1594	    // it as the trailing edge, or we've hit the `maxWait` limit.
1595	    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
1596	      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
1597	  }
1598
1599	  function timerExpired() {
1600	    var time = now();
1601	    if (shouldInvoke(time)) {
1602	      return trailingEdge(time);
1603	    }
1604	    // Restart the timer.
1605	    timerId = setTimeout(timerExpired, remainingWait(time));
1606	  }
1607
1608	  function trailingEdge(time) {
1609	    timerId = undefined;
1610
1611	    // Only invoke if we have `lastArgs` which means `func` has been
1612	    // debounced at least once.
1613	    if (trailing && lastArgs) {
1614	      return invokeFunc(time);
1615	    }
1616	    lastArgs = lastThis = undefined;
1617	    return result;
1618	  }
1619
1620	  function cancel() {
1621	    if (timerId !== undefined) {
1622	      clearTimeout(timerId);
1623	    }
1624	    lastInvokeTime = 0;
1625	    lastArgs = lastCallTime = lastThis = timerId = undefined;
1626	  }
1627
1628	  function flush() {
1629	    return timerId === undefined ? result : trailingEdge(now());
1630	  }
1631
1632	  function debounced() {
1633	    var time = now(),
1634	        isInvoking = shouldInvoke(time);
1635
1636	    lastArgs = arguments;
1637	    lastThis = this;
1638	    lastCallTime = time;
1639
1640	    if (isInvoking) {
1641	      if (timerId === undefined) {
1642	        return leadingEdge(lastCallTime);
1643	      }
1644	      if (maxing) {
1645	        // Handle invocations in a tight loop.
1646	        clearTimeout(timerId);
1647	        timerId = setTimeout(timerExpired, wait);
1648	        return invokeFunc(lastCallTime);
1649	      }
1650	    }
1651	    if (timerId === undefined) {
1652	      timerId = setTimeout(timerExpired, wait);
1653	    }
1654	    return result;
1655	  }
1656	  debounced.cancel = cancel;
1657	  debounced.flush = flush;
1658	  return debounced;
1659	}
1660
1661	debounce_1 = debounce;
1662	return debounce_1;
1663}
1664
1665var throttle_1;
1666var hasRequiredThrottle;
1667
1668function requireThrottle () {
1669	if (hasRequiredThrottle) return throttle_1;
1670	hasRequiredThrottle = 1;
1671	var debounce = requireDebounce(),
1672	    isObject = requireIsObject();
1673
1674	/** Error message constants. */
1675	var FUNC_ERROR_TEXT = 'Expected a function';
1676
1677	/**
1678	 * Creates a throttled function that only invokes `func` at most once per
1679	 * every `wait` milliseconds. The throttled function comes with a `cancel`
1680	 * method to cancel delayed `func` invocations and a `flush` method to
1681	 * immediately invoke them. Provide `options` to indicate whether `func`
1682	 * should be invoked on the leading and/or trailing edge of the `wait`
1683	 * timeout. The `func` is invoked with the last arguments provided to the
1684	 * throttled function. Subsequent calls to the throttled function return the
1685	 * result of the last `func` invocation.
1686	 *
1687	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
1688	 * invoked on the trailing edge of the timeout only if the throttled function
1689	 * is invoked more than once during the `wait` timeout.
1690	 *
1691	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
1692	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
1693	 *
1694	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
1695	 * for details over the differences between `_.throttle` and `_.debounce`.
1696	 *
1697	 * @static
1698	 * @memberOf _
1699	 * @since 0.1.0
1700	 * @category Function
1701	 * @param {Function} func The function to throttle.
1702	 * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
1703	 * @param {Object} [options={}] The options object.
1704	 * @param {boolean} [options.leading=true]
1705	 *  Specify invoking on the leading edge of the timeout.
1706	 * @param {boolean} [options.trailing=true]
1707	 *  Specify invoking on the trailing edge of the timeout.
1708	 * @returns {Function} Returns the new throttled function.
1709	 * @example
1710	 *
1711	 * // Avoid excessively updating the position while scrolling.
1712	 * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
1713	 *
1714	 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
1715	 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
1716	 * jQuery(element).on('click', throttled);
1717	 *
1718	 * // Cancel the trailing throttled invocation.
1719	 * jQuery(window).on('popstate', throttled.cancel);
1720	 */
1721	function throttle(func, wait, options) {
1722	  var leading = true,
1723	      trailing = true;
1724
1725	  if (typeof func != 'function') {
1726	    throw new TypeError(FUNC_ERROR_TEXT);
1727	  }
1728	  if (isObject(options)) {
1729	    leading = 'leading' in options ? !!options.leading : leading;
1730	    trailing = 'trailing' in options ? !!options.trailing : trailing;
1731	  }
1732	  return debounce(func, wait, {
1733	    'leading': leading,
1734	    'maxWait': wait,
1735	    'trailing': trailing
1736	  });
1737	}
1738
1739	throttle_1 = throttle;
1740	return throttle_1;
1741}
1742
1743var throttleExports = requireThrottle();

1979h(function (key) {
1980      key !== "__proto__" && iteratee(object[key], key);
1981    });
1982  }
1983
1984  return object;
1985}
1986
1987function assign$2(object) {
1988  slice$2(arguments, 1).forEach(function (source) {
1989    forOwn$2(source, function (value, key) {
1990      object[key] = source[key];
1991    });
1992  });
1993  return object;
1994}
1995
1996function merge(object) {
1997  slice$2(arguments, 1).forEach(function (source) {
1998    forOwn$2(source, function (value, key) {
1999      if (isArray$2(value)) {
2000        object[key] = value.slice();
2001      } else if (isObject$1(value)) {
2002        object[key] = merge({}, isObject$1(object[key]) ? object[key] : {}, value);
2003      } else {
2004        object[key] = value;
2005      }
2006    });
2007  });
2008  return object;
2009}
2010
2011function omit(object, keys) {
2012  forEach$2(keys || ownKeys$2(object), function (key) {
2013    delete object[key];
2014  });
2015}
2016
2017function removeAttribute$1(elms, attrs) {
2018  forEach$2(elms, function (elm) {
2019    forEach$2(attrs, function (attr) {
2020      elm && elm.removeAttribute(attr);
2021    });
2022  });
2023}
2024
2025function setAttribute$1(elms, attrs, value) {
2026  if (isObject$1(attrs)) {
2027    forOwn$2(attrs, function (value2, name) {
2028      setAttribute$1(elms, name, value2);
2029    });
2030  } else {
2031    forEach$2(elms, function (elm) {
2032      isNull$1(value) || value === "" ? removeAttribute$1(elm, attrs) : elm.setAttribute(attrs, String(value));
2033    });
2034  }
2035}
2036
2037function create(tag, attrs, parent) {
2038  var elm = document.createElement(tag);
2039
2040  if (attrs) {
2041    isString(attrs) ? addClass(elm, attrs) : setAttribute$1(elm, attrs);
2042  }
2043
2044  parent && append(parent, elm);
2045  return elm;
2046}
2047
2048function style(elm, prop, value) {
2049  if (isUndefined$1(value)) {
2050    return getComputedStyle(elm)[prop];
2051  }
2052
2053  if (!isNull$1(value)) {
2054    elm.style[prop] = "" + value;
2055  }
2056}
2057
2058function display(elm, display2) {
2059  style(elm, "display", display2);
2060}
2061
2062function focus(elm) {
2063  elm["setActive"] && elm["setActive"]() || elm.focus({
2064    preventScroll: true
2065  });
2066}
2067
2068function getAttribute(elm, attr) {
2069  return elm.getAttribute(attr);
2070}
2071
2072function hasClass(elm, className) {
2073  return elm && elm.classList.contains(className);
2074}
2075
2076function rect(target) {
2077  return target.getBoundingClientRect();
2078}
2079
2080function remove(nodes) {
2081  forEach$2(nodes, function (node) {
2082    if (node && node.parentNode) {
2083      node.parentNode.removeChild(node);
2084    }
2085  });
2086}
2087
2088function parseHtml(html) {
2089  return child(new DOMParser().parseFromString(html, "text/html").body);
2090}
2091
2092function prevent(e, stopPropagation) {
2093  e.preventDefault();
2094
2095  if (stopPropagation) {
2096    e.stopPropagation();
2097    e.stopImmediatePropagation();
2098  }
2099}
2100
2101function query(parent, selector) {
2102  return parent && parent.querySelector(selector);
2103}
2104
2105function queryAll(parent, selector) {
2106  return selector ? slice$2(parent.querySelectorAll(selector)) : [];
2107}
2108
2109function removeClass(elm, classes) {
2110  toggleClass$1(elm, classes, false);
2111}
2112
2113function timeOf(e) {
2114  return e.timeStamp;
2115}
2116
2117function unit(value) {
2118  return isString(value) ? value : value ? value + "px" : "";
2119}
2120
2121var PROJECT_CODE = "splide";
2122var DATA_ATTRIBUTE = "data-" + PROJECT_CODE;
2123
2124function assert(condition, message) {
2125  if (!condition) {
2126    throw new Error("[" + PROJECT_CODE + "] " + (message || ""));
2127  }
2128}
2129
2130var min$3 = Math.min,
2131    max$2 = Math.max,
2132    floor = Math.floor,
2133    ceil = Math.ceil,
2134    abs = Math.abs;
2135
2136function approximatelyEqual(x, y, epsilon) {
2137  return abs(x - y) < epsilon;
2138}
2139
2140function between(number, x, y, exclusive) {
2141  var minimum = min$3(x, y);
2142  var maximum = max$2(x, y);
2143  return exclusive ? minimum < number && number < maximum : minimum <= number && number <= maximum;
2144}
2145
2146function clamp$1(number, x, y) {
2147  var minimum = min$3(x, y);
2148  var maximum = max$2(x, y);
2149  return min$3(max$2(minimum, number), maximum);
2150}
2151
2152function sign(x) {
2153  return +(x > 0) - +(x < 0);
2154}
2155
2156function format(string, replacements) {
2157  forEach$2(replacements, function (replacement) {
2158    string = string.replace("%s", "" + replacement);
2159  });
2160  return string;
2161}
2162
2163function pad(number) {
2164  return number < 10 ? "0" + number : "" + number;
2165}
2166
2167var ids = {};
2168
2169function uniqueId(prefix) {
2170  return "" + prefix + pad(ids[prefix] = (ids[prefix] || 0) + 1);
2171}
2172
2173function EventBinder$1() {
2174  var listeners = [];
2175
2176  function bind(targets, events, callback, options) {

2177    forEachEvent(targets, events, function (target, event, namespace) {
2178      var isEventTarget = ("addEventListener" in target);
2179      var remover = isEventTarget ? target.removeEventListener.bind(target, event, callback, options) : target["removeListener"].bind(target, callback);
2180      isEventTarget ? target.addEventListener(event, callback, options) : target["addListener"](callback);
2181      listeners.push([target, event, namespace, callback, remover]);
2182    });
2183  }
2184
2185  function unbind(targets, events, callback) {
2186    forEachEvent(targets, events, function (target, event, namespace) {
2187      listeners = listeners.filter(function (listener) {
2188        if (listener[0] === target && listener[1] === event && listener[2] === namespace && (!callback || listener[3] === callback)) {
2189          listener[4]();
2190          return false;
2191        }
2192
2193        return true;
2194      });
2195    });
2196  }
2197
2198  function dispatch(target, type, detail) {
2199    var e;
2200    var bubbles = true;
2201
2202    if (typeof CustomEvent === "function") {
2203      e = new CustomEvent(type, {
2204        bubbles: bubbles,
2205        detail: detail
2206      });
2207    } else {
2208      e = document.createEvent("CustomEvent");
2209      e.initCustomEvent(type, bubbles, false, detail);
2210    }
2211
2212    target.dispatchEvent(e);
2213    return e;
2214  }
2215
2216  function forEachEvent(targets, events, iteratee) {
2217    forEach$2(targets, function (target) {
2218      target && forEach$2(events, function (events2) {
2219        events2.split(" ").forEach(function (eventNS) {
2220          var fragment = eventNS.split(".");
2221          iteratee(target, fragment[0], fragment[1]);
2222        });
2223      });
2224    });
2225  }
2226
2227  function destroy() {
2228    listeners.forEach(function (data) {
2229      data[4]();
2230    });
2231    empty$1(listeners);
2232  }
2233
2234  return {
2235    bind: bind,
2236    unbind: unbind,
2237    dispatch: dispatch,
2238    destroy: destroy
2239  };
2240}
2241
2242var EVENT_MOUNTED = "mounted";
2243var EVENT_READY = "ready";
2244var EVENT_MOVE$1 = "move";
2245var EVENT_MOVED$1 = "moved";
2246var EVENT_CLICK = "click";
2247var EVENT_ACTIVE = "active";
2248var EVENT_INACTIVE = "inactive";
2249var EVENT_VISIBLE = "visible";
2250var EVENT_HIDDEN = "hidden";
2251var EVENT_REFRESH = "refresh";
2252var EVENT_UPDATED$1 = "updated";
2253var EVENT_RESIZE = "resize";
2254var EVENT_RESIZED = "resized";
2255var EVENT_DRAG$1 = "drag";
2256var EVENT_DRAGGING = "dragging";
2257var EVENT_DRAGGED = "dragged";
2258var EVENT_SCROLL$1 = "scroll";
2259var EVENT_SCROLLED$1 = "scrolled";
2260var EVENT_OVERFLOW = "overflow";
2261var EVENT_DESTROY$1 = "destroy";
2262var EVENT_ARROWS_MOUNTED = "arrows:mounted";
2263var EVENT_ARROWS_UPDATED = "arrows:updated";
2264var EVENT_PAGINATION_MOUNTED = "pagination:mounted";
2265var EVENT_PAGINATION_UPDATED = "pagination:updated";
2266var EVENT_NAVIGATION_MOUNTED = "navigation:mounted";
2267var EVENT_AUTOPLAY_PLAY = "autoplay:play";
2268var EVENT_AUTOPLAY_PLAYING = "autoplay:playing";
2269var EVENT_AUTOPLAY_PAUSE = "autoplay:pause";
2270var EVENT_LAZYLOAD_LOADED = "lazyload:loaded";
2271var EVENT_SLIDE_KEYDOWN = "sk";
2272var EVENT_SHIFTED = "sh";
2273var EVENT_END_INDEX_CHANGED = "ei";
2274
2275function EventInterface$1(Splide2) {
2276  var bus = Splide2 ? Splide2.event.bus : document.createDocumentFragment();
2277  var binder = EventBinder$1();
2278
2279  function on(events, callback) {
2280    binder.bind(bus, toArray$2(events).join(" "), function (e) {
2281      callback.apply(callback, isArray$2(e.detail) ? e.detail : []);
2282    });
2283  }
2284
2285  function emit(event) {
2286    binder.dispatch(bus, event, slice$2(arguments, 1));
2287  }
2288
2289  if (Splide2) {
2290    Splide2.event.on(EVENT_DESTROY$1, binder.destroy);
2291  }
2292
2293  return assign$2(binder, {
2294    bus: bus,
2295    on: on,
2296    off: apply$2(binder.unbind, bus),
2297    emit: emit
2298  });
2299}
2300
2301function RequestInterval$1(interval, onInterval, onUpdate, limit) {
2302  var now = Date.now;
2303  var startTime;
2304  var rate = 0;
2305  var id;
2306  var paused = true;
2307  var count = 0;
2308
2309  function update() {
2310    if (!paused) {
2311      rate = interval ? min$3((now() - startTime) / interval, 1) : 1;
2312      onUpdate && onUpdate(rate);
2313
2314      if (rate >= 1) {
2315        onInterval();
2316        startTime = now();
2317
2318        if (limit && ++count >= limit) {
2319          return pause();
2320        }
2321      }
2322
2323      id = raf$1(update);
2324    }
2325  }
2326
2327  function start(resume) {
2328    resume || cancel();
2329    startTime = now() - (resume ? rate * interval : 0);
2330    paused = false;
2331    id = raf$1(update);
2332  }
2333
2334  function pause() {
2335    paused = true;
2336  }
2337
2338  function rewind() {
2339    startTime = now();
2340    rate = 0;
2341
2342    if (onUpdate) {
2343      onUpdate(rate);
2344    }
2345  }
2346
2347  function cancel() {
2348    id && cancelAnimationFrame(id);
2349    rate = 0;
2350    id = 0;
2351    paused = true;
2352  }
2353
2354  function set(time) {
2355    interval = time;
2356  }
2357
2358  function isPaused() {
2359    return paused;
2360  }
2361
2362  return {
2363    start: start,
2364    rewind: rewind,
2365    pause: pause,
2366    cancel: cancel,
2367    set: set,
2368    isPaused: isPaused
2369  };
2370}
2371
2372function State(initialState) {
2373  var state = initialState;
2374
2375  function set(value) {
2376    state = value;
2377  }
2378
2379  function is(states) {
2380    return includes(toArray$2(states), state);
2381  }
2382
2383  return {
2384    set: set,
2385    is: is
2386  };
2387}
2388
2389function Throttle(func, duration) {
2390  var interval = RequestInterval$1(0, func, null, 1);
2391  return function () {
2392    interval.isPaused() && interval.start();
2393  };
2394}
2395
2396function Media(Splide2, Components2, options) {
2397  var state = Splide2.state;
2398  var breakpoints = options.breakpoints || {};
2399  var reducedMotion = options.reducedMotion || {};
2400  var binder = EventBinder$1();
2401  var queries = [];
2402
2403  function setup() {
2404    var isMin = options.mediaQuery === "min";
2405    ownKeys$2(breakpoints).sort(function (n, m) {
2406      return isMin ? +n - +m : +m - +n;
2407    }).forEach(function (key) {
2408      register(breakpoints[key], "(" + (isMin ? "min" : "max") + "-width:" + key + "px)");
2409    });
2410    register(reducedMotion, MEDIA_PREFERS_REDUCED_MOTION);
2411    update();
2412  }
2413
2414  function destroy(completely) {
2415    if (completely) {
2416      binder.destroy();
2417    }
2418  }
2419
2420  function register(options2, query) {
2421    var queryList = matchMedia(query);
2422    binder.bind(queryList, "change", update);
2423    queries.push([options2, queryList]);
2424  }
2425
2426  function update() {
2427    var destroyed = state.is(DESTROYED);
2428    var direction = options.direction;
2429    var merged = queries.reduce(function (merged2, entry) {
2430      return merge(merged2, entry[1].matches ? entry[0] : {});
2431    }, {});
2432    omit(options);
2433    set(merged);
2434
2435    if (options.destroy) {
2436      Splide2.destroy(options.destroy === "completely");
2437    } else if (destroyed) {
2438      destroy(true);
2439      Splide2.mount();
2440    } else {
2441      direction !== options.direction && Splide2.refresh();
2442    }
2443  }
2444
2445  function reduce(enable) {
2446    if (matchMedia(MEDIA_PREFERS_REDUCED_MOTION).matches) {
2447      enable ? merge(options, reducedMotion) : omit(options, ownKeys$2(reducedMotion));
2448    }
2449  }
2450
2451  function set(opts, base, notify) {
2452    merge(options, opts);
2453    base && merge(Object.getPrototypeOf(options), opts);
2454
2455    if (notify || !state.is(CREATED)) {
2456      Splide2.emit(EVENT_UPDATED$1, options);
2457    }
2458  }
2459
2460  return {
2461    setup: setup,
2462    destroy: destroy,
2463    reduce: reduce,
2464    set: set
2465  };
2466}
2467
2468var ARROW = "Arrow";
2469var ARROW_LEFT = ARROW + "Left";
2470var ARROW_RIGHT = ARROW + "Right";
2471var ARROW_UP = ARROW + "Up";
2472var ARROW_DOWN = ARROW + "Down";
2473var RTL = "rtl";
2474var TTB = "ttb";
2475var ORIENTATION_MAP = {
2476  width: ["height"],
2477  left: ["top", "right"],
2478  right: ["bottom", "left"],
2479  x: ["y"],
2480  X: ["Y"],
2481  Y: ["X"],
2482  ArrowLeft: [ARROW_UP, ARROW_RIGHT],
2483  ArrowRight: [ARROW_DOWN, ARROW_LEFT]
2484};
2485
2486function Direction(Splide2, Components2, options) {
2487  function resolve(prop, axisOnly, direction) {
2488    direction = direction || options.direction;
2489    var index = direction === RTL && !axisOnly ? 1 : direction === TTB ? 0 : -1;
2490    return ORIENTATION_MAP[prop] && ORIENTATION_MAP[prop][index] || prop.replace(/width|left|right/i, function (match, offset) {
2491      var replacement = ORIENTATION_MAP[match.toLowerCase()][index] || match;
2492      return offset > 0 ? replacement.charAt(0).toUpperCase() + replacement.slice(1) : replacement;
2493    });
2494  }
2495
2496  function orient(value) {
2497    return value * (options.direction === RTL ? 1 : -1);
2498  }
2499
2500  return {
2501    resolve: resolve,
2502    orient: orient
2503  };
2504}
2505
2506var ROLE = "role";
2507var TAB_INDEX = "tabindex";
2508var DISABLED = "disabled";
2509var ARIA_PREFIX = "aria-";
2510var ARIA_CONTROLS = ARIA_PREFIX + "controls";
2511var ARIA_CURRENT = ARIA_PREFIX + "current";
2512var ARIA_SELECTED = ARIA_PREFIX + "selected";
2513var ARIA_LABEL = ARIA_PREFIX + "label";
2514var ARIA_LABELLEDBY = ARIA_PREFIX + "labelledby";
2515var ARIA_HIDDEN = ARIA_PREFIX + "hidden";
2516var ARIA_ORIENTATION = ARIA_PREFIX + "orientation";
2517var ARIA_ROLEDESCRIPTION = ARIA_PREFIX + "roledescription";
2518var ARIA_LIVE = ARIA_PREFIX + "live";
2519var ARIA_BUSY = ARIA_PREFIX + "busy";
2520var ARIA_ATOMIC = ARIA_PREFIX + "atomic";
2521var ALL_ATTRIBUTES = [ROLE, TAB_INDEX, DISABLED, ARIA_CONTROLS, ARIA_CURRENT, ARIA_LABEL, ARIA_LABELLEDBY, ARIA_HIDDEN, ARIA_ORIENTATION, ARIA_ROLEDESCRIPTION];
2522var CLASS_PREFIX = PROJECT_CODE + "__";
2523var STATUS_CLASS_PREFIX = "is-";
2524var CLASS_ROOT = PROJECT_CODE;
2525var CLASS_TRACK = CLASS_PREFIX + "track";
2526var CLASS_LIST = CLASS_PREFIX + "list";
2527var CLASS_SLIDE = CLASS_PREFIX + "slide";
2528var CLASS_CLONE = CLASS_SLIDE + "--clone";
2529var CLASS_CONTAINER = CLASS_SLIDE + "__container";
2530var CLASS_ARROWS = CLASS_PREFIX + "arrows";
2531var CLASS_ARROW = CLASS_PREFIX + "arrow";
2532var CLASS_ARROW_PREV = CLASS_ARROW + "--prev";
2533var CLASS_ARROW_NEXT = CLASS_ARROW + "--next";
2534var CLASS_PAGINATION = CLASS_PREFIX + "pagination";
2535var CLASS_PAGINATION_PAGE = CLASS_PAGINATION + "__page";
2536var CLASS_PROGRESS = CLASS_PREFIX + "progress";
2537var CLASS_PROGRESS_BAR = CLASS_PROGRESS + "__bar";
2538var CLASS_TOGGLE = CLASS_PREFIX + "toggle";
2539var CLASS_SPINNER = CLASS_PREFIX + "spinner";
2540var CLASS_SR = CLASS_PREFIX + "sr";
2541var CLASS_INITIALIZED = STATUS_CLASS_PREFIX + "initialized";
2542var CLASS_ACTIVE$1 = STATUS_CLASS_PREFIX + "active";
2543var CLASS_PREV = STATUS_CLASS_PREFIX + "prev";
2544var CLASS_NEXT = STATUS_CLASS_PREFIX + "next";
2545var CLASS_VISIBLE = STATUS_CLASS_PREFIX + "visible";
2546var CLASS_LOADING = STATUS_CLASS_PREFIX + "loading";
2547var CLASS_FOCUS_IN = STATUS_CLASS_PREFIX + "focus-in";
2548var CLASS_OVERFLOW = STATUS_CLASS_PREFIX + "overflow";
2549var STATUS_CLASSES = [CLASS_ACTIVE$1, CLASS_VISIBLE, CLASS_PREV, CLASS_NEXT, CLASS_LOADING, CLASS_FOCUS_IN, CLASS_OVERFLOW];
2550var CLASSES = {
2551  slide: CLASS_SLIDE,
2552  clone: CLASS_CLONE,
2553  arrows: CLASS_ARROWS,
2554  arrow: CLASS_ARROW,
2555  prev: CLASS_ARROW_PREV,
2556  next: CLASS_ARROW_NEXT,
2557  pagination: CLASS_PAGINATION,
2558  page: CLASS_PAGINATION_PAGE,
2559  spinner: CLASS_SPINNER
2560};
2561
2562function closest(from, selector) {
2563  if (isFunction(from.closest)) {
2564    return from.closest(selector);
2565  }
2566
2567  var elm = from;
2568
2569  while (elm && elm.nodeType === 1) {
2570    if (matches(elm, selector)) {
2571      break;
2572    }
2573
2574    elm = elm.parentElement;
2575  }
2576
2577  return elm;
2578}
2579
2580var FRICTION = 5;
2581var LOG_INTERVAL = 200;
2582var POINTER_DOWN_EVENTS = "touchstart mousedown";
2583var POINTER_MOVE_EVENTS = "touchmove mousemove";
2584var POINTER_UP_EVENTS = "touchend touchcancel mouseup click";
2585
2586function Elements(Splide2, Components2, options) {
2587  var _EventInterface = EventInterface$1(Splide2),
2588      on = _EventInterface.on,
2589      bind = _EventInterface.bind;
2590
2591  var root = Splide2.root;
2592  var i18n = options.i18n;
2593  var elements = {};
2594  var slides = [];
2595  var rootClasses = [];
2596  var trackClasses = [];
2597  var track;
2598  var list;
2599  var isUsingKey;
2600
2601  function setup() {
2602    collect();
2603    init();
2604    update();
2605  }
2606
2607  function mount() {
2608    on(EVENT_REFRESH, destroy);
2609    on(EVENT_REFRESH, setup);
2610    on(EVENT_UPDATED$1, update);
2611    bind(document, POINTER_DOWN_EVENTS + " keydown", function (e) {
2612      isUsingKey = e.type === "keydown";
2613    }, {
2614      capture: true
2615    });
2616    bind(root, "focusin", function () {
2617      toggleClass$1(root, CLASS_FOCUS_IN, !!isUsingKey);
2618    });
2619  }
2620
2621  function destroy(completely) {
2622    var attrs = ALL_ATTRIBUTES.concat("style");
2623    empty$1(slides);
2624    removeClass(root, rootClasses);
2625    removeClass(track, trackClasses);
2626    removeAttribute$1([track, list], attrs);
2627    removeAttribute$1(root, completely ? attrs : ["style", ARIA_ROLEDESCRIPTION]);
2628  }
2629
2630  function update() {
2631    removeClass(root, rootClasses);
2632    removeClass(track, trackClasses);
2633    rootClasses = getClasses(CLASS_ROOT);
2634    trackClasses = getClasses(CLASS_TRACK);
2635    addClass(root, rootClasses);
2636    addClass(track, trackClasses);
2637    setAttribute$1(root, ARIA_LABEL, options.label);
2638    setAttribute$1(root, ARIA_LABELLEDBY, options.labelledby);
2639  }
2640
2641  function collect() {
2642    track = find("." + CLASS_TRACK);
2643    list = child(track, "." + CLASS_LIST);
2644    assert(track && list, "A track/list element is missing.");
2645    push(slides, children(list, "." + CLASS_SLIDE + ":not(." + CLASS_CLONE + ")"));
2646    forOwn$2({
2647      arrows: CLASS_ARROWS,
2648      pagination: CLASS_PAGINATION,
2649      prev: CLASS_ARROW_PREV,
2650      next: CLASS_ARROW_NEXT,
2651      bar: CLASS_PROGRESS_BAR,
2652      toggle: CLASS_TOGGLE
2653    }, function (className, key) {
2654      elements[key] = find("." + className);
2655    });
2656    assign$2(elements, {
2657      root: root,
2658      track: track,
2659      list: list,
2660      slides: slides
2661    });
2662  }
2663
2664  function init() {
2665    var id = root.id || uniqueId(PROJECT_CODE);
2666    var role = options.role;
2667    root.id = id;
2668    track.id = track.id || id + "-track";
2669    list.id = list.id || id + "-list";
2670
2671    if (!getAttribute(root, ROLE) && root.tagName !== "SECTION" && role) {
2672      setAttribute$1(root, ROLE, role);
2673    }
2674
2675    setAttribute$1(root, ARIA_ROLEDESCRIPTION, i18n.carousel);
2676    setAttribute$1(list, ROLE, "presentation");
2677  }
2678
2679  function find(selector) {
2680    var elm = query(root, selector);
2681    return elm && closest(elm, "." + CLASS_ROOT) === root ? elm : void 0;
2682  }
2683
2684  function getClasses(base) {
2685    return [base + "--" + options.type, base + "--" + options.direction, options.drag && base + "--draggable", options.isNavigation && base + "--nav", base === CLASS_ROOT && CLASS_ACTIVE$1];
2686  }
2687
2688  return assign$2(elements, {
2689    setup: setup,
2690    mount: mount,
2691    destroy: destroy
2692  });
2693}
2694
2695var SLIDE$1 = "slide";
2696var LOOP = "loop";
2697var FADE$1 = "fade";
2698
2699function Slide$1(Splide2, index, slideIndex, slide) {
2700  var event = EventInterface$1(Splide2);
2701  var on = event.on,
2702      emit = event.emit,
2703      bind = event.bind;
2704  var Components = Splide2.Components,
2705      root = Splide2.root,
2706      options = Splide2.options;
2707  var isNavigation = options.isNavigation,
2708      updateOnMove = options.updateOnMove,
2709      i18n = options.i18n,
2710      pagination = options.pagination,
2711      slideFocus = options.slideFocus;
2712  var resolve = Components.Direction.resolve;
2713  var styles = getAttribute(slide, "style");
2714  var label = getAttribute(slide, ARIA_LABEL);
2715  var isClone = slideIndex > -1;
2716  var container = child(slide, "." + CLASS_CONTAINER);
2717  var destroyed;
2718
2719  function mount() {
2720    if (!isClone) {
2721      slide.id = root.id + "-slide" + pad(index + 1);
2722      setAttribute$1(slide, ROLE, pagination ? "tabpanel" : "group");
2723      setAttribute$1(slide, ARIA_ROLEDESCRIPTION, i18n.slide);
2724      setAttribute$1(slide, ARIA_LABEL, label || format(i18n.slideLabel, [index + 1, Splide2.length]));
2725    }
2726
2727    listen();
2728  }
2729
2730  function listen() {
2731    bind(slide, "click", apply$2(emit, EVENT_CLICK, self));
2732    bind(slide, "keydown", apply$2(emit, EVENT_SLIDE_KEYDOWN, self));
2733    on([EVENT_MOVED$1, EVENT_SHIFTED, EVENT_SCROLLED$1], update);
2734    on(EVENT_NAVIGATION_MOUNTED, initNavigation);
2735
2736    if (updateOnMove) {
2737      on(EVENT_MOVE$1, onMove);
2738    }
2739  }
2740
2741  function destroy() {
2742    destroyed = true;
2743    event.destroy();
2744    removeClass(slide, STATUS_CLASSES);
2745    removeAttribute$1(slide, ALL_ATTRIBUTES);
2746    setAttribute$1(slide, "style", styles);
2747    setAttribute$1(slide, ARIA_LABEL, label || "");
2748  }
2749
2750  function initNavigation() {
2751    var controls = Splide2.splides.map(function (target) {
2752      var Slide2 = target.splide.Components.Slides.getAt(index);
2753      return Slide2 ? Slide2.slide.id : "";
2754    }).join(" ");
2755    setAttribute$1(slide, ARIA_LABEL, format(i18n.slideX, (isClone ? slideIndex : index) + 1));
2756    setAttribute$1(slide, ARIA_CONTROLS, controls);
2757    setAttribute$1(slide, ROLE, slideFocus ? "button" : "");
2758    slideFocus && removeAttribute$1(slide, ARIA_ROLEDESCRIPTION);
2759  }
2760
2761  function onMove() {
2762    if (!destroyed) {
2763      update();
2764    }
2765  }
2766
2767  function update() {
2768    if (!destroyed) {
2769      var curr = Splide2.index;
2770      updateActivity();
2771      updateVisibility();
2772      toggleClass$1(slide, CLASS_PREV, index === curr - 1);
2773      toggleClass$1(slide, CLASS_NEXT, index === curr + 1);
2774    }
2775  }
2776
2777  function updateActivity() {
2778    var active = isActive();
2779
2780    if (active !== hasClass(slide, CLASS_ACTIVE$1)) {
2781      toggleClass$1(slide, CLASS_ACTIVE$1, active);
2782      setAttribute$1(slide, ARIA_CURRENT, isNavigation && active || "");
2783      emit(active ? EVENT_ACTIVE : EVENT_INACTIVE, self);
2784    }
2785  }
2786
2787  function updateVisibility() {
2788    var visible = isVisible();
2789    var hidden = !visible && (!isActive() || isClone);
2790
2791    if (!Splide2.state.is([MOVING, SCROLLING])) {
2792      setAttribute$1(slide, ARIA_HIDDEN, hidden || "");
2793    }
2794
2795    setAttribute$1(queryAll(slide, options.focusableNodes || ""), TAB_INDEX, hidden ? -1 : "");
2796
2797    if (slideFocus) {
2798      setAttribute$1(slide, TAB_INDEX, hidden ? -1 : 0);
2799    }
2800
2801    if (visible !== hasClass(slide, CLASS_VISIBLE)) {
2802      toggleClass$1(slide, CLASS_VISIBLE, visible);
2803      emit(visible ? EVENT_VISIBLE : EVENT_HIDDEN, self);
2804    }
2805
2806    if (!visible && document.activeElement === slide) {
2807      var Slide2 = Components.Slides.getAt(Splide2.index);
2808      Slide2 && focus(Slide2.slide);
2809    }
2810  }
2811
2812  function style$1(prop, value, useContainer) {
2813    style(useContainer && container || slide, prop, value);
2814  }
2815
2816  function isActive() {
2817    var curr = Splide2.index;
2818    return curr === index || options.cloneStatus && curr === slideIndex;
2819  }
2820
2821  function isVisible() {
2822    if (Splide2.is(FADE$1)) {
2823      return isActive();
2824    }
2825
2826    var trackRect = rect(Components.Elements.track);
2827    var slideRect = rect(slide);
2828    var left = resolve("left", true);
2829    var right = resolve("right", true);
2830    return floor(trackRect[left]) <= ceil(slideRect[left]) && floor(slideRect[right]) <= ceil(trackRect[right]);
2831  }
2832
2833  function isWithin(from, distance) {
2834    var diff = abs(from - index);
2835
2836    if (!isClone && (options.rewind || Splide2.is(LOOP))) {
2837      diff = min$3(diff, Splide2.length - diff);
2838    }
2839
2840    return diff <= distance;
2841  }
2842
2843  var self = {
2844    index: index,
2845    slideIndex: slideIndex,
2846    slide: slide,
2847    container: container,
2848    isClone: isClone,
2849    mount: mount,
2850    destroy: destroy,
2851    update: update,
2852    style: style$1,
2853    isWithin: isWithin
2854  };
2855  return self;
2856}
2857
2858function Slides(Splide2, Components2, options) {
2859  var _EventInterface2 = EventInterface$1(Splide2),
2860      on = _EventInterface2.on,
2861      emit = _EventInterface2.emit,
2862      bind = _EventInterface2.bind;
2863
2864  var _Components2$Elements = Components2.Elements,
2865      slides = _Components2$Elements.slides,
2866      list = _Components2$Elements.list;
2867  var Slides2 = [];
2868
2869  function mount() {
2870    init();
2871    on(EVENT_REFRESH, destroy);
2872    on(EVENT_REFRESH, init);
2873  }
2874
2875  function init() {
2876    slides.forEach(function (slide, index) {
2877      register(slide, index, -1);
2878    });
2879  }
2880
2881  function destroy() {
2882    forEach$1(function (Slide2) {
2883      Slide2.destroy();
2884    });
2885    empty$1(Slides2);
2886  }
2887
2888  function update() {
2889    forEach$1(function (Slide2) {
2890      Slide2.update();
2891    });
2892  }
2893
2894  function register(slide, index, slideIndex) {
2895    var object = Slide$1(Splide2, index, slideIndex, slide);
2896    object.mount();
2897    Slides2.push(object);
2898    Slides2.sort(function (Slide1, Slide2) {
2899      return Slide1.index - Slide2.index;
2900    });
2901  }
2902
2903  function get(excludeClones) {
2904    return excludeClones ? filter(function (Slide2) {
2905      return !Slide2.isClone;
2906    }) : Slides2;
2907  }
2908
2909  function getIn(page) {
2910    var Controller = Components2.Controller;
2911    var index = Controller.toIndex(page);
2912    var max = Controller.hasFocus() ? 1 : options.perPage;
2913    return filter(function (Slide2) {
2914      return between(Slide2.index, index, index + max - 1);
2915    });
2916  }
2917
2918  function getAt(index) {
2919    return filter(index)[0];
2920  }
2921
2922  function add(items, index) {
2923    forEach$2(items, function (slide) {
2924      if (isString(slide)) {
2925        slide = parseHtml(slide);
2926      }
2927
2928      if (isHTMLElement$1(slide)) {
2929        var ref = slides[index];
2930        ref ? before(slide, ref) : append(list, slide);
2931        addClass(slide, options.classes.slide);
2932        observeImages(slide, apply$2(emit, EVENT_RESIZE));
2933      }
2934    });
2935    emit(EVENT_REFRESH);
2936  }
2937
2938  function remove$1(matcher) {
2939    remove(filter(matcher).map(function (Slide2) {
2940      return Slide2.slide;
2941    }));
2942    emit(EVENT_REFRESH);
2943  }
2944
2945  function forEach$1(iteratee, excludeClones) {
2946    get(excludeClones).forEach(iteratee);
2947  }
2948
2949  function filter(matcher) {
2950    return Slides2.filter(isFunction(matcher) ? matcher : function (Slide2) {
2951      return isString(matcher) ? matches(Slide2.slide, matcher) : includes(toArray$2(matcher), Slide2.index);
2952    });
2953  }
2954
2955  function style(prop, value, useContainer) {
2956    forEach$1(function (Slide2) {
2957      Slide2.style(prop, value, useContainer);
2958    });
2959  }
2960
2961  function observeImages(elm, callback) {
2962    var images = queryAll(elm, "img");
2963    var length = images.length;
2964
2965    if (length) {
2966      images.forEach(function (img) {
2967        bind(img, "load error", function () {
2968          if (! --length) {
2969            callback();
2970          }
2971        });
2972      });
2973    } else {
2974      callback();
2975    }
2976  }
2977
2978  function getLength(excludeClones) {
2979    return excludeClones ? slides.length : Slides2.length;
2980  }
2981
2982  function isEnough() {
2983    return Slides2.length > options.perPage;
2984  }
2985
2986  return {
2987    mount: mount,
2988    destroy: destroy,
2989    update: update,
2990    register: register,
2991    get: get,
2992    getIn: getIn,
2993    getAt: getAt,
2994    add: add,
2995    remove: remove$1,
2996    forEach: forEach$1,
2997    filter: filter,
2998    style: style,
2999    getLength: getLength,
3000    isEnough: isEnough
3001  };
3002}
3003
3004function Layout(Splide2, Components2, options) {
3005  var _EventInterface3 = EventInterface$1(Splide2),
3006      on = _EventInterface3.on,
3007      bind = _EventInterface3.bind,
3008      emit = _EventInterface3.emit;
3009
3010  var Slides = Components2.Slides;
3011  var resolve = Components2.Direction.resolve;
3012  var _Components2$Elements2 = Components2.Elements,
3013      root = _Components2$Elements2.root,
3014      track = _Components2$Elements2.track,
3015      list = _Components2$Elements2.list;
3016  var getAt = Slides.getAt,
3017      styleSlides = Slides.style;
3018  var vertical;
3019  var rootRect;
3020  var overflow;
3021
3022  function mount() {
3023    init();
3024    bind(window, "resize load", Throttle(apply$2(emit, EVENT_RESIZE)));
3025    on([EVENT_UPDATED$1, EVENT_REFRESH], init);
3026    on(EVENT_RESIZE, resize);
3027  }
3028
3029  function init() {
3030    vertical = options.direction === TTB;
3031    style(root, "maxWidth", unit(options.width));
3032    style(track, resolve("paddingLeft"), cssPadding(false));
3033    style(track, resolve("paddingRight"), cssPadding(true));
3034    resize(true);
3035  }
3036
3037  function resize(force) {
3038    var newRect = rect(root);
3039
3040    if (force || rootRect.width !== newRect.width || rootRect.height !== newRect.height) {
3041      style(track, "height", cssTrackHeight());
3042      styleSlides(resolve("marginRight"), unit(options.gap));
3043      styleSlides("width", cssSlideWidth());
3044      styleSlides("height", cssSlideHeight(), true);
3045      rootRect = newRect;
3046      emit(EVENT_RESIZED);
3047
3048      if (overflow !== (overflow = isOverflow())) {
3049        toggleClass$1(root, CLASS_OVERFLOW, overflow);
3050        emit(EVENT_OVERFLOW, overflow);
3051      }
3052    }
3053  }
3054
3055  function cssPadding(right) {
3056    var padding = options.padding;
3057    var prop = resolve(right ? "right" : "left");
3058    return padding && unit(padding[prop] || (isObject$1(padding) ? 0 : padding)) || "0px";
3059  }
3060
3061  function cssTrackHeight() {
3062    var height = "";
3063
3064    if (vertical) {
3065      height = cssHeight();
3066      assert(height, "height or heightRatio is missing.");
3067      height = "calc(" + height + " - " + cssPadding(false) + " - " + cssPadding(true) + ")";
3068    }
3069
3070    return height;
3071  }
3072
3073  function cssHeight() {
3074    return unit(options.height || rect(list).width * options.heightRatio);
3075  }
3076
3077  function cssSlideWidth() {
3078    return options.autoWidth ? null : unit(options.fixedWidth) || (vertical ? "" : cssSlideSize());
3079  }
3080
3081  function cssSlideHeight() {
3082    return unit(options.fixedHeight) || (vertical ? options.autoHeight ? null : cssSlideSize() : cssHeight());
3083  }
3084
3085  function cssSlideSize() {
3086    var gap = unit(options.gap);
3087    return "calc((100%" + (gap && " + " + gap) + ")/" + (options.perPage || 1) + (gap && " - " + gap) + ")";
3088  }
3089
3090  function listSize() {
3091    return rect(list)[resolve("width")];
3092  }
3093
3094  function slideSize(index, withoutGap) {
3095    var Slide = getAt(index || 0);
3096    return Slide ? rect(Slide.slide)[resolve("width")] + (withoutGap ? 0 : getGap()) : 0;
3097  }
3098
3099  function totalSize(index, withoutGap) {
3100    var Slide = getAt(index);
3101
3102    if (Slide) {
3103      var right = rect(Slide.slide)[resolve("right")];
3104      var left = rect(list)[resolve("left")];
3105      return abs(right - left) + (withoutGap ? 0 : getGap());
3106    }
3107
3108    return 0;
3109  }
3110
3111  function sliderSize(withoutGap) {
3112    return totalSize(Splide2.length - 1) - totalSize(0) + slideSize(0, withoutGap);
3113  }
3114
3115  function getGap() {
3116    var Slide = getAt(0);
3117    return Slide && parseFloat(style(Slide.slide, resolve("marginRight"))) || 0;
3118  }
3119
3120  function getPadding(right) {
3121    return parseFloat(style(track, resolve("padding" + (right ? "Right" : "Left")))) || 0;
3122  }
3123
3124  function isOverflow() {
3125    return Splide2.is(FADE$1) || sliderSize(true) > listSize();
3126  }
3127
3128  return {
3129    mount: mount,
3130    resize: resize,
3131    listSize: listSize,
3132    slideSize: slideSize,
3133    sliderSize: sliderSize,
3134    totalSize: totalSize,
3135    getPadding: getPadding,
3136    isOverflow: isOverflow
3137  };
3138}
3139
3140var MULTIPLIER = 2;
3141
3142function Clones(Splide2, Components2, options) {
3143  var event = EventInterface$1(Splide2);
3144  var on = event.on;
3145  var Elements = Components2.Elements,
3146      Slides = Components2.Slides;
3147  var resolve = Components2.Direction.resolve;
3148  var clones = [];
3149  var cloneCount;
3150
3151  function mount() {
3152    on(EVENT_REFRESH, remount);
3153    on([EVENT_UPDATED$1, EVENT_RESIZE], observe);
3154
3155    if (cloneCount = computeCloneCount()) {
3156      generate(cloneCount);
3157      Components2.Layout.resize(true);
3158    }
3159  }
3160
3161  function remount() {
3162    destroy();
3163    mount();
3164  }
3165
3166  function destroy() {
3167    remove(clones);
3168    empty$1(clones);
3169    event.destroy();
3170  }
3171
3172  function observe() {
3173    var count = computeCloneCount();
3174
3175    if (cloneCount !== count) {
3176      if (cloneCount < count || !count) {
3177        event.emit(EVENT_REFRESH);
3178      }
3179    }
3180  }
3181
3182  function generate(count) {
3183    var slides = Slides.get().slice();
3184    var length = slides.length;
3185
3186    if (length) {
3187      while (slides.length < count) {
3188        push(slides, slides);
3189      }
3190
3191      push(slides.slice(-count), slides.slice(0, count)).forEach(function (Slide, index) {
3192        var isHead = index < count;
3193        var clone = cloneDeep(Slide.slide, index);
3194        isHead ? before(clone, slides[0].slide) : append(Elements.list, clone);
3195        push(clones, clone);
3196        Slides.register(clone, index - count + (isHead ? 0 : length), Slide.index);
3197      });
3198    }
3199  }
3200
3201  function cloneDeep(elm, index) {
3202    var clone = elm.cloneNode(true);
3203    addClass(clone, options.classes.clone);
3204    clone.id = Splide2.root.id + "-clone" + pad(index + 1);
3205    return clone;
3206  }
3207
3208  function computeCloneCount() {
3209    var clones2 = options.clones;
3210
3211    if (!Splide2.is(LOOP)) {
3212      clones2 = 0;
3213    } else if (isUndefined$1(clones2)) {
3214      var fixedSize = options[resolve("fixedWidth")] && Components2.Layout.slideSize(0);
3215      var fixedCount = fixedSize && ceil(rect(Elements.track)[resolve("width")] / fixedSize);
3216      clones2 = fixedCount || options[resolve("autoWidth")] && Splide2.length || options.perPage * MULTIPLIER;
3217    }
3218
3219    return clones2;
3220  }
3221
3222  return {
3223    mount: mount,
3224    destroy: destroy
3225  };
3226}
3227
3228function Move(Splide2, Components2, options) {
3229  var _EventInterface4 = EventInterface$1(Splide2),
3230      on = _EventInterface4.on,
3231      emit = _EventInterface4.emit;
3232
3233  var set = Splide2.state.set;
3234  var _Components2$Layout = Components2.Layout,
3235      slideSize = _Components2$Layout.slideSize,
3236      getPadding = _Components2$Layout.getPadding,
3237      totalSize = _Components2$Layout.totalSize,
3238      listSize = _Components2$Layout.listSize,
3239      sliderSize = _Components2$Layout.sliderSize;
3240  var _Components2$Directio = Components2.Direction,
3241      resolve = _Components2$Directio.resolve,
3242      orient = _Components2$Directio.orient;
3243  var _Components2$Elements3 = Components2.Elements,
3244      list = _Components2$Elements3.list,
3245      track = _Components2$Elements3.track;
3246  var Transition;
3247
3248  function mount() {
3249    Transition = Components2.Transition;
3250    on([EVENT_MOUNTED, EVENT_RESIZED, EVENT_UPDATED$1, EVENT_REFRESH], reposition);
3251  }
3252
3253  function reposition() {
3254    if (!Components2.Controller.isBusy()) {
3255      Components2.Scroll.cancel();
3256      jump(Splide2.index);
3257      Components2.Slides.update();
3258    }
3259  }
3260
3261  function move(dest, index, prev, callback) {
3262    if (dest !== index && canShift(dest > prev)) {
3263      cancel();
3264      translate(shift(getPosition(), dest > prev), true);
3265    }
3266
3267    set(MOVING);
3268    emit(EVENT_MOVE$1, index, prev, dest);
3269    Transition.start(index, function () {
3270      set(IDLE);
3271      emit(EVENT_MOVED$1, index, prev, dest);
3272      callback && callback();
3273    });
3274  }
3275
3276  function jump(index) {
3277    translate(toPosition(index, true));
3278  }
3279
3280  function translate(position, preventLoop) {
3281    if (!Splide2.is(FADE$1)) {
3282      var destination = preventLoop ? position : loop(position);
3283      style(list, "transform", "translate" + resolve("X") + "(" + destination + "px)");
3284      position !== destination && emit(EVENT_SHIFTED);
3285    }
3286  }
3287
3288  function loop(position) {
3289    if (Splide2.is(LOOP)) {
3290      var index = toIndex(position);
3291      var exceededMax = index > Components2.Controller.getEnd();
3292      var exceededMin = index < 0;
3293
3294      if (exceededMin || exceededMax) {
3295        position = shift(position, exceededMax);
3296      }
3297    }
3298
3299    return position;
3300  }
3301
3302  function shift(position, backwards) {
3303    var excess = position - getLimit(backwards);
3304    var size = sliderSize();
3305    position -= orient(size * (ceil(abs(excess) / size) || 1)) * (backwards ? 1 : -1);
3306    return position;
3307  }
3308
3309  function cancel() {
3310    translate(getPosition(), true);
3311    Transition.cancel();
3312  }
3313
3314  function toIndex(position) {
3315    var Slides = Components2.Slides.get();
3316    var index = 0;
3317    var minDistance = Infinity;
3318
3319    for (var i = 0; i < Slides.length; i++) {
3320      var slideIndex = Slides[i].index;
3321      var distance = abs(toPosition(slideIndex, true) - position);
3322
3323      if (distance <= minDistance) {
3324        minDistance = distance;
3325        index = slideIndex;
3326      } else {
3327        break;
3328      }
3329    }
3330
3331    return index;
3332  }
3333
3334  function toPosition(index, trimming) {
3335    var position = orient(totalSize(index - 1) - offset(index));
3336    return trimming ? trim(position) : position;
3337  }
3338
3339  function getPosition() {
3340    var left = resolve("left");
3341    return rect(list)[left] - rect(track)[left] + orient(getPadding(false));
3342  }
3343
3344  function trim(position) {
3345    if (options.trimSpace && Splide2.is(SLIDE$1)) {
3346      position = clamp$1(position, 0, orient(sliderSize(true) - listSize()));
3347    }
3348
3349    return position;
3350  }
3351
3352  function offset(index) {
3353    var focus = options.focus;
3354    return focus === "center" ? (listSize() - slideSize(index, true)) / 2 : +focus * slideSize(index) || 0;
3355  }
3356
3357  function getLimit(max) {
3358    return toPosition(max ? Components2.Controller.getEnd() : 0, !!options.trimSpace);
3359  }
3360
3361  function canShift(backwards) {
3362    var shifted = orient(shift(getPosition(), backwards));
3363    return backwards ? shifted >= 0 : shifted <= list[resolve("scrollWidth")] - rect(track)[resolve("width")];
3364  }
3365
3366  function exceededLimit(max, position) {
3367    position = isUndefined$1(position) ? getPosition() : position;
3368    var exceededMin = max !== true && orient(position) < orient(getLimit(false));
3369    var exceededMax = max !== false && orient(position) > orient(getLimit(true));
3370    return exceededMin || exceededMax;
3371  }
3372
3373  return {
3374    mount: mount,
3375    move: move,
3376    jump: jump,
3377    translate: translate,
3378    shift: shift,
3379    cancel: cancel,
3380    toIndex: toIndex,
3381    toPosition: toPosition,
3382    getPosition: getPosition,
3383    getLimit: getLimit,
3384    exceededLimit: exceededLimit,
3385    reposition: reposition
3386  };
3387}
3388
3389function Controller(Splide2, Components2, options) {
3390  var _EventInterface5 = EventInterface$1(Splide2),
3391      on = _EventInterface5.on,
3392      emit = _EventInterface5.emit;
3393
3394  var Move = Components2.Move;
3395  var getPosition = Move.getPosition,
3396      getLimit = Move.getLimit,
3397      toPosition = Move.toPosition;
3398  var _Components2$Slides = Components2.Slides,
3399      isEnough = _Components2$Slides.isEnough,
3400      getLength = _Components2$Slides.getLength;
3401  var omitEnd = options.omitEnd;
3402  var isLoop = Splide2.is(LOOP);
3403  var isSlide = Splide2.is(SLIDE$1);
3404  var getNext = apply$2(getAdjacent, false);
3405  var getPrev = apply$2(getAdjacent, true);
3406  var currIndex = options.start || 0;
3407  var endIndex;
3408  var prevIndex = currIndex;
3409  var slideCount;
3410  var perMove;
3411  var perPage;
3412
3413  function mount() {
3414    init();
3415    on([EVENT_UPDATED$1, EVENT_REFRESH, EVENT_END_INDEX_CHANGED], init);
3416    on(EVENT_RESIZED, onResized);
3417  }
3418
3419  function init() {
3420    slideCount = getLength(true);
3421    perMove = options.perMove;
3422    perPage = options.perPage;
3423    endIndex = getEnd();
3424    var index = clamp$1(currIndex, 0, omitEnd ? endIndex : slideCount - 1);
3425
3426    if (index !== currIndex) {
3427      currIndex = index;
3428      Move.reposition();
3429    }
3430  }
3431
3432  function onResized() {
3433    if (endIndex !== getEnd()) {
3434      emit(EVENT_END_INDEX_CHANGED);
3435    }
3436  }
3437
3438  function go(control, allowSameIndex, callback) {
3439    if (!isBusy()) {
3440      var dest = parse(control);
3441      var index = loop(dest);
3442
3443      if (index > -1 && (allowSameIndex || index !== currIndex)) {
3444        setIndex(index);
3445        Move.move(dest, index, prevIndex, callback);
3446      }
3447    }
3448  }
3449
3450  function scroll(destination, duration, snap, callback) {
3451    Components2.Scroll.scroll(destination, duration, snap, function () {
3452      var index = loop(Move.toIndex(getPosition()));
3453      setIndex(omitEnd ? min$3(index, endIndex) : index);
3454      callback && callback();
3455    });
3456  }
3457
3458  function parse(control) {
3459    var index = currIndex;
3460
3461    if (isString(control)) {
3462      var _ref = control.match(/([+\-<>])(\d+)?/) || [],
3463          indicator = _ref[1],
3464          number = _ref[2];
3465
3466      if (indicator === "+" || indicator === "-") {
3467        index = computeDestIndex(currIndex + +("" + indicator + (+number || 1)), currIndex);
3468      } else if (indicator === ">") {
3469        index = number ? toIndex(+number) : getNext(true);
3470      } else if (indicator === "<") {
3471        index = getPrev(true);
3472      }
3473    } else {
3474      index = isLoop ? control : clamp$1(control, 0, endIndex);
3475    }
3476
3477    return index;
3478  }
3479
3480  function getAdjacent(prev, destination) {
3481    var number = perMove || (hasFocus() ? 1 : perPage);
3482    var dest = computeDestIndex(currIndex + number * (prev ? -1 : 1), currIndex, !(perMove || hasFocus()));
3483
3484    if (dest === -1 && isSlide) {
3485      if (!approximatelyEqual(getPosition(), getLimit(!prev), 1)) {
3486        return prev ? 0 : endIndex;
3487      }
3488    }
3489
3490    return destination ? dest : loop(dest);
3491  }
3492
3493  function computeDestIndex(dest, from, snapPage) {
3494    if (isEnough() || hasFocus()) {
3495      var index = computeMovableDestIndex(dest);
3496
3497      if (index !== dest) {
3498        from = dest;
3499        dest = index;
3500        snapPage = false;
3501      }
3502
3503      if (dest < 0 || dest > endIndex) {
3504        if (!perMove && (between(0, dest, from, true) || between(endIndex, from, dest, true))) {
3505          dest = toIndex(toPage(dest));
3506        } else {
3507          if (isLoop) {
3508            dest = snapPage ? dest < 0 ? -(slideCount % perPage || perPage) : slideCount : dest;
3509          } else if (options.rewind) {
3510            dest = dest < 0 ? endIndex : 0;
3511          } else {
3512            dest = -1;
3513          }
3514        }
3515      } else {
3516        if (snapPage && dest !== from) {
3517          dest = toIndex(toPage(from) + (dest < from ? -1 : 1));
3518        }
3519      }
3520    } else {
3521      dest = -1;
3522    }
3523
3524    return dest;
3525  }
3526
3527  function computeMovableDestIndex(dest) {
3528    if (isSlide && options.trimSpace === "move" && dest !== currIndex) {
3529      var position = getPosition();
3530
3531      while (position === toPosition(dest, true) && between(dest, 0, Splide2.length - 1, !options.rewind)) {
3532        dest < currIndex ? --dest : ++dest;
3533      }
3534    }
3535
3536    return dest;
3537  }
3538
3539  function loop(index) {
3540    return isLoop ? (index + slideCount) % slideCount || 0 : index;
3541  }
3542
3543  function getEnd() {
3544    var end = slideCount - (hasFocus() || isLoop && perMove ? 1 : perPage);
3545
3546    while (omitEnd && end-- > 0) {
3547      if (toPosition(slideCount - 1, true) !== toPosition(end, true)) {
3548        end++;
3549        break;
3550      }
3551    }
3552
3553    return clamp$1(end, 0, slideCount - 1);
3554  }
3555
3556  function toIndex(page) {
3557    return clamp$1(hasFocus() ? page : perPage * page, 0, endIndex);
3558  }
3559
3560  function toPage(index) {
3561    return hasFocus() ? min$3(index, endIndex) : floor((index >= endIndex ? slideCount - 1 : index) / perPage);
3562  }
3563
3564  function toDest(destination) {
3565    var closest = Move.toIndex(destination);
3566    return isSlide ? clamp$1(closest, 0, endIndex) : closest;
3567  }
3568
3569  function setIndex(index) {
3570    if (index !== currIndex) {
3571      prevIndex = currIndex;
3572      currIndex = index;
3573    }
3574  }
3575
3576  function getIndex(prev) {
3577    return prev ? prevIndex : currIndex;
3578  }
3579
3580  function hasFocus() {
3581    return !isUndefined$1(options.focus) || options.isNavigation;
3582  }
3583
3584  function isBusy() {
3585    return Splide2.state.is([MOVING, SCROLLING]) && !!options.waitForTransition;
3586  }
3587
3588  return {
3589    mount: mount,
3590    go: go,
3591    scroll: scroll,
3592    getNext: getNext,
3593    getPrev: getPrev,
3594    getAdjacent: getAdjacent,
3595    getEnd: getEnd,
3596    setIndex: setIndex,
3597    getIndex: getIndex,
3598    toIndex: toIndex,
3599    toPage: toPage,
3600    toDest: toDest,
3601    hasFocus: hasFocus,
3602    isBusy: isBusy
3603  };
3604}
3605
3606var XML_NAME_SPACE = "http://www.w3.org/2000/svg";
3607var PATH = "m15.5 0.932-4.3 4.38 14.5 14.6-14.5 14.5 4.3 4.4 14.6-14.6 4.4-4.3-4.4-4.4-14.6-14.6z";
3608var SIZE = 40;
3609
3610function Arrows(Splide2, Components2, options) {
3611  var event = EventInterface$1(Splide2);
3612  var on = event.on,
3613      bind = event.bind,
3614      emit = event.emit;
3615  var classes = options.classes,
3616      i18n = options.i18n;
3617  var Elements = Components2.Elements,
3618      Controller = Components2.Controller;
3619  var placeholder = Elements.arrows,
3620      track = Elements.track;
3621  var wrapper = placeholder;
3622  var prev = Elements.prev;
3623  var next = Elements.next;
3624  var created;
3625  var wrapperClasses;
3626  var arrows = {};
3627
3628  function mount() {
3629    init();
3630    on(EVENT_UPDATED$1, remount);
3631  }
3632
3633  function remount() {
3634    destroy();
3635    mount();
3636  }
3637
3638  function init() {
3639    var enabled = options.arrows;
3640
3641    if (enabled && !(prev && next)) {
3642      createArrows();
3643    }
3644
3645    if (prev && next) {
3646      assign$2(arrows, {
3647        prev: prev,
3648        next: next
3649      });
3650      display(wrapper, enabled ? "" : "none");
3651      addClass(wrapper, wrapperClasses = CLASS_ARROWS + "--" + options.direction);
3652
3653      if (enabled) {
3654        listen();
3655        update();
3656        setAttribute$1([prev, next], ARIA_CONTROLS, track.id);
3657        emit(EVENT_ARROWS_MOUNTED, prev, next);
3658      }
3659    }
3660  }
3661
3662  function destroy() {
3663    event.destroy();
3664    removeClass(wrapper, wrapperClasses);
3665
3666    if (created) {
3667      remove(placeholder ? [prev, next] : wrapper);
3668      prev = next = null;
3669    } else {
3670      removeAttribute$1([prev, next], ALL_ATTRIBUTES);
3671    }
3672  }
3673
3674  function listen() {
3675    on([EVENT_MOUNTED, EVENT_MOVED$1, EVENT_REFRESH, EVENT_SCROLLED$1, EVENT_END_INDEX_CHANGED], update);
3676    bind(next, "click", apply$2(go, ">"));
3677    bind(prev, "click", apply$2(go, "<"));
3678  }
3679
3680  function go(control) {
3681    Controller.go(control, true);
3682  }
3683
3684  function createArrows() {
3685    wrapper = placeholder || create("div", classes.arrows);
3686    prev = createArrow(true);
3687    next = createArrow(false);
3688    created = true;
3689    append(wrapper, [prev, next]);
3690    !placeholder && before(wrapper, track);
3691  }
3692
3693  function createArrow(prev2) {
3694    var arrow = "<button class=\"" + classes.arrow + " " + (prev2 ? classes.prev : classes.next) + "\" type=\"button\"><svg xmlns=\"" + XML_NAME_SPACE + "\" viewBox=\"0 0 " + SIZE + " " + SIZE + "\" width=\"" + SIZE + "\" height=\"" + SIZE + "\" focusable=\"false\"><path d=\"" + (options.arrowPath || PATH) + "\" />";
3695    return parseHtml(arrow);
3696  }
3697
3698  function update() {
3699    if (prev && next) {
3700      var index = Splide2.index;
3701      var prevIndex = Controller.getPrev();
3702      var nextIndex = Controller.getNext();
3703      var prevLabel = prevIndex > -1 && index < prevIndex ? i18n.last : i18n.prev;
3704      var nextLabel = nextIndex > -1 && index > nextIndex ? i18n.first : i18n.next;
3705      prev.disabled = prevIndex < 0;
3706      next.disabled = nextIndex < 0;
3707      setAttribute$1(prev, ARIA_LABEL, prevLabel);
3708      setAttribute$1(next, ARIA_LABEL, nextLabel);
3709      emit(EVENT_ARROWS_UPDATED, prev, next, prevIndex, nextIndex);
3710    }
3711  }
3712
3713  return {
3714    arrows: arrows,
3715    mount: mount,
3716    destroy: destroy,
3717    update: update
3718  };
3719}
3720
3721var INTERVAL_DATA_ATTRIBUTE = DATA_ATTRIBUTE + "-interval";
3722
3723function Autoplay(Splide2, Components2, options) {
3724  var _EventInterface6 = EventInterface$1(Splide2),
3725      on = _EventInterface6.on,
3726      bind = _EventInterface6.bind,
3727      emit = _EventInterface6.emit;
3728
3729  var interval = RequestInterval$1(options.interval, Splide2.go.bind(Splide2, ">"), onAnimationFrame);
3730  var isPaused = interval.isPaused;
3731  var Elements = Components2.Elements,
3732      _Components2$Elements4 = Components2.Elements,
3733      root = _Components2$Elements4.root,
3734      toggle = _Components2$Elements4.toggle;
3735  var autoplay = options.autoplay;
3736  var hovered;
3737  var focused;
3738  var stopped = autoplay === "pause";
3739
3740  function mount() {
3741    if (autoplay) {
3742      listen();
3743      toggle && setAttribute$1(toggle, ARIA_CONTROLS, Elements.track.id);
3744      stopped || play();
3745      update();
3746    }
3747  }
3748
3749  function listen() {
3750    if (options.pauseOnHover) {
3751      bind(root, "mouseenter mouseleave", function (e) {
3752        hovered = e.type === "mouseenter";
3753        autoToggle();
3754      });
3755    }
3756
3757    if (options.pauseOnFocus) {
3758      bind(root, "focusin focusout", function (e) {
3759        focused = e.type === "focusin";
3760        autoToggle();
3761      });
3762    }
3763
3764    if (toggle) {
3765      bind(toggle, "click", function () {
3766        stopped ? play() : pause(true);
3767      });
3768    }
3769
3770    on([EVENT_MOVE$1, EVENT_SCROLL$1, EVENT_REFRESH], interval.rewind);
3771    on(EVENT_MOVE$1, onMove);
3772  }
3773
3774  function play() {
3775    if (isPaused() && Components2.Slides.isEnough()) {
3776      interval.start(!options.resetProgress);
3777      focused = hovered = stopped = false;
3778      update();
3779      emit(EVENT_AUTOPLAY_PLAY);
3780    }
3781  }
3782
3783  function pause(stop) {
3784    if (stop === void 0) {
3785      stop = true;
3786    }
3787
3788    stopped = !!stop;
3789    update();
3790
3791    if (!isPaused()) {
3792      interval.pause();
3793      emit(EVENT_AUTOPLAY_PAUSE);
3794    }
3795  }
3796
3797  function autoToggle() {
3798    if (!stopped) {
3799      hovered || focused ? pause(false) : play();
3800    }
3801  }
3802
3803  function update() {
3804    if (toggle) {
3805      toggleClass$1(toggle, CLASS_ACTIVE$1, !stopped);
3806      setAttribute$1(toggle, ARIA_LABEL, options.i18n[stopped ? "play" : "pause"]);
3807    }
3808  }
3809
3810  function onAnimationFrame(rate) {
3811    var bar = Elements.bar;
3812    bar && style(bar, "width", rate * 100 + "%");
3813    emit(EVENT_AUTOPLAY_PLAYING, rate);
3814  }
3815
3816  function onMove(index) {
3817    var Slide = Components2.Slides.getAt(index);
3818    interval.set(Slide && +getAttribute(Slide.slide, INTERVAL_DATA_ATTRIBUTE) || options.interval);
3819  }
3820
3821  return {
3822    mount: mount,
3823    destroy: interval.cancel,
3824    play: play,
3825    pause: pause,
3826    isPaused: isPaused
3827  };
3828}
3829
3830function Cover(Splide2, Components2, options) {
3831  var _EventInterface7 = EventInterface$1(Splide2),
3832      on = _EventInterface7.on;
3833
3834  function mount() {
3835    if (options.cover) {
3836      on(EVENT_LAZYLOAD_LOADED, apply$2(toggle, true));
3837      on([EVENT_MOUNTED, EVENT_UPDATED$1, EVENT_REFRESH], apply$2(cover, true));
3838    }
3839  }
3840
3841  function cover(cover2) {
3842    Components2.Slides.forEach(function (Slide) {
3843      var img = child(Slide.container || Slide.slide, "img");
3844
3845      if (img && img.src) {
3846        toggle(cover2, img, Slide);
3847      }
3848    });
3849  }
3850
3851  function toggle(cover2, img, Slide) {
3852    Slide.style("background", cover2 ? "center/cover no-repeat url(\"" + img.src + "\")" : "", true);
3853    display(img, cover2 ? "none" : "");
3854  }
3855
3856  return {
3857    mount: mount,
3858    destroy: apply$2(cover, false)
3859  };
3860}
3861
3862var BOUNCE_DIFF_THRESHOLD = 10;
3863var BOUNCE_DURATION = 600;
3864var FRICTION_FACTOR = 0.6;
3865var BASE_VELOCITY = 1.5;
3866var MIN_DURATION = 800;
3867
3868function Scroll(Splide2, Components2, options) {
3869  var _EventInterface8 = EventInterface$1(Splide2),
3870      on = _EventInterface8.on,
3871      emit = _EventInterface8.emit;
3872
3873  var set = Splide2.state.set;
3874  var Move = Components2.Move;
3875  var getPosition = Move.getPosition,
3876      getLimit = Move.getLimit,
3877      exceededLimit = Move.exceededLimit,
3878      translate = Move.translate;
3879  var isSlide = Splide2.is(SLIDE$1);
3880  var interval;
3881  var callback;
3882  var friction = 1;
3883
3884  function mount() {
3885    on(EVENT_MOVE$1, clear);
3886    on([EVENT_UPDATED$1, EVENT_REFRESH], cancel);
3887  }
3888
3889  function scroll(destination, duration, snap, onScrolled, noConstrain) {
3890    var from = getPosition();
3891    clear();
3892
3893    if (snap && (!isSlide || !exceededLimit())) {
3894      var size = Components2.Layout.sliderSize();
3895      var offset = sign(destination) * size * floor(abs(destination) / size) || 0;
3896      destination = Move.toPosition(Components2.Controller.toDest(destination % size)) + offset;
3897    }
3898
3899    var noDistance = approximatelyEqual(from, destination, 1);
3900    friction = 1;
3901    duration = noDistance ? 0 : duration || max$2(abs(destination - from) / BASE_VELOCITY, MIN_DURATION);
3902    callback = onScrolled;
3903    interval = RequestInterval$1(duration, onEnd, apply$2(update, from, destination, noConstrain), 1);
3904    set(SCROLLING);
3905    emit(EVENT_SCROLL$1);
3906    interval.start();
3907  }
3908
3909  function onEnd() {
3910    set(IDLE);
3911    callback && callback();
3912    emit(EVENT_SCROLLED$1);
3913  }
3914
3915  function update(from, to, noConstrain, rate) {
3916    var position = getPosition();
3917    var target = from + (to - from) * easing(rate);
3918    var diff = (target - position) * friction;
3919    translate(position + diff);
3920
3921    if (isSlide && !noConstrain && exceededLimit()) {
3922      friction *= FRICTION_FACTOR;
3923
3924      if (abs(diff) < BOUNCE_DIFF_THRESHOLD) {
3925        scroll(getLimit(exceededLimit(true)), BOUNCE_DURATION, false, callback, true);
3926      }
3927    }
3928  }
3929
3930  function clear() {
3931    if (interval) {
3932      interval.cancel();
3933    }
3934  }
3935
3936  function cancel() {
3937    if (interval && !interval.isPaused()) {
3938      clear();
3939      onEnd();
3940    }
3941  }
3942
3943  function easing(t) {
3944    var easingFunc = options.easingFunc;
3945    return easingFunc ? easingFunc(t) : 1 - Math.pow(1 - t, 4);
3946  }
3947
3948  return {
3949    mount: mount,
3950    destroy: clear,
3951    scroll: scroll,
3952    cancel: cancel
3953  };
3954}
3955
3956var SCROLL_LISTENER_OPTIONS = {
3957  passive: false,
3958  capture: true
3959};
3960
3961function Drag(Splide2, Components2, options) {
3962  var _EventInterface9 = EventInterface$1(Splide2),
3963      on = _EventInterface9.on,
3964      emit = _EventInterface9.emit,
3965      bind = _EventInterface9.bind,
3966      unbind = _EventInterface9.unbind;
3967
3968  var state = Splide2.state;
3969  var Move = Components2.Move,
3970      Scroll = Components2.Scroll,
3971      Controller = Components2.Controller,
3972      track = Components2.Elements.track,
3973      reduce = Components2.Media.reduce;
3974  var _Components2$Directio2 = Components2.Direction,
3975      resolve = _Components2$Directio2.resolve,
3976      orient = _Components2$Directio2.orient;
3977  var getPosition = Move.getPosition,
3978      exceededLimit = Move.exceededLimit;
3979  var basePosition;
3980  var baseEvent;
3981  var prevBaseEvent;
3982  var isFree;
3983  var dragging;
3984  var exceeded = false;
3985  var clickPrevented;
3986  var disabled;
3987  var target;
3988
3989  function mount() {
3990    bind(track, POINTER_MOVE_EVENTS, noop, SCROLL_LISTENER_OPTIONS);
3991    bind(track, POINTER_UP_EVENTS, noop, SCROLL_LISTENER_OPTIONS);
3992    bind(track, POINTER_DOWN_EVENTS, onPointerDown, SCROLL_LISTENER_OPTIONS);
3993    bind(track, "click", onClick, {
3994      capture: true
3995    });
3996    bind(track, "dragstart", prevent);
3997    on([EVENT_MOUNTED, EVENT_UPDATED$1], init);
3998  }
3999
4000  function init() {
4001    var drag = options.drag;
4002    disable(!drag);
4003    isFree = drag === "free";
4004  }
4005
4006  function onPointerDown(e) {
4007    clickPrevented = false;
4008
4009    if (!disabled) {
4010      var isTouch = isTouchEvent(e);
4011
4012      if (isDraggable(e.target) && (isTouch || !e.button)) {
4013        if (!Controller.isBusy()) {
4014          target = isTouch ? track : window;
4015          dragging = state.is([MOVING, SCROLLING]);
4016          prevBaseEvent = null;
4017          bind(target, POINTER_MOVE_EVENTS, onPointerMove, SCROLL_LISTENER_OPTIONS);
4018          bind(target, POINTER_UP_EVENTS, onPointerUp, SCROLL_LISTENER_OPTIONS);
4019          Move.cancel();
4020          Scroll.cancel();
4021          save(e);
4022        } else {
4023          prevent(e, true);
4024        }
4025      }
4026    }
4027  }
4028
4029  function onPointerMove(e) {
4030    if (!state.is(DRAGGING)) {
4031      state.set(DRAGGING);
4032      emit(EVENT_DRAG$1);
4033    }
4034
4035    if (e.cancelable) {
4036      if (dragging) {
4037        Move.translate(basePosition + constrain(diffCoord(e)));
4038        var expired = diffTime(e) > LOG_INTERVAL;
4039        var hasExceeded = exceeded !== (exceeded = exceededLimit());
4040
4041        if (expired || hasExceeded) {
4042          save(e);
4043        }
4044
4045        clickPrevented = true;
4046        emit(EVENT_DRAGGING);
4047        prevent(e);
4048      } else if (isSliderDirection(e)) {
4049        dragging = shouldStart(e);
4050        prevent(e);
4051      }
4052    }
4053  }
4054
4055  function onPointerUp(e) {
4056    if (state.is(DRAGGING)) {
4057      state.set(IDLE);
4058      emit(EVENT_DRAGGED);
4059    }
4060
4061    if (dragging) {
4062      move(e);
4063      prevent(e);
4064    }
4065
4066    unbind(target, POINTER_MOVE_EVENTS, onPointerMove);
4067    unbind(target, POINTER_UP_EVENTS, onPointerUp);
4068    dragging = false;
4069  }
4070
4071  function onClick(e) {
4072    if (!disabled && clickPrevented) {
4073      prevent(e, true);
4074    }
4075  }
4076
4077  function save(e) {
4078    prevBaseEvent = baseEvent;
4079    baseEvent = e;
4080    basePosition = getPosition();
4081  }
4082
4083  function move(e) {
4084    var velocity = computeVelocity(e);
4085    var destination = computeDestination(velocity);
4086    var rewind = options.rewind && options.rewindByDrag;
4087    reduce(false);
4088
4089    if (isFree) {
4090      Controller.scroll(destination, 0, options.snap);
4091    } else if (Splide2.is(FADE$1)) {
4092      Controller.go(orient(sign(velocity)) < 0 ? rewind ? "<" : "-" : rewind ? ">" : "+");
4093    } else if (Splide2.is(SLIDE$1) && exceeded && rewind) {
4094      Controller.go(exceededLimit(true) ? ">" : "<");
4095    } else {
4096      Controller.go(Controller.toDest(destination), true);
4097    }
4098
4099    reduce(true);
4100  }
4101
4102  function shouldStart(e) {
4103    var thresholds = options.dragMinThreshold;
4104    var isObj = isObject$1(thresholds);
4105    var mouse = isObj && thresholds.mouse || 0;
4106    var touch = (isObj ? thresholds.touch : +thresholds) || 10;
4107    return abs(diffCoord(e)) > (isTouchEvent(e) ? touch : mouse);
4108  }
4109
4110  function isSliderDirection(e) {
4111    return abs(diffCoord(e)) > abs(diffCoord(e, true));
4112  }
4113
4114  function computeVelocity(e) {
4115    if (Splide2.is(LOOP) || !exceeded) {
4116      var time = diffTime(e);
4117
4118      if (time && time < LOG_INTERVAL) {
4119        return diffCoord(e) / time;
4120      }
4121    }
4122
4123    return 0;
4124  }
4125
4126  function computeDestination(velocity) {
4127    return getPosition() + sign(velocity) * min$3(abs(velocity) * (options.flickPower || 600), isFree ? Infinity : Components2.Layout.listSize() * (options.flickMaxPages || 1));
4128  }
4129
4130  function diffCoord(e, orthogonal) {
4131    return coordOf(e, orthogonal) - coordOf(getBaseEvent(e), orthogonal);
4132  }
4133
4134  function diffTime(e) {
4135    return timeOf(e) - timeOf(getBaseEvent(e));
4136  }
4137
4138  function getBaseEvent(e) {
4139    return baseEvent === e && prevBaseEvent || baseEvent;
4140  }
4141
4142  function coordOf(e, orthogonal) {
4143    return (isTouchEvent(e) ? e.changedTouches[0] : e)["page" + resolve(orthogonal ? "Y" : "X")];
4144  }
4145
4146  function constrain(diff) {
4147    return diff / (exceeded && Splide2.is(SLIDE$1) ? FRICTION : 1);
4148  }
4149
4150  function isDraggable(target2) {
4151    var noDrag = options.noDrag;
4152    return !matches(target2, "." + CLASS_PAGINATION_PAGE + ", ." + CLASS_ARROW) && (!noDrag || !matches(target2, noDrag));
4153  }
4154
4155  function isTouchEvent(e) {
4156    return typeof TouchEvent !== "undefined" && e instanceof TouchEvent;
4157  }
4158
4159  function isDragging() {
4160    return dragging;
4161  }
4162
4163  function disable(value) {
4164    disabled = value;
4165  }
4166
4167  return {
4168    mount: mount,
4169    disable: disable,
4170    isDragging: isDragging
4171  };
4172}
4173
4174var NORMALIZATION_MAP = {
4175  Spacebar: " ",
4176  Right: ARROW_RIGHT,
4177  Left: ARROW_LEFT,
4178  Up: ARROW_UP,
4179  Down: ARROW_DOWN
4180};
4181
4182function normalizeKey(key) {
4183  key = isString(key) ? key : key.key;
4184  return NORMALIZATION_MAP[key] || key;
4185}
4186
4187var KEYBOARD_EVENT = "keydown";
4188
4189function Keyboard(Splide2, Components2, options) {
4190  var _EventInterface10 = EventInterface$1(Splide2),
4191      on = _EventInterface10.on,
4192      bind = _EventInterface10.bind,
4193      unbind = _EventInterface10.unbind;
4194
4195  var root = Splide2.root;
4196  var resolve = Components2.Direction.resolve;
4197  var target;
4198  var disabled;
4199
4200  function mount() {
4201    init();
4202    on(EVENT_UPDATED$1, destroy);
4203    on(EVENT_UPDATED$1, init);
4204    on(EVENT_MOVE$1, onMove);
4205  }
4206
4207  function init() {
4208    var keyboard = options.keyboard;
4209
4210    if (keyboard) {
4211      target = keyboard === "global" ? window : root;
4212      bind(target, KEYBOARD_EVENT, onKeydown);
4213    }
4214  }
4215
4216  function destroy() {
4217    unbind(target, KEYBOARD_EVENT);
4218  }
4219
4220  function disable(value) {
4221    disabled = value;
4222  }
4223
4224  function onMove() {
4225    var _disabled = disabled;
4226    disabled = true;
4227    nextTick(function () {
4228      disabled = _disabled;
4229    });
4230  }
4231
4232  function onKeydown(e) {
4233    if (!disabled) {
4234      var key = normalizeKey(e);
4235
4236      if (key === resolve(ARROW_LEFT)) {
4237        Splide2.go("<");
4238      } else if (key === resolve(ARROW_RIGHT)) {
4239        Splide2.go(">");
4240      }
4241    }
4242  }
4243
4244  return {
4245    mount: mount,
4246    destroy: destroy,
4247    disable: disable
4248  };
4249}
4250
4251var SRC_DATA_ATTRIBUTE = DATA_ATTRIBUTE + "-lazy";
4252var SRCSET_DATA_ATTRIBUTE = SRC_DATA_ATTRIBUTE + "-srcset";
4253var IMAGE_SELECTOR = "[" + SRC_DATA_ATTRIBUTE + "], [" + SRCSET_DATA_ATTRIBUTE + "]";
4254
4255function LazyLoad(Splide2, Components2, options) {
4256  var _EventInterface11 = EventInterface$1(Splide2),
4257      on = _EventInterface11.on,
4258      off = _EventInterface11.off,
4259      bind = _EventInterface11.bind,
4260      emit = _EventInterface11.emit;
4261
4262  var isSequential = options.lazyLoad === "sequential";
4263  var events = [EVENT_MOVED$1, EVENT_SCROLLED$1];
4264  var entries = [];
4265
4266  function mount() {
4267    if (options.lazyLoad) {
4268      init();
4269      on(EVENT_REFRESH, init);
4270    }
4271  }
4272
4273  function init() {
4274    empty$1(entries);
4275    register();
4276
4277    if (isSequential) {
4278      loadNext();
4279    } else {
4280      off(events);
4281      on(events, check);
4282      check();
4283    }
4284  }
4285
4286  function register() {
4287    Components2.Slides.forEach(function (Slide) {
4288      queryAll(Slide.slide, IMAGE_SELECTOR).forEach(function (img) {
4289        var src = getAttribute(img, SRC_DATA_ATTRIBUTE);
4290        var srcset = getAttribute(img, SRCSET_DATA_ATTRIBUTE);
4291
4292        if (src !== img.src || srcset !== img.srcset) {
4293          var className = options.classes.spinner;
4294          var parent = img.parentElement;
4295          var spinner = child(parent, "." + className) || create("span", className, parent);
4296          entries.push([img, Slide, spinner]);
4297          img.src || display(img, "none");
4298        }
4299      });
4300    });
4301  }
4302
4303  function check() {
4304    entries = entries.filter(function (data) {
4305      var distance = options.perPage * ((options.preloadPages || 1) + 1) - 1;
4306      return data[1].isWithin(Splide2.index, distance) ? load(data) : true;
4307    });
4308    entries.length || off(events);
4309  }
4310
4311  function load(data) {
4312    var img = data[0];
4313    addClass(data[1].slide, CLASS_LOADING);
4314    bind(img, "load error", apply$2(onLoad, data));
4315    setAttribute$1(img, "src", getAttribute(img, SRC_DATA_ATTRIBUTE));
4316    setAttribute$1(img, "srcset", getAttribute(img, SRCSET_DATA_ATTRIBUTE));
4317    removeAttribute$1(img, SRC_DATA_ATTRIBUTE);
4318    removeAttribute$1(img, SRCSET_DATA_ATTRIBUTE);
4319  }
4320
4321  function onLoad(data, e) {
4322    var img = data[0],
4323        Slide = data[1];
4324    removeClass(Slide.slide, CLASS_LOADING);
4325
4326    if (e.type !== "error") {
4327      remove(data[2]);
4328      display(img, "");
4329      emit(EVENT_LAZYLOAD_LOADED, img, Slide);
4330      emit(EVENT_RESIZE);
4331    }
4332
4333    isSequential && loadNext();
4334  }
4335
4336  function loadNext() {
4337    entries.length && load(entries.shift());
4338  }
4339
4340  return {
4341    mount: mount,
4342    destroy: apply$2(empty$1, entries),
4343    check: check
4344  };
4345}
4346
4347function Pagination(Splide2, Components2, options) {
4348  var event = EventInterface$1(Splide2);
4349  var on = event.on,
4350      emit = event.emit,
4351      bind = event.bind;
4352  var Slides = Components2.Slides,
4353      Elements = Components2.Elements,
4354      Controller = Components2.Controller;
4355  var hasFocus = Controller.hasFocus,
4356      getIndex = Controller.getIndex,
4357      go = Controller.go;
4358  var resolve = Components2.Direction.resolve;
4359  var placeholder = Elements.pagination;
4360  var items = [];
4361  var list;
4362  var paginationClasses;
4363
4364  function mount() {
4365    destroy();
4366    on([EVENT_UPDATED$1, EVENT_REFRESH, EVENT_END_INDEX_CHANGED], mount);
4367    var enabled = options.pagination;
4368    placeholder && display(placeholder, enabled ? "" : "none");
4369
4370    if (enabled) {
4371      on([EVENT_MOVE$1, EVENT_SCROLL$1, EVENT_SCROLLED$1], update);
4372      createPagination();
4373      update();
4374      emit(EVENT_PAGINATION_MOUNTED, {
4375        list: list,
4376        items: items
4377      }, getAt(Splide2.index));
4378    }
4379  }
4380
4381  function destroy() {
4382    if (list) {
4383      remove(placeholder ? slice$2(list.children) : list);
4384      removeClass(list, paginationClasses);
4385      empty$1(items);
4386      list = null;
4387    }
4388
4389    event.destroy();
4390  }
4391
4392  function createPagination() {
4393    var length = Splide2.length;
4394    var classes = options.classes,
4395        i18n = options.i18n,
4396        perPage = options.perPage;
4397    var max = hasFocus() ? Controller.getEnd() + 1 : ceil(length / perPage);
4398    list = placeholder || create("ul", classes.pagination, Elements.track.parentElement);
4399    addClass(list, paginationClasses = CLASS_PAGINATION + "--" + getDirection());
4400    setAttribute$1(list, ROLE, "tablist");
4401    setAttribute$1(list, ARIA_LABEL, i18n.select);
4402    setAttribute$1(list, ARIA_ORIENTATION, getDirection() === TTB ? "vertical" : "");
4403
4404    for (var i = 0; i < max; i++) {
4405      var li = create("li", null, list);
4406      var button = create("button", {
4407        class: classes.page,
4408        type: "button"
4409      }, li);
4410      var controls = Slides.getIn(i).map(function (Slide) {
4411        return Slide.slide.id;
4412      });
4413      var text = !hasFocus() && perPage > 1 ? i18n.pageX : i18n.slideX;
4414      bind(button, "click", apply$2(onClick, i));
4415
4416      if (options.paginationKeyboard) {
4417        bind(button, "keydown", apply$2(onKeydown, i));
4418      }
4419
4420      setAttribute$1(li, ROLE, "presentation");
4421      setAttribute$1(button, ROLE, "tab");
4422      setAttribute$1(button, ARIA_CONTROLS, controls.join(" "));
4423      setAttribute$1(button, ARIA_LABEL, format(text, i + 1));
4424      setAttribute$1(button, TAB_INDEX, -1);
4425      items.push({
4426        li: li,
4427        button: button,
4428        page: i
4429      });
4430    }
4431  }
4432
4433  function onClick(page) {
4434    go(">" + page, true);
4435  }
4436
4437  function onKeydown(page, e) {
4438    var length = items.length;
4439    var key = normalizeKey(e);
4440    var dir = getDirection();
4441    var nextPage = -1;
4442
4443    if (key === resolve(ARROW_RIGHT, false, dir)) {
4444      nextPage = ++page % length;
4445    } else if (key === resolve(ARROW_LEFT, false, dir)) {
4446      nextPage = (--page + length) % length;
4447    } else if (key === "Home") {
4448      nextPage = 0;
4449    } else if (key === "End") {
4450      nextPage = length - 1;
4451    }
4452
4453    var item = items[nextPage];
4454
4455    if (item) {
4456      focus(item.button);
4457      go(">" + nextPage);
4458      prevent(e, true);
4459    }
4460  }
4461
4462  function getDirection() {
4463    return options.paginationDirection || options.direction;
4464  }
4465
4466  function getAt(index) {
4467    return items[Controller.toPage(index)];
4468  }
4469
4470  function update() {
4471    var prev = getAt(getIndex(true));
4472    var curr = getAt(getIndex());
4473
4474    if (prev) {
4475      var button = prev.button;
4476      removeClass(button, CLASS_ACTIVE$1);
4477      removeAttribute$1(button, ARIA_SELECTED);
4478      setAttribute$1(button, TAB_INDEX, -1);
4479    }
4480
4481    if (curr) {
4482      var _button = curr.button;
4483      addClass(_button, CLASS_ACTIVE$1);
4484      setAttribute$1(_button, ARIA_SELECTED, true);
4485      setAttribute$1(_button, TAB_INDEX, "");
4486    }
4487
4488    emit(EVENT_PAGINATION_UPDATED, {
4489      list: list,
4490      items: items
4491    }, prev, curr);
4492  }
4493
4494  return {
4495    items: items,
4496    mount: mount,
4497    destroy: destroy,
4498    getAt: getAt,
4499    update: update
4500  };
4501}
4502
4503var TRIGGER_KEYS = [" ", "Enter"];
4504
4505function Sync(Splide2, Components2, options) {
4506  var isNavigation = options.isNavigation,
4507      slideFocus = options.slideFocus;
4508  var events = [];
4509
4510  function mount() {
4511    Splide2.splides.forEach(function (target) {
4512      if (!target.isParent) {
4513        sync(Splide2, target.splide);
4514        sync(target.splide, Splide2);
4515      }
4516    });
4517
4518    if (isNavigation) {
4519      navigate();
4520    }
4521  }
4522
4523  function destroy() {
4524    events.forEach(function (event) {
4525      event.destroy();
4526    });
4527    empty$1(events);
4528  }
4529
4530  function remount() {
4531    destroy();
4532    mount();
4533  }
4534
4535  function sync(splide, target) {
4536    var event = EventInterface$1(splide);
4537    event.on(EVENT_MOVE$1, function (index, prev, dest) {
4538      target.go(target.is(LOOP) ? dest : index);
4539    });
4540    events.push(event);
4541  }
4542
4543  function navigate() {
4544    var event = EventInterface$1(Splide2);
4545    var on = event.on;
4546    on(EVENT_CLICK, onClick);
4547    on(EVENT_SLIDE_KEYDOWN, onKeydown);
4548    on([EVENT_MOUNTED, EVENT_UPDATED$1], update);
4549    events.push(event);
4550    event.emit(EVENT_NAVIGATION_MOUNTED, Splide2.splides);
4551  }
4552
4553  function update() {
4554    setAttribute$1(Components2.Elements.list, ARIA_ORIENTATION, options.direction === TTB ? "vertical" : "");
4555  }
4556
4557  function onClick(Slide) {
4558    Splide2.go(Slide.index);
4559  }
4560
4561  function onKeydown(Slide, e) {
4562    if (includes(TRIGGER_KEYS, normalizeKey(e))) {
4563      onClick(Slide);
4564      prevent(e);
4565    }
4566  }
4567
4568  return {
4569    setup: apply$2(Components2.Media.set, {
4570      slideFocus: isUndefined$1(slideFocus) ? isNavigation : slideFocus
4571    }, true),
4572    mount: mount,
4573    destroy: destroy,
4574    remount: remount
4575  };
4576}
4577
4578function Wheel(Splide2, Components2, options) {
4579  var _EventInterface12 = EventInterface$1(Splide2),
4580      bind = _EventInterface12.bind;
4581
4582  var lastTime = 0;
4583
4584  function mount() {
4585    if (options.wheel) {
4586      bind(Components2.Elements.track, "wheel", onWheel, SCROLL_LISTENER_OPTIONS);
4587    }
4588  }
4589
4590  function onWheel(e) {
4591    if (e.cancelable) {
4592      var deltaY = e.deltaY;
4593      var backwards = deltaY < 0;
4594      var timeStamp = timeOf(e);
4595
4596      var _min = options.wheelMinThreshold || 0;
4597
4598      var sleep = options.wheelSleep || 0;
4599
4600      if (abs(deltaY) > _min && timeStamp - lastTime > sleep) {
4601        Splide2.go(backwards ? "<" : ">");
4602        lastTime = timeStamp;
4603      }
4604
4605      shouldPrevent(backwards) && prevent(e);
4606    }
4607  }
4608
4609  function shouldPrevent(backwards) {
4610    return !options.releaseWheel || Splide2.state.is(MOVING) || Components2.Controller.getAdjacent(backwards) !== -1;
4611  }
4612
4613  return {
4614    mount: mount
4615  };
4616}
4617
4618var SR_REMOVAL_DELAY = 90;
4619
4620function Live(Splide2, Components2, options) {
4621  var _EventInterface13 = EventInterface$1(Splide2),
4622      on = _EventInterface13.on;
4623
4624  var track = Components2.Elements.track;
4625  var enabled = options.live && !options.isNavigation;
4626  var sr = create("span", CLASS_SR);
4627  var interval = RequestInterval$1(SR_REMOVAL_DELAY, apply$2(toggle, false));
4628
4629  function mount() {
4630    if (enabled) {
4631      disable(!Components2.Autoplay.isPaused());
4632      setAttribute$1(track, ARIA_ATOMIC, true);
4633      sr.textContent = "\u2026";
4634      on(EVENT_AUTOPLAY_PLAY, apply$2(disable, true));
4635      on(EVENT_AUTOPLAY_PAUSE, apply$2(disable, false));
4636      on([EVENT_MOVED$1, EVENT_SCROLLED$1], apply$2(toggle, true));
4637    }
4638  }
4639
4640  function toggle(active) {
4641    setAttribute$1(track, ARIA_BUSY, active);
4642
4643    if (active) {
4644      append(track, sr);
4645      interval.start();
4646    } else {
4647      remove(sr);
4648      interval.cancel();
4649    }
4650  }
4651
4652  function destroy() {
4653    removeAttribute$1(track, [ARIA_LIVE, ARIA_ATOMIC, ARIA_BUSY]);
4654    remove(sr);
4655  }
4656
4657  function disable(disabled) {
4658    if (enabled) {
4659      setAttribute$1(track, ARIA_LIVE, disabled ? "off" : "polite");
4660    }
4661  }
4662
4663  return {
4664    mount: mount,
4665    disable: disable,
4666    destroy: destroy
4667  };
4668}
4669
4670var ComponentConstructors = /*#__PURE__*/Object.freeze({
4671  __proto__: null,
4672  Media: Media,
4673  Direction: Direction,
4674  Elements: Elements,
4675  Slides: Slides,
4676  Layout: Layout,
4677  Clones: Clones,
4678  Move: Move,
4679  Controller: Controller,
4680  Arrows: Arrows,
4681  Autoplay: Autoplay,
4682  Cover: Cover,
4683  Scroll: Scroll,
4684  Drag: Drag,
4685  Keyboard: Keyboard,
4686  LazyLoad: LazyLoad,
4687  Pagination: Pagination,
4688  Sync: Sync,
4689  Wheel: Wheel,
4690  Live: Live
4691});
4692var I18N$1 = {
4693  prev: "Previous slide",
4694  next: "Next slide",
4695  first: "Go to first slide",
4696  last: "Go to last slide",
4697  slideX: "Go to slide %s",
4698  pageX: "Go to page %s",
4699  play: "Start autoplay",
4700  pause: "Pause autoplay",
4701  carousel: "carousel",
4702  slide: "slide",
4703  select: "Select a slide to show",
4704  slideLabel: "%s of %s"
4705};
4706var DEFAULTS$1 = {
4707  type: "slide",
4708  role: "region",
4709  speed: 400,
4710  perPage: 1,
4711  cloneStatus: true,
4712  arrows: true,
4713  pagination: true,
4714  paginationKeyboard: true,
4715  interval: 5e3,
4716  pauseOnHover: true,
4717  pauseOnFocus: true,
4718  resetProgress: true,
4719  easing: "cubic-bezier(0.25, 1, 0.5, 1)",
4720  drag: true,
4721  direction: "ltr",
4722  trimSpace: true,
4723  focusableNodes: "a, button, textarea, input, select, iframe",
4724  live: true,
4725  classes: CLASSES,
4726  i18n: I18N$1,
4727  reducedMotion: {
4728    speed: 0,
4729    rewindSpeed: 0,
4730    autoplay: "pause"
4731  }
4732};
4733
4734function Fade(Splide2, Components2, options) {
4735  var Slides = Components2.Slides;
4736
4737  function mount() {
4738    EventInterface$1(Splide2).on([EVENT_MOUNTED, EVENT_REFRESH], init);
4739  }
4740
4741  function init() {
4742    Slides.forEach(function (Slide) {
4743      Slide.style("transform", "translateX(-" + 100 * Slide.index + "%)");
4744    });
4745  }
4746
4747  function start(index, done) {
4748    Slides.style("transition", "opacity " + options.speed + "ms " + options.easing);
4749    nextTick(done);
4750  }
4751
4752  return {
4753    mount: mount,
4754    start: start,
4755    cancel: noop
4756  };
4757}
4758
4759function Slide(Splide2, Components2, options) {
4760  var Move = Components2.Move,
4761      Controller = Components2.Controller,
4762      Scroll = Components2.Scroll;
4763  var list = Components2.Elements.list;
4764  var transition = apply$2(style, list, "transition");
4765  var endCallback;
4766
4767  function mount() {
4768    EventInterface$1(Splide2).bind(list, "transitionend", function (e) {
4769      if (e.target === list && endCallback) {
4770        cancel();
4771        endCallback();
4772      }
4773    });
4774  }
4775
4776  function start(index, done) {
4777    var destination = Move.toPosition(index, true);
4778    var position = Move.getPosition();
4779    var speed = getSpeed(index);
4780
4781    if (abs(destination - position) >= 1 && speed >= 1) {
4782      if (options.useScroll) {
4783        Scroll.scroll(destination, speed, false, done);
4784      } else {
4785        transition("transform " + speed + "ms " + options.easing);
4786        Move.translate(destination, true);
4787        endCallback = done;
4788      }
4789    } else {
4790      Move.jump(index);
4791      done();
4792    }
4793  }
4794
4795  function cancel() {
4796    transition("");
4797    Scroll.cancel();
4798  }
4799
4800  function getSpeed(index) {
4801    var rewindSpeed = options.rewindSpeed;
4802
4803    if (Splide2.is(SLIDE$1) && rewindSpeed) {
4804      var prev = Controller.getIndex(true);
4805      var end = Controller.getEnd();
4806
4807      if (prev === 0 && index >= end || prev >= end && index === 0) {
4808        return rewindSpeed;
4809      }
4810    }
4811
4812    return options.speed;
4813  }
4814
4815  return {
4816    mount: mount,
4817    start: start,
4818    cancel: cancel
4819  };
4820}
4821
4822var _Splide = /*#__PURE__*/function () {
4823  function _Splide(target, options) {
4824    this.event = EventInterface$1();
4825    this.Components = {};
4826    this.state = State(CREATED);
4827    this.splides = [];
4828    this._o = {};
4829    this._E = {};
4830    var root = isString(target) ? query(document, target) : target;
4831    assert(root, root + " is invalid.");
4832    this.root = root;
4833    options = merge({
4834      label: getAttribute(root, ARIA_LABEL) || "",
4835      labelledby: getAttribute(root, ARIA_LABELLEDBY) || ""
4836    }, DEFAULTS$1, _Splide.defaults, options || {});
4837
4838    try {
4839      merge(options, JSON.parse(getAttribute(root, DATA_ATTRIBUTE)));
4840    } catch (e) {
4841      assert(false, "Invalid JSON");
4842    }
4843
4844    this._o = Object.create(merge({}, options));
4845  }
4846
4847  var _proto = _Splide.prototype;
4848
4849  _proto.mount = function mount(Extensions, Transition) {
4850    var _this = this;
4851
4852    var state = this.state,
4853        Components2 = this.Components;
4854    assert(state.is([CREATED, DESTROYED]), "Already mounted!");
4855    state.set(CREATED);
4856    this._C = Components2;
4857    this._T = Transition || this._T || (this.is(FADE$1) ? Fade : Slide);
4858    this._E = Extensions || this._E;
4859    var Constructors = assign$2({}, ComponentConstructors, this._E, {
4860      Transition: this._T
4861    });
4862    forOwn$2(Constructors, function (Component, key) {
4863      var component = Component(_this, Components2, _this._o);
4864      Components2[key] = component;
4865      component.setup && component.setup();
4866    });
4867    forOwn$2(Components2, function (component) {
4868      component.mount && component.mount();
4869    });
4870    this.emit(EVENT_MOUNTED);
4871    addClass(this.root, CLASS_INITIALIZED);
4872    state.set(IDLE);
4873    this.emit(EVENT_READY);
4874    return this;
4875  };
4876
4877  _proto.sync = function sync(splide) {
4878    this.splides.push({
4879      splide: splide
4880    });
4881    splide.splides.push({
4882      splide: this,
4883      isParent: true
4884    });
4885
4886    if (this.state.is(IDLE)) {
4887      this._C.Sync.remount();
4888
4889      splide.Components.Sync.remount();
4890    }
4891
4892    return this;
4893  };
4894
4895  _proto.go = function go(control) {
4896    this._C.Controller.go(control);
4897
4898    return this;
4899  };
4900
4901  _proto.on = function on(events, callback) {
4902    this.event.on(events, callback);
4903    return this;
4904  };
4905
4906  _proto.off = function off(events) {
4907    this.event.off(events);
4908    return this;
4909  };
4910
4911  _proto.emit = function emit(event) {
4912    var _this$event;
4913
4914    (_this$event = this.event).emit.apply(_this$event, [event].concat(slice$2(arguments, 1)));
4915
4916    return this;
4917  };
4918
4919  _proto.add = function add(slides, index) {
4920    this._C.Slides.add(slides, index);
4921
4922    return this;
4923  };
4924
4925  _proto.remove = function remove(matcher) {
4926    this._C.Slides.remove(matcher);
4927
4928    return this;
4929  };
4930
4931  _proto.is = function is(type) {
4932    return this._o.type === type;
4933  };
4934
4935  _proto.refresh = function refresh() {
4936    this.emit(EVENT_REFRESH);
4937    return this;
4938  };
4939
4940  _proto.destroy = function destroy(completely) {
4941    if (completely === void 0) {
4942      completely = true;
4943    }
4944
4945    var event = this.event,
4946        state = this.state;
4947
4948    if (state.is(CREATED)) {
4949      EventInterface$1(this).on(EVENT_READY, this.destroy.bind(this, completely));
4950    } else {
4951      forOwn$2(this._C, function (component) {
4952        component.destroy && component.destroy(completely);
4953      }, true);
4954      event.emit(EVENT_DESTROY$1);
4955      event.destroy();
4956      completely && empty$1(this.splides);
4957      state.set(DESTROYED);
4958    }
4959
4960    return this;
4961  };
4962
4963  _createClass(_Splide, [{
4964    key: "options",
4965    get: function get() {
4966      return this._o;
4967    },
4968    set: function set(options) {
4969      this._C.Media.set(options, true, true);
4970    }
4971  }, {
4972    key: "length",
4973    get: function get() {
4974      return this._C.Slides.getLength(true);
4975    }
4976  }, {
4977    key: "index",
4978    get: function get() {
4979      return this._C.Controller.getIndex();
4980    }
4981  }]);
4982
4983  return _Splide;
4984}();
4985
4986var Splide = _Splide;
4987Splide.defaults = {};
4988Splide.STATES = STATES;
4989
4990class SplideThumbnailsSlider {
4991  constructor(container) {
4992    if (!container) {
4993      return;
4994    }
4995
4996    this.ui = {
4997      container,
4998      splideMainSliderSelector: container.querySelector(".splide--main"),
4999      splideThumbnailSliderSelector: container.querySelector(