@socketsecurity/lib 5.26.1 → 5.28.0

package/dist/node/async-hooks.d.ts

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

package/dist/node/async-hooks.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 async_hooks_exports = {};
+__export(async_hooks_exports, {
+  getNodeAsyncHooks: () => getNodeAsyncHooks
+});
+module.exports = __toCommonJS(async_hooks_exports);
+let _asyncHooks;
+// @__NO_SIDE_EFFECTS__
+function getNodeAsyncHooks() {
+  return _asyncHooks ??= require("node:async_hooks");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeAsyncHooks
+});

package/dist/node/child-process.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Lazy-loader for `node:child_process`. See `node/fs.ts`
+ * for the design rationale shared across all `node/*.ts` lazy-loaders.
+ *
+ * Filename uses `child-process` (kebab-case) to match the rest of
+ * socket-lib's filename convention. The exported getter name is
+ * `getNodeChildProcess` (camelCase, prefixed with `Node` to match
+ * every other `node/*` lazy-loader).
+ */
+import type * as NodeChildProcess from 'node:child_process';
+export declare function getNodeChildProcess(): typeof NodeChildProcess;

package/dist/node/child-process.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 child_process_exports = {};
+__export(child_process_exports, {
+  getNodeChildProcess: () => getNodeChildProcess
+});
+module.exports = __toCommonJS(child_process_exports);
+let _childProcess;
+// @__NO_SIDE_EFFECTS__
+function getNodeChildProcess() {
+  return _childProcess ??= require("node:child_process");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeChildProcess
+});

package/dist/node/crypto.d.ts

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

package/dist/node/crypto.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 crypto_exports = {};
+__export(crypto_exports, {
+  getNodeCrypto: () => getNodeCrypto
+});
+module.exports = __toCommonJS(crypto_exports);
+let _crypto;
+// @__NO_SIDE_EFFECTS__
+function getNodeCrypto() {
+  return _crypto ??= require("node:crypto");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeCrypto
+});

package/dist/node/events.d.ts

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

package/dist/node/events.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 events_exports = {};
+__export(events_exports, {
+  getNodeEvents: () => getNodeEvents
+});
+module.exports = __toCommonJS(events_exports);
+let _events;
+// @__NO_SIDE_EFFECTS__
+function getNodeEvents() {
+  return _events ??= require("node:events");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeEvents
+});

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

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

package/dist/node/fs-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 fs_promises_exports = {};
+__export(fs_promises_exports, {
+  getNodeFsPromises: () => getNodeFsPromises
+});
+module.exports = __toCommonJS(fs_promises_exports);
+let _fsPromises;
+// @__NO_SIDE_EFFECTS__
+function getNodeFsPromises() {
+  return _fsPromises ??= require("node:fs/promises");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeFsPromises
+});

package/dist/node/fs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Lazy-loader for `node:fs`.
+ *
+ * Bundlers (Webpack/Rollup/esbuild) targeting browsers can't statically
+ * resolve `require('node:fs')` — but they CAN drop the call entirely
+ * if it's wrapped in a `/*@__NO_SIDE_EFFECTS__*\/`-marked function and
+ * never called. So we always go through `getFs()` instead of importing
+ * top-level.
+ *
+ * Cache slot is module-local: first call resolves the require, every
+ * subsequent call returns the cached reference.
+ */
+import type * as NodeFs from 'node:fs';
+export declare function getNodeFs(): typeof NodeFs;

package/dist/node/fs.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 fs_exports = {};
+__export(fs_exports, {
+  getNodeFs: () => getNodeFs
+});
+module.exports = __toCommonJS(fs_exports);
+let _fs;
+// @__NO_SIDE_EFFECTS__
+function getNodeFs() {
+  return _fs ??= require("node:fs");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeFs
+});

package/dist/node/http.d.ts

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

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
+});