watermark-js-plus 1.6.0 → 1.6.2

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

@@ -0,0 +1,98 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireSafeGetBuiltIn } from './safe-get-built-in.js';
+import { __require as requireFunctionBindContext } from './function-bind-context.js';
+import { __require as requireTask } from './task.js';
+import { __require as requireQueue } from './queue.js';
+import { __require as requireEnvironmentIsIos } from './environment-is-ios.js';
+import { __require as requireEnvironmentIsIosPebble } from './environment-is-ios-pebble.js';
+import { __require as requireEnvironmentIsWebosWebkit } from './environment-is-webos-webkit.js';
+import { __require as requireEnvironmentIsNode } from './environment-is-node.js';
+
+var microtask_1;
+var hasRequiredMicrotask;
+
+function requireMicrotask () {
+	if (hasRequiredMicrotask) return microtask_1;
+	hasRequiredMicrotask = 1;
+	var globalThis = requireGlobalThis();
+	var safeGetBuiltIn = requireSafeGetBuiltIn();
+	var bind = requireFunctionBindContext();
+	var macrotask = requireTask().set;
+	var Queue = requireQueue();
+	var IS_IOS = requireEnvironmentIsIos();
+	var IS_IOS_PEBBLE = requireEnvironmentIsIosPebble();
+	var IS_WEBOS_WEBKIT = requireEnvironmentIsWebosWebkit();
+	var IS_NODE = requireEnvironmentIsNode();
+
+	var MutationObserver = globalThis.MutationObserver || globalThis.WebKitMutationObserver;
+	var document = globalThis.document;
+	var process = globalThis.process;
+	var Promise = globalThis.Promise;
+	var microtask = safeGetBuiltIn('queueMicrotask');
+	var notify, toggle, node, promise, then;
+
+	// modern engines have queueMicrotask method
+	if (!microtask) {
+	  var queue = new Queue();
+
+	  var flush = function () {
+	    var parent, fn;
+	    if (IS_NODE && (parent = process.domain)) parent.exit();
+	    while (fn = queue.get()) try {
+	      fn();
+	    } catch (error) {
+	      if (queue.head) notify();
+	      throw error;
+	    }
+	    if (parent) parent.enter();
+	  };
+
+	  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
+	  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
+	  if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {
+	    toggle = true;
+	    node = document.createTextNode('');
+	    new MutationObserver(flush).observe(node, { characterData: true });
+	    notify = function () {
+	      node.data = toggle = !toggle;
+	    };
+	  // environments with maybe non-completely correct, but existent Promise
+	  } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {
+	    // Promise.resolve without an argument throws an error in LG WebOS 2
+	    promise = Promise.resolve(undefined);
+	    // workaround of WebKit ~ iOS Safari 10.1 bug
+	    promise.constructor = Promise;
+	    then = bind(promise.then, promise);
+	    notify = function () {
+	      then(flush);
+	    };
+	  // Node.js without promises
+	  } else if (IS_NODE) {
+	    notify = function () {
+	      process.nextTick(flush);
+	    };
+	  // for other environments - macrotask based on:
+	  // - setImmediate
+	  // - MessageChannel
+	  // - window.postMessage
+	  // - onreadystatechange
+	  // - setTimeout
+	  } else {
+	    // `webpack` dev server bug on IE global methods - use bind(fn, global)
+	    macrotask = bind(macrotask, globalThis);
+	    notify = function () {
+	      macrotask(flush);
+	    };
+	  }
+
+	  microtask = function (fn) {
+	    if (!queue.head) notify();
+	    queue.add(fn);
+	  };
+	}
+
+	microtask_1 = microtask;
+	return microtask_1;
+}
+
+export { requireMicrotask as __require };

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

