watermark-js-plus 1.6.0 → 1.6.2

package/dist/ie/es/node_modules/core-js/internals/promise-constructor-detection.js

@@ -0,0 +1,66 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requirePromiseNativeConstructor } from './promise-native-constructor.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireIsForced } from './is-forced.js';
+import { __require as requireInspectSource } from './inspect-source.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+import { __require as requireEnvironment } from './environment.js';
+import { __require as requireIsPure } from './is-pure.js';
+import { __require as requireEnvironmentV8Version } from './environment-v8-version.js';
+
+var promiseConstructorDetection;
+var hasRequiredPromiseConstructorDetection;
+
+function requirePromiseConstructorDetection () {
+	if (hasRequiredPromiseConstructorDetection) return promiseConstructorDetection;
+	hasRequiredPromiseConstructorDetection = 1;
+	var globalThis = requireGlobalThis();
+	var NativePromiseConstructor = requirePromiseNativeConstructor();
+	var isCallable = requireIsCallable();
+	var isForced = requireIsForced();
+	var inspectSource = requireInspectSource();
+	var wellKnownSymbol = requireWellKnownSymbol();
+	var ENVIRONMENT = requireEnvironment();
+	var IS_PURE = requireIsPure();
+	var V8_VERSION = requireEnvironmentV8Version();
+
+	var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+	var SPECIES = wellKnownSymbol('species');
+	var SUBCLASSING = false;
+	var NATIVE_PROMISE_REJECTION_EVENT = isCallable(globalThis.PromiseRejectionEvent);
+
+	var FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {
+	  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);
+	  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);
+	  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+	  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+	  // We can't detect it synchronously, so just check versions
+	  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
+	  // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution
+	  if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;
+	  // We can't use @@species feature detection in V8 since it causes
+	  // deoptimization and performance degradation
+	  // https://github.com/zloirock/core-js/issues/679
+	  if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
+	    // Detect correctness of subclassing with @@species support
+	    var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });
+	    var FakePromise = function (exec) {
+	      exec(function () { /* empty */ }, function () { /* empty */ });
+	    };
+	    var constructor = promise.constructor = {};
+	    constructor[SPECIES] = FakePromise;
+	    SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
+	    if (!SUBCLASSING) return true;
+	  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+	  } return !GLOBAL_CORE_JS_PROMISE && (ENVIRONMENT === 'BROWSER' || ENVIRONMENT === 'DENO') && !NATIVE_PROMISE_REJECTION_EVENT;
+	});
+
+	promiseConstructorDetection = {
+	  CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,
+	  REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,
+	  SUBCLASSING: SUBCLASSING
+	};
+	return promiseConstructorDetection;
+}
+
+export { requirePromiseConstructorDetection as __require };

package/dist/ie/es/node_modules/core-js/internals/promise-native-constructor.js

@@ -0,0 +1,15 @@
+import { __require as requireGlobalThis } from './global-this.js';
+
+var promiseNativeConstructor;
+var hasRequiredPromiseNativeConstructor;
+
+function requirePromiseNativeConstructor () {
+	if (hasRequiredPromiseNativeConstructor) return promiseNativeConstructor;
+	hasRequiredPromiseNativeConstructor = 1;
+	var globalThis = requireGlobalThis();
+
+	promiseNativeConstructor = globalThis.Promise;
+	return promiseNativeConstructor;
+}
+
+export { requirePromiseNativeConstructor as __require };

package/dist/ie/es/node_modules/core-js/internals/promise-resolve.js

@@ -0,0 +1,26 @@
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireIsObject } from './is-object.js';
+import { __require as requireNewPromiseCapability } from './new-promise-capability.js';
+
+var promiseResolve;
+var hasRequiredPromiseResolve;
+
+function requirePromiseResolve () {
+	if (hasRequiredPromiseResolve) return promiseResolve;
+	hasRequiredPromiseResolve = 1;
+	var anObject = requireAnObject();
+	var isObject = requireIsObject();
+	var newPromiseCapability = requireNewPromiseCapability();
+
+	promiseResolve = function (C, x) {
+	  anObject(C);
+	  if (isObject(x) && x.constructor === C) return x;
+	  var promiseCapability = newPromiseCapability.f(C);
+	  var resolve = promiseCapability.resolve;
+	  resolve(x);
+	  return promiseCapability.promise;
+	};
+	return promiseResolve;
+}
+
+export { requirePromiseResolve as __require };

