@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/primordials/array.js

@@ -0,0 +1,220 @@
+"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 array_exports = {};
+__export(array_exports, {
+  ArrayBufferCtor: () => ArrayBufferCtor,
+  ArrayBufferIsView: () => ArrayBufferIsView,
+  ArrayCtor: () => ArrayCtor,
+  ArrayFrom: () => ArrayFrom,
+  ArrayFromAsync: () => ArrayFromAsync,
+  ArrayIsArray: () => ArrayIsArray,
+  ArrayOf: () => ArrayOf,
+  ArrayPrototypeAt: () => ArrayPrototypeAt,
+  ArrayPrototypeConcat: () => ArrayPrototypeConcat,
+  ArrayPrototypeCopyWithin: () => ArrayPrototypeCopyWithin,
+  ArrayPrototypeEntries: () => ArrayPrototypeEntries,
+  ArrayPrototypeEvery: () => ArrayPrototypeEvery,
+  ArrayPrototypeFill: () => ArrayPrototypeFill,
+  ArrayPrototypeFilter: () => ArrayPrototypeFilter,
+  ArrayPrototypeFind: () => ArrayPrototypeFind,
+  ArrayPrototypeFindIndex: () => ArrayPrototypeFindIndex,
+  ArrayPrototypeFindLast: () => ArrayPrototypeFindLast,
+  ArrayPrototypeFindLastIndex: () => ArrayPrototypeFindLastIndex,
+  ArrayPrototypeFlat: () => ArrayPrototypeFlat,
+  ArrayPrototypeFlatMap: () => ArrayPrototypeFlatMap,
+  ArrayPrototypeForEach: () => ArrayPrototypeForEach,
+  ArrayPrototypeIncludes: () => ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf: () => ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin: () => ArrayPrototypeJoin,
+  ArrayPrototypeKeys: () => ArrayPrototypeKeys,
+  ArrayPrototypeLastIndexOf: () => ArrayPrototypeLastIndexOf,
+  ArrayPrototypeMap: () => ArrayPrototypeMap,
+  ArrayPrototypePop: () => ArrayPrototypePop,
+  ArrayPrototypePush: () => ArrayPrototypePush,
+  ArrayPrototypeReduce: () => ArrayPrototypeReduce,
+  ArrayPrototypeReduceRight: () => ArrayPrototypeReduceRight,
+  ArrayPrototypeReverse: () => ArrayPrototypeReverse,
+  ArrayPrototypeShift: () => ArrayPrototypeShift,
+  ArrayPrototypeSlice: () => ArrayPrototypeSlice,
+  ArrayPrototypeSome: () => ArrayPrototypeSome,
+  ArrayPrototypeSort: () => ArrayPrototypeSort,
+  ArrayPrototypeSplice: () => ArrayPrototypeSplice,
+  ArrayPrototypeToLocaleString: () => ArrayPrototypeToLocaleString,
+  ArrayPrototypeToReversed: () => ArrayPrototypeToReversed,
+  ArrayPrototypeToSorted: () => ArrayPrototypeToSorted,
+  ArrayPrototypeToSpliced: () => ArrayPrototypeToSpliced,
+  ArrayPrototypeToString: () => ArrayPrototypeToString,
+  ArrayPrototypeUnshift: () => ArrayPrototypeUnshift,
+  ArrayPrototypeValues: () => ArrayPrototypeValues,
+  ArrayPrototypeWith: () => ArrayPrototypeWith,
+  AtomicsWait: () => AtomicsWait,
+  DataViewCtor: () => DataViewCtor,
+  Float32ArrayCtor: () => Float32ArrayCtor,
+  Float64ArrayCtor: () => Float64ArrayCtor,
+  Int16ArrayCtor: () => Int16ArrayCtor,
+  Int32ArrayCtor: () => Int32ArrayCtor,
+  Int8ArrayCtor: () => Int8ArrayCtor,
+  IteratorPrototypeNext: () => IteratorPrototypeNext,
+  IteratorPrototypeReturn: () => IteratorPrototypeReturn,
+  Uint16ArrayCtor: () => Uint16ArrayCtor,
+  Uint32ArrayCtor: () => Uint32ArrayCtor,
+  Uint8ArrayCtor: () => Uint8ArrayCtor,
+  Uint8ClampedArrayCtor: () => Uint8ClampedArrayCtor
+});
+module.exports = __toCommonJS(array_exports);
+var import_primordial = require("../smol/primordial");
+var import_uncurry = require("./uncurry");
+const _smolPrimordial = (0, import_primordial.getSmolPrimordial)();
+const ArrayCtor = Array;
+const ArrayBufferCtor = ArrayBuffer;
+const DataViewCtor = DataView;
+const Float32ArrayCtor = Float32Array;
+const Float64ArrayCtor = Float64Array;
+const Int8ArrayCtor = Int8Array;
+const Int16ArrayCtor = Int16Array;
+const Int32ArrayCtor = Int32Array;
+const Uint8ArrayCtor = Uint8Array;
+const Uint8ClampedArrayCtor = Uint8ClampedArray;
+const Uint16ArrayCtor = Uint16Array;
+const Uint32ArrayCtor = Uint32Array;
+const ArrayFrom = Array.from;
+const ArrayFromAsync = Array.fromAsync;
+const ArrayIsArray = _smolPrimordial?.arrayIsArray ?? Array.isArray;
+const ArrayOf = Array.of;
+const ArrayBufferIsView = ArrayBuffer.isView;
+const AtomicsWait = Atomics.wait;
+const ArrayPrototypeAt = (0, import_uncurry.uncurryThis)(Array.prototype.at);
+const ArrayPrototypeConcat = (0, import_uncurry.uncurryThis)(Array.prototype.concat);
+const ArrayPrototypeCopyWithin = (0, import_uncurry.uncurryThis)(Array.prototype.copyWithin);
+const ArrayPrototypeEntries = (0, import_uncurry.uncurryThis)(Array.prototype.entries);
+const ArrayPrototypeEvery = (0, import_uncurry.uncurryThis)(Array.prototype.every);
+const ArrayPrototypeFill = (0, import_uncurry.uncurryThis)(Array.prototype.fill);
+const ArrayPrototypeFilter = (0, import_uncurry.uncurryThis)(Array.prototype.filter);
+const ArrayPrototypeFind = (0, import_uncurry.uncurryThis)(Array.prototype.find);
+const ArrayPrototypeFindIndex = (0, import_uncurry.uncurryThis)(Array.prototype.findIndex);
+const ArrayPrototypeFindLast = (0, import_uncurry.uncurryThis)(Array.prototype.findLast);
+const ArrayPrototypeFindLastIndex = (0, import_uncurry.uncurryThis)(
+  Array.prototype.findLastIndex
+);
+const ArrayPrototypeFlat = (0, import_uncurry.uncurryThis)(Array.prototype.flat);
+const ArrayPrototypeFlatMap = (0, import_uncurry.uncurryThis)(Array.prototype.flatMap);
+const ArrayPrototypeForEach = (0, import_uncurry.uncurryThis)(Array.prototype.forEach);
+const ArrayPrototypeIncludes = (0, import_uncurry.uncurryThis)(Array.prototype.includes);
+const ArrayPrototypeIndexOf = (0, import_uncurry.uncurryThis)(Array.prototype.indexOf);
+const ArrayPrototypeJoin = (0, import_uncurry.uncurryThis)(Array.prototype.join);
+const ArrayPrototypeKeys = (0, import_uncurry.uncurryThis)(Array.prototype.keys);
+const ArrayPrototypeLastIndexOf = (0, import_uncurry.uncurryThis)(
+  Array.prototype.lastIndexOf
+);
+const ArrayPrototypeMap = (0, import_uncurry.uncurryThis)(Array.prototype.map);
+const ArrayPrototypePop = (0, import_uncurry.uncurryThis)(Array.prototype.pop);
+const ArrayPrototypePush = (0, import_uncurry.uncurryThis)(Array.prototype.push);
+const ArrayPrototypeReduce = (0, import_uncurry.uncurryThis)(Array.prototype.reduce);
+const ArrayPrototypeReduceRight = (0, import_uncurry.uncurryThis)(
+  Array.prototype.reduceRight
+);
+const ArrayPrototypeReverse = (0, import_uncurry.uncurryThis)(Array.prototype.reverse);
+const ArrayPrototypeShift = (0, import_uncurry.uncurryThis)(Array.prototype.shift);
+const ArrayPrototypeSlice = (0, import_uncurry.uncurryThis)(Array.prototype.slice);
+const ArrayPrototypeSome = (0, import_uncurry.uncurryThis)(Array.prototype.some);
+const ArrayPrototypeSort = (0, import_uncurry.uncurryThis)(Array.prototype.sort);
+const ArrayPrototypeSplice = (0, import_uncurry.uncurryThis)(Array.prototype.splice);
+const ArrayPrototypeToLocaleString = (0, import_uncurry.uncurryThis)(
+  Array.prototype.toLocaleString
+);
+const ArrayPrototypeToReversed = (0, import_uncurry.uncurryThis)(Array.prototype.toReversed);
+const ArrayPrototypeToSorted = (0, import_uncurry.uncurryThis)(Array.prototype.toSorted);
+const ArrayPrototypeToSpliced = (0, import_uncurry.uncurryThis)(
+  Array.prototype.toSpliced
+);
+const ArrayPrototypeToString = (0, import_uncurry.uncurryThis)(Array.prototype.toString);
+const ArrayPrototypeUnshift = (0, import_uncurry.uncurryThis)(Array.prototype.unshift);
+const ArrayPrototypeValues = (0, import_uncurry.uncurryThis)(Array.prototype.values);
+const ArrayPrototypeWith = (0, import_uncurry.uncurryThis)(Array.prototype.with);
+const _anyIterator = (/* @__PURE__ */ new Map()).keys();
+let _iteratorLookup = Object.getPrototypeOf(_anyIterator);
+while (_iteratorLookup && typeof _iteratorLookup.next !== "function") {
+  _iteratorLookup = Object.getPrototypeOf(_iteratorLookup);
+}
+const _iteratorProto = _iteratorLookup;
+const IteratorPrototypeNext = (0, import_uncurry.uncurryThis)(_iteratorProto.next);
+const IteratorPrototypeReturn = typeof _iteratorProto.return === "function" ? (0, import_uncurry.uncurryThis)(_iteratorProto.return) : void 0;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayBufferCtor,
+  ArrayBufferIsView,
+  ArrayCtor,
+  ArrayFrom,
+  ArrayFromAsync,
+  ArrayIsArray,
+  ArrayOf,
+  ArrayPrototypeAt,
+  ArrayPrototypeConcat,
+  ArrayPrototypeCopyWithin,
+  ArrayPrototypeEntries,
+  ArrayPrototypeEvery,
+  ArrayPrototypeFill,
+  ArrayPrototypeFilter,
+  ArrayPrototypeFind,
+  ArrayPrototypeFindIndex,
+  ArrayPrototypeFindLast,
+  ArrayPrototypeFindLastIndex,
+  ArrayPrototypeFlat,
+  ArrayPrototypeFlatMap,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypeKeys,
+  ArrayPrototypeLastIndexOf,
+  ArrayPrototypeMap,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypeReduce,
+  ArrayPrototypeReduceRight,
+  ArrayPrototypeReverse,
+  ArrayPrototypeShift,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSome,
+  ArrayPrototypeSort,
+  ArrayPrototypeSplice,
+  ArrayPrototypeToLocaleString,
+  ArrayPrototypeToReversed,
+  ArrayPrototypeToSorted,
+  ArrayPrototypeToSpliced,
+  ArrayPrototypeToString,
+  ArrayPrototypeUnshift,
+  ArrayPrototypeValues,
+  ArrayPrototypeWith,
+  AtomicsWait,
+  DataViewCtor,
+  Float32ArrayCtor,
+  Float64ArrayCtor,
+  Int16ArrayCtor,
+  Int32ArrayCtor,
+  Int8ArrayCtor,
+  IteratorPrototypeNext,
+  IteratorPrototypeReturn,
+  Uint16ArrayCtor,
+  Uint32ArrayCtor,
+  Uint8ArrayCtor,
+  Uint8ClampedArrayCtor
+});

