web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/core-js/internals/ie8-dom-define.js

@@ -0,0 +1,26 @@
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireDocumentCreateElement } from './document-create-element.js';
+
+var ie8DomDefine;
+var hasRequiredIe8DomDefine;
+function requireIe8DomDefine() {
+  if (hasRequiredIe8DomDefine) return ie8DomDefine;
+  hasRequiredIe8DomDefine = 1;
+  var DESCRIPTORS = requireDescriptors();
+  var fails = requireFails();
+  var createElement = requireDocumentCreateElement();
+
+  // Thanks to IE8 for its funny defineProperty
+  ie8DomDefine = !DESCRIPTORS && !fails(function () {
+    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+    return Object.defineProperty(createElement('div'), 'a', {
+      get: function () {
+        return 7;
+      }
+    }).a !== 7;
+  });
+  return ie8DomDefine;
+}
+
+export { requireIe8DomDefine as __require };

package/dist/esm/node_modules/core-js/internals/indexed-object.js

@@ -0,0 +1,27 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireClassofRaw } from './classof-raw.js';
+
+var indexedObject;
+var hasRequiredIndexedObject;
+function requireIndexedObject() {
+  if (hasRequiredIndexedObject) return indexedObject;
+  hasRequiredIndexedObject = 1;
+  var uncurryThis = requireFunctionUncurryThis();
+  var fails = requireFails();
+  var classof = requireClassofRaw();
+  var $Object = Object;
+  var split = uncurryThis(''.split);
+
+  // fallback for non-array-like ES3 and non-enumerable old V8 strings
+  indexedObject = fails(function () {
+    // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+    // eslint-disable-next-line no-prototype-builtins -- safe
+    return !$Object('z').propertyIsEnumerable(0);
+  }) ? function (it) {
+    return classof(it) === 'String' ? split(it, '') : $Object(it);
+  } : $Object;
+  return indexedObject;
+}
+
+export { requireIndexedObject as __require };

package/dist/esm/node_modules/core-js/internals/inspect-source.js

@@ -0,0 +1,25 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireSharedStore } from './shared-store.js';
+
+var inspectSource;
+var hasRequiredInspectSource;
+function requireInspectSource() {
+  if (hasRequiredInspectSource) return inspectSource;
+  hasRequiredInspectSource = 1;
+  var uncurryThis = requireFunctionUncurryThis();
+  var isCallable = requireIsCallable();
+  var store = requireSharedStore();
+  var functionToString = uncurryThis(Function.toString);
+
+  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+  if (!isCallable(store.inspectSource)) {
+    store.inspectSource = function (it) {
+      return functionToString(it);
+    };
+  }
+  inspectSource = store.inspectSource;
+  return inspectSource;
+}
+
+export { requireInspectSource as __require };

package/dist/esm/node_modules/core-js/internals/internal-state.js

