@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/primordials/object.js

@@ -0,0 +1,142 @@
+"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 object_exports = {};
+__export(object_exports, {
+  ObjectAssign: () => ObjectAssign,
+  ObjectCreate: () => ObjectCreate,
+  ObjectCtor: () => ObjectCtor,
+  ObjectDefineProperties: () => ObjectDefineProperties,
+  ObjectDefineProperty: () => ObjectDefineProperty,
+  ObjectEntries: () => ObjectEntries,
+  ObjectFreeze: () => ObjectFreeze,
+  ObjectFromEntries: () => ObjectFromEntries,
+  ObjectGetOwnPropertyDescriptor: () => ObjectGetOwnPropertyDescriptor,
+  ObjectGetOwnPropertyDescriptors: () => ObjectGetOwnPropertyDescriptors,
+  ObjectGetOwnPropertyNames: () => ObjectGetOwnPropertyNames,
+  ObjectGetOwnPropertySymbols: () => ObjectGetOwnPropertySymbols,
+  ObjectGetPrototypeOf: () => ObjectGetPrototypeOf,
+  ObjectHasOwn: () => ObjectHasOwn,
+  ObjectIs: () => ObjectIs,
+  ObjectIsExtensible: () => ObjectIsExtensible,
+  ObjectIsFrozen: () => ObjectIsFrozen,
+  ObjectIsSealed: () => ObjectIsSealed,
+  ObjectKeys: () => ObjectKeys,
+  ObjectPreventExtensions: () => ObjectPreventExtensions,
+  ObjectPrototype: () => ObjectPrototype,
+  ObjectPrototypeDefineGetter: () => ObjectPrototypeDefineGetter,
+  ObjectPrototypeDefineSetter: () => ObjectPrototypeDefineSetter,
+  ObjectPrototypeHasOwnProperty: () => ObjectPrototypeHasOwnProperty,
+  ObjectPrototypeIsPrototypeOf: () => ObjectPrototypeIsPrototypeOf,
+  ObjectPrototypeLookupGetter: () => ObjectPrototypeLookupGetter,
+  ObjectPrototypeLookupSetter: () => ObjectPrototypeLookupSetter,
+  ObjectPrototypePropertyIsEnumerable: () => ObjectPrototypePropertyIsEnumerable,
+  ObjectPrototypeToString: () => ObjectPrototypeToString,
+  ObjectPrototypeValueOf: () => ObjectPrototypeValueOf,
+  ObjectSeal: () => ObjectSeal,
+  ObjectSetPrototypeOf: () => ObjectSetPrototypeOf,
+  ObjectValues: () => ObjectValues
+});
+module.exports = __toCommonJS(object_exports);
+var import_uncurry = require("./uncurry");
+const ObjectCtor = Object;
+const ObjectAssign = Object.assign;
+const ObjectCreate = Object.create;
+const ObjectDefineProperties = Object.defineProperties;
+const ObjectDefineProperty = Object.defineProperty;
+const ObjectEntries = Object.entries;
+const ObjectFreeze = Object.freeze;
+const ObjectFromEntries = Object.fromEntries;
+const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const ObjectGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const ObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const ObjectGetPrototypeOf = Object.getPrototypeOf;
+const ObjectHasOwn = Object.hasOwn;
+const ObjectIs = Object.is;
+const ObjectIsExtensible = Object.isExtensible;
+const ObjectIsFrozen = Object.isFrozen;
+const ObjectIsSealed = Object.isSealed;
+const ObjectKeys = Object.keys;
+const ObjectPreventExtensions = Object.preventExtensions;
+const ObjectSeal = Object.seal;
+const ObjectSetPrototypeOf = Object.setPrototypeOf;
+const ObjectValues = Object.values;
+const ObjectPrototype = Object.prototype;
+const ObjectPrototypeHasOwnProperty = (0, import_uncurry.uncurryThis)(
+  Object.prototype.hasOwnProperty
+);
+const ObjectPrototypeIsPrototypeOf = (0, import_uncurry.uncurryThis)(
+  Object.prototype.isPrototypeOf
+);
+const ObjectPrototypePropertyIsEnumerable = (0, import_uncurry.uncurryThis)(
+  Object.prototype.propertyIsEnumerable
+);
+const ObjectPrototypeToString = (0, import_uncurry.uncurryThis)(Object.prototype.toString);
+const ObjectPrototypeValueOf = (0, import_uncurry.uncurryThis)(Object.prototype.valueOf);
+const _objectProto = Object.prototype;
+const ObjectPrototypeDefineGetter = (0, import_uncurry.uncurryThis)(
+  _objectProto.__defineGetter__
+);
+const ObjectPrototypeDefineSetter = (0, import_uncurry.uncurryThis)(
+  _objectProto.__defineSetter__
+);
+const ObjectPrototypeLookupGetter = (0, import_uncurry.uncurryThis)(
+  _objectProto.__lookupGetter__
+);
+const ObjectPrototypeLookupSetter = (0, import_uncurry.uncurryThis)(
+  _objectProto.__lookupSetter__
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObjectAssign,
+  ObjectCreate,
+  ObjectCtor,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectEntries,
+  ObjectFreeze,
+  ObjectFromEntries,
+  ObjectGetOwnPropertyDescriptor,
+  ObjectGetOwnPropertyDescriptors,
+  ObjectGetOwnPropertyNames,
+  ObjectGetOwnPropertySymbols,
+  ObjectGetPrototypeOf,
+  ObjectHasOwn,
+  ObjectIs,
+  ObjectIsExtensible,
+  ObjectIsFrozen,
+  ObjectIsSealed,
+  ObjectKeys,
+  ObjectPreventExtensions,
+  ObjectPrototype,
+  ObjectPrototypeDefineGetter,
+  ObjectPrototypeDefineSetter,
+  ObjectPrototypeHasOwnProperty,
+  ObjectPrototypeIsPrototypeOf,
+  ObjectPrototypeLookupGetter,
+  ObjectPrototypeLookupSetter,
+  ObjectPrototypePropertyIsEnumerable,
+  ObjectPrototypeToString,
+  ObjectPrototypeValueOf,
+  ObjectSeal,
+  ObjectSetPrototypeOf,
+  ObjectValues
+});

