@socketsecurity/lib 3.2.3 → 3.2.5

package/dist/stdio/stderr.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/stdio/stderr.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Standard error stream utilities.\n * Provides utilities for writing to stderr with formatting and control.\n */\n\n// Get the actual stderr stream\nconst stderr: NodeJS.WriteStream = process.stderr\n\n/**\n * Write a line to stderr with trailing newline.\n * Used for error messages, warnings, and diagnostic output.\n *\n * @param text - Text to write\n * @default text ''\n *\n * @example\n * ```ts\n * writeErrorLine('Error: File not found')\n * writeErrorLine() // Write empty line\n * ```\n */\nexport function writeErrorLine(text: string = ''): void {\n  stderr.write(`${text}\\n`)\n}\n\n/**\n * Write text to stderr without adding a newline.\n *\n * @param text - Text to write\n *\n * @example\n * ```ts\n * writeError('Downloading...')\n * // Later update progress\n * ```\n */\nexport function writeError(text: string): void {\n  stderr.write(text)\n}\n\n/**\n * Clear the current line on stderr.\n * Only works in TTY environments.\n *\n * @example\n * ```ts\n * writeError('Processing...')\n * clearLine()\n * writeError('Done!')\n * ```\n */\nexport function clearLine(): void {\n  if (stderr.isTTY) {\n    stderr.cursorTo(0)\n    stderr.clearLine(0)\n  }\n}\n\n/**\n * Move cursor to specific position on stderr.\n * Only works in TTY environments.\n *\n * @param x - Column position (0-based)\n * @param y - Row position (0-based, optional)\n *\n * @example\n * ```ts\n * cursorTo(0) // Move to start of line\n * cursorTo(10, 5) // Move to column 10, row 5\n * ```\n */\nexport function cursorTo(x: number, y?: number | undefined): void {\n  if (stderr.isTTY) {\n    stderr.cursorTo(x, y)\n  }\n}\n\n/**\n * Check if stderr is connected to a TTY (terminal).\n *\n * @returns `true` if stderr is a TTY, `false` if piped/redirected\n *\n * @example\n * ```ts\n * if (isTTY()) {\n *   // Show colored error messages\n * } else {\n *   // Use plain text\n * }\n * ```\n */\nexport function isTTY(): boolean {\n  return stderr.isTTY || false\n}\n\n/**\n * Get the number of columns (width) in the terminal.\n *\n * @returns Terminal width in characters\n * @default 80\n *\n * @example\n * ```ts\n * const width = getColumns()\n * console.error(`Terminal is ${width} characters wide`)\n * ```\n */\nexport function getColumns(): number {\n  return stderr.columns || 80\n}\n\n/**\n * Get the number of rows (height) in the terminal.\n *\n * @returns Terminal height in lines\n * @default 24\n *\n * @example\n * ```ts\n * const height = getRows()\n * console.error(`Terminal is ${height} lines tall`)\n * ```\n */\nexport function getRows(): number {\n  return stderr.rows || 24\n}\n\n/**\n * Write a formatted warning message to stderr.\n *\n * @param message - Warning message text\n * @param prefix - Prefix label for the warning\n * @default prefix 'Warning'\n *\n * @example\n * ```ts\n * writeWarning('Deprecated API usage')\n * // Output: 'Warning: Deprecated API usage'\n *\n * writeWarning('Invalid config', 'Config')\n * // Output: 'Config: Invalid config'\n * ```\n */\nexport function writeWarning(\n  message: string,\n  prefix: string = 'Warning',\n): void {\n  const formatted = `${prefix}: ${message}`\n  writeErrorLine(formatted)\n}\n\n/**\n * Write a formatted error message to stderr.\n *\n * @param message - Error message text\n * @param prefix - Prefix label for the error\n * @default prefix 'Error'\n *\n * @example\n * ```ts\n * writeErrorFormatted('File not found')\n * // Output: 'Error: File not found'\n *\n * writeErrorFormatted('Connection failed', 'Network')\n * // Output: 'Network: Connection failed'\n * ```\n */\nexport function writeErrorFormatted(\n  message: string,\n  prefix: string = 'Error',\n): void {\n  const formatted = `${prefix}: ${message}`\n  writeErrorLine(formatted)\n}\n\n/**\n * Write an error's stack trace to stderr.\n * Falls back to formatted error message if no stack is available.\n *\n * @param error - Error object to write\n *\n * @example\n * ```ts\n * try {\n *   throw new Error('Something went wrong')\n * } catch (err) {\n *   writeStackTrace(err as Error)\n * }\n * ```\n */\nexport function writeStackTrace(error: Error): void {\n  if (error.stack) {\n    writeErrorLine(error.stack)\n  } else {\n    writeErrorFormatted(error.message)\n  }\n}\n\n// Export the raw stream for advanced usage\nexport { stderr }\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,MAAM,SAA6B,QAAQ;AAepC,SAAS,eAAe,OAAe,IAAU;AACtD,SAAO,MAAM,GAAG,IAAI;AAAA,CAAI;AAC1B;AAaO,SAAS,WAAW,MAAoB;AAC7C,SAAO,MAAM,IAAI;AACnB;AAaO,SAAS,YAAkB;AAChC,MAAI,OAAO,OAAO;AAChB,WAAO,SAAS,CAAC;AACjB,WAAO,UAAU,CAAC;AAAA,EACpB;AACF;AAeO,SAAS,SAAS,GAAW,GAA8B;AAChE,MAAI,OAAO,OAAO;AAChB,WAAO,SAAS,GAAG,CAAC;AAAA,EACtB;AACF;AAgBO,SAAS,QAAiB;AAC/B,SAAO,OAAO,SAAS;AACzB;AAcO,SAAS,aAAqB;AACnC,SAAO,OAAO,WAAW;AAC3B;AAcO,SAAS,UAAkB;AAChC,SAAO,OAAO,QAAQ;AACxB;AAkBO,SAAS,aACd,SACA,SAAiB,WACX;AACN,QAAM,YAAY,GAAG,MAAM,KAAK,OAAO;AACvC,iBAAe,SAAS;AAC1B;AAkBO,SAAS,oBACd,SACA,SAAiB,SACX;AACN,QAAM,YAAY,GAAG,MAAM,KAAK,OAAO;AACvC,iBAAe,SAAS;AAC1B;AAiBO,SAAS,gBAAgB,OAAoB;AAClD,MAAI,MAAM,OAAO;AACf,mBAAe,MAAM,KAAK;AAAA,EAC5B,OAAO;AACL,wBAAoB,MAAM,OAAO;AAAA,EACnC;AACF;",
-  "names": []
-}

package/dist/stdio/stdout.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/stdio/stdout.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Standard output stream utilities.\n * Provides utilities for writing to stdout with formatting and control.\n */\n\nimport { WriteStream } from 'tty'\n\n// Get the actual stdout stream\nconst stdout: NodeJS.WriteStream = process.stdout\n\n/**\n * Write a line to stdout with trailing newline.\n *\n * @param text - Text to write\n * @default text ''\n *\n * @example\n * ```ts\n * writeLine('Hello, world!')\n * writeLine() // Write empty line\n * ```\n */\nexport function writeLine(text: string = ''): void {\n  stdout.write(`${text}\\n`)\n}\n\n/**\n * Write text to stdout without adding a newline.\n *\n * @param text - Text to write\n *\n * @example\n * ```ts\n * write('Loading...')\n * // Later: clear and update\n * ```\n */\nexport function write(text: string): void {\n  stdout.write(text)\n}\n\n/**\n * Clear the current line on stdout.\n * Only works in TTY environments.\n *\n * @example\n * ```ts\n * write('Processing...')\n * clearLine()\n * write('Done!')\n * ```\n */\nexport function clearLine(): void {\n  if (stdout.isTTY) {\n    stdout.cursorTo(0)\n    stdout.clearLine(0)\n  }\n}\n\n/**\n * Move cursor to specific position on stdout.\n * Only works in TTY environments.\n *\n * @param x - Column position (0-based)\n * @param y - Row position (0-based, optional)\n *\n * @example\n * ```ts\n * cursorTo(0) // Move to start of line\n * cursorTo(10, 5) // Move to column 10, row 5\n * ```\n */\nexport function cursorTo(x: number, y?: number | undefined): void {\n  if (stdout.isTTY) {\n    stdout.cursorTo(x, y)\n  }\n}\n\n/**\n * Clear screen from cursor position down to bottom.\n * Only works in TTY environments.\n *\n * @example\n * ```ts\n * cursorTo(0, 5)\n * clearScreenDown() // Clear from row 5 to bottom\n * ```\n */\nexport function clearScreenDown(): void {\n  if (stdout.isTTY) {\n    stdout.clearScreenDown()\n  }\n}\n\n/**\n * Check if stdout is connected to a TTY (terminal).\n *\n * @returns `true` if stdout is a TTY, `false` if piped/redirected\n *\n * @example\n * ```ts\n * if (isTTY()) {\n *   // Show interactive UI\n * } else {\n *   // Use simple text output\n * }\n * ```\n */\nexport function isTTY(): boolean {\n  return stdout.isTTY || false\n}\n\n/**\n * Get the number of columns (width) in the terminal.\n *\n * @returns Terminal width in characters\n * @default 80\n *\n * @example\n * ```ts\n * const width = getColumns()\n * console.log(`Terminal is ${width} characters wide`)\n * ```\n */\nexport function getColumns(): number {\n  return stdout.columns || 80\n}\n\n/**\n * Get the number of rows (height) in the terminal.\n *\n * @returns Terminal height in lines\n * @default 24\n *\n * @example\n * ```ts\n * const height = getRows()\n * console.log(`Terminal is ${height} lines tall`)\n * ```\n */\nexport function getRows(): number {\n  return stdout.rows || 24\n}\n\n/**\n * Hide the cursor on stdout.\n * Useful for cleaner output during animations.\n *\n * @example\n * ```ts\n * hideCursor()\n * // Show animation\n * showCursor()\n * ```\n */\nexport function hideCursor(): void {\n  if (stdout.isTTY && stdout instanceof WriteStream) {\n    stdout.write('\\u001B[?25l')\n  }\n}\n\n/**\n * Show the cursor on stdout.\n * Should be called after `hideCursor()`.\n *\n * @example\n * ```ts\n * hideCursor()\n * // Show animation\n * showCursor()\n * ```\n */\nexport function showCursor(): void {\n  if (stdout.isTTY && stdout instanceof WriteStream) {\n    stdout.write('\\u001B[?25h')\n  }\n}\n\n/**\n * Register handlers to ensure cursor is shown on process exit.\n * Prevents hidden cursor after abnormal termination.\n * Handles SIGINT (Ctrl+C) and SIGTERM signals.\n *\n * @example\n * ```ts\n * ensureCursorOnExit()\n * hideCursor()\n * // Even if process crashes, cursor will be restored\n * ```\n */\nexport function ensureCursorOnExit(): void {\n  process.on('exit', showCursor)\n  process.on('SIGINT', () => {\n    showCursor()\n    // eslint-disable-next-line n/no-process-exit\n    process.exit(130)\n  })\n  process.on('SIGTERM', () => {\n    showCursor()\n    // eslint-disable-next-line n/no-process-exit\n    process.exit(143)\n  })\n}\n\n// Export the raw stream for advanced usage\nexport { stdout }\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,iBAA4B;AAG5B,MAAM,SAA6B,QAAQ;AAcpC,SAAS,UAAU,OAAe,IAAU;AACjD,SAAO,MAAM,GAAG,IAAI;AAAA,CAAI;AAC1B;AAaO,SAAS,MAAM,MAAoB;AACxC,SAAO,MAAM,IAAI;AACnB;AAaO,SAAS,YAAkB;AAChC,MAAI,OAAO,OAAO;AAChB,WAAO,SAAS,CAAC;AACjB,WAAO,UAAU,CAAC;AAAA,EACpB;AACF;AAeO,SAAS,SAAS,GAAW,GAA8B;AAChE,MAAI,OAAO,OAAO;AAChB,WAAO,SAAS,GAAG,CAAC;AAAA,EACtB;AACF;AAYO,SAAS,kBAAwB;AACtC,MAAI,OAAO,OAAO;AAChB,WAAO,gBAAgB;AAAA,EACzB;AACF;AAgBO,SAAS,QAAiB;AAC/B,SAAO,OAAO,SAAS;AACzB;AAcO,SAAS,aAAqB;AACnC,SAAO,OAAO,WAAW;AAC3B;AAcO,SAAS,UAAkB;AAChC,SAAO,OAAO,QAAQ;AACxB;AAaO,SAAS,aAAmB;AACjC,MAAI,OAAO,SAAS,kBAAkB,wBAAa;AACjD,WAAO,MAAM,WAAa;AAAA,EAC5B;AACF;AAaO,SAAS,aAAmB;AACjC,MAAI,OAAO,SAAS,kBAAkB,wBAAa;AACjD,WAAO,MAAM,WAAa;AAAA,EAC5B;AACF;AAcO,SAAS,qBAA2B;AACzC,UAAQ,GAAG,QAAQ,UAAU;AAC7B,UAAQ,GAAG,UAAU,MAAM;AACzB,eAAW;AAEX,YAAQ,KAAK,GAAG;AAAA,EAClB,CAAC;AACD,UAAQ,GAAG,WAAW,MAAM;AAC1B,eAAW;AAEX,YAAQ,KAAK,GAAG;AAAA,EAClB,CAAC;AACH;",
-  "names": []
-}