package/dist/ie/es/node_modules/core-js/internals/promise-statics-incorrect-iteration.js

@@ -0,0 +1,21 @@
+import { __require as requirePromiseNativeConstructor } from './promise-native-constructor.js';
+import { __require as requireCheckCorrectnessOfIteration } from './check-correctness-of-iteration.js';
+import { __require as requirePromiseConstructorDetection } from './promise-constructor-detection.js';
+
+var promiseStaticsIncorrectIteration;
+var hasRequiredPromiseStaticsIncorrectIteration;
+
+function requirePromiseStaticsIncorrectIteration () {
+	if (hasRequiredPromiseStaticsIncorrectIteration) return promiseStaticsIncorrectIteration;
+	hasRequiredPromiseStaticsIncorrectIteration = 1;
+	var NativePromiseConstructor = requirePromiseNativeConstructor();
+	var checkCorrectnessOfIteration = requireCheckCorrectnessOfIteration();
+	var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+
+	promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {
+	  NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });
+	});
+	return promiseStaticsIncorrectIteration;
+}
+
+export { requirePromiseStaticsIncorrectIteration as __require };

package/dist/ie/es/node_modules/core-js/internals/queue.js

@@ -0,0 +1,34 @@
+var queue;
+var hasRequiredQueue;
+
+function requireQueue () {
+	if (hasRequiredQueue) return queue;
+	hasRequiredQueue = 1;
+	var Queue = function () {
+	  this.head = null;
+	  this.tail = null;
+	};
+
+	Queue.prototype = {
+	  add: function (item) {
+	    var entry = { item: item, next: null };
+	    var tail = this.tail;
+	    if (tail) tail.next = entry;
+	    else this.head = entry;
+	    this.tail = entry;
+	  },
+	  get: function () {
+	    var entry = this.head;
+	    if (entry) {
+	      var next = this.head = entry.next;
+	      if (next === null) this.tail = null;
+	      return entry.item;
+	    }
+	  }
+	};
+
+	queue = Queue;
+	return queue;
+}
+
+export { requireQueue as __require };

package/dist/ie/es/node_modules/core-js/internals/require-object-coercible.js

@@ -0,0 +1,22 @@
+import { __require as requireIsNullOrUndefined } from './is-null-or-undefined.js';
+
+var requireObjectCoercible;
+var hasRequiredRequireObjectCoercible;
+
+function requireRequireObjectCoercible () {
+	if (hasRequiredRequireObjectCoercible) return requireObjectCoercible;
+	hasRequiredRequireObjectCoercible = 1;
+	var isNullOrUndefined = requireIsNullOrUndefined();
+
+	var $TypeError = TypeError;
+
+	// `RequireObjectCoercible` abstract operation
+	// https://tc39.es/ecma262/#sec-requireobjectcoercible
+	requireObjectCoercible = function (it) {
+	  if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
+	  return it;
+	};
+	return requireObjectCoercible;
+}
+
+export { requireRequireObjectCoercible as __require };

package/dist/ie/es/node_modules/core-js/internals/safe-get-built-in.js

@@ -0,0 +1,25 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireDescriptors } from './descriptors.js';
+
+var safeGetBuiltIn;
+var hasRequiredSafeGetBuiltIn;
+
+function requireSafeGetBuiltIn () {
+	if (hasRequiredSafeGetBuiltIn) return safeGetBuiltIn;
+	hasRequiredSafeGetBuiltIn = 1;
+	var globalThis = requireGlobalThis();
+	var DESCRIPTORS = requireDescriptors();
+
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+	// Avoid NodeJS experimental warning
+	safeGetBuiltIn = function (name) {
+	  if (!DESCRIPTORS) return globalThis[name];
+	  var descriptor = getOwnPropertyDescriptor(globalThis, name);
+	  return descriptor && descriptor.value;
+	};
+	return safeGetBuiltIn;
+}
+
+export { requireSafeGetBuiltIn as __require };

