@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/primordials/map-set.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file Safe references to `Map`, `Set`, `WeakMap`, `WeakSet`, and `WeakRef`.
+ *   Constructors plus uncurried prototype methods. `WeakRef` exposes only its
+ *   constructor — there's a separate `weakRefSafe` wrapper in `./uncurry` for
+ *   the throws-on-non-Object case.
+ */
+export declare const MapCtor: MapConstructor;
+export declare const SetCtor: SetConstructor;
+export declare const WeakMapCtor: WeakMapConstructor;
+export declare const WeakRefCtor: WeakRefConstructor;
+export declare const WeakSetCtor: WeakSetConstructor;
+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 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 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;

package/dist/primordials/map-set.js

@@ -0,0 +1,115 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var map_set_exports = {};
+__export(map_set_exports, {
+  MapCtor: () => MapCtor,
+  MapPrototypeClear: () => MapPrototypeClear,
+  MapPrototypeDelete: () => MapPrototypeDelete,
+  MapPrototypeEntries: () => MapPrototypeEntries,
+  MapPrototypeForEach: () => MapPrototypeForEach,
+  MapPrototypeGet: () => MapPrototypeGet,
+  MapPrototypeHas: () => MapPrototypeHas,
+  MapPrototypeKeys: () => MapPrototypeKeys,
+  MapPrototypeSet: () => MapPrototypeSet,
+  MapPrototypeValues: () => MapPrototypeValues,
+  SetCtor: () => SetCtor,
+  SetPrototypeAdd: () => SetPrototypeAdd,
+  SetPrototypeClear: () => SetPrototypeClear,
+  SetPrototypeDelete: () => SetPrototypeDelete,
+  SetPrototypeEntries: () => SetPrototypeEntries,
+  SetPrototypeForEach: () => SetPrototypeForEach,
+  SetPrototypeHas: () => SetPrototypeHas,
+  SetPrototypeKeys: () => SetPrototypeKeys,
+  SetPrototypeValues: () => SetPrototypeValues,
+  WeakMapCtor: () => WeakMapCtor,
+  WeakMapPrototypeDelete: () => WeakMapPrototypeDelete,
+  WeakMapPrototypeGet: () => WeakMapPrototypeGet,
+  WeakMapPrototypeHas: () => WeakMapPrototypeHas,
+  WeakMapPrototypeSet: () => WeakMapPrototypeSet,
+  WeakRefCtor: () => WeakRefCtor,
+  WeakSetCtor: () => WeakSetCtor,
+  WeakSetPrototypeAdd: () => WeakSetPrototypeAdd,
+  WeakSetPrototypeDelete: () => WeakSetPrototypeDelete,
+  WeakSetPrototypeHas: () => WeakSetPrototypeHas
+});
+module.exports = __toCommonJS(map_set_exports);
+var import_uncurry = require("./uncurry");
+const MapCtor = Map;
+const SetCtor = Set;
+const WeakMapCtor = WeakMap;
+const WeakRefCtor = WeakRef;
+const WeakSetCtor = WeakSet;
+const MapPrototypeClear = (0, import_uncurry.uncurryThis)(Map.prototype.clear);
+const MapPrototypeDelete = (0, import_uncurry.uncurryThis)(Map.prototype.delete);
+const MapPrototypeEntries = (0, import_uncurry.uncurryThis)(Map.prototype.entries);
+const MapPrototypeForEach = (0, import_uncurry.uncurryThis)(Map.prototype.forEach);
+const MapPrototypeGet = (0, import_uncurry.uncurryThis)(Map.prototype.get);
+const MapPrototypeHas = (0, import_uncurry.uncurryThis)(Map.prototype.has);
+const MapPrototypeKeys = (0, import_uncurry.uncurryThis)(Map.prototype.keys);
+const MapPrototypeSet = (0, import_uncurry.uncurryThis)(Map.prototype.set);
+const MapPrototypeValues = (0, import_uncurry.uncurryThis)(Map.prototype.values);
+const SetPrototypeAdd = (0, import_uncurry.uncurryThis)(Set.prototype.add);
+const SetPrototypeClear = (0, import_uncurry.uncurryThis)(Set.prototype.clear);
+const SetPrototypeDelete = (0, import_uncurry.uncurryThis)(Set.prototype.delete);
+const SetPrototypeEntries = (0, import_uncurry.uncurryThis)(Set.prototype.entries);
+const SetPrototypeForEach = (0, import_uncurry.uncurryThis)(Set.prototype.forEach);
+const SetPrototypeHas = (0, import_uncurry.uncurryThis)(Set.prototype.has);
+const SetPrototypeKeys = (0, import_uncurry.uncurryThis)(Set.prototype.keys);
+const SetPrototypeValues = (0, import_uncurry.uncurryThis)(Set.prototype.values);
+const WeakMapPrototypeDelete = (0, import_uncurry.uncurryThis)(WeakMap.prototype.delete);
+const WeakMapPrototypeGet = (0, import_uncurry.uncurryThis)(WeakMap.prototype.get);
+const WeakMapPrototypeHas = (0, import_uncurry.uncurryThis)(WeakMap.prototype.has);
+const WeakMapPrototypeSet = (0, import_uncurry.uncurryThis)(WeakMap.prototype.set);
+const WeakSetPrototypeAdd = (0, import_uncurry.uncurryThis)(WeakSet.prototype.add);
+const WeakSetPrototypeDelete = (0, import_uncurry.uncurryThis)(WeakSet.prototype.delete);
+const WeakSetPrototypeHas = (0, import_uncurry.uncurryThis)(WeakSet.prototype.has);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MapCtor,
+  MapPrototypeClear,
+  MapPrototypeDelete,
+  MapPrototypeEntries,
+  MapPrototypeForEach,
+  MapPrototypeGet,
+  MapPrototypeHas,
+  MapPrototypeKeys,
+  MapPrototypeSet,
+  MapPrototypeValues,
+  SetCtor,
+  SetPrototypeAdd,
+  SetPrototypeClear,
+  SetPrototypeDelete,
+  SetPrototypeEntries,
+  SetPrototypeForEach,
+  SetPrototypeHas,
+  SetPrototypeKeys,
+  SetPrototypeValues,
+  WeakMapCtor,
+  WeakMapPrototypeDelete,
+  WeakMapPrototypeGet,
+  WeakMapPrototypeHas,
+  WeakMapPrototypeSet,
+  WeakRefCtor,
+  WeakSetCtor,
+  WeakSetPrototypeAdd,
+  WeakSetPrototypeDelete,
+  WeakSetPrototypeHas
+});

