@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/cacache.js

@@ -1,156 +0,0 @@
-"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 cacache_exports = {};
-__export(cacache_exports, {
-  clear: () => clear,
-  get: () => get,
-  getCacache: () => getCacache,
-  put: () => put,
-  remove: () => remove,
-  safeGet: () => safeGet,
-  withTmp: () => withTmp
-});
-module.exports = __toCommonJS(cacache_exports);
-var import_cacache = __toESM(require("./external/cacache"));
-var import_socket = require("./paths/socket");
-var import_primordials = require("./primordials");
-function createPatternMatcher(pattern) {
-  if (!pattern.includes("*")) {
-    return (key) => (0, import_primordials.StringPrototypeStartsWith)(key, pattern);
-  }
-  const escaped = (0, import_primordials.StringPrototypeReplaceAll)(
-    pattern,
-    /[.+?^${}()|[\]\\]/g,
-    "\\$&"
-  );
-  const regexPattern = (0, import_primordials.StringPrototypeReplaceAll)(escaped, "*", ".*");
-  const regex = new import_primordials.RegExpCtor(`^${regexPattern}$`);
-  return (key) => (0, import_primordials.RegExpPrototypeTest)(regex, key);
-}
-async function clear(options) {
-  const opts = { __proto__: null, ...options };
-  const cacache2 = getCacache();
-  const cacheDir = (0, import_socket.getSocketCacacheDir)();
-  if (!opts.prefix) {
-    try {
-      await cacache2.rm.all(cacheDir);
-      return;
-    } catch (e) {
-      if (e?.code !== "ENOTEMPTY") {
-        throw e;
-      }
-      return;
-    }
-  }
-  const hasWildcard = opts.prefix.includes("*");
-  if (!hasWildcard) {
-    let removed2 = 0;
-    const stream2 = cacache2.ls.stream(cacheDir);
-    for await (const entry of stream2) {
-      if (entry.key.startsWith(opts.prefix)) {
-        try {
-          await cacache2.rm.entry(cacheDir, entry.key);
-          removed2++;
-        } catch {
-        }
-      }
-    }
-    return removed2;
-  }
-  let removed = 0;
-  const matches = createPatternMatcher(opts.prefix);
-  const stream = cacache2.ls.stream(cacheDir);
-  for await (const entry of stream) {
-    if (matches(entry.key)) {
-      try {
-        await cacache2.rm.entry(cacheDir, entry.key);
-        removed++;
-      } catch {
-      }
-    }
-  }
-  return removed;
-}
-async function get(key, options) {
-  if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-    throw new import_primordials.TypeErrorCtor(
-      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
-    );
-  }
-  const cacache2 = getCacache();
-  return await cacache2.get((0, import_socket.getSocketCacacheDir)(), key, options);
-}
-function getCacache() {
-  return import_cacache.default;
-}
-async function put(key, data, options) {
-  if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-    throw new import_primordials.TypeErrorCtor(
-      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
-    );
-  }
-  const cacache2 = getCacache();
-  return await cacache2.put((0, import_socket.getSocketCacacheDir)(), key, data, options);
-}
-async function remove(key) {
-  if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-    throw new import_primordials.TypeErrorCtor(
-      'Cache key cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) to remove multiple entries.'
-    );
-  }
-  const cacache2 = getCacache();
-  return await cacache2.rm.entry((0, import_socket.getSocketCacacheDir)(), key);
-}
-async function safeGet(key, options) {
-  try {
-    return await get(key, options);
-  } catch {
-    return void 0;
-  }
-}
-async function withTmp(callback) {
-  const cacache2 = getCacache();
-  return await cacache2.tmp.withTmp(
-    (0, import_socket.getSocketCacacheDir)(),
-    {},
-    callback
-  );
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clear,
-  get,
-  getCacache,
-  put,
-  remove,
-  safeGet,
-  withTmp
-});

