@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/colors/socket-palette.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @file Socket terminal-color palette — mirrors the CSS design tokens defined
+ *   in the fleet's `template/styles/tokens.css` (light / dark / synthwave
+ *   themes). Each helper returns the input string wrapped in a 24-bit ANSI
+ *   escape sequence so the rendered hex matches the brand exactly; no rounding
+ *   to the legacy 8-color palette. Picocolors / yoctocolors only ship a fixed
+ *   8-color ANSI set, which would collapse `#8c50ff` to a generic "magenta".
+ *   This module sidesteps that by emitting `\x1b[38;2;R;G;Bm…\x1b[39m`
+ *   directly. Zero runtime dependencies. Usage: import { getPalette } from
+ *   '@socketsecurity/lib/colors/socket-palette' const palette =
+ *   getPalette('dark') console.log(palette.success('Done')) // Or read raw hex
+ *   values for callers building their own escape codes.
+ *   console.log(palette.hex.socketPurple) // "#8c50ff" Pick a theme by passing
+ *   `'light' | 'dark' | 'synthwave'`. Defaults to `'dark'` since terminals are
+ *   dark-on-light far less often than the opposite.
+ */
+/**
+ * Available palette themes — kept in sync with the CSS theme blocks in
+ * template/styles/tokens.css.
+ */
+export type SocketPaletteTheme = 'dark' | 'light' | 'synthwave';
+/**
+ * Hex-color value for each named slot. Exposed so callers can build their own
+ * ANSI escapes (e.g. for backgrounds, which this module doesn't wrap).
+ */
+export interface SocketPaletteHex {
+    alert: string;
+    error: string;
+    info: string;
+    socketPink: string;
+    socketPurple: string;
+    success: string;
+    warning: string;
+}
+/**
+ * Color-application helpers. Each takes a string and returns it wrapped in the
+ * matching 24-bit ANSI escape.
+ */
+export interface SocketPalette {
+    alert: (s: string) => string;
+    error: (s: string) => string;
+    hex: SocketPaletteHex;
+    info: (s: string) => string;
+    socketPink: (s: string) => string;
+    socketPurple: (s: string) => string;
+    success: (s: string) => string;
+    warning: (s: string) => string;
+}
+/**
+ * Build an ANSI-wrapping function for a single hex color. Emits the 24-bit
+ * sequence rather than rounding to the legacy 8-color palette so the rendered
+ * output matches the CSS token byte-for-byte (modulo terminal gamut).
+ * `\x1b[39m` resets fg to the terminal default — using `[0m` would also clear
+ * bg / styles, which the caller may have set deliberately.
+ */
+export declare function colorizer(hex: string): (s: string) => string;
+/**
+ * Resolve a Socket palette for the requested theme. Defaults to `'dark'` — the
+ * common case for terminal output.
+ *
+ * @example
+ *   ;```typescript
+ *   import { getPalette } from '@socketsecurity/lib/colors/socket-palette'
+ *
+ *   const palette = getPalette('dark')
+ *   process.stdout.write(palette.success('Build complete\n'))
+ *   ```
+ */
+export declare function getPalette(theme?: SocketPaletteTheme): SocketPalette;

package/dist/colors/socket-palette.js

