lifecycleion 0.0.1

package/dist/lib/safe-handle-callback.cjs

@@ -0,0 +1,818 @@
+"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);
+
+// src/lib/safe-handle-callback.ts
+var safe_handle_callback_exports = {};
+__export(safe_handle_callback_exports, {
+  safeHandleCallback: () => safeHandleCallback,
+  safeHandleCallbackAndWait: () => safeHandleCallbackAndWait
+});
+module.exports = __toCommonJS(safe_handle_callback_exports);
+
+// src/lib/strings.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function splitGraphemes(text) {
+  const graphemes = [];
+  let grapheme = "";
+  let zwjSequence = "";
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const nextChar = text[i + 1] || "";
+    const code = char.charCodeAt(0);
+    if (code >= 768 && code <= 879 || // Combining Diacritical Marks
+    code >= 6832 && code <= 6911 || // Combining Diacritical Marks Extended
+    code >= 7616 && code <= 7679 || // Combining Diacritical Marks Supplement
+    code >= 65056 && code <= 65071 || // Combining Half Marks
+    code >= 3633 && code <= 3642 || // Thai combining marks
+    code >= 3655 && code <= 3662) {
+      grapheme += char;
+    } else if (char === "\u200D") {
+      zwjSequence += grapheme + char;
+      grapheme = "";
+    } else {
+      if (grapheme) {
+        if (zwjSequence) {
+          graphemes.push(zwjSequence + grapheme);
+          zwjSequence = "";
+        } else {
+          graphemes.push(grapheme);
+        }
+      }
+      grapheme = char;
+      if (char >= "\uD800" && char <= "\uDBFF" && nextChar >= "\uDC00" && nextChar <= "\uDFFF") {
+        grapheme += nextChar;
+        i++;
+      }
+    }
+  }
+  if (grapheme) {
+    if (zwjSequence) {
+      graphemes.push(zwjSequence + grapheme);
+    } else {
+      graphemes.push(grapheme);
+    }
+  }
+  return graphemes;
+}
+
+// src/lib/constants.ts
+var BLANK_SPACE = " ";
+var EOL = "\n";
+var DOUBLE_EOL = EOL + EOL;
+var INDENT = " ".repeat(4);
+var DOUBLE_INDENT = INDENT + INDENT;
+var ASCII_LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+var ASCII_UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var ASCII_LETTERS = ASCII_LOWERCASE + ASCII_UPPERCASE;
+var DIGITS = "0123456789";
+var HEX_DIGITS = DIGITS + "abcdefABCDEF";
+var PUNCTUATION = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+var WHITESPACE = " 	\n\r\v\f";
+var PRINTABLE = DIGITS + ASCII_LETTERS + PUNCTUATION + WHITESPACE;
+
+// src/lib/padding-utils.ts
+function padLeft(str, length, padStr = BLANK_SPACE) {
+  return str.padStart(length, padStr);
+}
+function padRight(str, length, padStr = BLANK_SPACE) {
+  return str.padEnd(length, padStr);
+}
+function padCenter(str, length, prefer = "left", padStr = BLANK_SPACE) {
+  const midStrLength = length - str.length;
+  if (midStrLength > 0) {
+    const padLeftAmount = prefer === "left" ? Math.ceil(midStrLength / 2) : Math.floor(midStrLength / 2);
+    const padRightAmount = prefer === "left" ? Math.floor(midStrLength / 2) : Math.ceil(midStrLength / 2);
+    return padLeft("", padLeftAmount, padStr) + str + padRight("", padRightAmount, padStr);
+  } else {
+    return str;
+  }
+}
+function padCenterPreferRight(str, length, padStr = BLANK_SPACE) {
+  return padCenter(str, length, "right", padStr);
+}
+
+// src/lib/ascii-tables/ascii-table-utils.ts
+var import_string_width = __toESM(require("string-width"), 1);
+var ASCIITableUtils = class _ASCIITableUtils {
+  static centerText(text, width) {
+    return padCenterPreferRight(text, width, " ");
+  }
+  static createSeparator(columnWidths, character = "=") {
+    const totalWidth = columnWidths.reduce((sum, width) => sum + width + 3, 0) - 1;
+    return `+${padRight("", totalWidth, character)}+`;
+  }
+  static wrapText(text, maxLength) {
+    const words = text.split(" ");
+    const lines = [];
+    let currentLine = "";
+    for (const word of words) {
+      if ((0, import_string_width.default)(currentLine) + (0, import_string_width.default)(word) + 1 <= maxLength) {
+        currentLine += (currentLine ? " " : "") + word;
+      } else {
+        if (currentLine) {
+          lines.push(currentLine);
+        }
+        if ((0, import_string_width.default)(word) <= maxLength) {
+          currentLine = word;
+        } else {
+          const subWords = _ASCIITableUtils.splitWord(word, maxLength);
+          lines.push(...subWords.slice(0, -1));
+          currentLine = subWords[subWords.length - 1];
+        }
+      }
+    }
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+    return lines;
+  }
+  static splitWord(word, maxLength) {
+    const graphemes = splitGraphemes(word);
+    const subWords = [];
+    let currentSubWord = "";
+    for (const grapheme of graphemes) {
+      if ((0, import_string_width.default)(currentSubWord + grapheme) <= maxLength) {
+        currentSubWord += grapheme;
+      } else {
+        subWords.push(currentSubWord);
+        currentSubWord = grapheme;
+      }
+    }
+    if (currentSubWord) {
+      subWords.push(currentSubWord);
+    }
+    return subWords;
+  }
+};
+
+// src/lib/ascii-tables/multi-column-ascii-table.ts
+var import_string_width2 = __toESM(require("string-width"), 1);
+var MultiColumnASCIITable = class {
+  headers;
+  rows;
+  tableWidth;
+  emptyMessage;
+  widthMode;
+  constructor(headers, options = {}) {
+    this.headers = headers;
+    this.rows = [];
+    this.tableWidth = options.tableWidth || 80;
+    this.emptyMessage = options.emptyMessage || "";
+    this.widthMode = options.widthMode || "flex";
+    const minTableWidth = this.getMinimumWidth();
+    if (this.tableWidth < minTableWidth) {
+      throw new Error(
+        `Table width must be at least ${minTableWidth} to accommodate the headers.`
+      );
+    }
+  }
+  getMinimumWidth() {
+    return this.headers.length * 4 + 1;
+  }
+  addRow(row) {
+    if (row.length !== this.headers.length) {
+      throw new Error(
+        `Number of values in the row (${row.length}) must match the number of headers (${this.headers.length}).`
+      );
+    }
+    this.rows.push(row);
+  }
+  toString(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const emptyMessage = options.emptyMessage || this.emptyMessage;
+    if (this.rows.length === 0) {
+      const emptyTableWidth = Math.min(tableWidth, 40);
+      const separator = "+" + "-".repeat(emptyTableWidth - 2) + "+";
+      const emptyMessageLines = ASCIITableUtils.wrapText(
+        emptyMessage,
+        emptyTableWidth - 4
+      );
+      const emptyRows = emptyMessageLines.map((line) => {
+        const paddingLeft = " ".repeat(
+          Math.floor((emptyTableWidth - (0, import_string_width2.default)(line) - 4) / 2)
+        );
+        const paddingRight = " ".repeat(
+          Math.ceil((emptyTableWidth - (0, import_string_width2.default)(line) - 4) / 2)
+        );
+        return `| ${paddingLeft}${line}${paddingRight} |`;
+      });
+      if (emptyRows.length === 0) {
+        emptyRows.push(`| ${" ".repeat(emptyTableWidth - 4)} |`);
+      }
+      return [separator, ...emptyRows, separator].join("\n");
+    }
+    const columnWidths = this.calculateColumnWidths(options);
+    const headerSeparator = ASCIITableUtils.createSeparator(columnWidths);
+    const rowSeparator = ASCIITableUtils.createSeparator(columnWidths, "-");
+    let tableString = headerSeparator + "\n";
+    const header = this.renderRow(this.headers, columnWidths);
+    tableString += header + "\n" + rowSeparator + "\n";
+    const rows = this.rows.map((row) => {
+      return this.renderRow(row, columnWidths);
+    });
+    tableString += rows.join("\n" + rowSeparator + "\n");
+    tableString += "\n" + headerSeparator;
+    return tableString;
+  }
+  calculateColumnWidths(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const widthMode = options.widthMode || this.widthMode;
+    const numColumns = this.headers.length;
+    if (widthMode === "fixed") {
+      const availableWidth2 = tableWidth - (numColumns + 1) * 3 + 1;
+      const columnWidth = Math.floor(availableWidth2 / numColumns);
+      const extraWidth = availableWidth2 % numColumns;
+      const columnWidths = new Array(numColumns).fill(columnWidth);
+      for (let i = 0; i < extraWidth; i++) {
+        columnWidths[i] += 1;
+      }
+      return columnWidths;
+    }
+    const availableWidth = tableWidth - (numColumns + 1) * 3 + 1;
+    const maxColumnWidth = Math.floor(availableWidth / numColumns);
+    const totalContentWidth = this.headers.reduce(
+      (sum, header) => sum + (0, import_string_width2.default)(header),
+      0
+    );
+    if (availableWidth >= totalContentWidth) {
+      const remainingWidth = availableWidth - totalContentWidth;
+      const extraCharWidth = Math.floor(remainingWidth / numColumns);
+      const extraCharRemainder = remainingWidth % numColumns;
+      const columnWidths = this.headers.map((header, index) => {
+        const extraWidth = index < extraCharRemainder ? 1 : 0;
+        return (0, import_string_width2.default)(header) + extraCharWidth + extraWidth;
+      });
+      return columnWidths;
+    } else {
+      const columnWidths = this.headers.map(() => maxColumnWidth);
+      return columnWidths;
+    }
+  }
+  renderRow(row, columnWidths) {
+    const wrappedCells = row.map((value, index) => {
+      const wrappedLines = ASCIITableUtils.wrapText(value, columnWidths[index]);
+      return wrappedLines.map((line) => line.padEnd(columnWidths[index])).join("\n");
+    });
+    const maxLines = Math.max(
+      ...wrappedCells.map((cell) => cell.split("\n").length)
+    );
+    const paddedRows = [];
+    for (let i = 0; i < maxLines; i++) {
+      const rowLine = wrappedCells.map((cell, index) => {
+        const cellLines = cell.split("\n");
+        const cellLine = cellLines[i] || "";
+        const padding = " ".repeat(columnWidths[index] - (0, import_string_width2.default)(cellLine));
+        return " " + cellLine + padding + " ";
+      });
+      paddedRows.push("|" + rowLine.join("|") + "|");
+    }
+    return paddedRows.join("\n");
+  }
+};
+
+// src/lib/ascii-tables/key-value-ascii-table.ts
+var import_string_width3 = __toESM(require("string-width"), 1);
+
+// src/lib/clamp.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+
+// src/lib/ascii-tables/key-value-ascii-table.ts
+var KeyValueASCIITable = class _KeyValueASCIITable {
+  tableWidth;
+  emptyMessage;
+  autoAdjustWidthWhenPossible = true;
+  rows = [];
+  constructor(options = {}) {
+    const minTableWidth = this.getMinimumWidth();
+    if (options.tableWidth && options.tableWidth < minTableWidth) {
+      throw new Error(
+        `Table width must be at least ${minTableWidth} to accommodate the table structure.`
+      );
+    }
+    this.tableWidth = options.tableWidth || 80;
+    this.autoAdjustWidthWhenPossible = options.autoAdjustWidthWhenPossible ?? true;
+    this.emptyMessage = options.emptyMessage || "";
+  }
+  getMinimumWidth() {
+    return 9;
+  }
+  /**
+   * Adds key and value to the table but placing the value on its own row.
+   *
+   * @param key
+   * @param value
+   */
+  addValueOnSeparateRow(key, value) {
+    const row = { kind: "own", key, value };
+    this.rows.push(row);
+  }
+  /**
+   * Adds key and value to the table.
+   *
+   * If provided value is an instance of ASCIITable or MultiColumnASCIITable, it will be rendered as a nested table on its own row for readability.
+   *
+   * @param key
+   * @param value
+   */
+  addRow(key, value) {
+    const row = { kind: "regular", key, value };
+    this.rows.push(row);
+  }
+  toString(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const canAutoAdjustWidthWhenPossible = options.autoAdjustWidthWhenPossible ?? this.autoAdjustWidthWhenPossible;
+    const emptyMessage = options.emptyMessage || this.emptyMessage;
+    if (this.rows.length === 0) {
+      const emptyTableWidth = Math.min(tableWidth, 40);
+      const separator = "+" + "-".repeat(emptyTableWidth - 2) + "+";
+      const emptyMessageLines = ASCIITableUtils.wrapText(
+        emptyMessage,
+        emptyTableWidth - 4
+      );
+      const emptyRows = emptyMessageLines.map((line) => {
+        const paddingLeft = padRight(
+          "",
+          Math.floor((emptyTableWidth - (0, import_string_width3.default)(line) - 4) / 2),
+          " "
+        );
+        const paddingRight = padRight(
+          "",
+          Math.ceil((emptyTableWidth - (0, import_string_width3.default)(line) - 4) / 2),
+          " "
+        );
+        return `| ${paddingLeft}${line}${paddingRight} |`;
+      });
+      if (emptyRows.length === 0) {
+        emptyRows.push(`| ${" ".repeat(emptyTableWidth - 4)} |`);
+      }
+      return [separator, ...emptyRows, separator].join("\n");
+    }
+    const columnWidths = this.calculateColumnWidths(options);
+    const headerSeparator = ASCIITableUtils.createSeparator(columnWidths);
+    const rowSeparator = ASCIITableUtils.createSeparator(columnWidths, "-");
+    let tableString = headerSeparator + "\n";
+    for (const [rowIndex, row] of this.rows.entries()) {
+      const { kind, key, value } = row;
+      if (kind === "own" || value instanceof _KeyValueASCIITable || value instanceof MultiColumnASCIITable || Array.isArray(value)) {
+        const keyString = ASCIITableUtils.centerText(
+          key,
+          columnWidths[0] + columnWidths[1] + 3
+        );
+        tableString += `| ${keyString} |
+`;
+        tableString += rowSeparator + "\n";
+        let valueString = "";
+        if (value instanceof _KeyValueASCIITable) {
+          valueString = this.formatValue(
+            value,
+            tableWidth - 4,
+            canAutoAdjustWidthWhenPossible,
+            ""
+          );
+        } else if (value instanceof MultiColumnASCIITable) {
+          valueString = this.formatValue(
+            value,
+            tableWidth - 4,
+            canAutoAdjustWidthWhenPossible,
+            ""
+          );
+        } else if (Array.isArray(value)) {
+          valueString = this.formatValue(
+            value,
+            tableWidth - 4,
+            canAutoAdjustWidthWhenPossible,
+            ""
+          );
+        } else if (row.kind === "own") {
+          valueString = this.formatTableRowOnOwnRow(
+            value,
+            tableWidth - 4,
+            tableWidth
+          );
+        }
+        const valueLines = valueString.split("\n");
+        const paddedValueLines = valueLines.map((line) => {
+          const padding = padRight("", tableWidth - (0, import_string_width3.default)(line) - 4, " ");
+          return `| ${line}${padding} |`;
+        });
+        tableString += paddedValueLines.join("\n") + "\n";
+        tableString += headerSeparator + "\n";
+      } else {
+        const keyLines = ASCIITableUtils.wrapText(key, columnWidths[0]);
+        const valueLines = ASCIITableUtils.wrapText(
+          this.formatValue(
+            value,
+            columnWidths[1],
+            canAutoAdjustWidthWhenPossible,
+            ""
+          ),
+          columnWidths[1]
+        );
+        const maxLines = Math.max(keyLines.length, valueLines.length);
+        for (let i = 0; i < maxLines; i++) {
+          const keyLine = keyLines[i] || "";
+          const valueLine = valueLines[i] || "";
+          const keyPadding = " ".repeat(columnWidths[0] - (0, import_string_width3.default)(keyLine));
+          const valuePadding = " ".repeat(
+            columnWidths[1] - (0, import_string_width3.default)(valueLine)
+          );
+          tableString += `| ${keyLine}${keyPadding} | ${valueLine}${valuePadding} |
+`;
+          if (i === maxLines - 1) {
+            if (rowIndex === this.rows.length - 1) {
+              tableString += headerSeparator + "\n";
+            } else {
+              tableString += rowSeparator + "\n";
+            }
+          }
+        }
+      }
+    }
+    return tableString.trim();
+  }
+  calculateColumnWidths(options = {}) {
+    const tableWidth = options.tableWidth || this.tableWidth;
+    const canAutoAdjustWidthWhenPossible = options.autoAdjustWidthWhenPossible ?? this.autoAdjustWidthWhenPossible;
+    const columnWidths = [0, 0];
+    for (const row of this.rows) {
+      const { key, value } = row;
+      const keyWidth = (0, import_string_width3.default)(key);
+      const maxKeyWidth = Math.floor((tableWidth - 7) / 2);
+      if (keyWidth > columnWidths[0]) {
+        columnWidths[0] = Math.min(keyWidth, maxKeyWidth);
+        columnWidths[1] = Math.max(0, tableWidth - columnWidths[0] - 7);
+      }
+      if (typeof value === "string") {
+        const valueWidth = Math.max(
+          ...value.split("\n").map((line) => (0, import_string_width3.default)(line))
+        );
+        if (valueWidth > columnWidths[1]) {
+          columnWidths[1] = Math.min(
+            valueWidth,
+            tableWidth - columnWidths[0] - 7
+          );
+          columnWidths[0] = Math.max(0, tableWidth - columnWidths[1] - 7);
+        }
+      } else if (row.kind === "own") {
+        let valueWidth = 0;
+        if (isString(value)) {
+          valueWidth = Math.max(
+            ...value.split("\n").map((line) => (0, import_string_width3.default)(line))
+          );
+        }
+        if (valueWidth > columnWidths[1]) {
+          columnWidths[1] = Math.min(
+            valueWidth,
+            tableWidth - columnWidths[0] - 7
+          );
+          columnWidths[0] = Math.max(0, tableWidth - columnWidths[1] - 7);
+        }
+      } else if (value instanceof _KeyValueASCIITable) {
+        let nestedTableColumnWidths = [];
+        if (canAutoAdjustWidthWhenPossible) {
+          const minWidth = value.getMinimumWidth();
+          const availableWidth2 = tableWidth - columnWidths[0] - 7;
+          const adjustedWidth = clamp(availableWidth2, minWidth, availableWidth2);
+          nestedTableColumnWidths = value.calculateColumnWidths({
+            tableWidth: adjustedWidth
+          });
+        } else {
+          nestedTableColumnWidths = value.calculateColumnWidths();
+        }
+        const nestedTableWidth = nestedTableColumnWidths.reduce((sum, width) => sum + width, 0) + nestedTableColumnWidths.length * 3 - 1;
+        const availableWidth = tableWidth - columnWidths[0] - 7;
+        if (nestedTableWidth > availableWidth) {
+          columnWidths[1] = availableWidth;
+        } else {
+          columnWidths[1] = Math.max(columnWidths[1], nestedTableWidth);
+        }
+      } else if (value instanceof MultiColumnASCIITable) {
+        let nestedTableColumnWidths = [];
+        if (canAutoAdjustWidthWhenPossible) {
+          const minWidth = value.getMinimumWidth();
+          const availableWidth2 = tableWidth - columnWidths[0] - 7;
+          const adjustedWidth = clamp(availableWidth2, minWidth, availableWidth2);
+          nestedTableColumnWidths = value.calculateColumnWidths({
+            tableWidth: adjustedWidth
+          });
+        } else {
+          nestedTableColumnWidths = value.calculateColumnWidths();
+        }
+        const nestedTableWidth = nestedTableColumnWidths.reduce((sum, width) => sum + width, 0) + nestedTableColumnWidths.length * 3 - 1;
+        const availableWidth = tableWidth - columnWidths[0] - 7;
+        if (nestedTableWidth > availableWidth) {
+          columnWidths[1] = availableWidth;
+        } else {
+          columnWidths[1] = Math.max(columnWidths[1], nestedTableWidth);
+        }
+      } else if (Array.isArray(value)) {
+        for (const nestedCell of value) {
+          const nestedKeyWidth = (0, import_string_width3.default)(nestedCell.key);
+          const maxNestedKeyWidth = Math.floor((tableWidth - 7) / 2);
+          if (nestedKeyWidth > columnWidths[0]) {
+            columnWidths[0] = Math.min(nestedKeyWidth, maxNestedKeyWidth);
+            columnWidths[1] = Math.max(0, tableWidth - columnWidths[0] - 7);
+          }
+          if (typeof nestedCell.value === "string") {
+            const nestedValueWidth = Math.max(
+              ...nestedCell.value.split("\n").map((line) => (0, import_string_width3.default)(line))
+            );
+            if (nestedValueWidth > columnWidths[1]) {
+              columnWidths[1] = Math.min(
+                nestedValueWidth,
+                tableWidth - columnWidths[0] - 7
+              );
+              columnWidths[0] = Math.max(0, tableWidth - columnWidths[1] - 7);
+            }
+          }
+        }
+      }
+    }
+    return columnWidths;
+  }
+  formatValue(value, cellWidth, canAutoAdjustWidthWhenPossible, indent = "") {
+    if (typeof value === "string") {
+      return value;
+    } else if (typeof value === "number") {
+      return String(value);
+    } else if (typeof value === "boolean") {
+      return String(value);
+    } else if (value === null) {
+      return "null";
+    } else if (value === void 0) {
+      return "undefined";
+    } else if (value instanceof _KeyValueASCIITable) {
+      let nestedTableLines;
+      if (canAutoAdjustWidthWhenPossible) {
+        const minWidth = value.getMinimumWidth();
+        const adjustedWidth = clamp(cellWidth, minWidth, cellWidth);
+        nestedTableLines = value.toString({ tableWidth: adjustedWidth }).split("\n");
+      } else {
+        nestedTableLines = value.toString().split("\n");
+      }
+      const indentedLines = nestedTableLines.map((line) => `${indent}${line}`);
+      return indentedLines.join("\n");
+    } else if (value instanceof MultiColumnASCIITable) {
+      let nestedTableLines;
+      if (canAutoAdjustWidthWhenPossible) {
+        const minWidth = value.getMinimumWidth();
+        const adjustedWidth = clamp(cellWidth, minWidth, cellWidth);
+        nestedTableLines = value.toString({ tableWidth: adjustedWidth }).split("\n");
+      } else {
+        nestedTableLines = value.toString().split("\n");
+      }
+      const indentedLines = nestedTableLines.map((line) => `${indent}${line}`);
+      return indentedLines.join("\n");
+    } else if (Array.isArray(value)) {
+      const nestedValueLines = [];
+      for (const { key, value: nestedValue } of value) {
+        const formattedKey = `${indent}${key}:`;
+        const formattedValue = this.formatValue(
+          nestedValue,
+          cellWidth - indent.length - (0, import_string_width3.default)(key) - 2,
+          canAutoAdjustWidthWhenPossible,
+          `${indent}`
+        );
+        const wrappedSpacer = padRight("", 4, " ");
+        const wrappedValue = formattedValue.split("\n").map((line) => `${indent}${wrappedSpacer}${line}`);
+        nestedValueLines.push(formattedKey);
+        nestedValueLines.push(...wrappedValue);
+        nestedValueLines.push("");
+      }
+      return nestedValueLines.slice(0, -1).join("\n");
+    } else {
+      throw new TypeError("Invalid value type provided");
+    }
+  }
+  formatTableRowOnOwnRow(value, width, maxRowLength) {
+    const lines = value.split("\n");
+    const paddedLines = lines.map((line) => {
+      const wrappedLines = ASCIITableUtils.wrapText(line, maxRowLength - 4);
+      return wrappedLines.map((wrappedLine) => {
+        const padding = padRight(
+          "",
+          width - (0, import_string_width3.default)(wrappedLine) - 2,
+          " "
+        );
+        return `${wrappedLine}${padding}`;
+      }).join("\n");
+    });
+    return paddedLines.join("\n");
+  }
+};
+
+// src/lib/error-to-string.ts
+function safeStringify(value) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(value);
+    case "object":
+      return JSON.stringify(value);
+    case "function":
+      return "[Function]";
+    case "symbol":
+      return value.toString();
+    default:
+      return String(value);
+  }
+}
+function errorToString(error, maxRowLength = 80) {
+  const table = errorToASCIITable(error, maxRowLength);
+  return table.toString();
+}
+function errorToASCIITable(error, maxRowLength) {
+  const table = new KeyValueASCIITable({
+    tableWidth: maxRowLength,
+    autoAdjustWidthWhenPossible: true
+  });
+  if (error && typeof error === "object") {
+    const err = error;
+    table.addRow("Key", "Value");
+    if (err["message"]) {
+      table.addRow("Message", safeStringify(err["message"]));
+    }
+    if (err["name"]) {
+      table.addRow("Name", safeStringify(err["name"]));
+    }
+    if (err["code"]) {
+      table.addRow("Code", safeStringify(err["code"]));
+    }
+    if (err["errno"]) {
+      table.addRow("Errno", safeStringify(err["errno"]));
+    }
+    if (err["errPrefix"]) {
+      table.addRow("Prefix", safeStringify(err["errPrefix"]));
+    }
+    if (err["errType"]) {
+      table.addRow("errType", safeStringify(err["errType"]));
+    }
+    if (err["errCode"]) {
+      table.addRow("errCode", safeStringify(err["errCode"]));
+    }
+    if (err["additionalInfo"]) {
+      const additionalInfo = err["additionalInfo"];
+      const sensitiveFieldNames = err["sensitiveFieldNames"] || [];
+      for (const key in additionalInfo) {
+        if (sensitiveFieldNames.includes(key)) {
+          table.addRow(`AdditionalInfo.${key}`, "***");
+        } else {
+          const value = additionalInfo[key];
+          table.addRow(
+            `AdditionalInfo.${key}`,
+            stringifyValue(value, table, maxRowLength)
+          );
+        }
+      }
+    }
+    if (err["stack"]) {
+      table.addValueOnSeparateRow("Stack", safeStringify(err["stack"]));
+    }
+  }
+  return table;
+}
+function stringifyValue(value, table, maxRowLength) {
+  if (typeof value === "string") {
+    return value;
+  } else if (Array.isArray(value)) {
+    return value.map((item) => {
+      const result = stringifyValue(item, table, maxRowLength);
+      if (typeof result === "string") {
+        return result;
+      } else if (result instanceof KeyValueASCIITable) {
+        return result.toString();
+      } else {
+        return JSON.stringify(result);
+      }
+    }).join(", ");
+  } else if (typeof value === "object" && value !== null) {
+    if (value instanceof Error) {
+      return errorToASCIITable(value, maxRowLength - 4);
+    } else {
+      const entries = Object.entries(value).map(
+        ([key, val]) => ({
+          key,
+          value: stringifyValue(val, table, maxRowLength - 4)
+        })
+      );
+      return entries;
+    }
+  } else {
+    return String(value);
+  }
+}
+
+// src/lib/is-promise.ts
+function isPromise(obj) {
+  return !!obj && (typeof obj === "object" || typeof obj === "function") && // @ts-expect-error - obj is checked to be object/function, then property access works at runtime
+  typeof obj["then"] === "function";
+}
+
+// src/lib/is-function.ts
+function isFunction(value) {
+  return typeof value === "function" || value instanceof Function;
+}
+
+// src/lib/safe-handle-callback.ts
+function safeHandleCallback(callbackName, callback, ...args) {
+  const handleError = (error) => {
+    if (typeof globalThis.dispatchEvent === "function") {
+      globalThis.dispatchEvent(
+        new ErrorEvent("reportError", {
+          error: new Error(
+            `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
+          )
+        })
+      );
+    }
+  };
+  if (isFunction(callback)) {
+    try {
+      const result = callback(...args);
+      if (isPromise(result)) {
+        result.catch((error) => {
+          handleError(error);
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  } else {
+    handleError(
+      new Error(`Callback provided for ${callbackName} is not a function`)
+    );
+  }
+}
+async function safeHandleCallbackAndWait(callbackName, callback, ...args) {
+  const handleError = (error) => {
+    if (typeof globalThis.dispatchEvent === "function") {
+      globalThis.dispatchEvent(
+        new ErrorEvent("reportError", {
+          error: new Error(
+            `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
+          )
+        })
+      );
+    }
+    return { success: false, error };
+  };
+  if (isFunction(callback)) {
+    try {
+      const result = callback(...args);
+      if (isPromise(result)) {
+        const value = await result;
+        return { success: true, value };
+      } else {
+        return { success: true, value: result };
+      }
+    } catch (error) {
+      return handleError(error);
+    }
+  } else {
+    return handleError(
+      new Error(`Callback provided for ${callbackName} is not a function`)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  safeHandleCallback,
+  safeHandleCallbackAndWait
+});
+//# sourceMappingURL=safe-handle-callback.cjs.map