package/dist/primordials/math.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @file Safe references to `Math` constants and methods. Methods prefer the
+ *   smol fast-path (`node:smol-primordial`) when available — V8 Fast API typed
+ *   implementations TurboFan inlines into JIT'd callers. Constants stay as the
+ *   stock `Math.X` since they are pre-computed scalar values with no fast-path
+ *   benefit.
+ */
+export declare const MathE: number;
+export declare const MathLN2: number;
+export declare const MathLN10: number;
+export declare const MathLOG2E: number;
+export declare const MathLOG10E: number;
+export declare const MathPI: number;
+export declare const MathSQRT1_2: number;
+export declare const MathSQRT2: number;
+export declare const MathAbs: (x: number) => number;
+export declare const MathAcos: (x: number) => number;
+export declare const MathAcosh: (x: number) => number;
+export declare const MathAsin: (x: number) => number;
+export declare const MathAsinh: (x: number) => number;
+export declare const MathAtan: (x: number) => number;
+export declare const MathAtan2: (y: number, x: number) => number;
+export declare const MathAtanh: (x: number) => number;
+export declare const MathCbrt: (x: number) => number;
+export declare const MathCeil: (x: number) => number;
+export declare const MathClz32: (x: number) => number;
+export declare const MathCos: (x: number) => number;
+export declare const MathCosh: (x: number) => number;
+export declare const MathExp: (x: number) => number;
+export declare const MathExpm1: (x: number) => number;
+export declare const MathF16round: ((value: number) => number) | undefined;
+export declare const MathFloor: (x: number) => number;
+export declare const MathFround: (x: number) => number;
+export declare const MathHypot: (...values: number[]) => number;
+export declare const MathImul: (x: number, y: number) => number;
+export declare const MathLog: (x: number) => number;
+export declare const MathLog1p: (x: number) => number;
+export declare const MathLog2: (x: number) => number;
+export declare const MathLog10: (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 MathSin: (x: number) => number;
+export declare const MathSinh: (x: number) => number;
+export declare const MathSqrt: (x: number) => number;
+export declare const MathTan: (x: number) => number;
+export declare const MathTanh: (x: number) => number;
+export declare const MathTrunc: (x: number) => number;

package/dist/primordials/math.js

@@ -0,0 +1,161 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var math_exports = {};
+__export(math_exports, {
+  MathAbs: () => MathAbs,
+  MathAcos: () => MathAcos,
+  MathAcosh: () => MathAcosh,
+  MathAsin: () => MathAsin,
+  MathAsinh: () => MathAsinh,
+  MathAtan: () => MathAtan,
+  MathAtan2: () => MathAtan2,
+  MathAtanh: () => MathAtanh,
+  MathCbrt: () => MathCbrt,
+  MathCeil: () => MathCeil,
+  MathClz32: () => MathClz32,
+  MathCos: () => MathCos,
+  MathCosh: () => MathCosh,
+  MathE: () => MathE,
+  MathExp: () => MathExp,
+  MathExpm1: () => MathExpm1,
+  MathF16round: () => MathF16round,
+  MathFloor: () => MathFloor,
+  MathFround: () => MathFround,
+  MathHypot: () => MathHypot,
+  MathImul: () => MathImul,
+  MathLN10: () => MathLN10,
+  MathLN2: () => MathLN2,
+  MathLOG10E: () => MathLOG10E,
+  MathLOG2E: () => MathLOG2E,
+  MathLog: () => MathLog,
+  MathLog10: () => MathLog10,
+  MathLog1p: () => MathLog1p,
+  MathLog2: () => MathLog2,
+  MathMax: () => MathMax,
+  MathMin: () => MathMin,
+  MathPI: () => MathPI,
+  MathPow: () => MathPow,
+  MathRandom: () => MathRandom,
+  MathRound: () => MathRound,
+  MathSQRT1_2: () => MathSQRT1_2,
+  MathSQRT2: () => MathSQRT2,
+  MathSign: () => MathSign,
+  MathSin: () => MathSin,
+  MathSinh: () => MathSinh,
+  MathSqrt: () => MathSqrt,
+  MathTan: () => MathTan,
+  MathTanh: () => MathTanh,
+  MathTrunc: () => MathTrunc
+});
+module.exports = __toCommonJS(math_exports);
+var import_primordial = require("../smol/primordial");
+const _smolPrimordial = (0, import_primordial.getSmolPrimordial)();
+const MathE = Math.E;
+const MathLN2 = Math.LN2;
+const MathLN10 = Math.LN10;
+const MathLOG2E = Math.LOG2E;
+const MathLOG10E = Math.LOG10E;
+const MathPI = Math.PI;
+const MathSQRT1_2 = Math.SQRT1_2;
+const MathSQRT2 = Math.SQRT2;
+const MathAbs = _smolPrimordial?.mathAbs ?? Math.abs;
+const MathAcos = _smolPrimordial?.mathAcos ?? Math.acos;
+const MathAcosh = _smolPrimordial?.mathAcosh ?? Math.acosh;
+const MathAsin = _smolPrimordial?.mathAsin ?? Math.asin;
+const MathAsinh = _smolPrimordial?.mathAsinh ?? Math.asinh;
+const MathAtan = _smolPrimordial?.mathAtan ?? Math.atan;
+const MathAtan2 = _smolPrimordial?.mathAtan2 ?? Math.atan2;
+const MathAtanh = _smolPrimordial?.mathAtanh ?? Math.atanh;
+const MathCbrt = _smolPrimordial?.mathCbrt ?? Math.cbrt;
+const MathCeil = _smolPrimordial?.mathCeil ?? Math.ceil;
+const MathClz32 = _smolPrimordial?.mathClz32 ?? Math.clz32;
+const MathCos = _smolPrimordial?.mathCos ?? Math.cos;
+const MathCosh = _smolPrimordial?.mathCosh ?? Math.cosh;
+const MathExp = _smolPrimordial?.mathExp ?? Math.exp;
+const MathExpm1 = _smolPrimordial?.mathExpm1 ?? Math.expm1;
+const MathF16round = Math.f16round;
+const MathFloor = _smolPrimordial?.mathFloor ?? Math.floor;
+const MathFround = _smolPrimordial?.mathFround ?? Math.fround;
+const MathHypot = _smolPrimordial?.mathHypot ?? Math.hypot;
+const MathImul = _smolPrimordial?.mathImul ?? Math.imul;
+const MathLog = _smolPrimordial?.mathLog ?? Math.log;
+const MathLog1p = _smolPrimordial?.mathLog1p ?? Math.log1p;
+const MathLog2 = _smolPrimordial?.mathLog2 ?? Math.log2;
+const MathLog10 = _smolPrimordial?.mathLog10 ?? Math.log10;
+const MathMax = Math.max;
+const MathMin = Math.min;
+const MathPow = _smolPrimordial?.mathPow ?? Math.pow;
+const MathRandom = Math.random;
+const MathRound = _smolPrimordial?.mathRound ?? Math.round;
+const MathSign = _smolPrimordial?.mathSign ?? Math.sign;
+const MathSin = _smolPrimordial?.mathSin ?? Math.sin;
+const MathSinh = _smolPrimordial?.mathSinh ?? Math.sinh;
+const MathSqrt = _smolPrimordial?.mathSqrt ?? Math.sqrt;
+const MathTan = _smolPrimordial?.mathTan ?? Math.tan;
+const MathTanh = _smolPrimordial?.mathTanh ?? Math.tanh;
+const MathTrunc = _smolPrimordial?.mathTrunc ?? Math.trunc;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MathAbs,
+  MathAcos,
+  MathAcosh,
+  MathAsin,
+  MathAsinh,
+  MathAtan,
+  MathAtan2,
+  MathAtanh,
+  MathCbrt,
+  MathCeil,
+  MathClz32,
+  MathCos,
+  MathCosh,
+  MathE,
+  MathExp,
+  MathExpm1,
+  MathF16round,
+  MathFloor,
+  MathFround,
+  MathHypot,
+  MathImul,
+  MathLN10,
+  MathLN2,
+  MathLOG10E,
+  MathLOG2E,
+  MathLog,
+  MathLog10,
+  MathLog1p,
+  MathLog2,
+  MathMax,
+  MathMin,
+  MathPI,
+  MathPow,
+  MathRandom,
+  MathRound,
+  MathSQRT1_2,
+  MathSQRT2,
+  MathSign,
+  MathSin,
+  MathSinh,
+  MathSqrt,
+  MathTan,
+  MathTanh,
+  MathTrunc
+});