package/dist/ie/es/node_modules/core-js/internals/set-species.js

@@ -0,0 +1,32 @@
+import { __require as requireGetBuiltIn } from './get-built-in.js';
+import { __require as requireDefineBuiltInAccessor } from './define-built-in-accessor.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+import { __require as requireDescriptors } from './descriptors.js';
+
+var setSpecies;
+var hasRequiredSetSpecies;
+
+function requireSetSpecies () {
+	if (hasRequiredSetSpecies) return setSpecies;
+	hasRequiredSetSpecies = 1;
+	var getBuiltIn = requireGetBuiltIn();
+	var defineBuiltInAccessor = requireDefineBuiltInAccessor();
+	var wellKnownSymbol = requireWellKnownSymbol();
+	var DESCRIPTORS = requireDescriptors();
+
+	var SPECIES = wellKnownSymbol('species');
+
+	setSpecies = function (CONSTRUCTOR_NAME) {
+	  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
+
+	  if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
+	    defineBuiltInAccessor(Constructor, SPECIES, {
+	      configurable: true,
+	      get: function () { return this; }
+	    });
+	  }
+	};
+	return setSpecies;
+}
+
+export { requireSetSpecies as __require };

package/dist/ie/es/node_modules/core-js/internals/set-to-string-tag.js

@@ -0,0 +1,26 @@
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var setToStringTag;
+var hasRequiredSetToStringTag;
+
+function requireSetToStringTag () {
+	if (hasRequiredSetToStringTag) return setToStringTag;
+	hasRequiredSetToStringTag = 1;
+	var defineProperty = requireObjectDefineProperty().f;
+	var hasOwn = requireHasOwnProperty();
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+
+	setToStringTag = function (target, TAG, STATIC) {
+	  if (target && !STATIC) target = target.prototype;
+	  if (target && !hasOwn(target, TO_STRING_TAG)) {
+	    defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
+	  }
+	};
+	return setToStringTag;
+}
+
+export { requireSetToStringTag as __require };

package/dist/ie/es/node_modules/core-js/internals/shared-key.js

@@ -0,0 +1,21 @@
+import { __require as requireShared } from './shared.js';
+import { __require as requireUid } from './uid.js';
+
+var sharedKey;
+var hasRequiredSharedKey;
+
+function requireSharedKey () {
+	if (hasRequiredSharedKey) return sharedKey;
+	hasRequiredSharedKey = 1;
+	var shared = requireShared();
+	var uid = requireUid();
+
+	var keys = shared('keys');
+
+	sharedKey = function (key) {
+	  return keys[key] || (keys[key] = uid(key));
+	};
+	return sharedKey;
+}
+
+export { requireSharedKey as __require };

package/dist/ie/es/node_modules/core-js/internals/shared-store.js

@@ -0,0 +1,28 @@
+import { __module as sharedStore } from '../../../_virtual/shared-store.js';
+import { __require as requireIsPure } from './is-pure.js';
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireDefineGlobalProperty } from './define-global-property.js';
+
+var hasRequiredSharedStore;
+
+function requireSharedStore () {
+	if (hasRequiredSharedStore) return sharedStore.exports;
+	hasRequiredSharedStore = 1;
+	var IS_PURE = requireIsPure();
+	var globalThis = requireGlobalThis();
+	var defineGlobalProperty = requireDefineGlobalProperty();
+
+	var SHARED = '__core-js_shared__';
+	var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
+
+	(store.versions || (store.versions = [])).push({
+	  version: '3.42.0',
+	  mode: IS_PURE ? 'pure' : 'global',
+	  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
+	  license: 'https://github.com/zloirock/core-js/blob/v3.42.0/LICENSE',
+	  source: 'https://github.com/zloirock/core-js'
+	});
+	return sharedStore.exports;
+}
+
+export { requireSharedStore as __require };