package/dist/streams.js.map

@@ -1,7 +0,0 @@
-{
-  "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,gCAAgC;AAAA,EAC9E;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.js.map

@@ -1,7 +0,0 @@
-{
-  "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  /**\n   * The prefix to add to each line.\n   * @default ''\n   */\n  prefix?: string | undefined\n}\n\n/**\n * Apply a prefix to each line of a string.\n *\n * Prepends the specified prefix to the beginning of each line in the input string.\n * If the string contains newlines, the prefix is added after each newline as well.\n * When no prefix is provided or prefix is empty, returns the original string unchanged.\n *\n * @param str - The string to add prefixes to\n * @param options - Configuration options\n * @returns The string with prefix applied to each line\n *\n * @example\n * ```ts\n * applyLinePrefix('hello\\nworld', { prefix: '> ' })\n * // Returns: '> hello\\n> world'\n *\n * applyLinePrefix('single line', { prefix: '  ' })\n * // Returns: '  single line'\n *\n * applyLinePrefix('no prefix')\n * // Returns: 'no prefix'\n * ```\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 * Transforms camelCase strings by converting uppercase letters to lowercase\n * and inserting hyphens before uppercase sequences. Handles consecutive\n * uppercase letters (like \"XMLHttpRequest\") by treating them as a single word.\n * Returns empty string for empty input.\n *\n * Note: This function only handles camelCase. For mixed formats including\n * snake_case, use `toKebabCase()` instead.\n *\n * @param str - The camelCase string to convert\n * @returns The kebab-case string\n *\n * @example\n * ```ts\n * camelToKebab('helloWorld')\n * // Returns: 'hello-world'\n *\n * camelToKebab('XMLHttpRequest')\n * // Returns: 'xmlhttprequest'\n *\n * camelToKebab('iOS')\n * // Returns: 'ios'\n *\n * camelToKebab('')\n * // Returns: ''\n * ```\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  /**\n   * Number of spaces to indent each line.\n   * @default 1\n   */\n  count?: number | undefined\n}\n\n/**\n * Indent each line of a string with spaces.\n *\n * Adds the specified number of spaces to the beginning of each non-empty line\n * in the input string. Empty lines (containing only whitespace) are not indented.\n * Uses a regular expression to efficiently handle multi-line strings.\n *\n * @param str - The string to indent\n * @param options - Configuration options\n * @returns The indented string\n *\n * @example\n * ```ts\n * indentString('hello\\nworld', { count: 2 })\n * // Returns: '  hello\\n  world'\n *\n * indentString('line1\\n\\nline3', { count: 4 })\n * // Returns: '    line1\\n\\n    line3'\n *\n * indentString('single line')\n * // Returns: ' single line' (default: 1 space)\n * ```\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 * A blank string is defined as a string that is either:\n * - Completely empty (length 0)\n * - Contains only whitespace characters (spaces, tabs, newlines, etc.)\n *\n * This is useful for validation when you need to ensure user input\n * contains actual content, not just whitespace.\n *\n * @param value - The value to check\n * @returns `true` if the value is a blank string, `false` otherwise\n *\n * @example\n * ```ts\n * isBlankString('')\n * // Returns: true\n *\n * isBlankString('   ')\n * // Returns: true\n *\n * isBlankString('\\n\\t  ')\n * // Returns: true\n *\n * isBlankString('hello')\n * // Returns: false\n *\n * isBlankString(null)\n * // Returns: false\n * ```\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 * Returns `true` only if the value is a string with at least one character.\n * This includes strings containing only whitespace (use `isBlankString()` if\n * you want to exclude those). Type guard ensures TypeScript knows the value\n * is a string after this check.\n *\n * @param value - The value to check\n * @returns `true` if the value is a non-empty string, `false` otherwise\n *\n * @example\n * ```ts\n * isNonEmptyString('hello')\n * // Returns: true\n *\n * isNonEmptyString('   ')\n * // Returns: true (contains whitespace)\n *\n * isNonEmptyString('')\n * // Returns: false\n *\n * isNonEmptyString(null)\n * // Returns: false\n *\n * isNonEmptyString(123)\n * // Returns: false\n * ```\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  /**\n   * The position in the string to begin searching from.\n   * Negative values count back from the end of the string.\n   * @default 0\n   */\n  fromIndex?: number | undefined\n}\n\n/**\n * Search for a regular expression in a string starting from an index.\n *\n * Similar to `String.prototype.search()` but allows specifying a starting\n * position. Returns the index of the first match at or after `fromIndex`,\n * or -1 if no match is found. Negative `fromIndex` values count back from\n * the end of the string.\n *\n * This is more efficient than using `str.slice(fromIndex).search()` when\n * you need the absolute position in the original string, as it handles\n * the offset calculation for you.\n *\n * @param str - The string to search in\n * @param regexp - The regular expression to search for\n * @param options - Configuration options\n * @returns The index of the first match, or -1 if not found\n *\n * @example\n * ```ts\n * search('hello world hello', /hello/, { fromIndex: 0 })\n * // Returns: 0 (first 'hello')\n *\n * search('hello world hello', /hello/, { fromIndex: 6 })\n * // Returns: 12 (second 'hello')\n *\n * search('hello world', /goodbye/, { fromIndex: 0 })\n * // Returns: -1 (not found)\n *\n * search('hello world', /hello/, { fromIndex: -5 })\n * // Returns: -1 (starts searching from 'world', no match)\n * ```\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 * The BOM (U+FEFF) is a Unicode character that can appear at the start of\n * a text file to indicate byte order and encoding. In UTF-16 (JavaScript's\n * internal string representation), it appears as 0xFEFF. This function\n * removes it if present, leaving the rest of the string unchanged.\n *\n * Most text processing doesn't need to handle the BOM explicitly, but it\n * can cause issues when parsing JSON, CSV, or other structured data formats\n * that don't expect a leading invisible character.\n *\n * @param str - The string to strip BOM from\n * @returns The string without BOM\n *\n * @example\n * ```ts\n * stripBom('\\uFEFFhello world')\n * // Returns: 'hello world'\n *\n * stripBom('hello world')\n * // Returns: 'hello world' (no BOM to strip)\n *\n * stripBom('')\n * // Returns: ''\n * ```\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 *\n * Calculates how many columns a string will occupy when displayed in a terminal,\n * accounting for:\n * - ANSI escape codes (stripped before calculation)\n * - Wide characters (CJK ideographs, fullwidth forms) that take 2 columns\n * - Emoji (including complex sequences) that take 2 columns\n * - Combining marks and zero-width characters (take 0 columns)\n * - East Asian Width properties (Fullwidth, Wide, Halfwidth, Narrow, etc.)\n *\n * Based on string-width by Sindre Sorhus:\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. This function calculates\n * the actual visual width, which is crucial for:\n * - Aligning text properly in tables or columns\n * - Preventing text from jumping when characters change\n * - Calculating padding/spacing for spinners and progress bars\n * - Wrapping text at the correct column width\n *\n * Algorithm Overview:\n * 1. Strip ANSI escape codes (invisible in terminal)\n * 2. Segment into grapheme clusters (user-perceived characters)\n * 3. For each cluster:\n *    - Skip zero-width/non-printing clusters (width = 0)\n *    - RGI emoji clusters are double-width (width = 2)\n *    - Otherwise use East Asian Width of first visible code point\n *    - Add width for trailing Halfwidth/Fullwidth Forms\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, treated as 1 column by default\n * - N (Neutral): 1 column - e.g., most symbols (\u2726, \u2727, \u22C6)\n *\n * Why This Matters for Socket:\n * - Lightning bolt (\u26A1) takes 2 columns\n * - Stars (\u2726, \u2727, \u22C6) take 1 column\n * - Without proper width calculation, spinner text jumps between frames\n * - This function enables consistent alignment by calculating padding\n *\n * @param text - The string to measure\n * @returns The visual width in terminal columns\n *\n * @example\n * ```ts\n * stringWidth('hello')\n * // Returns: 5 (5 ASCII chars = 5 columns)\n *\n * stringWidth('\u26A1')\n * // Returns: 2 (lightning bolt is wide)\n *\n * stringWidth('\u2726')\n * // Returns: 1 (star is narrow)\n *\n * stringWidth('\u6F22\u5B57')\n * // Returns: 4 (2 CJK characters \u00D7 2 columns each)\n *\n * stringWidth('\\x1b[31mred\\x1b[0m')\n * // Returns: 3 (ANSI codes stripped, 'red' = 3)\n *\n * stringWidth('\uD83D\uDC4D\uD83C\uDFFD')\n * // Returns: 2 (emoji with skin tone = 1 grapheme cluster = 2 columns)\n *\n * stringWidth('\u00E9')\n * // Returns: 1 (combining accent doesn't add width)\n *\n * stringWidth('')\n * // Returns: 0\n * ```\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 * Transforms strings from camelCase or snake_case to kebab-case by:\n * - Converting uppercase letters to lowercase\n * - Inserting hyphens before uppercase letters (for camelCase)\n * - Replacing underscores with hyphens (for snake_case)\n *\n * This is more comprehensive than `camelToKebab()` as it handles mixed\n * formats including snake_case. Returns empty string for empty input.\n *\n * @param str - The string to convert\n * @returns The kebab-case string\n *\n * @example\n * ```ts\n * toKebabCase('helloWorld')\n * // Returns: 'hello-world'\n *\n * toKebabCase('hello_world')\n * // Returns: 'hello-world'\n *\n * toKebabCase('XMLHttpRequest')\n * // Returns: 'xmlhttp-request'\n *\n * toKebabCase('iOS_Version')\n * // Returns: 'io-s-version'\n *\n * toKebabCase('')\n * // Returns: ''\n * ```\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 * Removes all leading and trailing newline characters (both `\\n` and `\\r`)\n * from a string, while preserving any newlines in the middle. This is similar\n * to `String.prototype.trim()` but specifically targets newlines instead of\n * all whitespace.\n *\n * Optimized for performance by checking the first and last characters before\n * doing any string manipulation. Returns the original string unchanged if no\n * newlines are found at the edges.\n *\n * @param str - The string to trim\n * @returns The string with leading and trailing newlines removed\n *\n * @example\n * ```ts\n * trimNewlines('\\n\\nhello\\n\\n')\n * // Returns: 'hello'\n *\n * trimNewlines('\\r\\nworld\\r\\n')\n * // Returns: 'world'\n *\n * trimNewlines('hello\\nworld')\n * // Returns: 'hello\\nworld' (middle newline preserved)\n *\n * trimNewlines('  hello  ')\n * // Returns: '  hello  ' (spaces not trimmed, only newlines)\n *\n * trimNewlines('hello')\n * // Returns: 'hello'\n * ```\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 * Creates a new string by repeating the input string the specified number of times.\n * Returns an empty string if count is zero or negative. This is a simple wrapper\n * around `String.prototype.repeat()` with guard for non-positive counts.\n *\n * @param str - The string to repeat\n * @param count - The number of times to repeat the string\n * @returns The repeated string, or empty string if count <= 0\n *\n * @example\n * ```ts\n * repeatString('hello', 3)\n * // Returns: 'hellohellohello'\n *\n * repeatString('x', 5)\n * // Returns: 'xxxxx'\n *\n * repeatString('hello', 0)\n * // Returns: ''\n *\n * repeatString('hello', -1)\n * // Returns: ''\n * ```\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 * Adds spaces before and after the text to center it within the specified width.\n * Distributes padding evenly on both sides. When the padding is odd, the extra\n * space is added to the right side. Strips ANSI codes before calculating text\n * length to ensure accurate centering of colored text.\n *\n * If the text is already wider than or equal to the target width, returns the\n * original text unchanged (no truncation occurs).\n *\n * @param text - The text to center (may include ANSI codes)\n * @param width - The target width in columns\n * @returns The centered text with padding\n *\n * @example\n * ```ts\n * centerText('hello', 11)\n * // Returns: '   hello   ' (3 spaces on each side)\n *\n * centerText('hi', 10)\n * // Returns: '    hi    ' (4 spaces on each side)\n *\n * centerText('odd', 8)\n * // Returns: '  odd   ' (2 left, 3 right)\n *\n * centerText('\\x1b[31mred\\x1b[0m', 7)\n * // Returns: '  \\x1b[31mred\\x1b[0m  ' (ANSI codes preserved, 'red' centered)\n *\n * centerText('too long text', 5)\n * // Returns: 'too long text' (no truncation, returned as-is)\n * ```\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.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/suppress-warnings.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Utilities to suppress specific process warnings.\n */\n\nconst { apply: ReflectApply } = Reflect\n\n// Store the original emitWarning function to avoid repeat wrapping.\nlet originalEmitWarning: typeof process.emitWarning | undefined\n\n// Track which warning types are currently suppressed.\nconst suppressedWarnings = new Set<string>()\n\n/**\n * Internal function to set up warning suppression.\n * Only wraps process.emitWarning once, regardless of how many times it's called.\n */\nfunction setupSuppression(): void {\n  // Only wrap once - store the original on first call.\n  if (!originalEmitWarning) {\n    originalEmitWarning = process.emitWarning\n    process.emitWarning = (warning: string | Error, ...args: any[]) => {\n      // Check both string warnings and warning objects.\n      if (typeof warning === 'string') {\n        // Check if any suppressed warning type matches.\n        for (const suppressedType of suppressedWarnings) {\n          if (warning.includes(suppressedType)) {\n            return\n          }\n        }\n      } else if (warning && typeof warning === 'object') {\n        const warningObj = warning as { name?: string }\n        if (warningObj.name && suppressedWarnings.has(warningObj.name)) {\n          return\n        }\n      }\n      // Not suppressed - call the original function.\n      return ReflectApply(\n        originalEmitWarning as typeof process.emitWarning,\n        process,\n        [warning, ...args],\n      )\n    }\n  }\n}\n\n/**\n * Suppress MaxListenersExceededWarning messages.\n * This is useful in tests or scripts where multiple listeners are expected.\n *\n * @example\n * import { suppressMaxListenersWarning } from '@socketsecurity/lib/suppress-warnings'\n *\n * suppressMaxListenersWarning()\n */\nexport function suppressMaxListenersWarning(): void {\n  suppressedWarnings.add('MaxListenersExceededWarning')\n  setupSuppression()\n}\n\n/**\n * Suppress all process warnings of a specific type.\n *\n * @param warningType - The warning type to suppress (e.g., 'DeprecationWarning', 'ExperimentalWarning')\n *\n * @example\n * import { suppressWarningType } from '@socketsecurity/lib/suppress-warnings'\n *\n * suppressWarningType('ExperimentalWarning')\n */\nexport function suppressWarningType(warningType: string): void {\n  suppressedWarnings.add(warningType)\n  setupSuppression()\n}\n\n/**\n * Set max listeners on an EventTarget (like AbortSignal) to avoid TypeError.\n *\n * By manually setting `kMaxEventTargetListeners` on the target we avoid:\n *   TypeError [ERR_INVALID_ARG_TYPE]: The \"emitter\" argument must be an\n *   instance of EventEmitter or EventTarget. Received an instance of\n *   AbortSignal\n *\n * in some patch releases of Node 18-23 when calling events.getMaxListeners().\n * See https://github.com/nodejs/node/pull/56807.\n *\n * Instead of calling events.setMaxListeners(n, target) we set the symbol\n * property directly to avoid depending on 'node:events' module.\n *\n * @param target - The EventTarget or AbortSignal to configure\n * @param maxListeners - Maximum number of listeners (defaults to 10, the Node.js default)\n *\n * @example\n * import { setMaxEventTargetListeners } from '@socketsecurity/lib/suppress-warnings'\n *\n * const controller = new AbortController()\n * setMaxEventTargetListeners(controller.signal)\n */\nexport function setMaxEventTargetListeners(\n  target: EventTarget | AbortSignal | undefined,\n  maxListeners: number = 10,\n): void {\n  if (!target) {\n    return\n  }\n  const symbols = Object.getOwnPropertySymbols(target)\n  const kMaxEventTargetListeners = symbols.find(\n    s => s.description === 'events.maxEventTargetListeners',\n  )\n  if (kMaxEventTargetListeners) {\n    // The default events.defaultMaxListeners value is 10.\n    // https://nodejs.org/api/events.html#eventsdefaultmaxlisteners\n    ;(target as any)[kMaxEventTargetListeners] = maxListeners\n  }\n}\n\n/**\n * Restore the original process.emitWarning function.\n * Call this to re-enable all warnings after suppressing them.\n */\nexport function restoreWarnings(): void {\n  if (originalEmitWarning) {\n    process.emitWarning = originalEmitWarning\n    originalEmitWarning = undefined\n    suppressedWarnings.clear()\n  }\n}\n\n/**\n * Suppress warnings temporarily within a callback.\n *\n * @param warningType - The warning type to suppress\n * @param callback - Function to execute with warnings suppressed\n * @returns The result of the callback\n *\n * @example\n * import { withSuppressedWarnings } from '@socketsecurity/lib/suppress-warnings'\n *\n * const result = await withSuppressedWarnings('ExperimentalWarning', async () => {\n *   // Code that triggers experimental warnings\n *   return someValue\n * })\n */\nexport async function withSuppressedWarnings<T>(\n  warningType: string,\n  callback: () => T | Promise<T>,\n): Promise<T> {\n  const original = process.emitWarning\n  suppressWarningType(warningType)\n  try {\n    return await callback()\n  } finally {\n    process.emitWarning = original\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,MAAM,EAAE,OAAO,aAAa,IAAI;AAGhC,IAAI;AAGJ,MAAM,qBAAqB,oBAAI,IAAY;AAM3C,SAAS,mBAAyB;AAEhC,MAAI,CAAC,qBAAqB;AACxB,0BAAsB,QAAQ;AAC9B,YAAQ,cAAc,CAAC,YAA4B,SAAgB;AAEjE,UAAI,OAAO,YAAY,UAAU;AAE/B,mBAAW,kBAAkB,oBAAoB;AAC/C,cAAI,QAAQ,SAAS,cAAc,GAAG;AACpC;AAAA,UACF;AAAA,QACF;AAAA,MACF,WAAW,WAAW,OAAO,YAAY,UAAU;AACjD,cAAM,aAAa;AACnB,YAAI,WAAW,QAAQ,mBAAmB,IAAI,WAAW,IAAI,GAAG;AAC9D;AAAA,QACF;AAAA,MACF;AAEA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA,CAAC,SAAS,GAAG,IAAI;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AACF;AAWO,SAAS,8BAAoC;AAClD,qBAAmB,IAAI,6BAA6B;AACpD,mBAAiB;AACnB;AAYO,SAAS,oBAAoB,aAA2B;AAC7D,qBAAmB,IAAI,WAAW;AAClC,mBAAiB;AACnB;AAyBO,SAAS,2BACd,QACA,eAAuB,IACjB;AACN,MAAI,CAAC,QAAQ;AACX;AAAA,EACF;AACA,QAAM,UAAU,OAAO,sBAAsB,MAAM;AACnD,QAAM,2BAA2B,QAAQ;AAAA,IACvC,OAAK,EAAE,gBAAgB;AAAA,EACzB;AACA,MAAI,0BAA0B;AAG5B;AAAC,IAAC,OAAe,wBAAwB,IAAI;AAAA,EAC/C;AACF;AAMO,SAAS,kBAAwB;AACtC,MAAI,qBAAqB;AACvB,YAAQ,cAAc;AACtB,0BAAsB;AACtB,uBAAmB,MAAM;AAAA,EAC3B;AACF;AAiBA,eAAsB,uBACpB,aACA,UACY;AACZ,QAAM,WAAW,QAAQ;AACzB,sBAAoB,WAAW;AAC/B,MAAI;AACF,WAAO,MAAM,SAAS;AAAA,EACxB,UAAE;AACA,YAAQ,cAAc;AAAA,EACxB;AACF;",
-  "names": []
-}

package/dist/tables.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/tables.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Table formatting utilities for CLI applications.\n * Provides ASCII table rendering with borders, alignment, and colors.\n */\n\nimport colors from './external/yoctocolors-cjs'\nimport { stripAnsi } from './strings'\n\nexport type ColumnAlignment = 'left' | 'right' | 'center'\n\n/**\n * Table column configuration.\n */\nexport type TableColumn = {\n  key: string\n  header: string\n  align?: ColumnAlignment | undefined\n  width?: number | undefined\n  color?: ((value: string) => string) | undefined\n}\n\n/**\n * Calculate display width accounting for ANSI codes.\n */\nfunction displayWidth(text: string): number {\n  return stripAnsi(text).length\n}\n\n/**\n * Pad text to specified width with alignment.\n */\nfunction padText(\n  text: string,\n  width: number,\n  align: ColumnAlignment = 'left',\n): string {\n  const stripped = stripAnsi(text)\n  const textWidth = stripped.length\n  const padding = Math.max(0, width - textWidth)\n\n  switch (align) {\n    case 'right':\n      return ' '.repeat(padding) + text\n    case 'center': {\n      const leftPad = Math.floor(padding / 2)\n      const rightPad = padding - leftPad\n      return ' '.repeat(leftPad) + text + ' '.repeat(rightPad)\n    }\n    default:\n      return text + ' '.repeat(padding)\n  }\n}\n\n/**\n * Format data as an ASCII table with borders.\n *\n * @param data - Array of data objects\n * @param columns - Column configuration\n * @returns Formatted table string\n *\n * @example\n * import { formatTable } from '@socketsecurity/lib/tables'\n * import colors from 'yoctocolors-cjs'\n *\n * const data = [\n *   { name: 'lodash', version: '4.17.21', issues: 0 },\n *   { name: 'react', version: '18.2.0', issues: 2 },\n * ]\n * const columns = [\n *   { key: 'name', header: 'Package' },\n *   { key: 'version', header: 'Version', align: 'center' },\n *   { key: 'issues', header: 'Issues', align: 'right', color: (v) => v === '0' ? colors.green(v) : colors.red(v) },\n * ]\n * console.log(formatTable(data, columns))\n * // Output:\n * // \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n * // \u2502 Package \u2502 Version \u2502 Issues \u2502\n * // \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524\n * // \u2502 lodash  \u2502 4.17.21 \u2502      0 \u2502\n * // \u2502 react   \u2502 18.2.0  \u2502      2 \u2502\n * // \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n */\nexport function formatTable(\n  data: Array<Record<string, unknown>>,\n  columns: TableColumn[],\n): string {\n  if (data.length === 0) {\n    return '(no data)'\n  }\n\n  // Calculate column widths\n  const widths = columns.map(col => {\n    const headerWidth = displayWidth(col.header)\n    const maxDataWidth = Math.max(\n      ...data.map(row => displayWidth(String(row[col.key] ?? ''))),\n    )\n    return col.width ?? Math.max(headerWidth, maxDataWidth)\n  })\n\n  const lines: string[] = []\n\n  // Top border\n  const topBorder = `\u250C\u2500${widths.map(w => '\u2500'.repeat(w)).join('\u2500\u252C\u2500')}\u2500\u2510`\n  lines.push(colors.dim(topBorder))\n\n  // Header row\n  const headerCells = columns.map((col, i) => {\n    const text = colors.bold(col.header)\n    return padText(text, widths[i] as number, col.align)\n  })\n  lines.push(\n    colors.dim('\u2502 ') + headerCells.join(colors.dim(' \u2502 ')) + colors.dim(' \u2502'),\n  )\n\n  // Header separator\n  const headerSep = `\u251C\u2500${widths.map(w => '\u2500'.repeat(w)).join('\u2500\u253C\u2500')}\u2500\u2524`\n  lines.push(colors.dim(headerSep))\n\n  // Data rows\n  for (const row of data) {\n    const cells = columns.map((col, i) => {\n      let value = String(row[col.key] ?? '')\n      if (col.color) {\n        value = col.color(value)\n      }\n      return padText(value, widths[i] as number, col.align)\n    })\n    lines.push(\n      colors.dim('\u2502 ') + cells.join(colors.dim(' \u2502 ')) + colors.dim(' \u2502'),\n    )\n  }\n\n  // Bottom border\n  const bottomBorder = `\u2514\u2500${widths.map(w => '\u2500'.repeat(w)).join('\u2500\u2534\u2500')}\u2500\u2518`\n  lines.push(colors.dim(bottomBorder))\n\n  return lines.join('\\n')\n}\n\n/**\n * Format data as a simple table without borders.\n * Lighter weight alternative to formatTable().\n *\n * @param data - Array of data objects\n * @param columns - Column configuration\n * @returns Formatted table string\n *\n * @example\n * import { formatSimpleTable } from '@socketsecurity/lib/tables'\n * import colors from 'yoctocolors-cjs'\n *\n * const data = [\n *   { name: 'lodash', version: '4.17.21' },\n *   { name: 'react', version: '18.2.0' },\n * ]\n * const columns = [\n *   { key: 'name', header: 'Package' },\n *   { key: 'version', header: 'Version' },\n * ]\n * console.log(formatSimpleTable(data, columns))\n * // Output:\n * // Package  Version\n * // \u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n * // lodash   4.17.21\n * // react    18.2.0\n */\nexport function formatSimpleTable(\n  data: Array<Record<string, unknown>>,\n  columns: TableColumn[],\n): string {\n  if (data.length === 0) {\n    return '(no data)'\n  }\n\n  // Calculate column widths\n  const widths = columns.map(col => {\n    const headerWidth = displayWidth(col.header)\n    const maxDataWidth = Math.max(\n      ...data.map(row => displayWidth(String(row[col.key] ?? ''))),\n    )\n    return col.width ?? Math.max(headerWidth, maxDataWidth)\n  })\n\n  const lines: string[] = []\n\n  // Header row\n  const headerCells = columns.map((col, i) =>\n    padText(colors.bold(col.header), widths[i] as number, col.align),\n  )\n  lines.push(headerCells.join('  '))\n\n  // Header separator\n  const separators = widths.map(w => colors.dim('\u2500'.repeat(w)))\n  lines.push(separators.join('  '))\n\n  // Data rows\n  for (const row of data) {\n    const cells = columns.map((col, i) => {\n      let value = String(row[col.key] ?? '')\n      if (col.color) {\n        value = col.color(value)\n      }\n      return padText(value, widths[i] as number, col.align)\n    })\n    lines.push(cells.join('  '))\n  }\n\n  return lines.join('\\n')\n}\n"],
-  "mappings": "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",
-  "names": ["colors"]
-}

package/dist/temporary-executor.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/temporary-executor.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Temporary package executor detection utilities for Socket ecosystem.\n * Identifies and handles temporary execution contexts such as npx, pnpm dlx, and yarn dlx.\n */\n\nimport { WIN32 } from '#constants/platform'\nimport { normalizePath } from './path'\n\n/**\n * Detects if the current process is running in a temporary package execution context\n * such as npm exec, npx, pnpm dlx, or yarn dlx.\n *\n * When package managers run commands via exec/npx/dlx, they execute in temporary directories\n * that are cleaned up after execution. Creating persistent shadows or modifying PATH\n * in these contexts can break subsequent package manager commands.\n */\nexport function isRunningInTemporaryExecutor(cwd = process.cwd()): boolean {\n  // Check environment variable for exec/npx/dlx indicators.\n  const userAgent = process.env['npm_config_user_agent']\n  if (\n    userAgent?.includes('exec') ||\n    userAgent?.includes('npx') ||\n    userAgent?.includes('dlx')\n  ) {\n    return true\n  }\n\n  // Normalize the cwd path for consistent checking across platforms.\n  const normalizedCwd = normalizePath(cwd)\n\n  // Check if running from npm's npx cache.\n  const npmCache = process.env['npm_config_cache']\n  if (npmCache && normalizedCwd.includes(normalizePath(npmCache))) {\n    return true\n  }\n\n  // Check common temporary execution path patterns.\n  const tempPatterns = [\n    // npm's npx cache directory\n    '_npx',\n    // pnpm dlx temporary store\n    '.pnpm-store',\n    // Common dlx directory prefix\n    'dlx-',\n    // Yarn Berry PnP virtual packages.\n    '.yarn/$$',\n  ]\n\n  // Yarn on Windows uses AppData/Local/Temp/xfs- pattern.\n  if (WIN32) {\n    tempPatterns.push('AppData/Local/Temp/xfs-')\n  }\n\n  return tempPatterns.some(pattern => normalizedCwd.includes(pattern))\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,sBAAsB;AACtB,kBAA8B;AAUvB,SAAS,6BAA6B,MAAM,QAAQ,IAAI,GAAY;AAEzE,QAAM,YAAY,QAAQ,IAAI,uBAAuB;AACrD,MACE,WAAW,SAAS,MAAM,KAC1B,WAAW,SAAS,KAAK,KACzB,WAAW,SAAS,KAAK,GACzB;AACA,WAAO;AAAA,EACT;AAGA,QAAM,oBAAgB,2BAAc,GAAG;AAGvC,QAAM,WAAW,QAAQ,IAAI,kBAAkB;AAC/C,MAAI,YAAY,cAAc,aAAS,2BAAc,QAAQ,CAAC,GAAG;AAC/D,WAAO;AAAA,EACT;AAGA,QAAM,eAAe;AAAA;AAAA,IAEnB;AAAA;AAAA,IAEA;AAAA;AAAA,IAEA;AAAA;AAAA,IAEA;AAAA,EACF;AAGA,MAAI,uBAAO;AACT,iBAAa,KAAK,yBAAyB;AAAA,EAC7C;AAEA,SAAO,aAAa,KAAK,aAAW,cAAc,SAAS,OAAO,CAAC;AACrE;",
-  "names": []
-}

package/dist/themes/context.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/themes/context.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Elegant theme context management.\n * Async-aware theming with automatic context isolation via AsyncLocalStorage.\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks'\n\nimport type { Theme } from './types'\nimport { SOCKET_THEME, THEMES, type ThemeName } from './themes'\n\n/**\n * Theme change event listener signature.\n */\nexport type ThemeChangeListener = (theme: Theme) => void\n\n/**\n * AsyncLocalStorage for theme context isolation.\n */\nconst themeStorage = new AsyncLocalStorage<Theme>()\n\n/**\n * Fallback theme for global context.\n */\nlet fallbackTheme: Theme = SOCKET_THEME\n\n/**\n * Registered theme change listeners.\n */\nconst listeners: Set<ThemeChangeListener> = new Set()\n\n/**\n * Set the global fallback theme.\n *\n * @param theme - Theme name or object\n *\n * @example\n * ```ts\n * setTheme('socket-firewall')\n * ```\n */\nexport function setTheme(theme: Theme | ThemeName): void {\n  fallbackTheme = typeof theme === 'string' ? THEMES[theme] : theme\n  emitThemeChange(fallbackTheme)\n}\n\n/**\n * Get the active theme from context.\n *\n * @returns Current theme\n *\n * @example\n * ```ts\n * const theme = getTheme()\n * console.log(theme.displayName)\n * ```\n */\nexport function getTheme(): Theme {\n  return themeStorage.getStore() ?? fallbackTheme\n}\n\n/**\n * Execute async operation with scoped theme.\n * Theme automatically restored on completion.\n *\n * @template T - Return type\n * @param theme - Scoped theme\n * @param fn - Async operation\n * @returns Operation result\n *\n * @example\n * ```ts\n * await withTheme('ultra', async () => {\n *   // Operations use Ultra theme\n * })\n * ```\n */\nexport async function withTheme<T>(\n  theme: Theme | ThemeName,\n  fn: () => Promise<T>,\n): Promise<T> {\n  const resolvedTheme: Theme = typeof theme === 'string' ? THEMES[theme] : theme\n  return await themeStorage.run(resolvedTheme, async () => {\n    emitThemeChange(resolvedTheme)\n    return await fn()\n  })\n}\n\n/**\n * Execute sync operation with scoped theme.\n * Theme automatically restored on completion.\n *\n * @template T - Return type\n * @param theme - Scoped theme\n * @param fn - Sync operation\n * @returns Operation result\n *\n * @example\n * ```ts\n * const result = withThemeSync('coana', () => {\n *   return processData()\n * })\n * ```\n */\nexport function withThemeSync<T>(theme: Theme | ThemeName, fn: () => T): T {\n  const resolvedTheme: Theme = typeof theme === 'string' ? THEMES[theme] : theme\n  return themeStorage.run(resolvedTheme, () => {\n    emitThemeChange(resolvedTheme)\n    return fn()\n  })\n}\n\n/**\n * Subscribe to theme change events.\n *\n * @param listener - Change handler\n * @returns Unsubscribe function\n *\n * @example\n * ```ts\n * const unsubscribe = onThemeChange((theme) => {\n *   console.log('Theme:', theme.displayName)\n * })\n *\n * // Cleanup\n * unsubscribe()\n * ```\n */\nexport function onThemeChange(listener: ThemeChangeListener): () => void {\n  listeners.add(listener)\n  return () => {\n    listeners.delete(listener)\n  }\n}\n\n/**\n * Emit theme change event to listeners.\n * @private\n */\nfunction emitThemeChange(theme: Theme): void {\n  for (const listener of listeners) {\n    listener(theme)\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,8BAAkC;AAGlC,oBAAqD;AAUrD,MAAM,eAAe,IAAI,0CAAyB;AAKlD,IAAI,gBAAuB;AAK3B,MAAM,YAAsC,oBAAI,IAAI;AAY7C,SAAS,SAAS,OAAgC;AACvD,kBAAgB,OAAO,UAAU,WAAW,qBAAO,KAAK,IAAI;AAC5D,kBAAgB,aAAa;AAC/B;AAaO,SAAS,WAAkB;AAChC,SAAO,aAAa,SAAS,KAAK;AACpC;AAkBA,eAAsB,UACpB,OACA,IACY;AACZ,QAAM,gBAAuB,OAAO,UAAU,WAAW,qBAAO,KAAK,IAAI;AACzE,SAAO,MAAM,aAAa,IAAI,eAAe,YAAY;AACvD,oBAAgB,aAAa;AAC7B,WAAO,MAAM,GAAG;AAAA,EAClB,CAAC;AACH;AAkBO,SAAS,cAAiB,OAA0B,IAAgB;AACzE,QAAM,gBAAuB,OAAO,UAAU,WAAW,qBAAO,KAAK,IAAI;AACzE,SAAO,aAAa,IAAI,eAAe,MAAM;AAC3C,oBAAgB,aAAa;AAC7B,WAAO,GAAG;AAAA,EACZ,CAAC;AACH;AAkBO,SAAS,cAAc,UAA2C;AACvE,YAAU,IAAI,QAAQ;AACtB,SAAO,MAAM;AACX,cAAU,OAAO,QAAQ;AAAA,EAC3B;AACF;AAMA,SAAS,gBAAgB,OAAoB;AAC3C,aAAW,YAAY,WAAW;AAChC,aAAS,KAAK;AAAA,EAChB;AACF;",
-  "names": []
-}