package/dist/primordials/promise.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @file Safe references to `Promise` static methods, prototype methods, and the
+ *   ES2024 `withResolvers` factory. Static methods are bound to `Promise` so
+ *   callers can pass them around as standalone functions (`PromiseAll(arr)`
+ *   instead of `Promise.all(arr)`); the `this`-receiver capture matches Node's
+ *   primordials convention.
+ */
+export declare const PromiseCtor: PromiseConstructor;
+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>;

package/dist/primordials/promise.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 promise_exports = {};
+__export(promise_exports, {
+  PromiseAll: () => PromiseAll,
+  PromiseAllSettled: () => PromiseAllSettled,
+  PromiseAny: () => PromiseAny,
+  PromiseCtor: () => PromiseCtor,
+  PromisePrototypeCatch: () => PromisePrototypeCatch,
+  PromisePrototypeFinally: () => PromisePrototypeFinally,
+  PromisePrototypeThen: () => PromisePrototypeThen,
+  PromiseRace: () => PromiseRace,
+  PromiseReject: () => PromiseReject,
+  PromiseResolve: () => PromiseResolve,
+  PromiseWithResolvers: () => PromiseWithResolvers
+});
+module.exports = __toCommonJS(promise_exports);
+var import_uncurry = require("./uncurry");
+const PromiseCtor = Promise;
+const PromiseAll = Promise.all.bind(Promise);
+const PromiseAllSettled = Promise.allSettled.bind(Promise);
+const PromiseAny = Promise.any.bind(Promise);
+const PromiseRace = Promise.race.bind(Promise);
+const PromiseReject = Promise.reject.bind(Promise);
+const PromiseResolve = Promise.resolve.bind(Promise);
+const PromiseWithResolvers = Promise.withResolvers?.bind(Promise);
+const PromisePrototypeCatch = (0, import_uncurry.uncurryThis)(Promise.prototype.catch);
+const PromisePrototypeFinally = (0, import_uncurry.uncurryThis)(Promise.prototype.finally);
+const PromisePrototypeThen = (0, import_uncurry.uncurryThis)(Promise.prototype.then);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromiseAll,
+  PromiseAllSettled,
+  PromiseAny,
+  PromiseCtor,
+  PromisePrototypeCatch,
+  PromisePrototypeFinally,
+  PromisePrototypeThen,
+  PromiseRace,
+  PromiseReject,
+  PromiseResolve,
+  PromiseWithResolvers
+});