package/dist/primordials/number.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file Safe references to `Number`, its constants, predicates, and parse
+ *   helpers. Predicates prefer the smol fast-path (`node:smol-primordial`);
+ *   static `parseFloat` / `parseInt` use the FastOneByteString-typed bindings
+ *   for ASCII inputs and fall back to stock `Number.parse*` otherwise.
+ */
+export declare const NumberCtor: NumberConstructor;
+export declare const NumberEPSILON: number;
+export declare const NumberMAX_SAFE_INTEGER: number;
+export declare const NumberMAX_VALUE: number;
+export declare const NumberMIN_SAFE_INTEGER: number;
+export declare const NumberMIN_VALUE: number;
+export declare const NumberNEGATIVE_INFINITY: number;
+export declare const NumberPOSITIVE_INFINITY: 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: typeof Number.parseInt;
+export declare const NumberPrototypeToExponential: (self: unknown, fractionDigits?: number | undefined) => string;
+export declare const NumberPrototypeToFixed: (self: unknown, fractionDigits?: number | undefined) => string;
+export declare const NumberPrototypeToPrecision: (self: unknown, precision?: number | undefined) => string;
+export declare const NumberPrototypeToString: (self: unknown, radix?: number | undefined) => string;
+export declare const NumberPrototypeValueOf: (self: unknown) => number;

