@socketsecurity/lib 5.23.0 → 5.25.0

package/dist/objects.js

@@ -43,46 +43,35 @@ __export(objects_exports, {
 module.exports = __toCommonJS(objects_exports);
 var import_core = require("./constants/core");
 var import_arrays = require("./arrays");
+var import_primordials = require("./primordials");
 var import_sorts = require("./sorts");
-const ObjectDefineProperties = Object.defineProperties;
-const ObjectDefineProperty = Object.defineProperty;
-const ObjectFreeze = Object.freeze;
-const ObjectFromEntries = Object.fromEntries;
-const ObjectGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
-const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
-const ObjectGetPrototypeOf = Object.getPrototypeOf;
-const ObjectHasOwn = Object.hasOwn;
-const ObjectKeys = Object.keys;
-const ObjectPrototype = Object.prototype;
-const ObjectSetPrototypeOf = Object.setPrototypeOf;
-const ReflectOwnKeys = Reflect.ownKeys;
 // @__NO_SIDE_EFFECTS__
 function createConstantsObject(props, options_) {
   const options = { __proto__: null, ...options_ };
-  const attributes = ObjectFreeze({
+  const attributes = (0, import_primordials.ObjectFreeze)({
     __proto__: null,
-    getters: options.getters ? ObjectFreeze(
-      ObjectSetPrototypeOf(/* @__PURE__ */ toSortedObject(options.getters), null)
+    getters: options.getters ? (0, import_primordials.ObjectFreeze)(
+      (0, import_primordials.ObjectSetPrototypeOf)(/* @__PURE__ */ toSortedObject(options.getters), null)
     ) : void 0,
-    internals: options.internals ? ObjectFreeze(
-      ObjectSetPrototypeOf(/* @__PURE__ */ toSortedObject(options.internals), null)
+    internals: options.internals ? (0, import_primordials.ObjectFreeze)(
+      (0, import_primordials.ObjectSetPrototypeOf)(/* @__PURE__ */ toSortedObject(options.internals), null)
     ) : void 0,
-    mixin: options.mixin ? ObjectFreeze(
-      ObjectDefineProperties(
+    mixin: options.mixin ? (0, import_primordials.ObjectFreeze)(
+      (0, import_primordials.ObjectDefineProperties)(
         { __proto__: null },
-        ObjectGetOwnPropertyDescriptors(options.mixin)
+        (0, import_primordials.ObjectGetOwnPropertyDescriptors)(options.mixin)
       )
     ) : void 0,
-    props: props ? ObjectFreeze(ObjectSetPrototypeOf(/* @__PURE__ */ toSortedObject(props), null)) : void 0
+    props: props ? (0, import_primordials.ObjectFreeze)((0, import_primordials.ObjectSetPrototypeOf)(/* @__PURE__ */ toSortedObject(props), null)) : void 0
   });
-  const lazyGetterStats = ObjectFreeze({
+  const lazyGetterStats = (0, import_primordials.ObjectFreeze)({
     __proto__: null,
     initialized: /* @__PURE__ */ new Set()
   });
   const object = defineLazyGetters(
     {
       __proto__: null,
-      [import_core.kInternalsSymbol]: ObjectFreeze({
+      [import_core.kInternalsSymbol]: (0, import_primordials.ObjectFreeze)({
         __proto__: null,
         get attributes() {
           return attributes;
@@ -99,16 +88,16 @@ function createConstantsObject(props, options_) {
     lazyGetterStats
   );
   if (attributes.mixin) {
-    ObjectDefineProperties(
+    (0, import_primordials.ObjectDefineProperties)(
       object,
       /* @__PURE__ */ toSortedObjectFromEntries(
-        (/* @__PURE__ */ objectEntries(ObjectGetOwnPropertyDescriptors(attributes.mixin))).filter(
-          (p) => !ObjectHasOwn(object, p[0])
+        (/* @__PURE__ */ objectEntries((0, import_primordials.ObjectGetOwnPropertyDescriptors)(attributes.mixin))).filter(
+          (p) => !(0, import_primordials.ObjectHasOwn)(object, p[0])
         )
       )
     );
   }
-  return ObjectFreeze(object);
+  return (0, import_primordials.ObjectFreeze)(object);
 }
 // @__NO_SIDE_EFFECTS__
 function createLazyGetter(name, getter, stats) {
@@ -125,7 +114,7 @@ function createLazyGetter(name, getter, stats) {
   return lazyGetter;
 }
 function defineGetter(object, propKey, getter) {
-  ObjectDefineProperty(object, propKey, {
+  (0, import_primordials.ObjectDefineProperty)(object, propKey, {
     get: getter,
     enumerable: false,
     configurable: true
@@ -137,7 +126,7 @@ function defineLazyGetter(object, propKey, getter, stats) {
 }
 function defineLazyGetters(object, getterDefObj, stats) {
   if (getterDefObj !== null && typeof getterDefObj === "object") {
-    const keys = ReflectOwnKeys(getterDefObj);
+    const keys = (0, import_primordials.ReflectOwnKeys)(getterDefObj);
     for (let i = 0, { length } = keys; i < length; i += 1) {
       const key = keys[i];
       defineLazyGetter(object, key, getterDefObj[key], stats);
@@ -155,21 +144,21 @@ function entryKeyComparator(a, b) {
 }
 // @__NO_SIDE_EFFECTS__
 function getKeys(obj) {
-  return /* @__PURE__ */ isObject(obj) ? ObjectKeys(obj) : [];
+  return /* @__PURE__ */ isObject(obj) ? (0, import_primordials.ObjectKeys)(obj) : [];
 }
 // @__NO_SIDE_EFFECTS__
 function getOwn(obj, propKey) {
   if (obj === null || obj === void 0) {
     return void 0;
   }
-  return ObjectHasOwn(obj, propKey) ? obj[propKey] : void 0;
+  return (0, import_primordials.ObjectHasOwn)(obj, propKey) ? obj[propKey] : void 0;
 }
 // @__NO_SIDE_EFFECTS__
 function getOwnPropertyValues(obj) {
   if (obj === null || obj === void 0) {
     return [];
   }
-  const keys = ObjectGetOwnPropertyNames(obj);
+  const keys = (0, import_primordials.ObjectGetOwnPropertyNames)(obj);
   const { length } = keys;
   const values = Array(length);
   for (let i = 0; i < length; i += 1) {
@@ -183,7 +172,7 @@ function hasKeys(obj) {
     return false;
   }
   for (const key in obj) {
-    if (ObjectHasOwn(obj, key)) {
+    if ((0, import_primordials.ObjectHasOwn)(obj, key)) {
       return true;
     }
   }
@@ -194,7 +183,7 @@ function hasOwn(obj, propKey) {
   if (obj === null || obj === void 0) {
     return false;
   }
-  return ObjectHasOwn(obj, propKey);
+  return (0, import_primordials.ObjectHasOwn)(obj, propKey);
 }
 // @__NO_SIDE_EFFECTS__
 function isObject(value) {
@@ -205,8 +194,8 @@ function isObjectObject(value) {
   if (value === null || typeof value !== "object" || (0, import_arrays.isArray)(value)) {
     return false;
   }
-  const proto = ObjectGetPrototypeOf(value);
-  return proto === null || proto === ObjectPrototype;
+  const proto = (0, import_primordials.ObjectGetPrototypeOf)(value);
+  return proto === null || proto === import_primordials.ObjectPrototype;
 }
 // @__NO_SIDE_EFFECTS__
 function merge(target, source) {
@@ -229,7 +218,7 @@ function merge(target, source) {
     if (isSourceArray || isTargetArray) {
       continue;
     }
-    const keys = ReflectOwnKeys(currentSource);
+    const keys = (0, import_primordials.ReflectOwnKeys)(currentSource);
     for (let i = 0, { length } = keys; i < length; i += 1) {
       const key = keys[i];
       const srcVal = currentSource[key];
@@ -255,7 +244,7 @@ function objectEntries(obj) {
   if (obj === null || obj === void 0) {
     return [];
   }
-  const keys = ReflectOwnKeys(obj);
+  const keys = (0, import_primordials.ReflectOwnKeys)(obj);
   const { length } = keys;
   const entries = Array(length);
   const record = obj;
@@ -284,7 +273,7 @@ function toSortedObjectFromEntries(entries) {
   if (!otherEntries.length && !symbolEntries.length) {
     return {};
   }
-  return ObjectFromEntries([
+  return (0, import_primordials.ObjectFromEntries)([
     // The String constructor is safe to use with symbols.
     ...symbolEntries.sort(entryKeyComparator),
     ...otherEntries.sort(entryKeyComparator)

package/dist/packages/edit.js

@@ -151,11 +151,11 @@ function getEditablePackageJsonClass() {
         let parseErr;
         try {
           this._readFileContent = await (0, import_read_package.read)(this.filename);
-        } catch (err) {
+        } catch (e) {
           if (!create) {
-            throw err;
+            throw e;
           }
-          parseErr = err;
+          parseErr = e;
         }
         if (parseErr) {
           const nodePath = /* @__PURE__ */ getPath();

package/dist/packages/isolation.js

@@ -69,9 +69,9 @@ async function mergePackageJson(pkgJsonPath, originalPkgJson) {
   let pkgJson;
   try {
     pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf8"));
-  } catch (error) {
-    throw new Error(`Failed to parse ${pkgJsonPath}: ${(0, import_errors.errorMessage)(error)}`, {
-      cause: error
+  } catch (e) {
+    throw new Error(`Failed to parse ${pkgJsonPath}: ${(0, import_errors.errorMessage)(e)}`, {
+      cause: e
     });
   }
   const mergedPkgJson = originalPkgJson ? { ...originalPkgJson, ...pkgJson } : pkgJson;

package/dist/primordials.d.ts

@@ -0,0 +1,337 @@
+/**
+ * @fileoverview Safe references to built-in functions and constructors.
+ *
+ * Captures references to JavaScript built-ins at module load time, before
+ * user code can tamper with prototypes or globals. Consumers that process
+ * adversarial input (PURL parsers, manifest readers, config validators,
+ * anything that ingests untrusted strings or JSON) should import from here
+ * instead of using globals directly, so prototype-pollution attacks on the
+ * caller realm can't silently redirect library internals.
+ *
+ * Convention follows Node.js's internal primordials module:
+ *
+ * - **Static methods** retain their original name: `ObjectKeys`,
+ *   `ArrayIsArray`, `JSONParse`.
+ * - **Prototype methods** are uncurried via `uncurryThis`, so you call
+ *   `StringPrototypeSlice(str, 0, 3)` instead of `str.slice(0, 3)`.
+ * - **Constructors** get a `Ctor` suffix to avoid shadowing the capital-
+ *   case global: `MapCtor`, `SetCtor`.
+ *
+ * **IMPORTANT**: do not use destructuring on `globalThis` or `Reflect`
+ * here. tsgo has a bug that mis-transpiles destructured exports.
+ * See: https://github.com/SocketDev/socket-packageurl-js/issues/3
+ *
+ * @see https://github.com/nicolo-ribaudo/tc39-proposal-primordials
+ * @see https://github.com/nodejs/node/blob/main/lib/internal/per_context/primordials.js
+ */
+export declare const uncurryThis: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, ...args: A) => R;
+export declare const applyBind: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R;
+export declare const ArrayCtor: ArrayConstructor;
+export declare const ArrayBufferCtor: ArrayBufferConstructor;
+export declare const BooleanCtor: BooleanConstructor;
+export declare const BufferCtor: typeof globalThis.Buffer | undefined;
+export declare const DataViewCtor: DataViewConstructor;
+export declare const DateCtor: DateConstructor;
+export declare const ErrorCtor: ErrorConstructor;
+export declare const AggregateErrorCtor: AggregateErrorConstructor;
+export declare const EvalErrorCtor: EvalErrorConstructor;
+export declare const RangeErrorCtor: RangeErrorConstructor;
+export declare const ReferenceErrorCtor: ReferenceErrorConstructor;
+export declare const SyntaxErrorCtor: SyntaxErrorConstructor;
+export declare const TypeErrorCtor: TypeErrorConstructor;
+export declare const URIErrorCtor: URIErrorConstructor;
+export declare const MapCtor: MapConstructor;
+export declare const NumberCtor: NumberConstructor;
+export declare const ObjectCtor: ObjectConstructor;
+export declare const PromiseCtor: PromiseConstructor;
+export declare const RegExpCtor: RegExpConstructor;
+export declare const SetCtor: SetConstructor;
+export declare const StringCtor: StringConstructor;
+export declare const SymbolCtor: SymbolConstructor;
+export declare const Float32ArrayCtor: Float32ArrayConstructor;
+export declare const Float64ArrayCtor: Float64ArrayConstructor;
+export declare const Int8ArrayCtor: Int8ArrayConstructor;
+export declare const Int16ArrayCtor: Int16ArrayConstructor;
+export declare const Int32ArrayCtor: Int32ArrayConstructor;
+export declare const Uint8ArrayCtor: Uint8ArrayConstructor;
+export declare const Uint8ClampedArrayCtor: Uint8ClampedArrayConstructor;
+export declare const Uint16ArrayCtor: Uint16ArrayConstructor;
+export declare const Uint32ArrayCtor: Uint32ArrayConstructor;
+export declare const URLCtor: typeof URL;
+export declare const URLSearchParamsCtor: typeof URLSearchParams;
+export declare const WeakMapCtor: WeakMapConstructor;
+export declare const WeakRefCtor: WeakRefConstructor;
+export declare const WeakSetCtor: WeakSetConstructor;
+export declare const decodeComponent: typeof decodeURIComponent;
+export declare const encodeComponent: typeof encodeURIComponent;
+export declare const JSONParse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
+export declare const JSONStringify: {
+    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+};
+export declare const ArrayFrom: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+    <T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+    <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+};
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayOf: <T>(...items: T[]) => T[];
+export declare const ArrayBufferIsView: (arg: any) => arg is ArrayBufferView;
+export declare const ArrayPrototypeAt: (self: unknown, index: number) => any;
+export declare const ArrayPrototypeConcat: <T>(self: T[], ...items: Array<T | readonly T[]>) => T[];
+export declare const ArrayPrototypeCopyWithin: (self: unknown, target: number, start: number, end?: number | undefined) => any[];
+export declare const ArrayPrototypeEntries: (self: unknown) => ArrayIterator<[number, any]>;
+export declare const ArrayPrototypeEvery: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => boolean;
+export declare const ArrayPrototypeFill: (self: unknown, value: any, start?: number | undefined, end?: number | undefined) => any[];
+export declare const ArrayPrototypeFilter: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => any[];
+export declare const ArrayPrototypeFind: (self: unknown, predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any) => any;
+export declare const ArrayPrototypeFindIndex: (self: unknown, predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any) => number;
+export declare const ArrayPrototypeFindLast: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => any;
+export declare const ArrayPrototypeFindLastIndex: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => number;
+export declare const ArrayPrototypeFlat: <A, D extends number = 1>(self: A, depth?: D | undefined) => FlatArray<A, D>[];
+export declare const ArrayPrototypeFlatMap: <U, This = undefined>(self: unknown, callback: (this: This, value: any, index: number, array: any[]) => U | readonly U[], thisArg?: This | undefined) => U[];
+export declare const ArrayPrototypeForEach: (self: unknown, callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;
+export declare const ArrayPrototypeIncludes: (self: unknown, searchElement: any, fromIndex?: number | undefined) => boolean;
+export declare const ArrayPrototypeIndexOf: (self: unknown, searchElement: any, fromIndex?: number | undefined) => number;
+export declare const ArrayPrototypeJoin: (self: unknown, separator?: string | undefined) => string;
+export declare const ArrayPrototypeKeys: (self: unknown) => ArrayIterator<number>;
+export declare const ArrayPrototypeLastIndexOf: (self: unknown, searchElement: any, fromIndex?: number | undefined) => number;
+export declare const ArrayPrototypeMap: <U>(self: unknown, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[];
+export declare const ArrayPrototypePop: (self: unknown) => any;
+export declare const ArrayPrototypePush: <T>(self: T[], ...items: T[]) => number;
+export declare const ArrayPrototypeReduce: (self: unknown, callbackfn: (previousValue: unknown, currentValue: any, currentIndex: number, array: any[]) => unknown, initialValue: unknown) => unknown;
+export declare const ArrayPrototypeReduceRight: (self: unknown, callbackfn: (previousValue: unknown, currentValue: any, currentIndex: number, array: any[]) => unknown, initialValue: unknown) => unknown;
+export declare const ArrayPrototypeReverse: (self: unknown) => any[];
+export declare const ArrayPrototypeShift: (self: unknown) => any;
+export declare const ArrayPrototypeSlice: (self: unknown, start?: number | undefined, end?: number | undefined) => any[];
+export declare const ArrayPrototypeSome: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => boolean;
+export declare const ArrayPrototypeSort: (self: unknown, compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+export declare const ArrayPrototypeSplice: <T>(self: T[], start: number, deleteCount?: number, ...items: T[]) => T[];
+export declare const ArrayPrototypeToReversed: (self: unknown) => any[];
+export declare const ArrayPrototypeToSorted: (self: unknown, compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+export declare const ArrayPrototypeUnshift: <T>(self: T[], ...items: T[]) => number;
+export declare const ArrayPrototypeValues: (self: unknown) => ArrayIterator<any>;
+export declare const BufferAlloc: typeof Buffer.alloc | undefined;
+export declare const BufferAllocUnsafe: typeof Buffer.allocUnsafe | undefined;
+export declare const BufferAllocUnsafeSlow: typeof Buffer.allocUnsafeSlow | undefined;
+export declare const BufferByteLength: typeof Buffer.byteLength | undefined;
+export declare const BufferConcat: typeof Buffer.concat | undefined;
+export declare const BufferFrom: typeof Buffer.from | undefined;
+export declare const BufferIsBuffer: typeof Buffer.isBuffer | undefined;
+export declare const BufferIsEncoding: typeof Buffer.isEncoding | undefined;
+export declare const BufferPrototypeSlice: ((buf: Buffer, start?: number, end?: number) => Buffer) | undefined;
+export declare const BufferPrototypeToString: ((buf: Buffer, encoding?: BufferEncoding, start?: number, end?: number) => string) | undefined;
+export declare const DateNow: () => number;
+export declare const DateParse: (s: string) => number;
+export declare const DateUTC: {
+    (year: number, monthIndex: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+    (year: number, monthIndex?: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+};
+export declare const DatePrototypeGetTime: (self: unknown) => number;
+export declare const DatePrototypeToISOString: (self: unknown) => string;
+export declare const DatePrototypeValueOf: (self: unknown) => number;
+export declare const ErrorIsError: ((value: unknown) => value is Error) | undefined;
+export declare const FunctionPrototypeApply: (self: (...args: unknown[]) => unknown, thisArg: unknown, args: unknown[]) => unknown;
+export declare const FunctionPrototypeBind: (self: (...args: unknown[]) => unknown, thisArg: unknown, ...args: unknown[]) => (...args: unknown[]) => unknown;
+export declare const FunctionPrototypeCall: (self: (...args: unknown[]) => unknown, thisArg: unknown, ...args: unknown[]) => unknown;
+export declare const IteratorPrototypeNext: (self: Iterator<unknown, any, any>) => IteratorResult<unknown, any>;
+export declare const IteratorPrototypeReturn: ((self: Iterator<unknown, any, any>, value?: unknown) => IteratorResult<unknown, any>) | undefined;
+export declare const MapPrototypeClear: (self: unknown) => void;
+export declare const MapPrototypeDelete: (self: unknown, key: any) => boolean;
+export declare const MapPrototypeEntries: (self: unknown) => MapIterator<[any, any]>;
+export declare const MapPrototypeForEach: (self: unknown, callbackfn: (value: any, key: any, map: Map<any, any>) => void, thisArg?: any) => void;
+export declare const MapPrototypeGet: (self: unknown, key: any) => any;
+export declare const MapPrototypeHas: (self: unknown, key: any) => boolean;
+export declare const MapPrototypeKeys: (self: unknown) => MapIterator<any>;
+export declare const MapPrototypeSet: (self: unknown, key: any, value: any) => Map<any, any>;
+export declare const MapPrototypeValues: (self: unknown) => MapIterator<any>;
+export declare const MathAbs: (x: number) => number;
+export declare const MathCeil: (x: number) => number;
+export declare const MathFloor: (x: number) => number;
+export declare const MathMax: (...values: number[]) => number;
+export declare const MathMin: (...values: number[]) => number;
+export declare const MathPow: (x: number, y: number) => number;
+export declare const MathRandom: () => number;
+export declare const MathRound: (x: number) => number;
+export declare const MathSign: (x: number) => number;
+export declare const MathSqrt: (x: number) => number;
+export declare const MathTrunc: (x: number) => number;
+export declare const NumberIsFinite: (number: unknown) => boolean;
+export declare const NumberIsInteger: (number: unknown) => boolean;
+export declare const NumberIsNaN: (number: unknown) => boolean;
+export declare const NumberIsSafeInteger: (number: unknown) => boolean;
+export declare const NumberParseFloat: (string: string) => number;
+export declare const NumberParseInt: (string: string, radix?: number) => number;
+export declare const NumberPrototypeToFixed: (self: unknown, fractionDigits?: number | undefined) => string;
+export declare const NumberPrototypeToString: (self: unknown, radix?: number | undefined) => string;
+export declare const ObjectAssign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export declare const ObjectDefineProperties: <T>(o: T, properties: PropertyDescriptorMap & ThisType<any>) => T;
+export declare const ObjectDefineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+export declare const ObjectEntries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+export declare const ObjectFreeze: {
+    <T extends Function>(f: T): T;
+    <T extends {
+        [idx: string]: U | null | undefined | object;
+    }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    <T>(o: T): Readonly<T>;
+};
+export declare const ObjectFromEntries: {
+    <T = any>(entries: Iterable<readonly [PropertyKey, T]>): {
+        [k: string]: T;
+    };
+    (entries: Iterable<readonly any[]>): any;
+};
+export declare const ObjectGetOwnPropertyDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
+export declare const ObjectGetOwnPropertyDescriptors: <T>(o: T) => { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & {
+    [x: string]: PropertyDescriptor;
+};
+export declare const ObjectGetOwnPropertyNames: (o: any) => string[];
+export declare const ObjectGetOwnPropertySymbols: (o: any) => symbol[];
+export declare const ObjectGetPrototypeOf: (o: any) => any;
+export declare const ObjectHasOwn: (o: object, v: PropertyKey) => boolean;
+export declare const ObjectIs: (value1: any, value2: any) => boolean;
+export declare const ObjectIsExtensible: (o: any) => boolean;
+export declare const ObjectIsFrozen: (o: any) => boolean;
+export declare const ObjectIsSealed: (o: any) => boolean;
+export declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export declare const ObjectPreventExtensions: <T>(o: T) => T;
+export declare const ObjectSeal: <T>(o: T) => T;
+export declare const ObjectSetPrototypeOf: (o: any, proto: object | null) => any;
+export declare const ObjectValues: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
+};
+export declare const ObjectPrototype: Object;
+export declare const ObjectPrototypeHasOwnProperty: (self: unknown, v: PropertyKey) => boolean;
+export declare const ObjectPrototypeIsPrototypeOf: (self: unknown, v: Object) => boolean;
+export declare const ObjectPrototypePropertyIsEnumerable: (self: unknown, v: PropertyKey) => boolean;
+export declare const ObjectPrototypeToString: (self: unknown) => string;
+export declare const ObjectPrototypeValueOf: (self: unknown) => Object;
+export declare const PromiseAll: {
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
+    <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
+};
+export declare const PromiseAllSettled: {
+    <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
+};
+export declare const PromiseAny: {
+    <T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+};
+export declare const PromiseRace: {
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+    <T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+};
+export declare const PromiseReject: <T = never>(reason?: any) => Promise<T>;
+export declare const PromiseResolve: {
+    (): Promise<void>;
+    <T>(value: T): Promise<Awaited<T>>;
+    <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
+};
+export declare const PromiseWithResolvers: typeof Promise.withResolvers | undefined;
+export declare const PromisePrototypeCatch: <TResult = never>(self: unknown, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+export declare const PromisePrototypeFinally: (self: unknown, onfinally?: (() => void) | null | undefined) => Promise<any>;
+export declare const PromisePrototypeThen: <TResult1 = any, TResult2 = never>(self: unknown, onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+export declare const ReflectApply: typeof Reflect.apply;
+export declare const ReflectConstruct: typeof Reflect.construct;
+export declare const ReflectDefineProperty: typeof Reflect.defineProperty;
+export declare const ReflectDeleteProperty: typeof Reflect.deleteProperty;
+export declare const ReflectGet: typeof Reflect.get;
+export declare const ReflectGetOwnPropertyDescriptor: typeof Reflect.getOwnPropertyDescriptor;
+export declare const ReflectGetPrototypeOf: typeof Reflect.getPrototypeOf;
+export declare const ReflectHas: typeof Reflect.has;
+export declare const ReflectIsExtensible: typeof Reflect.isExtensible;
+export declare const ReflectOwnKeys: typeof Reflect.ownKeys;
+export declare const ReflectPreventExtensions: typeof Reflect.preventExtensions;
+export declare const ReflectSet: typeof Reflect.set;
+export declare const ReflectSetPrototypeOf: typeof Reflect.setPrototypeOf;
+export declare const RegExpEscape: ((s: string) => string) | undefined;
+export declare const RegExpPrototypeExec: (self: unknown, string: string) => RegExpExecArray | null;
+export declare const RegExpPrototypeTest: (self: unknown, string: string) => boolean;
+export declare const RegExpPrototypeSymbolMatch: (self: RegExp, str: string) => unknown;
+export declare const RegExpPrototypeSymbolReplace: (self: RegExp, str: string, replaceValue: string) => string;
+export declare const SetPrototypeAdd: (self: unknown, value: any) => Set<any>;
+export declare const SetPrototypeClear: (self: unknown) => void;
+export declare const SetPrototypeDelete: (self: unknown, value: any) => boolean;
+export declare const SetPrototypeEntries: (self: unknown) => SetIterator<[any, any]>;
+export declare const SetPrototypeForEach: (self: unknown, callbackfn: (value: any, value2: any, set: Set<any>) => void, thisArg?: any) => void;
+export declare const SetPrototypeHas: (self: unknown, value: any) => boolean;
+export declare const SetPrototypeKeys: (self: unknown) => SetIterator<any>;
+export declare const SetPrototypeValues: (self: unknown) => SetIterator<any>;
+export declare const StringFromCharCode: (...codes: number[]) => string;
+export declare const StringFromCodePoint: (...codePoints: number[]) => string;
+export declare const StringRaw: (template: {
+    raw: readonly string[] | ArrayLike<string>;
+}, ...substitutions: any[]) => string;
+export declare const StringPrototypeAt: (self: unknown, index: number) => string | undefined;
+export declare const StringPrototypeCharAt: (self: unknown, pos: number) => string;
+export declare const StringPrototypeCharCodeAt: (self: unknown, index: number) => number;
+export declare const StringPrototypeCodePointAt: (self: unknown, pos: number) => number | undefined;
+export declare const StringPrototypeConcat: (self: string, ...strs: string[]) => string;
+export declare const StringPrototypeEndsWith: (self: unknown, searchString: string, endPosition?: number | undefined) => boolean;
+export declare const StringPrototypeIncludes: (self: unknown, searchString: string, position?: number | undefined) => boolean;
+export declare const StringPrototypeIndexOf: (self: unknown, searchString: string, position?: number | undefined) => number;
+export declare const StringPrototypeLastIndexOf: (self: unknown, searchString: string, position?: number | undefined) => number;
+export declare const StringPrototypeLocaleCompare: (self: unknown, that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions | undefined) => number;
+export declare const StringPrototypeMatch: (self: string, matcher: string | RegExp) => RegExpMatchArray | null;
+export declare const StringPrototypeMatchAll: (self: string, matcher: string | RegExp) => IterableIterator<RegExpMatchArray>;
+export declare const StringPrototypeNormalize: (self: unknown, form?: string | undefined) => string;
+export declare const StringPrototypePadEnd: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
+export declare const StringPrototypePadStart: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
+export declare const StringPrototypeRepeat: (self: unknown, count: number) => string;
+export declare const StringPrototypeReplace: (self: string, searchValue: string | RegExp, replaceValue: string) => string;
+export declare const StringPrototypeReplaceAll: (self: string, searchValue: string, replaceValue: string) => string;
+export declare const StringPrototypeSearch: (self: unknown, searcher: {
+    [Symbol.search](string: string): number;
+}) => number;
+export declare const StringPrototypeSlice: (self: unknown, start?: number | undefined, end?: number | undefined) => string;
+export declare const StringPrototypeSplit: (self: string, separator: string | RegExp, limit?: number) => string[];
+export declare const StringPrototypeStartsWith: (self: unknown, searchString: string, position?: number | undefined) => boolean;
+export declare const StringPrototypeSubstring: (self: unknown, start: number, end?: number | undefined) => string;
+export declare const StringPrototypeToLocaleLowerCase: (self: unknown, locales?: Intl.LocalesArgument) => string;
+export declare const StringPrototypeToLocaleUpperCase: (self: unknown, locales?: Intl.LocalesArgument) => string;
+export declare const StringPrototypeToLowerCase: (self: unknown) => string;
+export declare const StringPrototypeToUpperCase: (self: unknown) => string;
+export declare const StringPrototypeTrim: (self: unknown) => string;
+export declare const StringPrototypeTrimEnd: (self: unknown) => string;
+export declare const StringPrototypeTrimStart: (self: unknown) => string;
+export declare const SymbolAsyncIterator: symbol;
+export declare const SymbolFor: (key: string) => symbol;
+export declare const SymbolIterator: symbol;
+export declare const SymbolToPrimitive: symbol;
+export declare const SymbolToStringTag: symbol;
+export declare const URLSearchParamsPrototypeAppend: (self: unknown, name: string, value: string) => void;
+export declare const URLSearchParamsPrototypeDelete: (self: unknown, name: string, value?: string | undefined) => void;
+export declare const URLSearchParamsPrototypeForEach: <TThis = import("url").URLSearchParams>(self: unknown, fn: (this: TThis, value: string, name: string, searchParams: import("url").URLSearchParams) => void, thisArg?: TThis | undefined) => void;
+export declare const URLSearchParamsPrototypeGet: (self: unknown, name: string) => string | null;
+export declare const URLSearchParamsPrototypeGetAll: (self: unknown, name: string) => string[];
+export declare const URLSearchParamsPrototypeHas: (self: unknown, name: string, value?: string | undefined) => boolean;
+export declare const URLSearchParamsPrototypeSet: (self: unknown, name: string, value: string) => void;
+export declare const WeakMapPrototypeDelete: (self: unknown, key: WeakKey) => boolean;
+export declare const WeakMapPrototypeGet: (self: unknown, key: WeakKey) => any;
+export declare const WeakMapPrototypeHas: (self: unknown, key: WeakKey) => boolean;
+export declare const WeakMapPrototypeSet: (self: unknown, key: WeakKey, value: any) => WeakMap<WeakKey, any>;
+export declare const WeakSetPrototypeAdd: (self: unknown, value: WeakKey) => WeakSet<WeakKey>;
+export declare const WeakSetPrototypeDelete: (self: unknown, value: WeakKey) => boolean;
+export declare const WeakSetPrototypeHas: (self: unknown, value: WeakKey) => boolean;