package/dist/primordials/reflect.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file Safe references to `Reflect.*`. **IMPORTANT**: do not destructure on
+ *   `Reflect` here. tsgo has a bug that mis-transpiles destructured exports.
+ *   See: https://github.com/SocketDev/socket-packageurl-js/issues/3.
+ */
+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;

package/dist/primordials/reflect.js

@@ -0,0 +1,66 @@
+"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 reflect_exports = {};
+__export(reflect_exports, {
+  ReflectApply: () => ReflectApply,
+  ReflectConstruct: () => ReflectConstruct,
+  ReflectDefineProperty: () => ReflectDefineProperty,
+  ReflectDeleteProperty: () => ReflectDeleteProperty,
+  ReflectGet: () => ReflectGet,
+  ReflectGetOwnPropertyDescriptor: () => ReflectGetOwnPropertyDescriptor,
+  ReflectGetPrototypeOf: () => ReflectGetPrototypeOf,
+  ReflectHas: () => ReflectHas,
+  ReflectIsExtensible: () => ReflectIsExtensible,
+  ReflectOwnKeys: () => ReflectOwnKeys,
+  ReflectPreventExtensions: () => ReflectPreventExtensions,
+  ReflectSet: () => ReflectSet,
+  ReflectSetPrototypeOf: () => ReflectSetPrototypeOf
+});
+module.exports = __toCommonJS(reflect_exports);
+const ReflectApply = Reflect.apply;
+const ReflectConstruct = Reflect.construct;
+const ReflectDefineProperty = Reflect.defineProperty;
+const ReflectDeleteProperty = Reflect.deleteProperty;
+const ReflectGet = Reflect.get;
+const ReflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor;
+const ReflectGetPrototypeOf = Reflect.getPrototypeOf;
+const ReflectHas = Reflect.has;
+const ReflectIsExtensible = Reflect.isExtensible;
+const ReflectOwnKeys = Reflect.ownKeys;
+const ReflectPreventExtensions = Reflect.preventExtensions;
+const ReflectSet = Reflect.set;
+const ReflectSetPrototypeOf = Reflect.setPrototypeOf;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReflectApply,
+  ReflectConstruct,
+  ReflectDefineProperty,
+  ReflectDeleteProperty,
+  ReflectGet,
+  ReflectGetOwnPropertyDescriptor,
+  ReflectGetPrototypeOf,
+  ReflectHas,
+  ReflectIsExtensible,
+  ReflectOwnKeys,
+  ReflectPreventExtensions,
+  ReflectSet,
+  ReflectSetPrototypeOf
+});

package/dist/primordials/regexp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file Safe references to `RegExp` and its prototype methods. `RegExp.escape`
+ *   is ES2025; the primordial is typed `Function | undefined` so older runtimes
+ *   still load. The Symbol-keyed `[Symbol.match]` / `[Symbol.replace]` slots
+ *   are exposed alongside the named methods because some callers use them via
+ *   dynamic dispatch (e.g. `String.prototype.match` invokes
+ *   `RegExp.prototype[Symbol.match]` internally).
+ */
+export declare const RegExpCtor: RegExpConstructor;
+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;

package/dist/primordials/regexp.js

@@ -0,0 +1,50 @@
+"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 regexp_exports = {};
+__export(regexp_exports, {
+  RegExpCtor: () => RegExpCtor,
+  RegExpEscape: () => RegExpEscape,
+  RegExpPrototypeExec: () => RegExpPrototypeExec,
+  RegExpPrototypeSymbolMatch: () => RegExpPrototypeSymbolMatch,
+  RegExpPrototypeSymbolReplace: () => RegExpPrototypeSymbolReplace,
+  RegExpPrototypeTest: () => RegExpPrototypeTest
+});
+module.exports = __toCommonJS(regexp_exports);
+var import_uncurry = require("./uncurry");
+const RegExpCtor = RegExp;
+const RegExpEscape = RegExp.escape;
+const RegExpPrototypeExec = (0, import_uncurry.uncurryThis)(RegExp.prototype.exec);
+const RegExpPrototypeTest = (0, import_uncurry.uncurryThis)(RegExp.prototype.test);
+const RegExpPrototypeSymbolMatch = (0, import_uncurry.uncurryThis)(
+  RegExp.prototype[Symbol.match]
+);
+const RegExpPrototypeSymbolReplace = (0, import_uncurry.uncurryThis)(
+  RegExp.prototype[Symbol.replace]
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegExpCtor,
+  RegExpEscape,
+  RegExpPrototypeExec,
+  RegExpPrototypeSymbolMatch,
+  RegExpPrototypeSymbolReplace,
+  RegExpPrototypeTest
+});