@@ -0,0 +1,32 @@
+import { __exports as newPromiseCapability } from '../../../_virtual/new-promise-capability.js';
+import { __require as requireACallable } from './a-callable.js';
+
+var hasRequiredNewPromiseCapability;
+
+function requireNewPromiseCapability () {
+	if (hasRequiredNewPromiseCapability) return newPromiseCapability;
+	hasRequiredNewPromiseCapability = 1;
+	var aCallable = requireACallable();
+
+	var $TypeError = TypeError;
+
+	var PromiseCapability = function (C) {
+	  var resolve, reject;
+	  this.promise = new C(function ($$resolve, $$reject) {
+	    if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');
+	    resolve = $$resolve;
+	    reject = $$reject;
+	  });
+	  this.resolve = aCallable(resolve);
+	  this.reject = aCallable(reject);
+	};
+
+	// `NewPromiseCapability` abstract operation
+	// https://tc39.es/ecma262/#sec-newpromisecapability
+	newPromiseCapability.f = function (C) {
+	  return new PromiseCapability(C);
+	};
+	return newPromiseCapability;
+}
+
+export { requireNewPromiseCapability as __require };

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

@@ -0,0 +1,102 @@
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireObjectDefineProperties } from './object-define-properties.js';
+import { __require as requireEnumBugKeys } from './enum-bug-keys.js';
+import { __require as requireHiddenKeys } from './hidden-keys.js';
+import { __require as requireHtml } from './html.js';
+import { __require as requireDocumentCreateElement } from './document-create-element.js';
+import { __require as requireSharedKey } from './shared-key.js';
+
+var objectCreate;
+var hasRequiredObjectCreate;
+
+function requireObjectCreate () {
+	if (hasRequiredObjectCreate) return objectCreate;
+	hasRequiredObjectCreate = 1;
+	/* global ActiveXObject -- old IE, WSH */
+	var anObject = requireAnObject();
+	var definePropertiesModule = requireObjectDefineProperties();
+	var enumBugKeys = requireEnumBugKeys();
+	var hiddenKeys = requireHiddenKeys();
+	var html = requireHtml();
+	var documentCreateElement = requireDocumentCreateElement();
+	var sharedKey = requireSharedKey();
+
+	var GT = '>';
+	var LT = '<';
+	var PROTOTYPE = 'prototype';
+	var SCRIPT = 'script';
+	var IE_PROTO = sharedKey('IE_PROTO');
+
+	var EmptyConstructor = function () { /* empty */ };
+
+	var scriptTag = function (content) {
+	  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+	};
+
+	// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+	var NullProtoObjectViaActiveX = function (activeXDocument) {
+	  activeXDocument.write(scriptTag(''));
+	  activeXDocument.close();
+	  var temp = activeXDocument.parentWindow.Object;
+	  // eslint-disable-next-line no-useless-assignment -- avoid memory leak
+	  activeXDocument = null;
+	  return temp;
+	};
+
+	// Create object with fake `null` prototype: use iframe Object with cleared prototype
+	var NullProtoObjectViaIFrame = function () {
+	  // Thrash, waste and sodomy: IE GC bug
+	  var iframe = documentCreateElement('iframe');
+	  var JS = 'java' + SCRIPT + ':';
+	  var iframeDocument;
+	  iframe.style.display = 'none';
+	  html.appendChild(iframe);
+	  // https://github.com/zloirock/core-js/issues/475
+	  iframe.src = String(JS);
+	  iframeDocument = iframe.contentWindow.document;
+	  iframeDocument.open();
+	  iframeDocument.write(scriptTag('document.F=Object'));
+	  iframeDocument.close();
+	  return iframeDocument.F;
+	};
+
+	// Check for document.domain and active x support
+	// No need to use active x approach when document.domain is not set
+	// see https://github.com/es-shims/es5-shim/issues/150
+	// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+	// avoid IE GC bug
+	var activeXDocument;
+	var NullProtoObject = function () {
+	  try {
+	    activeXDocument = new ActiveXObject('htmlfile');
+	  } catch (error) { /* ignore */ }
+	  NullProtoObject = typeof document != 'undefined'
+	    ? document.domain && activeXDocument
+	      ? NullProtoObjectViaActiveX(activeXDocument) // old IE
+	      : NullProtoObjectViaIFrame()
+	    : NullProtoObjectViaActiveX(activeXDocument); // WSH
+	  var length = enumBugKeys.length;
+	  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+	  return NullProtoObject();
+	};
+
+	hiddenKeys[IE_PROTO] = true;
+
+	// `Object.create` method
+	// https://tc39.es/ecma262/#sec-object.create
+	// eslint-disable-next-line es/no-object-create -- safe
+	objectCreate = Object.create || function create(O, Properties) {
+	  var result;
+	  if (O !== null) {
+	    EmptyConstructor[PROTOTYPE] = anObject(O);
+	    result = new EmptyConstructor();
+	    EmptyConstructor[PROTOTYPE] = null;
+	    // add "__proto__" for Object.getPrototypeOf polyfill
+	    result[IE_PROTO] = O;
+	  } else result = NullProtoObject();
+	  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
+	};
+	return objectCreate;
+}
+
+export { requireObjectCreate as __require };

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