package/dist/ie/es/node_modules/core-js/internals/shared.js

@@ -0,0 +1,17 @@
+import { __require as requireSharedStore } from './shared-store.js';
+
+var shared;
+var hasRequiredShared;
+
+function requireShared () {
+	if (hasRequiredShared) return shared;
+	hasRequiredShared = 1;
+	var store = requireSharedStore();
+
+	shared = function (key, value) {
+	  return store[key] || (store[key] = value || {});
+	};
+	return shared;
+}
+
+export { requireShared as __require };

package/dist/ie/es/node_modules/core-js/internals/species-constructor.js

@@ -0,0 +1,29 @@
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireAConstructor } from './a-constructor.js';
+import { __require as requireIsNullOrUndefined } from './is-null-or-undefined.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var speciesConstructor;
+var hasRequiredSpeciesConstructor;
+
+function requireSpeciesConstructor () {
+	if (hasRequiredSpeciesConstructor) return speciesConstructor;
+	hasRequiredSpeciesConstructor = 1;
+	var anObject = requireAnObject();
+	var aConstructor = requireAConstructor();
+	var isNullOrUndefined = requireIsNullOrUndefined();
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var SPECIES = wellKnownSymbol('species');
+
+	// `SpeciesConstructor` abstract operation
+	// https://tc39.es/ecma262/#sec-speciesconstructor
+	speciesConstructor = function (O, defaultConstructor) {
+	  var C = anObject(O).constructor;
+	  var S;
+	  return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);
+	};
+	return speciesConstructor;
+}
+
+export { requireSpeciesConstructor as __require };

package/dist/ie/es/node_modules/core-js/internals/symbol-constructor-detection.js

@@ -0,0 +1,32 @@
+import { __require as requireEnvironmentV8Version } from './environment-v8-version.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireGlobalThis } from './global-this.js';
+
+var symbolConstructorDetection;
+var hasRequiredSymbolConstructorDetection;
+
+function requireSymbolConstructorDetection () {
+	if (hasRequiredSymbolConstructorDetection) return symbolConstructorDetection;
+	hasRequiredSymbolConstructorDetection = 1;
+	/* eslint-disable es/no-symbol -- required for testing */
+	var V8_VERSION = requireEnvironmentV8Version();
+	var fails = requireFails();
+	var globalThis = requireGlobalThis();
+
+	var $String = globalThis.String;
+
+	// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+	symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails(function () {
+	  var symbol = Symbol('symbol detection');
+	  // Chrome 38 Symbol has incorrect toString conversion
+	  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+	  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
+	  // of course, fail.
+	  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
+	    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+	    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+	});
+	return symbolConstructorDetection;
+}
+
+export { requireSymbolConstructorDetection as __require };

package/dist/ie/es/node_modules/core-js/internals/task.js

