@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/external-tools/uv/asset-names.js

@@ -0,0 +1,80 @@
+"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 asset_names_exports = {};
+__export(asset_names_exports, {
+  UV_ASSET_MAP: () => UV_ASSET_MAP,
+  getUvAssetEntry: () => getUvAssetEntry,
+  getUvDownloadUrl: () => getUvDownloadUrl
+});
+module.exports = __toCommonJS(asset_names_exports);
+var import_object = require("../../primordials/object");
+const UV_ASSET_MAP = (0, import_object.ObjectFreeze)({
+  __proto__: null,
+  "darwin-arm64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-aarch64-apple-darwin.tar.gz"
+  }),
+  "darwin-x64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-x86_64-apple-darwin.tar.gz"
+  }),
+  "linux-arm64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-aarch64-unknown-linux-gnu.tar.gz"
+  }),
+  "linux-arm64-musl": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-aarch64-unknown-linux-musl.tar.gz"
+  }),
+  "linux-x64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-x86_64-unknown-linux-gnu.tar.gz"
+  }),
+  "linux-x64-musl": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-x86_64-unknown-linux-musl.tar.gz"
+  }),
+  "win-arm64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-aarch64-pc-windows-msvc.zip"
+  }),
+  "win-x64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "uv-x86_64-pc-windows-msvc.zip"
+  })
+});
+function getUvAssetEntry(platformArch) {
+  return UV_ASSET_MAP[platformArch];
+}
+function getUvDownloadUrl(opts) {
+  const { platformArch, version } = opts;
+  const entry = UV_ASSET_MAP[platformArch];
+  if (!entry) {
+    return void 0;
+  }
+  return `https://github.com/astral-sh/uv/releases/download/${version}/` + entry.asset;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UV_ASSET_MAP,
+  getUvAssetEntry,
+  getUvDownloadUrl
+});

package/dist/external-tools/uv/from-download.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file `uvFromDownload()` — fetches upstream uv and returns a `ResolvedUv`
+ *   pointing at the extracted binary. uv tarballs wrap the binary in a
+ *   `<asset-stem>/` directory; the extractor strips that level so the binary
+ *   sits at the cache-dir root.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedUv } from './types';
+export interface UvFromDownloadOptions {
+    version: string;
+    platformArch: string;
+    integrity?: HashSpec | undefined;
+    cacheDir?: string | undefined;
+    downloader?: BinaryDownloader | undefined;
+}
+export declare function uvFromDownload(opts: UvFromDownloadOptions): Promise<ResolvedUv | undefined>;

package/dist/external-tools/uv/from-download.js

