web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/get-intrinsic/index.js

@@ -0,0 +1,374 @@
+import { __require as requireEsObjectAtoms } from '../es-object-atoms/index.js';
+import { __require as requireEsErrors } from '../es-errors/index.js';
+import { __require as require_eval } from '../es-errors/eval.js';
+import { __require as requireRange } from '../es-errors/range.js';
+import { __require as requireRef } from '../es-errors/ref.js';
+import { __require as requireSyntax } from '../es-errors/syntax.js';
+import { __require as requireType } from '../es-errors/type.js';
+import { __require as requireUri } from '../es-errors/uri.js';
+import { __require as requireAbs } from '../math-intrinsics/abs.js';
+import { __require as requireFloor } from '../math-intrinsics/floor.js';
+import { __require as requireMax } from '../math-intrinsics/max.js';
+import { __require as requireMin } from '../math-intrinsics/min.js';
+import { __require as requirePow } from '../math-intrinsics/pow.js';
+import { __require as requireRound } from '../math-intrinsics/round.js';
+import { __require as requireSign } from '../math-intrinsics/sign.js';
+import { __require as requireGopd } from '../gopd/index.js';
+import { __require as requireEsDefineProperty } from '../es-define-property/index.js';
+import { __require as requireHasSymbols } from '../has-symbols/index.js';
+import { __require as requireGetProto } from '../get-proto/index.js';
+import { __require as requireObject_getPrototypeOf } from '../get-proto/Object.getPrototypeOf.js';
+import { __require as requireReflect_getPrototypeOf } from '../get-proto/Reflect.getPrototypeOf.js';
+import { __require as requireFunctionApply } from '../call-bind-apply-helpers/functionApply.js';
+import { __require as requireFunctionCall } from '../call-bind-apply-helpers/functionCall.js';
+import { __require as requireFunctionBind } from '../function-bind/index.js';
+import { __require as requireHasown } from '../hasown/index.js';
+
+var getIntrinsic;
+var hasRequiredGetIntrinsic;
+function requireGetIntrinsic() {
+  if (hasRequiredGetIntrinsic) return getIntrinsic;
+  hasRequiredGetIntrinsic = 1;
+  var undefined$1;
+  var $Object = /*@__PURE__*/requireEsObjectAtoms();
+  var $Error = /*@__PURE__*/requireEsErrors();
+  var $EvalError = /*@__PURE__*/require_eval();
+  var $RangeError = /*@__PURE__*/requireRange();
+  var $ReferenceError = /*@__PURE__*/requireRef();
+  var $SyntaxError = /*@__PURE__*/requireSyntax();
+  var $TypeError = /*@__PURE__*/requireType();
+  var $URIError = /*@__PURE__*/requireUri();
+  var abs = /*@__PURE__*/requireAbs();
+  var floor = /*@__PURE__*/requireFloor();
+  var max = /*@__PURE__*/requireMax();
+  var min = /*@__PURE__*/requireMin();
+  var pow = /*@__PURE__*/requirePow();
+  var round = /*@__PURE__*/requireRound();
+  var sign = /*@__PURE__*/requireSign();
+  var $Function = Function;
+
+  // eslint-disable-next-line consistent-return
+  var getEvalledConstructor = function (expressionSyntax) {
+    try {
+      return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+    } catch (e) {}
+  };
+  var $gOPD = /*@__PURE__*/requireGopd();
+  var $defineProperty = /*@__PURE__*/requireEsDefineProperty();
+  var throwTypeError = function () {
+    throw new $TypeError();
+  };
+  var ThrowTypeError = $gOPD ? function () {
+    try {
+      // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+      arguments.callee; // IE 8 does not throw here
+      return throwTypeError;
+    } catch (calleeThrows) {
+      try {
+        // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+        return $gOPD(arguments, 'callee').get;
+      } catch (gOPDthrows) {
+        return throwTypeError;
+      }
+    }
+  }() : throwTypeError;
+  var hasSymbols = requireHasSymbols()();
+  var getProto = requireGetProto();
+  var $ObjectGPO = requireObject_getPrototypeOf();
+  var $ReflectGPO = requireReflect_getPrototypeOf();
+  var $apply = requireFunctionApply();
+  var $call = requireFunctionCall();
+  var needsEval = {};
+  var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined$1 : getProto(Uint8Array);
+  var INTRINSICS = {
+    __proto__: null,
+    '%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
+    '%Array%': Array,
+    '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
+    '%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined$1,
+    '%AsyncFromSyncIteratorPrototype%': undefined$1,
+    '%AsyncFunction%': needsEval,
+    '%AsyncGenerator%': needsEval,
+    '%AsyncGeneratorFunction%': needsEval,
+    '%AsyncIteratorPrototype%': needsEval,
+    '%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
+    '%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
+    '%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined$1 : BigInt64Array,
+    '%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined$1 : BigUint64Array,
+    '%Boolean%': Boolean,
+    '%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+    '%Date%': Date,
+    '%decodeURI%': decodeURI,
+    '%decodeURIComponent%': decodeURIComponent,
+    '%encodeURI%': encodeURI,
+    '%encodeURIComponent%': encodeURIComponent,
+    '%Error%': $Error,
+    '%eval%': eval,
+    // eslint-disable-line no-eval
+    '%EvalError%': $EvalError,
+    '%Float16Array%': typeof Float16Array === 'undefined' ? undefined$1 : Float16Array,
+    '%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+    '%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
+    '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+    '%Function%': $Function,
+    '%GeneratorFunction%': needsEval,
+    '%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+    '%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+    '%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+    '%isFinite%': isFinite,
+    '%isNaN%': isNaN,
+    '%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
+    '%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+    '%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+    '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
+    '%Math%': Math,
+    '%Number%': Number,
+    '%Object%': $Object,
+    '%Object.getOwnPropertyDescriptor%': $gOPD,
+    '%parseFloat%': parseFloat,
+    '%parseInt%': parseInt,
+    '%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+    '%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
+    '%RangeError%': $RangeError,
+    '%ReferenceError%': $ReferenceError,
+    '%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
+    '%RegExp%': RegExp,
+    '%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
+    '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+    '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+    '%String%': String,
+    '%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined$1,
+    '%Symbol%': hasSymbols ? Symbol : undefined$1,
+    '%SyntaxError%': $SyntaxError,
+    '%ThrowTypeError%': ThrowTypeError,
+    '%TypedArray%': TypedArray,
+    '%TypeError%': $TypeError,
+    '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+    '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+    '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+    '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+    '%URIError%': $URIError,
+    '%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
+    '%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
+    '%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet,
+    '%Function.prototype.call%': $call,
+    '%Function.prototype.apply%': $apply,
+    '%Object.defineProperty%': $defineProperty,
+    '%Object.getPrototypeOf%': $ObjectGPO,
+    '%Math.abs%': abs,
+    '%Math.floor%': floor,
+    '%Math.max%': max,
+    '%Math.min%': min,
+    '%Math.pow%': pow,
+    '%Math.round%': round,
+    '%Math.sign%': sign,
+    '%Reflect.getPrototypeOf%': $ReflectGPO
+  };
+  if (getProto) {
+    try {
+      null.error; // eslint-disable-line no-unused-expressions
+    } catch (e) {
+      // https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
+      var errorProto = getProto(getProto(e));
+      INTRINSICS['%Error.prototype%'] = errorProto;
+    }
+  }
+  var doEval = function doEval(name) {
+    var value;
+    if (name === '%AsyncFunction%') {
+      value = getEvalledConstructor('async function () {}');
+    } else if (name === '%GeneratorFunction%') {
+      value = getEvalledConstructor('function* () {}');
+    } else if (name === '%AsyncGeneratorFunction%') {
+      value = getEvalledConstructor('async function* () {}');
+    } else if (name === '%AsyncGenerator%') {
+      var fn = doEval('%AsyncGeneratorFunction%');
+      if (fn) {
+        value = fn.prototype;
+      }
+    } else if (name === '%AsyncIteratorPrototype%') {
+      var gen = doEval('%AsyncGenerator%');
+      if (gen && getProto) {
+        value = getProto(gen.prototype);
+      }
+    }
+    INTRINSICS[name] = value;
+    return value;
+  };
+  var LEGACY_ALIASES = {
+    __proto__: null,
+    '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
+    '%ArrayPrototype%': ['Array', 'prototype'],
+    '%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
+    '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
+    '%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
+    '%ArrayProto_values%': ['Array', 'prototype', 'values'],
+    '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
+    '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
+    '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
+    '%BooleanPrototype%': ['Boolean', 'prototype'],
+    '%DataViewPrototype%': ['DataView', 'prototype'],
+    '%DatePrototype%': ['Date', 'prototype'],
+    '%ErrorPrototype%': ['Error', 'prototype'],
+    '%EvalErrorPrototype%': ['EvalError', 'prototype'],
+    '%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
+    '%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
+    '%FunctionPrototype%': ['Function', 'prototype'],
+    '%Generator%': ['GeneratorFunction', 'prototype'],
+    '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
+    '%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
+    '%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
+    '%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
+    '%JSONParse%': ['JSON', 'parse'],
+    '%JSONStringify%': ['JSON', 'stringify'],
+    '%MapPrototype%': ['Map', 'prototype'],
+    '%NumberPrototype%': ['Number', 'prototype'],
+    '%ObjectPrototype%': ['Object', 'prototype'],
+    '%ObjProto_toString%': ['Object', 'prototype', 'toString'],
+    '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
+    '%PromisePrototype%': ['Promise', 'prototype'],
+    '%PromiseProto_then%': ['Promise', 'prototype', 'then'],
+    '%Promise_all%': ['Promise', 'all'],
+    '%Promise_reject%': ['Promise', 'reject'],
+    '%Promise_resolve%': ['Promise', 'resolve'],
+    '%RangeErrorPrototype%': ['RangeError', 'prototype'],
+    '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
+    '%RegExpPrototype%': ['RegExp', 'prototype'],
+    '%SetPrototype%': ['Set', 'prototype'],
+    '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
+    '%StringPrototype%': ['String', 'prototype'],
+    '%SymbolPrototype%': ['Symbol', 'prototype'],
+    '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
+    '%TypedArrayPrototype%': ['TypedArray', 'prototype'],
+    '%TypeErrorPrototype%': ['TypeError', 'prototype'],
+    '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
+    '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
+    '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
+    '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
+    '%URIErrorPrototype%': ['URIError', 'prototype'],
+    '%WeakMapPrototype%': ['WeakMap', 'prototype'],
+    '%WeakSetPrototype%': ['WeakSet', 'prototype']
+  };
+  var bind = requireFunctionBind();
+  var hasOwn = /*@__PURE__*/requireHasown();
+  var $concat = bind.call($call, Array.prototype.concat);
+  var $spliceApply = bind.call($apply, Array.prototype.splice);
+  var $replace = bind.call($call, String.prototype.replace);
+  var $strSlice = bind.call($call, String.prototype.slice);
+  var $exec = bind.call($call, RegExp.prototype.exec);
+
+  /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+  var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+  var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
+  var stringToPath = function stringToPath(string) {
+    var first = $strSlice(string, 0, 1);
+    var last = $strSlice(string, -1);
+    if (first === '%' && last !== '%') {
+      throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
+    } else if (last === '%' && first !== '%') {
+      throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
+    }
+    var result = [];
+    $replace(string, rePropName, function (match, number, quote, subString) {
+      result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
+    });
+    return result;
+  };
+  /* end adaptation */
+
+  var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
+    var intrinsicName = name;
+    var alias;
+    if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+      alias = LEGACY_ALIASES[intrinsicName];
+      intrinsicName = '%' + alias[0] + '%';
+    }
+    if (hasOwn(INTRINSICS, intrinsicName)) {
+      var value = INTRINSICS[intrinsicName];
+      if (value === needsEval) {
+        value = doEval(intrinsicName);
+      }
+      if (typeof value === 'undefined' && !allowMissing) {
+        throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+      }
+      return {
+        alias: alias,
+        name: intrinsicName,
+        value: value
+      };
+    }
+    throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
+  };
+  getIntrinsic = function GetIntrinsic(name, allowMissing) {
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new $TypeError('intrinsic name must be a non-empty string');
+    }
+    if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+      throw new $TypeError('"allowMissing" argument must be a boolean');
+    }
+    if ($exec(/^%?[^%]*%?$/, name) === null) {
+      throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
+    }
+    var parts = stringToPath(name);
+    var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
+    var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
+    var intrinsicRealName = intrinsic.name;
+    var value = intrinsic.value;
+    var skipFurtherCaching = false;
+    var alias = intrinsic.alias;
+    if (alias) {
+      intrinsicBaseName = alias[0];
+      $spliceApply(parts, $concat([0, 1], alias));
+    }
+    for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+      var part = parts[i];
+      var first = $strSlice(part, 0, 1);
+      var last = $strSlice(part, -1);
+      if ((first === '"' || first === "'" || first === '`' || last === '"' || last === "'" || last === '`') && first !== last) {
+        throw new $SyntaxError('property names with quotes must have matching quotes');
+      }
+      if (part === 'constructor' || !isOwn) {
+        skipFurtherCaching = true;
+      }
+      intrinsicBaseName += '.' + part;
+      intrinsicRealName = '%' + intrinsicBaseName + '%';
+      if (hasOwn(INTRINSICS, intrinsicRealName)) {
+        value = INTRINSICS[intrinsicRealName];
+      } else if (value != null) {
+        if (!(part in value)) {
+          if (!allowMissing) {
+            throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
+          }
+          return void undefined$1;
+        }
+        if ($gOPD && i + 1 >= parts.length) {
+          var desc = $gOPD(value, part);
+          isOwn = !!desc;
+
+          // By convention, when a data property is converted to an accessor
+          // property to emulate a data property that does not suffer from
+          // the override mistake, that accessor's getter is marked with
+          // an `originalValue` property. Here, when we detect this, we
+          // uphold the illusion by pretending to see that original data
+          // property, i.e., returning the value rather than the getter
+          // itself.
+          if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
+            value = desc.get;
+          } else {
+            value = value[part];
+          }
+        } else {
+          isOwn = hasOwn(value, part);
+          value = value[part];
+        }
+        if (isOwn && !skipFurtherCaching) {
+          INTRINSICS[intrinsicRealName] = value;
+        }
+      }
+    }
+    return value;
+  };
+  return getIntrinsic;
+}
+
+export { requireGetIntrinsic as __require };

