@socketsecurity/lib 6.0.3 → 6.0.4

package/dist/stdio/stderr.js

@@ -1,99 +1,194 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var stderr_exports = {};
-__export(stderr_exports, {
-  clearLine: () => clearLine,
-  cursorTo: () => cursorTo,
-  getColumns: () => getColumns,
-  getRows: () => getRows,
-  isTTY: () => isTTY,
-  stderr: () => stderr,
-  writeError: () => writeError,
-  writeErrorFormatted: () => writeErrorFormatted,
-  writeErrorLine: () => writeErrorLine,
-  writeStackTrace: () => writeStackTrace,
-  writeWarning: () => writeWarning
-});
-module.exports = __toCommonJS(stderr_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_internal = require("./_internal");
-const stderr = import_node_process.default.stderr;
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_stdio__internal = require('./_internal.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+
+//#region src/stdio/stderr.ts
+/**
+* @file Standard error stream utilities. Provides utilities for writing to
+*   stderr with formatting and control.
+*/
+const stderr = node_process.default.stderr;
+/**
+* Clear the current line on stderr. Only works in TTY environments.
+*
+* @example
+*   ;```ts
+*   writeError('Processing...')
+*   clearLine()
+*   writeError('Done!')
+*   ```
+*/
 function clearLine() {
-  (0, import_internal.clearLineOn)(stderr);
+	require_stdio__internal.clearLineOn(stderr);
 }
+/**
+* Move cursor to specific position on stderr. Only works in TTY environments.
+*
+* @example
+*   ;```ts
+*   cursorTo(0) // Move to start of line
+*   cursorTo(10, 5) // Move to column 10, row 5
+*   ```
+*
+* @param x - Column position (0-based)
+* @param y - Row position (0-based, optional)
+*/
 function cursorTo(x, y) {
-  (0, import_internal.cursorToOn)(stderr, x, y);
+	require_stdio__internal.cursorToOn(stderr, x, y);
 }
+/**
+* Get the number of columns (width) in the terminal.
+*
+* @example
+*   ```ts
+*   const width = getColumns()
+*   console.error(`Terminal is ${width} characters wide`)
+*   ```
+*
+* @default 80
+*
+* @returns Terminal width in characters
+*/
 function getColumns() {
-  return (0, import_internal.getColumnsOf)(stderr);
+	return require_stdio__internal.getColumnsOf(stderr);
 }
+/**
+* Get the number of rows (height) in the terminal.
+*
+* @example
+*   ```ts
+*   const height = getRows()
+*   console.error(`Terminal is ${height} lines tall`)
+*   ```
+*
+* @default 24
+*
+* @returns Terminal height in lines
+*/
 function getRows() {
-  return (0, import_internal.getRowsOf)(stderr);
+	return require_stdio__internal.getRowsOf(stderr);
 }
+/**
+* Check if stderr is connected to a TTY (terminal).
+*
+* @example
+*   ;```ts
+*   if (isTTY()) {
+*     // Show colored error messages
+*   } else {
+*     // Use plain text
+*   }
+*   ```
+*
+* @returns `true` if stderr is a TTY, `false` if piped/redirected
+*/
 function isTTY() {
-  return (0, import_internal.isTTYOf)(stderr);
+	return require_stdio__internal.isTTYOf(stderr);
 }
+/**
+* Write text to stderr without adding a newline.
+*
+* @example
+*   ;```ts
+*   writeError('Downloading...')
+*   // Later update progress
+*   ```
+*
+* @param text - Text to write.
+*/
 function writeError(text) {
-  stderr.write(text);
+	stderr.write(text);
 }
+/**
+* Write a formatted error message to stderr.
+*
+* @example
+*   ;```ts
+*   writeErrorFormatted('File not found')
+*   // Output: 'Error: File not found'
+*
+*   writeErrorFormatted('Connection failed', 'Network')
+*   // Output: 'Network: Connection failed'
+*   ```
+*
+* @default prefix 'Error'
+*
+* @param message - Error message text.
+* @param prefix - Prefix label for the error.
+*/
 function writeErrorFormatted(message, prefix = "Error") {
-  const formatted = `${prefix}: ${message}`;
-  writeErrorLine(formatted);
+	writeErrorLine(`${prefix}: ${message}`);
 }
+/**
+* Write a line to stderr with trailing newline. Used for error messages,
+* warnings, and diagnostic output. Passing no argument writes an empty line.
+*
+* @example
+*   ;```ts
+*   writeErrorLine('Error: File not found')
+*   writeErrorLine() // Write empty line
+*   ```
+*
+* @default text ''
+*
+* @param text - Text to write (defaults to the empty string)
+*/
 function writeErrorLine(text = "") {
-  stderr.write(`${text}
-`);
+	stderr.write(`${text}\n`);
 }
+/**
+* Write an error's stack trace to stderr. Falls back to formatted error message
+* if no stack is available.
+*
+* @example
+*   ;```ts
+*   try {
+*     throw new ErrorCtor('Something went wrong')
+*   } catch (e) {
+*     writeStackTrace(e as Error)
+*   }
+*   ```
+*
+* @param error - Error object to write.
+*/
 function writeStackTrace(error) {
-  if (error.stack) {
-    writeErrorLine(error.stack);
-  } else {
-    writeErrorFormatted(error.message);
-  }
+	if (error.stack) writeErrorLine(error.stack);
+	else writeErrorFormatted(error.message);
 }
+/**
+* Write a formatted warning message to stderr.
+*
+* @example
+*   ;```ts
+*   writeWarning('Deprecated API usage')
+*   // Output: 'Warning: Deprecated API usage'
+*
+*   writeWarning('Invalid config', 'Config')
+*   // Output: 'Config: Invalid config'
+*   ```
+*
+* @default prefix 'Warning'
+*
+* @param message - Warning message text.
+* @param prefix - Prefix label for the warning.
+*/
 function writeWarning(message, prefix = "Warning") {
-  const formatted = `${prefix}: ${message}`;
-  writeErrorLine(formatted);
+	writeErrorLine(`${prefix}: ${message}`);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clearLine,
-  cursorTo,
-  getColumns,
-  getRows,
-  isTTY,
-  stderr,
-  writeError,
-  writeErrorFormatted,
-  writeErrorLine,
-  writeStackTrace,
-  writeWarning
-});
+
+//#endregion
+exports.clearLine = clearLine;
+exports.cursorTo = cursorTo;
+exports.getColumns = getColumns;
+exports.getRows = getRows;
+exports.isTTY = isTTY;
+exports.stderr = stderr;
+exports.writeError = writeError;
+exports.writeErrorFormatted = writeErrorFormatted;
+exports.writeErrorLine = writeErrorLine;
+exports.writeStackTrace = writeStackTrace;
+exports.writeWarning = writeWarning;

package/dist/stdio/stdout.js

@@ -1,118 +1,201 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var stdout_exports = {};
-__export(stdout_exports, {
-  clearLine: () => clearLine,
-  clearScreenDown: () => clearScreenDown,
-  cursorTo: () => cursorTo,
-  ensureCursorOnExit: () => ensureCursorOnExit,
-  getColumns: () => getColumns,
-  getRows: () => getRows,
-  hideCursor: () => hideCursor,
-  isTTY: () => isTTY,
-  showCursor: () => showCursor,
-  stdout: () => stdout,
-  write: () => write,
-  writeLine: () => writeLine
-});
-module.exports = __toCommonJS(stdout_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_node_tty = require("node:tty");
-var import_internal = require("./_internal");
-const stdout = import_node_process.default.stdout;
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_stdio__internal = require('./_internal.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+let node_tty = require("node:tty");
+
+//#region src/stdio/stdout.ts
+/**
+* @file Standard output stream utilities. Provides utilities for writing to
+*   stdout with formatting and control.
+*/
+const stdout = node_process.default.stdout;
 let _cursorExitRegistered = false;
+/**
+* Clear the current line on stdout. Only works in TTY environments.
+*
+* @example
+*   ;```ts
+*   write('Processing...')
+*   clearLine()
+*   write('Done!')
+*   ```
+*/
 function clearLine() {
-  (0, import_internal.clearLineOn)(stdout);
+	require_stdio__internal.clearLineOn(stdout);
 }
+/**
+* Clear screen from cursor position down to bottom. Only works in TTY
+* environments.
+*
+* @example
+*   ;```ts
+*   cursorTo(0, 5)
+*   clearScreenDown() // Clear from row 5 to bottom
+*   ```
+*/
 function clearScreenDown() {
-  if (stdout.isTTY) {
-    stdout.clearScreenDown();
-  }
+	if (stdout.isTTY) stdout.clearScreenDown();
 }
+/**
+* Move cursor to specific position on stdout. Only works in TTY environments.
+*
+* @example
+*   ;```ts
+*   cursorTo(0) // Move to start of line
+*   cursorTo(10, 5) // Move to column 10, row 5
+*   ```
+*
+* @param x - Column position (0-based)
+* @param y - Row position (0-based, optional)
+*/
 function cursorTo(x, y) {
-  (0, import_internal.cursorToOn)(stdout, x, y);
+	require_stdio__internal.cursorToOn(stdout, x, y);
 }
+/**
+* Register handlers to ensure cursor is shown on process exit. Prevents hidden
+* cursor after abnormal termination. Handles SIGINT (Ctrl+C) and SIGTERM
+* signals.
+*
+* @example
+*   ;```ts
+*   ensureCursorOnExit()
+*   hideCursor()
+*   // Even if process crashes, cursor will be restored
+*   ```
+*/
 function ensureCursorOnExit() {
-  if (_cursorExitRegistered) {
-    return;
-  }
-  _cursorExitRegistered = true;
-  import_node_process.default.on("exit", showCursor);
-  import_node_process.default.on("SIGINT", () => {
-    showCursor();
-    import_node_process.default.exit(130);
-  });
-  import_node_process.default.on("SIGTERM", () => {
-    showCursor();
-    import_node_process.default.exit(143);
-  });
+	if (_cursorExitRegistered) return;
+	_cursorExitRegistered = true;
+	node_process.default.on("exit", showCursor);
+	node_process.default.on("SIGINT", () => {
+		showCursor();
+		node_process.default.exit(130);
+	});
+	node_process.default.on("SIGTERM", () => {
+		showCursor();
+		node_process.default.exit(143);
+	});
 }
+/**
+* Get the number of columns (width) in the terminal.
+*
+* @example
+*   ```ts
+*   const width = getColumns()
+*   console.log(`Terminal is ${width} characters wide`)
+*   ```
+*
+* @default 80
+*
+* @returns Terminal width in characters
+*/
 function getColumns() {
-  return (0, import_internal.getColumnsOf)(stdout);
+	return require_stdio__internal.getColumnsOf(stdout);
 }
+/**
+* Get the number of rows (height) in the terminal.
+*
+* @example
+*   ```ts
+*   const height = getRows()
+*   console.log(`Terminal is ${height} lines tall`)
+*   ```
+*
+* @default 24
+*
+* @returns Terminal height in lines
+*/
 function getRows() {
-  return (0, import_internal.getRowsOf)(stdout);
+	return require_stdio__internal.getRowsOf(stdout);
 }
+/**
+* Hide the cursor on stdout. Useful for cleaner output during animations.
+*
+* @example
+*   ;```ts
+*   hideCursor()
+*   // Show animation
+*   showCursor()
+*   ```
+*/
 function hideCursor() {
-  if (stdout.isTTY && stdout instanceof import_node_tty.WriteStream) {
-    stdout.write("\x1B[?25l");
-  }
+	if (stdout.isTTY && stdout instanceof node_tty.WriteStream) stdout.write("\x1B[?25l");
 }
+/**
+* Check if stdout is connected to a TTY (terminal).
+*
+* @example
+*   ;```ts
+*   if (isTTY()) {
+*     // Show interactive UI
+*   } else {
+*     // Use simple text output
+*   }
+*   ```
+*
+* @returns `true` if stdout is a TTY, `false` if piped/redirected
+*/
 function isTTY() {
-  return (0, import_internal.isTTYOf)(stdout);
+	return require_stdio__internal.isTTYOf(stdout);
 }
+/**
+* Show the cursor on stdout. Should be called after `hideCursor()`.
+*
+* @example
+*   ;```ts
+*   hideCursor()
+*   // Show animation
+*   showCursor()
+*   ```
+*/
 function showCursor() {
-  if (stdout.isTTY && stdout instanceof import_node_tty.WriteStream) {
-    stdout.write("\x1B[?25h");
-  }
+	if (stdout.isTTY && stdout instanceof node_tty.WriteStream) stdout.write("\x1B[?25h");
 }
+/**
+* Write text to stdout without adding a newline.
+*
+* @example
+*   ;```ts
+*   write('Loading...')
+*   // Later: clear and update
+*   ```
+*
+* @param text - Text to write.
+*/
 function write(text) {
-  stdout.write(text);
+	stdout.write(text);
 }
+/**
+* Write a line to stdout with trailing newline.
+*
+* @example
+*   ;```ts
+*   writeLine('Hello, world!')
+*   writeLine() // Write empty line
+*   ```
+*
+* @default text ''
+*
+* @param text - Text to write.
+*/
 function writeLine(text = "") {
-  stdout.write(`${text}
-`);
+	stdout.write(`${text}\n`);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clearLine,
-  clearScreenDown,
-  cursorTo,
-  ensureCursorOnExit,
-  getColumns,
-  getRows,
-  hideCursor,
-  isTTY,
-  showCursor,
-  stdout,
-  write,
-  writeLine
-});
+
+//#endregion
+exports.clearLine = clearLine;
+exports.clearScreenDown = clearScreenDown;
+exports.cursorTo = cursorTo;
+exports.ensureCursorOnExit = ensureCursorOnExit;
+exports.getColumns = getColumns;
+exports.getRows = getRows;
+exports.hideCursor = hideCursor;
+exports.isTTY = isTTY;
+exports.showCursor = showCursor;
+exports.stdout = stdout;
+exports.write = write;
+exports.writeLine = writeLine;

package/dist/streams/parallel.js

@@ -1,55 +1,63 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var parallel_exports = {};
-__export(parallel_exports, {
-  parallelEach: () => parallelEach,
-  parallelMap: () => parallelMap
-});
-module.exports = __toCommonJS(parallel_exports);
-var import_streaming_iterables = require("../external/streaming-iterables");
-var import_options = require("../promises/options");
-var import_retry = require("../promises/retry");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_promises_options = require('../promises/options.js');
+const require_promises_retry = require('../promises/retry.js');
+let src_external_streaming_iterables = require("../external/streaming-iterables");
+
+//#region src/streams/parallel.ts
+/**
+* @file Parallel iteration helpers — `parallelMap()` and the fire-and-forget
+*   `parallelEach()`. Built on top of `streaming-iterables.parallelMap` with
+*   the project's `pRetry` wrapper applied per item.
+*/
+/**
+* Execute a function for each item in an iterable in parallel.
+*
+* @example
+*   ;```typescript
+*   const urls = ['https://a.io', 'https://b.io']
+*   await parallelEach(
+*     urls,
+*     async url => {
+*       await fetch(url)
+*     },
+*     { concurrency: 4 },
+*   )
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 async function parallelEach(iterable, func, options) {
-  for await (const _ of /* @__PURE__ */ parallelMap(iterable, func, options)) {
-  }
+	for await (const _ of /* @__PURE__ */ parallelMap(iterable, func, options));
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Map over an iterable in parallel with concurrency control.
+*
+* @example
+*   ;```typescript
+*   const ids = [1, 2, 3]
+*   for await (const result of parallelMap(
+*     ids,
+*     async id => {
+*       return await fetchData(id)
+*     },
+*     4,
+*   )) {
+*     console.log(result)
+*   }
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function parallelMap(iterable, func, options) {
-  const opts = (0, import_options.normalizeIterationOptions)(options);
-  const result = (0, import_streaming_iterables.parallelMap)(
-    opts.concurrency,
-    async (item) => {
-      const result2 = await (0, import_retry.pRetry)((...args) => func(args[0]), {
-        ...opts.retries,
-        args: [item]
-      });
-      return result2;
-    },
-    iterable
-  );
-  return result;
+	const opts = /* @__PURE__ */ require_promises_options.normalizeIterationOptions(options);
+	return (0, src_external_streaming_iterables.parallelMap)(opts.concurrency, async (item) => {
+		return await /* @__PURE__ */ require_promises_retry.pRetry((...args) => func(args[0]), {
+			...opts.retries,
+			args: [item]
+		});
+	}, iterable);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parallelEach,
-  parallelMap
-});
+
+//#endregion
+exports.parallelEach = parallelEach;
+exports.parallelMap = parallelMap;