@@ -0,0 +1,68 @@
+"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 from_download_exports = {};
+__export(from_download_exports, {
+  uvFromDownload: () => uvFromDownload
+});
+module.exports = __toCommonJS(from_download_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_socket = require("../../paths/socket");
+var import_from_download = require("../from-download");
+var import_asset_names = require("./asset-names");
+async function uvFromDownload(opts) {
+  const { cacheDir, downloader, integrity, platformArch, version } = opts;
+  const url = (0, import_asset_names.getUvDownloadUrl)({ version, platformArch });
+  const entry = (0, import_asset_names.getUvAssetEntry)(platformArch);
+  if (!url || !entry) {
+    return void 0;
+  }
+  const archiveExt = entry.asset.endsWith(".zip") ? ".zip" : ".tar.gz";
+  const extractedDir = cacheDir ?? import_node_path.default.join((0, import_socket.getSocketDlxDir)(), "uv", version, platformArch);
+  const archive = await (0, import_from_download.downloadAndExtractTool)({
+    url,
+    name: `uv-${version}-${platformArch}${archiveExt}`,
+    integrity,
+    extractedDir,
+    extractOptions: { strip: 1 },
+    downloader
+  });
+  const binary = import_node_process.default.platform === "win32" ? "uv.exe" : "uv";
+  return {
+    path: import_node_path.default.join(extractedDir, binary),
+    source: "download",
+    integrity: archive.integrity
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uvFromDownload
+});

package/dist/external-tools/uv/from-path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file `uvFromPath()` — looks for `uv` on the system PATH.
+ */
+import type { ResolvedUv } from './types';
+export declare function uvFromPath(): Promise<ResolvedUv | undefined>;

package/dist/external-tools/uv/from-path.js

@@ -0,0 +1,40 @@
+"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 from_path_exports = {};
+__export(from_path_exports, {
+  uvFromPath: () => uvFromPath
+});
+module.exports = __toCommonJS(from_path_exports);
+var import_which = require("../../bin/which");
+async function uvFromPath() {
+  const onPath = await (0, import_which.which)("uv", { nothrow: true });
+  if (typeof onPath !== "string") {
+    return void 0;
+  }
+  return {
+    path: onPath,
+    source: "path"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uvFromPath
+});

package/dist/external-tools/uv/from-vfs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file `uvFromVfs()` — extracts the uv binary from the smol binary's VFS.
+ *   Returns `undefined` when the binary doesn't have uv bundled.
+ */
+import type { ResolvedUv } from './types';
+export declare const UV_VFS_KEY = "uv";
+export declare function uvFromVfs(): Promise<ResolvedUv | undefined>;

package/dist/external-tools/uv/from-vfs.js

@@ -0,0 +1,47 @@
+"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 from_vfs_exports = {};
+__export(from_vfs_exports, {
+  UV_VFS_KEY: () => UV_VFS_KEY,
+  uvFromVfs: () => uvFromVfs
+});
+module.exports = __toCommonJS(from_vfs_exports);
+var import_vfs = require("../../smol/vfs");
+const UV_VFS_KEY = "uv";
+async function uvFromVfs() {
+  const vfs = (0, import_vfs.getSmolVfs)();
+  if (!vfs) {
+    return void 0;
+  }
+  if (!vfs.has(UV_VFS_KEY)) {
+    return void 0;
+  }
+  const realPath = await vfs.extract(UV_VFS_KEY);
+  return {
+    path: realPath,
+    source: "vfs"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UV_VFS_KEY,
+  uvFromVfs
+});

package/dist/external-tools/uv/resolve.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file `resolveUv()` — uv resolution entry point. Tries each source in order:
+ *
+ *   1. VFS — smol binary's embedded uv (if packed)
+ *   2. PATH — `uv` on the system PATH
+ *   3. download — upstream GitHub release archive (only when `downloadIfMissing`
+ *      is passed) Returns `undefined` if all of the enabled sources miss.
+ *      Memoized per option-shape.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedUv } from './types';
+export interface ResolveUvOptions {
+    downloadIfMissing?: {
+        version: string;
+        platformArch: string;
+        integrity?: HashSpec | undefined;
+        cacheDir?: string | undefined;
+        downloader?: BinaryDownloader | undefined;
+    } | undefined;
+}
+export declare function cacheKey(opts: ResolveUvOptions | undefined): string;
+export declare function doResolveUv(opts?: ResolveUvOptions | undefined): Promise<ResolvedUv | undefined>;
+export declare function resetUvResolution(): void;
+export declare function resolveUv(opts?: ResolveUvOptions | undefined): Promise<ResolvedUv | undefined>;

package/dist/external-tools/uv/resolve.js

