vis-util 6.0.0 → 6.0.1

package/peer/umd/vis-util.js

@@ -4,8 +4,8 @@
  *
  * utilitie collection for visjs
  *
- * @version 6.0.0
- * @date    2025-07-12T18:02:43.836Z
+ * @version 6.0.1
+ * @date    2026-08-03T17:52:53.613Z
  *
  * @copyright (c) 2011-2017 Almende B.V, http://almende.com
  * @copyright (c) 2017-2019 visjs contributors, https://github.com/visjs
@@ -87,7 +87,7 @@
 
 		functionBindNative = !fails(function () {
 		  // eslint-disable-next-line es/no-function-prototype-bind -- safe
-		  var test = (function () { /* empty */ }).bind();
+		  var test = function () { /* empty */ }.bind();
 		  // eslint-disable-next-line no-prototype-builtins -- safe
 		  return typeof test != 'function' || test.hasOwnProperty('prototype');
 		});
@@ -633,10 +633,10 @@
 		var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
 
 		(store.versions || (store.versions = [])).push({
-		  version: '3.44.0',
+		  version: '3.49.0',
 		  mode: IS_PURE ? 'pure' : 'global',
-		  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
-		  license: 'https://github.com/zloirock/core-js/blob/v3.44.0/LICENSE',
+		  copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.',
+		  license: 'https://github.com/zloirock/core-js/blob/v3.49.0/LICENSE',
 		  source: 'https://github.com/zloirock/core-js'
 		});
 		return sharedStore.exports;
@@ -1135,21 +1135,21 @@
 		return _export;
 	}
 
-	var isArray$3;
-	var hasRequiredIsArray$3;
+	var isArray$6;
+	var hasRequiredIsArray$6;
 
-	function requireIsArray$3 () {
-		if (hasRequiredIsArray$3) return isArray$3;
-		hasRequiredIsArray$3 = 1;
+	function requireIsArray$6 () {
+		if (hasRequiredIsArray$6) return isArray$6;
+		hasRequiredIsArray$6 = 1;
 		var classof = /*@__PURE__*/ requireClassofRaw();
 
 		// `IsArray` abstract operation
 		// https://tc39.es/ecma262/#sec-isarray
 		// eslint-disable-next-line es/no-array-isarray -- safe
-		isArray$3 = Array.isArray || function isArray(argument) {
+		isArray$6 = Array.isArray || function isArray(argument) {
 		  return classof(argument) === 'Array';
 		};
-		return isArray$3;
+		return isArray$6;
 	}
 
 	var mathTrunc;
@@ -1234,7 +1234,7 @@
 		var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
 
 		doesNotExceedSafeInteger = function (it) {
-		  if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
+		  if (it > MAX_SAFE_INTEGER) throw new $TypeError('Maximum allowed index exceeded');
 		  return it;
 		};
 		return doesNotExceedSafeInteger;
@@ -1257,6 +1257,41 @@
 		return createProperty;
 	}
 
+	var arraySetLength;
+	var hasRequiredArraySetLength;
+
+	function requireArraySetLength () {
+		if (hasRequiredArraySetLength) return arraySetLength;
+		hasRequiredArraySetLength = 1;
+		var DESCRIPTORS = /*@__PURE__*/ requireDescriptors();
+		var isArray = /*@__PURE__*/ requireIsArray$6();
+
+		var $TypeError = TypeError;
+		// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+		var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+		// Safari < 13 does not throw an error in this case
+		var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
+		  // makes no sense without proper strict mode support
+		  if (this !== undefined) return true;
+		  try {
+		    // eslint-disable-next-line es/no-object-defineproperty -- safe
+		    Object.defineProperty([], 'length', { writable: false }).length = 1;
+		  } catch (error) {
+		    return error instanceof TypeError;
+		  }
+		}();
+
+		arraySetLength = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
+		  if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
+		    throw new $TypeError('Cannot set read only .length');
+		  } return O.length = length;
+		} : function (O, length) {
+		  return O.length = length;
+		};
+		return arraySetLength;
+	}
+
 	var toStringTagSupport;
 	var hasRequiredToStringTagSupport;
 
@@ -1267,7 +1302,7 @@
 
 		var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 		var test = {};
-
+		// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
 		test[TO_STRING_TAG] = 'z';
 
 		toStringTagSupport = String(test) === '[object z]';
@@ -1401,7 +1436,7 @@
 	function requireArraySpeciesConstructor () {
 		if (hasRequiredArraySpeciesConstructor) return arraySpeciesConstructor;
 		hasRequiredArraySpeciesConstructor = 1;
-		var isArray = /*@__PURE__*/ requireIsArray$3();
+		var isArray = /*@__PURE__*/ requireIsArray$6();
 		var isConstructor = /*@__PURE__*/ requireIsConstructor();
 		var isObject = /*@__PURE__*/ requireIsObject();
 		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
@@ -1477,12 +1512,13 @@
 		hasRequiredEs_array_concat = 1;
 		var $ = /*@__PURE__*/ require_export();
 		var fails = /*@__PURE__*/ requireFails();
-		var isArray = /*@__PURE__*/ requireIsArray$3();
+		var isArray = /*@__PURE__*/ requireIsArray$6();
 		var isObject = /*@__PURE__*/ requireIsObject();
 		var toObject = /*@__PURE__*/ requireToObject();
 		var lengthOfArrayLike = /*@__PURE__*/ requireLengthOfArrayLike();
 		var doesNotExceedSafeInteger = /*@__PURE__*/ requireDoesNotExceedSafeInteger();
 		var createProperty = /*@__PURE__*/ requireCreateProperty();
+		var setArrayLength = /*@__PURE__*/ requireArraySetLength();
 		var arraySpeciesCreate = /*@__PURE__*/ requireArraySpeciesCreate();
 		var arrayMethodHasSpeciesSupport = /*@__PURE__*/ requireArrayMethodHasSpeciesSupport();
 		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
@@ -1528,7 +1564,7 @@
 		        createProperty(A, n++, E);
 		      }
 		    }
-		    A.length = n;
+		    setArrayLength(A, n);
 		    return A;
 		  }
 		});
@@ -2164,13 +2200,11 @@
 		if (hasRequiredArrayIteration) return arrayIteration;
 		hasRequiredArrayIteration = 1;
 		var bind = /*@__PURE__*/ requireFunctionBindContext();
-		var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
 		var IndexedObject = /*@__PURE__*/ requireIndexedObject();
 		var toObject = /*@__PURE__*/ requireToObject();
 		var lengthOfArrayLike = /*@__PURE__*/ requireLengthOfArrayLike();
 		var arraySpeciesCreate = /*@__PURE__*/ requireArraySpeciesCreate();
