lifecycleion 0.0.9 → 0.0.11

package/dist/lib/lru-cache/index.js

@@ -0,0 +1,1104 @@
+// 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
+import stringWidth from "string-width";
+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 (stringWidth(currentLine) + stringWidth(word) + 1 <= maxLength) {
+        currentLine += (currentLine ? " " : "") + word;
+      } else {
+        if (currentLine) {
+          lines.push(currentLine);
+        }
+        if (stringWidth(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 (stringWidth(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
+import stringWidth2 from "string-width";
+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 - stringWidth2(line) - 4) / 2)
+        );
+        const paddingRight = " ".repeat(
+          Math.ceil((emptyTableWidth - stringWidth2(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 + stringWidth2(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 stringWidth2(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] - stringWidth2(cellLine));
+        return " " + cellLine + padding + " ";
+      });
+      paddedRows.push("|" + rowLine.join("|") + "|");
+    }
+    return paddedRows.join("\n");
+  }
+};
+
+// src/lib/ascii-tables/key-value-ascii-table.ts
+import stringWidth3 from "string-width";
+
+// 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 - stringWidth3(line) - 4) / 2),
+          " "
+        );
+        const paddingRight = padRight(
+          "",
+          Math.ceil((emptyTableWidth - stringWidth3(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 - stringWidth3(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] - stringWidth3(keyLine));
+          const valuePadding = " ".repeat(
+            columnWidths[1] - stringWidth3(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 = stringWidth3(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) => stringWidth3(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) => stringWidth3(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 = stringWidth3(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) => stringWidth3(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 - stringWidth3(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 - stringWidth3(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`)
+    );
+  }
+}
+
+// src/lib/lru-cache/index.ts
+var VALID_CHANGE_REASONS = /* @__PURE__ */ new Set([
+  "evict",
+  "expired",
+  "delete",
+  "clear",
+  "set",
+  "skip"
+]);
+var LRUCache = class {
+  maxEntries;
+  maxSize;
+  // Optional maximum size in bytes
+  defaultTtl;
+  // Optional default TTL in milliseconds
+  lastCleanup = Date.now();
+  cleanupInterval = 60 * 1e3;
+  // Run cleanup once per minute at most
+  currentSize = 0;
+  // Track current total size in bytes
+  expirableEntryCount = 0;
+  // Track how many entries currently have expirations
+  sizeCalculator;
+  // Optional function to calculate item size
+  onChange;
+  onChangeReasons;
+  // Store values with their expiration time and size
+  map = /* @__PURE__ */ new Map();
+  /**
+   * Create a new LRU cache
+   * @param maxEntries Maximum number of entries to store
+   * @param options Configuration options
+   * @param options.defaultTtl Default time to live in milliseconds for all entries
+   * @param options.maxSize Maximum total size in bytes
+   * @param options.sizeCalculator Function to calculate the size of a value
+   * @param options.onChange Callback invoked for cache changes
+   * @param options.onChangeReasons Optional list of change reasons that should trigger onChange
+   */
+  constructor(maxEntries, options) {
+    if (!Number.isInteger(maxEntries) || maxEntries <= 0) {
+      throw new RangeError("maxEntries must be a positive integer");
+    }
+    if (options?.defaultTtl !== void 0) {
+      this.assertNonNegativeFiniteNumber(
+        options.defaultTtl,
+        "defaultTtl must be a non-negative finite number"
+      );
+    }
+    if (options?.maxSize !== void 0) {
+      if (!Number.isInteger(options.maxSize) || options.maxSize <= 0) {
+        throw new RangeError("maxSize must be a positive integer byte count");
+      }
+    }
+    if (options?.sizeCalculator !== void 0 && typeof options.sizeCalculator !== "function") {
+      throw new TypeError("sizeCalculator must be a function");
+    }
+    if (options?.onChange !== void 0 && typeof options.onChange !== "function") {
+      throw new TypeError("onChange must be a function");
+    }
+    if (options?.onChangeReasons !== void 0) {
+      if (!Array.isArray(options.onChangeReasons)) {
+        throw new TypeError("onChangeReasons must be an array");
+      }
+      for (const reason of options.onChangeReasons) {
+        if (!VALID_CHANGE_REASONS.has(reason)) {
+          throw new RangeError(`Invalid onChange reason: ${String(reason)}`);
+        }
+      }
+    }
+    this.maxEntries = maxEntries;
+    this.defaultTtl = options?.defaultTtl;
+    this.maxSize = options?.maxSize;
+    this.sizeCalculator = options?.sizeCalculator;
+    this.onChange = options?.onChange;
+    this.onChangeReasons = options?.onChangeReasons ? new Set(options.onChangeReasons) : void 0;
+  }
+  /**
+   * Get the current number of entries in the cache
+   */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * Get the current total size in bytes of all cached items
+   */
+  get byteSize() {
+    return this.currentSize;
+  }
+  /**
+   * Check if a key exists in the cache (without affecting LRU order)
+   * @param key The key to check
+   * @returns True if the key exists and hasn't expired
+   */
+  has(key) {
+    const entry = this.map.get(key);
+    if (entry) {
+      if (entry.expires && Date.now() > entry.expires) {
+        const changeEvents = this.createLocalChangeQueue();
+        this.removeEntry(key, "expired", changeEvents);
+        this.flushLocalChangeQueue(changeEvents);
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (entry) {
+      if (entry.expires && Date.now() > entry.expires) {
+        const changeEvents = this.createLocalChangeQueue();
+        this.removeEntry(key, "expired", changeEvents);
+        this.flushLocalChangeQueue(changeEvents);
+        return void 0;
+      }
+      this.map.delete(key);
+      this.map.set(key, entry);
+      this.maybeCleanup();
+      return entry.value;
+    }
+    return void 0;
+  }
+  set(key, value, customTtl) {
+    if (customTtl !== void 0) {
+      this.assertNonNegativeFiniteNumber(
+        customTtl,
+        "customTtl must be a non-negative finite number"
+      );
+    }
+    const size = this.calculateSize(value);
+    const changeEvents = this.createLocalChangeQueue();
+    this.cleanupExpiredInternal(changeEvents);
+    const existingEntry = this.map.get(key);
+    if (this.maxSize !== void 0 && size > this.maxSize) {
+      changeEvents.push(
+        existingEntry ? {
+          reason: "skip",
+          key,
+          currentValue: existingEntry.value,
+          newValue: value,
+          cause: "maxSize"
+        } : {
+          reason: "skip",
+          key,
+          newValue: value,
+          cause: "maxSize"
+        }
+      );
+      this.flushLocalChangeQueue(changeEvents);
+      return;
+    }
+    if (existingEntry) {
+      this.removeEntry(key);
+    }
+    const ttl = customTtl ?? this.defaultTtl;
+    const expires = ttl && ttl > 0 ? Date.now() + ttl : void 0;
+    this.map.set(key, { value, expires, size });
+    this.currentSize += size;
+    if (expires !== void 0) {
+      this.expirableEntryCount++;
+    }
+    changeEvents?.push(
+      existingEntry ? {
+        reason: "set",
+        key,
+        oldValue: existingEntry.value,
+        newValue: value
+      } : {
+        reason: "set",
+        key,
+        newValue: value
+      }
+    );
+    this.evictIfNeeded(changeEvents);
+    this.flushLocalChangeQueue(changeEvents);
+  }
+  /**
+   * Clear all entries from the cache
+   */
+  clear() {
+    const changeEvents = this.createLocalChangeQueue();
+    const shouldEmitClear = this.onChange !== void 0 && (this.onChangeReasons === void 0 || this.onChangeReasons.has("clear"));
+    if (shouldEmitClear) {
+      for (const [key, entry] of this.map.entries()) {
+        changeEvents.push({
+          reason: "clear",
+          key,
+          value: entry.value
+        });
+      }
+    }
+    this.map.clear();
+    this.currentSize = 0;
+    this.expirableEntryCount = 0;
+    this.lastCleanup = Date.now();
+    this.flushLocalChangeQueue(changeEvents);
+  }
+  /**
+   * Delete a specific entry from the cache
+   * @param key The key to delete
+   * @returns True if the entry was deleted, false if it didn't exist
+   */
+  delete(key) {
+    const changeEvents = this.createLocalChangeQueue();
+    const wasDeleted = this.removeEntry(key, "delete", changeEvents);
+    this.flushLocalChangeQueue(changeEvents);
+    return wasDeleted;
+  }
+  /**
+   * Remove all expired entries from the cache
+   * @returns The number of entries removed
+   */
+  cleanupExpired() {
+    const changeEvents = this.createLocalChangeQueue();
+    const removed = this.cleanupExpiredInternal(changeEvents);
+    this.flushLocalChangeQueue(changeEvents);
+    return removed;
+  }
+  cleanupExpiredInternal(changeEvents) {
+    let removed = 0;
+    const now = Date.now();
+    for (const [key, entry] of this.map.entries()) {
+      if (entry.expires && now > entry.expires) {
+        this.removeEntry(key, "expired", changeEvents);
+        removed++;
+      }
+    }
+    this.lastCleanup = now;
+    return removed;
+  }
+  isBufferValue(value) {
+    const globalBuffer = globalThis.Buffer;
+    if (globalBuffer === void 0) {
+      return false;
+    }
+    const bufferConstructor = globalBuffer;
+    return typeof globalBuffer === "function" && typeof bufferConstructor.isBuffer === "function" && bufferConstructor.isBuffer(value);
+  }
+  /**
+   * Calculate the size of a value in bytes
+   * Uses the provided sizeCalculator if available, otherwise makes a best guess
+   */
+  calculateSize(value, visitedArrays = /* @__PURE__ */ new WeakSet()) {
+    if (this.sizeCalculator) {
+      const size = this.sizeCalculator(value);
+      if (!Number.isInteger(size) || size < 0) {
+        throw new RangeError(
+          "sizeCalculator must return a non-negative integer byte count"
+        );
+      }
+      return size;
+    }
+    if (value === null || value === void 0) {
+      return 0;
+    } else if (typeof value === "boolean") {
+      return 4;
+    } else if (typeof value === "number") {
+      return 8;
+    } else if (typeof value === "string") {
+      return value.length * 2;
+    } else if (this.isBufferValue(value)) {
+      return value.length;
+    } else if (ArrayBuffer.isView(value)) {
+      return value.byteLength;
+    } else if (value instanceof ArrayBuffer) {
+      return value.byteLength;
+    } else if (Array.isArray(value)) {
+      if (visitedArrays.has(value)) {
+        return 1e3;
+      }
+      visitedArrays.add(value);
+      const estimatedSize = 40 + value.reduce(
+        (acc, item) => acc + this.calculateSize(item, visitedArrays),
+        0
+      );
+      visitedArrays.delete(value);
+      return estimatedSize;
+    } else if (typeof value === "object") {
+      try {
+        const jsonSize = JSON.stringify(value).length * 2;
+        return Math.max(jsonSize, 40);
+      } catch {
+        return 1e3;
+      }
+    }
+    return 100;
+  }
+  /**
+   * Evict entries if we exceed either max entries or max size
+   */
+  evictIfNeeded(changeEvents) {
+    if (this.map.size > this.maxEntries) {
+      this.evictOldest(changeEvents);
+    }
+    if (this.maxSize !== void 0 && this.currentSize > this.maxSize) {
+      while (this.currentSize > this.maxSize && this.map.size > 0) {
+        this.evictOldest(changeEvents);
+      }
+    }
+  }
+  /**
+   * Evict the oldest (least recently used) entry
+   */
+  evictOldest(changeEvents) {
+    if (this.map.size > 0) {
+      const oldest = this.map.keys().next().value;
+      this.removeEntry(oldest, "evict", changeEvents);
+    }
+  }
+  maybeCleanup() {
+    const now = Date.now();
+    if (now - this.lastCleanup > this.cleanupInterval && this.expirableEntryCount > 0) {
+      this.cleanupExpired();
+    }
+  }
+  // Collect changes locally so each cache operation flushes its own events in order.
+  createLocalChangeQueue() {
+    return [];
+  }
+  flushLocalChangeQueue(changeEvents) {
+    if (!this.onChange || changeEvents.length === 0) {
+      return;
+    }
+    for (const changeEvent of changeEvents) {
+      if (this.onChangeReasons !== void 0 && !this.onChangeReasons.has(changeEvent.reason)) {
+        continue;
+      }
+      safeHandleCallback("LRUCache onChange", this.onChange, changeEvent);
+    }
+  }
+  removeEntry(key, reason, changeEvents) {
+    const entry = this.map.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.currentSize -= entry.size;
+    if (entry.expires !== void 0) {
+      this.expirableEntryCount--;
+    }
+    this.map.delete(key);
+    if (reason && changeEvents) {
+      changeEvents.push({
+        reason,
+        key,
+        value: entry.value
+      });
+    }
+    return true;
+  }
+  assertNonNegativeFiniteNumber(value, message) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new RangeError(message);
+    }
+  }
+};
+export {
+  LRUCache
+};
+//# sourceMappingURL=index.js.map