package/dist/cache-with-ttl.d.ts

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Generic TTL-based caching utility using cacache.
- *
- * Provides a simple interface for caching data with time-to-live (TTL) expiration.
- * Uses cacache for persistent storage with metadata for TTL tracking.
- *
- * Features:
- * - Automatic expiration based on TTL
- * - In-memory memoization for hot data
- * - Persistent storage across process restarts
- * - Type-safe with generics
- *
- * Usage:
- * ```ts
- * const cache = createTtlCache({ ttl: 5 * 60 * 1000 }) // 5 minutes
- * const data = await cache.getOrFetch('key', async () => fetchData())
- * ```
- */
-export interface ClearOptions {
-    /**
-     * Only clear in-memory memoization cache, not persistent cache.
-     * Useful for forcing a refresh of cached data without removing it from disk.
-     *
-     * @default false
-     */
-    memoOnly?: boolean | undefined;
-}
-export interface TtlCache {
-    /**
-     * Get cached data without fetching.
-     * Returns undefined if not found or expired.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     * @throws {TypeError} If key contains wildcards (*)
-     */
-    get<T>(key: string): Promise<T | undefined>;
-    /**
-     * Get all cached entries matching a pattern.
-     * Supports wildcards (*) for flexible matching.
-     *
-     * @param pattern - Key pattern (supports * wildcards, or use '*' for all entries)
-     * @returns Map of matching entries (key -> value)
-     *
-     * @example
-     * // Get all organization entries
-     * const orgs = await cache.getAll<OrgData>('organizations:*')
-     * for (const [key, org] of orgs) {
-     *   console.log(`${key}: ${org.name}`)
-     * }
-     *
-     * @example
-     * // Get all entries with this cache's prefix
-     * const all = await cache.getAll<unknown>('*')
-     */
-    getAll<T>(pattern: string): Promise<Map<string, T>>;
-    /**
-     * Get cached data or fetch and cache if missing/expired.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     */
-    getOrFetch<T>(key: string, fetcher: () => Promise<T>): Promise<T>;
-    /**
-     * Set cached data with TTL.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     * @throws {TypeError} If key contains wildcards (*)
-     */
-    set<T>(key: string, data: T): Promise<void>;
-    /**
-     * Delete a specific cache entry.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     * @throws {TypeError} If key contains wildcards (*)
-     */
-    delete(key: string): Promise<void>;
-    /**
-     * Delete all cache entries matching a pattern.
-     * Supports wildcards (*) for flexible matching.
-     *
-     * @param pattern - Key pattern (supports * wildcards, or omit to delete all)
-     * @returns Number of entries deleted
-     *
-     * @example
-     * // Delete all entries with this cache's prefix
-     * await cache.deleteAll()
-     *
-     * @example
-     * // Delete entries matching prefix
-     * await cache.deleteAll('organizations')
-     *
-     * @example
-     * // Delete entries with wildcard pattern
-     * await cache.deleteAll('scans:abc*')
-     * await cache.deleteAll('npm/lodash/*')
-     */
-    deleteAll(pattern?: string | undefined): Promise<number>;
-    /**
-     * Clear all cache entries (like Map.clear()).
-     * Optionally clear only in-memory cache.
-     *
-     * @param options - Optional configuration
-     * @param options.memoOnly - If true, only clears in-memory cache
-     *
-     * @example
-     * // Clear everything (memory + disk)
-     * await cache.clear()
-     *
-     * @example
-     * // Clear only in-memory cache (force refresh)
-     * await cache.clear({ memoOnly: true })
-     */
-    clear(options?: ClearOptions | undefined): Promise<void>;
-}
-export interface TtlCacheEntry<T> {
-    data: T;
-    expiresAt: number;
-}
-export interface TtlCacheOptions {
-    /**
-     * Time-to-live in milliseconds.
-     * @default 5 * 60 * 1000 (5 minutes)
-     */
-    ttl?: number | undefined;
-    /**
-     * Enable in-memory memoization for hot data.
-     * @default true
-     */
-    memoize?: boolean | undefined;
-    /**
-     * Maximum number of entries to keep in the in-memory memo cache. When
-     * exceeded, the least-recently-used entry is evicted. The persistent
-     * (cacache) layer is unaffected.
-     * @default 1000
-     */
-    memoMaxSize?: number | undefined;
-    /**
-     * Custom cache key prefix.
-     * Must not contain wildcards (*).
-     * Use clear({ prefix: "pattern*" }) for wildcard matching instead.
-     *
-     * @default 'ttl-cache'
-     * @throws {TypeError} If prefix contains wildcards
-     *
-     * @example
-     * // Valid
-     * createTtlCache({ prefix: 'socket-sdk' })
-     * createTtlCache({ prefix: 'my-app:cache' })
-     *
-     * @example
-     * // Invalid - throws TypeError
-     * createTtlCache({ prefix: 'socket-*' })
-     */
-    prefix?: string | undefined;
-}
-/**
- * Create a TTL-based cache instance.
- *
- * @example
- * ```typescript
- * const cache = createTtlCache({ ttl: 60_000, prefix: 'my-app' })
- * await cache.set('key', { value: 42 })
- * const data = await cache.get('key') // { value: 42 }
- * ```
- */
-export declare function createTtlCache(options?: TtlCacheOptions): TtlCache;

package/dist/colors.d.ts

@@ -1,49 +0,0 @@
-/**
- * @fileoverview Color utilities for RGB color conversion and manipulation.
- * Provides type-safe color handling with named colors and RGB tuples.
- */
-/**
- * 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;
-/**
- * Type guard to check if a color value is an RGB tuple.
- * @param value - Color value to check
- * @returns `true` if value is an RGB tuple, `false` if it's a color name
- *
- * @example
- * ```typescript
- * isRgbTuple([255, 0, 0]) // true
- * isRgbTuple('red')       // false
- * ```
- */
-export declare function isRgbTuple(value: ColorValue): value is ColorRgb;
-/**
- * Convert a color value to RGB tuple format.
- * Named colors are looked up in the `colorToRgb` map, RGB tuples are returned as-is.
- * @param color - Color name or RGB tuple
- * @returns RGB tuple with values 0-255
- *
- * @example
- * ```typescript
- * toRgb('red')       // [255, 0, 0]
- * toRgb([0, 128, 0]) // [0, 128, 0]
- * ```
- */
-export declare function toRgb(color: ColorValue): ColorRgb;