-
-		var push = uncurryThis([].push);
+		var createProperty = /*@__PURE__*/ requireCreateProperty();
 
 		// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
 		var createMethod = function (TYPE) {
@@ -2181,28 +2215,28 @@
 		  var IS_FIND_INDEX = TYPE === 6;
 		  var IS_FILTER_REJECT = TYPE === 7;
 		  var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;
-		  return function ($this, callbackfn, that, specificCreate) {
+		  return function ($this, callbackfn, that) {
 		    var O = toObject($this);
 		    var self = IndexedObject(O);
 		    var length = lengthOfArrayLike(self);
 		    var boundFunction = bind(callbackfn, that);
 		    var index = 0;
-		    var create = specificCreate || arraySpeciesCreate;
-		    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
+		    var resIndex = 0;
+		    var target = IS_MAP ? arraySpeciesCreate($this, length) : IS_FILTER || IS_FILTER_REJECT ? arraySpeciesCreate($this, 0) : undefined;
 		    var value, result;
 		    for (;length > index; index++) if (NO_HOLES || index in self) {
 		      value = self[index];
 		      result = boundFunction(value, index, O);
 		      if (TYPE) {
-		        if (IS_MAP) target[index] = result; // map
+		        if (IS_MAP) createProperty(target, index, result);    // map
 		        else if (result) switch (TYPE) {
-		          case 3: return true;              // some
-		          case 5: return value;             // find
-		          case 6: return index;             // findIndex
-		          case 2: push(target, value);      // filter
+		          case 3: return true;                                // some
+		          case 5: return value;                               // find
+		          case 6: return index;                               // findIndex
+		          case 2: createProperty(target, resIndex++, value);  // filter
 		        } else switch (TYPE) {
-		          case 4: return false;             // every
-		          case 7: push(target, value);      // filterReject
+		          case 4: return false;                               // every
+		          case 7: createProperty(target, resIndex++, value);  // filterReject
 		        }
 		      }
 		    }
@@ -2315,7 +2349,7 @@
 		  nativeDefineProperty(O, P, Attributes);
 		  if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
 		    nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
-		  }
+		  } return O;
 		};
 
 		var setSymbolDescriptor = DESCRIPTORS && fails(function () {
@@ -2341,7 +2375,8 @@
 		  var key = toPropertyKey(P);
 		  anObject(Attributes);
 		  if (hasOwn(AllSymbols, key)) {
-		    if (!Attributes.enumerable) {
+		    // first definition - default non-enumerable; redefinition - preserve existing state
+		    if (!('enumerable' in Attributes) ? !hasOwn(O, key) || (hasOwn(O, HIDDEN) && O[HIDDEN][key]) : !Attributes.enumerable) {
 		      if (!hasOwn(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, nativeObjectCreate(null)));
 		      O[HIDDEN][key] = true;
 		    } else {
@@ -2583,42 +2618,104 @@
 
 	var es_json_stringify = {};
 
-	var getJsonReplacerFunction;
-	var hasRequiredGetJsonReplacerFunction;
+	var isRawJson;
+	var hasRequiredIsRawJson;
+
+	function requireIsRawJson () {
+		if (hasRequiredIsRawJson) return isRawJson;
+		hasRequiredIsRawJson = 1;
+		var isObject = /*@__PURE__*/ requireIsObject();
+		var getInternalState = /*@__PURE__*/ requireInternalState().get;
+
+		isRawJson = function isRawJSON(O) {
+		  if (!isObject(O)) return false;
+		  var state = getInternalState(O);
+		  return !!state && state.type === 'RawJSON';
+		};
+		return isRawJson;
+	}
+
+	var parseJsonString;
+	var hasRequiredParseJsonString;
 
-	function requireGetJsonReplacerFunction () {
-		if (hasRequiredGetJsonReplacerFunction) return getJsonReplacerFunction;
-		hasRequiredGetJsonReplacerFunction = 1;
+	function requireParseJsonString () {
+		if (hasRequiredParseJsonString) return parseJsonString;
+		hasRequiredParseJsonString = 1;
 		var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
-		var isArray = /*@__PURE__*/ requireIsArray$3();
-		var isCallable = /*@__PURE__*/ requireIsCallable();
-		var classof = /*@__PURE__*/ requireClassofRaw();
-		var toString = /*@__PURE__*/ requireToString();
+		var hasOwn = /*@__PURE__*/ requireHasOwnProperty();
 
-		var push = uncurryThis([].push);
+		var $SyntaxError = SyntaxError;
+		var $parseInt = parseInt;
+		var fromCharCode = String.fromCharCode;
+		var at = uncurryThis(''.charAt);
+		var slice = uncurryThis(''.slice);
+		var exec = uncurryThis(/./.exec);
 
-		getJsonReplacerFunction = function (replacer) {
-		  if (isCallable(replacer)) return replacer;
-		  if (!isArray(replacer)) return;
-		  var rawLength = replacer.length;
-		  var keys = [];
-		  for (var i = 0; i < rawLength; i++) {
-		    var element = replacer[i];
-		    if (typeof element == 'string') push(keys, element);
-		    else if (typeof element == 'number' || classof(element) === 'Number' || classof(element) === 'String') push(keys, toString(element));
-		  }
-		  var keysLength = keys.length;
-		  var root = true;
-		  return function (key, value) {
-		    if (root) {
-		      root = false;
-		      return value;
+		var codePoints = {
+		  '\\"': '"',
+		  '\\\\': '\\',
+		  '\\/': '/',
+		  '\\b': '\b',
+		  '\\f': '\f',
+		  '\\n': '\n',
+		  '\\r': '\r',
+		  '\\t': '\t'
+		};
+
+		var IS_4_HEX_DIGITS = /^[\da-f]{4}$/i;
+		// eslint-disable-next-line regexp/no-control-character -- safe
+		var IS_C0_CONTROL_CODE = /^[\u0000-\u001F]$/;
+
+		parseJsonString = function (source, i) {
+		  var unterminated = true;
+		  var value = '';
+		  while (i < source.length) {
+		    var chr = at(source, i);
+		    if (chr === '\\') {
+		      var twoChars = slice(source, i, i + 2);
+		      if (hasOwn(codePoints, twoChars)) {
+		        value += codePoints[twoChars];
+		        i += 2;
+		      } else if (twoChars === '\\u') {
+		        i += 2;
+		        var fourHexDigits = slice(source, i, i + 4);
+		        if (!exec(IS_4_HEX_DIGITS, fourHexDigits)) throw new $SyntaxError('Bad Unicode escape at: ' + i);
+		        value += fromCharCode($parseInt(fourHexDigits, 16));
+		        i += 4;
+		      } else throw new $SyntaxError('Unknown escape sequence: "' + twoChars + '"');
+		    } else if (chr === '"') {
+		      unterminated = false;
+		      i++;
+		      break;
+		    } else {
+		      if (exec(IS_C0_CONTROL_CODE, chr)) throw new $SyntaxError('Bad control character in string literal at: ' + i);
+		      value += chr;
+		      i++;
 		    }
-		    if (isArray(this)) return value;
-		    for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value;
-		  };
+		  }
+		  if (unterminated) throw new $SyntaxError('Unterminated string at: ' + i);
+		  return { value: value, end: i };
 		};
-		return getJsonReplacerFunction;
+		return parseJsonString;
+	}
+
+	var nativeRawJson;
+	var hasRequiredNativeRawJson;
+
+	function requireNativeRawJson () {
+		if (hasRequiredNativeRawJson) return nativeRawJson;
+		hasRequiredNativeRawJson = 1;
+		/* eslint-disable es/no-json -- safe */
+		var fails = /*@__PURE__*/ requireFails();
+
+		nativeRawJson = !fails(function () {
+		  var unsafeInt = '9007199254740993';
+		  // eslint-disable-next-line es/no-json-rawjson -- feature detection
+		  var raw = JSON.rawJSON(unsafeInt);
+		  // eslint-disable-next-line es/no-json-israwjson -- feature detection
+		  return !JSON.isRawJSON(raw) || JSON.stringify(raw) !== unsafeInt;
+		});
+		return nativeRawJson;
 	}
 
 	var hasRequiredEs_json_stringify;
@@ -2632,11 +2729,17 @@
 		var call = /*@__PURE__*/ requireFunctionCall();
 		var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
 		var fails = /*@__PURE__*/ requireFails();
+		var isArray = /*@__PURE__*/ requireIsArray$6();
 		var isCallable = /*@__PURE__*/ requireIsCallable();
+		var isRawJSON = /*@__PURE__*/ requireIsRawJson();
 		var isSymbol = /*@__PURE__*/ requireIsSymbol();
+		var classof = /*@__PURE__*/ requireClassofRaw();
+		var toString = /*@__PURE__*/ requireToString();
 		var arraySlice = /*@__PURE__*/ requireArraySlice();
-		var getReplacerFunction = /*@__PURE__*/ requireGetJsonReplacerFunction();
+		var parseJSONString = /*@__PURE__*/ requireParseJsonString();
+		var uid = /*@__PURE__*/ requireUid();
 		var NATIVE_SYMBOL = /*@__PURE__*/ requireSymbolConstructorDetection();
+		var NATIVE_RAW_JSON = /*@__PURE__*/ requireNativeRawJson();
 
 		var $String = String;
 		var $stringify = getBuiltIn('JSON', 'stringify');
@@ -2644,11 +2747,16 @@
 		var charAt = uncurryThis(''.charAt);
 		var charCodeAt = uncurryThis(''.charCodeAt);
 		var replace = uncurryThis(''.replace);
+		var slice = uncurryThis(''.slice);
+		var push = uncurryThis([].push);
 		var numberToString = uncurryThis(1.1.toString);
 
-		var tester = /[\uD800-\uDFFF]/g;
-		var low = /^[\uD800-\uDBFF]$/;
-		var hi = /^[\uDC00-\uDFFF]$/;
+		var surrogates = /[\uD800-\uDFFF]/g;
+		var leadingSurrogates = /^[\uD800-\uDBFF]$/;
+		var trailingSurrogates = /^[\uDC00-\uDFFF]$/;
+
+		var MARK = uid();
+		var MARK_LENGTH = MARK.length;
 
 		var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails(function () {
 		  var symbol = getBuiltIn('Symbol')('stringify detection');
@@ -2666,7 +2774,7 @@
 		    || $stringify('\uDEAD') !== '"\\udead"';
 		});
 
-		var stringifyWithSymbolsFix = function (it, replacer) {
+		var stringifyWithProperSymbolsConversion = WRONG_SYMBOLS_CONVERSION ? function (it, replacer) {
 		  var args = arraySlice(arguments);
 		  var $replacer = getReplacerFunction(replacer);
 		  if (!isCallable($replacer) && (it === undefined || isSymbol(it))) return; // IE8 returns string on undefined
@@ -2676,28 +2784,79 @@
 		    if (!isSymbol(value)) return value;
 		  };
 		  return apply($stringify, null, args);
-		};
+		} : $stringify;
 
-		var fixIllFormed = function (match, offset, string) {
+		var fixIllFormedJSON = function (match, offset, string) {
 		  var prev = charAt(string, offset - 1);
 		  var next = charAt(string, offset + 1);
-		  if ((exec(low, match) && !exec(hi, next)) || (exec(hi, match) && !exec(low, prev))) {
+		  if (
+		    (exec(leadingSurrogates, match) && !exec(trailingSurrogates, next)) ||
+		    (exec(trailingSurrogates, match) && !exec(leadingSurrogates, prev))
+		  ) {
 		    return '\\u' + numberToString(charCodeAt(match, 0), 16);
 		  } return match;
 		};
 
-		if ($stringify) {
-		  // `JSON.stringify` method
-		  // https://tc39.es/ecma262/#sec-json.stringify
-		  $({ target: 'JSON', stat: true, arity: 3, forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE }, {
-		    // eslint-disable-next-line no-unused-vars -- required for `.length`
-		    stringify: function stringify(it, replacer, space) {
-		      var args = arraySlice(arguments);
-		      var result = apply(WRONG_SYMBOLS_CONVERSION ? stringifyWithSymbolsFix : $stringify, null, args);
-		      return ILL_FORMED_UNICODE && typeof result == 'string' ? replace(result, tester, fixIllFormed) : result;
+		var getReplacerFunction = function (replacer) {
+		  if (isCallable(replacer)) return replacer;
+		  if (!isArray(replacer)) return;
+		  var rawLength = replacer.length;
+		  var keys = [];
+		  for (var i = 0; i < rawLength; i++) {
+		    var element = replacer[i];
+		    if (typeof element == 'string') push(keys, element);
+		    else if (typeof element == 'number' || classof(element) === 'Number' || classof(element) === 'String') push(keys, toString(element));
+		  }
+		  var keysLength = keys.length;
+		  var root = true;
+		  return function (key, value) {
+		    if (root) {
+		      root = false;
+		      return value;
+		    }
+		    if (isArray(this)) return value;
+		    for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value;
+		  };
+		};
+
+		// `JSON.stringify` method
+		// https://tc39.es/ecma262/#sec-json.stringify
+		// https://github.com/tc39/proposal-json-parse-with-source
+		if ($stringify) $({ target: 'JSON', stat: true, arity: 3, forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE || !NATIVE_RAW_JSON }, {
+		  stringify: function stringify(text, replacer, space) {
+		    var replacerFunction = getReplacerFunction(replacer);
+		    var rawStrings = [];
+
+		    var json = stringifyWithProperSymbolsConversion(text, function (key, value) {
+		      // some old implementations (like WebKit) could pass numbers as keys
+		      var v = isCallable(replacerFunction) ? call(replacerFunction, this, $String(key), value) : value;
+		      return !NATIVE_RAW_JSON && isRawJSON(v) ? MARK + (push(rawStrings, v.rawJSON) - 1) : v;
+		    }, space);
+
+		    if (typeof json != 'string') return json;
+
+		    if (ILL_FORMED_UNICODE) json = replace(json, surrogates, fixIllFormedJSON);
+
+		    if (NATIVE_RAW_JSON) return json;
+
+		    var result = '';
+		    var length = json.length;
+
+		    for (var i = 0; i < length; i++) {
+		      var chr = charAt(json, i);
+		      if (chr === '"') {
+		        var end = parseJSONString(json, ++i).end - 1;
+		        var string = slice(json, i, end);
+		        result += slice(string, 0, MARK_LENGTH) === MARK
+		          ? rawStrings[slice(string, MARK_LENGTH)]
+		          : '"' + string + '"';
+		        i = end;
+		      } else result += chr;
 		    }
-		  });
-		}
+
+		    return result;
+		  }
+		});
 		return es_json_stringify;
 	}
 
@@ -2995,12 +3154,12 @@
 		return es_json_toStringTag;
 	}
 
-	var symbol$2;
-	var hasRequiredSymbol$2;
+	var symbol$5;
+	var hasRequiredSymbol$5;
 
-	function requireSymbol$2 () {
-		if (hasRequiredSymbol$2) return symbol$2;
-		hasRequiredSymbol$2 = 1;
+	function requireSymbol$5 () {
+		if (hasRequiredSymbol$5) return symbol$5;
+		hasRequiredSymbol$5 = 1;
 		requireEs_array_concat();
 		requireEs_symbol();
 		requireEs_symbol_asyncDispose();
@@ -3021,8 +3180,8 @@
 		requireEs_json_toStringTag();
 		var path = /*@__PURE__*/ requirePath();
 
-		symbol$2 = path.Symbol;
-		return symbol$2;
+		symbol$5 = path.Symbol;
+		return symbol$5;
 	}
 
 	var web_domCollections_iterator = {};
@@ -3062,7 +3221,7 @@
 
 		var EXISTS = hasOwn(FunctionPrototype, 'name');
 		// additional protection from minified / mangled / dropped function names
-		var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+		var PROPER = EXISTS && function something() { /* empty */ }.name === 'something';
 		var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
 
 		functionName = {
@@ -3544,31 +3703,31 @@
 		return web_domCollections_iterator;
 	}
 
-	var symbol$1;
-	var hasRequiredSymbol$1;
+	var symbol$4;
+	var hasRequiredSymbol$4;
 
-	function requireSymbol$1 () {
-		if (hasRequiredSymbol$1) return symbol$1;
-		hasRequiredSymbol$1 = 1;
-		var parent = /*@__PURE__*/ requireSymbol$2();
+	function requireSymbol$4 () {
+		if (hasRequiredSymbol$4) return symbol$4;
+		hasRequiredSymbol$4 = 1;
+		var parent = /*@__PURE__*/ requireSymbol$5();
 		requireWeb_domCollections_iterator();
 
-		symbol$1 = parent;
-		return symbol$1;
+		symbol$4 = parent;
+		return symbol$4;
 	}
 
-	var symbol;
-	var hasRequiredSymbol;
+	var symbol$3;
+	var hasRequiredSymbol$3;
 
-	function requireSymbol () {
-		if (hasRequiredSymbol) return symbol;
-		hasRequiredSymbol = 1;
-		symbol = /*@__PURE__*/ requireSymbol$1();
-		return symbol;
+	function requireSymbol$3 () {
+		if (hasRequiredSymbol$3) return symbol$3;
+		hasRequiredSymbol$3 = 1;
+		symbol$3 = /*@__PURE__*/ requireSymbol$4();
+		return symbol$3;
 	}
 
-	var symbolExports = requireSymbol();
-	var _Symbol = /*@__PURE__*/getDefaultExportFromCjs(symbolExports);
+	var symbolExports$1 = requireSymbol$3();
+	var _Symbol$1 = /*@__PURE__*/getDefaultExportFromCjs(symbolExports$1);
 
 	var es_array_slice = {};
 
@@ -3578,13 +3737,14 @@
 		if (hasRequiredEs_array_slice) return es_array_slice;
 		hasRequiredEs_array_slice = 1;
 		var $ = /*@__PURE__*/ require_export();
-		var isArray = /*@__PURE__*/ requireIsArray$3();
+		var isArray = /*@__PURE__*/ requireIsArray$6();
 		var isConstructor = /*@__PURE__*/ requireIsConstructor();
 		var isObject = /*@__PURE__*/ requireIsObject();
 		var toAbsoluteIndex = /*@__PURE__*/ requireToAbsoluteIndex();
 		var lengthOfArrayLike = /*@__PURE__*/ requireLengthOfArrayLike();
 		var toIndexedObject = /*@__PURE__*/ requireToIndexedObject();
 		var createProperty = /*@__PURE__*/ requireCreateProperty();
+		var setArrayLength = /*@__PURE__*/ requireArraySetLength();
 		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
 		var arrayMethodHasSpeciesSupport = /*@__PURE__*/ requireArrayMethodHasSpeciesSupport();
 		var nativeSlice = /*@__PURE__*/ requireArraySlice();
@@ -3621,7 +3781,7 @@
 		    }
 		    result = new (Constructor === undefined ? $Array : Constructor)(max(fin - k, 0));
 		    for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
-		    result.length = n;
+		    setArrayLength(result, n);
 		    return result;
 		  }
 		});
@@ -3648,61 +3808,61 @@
 		return getBuiltInPrototypeMethod;
 	}
 
-	var slice$3;
-	var hasRequiredSlice$3;
+	var slice$6;
+	var hasRequiredSlice$6;
 
-	function requireSlice$3 () {
-		if (hasRequiredSlice$3) return slice$3;
-		hasRequiredSlice$3 = 1;
+	function requireSlice$6 () {
+		if (hasRequiredSlice$6) return slice$6;
+		hasRequiredSlice$6 = 1;
 		requireEs_array_slice();
 		var getBuiltInPrototypeMethod = /*@__PURE__*/ requireGetBuiltInPrototypeMethod();
 
-		slice$3 = getBuiltInPrototypeMethod('Array', 'slice');
-		return slice$3;
+		slice$6 = getBuiltInPrototypeMethod('Array', 'slice');
+		return slice$6;
 	}
 
-	var slice$2;
-	var hasRequiredSlice$2;
+	var slice$5;
+	var hasRequiredSlice$5;
 
-	function requireSlice$2 () {
-		if (hasRequiredSlice$2) return slice$2;
-		hasRequiredSlice$2 = 1;
+	function requireSlice$5 () {
+		if (hasRequiredSlice$5) return slice$5;
+		hasRequiredSlice$5 = 1;
 		var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
-		var method = /*@__PURE__*/ requireSlice$3();
+		var method = /*@__PURE__*/ requireSlice$6();
 
 		var ArrayPrototype = Array.prototype;
 
-		slice$2 = function (it) {
+		slice$5 = function (it) {
 		  var own = it.slice;
 		  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.slice) ? method : own;
 		};
-		return slice$2;
+		return slice$5;
 	}
 
-	var slice$1;
-	var hasRequiredSlice$1;
+	var slice$4;
+	var hasRequiredSlice$4;
 
-	function requireSlice$1 () {
-		if (hasRequiredSlice$1) return slice$1;
-		hasRequiredSlice$1 = 1;
-		var parent = /*@__PURE__*/ requireSlice$2();
+	function requireSlice$4 () {
+		if (hasRequiredSlice$4) return slice$4;
+		hasRequiredSlice$4 = 1;
+		var parent = /*@__PURE__*/ requireSlice$5();
 
-		slice$1 = parent;
-		return slice$1;
+		slice$4 = parent;
+		return slice$4;
 	}
 
-	var slice;
-	var hasRequiredSlice;
+	var slice$3;
+	var hasRequiredSlice$3;
 
-	function requireSlice () {
-		if (hasRequiredSlice) return slice;
-		hasRequiredSlice = 1;
-		slice = /*@__PURE__*/ requireSlice$1();
-		return slice;
+	function requireSlice$3 () {
+		if (hasRequiredSlice$3) return slice$3;
+		hasRequiredSlice$3 = 1;
+		slice$3 = /*@__PURE__*/ requireSlice$4();
+		return slice$3;
 	}
 
-	var sliceExports = requireSlice();
-	var _sliceInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(sliceExports);
+	var sliceExports$1 = requireSlice$3();
+	var _sliceInstanceProperty$1 = /*@__PURE__*/getDefaultExportFromCjs(sliceExports$1);
 
 	var es_reflect_ownKeys = {};
 
@@ -3791,7 +3951,7 @@
 		if (hasRequiredEs_array_isArray) return es_array_isArray;
 		hasRequiredEs_array_isArray = 1;
 		var $ = /*@__PURE__*/ require_export();
-		var isArray = /*@__PURE__*/ requireIsArray$3();
+		var isArray = /*@__PURE__*/ requireIsArray$6();
 
 		// `Array.isArray` method
 		// https://tc39.es/ecma262/#sec-array.isarray
@@ -3801,43 +3961,43 @@
 		return es_array_isArray;
 	}
 
-	var isArray$2;
-	var hasRequiredIsArray$2;
+	var isArray$5;
+	var hasRequiredIsArray$5;
 
-	function requireIsArray$2 () {
-		if (hasRequiredIsArray$2) return isArray$2;
-		hasRequiredIsArray$2 = 1;
+	function requireIsArray$5 () {
+		if (hasRequiredIsArray$5) return isArray$5;
+		hasRequiredIsArray$5 = 1;
 		requireEs_array_isArray();
 		var path = /*@__PURE__*/ requirePath();
 
-		isArray$2 = path.Array.isArray;
-		return isArray$2;
+		isArray$5 = path.Array.isArray;
+		return isArray$5;
 	}
 
-	var isArray$1;
-	var hasRequiredIsArray$1;
+	var isArray$4;
+	var hasRequiredIsArray$4;
 
-	function requireIsArray$1 () {
-		if (hasRequiredIsArray$1) return isArray$1;
-		hasRequiredIsArray$1 = 1;
-		var parent = /*@__PURE__*/ requireIsArray$2();
+	function requireIsArray$4 () {
+		if (hasRequiredIsArray$4) return isArray$4;
+		hasRequiredIsArray$4 = 1;
+		var parent = /*@__PURE__*/ requireIsArray$5();
 
-		isArray$1 = parent;
-		return isArray$1;
+		isArray$4 = parent;
+		return isArray$4;
 	}
 
-	var isArray;
-	var hasRequiredIsArray;
+	var isArray$3;
+	var hasRequiredIsArray$3;
 
-	function requireIsArray () {
-		if (hasRequiredIsArray) return isArray;
-		hasRequiredIsArray = 1;
-		isArray = /*@__PURE__*/ requireIsArray$1();
-		return isArray;
+	function requireIsArray$3 () {
+		if (hasRequiredIsArray$3) return isArray$3;
+		hasRequiredIsArray$3 = 1;
+		isArray$3 = /*@__PURE__*/ requireIsArray$4();
+		return isArray$3;
 	}
 
-	var isArrayExports = requireIsArray();
-	var _Array$isArray = /*@__PURE__*/getDefaultExportFromCjs(isArrayExports);
+	var isArrayExports$1 = requireIsArray$3();
+	var _Array$isArray$1 = /*@__PURE__*/getDefaultExportFromCjs(isArrayExports$1);
 
 	var es_array_map = {};
 
@@ -3885,190 +4045,1260 @@
 		var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
 		var method = /*@__PURE__*/ requireMap$3();
 
-		var ArrayPrototype = Array.prototype;
+		var ArrayPrototype = Array.prototype;
+
+		map$2 = function (it) {
+		  var own = it.map;
+		  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.map) ? method : own;
+		};
+		return map$2;
+	}
+
+	var map$1;
+	var hasRequiredMap$1;
+
+	function requireMap$1 () {
+		if (hasRequiredMap$1) return map$1;
+		hasRequiredMap$1 = 1;
+		var parent = /*@__PURE__*/ requireMap$2();
+
+		map$1 = parent;
+		return map$1;
+	}
+
+	var map;
+	var hasRequiredMap;
+
+	function requireMap () {
+		if (hasRequiredMap) return map;
+		hasRequiredMap = 1;
+		map = /*@__PURE__*/ requireMap$1();
+		return map;
+	}
+
+	var mapExports = requireMap();
+	var _mapInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(mapExports);
+
+	var es_object_keys = {};
+
+	var hasRequiredEs_object_keys;
+
+	function requireEs_object_keys () {
+		if (hasRequiredEs_object_keys) return es_object_keys;
+		hasRequiredEs_object_keys = 1;
+		var $ = /*@__PURE__*/ require_export();
+		var toObject = /*@__PURE__*/ requireToObject();
+		var nativeKeys = /*@__PURE__*/ requireObjectKeys();
+		var fails = /*@__PURE__*/ requireFails();
+
+		var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });
+
+		// `Object.keys` method
+		// https://tc39.es/ecma262/#sec-object.keys
+		$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
+		  keys: function keys(it) {
+		    return nativeKeys(toObject(it));
+		  }
+		});
+		return es_object_keys;
+	}
+
+	var keys$2;
+	var hasRequiredKeys$2;
+
+	function requireKeys$2 () {
+		if (hasRequiredKeys$2) return keys$2;
+		hasRequiredKeys$2 = 1;
+		requireEs_object_keys();
+		var path = /*@__PURE__*/ requirePath();
+
+		keys$2 = path.Object.keys;
+		return keys$2;
+	}
+
+	var keys$1;
+	var hasRequiredKeys$1;
+
+	function requireKeys$1 () {
+		if (hasRequiredKeys$1) return keys$1;
+		hasRequiredKeys$1 = 1;
+		var parent = /*@__PURE__*/ requireKeys$2();
+
+		keys$1 = parent;
+		return keys$1;
+	}
+
+	var keys;
+	var hasRequiredKeys;
+
+	function requireKeys () {
+		if (hasRequiredKeys) return keys;
+		hasRequiredKeys = 1;
+		keys = /*@__PURE__*/ requireKeys$1();
+		return keys;
+	}
+
+	var keysExports = requireKeys();
+	var _Object$keys = /*@__PURE__*/getDefaultExportFromCjs(keysExports);
+
+	/**
+	 * Use this symbol to delete properies in deepObjectAssign.
+	 */
+	const DELETE = _Symbol$1("DELETE");
+	/**
+	 * Pure version of deepObjectAssign, it doesn't modify any of it's arguments.
+	 * @param base - The base object that fullfils the whole interface T.
+	 * @param updates - Updates that may change or delete props.
+	 * @returns A brand new instance with all the supplied objects deeply merged.
+	 */
+	function pureDeepObjectAssign(base) {
+	  for (var _len = arguments.length, updates = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+	    updates[_key - 1] = arguments[_key];
+	  }
+	  return deepObjectAssign({}, base, ...updates);
+	}
+	/**
+	 * Deep version of object assign with additional deleting by the DELETE symbol.
+	 * @param values - Objects to be deeply merged.
+	 * @returns The first object from values.
+	 */
+	function deepObjectAssign() {
+	  const merged = deepObjectAssignNonentry(...arguments);
+	  stripDelete(merged);
+	  return merged;
+	}
+	/**
+	 * Deep version of object assign with additional deleting by the DELETE symbol.
+	 * @remarks
+	 * This doesn't strip the DELETE symbols so they may end up in the final object.
+	 * @param values - Objects to be deeply merged.
+	 * @returns The first object from values.
+	 */
+	function deepObjectAssignNonentry() {
+	  for (var _len2 = arguments.length, values = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+	    values[_key2] = arguments[_key2];
+	  }
+	  if (values.length < 2) {
+	    return values[0];
+	  } else if (values.length > 2) {
+	    return deepObjectAssignNonentry(deepObjectAssign(values[0], values[1]), ..._sliceInstanceProperty$1(values).call(values, 2));
+	  }
+	  const a = values[0];
+	  const b = values[1];
+	  if (a instanceof Date && b instanceof Date) {
+	    a.setTime(b.getTime());
+	    return a;
+	  }
+	  for (const prop of _Reflect$ownKeys(b)) {
+	    if (!Object.prototype.propertyIsEnumerable.call(b, prop)) ; else if (b[prop] === DELETE) {
+	      delete a[prop];
+	    } else if (a[prop] !== null && b[prop] !== null && typeof a[prop] === "object" && typeof b[prop] === "object" && !_Array$isArray$1(a[prop]) && !_Array$isArray$1(b[prop])) {
+	      a[prop] = deepObjectAssignNonentry(a[prop], b[prop]);
+	    } else {
+	      a[prop] = clone(b[prop]);
+	    }
+	  }
+	  return a;
+	}
+	/**
+	 * Deep clone given object or array. In case of primitive simply return.
+	 * @param a - Anything.
+	 * @returns Deep cloned object/array or unchanged a.
+	 */
+	function clone(a) {
+	  if (_Array$isArray$1(a)) {
+	    return _mapInstanceProperty(a).call(a, value => clone(value));
+	  } else if (typeof a === "object" && a !== null) {
+	    if (a instanceof Date) {
+	      return new Date(a.getTime());
+	    }
+	    return deepObjectAssignNonentry({}, a);
+	  } else {
+	    return a;
+	  }
+	}
+	/**
+	 * Strip DELETE from given object.
+	 * @param a - Object which may contain DELETE but won't after this is executed.
+	 */
+	function stripDelete(a) {
+	  for (const prop of _Object$keys(a)) {
+	    if (a[prop] === DELETE) {
+	      delete a[prop];
+	    } else if (typeof a[prop] === "object" && a[prop] !== null) {
+	      stripDelete(a[prop]);
+	    }
+	  }
+	}
+
+	var isArray$2;
+	var hasRequiredIsArray$2;
+
+	function requireIsArray$2 () {
+		if (hasRequiredIsArray$2) return isArray$2;
+		hasRequiredIsArray$2 = 1;
+		var parent = /*@__PURE__*/ requireIsArray$4();
+
+		isArray$2 = parent;
+		return isArray$2;
+	}
+
+	var isArray$1;
+	var hasRequiredIsArray$1;
+
+	function requireIsArray$1 () {
+		if (hasRequiredIsArray$1) return isArray$1;
+		hasRequiredIsArray$1 = 1;
+		var parent = /*@__PURE__*/ requireIsArray$2();
+
+		isArray$1 = parent;
+		return isArray$1;
+	}
+
+	var isArray;
+	var hasRequiredIsArray;
+
+	function requireIsArray () {
+		if (hasRequiredIsArray) return isArray;
+		hasRequiredIsArray = 1;
+		isArray = /*@__PURE__*/ requireIsArray$1();
+		return isArray;
+	}
+
+	var isArrayExports = /*@__PURE__*/ requireIsArray();
+	var _Array$isArray = /*@__PURE__*/getDefaultExportFromCjs(isArrayExports);
+
+	function _arrayWithHoles(r) {
+	  if (_Array$isArray(r)) return r;
+	}
+
+	var esnext_function_metadata = {};
+
+	var hasRequiredEsnext_function_metadata;
+
+	function requireEsnext_function_metadata () {
+		if (hasRequiredEsnext_function_metadata) return esnext_function_metadata;
+		hasRequiredEsnext_function_metadata = 1;
+		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
+		var defineProperty = /*@__PURE__*/ requireObjectDefineProperty().f;
+
+		var METADATA = wellKnownSymbol('metadata');
+		var FunctionPrototype = Function.prototype;
+
+		// Function.prototype[@@metadata]
+		// https://github.com/tc39/proposal-decorator-metadata
+		if (FunctionPrototype[METADATA] === undefined) {
+		  defineProperty(FunctionPrototype, METADATA, {
+		    value: null
+		  });
+		}
+		return esnext_function_metadata;
+	}
+
+	var esnext_symbol_asyncDispose = {};
+
+	var hasRequiredEsnext_symbol_asyncDispose;
+
+	function requireEsnext_symbol_asyncDispose () {
+		if (hasRequiredEsnext_symbol_asyncDispose) return esnext_symbol_asyncDispose;
+		hasRequiredEsnext_symbol_asyncDispose = 1;
+		// TODO: Remove from `core-js@4`
+		requireEs_symbol_asyncDispose();
+		return esnext_symbol_asyncDispose;
+	}
+
+	var esnext_symbol_dispose = {};
+
+	var hasRequiredEsnext_symbol_dispose;
+
+	function requireEsnext_symbol_dispose () {
+		if (hasRequiredEsnext_symbol_dispose) return esnext_symbol_dispose;
+		hasRequiredEsnext_symbol_dispose = 1;
+		// TODO: Remove from `core-js@4`
+		requireEs_symbol_dispose();
+		return esnext_symbol_dispose;
+	}
+
+	var esnext_symbol_metadata = {};
+
+	var hasRequiredEsnext_symbol_metadata;
+
+	function requireEsnext_symbol_metadata () {
+		if (hasRequiredEsnext_symbol_metadata) return esnext_symbol_metadata;
+		hasRequiredEsnext_symbol_metadata = 1;
+		var defineWellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbolDefine();
+
+		// `Symbol.metadata` well-known symbol
+		// https://github.com/tc39/proposal-decorators
+		defineWellKnownSymbol('metadata');
+		return esnext_symbol_metadata;
+	}
+
+	var symbol$2;
+	var hasRequiredSymbol$2;
+
+	function requireSymbol$2 () {
+		if (hasRequiredSymbol$2) return symbol$2;
+		hasRequiredSymbol$2 = 1;
+		var parent = /*@__PURE__*/ requireSymbol$4();
+
+		requireEsnext_function_metadata();
+		requireEsnext_symbol_asyncDispose();
+		requireEsnext_symbol_dispose();
+		requireEsnext_symbol_metadata();
+
+		symbol$2 = parent;
+		return symbol$2;
+	}
+
+	var esnext_symbol_isRegisteredSymbol = {};
+
+	var symbolIsRegistered;
+	var hasRequiredSymbolIsRegistered;
+
+	function requireSymbolIsRegistered () {
+		if (hasRequiredSymbolIsRegistered) return symbolIsRegistered;
+		hasRequiredSymbolIsRegistered = 1;
+		var getBuiltIn = /*@__PURE__*/ requireGetBuiltIn();
+		var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
+
+		var Symbol = getBuiltIn('Symbol');
+		var keyFor = Symbol.keyFor;
+		var thisSymbolValue = uncurryThis(Symbol.prototype.valueOf);
+
+		// `Symbol.isRegisteredSymbol` method
+		// https://tc39.es/proposal-symbol-predicates/#sec-symbol-isregisteredsymbol
+		symbolIsRegistered = Symbol.isRegisteredSymbol || function isRegisteredSymbol(value) {
+		  try {
+		    return keyFor(thisSymbolValue(value)) !== undefined;
+		  } catch (error) {
+		    return false;
+		  }
+		};
+		return symbolIsRegistered;
+	}
+
+	var hasRequiredEsnext_symbol_isRegisteredSymbol;
+
+	function requireEsnext_symbol_isRegisteredSymbol () {
+		if (hasRequiredEsnext_symbol_isRegisteredSymbol) return esnext_symbol_isRegisteredSymbol;
+		hasRequiredEsnext_symbol_isRegisteredSymbol = 1;
+		var $ = /*@__PURE__*/ require_export();
+		var isRegisteredSymbol = /*@__PURE__*/ requireSymbolIsRegistered();
+
+		// `Symbol.isRegisteredSymbol` method
+		// https://tc39.es/proposal-symbol-predicates/#sec-symbol-isregisteredsymbol
+		$({ target: 'Symbol', stat: true }, {
+		  isRegisteredSymbol: isRegisteredSymbol
+		});
+		return esnext_symbol_isRegisteredSymbol;
+	}
+
+	var esnext_symbol_isWellKnownSymbol = {};
+
+	var symbolIsWellKnown;
+	var hasRequiredSymbolIsWellKnown;
+
+	function requireSymbolIsWellKnown () {
+		if (hasRequiredSymbolIsWellKnown) return symbolIsWellKnown;
+		hasRequiredSymbolIsWellKnown = 1;
+		var shared = /*@__PURE__*/ requireShared();
+		var getBuiltIn = /*@__PURE__*/ requireGetBuiltIn();
+		var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
+		var isSymbol = /*@__PURE__*/ requireIsSymbol();
+		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
+
+		var Symbol = getBuiltIn('Symbol');
+		var $isWellKnownSymbol = Symbol.isWellKnownSymbol;
+		var getOwnPropertyNames = getBuiltIn('Object', 'getOwnPropertyNames');
+		var thisSymbolValue = uncurryThis(Symbol.prototype.valueOf);
+		var WellKnownSymbolsStore = shared('wks');
+
+		for (var i = 0, symbolKeys = getOwnPropertyNames(Symbol), symbolKeysLength = symbolKeys.length; i < symbolKeysLength; i++) {
+		  // some old engines throws on access to some keys like `arguments` or `caller`
+		  try {
+		    var symbolKey = symbolKeys[i];
+		    if (isSymbol(Symbol[symbolKey])) wellKnownSymbol(symbolKey);
+		  } catch (error) { /* empty */ }
+		}
+
+		// `Symbol.isWellKnownSymbol` method
+		// https://tc39.es/proposal-symbol-predicates/#sec-symbol-iswellknownsymbol
+		// We should patch it for newly added well-known symbols. If it's not required, this module just will not be injected
+		symbolIsWellKnown = function isWellKnownSymbol(value) {
+		  if ($isWellKnownSymbol && $isWellKnownSymbol(value)) return true;
+		  try {
+		    var symbol = thisSymbolValue(value);
+		    for (var j = 0, keys = getOwnPropertyNames(WellKnownSymbolsStore), keysLength = keys.length; j < keysLength; j++) {
+		      // eslint-disable-next-line eqeqeq -- polyfilled symbols case
+		      if (WellKnownSymbolsStore[keys[j]] == symbol) return true;
+		    }
+		  } catch (error) { /* empty */ }
+		  return false;
+		};
+		return symbolIsWellKnown;
+	}
+
+	var hasRequiredEsnext_symbol_isWellKnownSymbol;
+
+	function requireEsnext_symbol_isWellKnownSymbol () {
+		if (hasRequiredEsnext_symbol_isWellKnownSymbol) return esnext_symbol_isWellKnownSymbol;
+		hasRequiredEsnext_symbol_isWellKnownSymbol = 1;
+		var $ = /*@__PURE__*/ require_export();
+		var isWellKnownSymbol = /*@__PURE__*/ requireSymbolIsWellKnown();
+
+		// `Symbol.isWellKnownSymbol` method
+		// https://tc39.es/proposal-symbol-predicates/#sec-symbol-iswellknownsymbol
+		// We should patch it for newly added well-known symbols. If it's not required, this module just will not be injected
+		$({ target: 'Symbol', stat: true, forced: true }, {
+		  isWellKnownSymbol: isWellKnownSymbol
+		});
+		return esnext_symbol_isWellKnownSymbol;
+	}
+
+	var esnext_symbol_customMatcher = {};
+
+	var hasRequiredEsnext_symbol_customMatcher;
+
+	function requireEsnext_symbol_customMatcher () {
+		if (hasRequiredEsnext_symbol_customMatcher) return esnext_symbol_customMatcher;
+		hasRequiredEsnext_symbol_customMatcher = 1;
+		var defineWellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbolDefine();
+
+		// `Symbol.customMatcher` well-known symbol
+		// https://github.com/tc39/proposal-pattern-matching
+		defineWellKnownSymbol('customMatcher');
+		return esnext_symbol_customMatcher;
+	}
+
+	var esnext_symbol_observable = {};
+
+	var hasRequiredEsnext_symbol_observable;
+
+	function requireEsnext_symbol_observable () {
+		if (hasRequiredEsnext_symbol_observable) return esnext_symbol_observable;
+		hasRequiredEsnext_symbol_observable = 1;
+		var defineWellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbolDefine();
+
+		// `Symbol.observable` well-known symbol
+		// https://github.com/tc39/proposal-observable
+		defineWellKnownSymbol('observable');
+		return esnext_symbol_observable;
+	}
+
+	var esnext_symbol_isRegistered = {};
+
+	var hasRequiredEsnext_symbol_isRegistered;
+
+	function requireEsnext_symbol_isRegistered () {
+		if (hasRequiredEsnext_symbol_isRegistered) return esnext_symbol_isRegistered;
+		hasRequiredEsnext_symbol_isRegistered = 1;
+		var $ = /*@__PURE__*/ require_export();
+		var isRegisteredSymbol = /*@__PURE__*/ requireSymbolIsRegistered();
+
+		// `Symbol.isRegistered` method
+		// obsolete version of https://tc39.es/proposal-symbol-predicates/#sec-symbol-isregisteredsymbol
+		$({ target: 'Symbol', stat: true, name: 'isRegisteredSymbol' }, {
+		  isRegistered: isRegisteredSymbol
+		});
+		return esnext_symbol_isRegistered;
+	}
+
+	var esnext_symbol_isWellKnown = {};
+
+	var hasRequiredEsnext_symbol_isWellKnown;
+
+	function requireEsnext_symbol_isWellKnown () {
+		if (hasRequiredEsnext_symbol_isWellKnown) return esnext_symbol_isWellKnown;
+		hasRequiredEsnext_symbol_isWellKnown = 1;
+		var $ = /*@__PURE__*/ require_export();
+		var isWellKnownSymbol = /*@__PURE__*/ requireSymbolIsWellKnown();
+
+		// `Symbol.isWellKnown` method
+		// obsolete version of https://tc39.es/proposal-symbol-predicates/#sec-symbol-iswellknownsymbol
+		// We should patch it for newly added well-known symbols. If it's not required, this module just will not be injected
+		$({ target: 'Symbol', stat: true, name: 'isWellKnownSymbol', forced: true }, {
+		  isWellKnown: isWellKnownSymbol
+		});
+		return esnext_symbol_isWellKnown;
+	}
+
+	var esnext_symbol_matcher = {};
+
+	var hasRequiredEsnext_symbol_matcher;
+
+	function requireEsnext_symbol_matcher () {
+		if (hasRequiredEsnext_symbol_matcher) return esnext_symbol_matcher;
+		hasRequiredEsnext_symbol_matcher = 1;
+		var defineWellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbolDefine();
+
+		// `Symbol.matcher` well-known symbol
+		// https://github.com/tc39/proposal-pattern-matching
+		defineWellKnownSymbol('matcher');
+		return esnext_symbol_matcher;
+	}
+
+	var esnext_symbol_metadataKey = {};
+
+	var hasRequiredEsnext_symbol_metadataKey;
+
+	function requireEsnext_symbol_metadataKey () {
+		if (hasRequiredEsnext_symbol_metadataKey) return esnext_symbol_metadataKey;
+		hasRequiredEsnext_symbol_metadataKey = 1;
+		// TODO: Remove from `core-js@4`
+		var defineWellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbolDefine();
+
+		// `Symbol.metadataKey` well-known symbol
+		// https://github.com/tc39/proposal-decorator-metadata
+		defineWellKnownSymbol('metadataKey');
+		return esnext_symbol_metadataKey;
+	}
+
+	var esnext_symbol_patternMatch = {};
+
+	var hasRequiredEsnext_symbol_patternMatch;
+
+	function requireEsnext_symbol_patternMatch () {
+		if (hasRequiredEsnext_symbol_patternMatch) return esnext_symbol_patternMatch;
+		hasRequiredEsnext_symbol_patternMatch = 1;
+		// TODO: remove from `core-js@4`
+		var defineWellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbolDefine();
+
+		// `Symbol.patternMatch` well-known symbol
+		// https://github.com/tc39/proposal-pattern-matching
+		defineWellKnownSymbol('patternMatch');
+		return esnext_symbol_patternMatch;
+	}
+
+	var esnext_symbol_replaceAll = {};
+
+	var hasRequiredEsnext_symbol_replaceAll;
+
+	function requireEsnext_symbol_replaceAll () {
+		if (hasRequiredEsnext_symbol_replaceAll) return esnext_symbol_replaceAll;
+		hasRequiredEsnext_symbol_replaceAll = 1;
+		// TODO: remove from `core-js@4`
+		var defineWellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbolDefine();
+
+		defineWellKnownSymbol('replaceAll');
+		return esnext_symbol_replaceAll;
+	}
+
+	var symbol$1;
+	var hasRequiredSymbol$1;
+
+	function requireSymbol$1 () {
+		if (hasRequiredSymbol$1) return symbol$1;
+		hasRequiredSymbol$1 = 1;
+		var parent = /*@__PURE__*/ requireSymbol$2();
+		requireEsnext_symbol_isRegisteredSymbol();
+		requireEsnext_symbol_isWellKnownSymbol();
+		requireEsnext_symbol_customMatcher();
+		requireEsnext_symbol_observable();
+		// TODO: Remove from `core-js@4`
+		requireEsnext_symbol_isRegistered();
+		requireEsnext_symbol_isWellKnown();
+		requireEsnext_symbol_matcher();
+		requireEsnext_symbol_metadataKey();
+		requireEsnext_symbol_patternMatch();
+		requireEsnext_symbol_replaceAll();
+
+		symbol$1 = parent;
+		return symbol$1;
+	}
+
+	var symbol;
+	var hasRequiredSymbol;
+
+	function requireSymbol () {
+		if (hasRequiredSymbol) return symbol;
+		hasRequiredSymbol = 1;
+		symbol = /*@__PURE__*/ requireSymbol$1();
+		return symbol;
+	}
+
+	var symbolExports = /*@__PURE__*/ requireSymbol();
+	var _Symbol = /*@__PURE__*/getDefaultExportFromCjs(symbolExports);
+
+	var es_string_iterator = {};
+
+	var stringMultibyte;
+	var hasRequiredStringMultibyte;
+
+	function requireStringMultibyte () {
+		if (hasRequiredStringMultibyte) return stringMultibyte;
+		hasRequiredStringMultibyte = 1;
+		var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
+		var toIntegerOrInfinity = /*@__PURE__*/ requireToIntegerOrInfinity();
+		var toString = /*@__PURE__*/ requireToString();
+		var requireObjectCoercible = /*@__PURE__*/ requireRequireObjectCoercible();
+
+		var charAt = uncurryThis(''.charAt);
+		var charCodeAt = uncurryThis(''.charCodeAt);
+		var stringSlice = uncurryThis(''.slice);
+
+		var createMethod = function (CONVERT_TO_STRING) {
+		  return function ($this, pos) {
+		    var S = toString(requireObjectCoercible($this));
+		    var position = toIntegerOrInfinity(pos);
+		    var size = S.length;
+		    var first, second;
+		    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
+		    first = charCodeAt(S, position);
+		    return first < 0xD800 || first > 0xDBFF || position + 1 === size
+		      || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
+		        ? CONVERT_TO_STRING
+		          ? charAt(S, position)
+		          : first
+		        : CONVERT_TO_STRING
+		          ? stringSlice(S, position, position + 2)
+		          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
+		  };
+		};
+
+		stringMultibyte = {
+		  // `String.prototype.codePointAt` method
+		  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
+		  codeAt: createMethod(false),
+		  // `String.prototype.at` method
+		  // https://github.com/mathiasbynens/String.prototype.at
+		  charAt: createMethod(true)
+		};
+		return stringMultibyte;
+	}
+
+	var hasRequiredEs_string_iterator;
+
+	function requireEs_string_iterator () {
+		if (hasRequiredEs_string_iterator) return es_string_iterator;
+		hasRequiredEs_string_iterator = 1;
+		var charAt = /*@__PURE__*/ requireStringMultibyte().charAt;
+		var toString = /*@__PURE__*/ requireToString();
+		var InternalStateModule = /*@__PURE__*/ requireInternalState();
+		var defineIterator = /*@__PURE__*/ requireIteratorDefine();
+		var createIterResultObject = /*@__PURE__*/ requireCreateIterResultObject();
+
+		var STRING_ITERATOR = 'String Iterator';
+		var setInternalState = InternalStateModule.set;
+		var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
+
+		// `String.prototype[@@iterator]` method
+		// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
+		defineIterator(String, 'String', function (iterated) {
+		  setInternalState(this, {
+		    type: STRING_ITERATOR,
+		    string: toString(iterated),
+		    index: 0
+		  });
+		// `%StringIteratorPrototype%.next` method
+		// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next
+		}, function next() {
+		  var state = getInternalState(this);
+		  var string = state.string;
+		  var index = state.index;
+		  var point;
+		  if (index >= string.length) return createIterResultObject(undefined, true);
+		  point = charAt(string, index);
+		  state.index += point.length;
+		  return createIterResultObject(point, false);
+		});
+		return es_string_iterator;
+	}
+
+	var getIteratorMethod$4;
+	var hasRequiredGetIteratorMethod$5;
+
+	function requireGetIteratorMethod$5 () {
+		if (hasRequiredGetIteratorMethod$5) return getIteratorMethod$4;
+		hasRequiredGetIteratorMethod$5 = 1;
+		var classof = /*@__PURE__*/ requireClassof();
+		var getMethod = /*@__PURE__*/ requireGetMethod();
+		var isNullOrUndefined = /*@__PURE__*/ requireIsNullOrUndefined();
+		var Iterators = /*@__PURE__*/ requireIterators();
+		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
+
+		var ITERATOR = wellKnownSymbol('iterator');
+
+		getIteratorMethod$4 = function (it) {
+		  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
+		    || getMethod(it, '@@iterator')
+		    || Iterators[classof(it)];
+		};
+		return getIteratorMethod$4;
+	}
+
+	var getIteratorMethod_1;
+	var hasRequiredGetIteratorMethod$4;
+
+	function requireGetIteratorMethod$4 () {
+		if (hasRequiredGetIteratorMethod$4) return getIteratorMethod_1;
+		hasRequiredGetIteratorMethod$4 = 1;
+		requireEs_array_iterator();
+		requireEs_string_iterator();
+		var getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod$5();
+
+		getIteratorMethod_1 = getIteratorMethod;
+		return getIteratorMethod_1;
+	}
+
+	var getIteratorMethod$3;
+	var hasRequiredGetIteratorMethod$3;
+
+	function requireGetIteratorMethod$3 () {
+		if (hasRequiredGetIteratorMethod$3) return getIteratorMethod$3;
+		hasRequiredGetIteratorMethod$3 = 1;
+		var parent = /*@__PURE__*/ requireGetIteratorMethod$4();
+		requireWeb_domCollections_iterator();
+
+		getIteratorMethod$3 = parent;
+		return getIteratorMethod$3;
+	}
+
+	var getIteratorMethod$2;
+	var hasRequiredGetIteratorMethod$2;
+
+	function requireGetIteratorMethod$2 () {
+		if (hasRequiredGetIteratorMethod$2) return getIteratorMethod$2;
+		hasRequiredGetIteratorMethod$2 = 1;
+		var parent = /*@__PURE__*/ requireGetIteratorMethod$3();
+
+		getIteratorMethod$2 = parent;
+		return getIteratorMethod$2;
+	}
+
+	var getIteratorMethod$1;
+	var hasRequiredGetIteratorMethod$1;
+
+	function requireGetIteratorMethod$1 () {
+		if (hasRequiredGetIteratorMethod$1) return getIteratorMethod$1;
+		hasRequiredGetIteratorMethod$1 = 1;
+		var parent = /*@__PURE__*/ requireGetIteratorMethod$2();
+
+		getIteratorMethod$1 = parent;
+		return getIteratorMethod$1;
+	}
+
+	var getIteratorMethod;
+	var hasRequiredGetIteratorMethod;
+
+	function requireGetIteratorMethod () {
+		if (hasRequiredGetIteratorMethod) return getIteratorMethod;
+		hasRequiredGetIteratorMethod = 1;
+		getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod$1();
+		return getIteratorMethod;
+	}
+
+	var getIteratorMethodExports = /*@__PURE__*/ requireGetIteratorMethod();
+	var _getIteratorMethod = /*@__PURE__*/getDefaultExportFromCjs(getIteratorMethodExports);
+
+	var es_array_push = {};
+
+	var hasRequiredEs_array_push;
+
+	function requireEs_array_push () {
+		if (hasRequiredEs_array_push) return es_array_push;
+		hasRequiredEs_array_push = 1;
+		var $ = /*@__PURE__*/ require_export();
+		var toObject = /*@__PURE__*/ requireToObject();
+		var lengthOfArrayLike = /*@__PURE__*/ requireLengthOfArrayLike();
+		var setArrayLength = /*@__PURE__*/ requireArraySetLength();
+		var doesNotExceedSafeInteger = /*@__PURE__*/ requireDoesNotExceedSafeInteger();
+		var fails = /*@__PURE__*/ requireFails();
+
+		var INCORRECT_TO_LENGTH = fails(function () {
+		  return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
+		});
+
+		// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
+		// https://bugs.chromium.org/p/v8/issues/detail?id=12681
+		var properErrorOnNonWritableLength = function () {
+		  try {
+		    // eslint-disable-next-line es/no-object-defineproperty -- safe
+		    Object.defineProperty([], 'length', { writable: false }).push();
+		  } catch (error) {
+		    return error instanceof TypeError;
+		  }
+		};
+
+		var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
+
+		// `Array.prototype.push` method
+		// https://tc39.es/ecma262/#sec-array.prototype.push
+		$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
+		  // eslint-disable-next-line no-unused-vars -- required for `.length`
+		  push: function push(item) {
+		    var O = toObject(this);
+		    var len = lengthOfArrayLike(O);
+		    var argCount = arguments.length;
+		    doesNotExceedSafeInteger(len + argCount);
+		    for (var i = 0; i < argCount; i++) {
+		      O[len] = arguments[i];
+		      len++;
+		    }
+		    setArrayLength(O, len);
+		    return len;
+		  }
+		});
+		return es_array_push;
+	}
+
+	var push$5;
+	var hasRequiredPush$5;
+
+	function requirePush$5 () {
+		if (hasRequiredPush$5) return push$5;
+		hasRequiredPush$5 = 1;
+		requireEs_array_push();
+		var getBuiltInPrototypeMethod = /*@__PURE__*/ requireGetBuiltInPrototypeMethod();
+
+		push$5 = getBuiltInPrototypeMethod('Array', 'push');
+		return push$5;
+	}
+
+	var push$4;
+	var hasRequiredPush$4;
+
+	function requirePush$4 () {
+		if (hasRequiredPush$4) return push$4;
+		hasRequiredPush$4 = 1;
+		var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
+		var method = /*@__PURE__*/ requirePush$5();
+
+		var ArrayPrototype = Array.prototype;
+
+		push$4 = function (it) {
+		  var own = it.push;
+		  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.push) ? method : own;
+		};
+		return push$4;
+	}
+
+	var push$3;
+	var hasRequiredPush$3;
+
+	function requirePush$3 () {
+		if (hasRequiredPush$3) return push$3;
+		hasRequiredPush$3 = 1;
+		var parent = /*@__PURE__*/ requirePush$4();
+
+		push$3 = parent;
+		return push$3;
+	}
+
+	var push$2;
+	var hasRequiredPush$2;
+
+	function requirePush$2 () {
+		if (hasRequiredPush$2) return push$2;
+		hasRequiredPush$2 = 1;
+		var parent = /*@__PURE__*/ requirePush$3();
+
+		push$2 = parent;
+		return push$2;
+	}
+
+	var push$1;
+	var hasRequiredPush$1;
+
+	function requirePush$1 () {
+		if (hasRequiredPush$1) return push$1;
+		hasRequiredPush$1 = 1;
+		var parent = /*@__PURE__*/ requirePush$2();
+
+		push$1 = parent;
+		return push$1;
+	}
+
+	var push;
+	var hasRequiredPush;
+
+	function requirePush () {
+		if (hasRequiredPush) return push;
+		hasRequiredPush = 1;
+		push = /*@__PURE__*/ requirePush$1();
+		return push;
+	}
+
+	var pushExports = /*@__PURE__*/ requirePush();
+	var _pushInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(pushExports);
+
+	function _iterableToArrayLimit(r, l) {
+	  var t = null == r ? null : "undefined" != typeof _Symbol && _getIteratorMethod(r) || r["@@iterator"];
+	  if (null != t) {
+	    var e,
+	      n,
+	      i,
+	      u,
+	      a = [],
+	      f = true,
+	      o = false;
+	    try {
+	      if (i = (t = t.call(r)).next, 0 === l) {
+	        if (Object(t) !== t) return;
+	        f = !1;
+	      } else for (; !(f = (e = i.call(t)).done) && (_pushInstanceProperty(a).call(a, e.value), a.length !== l); f = !0);
+	    } catch (r) {
+	      o = true, n = r;
+	    } finally {
+	      try {
+	        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+	      } finally {
+	        if (o) throw n;
+	      }
+	    }
+	    return a;
+	  }
+	}
+
+	var slice$2;
+	var hasRequiredSlice$2;
+
+	function requireSlice$2 () {
+		if (hasRequiredSlice$2) return slice$2;
+		hasRequiredSlice$2 = 1;
+		var parent = /*@__PURE__*/ requireSlice$4();
+
+		slice$2 = parent;
+		return slice$2;
+	}
+
+	var slice$1;
+	var hasRequiredSlice$1;
+
+	function requireSlice$1 () {
+		if (hasRequiredSlice$1) return slice$1;
+		hasRequiredSlice$1 = 1;
+		var parent = /*@__PURE__*/ requireSlice$2();
+
+		slice$1 = parent;
+		return slice$1;
+	}
+
+	var slice;
+	var hasRequiredSlice;
+
+	function requireSlice () {
+		if (hasRequiredSlice) return slice;
+		hasRequiredSlice = 1;
+		slice = /*@__PURE__*/ requireSlice$1();
+		return slice;
+	}
+
+	var sliceExports = /*@__PURE__*/ requireSlice();
+	var _sliceInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(sliceExports);
+
+	var es_array_from = {};
+
+	var iteratorClose;
+	var hasRequiredIteratorClose;
+
+	function requireIteratorClose () {
+		if (hasRequiredIteratorClose) return iteratorClose;
+		hasRequiredIteratorClose = 1;
+		var call = /*@__PURE__*/ requireFunctionCall();
+		var anObject = /*@__PURE__*/ requireAnObject();
+		var getMethod = /*@__PURE__*/ requireGetMethod();
+
+		iteratorClose = function (iterator, kind, value) {
+		  var innerResult, innerError;
+		  anObject(iterator);
+		  try {
+		    innerResult = getMethod(iterator, 'return');
+		    if (!innerResult) {
+		      if (kind === 'throw') throw value;
+		      return value;
+		    }
+		    innerResult = call(innerResult, iterator);
+		  } catch (error) {
+		    innerError = true;
+		    innerResult = error;
+		  }
+		  if (kind === 'throw') throw value;
+		  if (innerError) throw innerResult;
+		  anObject(innerResult);
+		  return value;
+		};
+		return iteratorClose;
+	}
+
+	var callWithSafeIterationClosing;
+	var hasRequiredCallWithSafeIterationClosing;
+
+	function requireCallWithSafeIterationClosing () {
+		if (hasRequiredCallWithSafeIterationClosing) return callWithSafeIterationClosing;
+		hasRequiredCallWithSafeIterationClosing = 1;
+		var anObject = /*@__PURE__*/ requireAnObject();
+		var iteratorClose = /*@__PURE__*/ requireIteratorClose();
+
+		// call something on iterator step with safe closing on error
+		callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) {
+		  try {
+		    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+		  } catch (error) {
+		    iteratorClose(iterator, 'throw', error);
+		  }
+		};
+		return callWithSafeIterationClosing;
+	}
+
+	var isArrayIteratorMethod;
+	var hasRequiredIsArrayIteratorMethod;
+
+	function requireIsArrayIteratorMethod () {
+		if (hasRequiredIsArrayIteratorMethod) return isArrayIteratorMethod;
+		hasRequiredIsArrayIteratorMethod = 1;
+		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
+		var Iterators = /*@__PURE__*/ requireIterators();
+
+		var ITERATOR = wellKnownSymbol('iterator');
+		var ArrayPrototype = Array.prototype;
+
+		// check on default Array iterator
+		isArrayIteratorMethod = function (it) {
+		  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+		};
+		return isArrayIteratorMethod;
+	}
+
+	var getIterator;
+	var hasRequiredGetIterator;
+
+	function requireGetIterator () {
+		if (hasRequiredGetIterator) return getIterator;
+		hasRequiredGetIterator = 1;
+		var call = /*@__PURE__*/ requireFunctionCall();
+		var aCallable = /*@__PURE__*/ requireACallable();
+		var anObject = /*@__PURE__*/ requireAnObject();
+		var tryToString = /*@__PURE__*/ requireTryToString();
+		var getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod$5();
+
+		var $TypeError = TypeError;
 
-		map$2 = function (it) {
-		  var own = it.map;
-		  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.map) ? method : own;
+		getIterator = function (argument, usingIterator) {
+		  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+		  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+		  throw new $TypeError(tryToString(argument) + ' is not iterable');
 		};
-		return map$2;
+		return getIterator;
 	}
 
-	var map$1;
-	var hasRequiredMap$1;
+	var arrayFrom;
+	var hasRequiredArrayFrom;
 
-	function requireMap$1 () {
-		if (hasRequiredMap$1) return map$1;
-		hasRequiredMap$1 = 1;
-		var parent = /*@__PURE__*/ requireMap$2();
+	function requireArrayFrom () {
+		if (hasRequiredArrayFrom) return arrayFrom;
+		hasRequiredArrayFrom = 1;
+		var bind = /*@__PURE__*/ requireFunctionBindContext();
+		var call = /*@__PURE__*/ requireFunctionCall();
+		var toObject = /*@__PURE__*/ requireToObject();
+		var callWithSafeIterationClosing = /*@__PURE__*/ requireCallWithSafeIterationClosing();
+		var isArrayIteratorMethod = /*@__PURE__*/ requireIsArrayIteratorMethod();
+		var isConstructor = /*@__PURE__*/ requireIsConstructor();
+		var lengthOfArrayLike = /*@__PURE__*/ requireLengthOfArrayLike();
+		var createProperty = /*@__PURE__*/ requireCreateProperty();
+		var setArrayLength = /*@__PURE__*/ requireArraySetLength();
+		var getIterator = /*@__PURE__*/ requireGetIterator();
+		var getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod$5();
+		var iteratorClose = /*@__PURE__*/ requireIteratorClose();
 
-		map$1 = parent;
-		return map$1;
+		var $Array = Array;
+
+		// `Array.from` method implementation
+		// https://tc39.es/ecma262/#sec-array.from
+		arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+		  var IS_CONSTRUCTOR = isConstructor(this);
+		  var argumentsLength = arguments.length;
+		  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
+		  var mapping = mapfn !== undefined;
+		  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
+		  var O = toObject(arrayLike);
+		  var iteratorMethod = getIteratorMethod(O);
+		  var index = 0;
+		  var length, result, step, iterator, next, value;
+		  // if the target is not iterable or it's an array with the default iterator - use a simple case
+		  if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {
+		    result = IS_CONSTRUCTOR ? new this() : [];
+		    iterator = getIterator(O, iteratorMethod);
+		    next = iterator.next;
+		    for (;!(step = call(next, iterator)).done; index++) {
+		      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
+		      try {
+		        createProperty(result, index, value);
+		      } catch (error) {
+		        iteratorClose(iterator, 'throw', error);
+		      }
+		    }
+		  } else {
+		    length = lengthOfArrayLike(O);
+		    result = IS_CONSTRUCTOR ? new this(length) : $Array(length);
+		    for (;length > index; index++) {
+		      value = mapping ? mapfn(O[index], index) : O[index];
+		      createProperty(result, index, value);
+		    }
+		  }
+		  setArrayLength(result, index);
+		  return result;
+		};
+		return arrayFrom;
 	}
 
-	var map;
-	var hasRequiredMap;
+	var checkCorrectnessOfIteration;
+	var hasRequiredCheckCorrectnessOfIteration;
 
-	function requireMap () {
-		if (hasRequiredMap) return map;
-		hasRequiredMap = 1;
-		map = /*@__PURE__*/ requireMap$1();
-		return map;
-	}
+	function requireCheckCorrectnessOfIteration () {
+		if (hasRequiredCheckCorrectnessOfIteration) return checkCorrectnessOfIteration;
+		hasRequiredCheckCorrectnessOfIteration = 1;
+		var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
 
-	var mapExports = requireMap();
-	var _mapInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(mapExports);
+		var ITERATOR = wellKnownSymbol('iterator');
+		var SAFE_CLOSING = false;
+
+		try {
+		  var called = 0;
+		  var iteratorWithReturn = {
+		    next: function () {
+		      return { done: !!called++ };
+		    },
+		    'return': function () {
+		      SAFE_CLOSING = true;
+		    }
+		  };
+		  // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
+		  iteratorWithReturn[ITERATOR] = function () {
+		    return this;
+		  };
+		  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
+		  Array.from(iteratorWithReturn, function () { throw 2; });
+		} catch (error) { /* empty */ }
 
-	var es_object_keys = {};
+		checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) {
+		  try {
+		    if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
+		  } catch (error) { return false; } // workaround of old WebKit + `eval` bug
+		  var ITERATION_SUPPORT = false;
+		  try {
+		    var object = {};
+		    // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
+		    object[ITERATOR] = function () {
+		      return {
+		        next: function () {
+		          return { done: ITERATION_SUPPORT = true };
+		        }
+		      };
+		    };
+		    exec(object);
+		  } catch (error) { /* empty */ }
+		  return ITERATION_SUPPORT;
+		};
+		return checkCorrectnessOfIteration;
+	}
 
-	var hasRequiredEs_object_keys;
+	var hasRequiredEs_array_from;
 
-	function requireEs_object_keys () {
-		if (hasRequiredEs_object_keys) return es_object_keys;
-		hasRequiredEs_object_keys = 1;
+	function requireEs_array_from () {
+		if (hasRequiredEs_array_from) return es_array_from;
+		hasRequiredEs_array_from = 1;
 		var $ = /*@__PURE__*/ require_export();
-		var toObject = /*@__PURE__*/ requireToObject();
-		var nativeKeys = /*@__PURE__*/ requireObjectKeys();
-		var fails = /*@__PURE__*/ requireFails();
+		var from = /*@__PURE__*/ requireArrayFrom();
+		var checkCorrectnessOfIteration = /*@__PURE__*/ requireCheckCorrectnessOfIteration();
 
-		var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });
+		var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
+		  // eslint-disable-next-line es/no-array-from -- required for testing
+		  Array.from(iterable);
+		});
 