package/dist/themes/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/themes/index.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Elegant theming system for Socket libraries.\n * Unified visual language across spinners, loggers, prompts, and links.\n *\n * @example\n * ```ts\n * import { setTheme, THEMES } from '@socketsecurity/lib/themes'\n *\n * // Set global theme\n * setTheme('terracotta')\n * ```\n *\n * @example\n * ```ts\n * import { withTheme } from '@socketsecurity/lib/themes'\n *\n * // Scoped theme context\n * await withTheme('ultra', async () => {\n *   // All operations inherit Ultra theme\n * })\n * ```\n *\n * @example\n * ```ts\n * import { createTheme } from '@socketsecurity/lib/themes'\n *\n * // Custom theme creation\n * const myTheme = createTheme({\n *   name: 'custom',\n *   displayName: 'Custom Theme',\n *   colors: {\n *     primary: [255, 100, 200],\n *     success: 'greenBright',\n *     error: 'redBright',\n *     warning: 'yellowBright',\n *     info: 'blueBright',\n *     step: 'cyanBright',\n *     text: 'white',\n *     textDim: 'gray',\n *     link: 'cyanBright',\n *     prompt: 'primary'\n *   }\n * })\n * ```\n */\n\n// Type system\nexport type {\n  ColorReference,\n  Theme,\n  ThemeColors,\n  ThemeEffects,\n  ThemeMeta,\n} from './types'\n\n// Curated themes\nexport {\n  LUSH_THEME,\n  SOCKET_THEME,\n  SUNSET_THEME,\n  TERRACOTTA_THEME,\n  THEMES,\n  ULTRA_THEME,\n  type ThemeName,\n} from './themes'\n\n// Context management\nexport {\n  getTheme,\n  onThemeChange,\n  setTheme,\n  withTheme,\n  withThemeSync,\n  type ThemeChangeListener,\n} from './context'\n\n// Composition utilities\nexport {\n  createTheme,\n  extendTheme,\n  resolveColor,\n  resolveShimmerColor,\n} from './utils'\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwDA,oBAQO;AAGP,qBAOO;AAGP,mBAKO;",
-  "names": []
-}