@@ -0,0 +1,91 @@
+"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 socket_palette_exports = {};
+__export(socket_palette_exports, {
+  colorizer: () => colorizer,
+  getPalette: () => getPalette
+});
+module.exports = __toCommonJS(socket_palette_exports);
+const HEX_BY_THEME = {
+  __proto__: null,
+  // The dark theme is the default — bright values that pop on terminal
+  // backgrounds (which are overwhelmingly dark).
+  dark: {
+    __proto__: null,
+    alert: "#fb923c",
+    error: "#f87171",
+    info: "#60a5fa",
+    socketPink: "#ff00aa",
+    socketPurple: "#8c50ff",
+    success: "#4ade80",
+    warning: "#facc15"
+  },
+  // Saturated, deep values for light terminals (rare but supported).
+  light: {
+    __proto__: null,
+    alert: "#9a3412",
+    error: "#b91c1c",
+    info: "#1d4ed8",
+    socketPink: "#ff00aa",
+    socketPurple: "#8c50ff",
+    success: "#15803d",
+    warning: "#a16207"
+  },
+  // Neon palette for celebratory / hero output.
+  synthwave: {
+    __proto__: null,
+    alert: "#ffb86c",
+    error: "#ff6b9d",
+    info: "#8be9fd",
+    socketPink: "#ff00aa",
+    socketPurple: "#8c50ff",
+    success: "#50fa7b",
+    warning: "#f1fa8c"
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function colorizer(hex) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  const prefix = `\x1B[38;2;${r};${g};${b}m`;
+  const suffix = "\x1B[39m";
+  return (s) => `${prefix}${s}${suffix}`;
+}
+// @__NO_SIDE_EFFECTS__
+function getPalette(theme = "dark") {
+  const hex = HEX_BY_THEME[theme];
+  return {
+    alert: /* @__PURE__ */ colorizer(hex.alert),
+    error: /* @__PURE__ */ colorizer(hex.error),
+    hex,
+    info: /* @__PURE__ */ colorizer(hex.info),
+    socketPink: /* @__PURE__ */ colorizer(hex.socketPink),
+    socketPurple: /* @__PURE__ */ colorizer(hex.socketPurple),
+    success: /* @__PURE__ */ colorizer(hex.success),
+    warning: /* @__PURE__ */ colorizer(hex.warning)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  colorizer,
+  getPalette
+});

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;

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.js → compression/brotli.js}