package/dist/primordials/string.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @file Safe references to `String` static methods and prototype methods.
+ *   `StringPrototypeCharCodeAt` prefers the smol Fast API binding for ASCII
+ *   inputs (single byte load) and translates the `-1` Fast API sentinel back to
+ *   `NaN` to preserve spec parity. Two-byte strings fall back to the uncurried
+ *   `String.prototype.charCodeAt`.
+ *
+ *   ## Fast API surface — and why it's small
+ *
+ *   Mirrors the design rationale from socket-btm's `primordial_binding.cc`
+ *   (lines 41-72). The smol Fast API exposes exactly one string op
+ *   (`stringCharCodeAt`) because that's the one shape where the C++ trampoline
+ *   genuinely beats V8's existing hot path: a single ASCII byte load, no
+ *   encoding dispatch, no HandleScope, returns a primitive. String **searches**
+ *   (`startsWith` / `endsWith` / `includes` / `indexOf` / `lastIndexOf`) are
+ *   intentionally NOT exposed. V8's existing hot path dispatches on encoding
+ *   and runs native SIMD memcmp — a Fast API binding would add overhead without
+ *   winning. Same for `Map.has` / `Set.has` / `Array.includes`. Fast API also
+ *   has a hard constraint: a fast-path function cannot return a new V8 object —
+ *   only primitives, Local<Value/Object/Array>, or FastOneByteString. That
+ *   rules out anything that produces a new string (`slice`, `substring`,
+ *   `toUpperCase`, `concat`, `repeat`, `padStart`/`padEnd`, formatted-number)
+ *   from ever being a Fast API win on the return path. Net: the current surface
+ *   is approximately the ceiling. Adding more Fast API string ops without a
+ *   flamegraph showing the cost is a regression risk, not a perf win. See
+ *   `socket-btm/packages/node-smol-builder/additions/source-patched/`
+ *   `src/socketsecurity/primordial/primordial_binding.cc:41-72` for the
+ *   canonical design statement.
+ */
+export declare const StringCtor: StringConstructor;
+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: (s: string, i: 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 StringPrototypeIsWellFormed: (s: string) => boolean;
+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 | ((substring: string, ...args: any[]) => string)) => string;
+export declare const StringPrototypeReplaceAll: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => 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 StringPrototypeToString: (self: unknown) => string;
+export declare const StringPrototypeToUpperCase: (self: unknown) => string;
+export declare const StringPrototypeToWellFormed: (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 StringPrototypeValueOf: (self: unknown) => string;

package/dist/primordials/string.js

@@ -0,0 +1,174 @@
+"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 string_exports = {};
+__export(string_exports, {
+  StringCtor: () => StringCtor,
+  StringFromCharCode: () => StringFromCharCode,
+  StringFromCodePoint: () => StringFromCodePoint,
+  StringPrototypeAt: () => StringPrototypeAt,
+  StringPrototypeCharAt: () => StringPrototypeCharAt,
+  StringPrototypeCharCodeAt: () => StringPrototypeCharCodeAt,
+  StringPrototypeCodePointAt: () => StringPrototypeCodePointAt,
+  StringPrototypeConcat: () => StringPrototypeConcat,
+  StringPrototypeEndsWith: () => StringPrototypeEndsWith,
+  StringPrototypeIncludes: () => StringPrototypeIncludes,
+  StringPrototypeIndexOf: () => StringPrototypeIndexOf,
+  StringPrototypeIsWellFormed: () => StringPrototypeIsWellFormed,
+  StringPrototypeLastIndexOf: () => StringPrototypeLastIndexOf,
+  StringPrototypeLocaleCompare: () => StringPrototypeLocaleCompare,
+  StringPrototypeMatch: () => StringPrototypeMatch,
+  StringPrototypeMatchAll: () => StringPrototypeMatchAll,
+  StringPrototypeNormalize: () => StringPrototypeNormalize,
+  StringPrototypePadEnd: () => StringPrototypePadEnd,
+  StringPrototypePadStart: () => StringPrototypePadStart,
+  StringPrototypeRepeat: () => StringPrototypeRepeat,
+  StringPrototypeReplace: () => StringPrototypeReplace,
+  StringPrototypeReplaceAll: () => StringPrototypeReplaceAll,
+  StringPrototypeSearch: () => StringPrototypeSearch,
+  StringPrototypeSlice: () => StringPrototypeSlice,
+  StringPrototypeSplit: () => StringPrototypeSplit,
+  StringPrototypeStartsWith: () => StringPrototypeStartsWith,
+  StringPrototypeSubstring: () => StringPrototypeSubstring,
+  StringPrototypeToLocaleLowerCase: () => StringPrototypeToLocaleLowerCase,
+  StringPrototypeToLocaleUpperCase: () => StringPrototypeToLocaleUpperCase,
+  StringPrototypeToLowerCase: () => StringPrototypeToLowerCase,
+  StringPrototypeToString: () => StringPrototypeToString,
+  StringPrototypeToUpperCase: () => StringPrototypeToUpperCase,
+  StringPrototypeToWellFormed: () => StringPrototypeToWellFormed,
+  StringPrototypeTrim: () => StringPrototypeTrim,
+  StringPrototypeTrimEnd: () => StringPrototypeTrimEnd,
+  StringPrototypeTrimStart: () => StringPrototypeTrimStart,
+  StringPrototypeValueOf: () => StringPrototypeValueOf,
+  StringRaw: () => StringRaw
+});
+module.exports = __toCommonJS(string_exports);
+var import_primordial = require("../smol/primordial");
+var import_uncurry = require("./uncurry");
+const _smolPrimordial = (0, import_primordial.getSmolPrimordial)();
+const StringCtor = String;
+const StringFromCharCode = String.fromCharCode;
+const StringFromCodePoint = String.fromCodePoint;
+const StringRaw = String.raw;
+const StringPrototypeAt = (0, import_uncurry.uncurryThis)(String.prototype.at);
+const StringPrototypeCharAt = (0, import_uncurry.uncurryThis)(String.prototype.charAt);
+const _smolCharCodeAt = _smolPrimordial?.stringCharCodeAt;
+const StringPrototypeCharCodeAt = _smolCharCodeAt ? (s, i) => {
+  const code = _smolCharCodeAt(s, i);
+  return code === -1 ? NaN : code;
+} : (0, import_uncurry.uncurryThis)(String.prototype.charCodeAt);
+const StringPrototypeCodePointAt = (0, import_uncurry.uncurryThis)(
+  String.prototype.codePointAt
+);
+const StringPrototypeConcat = (0, import_uncurry.uncurryThis)(String.prototype.concat);
+const StringPrototypeEndsWith = (0, import_uncurry.uncurryThis)(String.prototype.endsWith);
+const StringPrototypeIncludes = (0, import_uncurry.uncurryThis)(String.prototype.includes);
+const StringPrototypeIndexOf = (0, import_uncurry.uncurryThis)(String.prototype.indexOf);
+const StringPrototypeIsWellFormed = _smolPrimordial?.stringIsWellFormed ?? (0, import_uncurry.uncurryThis)(String.prototype.isWellFormed);
+const StringPrototypeLastIndexOf = (0, import_uncurry.uncurryThis)(
+  String.prototype.lastIndexOf
+);
+const StringPrototypeLocaleCompare = (0, import_uncurry.uncurryThis)(
+  String.prototype.localeCompare
+);
+const StringPrototypeMatch = (0, import_uncurry.uncurryThis)(
+  String.prototype.match
+);
+const StringPrototypeMatchAll = (0, import_uncurry.uncurryThis)(
+  String.prototype.matchAll
+);
+const StringPrototypeNormalize = (0, import_uncurry.uncurryThis)(String.prototype.normalize);
+const StringPrototypePadEnd = (0, import_uncurry.uncurryThis)(String.prototype.padEnd);
+const StringPrototypePadStart = (0, import_uncurry.uncurryThis)(String.prototype.padStart);
+const StringPrototypeRepeat = (0, import_uncurry.uncurryThis)(String.prototype.repeat);
+const StringPrototypeReplace = (0, import_uncurry.uncurryThis)(
+  String.prototype.replace
+);
+const StringPrototypeReplaceAll = (0, import_uncurry.uncurryThis)(
+  String.prototype.replaceAll
+);
+const StringPrototypeSearch = (0, import_uncurry.uncurryThis)(String.prototype.search);
+const StringPrototypeSlice = (0, import_uncurry.uncurryThis)(String.prototype.slice);
+const StringPrototypeSplit = (0, import_uncurry.uncurryThis)(String.prototype.split);
+const StringPrototypeStartsWith = (0, import_uncurry.uncurryThis)(
+  String.prototype.startsWith
+);
+const StringPrototypeSubstring = (0, import_uncurry.uncurryThis)(String.prototype.substring);
+const StringPrototypeToLocaleLowerCase = (0, import_uncurry.uncurryThis)(
+  String.prototype.toLocaleLowerCase
+);
+const StringPrototypeToLocaleUpperCase = (0, import_uncurry.uncurryThis)(
+  String.prototype.toLocaleUpperCase
+);
+const StringPrototypeToLowerCase = (0, import_uncurry.uncurryThis)(
+  String.prototype.toLowerCase
+);
+const StringPrototypeToString = (0, import_uncurry.uncurryThis)(String.prototype.toString);
+const StringPrototypeToUpperCase = (0, import_uncurry.uncurryThis)(
+  String.prototype.toUpperCase
+);
+const StringPrototypeToWellFormed = (0, import_uncurry.uncurryThis)(
+  String.prototype.toWellFormed
+);
+const StringPrototypeTrim = (0, import_uncurry.uncurryThis)(String.prototype.trim);
+const StringPrototypeTrimEnd = (0, import_uncurry.uncurryThis)(String.prototype.trimEnd);
+const StringPrototypeTrimStart = (0, import_uncurry.uncurryThis)(String.prototype.trimStart);
+const StringPrototypeValueOf = (0, import_uncurry.uncurryThis)(String.prototype.valueOf);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StringCtor,
+  StringFromCharCode,
+  StringFromCodePoint,
+  StringPrototypeAt,
+  StringPrototypeCharAt,
+  StringPrototypeCharCodeAt,
+  StringPrototypeCodePointAt,
+  StringPrototypeConcat,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  StringPrototypeIndexOf,
+  StringPrototypeIsWellFormed,
+  StringPrototypeLastIndexOf,
+  StringPrototypeLocaleCompare,
+  StringPrototypeMatch,
+  StringPrototypeMatchAll,
+  StringPrototypeNormalize,
+  StringPrototypePadEnd,
+  StringPrototypePadStart,
+  StringPrototypeRepeat,
+  StringPrototypeReplace,
+  StringPrototypeReplaceAll,
+  StringPrototypeSearch,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  StringPrototypeSubstring,
+  StringPrototypeToLocaleLowerCase,
+  StringPrototypeToLocaleUpperCase,
+  StringPrototypeToLowerCase,
+  StringPrototypeToString,
+  StringPrototypeToUpperCase,
+  StringPrototypeToWellFormed,
+  StringPrototypeTrim,
+  StringPrototypeTrimEnd,
+  StringPrototypeTrimStart,
+  StringPrototypeValueOf,
+  StringRaw
+});

