@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/streams.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Stream processing utilities with streaming-iterables integration.
+ * Provides async stream handling and transformation functions.
+ */
+import type { IterationOptions } from './promises';
+/**
+ * Execute a function for each item in an iterable in parallel.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function parallelEach<T>(iterable: Iterable<T> | AsyncIterable<T>, func: (item: T) => Promise<unknown>, options?: number | IterationOptions): Promise<void>;
+/**
+ * Map over an iterable in parallel with concurrency control.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function parallelMap<T, U>(iterable: Iterable<T> | AsyncIterable<T>, func: (item: T) => Promise<U>, options?: number | IterationOptions): AsyncIterable<U>;
+/**
+ * Transform an iterable with a function.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function transform<T, U>(iterable: Iterable<T> | AsyncIterable<T>, func: (item: T) => Promise<U>, options?: number | IterationOptions): AsyncIterable<U>;

package/dist/streams.js

@@ -0,0 +1,80 @@
+/* Socket Lib - Built with esbuild */
+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 streams_exports = {};
+__export(streams_exports, {
+  parallelEach: () => parallelEach,
+  parallelMap: () => parallelMap,
+  transform: () => transform
+});
+module.exports = __toCommonJS(streams_exports);
+var import_promises = require("./promises");
+let _streamingIterables;
+// @__NO_SIDE_EFFECTS__
+function getStreamingIterables() {
+  if (_streamingIterables === void 0) {
+    _streamingIterables = require("../external/streaming-iterables");
+  }
+  return _streamingIterables;
+}
+// @__NO_SIDE_EFFECTS__
+async function parallelEach(iterable, func, options) {
+  for await (const _ of /* @__PURE__ */ parallelMap(iterable, func, options)) {
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function parallelMap(iterable, func, options) {
+  const streamingIterables = /* @__PURE__ */ getStreamingIterables();
+  const opts = (0, import_promises.normalizeIterationOptions)(options);
+  const result = streamingIterables?.parallelMap(
+    opts.concurrency,
+    async (item) => {
+      const result2 = await (0, import_promises.pRetry)((...args) => func(args[0]), {
+        ...opts.retries,
+        args: [item]
+      });
+      return result2;
+    },
+    iterable
+  );
+  return result;
+}
+// @__NO_SIDE_EFFECTS__
+function transform(iterable, func, options) {
+  const streamingIterables = /* @__PURE__ */ getStreamingIterables();
+  const opts = (0, import_promises.normalizeIterationOptions)(options);
+  const result = streamingIterables?.transform(
+    opts.concurrency,
+    async (item) => {
+      const result2 = await (0, import_promises.pRetry)((...args) => func(args[0]), {
+        ...opts.retries,
+        args: [item]
+      });
+      return result2;
+    },
+    iterable
+  );
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parallelEach,
+  parallelMap,
+  transform
+});
+//# sourceMappingURL=streams.js.map

package/dist/streams.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/streams.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Stream processing utilities with streaming-iterables integration.\n * Provides async stream handling and transformation functions.\n */\n\nimport type { IterationOptions } from './promises'\nimport { normalizeIterationOptions, pRetry } from './promises'\n\nlet _streamingIterables:\n  | {\n      parallelMap: <T, U>(\n        concurrency: number,\n        mapper: (item: T) => Promise<U>,\n        iterable: Iterable<T> | AsyncIterable<T>,\n      ) => AsyncIterable<U>\n      transform: <T, U>(\n        concurrency: number,\n        mapper: (item: T) => Promise<U>,\n        iterable: Iterable<T> | AsyncIterable<T>,\n      ) => AsyncIterable<U>\n    }\n  | undefined\n/**\n * Get the streaming-iterables module.\n * @private\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getStreamingIterables() {\n  if (_streamingIterables === undefined) {\n    _streamingIterables = /*@__PURE__*/ require('../external/streaming-iterables')\n  }\n  return _streamingIterables\n}\n\n/**\n * Execute a function for each item in an iterable in parallel.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport async function parallelEach<T>(\n  iterable: Iterable<T> | AsyncIterable<T>,\n  func: (item: T) => Promise<unknown>,\n  options?: number | IterationOptions,\n): Promise<void> {\n  for await (const _ of parallelMap(iterable, func, options)) {\n    /* empty block */\n  }\n}\n\n/**\n * Map over an iterable in parallel with concurrency control.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function parallelMap<T, U>(\n  iterable: Iterable<T> | AsyncIterable<T>,\n  func: (item: T) => Promise<U>,\n  options?: number | IterationOptions,\n): AsyncIterable<U> {\n  const streamingIterables = getStreamingIterables()\n  const opts = normalizeIterationOptions(options)\n  const result = streamingIterables?.parallelMap(\n    opts.concurrency,\n    async (item: T) => {\n      const result = await pRetry((...args: unknown[]) => func(args[0] as T), {\n        ...opts.retries,\n        args: [item],\n      })\n      return result as U\n    },\n    iterable,\n  )\n  return result as AsyncIterable<U>\n}\n\n/**\n * Transform an iterable with a function.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function transform<T, U>(\n  iterable: Iterable<T> | AsyncIterable<T>,\n  func: (item: T) => Promise<U>,\n  options?: number | IterationOptions,\n): AsyncIterable<U> {\n  const streamingIterables = getStreamingIterables()\n  const opts = normalizeIterationOptions(options)\n  const result = streamingIterables?.transform(\n    opts.concurrency,\n    async (item: T) => {\n      const result = await pRetry((...args: unknown[]) => func(args[0] as T), {\n        ...opts.retries,\n        args: [item],\n      })\n      return result as U\n    },\n    iterable,\n  )\n  return result as AsyncIterable<U>\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,sBAAkD;AAElD,IAAI;AAAA;AAmBJ,SAAS,wBAAwB;AAC/B,MAAI,wBAAwB,QAAW;AACrC,0BAAoC,QAAQ,iCAAiC;AAAA,EAC/E;AACA,SAAO;AACT;AAAA;AAMA,eAAsB,aACpB,UACA,MACA,SACe;AACf,mBAAiB,KAAK,4BAAY,UAAU,MAAM,OAAO,GAAG;AAAA,EAE5D;AACF;AAAA;AAMO,SAAS,YACd,UACA,MACA,SACkB;AAClB,QAAM,qBAAqB,sCAAsB;AACjD,QAAM,WAAO,2CAA0B,OAAO;AAC9C,QAAM,SAAS,oBAAoB;AAAA,IACjC,KAAK;AAAA,IACL,OAAO,SAAY;AACjB,YAAMA,UAAS,UAAM,wBAAO,IAAI,SAAoB,KAAK,KAAK,CAAC,CAAM,GAAG;AAAA,QACtE,GAAG,KAAK;AAAA,QACR,MAAM,CAAC,IAAI;AAAA,MACb,CAAC;AACD,aAAOA;AAAA,IACT;AAAA,IACA;AAAA,EACF;AACA,SAAO;AACT;AAAA;AAMO,SAAS,UACd,UACA,MACA,SACkB;AAClB,QAAM,qBAAqB,sCAAsB;AACjD,QAAM,WAAO,2CAA0B,OAAO;AAC9C,QAAM,SAAS,oBAAoB;AAAA,IACjC,KAAK;AAAA,IACL,OAAO,SAAY;AACjB,YAAMA,UAAS,UAAM,wBAAO,IAAI,SAAoB,KAAK,KAAK,CAAC,CAAM,GAAG;AAAA,QACtE,GAAG,KAAK;AAAA,QACR,MAAM,CAAC,IAAI;AAAA,MACb,CAAC;AACD,aAAOA;AAAA,IACT;AAAA,IACA;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": ["result"]
+}

package/dist/strings.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview String manipulation utilities including ANSI code handling.
+ * Provides string processing, prefix application, and terminal output utilities.
+ */
+import { ansiRegex, stripAnsi } from './ansi';
+// Import get-east-asian-width from external wrapper.
+// This library implements Unicode Standard Annex #11 (East Asian Width).
+// https://www.unicode.org/reports/tr11/
+// Re-export ANSI utilities for backward compatibility.
+export { ansiRegex, stripAnsi };
+// Type definitions
+declare const BlankStringBrand: unique symbol;
+export type BlankString = string & {
+    [BlankStringBrand]: true;
+};
+declare const EmptyStringBrand: unique symbol;
+export type EmptyString = string & {
+    [EmptyStringBrand]: true;
+};
+// IMPORTANT: Do not use destructuring here - use direct assignment instead.
+// tsgo has a bug that incorrectly transpiles destructured exports, resulting in
+// `exports.SomeName = void 0;` which causes runtime errors.
+// See: https://github.com/SocketDev/socket-packageurl-js/issues/3
+export declare const fromCharCode: (...codes: number[]) => string;
+export interface ApplyLinePrefixOptions {
+    prefix?: string;
+}
+/**
+ * Apply a prefix to each line of a string.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function applyLinePrefix(str: string, options?: ApplyLinePrefixOptions | undefined): string;
+/**
+ * Convert a camelCase string to kebab-case.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function camelToKebab(str: string): string;
+export interface IndentStringOptions {
+    count?: number;
+}
+/**
+ * Indent each line of a string with spaces.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function indentString(str: string, options?: IndentStringOptions | undefined): string;
+/**
+ * Check if a value is a blank string (empty or only whitespace).
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function isBlankString(value: unknown): value is BlankString;
+/**
+ * Check if a value is a non-empty string.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function isNonEmptyString(value: unknown): value is Exclude<string, EmptyString>;
+export interface SearchOptions {
+    fromIndex?: number;
+}
+/**
+ * Search for a regular expression in a string starting from an index.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function search(str: string, regexp: RegExp, options?: SearchOptions | undefined): number;
+/**
+ * Strip the Byte Order Mark (BOM) from the beginning of a string.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function stripBom(str: string): string;
+/**
+ * Get the visual width of a string in terminal columns.
+ * Strips ANSI escape codes and accounts for wide characters.
+ *
+ * Based on string-width:
+ * https://socket.dev/npm/package/string-width/overview/7.2.0
+ * MIT License
+ * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+ *
+ * Terminal emulators display characters in a grid of cells (columns).
+ * Most ASCII characters take 1 column, but some characters (especially
+ * emoji and CJK characters) take 2 columns.
+ *
+ * This function calculates how many columns a string will occupy when
+ * displayed in a terminal, which is crucial for:
+ * - Aligning text properly
+ * - Preventing text from jumping when characters change
+ * - Calculating padding/spacing
+ *
+ * Logic:
+ * - Segment graphemes to match how terminals render clusters.
+ * - Width rules:
+ *   1. Skip non-printing clusters (Default_Ignorable, Control, pure Mark, lone Surrogates).
+ *   2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
+ *   3. Otherwise use East Asian Width of the cluster's first visible code point.
+ *   4. Add widths for trailing Halfwidth/Fullwidth Forms within the same cluster.
+ *
+ * East Asian Width categories (Unicode Standard Annex #11):
+ * - F (Fullwidth): 2 columns - e.g., fullwidth Latin letters (Ａ, Ｂ)
+ * - W (Wide): 2 columns - e.g., CJK ideographs (漢字), emoji (⚡, 😀)
+ * - H (Halfwidth): 1 column - e.g., halfwidth Katakana (ｱ, ｲ)
+ * - Na (Narrow): 1 column - e.g., ASCII (a-z, 0-9)
+ * - A (Ambiguous): Context-dependent, we treat as 1 column
+ * - N (Neutral): 1 column - e.g., most symbols (✦, ✧, ⋆)
+ *
+ * Why this matters for Socket spinners:
+ * - Lightning bolt (⚡) takes 2 columns
+ * - Stars (✦, ✧, ⋆) take 1 column
+ * - Without compensation, text jumps when frames change
+ * - We use this to calculate padding for consistent alignment
+ *
+ * @example
+ * stringWidth('hello') // => 5 (5 ASCII chars = 5 columns)
+ * stringWidth('⚡') // => 2 (lightning bolt is wide)
+ * stringWidth('✦') // => 1 (star is narrow)
+ * stringWidth('\x1b[31mred\x1b[0m') // => 3 (ANSI codes stripped, 'red' = 3)
+ *
+ * @throws {TypeError} When input is not a string.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function stringWidth(text: string): number;
+/**
+ * Convert a string to kebab-case (handles camelCase and snake_case).
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function toKebabCase(str: string): string;
+/**
+ * Trim newlines from the beginning and end of a string.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function trimNewlines(str: string): string;
+/**
+ * Repeat a string n times.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function repeatString(str: string, count: number): string;
+/**
+ * Center text within a given width.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function centerText(text: string, width: number): string;

package/dist/strings.js

@@ -0,0 +1,253 @@
+/* Socket Lib - Built with esbuild */
+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 strings_exports = {};
+__export(strings_exports, {
+  ansiRegex: () => import_ansi.ansiRegex,
+  applyLinePrefix: () => applyLinePrefix,
+  camelToKebab: () => camelToKebab,
+  centerText: () => centerText,
+  fromCharCode: () => fromCharCode,
+  indentString: () => indentString,
+  isBlankString: () => isBlankString,
+  isNonEmptyString: () => isNonEmptyString,
+  repeatString: () => repeatString,
+  search: () => search,
+  stringWidth: () => stringWidth,
+  stripAnsi: () => import_ansi.stripAnsi,
+  stripBom: () => stripBom,
+  toKebabCase: () => toKebabCase,
+  trimNewlines: () => trimNewlines
+});
+module.exports = __toCommonJS(strings_exports);
+var import_ansi = require("./ansi");
+var import_get_east_asian_width = require("./external/get-east-asian-width");
+const fromCharCode = String.fromCharCode;
+// @__NO_SIDE_EFFECTS__
+function applyLinePrefix(str, options) {
+  const { prefix = "" } = {
+    __proto__: null,
+    ...options
+  };
+  return prefix.length ? `${prefix}${str.includes("\n") ? str.replace(/\n/g, `
+${prefix}`) : str}` : str;
+}
+// @__NO_SIDE_EFFECTS__
+function camelToKebab(str) {
+  const { length } = str;
+  if (!length) {
+    return "";
+  }
+  let result = "";
+  let i = 0;
+  while (i < length) {
+    const char = str[i];
+    if (!char) {
+      break;
+    }
+    const charCode = char.charCodeAt(0);
+    const isUpperCase = charCode >= 65 && charCode <= 90;
+    if (isUpperCase) {
+      if (result.length > 0) {
+        result += "-";
+      }
+      while (i < length) {
+        const currChar = str[i];
+        if (!currChar) {
+          break;
+        }
+        const currCharCode = currChar.charCodeAt(0);
+        const isCurrUpper = currCharCode >= 65 && currCharCode <= 90;
+        if (isCurrUpper) {
+          result += fromCharCode(
+            currCharCode + 32
+            /*'a'-'A'*/
+          );
+          i += 1;
+        } else {
+          break;
+        }
+      }
+    } else {
+      result += char;
+      i += 1;
+    }
+  }
+  return result;
+}
+// @__NO_SIDE_EFFECTS__
+function indentString(str, options) {
+  const { count = 1 } = { __proto__: null, ...options };
+  return str.replace(/^(?!\s*$)/gm, " ".repeat(count));
+}
+// @__NO_SIDE_EFFECTS__
+function isBlankString(value) {
+  return typeof value === "string" && (!value.length || /^\s+$/.test(value));
+}
+// @__NO_SIDE_EFFECTS__
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+// @__NO_SIDE_EFFECTS__
+function search(str, regexp, options) {
+  const { fromIndex = 0 } = { __proto__: null, ...options };
+  const { length } = str;
+  if (fromIndex >= length) {
+    return -1;
+  }
+  if (fromIndex === 0) {
+    return str.search(regexp);
+  }
+  const offset = fromIndex < 0 ? Math.max(length + fromIndex, 0) : fromIndex;
+  const result = str.slice(offset).search(regexp);
+  return result === -1 ? -1 : result + offset;
+}
+// @__NO_SIDE_EFFECTS__
+function stripBom(str) {
+  return str.length > 0 && str.charCodeAt(0) === 65279 ? str.slice(1) : str;
+}
+const segmenter = new Intl.Segmenter();
+let zeroWidthClusterRegex;
+let leadingNonPrintingRegex;
+let emojiRegex;
+try {
+  zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$", "v");
+  leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+", "v");
+  emojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+} catch {
+  zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark})+$", "u");
+  leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}]+/u;
+  emojiRegex = new RegExp("^\\p{Extended_Pictographic}$", "u");
+}
+// @__NO_SIDE_EFFECTS__
+function stringWidth(text) {
+  if (typeof text !== "string" || !text.length) {
+    return 0;
+  }
+  const plainText = (0, import_ansi.stripAnsi)(text);
+  if (!plainText.length) {
+    return 0;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: false };
+  for (const { segment } of segmenter.segment(plainText)) {
+    if (zeroWidthClusterRegex.test(segment)) {
+      continue;
+    }
+    if (emojiRegex.test(segment)) {
+      width += 2;
+      continue;
+    }
+    const baseSegment = segment.replace(leadingNonPrintingRegex, "");
+    const codePoint = baseSegment.codePointAt(0);
+    if (codePoint === void 0) {
+      continue;
+    }
+    width += (0, import_get_east_asian_width.eastAsianWidth)(codePoint, eastAsianWidthOptions);
+    if (segment.length > 1) {
+      for (const char of segment.slice(1)) {
+        const charCode = char.charCodeAt(0);
+        if (charCode >= 65280 && charCode <= 65519) {
+          const trailingCodePoint = char.codePointAt(0);
+          if (trailingCodePoint !== void 0) {
+            width += (0, import_get_east_asian_width.eastAsianWidth)(trailingCodePoint, eastAsianWidthOptions);
+          }
+        }
+      }
+    }
+  }
+  return width;
+}
+// @__NO_SIDE_EFFECTS__
+function toKebabCase(str) {
+  if (!str.length) {
+    return str;
+  }
+  return str.replace(/([a-z]+[0-9]*)([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+// @__NO_SIDE_EFFECTS__
+function trimNewlines(str) {
+  const { length } = str;
+  if (length === 0) {
+    return str;
+  }
+  const first = str.charCodeAt(0);
+  const noFirstNewline = first !== 13 && first !== 10;
+  if (length === 1) {
+    return noFirstNewline ? str : "";
+  }
+  const last = str.charCodeAt(length - 1);
+  const noLastNewline = last !== 13 && last !== 10;
+  if (noFirstNewline && noLastNewline) {
+    return str;
+  }
+  let start = 0;
+  let end = length;
+  while (start < end) {
+    const code = str.charCodeAt(start);
+    if (code !== 13 && code !== 10) {
+      break;
+    }
+    start += 1;
+  }
+  while (end > start) {
+    const code = str.charCodeAt(end - 1);
+    if (code !== 13 && code !== 10) {
+      break;
+    }
+    end -= 1;
+  }
+  return start === 0 && end === length ? str : str.slice(start, end);
+}
+// @__NO_SIDE_EFFECTS__
+function repeatString(str, count) {
+  if (count <= 0) {
+    return "";
+  }
+  return str.repeat(count);
+}
+// @__NO_SIDE_EFFECTS__
+function centerText(text, width) {
+  const textLength = (0, import_ansi.stripAnsi)(text).length;
+  if (textLength >= width) {
+    return text;
+  }
+  const padding = width - textLength;
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ansiRegex,
+  applyLinePrefix,
+  camelToKebab,
+  centerText,
+  fromCharCode,
+  indentString,
+  isBlankString,
+  isNonEmptyString,
+  repeatString,
+  search,
+  stringWidth,
+  stripAnsi,
+  stripBom,
+  toKebabCase,
+  trimNewlines
+});
+//# sourceMappingURL=strings.js.map

package/dist/strings.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/strings.ts"],
+  "sourcesContent": ["/**\n * @fileoverview String manipulation utilities including ANSI code handling.\n * Provides string processing, prefix application, and terminal output utilities.\n */\n\nimport { ansiRegex, stripAnsi } from './ansi'\nimport { eastAsianWidth } from './external/get-east-asian-width'\n// Import get-east-asian-width from external wrapper.\n// This library implements Unicode Standard Annex #11 (East Asian Width).\n// https://www.unicode.org/reports/tr11/\n\n// Re-export ANSI utilities for backward compatibility.\nexport { ansiRegex, stripAnsi }\n\n// Type definitions\ndeclare const BlankStringBrand: unique symbol\nexport type BlankString = string & { [BlankStringBrand]: true }\ndeclare const EmptyStringBrand: unique symbol\nexport type EmptyString = string & { [EmptyStringBrand]: true }\n\n// IMPORTANT: Do not use destructuring here - use direct assignment instead.\n// tsgo has a bug that incorrectly transpiles destructured exports, resulting in\n// `exports.SomeName = void 0;` which causes runtime errors.\n// See: https://github.com/SocketDev/socket-packageurl-js/issues/3\nexport const fromCharCode = String.fromCharCode\n\nexport interface ApplyLinePrefixOptions {\n  prefix?: string\n}\n\n/**\n * Apply a prefix to each line of a string.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function applyLinePrefix(\n  str: string,\n  options?: ApplyLinePrefixOptions | undefined,\n): string {\n  const { prefix = '' } = {\n    __proto__: null,\n    ...options,\n  } as ApplyLinePrefixOptions\n  return prefix.length\n    ? `${prefix}${str.includes('\\n') ? str.replace(/\\n/g, `\\n${prefix}`) : str}`\n    : str\n}\n\n/**\n * Convert a camelCase string to kebab-case.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function camelToKebab(str: string): string {\n  const { length } = str\n  if (!length) {\n    return ''\n  }\n  let result = ''\n  let i = 0\n  while (i < length) {\n    const char = str[i]\n    if (!char) {\n      break\n    }\n    const charCode = char.charCodeAt(0)\n    // Check if current character is uppercase letter.\n    // A = 65, Z = 90\n    const isUpperCase = charCode >= 65 /*'A'*/ && charCode <= 90 /*'Z'*/\n    if (isUpperCase) {\n      // Add dash before uppercase sequence (except at start).\n      if (result.length > 0) {\n        result += '-'\n      }\n      // Collect all consecutive uppercase letters.\n      while (i < length) {\n        const currChar = str[i]\n        if (!currChar) {\n          break\n        }\n        const currCharCode = currChar.charCodeAt(0)\n        const isCurrUpper =\n          currCharCode >= 65 /*'A'*/ && currCharCode <= 90 /*'Z'*/\n        if (isCurrUpper) {\n          // Convert uppercase to lowercase: subtract 32 (A=65 -> a=97, diff=32)\n          result += fromCharCode(currCharCode + 32 /*'a'-'A'*/)\n          i += 1\n        } else {\n          // Stop when we hit non-uppercase.\n          break\n        }\n      }\n    } else {\n      // Handle lowercase letters, digits, and other characters.\n      result += char\n      i += 1\n    }\n  }\n  return result\n}\n\nexport interface IndentStringOptions {\n  count?: number\n}\n\n/**\n * Indent each line of a string with spaces.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function indentString(\n  str: string,\n  options?: IndentStringOptions | undefined,\n): string {\n  const { count = 1 } = { __proto__: null, ...options } as IndentStringOptions\n  return str.replace(/^(?!\\s*$)/gm, ' '.repeat(count))\n}\n\n/**\n * Check if a value is a blank string (empty or only whitespace).\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isBlankString(value: unknown): value is BlankString {\n  return typeof value === 'string' && (!value.length || /^\\s+$/.test(value))\n}\n\n/**\n * Check if a value is a non-empty string.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isNonEmptyString(\n  value: unknown,\n): value is Exclude<string, EmptyString> {\n  return typeof value === 'string' && value.length > 0\n}\n\nexport interface SearchOptions {\n  fromIndex?: number\n}\n\n/**\n * Search for a regular expression in a string starting from an index.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function search(\n  str: string,\n  regexp: RegExp,\n  options?: SearchOptions | undefined,\n): number {\n  const { fromIndex = 0 } = { __proto__: null, ...options } as SearchOptions\n  const { length } = str\n  if (fromIndex >= length) {\n    return -1\n  }\n  if (fromIndex === 0) {\n    return str.search(regexp)\n  }\n  const offset = fromIndex < 0 ? Math.max(length + fromIndex, 0) : fromIndex\n  const result = str.slice(offset).search(regexp)\n  return result === -1 ? -1 : result + offset\n}\n\n/**\n * Strip the Byte Order Mark (BOM) from the beginning of a string.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function stripBom(str: string): string {\n  // In JavaScript, string data is stored as UTF-16, so BOM is 0xFEFF.\n  // https://tc39.es/ecma262/#sec-unicode-format-control-characters\n  return str.length > 0 && str.charCodeAt(0) === 0xfe_ff ? str.slice(1) : str\n}\n\n// Initialize Intl.Segmenter for proper grapheme cluster segmentation.\n// Hoisted outside stringWidth() for reuse across multiple calls.\n//\n// A grapheme cluster is what a user perceives as a single character, but may\n// be composed of multiple Unicode code points.\n//\n// Why this matters:\n// - '\uD83D\uDC4D' (thumbs up) is 1 code point but appears as 1 character \u2192 1 grapheme\n// - '\uD83D\uDC4D\uD83C\uDFFD' (thumbs up + skin tone) is 2 code points but appears as 1 character \u2192 1 grapheme\n// - '\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66' (family) is 7 code points (4 people + 3 ZWJ) but appears as 1 character \u2192 1 grapheme\n// - '\u00E9' can be 1 code point (U+00E9) OR 2 code points (e + \u0301) but appears as 1 character \u2192 1 grapheme\n//\n// Without Intl.Segmenter, simple iteration treats each code point separately,\n// leading to incorrect width calculations for complex sequences.\n//\n// Intl.Segmenter is available in:\n// - Node.js 16.0.0+ (our minimum is 18.0.0, so always available)\n// - All modern browsers\n//\n// Performance: Creating this once and reusing it is more efficient than\n// creating a new Intl.Segmenter instance on every stringWidth() call.\nconst segmenter = new Intl.Segmenter()\n\n// Feature-detect Unicode property escapes support and create regex patterns.\n// Hoisted outside stringWidth() for reuse across multiple calls.\n//\n// Unicode property escapes in regex allow matching characters by their Unicode properties.\n// The 'v' flag (ES2024, Node 20+) provides the most accurate Unicode support including:\n// - \\p{RGI_Emoji} - Matches only emoji recommended for general interchange\n// - Full support for Unicode sets and properties\n//\n// The 'u' flag (ES2015, Node 18+) provides basic Unicode support but:\n// - No \\p{RGI_Emoji} property (must use broader \\p{Extended_Pictographic})\n// - No \\p{Surrogate} property (must omit from patterns)\n// - Less accurate for complex emoji sequences\n//\n// We feature-detect by attempting to create a regex with 'v' flag.\n// If it throws, we fall back to 'u' flag with adjusted patterns.\n//\n// This ensures:\n// - Best accuracy on Node 20+ (our test matrix: 20, 22, 24)\n// - Backward compatibility with Node 18 (our minimum version)\n// - No runtime errors from unsupported regex features\n//\n// Performance: Creating these once and reusing them is more efficient than\n// creating new regex instances on every stringWidth() call.\nlet zeroWidthClusterRegex: RegExp\nlet leadingNonPrintingRegex: RegExp\nlet emojiRegex: RegExp\n\ntry {\n  // Try 'v' flag first (Node 20+) for most accurate Unicode property support.\n  //\n  // ZERO-WIDTH CLUSTER PATTERN:\n  // Matches entire clusters that should be invisible (width = 0):\n  // - \\p{Default_Ignorable_Code_Point} - Characters like Zero Width Space (U+200B)\n  // - \\p{Control} - ASCII control chars (0x00-0x1F, 0x7F-0x9F) like \\t, \\n\n  // - \\p{Mark} - Combining marks that modify previous character (accents, diacritics)\n  // - \\p{Surrogate} - Lone surrogate halves (invalid UTF-16, should not appear)\n  zeroWidthClusterRegex =\n    /^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$/v\n\n  // LEADING NON-PRINTING PATTERN:\n  // Matches non-printing characters at the start of a cluster.\n  // Used to find the \"base\" visible character in a cluster.\n  // - \\p{Format} - Formatting characters like Right-to-Left marks\n  // Example: In a cluster starting with format chars, we skip them to find the base character.\n  leadingNonPrintingRegex =\n    /^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+/v\n\n  // RGI EMOJI PATTERN:\n  // \\p{RGI_Emoji} matches emoji in the \"Recommended for General Interchange\" set.\n  // This is the most accurate way to detect emoji that should render as double-width.\n  //\n  // RGI emoji include:\n  // - Basic emoji: \uD83D\uDC4D, \uD83D\uDE00, \u26A1\n  // - Emoji with modifiers: \uD83D\uDC4D\uD83C\uDFFD (thumbs up + medium skin tone)\n  // - ZWJ sequences: \uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66 (family: man, woman, girl, boy)\n  // - Keycap sequences: 1\uFE0F\u20E3 (digit + variation selector + combining enclosing keycap)\n  //\n  // Why RGI? The Unicode Consortium recommends this subset for interchange because:\n  // - They have consistent rendering across platforms\n  // - They're widely supported\n  // - They follow a standardized format\n  //\n  // Non-RGI emoji might be symbols that look like emoji but render as 1 column.\n  emojiRegex = /^\\p{RGI_Emoji}$/v\n} catch {\n  // Fall back to 'u' flag (Node 18+) with slightly less accurate patterns.\n  //\n  // KEY DIFFERENCES from 'v' flag patterns:\n  // 1. No \\p{Surrogate} property - omitted from patterns\n  // 2. No \\p{RGI_Emoji} property - use \\p{Extended_Pictographic} instead\n  //\n  // \\p{Extended_Pictographic} is broader than \\p{RGI_Emoji}:\n  // - Includes emoji-like symbols that might render as 1 column\n  // - Less precise but better than nothing\n  // - Defined in Unicode Technical Standard #51\n  //\n  // The patterns are otherwise identical, just with \\p{Surrogate} removed\n  // and \\p{RGI_Emoji} replaced with \\p{Extended_Pictographic}.\n  zeroWidthClusterRegex =\n    /^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark})+$/u\n  leadingNonPrintingRegex =\n    /^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}]+/u\n  emojiRegex = /^\\p{Extended_Pictographic}$/u\n}\n\n/**\n * Get the visual width of a string in terminal columns.\n * Strips ANSI escape codes and accounts for wide characters.\n *\n * Based on string-width:\n * https://socket.dev/npm/package/string-width/overview/7.2.0\n * MIT License\n * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)\n *\n * Terminal emulators display characters in a grid of cells (columns).\n * Most ASCII characters take 1 column, but some characters (especially\n * emoji and CJK characters) take 2 columns.\n *\n * This function calculates how many columns a string will occupy when\n * displayed in a terminal, which is crucial for:\n * - Aligning text properly\n * - Preventing text from jumping when characters change\n * - Calculating padding/spacing\n *\n * Logic:\n * - Segment graphemes to match how terminals render clusters.\n * - Width rules:\n *   1. Skip non-printing clusters (Default_Ignorable, Control, pure Mark, lone Surrogates).\n *   2. RGI emoji clusters (\\p{RGI_Emoji}) are double-width.\n *   3. Otherwise use East Asian Width of the cluster's first visible code point.\n *   4. Add widths for trailing Halfwidth/Fullwidth Forms within the same cluster.\n *\n * East Asian Width categories (Unicode Standard Annex #11):\n * - F (Fullwidth): 2 columns - e.g., fullwidth Latin letters (\uFF21, \uFF22)\n * - W (Wide): 2 columns - e.g., CJK ideographs (\u6F22\u5B57), emoji (\u26A1, \uD83D\uDE00)\n * - H (Halfwidth): 1 column - e.g., halfwidth Katakana (\uFF71, \uFF72)\n * - Na (Narrow): 1 column - e.g., ASCII (a-z, 0-9)\n * - A (Ambiguous): Context-dependent, we treat as 1 column\n * - N (Neutral): 1 column - e.g., most symbols (\u2726, \u2727, \u22C6)\n *\n * Why this matters for Socket spinners:\n * - Lightning bolt (\u26A1) takes 2 columns\n * - Stars (\u2726, \u2727, \u22C6) take 1 column\n * - Without compensation, text jumps when frames change\n * - We use this to calculate padding for consistent alignment\n *\n * @example\n * stringWidth('hello') // => 5 (5 ASCII chars = 5 columns)\n * stringWidth('\u26A1') // => 2 (lightning bolt is wide)\n * stringWidth('\u2726') // => 1 (star is narrow)\n * stringWidth('\\x1b[31mred\\x1b[0m') // => 3 (ANSI codes stripped, 'red' = 3)\n *\n * @throws {TypeError} When input is not a string.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function stringWidth(text: string): number {\n  if (typeof text !== 'string' || !text.length) {\n    return 0\n  }\n\n  // Strip ANSI escape codes first (colors, bold, italic, etc.).\n  // These are invisible and don't contribute to visual width.\n  // Example: '\\x1b[31mred\\x1b[0m' becomes 'red'.\n  const plainText = stripAnsi(text)\n\n  if (!plainText.length) {\n    return 0\n  }\n\n  // KEY IMPROVEMENT #1: Proper Grapheme Cluster Segmentation\n  //\n  // Use the hoisted Intl.Segmenter instance (defined outside this function).\n  // See comments above for detailed explanation of grapheme cluster segmentation.\n\n  // KEY IMPROVEMENT #2: Feature Detection for Unicode Property Escapes\n  //\n  // Use the hoisted regex patterns (defined outside this function).\n  // See comments above for detailed explanation of feature detection and fallback patterns.\n\n  let width = 0\n\n  // Configure East Asian Width calculation.\n  // ambiguousAsWide: false - treat ambiguous-width characters as narrow (1 column).\n  //\n  // Ambiguous width characters (category 'A') include:\n  // - Greek letters: \u03B1, \u03B2, \u03B3\n  // - Cyrillic letters: \u0410, \u0411, \u0412\n  // - Box drawing characters: \u2500, \u2502, \u250C\n  //\n  // In East Asian contexts, these are often rendered as wide (2 columns).\n  // In Western contexts, they're typically narrow (1 column).\n  //\n  // We choose narrow (false) because:\n  // - Socket's primary audience is Western developers\n  // - Most terminal emulators default to narrow for ambiguous characters\n  // - Consistent with string-width's default behavior\n  const eastAsianWidthOptions = { ambiguousAsWide: false }\n\n  // KEY IMPROVEMENT #3: Comprehensive Width Calculation\n  //\n  // Segment the string into grapheme clusters and calculate width for each.\n  // This is the core algorithm that handles all the complexity of Unicode text rendering.\n  for (const { segment } of segmenter.segment(plainText)) {\n    // STEP 1: Skip zero-width / non-printing clusters\n    //\n    // These clusters contain only invisible characters that take no space.\n    // Examples:\n    // - '\\t' (tab) - Control character\n    // - '\\n' (newline) - Control character\n    // - '\\u200B' (zero-width space) - Default ignorable\n    // - Combining marks without base character\n    //\n    // Why skip? Terminals don't allocate columns for these characters.\n    // They're either control codes or modify adjacent characters without adding width.\n    if (zeroWidthClusterRegex.test(segment)) {\n      continue\n    }\n\n    // STEP 2: Handle emoji (double-width)\n    //\n    // RGI emoji are always rendered as double-width (2 columns) in terminals.\n    // This is true even for complex sequences:\n    // - \uD83D\uDC4D (basic emoji) = 2 columns\n    // - \uD83D\uDC4D\uD83C\uDFFD (emoji + skin tone modifier) = 2 columns (not 4!)\n    // - \uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66 (family ZWJ sequence) = 2 columns (not 14!)\n    //\n    // Why double-width? Historical reasons:\n    // - Emoji originated in Japanese mobile carriers\n    // - They were designed to match CJK character width\n    // - Terminal emulators inherited this behavior\n    //\n    // The key insight: The ENTIRE grapheme cluster is 2 columns, regardless\n    // of how many code points it contains. That's why we need Intl.Segmenter!\n    if (emojiRegex.test(segment)) {\n      width += 2\n      continue\n    }\n\n    // STEP 3: Use East Asian Width for everything else\n    //\n    // For non-emoji clusters, calculate width based on the first visible character.\n    //\n    // Why first visible character? In a grapheme cluster like \"\u00E9\" (e + combining acute),\n    // the base character 'e' determines the width, and the combining mark modifies it\n    // without adding width.\n    //\n    // Strip leading non-printing characters to find the base character.\n    // Example: If a cluster starts with format characters, skip them to find\n    // the actual visible character that determines width.\n    const baseSegment = segment.replace(leadingNonPrintingRegex, '')\n    const codePoint = baseSegment.codePointAt(0)\n\n    if (codePoint === undefined) {\n      // If no visible character remains after stripping non-printing chars, skip.\n      // This shouldn't happen if our zero-width regex is correct, but defensive programming.\n      continue\n    }\n\n    // Calculate width using East Asian Width property.\n    // This handles:\n    // - Narrow (1 column): ASCII a-z, A-Z, 0-9, most symbols\n    // - Wide (2 columns): CJK ideographs (\u6F22, \u5B57), fullwidth forms (\uFF21, \uFF22)\n    // - Halfwidth (1 column): Halfwidth Katakana (\uFF71, \uFF72, \uFF73)\n    // - Ambiguous (1 column per our config): Greek, Cyrillic, box drawing\n    width += eastAsianWidth(codePoint, eastAsianWidthOptions)\n\n    // STEP 4: Handle trailing Halfwidth and Fullwidth Forms\n    //\n    // The Halfwidth and Fullwidth Forms Unicode block (U+FF00-U+FFEF) contains\n    // compatibility characters for legacy East Asian encodings.\n    //\n    // Examples:\n    // - \uFF9E (U+FF9E) - Halfwidth Katakana voiced sound mark (dakuten)\n    // - \uFF9F (U+FF9F) - Halfwidth Katakana semi-voiced sound mark (handakuten)\n    // - \uFF70 (U+FF70) - Halfwidth Katakana-Hiragana prolonged sound mark\n    //\n    // These can appear as TRAILING characters in a grapheme cluster (not leading).\n    // When they do, they add their own width to the cluster.\n    //\n    // Example: A cluster might be [base character][dakuten]\n    // - Base character contributes its width (calculated above)\n    // - Dakuten contributes its width (calculated here)\n    //\n    // Why is this necessary? These forms are spacing characters, not combining marks.\n    // They occupy their own column(s) even when following another character.\n    //\n    // Note: We only check trailing characters (segment.slice(1)).\n    // The base character width was already calculated above.\n    if (segment.length > 1) {\n      for (const char of segment.slice(1)) {\n        const charCode = char.charCodeAt(0)\n        // Check if character is in Halfwidth and Fullwidth Forms range.\n        if (charCode >= 0xff_00 && charCode <= 0xff_ef) {\n          const trailingCodePoint = char.codePointAt(0)\n          if (trailingCodePoint !== undefined) {\n            // Add the East Asian Width of this trailing character.\n            // Most halfwidth forms contribute 1 column, fullwidth contribute 2.\n            width += eastAsianWidth(trailingCodePoint, eastAsianWidthOptions)\n          }\n        }\n      }\n    }\n  }\n\n  return width\n}\n\n/**\n * Convert a string to kebab-case (handles camelCase and snake_case).\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function toKebabCase(str: string): string {\n  if (!str.length) {\n    return str\n  }\n  return (\n    str\n      // Convert camelCase to kebab-case\n      .replace(/([a-z]+[0-9]*)([A-Z])/g, '$1-$2')\n      // Convert underscores to hyphens\n      .replace(/_/g, '-')\n      .toLowerCase()\n  )\n}\n\n/**\n * Trim newlines from the beginning and end of a string.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function trimNewlines(str: string): string {\n  const { length } = str\n  if (length === 0) {\n    return str\n  }\n  const first = str.charCodeAt(0)\n  const noFirstNewline = first !== 13 /*'\\r'*/ && first !== 10 /*'\\n'*/\n  if (length === 1) {\n    return noFirstNewline ? str : ''\n  }\n  const last = str.charCodeAt(length - 1)\n  const noLastNewline = last !== 13 /*'\\r'*/ && last !== 10 /*'\\n'*/\n  if (noFirstNewline && noLastNewline) {\n    return str\n  }\n  let start = 0\n  let end = length\n  while (start < end) {\n    const code = str.charCodeAt(start)\n    if (code !== 13 /*'\\r'*/ && code !== 10 /*'\\n'*/) {\n      break\n    }\n    start += 1\n  }\n  while (end > start) {\n    const code = str.charCodeAt(end - 1)\n    if (code !== 13 /*'\\r'*/ && code !== 10 /*'\\n'*/) {\n      break\n    }\n    end -= 1\n  }\n  return start === 0 && end === length ? str : str.slice(start, end)\n}\n\n/**\n * Repeat a string n times.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function repeatString(str: string, count: number): string {\n  if (count <= 0) {\n    return ''\n  }\n  return str.repeat(count)\n}\n\n/**\n * Center text within a given width.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function centerText(text: string, width: number): string {\n  const textLength = stripAnsi(text).length\n  if (textLength >= width) {\n    return text\n  }\n\n  const padding = width - textLength\n  const leftPad = Math.floor(padding / 2)\n  const rightPad = padding - leftPad\n\n  return ' '.repeat(leftPad) + text + ' '.repeat(rightPad)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/suppress-warnings.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Suppress MaxListenersExceededWarning messages.
+ * This is useful in tests or scripts where multiple listeners are expected.
+ *
+ * @example
+ * import { suppressMaxListenersWarning } from '@socketsecurity/registry/lib/suppress-warnings'
+ *
+ * suppressMaxListenersWarning()
+ */
+export declare function suppressMaxListenersWarning(): void;
+/**
+ * Suppress all process warnings of a specific type.
+ *
+ * @param warningType - The warning type to suppress (e.g., 'DeprecationWarning', 'ExperimentalWarning')
+ *
+ * @example
+ * import { suppressWarningType } from '@socketsecurity/registry/lib/suppress-warnings'
+ *
+ * suppressWarningType('ExperimentalWarning')
+ */
+export declare function suppressWarningType(warningType: string): void;
+/**
+ * Set max listeners on an EventTarget (like AbortSignal) to avoid TypeError.
+ *
+ * By manually setting `kMaxEventTargetListeners` on the target we avoid:
+ *   TypeError [ERR_INVALID_ARG_TYPE]: The "emitter" argument must be an
+ *   instance of EventEmitter or EventTarget. Received an instance of
+ *   AbortSignal
+ *
+ * in some patch releases of Node 18-23 when calling events.getMaxListeners().
+ * See https://github.com/nodejs/node/pull/56807.
+ *
+ * Instead of calling events.setMaxListeners(n, target) we set the symbol
+ * property directly to avoid depending on 'node:events' module.
+ *
+ * @param target - The EventTarget or AbortSignal to configure
+ * @param maxListeners - Maximum number of listeners (defaults to 10, the Node.js default)
+ *
+ * @example
+ * import { setMaxEventTargetListeners } from '@socketsecurity/registry/lib/suppress-warnings'
+ *
+ * const controller = new AbortController()
+ * setMaxEventTargetListeners(controller.signal)
+ */
+export declare function setMaxEventTargetListeners(target: EventTarget | AbortSignal | undefined, maxListeners?: number): void;
+/**
+ * Restore the original process.emitWarning function.
+ * Call this to re-enable all warnings after suppressing them.
+ */
+export declare function restoreWarnings(): void;
+/**
+ * Suppress warnings temporarily within a callback.
+ *
+ * @param warningType - The warning type to suppress
+ * @param callback - Function to execute with warnings suppressed
+ * @returns The result of the callback
+ *
+ * @example
+ * import { withSuppressedWarnings } from '@socketsecurity/registry/lib/suppress-warnings'
+ *
+ * const result = await withSuppressedWarnings('ExperimentalWarning', async () => {
+ *   // Code that triggers experimental warnings
+ *   return someValue
+ * })
+ */
+export declare function withSuppressedWarnings<T>(warningType: string, callback: () => T | Promise<T>): Promise<T>;