web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,30 @@
+'use strict';
+
+var anObject = require('./an-object.js');
+
+var regexpFlags;
+var hasRequiredRegexpFlags;
+function requireRegexpFlags() {
+  if (hasRequiredRegexpFlags) return regexpFlags;
+  hasRequiredRegexpFlags = 1;
+  var anObject$1 = anObject.__require();
+
+  // `RegExp.prototype.flags` getter implementation
+  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
+  regexpFlags = function () {
+    var that = anObject$1(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;
+}
+
+exports.__require = requireRegexpFlags;

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

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

package/dist/cjs/node_modules/core-js/internals/shared-key.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var shared = require('./shared.js');
+var uid = require('./uid.js');
+
+var sharedKey;
+var hasRequiredSharedKey;
+function requireSharedKey() {
+  if (hasRequiredSharedKey) return sharedKey;
+  hasRequiredSharedKey = 1;
+  var shared$1 = shared.__require();
+  var uid$1 = uid.__require();
+  var keys = shared$1('keys');
+  sharedKey = function (key) {
+    return keys[key] || (keys[key] = uid$1(key));
+  };
+  return sharedKey;
+}
+
+exports.__require = requireSharedKey;

package/dist/cjs/node_modules/core-js/internals/shared-store.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var sharedStore = require('../../../_virtual/shared-store.js');
+var isPure = require('./is-pure.js');
+var globalThis = require('./global-this.js');
+var defineGlobalProperty = require('./define-global-property.js');
+
+var hasRequiredSharedStore;
+function requireSharedStore() {
+  if (hasRequiredSharedStore) return sharedStore.__module.exports;
+  hasRequiredSharedStore = 1;
+  var IS_PURE = isPure.__require();
+  var globalThis$1 = globalThis.__require();
+  var defineGlobalProperty$1 = defineGlobalProperty.__require();
+  var SHARED = '__core-js_shared__';
+  var store = sharedStore.__module.exports = globalThis$1[SHARED] || defineGlobalProperty$1(SHARED, {});
+  (store.versions || (store.versions = [])).push({
+    version: '3.43.0',
+    mode: IS_PURE ? 'pure' : 'global',
+    copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
+    license: 'https://github.com/zloirock/core-js/blob/v3.43.0/LICENSE',
+    source: 'https://github.com/zloirock/core-js'
+  });
+  return sharedStore.__module.exports;
+}
+
+exports.__require = requireSharedStore;

package/dist/cjs/node_modules/core-js/internals/shared.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var sharedStore = require('./shared-store.js');
+
+var shared;
+var hasRequiredShared;
+function requireShared() {
+  if (hasRequiredShared) return shared;
+  hasRequiredShared = 1;
+  var store = sharedStore.__require();
+  shared = function (key, value) {
+    return store[key] || (store[key] = value || {});
+  };
+  return shared;
+}
+
+exports.__require = requireShared;

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var environmentV8Version = require('./environment-v8-version.js');
+var fails = require('./fails.js');
+var globalThis = require('./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 = environmentV8Version.__require();
+  var fails$1 = fails.__require();
+  var globalThis$1 = globalThis.__require();
+  var $String = globalThis$1.String;
+
+  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+  symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$1(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;
+}
+
+exports.__require = requireSymbolConstructorDetection;

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var indexedObject = require('./indexed-object.js');
+var requireObjectCoercible = require('./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 = indexedObject.__require();
+  var requireObjectCoercible$1 = requireObjectCoercible.__require();
+  toIndexedObject = function (it) {
+    return IndexedObject(requireObjectCoercible$1(it));
+  };
+  return toIndexedObject;
+}
+
+exports.__require = requireToIndexedObject;

package/dist/cjs/node_modules/core-js/internals/to-object.js

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

package/dist/cjs/node_modules/core-js/internals/to-primitive.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var functionCall = require('./function-call.js');
+var isObject = require('./is-object.js');
+var isSymbol = require('./is-symbol.js');
+var getMethod = require('./get-method.js');
+var ordinaryToPrimitive = require('./ordinary-to-primitive.js');
+var wellKnownSymbol = require('./well-known-symbol.js');
+
+var toPrimitive;
+var hasRequiredToPrimitive;
+function requireToPrimitive() {
+  if (hasRequiredToPrimitive) return toPrimitive;
+  hasRequiredToPrimitive = 1;
+  var call = functionCall.__require();
+  var isObject$1 = isObject.__require();
+  var isSymbol$1 = isSymbol.__require();
+  var getMethod$1 = getMethod.__require();
+  var ordinaryToPrimitive$1 = ordinaryToPrimitive.__require();
+  var wellKnownSymbol$1 = wellKnownSymbol.__require();
+  var $TypeError = TypeError;
+  var TO_PRIMITIVE = wellKnownSymbol$1('toPrimitive');
+
+  // `ToPrimitive` abstract operation
+  // https://tc39.es/ecma262/#sec-toprimitive
+  toPrimitive = function (input, pref) {
+    if (!isObject$1(input) || isSymbol$1(input)) return input;
+    var exoticToPrim = getMethod$1(input, TO_PRIMITIVE);
+    var result;
+    if (exoticToPrim) {
+      if (pref === undefined) pref = 'default';
+      result = call(exoticToPrim, input, pref);
+      if (!isObject$1(result) || isSymbol$1(result)) return result;
+      throw new $TypeError("Can't convert object to primitive value");
+    }
+    if (pref === undefined) pref = 'number';
+    return ordinaryToPrimitive$1(input, pref);
+  };
+  return toPrimitive;
+}
+
+exports.__require = requireToPrimitive;

package/dist/cjs/node_modules/core-js/internals/to-property-key.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var toPrimitive = require('./to-primitive.js');
+var isSymbol = require('./is-symbol.js');
+
+var toPropertyKey;
+var hasRequiredToPropertyKey;
+function requireToPropertyKey() {
+  if (hasRequiredToPropertyKey) return toPropertyKey;
+  hasRequiredToPropertyKey = 1;
+  var toPrimitive$1 = toPrimitive.__require();
+  var isSymbol$1 = isSymbol.__require();
+
+  // `ToPropertyKey` abstract operation
+  // https://tc39.es/ecma262/#sec-topropertykey
+  toPropertyKey = function (argument) {
+    var key = toPrimitive$1(argument, 'string');
+    return isSymbol$1(key) ? key : key + '';
+  };
+  return toPropertyKey;
+}
+
+exports.__require = requireToPropertyKey;

package/dist/cjs/node_modules/core-js/internals/try-to-string.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var tryToString;
+var hasRequiredTryToString;
+function requireTryToString() {
+  if (hasRequiredTryToString) return tryToString;
+  hasRequiredTryToString = 1;
+  var $String = String;
+  tryToString = function (argument) {
+    try {
+      return $String(argument);
+    } catch (error) {
+      return 'Object';
+    }
+  };
+  return tryToString;
+}
+
+exports.__require = requireTryToString;

package/dist/cjs/node_modules/core-js/internals/uid.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var functionUncurryThis = require('./function-uncurry-this.js');
+
+var uid;
+var hasRequiredUid;
+function requireUid() {
+  if (hasRequiredUid) return uid;
+  hasRequiredUid = 1;
+  var uncurryThis = functionUncurryThis.__require();
+  var id = 0;
+  var postfix = Math.random();
+  var toString = uncurryThis(1.1.toString);
+  uid = function (key) {
+    return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
+  };
+  return uid;
+}
+
+exports.__require = requireUid;

package/dist/cjs/node_modules/core-js/internals/use-symbol-as-uid.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var symbolConstructorDetection = require('./symbol-constructor-detection.js');
+
+var useSymbolAsUid;
+var hasRequiredUseSymbolAsUid;
+function requireUseSymbolAsUid() {
+  if (hasRequiredUseSymbolAsUid) return useSymbolAsUid;
+  hasRequiredUseSymbolAsUid = 1;
+  /* eslint-disable es/no-symbol -- required for testing */
+  var NATIVE_SYMBOL = symbolConstructorDetection.__require();
+  useSymbolAsUid = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == 'symbol';
+  return useSymbolAsUid;
+}
+
+exports.__require = requireUseSymbolAsUid;

package/dist/cjs/node_modules/core-js/internals/v8-prototype-define-bug.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var descriptors = require('./descriptors.js');
+var fails = require('./fails.js');
+
+var v8PrototypeDefineBug;
+var hasRequiredV8PrototypeDefineBug;
+function requireV8PrototypeDefineBug() {
+  if (hasRequiredV8PrototypeDefineBug) return v8PrototypeDefineBug;
+  hasRequiredV8PrototypeDefineBug = 1;
+  var DESCRIPTORS = descriptors.__require();
+  var fails$1 = fails.__require();
+
+  // V8 ~ Chrome 36-
+  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
+  v8PrototypeDefineBug = DESCRIPTORS && fails$1(function () {
+    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+    return Object.defineProperty(function () {/* empty */}, 'prototype', {
+      value: 42,
+      writable: false
+    }).prototype !== 42;
+  });
+  return v8PrototypeDefineBug;
+}
+
+exports.__require = requireV8PrototypeDefineBug;

package/dist/cjs/node_modules/core-js/internals/weak-map-basic-detection.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var globalThis = require('./global-this.js');
+var isCallable = require('./is-callable.js');
+
+var weakMapBasicDetection;
+var hasRequiredWeakMapBasicDetection;
+function requireWeakMapBasicDetection() {
+  if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
+  hasRequiredWeakMapBasicDetection = 1;
+  var globalThis$1 = globalThis.__require();
+  var isCallable$1 = isCallable.__require();
+  var WeakMap = globalThis$1.WeakMap;
+  weakMapBasicDetection = isCallable$1(WeakMap) && /native code/.test(String(WeakMap));
+  return weakMapBasicDetection;
+}
+
+exports.__require = requireWeakMapBasicDetection;

package/dist/cjs/node_modules/core-js/internals/well-known-symbol-define.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var path = require('./path.js');
+var hasOwnProperty = require('./has-own-property.js');
+var wellKnownSymbolWrapped = require('./well-known-symbol-wrapped.js');
+var objectDefineProperty = require('./object-define-property.js');
+
+var wellKnownSymbolDefine;
+var hasRequiredWellKnownSymbolDefine;
+function requireWellKnownSymbolDefine() {
+  if (hasRequiredWellKnownSymbolDefine) return wellKnownSymbolDefine;
+  hasRequiredWellKnownSymbolDefine = 1;
+  var path$1 = path.__require();
+  var hasOwn = hasOwnProperty.__require();
+  var wrappedWellKnownSymbolModule = wellKnownSymbolWrapped.__require();
+  var defineProperty = objectDefineProperty.__require().f;
+  wellKnownSymbolDefine = function (NAME) {
+    var Symbol = path$1.Symbol || (path$1.Symbol = {});
+    if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
+      value: wrappedWellKnownSymbolModule.f(NAME)
+    });
+  };
+  return wellKnownSymbolDefine;
+}
+
+exports.__require = requireWellKnownSymbolDefine;

package/dist/cjs/node_modules/core-js/internals/well-known-symbol-wrapped.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var wellKnownSymbolWrapped = require('../../../_virtual/well-known-symbol-wrapped.js');
+var wellKnownSymbol = require('./well-known-symbol.js');
+
+var hasRequiredWellKnownSymbolWrapped;
+function requireWellKnownSymbolWrapped() {
+  if (hasRequiredWellKnownSymbolWrapped) return wellKnownSymbolWrapped.__exports;
+  hasRequiredWellKnownSymbolWrapped = 1;
+  var wellKnownSymbol$1 = wellKnownSymbol.__require();
+  wellKnownSymbolWrapped.__exports.f = wellKnownSymbol$1;
+  return wellKnownSymbolWrapped.__exports;
+}
+
+exports.__require = requireWellKnownSymbolWrapped;

package/dist/cjs/node_modules/core-js/internals/well-known-symbol.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var globalThis = require('./global-this.js');
+var shared = require('./shared.js');
+var hasOwnProperty = require('./has-own-property.js');
+var uid = require('./uid.js');
+var symbolConstructorDetection = require('./symbol-constructor-detection.js');
+var useSymbolAsUid = require('./use-symbol-as-uid.js');
+
+var wellKnownSymbol;
+var hasRequiredWellKnownSymbol;
+function requireWellKnownSymbol() {
+  if (hasRequiredWellKnownSymbol) return wellKnownSymbol;
+  hasRequiredWellKnownSymbol = 1;
+  var globalThis$1 = globalThis.__require();
+  var shared$1 = shared.__require();
+  var hasOwn = hasOwnProperty.__require();
+  var uid$1 = uid.__require();
+  var NATIVE_SYMBOL = symbolConstructorDetection.__require();
+  var USE_SYMBOL_AS_UID = useSymbolAsUid.__require();
+  var Symbol = globalThis$1.Symbol;
+  var WellKnownSymbolsStore = shared$1('wks');
+  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid$1;
+  wellKnownSymbol = function (name) {
+    if (!hasOwn(WellKnownSymbolsStore, name)) {
+      WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name) ? Symbol[name] : createWellKnownSymbol('Symbol.' + name);
+    }
+    return WellKnownSymbolsStore[name];
+  };
+  return wellKnownSymbol;
+}
+
+exports.__require = requireWellKnownSymbol;

