@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/cacache/write.js

@@ -0,0 +1,53 @@
+"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 write_exports = {};
+__export(write_exports, {
+  put: () => put,
+  remove: () => remove
+});
+module.exports = __toCommonJS(write_exports);
+var import_socket = require("../paths/socket");
+var import_error = require("../primordials/error");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+async function put(key, data, options) {
+  if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+    throw new import_error.TypeErrorCtor(
+      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
+    );
+  }
+  const cacache = (0, import_internal.getCacache)();
+  return await cacache.put((0, import_socket.getSocketCacacheDir)(), key, data, options);
+}
+async function remove(key) {
+  if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+    throw new import_error.TypeErrorCtor(
+      'Cache key cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) to remove multiple entries.'
+    );
+  }
+  const cacache = (0, import_internal.getCacache)();
+  return await cacache.rm.entry((0, import_socket.getSocketCacacheDir)(), key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  put,
+  remove
+});

package/dist/checks/primordials.d.ts

@@ -0,0 +1,118 @@
+/**
+ * @file Primordials drift check — generic core. Each fleet repo that
+ *   destructures from Node's internal `primordials` global needs to keep its
+ *   usage shape-aligned with socket-lib's userland mirror
+ *   (`@socketsecurity/lib/primordials`). This module is the parser + diff
+ *   engine; per-repo policy (which dirs to scan, naming aliases, allowlist)
+ *   lives in a config the caller supplies. Used by the `socket-lib check
+ *   primordials` CLI subcommand. Kept importable as a library so repos with
+ *   bespoke needs can compose it directly without going through the CLI. The
+ *   flow:
+ *
+ *   1. Walk the configured `scanDirs` for `*.js` files.
+ *   2. From each file, extract names from every `const { Foo, Bar } = primordials`
+ *      destructure.
+ *   3. Read socket-lib's `primordials/` directory (sibling clone) or
+ *      `primordials/*.d.ts` (installed `node_modules`) and pull every exported
+ *      name across all leaves.
+ *   4. Diff: every destructured name must be either (a) in socket-lib verbatim,
+ *      (b) in socket-lib via the configured alias map, or (c) in the configured
+ *      node-internal-only allowlist. Findings come back classified so callers
+ *      can render or fail-CI on specific kinds.
+ */
+export interface PrimordialsCheckConfig {
+    /**
+     * Repo-relative directories to scan recursively for `*.js` files containing
+     * `primordials` destructures. Each entry is resolved against `repoRoot`.
+     */
+    readonly scanDirs: readonly string[];
+    /**
+     * Map from the source name a repo destructures (e.g. `Array`) to the
+     * socket-lib export name it should resolve to (e.g. `ArrayCtor`). socket-lib
+     * uses the `Ctor` suffix to avoid shadowing globals; repos that need the
+     * original name go through the alias.
+     */
+    readonly aliasMap: ReadonlyMap<string, string>;
+    /**
+     * Names that exist only in Node's internal `primordials` and are
+     * intentionally NOT mirrored to socket-lib. Adding to this set is a
+     * deliberate decision per name.
+     */
+    readonly nodeInternalOnly: ReadonlySet<string>;
+    /**
+     * Override the auto-resolution of socket-lib's primordials source. Useful for
+     * tests; production callers should leave this undefined so the resolver picks
+     * sibling clone → installed `node_modules`.
+     */
+    readonly socketLibPrimordialsPath?: string | undefined;
+    /**
+     * Repo root used to resolve `scanDirs` and to anchor the sibling-clone
+     * fallback (`<repoRoot>/../socket-lib/...`). Defaults to `process.cwd()`.
+     */
+    readonly repoRoot?: string | undefined;
+}
+export interface PrimordialsFinding {
+    readonly kind: 'unmapped' | 'missing-from-socket-lib';
+    readonly name: string;
+    readonly files: readonly string[];
+    readonly hint: string;
+}
+export interface PrimordialsCheckResult {
+    readonly used: ReadonlySet<string>;
+    readonly usedToFiles: ReadonlyMap<string, readonly string[]>;
+    readonly socketLibNames: ReadonlySet<string>;
+    readonly findings: readonly PrimordialsFinding[];
+}
+/**
+ * Run the primordials drift check against the configured repo. Returns the full
+ * result including raw inputs (used names, lib exports) so renderers can show
+ * context, plus a sorted list of findings classified by kind.
+ */
+export declare function checkPrimordials(config: PrimordialsCheckConfig): PrimordialsCheckResult;
+/**
+ * Recursively collect every `*.js` file under `dir`.
+ */
+export declare function collectJsFiles(dir: string): string[];
+/**
+ * Pull every `const { … } = primordials` destructure body out of `src`.
+ * Comments are stripped first so commentary inside a destructure doesn't leak
+ * into captured names. The body regex disallows nested `}`, which is safe after
+ * the comment-strip pass — destructures themselves don't contain `}`.
+ */
+export declare function extractPrimordialsNames(src: string): string[];
+/**
+ * Pull every `export const Foo` / `export function Foo` / `export { Foo }` from
+ * a TS file. Also matches `.d.ts` declaration forms (`export declare const
+ * Foo`, `export declare function Foo`) since the fallback path reads
+ * `primordials.d.ts` from `node_modules` when no sibling clone is present.
+ */
+export declare function extractTsExports(src: string): string[];
+/**
+ * Read TS exports from a resolved primordials path. Handles both the legacy
+ * single-file layout (returns one file's exports) and the post-split directory
+ * layout (concatenates exports across every `*.ts` / `*.d.ts` leaf).
+ */
+export declare function readSocketLibPrimordialNames(resolved: string): Set<string>;
+/**
+ * Locate socket-lib's primordials source. Search order:
+ *
+ * 1. `config.socketLibPrimordialsPath` if explicitly set. Accepts either a single
+ *    file (legacy `primordials.ts` / `.d.ts`) or a directory of leaves
+ *    (`primordials/`).
+ * 2. Sibling clone — `<repoRoot>/../socket-lib/src/primordials/` (post-split
+ *    layout) or `<repoRoot>/../socket-lib/src/primordials.ts` (legacy
+ *    single-file layout). Preferred for the dev-loop case where a developer is
+ *    editing socket-lib and a consumer in parallel.
+ * 3. Installed copy — `<repoRoot>/node_modules/@socketsecurity/lib/
+ *    dist/primordials/` (post-split) or `<repoRoot>/node_modules/
+ *    @socketsecurity/lib/dist/primordials.d.ts` (legacy). The CI fallback.
+ *
+ * Throws when none of the candidates exist.
+ */
+export declare function resolveSocketLibPrimordials(config: PrimordialsCheckConfig): string;
+/**
+ * Strip `/* … *‍/` block comments and `//` line comments. Comments inside
+ * primordials destructures would otherwise leak captured names; stripping first
+ * keeps the regex simple.
+ */
+export declare function stripComments(src: string): string;

