vis-data 8.0.4 → 8.0.5

package/standalone/esm/vis-data.mjs

@@ -4,8 +4,8 @@
  *
  * Manage unstructured data using DataSet. Add, update, and remove data, and listen for changes in the data.
  *
- * @version 8.0.4
- * @date    2026-05-07T14:01:00.852Z
+ * @version 8.0.5
+ * @date    2026-08-06T17:35:20.924Z
  *
  * @copyright (c) 2011-2017 Almende B.V, http://almende.com
  * @copyright (c) 2017-2019 visjs contributors, https://github.com/visjs
@@ -84,7 +84,7 @@ function requireFunctionBindNative () {
 
 	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');
 	});
@@ -630,10 +630,10 @@ function requireSharedStore () {
 	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;
@@ -1160,11 +1160,11 @@ function requireDefineProperty$5 () {
 
 	var Object = path.Object;
 
-	var defineProperty = defineProperty$5.exports = function defineProperty(it, key, desc) {
+	var $defineProperty = defineProperty$5.exports = function defineProperty(it, key, desc) {
 	  return Object.defineProperty(it, key, desc);
 	};
 
-	if (Object.defineProperty.sham) defineProperty.sham = true;
+	if (Object.defineProperty.sham) $defineProperty.sham = true;
 	return defineProperty$5.exports;
 }
 
@@ -1219,21 +1219,21 @@ var _Object$defineProperty$1 = /*@__PURE__*/getDefaultExportFromCjs(defineProper
 
 var es_array_concat = {};
 
-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;
@@ -1318,7 +1318,7 @@ function requireDoesNotExceedSafeInteger () {
 	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;
@@ -1341,6 +1341,41 @@ function requireCreateProperty () {
 	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;
 
@@ -1351,7 +1386,7 @@ function requireToStringTagSupport () {
 
 	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]';
@@ -1485,7 +1520,7 @@ var hasRequiredArraySpeciesConstructor;
 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();
@@ -1561,12 +1596,13 @@ function requireEs_array_concat () {
 	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();
@@ -1612,7 +1648,7 @@ function requireEs_array_concat () {
 	        createProperty(A, n++, E);
 	      }
 	    }
-	    A.length = n;
+	    setArrayLength(A, n);
 	    return A;
 	  }
 	});
@@ -2248,13 +2284,11 @@ function requireArrayIteration () {
 	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) {
@@ -2265,28 +2299,28 @@ function requireArrayIteration () {
 	  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
 	        }
 	      }
 	    }
@@ -2399,7 +2433,7 @@ function requireEs_symbol_constructor () {
 	  nativeDefineProperty(O, P, Attributes);
 	  if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
 	    nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
-	  }
+	  } return O;
 	};
 
 	var setSymbolDescriptor = DESCRIPTORS && fails(function () {
@@ -2425,7 +2459,8 @@ function requireEs_symbol_constructor () {
 	  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 {
@@ -2667,42 +2702,104 @@ function requireEs_symbol_keyFor () {
 
 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;
@@ -2716,11 +2813,17 @@ function requireEs_json_stringify () {
 	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');
@@ -2728,11 +2831,16 @@ function requireEs_json_stringify () {
 	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');
@@ -2750,7 +2858,7 @@ function requireEs_json_stringify () {
 	    || $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
@@ -2760,28 +2868,79 @@ function requireEs_json_stringify () {
 	    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;
 }
 
@@ -3146,7 +3305,7 @@ function requireFunctionName () {
 
 	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 = {
@@ -4742,10 +4901,11 @@ var hasRequiredFlattenIntoArray;
 function requireFlattenIntoArray () {
 	if (hasRequiredFlattenIntoArray) return flattenIntoArray_1;
 	hasRequiredFlattenIntoArray = 1;
-	var isArray = /*@__PURE__*/ requireIsArray$3();
+	var isArray = /*@__PURE__*/ requireIsArray$6();
 	var lengthOfArrayLike = /*@__PURE__*/ requireLengthOfArrayLike();
 	var doesNotExceedSafeInteger = /*@__PURE__*/ requireDoesNotExceedSafeInteger();
 	var bind = /*@__PURE__*/ requireFunctionBindContext();
+	var createProperty = /*@__PURE__*/ requireCreateProperty();
 
 	// `FlattenIntoArray` abstract operation
 	// https://tc39.es/ecma262/#sec-flattenintoarray
@@ -4764,7 +4924,7 @@ function requireFlattenIntoArray () {
 	        targetIndex = flattenIntoArray(target, original, element, elementLen, targetIndex, depth - 1) - 1;
 	      } else {
 	        doesNotExceedSafeInteger(targetIndex + 1);
-	        target[targetIndex] = element;
+	        createProperty(target, targetIndex, element);
 	      }
 
 	      targetIndex++;
@@ -4799,7 +4959,7 @@ function requireEs_array_flatMap () {
 	    var A;
 	    aCallable(callbackfn);
 	    A = arraySpeciesCreate(O, 0);
-	    A.length = flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+	    flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
 	    return A;
 	  }
 	});
@@ -5072,132 +5232,813 @@ class DataPipeUnderConstruction {
   }
 }
 
-var symbol;
-var hasRequiredSymbol;
+var es_array_isArray = {};
 
-function requireSymbol () {
-	if (hasRequiredSymbol) return symbol;
-	hasRequiredSymbol = 1;
-	symbol = /*@__PURE__*/ requireSymbol$4();
-	return symbol;
-}
+var hasRequiredEs_array_isArray;
 
-var symbolExports = requireSymbol();
-var _Symbol = /*@__PURE__*/getDefaultExportFromCjs(symbolExports);
+function requireEs_array_isArray () {
+	if (hasRequiredEs_array_isArray) return es_array_isArray;
+	hasRequiredEs_array_isArray = 1;
+	var $ = /*@__PURE__*/ require_export();
+	var isArray = /*@__PURE__*/ requireIsArray$6();
 
-var es_array_slice = {};
+	// `Array.isArray` method
+	// https://tc39.es/ecma262/#sec-array.isarray
+	$({ target: 'Array', stat: true }, {
+	  isArray: isArray
+	});
+	return es_array_isArray;
+}
 
-var hasRequiredEs_array_slice;
+var isArray$5;
+var hasRequiredIsArray$5;
 
-function requireEs_array_slice () {
-	if (hasRequiredEs_array_slice) return es_array_slice;
-	hasRequiredEs_array_slice = 1;
-	var $ = /*@__PURE__*/ require_export();
-	var isArray = /*@__PURE__*/ requireIsArray$3();
-	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 wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
-	var arrayMethodHasSpeciesSupport = /*@__PURE__*/ requireArrayMethodHasSpeciesSupport();
-	var nativeSlice = /*@__PURE__*/ requireArraySlice();
+function requireIsArray$5 () {
+	if (hasRequiredIsArray$5) return isArray$5;
+	hasRequiredIsArray$5 = 1;
+	requireEs_array_isArray();
+	var path = /*@__PURE__*/ requirePath();
 
-	var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');
+	isArray$5 = path.Array.isArray;
+	return isArray$5;
+}
 
-	var SPECIES = wellKnownSymbol('species');
-	var $Array = Array;
-	var max = Math.max;
+var isArray$4;
+var hasRequiredIsArray$4;
 
-	// `Array.prototype.slice` method
-	// https://tc39.es/ecma262/#sec-array.prototype.slice
-	// fallback for not array-like ES3 strings and DOM objects
-	$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
-	  slice: function slice(start, end) {
-	    var O = toIndexedObject(this);
-	    var length = lengthOfArrayLike(O);
-	    var k = toAbsoluteIndex(start, length);
-	    var fin = toAbsoluteIndex(end === undefined ? length : end, length);
-	    // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
-	    var Constructor, result, n;
-	    if (isArray(O)) {
-	      Constructor = O.constructor;
-	      // cross-realm fallback
-	      if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) {
-	        Constructor = undefined;
-	      } else if (isObject(Constructor)) {
-	        Constructor = Constructor[SPECIES];
-	        if (Constructor === null) Constructor = undefined;
-	      }
-	      if (Constructor === $Array || Constructor === undefined) {
-	        return nativeSlice(O, k, fin);
-	      }
-	    }
-	    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;
-	    return result;
-	  }
-	});
-	return es_array_slice;
+function requireIsArray$4 () {
+	if (hasRequiredIsArray$4) return isArray$4;
+	hasRequiredIsArray$4 = 1;
+	var parent = /*@__PURE__*/ requireIsArray$5();
+
+	isArray$4 = parent;
+	return isArray$4;
 }
 
-var slice$3;
-var hasRequiredSlice$3;
+var isArray$3;
+var hasRequiredIsArray$3;
 
-function requireSlice$3 () {
-	if (hasRequiredSlice$3) return slice$3;
-	hasRequiredSlice$3 = 1;
-	requireEs_array_slice();
-	var getBuiltInPrototypeMethod = /*@__PURE__*/ requireGetBuiltInPrototypeMethod();
+function requireIsArray$3 () {
+	if (hasRequiredIsArray$3) return isArray$3;
+	hasRequiredIsArray$3 = 1;
+	var parent = /*@__PURE__*/ requireIsArray$4();
 
-	slice$3 = getBuiltInPrototypeMethod('Array', 'slice');
-	return slice$3;
+	isArray$3 = parent;
+	return isArray$3;
 }
 
-var slice$2;
-var hasRequiredSlice$2;
-
-function requireSlice$2 () {
-	if (hasRequiredSlice$2) return slice$2;
-	hasRequiredSlice$2 = 1;
-	var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
-	var method = /*@__PURE__*/ requireSlice$3();
+var isArray$2;
+var hasRequiredIsArray$2;
 
-	var ArrayPrototype = Array.prototype;
+function requireIsArray$2 () {
+	if (hasRequiredIsArray$2) return isArray$2;
+	hasRequiredIsArray$2 = 1;
+	var parent = /*@__PURE__*/ requireIsArray$3();
 
-	slice$2 = function (it) {
-	  var own = it.slice;
-	  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.slice) ? method : own;
-	};
-	return slice$2;
+	isArray$2 = parent;
+	return isArray$2;
 }
 
-var slice$1;
-var hasRequiredSlice$1;
-
-function requireSlice$1 () {
-	if (hasRequiredSlice$1) return slice$1;
-	hasRequiredSlice$1 = 1;
-	var parent = /*@__PURE__*/ requireSlice$2();
+var isArray$1;
+var hasRequiredIsArray$1;
 
-	slice$1 = parent;
-	return slice$1;
+function requireIsArray$1 () {
+	if (hasRequiredIsArray$1) return isArray$1;
+	hasRequiredIsArray$1 = 1;
+	isArray$1 = /*@__PURE__*/ requireIsArray$2();
+	return isArray$1;
 }
 
-var slice;
-var hasRequiredSlice;
+var isArrayExports$1 = /*@__PURE__*/ requireIsArray$1();
+var _Array$isArray$1 = /*@__PURE__*/getDefaultExportFromCjs(isArrayExports$1);
 
-function requireSlice () {
-	if (hasRequiredSlice) return slice;
-	hasRequiredSlice = 1;
-	slice = /*@__PURE__*/ requireSlice$1();
-	return slice;
+function _arrayWithHoles(r) {
+  if (_Array$isArray$1(r)) return r;
 }
 
-var sliceExports = requireSlice();
-var _sliceInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(sliceExports);
+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$1 && _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 es_array_slice = {};
+
+var hasRequiredEs_array_slice;
+
+function requireEs_array_slice () {
+	if (hasRequiredEs_array_slice) return es_array_slice;
+	hasRequiredEs_array_slice = 1;
+	var $ = /*@__PURE__*/ require_export();
+	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();
+
+	var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');
+
+	var SPECIES = wellKnownSymbol('species');
+	var $Array = Array;
+	var max = Math.max;
+
+	// `Array.prototype.slice` method
+	// https://tc39.es/ecma262/#sec-array.prototype.slice
+	// fallback for not array-like ES3 strings and DOM objects
+	$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
+	  slice: function slice(start, end) {
+	    var O = toIndexedObject(this);
+	    var length = lengthOfArrayLike(O);
+	    var k = toAbsoluteIndex(start, length);
+	    var fin = toAbsoluteIndex(end === undefined ? length : end, length);
+	    // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
+	    var Constructor, result, n;
+	    if (isArray(O)) {
+	      Constructor = O.constructor;
+	      // cross-realm fallback
+	      if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) {
+	        Constructor = undefined;
+	      } else if (isObject(Constructor)) {
+	        Constructor = Constructor[SPECIES];
+	        if (Constructor === null) Constructor = undefined;
+	      }
+	      if (Constructor === $Array || Constructor === undefined) {
+	        return nativeSlice(O, k, fin);
+	      }
+	    }
+	    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]);
+	    setArrayLength(result, n);
+	    return result;
+	  }
+	});
+	return es_array_slice;
+}
+
+var slice$6;
+var hasRequiredSlice$6;
+
+function requireSlice$6 () {
+	if (hasRequiredSlice$6) return slice$6;
+	hasRequiredSlice$6 = 1;
+	requireEs_array_slice();
+	var getBuiltInPrototypeMethod = /*@__PURE__*/ requireGetBuiltInPrototypeMethod();
+
+	slice$6 = getBuiltInPrototypeMethod('Array', 'slice');
+	return slice$6;
+}
+
+var slice$5;
+var hasRequiredSlice$5;
+
+function requireSlice$5 () {
+	if (hasRequiredSlice$5) return slice$5;
+	hasRequiredSlice$5 = 1;
+	var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
+	var method = /*@__PURE__*/ requireSlice$6();
+
+	var ArrayPrototype = Array.prototype;
+
+	slice$5 = function (it) {
+	  var own = it.slice;
+	  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.slice) ? method : own;
+	};
+	return slice$5;
+}
+
+var slice$4;
+var hasRequiredSlice$4;
+
+function requireSlice$4 () {
+	if (hasRequiredSlice$4) return slice$4;
+	hasRequiredSlice$4 = 1;
+	var parent = /*@__PURE__*/ requireSlice$5();
+
+	slice$4 = parent;
+	return slice$4;
+}
+
+var slice$3;
+var hasRequiredSlice$3;
+
+function requireSlice$3 () {
+	if (hasRequiredSlice$3) return slice$3;
+	hasRequiredSlice$3 = 1;
+	var parent = /*@__PURE__*/ requireSlice$4();
+
+	slice$3 = parent;
+	return slice$3;
+}
+
+var slice$2;
+var hasRequiredSlice$2;
+
+function requireSlice$2 () {
+	if (hasRequiredSlice$2) return slice$2;
+	hasRequiredSlice$2 = 1;
+	var parent = /*@__PURE__*/ requireSlice$3();
+
+	slice$2 = parent;
+	return slice$2;
+}
+
+var slice$1;
+var hasRequiredSlice$1;
+
+function requireSlice$1 () {
+	if (hasRequiredSlice$1) return slice$1;
+	hasRequiredSlice$1 = 1;
+	slice$1 = /*@__PURE__*/ requireSlice$2();
+	return slice$1;
+}
+
+var sliceExports$1 = /*@__PURE__*/ requireSlice$1();
+var _sliceInstanceProperty$1 = /*@__PURE__*/getDefaultExportFromCjs(sliceExports$1);
+
+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$5;
+var hasRequiredGetIterator$6;
+
+function requireGetIterator$6 () {
+	if (hasRequiredGetIterator$6) return getIterator$5;
+	hasRequiredGetIterator$6 = 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;
+
+	getIterator$5 = 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 getIterator$5;
+}
+
+var arrayFrom;
+var hasRequiredArrayFrom;
+
+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$6();
+	var getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod$5();
+	var iteratorClose = /*@__PURE__*/ requireIteratorClose();
+
+	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 checkCorrectnessOfIteration;
+var hasRequiredCheckCorrectnessOfIteration;
+
+function requireCheckCorrectnessOfIteration () {
+	if (hasRequiredCheckCorrectnessOfIteration) return checkCorrectnessOfIteration;
+	hasRequiredCheckCorrectnessOfIteration = 1;
+	var wellKnownSymbol = /*@__PURE__*/ requireWellKnownSymbol();
+
+	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 */ }
+
+	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_array_from;
+
+function requireEs_array_from () {
+	if (hasRequiredEs_array_from) return es_array_from;
+	hasRequiredEs_array_from = 1;
+	var $ = /*@__PURE__*/ require_export();
+	var from = /*@__PURE__*/ requireArrayFrom();
+	var checkCorrectnessOfIteration = /*@__PURE__*/ requireCheckCorrectnessOfIteration();
+
+	var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
+	  // eslint-disable-next-line es/no-array-from -- required for testing
+	  Array.from(iterable);
+	});
+
+	// `Array.from` method
+	// https://tc39.es/ecma262/#sec-array.from
+	$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
+	  from: from
+	});
+	return es_array_from;
+}
+
+var from$4;
+var hasRequiredFrom$4;
+
+function requireFrom$4 () {
+	if (hasRequiredFrom$4) return from$4;
+	hasRequiredFrom$4 = 1;
+	requireEs_string_iterator();
+	requireEs_array_from();
+	var path = /*@__PURE__*/ requirePath();
+
+	from$4 = path.Array.from;
+	return from$4;
+}
+
+var from$3;
+var hasRequiredFrom$3;
+
+function requireFrom$3 () {
+	if (hasRequiredFrom$3) return from$3;
+	hasRequiredFrom$3 = 1;
+	var parent = /*@__PURE__*/ requireFrom$4();
+
+	from$3 = parent;
+	return from$3;
+}
+
+var from$2;
+var hasRequiredFrom$2;
+
+function requireFrom$2 () {
+	if (hasRequiredFrom$2) return from$2;
+	hasRequiredFrom$2 = 1;
+	var parent = /*@__PURE__*/ requireFrom$3();
+
+	from$2 = parent;
+	return from$2;
+}
+
+var from$1;
+var hasRequiredFrom$1;
+
+function requireFrom$1 () {
+	if (hasRequiredFrom$1) return from$1;
+	hasRequiredFrom$1 = 1;
+	var parent = /*@__PURE__*/ requireFrom$2();
+
+	from$1 = parent;
+	return from$1;
+}
+
+var from;
+var hasRequiredFrom;
+
+function requireFrom () {
+	if (hasRequiredFrom) return from;
+	hasRequiredFrom = 1;
+	from = /*@__PURE__*/ requireFrom$1();
+	return from;
+}
+
+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;
+}
+
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    var _context;
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = _sliceInstanceProperty$1(_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;
+  }
+}
+
+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 symbol;
+var hasRequiredSymbol;
+
+function requireSymbol () {
+	if (hasRequiredSymbol) return symbol;
+	hasRequiredSymbol = 1;
+	symbol = /*@__PURE__*/ requireSymbol$4();
+	return symbol;
+}
+
+var symbolExports = requireSymbol();
+var _Symbol = /*@__PURE__*/getDefaultExportFromCjs(symbolExports);
+
+var slice;
+var hasRequiredSlice;
+
+function requireSlice () {
+	if (hasRequiredSlice) return slice;
+	hasRequiredSlice = 1;
+	slice = /*@__PURE__*/ requireSlice$4();
+	return slice;
+}
+
+var sliceExports = requireSlice();
+var _sliceInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(sliceExports);
 
 var es_reflect_ownKeys = {};
 
