@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/integrity.js

@@ -1,120 +1,119 @@
 "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 integrity_exports = {};
-__export(integrity_exports, {
-  DlxHashMismatchError: () => DlxHashMismatchError,
-  computeHashes: () => computeHashes,
-  isChecksumString: () => isChecksumString,
-  isIntegrityString: () => isIntegrityString,
-  normalizeHash: () => normalizeHash,
-  verifyHash: () => verifyHash
-});
-module.exports = __toCommonJS(integrity_exports);
-var import_node_crypto = require("node:crypto");
-var import_hash = require("./crypto/hash");
-var import_buffer = require("./primordials/buffer");
-var import_error = require("./primordials/error");
-var import_string = require("./primordials/string");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_crypto_hash = require('./crypto/hash.js');
+const require_primordials_buffer = require('./primordials/buffer.js');
+const require_primordials_error = require('./primordials/error.js');
+const require_primordials_string = require('./primordials/string.js');
+let node_crypto = require("node:crypto");
+
+//#region src/integrity.ts
+/**
+* @file Integrity specification helpers for downloads and file verification.
+*   Used by `dlx/binary-download` and external-tools resolvers; safe to consume
+*   from any module that needs to verify bytes against an expected hash. Single
+*   supported format per flavor:
+*
+*   - integrity: SRI with sha512 only (what npm registry returns)
+*   - checksum: sha256 hex (what `shasum -a 256` produces; common for binary
+*     release assets on GitHub) Callers may pass a {@link HashSpec} as a bare
+*     string (sniffed via format) or as an explicit `{ type, value }` object.
+*     The normalized form carried around internally is always the object.
+*/
 const INTEGRITY_PREFIX = "sha512-";
 const INTEGRITY_BODY_RE = /^[A-Za-z0-9+/=]+$/;
 const CHECKSUM_RE = /^[a-f0-9]{64}$/i;
+/**
+* Compute both integrity (sha512 SRI) and checksum (sha256 hex) for a buffer of
+* bytes.
+*/
 function computeHashes(bytes) {
-  const integrity = `sha512-${(0, import_hash.hash)("sha512", bytes, "base64")}`;
-  const checksum = (0, import_hash.hash)("sha256", bytes, "hex");
-  return { integrity, checksum };
+	return {
+		integrity: `sha512-${/* @__PURE__ */ require_crypto_hash.hash("sha512", bytes, "base64")}`,
+		checksum: /* @__PURE__ */ require_crypto_hash.hash("sha256", bytes, "hex")
+	};
 }
 function isChecksumString(s) {
-  return CHECKSUM_RE.test(s);
+	return CHECKSUM_RE.test(s);
 }
 function isIntegrityString(s) {
-  if (!(0, import_string.StringPrototypeStartsWith)(s, INTEGRITY_PREFIX)) {
-    return false;
-  }
-  const body = (0, import_string.StringPrototypeSlice)(s, INTEGRITY_PREFIX.length);
-  return body.length > 0 && INTEGRITY_BODY_RE.test(body);
+	if (!require_primordials_string.StringPrototypeStartsWith(s, INTEGRITY_PREFIX)) return false;
+	const body = require_primordials_string.StringPrototypeSlice(s, 7);
+	return body.length > 0 && INTEGRITY_BODY_RE.test(body);
 }
