web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/node_modules/call-bind/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var index = require('../../_virtual/index13.js');
+var index$2 = require('../set-function-length/index.js');
+var index$3 = require('../es-define-property/index.js');
+var index$1 = require('../call-bind-apply-helpers/index.js');
+var applyBind = require('../call-bind-apply-helpers/applyBind.js');
+
+var hasRequiredCallBind;
+function requireCallBind() {
+  if (hasRequiredCallBind) return index.__module.exports;
+  hasRequiredCallBind = 1;
+  (function (module) {
+
+    var setFunctionLength = /*@__PURE__*/index$2.__require();
+    var $defineProperty = /*@__PURE__*/index$3.__require();
+    var callBindBasic = index$1.__require();
+    var applyBind$1 = applyBind.__require();
+    module.exports = function callBind(originalFunction) {
+      var func = callBindBasic(arguments);
+      var adjustedLength = originalFunction.length - (arguments.length - 1);
+      return setFunctionLength(func, 1 + (adjustedLength > 0 ? adjustedLength : 0), true);
+    };
+    if ($defineProperty) {
+      $defineProperty(module.exports, 'apply', {
+        value: applyBind$1
+      });
+    } else {
+      module.exports.apply = applyBind$1;
+    }
+  })(index.__module);
+  return index.__module.exports;
+}
+
+exports.__require = requireCallBind;

package/dist/cjs/node_modules/call-bind-apply-helpers/actualApply.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var index = require('../function-bind/index.js');
+var functionApply = require('./functionApply.js');
+var functionCall = require('./functionCall.js');
+var reflectApply = require('./reflectApply.js');
+
+var actualApply;
+var hasRequiredActualApply;
+function requireActualApply() {
+  if (hasRequiredActualApply) return actualApply;
+  hasRequiredActualApply = 1;
+  var bind = index.__require();
+  var $apply = functionApply.__require();
+  var $call = functionCall.__require();
+  var $reflectApply = reflectApply.__require();
+
+  /** @type {import('./actualApply')} */
+  actualApply = $reflectApply || bind.call($call, $apply);
+  return actualApply;
+}
+
+exports.__require = requireActualApply;

package/dist/cjs/node_modules/call-bind-apply-helpers/applyBind.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var index = require('../function-bind/index.js');
+var functionApply = require('./functionApply.js');
+var actualApply = require('./actualApply.js');
+
+var applyBind;
+var hasRequiredApplyBind;
+function requireApplyBind() {
+  if (hasRequiredApplyBind) return applyBind;
+  hasRequiredApplyBind = 1;
+  var bind = index.__require();
+  var $apply = functionApply.__require();
+  var actualApply$1 = actualApply.__require();
+
+  /** @type {import('./applyBind')} */
+  applyBind = function applyBind() {
+    return actualApply$1(bind, $apply, arguments);
+  };
+  return applyBind;
+}
+
+exports.__require = requireApplyBind;

package/dist/cjs/node_modules/call-bind-apply-helpers/functionApply.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+
+  /** @type {import('./functionApply')} */
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
+
+exports.__require = requireFunctionApply;

package/dist/cjs/node_modules/call-bind-apply-helpers/functionCall.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var functionCall;
+var hasRequiredFunctionCall;
+function requireFunctionCall() {
+  if (hasRequiredFunctionCall) return functionCall;
+  hasRequiredFunctionCall = 1;
+
+  /** @type {import('./functionCall')} */
+  functionCall = Function.prototype.call;
+  return functionCall;
+}
+
+exports.__require = requireFunctionCall;

package/dist/cjs/node_modules/call-bind-apply-helpers/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var index = require('../function-bind/index.js');
+var type = require('../es-errors/type.js');
+var functionCall = require('./functionCall.js');
+var actualApply = require('./actualApply.js');
+
+var callBindApplyHelpers;
+var hasRequiredCallBindApplyHelpers;
+function requireCallBindApplyHelpers() {
+  if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
+  hasRequiredCallBindApplyHelpers = 1;
+  var bind = index.__require();
+  var $TypeError = /*@__PURE__*/type.__require();
+  var $call = functionCall.__require();
+  var $actualApply = actualApply.__require();
+
+  /** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
+  callBindApplyHelpers = function callBindBasic(args) {
+    if (args.length < 1 || typeof args[0] !== 'function') {
+      throw new $TypeError('a function is required');
+    }
+    return $actualApply(bind, $call, args);
+  };
+  return callBindApplyHelpers;
+}
+
+exports.__require = requireCallBindApplyHelpers;

package/dist/cjs/node_modules/call-bind-apply-helpers/reflectApply.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var reflectApply;
+var hasRequiredReflectApply;
+function requireReflectApply() {
+  if (hasRequiredReflectApply) return reflectApply;
+  hasRequiredReflectApply = 1;
+
+  /** @type {import('./reflectApply')} */
+  reflectApply = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
+  return reflectApply;
+}
+
+exports.__require = requireReflectApply;