package/dist/primordials/buffer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file Safe references to Node's `Buffer` global. `Buffer` is a Node-only
+ *   global; in browsers and Deno (without compatibility shim) the captured
+ *   references are `undefined`. Cross- env consumers must null-check before
+ *   calling.
+ */
+export declare const BufferCtor: typeof globalThis.Buffer | undefined;
+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;

package/dist/primordials/buffer.js

@@ -0,0 +1,61 @@
+"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 buffer_exports = {};
+__export(buffer_exports, {
+  BufferAlloc: () => BufferAlloc,
+  BufferAllocUnsafe: () => BufferAllocUnsafe,
+  BufferAllocUnsafeSlow: () => BufferAllocUnsafeSlow,
+  BufferByteLength: () => BufferByteLength,
+  BufferConcat: () => BufferConcat,
+  BufferCtor: () => BufferCtor,
+  BufferFrom: () => BufferFrom,
+  BufferIsBuffer: () => BufferIsBuffer,
+  BufferIsEncoding: () => BufferIsEncoding,
+  BufferPrototypeSlice: () => BufferPrototypeSlice,
+  BufferPrototypeToString: () => BufferPrototypeToString
+});
+module.exports = __toCommonJS(buffer_exports);
+var import_uncurry = require("./uncurry");
+const BufferCtor = globalThis.Buffer;
+const BufferAlloc = BufferCtor?.alloc;
+const BufferAllocUnsafe = BufferCtor?.allocUnsafe;
+const BufferAllocUnsafeSlow = BufferCtor?.allocUnsafeSlow;
+const BufferByteLength = BufferCtor?.byteLength;
+const BufferConcat = BufferCtor?.concat;
+const BufferFrom = BufferCtor?.from;
+const BufferIsBuffer = BufferCtor?.isBuffer;
+const BufferIsEncoding = BufferCtor?.isEncoding;
+const BufferPrototypeSlice = BufferCtor ? (0, import_uncurry.uncurryThis)(BufferCtor.prototype.slice) : void 0;
+const BufferPrototypeToString = BufferCtor ? (0, import_uncurry.uncurryThis)(BufferCtor.prototype.toString) : void 0;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BufferAlloc,
+  BufferAllocUnsafe,
+  BufferAllocUnsafeSlow,
+  BufferByteLength,
+  BufferConcat,
+  BufferCtor,
+  BufferFrom,
+  BufferIsBuffer,
+  BufferIsEncoding,
+  BufferPrototypeSlice,
+  BufferPrototypeToString
+});