@@ -0,0 +1,139 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireFunctionApply } from './function-apply.js';
+import { __require as requireFunctionBindContext } from './function-bind-context.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireHtml } from './html.js';
+import { __require as requireArraySlice } from './array-slice.js';
+import { __require as requireDocumentCreateElement } from './document-create-element.js';
+import { __require as requireValidateArgumentsLength } from './validate-arguments-length.js';
+import { __require as requireEnvironmentIsIos } from './environment-is-ios.js';
+import { __require as requireEnvironmentIsNode } from './environment-is-node.js';
+
+var task;
+var hasRequiredTask;
+
+function requireTask () {
+	if (hasRequiredTask) return task;
+	hasRequiredTask = 1;
+	var globalThis = requireGlobalThis();
+	var apply = requireFunctionApply();
+	var bind = requireFunctionBindContext();
+	var isCallable = requireIsCallable();
+	var hasOwn = requireHasOwnProperty();
+	var fails = requireFails();
+	var html = requireHtml();
+	var arraySlice = requireArraySlice();
+	var createElement = requireDocumentCreateElement();
+	var validateArgumentsLength = requireValidateArgumentsLength();
+	var IS_IOS = requireEnvironmentIsIos();
+	var IS_NODE = requireEnvironmentIsNode();
+
+	var set = globalThis.setImmediate;
+	var clear = globalThis.clearImmediate;
+	var process = globalThis.process;
+	var Dispatch = globalThis.Dispatch;
+	var Function = globalThis.Function;
+	var MessageChannel = globalThis.MessageChannel;
+	var String = globalThis.String;
+	var counter = 0;
+	var queue = {};
+	var ONREADYSTATECHANGE = 'onreadystatechange';
+	var $location, defer, channel, port;
+
+	fails(function () {
+	  // Deno throws a ReferenceError on `location` access without `--location` flag
+	  $location = globalThis.location;
+	});
+
+	var run = function (id) {
+	  if (hasOwn(queue, id)) {
+	    var fn = queue[id];
+	    delete queue[id];
+	    fn();
+	  }
+	};
+
+	var runner = function (id) {
+	  return function () {
+	    run(id);
+	  };
+	};
+
+	var eventListener = function (event) {
+	  run(event.data);
+	};
+
+	var globalPostMessageDefer = function (id) {
+	  // old engines have not location.origin
+	  globalThis.postMessage(String(id), $location.protocol + '//' + $location.host);
+	};
+
+	// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+	if (!set || !clear) {
+	  set = function setImmediate(handler) {
+	    validateArgumentsLength(arguments.length, 1);
+	    var fn = isCallable(handler) ? handler : Function(handler);
+	    var args = arraySlice(arguments, 1);
+	    queue[++counter] = function () {
+	      apply(fn, undefined, args);
+	    };
+	    defer(counter);
+	    return counter;
+	  };
+	  clear = function clearImmediate(id) {
+	    delete queue[id];
+	  };
+	  // Node.js 0.8-
+	  if (IS_NODE) {
+	    defer = function (id) {
+	      process.nextTick(runner(id));
+	    };
+	  // Sphere (JS game engine) Dispatch API
+	  } else if (Dispatch && Dispatch.now) {
+	    defer = function (id) {
+	      Dispatch.now(runner(id));
+	    };
+	  // Browsers with MessageChannel, includes WebWorkers
+	  // except iOS - https://github.com/zloirock/core-js/issues/624
+	  } else if (MessageChannel && !IS_IOS) {
+	    channel = new MessageChannel();
+	    port = channel.port2;
+	    channel.port1.onmessage = eventListener;
+	    defer = bind(port.postMessage, port);
+	  // Browsers with postMessage, skip WebWorkers
+	  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+	  } else if (
+	    globalThis.addEventListener &&
+	    isCallable(globalThis.postMessage) &&
+	    !globalThis.importScripts &&
+	    $location && $location.protocol !== 'file:' &&
+	    !fails(globalPostMessageDefer)
+	  ) {
+	    defer = globalPostMessageDefer;
+	    globalThis.addEventListener('message', eventListener, false);
+	  // IE8-
+	  } else if (ONREADYSTATECHANGE in createElement('script')) {
+	    defer = function (id) {
+	      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
+	        html.removeChild(this);
+	        run(id);
+	      };
+	    };
+	  // Rest old browsers
+	  } else {
+	    defer = function (id) {
+	      setTimeout(runner(id), 0);
+	    };
+	  }
+	}
+
+	task = {
+	  set: set,
+	  clear: clear
+	};
+	return task;
+}
+
+export { requireTask as __require };

package/dist/ie/es/node_modules/core-js/internals/to-absolute-index.js