package/dist/cjs/node_modules/core-js/modules/es.regexp.flags.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var es_regexp_flags = require('../../../_virtual/es.regexp.flags2.js');
+var descriptors = require('../internals/descriptors.js');
+var defineBuiltInAccessor = require('../internals/define-built-in-accessor.js');
+var regexpFlagsDetection = require('../internals/regexp-flags-detection.js');
+var regexpFlags = require('../internals/regexp-flags.js');
+
+var hasRequiredEs_regexp_flags;
+function requireEs_regexp_flags() {
+  if (hasRequiredEs_regexp_flags) return es_regexp_flags.__exports;
+  hasRequiredEs_regexp_flags = 1;
+  var DESCRIPTORS = descriptors.__require();
+  var defineBuiltInAccessor$1 = defineBuiltInAccessor.__require();
+  var regExpFlagsDetection = regexpFlagsDetection.__require();
+  var regExpFlagsGetterImplementation = regexpFlags.__require();
+
+  // `RegExp.prototype.flags` getter
+  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
+  if (DESCRIPTORS && !regExpFlagsDetection.correct) {
+    defineBuiltInAccessor$1(RegExp.prototype, 'flags', {
+      configurable: true,
+      get: regExpFlagsGetterImplementation
+    });
+    regExpFlagsDetection.correct = true;
+  }
+  return es_regexp_flags.__exports;
+}
+
+exports.__require = requireEs_regexp_flags;