package/dist/primordials/date.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Safe references to `Date`. `DateNow` prefers the smol Fast API binding
+ *   (single-byte wallclock read inlined into JIT'd callers) when available;
+ *   stock Node falls back to `Date.now`.
+ */
+export declare const DateCtor: DateConstructor;
+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 DatePrototypeToLocaleString: (self: unknown, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined) => string;
+export declare const DatePrototypeValueOf: (self: unknown) => number;

package/dist/primordials/date.js

@@ -0,0 +1,56 @@
+"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 date_exports = {};
+__export(date_exports, {
+  DateCtor: () => DateCtor,
+  DateNow: () => DateNow,
+  DateParse: () => DateParse,
+  DatePrototypeGetTime: () => DatePrototypeGetTime,
+  DatePrototypeToISOString: () => DatePrototypeToISOString,
+  DatePrototypeToLocaleString: () => DatePrototypeToLocaleString,
+  DatePrototypeValueOf: () => DatePrototypeValueOf,
+  DateUTC: () => DateUTC
+});
+module.exports = __toCommonJS(date_exports);
+var import_primordial = require("../smol/primordial");
+var import_uncurry = require("./uncurry");
+const _smolPrimordial = (0, import_primordial.getSmolPrimordial)();
+const DateCtor = Date;
+const DateNow = _smolPrimordial?.dateNow ?? Date.now;
+const DateParse = Date.parse;
+const DateUTC = Date.UTC;
+const DatePrototypeGetTime = (0, import_uncurry.uncurryThis)(Date.prototype.getTime);
+const DatePrototypeToISOString = (0, import_uncurry.uncurryThis)(Date.prototype.toISOString);
+const DatePrototypeToLocaleString = (0, import_uncurry.uncurryThis)(
+  Date.prototype.toLocaleString
+);
+const DatePrototypeValueOf = (0, import_uncurry.uncurryThis)(Date.prototype.valueOf);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DateCtor,
+  DateNow,
+  DateParse,
+  DatePrototypeGetTime,
+  DatePrototypeToISOString,
+  DatePrototypeToLocaleString,
+  DatePrototypeValueOf,
+  DateUTC
+});

