https://russianhighways.ru/bitrix/js/main/core/core.js?1780497317543783

1059	// have been (and was previously) designed to take a closure to be
1060	// invoked without arguments, but in all the cases we care about we
1061	// already have an existing method we want to call, so there's no need
1062	// to create a new function object. We can even get away with assuming
1063	// the method takes exactly one argument, since that happens to be true
1064	// in every case, so we don't have to touch the arguments object. The
1065	// only additional allocation required is the completion record, which
1066	// has a stable shape and so hopefully should be cheap to allocate.
1067	function tryCatch(fn, obj, arg) {
1068		try {
1069			return { type: "normal", arg: fn.call(obj, arg) };
1070		} catch (err) {
1071			return { type: "throw", arg: err };
1072		}
1073	}
1074
1075	var GenStateSuspendedStart = "suspendedStart";
1076	var GenStateSuspendedYield = "suspendedYield";
1077	var GenStateExecuting = "executing";
1078	var GenStateCompleted = "completed";
1079
1080	// Returning this object from the innerFn has the same effect as
1081	// breaking out of the dispatch switch statement.
1082	var ContinueSentinel = {};
1083
1084	// Dummy constructor functions that we use as the .constructor and
1085	// .constructor.prototype properties for functions that return Generator
1086	// objects. For full spec compliance, you may wish to configure your
1087	// minifier not to mangle the names of these two functions.
1088	function Generator() {}
1089	function GeneratorFunction() {}
1090	function GeneratorFunctionPrototype() {}
1091
1092	// This is a polyfill for %IteratorPrototype% for environments that
1093	// don't natively support it.
1094	var IteratorPrototype = {};
1095	IteratorPrototype[iteratorSymbol] = function () {
1096		return this;
1097	};
1098
1099	var getProto = Object.getPrototypeOf;
1100	var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
1101	if (NativeIteratorPrototype &&
1102		NativeIteratorPrototype !== Op &&
1103		hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
1104		// This environment has a native %IteratorPrototype%; use it instead
1105		// of the polyfill.
1106		IteratorPrototype = NativeIteratorPrototype;
1107	}
1108
1109	var Gp = GeneratorFunctionPrototype.prototype =
1110		Generator.prototype = Object.create(IteratorPrototype);
1111	GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
1112	GeneratorFunctionPrototype.constructor = GeneratorFunction;
1113	GeneratorFunctionPrototype[toStringTagSymbol] =
1114		GeneratorFunction.displayName = "GeneratorFunction";
1115
1116	// Helper for defining the .next, .throw, and .return methods of the
1117	// Iterator interface in terms of a single ._invoke method.
1118	function defineIteratorMethods(prototype) {
1119		["next", "throw", "return"].forEach(function(method) {
1120			prototype[method] = function(arg) {
1121				return this._invoke(method, arg);
1122			};
1123		});
1124	}
1125
1126	runtime.isGeneratorFunction = function(genFun) {
1127		var ctor = typeof genFun === "function" && genFun.constructor;
1128		return ctor
1129			? ctor === GeneratorFunction ||
1130			// For the native GeneratorFunction constructor, the best we can
1131			// do is to check its .name property.
1132			(ctor.displayName || ctor.name) === "GeneratorFunction"
1133			: false;
1134	};
1135
1136	runtime.mark = function(genFun) {
1137		if (Object.setPrototypeOf) {
1138			Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
1139		} else {
1140			genFun.__proto__ = GeneratorFunctionPrototype;
1141			if (!(toStringTagSymbol in genFun)) {
1142				genFun[toStringTagSymbol] = "GeneratorFunction";
1143			}
1144		}
1145		genFun.prototype = Object.create(Gp);
1146		return genFun;
1147	};
1148
1149	// Within the body of any async function, `await x` is transformed to
1150	// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
1151	// `hasOwn.call(value, "__await")` to determine if the yielded value is
1152	// meant to be awaited.
1153	runtime.awrap = function(arg) {
1154		return { __await: arg };
1155	};
1156
1157	function AsyncIterator(generator) {
1158		function invoke(method, arg, resolve, reject) {
1159			var record = tryCatch(generator[method], generator, arg);
1160			if (record.type === "throw") {
1161				reject(record.arg);
1162			} else {
1163				var result = record.arg;
1164				var value = result.value;
1165				if (value &&
1166					typeof value === "object" &&
1167					hasOwn.call(value, "__await")) {
1168					return Promise.resolve(value.__await).then(function(value) {
1169						invoke("next", value, resolve, reject);
1170					}, function(err) {
1171						invoke("throw", err, resolve, reject);
1172					});
1173				}
1174
1175				return Promise.resolve(value).then(function(unwrapped) {
1176					// When a yielded Promise is resolved, its final value becomes
1177					// the .value of the Promise<{value,done}> result for the
1178					// current iteration. If the Promise is rejected, however, the
1179					// result for this iteration will be rejected with the same
1180					// reason. Note that rejections of yielded Promises are not
1181					// thrown back into the generator function, as is the case
1182					// when an awaited Promise is rejected. This difference in
1183					// behavior between yield and await is important, because it
1184					// allows the consumer to decide what to do with the yielded
1185					// rejection (swallow it and continue, manually .throw it back
1186					// into the generator, abandon iteration, whatever). With
1187					// await, by contrast, there is no opportunity to examine the
1188					// rejection reason outside the generator function, so the
1189					// only option is to throw it from the await expression, and
1190					// let the generator function handle the exception.
1191					result.value = unwrapped;
1192					resolve(result);
1193				}, reject);
1194			}
1195		}
1196
1197		var previousPromise;
1198
1199		function enqueue(method, arg) {
1200			function callInvokeWithMethodAndArg() {
1201				return new Promise(function(resolve, reject) {
1202					invoke(method, arg, resolve, reject);
1203				});
1204			}
1205
1206			return previousPromise =
1207				// If enqueue has been called before, then we want to wait until
1208				// all previous Promises have been resolved before calling invoke,
1209				// so that results are always delivered in the correct order. If
1210				// enqueue has not been called before, then it is important to
1211				// call invoke immediately, without waiting on a callback to fire,
1212				// so that the async generator function has the opportunity to do
1213				// any necessary setup in a predictable way. This predictability
1214				// is why the Promise constructor synchronously invokes its
1215				// executor callback, and why async functions synchronously
1216				// execute code before the first await. Since we implement simple
1217				// async functions in terms of async generators, it is especially
1218				// important to get this right, even though it requires care.
1219				previousPromise ? previousPromise.then(
1220					callInvokeWithMethodAndArg,
1221					// Avoid propagating failures to Promises returned by later
1222					// invocations of the iterator.
1223					callInvokeWithMethodAndArg
1224				) : callInvokeWithMethodAndArg();
1225		}
1226
1227		// Define the unified helper method that is used to implement .next,
1228		// .throw, and .return (see defineIteratorMethods).
1229		this._invoke = enqueue;
1230	}
1231
1232	defineIteratorMethods(AsyncIterator.prototype);
1233	AsyncIterator.prototype[asyncIteratorSymbol] = function () {
1234		return this;
1235	};
1236	runtime.AsyncIterator = AsyncIterator;
1237
1238	// Note that simple async functions are implemented on top of
1239	// AsyncIterator objects; they just return a Promise for the value of
1240	// the final result produced by the iterator.
1241	runtime.async = function(innerFn, outerFn, self, tryLocsList) {
1242		var iter = new AsyncIterator(
1243			wrap(innerFn, outerFn, self, tryLocsList)
1244		);
1245
1246		return runtime.isGeneratorFunction(outerFn)
1247			? iter // If outerFn is a generator, return the full iterator.
1248			: iter.next().then(function(result) {
1249				return result.done ? result.value : iter.next();
1250			});
1251	};
1252
1253	function makeInvokeMethod(innerFn, self, context) {
1254		var state = GenStateSuspendedStart;
1255
1256		return function invoke(method, arg) {
1257			if (state === GenStateExecuting) {
1258				throw new Error("Generator is already running");
1259			}
1260
1261			if (state === GenStateCompleted) {
1262				if (method === "throw") {
1263					throw arg;
1264				}
1265
1266				// Be forgiving, per 25.3.3.3.3 of the spec:
1267				// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
1268				return doneResult();
1269			}
1270
1271			context.method = method;
1272			context.arg = arg;
1273
1274			while (true) {
1275				var delegate = context.delegate;
1276				if (delegate) {
1277					var delegateResult = maybeInvokeDelegate(delegate, context);
1278					if (delegateResult) {
1279						if (delegateResult === ContinueSentinel) continue;
1280						return delegateResult;
1281					}
1282				}
1283
1284				if (context.method === "next") {
1285					// Setting context._sent for legacy support of Babel's
1286					// function.sent implementation.
1287					context.sent = context._sent = context.arg;
1288
1289				} else if (context.method === "throw") {
1290					if (state === GenStateSuspendedStart) {
1291						state = GenStateCompleted;
1292						throw context.arg;
1293					}
1294
1295					context.dispatchException(context.arg);
1296
1297				} else if (context.method === "return") {
1298					context.abrupt("return", context.arg);
1299				}
1300
1301				state = GenStateExecuting;
1302
1303				var record = tryCatch(innerFn, self, context);
1304				if (record.type === "normal") {
1305					// If an exception is thrown from innerFn, we leave state ===
1306					// GenStateExecuting and loop back for another invocation.
1307					state = context.done
1308						? GenStateCompleted
1309						: GenStateSuspendedYield;
1310
1311					if (record.arg === ContinueSentinel) {
1312						continue;
1313					}
1314
1315					return {
1316						value: record.arg,
1317						done: context.done
1318					};
1319
1320				} else if (record.type === "throw") {
1321					state = GenStateCompleted;
1322					// Dispatch the exception by looping back around to the
1323					// context.dispatchException(context.arg) call above.
1324					context.method = "throw";
1325					context.arg = record.arg;
1326				}
1327			}
1328		};
1329	}
1330
1331	// Call delegate.iterator[context.method](context.arg) and handle the
1332	// result, either by returning a { value, done } result from the
1333	// delegate iterator, or by modifying context.method and context.arg,
1334	// setting context.delegate to null, and returning the ContinueSentinel.
1335	function maybeInvokeDelegate(delegate, context) {
1336		var method = delegate.iterator[context.method];
1337		if (method === undefined) {
1338			// A .throw or .return when the delegate iterator has no .throw
1339			// method always terminates the yield* loop.
1340			context.delegate = null;
1341
1342			if (context.method === "throw") {
1343				if (delegate.iterator.return) {
1344					// If the delegate iterator has a return method, give it a
1345					// chance to clean up.
1346					context.method = "return";
1347					context.arg = undefined;
1348					maybeInvokeDelegate(delegate, context);
1349
1350					if (context.method === "throw") {
1351						// If maybeInvokeDelegate(context) changed context.method from
1352						// "return" to "throw", let that override the TypeError below.

1353						return ContinueSentinel;
1354					}
1355				}
1356
1357				context.method = "throw";
1358				context.arg = new TypeError(
1359					"The iterator does not provide a 'throw' method");
1360			}
1361
1362			return ContinueSentinel;
1363		}
1364
1365		var record = tryCatch(method, delegate.iterator, context.arg);
1366
1367		if (record.type === "throw") {
1368			context.method = "throw";
1369			context.arg = record.arg;
1370			context.delegate = null;
1371			return ContinueSentinel;
1372		}
1373
1374		var info = record.arg;
1375
1376		if (! info) {
1377			context.method = "throw";
1378			context.arg = new TypeError("iterator result is not an object");
1379			context.delegate = null;
1380			return ContinueSentinel;
1381		}
1382
1383		if (info.done) {
1384			// Assign the result of the finished delegate to the temporary
1385			// variable specified by delegate.resultName (see delegateYield).
1386			context[delegate.resultName] = info.value;
1387
1388			// Resume execution at the desired location (see delegateYield).
1389			context.next = delegate.nextLoc;
1390
1391			// If context.method was "throw" but the delegate handled the
1392			// exception, let the outer generator proceed normally. If
1393			// context.method was "next", forget context.arg since it has been
1394			// "consumed" by the delegate iterator. If context.method was
1395			// "return", allow the original .return call to continue in the
1396			// outer generator.
1397			if (context.method !== "return") {
1398				context.method = "next";
1399				context.arg = undefined;
1400			}
1401
1402		} else {
1403			// Re-yield the result returned by the delegate method.
1404			return info;
1405		}
1406
1407		// The delegate iterator is finished, so forget it and continue with
1408		// the outer generator.
1409		context.delegate = null;
1410		return ContinueSentinel;
1411	}
1412
1413	// Define Generator.prototype.{next,throw,return} in terms of the
1414	// unified ._invoke helper method.
1415	defineIteratorMethods(Gp);
1416
1417	Gp[toStringTagSymbol] = "Generator";
1418
1419	// A Generator should always return itself as the iterator object when the
1420	// @@iterator function is called on it. Some browsers' implementations of the
1421	// iterator prototype chain incorrectly implement this, causing the Generator
1422	// object to not be returned from this call. This ensures that doesn't happen.
1423	// See https://github.com/facebook/regenerator/issues/274 for more details.
1424	Gp[iteratorSymbol] = function() {
1425		return this;
1426	};
1427
1428	Gp.toString = function() {
1429		return "[object Generator]";
1430	};
1431
1432	function pushTryEntry(locs) {
1433		var entry = { tryLoc: locs[0] };
1434
1435		if (1 in locs) {
1436			entry.catchLoc = locs[1];
1437		}
1438
1439		if (2 in locs) {
1440			entry.finallyLoc = locs[2];
1441			entry.afterLoc = locs[3];
1442		}
1443
1444		this.tryEntries.push(entry);
1445	}
1446
1447	function resetTryEntry(entry) {
1448		var record = entry.completion || {};
1449		record.type = "normal";
1450		delete record.arg;
1451		entry.completion = record;
1452	}
1453
1454	function Context(tryLocsList) {
1455		// The root entry object (effectively a try statement without a catch
1456		// or a finally block) gives us a place to store values thrown from
1457		// locations where there is no enclosing try statement.
1458		this.tryEntries = [{ tryLoc: "root" }];
1459		tryLocsList.forEach(pushTryEntry, this);
1460		this.reset(true);
1461	}
1462
1463	runtime.keys = function(object) {
1464		var keys = [];
1465		for (var key in object) {
1466			keys.push(key);
1467		}
1468		keys.reverse();
1469
1470		// Rather than returning an object with a next method, we keep
1471		// things simple and return the next function itself.
1472		return function next() {
1473			while (keys.length) {
1474				var key = keys.pop();
1475				if (key in object) {
1476					next.value = key;
1477					next.done = false;
1478					return next;
1479				}
1480			}
1481
1482			// To avoid creating an additional object, we just hang the .value
1483			// and .done properties off the next function object itself. This
1484			// also ensures that the minifier will not anonymize the function.
1485			next.done = true;
1486			return next;
1487		};
1488	};
1489
1490	function values(iterable) {
1491		if (iterable) {
1492			var iteratorMethod = iterable[iteratorSymbol];
1493			if (iteratorMethod) {
1494				return iteratorMethod.call(iterable);
1495			}
1496
1497			if (typeof iterable.next === "function") {
1498				return iterable;
1499			}
1500
1501			if (!isNaN(iterable.length)) {
1502				var i = -1, next = function next() {
1503					while (++i < iterable.length) {
1504						if (hasOwn.call(iterable, i)) {
1505							next.value = iterable[i];
1506							next.done = false;

1850	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
1851	var isNullOrUndefined = function (it) {
1852	  return it === null || it === undefined;
1853	};
1854
1855	var $TypeError = TypeError;
1856
1857	// `RequireObjectCoercible` abstract operation
1858	// https://tc39.es/ecma262/#sec-requireobjectcoercible
1859	var requireObjectCoercible = function (it) {
1860	  if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
1861	  return it;
1862	};
1863
1864	// toObject with fallback for non-array-like ES3 strings
1865
1866
1867	var toIndexedObject = function (it) {
1868	  return indexedObject(requireObjectCoercible(it));
1869	};
1870
1871	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
1872	var documentAll = typeof document == 'object' && document.all;
1873
1874	// `IsCallable` abstract operation
1875	// https://tc39.es/ecma262/#sec-iscallable
1876	// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
1877	var isCallable = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
1878	  return typeof argument == 'function' || argument === documentAll;
1879	} : function (argument) {
1880	  return typeof argument == 'function';
1881	};
1882
1883	var isObject = function (it) {
1884	  return typeof it == 'object' ? it !== null : isCallable(it);
1885	};
1886
1887	var aFunction = function (argument) {
1888	  return isCallable(argument) ? argument : undefined;
1889	};
1890	var getBuiltIn = function (namespace, method) {
1891	  return arguments.length < 2 ? aFunction(globalThis_1[namespace]) : globalThis_1[namespace] && globalThis_1[namespace][method];
1892	};
1893
1894	var objectIsPrototypeOf = functionUncurryThis({}.isPrototypeOf);
1895
1896	var navigator = globalThis_1.navigator;
1897	var userAgent = navigator && navigator.userAgent;
1898	var environmentUserAgent = userAgent ? String(userAgent) : '';
1899
1900	var process = globalThis_1.process;
1901	var Deno$1 = globalThis_1.Deno;
1902	var versions = process && process.versions || Deno$1 && Deno$1.version;
1903	var v8 = versions && versions.v8;
1904	var match, version;
1905	if (v8) {
1906	  match = v8.split('.');
1907	  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
1908	  // but their correct versions are not interesting for us
1909	  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
1910	}
1911
1912	// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
1913	// so check `userAgent` even if `.v8` exists, but 0
1914	if (!version && environmentUserAgent) {
1915	  match = environmentUserAgent.match(/Edge\/(\d+)/);
1916	  if (!match || match[1] >= 74) {
1917	    match = environmentUserAgent.match(/Chrome\/(\d+)/);
1918	    if (match) version = +match[1];
1919	  }
1920	}
1921	var environmentV8Version = version;
1922
1923	/* eslint-disable es/no-symbol -- required for testing */
1924
1925
1926
1927	var $String = globalThis_1.String;
1928
1929	// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
1930	var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails(function () {
1931	  var symbol = Symbol('symbol detection');
1932	  // Chrome 38 Symbol has incorrect toString conversion
1933	  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
1934	  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
1935	  // of course, fail.
1936	  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
1937	  // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
1938	  !Symbol.sham && environmentV8Version && environmentV8Version < 41;
1939	});
1940
1941	/* eslint-disable es/no-symbol -- required for testing */
1942
1943	var useSymbolAsUid = symbolConstructorDetection && !Symbol.sham && typeof Symbol.iterator == 'symbol';
1944
1945	var $Object$1 = Object;
1946	var isSymbol = useSymbolAsUid ? function (it) {
1947	  return typeof it == 'symbol';
1948	} : function (it) {
1949	  var $Symbol = getBuiltIn('Symbol');
1950	  return isCallable($Symbol) && objectIsPrototypeOf($Symbol.prototype, $Object$1(it));
1951	};
1952
1953	var $String$1 = String;
1954	var tryToString = function (argument) {
1955	  try {
1956	    return $String$1(argument);
1957	  } catch (error) {
1958	    return 'Object';
1959	  }
1960	};
1961
1962	var $TypeError$1 = TypeError;
1963
1964	// `Assert: IsCallable(argument) is true`
1965	var aCallable = function (argument) {
1966	  if (isCallable(argument)) return argument;
1967	  throw new $TypeError$1(tryToString(argument) + ' is not a function');
1968	};
1969
1970	// `GetMethod` abstract operation
1971	// https://tc39.es/ecma262/#sec-getmethod
1972	var getMethod = function (V, P) {
1973	  var func = V[P];
1974	  return isNullOrUndefined(func) ? undefined : aCallable(func);
1975	};
1976
1977	var $TypeError$2 = TypeError;
1978
1979	// `OrdinaryToPrimitive` abstract operation
1980	// https://tc39.es/ecma262/#sec-ordinarytoprimitive
1981	var ordinaryToPrimitive = function (input, pref) {
1982	  var fn, val;
1983	  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = functionCall(fn, input))) return val;
1984	  if (isCallable(fn = input.valueOf) && !isObject(val = functionCall(fn, input))) return val;
1985	  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = functionCall(fn, input))) return val;
1986	  throw new $TypeError$2("Can't convert object to primitive value");
1987	};
1988
1989	var isPure = false;
1990
1991	// eslint-disable-next-line es/no-object-defineproperty -- safe
1992	var defineProperty = Object.defineProperty;
1993	var defineGlobalProperty = function (key, value) {
1994	  try {
1995	    defineProperty(globalThis_1, key, {
1996	      value: value,
1997	      configurable: true,
1998	      writable: true
1999	    });
2000	  } catch (error) {
2001	    globalThis_1[key] = value;
2002	  }
2003	  return value;
2004	};
2005
2006	var sharedStore = createCommonjsModule(function (module) {
2007
2008
2009
2010
2011	var SHARED = '__core-js_shared__';
2012	var store = module.exports = globalThis_1[SHARED] || defineGlobalProperty(SHARED, {});
2013	(store.versions || (store.versions = [])).push({
2014	  version: '3.41.0',
2015	  mode: 'global',
2016	  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
2017	  license: 'https://github.com/zloirock/core-js/blob/v3.41.0/LICENSE',
2018	  source: 'https://github.com/zloirock/core-js'
2019	});
2020	});
2021
2022	var shared = createCommonjsModule(function (module) {
2023	(module.exports = function (key, value) {
2024	  return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});
2025	})('versions', []).push({
2026	  version: '3.19.2',
2027	  mode: 'global',
2028	  copyright: '(c) 2021 Denis Pushkarev (zloirock.ru)'
2029	});
2030	});
2031
2032	var $Object$2 = Object;
2033
2034	// `ToObject` abstract operation
2035	// https://tc39.es/ecma262/#sec-toobject
2036	var toObject = function (argument) {
2037	  return $Object$2(requireObjectCoercible(argument));
2038	};
2039
2040	var hasOwnProperty = functionUncurryThis({}.hasOwnProperty);
2041
2042	// `HasOwnProperty` abstract operation
2043	// https://tc39.es/ecma262/#sec-hasownproperty
2044	// eslint-disable-next-line es/no-object-hasown -- safe
2045	var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
2046	  return hasOwnProperty(toObject(it), key);
2047	};
2048
2049	var id = 0;
2050	var postfix = Math.random();
2051	var toString$1 = functionUncurryThis(1.0.toString);
2052	var uid = function (key) {
2053	  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$1(++id + postfix, 36);
2054	};
2055
2056	var Symbol$1 = globalThis_1.Symbol;
2057	var WellKnownSymbolsStore = shared('wks');
2058	var createWellKnownSymbol = useSymbolAsUid ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid;
2059	var wellKnownSymbol = function (name) {
2060	  if (!hasOwnProperty_1(WellKnownSymbolsStore, name)) {
2061	    WellKnownSymbolsStore[name] = symbolConstructorDetection && hasOwnProperty_1(Symbol$1, name) ? Symbol$1[name] : createWellKnownSymbol('Symbol.' + name);
2062	  }
2063	  return WellKnownSymbolsStore[name];
2064	};
2065
2066	var $TypeError$3 = TypeError;
2067	var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
2068
2069	// `ToPrimitive` abstract operation
2070	// https://tc39.es/ecma262/#sec-toprimitive
2071	var toPrimitive = function (input, pref) {
2072	  if (!isObject(input) || isSymbol(input)) return input;
2073	  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
2074	  var result;
2075	  if (exoticToPrim) {
2076	    if (pref === undefined) pref = 'default';
2077	    result = functionCall(exoticToPrim, input, pref);
2078	    if (!isObject(result) || isSymbol(result)) return result;
2079	    throw new $TypeError$3("Can't convert object to primitive value");
2080	  }
2081	  if (pref === undefined) pref = 'number';
2082	  return ordinaryToPrimitive(input, pref);
2083	};
2084
2085	// `ToPropertyKey` abstract operation
2086	// https://tc39.es/ecma262/#sec-topropertykey
2087	var toPropertyKey = function (argument) {
2088	  var key = toPrimitive(argument, 'string');
2089	  return isSymbol(key) ? key : key + '';
2090	};
2091
2092	var document$1 = globalThis_1.document;
2093	// typeof document.createElement is 'object' in old IE
2094	var EXISTS = isObject(document$1) && isObject(document$1.createElement);
2095	var documentCreateElement = function (it) {
2096	  return EXISTS ? document$1.createElement(it) : {};
2097	};
2098
2099	// Thanks to IE8 for its funny defineProperty
2100	var ie8DomDefine = !descriptors && !fails(function () {
2101	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
2102	  return Object.defineProperty(documentCreateElement('div'), 'a', {
2103	    get: function () {
2104	      return 7;
2105	    }
2106	  }).a !== 7;
2107	});
2108
2109	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2110	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2111
2112	// `Object.getOwnPropertyDescriptor` method
2113	// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
2114	var f$1 = descriptors ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
2115	  O = toIndexedObject(O);
2116	  P = toPropertyKey(P);
2117	  if (ie8DomDefine) try {
2118	    return $getOwnPropertyDescriptor(O, P);
2119	  } catch (error) {/* empty */}
2120	  if (hasOwnProperty_1(O, P)) return createPropertyDescriptor(!functionCall(objectPropertyIsEnumerable.f, O, P), O[P]);
2121	};
2122
2123	var objectGetOwnPropertyDescriptor = {
2124		f: f$1
2125	};
2126
2127	// V8 ~ Chrome 36-
2128	// https://bugs.chromium.org/p/v8/issues/detail?id=3334
2129	var v8PrototypeDefineBug = descriptors && fails(function () {
2130	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
2131	  return Object.defineProperty(function () {/* empty */}, 'prototype', {
2132	    value: 42,
2133	    writable: false
2134	  }).prototype !== 42;
2135	});
2136
2137	var $String$2 = String;
2138	var $TypeError$4 = TypeError;
2139
2140	// `Assert: Type(argument) is Object`
2141	var anObject = function (argument) {
2142	  if (isObject(argument)) return argument;
2143	  throw new $TypeError$4($String$2(argument) + ' is not an object');
2144	};
2145
2146	var $TypeError$5 = TypeError;
2147	// eslint-disable-next-line es/no-object-defineproperty -- safe
2148	var $defineProperty = Object.defineProperty;
2149	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2150	var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
2151	var ENUMERABLE = 'enumerable';
2152	var CONFIGURABLE = 'configurable';
2153	var WRITABLE = 'writable';
2154
2155	// `Object.defineProperty` method
2156	// https://tc39.es/ecma262/#sec-object.defineproperty
2157	var f$2 = descriptors ? v8PrototypeDefineBug ? function defineProperty(O, P, Attributes) {
2158	  anObject(O);
2159	  P = toPropertyKey(P);
2160	  anObject(Attributes);
2161	  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
2162	    var current = $getOwnPropertyDescriptor$1(O, P);
2163	    if (current && current[WRITABLE]) {
2164	      O[P] = Attributes.value;
2165	      Attributes = {
2166	        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
2167	        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
2168	        writable: false
2169	      };
2170	    }
2171	  }
2172	  return $defineProperty(O, P, Attributes);
2173	} : $defineProperty : function defineProperty(O, P, Attributes) {
2174	  anObject(O);
2175	  P = toPropertyKey(P);
2176	  anObject(Attributes);
2177	  if (ie8DomDefine) try {
2178	    return $defineProperty(O, P, Attributes);
2179	  } catch (error) {/* empty */}
2180	  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$5('Accessors not supported');
2181	  if ('value' in Attributes) O[P] = Attributes.value;
2182	  return O;
2183	};
2184
2185	var objectDefineProperty = {
2186		f: f$2
2187	};
2188
2189	var createNonEnumerableProperty = descriptors ? function (object, key, value) {
2190	  return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
2191	} : function (object, key, value) {
2192	  object[key] = value;
2193	  return object;
2194	};
2195
2196	var FunctionPrototype$1 = Function.prototype;
2197	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2198	var getDescriptor = descriptors && Object.getOwnPropertyDescriptor;
2199	var EXISTS$1 = hasOwnProperty_1(FunctionPrototype$1, 'name');
2200	// additional protection from minified / mangled / dropped function names
2201	var PROPER = EXISTS$1 && function something() {/* empty */}.name === 'something';
2202	var CONFIGURABLE$1 = EXISTS$1 && (!descriptors || descriptors && getDescriptor(FunctionPrototype$1, 'name').configurable);
2203	var functionName = {
2204	  EXISTS: EXISTS$1,
2205	  PROPER: PROPER,
2206	  CONFIGURABLE: CONFIGURABLE$1
2207	};
2208
2209	var functionToString = functionUncurryThis(Function.toString);
2210
2211	// this helper broken in `[email protected]`, so we can't use `shared` helper
2212	if (!isCallable(sharedStore.inspectSource)) {
2213	  sharedStore.inspectSource = function (it) {
2214	    return functionToString(it);
2215	  };
2216	}
2217	var inspectSource = sharedStore.inspectSource;
2218
2219	var WeakMap = globalThis_1.WeakMap;
2220	var weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
2221
2222	var keys = shared('keys');
2223	var sharedKey = function (key) {
2224	  return keys[key] || (keys[key] = uid(key));
2225	};
2226
2227	var hiddenKeys = {};
2228
2229	var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
2230	var TypeError$1 = globalThis_1.TypeError;
2231	var WeakMap$1 = globalThis_1.WeakMap;
2232	var set, get, has;
2233	var enforce = function (it) {
2234	  return has(it) ? get(it) : set(it, {});
2235	};
2236	var getterFor = function (TYPE) {
2237	  return function (it) {
2238	    var state;
2239	    if (!isObject(it) || (state = get(it)).type !== TYPE) {
2240	      throw new TypeError$1('Incompatible receiver, ' + TYPE + ' required');
2241	    }
2242	    return state;
2243	  };
2244	};
2245	if (weakMapBasicDetection || sharedStore.state) {
2246	  var store = sharedStore.state || (sharedStore.state = new WeakMap$1());
2247	  /* eslint-disable no-self-assign -- prototype methods protection */
2248	  store.get = store.get;
2249	  store.has = store.has;
2250	  store.set = store.set;
2251	  /* eslint-enable no-self-assign -- prototype methods protection */
2252	  set = function (it, metadata) {
2253	    if (store.has(it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
2254	    metadata.facade = it;
2255	    store.set(it, metadata);
2256	    return metadata;
2257	  };
2258	  get = function (it) {
2259	    return store.get(it) || {};
2260	  };
2261	  has = function (it) {
2262	    return store.has(it);
2263	  };
2264	} else {
2265	  var STATE = sharedKey('state');
2266	  hiddenKeys[STATE] = true;
2267	  set = function (it, metadata) {
2268	    if (hasOwnProperty_1(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
2269	    metadata.facade = it;
2270	    createNonEnumerableProperty(it, STATE, metadata);
2271	    return metadata;
2272	  };
2273	  get = function (it) {
2274	    return hasOwnProperty_1(it, STATE) ? it[STATE] : {};
2275	  };
2276	  has = function (it) {
2277	    return hasOwnProperty_1(it, STATE);
2278	  };
2279	}
2280	var internalState = {
2281	  set: set,
2282	  get: get,
2283	  has: has,
2284	  enforce: enforce,
2285	  getterFor: getterFor
2286	};
2287
2288	var makeBuiltIn_1 = createCommonjsModule(function (module) {
2289
2290
2291
2292
2293
2294
2295	var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
2296
2297
2298	var enforceInternalState = internalState.enforce;
2299	var getInternalState = internalState.get;
2300	var $String = String;
2301	// eslint-disable-next-line es/no-object-defineproperty -- safe
2302	var defineProperty = Object.defineProperty;
2303	var stringSlice = functionUncurryThis(''.slice);
2304	var replace = functionUncurryThis(''.replace);
2305	var join = functionUncurryThis([].join);
2306	var CONFIGURABLE_LENGTH = descriptors && !fails(function () {
2307	  return defineProperty(function () {/* empty */}, 'length', {
2308	    value: 8
2309	  }).length !== 8;
2310	});
2311	var TEMPLATE = String(String).split('String');
2312	var makeBuiltIn = module.exports = function (value, name, options) {
2313	  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
2314	    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
2315	  }
2316	  if (options && options.getter) name = 'get ' + name;
2317	  if (options && options.setter) name = 'set ' + name;
2318	  if (!hasOwnProperty_1(value, 'name') || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
2319	    if (descriptors) defineProperty(value, 'name', {
2320	      value: name,
2321	      configurable: true
2322	    });else value.name = name;
2323	  }
2324	  if (CONFIGURABLE_LENGTH && options && hasOwnProperty_1(options, 'arity') && value.length !== options.arity) {
2325	    defineProperty(value, 'length', {
2326	      value: options.arity
2327	    });
2328	  }
2329	  try {
2330	    if (options && hasOwnProperty_1(options, 'constructor') && options.constructor) {
2331	      if (descriptors) defineProperty(value, 'prototype', {
2332	        writable: false
2333	      });
2334	      // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
2335	    } else if (value.prototype) value.prototype = undefined;
2336	  } catch (error) {/* empty */}
2337	  var state = enforceInternalState(value);
2338	  if (!hasOwnProperty_1(state, 'source')) {
2339	    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
2340	  }
2341	  return value;
2342	};
2343
2344	// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
2345	// eslint-disable-next-line no-extend-native -- required
2346	Function.prototype.toString = makeBuiltIn(function toString() {
2347	  return isCallable(this) && getInternalState(this).source || inspectSource(this);
2348	}, 'toString');
2349	});
2350
2351	var defineBuiltIn = function (O, key, value, options) {
2352	  if (!options) options = {};
2353	  var simple = options.enumerable;
2354	  var name = options.name !== undefined ? options.name : key;
2355	  if (isCallable(value)) makeBuiltIn_1(value, name, options);
2356	  if (options.global) {
2357	    if (simple) O[key] = value;else defineGlobalProperty(key, value);
2358	  } else {
2359	    try {
2360	      if (!options.unsafe) delete O[key];else if (O[key]) simple = true;
2361	    } catch (error) {/* empty */}
2362	    if (simple) O[key] = value;else objectDefineProperty.f(O, key, {
2363	      value: value,
2364	      enumerable: false,
2365	      configurable: !options.nonConfigurable,
2366	      writable: !options.nonWritable
2367	    });
2368	  }
2369	  return O;
2370	};
2371
2372	var ceil = Math.ceil;
2373	var floor = Math.floor;
2374
2375	// `Math.trunc` method
2376	// https://tc39.es/ecma262/#sec-math.trunc
2377	// eslint-disable-next-line es/no-math-trunc -- safe
2378	var mathTrunc = Math.trunc || function trunc(x) {
2379	  var n = +x;
2380	  return (n > 0 ? floor : ceil)(n);
2381	};
2382
2383	// `ToIntegerOrInfinity` abstract operation
2384	// https://tc39.es/ecma262/#sec-tointegerorinfinity
2385	var toIntegerOrInfinity = function (argument) {
2386	  var number = +argument;
2387	  // eslint-disable-next-line no-self-compare -- NaN check
2388	  return number !== number || number === 0 ? 0 : mathTrunc(number);
2389	};
2390
2391	var max = Math.max;
2392	var min = Math.min;
2393
2394	// Helper for a popular repeating case of the spec:
2395	// Let integer be ? ToInteger(index).
2396	// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
2397	var toAbsoluteIndex = function (index, length) {
2398	  var integer = toIntegerOrInfinity(index);
2399	  return integer < 0 ? max(integer + length, 0) : min(integer, length);
2400	};
2401
2402	var min$1 = Math.min;
2403
2404	// `ToLength` abstract operation
2405	// https://tc39.es/ecma262/#sec-tolength
2406	var toLength = function (argument) {
2407	  var len = toIntegerOrInfinity(argument);
2408	  return len > 0 ? min$1(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
2409	};
2410
2411	// `LengthOfArrayLike` abstract operation
2412	// https://tc39.es/ecma262/#sec-lengthofarraylike
2413	var lengthOfArrayLike = function (obj) {
2414	  return toLength(obj.length);
2415	};
2416
2417	// `Array.prototype.{ indexOf, includes }` methods implementation
2418	var createMethod = function (IS_INCLUDES) {
2419	  return function ($this, el, fromIndex) {
2420	    var O = toIndexedObject($this);
2421	    var length = lengthOfArrayLike(O);
2422	    if (length === 0) return !IS_INCLUDES && -1;
2423	    var index = toAbsoluteIndex(fromIndex, length);
2424	    var value;
2425	    // Array#includes uses SameValueZero equality algorithm
2426	    // eslint-disable-next-line no-self-compare -- NaN check
2427	    if (IS_INCLUDES && el !== el) while (length > index) {
2428	      value = O[index++];
2429	      // eslint-disable-next-line no-self-compare -- NaN check
2430	      if (value !== value) return true;
2431	      // Array#indexOf ignores holes, Array#includes - not
2432	    } else for (; length > index; index++) {
2433	      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
2434	    }
2435	    return !IS_INCLUDES && -1;
2436	  };
2437	};
2438	var arrayIncludes = {
2439	  // `Array.prototype.includes` method
2440	  // https://tc39.es/ecma262/#sec-array.prototype.includes
2441	  includes: createMethod(true),
2442	  // `Array.prototype.indexOf` method
2443	  // https://tc39.es/ecma262/#sec-array.prototype.indexof
2444	  indexOf: createMethod(false)
2445	};
2446
2447	var indexOf = arrayIncludes.indexOf;
2448
2449	var push = functionUncurryThis([].push);
2450	var objectKeysInternal = function (object, names) {
2451	  var O = toIndexedObject(object);
2452	  var i = 0;
2453	  var result = [];
2454	  var key;
2455	  for (key in O) !hasOwnProperty_1(hiddenKeys, key) && hasOwnProperty_1(O, key) && push(result, key);
2456	  // Don't enum bug & hidden keys
2457	  while (names.length > i) if (hasOwnProperty_1(O, key = names[i++])) {
2458	    ~indexOf(result, key) || push(result, key);
2459	  }
2460	  return result;
2461	};
2462
2463	// IE8- don't enum bug keys
2464	var enumBugKeys = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
2465
2466	var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype');
2467
2468	// `Object.getOwnPropertyNames` method
2469	// https://tc39.es/ecma262/#sec-object.getownpropertynames
2470	// eslint-disable-next-line es/no-object-getownpropertynames -- safe
2471	var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
2472	  return objectKeysInternal(O, hiddenKeys$1);
2473	};
2474
2475	var objectGetOwnPropertyNames = {
2476		f: f$3
2477	};
2478
2479	// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
2480	var f$4 = Object.getOwnPropertySymbols;
2481
2482	var objectGetOwnPropertySymbols = {
2483		f: f$4
2484	};
2485
2486	var concat = functionUncurryThis([].concat);
2487
2488	// all object keys, includes non-enumerable and symbols
2489	var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
2490	  var keys = objectGetOwnPropertyNames.f(anObject(it));
2491	  var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
2492	  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
2493	};
2494
2495	var copyConstructorProperties = function (target, source, exceptions) {
2496	  var keys = ownKeys(source);
2497	  var defineProperty = objectDefineProperty.f;
2498	  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
2499	  for (var i = 0; i < keys.length; i++) {
2500	    var key = keys[i];
2501	    if (!hasOwnProperty_1(target, key) && !(exceptions && hasOwnProperty_1(exceptions, key))) {
2502	      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
2503	    }
2504	  }
2505	};
2506
2507	var replacement = /#|\.prototype\./;
2508	var isForced = function (feature, detection) {
2509	  var value = data[normalize(feature)];
2510	  return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
2511	};
2512	var normalize = isForced.normalize = function (string) {
2513	  return String(string).replace(replacement, '.').toLowerCase();
2514	};
2515	var data = isForced.data = {};
2516	var NATIVE = isForced.NATIVE = 'N';
2517	var POLYFILL = isForced.POLYFILL = 'P';
2518	var isForced_1 = isForced;
2519
2520	var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
2521
2522
2523
2524
2525
2526
2527	/*
2528	  options.target         - name of the target object
2529	  options.global         - target is the global object
2530	  options.stat           - export as static methods of target
2531	  options.proto          - export as prototype methods of target
2532	  options.real           - real prototype method for the `pure` version
2533	  options.forced         - export even if the native feature is available
2534	  options.bind           - bind methods to the target, required for the `pure` version
2535	  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
2536	  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
2537	  options.sham           - add a flag to not completely full polyfills
2538	  options.enumerable     - export as enumerable property
2539	  options.dontCallGetSet - prevent calling a getter on target
2540	  options.name           - the .name of the function if it does not match the key
2541	*/
2542	var _export = function (options, source) {
2543	  var TARGET = options.target;
2544	  var GLOBAL = options.global;
2545	  var STATIC = options.stat;
2546	  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
2547	  if (GLOBAL) {
2548	    target = globalThis_1;
2549	  } else if (STATIC) {
2550	    target = globalThis_1[TARGET] || defineGlobalProperty(TARGET, {});
2551	  } else {
2552	    target = globalThis_1[TARGET] && globalThis_1[TARGET].prototype;
2553	  }
2554	  if (target) for (key in source) {
2555	    sourceProperty = source[key];
2556	    if (options.dontCallGetSet) {
2557	      descriptor = getOwnPropertyDescriptor$1(target, key);
2558	      targetProperty = descriptor && descriptor.value;
2559	    } else targetProperty = target[key];
2560	    FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
2561	    // contained in target
2562	    if (!FORCED && targetProperty !== undefined) {
2563	      if (typeof sourceProperty == typeof targetProperty) continue;
2564	      copyConstructorProperties(sourceProperty, targetProperty);
2565	    }
2566	    // add a flag to not completely full polyfills
2567	    if (options.sham || targetProperty && targetProperty.sham) {
2568	      createNonEnumerableProperty(sourceProperty, 'sham', true);
2569	    }
2570	    defineBuiltIn(target, key, sourceProperty, options);
2571	  }
2572	};
2573
2574	var correctPrototypeGetter = !fails(function () {
2575	  function F() {/* empty */}
2576	  F.prototype.constructor = null;
2577	  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
2578	  return Object.getPrototypeOf(new F()) !== F.prototype;
2579	});
2580
2581	var IE_PROTO = sharedKey('IE_PROTO');
2582	var $Object$3 = Object;
2583	var ObjectPrototype = $Object$3.prototype;
2584
2585	// `Object.getPrototypeOf` method
2586	// https://tc39.es/ecma262/#sec-object.getprototypeof
2587	// eslint-disable-next-line es/no-object-getprototypeof -- safe
2588	var objectGetPrototypeOf = correctPrototypeGetter ? $Object$3.getPrototypeOf : function (O) {
2589	  var object = toObject(O);
2590	  if (hasOwnProperty_1(object, IE_PROTO)) return object[IE_PROTO];
2591	  var constructor = object.constructor;
2592	  if (isCallable(constructor) && object instanceof constructor) {
2593	    return constructor.prototype;
2594	  }
2595	  return object instanceof $Object$3 ? ObjectPrototype : null;
2596	};
2597
2598	var functionUncurryThisAccessor = function (object, key, method) {
2599	  try {
2600	    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2601	    return functionUncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
2602	  } catch (error) {/* empty */}
2603	};
2604
2605	var isPossiblePrototype = function (argument) {
2606	  return isObject(argument) || argument === null;
2607	};
2608
2609	var $String$3 = String;
2610	var $TypeError$6 = TypeError;
2611	var aPossiblePrototype = function (argument) {
2612	  if (isPossiblePrototype(argument)) return argument;
2613	  throw new $TypeError$6("Can't set " + $String$3(argument) + ' as a prototype');
2614	};
2615
2616	/* eslint-disable no-proto -- safe */
2617
2618
2619
2620
2621
2622	// `Object.setPrototypeOf` method
2623	// https://tc39.es/ecma262/#sec-object.setprototypeof
2624	// Works with __proto__ only. Old v8 can't work with null proto objects.
2625	// eslint-disable-next-line es/no-object-setprototypeof -- safe
2626	var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
2627	  var CORRECT_SETTER = false;
2628	  var test = {};
2629	  var setter;
2630	  try {
2631	    setter = functionUncurryThisAccessor(Object.prototype, '__proto__', 'set');
2632	    setter(test, []);
2633	    CORRECT_SETTER = test instanceof Array;
2634	  } catch (error) {/* empty */}
2635	  return function setPrototypeOf(O, proto) {
2636	    requireObjectCoercible(O);
2637	    aPossiblePrototype(proto);
2638	    if (!isObject(O)) return O;
2639	    if (CORRECT_SETTER) setter(O, proto);else O.__proto__ = proto;
2640	    return O;
2641	  };
2642	}() : undefined);
2643
2644	// `Object.keys` method
2645	// https://tc39.es/ecma262/#sec-object.keys
2646	// eslint-disable-next-line es/no-object-keys -- safe
2647	var objectKeys = Object.keys || function keys(O) {
2648	  return objectKeysInternal(O, enumBugKeys);
2649	};
2650
2651	// `Object.defineProperties` method
2652	// https://tc39.es/ecma262/#sec-object.defineproperties
2653	// eslint-disable-next-line es/no-object-defineproperties -- safe
2654	var f$5 = descriptors && !v8PrototypeDefineBug ? Object.defineProperties : function defineProperties(O, Properties) {
2655	  anObject(O);
2656	  var props = toIndexedObject(Properties);
2657	  var keys = objectKeys(Properties);
2658	  var length = keys.length;
2659	  var index = 0;
2660	  var key;
2661	  while (length > index) objectDefineProperty.f(O, key = keys[index++], props[key]);
2662	  return O;
2663	};
2664
2665	var objectDefineProperties = {
2666		f: f$5
2667	};
2668
2669	var html = getBuiltIn('document', 'documentElement');
2670
2671	/* global ActiveXObject -- old IE, WSH */
2672
2673
2674
2675
2676
2677
2678
2679	var GT = '>';
2680	var LT = '<';
2681	var PROTOTYPE = 'prototype';
2682	var SCRIPT = 'script';
2683	var IE_PROTO$1 = sharedKey('IE_PROTO');
2684	var EmptyConstructor = function () {/* empty */};
2685	var scriptTag = function (content) {
2686	  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
2687	};
2688
2689	// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
2690	var NullProtoObjectViaActiveX = function (activeXDocument) {
2691	  activeXDocument.write(scriptTag(''));
2692	  activeXDocument.close();
2693	  var temp = activeXDocument.parentWindow.Object;
2694	  // eslint-disable-next-line no-useless-assignment -- avoid memory leak
2695	  activeXDocument = null;
2696	  return temp;
2697	};
2698
2699	// Create object with fake `null` prototype: use iframe Object with cleared prototype
2700	var NullProtoObjectViaIFrame = function () {
2701	  // Thrash, waste and sodomy: IE GC bug
2702	  var iframe = documentCreateElement('iframe');
2703	  var JS = 'java' + SCRIPT + ':';
2704	  var iframeDocument;
2705	  iframe.style.display = 'none';
2706	  html.appendChild(iframe);
2707	  // https://github.com/zloirock/core-js/issues/475
2708	  iframe.src = String(JS);
2709	  iframeDocument = iframe.contentWindow.document;
2710	  iframeDocument.open();
2711	  iframeDocument.write(scriptTag('document.F=Object'));
2712	  iframeDocument.close();
2713	  return iframeDocument.F;
2714	};
2715
2716	// Check for document.domain and active x support
2717	// No need to use active x approach when document.domain is not set
2718	// see https://github.com/es-shims/es5-shim/issues/150
2719	// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
2720	// avoid IE GC bug
2721	var activeXDocument;
2722	var NullProtoObject = function () {
2723	  try {
2724	    activeXDocument = new ActiveXObject('htmlfile');
2725	  } catch (error) {/* ignore */}
2726	  NullProtoObject = typeof document != 'undefined' ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) // old IE
2727	  : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument); // WSH
2728	  var length = enumBugKeys.length;
2729	  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
2730	  return NullProtoObject();
2731	};
2732	hiddenKeys[IE_PROTO$1] = true;
2733
2734	// `Object.create` method
2735	// https://tc39.es/ecma262/#sec-object.create
2736	// eslint-disable-next-line es/no-object-create -- safe
2737	var objectCreate = Object.create || function create(O, Properties) {
2738	  var result;
2739	  if (O !== null) {
2740	    EmptyConstructor[PROTOTYPE] = anObject(O);
2741	    result = new EmptyConstructor();
2742	    EmptyConstructor[PROTOTYPE] = null;
2743	    // add "__proto__" for Object.getPrototypeOf polyfill
2744	    result[IE_PROTO$1] = O;
2745	  } else result = NullProtoObject();
2746	  return Properties === undefined ? result : objectDefineProperties.f(result, Properties);
2747	};
2748
2749	// `InstallErrorCause` abstract operation
2750	// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause
2751	var installErrorCause = function (O, options) {
2752	  if (isObject(options) && 'cause' in options) {
2753	    createNonEnumerableProperty(O, 'cause', options.cause);
2754	  }
2755	};
2756
2757	var $Error = Error;
2758	var replace = functionUncurryThis(''.replace);
2759	var TEST = function (arg) {
2760	  return String(new $Error(arg).stack);
2761	}('zxcasd');
2762	// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe
2763	var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
2764	var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
2765	var errorStackClear = function (stack, dropEntries) {
2766	  if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
2767	    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
2768	  }
2769	  return stack;
2770	};
2771
2772	var errorStackInstallable = !fails(function () {
2773	  var error = new Error('a');
2774	  if (!('stack' in error)) return true;
2775	  // eslint-disable-next-line es/no-object-defineproperty -- safe
2776	  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
2777	  return error.stack !== 7;
2778	});
2779
2780	// non-standard V8
2781	var captureStackTrace = Error.captureStackTrace;
2782	var errorStackInstall = function (error, C, stack, dropEntries) {
2783	  if (errorStackInstallable) {
2784	    if (captureStackTrace) captureStackTrace(error, C);else createNonEnumerableProperty(error, 'stack', errorStackClear(stack, dropEntries));
2785	  }
2786	};
2787
2788	var functionUncurryThisClause = function (fn) {
2789	  // Nashorn bug:
2790	  //   https://github.com/zloirock/core-js/issues/1128
2791	  //   https://github.com/zloirock/core-js/issues/1130
2792	  if (classofRaw(fn) === 'Function') return functionUncurryThis(fn);
2793	};
2794
2795	var bind = functionUncurryThisClause(functionUncurryThisClause.bind);
2796
2797	// optional / simple context binding
2798	var functionBindContext = function (fn, that) {
2799	  aCallable(fn);
2800	  return that === undefined ? fn : functionBindNative ? bind(fn, that) : function /* ...args */
2801	  () {
2802	    return fn.apply(that, arguments);
2803	  };
2804	};
2805
2806	var iterators = {};
2807
2808	var ITERATOR = wellKnownSymbol('iterator');
2809	var ArrayPrototype = Array.prototype;
2810
2811	// check on default Array iterator
2812	var isArrayIteratorMethod = function (it) {
2813	  return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR] === it);
2814	};
2815
2816	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
2817	var test = {};
2818	test[TO_STRING_TAG] = 'z';
2819	var toStringTagSupport = String(test) === '[object z]';
2820
2821	var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag');
2822	var $Object$4 = Object;
2823
2824	// ES3 wrong here
2825	var CORRECT_ARGUMENTS = classofRaw(function () {
2826	  return arguments;
2827	}()) === 'Arguments';
2828
2829	// fallback for IE11 Script Access Denied error
2830	var tryGet = function (it, key) {
2831	  try {
2832	    return it[key];
2833	  } catch (error) {/* empty */}
2834	};
2835
2836	// getting tag from ES6+ `Object.prototype.toString`
2837	var classof = toStringTagSupport ? classofRaw : function (it) {
2838	  var O, tag, result;
2839	  return it === undefined ? 'Undefined' : it === null ? 'Null'
2840	  // @@toStringTag case
2841	  : typeof (tag = tryGet(O = $Object$4(it), TO_STRING_TAG$1)) == 'string' ? tag
2842	  // builtinTag case
2843	  : CORRECT_ARGUMENTS ? classofRaw(O)
2844	  // ES3 arguments fallback
2845	  : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
2846	};
2847
2848	var ITERATOR$1 = wellKnownSymbol('iterator');
2849	var getIteratorMethod = function (it) {
2850	  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR$1) || getMethod(it, '@@iterator') || iterators[classof(it)];
2851	};
2852
2853	var $TypeError$7 = TypeError;
2854	var getIterator = function (argument, usingIterator) {
2855	  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
2856	  if (aCallable(iteratorMethod)) return anObject(functionCall(iteratorMethod, argument));
2857	  throw new $TypeError$7(tryToString(argument) + ' is not iterable');
2858	};
2859
2860	var iteratorClose = function (iterator, kind, value) {
2861	  var innerResult, innerError;
2862	  anObject(iterator);
2863	  try {
2864	    innerResult = getMethod(iterator, 'return');
2865	    if (!innerResult) {
2866	      if (kind === 'throw') throw value;
2867	      return value;
2868	    }
2869	    innerResult = functionCall(innerResult, iterator);
2870	  } catch (error) {
2871	    innerError = true;
2872	    innerResult = error;
2873	  }
2874	  if (kind === 'throw') throw value;
2875	  if (innerError) throw innerResult;
2876	  anObject(innerResult);
2877	  return value;
2878	};
2879
2880	var $TypeError$8 = TypeError;
2881	var Result = function (stopped, result) {
2882	  this.stopped = stopped;
2883	  this.result = result;
2884	};
2885	var ResultPrototype = Result.prototype;
2886	var iterate = function (iterable, unboundFunction, options) {
2887	  var that = options && options.that;
2888	  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
2889	  var IS_RECORD = !!(options && options.IS_RECORD);
2890	  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
2891	  var INTERRUPTED = !!(options && options.INTERRUPTED);
2892	  var fn = functionBindContext(unboundFunction, that);
2893	  var iterator, iterFn, index, length, result, next, step;
2894	  var stop = function (condition) {
2895	    if (iterator) iteratorClose(iterator, 'normal', condition);
2896	    return new Result(true, condition);
2897	  };
2898	  var callFn = function (value) {
2899	    if (AS_ENTRIES) {
2900	      anObject(value);
2901	      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
2902	    }
2903	    return INTERRUPTED ? fn(value, stop) : fn(value);
2904	  };
2905	  if (IS_RECORD) {
2906	    iterator = iterable.iterator;
2907	  } else if (IS_ITERATOR) {
2908	    iterator = iterable;
2909	  } else {
2910	    iterFn = getIteratorMethod(iterable);
2911	    if (!iterFn) throw new $TypeError$8(tryToString(iterable) + ' is not iterable');
2912	    // optimisation for array iterators
2913	    if (isArrayIteratorMethod(iterFn)) {
2914	      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
2915	        result = callFn(iterable[index]);
2916	        if (result && objectIsPrototypeOf(ResultPrototype, result)) return result;
2917	      }
2918	      return new Result(false);
2919	    }
2920	    iterator = getIterator(iterable, iterFn);
2921	  }
2922	  next = IS_RECORD ? iterable.next : iterator.next;
2923	  while (!(step = functionCall(next, iterator)).done) {
2924	    try {
2925	      result = callFn(step.value);
2926	    } catch (error) {
2927	      iteratorClose(iterator, 'throw', error);
2928	    }
2929	    if (typeof result == 'object' && result && objectIsPrototypeOf(ResultPrototype, result)) return result;
2930	  }
2931	  return new Result(false);
2932	};
2933
2934	var $String$4 = String;
2935	var toString_1 = function (argument) {
2936	  if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
2937	  return $String$4(argument);
2938	};
2939
2940	var normalizeStringArgument = function (argument, $default) {
2941	  return argument === undefined ? arguments.length < 2 ? '' : $default : toString_1(argument);
2942	};
2943
2944	var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag');
2945	var $Error$1 = Error;
2946	var push$1 = [].push;
2947	var $AggregateError = function AggregateError(errors, message /* , options */) {
2948	  var isInstance = objectIsPrototypeOf(AggregateErrorPrototype, this);
2949	  var that;
2950	  if (objectSetPrototypeOf) {
2951	    that = objectSetPrototypeOf(new $Error$1(), isInstance ? objectGetPrototypeOf(this) : AggregateErrorPrototype);
2952	  } else {
2953	    that = isInstance ? this : objectCreate(AggregateErrorPrototype);
2954	    createNonEnumerableProperty(that, TO_STRING_TAG$2, 'Error');
2955	  }
2956	  if (message !== undefined) createNonEnumerableProperty(that, 'message', normalizeStringArgument(message));
2957	  errorStackInstall(that, $AggregateError, that.stack, 1);
2958	  if (arguments.length > 2) installErrorCause(that, arguments[2]);
2959	  var errorsArray = [];
2960	  iterate(errors, push$1, {
2961	    that: errorsArray
2962	  });
2963	  createNonEnumerableProperty(that, 'errors', errorsArray);
2964	  return that;
2965	};
2966	if (objectSetPrototypeOf) objectSetPrototypeOf($AggregateError, $Error$1);else copyConstructorProperties($AggregateError, $Error$1, {
2967	  name: true
2968	});
2969	var AggregateErrorPrototype = $AggregateError.prototype = objectCreate($Error$1.prototype, {
2970	  constructor: createPropertyDescriptor(1, $AggregateError),
2971	  message: createPropertyDescriptor(1, ''),
2972	  name: createPropertyDescriptor(1, 'AggregateError')
2973	});
2974
2975	// `AggregateError` constructor
2976	// https://tc39.es/ecma262/#sec-aggregate-error-constructor
2977	_export({
2978	  global: true,
2979	  constructor: true,
2980	  arity: 2
2981	}, {
2982	  AggregateError: $AggregateError
2983	});
2984
2985	var defineProperty$1 = objectDefineProperty.f;
2986	var UNSCOPABLES = wellKnownSymbol('unscopables');
2987	var ArrayPrototype$1 = Array.prototype;
2988
2989	// Array.prototype[@@unscopables]
2990	// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
2991	if (ArrayPrototype$1[UNSCOPABLES] === undefined) {
2992	  defineProperty$1(ArrayPrototype$1, UNSCOPABLES, {
2993	    configurable: true,
2994	    value: objectCreate(null)
2995	  });
2996	}
2997
2998	// add a key to Array.prototype[@@unscopables]
2999	var addToUnscopables = function (key) {
3000	  ArrayPrototype$1[UNSCOPABLES][key] = true;
3001	};
3002
3003	// `Array.prototype.at` method
3004	// https://tc39.es/ecma262/#sec-array.prototype.at
3005	_export({
3006	  target: 'Array',
3007	  proto: true
3008	}, {
3009	  at: function at(index) {
3010	    var O = toObject(this);
3011	    var len = lengthOfArrayLike(O);
3012	    var relativeIndex = toIntegerOrInfinity(index);
3013	    var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
3014	    return k < 0 || k >= len ? undefined : O[k];
3015	  }
3016	});
3017	addToUnscopables('at');
3018
3019	// eslint-disable-next-line es/no-typed-arrays -- safe
3020	var arrayBufferBasicDetection = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';
3021
3022	var defineBuiltInAccessor = function (target, name, descriptor) {
3023	  if (descriptor.get) makeBuiltIn_1(descriptor.get, name, {
3024	    getter: true
3025	  });
3026	  if (descriptor.set) makeBuiltIn_1(descriptor.set, name, {
3027	    setter: true
3028	  });
3029	  return objectDefineProperty.f(target, name, descriptor);
3030	};
3031
3032	var defineBuiltIns = function (target, src, options) {
3033	  for (var key in src) defineBuiltIn(target, key, src[key], options);
3034	  return target;
3035	};
3036
3037	var $TypeError$9 = TypeError;
3038	var anInstance = function (it, Prototype) {
3039	  if (objectIsPrototypeOf(Prototype, it)) return it;
3040	  throw new $TypeError$9('Incorrect invocation');
3041	};
3042
3043	var $RangeError = RangeError;
3044
3045	// `ToIndex` abstract operation
3046	// https://tc39.es/ecma262/#sec-toindex
3047	var toIndex = function (it) {
3048	  if (it === undefined) return 0;
3049	  var number = toIntegerOrInfinity(it);
3050	  var length = toLength(number);
3051	  if (number !== length) throw new $RangeError('Wrong length or index');
3052	  return length;
3053	};
3054
3055	// `Math.sign` method implementation
3056	// https://tc39.es/ecma262/#sec-math.sign
3057	// eslint-disable-next-line es/no-math-sign -- safe
3058	var mathSign = Math.sign || function sign(x) {
3059	  var n = +x;
3060	  // eslint-disable-next-line no-self-compare -- NaN check
3061	  return n === 0 || n !== n ? n : n < 0 ? -1 : 1;
3062	};
3063
3064	var EPSILON = 2.220446049250313e-16; // Number.EPSILON
3065	var INVERSE_EPSILON = 1 / EPSILON;
3066	var mathRoundTiesToEven = function (n) {
3067	  return n + INVERSE_EPSILON - INVERSE_EPSILON;
3068	};
3069
3070	var abs = Math.abs;
3071	var EPSILON$1 = 2.220446049250313e-16; // Number.EPSILON
3072
3073	var mathFloatRound = function (x, FLOAT_EPSILON, FLOAT_MAX_VALUE, FLOAT_MIN_VALUE) {
3074	  var n = +x;
3075	  var absolute = abs(n);
3076	  var s = mathSign(n);
3077	  if (absolute < FLOAT_MIN_VALUE) return s * mathRoundTiesToEven(absolute / FLOAT_MIN_VALUE / FLOAT_EPSILON) * FLOAT_MIN_VALUE * FLOAT_EPSILON;
3078	  var a = (1 + FLOAT_EPSILON / EPSILON$1) * absolute;
3079	  var result = a - (a - absolute);
3080	  // eslint-disable-next-line no-self-compare -- NaN check
3081	  if (result > FLOAT_MAX_VALUE || result !== result) return s * Infinity;
3082	  return s * result;
3083	};
3084
3085	var FLOAT32_EPSILON = 1.1920928955078125e-7; // 2 ** -23;
3086	var FLOAT32_MAX_VALUE = 3.4028234663852886e+38; // 2 ** 128 - 2 ** 104
3087	var FLOAT32_MIN_VALUE = 1.1754943508222875e-38; // 2 ** -126;
3088
3089	// `Math.fround` method implementation
3090	// https://tc39.es/ecma262/#sec-math.fround
3091	// eslint-disable-next-line es/no-math-fround -- safe
3092	var mathFround = Math.fround || function fround(x) {
3093	  return mathFloatRound(x, FLOAT32_EPSILON, FLOAT32_MAX_VALUE, FLOAT32_MIN_VALUE);
3094	};
3095
3096	// IEEE754 conversions based on https://github.com/feross/ieee754
3097	var $Array = Array;
3098	var abs$1 = Math.abs;
3099	var pow = Math.pow;
3100	var floor$1 = Math.floor;
3101	var log = Math.log;
3102	var LN2 = Math.LN2;
3103	var pack = function (number, mantissaLength, bytes) {
3104	  var buffer = $Array(bytes);
3105	  var exponentLength = bytes * 8 - mantissaLength - 1;
3106	  var eMax = (1 << exponentLength) - 1;
3107	  var eBias = eMax >> 1;
3108	  var rt = mantissaLength === 23 ? pow(2, -24) - pow(2, -77) : 0;
3109	  var sign = number < 0 || number === 0 && 1 / number < 0 ? 1 : 0;
3110	  var index = 0;
3111	  var exponent, mantissa, c;
3112	  number = abs$1(number);
3113	  // eslint-disable-next-line no-self-compare -- NaN check
3114	  if (number !== number || number === Infinity) {
3115	    // eslint-disable-next-line no-self-compare -- NaN check
3116	    mantissa = number !== number ? 1 : 0;
3117	    exponent = eMax;
3118	  } else {
3119	    exponent = floor$1(log(number) / LN2);
3120	    c = pow(2, -exponent);
3121	    if (number * c < 1) {
3122	      exponent--;
3123	      c *= 2;
3124	    }
3125	    if (exponent + eBias >= 1) {
3126	      number += rt / c;
3127	    } else {
3128	      number += rt * pow(2, 1 - eBias);
3129	    }
3130	    if (number * c >= 2) {
3131	      exponent++;
3132	      c /= 2;
3133	    }
3134	    if (exponent + eBias >= eMax) {
3135	      mantissa = 0;
3136	      exponent = eMax;
3137	    } else if (exponent + eBias >= 1) {
3138	      mantissa = (number * c - 1) * pow(2, mantissaLength);
3139	      exponent += eBias;
3140	    } else {
3141	      mantissa = number * pow(2, eBias - 1) * pow(2, mantissaLength);
3142	      exponent = 0;
3143	    }
3144	  }
3145	  while (mantissaLength >= 8) {
3146	    buffer[index++] = mantissa & 255;
3147	    mantissa /= 256;
3148	    mantissaLength -= 8;
3149	  }
3150	  exponent = exponent << mantissaLength | mantissa;
3151	  exponentLength += mantissaLength;
3152	  while (exponentLength > 0) {
3153	    buffer[index++] = exponent & 255;
3154	    exponent /= 256;
3155	    exponentLength -= 8;
3156	  }
3157	  buffer[index - 1] |= sign * 128;
3158	  return buffer;
3159	};
3160	var unpack = function (buffer, mantissaLength) {
3161	  var bytes = buffer.length;
3162	  var exponentLength = bytes * 8 - mantissaLength - 1;
3163	  var eMax = (1 << exponentLength) - 1;
3164	  var eBias = eMax >> 1;
3165	  var nBits = exponentLength - 7;
3166	  var index = bytes - 1;
3167	  var sign = buffer[index--];
3168	  var exponent = sign & 127;
3169	  var mantissa;
3170	  sign >>= 7;
3171	  while (nBits > 0) {
3172	    exponent = exponent * 256 + buffer[index--];
3173	    nBits -= 8;
3174	  }
3175	  mantissa = exponent & (1 << -nBits) - 1;
3176	  exponent >>= -nBits;
3177	  nBits += mantissaLength;
3178	  while (nBits > 0) {
3179	    mantissa = mantissa * 256 + buffer[index--];
3180	    nBits -= 8;
3181	  }
3182	  if (exponent === 0) {
3183	    exponent = 1 - eBias;
3184	  } else if (exponent === eMax) {
3185	    return mantissa ? NaN : sign ? -Infinity : Infinity;
3186	  } else {
3187	    mantissa += pow(2, mantissaLength);
3188	    exponent -= eBias;
3189	  }
3190	  return (sign ? -1 : 1) * mantissa * pow(2, exponent - mantissaLength);
3191	};
3192	var ieee754 = {
3193	  pack: pack,
3194	  unpack: unpack
3195	};
3196
3197	// `Array.prototype.fill` method implementation
3198	// https://tc39.es/ecma262/#sec-array.prototype.fill
3199	var arrayFill = function fill(value /* , start = 0, end = @length */) {
3200	  var O = toObject(this);
3201	  var length = lengthOfArrayLike(O);
3202	  var argumentsLength = arguments.length;
3203	  var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);
3204	  var end = argumentsLength > 2 ? arguments[2] : undefined;
3205	  var endPos = end === undefined ? length : toAbsoluteIndex(end, length);
3206	  while (endPos > index) O[index++] = value;
3207	  return O;
3208	};
3209
3210	var arraySlice = functionUncurryThis([].slice);
3211
3212	// makes subclassing work correct for wrapped built-ins
3213	var inheritIfRequired = function ($this, dummy, Wrapper) {
3214	  var NewTarget, NewTargetPrototype;
3215	  if (
3216	  // it can work only with native `setPrototypeOf`
3217	  objectSetPrototypeOf &&
3218	  // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
3219	  isCallable(NewTarget = dummy.constructor) && NewTarget !== Wrapper && isObject(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype) objectSetPrototypeOf($this, NewTargetPrototype);
3220	  return $this;
3221	};
3222
3223	var defineProperty$2 = objectDefineProperty.f;
3224
3225
3226	var TO_STRING_TAG$3 = wellKnownSymbol('toStringTag');
3227	var setToStringTag = function (target, TAG, STATIC) {
3228	  if (target && !STATIC) target = target.prototype;
3229	  if (target && !hasOwnProperty_1(target, TO_STRING_TAG$3)) {
3230	    defineProperty$2(target, TO_STRING_TAG$3, {
3231	      configurable: true,
3232	      value: TAG
3233	    });
3234	  }
3235	};
3236
3237	var PROPER_FUNCTION_NAME = functionName.PROPER;
3238	var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
3239	var ARRAY_BUFFER = 'ArrayBuffer';
3240	var DATA_VIEW = 'DataView';
3241	var PROTOTYPE$1 = 'prototype';
3242	var WRONG_LENGTH = 'Wrong length';
3243	var WRONG_INDEX = 'Wrong index';
3244	var getInternalArrayBufferState = internalState.getterFor(ARRAY_BUFFER);
3245	var getInternalDataViewState = internalState.getterFor(DATA_VIEW);
3246	var setInternalState = internalState.set;
3247	var NativeArrayBuffer = globalThis_1[ARRAY_BUFFER];
3248	var $ArrayBuffer = NativeArrayBuffer;
3249	var ArrayBufferPrototype = $ArrayBuffer && $ArrayBuffer[PROTOTYPE$1];
3250	var $DataView = globalThis_1[DATA_VIEW];
3251	var DataViewPrototype = $DataView && $DataView[PROTOTYPE$1];
3252	var ObjectPrototype$1 = Object.prototype;
3253	var Array$1 = globalThis_1.Array;
3254	var RangeError$1 = globalThis_1.RangeError;
3255	var fill = functionUncurryThis(arrayFill);
3256	var reverse = functionUncurryThis([].reverse);
3257	var packIEEE754 = ieee754.pack;
3258	var unpackIEEE754 = ieee754.unpack;
3259	var packInt8 = function (number) {
3260	  return [number & 0xFF];
3261	};
3262	var packInt16 = function (number) {
3263	  return [number & 0xFF, number >> 8 & 0xFF];
3264	};
3265	var packInt32 = function (number) {
3266	  return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF];
3267	};
3268	var unpackInt32 = function (buffer) {
3269	  return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0];
3270	};
3271	var packFloat32 = function (number) {
3272	  return packIEEE754(mathFround(number), 23, 4);
3273	};
3274	var packFloat64 = function (number) {
3275	  return packIEEE754(number, 52, 8);
3276	};
3277	var addGetter = function (Constructor, key, getInternalState) {
3278	  defineBuiltInAccessor(Constructor[PROTOTYPE$1], key, {
3279	    configurable: true,
3280	    get: function () {
3281	      return getInternalState(this)[key];
3282	    }
3283	  });
3284	};
3285	var get$1 = function (view, count, index, isLittleEndian) {
3286	  var store = getInternalDataViewState(view);
3287	  var intIndex = toIndex(index);
3288	  var boolIsLittleEndian = !!isLittleEndian;
3289	  if (intIndex + count > store.byteLength) throw new RangeError$1(WRONG_INDEX);
3290	  var bytes = store.bytes;
3291	  var start = intIndex + store.byteOffset;
3292	  var pack = arraySlice(bytes, start, start + count);
3293	  return boolIsLittleEndian ? pack : reverse(pack);
3294	};
3295	var set$1 = function (view, count, index, conversion, value, isLittleEndian) {
3296	  var store = getInternalDataViewState(view);
3297	  var intIndex = toIndex(index);
3298	  var pack = conversion(+value);
3299	  var boolIsLittleEndian = !!isLittleEndian;
3300	  if (intIndex + count > store.byteLength) throw new RangeError$1(WRONG_INDEX);
3301	  var bytes = store.bytes;
3302	  var start = intIndex + store.byteOffset;
3303	  for (var i = 0; i < count; i++) bytes[start + i] = pack[boolIsLittleEndian ? i : count - i - 1];
3304	};
3305	if (!arrayBufferBasicDetection) {
3306	  $ArrayBuffer = function ArrayBuffer(length) {
3307	    anInstance(this, ArrayBufferPrototype);
3308	    var byteLength = toIndex(length);
3309	    setInternalState(this, {
3310	      type: ARRAY_BUFFER,
3311	      bytes: fill(Array$1(byteLength), 0),
3312	      byteLength: byteLength
3313	    });
3314	    if (!descriptors) {
3315	      this.byteLength = byteLength;
3316	      this.detached = false;
3317	    }
3318	  };
3319	  ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE$1];
3320	  $DataView = function DataView(buffer, byteOffset, byteLength) {
3321	    anInstance(this, DataViewPrototype);
3322	    anInstance(buffer, ArrayBufferPrototype);
3323	    var bufferState = getInternalArrayBufferState(buffer);
3324	    var bufferLength = bufferState.byteLength;
3325	    var offset = toIntegerOrInfinity(byteOffset);
3326	    if (offset < 0 || offset > bufferLength) throw new RangeError$1('Wrong offset');
3327	    byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);
3328	    if (offset + byteLength > bufferLength) throw new RangeError$1(WRONG_LENGTH);
3329	    setInternalState(this, {
3330	      type: DATA_VIEW,
3331	      buffer: buffer,
3332	      byteLength: byteLength,
3333	      byteOffset: offset,
3334	      bytes: bufferState.bytes
3335	    });
3336	    if (!descriptors) {
3337	      this.buffer = buffer;
3338	      this.byteLength = byteLength;
3339	      this.byteOffset = offset;
3340	    }
3341	  };
3342	  DataViewPrototype = $DataView[PROTOTYPE$1];
3343	  if (descriptors) {
3344	    addGetter($ArrayBuffer, 'byteLength', getInternalArrayBufferState);
3345	    addGetter($DataView, 'buffer', getInternalDataViewState);
3346	    addGetter($DataView, 'byteLength', getInternalDataViewState);
3347	    addGetter($DataView, 'byteOffset', getInternalDataViewState);
3348	  }
3349	  defineBuiltIns(DataViewPrototype, {
3350	    getInt8: function getInt8(byteOffset) {
3351	      return get$1(this, 1, byteOffset)[0] << 24 >> 24;
3352	    },
3353	    getUint8: function getUint8(byteOffset) {
3354	      return get$1(this, 1, byteOffset)[0];
3355	    },
3356	    getInt16: function getInt16(byteOffset /* , littleEndian */) {
3357	      var bytes = get$1(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : false);
3358	      return (bytes[1] << 8 | bytes[0]) << 16 >> 16;
3359	    },
3360	    getUint16: function getUint16(byteOffset /* , littleEndian */) {
3361	      var bytes = get$1(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : false);
3362	      return bytes[1] << 8 | bytes[0];
3363	    },
3364	    getInt32: function getInt32(byteOffset /* , littleEndian */) {
3365	      return unpackInt32(get$1(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : false));
3366	    },
3367	    getUint32: function getUint32(byteOffset /* , littleEndian */) {
3368	      return unpackInt32(get$1(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : false)) >>> 0;
3369	    },
3370	    getFloat32: function getFloat32(byteOffset /* , littleEndian */) {
3371	      return unpackIEEE754(get$1(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : false), 23);
3372	    },
3373	    getFloat64: function getFloat64(byteOffset /* , littleEndian */) {
3374	      return unpackIEEE754(get$1(this, 8, byteOffset, arguments.length > 1 ? arguments[1] : false), 52);
3375	    },
3376	    setInt8: function setInt8(byteOffset, value) {
3377	      set$1(this, 1, byteOffset, packInt8, value);
3378	    },
3379	    setUint8: function setUint8(byteOffset, value) {
3380	      set$1(this, 1, byteOffset, packInt8, value);
3381	    },
3382	    setInt16: function setInt16(byteOffset, value /* , littleEndian */) {
3383	      set$1(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : false);
3384	    },
3385	    setUint16: function setUint16(byteOffset, value /* , littleEndian */) {
3386	      set$1(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : false);
3387	    },
3388	    setInt32: function setInt32(byteOffset, value /* , littleEndian */) {
3389	      set$1(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : false);
3390	    },
3391	    setUint32: function setUint32(byteOffset, value /* , littleEndian */) {
3392	      set$1(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : false);
3393	    },
3394	    setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) {
3395	      set$1(this, 4, byteOffset, packFloat32, value, arguments.length > 2 ? arguments[2] : false);
3396	    },
3397	    setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) {
3398	      set$1(this, 8, byteOffset, packFloat64, value, arguments.length > 2 ? arguments[2] : false);
3399	    }
3400	  });
3401	} else {
3402	  var INCORRECT_ARRAY_BUFFER_NAME = PROPER_FUNCTION_NAME && NativeArrayBuffer.name !== ARRAY_BUFFER;
3403	  /* eslint-disable no-new, sonarjs/inconsistent-function-call -- required for testing */
3404	  if (!fails(function () {
3405	    NativeArrayBuffer(1);
3406	  }) || !fails(function () {
3407	    new NativeArrayBuffer(-1);
3408	  }) || fails(function () {
3409	    new NativeArrayBuffer();
3410	    new NativeArrayBuffer(1.5);
3411	    new NativeArrayBuffer(NaN);
3412	    return NativeArrayBuffer.length !== 1 || INCORRECT_ARRAY_BUFFER_NAME && !CONFIGURABLE_FUNCTION_NAME;
3413	  })) {
3414	    /* eslint-enable no-new, sonarjs/inconsistent-function-call -- required for testing */
3415	    $ArrayBuffer = function ArrayBuffer(length) {
3416	      anInstance(this, ArrayBufferPrototype);
3417	      return inheritIfRequired(new NativeArrayBuffer(toIndex(length)), this, $ArrayBuffer);
3418	    };
3419	    $ArrayBuffer[PROTOTYPE$1] = ArrayBufferPrototype;
3420	    ArrayBufferPrototype.constructor = $ArrayBuffer;
3421	    copyConstructorProperties($ArrayBuffer, NativeArrayBuffer);
3422	  } else if (INCORRECT_ARRAY_BUFFER_NAME && CONFIGURABLE_FUNCTION_NAME) {
3423	    createNonEnumerableProperty(NativeArrayBuffer, 'name', ARRAY_BUFFER);
3424	  }
3425
3426	  // WebKit bug - the same parent prototype for typed arrays and data view
3427	  if (objectSetPrototypeOf && objectGetPrototypeOf(DataViewPrototype) !== ObjectPrototype$1) {
3428	    objectSetPrototypeOf(DataViewPrototype, ObjectPrototype$1);
3429	  }
3430
3431	  // iOS Safari 7.x bug
3432	  var testView = new $DataView(new $ArrayBuffer(2));
3433	  var $setInt8 = functionUncurryThis(DataViewPrototype.setInt8);
3434	  testView.setInt8(0, 2147483648);
3435	  testView.setInt8(1, 2147483649);
3436	  if (testView.getInt8(0) || !testView.getInt8(1)) defineBuiltIns(DataViewPrototype, {
3437	    setInt8: function setInt8(byteOffset, value) {
3438	      $setInt8(this, byteOffset, value << 24 >> 24);
3439	    },
3440	    setUint8: function setUint8(byteOffset, value) {
3441	      $setInt8(this, byteOffset, value << 24 >> 24);
3442	    }
3443	  }, {
3444	    unsafe: true
3445	  });
3446	}
3447	setToStringTag($ArrayBuffer, ARRAY_BUFFER);
3448	setToStringTag($DataView, DATA_VIEW);
3449	var arrayBuffer = {
3450	  ArrayBuffer: $ArrayBuffer,
3451	  DataView: $DataView
3452	};
3453
3454	var ArrayBuffer$1 = arrayBuffer.ArrayBuffer;
3455	var DataView$1 = arrayBuffer.DataView;
3456	var DataViewPrototype$1 = DataView$1.prototype;
3457	var nativeArrayBufferSlice = functionUncurryThisClause(ArrayBuffer$1.prototype.slice);
3458	var getUint8 = functionUncurryThisClause(DataViewPrototype$1.getUint8);
3459	var setUint8 = functionUncurryThisClause(DataViewPrototype$1.setUint8);
3460	var INCORRECT_SLICE = fails(function () {