@@ -0,0 +1,73 @@
+"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 resolve_exports = {};
+__export(resolve_exports, {
+  cacheKey: () => cacheKey,
+  doResolveUv: () => doResolveUv,
+  resetUvResolution: () => resetUvResolution,
+  resolveUv: () => resolveUv
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_from_download = require("./from-download");
+var import_from_path = require("./from-path");
+var import_from_vfs = require("./from-vfs");
+const resolutionCache = /* @__PURE__ */ new Map();
+function cacheKey(opts) {
+  if (!opts?.downloadIfMissing) {
+    return "local-only";
+  }
+  const { cacheDir, integrity, platformArch, version } = opts.downloadIfMissing;
+  const integrityKey = typeof integrity === "string" ? integrity : integrity ? `${integrity.type}:${integrity.value}` : "";
+  return `dl:${version}:${platformArch}:${integrityKey}:${cacheDir ?? ""}`;
+}
+async function doResolveUv(opts) {
+  const fromVfs = await (0, import_from_vfs.uvFromVfs)();
+  if (fromVfs) {
+    return fromVfs;
+  }
+  const fromPath = await (0, import_from_path.uvFromPath)();
+  if (fromPath) {
+    return fromPath;
+  }
+  if (opts?.downloadIfMissing) {
+    return (0, import_from_download.uvFromDownload)(opts.downloadIfMissing);
+  }
+  return void 0;
+}
+function resetUvResolution() {
+  resolutionCache.clear();
+}
+function resolveUv(opts) {
+  const key = cacheKey(opts);
+  let cached = resolutionCache.get(key);
+  if (!cached) {
+    cached = doResolveUv(opts);
+    resolutionCache.set(key, cached);
+  }
+  return cached;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheKey,
+  doResolveUv,
+  resetUvResolution,
+  resolveUv
+});

package/dist/external-tools/uv/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file Shared types for uv resolution. uv is Astral's Python package manager
+ *   used by socket-basics for Python project bootstrap. Ships per-platform
+ *   archives that wrap the `uv` binary one level deep.
+ */
+import type { ResolvedToolIntegrity } from '../from-download';
+export type UvSource = 'download' | 'path' | 'vfs';
+/**
+ * A resolved uv installation.
+ */
+export interface ResolvedUv {
+    /**
+     * Absolute path to the `uv` executable.
+     */
+    readonly path: string;
+    /**
+     * Which resolver tier found this.
+     */
+    readonly source: UvSource;
+    /**
+     * See {@link ResolvedToolIntegrity}.
+     */
+    readonly integrity?: ResolvedToolIntegrity;
+}

package/dist/external-tools/uv/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/fs/_internal.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file Private state shared between `fs/safe` and `fs/path-cache`. The `_`
+ *   prefix keeps this module out of the generated package.json `exports` map
+ *   (the `dist/**\/_*` ignore pattern in
+ *   `scripts/fix/generate-package-exports.mts` filters it out), so it is not
+ *   part of the public surface — it exists only to give the two leaves above a
+ *   common owner for the allowed-directory cache. The cache is invalidated by
+ *   `invalidatePathCache()` in `fs/path-cache.ts` whenever paths are rewired in
+ *   tests (`paths/rewire.ts` registers `invalidatePathCache` as one of its
+ *   cache callbacks); `getAllowedDirectories()` rehydrates on next call.
+ */
+/**
+ * Clear the cached allowed-directories list. Used by `invalidatePathCache()`
+ * when test path rewiring changes any of the underlying paths so the next read
+ * picks up the new resolved values.
+ */
+export declare function clearAllowedDirectories(): void;
+/**
+ * Get resolved allowed directories for safe deletion with lazy caching. These
+ * directories are resolved once and cached for the process lifetime.
+ */
+export declare function getAllowedDirectories(): string[];

package/dist/fs/_internal.js

@@ -0,0 +1,48 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  clearAllowedDirectories: () => clearAllowedDirectories,
+  getAllowedDirectories: () => getAllowedDirectories
+});
+module.exports = __toCommonJS(internal_exports);
+var import_path = require("../node/path");
+var import_socket = require("../paths/socket");
+let _cachedAllowedDirs;
+function clearAllowedDirectories() {
+  _cachedAllowedDirs = void 0;
+}
+function getAllowedDirectories() {
+  if (_cachedAllowedDirs === void 0) {
+    const path = (0, import_path.getNodePath)();
+    _cachedAllowedDirs = [
+      path.resolve((0, import_socket.getOsTmpDir)()),
+      path.resolve((0, import_socket.getSocketCacacheDir)()),
+      path.resolve((0, import_socket.getSocketUserDir)())
+    ];
+  }
+  return _cachedAllowedDirs;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearAllowedDirectories,
+  getAllowedDirectories
+});