package/dist/themes/themes.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/themes/themes.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Elegant theme definitions for Socket libraries.\n * Sophisticated color palettes crafted for clarity and visual harmony.\n *\n * Philosophy: Every color choice serves a purpose. Bright variants ensure\n * terminal legibility without compromising sophistication. Minimal emoji use,\n * refined symbols with color\u2014elegance in restraint.\n */\n\nimport type { Theme } from './types'\n\n/**\n * Socket Security \u2014 The signature theme.\n * Refined violet with subtle shimmer, designed for focus and elegance.\n */\nexport const SOCKET_THEME: Theme = {\n  name: 'socket',\n  displayName: 'Socket Security',\n  colors: {\n    primary: [140, 82, 255],\n    success: 'greenBright',\n    error: 'redBright',\n    warning: 'yellowBright',\n    info: 'blueBright',\n    step: 'cyanBright',\n    text: 'white',\n    textDim: 'gray',\n    link: 'cyanBright',\n    prompt: 'primary',\n  },\n  effects: {\n    spinner: {\n      color: 'primary',\n      style: 'socket',\n    },\n    shimmer: {\n      enabled: true,\n      color: 'inherit',\n      direction: 'ltr',\n      speed: 0.33,\n    },\n  },\n  meta: {\n    description: 'Signature theme with refined violet and subtle shimmer',\n    version: '1.0.0',\n  },\n}\n\n/**\n * Sunset \u2014 Vibrant twilight gradient.\n * Warm sunset palette with orange and purple/pink tones.\n */\nexport const SUNSET_THEME: Theme = {\n  name: 'sunset',\n  displayName: 'Sunset',\n  colors: {\n    primary: [255, 140, 100],\n    secondary: [200, 100, 180],\n    success: 'greenBright',\n    error: 'redBright',\n    warning: 'yellowBright',\n    info: 'magentaBright',\n    step: 'magentaBright',\n    text: 'white',\n    textDim: 'gray',\n    link: 'primary',\n    prompt: 'primary',\n  },\n  effects: {\n    spinner: {\n      color: 'primary',\n      style: 'dots',\n    },\n    shimmer: {\n      enabled: true,\n      color: [\n        [200, 100, 180],\n        [255, 140, 100],\n      ],\n      direction: 'ltr',\n      speed: 0.4,\n    },\n  },\n  meta: {\n    description: 'Warm sunset theme with purple-to-orange gradient',\n    version: '2.0.0',\n  },\n}\n\n/**\n * Terracotta \u2014 Solid warmth.\n * Rich terracotta and ember tones for grounded confidence.\n */\nexport const TERRACOTTA_THEME: Theme = {\n  name: 'terracotta',\n  displayName: 'Terracotta',\n  colors: {\n    primary: [255, 100, 50],\n    secondary: [255, 150, 100],\n    success: 'greenBright',\n    error: 'redBright',\n    warning: 'yellowBright',\n    info: 'blueBright',\n    step: 'cyanBright',\n    text: 'white',\n    textDim: 'gray',\n    link: 'secondary',\n    prompt: 'primary',\n  },\n  effects: {\n    spinner: {\n      color: 'primary',\n      style: 'socket',\n    },\n    shimmer: {\n      enabled: true,\n      color: 'inherit',\n      direction: 'ltr',\n      speed: 0.5,\n    },\n  },\n  meta: {\n    description: 'Solid theme with rich terracotta and ember warmth',\n    version: '1.0.0',\n  },\n}\n\n/**\n * Lush \u2014 Steel elegance.\n * Python-inspired steel blue with golden accents.\n */\nexport const LUSH_THEME: Theme = {\n  name: 'lush',\n  displayName: 'Lush',\n  colors: {\n    primary: [70, 130, 180],\n    secondary: [255, 215, 0],\n    success: 'greenBright',\n    error: 'redBright',\n    warning: 'yellowBright',\n    info: 'blueBright',\n    step: 'cyanBright',\n    text: 'white',\n    textDim: 'gray',\n    link: 'cyanBright',\n    prompt: 'primary',\n  },\n  effects: {\n    spinner: {\n      color: 'primary',\n      style: 'dots',\n    },\n  },\n  meta: {\n    description: 'Elegant theme with steel blue and golden harmony',\n    version: '1.0.0',\n  },\n}\n\n/**\n * Ultra \u2014 Premium intensity.\n * Prismatic shimmer for deep analysis, where complexity meets elegance.\n */\nexport const ULTRA_THEME: Theme = {\n  name: 'ultra',\n  displayName: 'Ultra',\n  colors: {\n    primary: [140, 82, 255],\n    success: 'greenBright',\n    error: 'redBright',\n    warning: 'yellowBright',\n    info: 'cyanBright',\n    step: 'magentaBright',\n    text: 'whiteBright',\n    textDim: 'gray',\n    link: 'cyanBright',\n    prompt: 'primary',\n  },\n  effects: {\n    spinner: {\n      color: 'inherit',\n      style: 'socket',\n    },\n    shimmer: {\n      enabled: true,\n      color: 'rainbow',\n      direction: 'bi',\n      speed: 0.5,\n    },\n  },\n  meta: {\n    description: 'Premium theme with prismatic shimmer for deep analysis',\n    version: '1.0.0',\n  },\n}\n\n/**\n * Theme registry \u2014 Curated palette collection.\n */\nexport const THEMES = {\n  __proto__: null,\n  socket: SOCKET_THEME,\n  sunset: SUNSET_THEME,\n  terracotta: TERRACOTTA_THEME,\n  lush: LUSH_THEME,\n  ultra: ULTRA_THEME,\n} as const\n\n/**\n * Available theme identifiers.\n */\nexport type ThemeName = keyof typeof THEMES\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/themes/types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/themes/types.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Elegant theme type system.\n * Type-safe theming for spinners, loggers, prompts, and links.\n */\n\nimport type { ColorValue, SpinnerStyle } from '../spinner'\nimport type { ShimmerDirection } from '../effects/text-shimmer'\n\n/**\n * Color reference \u2014 direct value or semantic keyword.\n * Keywords: 'primary', 'secondary', 'inherit', 'rainbow'\n */\nexport type ColorReference =\n  | ColorValue\n  | 'primary'\n  | 'secondary'\n  | 'inherit'\n  | 'rainbow'\n\n/**\n * Theme color palette \u2014 semantic colors for visual harmony.\n */\nexport type ThemeColors = {\n  /** Primary brand identity */\n  primary: ColorValue\n  /** Secondary accent (optional) */\n  secondary?: ColorValue | undefined\n\n  /** Success indicator \u2713 */\n  success: ColorValue\n  /** Error indicator \u2717 */\n  error: ColorValue\n  /** Warning indicator \u26A0 */\n  warning: ColorValue\n  /** Information indicator \u2139 */\n  info: ColorValue\n  /** Progress indicator \u2192 */\n  step: ColorValue\n\n  /** Primary text */\n  text: ColorValue\n  /** Dimmed text */\n  textDim: ColorValue\n  /** Hyperlinks */\n  link: ColorReference\n  /** Interactive prompts */\n  prompt: ColorReference\n}\n\n/**\n * Theme effects \u2014 animations and visual enhancements.\n */\nexport type ThemeEffects = {\n  /** Spinner configuration */\n  spinner?: {\n    /** Color (supports theme references) */\n    color?: ColorReference | undefined\n    /** Animation style */\n    style?: SpinnerStyle | string | undefined\n  }\n\n  /** Shimmer configuration */\n  shimmer?: {\n    /** Enable shimmer */\n    enabled?: boolean | undefined\n    /** Color (single, gradient, or keyword) */\n    color?: ColorReference | ColorValue[] | undefined\n    /** Direction */\n    direction?: ShimmerDirection | undefined\n    /** Speed (steps per frame) */\n    speed?: number | undefined\n  }\n\n  /** Pulse configuration */\n  pulse?: {\n    /** Speed (milliseconds) */\n    speed?: number | undefined\n  }\n}\n\n/**\n * Theme metadata \u2014 descriptive information.\n */\nexport type ThemeMeta = {\n  /** Description */\n  description?: string | undefined\n  /** Author */\n  author?: string | undefined\n  /** Version */\n  version?: string | undefined\n}\n\n/**\n * Theme definition \u2014 complete visual identity.\n */\nexport type Theme = {\n  /** Unique identifier (kebab-case) */\n  name: string\n  /** Display name */\n  displayName: string\n\n  /** Color palette */\n  colors: ThemeColors\n\n  /** Visual effects (optional) */\n  effects?: ThemeEffects | undefined\n\n  /** Metadata (optional) */\n  meta?: ThemeMeta | undefined\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
-  "names": []
-}