package/dist/primordials/error.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file Safe references to `Error` and its subclass constructors, plus V8's
+ *   stack-trace API. `Error.isError` is ES2025; `captureStackTrace` /
+ *   `prepareStackTrace` / `stackTraceLimit` are V8 extensions absent on
+ *   JavaScriptCore and SpiderMonkey. Each is typed `Function | undefined` so
+ *   non-V8 importers stay safe.
+ */
+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 ErrorIsError: ((value: unknown) => value is Error) | undefined;
+export declare const ErrorCaptureStackTrace: ((targetObject: object, constructorOpt?: Function) => void) | undefined;
+export declare const ErrorPrepareStackTrace: ((error: Error, structuredStackTrace: NodeJS.CallSite[]) => unknown) | undefined;
+export declare function ErrorStackTraceLimit(): number | undefined;

package/dist/primordials/error.js

@@ -0,0 +1,75 @@
+"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 error_exports = {};
+__export(error_exports, {
+  AggregateErrorCtor: () => AggregateErrorCtor,
+  ErrorCaptureStackTrace: () => ErrorCaptureStackTrace,
+  ErrorCtor: () => ErrorCtor,
+  ErrorIsError: () => ErrorIsError,
+  ErrorPrepareStackTrace: () => ErrorPrepareStackTrace,
+  ErrorStackTraceLimit: () => ErrorStackTraceLimit,
+  EvalErrorCtor: () => EvalErrorCtor,
+  RangeErrorCtor: () => RangeErrorCtor,
+  ReferenceErrorCtor: () => ReferenceErrorCtor,
+  SyntaxErrorCtor: () => SyntaxErrorCtor,
+  TypeErrorCtor: () => TypeErrorCtor,
+  URIErrorCtor: () => URIErrorCtor
+});
+module.exports = __toCommonJS(error_exports);
+const ErrorCtor = Error;
+const AggregateErrorCtor = AggregateError;
+const EvalErrorCtor = EvalError;
+const RangeErrorCtor = RangeError;
+const ReferenceErrorCtor = ReferenceError;
+const SyntaxErrorCtor = SyntaxError;
+const TypeErrorCtor = TypeError;
+const URIErrorCtor = URIError;
+const ErrorIsError = Error.isError;
+const ErrorCaptureStackTrace = Error.captureStackTrace;
+const ErrorPrepareStackTrace = Error.prepareStackTrace;
+const _stackTraceLimitGetter = (() => {
+  const getter = Error.__lookupGetter__?.("stackTraceLimit");
+  if (typeof getter === "function") {
+    return () => getter.call(Error);
+  }
+  return void 0;
+})();
+function ErrorStackTraceLimit() {
+  if (_stackTraceLimitGetter) {
+    return _stackTraceLimitGetter();
+  }
+  return Error.stackTraceLimit;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AggregateErrorCtor,
+  ErrorCaptureStackTrace,
+  ErrorCtor,
+  ErrorIsError,
+  ErrorPrepareStackTrace,
+  ErrorStackTraceLimit,
+  EvalErrorCtor,
+  RangeErrorCtor,
+  ReferenceErrorCtor,
+  SyntaxErrorCtor,
+  TypeErrorCtor,
+  URIErrorCtor
+});