package/dist/checks/primordials.js

@@ -0,0 +1,293 @@
+"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 primordials_exports = {};
+__export(primordials_exports, {
+  checkPrimordials: () => checkPrimordials,
+  collectJsFiles: () => collectJsFiles,
+  extractPrimordialsNames: () => extractPrimordialsNames,
+  extractTsExports: () => extractTsExports,
+  readSocketLibPrimordialNames: () => readSocketLibPrimordialNames,
+  resolveSocketLibPrimordials: () => resolveSocketLibPrimordials,
+  stripComments: () => stripComments
+});
+module.exports = __toCommonJS(primordials_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_join = require("../arrays/join");
+var import_error = require("../primordials/error");
+const NAME_HEAD_RE = /^([A-Za-z_$][A-Za-z0-9_$]*)/;
+function checkPrimordials(config) {
+  const repoRoot = config.repoRoot ?? process.cwd();
+  const used = /* @__PURE__ */ new Set();
+  const usedToFiles = /* @__PURE__ */ new Map();
+  for (const dir of config.scanDirs) {
+    const fullDir = import_node_path.default.resolve(repoRoot, dir);
+    const jsFiles = collectJsFiles(fullDir);
+    for (const file of jsFiles) {
+      let src;
+      try {
+        src = (0, import_node_fs.readFileSync)(file, "utf8");
+      } catch {
+        continue;
+      }
+      if (!src.includes("primordials")) {
+        continue;
+      }
+      const names = extractPrimordialsNames(src);
+      if (names.length === 0) {
+        continue;
+      }
+      const rel = import_node_path.default.relative(repoRoot, file);
+      for (const name of names) {
+        used.add(name);
+        const arr = usedToFiles.get(name) ?? [];
+        if (!arr.includes(rel)) {
+          arr.push(rel);
+        }
+        usedToFiles.set(name, arr);
+      }
+    }
+  }
+  const socketLibPath = resolveSocketLibPrimordials(config);
+  const socketLibNames = readSocketLibPrimordialNames(socketLibPath);
+  const findings = [];
+  for (const name of [...used].sort()) {
+    if (config.nodeInternalOnly.has(name)) {
+      continue;
+    }
+    if (socketLibNames.has(name)) {
+      continue;
+    }
+    const aliased = config.aliasMap.get(name);
+    if (aliased) {
+      if (socketLibNames.has(aliased)) {
+        continue;
+      }
+      findings.push({
+        kind: "missing-from-socket-lib",
+        name,
+        files: usedToFiles.get(name) ?? [],
+        hint: `\`${name}\` is mapped to socket-lib's \`${aliased}\`, but \`${aliased}\` is not exported. Add \`export const ${aliased} = ${name}\` to the appropriate leaf under socket-lib/src/primordials/.`
+      });
+      continue;
+    }
+    findings.push({
+      kind: "unmapped",
+      name,
+      files: usedToFiles.get(name) ?? [],
+      hint: `\`${name}\` is destructured from \`primordials\` but no socket-lib mapping exists. Pick one: ` + (0, import_join.joinOr)([
+        `add \`${name}\` to the appropriate leaf under socket-lib/src/primordials/`,
+        `add a \`${name}\` \u2192 \`<libName>\` entry to the alias map`,
+        `add \`${name}\` to nodeInternalOnly (if Node-internal only)`
+      ]) + "."
+    });
+  }
+  return {
+    used,
+    usedToFiles,
+    socketLibNames,
+    findings
+  };
+}
+function collectJsFiles(dir) {
+  const out = [];
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    return out;
+  }
+  const stack = [dir];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = (0, import_node_fs.readdirSync)(cur);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const full = import_node_path.default.join(cur, name);
+      let stat;
+      try {
+        stat = (0, import_node_fs.statSync)(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        stack.push(full);
+      } else if (stat.isFile() && full.endsWith(".js")) {
+        out.push(full);
+      }
+    }
+  }
+  return out;
+}
+function extractPrimordialsNames(src) {
+  const cleaned = stripComments(src);
+  const re = /const\s*\{\s*([^}]*?)\}\s*=\s*primordials\b/g;
+  const out = [];
+  let m;
+  while ((m = re.exec(cleaned)) !== null) {
+    for (const raw of m[1].split(",")) {
+      const trimmed = raw.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const nameMatch = NAME_HEAD_RE.exec(trimmed);
+      if (nameMatch) {
+        out.push(nameMatch[1]);
+      }
+    }
+  }
+  return out;
+}
+function extractTsExports(src) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of src.matchAll(
+    /^export\s+(?:declare\s+)?const\s+([A-Za-z_$][A-Za-z0-9_$]*)/gm
+  )) {
+    out.add(m[1]);
+  }
+  for (const m of src.matchAll(
+    /^export\s+(?:declare\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/gm
+  )) {
+    out.add(m[1]);
+  }
+  for (const m of src.matchAll(/^export\s*\{\s*([^}]+)\}/gm)) {
+    for (const raw of m[1].split(",")) {
+      const trimmed = raw.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const nameMatch = NAME_HEAD_RE.exec(trimmed);
+      if (nameMatch) {
+        out.add(nameMatch[1]);
+      }
+    }
+  }
+  return [...out];
+}
+function readSocketLibPrimordialNames(resolved) {
+  const stat = (0, import_node_fs.statSync)(resolved);
+  if (stat.isFile()) {
+    return new Set(extractTsExports((0, import_node_fs.readFileSync)(resolved, "utf8")));
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const name of (0, import_node_fs.readdirSync)(resolved)) {
+    if (!name.endsWith(".ts") && !name.endsWith(".d.ts")) {
+      continue;
+    }
+    const full = import_node_path.default.join(resolved, name);
+    const fileStat = (0, import_node_fs.statSync)(full);
+    if (!fileStat.isFile()) {
+      continue;
+    }
+    for (const exp of extractTsExports((0, import_node_fs.readFileSync)(full, "utf8"))) {
+      out.add(exp);
+    }
+  }
+  return out;
+}
+function resolveSocketLibPrimordials(config) {
+  if (config.socketLibPrimordialsPath) {
+    if (!(0, import_node_fs.existsSync)(config.socketLibPrimordialsPath)) {
+      throw new import_error.ErrorCtor(
+        `socketLibPrimordialsPath does not exist: ${config.socketLibPrimordialsPath}`
+      );
+    }
+    return config.socketLibPrimordialsPath;
+  }
+  const repoRoot = config.repoRoot ?? process.cwd();
+  const siblingDir = import_node_path.default.resolve(
+    repoRoot,
+    "..",
+    "socket-lib",
+    "src",
+    "primordials"
+  );
+  if ((0, import_node_fs.existsSync)(siblingDir)) {
+    return siblingDir;
+  }
+  const siblingLegacy = import_node_path.default.resolve(
+    repoRoot,
+    "..",
+    "socket-lib",
+    "src",
+    "primordials.ts"
+  );
+  if ((0, import_node_fs.existsSync)(siblingLegacy)) {
+    return siblingLegacy;
+  }
+  const installedDir = import_node_path.default.resolve(
+    repoRoot,
+    "node_modules",
+    "@socketsecurity",
+    "lib",
+    "dist",
+    "primordials"
+  );
+  if ((0, import_node_fs.existsSync)(installedDir)) {
+    return installedDir;
+  }
+  const installedLegacy = import_node_path.default.resolve(
+    repoRoot,
+    "node_modules",
+    "@socketsecurity",
+    "lib",
+    "dist",
+    "primordials.d.ts"
+  );
+  if ((0, import_node_fs.existsSync)(installedLegacy)) {
+    return installedLegacy;
+  }
+  throw new import_error.ErrorCtor(
+    `Cannot locate socket-lib primordials source. Looked at:
+  ${siblingDir}
+  ${siblingLegacy}
+  ${installedDir}
+  ${installedLegacy}
+Either clone socket-lib at ../socket-lib or run \`pnpm install\`.`
+  );
+}
+function stripComments(src) {
+  let out = src.replace(/\/\*[\s\S]*?\*\//g, "");
+  out = out.replace(/^[\t ]*\/\/.*$/gm, "");
+  out = out.replace(/[\t ]+\/\/.*$/gm, "");
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkPrimordials,
+  collectJsFiles,
+  extractPrimordialsNames,
+  extractTsExports,
+  readSocketLibPrimordialNames,
+  resolveSocketLibPrimordials,
+  stripComments
+});