@@ -0,0 +1,84 @@
+import { __require as requireWeakMapBasicDetection } from './weak-map-basic-detection.js';
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireIsObject } from './is-object.js';
+import { __require as requireCreateNonEnumerableProperty } from './create-non-enumerable-property.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireSharedStore } from './shared-store.js';
+import { __require as requireSharedKey } from './shared-key.js';
+import { __require as requireHiddenKeys } from './hidden-keys.js';
+
+var internalState;
+var hasRequiredInternalState;
+function requireInternalState() {
+  if (hasRequiredInternalState) return internalState;
+  hasRequiredInternalState = 1;
+  var NATIVE_WEAK_MAP = requireWeakMapBasicDetection();
+  var globalThis = requireGlobalThis();
+  var isObject = requireIsObject();
+  var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+  var hasOwn = requireHasOwnProperty();
+  var shared = requireSharedStore();
+  var sharedKey = requireSharedKey();
+  var hiddenKeys = requireHiddenKeys();
+  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+  var TypeError = globalThis.TypeError;
+  var WeakMap = globalThis.WeakMap;
+  var set, get, has;
+  var enforce = function (it) {
+    return has(it) ? get(it) : set(it, {});
+  };
+  var getterFor = function (TYPE) {
+    return function (it) {
+      var state;
+      if (!isObject(it) || (state = get(it)).type !== TYPE) {
+        throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
+      }
+      return state;
+    };
+  };
+  if (NATIVE_WEAK_MAP || shared.state) {
+    var store = shared.state || (shared.state = new WeakMap());
+    /* eslint-disable no-self-assign -- prototype methods protection */
+    store.get = store.get;
+    store.has = store.has;
+    store.set = store.set;
+    /* eslint-enable no-self-assign -- prototype methods protection */
+    set = function (it, metadata) {
+      if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+      metadata.facade = it;
+      store.set(it, metadata);
+      return metadata;
+    };
+    get = function (it) {
+      return store.get(it) || {};
+    };
+    has = function (it) {
+      return store.has(it);
+    };
+  } else {
+    var STATE = sharedKey('state');
+    hiddenKeys[STATE] = true;
+    set = function (it, metadata) {
+      if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+      metadata.facade = it;
+      createNonEnumerableProperty(it, STATE, metadata);
+      return metadata;
+    };
+    get = function (it) {
+      return hasOwn(it, STATE) ? it[STATE] : {};
+    };
+    has = function (it) {
+      return hasOwn(it, STATE);
+    };
+  }
+  internalState = {
+    set: set,
+    get: get,
+    has: has,
+    enforce: enforce,
+    getterFor: getterFor
+  };
+  return internalState;
+}
+
+export { requireInternalState as __require };

package/dist/esm/node_modules/core-js/internals/is-callable.js

@@ -0,0 +1,20 @@
+var isCallable;
+var hasRequiredIsCallable;
+function requireIsCallable() {
+  if (hasRequiredIsCallable) return isCallable;
+  hasRequiredIsCallable = 1;
+  // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+  var documentAll = typeof document == 'object' && document.all;
+
+  // `IsCallable` abstract operation
+  // https://tc39.es/ecma262/#sec-iscallable
+  // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+  isCallable = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
+    return typeof argument == 'function' || argument === documentAll;
+  } : function (argument) {
+    return typeof argument == 'function';
+  };
+  return isCallable;
+}
+
+export { requireIsCallable as __require };

package/dist/esm/node_modules/core-js/internals/is-null-or-undefined.js

@@ -0,0 +1,14 @@
+var isNullOrUndefined;
+var hasRequiredIsNullOrUndefined;
+function requireIsNullOrUndefined() {
+  if (hasRequiredIsNullOrUndefined) return isNullOrUndefined;
+  hasRequiredIsNullOrUndefined = 1;
+  // we can't use just `it == null` since of `document.all` special case
+  // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+  isNullOrUndefined = function (it) {
+    return it === null || it === undefined;
+  };
+  return isNullOrUndefined;
+}
+
+export { requireIsNullOrUndefined as __require };

package/dist/esm/node_modules/core-js/internals/is-object.js

@@ -0,0 +1,15 @@
+import { __require as requireIsCallable } from './is-callable.js';
+
+var isObject;
+var hasRequiredIsObject;
+function requireIsObject() {
+  if (hasRequiredIsObject) return isObject;
+  hasRequiredIsObject = 1;
+  var isCallable = requireIsCallable();
+  isObject = function (it) {
+    return typeof it == 'object' ? it !== null : isCallable(it);
+  };
+  return isObject;
+}
+
+export { requireIsObject as __require };

package/dist/esm/node_modules/core-js/internals/is-pure.js

@@ -0,0 +1,10 @@
+var isPure;
+var hasRequiredIsPure;
+function requireIsPure() {
+  if (hasRequiredIsPure) return isPure;
+  hasRequiredIsPure = 1;
+  isPure = false;
+  return isPure;
+}
+
+export { requireIsPure as __require };

package/dist/esm/node_modules/core-js/internals/is-symbol.js