@@ -0,0 +1,24 @@
+import { __require as requireToIntegerOrInfinity } from './to-integer-or-infinity.js';
+
+var toAbsoluteIndex;
+var hasRequiredToAbsoluteIndex;
+
+function requireToAbsoluteIndex () {
+	if (hasRequiredToAbsoluteIndex) return toAbsoluteIndex;
+	hasRequiredToAbsoluteIndex = 1;
+	var toIntegerOrInfinity = requireToIntegerOrInfinity();
+
+	var max = Math.max;
+	var min = Math.min;
+
+	// Helper for a popular repeating case of the spec:
+	// Let integer be ? ToInteger(index).
+	// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+	toAbsoluteIndex = function (index, length) {
+	  var integer = toIntegerOrInfinity(index);
+	  return integer < 0 ? max(integer + length, 0) : min(integer, length);
+	};
+	return toAbsoluteIndex;
+}
+
+export { requireToAbsoluteIndex as __require };

package/dist/ie/es/node_modules/core-js/internals/to-indexed-object.js

@@ -0,0 +1,20 @@
+import { __require as requireIndexedObject } from './indexed-object.js';
+import { __require as requireRequireObjectCoercible } from './require-object-coercible.js';
+
+var toIndexedObject;
+var hasRequiredToIndexedObject;
+
+function requireToIndexedObject () {
+	if (hasRequiredToIndexedObject) return toIndexedObject;
+	hasRequiredToIndexedObject = 1;
+	// toObject with fallback for non-array-like ES3 strings
+	var IndexedObject = requireIndexedObject();
+	var requireObjectCoercible = requireRequireObjectCoercible();
+
+	toIndexedObject = function (it) {
+	  return IndexedObject(requireObjectCoercible(it));
+	};
+	return toIndexedObject;
+}
+
+export { requireToIndexedObject as __require };

package/dist/ie/es/node_modules/core-js/internals/to-integer-or-infinity.js

@@ -0,0 +1,21 @@
+import { __require as requireMathTrunc } from './math-trunc.js';
+
+var toIntegerOrInfinity;
+var hasRequiredToIntegerOrInfinity;
+
+function requireToIntegerOrInfinity () {
+	if (hasRequiredToIntegerOrInfinity) return toIntegerOrInfinity;
+	hasRequiredToIntegerOrInfinity = 1;
+	var trunc = requireMathTrunc();
+
+	// `ToIntegerOrInfinity` abstract operation
+	// https://tc39.es/ecma262/#sec-tointegerorinfinity
+	toIntegerOrInfinity = function (argument) {
+	  var number = +argument;
+	  // eslint-disable-next-line no-self-compare -- NaN check
+	  return number !== number || number === 0 ? 0 : trunc(number);
+	};
+	return toIntegerOrInfinity;
+}
+
+export { requireToIntegerOrInfinity as __require };

package/dist/ie/es/node_modules/core-js/internals/to-length.js

@@ -0,0 +1,22 @@
+import { __require as requireToIntegerOrInfinity } from './to-integer-or-infinity.js';
+
+var toLength;
+var hasRequiredToLength;
+
+function requireToLength () {
+	if (hasRequiredToLength) return toLength;
+	hasRequiredToLength = 1;
+	var toIntegerOrInfinity = requireToIntegerOrInfinity();
+
+	var min = Math.min;
+
+	// `ToLength` abstract operation
+	// https://tc39.es/ecma262/#sec-tolength
+	toLength = function (argument) {
+	  var len = toIntegerOrInfinity(argument);
+	  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+	};
+	return toLength;
+}
+
+export { requireToLength as __require };

package/dist/ie/es/node_modules/core-js/internals/to-object.js

@@ -0,0 +1,21 @@
+import { __require as requireRequireObjectCoercible } from './require-object-coercible.js';
+
+var toObject;
+var hasRequiredToObject;
+
+function requireToObject () {
+	if (hasRequiredToObject) return toObject;
+	hasRequiredToObject = 1;
+	var requireObjectCoercible = requireRequireObjectCoercible();
+
+	var $Object = Object;
+
+	// `ToObject` abstract operation
+	// https://tc39.es/ecma262/#sec-toobject
+	toObject = function (argument) {
+	  return $Object(requireObjectCoercible(argument));
+	};
+	return toObject;
+}
+
+export { requireToObject as __require };