package/dist/primordials/symbol.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file Safe references to `Symbol`, well-known symbols, and
+ *   `Symbol.prototype`. `Symbol.asyncDispose` and `Symbol.dispose` are ES2024
+ *   (Node 20.4+); older engines lack them and the references resolve to
+ *   `undefined`. `SymbolPrototypeDescription` wraps the accessor since
+ *   `description` is a getter on `Symbol.prototype`, not a method.
+ */
+export declare const SymbolCtor: SymbolConstructor;
+export declare const SymbolAsyncDispose: typeof Symbol.asyncDispose | undefined;
+export declare const SymbolAsyncIterator: symbol;
+export declare const SymbolDispose: typeof Symbol.dispose | undefined;
+export declare const SymbolFor: (key: string) => symbol;
+export declare const SymbolHasInstance: symbol;
+export declare const SymbolIsConcatSpreadable: symbol;
+export declare const SymbolIterator: symbol;
+export declare const SymbolKeyFor: (sym: symbol) => string | undefined;
+export declare const SymbolMatch: symbol;
+export declare const SymbolMatchAll: symbol;
+export declare const SymbolReplace: symbol;
+export declare const SymbolSearch: symbol;
+export declare const SymbolSpecies: symbol;
+export declare const SymbolSplit: symbol;
+export declare const SymbolToPrimitive: symbol;
+export declare const SymbolToStringTag: symbol;
+export declare const SymbolUnscopables: symbol;
+export declare function SymbolPrototypeDescription(self: symbol): string | undefined;
+export declare const SymbolPrototypeToString: (self: unknown) => string;
+export declare const SymbolPrototypeValueOf: (self: symbol) => symbol;