+/**
+* Normalize a {@link HashSpec} to its canonical `{ type, value }` form.
+*
+* - Object form is trusted (its `value` is validated for shape).
+* - Bare string matching sha512 SRI → integrity.
+* - Bare string of 64 hex chars → checksum.
+* - Anything else throws TypeError.
+*
+* @throws TypeError if the string is not a recognized format, or if an explicit
+*   object's value doesn't match its declared type.
+*/
 function normalizeHash(spec) {
-  if (typeof spec === "object" && spec !== null) {
-    if (spec.type === "integrity") {
-      if (!isIntegrityString(spec.value)) {
-        throw new import_error.TypeErrorCtor(
-          `Expected SRI integrity string "sha512-<base64>", got: ${spec.value}`
-        );
-      }
-      return { type: "integrity", value: spec.value };
-    }
-    if (spec.type === "checksum") {
-      if (!isChecksumString(spec.value)) {
-        throw new import_error.TypeErrorCtor(
-          `Expected sha256 hex string (64 hex chars), got: ${spec.value}`
-        );
-      }
-      return { type: "checksum", value: spec.value };
-    }
-    throw new import_error.TypeErrorCtor(
-      `Unknown hash type: ${spec.type}`
-    );
-  }
-  if (typeof spec !== "string") {
-    throw new import_error.TypeErrorCtor(
-      `HashSpec must be a string or { type, value } object, got: ${typeof spec}`
-    );
-  }
-  if (isIntegrityString(spec)) {
-    return { type: "integrity", value: spec };
-  }
-  if (isChecksumString(spec)) {
-    return { type: "checksum", value: spec };
-  }
-  throw new import_error.TypeErrorCtor(
-    `Unrecognized hash format. Expected SRI integrity ("sha512-<base64>") or sha256 hex (64 hex chars), got: ${spec}`
-  );
+	if (typeof spec === "object" && spec !== null) {
+		if (spec.type === "integrity") {
+			if (!isIntegrityString(spec.value)) throw new require_primordials_error.TypeErrorCtor(`Expected SRI integrity string "sha512-<base64>", got: ${spec.value}`);
+			return {
+				type: "integrity",
+				value: spec.value
+			};
+		}
+		if (spec.type === "checksum") {
+			if (!isChecksumString(spec.value)) throw new require_primordials_error.TypeErrorCtor(`Expected sha256 hex string (64 hex chars), got: ${spec.value}`);
+			return {
+				type: "checksum",
+				value: spec.value
+			};
+		}
+		throw new require_primordials_error.TypeErrorCtor(`Unknown hash type: ${spec.type}`);
+	}
+	if (typeof spec !== "string") throw new require_primordials_error.TypeErrorCtor(`HashSpec must be a string or { type, value } object, got: ${typeof spec}`);
+	if (isIntegrityString(spec)) return {
+		type: "integrity",
+		value: spec
+	};
+	if (isChecksumString(spec)) return {
+		type: "checksum",
+		value: spec
+	};
+	throw new require_primordials_error.TypeErrorCtor(`Unrecognized hash format. Expected SRI integrity ("sha512-<base64>") or sha256 hex (64 hex chars), got: ${spec}`);
 }
+/**
+* Verify computed hashes against an expected {@link NormalizedHash}. Uses
+* `crypto.timingSafeEqual` for constant-time comparison.
+*
+* @throws DlxHashMismatchError when the hash of the matching type doesn't match
+*   the expected value.
+*/
 function verifyHash(expected, computed) {
-  const actual = expected.type === "integrity" ? computed.integrity : computed.checksum;
-  const expectedBuf = (0, import_buffer.BufferFrom)(expected.value);
-  const actualBuf = (0, import_buffer.BufferFrom)(actual);
-  if (expectedBuf.length !== actualBuf.length || !(0, import_node_crypto.timingSafeEqual)(expectedBuf, actualBuf)) {
-    throw new DlxHashMismatchError(expected, computed);
-  }
+	const actual = expected.type === "integrity" ? computed.integrity : computed.checksum;
+	const expectedBuf = require_primordials_buffer.BufferFrom(expected.value);
+	const actualBuf = require_primordials_buffer.BufferFrom(actual);
+	if (expectedBuf.length !== actualBuf.length || !(0, node_crypto.timingSafeEqual)(expectedBuf, actualBuf)) throw new DlxHashMismatchError(expected, computed);
 }
-class DlxHashMismatchError extends Error {
-  expected;
-  actual;
-  constructor(expected, actual) {
-    const actualValue = expected.type === "integrity" ? actual.integrity : actual.checksum;
-    super(
-      `Hash mismatch (${expected.type}): expected ${expected.value}, got ${actualValue}`
-    );
-    this.name = "DlxHashMismatchError";
-    this.expected = expected;
-    this.actual = actual;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DlxHashMismatchError,
-  computeHashes,
-  isChecksumString,
-  isIntegrityString,
-  normalizeHash,
-  verifyHash
-});
+/**
+* Thrown when an expected hash doesn't match the computed hash of the
+* downloaded bytes. Carries both sides for diagnostics.
+*/
+var DlxHashMismatchError = class extends Error {
+	expected;
+	actual;
+	constructor(expected, actual) {
+		const actualValue = expected.type === "integrity" ? actual.integrity : actual.checksum;
+		super(`Hash mismatch (${expected.type}): expected ${expected.value}, got ${actualValue}`);
+		this.name = "DlxHashMismatchError";
+		this.expected = expected;
+		this.actual = actual;
+	}
+};
+
+//#endregion
+exports.DlxHashMismatchError = DlxHashMismatchError;
+exports.computeHashes = computeHashes;
+exports.isChecksumString = isChecksumString;
+exports.isIntegrityString = isIntegrityString;
+exports.normalizeHash = normalizeHash;
+exports.verifyHash = verifyHash;