package/dist/cjs/node_modules/call-bound/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var index$1 = require('../get-intrinsic/index.js');
+var index = require('../call-bind-apply-helpers/index.js');
+
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = /*@__PURE__*/index$1.__require();
+  var callBindBasic = index.__require();
+
+  /** @type {(thisArg: string, searchString: string, position?: number) => number} */
+  var $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);
+
+  /** @type {import('.')} */
+  callBound = function callBoundIntrinsic(name, allowMissing) {
+    /* eslint no-extra-parens: 0 */
+
+    var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */GetIntrinsic(name, !!allowMissing);
+    if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+      return callBindBasic(/** @type {const} */[intrinsic]);
+    }
+    return intrinsic;
+  };
+  return callBound;
+}
+
+exports.__require = requireCallBound;

package/dist/cjs/node_modules/core-js/internals/a-callable.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var isCallable = require('./is-callable.js');
+var tryToString = require('./try-to-string.js');
+
+var aCallable;
+var hasRequiredACallable;
+function requireACallable() {
+  if (hasRequiredACallable) return aCallable;
+  hasRequiredACallable = 1;
+  var isCallable$1 = isCallable.__require();
+  var tryToString$1 = tryToString.__require();
+  var $TypeError = TypeError;
+
+  // `Assert: IsCallable(argument) is true`
+  aCallable = function (argument) {
+    if (isCallable$1(argument)) return argument;
+    throw new $TypeError(tryToString$1(argument) + ' is not a function');
+  };
+  return aCallable;
+}
+
+exports.__require = requireACallable;

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

@@ -0,0 +1,22 @@
+'use strict';
+
+var isObject = require('./is-object.js');
+
+var anObject;
+var hasRequiredAnObject;
+function requireAnObject() {
+  if (hasRequiredAnObject) return anObject;
+  hasRequiredAnObject = 1;
+  var isObject$1 = isObject.__require();
+  var $String = String;
+  var $TypeError = TypeError;
+
+  // `Assert: Type(argument) is Object`
+  anObject = function (argument) {
+    if (isObject$1(argument)) return argument;
+    throw new $TypeError($String(argument) + ' is not an object');
+  };
+  return anObject;
+}
+
+exports.__require = requireAnObject;

package/dist/cjs/node_modules/core-js/internals/classof-raw.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var functionUncurryThis = require('./function-uncurry-this.js');
+
+var classofRaw;
+var hasRequiredClassofRaw;
+function requireClassofRaw() {
+  if (hasRequiredClassofRaw) return classofRaw;
+  hasRequiredClassofRaw = 1;
+  var uncurryThis = functionUncurryThis.__require();
+  var toString = uncurryThis({}.toString);
+  var stringSlice = uncurryThis(''.slice);
+  classofRaw = function (it) {
+    return stringSlice(toString(it), 8, -1);
+  };
+  return classofRaw;
+}
+
+exports.__require = requireClassofRaw;

package/dist/cjs/node_modules/core-js/internals/create-non-enumerable-property.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var descriptors = require('./descriptors.js');
+var objectDefineProperty = require('./object-define-property.js');
+var createPropertyDescriptor = require('./create-property-descriptor.js');
+
+var createNonEnumerableProperty;
+var hasRequiredCreateNonEnumerableProperty;
+function requireCreateNonEnumerableProperty() {
+  if (hasRequiredCreateNonEnumerableProperty) return createNonEnumerableProperty;
+  hasRequiredCreateNonEnumerableProperty = 1;
+  var DESCRIPTORS = descriptors.__require();
+  var definePropertyModule = objectDefineProperty.__require();
+  var createPropertyDescriptor$1 = createPropertyDescriptor.__require();
+  createNonEnumerableProperty = DESCRIPTORS ? function (object, key, value) {
+    return definePropertyModule.f(object, key, createPropertyDescriptor$1(1, value));
+  } : function (object, key, value) {
+    object[key] = value;
+    return object;
+  };
+  return createNonEnumerableProperty;
+}
+
+exports.__require = requireCreateNonEnumerableProperty;

