@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/compression/brotli.js

@@ -1,147 +1,114 @@
 "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);
+/* 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_primordials_string = require('../primordials/string.js');
+const require_fs_safe = require('../fs/safe.js');
+const require_compression__internal = require('./_internal.js');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_util = require("node:util");
+let node_stream_promises = require("node:stream/promises");
+let node_zlib = require("node:zlib");
+let node_buffer = require("node:buffer");
+
+//#region src/compression/brotli.ts
+/**
+* @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)
+*/
+const brotliCompressAsync = (0, node_util.promisify)(node_zlib.brotliCompress);
+const brotliDecompressAsync = (0, node_util.promisify)(node_zlib.brotliDecompress);
+/**
+* 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.
+*/
 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 };
+	const level = options?.level ?? 11;
+	const params = { [node_zlib.constants.BROTLI_PARAM_QUALITY]: level };
+	if (options?.size !== void 0 && options.size > 0) params[node_zlib.constants.BROTLI_PARAM_SIZE_HINT] = options.size;
+	return { params };
 }
+/**
+* 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.
+*/
 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);
+	const buf = typeof input === "string" ? node_buffer.Buffer.from(input, "utf8") : input;
+	const opts = resolveBrotliOptions(options);
+	if (opts.params[node_zlib.constants.BROTLI_PARAM_SIZE_HINT] === void 0) opts.params[node_zlib.constants.BROTLI_PARAM_SIZE_HINT] = buf.byteLength;
+	return await brotliCompressAsync(buf, opts);
 }