package/dist/cjs/node_modules/core-js/modules/es.symbol.dispose.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var es_symbol_dispose = require('../../../_virtual/es.symbol.dispose.js');
+var globalThis = require('../internals/global-this.js');
+var wellKnownSymbolDefine = require('../internals/well-known-symbol-define.js');
+var objectDefineProperty = require('../internals/object-define-property.js');
+var objectGetOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor.js');
+
+var hasRequiredEs_symbol_dispose;
+function requireEs_symbol_dispose() {
+  if (hasRequiredEs_symbol_dispose) return es_symbol_dispose.__exports;
+  hasRequiredEs_symbol_dispose = 1;
+  var globalThis$1 = globalThis.__require();
+  var defineWellKnownSymbol = wellKnownSymbolDefine.__require();
+  var defineProperty = objectDefineProperty.__require().f;
+  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.__require().f;
+  var Symbol = globalThis$1.Symbol;
+
+  // `Symbol.dispose` well-known symbol
+  // https://github.com/tc39/proposal-explicit-resource-management
+  defineWellKnownSymbol('dispose');
+  if (Symbol) {
+    var descriptor = getOwnPropertyDescriptor(Symbol, 'dispose');
+    // workaround of NodeJS 20.4 bug
+    // https://github.com/nodejs/node/issues/48699
+    // and incorrect descriptor from some transpilers and userland helpers
+    if (descriptor.enumerable && descriptor.configurable && descriptor.writable) {
+      defineProperty(Symbol, 'dispose', {
+        value: descriptor.value,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+  }
+  return es_symbol_dispose.__exports;
+}
+
+exports.__require = requireEs_symbol_dispose;

package/dist/cjs/node_modules/core-js/modules/esnext.symbol.dispose.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var esnext_symbol_dispose = require('../../../_virtual/esnext.symbol.dispose2.js');
+var es_symbol_dispose = require('./es.symbol.dispose.js');
+
+var hasRequiredEsnext_symbol_dispose;
+function requireEsnext_symbol_dispose() {
+  if (hasRequiredEsnext_symbol_dispose) return esnext_symbol_dispose.__exports;
+  hasRequiredEsnext_symbol_dispose = 1;
+  // TODO: Remove from `core-js@4`
+  es_symbol_dispose.__require();
+  return esnext_symbol_dispose.__exports;
+}
+
+exports.__require = requireEsnext_symbol_dispose;