package/dist/cjs/node_modules/core-js/internals/create-property-descriptor.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var createPropertyDescriptor;
+var hasRequiredCreatePropertyDescriptor;
+function requireCreatePropertyDescriptor() {
+  if (hasRequiredCreatePropertyDescriptor) return createPropertyDescriptor;
+  hasRequiredCreatePropertyDescriptor = 1;
+  createPropertyDescriptor = function (bitmap, value) {
+    return {
+      enumerable: !(bitmap & 1),
+      configurable: !(bitmap & 2),
+      writable: !(bitmap & 4),
+      value: value
+    };
+  };
+  return createPropertyDescriptor;
+}
+
+exports.__require = requireCreatePropertyDescriptor;

package/dist/cjs/node_modules/core-js/internals/define-built-in-accessor.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var makeBuiltIn = require('./make-built-in.js');
+var objectDefineProperty = require('./object-define-property.js');
+
+var defineBuiltInAccessor;
+var hasRequiredDefineBuiltInAccessor;
+function requireDefineBuiltInAccessor() {
+  if (hasRequiredDefineBuiltInAccessor) return defineBuiltInAccessor;
+  hasRequiredDefineBuiltInAccessor = 1;
+  var makeBuiltIn$1 = makeBuiltIn.__require();
+  var defineProperty = objectDefineProperty.__require();
+  defineBuiltInAccessor = function (target, name, descriptor) {
+    if (descriptor.get) makeBuiltIn$1(descriptor.get, name, {
+      getter: true
+    });
+    if (descriptor.set) makeBuiltIn$1(descriptor.set, name, {
+      setter: true
+    });
+    return defineProperty.f(target, name, descriptor);
+  };
+  return defineBuiltInAccessor;
+}
+
+exports.__require = requireDefineBuiltInAccessor;

package/dist/cjs/node_modules/core-js/internals/define-global-property.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var globalThis = require('./global-this.js');
+
+var defineGlobalProperty;
+var hasRequiredDefineGlobalProperty;
+function requireDefineGlobalProperty() {
+  if (hasRequiredDefineGlobalProperty) return defineGlobalProperty;
+  hasRequiredDefineGlobalProperty = 1;
+  var globalThis$1 = globalThis.__require();
+
+  // eslint-disable-next-line es/no-object-defineproperty -- safe
+  var defineProperty = Object.defineProperty;
+  defineGlobalProperty = function (key, value) {
+    try {
+      defineProperty(globalThis$1, key, {
+        value: value,
+        configurable: true,
+        writable: true
+      });
+    } catch (error) {
+      globalThis$1[key] = value;
+    }
+    return value;
+  };
+  return defineGlobalProperty;
+}
+
+exports.__require = requireDefineGlobalProperty;

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

@@ -0,0 +1,24 @@
+'use strict';
+
+var fails = require('./fails.js');
+
+var descriptors;
+var hasRequiredDescriptors;
+function requireDescriptors() {
+  if (hasRequiredDescriptors) return descriptors;
+  hasRequiredDescriptors = 1;
+  var fails$1 = fails.__require();
+
+  // Detect IE8's incomplete defineProperty implementation
+  descriptors = !fails$1(function () {
+    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+    return Object.defineProperty({}, 1, {
+      get: function () {
+        return 7;
+      }
+    })[1] !== 7;
+  });
+  return descriptors;
+}
+
+exports.__require = requireDescriptors;

package/dist/cjs/node_modules/core-js/internals/document-create-element.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var globalThis = require('./global-this.js');
+var isObject = require('./is-object.js');
+
+var documentCreateElement;
+var hasRequiredDocumentCreateElement;
+function requireDocumentCreateElement() {
+  if (hasRequiredDocumentCreateElement) return documentCreateElement;
+  hasRequiredDocumentCreateElement = 1;
+  var globalThis$1 = globalThis.__require();
+  var isObject$1 = isObject.__require();
+  var document = globalThis$1.document;
+  // typeof document.createElement is 'object' in old IE
+  var EXISTS = isObject$1(document) && isObject$1(document.createElement);
+  documentCreateElement = function (it) {
+    return EXISTS ? document.createElement(it) : {};
+  };
+  return documentCreateElement;
+}
+
+exports.__require = requireDocumentCreateElement;