@@ -28,43 +28,32 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var compression_exports = {};
-__export(compression_exports, {
+var brotli_exports = {};
+__export(brotli_exports, {
   BROTLI_EXTS: () => BROTLI_EXTS,
-  GZIP_EXTS: () => GZIP_EXTS,
   compressBrotli: () => compressBrotli,
   compressBrotliFile: () => compressBrotliFile,
-  compressGzip: () => compressGzip,
-  compressGzipFile: () => compressGzipFile,
   createBrotliCompressor: () => createBrotliCompressor,
   createBrotliDecompressor: () => createBrotliDecompressor,
-  createGzipCompressor: () => createGzipCompressor,
-  createGzipDecompressor: () => createGzipDecompressor,
   decompressBrotli: () => decompressBrotli,
   decompressBrotliFile: () => decompressBrotliFile,
-  decompressGzip: () => decompressGzip,
-  decompressGzipFile: () => decompressGzipFile,
   hasBrotliExt: () => hasBrotliExt,
-  hasGzipExt: () => hasGzipExt,
   isBrotliCompressed: () => isBrotliCompressed,
-  isGzipCompressed: () => isGzipCompressed,
-  resolveBrotliOptions: () => resolveBrotliOptions,
-  resolveGzipOptions: () => resolveGzipOptions,
-  stripExt: () => stripExt
+  resolveBrotliOptions: () => resolveBrotliOptions
 });
-module.exports = __toCommonJS(compression_exports);
+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_zlib = require("node:zlib");
 var import_node_util = require("node:util");
-var import_fs = require("./fs");
-var import_primordials = require("./primordials");
+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);
-const gzipAsync = (0, import_node_util.promisify)(import_node_zlib.gzip);
-const gunzipAsync = (0, import_node_util.promisify)(import_node_zlib.gunzip);
 function resolveBrotliOptions(options) {
   const level = options?.level ?? 11;
   const params = {
@@ -75,13 +64,6 @@ function resolveBrotliOptions(options) {
   }
   return { params };
 }
-function resolveGzipOptions(options) {
-  const level = options?.level;
-  if (level === void 0) {
-    return { __proto__: null };
-  }
-  return { __proto__: null, level };
-}
 async function compressBrotli(input, options) {
   const buf = typeof input === "string" ? import_node_buffer.Buffer.from(input, "utf8") : input;
   const opts = resolveBrotliOptions(options);
@@ -94,7 +76,7 @@ async function decompressBrotli(input) {
   return await brotliDecompressAsync(input);
 }
 async function compressBrotliFile(srcPath, destOrOptions, maybeOptions) {
-  const { destPath, options, inPlace } = resolveFileArgs(
+  const { destPath, options, inPlace } = (0, import_internal.resolveFileArgs)(
     "compressBrotliFile",
     srcPath,
     destOrOptions,
@@ -107,23 +89,23 @@ async function compressBrotliFile(srcPath, destOrOptions, maybeOptions) {
     (0, import_node_fs.createWriteStream)(destPath)
   );
   if (inPlace) {
-    await (0, import_fs.safeDelete)(srcPath);
+    await (0, import_safe.safeDelete)(srcPath);
   }
   return destPath;
 }
 async function decompressBrotliFile(srcPath, destOrOptions) {
-  const { destPath, inPlace } = resolveFileArgs(
+  const { destPath, inPlace } = (0, import_internal.resolveFileArgs)(
     "decompressBrotliFile",
     srcPath,
     destOrOptions,
     void 0,
     (p) => {
       if (!hasBrotliExt(p)) {
-        throw new Error(
+        throw new import_error.ErrorCtor(
           `decompressBrotliFile: ${p} has no .br/.brotli extension; can't infer destination`
         );
       }
-      return stripExt(p, BROTLI_EXTS);
+      return (0, import_internal.stripExt)(p, BROTLI_EXTS);
     }
   );
   await (0, import_promises.pipeline)(
@@ -132,7 +114,7 @@ async function decompressBrotliFile(srcPath, destOrOptions) {
     (0, import_node_fs.createWriteStream)(destPath)
   );
   if (inPlace) {
-    await (0, import_fs.safeDelete)(srcPath);
+    await (0, import_safe.safeDelete)(srcPath);
   }
   return destPath;
 }
@@ -142,134 +124,24 @@ function createBrotliCompressor(options) {
 function createBrotliDecompressor() {
   return (0, import_node_zlib.createBrotliDecompress)();
 }
-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 } = 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_fs.safeDelete)(srcPath);
-  }
-  return destPath;
-}
-async function decompressGzipFile(srcPath, destOrOptions) {
-  const { destPath, inPlace } = resolveFileArgs(
-    "decompressGzipFile",
-    srcPath,
-    destOrOptions,
-    void 0,
-    (p) => {
-      if (!hasGzipExt(p)) {
-        throw new Error(
-          `decompressGzipFile: ${p} has no .gz/.gzip/.tgz extension; can't infer destination`
-        );
-      }
-      const stripped = stripExt(p, GZIP_EXTS);
-      return (0, import_primordials.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_fs.safeDelete)(srcPath);
-  }
-  return destPath;
-}
-function createGzipCompressor(options) {
-  return (0, import_node_zlib.createGzip)(resolveGzipOptions(options));
-}
-function createGzipDecompressor() {
-  return (0, import_node_zlib.createGunzip)();
-}
 const BROTLI_MIN_LEN = 4;
 function isBrotliCompressed(input) {
   return import_node_buffer.Buffer.isBuffer(input) && input.byteLength >= BROTLI_MIN_LEN;
 }
-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 BROTLI_EXTS = /* @__PURE__ */ new Set([".br", ".brotli"]);
-const GZIP_EXTS = /* @__PURE__ */ new Set([".gz", ".gzip", ".tgz"]);
 function hasBrotliExt(filePath) {
-  return BROTLI_EXTS.has((0, import_primordials.StringPrototypeToLowerCase)(import_node_path.default.extname(filePath)));
-}
-function hasGzipExt(filePath) {
-  return GZIP_EXTS.has((0, import_primordials.StringPrototypeToLowerCase)(import_node_path.default.extname(filePath)));
-}
-function stripExt(filePath, exts) {
-  const ext = import_node_path.default.extname(filePath);
-  if (!exts.has((0, import_primordials.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 Error(
-        `${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 Error(
-    `${fnName}: missing destPath; pass an explicit destination or { inPlace: true }`
-  );
+  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,
-  GZIP_EXTS,
   compressBrotli,
   compressBrotliFile,
-  compressGzip,
-  compressGzipFile,
   createBrotliCompressor,
   createBrotliDecompressor,
-  createGzipCompressor,
-  createGzipDecompressor,
   decompressBrotli,
   decompressBrotliFile,
-  decompressGzip,
-  decompressGzipFile,
   hasBrotliExt,
-  hasGzipExt,
   isBrotliCompressed,
-  isGzipCompressed,
-  resolveBrotliOptions,
-  resolveGzipOptions,
-  stripExt
+  resolveBrotliOptions
 });