package/dist/colors/convert.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file Color conversion helpers — `isRgbTuple()` narrows a `ColorValue` to the
+ *   RGB-tuple branch, and `toRgb()` resolves a named color or passes through an
+ *   existing tuple.
+ */
+import type { ColorRgb, ColorValue } from './types';
+/**
+ * Type guard to check if a color value is an RGB tuple.
+ *
+ * @example
+ *   ;```typescript
+ *   isRgbTuple([255, 0, 0]) // true
+ *   isRgbTuple('red') // false
+ *   ```
+ *
+ * @param value - Color value to check.
+ *
+ * @returns `true` if value is an RGB tuple, `false` if it's a color name
+ */
+export declare function isRgbTuple(value: ColorValue): value is ColorRgb;
+/**
+ * Convert a color value to RGB tuple format. Named colors are looked up in the
+ * `colorToRgb` map, RGB tuples are returned as-is.
+ *
+ * @example
+ *   ;```typescript
+ *   toRgb('red') // [255, 0, 0]
+ *   toRgb([0, 128, 0]) // [0, 128, 0]
+ *   ```
+ *
+ * @param color - Color name or RGB tuple.
+ *
+ * @returns RGB tuple with values 0-255
+ */
+export declare function toRgb(color: ColorValue): ColorRgb;

