@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/primordials/function.js

@@ -1,42 +1,22 @@
 "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 function_exports = {};
-__export(function_exports, {
-  FunctionPrototypeApply: () => FunctionPrototypeApply,
-  FunctionPrototypeBind: () => FunctionPrototypeBind,
-  FunctionPrototypeCall: () => FunctionPrototypeCall,
-  FunctionPrototypeToString: () => FunctionPrototypeToString
-});
-module.exports = __toCommonJS(function_exports);
-var import_uncurry = require("./uncurry");
-const FunctionPrototypeApply = (0, import_uncurry.uncurryThis)(Function.prototype.apply);
-const FunctionPrototypeBind = (0, import_uncurry.uncurryThis)(Function.prototype.bind);
-const FunctionPrototypeCall = (0, import_uncurry.uncurryThis)(Function.prototype.call);
-const FunctionPrototypeToString = (0, import_uncurry.uncurryThis)(
-  Function.prototype.toString
-);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FunctionPrototypeApply,
-  FunctionPrototypeBind,
-  FunctionPrototypeCall,
-  FunctionPrototypeToString
-});
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_uncurry = require('./uncurry.js');
+
+//#region src/primordials/function.ts
+/**
+* @file Safe references to `Function.prototype` methods. `apply`, `bind`,
+*   `call`, `toString` — used by reflection-heavy code paths (logger sinks,
+*   lazy bindings, debug formatters) where calling the global builtin without a
+*   captured reference would expose to prototype tampering.
+*/
+const FunctionPrototypeApply = require_primordials_uncurry.uncurryThis(Function.prototype.apply);
+const FunctionPrototypeBind = require_primordials_uncurry.uncurryThis(Function.prototype.bind);
+const FunctionPrototypeCall = require_primordials_uncurry.uncurryThis(Function.prototype.call);
+const FunctionPrototypeToString = require_primordials_uncurry.uncurryThis(Function.prototype.toString);
+
+//#endregion
+exports.FunctionPrototypeApply = FunctionPrototypeApply;
+exports.FunctionPrototypeBind = FunctionPrototypeBind;
+exports.FunctionPrototypeCall = FunctionPrototypeCall;
+exports.FunctionPrototypeToString = FunctionPrototypeToString;

package/dist/primordials/globals.js

@@ -1,38 +1,16 @@
 "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 globals_exports = {};
-__export(globals_exports, {
-  BigIntCtor: () => BigIntCtor,
-  BooleanCtor: () => BooleanCtor,
-  InfinityValue: () => InfinityValue,
-  NaNValue: () => NaNValue,
-  ProxyCtor: () => ProxyCtor,
-  SharedArrayBufferCtor: () => SharedArrayBufferCtor,
-  atob: () => atob,
-  btoa: () => btoa,
-  decodeURIComponent: () => decodeURIComponent,
-  encodeURIComponent: () => encodeURIComponent,
-  globalThis: () => capturedGlobalThis
-});
-module.exports = __toCommonJS(globals_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/primordials/globals.ts
+/**
+* @file Safe references to top-level globals that don't fit a larger
+*   primordials leaf — primitive constructors (`Boolean`, `BigInt`), `Proxy`,
+*   `SharedArrayBuffer`, language-level constants (`Infinity`, `NaN`,
+*   `globalThis`), and the encode/decode helpers. Every reference is captured
+*   once at module load so consumers reading adversarial input never see a
+*   tampered global.
+*/
 const BigIntCtor = BigInt;
 const BooleanCtor = Boolean;
 const ProxyCtor = Proxy;
@@ -44,17 +22,16 @@ const atob = globalThis.atob;
 const btoa = globalThis.btoa;
 const decodeURIComponent = globalThis.decodeURIComponent;
 const encodeURIComponent = globalThis.encodeURIComponent;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BigIntCtor,
-  BooleanCtor,
-  InfinityValue,
-  NaNValue,
-  ProxyCtor,
-  SharedArrayBufferCtor,
-  atob,
-  btoa,
-  decodeURIComponent,
-  encodeURIComponent,
-  globalThis
-});
+
+//#endregion
+exports.BigIntCtor = BigIntCtor;
+exports.BooleanCtor = BooleanCtor;
+exports.InfinityValue = InfinityValue;
+exports.NaNValue = NaNValue;
+exports.ProxyCtor = ProxyCtor;
+exports.SharedArrayBufferCtor = SharedArrayBufferCtor;
+exports.atob = atob;
+exports.btoa = btoa;
+exports.decodeURIComponent = decodeURIComponent;
+exports.encodeURIComponent = encodeURIComponent;
+exports.globalThis = capturedGlobalThis;

