@socketsecurity/lib 5.26.1 → 5.27.0

package/dist/node/http.js

@@ -0,0 +1,34 @@
+"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 http_exports = {};
+__export(http_exports, {
+  getNodeHttp: () => getNodeHttp
+});
+module.exports = __toCommonJS(http_exports);
+let _http;
+// @__NO_SIDE_EFFECTS__
+function getNodeHttp() {
+  return _http ??= require("node:http");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeHttp
+});

package/dist/node/https.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy-loader for `node:https`. See `node/fs.ts` for
+ * the design rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodeHttps from 'node:https';
+export declare function getNodeHttps(): typeof NodeHttps;

package/dist/node/https.js

@@ -0,0 +1,34 @@
+"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 https_exports = {};
+__export(https_exports, {
+  getNodeHttps: () => getNodeHttps
+});
+module.exports = __toCommonJS(https_exports);
+let _https;
+// @__NO_SIDE_EFFECTS__
+function getNodeHttps() {
+  return _https ??= require("node:https");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeHttps
+});

package/dist/node/os.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy-loader for `node:os`. See `node/fs.ts` for
+ * the design rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodeOs from 'node:os';
+export declare function getNodeOs(): typeof NodeOs;

package/dist/node/os.js

@@ -0,0 +1,34 @@
+"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 os_exports = {};
+__export(os_exports, {
+  getNodeOs: () => getNodeOs
+});
+module.exports = __toCommonJS(os_exports);
+let _os;
+// @__NO_SIDE_EFFECTS__
+function getNodeOs() {
+  return _os ??= require("node:os");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeOs
+});

package/dist/node/path.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy-loader for `node:path`. See `node/fs.ts` for the
+ * design rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodePath from 'node:path';
+export declare function getNodePath(): typeof NodePath;

package/dist/node/path.js

@@ -0,0 +1,34 @@
+"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 path_exports = {};
+__export(path_exports, {
+  getNodePath: () => getNodePath
+});
+module.exports = __toCommonJS(path_exports);
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getNodePath() {
+  return _path ??= require("node:path");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodePath
+});

package/dist/node/timers-promises.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy-loader for `node:timers/promises`. See `node/fs.ts`
+ * for the design rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodeTimersPromises from 'node:timers/promises';
+export declare function getNodeTimersPromises(): typeof NodeTimersPromises;

package/dist/node/timers-promises.js

@@ -0,0 +1,34 @@
+"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 timers_promises_exports = {};
+__export(timers_promises_exports, {
+  getNodeTimersPromises: () => getNodeTimersPromises
+});
+module.exports = __toCommonJS(timers_promises_exports);
+let _timersPromises;
+// @__NO_SIDE_EFFECTS__
+function getNodeTimersPromises() {
+  return _timersPromises ??= require("node:timers/promises");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeTimersPromises
+});

package/dist/node/url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy-loader for `node:url`. See `node/fs.ts` for
+ * the design rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodeUrl from 'node:url';
+export declare function getNodeUrl(): typeof NodeUrl;

package/dist/node/url.js

@@ -0,0 +1,34 @@
+"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 url_exports = {};
+__export(url_exports, {
+  getNodeUrl: () => getNodeUrl
+});
+module.exports = __toCommonJS(url_exports);
+let _url;
+// @__NO_SIDE_EFFECTS__
+function getNodeUrl() {
+  return _url ??= require("node:url");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeUrl
+});

package/dist/node/util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy-loader for `node:util`. See `node/fs.ts` for
+ * the design rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodeUtil from 'node:util';
+export declare function getNodeUtil(): typeof NodeUtil;

package/dist/node/util.js

@@ -0,0 +1,34 @@
+"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 util_exports = {};
+__export(util_exports, {
+  getNodeUtil: () => getNodeUtil
+});
+module.exports = __toCommonJS(util_exports);
+let _util;
+// @__NO_SIDE_EFFECTS__
+function getNodeUtil() {
+  return _util ??= require("node:util");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeUtil
+});

package/dist/primordials.d.ts

@@ -26,8 +26,13 @@
  */
 export declare const uncurryThis: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, ...args: A) => R;
 export declare const applyBind: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R;