package/dist/cjs/node_modules/core-js/internals/environment-user-agent.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var globalThis = require('./global-this.js');
+
+var environmentUserAgent;
+var hasRequiredEnvironmentUserAgent;
+function requireEnvironmentUserAgent() {
+  if (hasRequiredEnvironmentUserAgent) return environmentUserAgent;
+  hasRequiredEnvironmentUserAgent = 1;
+  var globalThis$1 = globalThis.__require();
+  var navigator = globalThis$1.navigator;
+  var userAgent = navigator && navigator.userAgent;
+  environmentUserAgent = userAgent ? String(userAgent) : '';
+  return environmentUserAgent;
+}
+
+exports.__require = requireEnvironmentUserAgent;

package/dist/cjs/node_modules/core-js/internals/environment-v8-version.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var globalThis = require('./global-this.js');
+var environmentUserAgent = require('./environment-user-agent.js');
+
+var environmentV8Version;
+var hasRequiredEnvironmentV8Version;
+function requireEnvironmentV8Version() {
+  if (hasRequiredEnvironmentV8Version) return environmentV8Version;
+  hasRequiredEnvironmentV8Version = 1;
+  var globalThis$1 = globalThis.__require();
+  var userAgent = environmentUserAgent.__require();
+  var process = globalThis$1.process;
+  var Deno = globalThis$1.Deno;
+  var versions = process && process.versions || Deno && Deno.version;
+  var v8 = versions && versions.v8;
+  var match, version;
+  if (v8) {
+    match = v8.split('.');
+    // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+    // but their correct versions are not interesting for us
+    version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+  }
+
+  // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+  // so check `userAgent` even if `.v8` exists, but 0
+  if (!version && userAgent) {
+    match = userAgent.match(/Edge\/(\d+)/);
+    if (!match || match[1] >= 74) {
+      match = userAgent.match(/Chrome\/(\d+)/);
+      if (match) version = +match[1];
+    }
+  }
+  environmentV8Version = version;
+  return environmentV8Version;
+}
+
+exports.__require = requireEnvironmentV8Version;

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var fails;
+var hasRequiredFails;
+function requireFails() {
+  if (hasRequiredFails) return fails;
+  hasRequiredFails = 1;
+  fails = function (exec) {
+    try {
+      return !!exec();
+    } catch (error) {
+      return true;
+    }
+  };
+  return fails;
+}
+
+exports.__require = requireFails;

package/dist/cjs/node_modules/core-js/internals/function-bind-native.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var fails = require('./fails.js');
+
+var functionBindNative;
+var hasRequiredFunctionBindNative;
+function requireFunctionBindNative() {
+  if (hasRequiredFunctionBindNative) return functionBindNative;
+  hasRequiredFunctionBindNative = 1;
+  var fails$1 = fails.__require();
+  functionBindNative = !fails$1(function () {
+    // eslint-disable-next-line es/no-function-prototype-bind -- safe
+    var test = function () {/* empty */}.bind();
+    // eslint-disable-next-line no-prototype-builtins -- safe
+    return typeof test != 'function' || test.hasOwnProperty('prototype');
+  });
+  return functionBindNative;
+}
+
+exports.__require = requireFunctionBindNative;

package/dist/cjs/node_modules/core-js/internals/function-call.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var functionBindNative = require('./function-bind-native.js');
+
+var functionCall;
+var hasRequiredFunctionCall;
+function requireFunctionCall() {
+  if (hasRequiredFunctionCall) return functionCall;
+  hasRequiredFunctionCall = 1;
+  var NATIVE_BIND = functionBindNative.__require();
+  var call = Function.prototype.call;
+  // eslint-disable-next-line es/no-function-prototype-bind -- safe
+  functionCall = NATIVE_BIND ? call.bind(call) : function () {
+    return call.apply(call, arguments);
+  };
+  return functionCall;
+}
+
+exports.__require = requireFunctionCall;