@@ -0,0 +1,37 @@
+import { __exports as objectDefineProperties } from '../../../_virtual/object-define-properties.js';
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireV8PrototypeDefineBug } from './v8-prototype-define-bug.js';
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireToIndexedObject } from './to-indexed-object.js';
+import { __require as requireObjectKeys } from './object-keys.js';
+
+var hasRequiredObjectDefineProperties;
+
+function requireObjectDefineProperties () {
+	if (hasRequiredObjectDefineProperties) return objectDefineProperties;
+	hasRequiredObjectDefineProperties = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
+	var definePropertyModule = requireObjectDefineProperty();
+	var anObject = requireAnObject();
+	var toIndexedObject = requireToIndexedObject();
+	var objectKeys = requireObjectKeys();
+
+	// `Object.defineProperties` method
+	// https://tc39.es/ecma262/#sec-object.defineproperties
+	// eslint-disable-next-line es/no-object-defineproperties -- safe
+	objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+	  anObject(O);
+	  var props = toIndexedObject(Properties);
+	  var keys = objectKeys(Properties);
+	  var length = keys.length;
+	  var index = 0;
+	  var key;
+	  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
+	  return O;
+	};
+	return objectDefineProperties;
+}
+
+export { requireObjectDefineProperties as __require };

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

@@ -0,0 +1,59 @@
+import { __exports as objectDefineProperty } from '../../../_virtual/object-define-property.js';
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireIe8DomDefine } from './ie8-dom-define.js';
+import { __require as requireV8PrototypeDefineBug } from './v8-prototype-define-bug.js';
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireToPropertyKey } from './to-property-key.js';
+
+var hasRequiredObjectDefineProperty;
+
+function requireObjectDefineProperty () {
+	if (hasRequiredObjectDefineProperty) return objectDefineProperty;
+	hasRequiredObjectDefineProperty = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var IE8_DOM_DEFINE = requireIe8DomDefine();
+	var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
+	var anObject = requireAnObject();
+	var toPropertyKey = requireToPropertyKey();
+
+	var $TypeError = TypeError;
+	// eslint-disable-next-line es/no-object-defineproperty -- safe
+	var $defineProperty = Object.defineProperty;
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+	var ENUMERABLE = 'enumerable';
+	var CONFIGURABLE = 'configurable';
+	var WRITABLE = 'writable';
+
+	// `Object.defineProperty` method
+	// https://tc39.es/ecma262/#sec-object.defineproperty
+	objectDefineProperty.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+	  anObject(O);
+	  P = toPropertyKey(P);
+	  anObject(Attributes);
+	  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+	    var current = $getOwnPropertyDescriptor(O, P);
+	    if (current && current[WRITABLE]) {
+	      O[P] = Attributes.value;
+	      Attributes = {
+	        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+	        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+	        writable: false
+	      };
+	    }
+	  } return $defineProperty(O, P, Attributes);
+	} : $defineProperty : function defineProperty(O, P, Attributes) {
+	  anObject(O);
+	  P = toPropertyKey(P);
+	  anObject(Attributes);
+	  if (IE8_DOM_DEFINE) try {
+	    return $defineProperty(O, P, Attributes);
+	  } catch (error) { /* empty */ }
+	  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
+	  if ('value' in Attributes) O[P] = Attributes.value;
+	  return O;
+	};
+	return objectDefineProperty;
+}
+
+export { requireObjectDefineProperty as __require };

package/dist/ie/es/node_modules/core-js/internals/object-get-own-property-descriptor.js