package/dist/esm/node_modules/get-iterator/dist/src/index.js

@@ -0,0 +1,16 @@
+function getIterator(obj) {
+  if (obj != null) {
+    if (typeof obj[Symbol.iterator] === 'function') {
+      return obj[Symbol.iterator]();
+    }
+    if (typeof obj[Symbol.asyncIterator] === 'function') {
+      return obj[Symbol.asyncIterator]();
+    }
+    if (typeof obj.next === 'function') {
+      return obj; // probably an iterator
+    }
+  }
+  throw new Error('argument is not an iterator or iterable');
+}
+
+export { getIterator };

package/dist/esm/node_modules/get-proto/Object.getPrototypeOf.js

@@ -0,0 +1,15 @@
+import { __require as requireEsObjectAtoms } from '../es-object-atoms/index.js';
+
+var Object_getPrototypeOf;
+var hasRequiredObject_getPrototypeOf;
+function requireObject_getPrototypeOf() {
+  if (hasRequiredObject_getPrototypeOf) return Object_getPrototypeOf;
+  hasRequiredObject_getPrototypeOf = 1;
+  var $Object = /*@__PURE__*/requireEsObjectAtoms();
+
+  /** @type {import('./Object.getPrototypeOf')} */
+  Object_getPrototypeOf = $Object.getPrototypeOf || null;
+  return Object_getPrototypeOf;
+}
+
+export { requireObject_getPrototypeOf as __require };