+export declare const applySafe: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R | undefined;
+type BindCall = <T, P extends readonly unknown[], A extends readonly unknown[], R>(fn: (this: T, ...args: [...P, ...A]) => R, thisArg: T, ...presetArgs: P) => (...newArgs: A) => R;
+export declare const bindCall: BindCall;
+export declare const weakRefSafe: <T extends object | symbol>(target: T) => WeakRef<T> | undefined;
 export declare const ArrayCtor: ArrayConstructor;
 export declare const ArrayBufferCtor: ArrayBufferConstructor;
+export declare const BigIntCtor: BigIntConstructor;
 export declare const BooleanCtor: BooleanConstructor;
 export declare const BufferCtor: typeof globalThis.Buffer | undefined;
 export declare const DataViewCtor: DataViewConstructor;
@@ -64,6 +69,9 @@ export declare const URLSearchParamsCtor: typeof URLSearchParams;
 export declare const WeakMapCtor: WeakMapConstructor;
 export declare const WeakRefCtor: WeakRefConstructor;
 export declare const WeakSetCtor: WeakSetConstructor;
+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;
 export declare const JSONParse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
@@ -118,8 +126,10 @@ export declare const ArrayPrototypeSort: (self: unknown, compareFn?: ((a: any, b
 export declare const ArrayPrototypeSplice: <T>(self: T[], start: number, deleteCount?: number, ...items: T[]) => T[];
 export declare const ArrayPrototypeToReversed: (self: unknown) => any[];
 export declare const ArrayPrototypeToSorted: (self: unknown, compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+export declare const ArrayPrototypeToSpliced: <T>(self: T[], start: number, deleteCount?: number, ...items: T[]) => T[];
 export declare const ArrayPrototypeUnshift: <T>(self: T[], ...items: T[]) => number;
 export declare const ArrayPrototypeValues: (self: unknown) => ArrayIterator<any>;
+export declare const ArrayPrototypeWith: <T>(self: T[], index: number, value: T) => T[];
 export declare const BufferAlloc: typeof Buffer.alloc | undefined;
 export declare const BufferAllocUnsafe: typeof Buffer.allocUnsafe | undefined;
 export declare const BufferAllocUnsafeSlow: typeof Buffer.allocUnsafeSlow | undefined;
@@ -141,9 +151,13 @@ 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;
 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;
 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;
 export declare const IteratorPrototypeNext: (self: Iterator<unknown, any, any>) => IteratorResult<unknown, any>;
 export declare const IteratorPrototypeReturn: ((self: Iterator<unknown, any, any>, value?: unknown) => IteratorResult<unknown, any>) | undefined;
 export declare const MapPrototypeClear: (self: unknown) => void;
@@ -155,23 +169,63 @@ 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 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;
+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: (string: string, radix?: number) => number;
+export declare const NumberParseInt: typeof Number.parseInt;
 export declare const NumberPrototypeToFixed: (self: unknown, fractionDigits?: number | undefined) => string;
 export declare const NumberPrototypeToString: (self: unknown, radix?: number | undefined) => string;
 export declare const ObjectAssign: {
@@ -236,6 +290,10 @@ export declare const ObjectPrototypeIsPrototypeOf: (self: unknown, v: Object) =>
 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;
 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]>; }>;
@@ -295,7 +353,7 @@ export declare const StringRaw: (template: {
 }, ...substitutions: any[]) => string;
 export declare const StringPrototypeAt: (self: unknown, index: number) => string | undefined;
 export declare const StringPrototypeCharAt: (self: unknown, pos: number) => string;
-export declare const StringPrototypeCharCodeAt: (self: unknown, index: number) => number;
+export declare const 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;
@@ -325,11 +383,26 @@ export declare const StringPrototypeToUpperCase: (self: unknown) => string;
 export declare const StringPrototypeTrim: (self: unknown) => string;
 export declare const StringPrototypeTrimEnd: (self: unknown) => string;
 export declare const StringPrototypeTrimStart: (self: unknown) => string;
+export declare const 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;
 export declare const URLSearchParamsPrototypeAppend: (self: unknown, name: string, value: string) => void;
 export declare const URLSearchParamsPrototypeDelete: (self: unknown, name: string, value?: string | undefined) => void;
 export declare const URLSearchParamsPrototypeForEach: <TThis = import("url").URLSearchParams>(self: unknown, fn: (this: TThis, value: string, name: string, searchParams: import("url").URLSearchParams) => void, thisArg?: TThis | undefined) => void;
@@ -344,3 +417,4 @@ export declare const WeakMapPrototypeSet: (self: unknown, key: WeakKey, value: a
 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;
+export {};