@@ -0,0 +1,41 @@
+import { __exports as objectGetOwnPropertyDescriptor } from '../../../_virtual/object-get-own-property-descriptor.js';
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireFunctionCall } from './function-call.js';
+import { __require as requireObjectPropertyIsEnumerable } from './object-property-is-enumerable.js';
+import { __require as requireCreatePropertyDescriptor } from './create-property-descriptor.js';
+import { __require as requireToIndexedObject } from './to-indexed-object.js';
+import { __require as requireToPropertyKey } from './to-property-key.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireIe8DomDefine } from './ie8-dom-define.js';
+
+var hasRequiredObjectGetOwnPropertyDescriptor;
+
+function requireObjectGetOwnPropertyDescriptor () {
+	if (hasRequiredObjectGetOwnPropertyDescriptor) return objectGetOwnPropertyDescriptor;
+	hasRequiredObjectGetOwnPropertyDescriptor = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var call = requireFunctionCall();
+	var propertyIsEnumerableModule = requireObjectPropertyIsEnumerable();
+	var createPropertyDescriptor = requireCreatePropertyDescriptor();
+	var toIndexedObject = requireToIndexedObject();
+	var toPropertyKey = requireToPropertyKey();
+	var hasOwn = requireHasOwnProperty();
+	var IE8_DOM_DEFINE = requireIe8DomDefine();
+
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+	// `Object.getOwnPropertyDescriptor` method
+	// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+	objectGetOwnPropertyDescriptor.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+	  O = toIndexedObject(O);
+	  P = toPropertyKey(P);
+	  if (IE8_DOM_DEFINE) try {
+	    return $getOwnPropertyDescriptor(O, P);
+	  } catch (error) { /* empty */ }
+	  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+	};
+	return objectGetOwnPropertyDescriptor;
+}
+
+export { requireObjectGetOwnPropertyDescriptor as __require };

package/dist/ie/es/node_modules/core-js/internals/object-get-own-property-names.js

@@ -0,0 +1,24 @@
+import { __exports as objectGetOwnPropertyNames } from '../../../_virtual/object-get-own-property-names.js';
+import { __require as requireObjectKeysInternal } from './object-keys-internal.js';
+import { __require as requireEnumBugKeys } from './enum-bug-keys.js';
+
+var hasRequiredObjectGetOwnPropertyNames;
+
+function requireObjectGetOwnPropertyNames () {
+	if (hasRequiredObjectGetOwnPropertyNames) return objectGetOwnPropertyNames;
+	hasRequiredObjectGetOwnPropertyNames = 1;
+	var internalObjectKeys = requireObjectKeysInternal();
+	var enumBugKeys = requireEnumBugKeys();
+
+	var hiddenKeys = enumBugKeys.concat('length', 'prototype');
+
+	// `Object.getOwnPropertyNames` method
+	// https://tc39.es/ecma262/#sec-object.getownpropertynames
+	// eslint-disable-next-line es/no-object-getownpropertynames -- safe
+	objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+	  return internalObjectKeys(O, hiddenKeys);
+	};
+	return objectGetOwnPropertyNames;
+}
+
+export { requireObjectGetOwnPropertyNames as __require };

package/dist/ie/es/node_modules/core-js/internals/object-get-own-property-symbols.js

@@ -0,0 +1,13 @@
+import { __exports as objectGetOwnPropertySymbols } from '../../../_virtual/object-get-own-property-symbols.js';
+
+var hasRequiredObjectGetOwnPropertySymbols;
+
+function requireObjectGetOwnPropertySymbols () {
+	if (hasRequiredObjectGetOwnPropertySymbols) return objectGetOwnPropertySymbols;
+	hasRequiredObjectGetOwnPropertySymbols = 1;
+	// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+	objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
+	return objectGetOwnPropertySymbols;
+}
+
+export { requireObjectGetOwnPropertySymbols as __require };

package/dist/ie/es/node_modules/core-js/internals/object-is-prototype-of.js