package/dist/ipc/_internal.js

@@ -1,50 +1,36 @@
 "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 internal_exports = {};
-__export(internal_exports, {
-  IpcStubSchema: () => IpcStubSchema,
-  getFs: () => import_fs.getNodeFs,
-  getPath: () => import_path.getNodePath
-});
-module.exports = __toCommonJS(internal_exports);
-var import_typebox = require("../external/@sinclair/typebox");
-var import_fs = require("../node/fs");
-var import_path = require("../node/path");
-const IpcStubSchema = import_typebox.Type.Object({
-  /**
-   * Process ID that created the stub.
-   */
-  pid: import_typebox.Type.Integer({ minimum: 1 }),
-  /**
-   * Creation timestamp for age validation.
-   */
-  timestamp: import_typebox.Type.Number({ exclusiveMinimum: 0 }),
-  /**
-   * The actual data payload.
-   */
-  data: import_typebox.Type.Unknown()
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  IpcStubSchema,
-  getFs,
-  getPath
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_fs = require('../node/fs.js');
+const require_node_path = require('../node/path.js');
+let src_external__sinclair_typebox = require("../external/@sinclair/typebox");
+
+//#region src/ipc/_internal.ts
+/**
+* @file Private internals for `ipc/*` modules — lazy node:fs / node:path
+*   accessors, the IpcStub schema, and the shared platform check. Used by every
+*   public IPC entrypoint.
+*/
+/**
+* IPC stub file schema - validates the structure of stub files. Stub files are
+* used for passing data between processes via filesystem.
+*/
+const IpcStubSchema = src_external__sinclair_typebox.Type.Object({
+	/**
+	* Process ID that created the stub.
+	*/
+	pid: src_external__sinclair_typebox.Type.Integer({ minimum: 1 }),
+	/**
+	* Creation timestamp for age validation.
+	*/
+	timestamp: src_external__sinclair_typebox.Type.Number({ exclusiveMinimum: 0 }),
+	/**
+	* The actual data payload.
+	*/
+	data: src_external__sinclair_typebox.Type.Unknown()
 });
+
+//#endregion
+exports.IpcStubSchema = IpcStubSchema;
+exports.getFs = require_node_fs.getNodeFs;
+exports.getPath = require_node_path.getNodePath;

package/dist/ipc/directory.js

@@ -1,66 +1,58 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var directory_exports = {};
-__export(directory_exports, {
-  ensureIpcDirectory: () => ensureIpcDirectory
-});
-module.exports = __toCommonJS(directory_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_error = require("../primordials/error");
-var import_internal = require("./_internal");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_primordials_error = require('../primordials/error.js');
+const require_node_fs = require('../node/fs.js');
+const require_node_path = require('../node/path.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+
+//#region src/ipc/directory.ts
+/**
+* @file Stub-directory creation + permission audit. The IPC directory is
+*   created with 0o700 so other users can't read or plant files; on POSIX we
+*   also verify ownership and permission bits before any write, since a
+*   pre-existing directory could belong to a different user or have permissive
+*   modes inherited from umask.
+*/
+/**
+* Ensure IPC directory exists for stub file creation. Uses restrictive (0o700)
+* permissions so other users cannot read or write stub files. On POSIX, after
+* `mkdir` we verify the directory is owned by the current user and not
+* world/group-writable — protects against a prior local attacker pre-creating
+* `.socket-ipc/<app>/` with permissive modes and planting symlinks for stub
+* filenames. Throws if the directory fails the check.
+*
+* @internal
+*/
 async function ensureIpcDirectory(filePath) {
-  const fs = (0, import_internal.getFs)();
-  const path = (0, import_internal.getPath)();
-  const dir = path.dirname(filePath);
-  await fs.promises.mkdir(dir, { recursive: true, mode: 448 });
-  if (import_node_process.default.platform === "win32") {
-    return;
-  }
-  const stats = await fs.promises.lstat(dir);
-  if (!stats.isDirectory()) {
-    throw new import_error.ErrorCtor(`IPC path is not a directory: ${dir}`);
-  }
-  const getuid = import_node_process.default.getuid;
-  const ownUid = typeof getuid === "function" ? getuid.call(import_node_process.default) : -1;
-  if (ownUid !== -1 && stats.uid !== ownUid) {
-    throw new import_error.ErrorCtor(
-      `IPC directory ${dir} is owned by another user (uid ${stats.uid}); refusing to use it.`
-    );
-  }
-  const mode = stats.mode & 511;
-  if ((mode & 63) !== 0) {
-    await fs.promises.chmod(dir, 448);
-  }
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const dir = (/* @__PURE__ */ require_node_path.getNodePath()).dirname(filePath);
+	await fs.promises.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	/* c8 ignore start */
+	if (node_process.default.platform === "win32") return;
+	/* c8 ignore stop */
+	const stats = await fs.promises.lstat(dir);
+	/* c8 ignore start */
+	if (!stats.isDirectory()) throw new require_primordials_error.ErrorCtor(`IPC path is not a directory: ${dir}`);
+	/* c8 ignore stop */
+	const getuid = node_process.default.getuid;
+	/* c8 ignore next - process.getuid is always present on POSIX. */
+	const ownUid = typeof getuid === "function" ? getuid.call(node_process.default) : -1;
+	/* c8 ignore next 5 - Cross-user ownership guard fires only if the
+	IPC directory was created by a different uid; can't be triggered
+	in-test without spawning a separate user. */
+	if (ownUid !== -1 && stats.uid !== ownUid) throw new require_primordials_error.ErrorCtor(`IPC directory ${dir} is owned by another user (uid ${stats.uid}); refusing to use it.`);
+	/* c8 ignore next 7 - chmod-tightening fires only if umask leaves
+	group/other bits set; default Node umask 0o022 strips group-write
+	but keeps group/other read+execute, so the value depends on the
+	CI runner's umask. */
+	if ((stats.mode & 63) !== 0) await fs.promises.chmod(dir, 448);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ensureIpcDirectory
-});
+
+//#endregion
+exports.ensureIpcDirectory = ensureIpcDirectory;

package/dist/ipc/paths.js

@@ -1,48 +1,55 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var paths_exports = {};
-__export(paths_exports, {
-  getIpcStubPath: () => getIpcStubPath
-});
-module.exports = __toCommonJS(paths_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_socket = require("../paths/socket");
-var import_internal = require("./_internal");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_node_path = require('../node/path.js');
+const require_paths_socket = require('../paths/socket.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+
+//#region src/ipc/paths.ts
+/**
+* @file IPC stub path resolution. The on-disk layout is
+*   `<tmpDir>/.socket-ipc/<appName>/stub-<pid>.json`, computed here once so
+*   writers and readers agree on where stubs land.
+*/
+/**
+* Get the IPC stub path for a given application.
+*
+* Generates a unique file path for IPC stub files that are used to pass data
+* between processes. The stub files are stored in a hidden directory within the
+* system's temporary folder.
+*
+* ## Path Structure:
+*
+* - Base: System temp directory (e.g., /tmp on Unix, %TEMP% on Windows)
+* - Directory: `.socket-ipc/{appName}/`
+* - Filename: `stub-{pid}.json`
+*
+* ## Security Features:
+*
+* - Files are isolated per application via appName parameter
+* - Process ID in filename prevents collisions between concurrent processes
+* - Temporary directory location ensures automatic cleanup on system restart
+*
+* @example
+*   ;```typescript
+*   const stubPath = getIpcStubPath('socket-cli')
+*   // Returns: '/tmp/.socket-ipc/socket-cli/stub-12345.json' (Unix)
+*   // Returns: 'C:\\Users\\Name\\AppData\\Local\\Temp\\.socket-ipc\\socket-cli\\stub-12345.json' (Windows)
+*   ```
+*
+* @param appName - The application identifier (e.g., 'socket-cli',
+*   'socket-dlx')
+*
+* @returns Full path to the IPC stub file
+*/
 function getIpcStubPath(appName) {
-  const tempDir = (0, import_socket.getOsTmpDir)();
-  const path = (0, import_internal.getPath)();
-  const stubDir = path.join(tempDir, ".socket-ipc", appName);
-  return path.join(stubDir, `stub-${import_node_process.default.pid}.json`);
+	const tempDir = require_paths_socket.getOsTmpDir();
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const stubDir = path.join(tempDir, ".socket-ipc", appName);
+	return path.join(stubDir, `stub-${node_process.default.pid}.json`);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getIpcStubPath
-});
+
+//#endregion
+exports.getIpcStubPath = getIpcStubPath;

package/dist/ipc/types.js

@@ -1,18 +1,2 @@
 "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 __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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+/* Socket Lib - Built with rolldown */