package/dist/primordials/json.js

@@ -1,33 +1,17 @@
 "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 json_exports = {};
-__export(json_exports, {
-  JSONParse: () => JSONParse,
-  JSONStringify: () => JSONStringify
-});
-module.exports = __toCommonJS(json_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/primordials/json.ts
+/**
+* @file Safe references to `JSON.parse` / `JSON.stringify`. Captured at module
+*   load so prototype-pollution attacks (e.g. monkey-patching `JSON.parse` to
+*   leak the parsed payload) can't redirect callers that route through these
+*   references.
+*/
 const JSONParse = JSON.parse;
 const JSONStringify = JSON.stringify;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  JSONParse,
-  JSONStringify
-});
+
+//#endregion
+exports.JSONParse = JSONParse;
+exports.JSONStringify = JSONStringify;

package/dist/primordials/map-set.js

@@ -1,158 +1,94 @@
 "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,
-  MapPrototypeGetOrInsert: () => MapPrototypeGetOrInsert,
-  MapPrototypeGetOrInsertComputed: () => MapPrototypeGetOrInsertComputed,
-  MapPrototypeHas: () => MapPrototypeHas,
-  MapPrototypeKeys: () => MapPrototypeKeys,
-  MapPrototypeSet: () => MapPrototypeSet,
-  MapPrototypeValues: () => MapPrototypeValues,
-  SetCtor: () => SetCtor,
-  SetPrototypeAdd: () => SetPrototypeAdd,
-  SetPrototypeClear: () => SetPrototypeClear,
-  SetPrototypeDelete: () => SetPrototypeDelete,
-  SetPrototypeDifference: () => SetPrototypeDifference,
-  SetPrototypeEntries: () => SetPrototypeEntries,
-  SetPrototypeForEach: () => SetPrototypeForEach,
-  SetPrototypeHas: () => SetPrototypeHas,
-  SetPrototypeIntersection: () => SetPrototypeIntersection,
-  SetPrototypeIsDisjointFrom: () => SetPrototypeIsDisjointFrom,
-  SetPrototypeIsSubsetOf: () => SetPrototypeIsSubsetOf,
-  SetPrototypeIsSupersetOf: () => SetPrototypeIsSupersetOf,
-  SetPrototypeKeys: () => SetPrototypeKeys,
-  SetPrototypeSymmetricDifference: () => SetPrototypeSymmetricDifference,
-  SetPrototypeUnion: () => SetPrototypeUnion,
-  SetPrototypeValues: () => SetPrototypeValues,
-  WeakMapCtor: () => WeakMapCtor,
-  WeakMapPrototypeDelete: () => WeakMapPrototypeDelete,
-  WeakMapPrototypeGet: () => WeakMapPrototypeGet,
-  WeakMapPrototypeGetOrInsert: () => WeakMapPrototypeGetOrInsert,
-  WeakMapPrototypeGetOrInsertComputed: () => WeakMapPrototypeGetOrInsertComputed,
-  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");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_uncurry = require('./uncurry.js');
+
+//#region src/primordials/map-set.ts
+/**
+* @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.
+*/
 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 MapPrototypeGetOrInsert = (0, import_uncurry.uncurryThis)(Map.prototype.getOrInsert);