package/dist/themes/utils.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/themes/utils.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Theme utilities \u2014 color resolution and composition.\n */\n\nimport { RAINBOW_GRADIENT } from '../effects/ultra'\nimport type { ColorValue } from '../spinner'\nimport type { ShimmerColorGradient } from '../effects/text-shimmer'\nimport type { Theme, ThemeColors, ColorReference } from './types'\n\n/**\n * Resolve color reference to concrete value.\n * Handles semantic keywords: 'primary', 'secondary', 'rainbow', 'inherit'\n *\n * @param value - Color reference\n * @param colors - Theme palette\n * @returns Resolved color\n *\n * @example\n * ```ts\n * resolveColor('primary', theme.colors)\n * resolveColor([255, 0, 0], theme.colors)\n * ```\n */\nexport function resolveColor(\n  value: ColorReference | ColorValue,\n  colors: ThemeColors,\n): ColorValue | 'inherit' | ShimmerColorGradient {\n  if (typeof value === 'string') {\n    if (value === 'primary') {\n      return colors.primary\n    }\n    if (value === 'secondary') {\n      return colors.secondary ?? colors.primary\n    }\n    if (value === 'inherit') {\n      return 'inherit'\n    }\n    if (value === 'rainbow') {\n      return RAINBOW_GRADIENT\n    }\n    return value as ColorValue\n  }\n  return value as ColorValue\n}\n\n/**\n * Resolve shimmer color with gradient support.\n *\n * @param value - Shimmer color\n * @param theme - Theme context\n * @returns Resolved color\n *\n * @example\n * ```ts\n * resolveShimmerColor('rainbow', theme)\n * resolveShimmerColor('primary', theme)\n * ```\n */\nexport function resolveShimmerColor(\n  value: ColorReference | ColorValue[] | undefined,\n  theme: Theme,\n): ColorValue | ShimmerColorGradient | 'inherit' {\n  if (!value) {\n    return 'inherit'\n  }\n  if (value === 'rainbow') {\n    return RAINBOW_GRADIENT\n  }\n  if (value === 'inherit') {\n    return 'inherit'\n  }\n  if (Array.isArray(value)) {\n    if (value.length > 0 && Array.isArray(value[0])) {\n      // Gradient\n      return value as ShimmerColorGradient\n    }\n    // Single RGB\n    return value as unknown as ColorValue\n  }\n  return resolveColor(value as ColorReference, theme.colors)\n}\n\n/**\n * Extend existing theme with custom overrides.\n * Deep merge of colors and effects.\n *\n * @param base - Base theme\n * @param overrides - Custom overrides\n * @returns Extended theme\n *\n * @example\n * ```ts\n * const custom = extendTheme(SOCKET_THEME, {\n *   name: 'custom',\n *   colors: { primary: [255, 100, 200] }\n * })\n * ```\n */\nexport function extendTheme(\n  base: Theme,\n  overrides: Partial<Omit<Theme, 'colors'>> & {\n    colors?: Partial<ThemeColors> | undefined\n  },\n): Theme {\n  return {\n    __proto__: null,\n    ...base,\n    ...overrides,\n    colors: {\n      __proto__: null,\n      ...base.colors,\n      ...overrides.colors,\n    } as ThemeColors,\n    effects: overrides.effects\n      ? {\n          __proto__: null,\n          ...base.effects,\n          ...overrides.effects,\n          spinner:\n            overrides.effects.spinner !== undefined\n              ? {\n                  __proto__: null,\n                  ...base.effects?.spinner,\n                  ...overrides.effects.spinner,\n                }\n              : base.effects?.spinner,\n          shimmer:\n            overrides.effects.shimmer !== undefined\n              ? {\n                  __proto__: null,\n                  ...base.effects?.shimmer,\n                  ...overrides.effects.shimmer,\n                }\n              : base.effects?.shimmer,\n          pulse:\n            overrides.effects.pulse !== undefined\n              ? {\n                  __proto__: null,\n                  ...base.effects?.pulse,\n                  ...overrides.effects.pulse,\n                }\n              : base.effects?.pulse,\n        }\n      : base.effects,\n    meta: overrides.meta\n      ? {\n          __proto__: null,\n          ...base.meta,\n          ...overrides.meta,\n        }\n      : base.meta,\n  } as Theme\n}\n\n/**\n * Create new theme from complete specification.\n *\n * @param config - Theme configuration\n * @returns Theme object\n *\n * @example\n * ```ts\n * const theme = createTheme({\n *   name: 'custom',\n *   displayName: 'Custom',\n *   colors: {\n *     primary: [255, 100, 200],\n *     success: 'greenBright',\n *     error: 'redBright',\n *     warning: 'yellowBright',\n *     info: 'blueBright',\n *     step: 'cyanBright',\n *     text: 'white',\n *     textDim: 'gray',\n *     link: 'cyanBright',\n *     prompt: 'primary'\n *   }\n * })\n * ```\n */\nexport function createTheme(\n  config: Pick<Theme, 'name' | 'displayName' | 'colors'> &\n    Partial<Omit<Theme, 'name' | 'displayName' | 'colors'>>,\n): Theme {\n  return {\n    __proto__: null,\n    name: config.name,\n    displayName: config.displayName,\n    colors: { __proto__: null, ...config.colors } as ThemeColors,\n    effects: config.effects\n      ? { __proto__: null, ...config.effects }\n      : undefined,\n    meta: config.meta ? { __proto__: null, ...config.meta } : undefined,\n  } as Theme\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,mBAAiC;AAmB1B,SAAS,aACd,OACA,QAC+C;AAC/C,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,UAAU,WAAW;AACvB,aAAO,OAAO;AAAA,IAChB;AACA,QAAI,UAAU,aAAa;AACzB,aAAO,OAAO,aAAa,OAAO;AAAA,IACpC;AACA,QAAI,UAAU,WAAW;AACvB,aAAO;AAAA,IACT;AACA,QAAI,UAAU,WAAW;AACvB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAeO,SAAS,oBACd,OACA,OAC+C;AAC/C,MAAI,CAAC,OAAO;AACV,WAAO;AAAA,EACT;AACA,MAAI,UAAU,WAAW;AACvB,WAAO;AAAA,EACT;AACA,MAAI,UAAU,WAAW;AACvB,WAAO;AAAA,EACT;AACA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,QAAI,MAAM,SAAS,KAAK,MAAM,QAAQ,MAAM,CAAC,CAAC,GAAG;AAE/C,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AACA,SAAO,aAAa,OAAyB,MAAM,MAAM;AAC3D;AAkBO,SAAS,YACd,MACA,WAGO;AACP,SAAO;AAAA,IACL,WAAW;AAAA,IACX,GAAG;AAAA,IACH,GAAG;AAAA,IACH,QAAQ;AAAA,MACN,WAAW;AAAA,MACX,GAAG,KAAK;AAAA,MACR,GAAG,UAAU;AAAA,IACf;AAAA,IACA,SAAS,UAAU,UACf;AAAA,MACE,WAAW;AAAA,MACX,GAAG,KAAK;AAAA,MACR,GAAG,UAAU;AAAA,MACb,SACE,UAAU,QAAQ,YAAY,SAC1B;AAAA,QACE,WAAW;AAAA,QACX,GAAG,KAAK,SAAS;AAAA,QACjB,GAAG,UAAU,QAAQ;AAAA,MACvB,IACA,KAAK,SAAS;AAAA,MACpB,SACE,UAAU,QAAQ,YAAY,SAC1B;AAAA,QACE,WAAW;AAAA,QACX,GAAG,KAAK,SAAS;AAAA,QACjB,GAAG,UAAU,QAAQ;AAAA,MACvB,IACA,KAAK,SAAS;AAAA,MACpB,OACE,UAAU,QAAQ,UAAU,SACxB;AAAA,QACE,WAAW;AAAA,QACX,GAAG,KAAK,SAAS;AAAA,QACjB,GAAG,UAAU,QAAQ;AAAA,MACvB,IACA,KAAK,SAAS;AAAA,IACtB,IACA,KAAK;AAAA,IACT,MAAM,UAAU,OACZ;AAAA,MACE,WAAW;AAAA,MACX,GAAG,KAAK;AAAA,MACR,GAAG,UAAU;AAAA,IACf,IACA,KAAK;AAAA,EACX;AACF;AA4BO,SAAS,YACd,QAEO;AACP,SAAO;AAAA,IACL,WAAW;AAAA,IACX,MAAM,OAAO;AAAA,IACb,aAAa,OAAO;AAAA,IACpB,QAAQ,EAAE,WAAW,MAAM,GAAG,OAAO,OAAO;AAAA,IAC5C,SAAS,OAAO,UACZ,EAAE,WAAW,MAAM,GAAG,OAAO,QAAQ,IACrC;AAAA,IACJ,MAAM,OAAO,OAAO,EAAE,WAAW,MAAM,GAAG,OAAO,KAAK,IAAI;AAAA,EAC5D;AACF;",
-  "names": []
-}

package/dist/types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/types.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Type definitions for Socket Registry.\n */\n\n// Type definitions\nenum Categories {\n  CLEANUP = 'cleanup',\n  LEVELUP = 'levelup',\n  SPEEDUP = 'speedup',\n  TUNEUP = 'tuneup',\n}\n\nexport type CategoryString = `${Categories}`\n\nenum Interop {\n  BROWSERIFY = 'browserify',\n  CJS = 'cjs',\n  ESM = 'esm',\n}\n\nexport type InteropString = `${Interop}`\n\n// Based on SocketPURL_Type from socket-sdk-js\nexport enum PURL_Type {\n  APK = 'apk',\n  BITBUCKET = 'bitbucket',\n  COCOAPODS = 'cocoapods',\n  CARGO = 'cargo',\n  CHROME = 'chrome',\n  COMPOSER = 'composer',\n  CONAN = 'conan',\n  CONDA = 'conda',\n  CRAN = 'cran',\n  DEB = 'deb',\n  DOCKER = 'docker',\n  GEM = 'gem',\n  GENERIC = 'generic',\n  GITHUB = 'github',\n  GOLANG = 'golang',\n  HACKAGE = 'hackage',\n  HEX = 'hex',\n  HUGGINGFACE = 'huggingface',\n  MAVEN = 'maven',\n  MLFLOW = 'mlflow',\n  NPM = 'npm',\n  NUGET = 'nuget',\n  OCI = 'oci',\n  PUB = 'pub',\n  PYPI = 'pypi',\n  QPKG = 'qpkg',\n  RPM = 'rpm',\n  SWID = 'swid',\n  SWIFT = 'swift',\n  VCS = 'vcs',\n}\n\nexport type PURLString = `${PURL_Type}`\n\n// Alias for backward compatibility and semantic clarity\nexport type EcosystemString = PURLString\n\n// Manifest types for Socket Registry\nexport type ManifestEntryData = {\n  categories?: CategoryString[] | undefined\n  interop?: InteropString | undefined\n  license?: string | undefined\n  name: string\n  version: string\n  [key: string]: unknown\n}\n\nexport type ManifestEntry = [packageName: string, data: ManifestEntryData]\n\nexport type Manifest = Record<EcosystemString, ManifestEntry[]>\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBO,IAAK,YAAL,kBAAKA,eAAL;AACL,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,eAAY;AACZ,EAAAA,WAAA,eAAY;AACZ,EAAAA,WAAA,WAAQ;AACR,EAAAA,WAAA,YAAS;AACT,EAAAA,WAAA,cAAW;AACX,EAAAA,WAAA,WAAQ;AACR,EAAAA,WAAA,WAAQ;AACR,EAAAA,WAAA,UAAO;AACP,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,YAAS;AACT,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,aAAU;AACV,EAAAA,WAAA,YAAS;AACT,EAAAA,WAAA,YAAS;AACT,EAAAA,WAAA,aAAU;AACV,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,iBAAc;AACd,EAAAA,WAAA,WAAQ;AACR,EAAAA,WAAA,YAAS;AACT,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,WAAQ;AACR,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,UAAO;AACP,EAAAA,WAAA,UAAO;AACP,EAAAA,WAAA,SAAM;AACN,EAAAA,WAAA,UAAO;AACP,EAAAA,WAAA,WAAQ;AACR,EAAAA,WAAA,SAAM;AA9BI,SAAAA;AAAA,GAAA;",
-  "names": ["PURL_Type"]
-}

package/dist/url.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/url.ts"],
-  "sourcesContent": ["/**\n * @fileoverview URL parsing and validation utilities.\n * Provides URL validation, normalization, and parsing helpers.\n */\n\nconst BooleanCtor = Boolean\nconst UrlCtor = URL\n\n/**\n * Check if a value is a valid URL.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isUrl(value: string | URL | null | undefined): boolean {\n  return (\n    ((typeof value === 'string' && value !== '') ||\n      (value !== null && typeof value === 'object')) &&\n    !!parseUrl(value)\n  )\n}\n\n/**\n * Parse a value as a URL.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function parseUrl(value: string | URL): URL | undefined {\n  try {\n    return new UrlCtor(value)\n  } catch {}\n  return undefined\n}\n\n/**\n * Convert a URL search parameter to an array.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsArray(\n  value: string | null | undefined,\n): string[] {\n  return typeof value === 'string'\n    ? value\n        .trim()\n        .split(/, */)\n        .map(v => v.trim())\n        .filter(BooleanCtor)\n    : []\n}\n\nexport interface UrlSearchParamAsBooleanOptions {\n  defaultValue?: boolean\n}\n\n/**\n * Convert a URL search parameter to a boolean.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsBoolean(\n  value: string | null | undefined,\n  options?: UrlSearchParamAsBooleanOptions | undefined,\n): boolean {\n  const { defaultValue = false } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamAsBooleanOptions\n  if (typeof value === 'string') {\n    const trimmed = value.trim()\n    return trimmed === '1' || trimmed.toLowerCase() === 'true'\n  }\n  if (value === null || value === undefined) {\n    return !!defaultValue\n  }\n  return !!value\n}\n\n/**\n * Helper to get array from URLSearchParams.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamsGetArray(\n  params: URLSearchParams | null | undefined,\n  key: string,\n): string[] {\n  if (params && typeof params.getAll === 'function') {\n    const values = params.getAll(key)\n    // If single value contains commas, split it\n    const firstValue = values[0]\n    if (values.length === 1 && firstValue && firstValue.includes(',')) {\n      return urlSearchParamAsArray(firstValue)\n    }\n    return values\n  }\n  return []\n}\n\nexport interface UrlSearchParamsGetBooleanOptions {\n  defaultValue?: boolean\n}\n\n/**\n * Helper to get boolean from URLSearchParams.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamsGetBoolean(\n  params: URLSearchParams | null | undefined,\n  key: string,\n  options?: UrlSearchParamsGetBooleanOptions | undefined,\n): boolean {\n  const { defaultValue = false } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamsGetBooleanOptions\n  if (params && typeof params.get === 'function') {\n    const value = params.get(key)\n    return value !== null\n      ? urlSearchParamAsBoolean(value, { defaultValue })\n      : defaultValue\n  }\n  return defaultValue\n}\n\nexport interface CreateRelativeUrlOptions {\n  base?: string\n}\n\n/**\n * Create a relative URL for testing.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function createRelativeUrl(\n  path: string,\n  options?: CreateRelativeUrlOptions | undefined,\n): string {\n  const { base = '' } = {\n    __proto__: null,\n    ...options,\n  } as CreateRelativeUrlOptions\n  // Remove leading slash to make it relative.\n  const relativePath = path.replace(/^\\//, '')\n\n  if (base) {\n    let baseUrl = base\n    if (!baseUrl.endsWith('/')) {\n      baseUrl += '/'\n    }\n    return baseUrl + relativePath\n  }\n\n  return relativePath\n}\n\nexport interface UrlSearchParamAsStringOptions {\n  defaultValue?: string\n}\n\n/**\n * Get string value from URLSearchParams with a default.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsString(\n  params: URLSearchParams | null | undefined,\n  key: string,\n  options?: UrlSearchParamAsStringOptions | undefined,\n): string {\n  const { defaultValue = '' } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamAsStringOptions\n  if (params && typeof params.get === 'function') {\n    const value = params.get(key)\n    return value !== null ? value : defaultValue\n  }\n  return defaultValue\n}\n\nexport interface UrlSearchParamAsNumberOptions {\n  defaultValue?: number\n}\n\n/**\n * Get number value from URLSearchParams with a default.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsNumber(\n  params: URLSearchParams | null | undefined,\n  key: string,\n  options?: UrlSearchParamAsNumberOptions | undefined,\n): number {\n  const { defaultValue = 0 } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamAsNumberOptions\n  if (params && typeof params.get === 'function') {\n    const value = params.get(key)\n    if (value !== null) {\n      const num = Number(value)\n      return !Number.isNaN(num) ? num : defaultValue\n    }\n  }\n  return defaultValue\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/utils/get-ipc.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/get-ipc.ts"],
-  "sourcesContent": ["/**\n * IPC (Inter-Process Communication) object getter.\n * Handles communication between parent and child processes.\n */\n\nexport interface IpcObject {\n  SOCKET_CLI_FIX?: string | undefined\n  SOCKET_CLI_OPTIMIZE?: boolean | undefined\n  SOCKET_CLI_SHADOW_ACCEPT_RISKS?: boolean | undefined\n  SOCKET_CLI_SHADOW_API_TOKEN?: string | undefined\n  SOCKET_CLI_SHADOW_BIN?: string | undefined\n  SOCKET_CLI_SHADOW_PROGRESS?: boolean | undefined\n  SOCKET_CLI_SHADOW_SILENT?: boolean | undefined\n}\n\nlet _ipcObject: IpcObject | undefined\n\nexport async function getIpc(): Promise<IpcObject>\nexport async function getIpc<K extends keyof IpcObject>(\n  key: K,\n): Promise<IpcObject[K]>\nexport async function getIpc(\n  key?: keyof IpcObject,\n): Promise<IpcObject | IpcObject[keyof IpcObject]> {\n  if (_ipcObject === undefined) {\n    _ipcObject = {}\n\n    // Check for IPC environment variables.\n    const { env } = process\n\n    if (env['SOCKET_CLI_FIX']) {\n      _ipcObject.SOCKET_CLI_FIX = env['SOCKET_CLI_FIX']\n    }\n\n    if (env['SOCKET_CLI_OPTIMIZE']) {\n      _ipcObject.SOCKET_CLI_OPTIMIZE =\n        env['SOCKET_CLI_OPTIMIZE'] === 'true' ||\n        env['SOCKET_CLI_OPTIMIZE'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_ACCEPT_RISKS']) {\n      _ipcObject.SOCKET_CLI_SHADOW_ACCEPT_RISKS =\n        env['SOCKET_CLI_SHADOW_ACCEPT_RISKS'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_ACCEPT_RISKS'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_API_TOKEN']) {\n      _ipcObject.SOCKET_CLI_SHADOW_API_TOKEN =\n        env['SOCKET_CLI_SHADOW_API_TOKEN']\n    }\n\n    if (env['SOCKET_CLI_SHADOW_BIN']) {\n      _ipcObject.SOCKET_CLI_SHADOW_BIN = env['SOCKET_CLI_SHADOW_BIN']\n    }\n\n    if (env['SOCKET_CLI_SHADOW_PROGRESS']) {\n      _ipcObject.SOCKET_CLI_SHADOW_PROGRESS =\n        env['SOCKET_CLI_SHADOW_PROGRESS'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_PROGRESS'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_SILENT']) {\n      _ipcObject.SOCKET_CLI_SHADOW_SILENT =\n        env['SOCKET_CLI_SHADOW_SILENT'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_SILENT'] === '1'\n    }\n\n    Object.freeze(_ipcObject)\n  }\n\n  return key ? _ipcObject[key] : _ipcObject\n}\n\nexport default getIpc\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,IAAI;AAMJ,eAAsB,OACpB,KACiD;AACjD,MAAI,eAAe,QAAW;AAC5B,iBAAa,CAAC;AAGd,UAAM,EAAE,IAAI,IAAI;AAEhB,QAAI,IAAI,gBAAgB,GAAG;AACzB,iBAAW,iBAAiB,IAAI,gBAAgB;AAAA,IAClD;AAEA,QAAI,IAAI,qBAAqB,GAAG;AAC9B,iBAAW,sBACT,IAAI,qBAAqB,MAAM,UAC/B,IAAI,qBAAqB,MAAM;AAAA,IACnC;AAEA,QAAI,IAAI,gCAAgC,GAAG;AACzC,iBAAW,iCACT,IAAI,gCAAgC,MAAM,UAC1C,IAAI,gCAAgC,MAAM;AAAA,IAC9C;AAEA,QAAI,IAAI,6BAA6B,GAAG;AACtC,iBAAW,8BACT,IAAI,6BAA6B;AAAA,IACrC;AAEA,QAAI,IAAI,uBAAuB,GAAG;AAChC,iBAAW,wBAAwB,IAAI,uBAAuB;AAAA,IAChE;AAEA,QAAI,IAAI,4BAA4B,GAAG;AACrC,iBAAW,6BACT,IAAI,4BAA4B,MAAM,UACtC,IAAI,4BAA4B,MAAM;AAAA,IAC1C;AAEA,QAAI,IAAI,0BAA0B,GAAG;AACnC,iBAAW,2BACT,IAAI,0BAA0B,MAAM,UACpC,IAAI,0BAA0B,MAAM;AAAA,IACxC;AAEA,WAAO,OAAO,UAAU;AAAA,EAC1B;AAEA,SAAO,MAAM,WAAW,GAAG,IAAI;AACjC;AAEA,IAAO,kBAAQ;",
-  "names": []
-}

package/dist/validation/json-parser.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/validation/json-parser.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Safe JSON parsing with validation and security controls.\n * Provides protection against prototype pollution, size limits, and schema validation.\n *\n * Key Features:\n * - Prototype pollution protection: Blocks `__proto__`, `constructor`, and `prototype` keys\n * - Size limits: Configurable maximum JSON string size (default 10MB)\n * - Schema validation: Optional Zod-compatible schema validation\n * - NDJSON support: Parse newline-delimited JSON streams\n * - Memory safety: Prevents memory exhaustion attacks\n */\n\nimport type { JsonParseOptions, JsonParseResult, Schema } from './types'\n\nconst { hasOwn: ObjectHasOwn } = Object\n\n/**\n * Safely parse JSON with optional schema validation and security controls.\n * Throws errors on parse failures, validation failures, or security violations.\n *\n * This is the recommended method for parsing untrusted JSON input as it provides\n * multiple layers of security including prototype pollution protection and size limits.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns The parsed and validated data\n *\n * @throws {Error} When JSON string exceeds `maxSize`\n * @throws {Error} When JSON parsing fails\n * @throws {Error} When prototype pollution keys are detected (unless `allowPrototype` is `true`)\n * @throws {Error} When schema validation fails\n *\n * @example\n * ```ts\n * // Basic parsing with type inference\n * const data = safeJsonParse<User>('{\"name\":\"Alice\",\"age\":30}')\n *\n * // With schema validation\n * import { z } from 'zod'\n * const userSchema = z.object({\n *   name: z.string(),\n *   age: z.number()\n * })\n * const user = safeJsonParse('{\"name\":\"Alice\",\"age\":30}', userSchema)\n *\n * // With size limit\n * const data = safeJsonParse(jsonString, undefined, {\n *   maxSize: 1024 * 1024 // 1MB\n * })\n *\n * // Allow prototype keys (dangerous - only for trusted sources)\n * const data = safeJsonParse(jsonString, undefined, {\n *   allowPrototype: true\n * })\n * ```\n */\nexport function safeJsonParse<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options: JsonParseOptions = {},\n): T {\n  const { allowPrototype = false, maxSize = 10 * 1024 * 1024 } = options\n\n  // Check size limit\n  const byteLength = Buffer.byteLength(jsonString, 'utf8')\n  if (byteLength > maxSize) {\n    throw new Error(\n      `JSON string exceeds maximum size limit${maxSize !== 10 * 1024 * 1024 ? ` of ${maxSize} bytes` : ''}`,\n    )\n  }\n\n  // Parse JSON\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(jsonString)\n  } catch (error) {\n    throw new Error(`Failed to parse JSON: ${error}`)\n  }\n\n  // Check for prototype pollution\n  if (\n    !allowPrototype &&\n    typeof parsed === 'object' &&\n    parsed !== null &&\n    !Array.isArray(parsed)\n  ) {\n    const dangerous = ['__proto__', 'constructor', 'prototype']\n    for (const key of dangerous) {\n      if (ObjectHasOwn(parsed, key)) {\n        throw new Error(\n          'JSON contains potentially malicious prototype pollution keys',\n        )\n      }\n    }\n  }\n\n  // Validate against schema if provided\n  if (schema) {\n    const result = schema.safeParse(parsed)\n    if (!result.success) {\n      const errors = result.error.issues\n        .map(\n          (issue: { path: Array<string | number>; message: string }) =>\n            `${issue.path.join('.')}: ${issue.message}`,\n        )\n        .join(', ')\n      throw new Error(`Validation failed: ${errors}`)\n    }\n    return result.data as T\n  }\n\n  return parsed as T\n}\n\n/**\n * Attempt to parse JSON, returning `undefined` on any error.\n * This is a non-throwing wrapper around `safeJsonParse` for cases where\n * you want to gracefully handle parse failures without try-catch blocks.\n *\n * Use this when parsing is optional or you have a fallback strategy.\n * For critical parsing where you need error details, use `safeJsonParse` or `parseJsonWithResult`.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns The parsed data on success, or `undefined` on any error\n *\n * @example\n * ```ts\n * // Graceful fallback to default\n * const config = tryJsonParse<Config>(jsonString) ?? defaultConfig\n *\n * // Optional parsing\n * const data = tryJsonParse(possiblyInvalidJson)\n * if (data) {\n *   console.log('Parsed successfully:', data)\n * }\n *\n * // With schema validation\n * const user = tryJsonParse(jsonString, userSchema)\n * ```\n */\nexport function tryJsonParse<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): T | undefined {\n  try {\n    return safeJsonParse(jsonString, schema, options)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Parse JSON and return a discriminated union result.\n * Never throws - always returns a result object with success/failure information.\n *\n * This is ideal when you need detailed error messages and type-safe result handling.\n * The discriminated union allows TypeScript to narrow types based on the `success` flag.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns Result object with either `{success: true, data}` or `{success: false, error}`\n *\n * @example\n * ```ts\n * // Type-safe error handling\n * const result = parseJsonWithResult<User>(jsonString, userSchema)\n *\n * if (result.success) {\n *   // TypeScript knows result.data is available\n *   console.log(`User: ${result.data.name}`)\n * } else {\n *   // TypeScript knows result.error is available\n *   console.error(`Parse failed: ${result.error}`)\n * }\n *\n * // Early return pattern\n * const result = parseJsonWithResult(jsonString)\n * if (!result.success) {\n *   logger.error(result.error)\n *   return\n * }\n * processData(result.data)\n * ```\n */\nexport function parseJsonWithResult<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): JsonParseResult<T> {\n  try {\n    const data = safeJsonParse(jsonString, schema, options)\n    return { success: true, data }\n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : 'Unknown error'\n    return { success: false, error: message }\n  }\n}\n\n/**\n * Create a reusable JSON parser with pre-configured schema and options.\n * Useful for parsing multiple JSON strings with the same validation rules.\n *\n * The returned parser function can accept per-call options that override the defaults.\n * This factory pattern reduces repetition when parsing many similar JSON payloads.\n *\n * @template T - The expected type of the parsed data\n * @param schema - Optional Zod-compatible schema for validation\n * @param defaultOptions - Default parsing options applied to all parse calls\n * @returns A parser function that accepts a JSON string and optional per-call options\n *\n * @example\n * ```ts\n * // Create a parser for API responses\n * import { z } from 'zod'\n * const apiResponseSchema = z.object({\n *   status: z.string(),\n *   data: z.unknown()\n * })\n *\n * const parseApiResponse = createJsonParser(apiResponseSchema, {\n *   maxSize: 5 * 1024 * 1024 // 5MB limit for API responses\n * })\n *\n * // Use the parser multiple times\n * const response1 = parseApiResponse(json1)\n * const response2 = parseApiResponse(json2)\n *\n * // Override options for specific calls\n * const response3 = parseApiResponse(json3, { maxSize: 10 * 1024 * 1024 })\n * ```\n */\nexport function createJsonParser<T = unknown>(\n  schema?: Schema<T> | undefined,\n  defaultOptions?: JsonParseOptions | undefined,\n) {\n  return (jsonString: string, options?: JsonParseOptions | undefined): T => {\n    return safeJsonParse(jsonString, schema, { ...defaultOptions, ...options })\n  }\n}\n\n/**\n * Parse newline-delimited JSON (NDJSON) into an array.\n * Each line is treated as a separate JSON object. Empty lines are skipped.\n *\n * NDJSON format is commonly used for streaming logs, bulk data transfers,\n * and event streams where each line represents a complete JSON document.\n *\n * @template T - The expected type of each parsed JSON object\n * @param ndjson - Newline-delimited JSON string (supports both `\\n` and `\\r\\n`)\n * @param schema - Optional Zod-compatible schema for validation of each line\n * @param options - Parsing options applied to each line\n * @returns Array of parsed objects, one per non-empty line\n *\n * @throws {Error} When any line fails to parse (includes line number in error message)\n *\n * @example\n * ```ts\n * // Parse NDJSON logs\n * const ndjsonString = `\n * {\"level\":\"info\",\"message\":\"Server started\"}\n * {\"level\":\"error\",\"message\":\"Connection failed\"}\n * {\"level\":\"info\",\"message\":\"Retrying...\"}\n * `\n * const logs = parseNdjson<LogEntry>(ndjsonString, logSchema)\n * console.log(logs.length) // 3\n *\n * // Parse with size limits per line\n * const entries = parseNdjson(ndjson, undefined, { maxSize: 1024 })\n *\n * // Empty lines are automatically skipped\n * const data = parseNdjson('{\"a\":1}\\n\\n{\"b\":2}\\n') // 2 objects\n * ```\n */\nexport function parseNdjson<T = unknown>(\n  ndjson: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): T[] {\n  const results: T[] = []\n  const lines = ndjson.split(/\\r?\\n/)\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]?.trim()\n    if (!line || line === '') {\n      continue\n    }\n\n    try {\n      const parsed = safeJsonParse<T>(line, schema, options)\n      results.push(parsed)\n    } catch (error: unknown) {\n      const message = error instanceof Error ? error.message : String(error)\n      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`)\n    }\n  }\n\n  return results\n}\n\n/**\n * Stream-parse newline-delimited JSON (NDJSON) using a generator.\n * Yields one parsed object at a time, enabling memory-efficient processing of large NDJSON files.\n *\n * Unlike `parseNdjson` which loads all results into memory, this generator allows\n * processing each line individually, making it ideal for large datasets or streaming scenarios.\n *\n * @template T - The expected type of each parsed JSON object\n * @param ndjson - Newline-delimited JSON string (supports both `\\n` and `\\r\\n`)\n * @param schema - Optional Zod-compatible schema for validation of each line\n * @param options - Parsing options applied to each line\n * @yields Parsed objects one at a time as the generator iterates\n *\n * @throws {Error} When any line fails to parse (includes line number in error message)\n *\n * @example\n * ```ts\n * // Memory-efficient processing of large NDJSON files\n * const ndjsonString = readLargeFile('logs.ndjson')\n *\n * for (const log of streamNdjson<LogEntry>(ndjsonString, logSchema)) {\n *   if (log.level === 'error') {\n *     console.error('Error found:', log.message)\n *   }\n * }\n *\n * // Collect filtered results without loading everything\n * const errors = [...streamNdjson(ndjson)]\n *   .filter(log => log.level === 'error')\n *\n * // Early termination when condition is met\n * for (const entry of streamNdjson(ndjson)) {\n *   if (entry.id === targetId) {\n *     processEntry(entry)\n *     break // Stop processing remaining lines\n *   }\n * }\n * ```\n */\nexport function* streamNdjson<T = unknown>(\n  ndjson: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): Generator<T, void, unknown> {\n  const lines = ndjson.split(/\\r?\\n/)\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]?.trim()\n    if (!line || line === '') {\n      continue\n    }\n\n    try {\n      yield safeJsonParse<T>(line, schema, options)\n    } catch (error: unknown) {\n      const message = error instanceof Error ? error.message : String(error)\n      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`)\n    }\n  }\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/validation/types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/validation/types.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Validation type definitions.\n * Provides core types for schema validation and JSON parsing with security features.\n */\n\n/**\n * Result of a schema validation operation.\n * Contains either successful parsed data or error information.\n *\n * @template T - The expected type of the parsed data\n *\n * @example\n * ```ts\n * const result: ParseResult<User> = schema.safeParse(data)\n * if (result.success) {\n *   console.log(result.data) // User object\n * } else {\n *   console.error(result.error) // Error details\n * }\n * ```\n */\nexport interface ParseResult<T> {\n  /** Indicates whether parsing was successful */\n  success: boolean\n  /** Parsed and validated data (only present when `success` is `true`) */\n  data?: T | undefined\n  /** Error information (only present when `success` is `false`) */\n  error?: any\n}\n\n/**\n * Base schema interface compatible with Zod and similar validation libraries.\n * Provides both safe and throwing parsing methods.\n *\n * @template T - The expected output type after validation\n *\n * @example\n * ```ts\n * import { z } from 'zod'\n *\n * const userSchema = z.object({\n *   name: z.string(),\n *   age: z.number()\n * })\n *\n * // Schema satisfies this interface\n * const schema: Schema<User> = userSchema\n * const result = schema.safeParse({ name: 'Alice', age: 30 })\n * ```\n */\nexport interface Schema<T = any> {\n  /**\n   * Safely parse data without throwing errors.\n   * Returns a result object indicating success or failure.\n   *\n   * @param data - The data to validate\n   * @returns Parse result with success flag and data or error\n   */\n  safeParse(data: any): ParseResult<T>\n\n  /**\n   * Parse data and throw an error if validation fails.\n   * Use this when you want to fail fast on invalid data.\n   *\n   * @param data - The data to validate\n   * @returns The validated and parsed data\n   * @throws {Error} When validation fails\n   */\n  parse(data: any): T\n\n  /**\n   * Optional schema name for debugging and error messages.\n   * Useful for identifying which schema failed in complex validation chains.\n   */\n  _name?: string | undefined\n}\n\n/**\n * Options for configuring JSON parsing behavior with security controls.\n *\n * @example\n * ```ts\n * const options: JsonParseOptions = {\n *   maxSize: 1024 * 1024, // 1MB limit\n *   allowPrototype: false // Block prototype pollution\n * }\n * ```\n */\nexport interface JsonParseOptions {\n  /**\n   * Allow dangerous prototype pollution keys (`__proto__`, `constructor`, `prototype`).\n   * Set to `true` only if you trust the JSON source completely.\n   *\n   * @default false\n   *\n   * @example\n   * ```ts\n   * // Will throw error by default\n   * safeJsonParse('{\"__proto__\": {\"polluted\": true}}')\n   *\n   * // Allows the parse (dangerous!)\n   * safeJsonParse('{\"__proto__\": {\"polluted\": true}}', undefined, {\n   *   allowPrototype: true\n   * })\n   * ```\n   */\n  allowPrototype?: boolean | undefined\n\n  /**\n   * Maximum allowed size of JSON string in bytes.\n   * Prevents memory exhaustion from extremely large payloads.\n   *\n   * @default 10_485_760 (10 MB)\n   *\n   * @example\n   * ```ts\n   * // Limit to 1KB\n   * safeJsonParse(jsonString, undefined, { maxSize: 1024 })\n   * ```\n   */\n  maxSize?: number | undefined\n}\n\n/**\n * Discriminated union type for JSON parsing results.\n * Enables type-safe handling of success and failure cases.\n *\n * @template T - The expected type of the parsed data\n *\n * @example\n * ```ts\n * const result: JsonParseResult<User> = parseJsonWithResult(jsonString)\n *\n * if (result.success) {\n *   // TypeScript knows result.data is available\n *   console.log(result.data.name)\n * } else {\n *   // TypeScript knows result.error is available\n *   console.error(result.error)\n * }\n * ```\n */\nexport type JsonParseResult<T> =\n  | { success: true; data: T }\n  | { success: false; error: string }\n"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
-  "names": []
-}