@@ -0,0 +1,25 @@
+import { __require as requireGetBuiltIn } from './get-built-in.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireObjectIsPrototypeOf } from './object-is-prototype-of.js';
+import { __require as requireUseSymbolAsUid } from './use-symbol-as-uid.js';
+
+var isSymbol;
+var hasRequiredIsSymbol;
+function requireIsSymbol() {
+  if (hasRequiredIsSymbol) return isSymbol;
+  hasRequiredIsSymbol = 1;
+  var getBuiltIn = requireGetBuiltIn();
+  var isCallable = requireIsCallable();
+  var isPrototypeOf = requireObjectIsPrototypeOf();
+  var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
+  var $Object = Object;
+  isSymbol = USE_SYMBOL_AS_UID ? function (it) {
+    return typeof it == 'symbol';
+  } : function (it) {
+    var $Symbol = getBuiltIn('Symbol');
+    return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+  };
+  return isSymbol;
+}
+
+export { requireIsSymbol as __require };

package/dist/esm/node_modules/core-js/internals/make-built-in.js

@@ -0,0 +1,77 @@
+import { __module as makeBuiltIn } from '../../../_virtual/make-built-in.js';
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireFunctionName } from './function-name.js';
+import { __require as requireInspectSource } from './inspect-source.js';
+import { __require as requireInternalState } from './internal-state.js';
+
+var hasRequiredMakeBuiltIn;
+function requireMakeBuiltIn() {
+  if (hasRequiredMakeBuiltIn) return makeBuiltIn.exports;
+  hasRequiredMakeBuiltIn = 1;
+  var uncurryThis = requireFunctionUncurryThis();
+  var fails = requireFails();
+  var isCallable = requireIsCallable();
+  var hasOwn = requireHasOwnProperty();
+  var DESCRIPTORS = requireDescriptors();
+  var CONFIGURABLE_FUNCTION_NAME = requireFunctionName().CONFIGURABLE;
+  var inspectSource = requireInspectSource();
+  var InternalStateModule = requireInternalState();
+  var enforceInternalState = InternalStateModule.enforce;
+  var getInternalState = InternalStateModule.get;
+  var $String = String;
+  // eslint-disable-next-line es/no-object-defineproperty -- safe
+  var defineProperty = Object.defineProperty;
+  var stringSlice = uncurryThis(''.slice);
+  var replace = uncurryThis(''.replace);
+  var join = uncurryThis([].join);
+  var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
+    return defineProperty(function () {/* empty */}, 'length', {
+      value: 8
+    }).length !== 8;
+  });
+  var TEMPLATE = String(String).split('String');
+  var makeBuiltIn$1 = makeBuiltIn.exports = function (value, name, options) {
+    if (stringSlice($String(name), 0, 7) === 'Symbol(') {
+      name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
+    }
+    if (options && options.getter) name = 'get ' + name;
+    if (options && options.setter) name = 'set ' + name;
+    if (!hasOwn(value, 'name') || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
+      if (DESCRIPTORS) defineProperty(value, 'name', {
+        value: name,
+        configurable: true
+      });else value.name = name;
+    }
+    if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
+      defineProperty(value, 'length', {
+        value: options.arity
+      });
+    }
+    try {
+      if (options && hasOwn(options, 'constructor') && options.constructor) {
+        if (DESCRIPTORS) defineProperty(value, 'prototype', {
+          writable: false
+        });
+        // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
+      } else if (value.prototype) value.prototype = undefined;
+    } catch (error) {/* empty */}
+    var state = enforceInternalState(value);
+    if (!hasOwn(state, 'source')) {
+      state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
+    }
+    return value;
+  };
+
+  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+  // eslint-disable-next-line no-extend-native -- required
+  Function.prototype.toString = makeBuiltIn$1(function toString() {
+    return isCallable(this) && getInternalState(this).source || inspectSource(this);
+  }, 'toString');
+  return makeBuiltIn.exports;
+}
+
+export { requireMakeBuiltIn as __require };

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