package/dist/cjs/node_modules/core-js/internals/function-name.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var descriptors = require('./descriptors.js');
+var hasOwnProperty = require('./has-own-property.js');
+
+var functionName;
+var hasRequiredFunctionName;
+function requireFunctionName() {
+  if (hasRequiredFunctionName) return functionName;
+  hasRequiredFunctionName = 1;
+  var DESCRIPTORS = descriptors.__require();
+  var hasOwn = hasOwnProperty.__require();
+  var FunctionPrototype = Function.prototype;
+  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+  var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+  var EXISTS = hasOwn(FunctionPrototype, 'name');
+  // additional protection from minified / mangled / dropped function names
+  var PROPER = EXISTS && function something() {/* empty */}.name === 'something';
+  var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable);
+  functionName = {
+    EXISTS: EXISTS,
+    PROPER: PROPER,
+    CONFIGURABLE: CONFIGURABLE
+  };
+  return functionName;
+}
+
+exports.__require = requireFunctionName;

package/dist/cjs/node_modules/core-js/internals/function-uncurry-this.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var functionBindNative = require('./function-bind-native.js');
+
+var functionUncurryThis;
+var hasRequiredFunctionUncurryThis;
+function requireFunctionUncurryThis() {
+  if (hasRequiredFunctionUncurryThis) return functionUncurryThis;
+  hasRequiredFunctionUncurryThis = 1;
+  var NATIVE_BIND = functionBindNative.__require();
+  var FunctionPrototype = Function.prototype;
+  var call = FunctionPrototype.call;
+  // eslint-disable-next-line es/no-function-prototype-bind -- safe
+  var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+  functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
+    return function () {
+      return call.apply(fn, arguments);
+    };
+  };
+  return functionUncurryThis;
+}
+
+exports.__require = requireFunctionUncurryThis;

package/dist/cjs/node_modules/core-js/internals/get-built-in.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var globalThis = require('./global-this.js');
+var isCallable = require('./is-callable.js');
+
+var getBuiltIn;
+var hasRequiredGetBuiltIn;
+function requireGetBuiltIn() {
+  if (hasRequiredGetBuiltIn) return getBuiltIn;
+  hasRequiredGetBuiltIn = 1;
+  var globalThis$1 = globalThis.__require();
+  var isCallable$1 = isCallable.__require();
+  var aFunction = function (argument) {
+    return isCallable$1(argument) ? argument : undefined;
+  };
+  getBuiltIn = function (namespace, method) {
+    return arguments.length < 2 ? aFunction(globalThis$1[namespace]) : globalThis$1[namespace] && globalThis$1[namespace][method];
+  };
+  return getBuiltIn;
+}
+
+exports.__require = requireGetBuiltIn;

package/dist/cjs/node_modules/core-js/internals/get-method.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var aCallable = require('./a-callable.js');
+var isNullOrUndefined = require('./is-null-or-undefined.js');
+
+var getMethod;
+var hasRequiredGetMethod;
+function requireGetMethod() {
+  if (hasRequiredGetMethod) return getMethod;
+  hasRequiredGetMethod = 1;
+  var aCallable$1 = aCallable.__require();
+  var isNullOrUndefined$1 = isNullOrUndefined.__require();
+
+  // `GetMethod` abstract operation
+  // https://tc39.es/ecma262/#sec-getmethod
+  getMethod = function (V, P) {
+    var func = V[P];
+    return isNullOrUndefined$1(func) ? undefined : aCallable$1(func);
+  };
+  return getMethod;
+}
+
+exports.__require = requireGetMethod;

package/dist/cjs/node_modules/core-js/internals/global-this.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var _commonjsHelpers = require('../../../_virtual/_commonjsHelpers.js');
+
+var globalThis_1;
+var hasRequiredGlobalThis;
+function requireGlobalThis() {
+  if (hasRequiredGlobalThis) return globalThis_1;
+  hasRequiredGlobalThis = 1;
+  var check = function (it) {
+    return it && it.Math === Math && it;
+  };
+
+  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+  globalThis_1 =
+  // eslint-disable-next-line es/no-global-this -- safe
+  check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) ||
+  // eslint-disable-next-line no-restricted-globals -- safe
+  check(typeof self == 'object' && self) || check(typeof _commonjsHelpers.commonjsGlobal == 'object' && _commonjsHelpers.commonjsGlobal) || check(typeof globalThis_1 == 'object' && globalThis_1) ||
+  // eslint-disable-next-line no-new-func -- fallback
+  function () {
+    return this;
+  }() || Function('return this')();
+  return globalThis_1;
+}
+
+exports.__require = requireGlobalThis;