@@ -0,0 +1,15 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+
+var objectIsPrototypeOf;
+var hasRequiredObjectIsPrototypeOf;
+
+function requireObjectIsPrototypeOf () {
+	if (hasRequiredObjectIsPrototypeOf) return objectIsPrototypeOf;
+	hasRequiredObjectIsPrototypeOf = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	objectIsPrototypeOf = uncurryThis({}.isPrototypeOf);
+	return objectIsPrototypeOf;
+}
+
+export { requireObjectIsPrototypeOf as __require };

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

@@ -0,0 +1,36 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireToIndexedObject } from './to-indexed-object.js';
+import { __require as requireArrayIncludes } from './array-includes.js';
+import { __require as requireHiddenKeys } from './hidden-keys.js';
+
+var objectKeysInternal;
+var hasRequiredObjectKeysInternal;
+
+function requireObjectKeysInternal () {
+	if (hasRequiredObjectKeysInternal) return objectKeysInternal;
+	hasRequiredObjectKeysInternal = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var hasOwn = requireHasOwnProperty();
+	var toIndexedObject = requireToIndexedObject();
+	var indexOf = requireArrayIncludes().indexOf;
+	var hiddenKeys = requireHiddenKeys();
+
+	var push = uncurryThis([].push);
+
+	objectKeysInternal = function (object, names) {
+	  var O = toIndexedObject(object);
+	  var i = 0;
+	  var result = [];
+	  var key;
+	  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
+	  // Don't enum bug & hidden keys
+	  while (names.length > i) if (hasOwn(O, key = names[i++])) {
+	    ~indexOf(result, key) || push(result, key);
+	  }
+	  return result;
+	};
+	return objectKeysInternal;
+}
+
+export { requireObjectKeysInternal as __require };

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

@@ -0,0 +1,22 @@
+import { __require as requireObjectKeysInternal } from './object-keys-internal.js';
+import { __require as requireEnumBugKeys } from './enum-bug-keys.js';
+
+var objectKeys;
+var hasRequiredObjectKeys;
+
+function requireObjectKeys () {
+	if (hasRequiredObjectKeys) return objectKeys;
+	hasRequiredObjectKeys = 1;
+	var internalObjectKeys = requireObjectKeysInternal();
+	var enumBugKeys = requireEnumBugKeys();
+
+	// `Object.keys` method
+	// https://tc39.es/ecma262/#sec-object.keys
+	// eslint-disable-next-line es/no-object-keys -- safe
+	objectKeys = Object.keys || function keys(O) {
+	  return internalObjectKeys(O, enumBugKeys);
+	};
+	return objectKeys;
+}
+
+export { requireObjectKeys as __require };

package/dist/ie/es/node_modules/core-js/internals/object-property-is-enumerable.js

@@ -0,0 +1,24 @@
+import { __exports as objectPropertyIsEnumerable } from '../../../_virtual/object-property-is-enumerable.js';
+
+var hasRequiredObjectPropertyIsEnumerable;
+
+function requireObjectPropertyIsEnumerable () {
+	if (hasRequiredObjectPropertyIsEnumerable) return objectPropertyIsEnumerable;
+	hasRequiredObjectPropertyIsEnumerable = 1;
+	var $propertyIsEnumerable = {}.propertyIsEnumerable;
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+	// Nashorn ~ JDK8 bug
+	var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+
+	// `Object.prototype.propertyIsEnumerable` method implementation
+	// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+	objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+	  var descriptor = getOwnPropertyDescriptor(this, V);
+	  return !!descriptor && descriptor.enumerable;
+	} : $propertyIsEnumerable;
+	return objectPropertyIsEnumerable;
+}
+
+export { requireObjectPropertyIsEnumerable as __require };

package/dist/ie/es/node_modules/core-js/internals/object-set-prototype-of.js