package/dist/compression.d.ts

@@ -1,218 +0,0 @@
-/**
- * @fileoverview Async compression / decompression helpers (brotli + gzip).
- *
- * Three calling shapes cover most use cases:
- *
- *   1. In-memory — compress/decompress a Buffer or string, get a Buffer
- *      back. For payloads small enough to fit in memory.
- *
- *      const compressed = await compressBrotli(JSON.stringify(payload))
- *      const original = await decompressBrotli(compressed)
- *
- *   2. File-to-file — stream pipeline through zlib, no memory hit.
- *      For arbitrary-sized files (build artifacts, scan output, logs).
- *
- *      await compressBrotliFile('input.json', 'input.json.br')
- *      await decompressBrotliFile('input.json.br', 'input.json')
- *
- *   3. Raw streams — use directly in your own pipeline. The factory
- *      returns the underlying zlib transform so you can compose it
- *      with anything (e.g. tar pipelines, HTTP body streams).
- *
- *      readable.pipe(createBrotliCompressor()).pipe(writable)
- *
- * Detection:
- *
- *   - `isBrotliCompressed(buf)` — peek the first byte for the brotli
- *     magic-byte signature (no full parse).
- *   - `hasBrotliExtension(path)` — `.br` / `.brotli` filename suffix.
- *
- * Compression-level defaults are tuned for one-shot CLI use: brotli at
- * quality 11 (max compression, slow but it's a one-shot upload), gzip
- * at level 6 (the zlib default). Override via the `level` option if
- * the call is hot or the input is large.
- */
-import { Buffer } from 'node:buffer';
-import { type BrotliOptions, type ZlibOptions } from 'node:zlib';
-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;
-}
-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;
-/**
- * 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 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;
-/**
- * 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;
-/**
- * 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;
-/**
- * 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 BROTLI_EXTS: ReadonlySet<string>;
-export declare const GZIP_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;
-/**
- * Extension check for gzip paths — matches `.gz` / `.gzip` / `.tgz`
- * (case-insensitive). Naming follows node:path's `extname`.
- */
-export declare function hasGzipExt(filePath: string): boolean;
-/**
- * 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`
- * (re-exported from this module) for the canonical compression sets,
- * or your own set for custom classifiers.
- *
- * This helper is 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 {};

package/dist/constants/process.d.ts

@@ -1,20 +0,0 @@
-/**
- * @fileoverview Process control helpers.
- * Lazily creates and exposes a shared `AbortController` and its `AbortSignal`
- * so cooperating modules can coordinate cancellation from a single source.
- */
-/**
- * Get the process-scoped shared `AbortController` singleton.
- * Cooperating modules use this to coordinate cancellation across the library.
- *
- * @returns The lazily-created shared `AbortController` instance.
- */
-export declare function getAbortController(): AbortController;
-/**
- * Get the process-scoped shared `AbortSignal` singleton.
- * This is the `signal` property of {@link getAbortController}'s controller and
- * is intended to be passed to APIs that accept an `AbortSignal`.
- *
- * @returns The shared `AbortSignal` instance.
- */
-export declare function getAbortSignal(): AbortSignal;

package/dist/crypto.d.ts

@@ -1,36 +0,0 @@
-/**
- * @fileoverview Crypto helpers that prefer Node builtins where available.
- */
-/**
- * Resolve `crypto.hash` (or `undefined` if the runtime predates it).
- *
- * Exported for unit tests; not part of the public API.
- *
- * @internal
- */
-export declare function getNativeHash(): typeof import('node:crypto').hash | undefined;
-/**
- * Compute a one-shot cryptographic hash.
- *
- * Prefers Node's `crypto.hash(algorithm, data, outputEncoding)` (added
- * v21.7.0 / v20.12.0), which is ~30% faster than the
- * `createHash().update().digest()` chain on small-to-medium inputs
- * because it skips constructing the streaming `Hash` object. Falls
- * back to that chain on older runtimes.
- *
- * Use this only for the one-shot case where the entire input is
- * available as a single buffer or string; if you need to feed chunks,
- * stay on `createHash()`.
- *
- * @example
- * ```typescript
- * import { hash } from '@socketsecurity/lib/crypto'
- *
- * hash('sha256', 'hello', 'hex')
- * // '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'
- *
- * hash('sha512', someBuffer, 'base64')
- * // 'z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg=='
- * ```
- */
-export declare function hash(algorithm: string, data: string | NodeJS.ArrayBufferView, outputEncoding: 'hex' | 'base64' | 'base64url' | 'binary'): string;