web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,25 @@
+import { __module as sharedStore } from '../../../_virtual/shared-store.js';
+import { __require as requireIsPure } from './is-pure.js';
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireDefineGlobalProperty } from './define-global-property.js';
+
+var hasRequiredSharedStore;
+function requireSharedStore() {
+  if (hasRequiredSharedStore) return sharedStore.exports;
+  hasRequiredSharedStore = 1;
+  var IS_PURE = requireIsPure();
+  var globalThis = requireGlobalThis();
+  var defineGlobalProperty = requireDefineGlobalProperty();
+  var SHARED = '__core-js_shared__';
+  var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(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.exports;
+}
+
+export { requireSharedStore as __require };

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

@@ -0,0 +1,15 @@
+import { __require as requireSharedStore } from './shared-store.js';
+
+var shared;
+var hasRequiredShared;
+function requireShared() {
+  if (hasRequiredShared) return shared;
+  hasRequiredShared = 1;
+  var store = requireSharedStore();
+  shared = function (key, value) {
+    return store[key] || (store[key] = value || {});
+  };
+  return shared;
+}
+
+export { requireShared as __require };

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

@@ -0,0 +1,30 @@
+import { __require as requireEnvironmentV8Version } from './environment-v8-version.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireGlobalThis } from './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 = requireEnvironmentV8Version();
+  var fails = requireFails();
+  var globalThis = requireGlobalThis();
+  var $String = globalThis.String;
+
+  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+  symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails(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;
+}
+
+export { requireSymbolConstructorDetection as __require };

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

@@ -0,0 +1,18 @@
+import { __require as requireIndexedObject } from './indexed-object.js';
+import { __require as requireRequireObjectCoercible } from './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 = requireIndexedObject();
+  var requireObjectCoercible = requireRequireObjectCoercible();
+  toIndexedObject = function (it) {
+    return IndexedObject(requireObjectCoercible(it));
+  };
+  return toIndexedObject;
+}
+
+export { requireToIndexedObject as __require };

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

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

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

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

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

@@ -0,0 +1,21 @@
+import { __require as requireToPrimitive } from './to-primitive.js';
+import { __require as requireIsSymbol } from './is-symbol.js';
+
+var toPropertyKey;
+var hasRequiredToPropertyKey;
+function requireToPropertyKey() {
+  if (hasRequiredToPropertyKey) return toPropertyKey;
+  hasRequiredToPropertyKey = 1;
+  var toPrimitive = requireToPrimitive();
+  var isSymbol = requireIsSymbol();
+
+  // `ToPropertyKey` abstract operation
+  // https://tc39.es/ecma262/#sec-topropertykey
+  toPropertyKey = function (argument) {
+    var key = toPrimitive(argument, 'string');
+    return isSymbol(key) ? key : key + '';
+  };
+  return toPropertyKey;
+}
+
+export { requireToPropertyKey as __require };

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

@@ -0,0 +1,17 @@
+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;
+}
+
+export { requireTryToString as __require };

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

@@ -0,0 +1,18 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+
+var uid;
+var hasRequiredUid;
+function requireUid() {
+  if (hasRequiredUid) return uid;
+  hasRequiredUid = 1;
+  var uncurryThis = requireFunctionUncurryThis();
+  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;
+}
+
+export { requireUid as __require };

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

@@ -0,0 +1,14 @@
+import { __require as requireSymbolConstructorDetection } from './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 = requireSymbolConstructorDetection();
+  useSymbolAsUid = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == 'symbol';
+  return useSymbolAsUid;
+}
+
+export { requireUseSymbolAsUid as __require };

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

@@ -0,0 +1,24 @@
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireFails } from './fails.js';
+
+var v8PrototypeDefineBug;
+var hasRequiredV8PrototypeDefineBug;
+function requireV8PrototypeDefineBug() {
+  if (hasRequiredV8PrototypeDefineBug) return v8PrototypeDefineBug;
+  hasRequiredV8PrototypeDefineBug = 1;
+  var DESCRIPTORS = requireDescriptors();
+  var fails = requireFails();
+
+  // V8 ~ Chrome 36-
+  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
+  v8PrototypeDefineBug = DESCRIPTORS && fails(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;
+}
+
+export { requireV8PrototypeDefineBug as __require };

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

@@ -0,0 +1,16 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireIsCallable } from './is-callable.js';
+
+var weakMapBasicDetection;
+var hasRequiredWeakMapBasicDetection;
+function requireWeakMapBasicDetection() {
+  if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
+  hasRequiredWeakMapBasicDetection = 1;
+  var globalThis = requireGlobalThis();
+  var isCallable = requireIsCallable();
+  var WeakMap = globalThis.WeakMap;
+  weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
+  return weakMapBasicDetection;
+}
+
+export { requireWeakMapBasicDetection as __require };

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