@@ -0,0 +1,43 @@
+import { __require as requireFunctionUncurryThisAccessor } from './function-uncurry-this-accessor.js';
+import { __require as requireIsObject } from './is-object.js';
+import { __require as requireRequireObjectCoercible } from './require-object-coercible.js';
+import { __require as requireAPossiblePrototype } from './a-possible-prototype.js';
+
+var objectSetPrototypeOf;
+var hasRequiredObjectSetPrototypeOf;
+
+function requireObjectSetPrototypeOf () {
+	if (hasRequiredObjectSetPrototypeOf) return objectSetPrototypeOf;
+	hasRequiredObjectSetPrototypeOf = 1;
+	/* eslint-disable no-proto -- safe */
+	var uncurryThisAccessor = requireFunctionUncurryThisAccessor();
+	var isObject = requireIsObject();
+	var requireObjectCoercible = requireRequireObjectCoercible();
+	var aPossiblePrototype = requireAPossiblePrototype();
+
+	// `Object.setPrototypeOf` method
+	// https://tc39.es/ecma262/#sec-object.setprototypeof
+	// Works with __proto__ only. Old v8 can't work with null proto objects.
+	// eslint-disable-next-line es/no-object-setprototypeof -- safe
+	objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+	  var CORRECT_SETTER = false;
+	  var test = {};
+	  var setter;
+	  try {
+	    setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
+	    setter(test, []);
+	    CORRECT_SETTER = test instanceof Array;
+	  } catch (error) { /* empty */ }
+	  return function setPrototypeOf(O, proto) {
+	    requireObjectCoercible(O);
+	    aPossiblePrototype(proto);
+	    if (!isObject(O)) return O;
+	    if (CORRECT_SETTER) setter(O, proto);
+	    else O.__proto__ = proto;
+	    return O;
+	  };
+	}() : undefined);
+	return objectSetPrototypeOf;
+}
+
+export { requireObjectSetPrototypeOf as __require };

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

@@ -0,0 +1,29 @@
+import { __require as requireFunctionCall } from './function-call.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireIsObject } from './is-object.js';
+
+var ordinaryToPrimitive;
+var hasRequiredOrdinaryToPrimitive;
+
+function requireOrdinaryToPrimitive () {
+	if (hasRequiredOrdinaryToPrimitive) return ordinaryToPrimitive;
+	hasRequiredOrdinaryToPrimitive = 1;
+	var call = requireFunctionCall();
+	var isCallable = requireIsCallable();
+	var isObject = requireIsObject();
+
+	var $TypeError = TypeError;
+
+	// `OrdinaryToPrimitive` abstract operation
+	// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+	ordinaryToPrimitive = function (input, pref) {
+	  var fn, val;
+	  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+	  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
+	  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+	  throw new $TypeError("Can't convert object to primitive value");
+	};
+	return ordinaryToPrimitive;
+}
+
+export { requireOrdinaryToPrimitive as __require };

package/dist/ie/es/node_modules/core-js/internals/own-keys.js

@@ -0,0 +1,30 @@
+import { __require as requireGetBuiltIn } from './get-built-in.js';
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireObjectGetOwnPropertyNames } from './object-get-own-property-names.js';
+import { __require as requireObjectGetOwnPropertySymbols } from './object-get-own-property-symbols.js';
+import { __require as requireAnObject } from './an-object.js';
+
+var ownKeys;
+var hasRequiredOwnKeys;
+
+function requireOwnKeys () {
+	if (hasRequiredOwnKeys) return ownKeys;
+	hasRequiredOwnKeys = 1;
+	var getBuiltIn = requireGetBuiltIn();
+	var uncurryThis = requireFunctionUncurryThis();
+	var getOwnPropertyNamesModule = requireObjectGetOwnPropertyNames();
+	var getOwnPropertySymbolsModule = requireObjectGetOwnPropertySymbols();
+	var anObject = requireAnObject();
+
+	var concat = uncurryThis([].concat);
+
+	// all object keys, includes non-enumerable and symbols
+	ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+	  var keys = getOwnPropertyNamesModule.f(anObject(it));
+	  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+	  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+	};
+	return ownKeys;
+}
+
+export { requireOwnKeys as __require };

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

@@ -0,0 +1,17 @@
+var perform;
+var hasRequiredPerform;
+
+function requirePerform () {
+	if (hasRequiredPerform) return perform;
+	hasRequiredPerform = 1;
+	perform = function (exec) {
+	  try {
+	    return { error: false, value: exec() };
+	  } catch (error) {
+	    return { error: true, value: error };
+	  }
+	};
+	return perform;
+}
+
+export { requirePerform as __require };