package/dist/colors/convert.js

@@ -0,0 +1,42 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var convert_exports = {};
+__export(convert_exports, {
+  isRgbTuple: () => isRgbTuple,
+  toRgb: () => toRgb
+});
+module.exports = __toCommonJS(convert_exports);
+var import_array = require("../primordials/array");
+var import_palette = require("./palette");
+function isRgbTuple(value) {
+  return (0, import_array.ArrayIsArray)(value);
+}
+function toRgb(color) {
+  if (isRgbTuple(color)) {
+    return color;
+  }
+  return import_palette.colorToRgb[color];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRgbTuple,
+  toRgb
+});

package/dist/colors/palette.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Named-color palette — maps each `ColorName` to its canonical RGB tuple.
+ *   Consumed by `colors/convert` and surfaced to downstream renderers (shimmer,
+ *   gradient, pulse) that need numeric channel values for color blending.
+ */
+import type { ColorName, ColorRgb } from './types';
+export declare const colorToRgb: Record<ColorName, ColorRgb>;

package/dist/{colors.js → colors/palette.js}

@@ -18,13 +18,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var colors_exports = {};
-__export(colors_exports, {
-  isRgbTuple: () => isRgbTuple,
-  toRgb: () => toRgb
+var palette_exports = {};
+__export(palette_exports, {
+  colorToRgb: () => colorToRgb
 });
-module.exports = __toCommonJS(colors_exports);
-var import_primordials = require("./primordials");
+module.exports = __toCommonJS(palette_exports);
 const colorToRgb = {
   __proto__: null,
   black: [0, 0, 0],
@@ -44,17 +42,7 @@ const colorToRgb = {
   yellow: [255, 255, 0],
   yellowBright: [255, 255, 153]
 };
-function isRgbTuple(value) {
-  return (0, import_primordials.ArrayIsArray)(value);
-}
-function toRgb(color) {
-  if (isRgbTuple(color)) {
-    return color;
-  }
-  return colorToRgb[color];
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isRgbTuple,
-  toRgb
+  colorToRgb
 });

package/dist/colors/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Public type surface for `colors/*` modules — the `ColorInherit`
+ *   literal, the `ColorName` named-color union, the `ColorRgb` tuple, and the
+ *   `ColorValue` super-union. Pure types, no runtime side effects.
+ */
+/**
+ * Special 'inherit' color value that uses the current color context. Used with
+ * effects like shimmer to dynamically inherit color.
+ */
+export type ColorInherit = 'inherit';
+/**
+ * Named color values supported by the library. Maps to standard terminal colors
+ * with bright variants.
+ */
+export type ColorName = 'black' | 'blue' | 'blueBright' | 'cyan' | 'cyanBright' | 'gray' | 'green' | 'greenBright' | 'magenta' | 'magentaBright' | 'red' | 'redBright' | 'white' | 'whiteBright' | 'yellow' | 'yellowBright';
+/**
+ * RGB color tuple with values 0-255 for red, green, and blue channels.
+ *
+ * @example
+ *   ;[140, 82, 255] // Socket purple
+ *
+ * @example
+ *   ;[255, 0, 0] // Red
+ */
+export type ColorRgb = readonly [number, number, number];
+/**
+ * Union of all supported color types: named colors or RGB tuples.
+ */
+export type ColorValue = ColorName | ColorRgb;

package/dist/colors/types.js

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

package/dist/compression/_internal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Private internals for `compression/*` modules — `resolveFileArgs`
+ *   disambiguates the `(src, dest, options?)` vs `(src, options)` calling
+ *   shape, and `stripExt` removes a trailing extension when it matches one of a
+ *   caller-supplied set. Both are shared by the brotli and gzip leaves and have
+ *   no callers outside this directory.
+ */
+import type { CompressFileOptions, CompressOptions } from './types';
+/**
+ * Strip the trailing extension from a filename when it matches one of `exts`.
+ * Returns the input unchanged when the trailing extname isn't in the set.
+ * Case-insensitive on the extension — preserves the rest of the path's casing.
+ *
+ * The `exts` set decides what counts. Pass `BROTLI_EXTS` / `GZIP_EXTS` for the
+ * canonical compression sets, or your own set for custom classifiers.
+ *
+ * Generic — it does NOT know that `.tgz` is short for `.tar.gz`. Callers that
+ * need that convention compose this with their own follow-up (see
+ * `decompressGzipFile` for the canonical example).
+ */
+export declare function stripExt(filePath: string, exts: ReadonlySet<string>): string;
+export interface ResolvedFileArgs {
+    destPath: string;
+    options: CompressOptions | undefined;
+    inPlace: boolean;
+}
+/**
+ * Disambiguate the `(src, dest, options?)` and `(src, options)` call shapes.
+ * Returns the resolved destPath, options, and inPlace flag. Validates that the
+ * explicit destPath is not the same as srcPath, since same-path streams would
+ * deadlock on read.
+ */
+export declare function resolveFileArgs(fnName: string, srcPath: string, destOrOptions: string | CompressFileOptions | undefined, maybeOptions: CompressOptions | undefined, computeInPlaceDest: (src: string) => string): ResolvedFileArgs;