-const MapPrototypeGetOrInsertComputed = (0, import_uncurry.uncurryThis)(
-  Map.prototype.getOrInsertComputed
-);
-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 SetPrototypeDifference = (0, import_uncurry.uncurryThis)(Set.prototype.difference);
-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 SetPrototypeIntersection = (0, import_uncurry.uncurryThis)(Set.prototype.intersection);
-const SetPrototypeIsDisjointFrom = (0, import_uncurry.uncurryThis)(
-  Set.prototype.isDisjointFrom
-);
-const SetPrototypeIsSubsetOf = (0, import_uncurry.uncurryThis)(Set.prototype.isSubsetOf);
-const SetPrototypeIsSupersetOf = (0, import_uncurry.uncurryThis)(Set.prototype.isSupersetOf);
-const SetPrototypeKeys = (0, import_uncurry.uncurryThis)(Set.prototype.keys);
-const SetPrototypeSymmetricDifference = (0, import_uncurry.uncurryThis)(
-  Set.prototype.symmetricDifference
-);
-const SetPrototypeUnion = (0, import_uncurry.uncurryThis)(Set.prototype.union);
-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 WeakMapPrototypeGetOrInsert = (0, import_uncurry.uncurryThis)(
-  WeakMap.prototype.getOrInsert
-);
-const WeakMapPrototypeGetOrInsertComputed = (0, import_uncurry.uncurryThis)(
-  WeakMap.prototype.getOrInsertComputed
-);
-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,
-  MapPrototypeGetOrInsert,
-  MapPrototypeGetOrInsertComputed,
-  MapPrototypeHas,
-  MapPrototypeKeys,
-  MapPrototypeSet,
-  MapPrototypeValues,
-  SetCtor,
-  SetPrototypeAdd,
-  SetPrototypeClear,
-  SetPrototypeDelete,
-  SetPrototypeDifference,
-  SetPrototypeEntries,
-  SetPrototypeForEach,
-  SetPrototypeHas,
-  SetPrototypeIntersection,
-  SetPrototypeIsDisjointFrom,
-  SetPrototypeIsSubsetOf,
-  SetPrototypeIsSupersetOf,
-  SetPrototypeKeys,
-  SetPrototypeSymmetricDifference,
-  SetPrototypeUnion,
-  SetPrototypeValues,
-  WeakMapCtor,
-  WeakMapPrototypeDelete,
-  WeakMapPrototypeGet,
-  WeakMapPrototypeGetOrInsert,
-  WeakMapPrototypeGetOrInsertComputed,
-  WeakMapPrototypeHas,
-  WeakMapPrototypeSet,
-  WeakRefCtor,
-  WeakSetCtor,
-  WeakSetPrototypeAdd,
-  WeakSetPrototypeDelete,
-  WeakSetPrototypeHas
-});
+const MapPrototypeClear = require_primordials_uncurry.uncurryThis(Map.prototype.clear);
+const MapPrototypeDelete = require_primordials_uncurry.uncurryThis(Map.prototype.delete);
+const MapPrototypeEntries = require_primordials_uncurry.uncurryThis(Map.prototype.entries);
+const MapPrototypeForEach = require_primordials_uncurry.uncurryThis(Map.prototype.forEach);
+const MapPrototypeGet = require_primordials_uncurry.uncurryThis(Map.prototype.get);
+const MapPrototypeGetOrInsert = require_primordials_uncurry.uncurryThis(Map.prototype.getOrInsert);
+const MapPrototypeGetOrInsertComputed = require_primordials_uncurry.uncurryThis(Map.prototype.getOrInsertComputed);
+const MapPrototypeHas = require_primordials_uncurry.uncurryThis(Map.prototype.has);
+const MapPrototypeKeys = require_primordials_uncurry.uncurryThis(Map.prototype.keys);
+const MapPrototypeSet = require_primordials_uncurry.uncurryThis(Map.prototype.set);
+const MapPrototypeValues = require_primordials_uncurry.uncurryThis(Map.prototype.values);
+const SetPrototypeAdd = require_primordials_uncurry.uncurryThis(Set.prototype.add);
+const SetPrototypeClear = require_primordials_uncurry.uncurryThis(Set.prototype.clear);
+const SetPrototypeDelete = require_primordials_uncurry.uncurryThis(Set.prototype.delete);
+const SetPrototypeDifference = require_primordials_uncurry.uncurryThis(Set.prototype.difference);
+const SetPrototypeEntries = require_primordials_uncurry.uncurryThis(Set.prototype.entries);
+const SetPrototypeForEach = require_primordials_uncurry.uncurryThis(Set.prototype.forEach);
+const SetPrototypeHas = require_primordials_uncurry.uncurryThis(Set.prototype.has);
+const SetPrototypeIntersection = require_primordials_uncurry.uncurryThis(Set.prototype.intersection);
+const SetPrototypeIsDisjointFrom = require_primordials_uncurry.uncurryThis(Set.prototype.isDisjointFrom);
+const SetPrototypeIsSubsetOf = require_primordials_uncurry.uncurryThis(Set.prototype.isSubsetOf);
+const SetPrototypeIsSupersetOf = require_primordials_uncurry.uncurryThis(Set.prototype.isSupersetOf);
+const SetPrototypeKeys = require_primordials_uncurry.uncurryThis(Set.prototype.keys);
+const SetPrototypeSymmetricDifference = require_primordials_uncurry.uncurryThis(Set.prototype.symmetricDifference);
+const SetPrototypeUnion = require_primordials_uncurry.uncurryThis(Set.prototype.union);
+const SetPrototypeValues = require_primordials_uncurry.uncurryThis(Set.prototype.values);
+const WeakMapPrototypeDelete = require_primordials_uncurry.uncurryThis(WeakMap.prototype.delete);
+const WeakMapPrototypeGet = require_primordials_uncurry.uncurryThis(WeakMap.prototype.get);
+const WeakMapPrototypeGetOrInsert = require_primordials_uncurry.uncurryThis(WeakMap.prototype.getOrInsert);
+const WeakMapPrototypeGetOrInsertComputed = require_primordials_uncurry.uncurryThis(WeakMap.prototype.getOrInsertComputed);
+const WeakMapPrototypeHas = require_primordials_uncurry.uncurryThis(WeakMap.prototype.has);
+const WeakMapPrototypeSet = require_primordials_uncurry.uncurryThis(WeakMap.prototype.set);
+const WeakSetPrototypeAdd = require_primordials_uncurry.uncurryThis(WeakSet.prototype.add);
+const WeakSetPrototypeDelete = require_primordials_uncurry.uncurryThis(WeakSet.prototype.delete);
+const WeakSetPrototypeHas = require_primordials_uncurry.uncurryThis(WeakSet.prototype.has);
+
+//#endregion
+exports.MapCtor = MapCtor;
+exports.MapPrototypeClear = MapPrototypeClear;
+exports.MapPrototypeDelete = MapPrototypeDelete;
+exports.MapPrototypeEntries = MapPrototypeEntries;
+exports.MapPrototypeForEach = MapPrototypeForEach;
+exports.MapPrototypeGet = MapPrototypeGet;
+exports.MapPrototypeGetOrInsert = MapPrototypeGetOrInsert;
+exports.MapPrototypeGetOrInsertComputed = MapPrototypeGetOrInsertComputed;
+exports.MapPrototypeHas = MapPrototypeHas;
+exports.MapPrototypeKeys = MapPrototypeKeys;
+exports.MapPrototypeSet = MapPrototypeSet;
+exports.MapPrototypeValues = MapPrototypeValues;
+exports.SetCtor = SetCtor;
+exports.SetPrototypeAdd = SetPrototypeAdd;
+exports.SetPrototypeClear = SetPrototypeClear;
+exports.SetPrototypeDelete = SetPrototypeDelete;
+exports.SetPrototypeDifference = SetPrototypeDifference;
+exports.SetPrototypeEntries = SetPrototypeEntries;
+exports.SetPrototypeForEach = SetPrototypeForEach;
+exports.SetPrototypeHas = SetPrototypeHas;
+exports.SetPrototypeIntersection = SetPrototypeIntersection;
+exports.SetPrototypeIsDisjointFrom = SetPrototypeIsDisjointFrom;
+exports.SetPrototypeIsSubsetOf = SetPrototypeIsSubsetOf;
+exports.SetPrototypeIsSupersetOf = SetPrototypeIsSupersetOf;
+exports.SetPrototypeKeys = SetPrototypeKeys;
+exports.SetPrototypeSymmetricDifference = SetPrototypeSymmetricDifference;
+exports.SetPrototypeUnion = SetPrototypeUnion;
+exports.SetPrototypeValues = SetPrototypeValues;
+exports.WeakMapCtor = WeakMapCtor;
+exports.WeakMapPrototypeDelete = WeakMapPrototypeDelete;
+exports.WeakMapPrototypeGet = WeakMapPrototypeGet;
+exports.WeakMapPrototypeGetOrInsert = WeakMapPrototypeGetOrInsert;
+exports.WeakMapPrototypeGetOrInsertComputed = WeakMapPrototypeGetOrInsertComputed;
+exports.WeakMapPrototypeHas = WeakMapPrototypeHas;
+exports.WeakMapPrototypeSet = WeakMapPrototypeSet;
+exports.WeakRefCtor = WeakRefCtor;
+exports.WeakSetCtor = WeakSetCtor;
+exports.WeakSetPrototypeAdd = WeakSetPrototypeAdd;
+exports.WeakSetPrototypeDelete = WeakSetPrototypeDelete;
+exports.WeakSetPrototypeHas = WeakSetPrototypeHas;