@@ -0,0 +1,24 @@
+import { __require as requirePath } from './path.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireWellKnownSymbolWrapped } from './well-known-symbol-wrapped.js';
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+
+var wellKnownSymbolDefine;
+var hasRequiredWellKnownSymbolDefine;
+function requireWellKnownSymbolDefine() {
+  if (hasRequiredWellKnownSymbolDefine) return wellKnownSymbolDefine;
+  hasRequiredWellKnownSymbolDefine = 1;
+  var path = requirePath();
+  var hasOwn = requireHasOwnProperty();
+  var wrappedWellKnownSymbolModule = requireWellKnownSymbolWrapped();
+  var defineProperty = requireObjectDefineProperty().f;
+  wellKnownSymbolDefine = function (NAME) {
+    var Symbol = path.Symbol || (path.Symbol = {});
+    if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
+      value: wrappedWellKnownSymbolModule.f(NAME)
+    });
+  };
+  return wellKnownSymbolDefine;
+}
+
+export { requireWellKnownSymbolDefine as __require };

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

@@ -0,0 +1,13 @@
+import { __exports as wellKnownSymbolWrapped } from '../../../_virtual/well-known-symbol-wrapped.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var hasRequiredWellKnownSymbolWrapped;
+function requireWellKnownSymbolWrapped() {
+  if (hasRequiredWellKnownSymbolWrapped) return wellKnownSymbolWrapped;
+  hasRequiredWellKnownSymbolWrapped = 1;
+  var wellKnownSymbol = requireWellKnownSymbol();
+  wellKnownSymbolWrapped.f = wellKnownSymbol;
+  return wellKnownSymbolWrapped;
+}
+
+export { requireWellKnownSymbolWrapped as __require };

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

@@ -0,0 +1,31 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireShared } from './shared.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireUid } from './uid.js';
+import { __require as requireSymbolConstructorDetection } from './symbol-constructor-detection.js';
+import { __require as requireUseSymbolAsUid } from './use-symbol-as-uid.js';
+
+var wellKnownSymbol;
+var hasRequiredWellKnownSymbol;
+function requireWellKnownSymbol() {
+  if (hasRequiredWellKnownSymbol) return wellKnownSymbol;
+  hasRequiredWellKnownSymbol = 1;
+  var globalThis = requireGlobalThis();
+  var shared = requireShared();
+  var hasOwn = requireHasOwnProperty();
+  var uid = requireUid();
+  var NATIVE_SYMBOL = requireSymbolConstructorDetection();
+  var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
+  var Symbol = globalThis.Symbol;
+  var WellKnownSymbolsStore = shared('wks');
+  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
+  wellKnownSymbol = function (name) {
+    if (!hasOwn(WellKnownSymbolsStore, name)) {
+      WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name) ? Symbol[name] : createWellKnownSymbol('Symbol.' + name);
+    }
+    return WellKnownSymbolsStore[name];
+  };
+  return wellKnownSymbol;
+}
+
+export { requireWellKnownSymbol as __require };

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

@@ -0,0 +1,28 @@
+import { __exports as es_regexp_flags } from '../../../_virtual/es.regexp.flags2.js';
+import { __require as requireDescriptors } from '../internals/descriptors.js';
+import { __require as requireDefineBuiltInAccessor } from '../internals/define-built-in-accessor.js';
+import { __require as requireRegexpFlagsDetection } from '../internals/regexp-flags-detection.js';
+import { __require as requireRegexpFlags } from '../internals/regexp-flags.js';
+
+var hasRequiredEs_regexp_flags;
+function requireEs_regexp_flags() {
+  if (hasRequiredEs_regexp_flags) return es_regexp_flags;
+  hasRequiredEs_regexp_flags = 1;
+  var DESCRIPTORS = requireDescriptors();
+  var defineBuiltInAccessor = requireDefineBuiltInAccessor();
+  var regExpFlagsDetection = requireRegexpFlagsDetection();
+  var regExpFlagsGetterImplementation = requireRegexpFlags();
+
+  // `RegExp.prototype.flags` getter
+  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
+  if (DESCRIPTORS && !regExpFlagsDetection.correct) {
+    defineBuiltInAccessor(RegExp.prototype, 'flags', {
+      configurable: true,
+      get: regExpFlagsGetterImplementation
+    });
+    regExpFlagsDetection.correct = true;
+  }
+  return es_regexp_flags;
+}
+
+export { requireEs_regexp_flags as __require };

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