@@ -0,0 +1,58 @@
+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/esm/node_modules/core-js/internals/object-get-own-property-descriptor.js

@@ -0,0 +1,40 @@
+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/esm/node_modules/core-js/internals/object-is-prototype-of.js

@@ -0,0 +1,13 @@
+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/esm/node_modules/core-js/internals/object-property-is-enumerable.js

@@ -0,0 +1,25 @@
+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/esm/node_modules/core-js/internals/ordinary-to-primitive.js

@@ -0,0 +1,27 @@
+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/esm/node_modules/core-js/internals/path.js

@@ -0,0 +1,13 @@
+import { __require as requireGlobalThis } from './global-this.js';
+
+var path;
+var hasRequiredPath;
+function requirePath() {
+  if (hasRequiredPath) return path;
+  hasRequiredPath = 1;
+  var globalThis = requireGlobalThis();
+  path = globalThis;
+  return path;
+}
+
+export { requirePath as __require };

package/dist/esm/node_modules/core-js/internals/regexp-flags-detection.js

@@ -0,0 +1,54 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireFails } from './fails.js';
+
+var regexpFlagsDetection;
+var hasRequiredRegexpFlagsDetection;
+function requireRegexpFlagsDetection() {
+  if (hasRequiredRegexpFlagsDetection) return regexpFlagsDetection;
+  hasRequiredRegexpFlagsDetection = 1;
+  var globalThis = requireGlobalThis();
+  var fails = requireFails();
+
+  // babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
+  var RegExp = globalThis.RegExp;
+  var FLAGS_GETTER_IS_CORRECT = !fails(function () {
+    var INDICES_SUPPORT = true;
+    try {
+      RegExp('.', 'd');
+    } catch (error) {
+      INDICES_SUPPORT = false;
+    }
+    var O = {};
+    // modern V8 bug
+    var calls = '';
+    var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy';
+    var addGetter = function (key, chr) {
+      // eslint-disable-next-line es/no-object-defineproperty -- safe
+      Object.defineProperty(O, key, {
+        get: function () {
+          calls += chr;
+          return true;
+        }
+      });
+    };
+    var pairs = {
+      dotAll: 's',
+      global: 'g',
+      ignoreCase: 'i',
+      multiline: 'm',
+      sticky: 'y'
+    };
+    if (INDICES_SUPPORT) pairs.hasIndices = 'd';
+    for (var key in pairs) addGetter(key, pairs[key]);
+
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var result = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get.call(O);
+    return result !== expected || calls !== expected;
+  });
+  regexpFlagsDetection = {
+    correct: FLAGS_GETTER_IS_CORRECT
+  };
+  return regexpFlagsDetection;
+}
+
+export { requireRegexpFlagsDetection as __require };

package/dist/esm/node_modules/core-js/internals/regexp-flags.js

@@ -0,0 +1,28 @@
+import { __require as requireAnObject } from './an-object.js';
+
+var regexpFlags;
+var hasRequiredRegexpFlags;
+function requireRegexpFlags() {
+  if (hasRequiredRegexpFlags) return regexpFlags;
+  hasRequiredRegexpFlags = 1;
+  var anObject = requireAnObject();
+
+  // `RegExp.prototype.flags` getter implementation
+  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
+  regexpFlags = function () {
+    var that = anObject(this);
+    var result = '';
+    if (that.hasIndices) result += 'd';
+    if (that.global) result += 'g';
+    if (that.ignoreCase) result += 'i';
+    if (that.multiline) result += 'm';
+    if (that.dotAll) result += 's';
+    if (that.unicode) result += 'u';
+    if (that.unicodeSets) result += 'v';
+    if (that.sticky) result += 'y';
+    return result;
+  };
+  return regexpFlags;
+}
+
+export { requireRegexpFlags as __require };

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

@@ -0,0 +1,20 @@
+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/esm/node_modules/core-js/internals/shared-key.js

@@ -0,0 +1,18 @@
+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 };