package/dist/primordials/function.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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.
+ */
+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 FunctionPrototypeToString: (self: (...args: unknown[]) => unknown) => string;

package/dist/primordials/function.js

@@ -0,0 +1,42 @@
+"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
+});

package/dist/primordials/globals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export declare const BigIntCtor: BigIntConstructor;
+export declare const BooleanCtor: BooleanConstructor;
+export declare const ProxyCtor: ProxyConstructor;
+export declare const SharedArrayBufferCtor: SharedArrayBufferConstructor;
+export declare const InfinityValue: number;
+export declare const NaNValue: number;
+export declare const globalThisRef: typeof globalThis;
+export declare const decodeComponent: typeof decodeURIComponent;
+export declare const encodeComponent: typeof encodeURIComponent;

package/dist/primordials/globals.js

@@ -0,0 +1,54 @@
+"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,
+  decodeComponent: () => decodeComponent,
+  encodeComponent: () => encodeComponent,
+  globalThisRef: () => globalThisRef
+});
+module.exports = __toCommonJS(globals_exports);
+const BigIntCtor = BigInt;
+const BooleanCtor = Boolean;
+const ProxyCtor = Proxy;
+const SharedArrayBufferCtor = SharedArrayBuffer;
+const InfinityValue = Infinity;
+const NaNValue = NaN;
+const globalThisRef = globalThis;
+const decodeComponent = globalThis.decodeURIComponent;
+const encodeComponent = globalThis.encodeURIComponent;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BigIntCtor,
+  BooleanCtor,
+  InfinityValue,
+  NaNValue,
+  ProxyCtor,
+  SharedArrayBufferCtor,
+  decodeComponent,
+  encodeComponent,
+  globalThisRef
+});

package/dist/primordials/json.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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.
+ */
+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;
+};

package/dist/primordials/json.js

@@ -0,0 +1,33 @@
+"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);
+const JSONParse = JSON.parse;
+const JSONStringify = JSON.stringify;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JSONParse,
+  JSONStringify
+});