package/dist/primordials/math.js

@@ -1,73 +1,17 @@
 "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)();
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_smol_primordial = require('../smol/primordial.js');
+
+//#region src/primordials/math.ts
+/**
+* @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.
+*/
+const _smolPrimordial = /* @__PURE__ */ require_smol_primordial.getSmolPrimordial();
 const MathE = Math.E;
 const MathLN2 = Math.LN2;
 const MathLN10 = Math.LN10;
@@ -112,50 +56,49 @@ 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
-});
+
+//#endregion
+exports.MathAbs = MathAbs;
+exports.MathAcos = MathAcos;
+exports.MathAcosh = MathAcosh;
+exports.MathAsin = MathAsin;
+exports.MathAsinh = MathAsinh;
+exports.MathAtan = MathAtan;
+exports.MathAtan2 = MathAtan2;
+exports.MathAtanh = MathAtanh;
+exports.MathCbrt = MathCbrt;
+exports.MathCeil = MathCeil;
+exports.MathClz32 = MathClz32;
+exports.MathCos = MathCos;
+exports.MathCosh = MathCosh;
+exports.MathE = MathE;
+exports.MathExp = MathExp;
+exports.MathExpm1 = MathExpm1;
+exports.MathF16round = MathF16round;
+exports.MathFloor = MathFloor;
+exports.MathFround = MathFround;
+exports.MathHypot = MathHypot;
+exports.MathImul = MathImul;
+exports.MathLN10 = MathLN10;
+exports.MathLN2 = MathLN2;
+exports.MathLOG10E = MathLOG10E;
+exports.MathLOG2E = MathLOG2E;
+exports.MathLog = MathLog;
+exports.MathLog10 = MathLog10;
+exports.MathLog1p = MathLog1p;
+exports.MathLog2 = MathLog2;
+exports.MathMax = MathMax;
+exports.MathMin = MathMin;
+exports.MathPI = MathPI;
+exports.MathPow = MathPow;
+exports.MathRandom = MathRandom;
+exports.MathRound = MathRound;
+exports.MathSQRT1_2 = MathSQRT1_2;
+exports.MathSQRT2 = MathSQRT2;
+exports.MathSign = MathSign;
+exports.MathSin = MathSin;
+exports.MathSinh = MathSinh;
+exports.MathSqrt = MathSqrt;
+exports.MathTan = MathTan;
+exports.MathTanh = MathTanh;
+exports.MathTrunc = MathTrunc;