@@ -5278,56 +6119,13 @@ function requireOwnKeys () {
 var ownKeysExports = requireOwnKeys();
 var _Reflect$ownKeys = /*@__PURE__*/getDefaultExportFromCjs(ownKeysExports);
 
-var es_array_isArray = {};
-
-var hasRequiredEs_array_isArray;
-
-function requireEs_array_isArray () {
-	if (hasRequiredEs_array_isArray) return es_array_isArray;
-	hasRequiredEs_array_isArray = 1;
-	var $ = /*@__PURE__*/ require_export();
-	var isArray = /*@__PURE__*/ requireIsArray$3();
-
-	// `Array.isArray` method
-	// https://tc39.es/ecma262/#sec-array.isarray
-	$({ target: 'Array', stat: true }, {
-	  isArray: isArray
-	});
-	return es_array_isArray;
-}
-
-var isArray$2;
-var hasRequiredIsArray$2;
-
-function requireIsArray$2 () {
-	if (hasRequiredIsArray$2) return isArray$2;
-	hasRequiredIsArray$2 = 1;
-	requireEs_array_isArray();
-	var path = /*@__PURE__*/ requirePath();
-
-	isArray$2 = path.Array.isArray;
-	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();
+	isArray = /*@__PURE__*/ requireIsArray$4();
 	return isArray;
 }
 
@@ -5508,7 +6306,7 @@ function requireEs_array_reverse () {
 	hasRequiredEs_array_reverse = 1;
 	var $ = /*@__PURE__*/ require_export();
 	var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
-	var isArray = /*@__PURE__*/ requireIsArray$3();
+	var isArray = /*@__PURE__*/ requireIsArray$6();
 
 	var nativeReverse = uncurryThis([].reverse);
 	var test = [1, 2];
@@ -5585,41 +6383,6 @@ var _reverseInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(reverseExpor
 
 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;
 
@@ -5683,7 +6446,7 @@ function requireEs_array_splice () {
 	      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;
@@ -6020,6 +6783,7 @@ function requireStringRepeat () {
 	var requireObjectCoercible = /*@__PURE__*/ requireRequireObjectCoercible();
 
 	var $RangeError = RangeError;
+	var floor = Math.floor;
 
 	// `String.prototype.repeat` method implementation
 	// https://tc39.es/ecma262/#sec-string.prototype.repeat
@@ -6028,7 +6792,7 @@ function requireStringRepeat () {
 	  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;
@@ -6056,9 +6820,10 @@ function requireStringPad () {
 	    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);
@@ -9776,11 +10541,11 @@ function requireGetOwnPropertyDescriptor$2 () {
 
 	var Object = path.Object;
 
-	var getOwnPropertyDescriptor = getOwnPropertyDescriptor$2.exports = function getOwnPropertyDescriptor(it, key) {
+	var $getOwnPropertyDescriptor = getOwnPropertyDescriptor$2.exports = function getOwnPropertyDescriptor(it, key) {
 	  return Object.getOwnPropertyDescriptor(it, key);
 	};
 
-	if (Object.getOwnPropertyDescriptor.sham) getOwnPropertyDescriptor.sham = true;
+	if (Object.getOwnPropertyDescriptor.sham) $getOwnPropertyDescriptor.sham = true;
 	return getOwnPropertyDescriptor$2.exports;
 }
 
@@ -9913,11 +10678,11 @@ function requireDefineProperties$2 () {
 
 	var Object = path.Object;
 
-	var defineProperties = defineProperties$2.exports = function defineProperties(T, D) {
+	var $defineProperties = defineProperties$2.exports = function defineProperties(T, D) {
 	  return Object.defineProperties(T, D);
 	};
 
-	if (Object.defineProperties.sham) defineProperties.sham = true;
+	if (Object.defineProperties.sham) $defineProperties.sham = true;
 	return defineProperties$2.exports;
 }
 
@@ -10090,6 +10855,7 @@ function requireInternalMetadata () {
 	  var getOwnPropertyNames = getOwnPropertyNamesModule.f;
 	  var splice = uncurryThis([].splice);
 	  var test = {};
+	  // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
 	  test[METADATA] = 1;
 
 	  // prevent exposing of metadata key
@@ -10121,101 +10887,6 @@ function requireInternalMetadata () {
 	return internalMetadata.exports;
 }
 
-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 getIteratorMethod;
-var hasRequiredGetIteratorMethod;
-
-function requireGetIteratorMethod () {
-	if (hasRequiredGetIteratorMethod) return getIteratorMethod;
-	hasRequiredGetIteratorMethod = 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 = function (it) {
-	  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
-	    || getMethod(it, '@@iterator')
-	    || Iterators[classof(it)];
-	};
-	return getIteratorMethod;
-}
-
-var getIterator$5;
-var hasRequiredGetIterator$6;
-
-function requireGetIterator$6 () {
-	if (hasRequiredGetIterator$6) return getIterator$5;
-	hasRequiredGetIterator$6 = 1;
-	var call = /*@__PURE__*/ requireFunctionCall();
-	var aCallable = /*@__PURE__*/ requireACallable();
-	var anObject = /*@__PURE__*/ requireAnObject();
-	var tryToString = /*@__PURE__*/ requireTryToString();
-	var getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod();
-
-	var $TypeError = TypeError;
-
-	getIterator$5 = 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 getIterator$5;
-}
-
-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 iterate;
 var hasRequiredIterate;
 
@@ -10230,7 +10901,7 @@ function requireIterate () {
 	var lengthOfArrayLike = /*@__PURE__*/ requireLengthOfArrayLike();
 	var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
 	var getIterator = /*@__PURE__*/ requireGetIterator$6();
-	var getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod();
+	var getIteratorMethod = /*@__PURE__*/ requireGetIteratorMethod$5();
 	var iteratorClose = /*@__PURE__*/ requireIteratorClose();
 
 	var $TypeError = TypeError;
@@ -10252,7 +10923,9 @@ function requireIterate () {
 	  var iterator, iterFn, index, length, result, next, step;
 
 	  var stop = function (condition) {
-	    if (iterator) iteratorClose(iterator, 'normal');
+	    var $iterator = iterator;
+	    iterator = undefined;
+	    if ($iterator) iteratorClose($iterator, 'normal');
 	    return new Result(true, condition);
 	  };
 
@@ -10282,10 +10955,13 @@ function requireIterate () {
 
 	  next = IS_RECORD ? iterable.next : iterator.next;
 	  while (!(step = call(next, iterator)).done) {
+	    // `IteratorValue` errors should propagate without closing the iterator
+	    var value = step.value;
 	    try {
-	      result = callFn(step.value);
+	      result = callFn(value);
 	    } catch (error) {
-	      iteratorClose(iterator, 'throw', error);
+	      if (iterator) iteratorClose(iterator, 'throw', error);
+	      else throw error;
 	    }
 	    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
 	  } return new Result(false);
@@ -10319,6 +10995,7 @@ function requireCollection () {
 	var $ = /*@__PURE__*/ require_export();
 	var globalThis = /*@__PURE__*/ requireGlobalThis();
 	var InternalMetadataModule = /*@__PURE__*/ requireInternalMetadata();
+	var call = /*@__PURE__*/ requireFunctionCall();
 	var fails = /*@__PURE__*/ requireFails();
 	var createNonEnumerableProperty = /*@__PURE__*/ requireCreateNonEnumerableProperty();
 	var iterate = /*@__PURE__*/ requireIterate();
@@ -10367,10 +11044,13 @@ function requireCollection () {
 	      var IS_ADDER = KEY === 'add' || KEY === 'set';
 	      if (KEY in NativePrototype && !(IS_WEAK && KEY === 'clear')) {
 	        createNonEnumerableProperty(Prototype, KEY, function (a, b) {
-	          var collection = getInternalState(this).collection;
+	          var that = this;
+	          var collection = getInternalState(that).collection;
 	          if (!IS_ADDER && IS_WEAK && !isObject(a)) return KEY === 'get' ? undefined : false;
-	          var result = collection[KEY](a === 0 ? 0 : a, b);
-	          return IS_ADDER ? this : result;
+	          var result = collection[KEY](KEY === 'forEach' ? function (value, key) {
+	            call(a, b, value, key, that);
+	          } : a === 0 ? 0 : a, b);
+	          return IS_ADDER ? that : result;
 	        });
 	      }
 	    });
@@ -10724,44 +11404,104 @@ function requireEs_map_groupBy () {
 	if (hasRequiredEs_map_groupBy) return es_map_groupBy;
 	hasRequiredEs_map_groupBy = 1;
 	var $ = /*@__PURE__*/ require_export();
-	var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
+	var uncurryThis = /*@__PURE__*/ requireFunctionUncurryThis();
+	var aCallable = /*@__PURE__*/ requireACallable();
+	var requireObjectCoercible = /*@__PURE__*/ requireRequireObjectCoercible();
+	var iterate = /*@__PURE__*/ requireIterate();
+	var MapHelpers = /*@__PURE__*/ requireMapHelpers();
+	var IS_PURE = /*@__PURE__*/ requireIsPure();
+	var fails = /*@__PURE__*/ requireFails();
+
+	var Map = MapHelpers.Map;
+	var has = MapHelpers.has;
+	var get = MapHelpers.get;
+	var set = MapHelpers.set;
+	var push = uncurryThis([].push);
+
+	// https://bugs.webkit.org/show_bug.cgi?id=271524
+	var DOES_NOT_WORK_WITH_PRIMITIVES = IS_PURE || fails(function () {
+	  return Map.groupBy('ab', function (it) {
+	    return it;
+	  }).get('a').length !== 1;
+	});
+
+	// `Map.groupBy` method
+	// https://tc39.es/ecma262/#sec-map.groupby
+	$({ target: 'Map', stat: true, forced: IS_PURE || DOES_NOT_WORK_WITH_PRIMITIVES }, {
+	  groupBy: function groupBy(items, callbackfn) {
+	    requireObjectCoercible(items);
+	    aCallable(callbackfn);
+	    var map = new Map();
+	    var k = 0;
+	    iterate(items, function (value) {
+	      var key = callbackfn(value, k++);
+	      if (!has(map, key)) set(map, key, [value]);
+	      else push(get(map, key), value);
+	    });
+	    return map;
+	  }
+	});
+	return es_map_groupBy;
+}
+
+var es_map_getOrInsert = {};
+
+var hasRequiredEs_map_getOrInsert;
+
+function requireEs_map_getOrInsert () {
+	if (hasRequiredEs_map_getOrInsert) return es_map_getOrInsert;
+	hasRequiredEs_map_getOrInsert = 1;
+	var $ = /*@__PURE__*/ require_export();
+	var MapHelpers = /*@__PURE__*/ requireMapHelpers();
+	var IS_PURE = /*@__PURE__*/ requireIsPure();
+
+	var get = MapHelpers.get;
+	var has = MapHelpers.has;
+	var set = MapHelpers.set;
+
+	// `Map.prototype.getOrInsert` method
+	// https://tc39.es/ecma262/#sec-map.prototype.getorinsert
+	$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
+	  getOrInsert: function getOrInsert(key, value) {
+	    if (has(this, key)) return get(this, key);
+	    set(this, key, value);
+	    return value;
+	  }
+	});
+	return es_map_getOrInsert;
+}
+
+var es_map_getOrInsertComputed = {};
+
+var hasRequiredEs_map_getOrInsertComputed;
+
+function requireEs_map_getOrInsertComputed () {
+	if (hasRequiredEs_map_getOrInsertComputed) return es_map_getOrInsertComputed;
+	hasRequiredEs_map_getOrInsertComputed = 1;
+	var $ = /*@__PURE__*/ require_export();
 	var aCallable = /*@__PURE__*/ requireACallable();
-	var requireObjectCoercible = /*@__PURE__*/ requireRequireObjectCoercible();
-	var iterate = /*@__PURE__*/ requireIterate();
 	var MapHelpers = /*@__PURE__*/ requireMapHelpers();
 	var IS_PURE = /*@__PURE__*/ requireIsPure();
-	var fails = /*@__PURE__*/ requireFails();
 
-	var Map = MapHelpers.Map;
-	var has = MapHelpers.has;
 	var get = MapHelpers.get;
+	var has = MapHelpers.has;
 	var set = MapHelpers.set;
-	var push = uncurryThis([].push);
 
-	// https://bugs.webkit.org/show_bug.cgi?id=271524
-	var DOES_NOT_WORK_WITH_PRIMITIVES = IS_PURE || fails(function () {
-	  return Map.groupBy('ab', function (it) {
-	    return it;
-	  }).get('a').length !== 1;
-	});
-
-	// `Map.groupBy` method
-	// https://tc39.es/ecma262/#sec-map.groupby
-	$({ target: 'Map', stat: true, forced: IS_PURE || DOES_NOT_WORK_WITH_PRIMITIVES }, {
-	  groupBy: function groupBy(items, callbackfn) {
-	    requireObjectCoercible(items);
+	// `Map.prototype.getOrInsertComputed` method
+	// https://tc39.es/ecma262/#sec-map.prototype.getorinsertcomputed
+	$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
+	  getOrInsertComputed: function getOrInsertComputed(key, callbackfn) {
+	    var hasKey = has(this, key);
 	    aCallable(callbackfn);
-	    var map = new Map();
-	    var k = 0;
-	    iterate(items, function (value) {
-	      var key = callbackfn(value, k++);
-	      if (!has(map, key)) set(map, key, [value]);
-	      else push(get(map, key), value);
-	    });
-	    return map;
+	    if (hasKey) return get(this, key);
+	    // CanonicalizeKeyedCollectionKey
+	    if (key === 0 && 1 / key === -Infinity) key = 0;
+	    var value = callbackfn(key);
+	    set(this, key, value);
+	    return value;
 	  }
 	});
-	return es_map_groupBy;
+	return es_map_getOrInsertComputed;
 }
 
 var map$2;
@@ -10773,6 +11513,8 @@ function requireMap$2 () {
 	requireEs_array_iterator();
 	requireEs_map();
 	requireEs_map_groupBy();
+	requireEs_map_getOrInsert();
+	requireEs_map_getOrInsertComputed();
 	requireEs_string_iterator();
 	var path = /*@__PURE__*/ requirePath();
 
@@ -11119,7 +11861,9 @@ function requireEs_array_sort () {
 	    if (y === undefined) return -1;
 	    if (x === undefined) return 1;
 	    if (comparefn !== undefined) return +comparefn(x, y) || 0;
-	    return toString(x) > toString(y) ? 1 : -1;
+	    var xString = toString(x);
+	    var yString = toString(y);
+	    return xString === yString ? 0 : xString > yString ? 1 : -1;
 	  };
 	};
 
@@ -11326,249 +12070,90 @@ function requireEntries$1 () {
 	var isPrototypeOf = /*@__PURE__*/ requireObjectIsPrototypeOf();
 	var method = /*@__PURE__*/ requireEntries$2();
 
-	var ArrayPrototype = Array.prototype;
-
-	var DOMIterables = {
-	  DOMTokenList: true,
-	  NodeList: true
-	};
-
-	entries$1 = function (it) {
-	  var own = it.entries;
-	  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.entries)
-	    || hasOwn(DOMIterables, classof(it)) ? method : own;
-	};
-	return entries$1;
-}
-
-var entries;
-var hasRequiredEntries;
-
-function requireEntries () {
-	if (hasRequiredEntries) return entries;
-	hasRequiredEntries = 1;
-	entries = /*@__PURE__*/ requireEntries$1();
-	return entries;
-}
-
-var entriesExports = requireEntries();
-var _entriesInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(entriesExports);
-
-const byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-    byteToHex.push((i + 0x100).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-    return (byteToHex[arr[offset + 0]] +
-        byteToHex[arr[offset + 1]] +
-        byteToHex[arr[offset + 2]] +
-        byteToHex[arr[offset + 3]] +
-        '-' +
-        byteToHex[arr[offset + 4]] +
-        byteToHex[arr[offset + 5]] +
-        '-' +
-        byteToHex[arr[offset + 6]] +
-        byteToHex[arr[offset + 7]] +
-        '-' +
-        byteToHex[arr[offset + 8]] +
-        byteToHex[arr[offset + 9]] +
-        '-' +
-        byteToHex[arr[offset + 10]] +
-        byteToHex[arr[offset + 11]] +
-        byteToHex[arr[offset + 12]] +
-        byteToHex[arr[offset + 13]] +
-        byteToHex[arr[offset + 14]] +
-        byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-const rnds8 = new Uint8Array(16);
-function rng() {
-    return crypto.getRandomValues(rnds8);
-}
-
-function v4(options, buf, offset) {
-    if (crypto.randomUUID) {
-        return crypto.randomUUID();
-    }
-    return _v4(options);
-}
-function _v4(options, buf, offset) {
-    options = options || {};
-    const rnds = options.random ?? options.rng?.() ?? rng();
-    if (rnds.length < 16) {
-        throw new Error('Random bytes length must be >= 16');
-    }
-    rnds[6] = (rnds[6] & 0x0f) | 0x40;
-    rnds[8] = (rnds[8] & 0x3f) | 0x80;
-    return unsafeStringify(rnds);
-}
-
-/**
- * Determine whether a value can be used as an id.
- * @param value - Input value of unknown type.
- * @returns True if the value is valid id, false otherwise.
- */
-function isId(value) {
-  return typeof value === "string" || typeof value === "number";
-}
-
-/**
- * A queue.
- * @typeParam T - The type of method names to be replaced by queued versions.
- */
-class Queue {
-  /**
-   * Construct a new Queue.
-   * @param options - Queue configuration.
-   */
-  constructor(options) {
-    /** Delay in milliseconds. If defined the queue will be periodically flushed. */
-    /** Maximum number of entries in the queue before it will be flushed. */
-    _defineProperty(this, "_queue", []);
-    _defineProperty(this, "_timeout", null);
-    _defineProperty(this, "_extended", null);
-    // options
-    this.delay = null;
-    this.max = Infinity;
-    this.setOptions(options);
-  }
-  /**
-   * Update the configuration of the queue.
-   * @param options - Queue configuration.
-   */
-  setOptions(options) {
-    if (options && typeof options.delay !== "undefined") {
-      this.delay = options.delay;
-    }
-    if (options && typeof options.max !== "undefined") {
-      this.max = options.max;
-    }
-    this._flushIfNeeded();
-  }
-  /**
-   * Extend an object with queuing functionality.
-   * The object will be extended with a function flush, and the methods provided in options.replace will be replaced with queued ones.
-   * @param object - The object to be extended.
-   * @param options - Additional options.
-   * @returns The created queue.
-   */
-  static extend(object, options) {
-    const queue = new Queue(options);
-    if (object.flush !== undefined) {
-      throw new Error("Target object already has a property flush");
-    }
-    object.flush = () => {
-      queue.flush();
-    };
-    const methods = [{
-      name: "flush",
-      original: undefined
-    }];
-    if (options && options.replace) {
-      for (let i = 0; i < options.replace.length; i++) {
-        const name = options.replace[i];
-        methods.push({
-          name: name,
-          // @TODO: better solution?
-          original: object[name]
-        });
-        // @TODO: better solution?
-        queue.replace(object, name);
-      }
-    }
-    queue._extended = {
-      object: object,
-      methods: methods
-    };
-    return queue;
-  }
-  /**
-   * Destroy the queue. The queue will first flush all queued actions, and in case it has extended an object, will restore the original object.
-   */
-  destroy() {
-    this.flush();
-    if (this._extended) {
-      const object = this._extended.object;
-      const methods = this._extended.methods;
-      for (let i = 0; i < methods.length; i++) {
-        const method = methods[i];
-        if (method.original) {
-          // @TODO: better solution?
-          object[method.name] = method.original;
-        } else {
-          // @TODO: better solution?
-          delete object[method.name];
-        }
-      }
-      this._extended = null;
-    }
-  }
-  /**
-   * Replace a method on an object with a queued version.
-   * @param object - Object having the method.
-   * @param method - The method name.
-   */
-  replace(object, method) {
-    /* eslint-disable-next-line @typescript-eslint/no-this-alias -- Function this is necessary in the function bellow, so class this has to be saved into a variable here. */
-    const me = this;
-    const original = object[method];
-    if (!original) {
-      throw new Error("Method " + method + " undefined");
-    }
-    object[method] = function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      // add this call to the queue
-      me.queue({
-        args: args,
-        fn: original,
-        context: this
-      });
-    };
-  }
-  /**
-   * Queue a call.
-   * @param entry - The function or entry to be queued.
-   */
-  queue(entry) {
-    if (typeof entry === "function") {
-      this._queue.push({
-        fn: entry
-      });
-    } else {
-      this._queue.push(entry);
-    }
-    this._flushIfNeeded();
-  }
-  /**
-   * Check whether the queue needs to be flushed.
-   */
-  _flushIfNeeded() {
-    // flush when the maximum is exceeded.
-    if (this._queue.length > this.max) {
-      this.flush();
-    }
-    // flush after a period of inactivity when a delay is configured
-    if (this._timeout != null) {
-      clearTimeout(this._timeout);
-      this._timeout = null;
+	var ArrayPrototype = Array.prototype;
+
+	var DOMIterables = {
+	  DOMTokenList: true,
+	  NodeList: true
+	};
+
+	entries$1 = function (it) {
+	  var own = it.entries;
+	  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.entries)
+	    || hasOwn(DOMIterables, classof(it)) ? method : own;
+	};
+	return entries$1;
+}
+
+var entries;
+var hasRequiredEntries;
+
+function requireEntries () {
+	if (hasRequiredEntries) return entries;
+	hasRequiredEntries = 1;
+	entries = /*@__PURE__*/ requireEntries$1();
+	return entries;
+}
+
+var entriesExports = requireEntries();
+var _entriesInstanceProperty = /*@__PURE__*/getDefaultExportFromCjs(entriesExports);
+
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+const rnds8 = new Uint8Array(16);
+function rng() {
+    return crypto.getRandomValues(rnds8);
+}
+
+function v4(options, buf, offset) {
+    if (crypto.randomUUID) {
+        return crypto.randomUUID();
     }
-    if (this.queue.length > 0 && typeof this.delay === "number") {
-      this._timeout = _setTimeout(() => {
-        this.flush();
-      }, this.delay);
+    return _v4(options);
+}
+function _v4(options, buf, offset) {
+    options = options || {};
+    const rnds = options.random ?? options.rng?.() ?? rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
     }
-  }
-  /**
-   * Flush all queued calls
-   */
-  flush() {
-    var _context, _context2;
-    _forEachInstanceProperty(_context = _spliceInstanceProperty(_context2 = this._queue).call(_context2, 0)).call(_context, entry => {
-      entry.fn.apply(entry.context || entry.fn, entry.args || []);
-    });
-  }
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    return unsafeStringify(rnds);
+}
+
+/**
+ * Determine whether a value can be used as an id.
+ * @param value - Input value of unknown type.
+ * @returns True if the value is valid id, false otherwise.
+ */
+function isId(value) {
+  return typeof value === "string" || typeof value === "number";
 }
 
 /**
@@ -11861,7 +12446,7 @@ function requireSetDifference () {
 	  var O = aSet(this);
 	  var otherRec = getSetRecord(other);
 	  var result = clone(O);
-	  if (size(O) <= otherRec.size) iterateSet(O, function (e) {
+	  if (size(result) <= otherRec.size) iterateSet(result, function (e) {
 	    if (otherRec.includes(e)) remove(result, e);
 	  });
 	  else iterateSimple(otherRec.getIterator(), function (e) {
@@ -12020,7 +12605,7 @@ function requireSetIsDisjointFrom () {
 	  }, true) !== false;
 	  var iterator = otherRec.getIterator();
 	  return iterateSimple(iterator, function (e) {
-	    if (has(O, e)) return iteratorClose(iterator, 'normal', false);
+	    if (has(O, e)) return iteratorClose(iterator.iterator, 'normal', false);
 	  }) !== false;
 	};
 	return setIsDisjointFrom;
@@ -12117,7 +12702,7 @@ function requireSetIsSupersetOf () {
 	  if (size(O) < otherRec.size) return false;
 	  var iterator = otherRec.getIterator();
 	  return iterateSimple(iterator, function (e) {
-	    if (!has(O, e)) return iteratorClose(iterator, 'normal', false);
+	    if (!has(O, e)) return iteratorClose(iterator.iterator, 'normal', false);
 	  }) !== false;
 	};
 	return setIsSupersetOf;
@@ -12425,7 +13010,10 @@ class DataStream {
    * Return an iterable of key, value pairs for every entry in the stream.
    */
   *[_Symbol$iterator]() {
-    for (const [id, item] of this._pairs) {
+    for (const _ref of this._pairs) {
+      var _ref2 = _slicedToArray(_ref, 2);
+      const id = _ref2[0];
+      const item = _ref2[1];
       yield [id, item];
     }
   }
@@ -12433,7 +13021,10 @@ class DataStream {
    * Return an iterable of key, value pairs for every entry in the stream.
    */
   *entries() {
-    for (const [id, item] of this._pairs) {
+    for (const _ref3 of this._pairs) {
+      var _ref4 = _slicedToArray(_ref3, 2);
+      const id = _ref4[0];
+      const item = _ref4[1];
       yield [id, item];
     }
   }
@@ -12441,7 +13032,9 @@ class DataStream {
    * Return an iterable of keys in the stream.
    */
   *keys() {
-    for (const [id] of this._pairs) {
+    for (const _ref5 of this._pairs) {
+      var _ref6 = _slicedToArray(_ref5, 1);
+      const id = _ref6[0];
       yield id;
     }
   }
@@ -12449,7 +13042,9 @@ class DataStream {
    * Return an iterable of values in the stream.
    */
   *values() {
-    for (const [, item] of this._pairs) {
+    for (const _ref7 of this._pairs) {
+      var _ref8 = _slicedToArray(_ref7, 2);
+      const item = _ref8[1];
       yield item;
     }
   }
@@ -12490,7 +13085,10 @@ class DataStream {
    */
   toObjectMap() {
     const map = _Object$create(null);
-    for (const [id, item] of this._pairs) {
+    for (const _ref9 of this._pairs) {
+      var _ref0 = _slicedToArray(_ref9, 2);
+      const id = _ref0[0];
+      const item = _ref0[1];
       map[id] = item;
     }
     return map;
@@ -12548,7 +13146,10 @@ class DataStream {
    */
   distinct(callback) {
     const set = new _Set();
-    for (const [id, item] of this._pairs) {
+    for (const _ref1 of this._pairs) {
+      var _ref10 = _slicedToArray(_ref1, 2);
+      const id = _ref10[0];
+      const item = _ref10[1];
       set.add(callback(item, id));
     }
     return set;
@@ -12562,7 +13163,10 @@ class DataStream {
     const pairs = this._pairs;
     return new DataStream({
       *[_Symbol$iterator]() {
-        for (const [id, item] of pairs) {
+        for (const _ref11 of pairs) {
+          var _ref12 = _slicedToArray(_ref11, 2);
+          const id = _ref12[0];
+          const item = _ref12[1];
           if (callback(item, id)) {
             yield [id, item];
           }
@@ -12575,7 +13179,10 @@ class DataStream {
    * @param callback - The function that will be invoked for each item.
    */
   forEach(callback) {
-    for (const [id, item] of this._pairs) {
+    for (const _ref13 of this._pairs) {
+      var _ref14 = _slicedToArray(_ref13, 2);
+      const id = _ref14[0];
+      const item = _ref14[1];
       callback(item, id);
     }
   }
@@ -12589,7 +13196,10 @@ class DataStream {
     const pairs = this._pairs;
     return new DataStream({
       *[_Symbol$iterator]() {
-        for (const [id, item] of pairs) {
+        for (const _ref15 of pairs) {
+          var _ref16 = _slicedToArray(_ref15, 2);
+          const id = _ref16[0];
+          const item = _ref16[1];
           yield [id, callback(item, id)];
         }
       }
@@ -12609,7 +13219,9 @@ class DataStream {
     let maxItem = curr.value[1];
     let maxValue = callback(curr.value[1], curr.value[0]);
     while (!(curr = iter.next()).done) {
-      const [id, item] = curr.value;
+      const _curr$value = _slicedToArray(curr.value, 2),
+        id = _curr$value[0],
+        item = _curr$value[1];
       const value = callback(item, id);
       if (value > maxValue) {
         maxValue = value;
@@ -12632,7 +13244,9 @@ class DataStream {
     let minItem = curr.value[1];
     let minValue = callback(curr.value[1], curr.value[0]);
     while (!(curr = iter.next()).done) {
-      const [id, item] = curr.value;
+      const _curr$value2 = _slicedToArray(curr.value, 2),
+        id = _curr$value2[0],
+        item = _curr$value2[1];
       const value = callback(item, id);
       if (value < minValue) {
         minValue = value;
@@ -12649,7 +13263,10 @@ class DataStream {
    * @returns The reduced value.
    */
   reduce(callback, accumulator) {
-    for (const [id, item] of this._pairs) {
+    for (const _ref17 of this._pairs) {
+      var _ref18 = _slicedToArray(_ref17, 2);
+      const id = _ref18[0];
+      const item = _ref18[1];
       accumulator = callback(accumulator, item, id);
     }
     return accumulator;
@@ -12661,14 +13278,174 @@ class DataStream {
    */
   sort(callback) {
     return new DataStream({
-      [_Symbol$iterator]: () => {
-        var _context3;
-        return _getIterator(_sortInstanceProperty(_context3 = [...this._pairs]).call(_context3, (_ref, _ref2) => {
-          let [idA, itemA] = _ref;
-          let [idB, itemB] = _ref2;
-          return callback(itemA, itemB, idA, idB);
-        }));
+      [_Symbol$iterator]: () => _getIterator([...this._pairs].toSorted((_ref19, _ref20) => {
+        let _ref21 = _slicedToArray(_ref19, 2),
+          idA = _ref21[0],
+          itemA = _ref21[1];
+        let _ref22 = _slicedToArray(_ref20, 2),
+          idB = _ref22[0],
+          itemB = _ref22[1];
+        return callback(itemA, itemB, idA, idB);
+      }))
+    });
+  }
+}
+
+/**
+ * A queue.
+ * @typeParam T - The type of method names to be replaced by queued versions.
+ */
+class Queue {
+  /**
+   * Construct a new Queue.
+   * @param options - Queue configuration.
+   */
+  constructor(options) {
+    /** Delay in milliseconds. If defined the queue will be periodically flushed. */
+    /** Maximum number of entries in the queue before it will be flushed. */
+    _defineProperty(this, "_queue", []);
+    _defineProperty(this, "_timeout", null);
+    _defineProperty(this, "_extended", null);
+    // options
+    this.delay = null;
+    this.max = Infinity;
+    this.setOptions(options);
+  }
+  /**
+   * Update the configuration of the queue.
+   * @param options - Queue configuration.
+   */
+  setOptions(options) {
+    if (options && typeof options.delay !== "undefined") {
+      this.delay = options.delay;
+    }
+    if (options && typeof options.max !== "undefined") {
+      this.max = options.max;
+    }
+    this._flushIfNeeded();
+  }
+  /**
+   * Extend an object with queuing functionality.
+   * The object will be extended with a function flush, and the methods provided in options.replace will be replaced with queued ones.
+   * @param object - The object to be extended.
+   * @param options - Additional options.
+   * @returns The created queue.
+   */
+  static extend(object, options) {
+    const queue = new Queue(options);
+    if (object.flush !== undefined) {
+      throw new Error("Target object already has a property flush");
+    }
+    object.flush = () => {
+      queue.flush();
+    };
+    const methods = [{
+      name: "flush",
+      original: undefined
+    }];
+    if (options && options.replace) {
+      for (let i = 0; i < options.replace.length; i++) {
+        const name = options.replace[i];
+        methods.push({
+          name: name,
+          // @TODO: better solution?
+          original: object[name]
+        });
+        // @TODO: better solution?
+        queue.replace(object, name);
+      }
+    }
+    queue._extended = {
+      object: object,
+      methods: methods
+    };
+    return queue;
+  }
+  /**
+   * Destroy the queue. The queue will first flush all queued actions, and in case it has extended an object, will restore the original object.
+   */
+  destroy() {
+    this.flush();
+    if (this._extended) {
+      const object = this._extended.object;
+      const methods = this._extended.methods;
+      for (let i = 0; i < methods.length; i++) {
+        const method = methods[i];
+        if (method.original) {
+          // @TODO: better solution?
+          object[method.name] = method.original;
+        } else {
+          // @TODO: better solution?
+          delete object[method.name];
+        }
+      }
+      this._extended = null;
+    }
+  }
+  /**
+   * Replace a method on an object with a queued version.
+   * @param object - Object having the method.
+   * @param method - The method name.
+   */
+  replace(object, method) {
+    /* eslint-disable-next-line @typescript-eslint/no-this-alias -- Function this is necessary in the function bellow, so class this has to be saved into a variable here. */
+    const me = this;
+    const original = object[method];
+    if (!original) {
+      throw new Error("Method " + method + " undefined");
+    }
+    object[method] = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
       }
+      // add this call to the queue
+      me.queue({
+        args: args,
+        fn: original,
+        context: this
+      });
+    };
+  }
+  /**
+   * Queue a call.
+   * @param entry - The function or entry to be queued.
+   */
+  queue(entry) {
+    if (typeof entry === "function") {
+      this._queue.push({
+        fn: entry
+      });
+    } else {
+      this._queue.push(entry);
+    }
+    this._flushIfNeeded();
+  }
+  /**
+   * Check whether the queue needs to be flushed.
+   */
+  _flushIfNeeded() {
+    // flush when the maximum is exceeded.
+    if (this._queue.length > this.max) {
+      this.flush();
+    }
+    // flush after a period of inactivity when a delay is configured
+    if (this._timeout != null) {
+      clearTimeout(this._timeout);
+      this._timeout = null;
+    }
+    if (this.queue.length > 0 && typeof this.delay === "number") {
+      this._timeout = _setTimeout(() => {
+        this.flush();
+      }, this.delay);
+    }
+  }
+  /**
+   * Flush all queued calls
+   */
+  flush() {
+    var _context, _context2;
+    _forEachInstanceProperty(_context = _spliceInstanceProperty(_context2 = this._queue).call(_context2, 0)).call(_context, entry => {
+      entry.fn.apply(entry.context || entry.fn, entry.args || []);
     });
   }
 }
@@ -12999,10 +13776,8 @@ class DataSet extends DataSetPart {
         update
       };
     })).call(_context, _ref => {
-      let {
-        oldData,
-        update
-      } = _ref;
+      let oldData = _ref.oldData,
+        update = _ref.update;
       const id = oldData[this._idProp];
       const updatedData = pureDeepObjectAssign(oldData, update);
       this._data.set(id, updatedData);