package/dist/primordials/number.js

@@ -0,0 +1,92 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var number_exports = {};
+__export(number_exports, {
+  NumberCtor: () => NumberCtor,
+  NumberEPSILON: () => NumberEPSILON,
+  NumberIsFinite: () => NumberIsFinite,
+  NumberIsInteger: () => NumberIsInteger,
+  NumberIsNaN: () => NumberIsNaN,
+  NumberIsSafeInteger: () => NumberIsSafeInteger,
+  NumberMAX_SAFE_INTEGER: () => NumberMAX_SAFE_INTEGER,
+  NumberMAX_VALUE: () => NumberMAX_VALUE,
+  NumberMIN_SAFE_INTEGER: () => NumberMIN_SAFE_INTEGER,
+  NumberMIN_VALUE: () => NumberMIN_VALUE,
+  NumberNEGATIVE_INFINITY: () => NumberNEGATIVE_INFINITY,
+  NumberPOSITIVE_INFINITY: () => NumberPOSITIVE_INFINITY,
+  NumberParseFloat: () => NumberParseFloat,
+  NumberParseInt: () => NumberParseInt,
+  NumberPrototypeToExponential: () => NumberPrototypeToExponential,
+  NumberPrototypeToFixed: () => NumberPrototypeToFixed,
+  NumberPrototypeToPrecision: () => NumberPrototypeToPrecision,
+  NumberPrototypeToString: () => NumberPrototypeToString,
+  NumberPrototypeValueOf: () => NumberPrototypeValueOf
+});
+module.exports = __toCommonJS(number_exports);
+var import_primordial = require("../smol/primordial");
+var import_uncurry = require("./uncurry");
+const _smolPrimordial = (0, import_primordial.getSmolPrimordial)();
+const NumberCtor = Number;
+const NumberEPSILON = Number.EPSILON;
+const NumberMAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const NumberMAX_VALUE = Number.MAX_VALUE;
+const NumberMIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
+const NumberMIN_VALUE = Number.MIN_VALUE;
+const NumberNEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;
+const NumberPOSITIVE_INFINITY = Number.POSITIVE_INFINITY;
+const NumberIsFinite = _smolPrimordial?.numberIsFinite ?? Number.isFinite;
+const NumberIsInteger = _smolPrimordial?.numberIsInteger ?? Number.isInteger;
+const NumberIsNaN = _smolPrimordial?.numberIsNaN ?? Number.isNaN;
+const NumberIsSafeInteger = _smolPrimordial?.numberIsSafeInteger ?? Number.isSafeInteger;
+const NumberParseFloat = _smolPrimordial?.numberParseFloat ?? Number.parseFloat;
+const _smolParseInt10 = _smolPrimordial?.numberParseInt10;
+const NumberParseInt = _smolParseInt10 ? (s, radix) => radix === void 0 || radix === 10 ? _smolParseInt10(s) : Number.parseInt(s, radix) : Number.parseInt;
+const NumberPrototypeToExponential = (0, import_uncurry.uncurryThis)(
+  Number.prototype.toExponential
+);
+const NumberPrototypeToFixed = (0, import_uncurry.uncurryThis)(Number.prototype.toFixed);
+const NumberPrototypeToPrecision = (0, import_uncurry.uncurryThis)(
+  Number.prototype.toPrecision
+);
+const NumberPrototypeToString = (0, import_uncurry.uncurryThis)(Number.prototype.toString);
+const NumberPrototypeValueOf = (0, import_uncurry.uncurryThis)(Number.prototype.valueOf);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NumberCtor,
+  NumberEPSILON,
+  NumberIsFinite,
+  NumberIsInteger,
+  NumberIsNaN,
+  NumberIsSafeInteger,
+  NumberMAX_SAFE_INTEGER,
+  NumberMAX_VALUE,
+  NumberMIN_SAFE_INTEGER,
+  NumberMIN_VALUE,
+  NumberNEGATIVE_INFINITY,
+  NumberPOSITIVE_INFINITY,
+  NumberParseFloat,
+  NumberParseInt,
+  NumberPrototypeToExponential,
+  NumberPrototypeToFixed,
+  NumberPrototypeToPrecision,
+  NumberPrototypeToString,
+  NumberPrototypeValueOf
+});

package/dist/primordials/object.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @file Safe references to `Object` static methods and prototype methods. Annex
+ *   B legacy accessor methods (`__defineGetter__`, `__lookupGetter__`, etc.)
+ *   are exposed alongside the canonical static methods — implementations exist
+ *   in V8, SpiderMonkey, and JavaScriptCore even though the spec calls them
+ *   "normative optional".
+ */
+export declare const ObjectCtor: ObjectConstructor;
+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 ObjectPrototypeDefineGetter: (self: object, key: PropertyKey, fn: () => unknown) => void;
+export declare const ObjectPrototypeDefineSetter: (self: object, key: PropertyKey, fn: (value: unknown) => void) => void;
+export declare const ObjectPrototypeLookupGetter: (self: object, key: PropertyKey) => (() => unknown) | undefined;
+export declare const ObjectPrototypeLookupSetter: (self: object, key: PropertyKey) => ((value: unknown) => void) | undefined;