+/**
+* Decompress a brotli-compressed Buffer.
+*/
 async function decompressBrotli(input) {
-  return await brotliDecompressAsync(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;
+	const { destPath, options, inPlace } = require_compression__internal.resolveFileArgs("compressBrotliFile", srcPath, destOrOptions, maybeOptions, (p) => `${p}.br`);
+	await (0, node_stream_promises.pipeline)((0, node_fs.createReadStream)(srcPath), (0, node_zlib.createBrotliCompress)(resolveBrotliOptions(options)), (0, node_fs.createWriteStream)(destPath));
+	if (inPlace) await require_fs_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;
+	const { destPath, inPlace } = require_compression__internal.resolveFileArgs("decompressBrotliFile", srcPath, destOrOptions, void 0, (p) => {
+		if (!hasBrotliExt(p)) throw new require_primordials_error.ErrorCtor(`decompressBrotliFile: ${p} has no .br/.brotli extension; can't infer destination`);
+		return require_compression__internal.stripExt(p, BROTLI_EXTS);
+	});
+	await (0, node_stream_promises.pipeline)((0, node_fs.createReadStream)(srcPath), (0, node_zlib.createBrotliDecompress)(), (0, node_fs.createWriteStream)(destPath));
+	if (inPlace) await require_fs_safe.safeDelete(srcPath);
+	return destPath;
 }
+/**
+* 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.
+*/
 function createBrotliCompressor(options) {
-  return (0, import_node_zlib.createBrotliCompress)(resolveBrotliOptions(options));
+	return (0, node_zlib.createBrotliCompress)(resolveBrotliOptions(options));
 }
+/**
+* Create a brotli decompress transform stream.
+*/
 function createBrotliDecompressor() {
-  return (0, import_node_zlib.createBrotliDecompress)();
+	return (0, node_zlib.createBrotliDecompress)();
 }
 const BROTLI_MIN_LEN = 4;
+/**
+* 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.
+*/
 function isBrotliCompressed(input) {
-  return import_node_buffer.Buffer.isBuffer(input) && input.byteLength >= BROTLI_MIN_LEN;
+	return node_buffer.Buffer.isBuffer(input) && input.byteLength >= BROTLI_MIN_LEN;
 }
-const BROTLI_EXTS = /* @__PURE__ */ new Set([".br", ".brotli"]);
+const BROTLI_EXTS = new Set([".br", ".brotli"]);
+/**
+* Extension check for brotli paths — matches `.br` / `.brotli`
+* (case-insensitive). Naming follows node:path's `extname`.
+*/
 function hasBrotliExt(filePath) {
-  return BROTLI_EXTS.has((0, import_string.StringPrototypeToLowerCase)(import_node_path.default.extname(filePath)));
+	return BROTLI_EXTS.has(require_primordials_string.StringPrototypeToLowerCase(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
-});
+
+//#endregion
+exports.BROTLI_EXTS = BROTLI_EXTS;
+exports.compressBrotli = compressBrotli;
+exports.compressBrotliFile = compressBrotliFile;
+exports.createBrotliCompressor = createBrotliCompressor;
+exports.createBrotliDecompressor = createBrotliDecompressor;
+exports.decompressBrotli = decompressBrotli;
+exports.decompressBrotliFile = decompressBrotliFile;
+exports.hasBrotliExt = hasBrotliExt;
+exports.isBrotliCompressed = isBrotliCompressed;
+exports.resolveBrotliOptions = resolveBrotliOptions;

package/dist/compression/gzip.js

@@ -1,142 +1,116 @@
 "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);
+/* 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_primordials_string = require('../primordials/string.js');
+const require_fs_safe = require('../fs/safe.js');
+const require_compression__internal = require('./_internal.js');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_util = require("node:util");
+let node_stream_promises = require("node:stream/promises");
+let node_zlib = require("node:zlib");
+let node_buffer = require("node:buffer");
+
+//#region src/compression/gzip.ts
+/**
+* @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)
+*/
+const gzipAsync = (0, node_util.promisify)(node_zlib.gzip);
+const gunzipAsync = (0, node_util.promisify)(node_zlib.gunzip);
+/**
+* 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.
+*/
 function resolveGzipOptions(options) {
-  const level = options?.level;
-  if (level === void 0) {
-    return { __proto__: null };
-  }
-  return { __proto__: null, level };
+	const level = options?.level;
+	if (level === void 0) return { __proto__: null };
+	return {
+		__proto__: null,
+		level
+	};
 }
+/**
+* Compress a string or Buffer with gzip. Strings are encoded as UTF-8 before
+* compression. Default level is 6 (zlib default).
+*/
 async function compressGzip(input, options) {
-  const buf = typeof input === "string" ? import_node_buffer.Buffer.from(input, "utf8") : input;
-  return await gzipAsync(buf, resolveGzipOptions(options));
+	return await gzipAsync(typeof input === "string" ? node_buffer.Buffer.from(input, "utf8") : input, resolveGzipOptions(options));
 }
+/**
+* Decompress a gzip-compressed Buffer.
+*/
 async function decompressGzip(input) {
-  return await gunzipAsync(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;
+	const { destPath, options, inPlace } = require_compression__internal.resolveFileArgs("compressGzipFile", srcPath, destOrOptions, maybeOptions, (p) => `${p}.gz`);
+	await (0, node_stream_promises.pipeline)((0, node_fs.createReadStream)(srcPath), (0, node_zlib.createGzip)(resolveGzipOptions(options)), (0, node_fs.createWriteStream)(destPath));
+	if (inPlace) await require_fs_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;
+	const { destPath, inPlace } = require_compression__internal.resolveFileArgs("decompressGzipFile", srcPath, destOrOptions, void 0, (p) => {
+		if (!hasGzipExt(p)) throw new require_primordials_error.ErrorCtor(`decompressGzipFile: ${p} has no .gz/.gzip/.tgz extension; can't infer destination`);
+		const stripped = require_compression__internal.stripExt(p, GZIP_EXTS);
+		return require_primordials_string.StringPrototypeToLowerCase(node_path.default.extname(p)) === ".tgz" ? `${stripped}.tar` : stripped;
+	});
+	await (0, node_stream_promises.pipeline)((0, node_fs.createReadStream)(srcPath), (0, node_zlib.createGunzip)(), (0, node_fs.createWriteStream)(destPath));
+	if (inPlace) await require_fs_safe.safeDelete(srcPath);
+	return destPath;
 }
+/**
+* Create a gzip compress transform stream.
+*/
 function createGzipCompressor(options) {
-  return (0, import_node_zlib.createGzip)(resolveGzipOptions(options));
+	return (0, node_zlib.createGzip)(resolveGzipOptions(options));
 }
+/**
+* Create a gzip decompress transform stream.
+*/
 function createGzipDecompressor() {
-  return (0, import_node_zlib.createGunzip)();
+	return (0, node_zlib.createGunzip)();
 }
 const GZIP_MAGIC_0 = 31;
 const GZIP_MAGIC_1 = 139;
+/**
+* Magic-byte check for gzip. Reads the first two bytes and matches the gzip
+* spec's 0x1f 0x8b signature. Authoritative.
+*/
 function isGzipCompressed(input) {
-  return import_node_buffer.Buffer.isBuffer(input) && input.byteLength >= 2 && input[0] === GZIP_MAGIC_0 && input[1] === GZIP_MAGIC_1;
+	return 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"]);
+const GZIP_EXTS = new Set([
+	".gz",
+	".gzip",
+	".tgz"
+]);
+/**
+* Extension check for gzip paths — matches `.gz` / `.gzip` / `.tgz`
+* (case-insensitive). Naming follows node:path's `extname`.
+*/
 function hasGzipExt(filePath) {
-  return GZIP_EXTS.has((0, import_string.StringPrototypeToLowerCase)(import_node_path.default.extname(filePath)));
+	return GZIP_EXTS.has(require_primordials_string.StringPrototypeToLowerCase(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
-});
+
+//#endregion
+exports.GZIP_EXTS = GZIP_EXTS;
+exports.compressGzip = compressGzip;
+exports.compressGzipFile = compressGzipFile;
+exports.createGzipCompressor = createGzipCompressor;
+exports.createGzipDecompressor = createGzipDecompressor;
+exports.decompressGzip = decompressGzip;
+exports.decompressGzipFile = decompressGzipFile;
+exports.hasGzipExt = hasGzipExt;
+exports.isGzipCompressed = isGzipCompressed;
+exports.resolveGzipOptions = resolveGzipOptions;

package/dist/compression/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 */