@@ -0,0 +1,37 @@
+import { __exports as es_symbol_dispose } from '../../../_virtual/es.symbol.dispose.js';
+import { __require as requireGlobalThis } from '../internals/global-this.js';
+import { __require as requireWellKnownSymbolDefine } from '../internals/well-known-symbol-define.js';
+import { __require as requireObjectDefineProperty } from '../internals/object-define-property.js';
+import { __require as requireObjectGetOwnPropertyDescriptor } from '../internals/object-get-own-property-descriptor.js';
+
+var hasRequiredEs_symbol_dispose;
+function requireEs_symbol_dispose() {
+  if (hasRequiredEs_symbol_dispose) return es_symbol_dispose;
+  hasRequiredEs_symbol_dispose = 1;
+  var globalThis = requireGlobalThis();
+  var defineWellKnownSymbol = requireWellKnownSymbolDefine();
+  var defineProperty = requireObjectDefineProperty().f;
+  var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
+  var Symbol = globalThis.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;
+}
+
+export { requireEs_symbol_dispose as __require };

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

@@ -0,0 +1,13 @@
+import { __exports as esnext_symbol_dispose } from '../../../_virtual/esnext.symbol.dispose2.js';
+import { __require as requireEs_symbol_dispose } from './es.symbol.dispose.js';
+
+var hasRequiredEsnext_symbol_dispose;
+function requireEsnext_symbol_dispose() {
+  if (hasRequiredEsnext_symbol_dispose) return esnext_symbol_dispose;
+  hasRequiredEsnext_symbol_dispose = 1;
+  // TODO: Remove from `core-js@4`
+  requireEs_symbol_dispose();
+  return esnext_symbol_dispose;
+}
+
+export { requireEsnext_symbol_dispose as __require };

package/dist/esm/node_modules/datastore-core/dist/src/base.js