package/dist/fs/encoding.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @file Encoding-name normalization. Maps user-supplied encoding strings (case-
+ *   and dash-variant) to the canonical Node Buffer encoding tokens. Mirrors
+ *   `internal/util.js#normalizeEncoding` so the common-case fast path is
+ *   identical to Node's, and slow cases delegate to a separate function so v8
+ *   will inline the hot one.
+ */
+import type { BufferEncoding } from './types';
+/**
+ * Normalize encoding string to canonical form. Handles common encodings inline
+ * for performance, delegates to slowCases for others.
+ *
+ * Based on Node.js internal/util.js normalizeEncoding implementation.
+ *
+ * @example
+ *   ;```ts
+ *   normalizeEncoding('UTF-8') // Returns 'utf8'
+ *   normalizeEncoding('binary') // Returns 'latin1'
+ *   normalizeEncoding('ucs-2') // Returns 'utf16le'
+ *   normalizeEncoding(null) // Returns 'utf8'
+ *   ```
+ *
+ * @param enc - Encoding to normalize (can be null/undefined)
+ *
+ * @returns Normalized encoding string, defaults to 'utf8'
+ *
+ * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
+ */
+export declare function normalizeEncoding(enc: BufferEncoding | string | null | undefined): BufferEncoding;
+/**
+ * Move the "slow cases" to a separate function to make sure this function gets
+ * inlined properly. That prioritizes the common case.
+ *
+ * Based on Node.js internal/util.js normalizeEncoding implementation.
+ *
+ * @example
+ *   ;```typescript
+ *   normalizeEncodingSlow('ucs2') // 'utf16le'
+ *   normalizeEncodingSlow('LATIN1') // 'latin1'
+ *   normalizeEncodingSlow('binary') // 'latin1'
+ *   ```
+ *
+ * @param enc - Encoding to normalize.
+ *
+ * @returns Normalized encoding string, defaults to 'utf8' for unknown encodings
+ *
+ * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
+ */
+export declare function normalizeEncodingSlow(enc: string): BufferEncoding;

package/dist/fs/encoding.js

@@ -0,0 +1,102 @@
+"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 encoding_exports = {};
+__export(encoding_exports, {
+  normalizeEncoding: () => normalizeEncoding,
+  normalizeEncodingSlow: () => normalizeEncodingSlow
+});
+module.exports = __toCommonJS(encoding_exports);
+// @__NO_SIDE_EFFECTS__
+function normalizeEncoding(enc) {
+  return enc == null || enc === "utf8" || enc === "utf-8" ? "utf8" : /* @__PURE__ */ normalizeEncodingSlow(enc);
+}
+// @__NO_SIDE_EFFECTS__
+function normalizeEncodingSlow(enc) {
+  const { length } = enc;
+  if (length === 4) {
+    if (enc === "ucs2" || enc === "UCS2") {
+      return "utf16le";
+    }
+    if (enc.toLowerCase() === "ucs2") {
+      return "utf16le";
+    }
+  } else if (length === 3 && enc === "hex" || enc === "HEX" || enc.toLowerCase() === "hex") {
+    return "hex";
+  } else if (length === 5) {
+    if (enc === "ascii") {
+      return "ascii";
+    }
+    if (enc === "ucs-2") {
+      return "utf16le";
+    }
+    if (enc === "ASCII") {
+      return "ascii";
+    }
+    if (enc === "UCS-2") {
+      return "utf16le";
+    }
+    enc = enc.toLowerCase();
+    if (enc === "ascii") {
+      return "ascii";
+    }
+    if (enc === "ucs-2") {
+      return "utf16le";
+    }
+  } else if (length === 6) {
+    if (enc === "base64") {
+      return "base64";
+    }
+    if (enc === "latin1" || enc === "binary") {
+      return "latin1";
+    }
+    if (enc === "BASE64") {
+      return "base64";
+    }
+    if (enc === "LATIN1" || enc === "BINARY") {
+      return "latin1";
+    }
+    enc = enc.toLowerCase();
+    if (enc === "base64") {
+      return "base64";
+    }
+    if (enc === "latin1" || enc === "binary") {
+      return "latin1";
+    }
+  } else if (length === 7) {
+    if (enc === "utf16le" || enc === "UTF16LE" || enc.toLowerCase() === "utf16le") {
+      return "utf16le";
+    }
+  } else if (length === 8) {
+    if (enc === "utf-16le" || enc === "UTF-16LE" || enc.toLowerCase() === "utf-16le") {
+      return "utf16le";
+    }
+  } else if (length === 9) {
+    if (enc === "base64url" || enc === "BASE64URL" || enc.toLowerCase() === "base64url") {
+      return "base64url";
+    }
+  }
+  return "utf8";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeEncoding,
+  normalizeEncodingSlow
+});