@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/compression/_internal.js

@@ -0,0 +1,77 @@
+"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 internal_exports = {};
+__export(internal_exports, {
+  resolveFileArgs: () => resolveFileArgs,
+  stripExt: () => stripExt
+});
+module.exports = __toCommonJS(internal_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_error = require("../primordials/error");
+var import_string = require("../primordials/string");
+function stripExt(filePath, exts) {
+  const ext = import_node_path.default.extname(filePath);
+  if (!exts.has((0, import_string.StringPrototypeToLowerCase)(ext))) {
+    return filePath;
+  }
+  return filePath.slice(0, -ext.length);
+}
+function resolveFileArgs(fnName, srcPath, destOrOptions, maybeOptions, computeInPlaceDest) {
+  if (typeof destOrOptions === "string") {
+    if (srcPath === destOrOptions) {
+      throw new import_error.ErrorCtor(
+        `${fnName}: srcPath and destPath must differ; got ${srcPath}`
+      );
+    }
+    return Object.freeze({
+      __proto__: null,
+      destPath: destOrOptions,
+      options: maybeOptions,
+      inPlace: false
+    });
+  }
+  if (destOrOptions?.inPlace) {
+    return Object.freeze({
+      __proto__: null,
+      destPath: computeInPlaceDest(srcPath),
+      options: destOrOptions,
+      inPlace: true
+    });
+  }
+  throw new import_error.ErrorCtor(
+    `${fnName}: missing destPath; pass an explicit destination or { inPlace: true }`
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveFileArgs,
+  stripExt
+});

package/dist/compression/brotli.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @file Brotli compression / decompression — in-memory, file-to-file, and
+ *   raw-stream variants. Default quality is 11 (max compression, slow) on the
+ *   assumption these are one-shot CLI calls. Override via `options.level` for
+ *   hot paths. await compressBrotli(JSON.stringify(payload)) await
+ *   compressBrotliFile('input.json', 'input.json.br')
+ *   readable.pipe(createBrotliCompressor()).pipe(writable)
+ */
+import { Buffer } from 'node:buffer';
+import { type BrotliOptions } from 'node:zlib';
+import type { CompressFileOptions, CompressOptions } from './types';
+interface ResolvedBrotliOptions extends BrotliOptions {
+    params: NonNullable<BrotliOptions['params']>;
+}
+/**
+ * Translate `CompressOptions` into the `BrotliOptions` zlib expects. Defaults
+ * `quality` to 11 (max) when not provided, and forwards a positive `size` hint.
+ * Exposed for callers building their own zlib pipelines and for unit-test
+ * coverage.
+ */
+export declare function resolveBrotliOptions(options: CompressOptions | undefined): ResolvedBrotliOptions;
+/**
+ * Compress a string or Buffer with brotli. Strings are encoded as UTF-8 before
+ * compression — pass an explicit Buffer if you have non-UTF-8 input.
+ */
+export declare function compressBrotli(input: string | Buffer, options?: CompressOptions | undefined): Promise<Buffer>;
+/**
+ * Decompress a brotli-compressed Buffer.
+ */
+export declare function decompressBrotli(input: Buffer): Promise<Buffer>;
+/**
+ * Stream-compress a file with brotli. Two call shapes:
+ *
+ * CompressBrotliFile(src, dest, options?) Writes compressed output to `dest`.
+ * Source is left intact.
+ *
+ * CompressBrotliFile(src, { inPlace: true, ...options }) Writes to `<src>.br`
+ * and deletes `src` after the write succeeds. Returns the new path.
+ *
+ * Returns the destination path in both shapes — same string the caller passed
+ * in or the computed `.br` path for inPlace.
+ */
+export declare function compressBrotliFile(srcPath: string, destPath: string, options?: CompressOptions | undefined): Promise<string>;
+export declare function compressBrotliFile(srcPath: string, options: CompressFileOptions): Promise<string>;
+/**
+ * Stream-decompress a brotli file. Two call shapes:
+ *
+ * DecompressBrotliFile(src, dest) Writes decompressed output to `dest`. Source
+ * is left intact.
+ *
+ * DecompressBrotliFile(src, { inPlace: true }) Strips the `.br`/`.brotli`
+ * suffix to derive the destination, then deletes the compressed source after
+ * the write succeeds. Throws if `src` has no recognizable extension.
+ *
+ * Returns the destination path in both shapes.
+ */
+export declare function decompressBrotliFile(srcPath: string, destPath: string): Promise<string>;
+export declare function decompressBrotliFile(srcPath: string, options: CompressFileOptions): Promise<string>;
+/**
+ * Create a brotli compress transform stream. Compose into your own pipeline.
+ * The `pipeline` from `node:stream/promises` is the safe way to wire it up — it
+ * handles error propagation across all stages.
+ */
+export declare function createBrotliCompressor(options?: CompressOptions | undefined): import("zlib").BrotliCompress;
+/**
+ * Create a brotli decompress transform stream.
+ */
+export declare function createBrotliDecompressor(): import("zlib").BrotliDecompress;
+/**
+ * Cheap pre-flight check: does the buffer look like it could be brotli? Returns
+ * false for inputs too short to be valid. Brotli has no fixed magic bytes, so
+ * this is intentionally permissive — the authoritative test is
+ * `decompressBrotli(buf)` succeeding. Use for UI hints, not correctness.
+ */
+export declare function isBrotliCompressed(input: Buffer): boolean;
+export declare const BROTLI_EXTS: ReadonlySet<string>;
+/**
+ * Extension check for brotli paths — matches `.br` / `.brotli`
+ * (case-insensitive). Naming follows node:path's `extname`.
+ */
+export declare function hasBrotliExt(filePath: string): boolean;
+export {};

package/dist/compression/brotli.js

@@ -0,0 +1,147 @@
+"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 brotli_exports = {};
+__export(brotli_exports, {
+  BROTLI_EXTS: () => BROTLI_EXTS,
+  compressBrotli: () => compressBrotli,
+  compressBrotliFile: () => compressBrotliFile,
+  createBrotliCompressor: () => createBrotliCompressor,
+  createBrotliDecompressor: () => createBrotliDecompressor,
+  decompressBrotli: () => decompressBrotli,
+  decompressBrotliFile: () => decompressBrotliFile,
+  hasBrotliExt: () => hasBrotliExt,
+  isBrotliCompressed: () => isBrotliCompressed,
+  resolveBrotliOptions: () => resolveBrotliOptions
+});
+module.exports = __toCommonJS(brotli_exports);
+var import_node_buffer = require("node:buffer");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_promises = require("node:stream/promises");
+var import_node_util = require("node:util");
+var import_node_zlib = require("node:zlib");
+var import_safe = require("../fs/safe");
+var import_error = require("../primordials/error");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+const brotliCompressAsync = (0, import_node_util.promisify)(import_node_zlib.brotliCompress);
+const brotliDecompressAsync = (0, import_node_util.promisify)(import_node_zlib.brotliDecompress);
+function resolveBrotliOptions(options) {
+  const level = options?.level ?? 11;
+  const params = {
+    [import_node_zlib.constants.BROTLI_PARAM_QUALITY]: level
+  };
+  if (options?.size !== void 0 && options.size > 0) {
+    params[import_node_zlib.constants.BROTLI_PARAM_SIZE_HINT] = options.size;
+  }
+  return { params };
+}
+async function compressBrotli(input, options) {
+  const buf = typeof input === "string" ? import_node_buffer.Buffer.from(input, "utf8") : input;
+  const opts = resolveBrotliOptions(options);
+  if (opts.params[import_node_zlib.constants.BROTLI_PARAM_SIZE_HINT] === void 0) {
+    opts.params[import_node_zlib.constants.BROTLI_PARAM_SIZE_HINT] = buf.byteLength;
+  }
+  return await brotliCompressAsync(buf, opts);
+}
+async function decompressBrotli(input) {
+  return await brotliDecompressAsync(input);
+}
+async function compressBrotliFile(srcPath, destOrOptions, maybeOptions) {
+  const { destPath, options, inPlace } = (0, import_internal.resolveFileArgs)(
+    "compressBrotliFile",
+    srcPath,
+    destOrOptions,
+    maybeOptions,
+    (p) => `${p}.br`
+  );
+  await (0, import_promises.pipeline)(
+    (0, import_node_fs.createReadStream)(srcPath),
+    (0, import_node_zlib.createBrotliCompress)(resolveBrotliOptions(options)),
+    (0, import_node_fs.createWriteStream)(destPath)
+  );
+  if (inPlace) {
+    await (0, import_safe.safeDelete)(srcPath);
+  }
+  return destPath;
+}
+async function decompressBrotliFile(srcPath, destOrOptions) {
+  const { destPath, inPlace } = (0, import_internal.resolveFileArgs)(
+    "decompressBrotliFile",
+    srcPath,
+    destOrOptions,
+    void 0,
+    (p) => {
+      if (!hasBrotliExt(p)) {
+        throw new import_error.ErrorCtor(
+          `decompressBrotliFile: ${p} has no .br/.brotli extension; can't infer destination`
+        );
+      }
+      return (0, import_internal.stripExt)(p, BROTLI_EXTS);
+    }
+  );
+  await (0, import_promises.pipeline)(
+    (0, import_node_fs.createReadStream)(srcPath),
+    (0, import_node_zlib.createBrotliDecompress)(),
+    (0, import_node_fs.createWriteStream)(destPath)
+  );
+  if (inPlace) {
+    await (0, import_safe.safeDelete)(srcPath);
+  }
+  return destPath;
+}
+function createBrotliCompressor(options) {
+  return (0, import_node_zlib.createBrotliCompress)(resolveBrotliOptions(options));
+}
+function createBrotliDecompressor() {
+  return (0, import_node_zlib.createBrotliDecompress)();
+}
+const BROTLI_MIN_LEN = 4;
+function isBrotliCompressed(input) {
+  return import_node_buffer.Buffer.isBuffer(input) && input.byteLength >= BROTLI_MIN_LEN;
+}
+const BROTLI_EXTS = /* @__PURE__ */ new Set([".br", ".brotli"]);
+function hasBrotliExt(filePath) {
+  return BROTLI_EXTS.has((0, import_string.StringPrototypeToLowerCase)(import_node_path.default.extname(filePath)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BROTLI_EXTS,
+  compressBrotli,
+  compressBrotliFile,
+  createBrotliCompressor,
+  createBrotliDecompressor,
+  decompressBrotli,
+  decompressBrotliFile,
+  hasBrotliExt,
+  isBrotliCompressed,
+  resolveBrotliOptions
+});

package/dist/compression/gzip.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @file Gzip compression / decompression — same calling shapes as brotli:
+ *   in-memory, file-to-file, and raw-stream variants. Default level is 6 (zlib
+ *   default). The decompress-file helper recognises `.gz` / `.gzip` / `.tgz`,
+ *   and special-cases `.tgz` back to `.tar` on inPlace decompress so a
+ *   round-trip stays lossless. await compressGzip(JSON.stringify(payload))
+ *   await compressGzipFile('input.json', 'input.json.gz')
+ *   readable.pipe(createGzipCompressor()).pipe(writable)
+ */
+import { Buffer } from 'node:buffer';
+import { type ZlibOptions } from 'node:zlib';
+import type { CompressFileOptions, CompressOptions } from './types';
+/**
+ * Translate `CompressOptions` into the `ZlibOptions` zlib expects. Returns an
+ * empty options object when no `level` is given (zlib uses its default, level
+ * 6). Exposed for parity with `resolveBrotliOptions` and for unit-test
+ * coverage.
+ */
+export declare function resolveGzipOptions(options: CompressOptions | undefined): ZlibOptions;
+/**
+ * Compress a string or Buffer with gzip. Strings are encoded as UTF-8 before
+ * compression. Default level is 6 (zlib default).
+ */
+export declare function compressGzip(input: string | Buffer, options?: CompressOptions | undefined): Promise<Buffer>;
+/**
+ * Decompress a gzip-compressed Buffer.
+ */
+export declare function decompressGzip(input: Buffer): Promise<Buffer>;
+/**
+ * Stream-compress a file with gzip. Two call shapes:
+ *
+ * CompressGzipFile(src, dest, options?) Writes compressed output to `dest`.
+ * Source is left intact.
+ *
+ * CompressGzipFile(src, { inPlace: true, ...options }) Writes to `<src>.gz` and
+ * deletes `src` after the write succeeds. Returns the new path.
+ */
+export declare function compressGzipFile(srcPath: string, destPath: string, options?: CompressOptions | undefined): Promise<string>;
+export declare function compressGzipFile(srcPath: string, options: CompressFileOptions): Promise<string>;
+/**
+ * Stream-decompress a gzip file. Two call shapes:
+ *
+ * DecompressGzipFile(src, dest) Writes decompressed output to `dest`. Source is
+ * left intact.
+ *
+ * DecompressGzipFile(src, { inPlace: true }) Strips the `.gz`/`.gzip`/`.tgz`
+ * suffix to derive the destination, then deletes the compressed source after
+ * the write succeeds. Throws if `src` has no recognizable extension.
+ */
+export declare function decompressGzipFile(srcPath: string, destPath: string): Promise<string>;
+export declare function decompressGzipFile(srcPath: string, options: CompressFileOptions): Promise<string>;
+/**
+ * Create a gzip compress transform stream.
+ */
+export declare function createGzipCompressor(options?: CompressOptions | undefined): import("zlib").Gzip;
+/**
+ * Create a gzip decompress transform stream.
+ */
+export declare function createGzipDecompressor(): import("zlib").Gunzip;
+/**
+ * Magic-byte check for gzip. Reads the first two bytes and matches the gzip
+ * spec's 0x1f 0x8b signature. Authoritative.
+ */
+export declare function isGzipCompressed(input: Buffer): boolean;
+export declare const GZIP_EXTS: ReadonlySet<string>;
+/**
+ * Extension check for gzip paths — matches `.gz` / `.gzip` / `.tgz`
+ * (case-insensitive). Naming follows node:path's `extname`.
+ */
+export declare function hasGzipExt(filePath: string): boolean;

package/dist/compression/gzip.js

@@ -0,0 +1,142 @@
+"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 gzip_exports = {};
+__export(gzip_exports, {
+  GZIP_EXTS: () => GZIP_EXTS,
+  compressGzip: () => compressGzip,
+  compressGzipFile: () => compressGzipFile,
+  createGzipCompressor: () => createGzipCompressor,
+  createGzipDecompressor: () => createGzipDecompressor,
+  decompressGzip: () => decompressGzip,
+  decompressGzipFile: () => decompressGzipFile,
+  hasGzipExt: () => hasGzipExt,
+  isGzipCompressed: () => isGzipCompressed,
+  resolveGzipOptions: () => resolveGzipOptions
+});
+module.exports = __toCommonJS(gzip_exports);
+var import_node_buffer = require("node:buffer");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_promises = require("node:stream/promises");
+var import_node_util = require("node:util");
+var import_node_zlib = require("node:zlib");
+var import_safe = require("../fs/safe");
+var import_error = require("../primordials/error");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+const gzipAsync = (0, import_node_util.promisify)(import_node_zlib.gzip);
+const gunzipAsync = (0, import_node_util.promisify)(import_node_zlib.gunzip);
+function resolveGzipOptions(options) {
+  const level = options?.level;
+  if (level === void 0) {
+    return { __proto__: null };
+  }
+  return { __proto__: null, level };
+}
+async function compressGzip(input, options) {
+  const buf = typeof input === "string" ? import_node_buffer.Buffer.from(input, "utf8") : input;
+  return await gzipAsync(buf, resolveGzipOptions(options));
+}
+async function decompressGzip(input) {
+  return await gunzipAsync(input);
+}
+async function compressGzipFile(srcPath, destOrOptions, maybeOptions) {
+  const { destPath, options, inPlace } = (0, import_internal.resolveFileArgs)(
+    "compressGzipFile",
+    srcPath,
+    destOrOptions,
+    maybeOptions,
+    (p) => `${p}.gz`
+  );
+  await (0, import_promises.pipeline)(
+    (0, import_node_fs.createReadStream)(srcPath),
+    (0, import_node_zlib.createGzip)(resolveGzipOptions(options)),
+    (0, import_node_fs.createWriteStream)(destPath)
+  );
+  if (inPlace) {
+    await (0, import_safe.safeDelete)(srcPath);
+  }
+  return destPath;
+}
+async function decompressGzipFile(srcPath, destOrOptions) {
+  const { destPath, inPlace } = (0, import_internal.resolveFileArgs)(
+    "decompressGzipFile",
+    srcPath,
+    destOrOptions,
+    void 0,
+    (p) => {
+      if (!hasGzipExt(p)) {
+        throw new import_error.ErrorCtor(
+          `decompressGzipFile: ${p} has no .gz/.gzip/.tgz extension; can't infer destination`
+        );
+      }
+      const stripped = (0, import_internal.stripExt)(p, GZIP_EXTS);
+      return (0, import_string.StringPrototypeToLowerCase)(import_node_path.default.extname(p)) === ".tgz" ? `${stripped}.tar` : stripped;
+    }
+  );
+  await (0, import_promises.pipeline)(
+    (0, import_node_fs.createReadStream)(srcPath),
+    (0, import_node_zlib.createGunzip)(),
+    (0, import_node_fs.createWriteStream)(destPath)
+  );
+  if (inPlace) {
+    await (0, import_safe.safeDelete)(srcPath);
+  }
+  return destPath;
+}
+function createGzipCompressor(options) {
+  return (0, import_node_zlib.createGzip)(resolveGzipOptions(options));
+}
+function createGzipDecompressor() {
+  return (0, import_node_zlib.createGunzip)();
+}
+const GZIP_MAGIC_0 = 31;
+const GZIP_MAGIC_1 = 139;
+function isGzipCompressed(input) {
+  return import_node_buffer.Buffer.isBuffer(input) && input.byteLength >= 2 && input[0] === GZIP_MAGIC_0 && input[1] === GZIP_MAGIC_1;
+}
+const GZIP_EXTS = /* @__PURE__ */ new Set([".gz", ".gzip", ".tgz"]);
+function hasGzipExt(filePath) {
+  return GZIP_EXTS.has((0, import_string.StringPrototypeToLowerCase)(import_node_path.default.extname(filePath)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GZIP_EXTS,
+  compressGzip,
+  compressGzipFile,
+  createGzipCompressor,
+  createGzipDecompressor,
+  decompressGzip,
+  decompressGzipFile,
+  hasGzipExt,
+  isGzipCompressed,
+  resolveGzipOptions
+});

package/dist/compression/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Public type surface for `compression/*` modules — the `CompressOptions`
+ *   accepted by every compression entrypoint and `CompressFileOptions` which
+ *   extends it with `inPlace`. Pure types, no runtime side effects.
+ */
+export interface CompressOptions {
+    /**
+     * Compression level. Brotli accepts 0–11 (11 = max, slowest). Gzip accepts
+     * 0–9 (9 = max). Defaults: brotli 11, gzip 6.
+     */
+    level?: number | undefined;
+    /**
+     * Hint for the input size in bytes. Lets brotli pick a better window/blocking
+     * strategy. Pass when known; ignored for gzip.
+     */
+    size?: number | undefined;
+}
+/**
+ * Options for the file-to-file helpers. Pass `{ inPlace: true }` to skip the
+ * explicit destPath argument: the helper picks the canonical destination (`.br`
+ * / `.gz` suffix on compress; suffix stripped on decompress) and removes the
+ * source file on success.
+ *
+ * Await compressBrotliFile('input.json', { inPlace: true }) // => writes
+ * input.json.br, deletes input.json.
+ *
+ * Await decompressBrotliFile('input.json.br', { inPlace: true }) // => writes
+ * input.json, deletes input.json.br.
+ */
+export interface CompressFileOptions extends CompressOptions {
+    /**
+     * Replace the source file: derive destPath from srcPath, then
+     * `safeDelete(srcPath)` after the write succeeds. When set, the `destPath`
+     * positional argument must be omitted.
+     */
+    inPlace?: boolean | undefined;
+}

package/dist/compression/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/constants/agents.d.ts

@@ -1,7 +1,7 @@
 /**
- * @fileoverview Package manager agent constants.
- * Exports agent names (npm/pnpm/yarn/bun/vlt/npx), lockfile names, registry
- * URLs, and resolved npm binary paths used across Socket tooling.
+ * @file Package manager agent constants. Exports agent names
+ *   (npm/pnpm/yarn/bun/vlt/npx), lockfile names, registry URLs, and resolved
+ *   npm binary paths used across Socket tooling.
  */
 export declare const NPM = "npm";
 export declare const PNPM = "pnpm";
@@ -14,6 +14,7 @@ export declare const NPM_REAL_EXEC_PATH: any;
 export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org";
 export declare const YARN_BERRY = "yarn/berry";
 export declare const YARN_CLASSIC = "yarn/classic";
+export declare const ZPM = "zpm";
 export declare const PACKAGE_LOCK = "package-lock";
 export declare const PACKAGE_LOCK_JSON = "package-lock.json";
 export declare const NPM_SHRINKWRAP_JSON = "npm-shrinkwrap.json";

package/dist/constants/agents.js

@@ -52,7 +52,8 @@ __export(agents_exports, {
   YARN: () => YARN,
   YARN_BERRY: () => YARN_BERRY,
   YARN_CLASSIC: () => YARN_CLASSIC,
-  YARN_LOCK: () => YARN_LOCK
+  YARN_LOCK: () => YARN_LOCK,
+  ZPM: () => ZPM
 });
 module.exports = __toCommonJS(agents_exports);
 var import_which = __toESM(require("../external/which"));
@@ -64,9 +65,9 @@ const VLT = "vlt";
 const NPX = "npx";
 const _npmBinPath = /* @__PURE__ */ (() => {
   try {
-    return import_which.default.sync("npm", { nothrow: true }) || null;
+    return import_which.default.sync("npm", { nothrow: true }) || void 0;
   } catch {
-    return null;
+    return void 0;
   }
 })();
 const NPM_BIN_PATH = _npmBinPath || "npm";
@@ -98,6 +99,7 @@ const NPM_REAL_EXEC_PATH = /* @__PURE__ */ (() => {
 const NPM_REGISTRY_URL = "https://registry.npmjs.org";
 const YARN_BERRY = "yarn/berry";
 const YARN_CLASSIC = "yarn/classic";
+const ZPM = "zpm";
 const PACKAGE_LOCK = "package-lock";
 const PACKAGE_LOCK_JSON = "package-lock.json";
 const NPM_SHRINKWRAP_JSON = "npm-shrinkwrap.json";
@@ -134,5 +136,6 @@ const RESOLUTIONS = "resolutions";
   YARN,
   YARN_BERRY,
   YARN_CLASSIC,
-  YARN_LOCK
+  YARN_LOCK,
+  ZPM
 });

package/dist/constants/encoding.d.ts

@@ -1,7 +1,7 @@
 /**
- * @fileoverview Character encoding and character code constants.
- * Exports the default UTF-8 encoding name and numeric char codes for common
- * ASCII characters used by path and parsing utilities.
+ * @file Character encoding and character code constants. Exports the default
+ *   UTF-8 encoding name and numeric char codes for common ASCII characters used
+ *   by path and parsing utilities.
  */
 export declare const UTF8 = "utf8";
 export declare const CHAR_BACKWARD_SLASH = 92;

package/dist/constants/github.d.ts

@@ -1,7 +1,6 @@
 /**
- * @fileoverview GitHub API and cache constants.
- * Provides the GitHub REST API base URL and the cache subdirectory name used
- * for persisting GitHub responses.
+ * @file GitHub API and cache constants. Provides the GitHub REST API base URL
+ *   and the cache subdirectory name used for persisting GitHub responses.
  */
 export declare const GITHUB_API_BASE_URL = "https://api.github.com";
 export declare const CACHE_GITHUB_DIR = "github";

package/dist/constants/licenses.d.ts

@@ -1,14 +1,14 @@
 /**
- * @fileoverview License identifier constants.
- * Exports common SPDX license strings (MIT, UNLICENSED) and a lazily-built
- * set of copy-left SPDX identifiers used when classifying package licenses.
+ * @file License identifier constants. Exports common SPDX license strings (MIT,
+ *   UNLICENSED) and a lazily-built set of copy-left SPDX identifiers used when
+ *   classifying package licenses.
  */
 export declare const MIT = "MIT";
 export declare const UNLICENCED = "UNLICENCED";
 export declare const UNLICENSED = "UNLICENSED";
 /**
- * Get the set of SPDX identifiers considered copy-left (AGPL, GPL, EPL,
- * EUPL, CC-BY-SA variants). The set is lazily built and cached on first call.
+ * Get the set of SPDX identifiers considered copy-left (AGPL, GPL, EPL, EUPL,
+ * CC-BY-SA variants). The set is lazily built and cached on first call.
  *
  * @returns A `Set` of SPDX license identifier strings.
  */