-		// `Object.keys` method
-		// https://tc39.es/ecma262/#sec-object.keys
-		$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
-		  keys: function keys(it) {
-		    return nativeKeys(toObject(it));
-		  }
+		// `Array.from` method
+		// https://tc39.es/ecma262/#sec-array.from
+		$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
+		  from: from
 		});
-		return es_object_keys;
+		return es_array_from;
 	}
 
-	var keys$2;
-	var hasRequiredKeys$2;
+	var from$4;
+	var hasRequiredFrom$4;
 
-	function requireKeys$2 () {
-		if (hasRequiredKeys$2) return keys$2;
-		hasRequiredKeys$2 = 1;
-		requireEs_object_keys();
+	function requireFrom$4 () {
+		if (hasRequiredFrom$4) return from$4;
+		hasRequiredFrom$4 = 1;
+		requireEs_string_iterator();
+		requireEs_array_from();
 		var path = /*@__PURE__*/ requirePath();
 
-		keys$2 = path.Object.keys;
-		return keys$2;
+		from$4 = path.Array.from;
+		return from$4;
 	}
 
-	var keys$1;
-	var hasRequiredKeys$1;
+	var from$3;
+	var hasRequiredFrom$3;
 
-	function requireKeys$1 () {
-		if (hasRequiredKeys$1) return keys$1;
-		hasRequiredKeys$1 = 1;
-		var parent = /*@__PURE__*/ requireKeys$2();
+	function requireFrom$3 () {
+		if (hasRequiredFrom$3) return from$3;
+		hasRequiredFrom$3 = 1;
+		var parent = /*@__PURE__*/ requireFrom$4();
 
-		keys$1 = parent;
-		return keys$1;
+		from$3 = parent;
+		return from$3;
 	}
 
-	var keys;
-	var hasRequiredKeys;
+	var from$2;
+	var hasRequiredFrom$2;
 
-	function requireKeys () {
-		if (hasRequiredKeys) return keys;
-		hasRequiredKeys = 1;
-		keys = /*@__PURE__*/ requireKeys$1();
-		return keys;
+	function requireFrom$2 () {
+		if (hasRequiredFrom$2) return from$2;
+		hasRequiredFrom$2 = 1;
+		var parent = /*@__PURE__*/ requireFrom$3();
+
+		from$2 = parent;
+		return from$2;
 	}
 
-	var keysExports = requireKeys();
-	var _Object$keys = /*@__PURE__*/getDefaultExportFromCjs(keysExports);
+	var from$1;
+	var hasRequiredFrom$1;
 
-	/**
-	 * Use this symbol to delete properies in deepObjectAssign.
-	 */
-	const DELETE = _Symbol("DELETE");
-	/**
-	 * Pure version of deepObjectAssign, it doesn't modify any of it's arguments.
-	 * @param base - The base object that fullfils the whole interface T.
-	 * @param updates - Updates that may change or delete props.
-	 * @returns A brand new instance with all the supplied objects deeply merged.
-	 */
-	function pureDeepObjectAssign(base) {
-	  for (var _len = arguments.length, updates = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-	    updates[_key - 1] = arguments[_key];
-	  }
-	  return deepObjectAssign({}, base, ...updates);
+	function requireFrom$1 () {
+		if (hasRequiredFrom$1) return from$1;
+		hasRequiredFrom$1 = 1;
+		var parent = /*@__PURE__*/ requireFrom$2();
+
+		from$1 = parent;
+		return from$1;
 	}
-	/**
-	 * Deep version of object assign with additional deleting by the DELETE symbol.
-	 * @param values - Objects to be deeply merged.
-	 * @returns The first object from values.
-	 */
-	function deepObjectAssign() {
-	  const merged = deepObjectAssignNonentry(...arguments);
-	  stripDelete(merged);
-	  return merged;
+
+	var from;
+	var hasRequiredFrom;
+
+	function requireFrom () {
+		if (hasRequiredFrom) return from;
+		hasRequiredFrom = 1;
+		from = /*@__PURE__*/ requireFrom$1();
+		return from;
 	}
-	/**
-	 * Deep version of object assign with additional deleting by the DELETE symbol.
-	 * @remarks
-	 * This doesn't strip the DELETE symbols so they may end up in the final object.
-	 * @param values - Objects to be deeply merged.
-	 * @returns The first object from values.
-	 */
-	function deepObjectAssignNonentry() {
-	  for (var _len2 = arguments.length, values = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-	    values[_key2] = arguments[_key2];
-	  }
-	  if (values.length < 2) {
-	    return values[0];
-	  } else if (values.length > 2) {
-	    return deepObjectAssignNonentry(deepObjectAssign(values[0], values[1]), ..._sliceInstanceProperty(values).call(values, 2));
-	  }
-	  const a = values[0];
-	  const b = values[1];
-	  if (a instanceof Date && b instanceof Date) {
-	    a.setTime(b.getTime());
-	    return a;
-	  }
-	  for (const prop of _Reflect$ownKeys(b)) {
-	    if (!Object.prototype.propertyIsEnumerable.call(b, prop)) ; else if (b[prop] === DELETE) {
-	      delete a[prop];
-	    } else if (a[prop] !== null && b[prop] !== null && typeof a[prop] === "object" && typeof b[prop] === "object" && !_Array$isArray(a[prop]) && !_Array$isArray(b[prop])) {
-	      a[prop] = deepObjectAssignNonentry(a[prop], b[prop]);
-	    } else {
-	      a[prop] = clone(b[prop]);
-	    }
-	  }
-	  return a;
+
+	var fromExports = /*@__PURE__*/ requireFrom();
+	var _Array$from = /*@__PURE__*/getDefaultExportFromCjs(fromExports);
+
+	function _arrayLikeToArray(r, a) {
+	  (null == a || a > r.length) && (a = r.length);
+	  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+	  return n;
 	}
-	/**
-	 * Deep clone given object or array. In case of primitive simply return.
-	 * @param a - Anything.
-	 * @returns Deep cloned object/array or unchanged a.
-	 */
-	function clone(a) {
-	  if (_Array$isArray(a)) {
-	    return _mapInstanceProperty(a).call(a, value => clone(value));
-	  } else if (typeof a === "object" && a !== null) {
-	    if (a instanceof Date) {
-	      return new Date(a.getTime());
-	    }
-	    return deepObjectAssignNonentry({}, a);
-	  } else {
-	    return a;
+
+	function _unsupportedIterableToArray(r, a) {
+	  if (r) {
+	    var _context;
+	    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+	    var t = _sliceInstanceProperty(_context = {}.toString.call(r)).call(_context, 8, -1);
+	    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
 	  }
 	}
-	/**
-	 * Strip DELETE from given object.
-	 * @param a - Object which may contain DELETE but won't after this is executed.
-	 */
-	function stripDelete(a) {
-	  for (const prop of _Object$keys(a)) {
-	    if (a[prop] === DELETE) {
-	      delete a[prop];
-	    } else if (typeof a[prop] === "object" && a[prop] !== null) {
-	      stripDelete(a[prop]);
-	    }
-	  }
+
+	function _nonIterableRest() {
+	  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+
+	function _slicedToArray(r, e) {
+	  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 	}
 
 	var es_date_now = {};
@@ -4158,7 +5388,11 @@
 	 * @returns A ready to use seeded generator.
 	 */
 	function AleaImplementation(seed) {
-	  let [s0, s1, s2] = mashSeed(seed);
+	  let _mashSeed = mashSeed(seed),
+	    _mashSeed2 = _slicedToArray(_mashSeed, 3),
+	    s0 = _mashSeed2[0],
+	    s1 = _mashSeed2[1],
+	    s2 = _mashSeed2[2];
 	  let c = 1;
 	  const random = () => {
 	    const t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32
@@ -4464,127 +5698,8 @@
 	var forEachExports = requireForEach();
 	var _forEachInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(forEachExports);
 
-	var es_array_reverse = {};
-
-	var hasRequiredEs_array_reverse;
-
-	function requireEs_array_reverse () {
-		if (hasRequiredEs_array_reverse) return es_array_reverse;
-		hasRequiredEs_array_reverse = 1;
-		var $ = /*@__PURE__*/ require_export();
-		var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
-		var isArray = /*@__PURE__*/ requireIsArray$3();
-
-		var nativeReverse = uncurryThis([].reverse);
-		var test = [1, 2];
-
-		// `Array.prototype.reverse` method
-		// https://tc39.es/ecma262/#sec-array.prototype.reverse
-		// fix for Safari 12.0 bug
-		// https://bugs.webkit.org/show_bug.cgi?id=188794
-		$({ target: 'Array', proto: true, forced: String(test) === String(test.reverse()) }, {
-		  reverse: function reverse() {
-		    // eslint-disable-next-line no-self-assign -- dirty hack
-		    if (isArray(this)) this.length = this.length;
-		    return nativeReverse(this);
-		  }
-		});
-		return es_array_reverse;
-	}
-
-	var reverse$3;
-	var hasRequiredReverse$3;
-
-	function requireReverse$3 () {
-		if (hasRequiredReverse$3) return reverse$3;
-		hasRequiredReverse$3 = 1;
-		requireEs_array_reverse();
-		var getBuiltInPrototypeMethod = /*@__PURE__*/ requireGetBuiltInPrototypeMethod();
-
-		reverse$3 = getBuiltInPrototypeMethod('Array', 'reverse');
-		return reverse$3;
-	}
-
-	var reverse$2;
-	var hasRequiredReverse$2;
-
-	function requireReverse$2 () {
-		if (hasRequiredReverse$2) return reverse$2;
-		hasRequiredReverse$2 = 1;
-		var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
-		var method = /*@__PURE__*/ requireReverse$3();
-
-		var ArrayPrototype = Array.prototype;
-
-		reverse$2 = function (it) {
-		  var own = it.reverse;
-		  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.reverse) ? method : own;
-		};
-		return reverse$2;
-	}
-
-	var reverse$1;
-	var hasRequiredReverse$1;
-
-	function requireReverse$1 () {
-		if (hasRequiredReverse$1) return reverse$1;
-		hasRequiredReverse$1 = 1;
-		var parent = /*@__PURE__*/ requireReverse$2();
-
-		reverse$1 = parent;
-		return reverse$1;
-	}
-
-	var reverse;
-	var hasRequiredReverse;
-
-	function requireReverse () {
-		if (hasRequiredReverse) return reverse;
-		hasRequiredReverse = 1;
-		reverse = /*@__PURE__*/ requireReverse$1();
-		return reverse;
-	}
-
-	var reverseExports = requireReverse();
-	var _reverseInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(reverseExports);
-
 	var es_array_splice = {};
 
-	var arraySetLength;
-	var hasRequiredArraySetLength;
-
-	function requireArraySetLength () {
-		if (hasRequiredArraySetLength) return arraySetLength;
-		hasRequiredArraySetLength = 1;
-		var DESCRIPTORS = /*@__PURE__*/ requireDescriptors();
-		var isArray = /*@__PURE__*/ requireIsArray$3();
-
-		var $TypeError = TypeError;
-		// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-		var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-
-		// Safari < 13 does not throw an error in this case
-		var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
-		  // makes no sense without proper strict mode support
-		  if (this !== undefined) return true;
-		  try {
-		    // eslint-disable-next-line es/no-object-defineproperty -- safe
-		    Object.defineProperty([], 'length', { writable: false }).length = 1;
-		  } catch (error) {
-		    return error instanceof TypeError;
-		  }
-		}();
-
-		arraySetLength = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
-		  if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
-		    throw new $TypeError('Cannot set read only .length');
-		  } return O.length = length;
-		} : function (O, length) {
-		  return O.length = length;
-		};
-		return arraySetLength;
-	}
-
 	var deletePropertyOrThrow;
 	var hasRequiredDeletePropertyOrThrow;
 
@@ -4648,7 +5763,7 @@
 		      from = actualStart + k;
 		      if (from in O) createProperty(A, k, O[from]);
 		    }
-		    A.length = actualDeleteCount;
+		    setArrayLength(A, actualDeleteCount);
 		    if (insertCount < actualDeleteCount) {
 		      for (k = actualStart; k < len - actualDeleteCount; k++) {
 		        from = k + actualDeleteCount;
@@ -7937,8 +9052,8 @@
 	 */
 	Activator$1.prototype.destroy = function () {
 	  this.deactivate();
-	  for (const callback of _reverseInstanceProperty(_context2 = _spliceInstanceProperty(_context3 = this._cleanupQueue).call(_context3, 0)).call(_context2)) {
-	    var _context2, _context3;
+	  for (const callback of _spliceInstanceProperty(_context2 = this._cleanupQueue).call(_context2, 0).toReversed()) {
+	    var _context2;
 	    callback();
 	  }
 	};
@@ -8020,6 +9135,7 @@
 		var requireObjectCoercible = /*@__PURE__*/ requireRequireObjectCoercible();
 
 		var $RangeError = RangeError;
+		var floor = Math.floor;
 
 		// `String.prototype.repeat` method implementation
 		// https://tc39.es/ecma262/#sec-string.prototype.repeat
@@ -8028,7 +9144,7 @@
 		  var result = '';
 		  var n = toIntegerOrInfinity(count);
 		  if (n < 0 || n === Infinity) throw new $RangeError('Wrong number of repetitions');
-		  for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str;
+		  for (;n > 0; (n = floor(n / 2)) && (str += str)) if (n % 2) result += str;
 		  return result;
 		};
 		return stringRepeat;
@@ -8056,9 +9172,10 @@
 		    var S = toString(requireObjectCoercible($this));
 		    var intMaxLength = toLength(maxLength);
 		    var stringLength = S.length;
+		    if (intMaxLength <= stringLength) return S;
 		    var fillStr = fillString === undefined ? ' ' : toString(fillString);
 		    var fillLen, stringFiller;
-		    if (intMaxLength <= stringLength || fillStr === '') return S;
+		    if (fillStr === '') return S;
 		    fillLen = intMaxLength - stringLength;
 		    stringFiller = repeat(fillStr, ceil(fillLen / fillStr.length));
 		    if (stringFiller.length > fillLen) stringFiller = stringSlice(stringFiller, 0, fillLen);
@@ -8612,9 +9729,15 @@
 		  return !Array(1).includes();
 		});
 
+		// Safari 26.4- bug
+		var BROKEN_ON_SPARSE_WITH_FROM_INDEX = fails(function () {
+		  // eslint-disable-next-line no-sparse-arrays, es/no-array-prototype-includes -- detection
+		  return [, 1].includes(undefined, 1);
+		});
+
 		// `Array.prototype.includes` method
 		// https://tc39.es/ecma262/#sec-array.prototype.includes
-		$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
+		$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE || BROKEN_ON_SPARSE_WITH_FROM_INDEX }, {
 		  includes: function includes(el /* , fromIndex = 0 */) {
 		    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
 		  }
@@ -9587,7 +10710,7 @@
 	 * @returns Argument a.
 	 */
 	function selectiveExtend(props, a) {
-	  if (!_Array$isArray(props)) {
+	  if (!_Array$isArray$1(props)) {
 	    throw new Error("Array with property names expected as first argument");
 	  }
 	  for (var _len = arguments.length, others = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
@@ -9619,7 +10742,7 @@
 	function selectiveDeepExtend(props, a, b) {
 	  let allowDeletion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 	  // TODO: add support for Arrays to deepExtend
-	  if (_Array$isArray(b)) {
+	  if (_Array$isArray$1(b)) {
 	    throw new TypeError("Arrays are not supported by deepExtend");
 	  }
 	  for (let p = 0; p < props.length; p++) {
@@ -9634,7 +10757,7 @@
 	        } else {
 	          copyOrDelete(a, b, prop, allowDeletion);
 	        }
-	      } else if (_Array$isArray(b[prop])) {
+	      } else if (_Array$isArray$1(b[prop])) {
 	        throw new TypeError("Arrays are not supported by deepExtend");
 	      } else {
 	        copyOrDelete(a, b, prop, allowDeletion);
@@ -9661,7 +10784,7 @@
 	  let allowDeletion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 	  // TODO: add support for Arrays to deepExtend
 	  // NOTE: array properties have an else-below; apparently, there is a problem here.
-	  if (_Array$isArray(b)) {
+	  if (_Array$isArray$1(b)) {
 	    throw new TypeError("Arrays are not supported by deepExtend");
 	  }
 	  for (const prop in b) {
@@ -9680,7 +10803,7 @@
 	      } else {
 	        copyOrDelete(a, b, prop, allowDeletion);
 	      }
-	    } else if (_Array$isArray(b[prop])) {
+	    } else if (_Array$isArray$1(b[prop])) {
 	      a[prop] = [];
 	      for (let i = 0; i < b[prop].length; i++) {
 	        a[prop].push(b[prop][i]);
@@ -9714,9 +10837,9 @@
 	        } else {
 	          copyOrDelete(a, b, prop, allowDeletion);
 	        }
-	      } else if (_Array$isArray(b[prop])) {
+	      } else if (_Array$isArray$1(b[prop])) {
 	        var _context;
-	        a[prop] = _sliceInstanceProperty(_context = b[prop]).call(_context);
+	        a[prop] = _sliceInstanceProperty$1(_context = b[prop]).call(_context);
 	      } else {
 	        copyOrDelete(a, b, prop, allowDeletion);
 	      }
@@ -9761,7 +10884,7 @@
 	    if (object instanceof String) {
 	      return "String";
 	    }
-	    if (_Array$isArray(object)) {
+	    if (_Array$isArray$1(object)) {
 	      return "Array";
 	    }
 	    if (object instanceof Date) {
@@ -9798,7 +10921,7 @@
 	 * @returns Shallow copy of arr.
 	 */
 	function copyArray(arr) {
-	  return _sliceInstanceProperty(arr).call(arr);
+	  return _sliceInstanceProperty$1(arr).call(arr);
 	}
 	/**
 	 * Retrieve the absolute left value of a DOM element.
@@ -9858,7 +10981,7 @@
 	 * @param callback - Array.forEach-like callback.
 	 */
 	function forEach(object, callback) {
-	  if (_Array$isArray(object)) {
+	  if (_Array$isArray$1(object)) {
 	    // array
 	    const len = object.length;
 	    for (let i = 0; i < len; i++) {
@@ -10109,7 +11232,7 @@
 	 */
 	function RGBToHex(red, green, blue) {
 	  var _context2;
-	  return "#" + _sliceInstanceProperty(_context2 = ((1 << 24) + (red << 16) + (green << 8) + blue).toString(16)).call(_context2, 1);
+	  return "#" + _sliceInstanceProperty$1(_context2 = ((1 << 24) + (red << 16) + (green << 8) + blue).toString(16)).call(_context2, 1);
 	}
 	/**
 	 * Parse a color property into an object with border, background, and highlight colors.
@@ -10267,7 +11390,10 @@
 	 */
 	function addCssText(element, cssText) {
 	  const cssStyle = splitCSSText(cssText);
-	  for (const [key, value] of _Object$entries(cssStyle)) {
+	  for (const _ref of _Object$entries(cssStyle)) {
+	    var _ref2 = _slicedToArray(_ref, 2);
+	    const key = _ref2[0];
+	    const value = _ref2[1];
 	    element.style.setProperty(key, value);
 	  }
 	}
@@ -10793,7 +11919,7 @@
 	 */
 	function topMost(pile, accessors) {
 	  let candidate;
-	  if (!_Array$isArray(accessors)) {
+	  if (!_Array$isArray$1(accessors)) {
 	    accessors = [accessors];
 	  }
 	  for (const member of pile) {
@@ -11320,7 +12446,7 @@
 	      this.opacityRange.type = "range"; // Not supported on IE9
 	      this.opacityRange.min = "0";
 	      this.opacityRange.max = "100";
-	    } catch (err) {
+	    } catch (_unused) {
 	      // TODO: Add some error handling.
 	    }
 	    this.opacityRange.value = "100";
@@ -11330,7 +12456,7 @@
 	      this.brightnessRange.type = "range"; // Not supported on IE9
 	      this.brightnessRange.min = "0";
 	      this.brightnessRange.max = "100";
-	    } catch (err) {
+	    } catch (_unused2) {
 	      // TODO: Add some error handling.
 	    }
 	    this.brightnessRange.value = "100";
@@ -11519,7 +12645,7 @@
 	    return document.createTextNode(rest[0]);
 	  } else {
 	    const element = document.createElement(rest[0]);
-	    element.appendChild(wrapInTag(..._sliceInstanceProperty(rest).call(rest, 1)));
+	    element.appendChild(wrapInTag(..._sliceInstanceProperty$1(rest).call(rest, 1)));
 	    return element;
 	  }
 	}
@@ -11582,7 +12708,7 @@
 	      let enabled = true;
 	      if (typeof options === "string") {
 	        this.options.filter = options;
-	      } else if (_Array$isArray(options)) {
+	      } else if (_Array$isArray$1(options)) {
 	        this.options.filter = options.join();
 	      } else if (typeof options === "object") {
 	        if (options == null) {
@@ -11829,7 +12955,7 @@
 	      range.type = "range"; // not supported on IE9
 	      range.min = min;
 	      range.max = max;
-	    } catch (err) {
+	    } catch (_unused) {
 	      // TODO: Add some error handling.
 	    }
 	    range.step = step;
@@ -12099,7 +13225,7 @@
 
 	          // if needed we must go deeper into the object.
 	          if (show === false) {
-	            if (!_Array$isArray(item) && typeof item !== "string" && typeof item !== "boolean" && item instanceof Object) {
+	            if (!_Array$isArray$1(item) && typeof item !== "string" && typeof item !== "boolean" && item instanceof Object) {
 	              this.allowCreation = false;
 	              show = this._handleObject(item, newPath, true);
 	              this.allowCreation = checkOnly === false;
@@ -12109,7 +13235,7 @@
 	        if (show !== false) {
 	          visibleInSet = true;
 	          const value = this._getValue(newPath);
-	          if (_Array$isArray(item)) {
+	          if (_Array$isArray$1(item)) {
 	            this._handleArray(item, value, newPath);
 	          } else if (typeof item === "string") {
 	            this._makeTextInput(item, value, newPath);
@@ -12503,7 +13629,7 @@
 	      if (object instanceof String) {
 	        return "string";
 	      }
-	      if (_Array$isArray(object)) {
+	      if (_Array$isArray$1(object)) {
 	        return "array";
 	      }
 	      if (object instanceof Date) {
@@ -12569,6 +13695,7 @@
 	    let closestMatchPath = [];
 	    const lowerCaseOption = option.toLowerCase();
 	    let indexMatch = undefined;
+	    // oxlint-disable-next-line guard-for-in -- Options use prototype inheritance to override defaults, parent options, etc.
 	    for (const op in options) {
 	      let distance;
 	      if (options[op].__type__ !== undefined && recursive === true) {