package/dist/versions.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/versions.ts"],
-  "sourcesContent": ["/** @fileoverview Version comparison and validation utilities for Socket ecosystem. */\n\nlet _semver: typeof import('semver') | undefined\n/*@__NO_SIDE_EFFECTS__*/\nfunction getSemver() {\n  if (_semver === undefined) {\n    // The 'semver' package is browser safe.\n    _semver = /*@__PURE__*/ require('./external/semver')\n  }\n  return _semver as typeof import('semver')\n}\n\n/**\n * Coerce a version string to valid semver format.\n */\nexport function coerceVersion(version: string): string | undefined {\n  const coerced = getSemver().coerce(version)\n  return coerced?.version\n}\n\n/**\n * Compare two semantic version strings.\n * @returns -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2, or undefined if invalid.\n */\nexport function compareVersions(\n  v1: string,\n  v2: string,\n): -1 | 0 | 1 | undefined {\n  try {\n    return getSemver().compare(v1, v2)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Get all versions from an array that satisfy a semver range.\n */\nexport function filterVersions(versions: string[], range: string): string[] {\n  return versions.filter(v => getSemver().satisfies(v, range))\n}\n\n/**\n * Get the major version number from a version string.\n */\nexport function getMajorVersion(version: string): number | undefined {\n  const parsed = getSemver().parse(version)\n  return parsed?.major\n}\n\n/**\n * Get the minor version number from a version string.\n */\nexport function getMinorVersion(version: string): number | undefined {\n  const parsed = getSemver().parse(version)\n  return parsed?.minor\n}\n\n/**\n * Get the patch version number from a version string.\n */\nexport function getPatchVersion(version: string): number | undefined {\n  const parsed = getSemver().parse(version)\n  return parsed?.patch\n}\n\n/**\n * Increment a version by the specified release type.\n */\nexport function incrementVersion(\n  version: string,\n  release:\n    | 'major'\n    | 'minor'\n    | 'patch'\n    | 'premajor'\n    | 'preminor'\n    | 'prepatch'\n    | 'prerelease',\n  identifier?: string | undefined,\n): string | undefined {\n  return getSemver().inc(version, release, identifier) || undefined\n}\n\n/**\n * Check if version1 equals version2.\n */\nexport function isEqual(version1: string, version2: string): boolean {\n  return getSemver().eq(version1, version2)\n}\n\n/**\n * Check if version1 is greater than version2.\n */\nexport function isGreaterThan(version1: string, version2: string): boolean {\n  return getSemver().gt(version1, version2)\n}\n\n/**\n * Check if version1 is greater than or equal to version2.\n */\nexport function isGreaterThanOrEqual(\n  version1: string,\n  version2: string,\n): boolean {\n  return getSemver().gte(version1, version2)\n}\n\n/**\n * Check if version1 is less than version2.\n */\nexport function isLessThan(version1: string, version2: string): boolean {\n  return getSemver().lt(version1, version2)\n}\n\n/**\n * Check if version1 is less than or equal to version2.\n */\nexport function isLessThanOrEqual(version1: string, version2: string): boolean {\n  return getSemver().lte(version1, version2)\n}\n\n/**\n * Validate if a string is a valid semantic version.\n */\nexport function isValidVersion(version: string): boolean {\n  return getSemver().valid(version) !== null\n}\n\n/**\n * Get the highest version from an array of versions.\n */\nexport function maxVersion(versions: string[]): string | undefined {\n  return getSemver().maxSatisfying(versions, '*') || undefined\n}\n\n/**\n * Get the lowest version from an array of versions.\n */\nexport function minVersion(versions: string[]): string | undefined {\n  return getSemver().minSatisfying(versions, '*') || undefined\n}\n\n/**\n * Parse a version string and return major, minor, patch components.\n */\nexport function parseVersion(version: string):\n  | {\n      major: number\n      minor: number\n      patch: number\n      prerelease: ReadonlyArray<string | number>\n      build: readonly string[]\n    }\n  | undefined {\n  const parsed = getSemver().parse(version)\n  if (!parsed) {\n    return undefined\n  }\n  return {\n    major: parsed.major,\n    minor: parsed.minor,\n    patch: parsed.patch,\n    prerelease: parsed.prerelease,\n    build: parsed.build,\n  }\n}\n\n/**\n * Check if a version satisfies a semver range.\n */\nexport function satisfiesVersion(version: string, range: string): boolean {\n  return getSemver().satisfies(version, range)\n}\n\n/**\n * Sort versions in ascending order.\n */\nexport function sortVersions(versions: string[]): string[] {\n  return getSemver().sort([...versions])\n}\n\n/**\n * Sort versions in descending order.\n */\nexport function sortVersionsDesc(versions: string[]): string[] {\n  return getSemver().rsort([...versions])\n}\n\n/**\n * Get the difference between two versions.\n */\nexport function versionDiff(\n  version1: string,\n  version2: string,\n):\n  | 'major'\n  | 'premajor'\n  | 'minor'\n  | 'preminor'\n  | 'patch'\n  | 'prepatch'\n  | 'prerelease'\n  | undefined {\n  try {\n    return getSemver().diff(version1, version2) || undefined\n  } catch {\n    return undefined\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,IAAI;AAAA;AAEJ,SAAS,YAAY;AACnB,MAAI,YAAY,QAAW;AAEzB,cAAwB,QAAQ,mBAAmB;AAAA,EACrD;AACA,SAAO;AACT;AAKO,SAAS,cAAc,SAAqC;AACjE,QAAM,WAAU,0BAAU,GAAE,OAAO,OAAO;AAC1C,SAAO,SAAS;AAClB;AAMO,SAAS,gBACd,IACA,IACwB;AACxB,MAAI;AACF,YAAO,0BAAU,GAAE,QAAQ,IAAI,EAAE;AAAA,EACnC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKO,SAAS,eAAe,UAAoB,OAAyB;AAC1E,SAAO,SAAS,OAAO,QAAK,0BAAU,GAAE,UAAU,GAAG,KAAK,CAAC;AAC7D;AAKO,SAAS,gBAAgB,SAAqC;AACnE,QAAM,UAAS,0BAAU,GAAE,MAAM,OAAO;AACxC,SAAO,QAAQ;AACjB;AAKO,SAAS,gBAAgB,SAAqC;AACnE,QAAM,UAAS,0BAAU,GAAE,MAAM,OAAO;AACxC,SAAO,QAAQ;AACjB;AAKO,SAAS,gBAAgB,SAAqC;AACnE,QAAM,UAAS,0BAAU,GAAE,MAAM,OAAO;AACxC,SAAO,QAAQ;AACjB;AAKO,SAAS,iBACd,SACA,SAQA,YACoB;AACpB,UAAO,0BAAU,GAAE,IAAI,SAAS,SAAS,UAAU,KAAK;AAC1D;AAKO,SAAS,QAAQ,UAAkB,UAA2B;AACnE,UAAO,0BAAU,GAAE,GAAG,UAAU,QAAQ;AAC1C;AAKO,SAAS,cAAc,UAAkB,UAA2B;AACzE,UAAO,0BAAU,GAAE,GAAG,UAAU,QAAQ;AAC1C;AAKO,SAAS,qBACd,UACA,UACS;AACT,UAAO,0BAAU,GAAE,IAAI,UAAU,QAAQ;AAC3C;AAKO,SAAS,WAAW,UAAkB,UAA2B;AACtE,UAAO,0BAAU,GAAE,GAAG,UAAU,QAAQ;AAC1C;AAKO,SAAS,kBAAkB,UAAkB,UAA2B;AAC7E,UAAO,0BAAU,GAAE,IAAI,UAAU,QAAQ;AAC3C;AAKO,SAAS,eAAe,SAA0B;AACvD,UAAO,0BAAU,GAAE,MAAM,OAAO,MAAM;AACxC;AAKO,SAAS,WAAW,UAAwC;AACjE,UAAO,0BAAU,GAAE,cAAc,UAAU,GAAG,KAAK;AACrD;AAKO,SAAS,WAAW,UAAwC;AACjE,UAAO,0BAAU,GAAE,cAAc,UAAU,GAAG,KAAK;AACrD;AAKO,SAAS,aAAa,SAQf;AACZ,QAAM,UAAS,0BAAU,GAAE,MAAM,OAAO;AACxC,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd,OAAO,OAAO;AAAA,IACd,OAAO,OAAO;AAAA,IACd,YAAY,OAAO;AAAA,IACnB,OAAO,OAAO;AAAA,EAChB;AACF;AAKO,SAAS,iBAAiB,SAAiB,OAAwB;AACxE,UAAO,0BAAU,GAAE,UAAU,SAAS,KAAK;AAC7C;AAKO,SAAS,aAAa,UAA8B;AACzD,UAAO,0BAAU,GAAE,KAAK,CAAC,GAAG,QAAQ,CAAC;AACvC;AAKO,SAAS,iBAAiB,UAA8B;AAC7D,UAAO,0BAAU,GAAE,MAAM,CAAC,GAAG,QAAQ,CAAC;AACxC;AAKO,SAAS,YACd,UACA,UASY;AACZ,MAAI;AACF,YAAO,0BAAU,GAAE,KAAK,UAAU,QAAQ,KAAK;AAAA,EACjD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/dist/words.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/words.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Word manipulation utilities for capitalization and formatting.\n * Provides text transformation functions for consistent word processing.\n */\n\n/**\n * Capitalize the first letter of a word.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function capitalize(word: string): string {\n  const { length } = word\n  if (length === 0) {\n    return word\n  }\n  if (length === 1) {\n    return word.toUpperCase()\n  }\n  return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`\n}\n\n/**\n * Determine the appropriate article (a/an) for a word.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function determineArticle(word: string): string {\n  return /^[aeiou]/.test(word) ? 'an' : 'a'\n}\n\nexport interface PluralizeOptions {\n  count?: number\n}\n\n/**\n * Pluralize a word based on count.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function pluralize(\n  word: string,\n  options?: PluralizeOptions | undefined,\n): string {\n  const { count = 1 } = { __proto__: null, ...options } as PluralizeOptions\n  // Handle 0, negatives, decimals, and values > 1 as plural.\n  return count === 1 ? word : `${word}s`\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,SAAS,WAAW,MAAsB;AAC/C,QAAM,EAAE,OAAO,IAAI;AACnB,MAAI,WAAW,GAAG;AAChB,WAAO;AAAA,EACT;AACA,MAAI,WAAW,GAAG;AAChB,WAAO,KAAK,YAAY;AAAA,EAC1B;AACA,SAAO,GAAG,KAAK,OAAO,CAAC,EAAE,YAAY,CAAC,GAAG,KAAK,MAAM,CAAC,EAAE,YAAY,CAAC;AACtE;AAAA;AAMO,SAAS,iBAAiB,MAAsB;AACrD,SAAO,WAAW,KAAK,IAAI,IAAI,OAAO;AACxC;AAAA;AAUO,SAAS,UACd,MACA,SACQ;AACR,QAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,MAAM,GAAG,QAAQ;AAEpD,SAAO,UAAU,IAAI,OAAO,GAAG,IAAI;AACrC;",
-  "names": []
-}

package/dist/zod.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/zod.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Zod schema validation library wrapper for type-safe runtime validation.\n * Provides access to zod's schema builder through the z object.\n */\n\nexport { z } from './external/zod'\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,iBAAkB;",
-  "names": []
-}