@@ -0,0 +1,147 @@
+import drain from '../../../it-drain/dist/src/index.js';
+import filter from '../../../it-filter/dist/src/index.js';
+import sort from '../../../it-sort/dist/src/index.js';
+import take from '../../../it-take/dist/src/index.js';
+
+class BaseDatastore {
+  put(key, val, options) {
+    return Promise.reject(new Error('.put is not implemented'));
+  }
+  get(key, options) {
+    return Promise.reject(new Error('.get is not implemented'));
+  }
+  has(key, options) {
+    return Promise.reject(new Error('.has is not implemented'));
+  }
+  delete(key, options) {
+    return Promise.reject(new Error('.delete is not implemented'));
+  }
+  putMany(source) {
+    try {
+      var _this = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        for await (const {
+          key,
+          value
+        } of source) {
+          await _this.put(key, value, options);
+          yield key;
+        }
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getMany(source) {
+    try {
+      var _this2 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        for await (const key of source) {
+          yield {
+            key,
+            value: await _this2.get(key, options)
+          };
+        }
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  deleteMany(source) {
+    try {
+      var _this3 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        for await (const key of source) {
+          await _this3.delete(key, options);
+          yield key;
+        }
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  batch() {
+    let puts = [];
+    let dels = [];
+    return {
+      put(key, value) {
+        puts.push({
+          key,
+          value
+        });
+      },
+      delete(key) {
+        dels.push(key);
+      },
+      commit: async options => {
+        await drain(this.putMany(puts, options));
+        puts = [];
+        await drain(this.deleteMany(dels, options));
+        dels = [];
+      }
+    };
+  }
+  /**
+   * Extending classes should override `query` or implement this method
+   */
+  // eslint-disable-next-line require-yield
+  async *_all(q, options) {
+    throw new Error('._all is not implemented');
+  }
+  /**
+   * Extending classes should override `queryKeys` or implement this method
+   */
+  // eslint-disable-next-line require-yield
+  async *_allKeys(q, options) {
+    throw new Error('._allKeys is not implemented');
+  }
+  query(q, options) {
+    let it = this._all(q, options);
+    if (q.prefix != null) {
+      const prefix = q.prefix;
+      it = filter(it, e => e.key.toString().startsWith(prefix));
+    }
+    if (Array.isArray(q.filters)) {
+      it = q.filters.reduce((it, f) => filter(it, f), it);
+    }
+    if (Array.isArray(q.orders)) {
+      it = q.orders.reduce((it, f) => sort(it, f), it);
+    }
+    if (q.offset != null) {
+      let i = 0;
+      const offset = q.offset;
+      it = filter(it, () => i++ >= offset);
+    }
+    if (q.limit != null) {
+      it = take(it, q.limit);
+    }
+    return it;
+  }
+  queryKeys(q, options) {
+    let it = this._allKeys(q, options);
+    if (q.prefix != null) {
+      const prefix = q.prefix;
+      it = filter(it, key => key.toString().startsWith(prefix));
+    }
+    if (Array.isArray(q.filters)) {
+      it = q.filters.reduce((it, f) => filter(it, f), it);
+    }
+    if (Array.isArray(q.orders)) {
+      it = q.orders.reduce((it, f) => sort(it, f), it);
+    }
+    if (q.offset != null) {
+      const offset = q.offset;
+      let i = 0;
+      it = filter(it, () => i++ >= offset);
+    }
+    if (q.limit != null) {
+      it = take(it, q.limit);
+    }
+    return it;
+  }
+}
+
+export { BaseDatastore };

package/dist/esm/node_modules/datastore-core/dist/src/shard.js

@@ -0,0 +1,5 @@
+import '../../../interface-datastore/dist/src/key.js';
+
+const SHARDING_FN = 'SHARDING';
+
+export { SHARDING_FN };

package/dist/esm/node_modules/datastore-core/dist/src/sharding.js

@@ -0,0 +1,4 @@
+import { Key } from '../../../interface-datastore/dist/src/key.js';
+import { SHARDING_FN } from './shard.js';
+
+new Key(SHARDING_FN);

package/dist/esm/node_modules/datastore-core/dist/src/tiered.js

@@ -0,0 +1,3 @@
+import { logger } from '../../../@libp2p/logger/dist/src/index.js';
+
+logger('datastore:core:tiered');

package/dist/esm/node_modules/define-data-property/index.js

@@ -0,0 +1,60 @@
+import { __require as requireEsDefineProperty } from '../es-define-property/index.js';
+import { __require as requireSyntax } from '../es-errors/syntax.js';
+import { __require as requireType } from '../es-errors/type.js';
+import { __require as requireGopd } from '../gopd/index.js';
+
+var defineDataProperty;
+var hasRequiredDefineDataProperty;
+function requireDefineDataProperty() {
+  if (hasRequiredDefineDataProperty) return defineDataProperty;
+  hasRequiredDefineDataProperty = 1;
+  var $defineProperty = /*@__PURE__*/requireEsDefineProperty();
+  var $SyntaxError = /*@__PURE__*/requireSyntax();
+  var $TypeError = /*@__PURE__*/requireType();
+  var gopd = /*@__PURE__*/requireGopd();
+
+  /** @type {import('.')} */
+  defineDataProperty = function defineDataProperty(obj, property, value) {
+    if (!obj || typeof obj !== 'object' && typeof obj !== 'function') {
+      throw new $TypeError('`obj` must be an object or a function`');
+    }
+    if (typeof property !== 'string' && typeof property !== 'symbol') {
+      throw new $TypeError('`property` must be a string or a symbol`');
+    }
+    if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {
+      throw new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');
+    }
+    if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {
+      throw new $TypeError('`nonWritable`, if provided, must be a boolean or null');
+    }
+    if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {
+      throw new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');
+    }
+    if (arguments.length > 6 && typeof arguments[6] !== 'boolean') {
+      throw new $TypeError('`loose`, if provided, must be a boolean');
+    }
+    var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+    var nonWritable = arguments.length > 4 ? arguments[4] : null;
+    var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+    var loose = arguments.length > 6 ? arguments[6] : false;
+
+    /* @type {false | TypedPropertyDescriptor<unknown>} */
+    var desc = !!gopd && gopd(obj, property);
+    if ($defineProperty) {
+      $defineProperty(obj, property, {
+        configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+        enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+        value: value,
+        writable: nonWritable === null && desc ? desc.writable : !nonWritable
+      });
+    } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
+      // must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable
+      obj[property] = value; // eslint-disable-line no-param-reassign
+    } else {
+      throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');
+    }
+  };
+  return defineDataProperty;
+}
+
+export { requireDefineDataProperty as __require };