package/dist/esm/node_modules/get-proto/Reflect.getPrototypeOf.js

@@ -0,0 +1,12 @@
+var Reflect_getPrototypeOf;
+var hasRequiredReflect_getPrototypeOf;
+function requireReflect_getPrototypeOf() {
+  if (hasRequiredReflect_getPrototypeOf) return Reflect_getPrototypeOf;
+  hasRequiredReflect_getPrototypeOf = 1;
+
+  /** @type {import('./Reflect.getPrototypeOf')} */
+  Reflect_getPrototypeOf = typeof Reflect !== 'undefined' && Reflect.getPrototypeOf || null;
+  return Reflect_getPrototypeOf;
+}
+
+export { requireReflect_getPrototypeOf as __require };

package/dist/esm/node_modules/get-proto/index.js

@@ -0,0 +1,31 @@
+import { __require as requireReflect_getPrototypeOf } from './Reflect.getPrototypeOf.js';
+import { __require as requireObject_getPrototypeOf } from './Object.getPrototypeOf.js';
+import { __require as requireGet } from '../dunder-proto/get.js';
+
+var getProto;
+var hasRequiredGetProto;
+function requireGetProto() {
+  if (hasRequiredGetProto) return getProto;
+  hasRequiredGetProto = 1;
+  var reflectGetProto = requireReflect_getPrototypeOf();
+  var originalGetProto = requireObject_getPrototypeOf();
+  var getDunderProto = /*@__PURE__*/requireGet();
+
+  /** @type {import('.')} */
+  getProto = reflectGetProto ? function getProto(O) {
+    // @ts-expect-error TS can't narrow inside a closure, for some reason
+    return reflectGetProto(O);
+  } : originalGetProto ? function getProto(O) {
+    if (!O || typeof O !== 'object' && typeof O !== 'function') {
+      throw new TypeError('getProto: not an object');
+    }
+    // @ts-expect-error TS can't narrow inside a closure, for some reason
+    return originalGetProto(O);
+  } : getDunderProto ? function getProto(O) {
+    // @ts-expect-error TS can't narrow inside a closure, for some reason
+    return getDunderProto(O);
+  } : null;
+  return getProto;
+}
+
+export { requireGetProto as __require };

package/dist/esm/node_modules/gopd/gOPD.js

@@ -0,0 +1,12 @@
+var gOPD;
+var hasRequiredGOPD;
+function requireGOPD() {
+  if (hasRequiredGOPD) return gOPD;
+  hasRequiredGOPD = 1;
+
+  /** @type {import('./gOPD')} */
+  gOPD = Object.getOwnPropertyDescriptor;
+  return gOPD;
+}
+
+export { requireGOPD as __require };

package/dist/esm/node_modules/gopd/index.js

@@ -0,0 +1,23 @@
+import { __require as requireGOPD } from './gOPD.js';
+
+var gopd;
+var hasRequiredGopd;
+function requireGopd() {
+  if (hasRequiredGopd) return gopd;
+  hasRequiredGopd = 1;
+
+  /** @type {import('.')} */
+  var $gOPD = /*@__PURE__*/requireGOPD();
+  if ($gOPD) {
+    try {
+      $gOPD([], 'length');
+    } catch (e) {
+      // IE 8 has a broken gOPD
+      $gOPD = null;
+    }
+  }
+  gopd = $gOPD;
+  return gopd;
+}
+
+export { requireGopd as __require };