@visulima/pail 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/packem_shared/abstract-pretty-reporter-jU8WL_6c.js

@@ -0,0 +1,2602 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const process$2 = __cjs_getProcess;
+const {
+  execFileSync
+} = __cjs_getBuiltinModule("node:child_process");
+const fs = __cjs_getBuiltinModule("node:fs");
+const tty = __cjs_getBuiltinModule("node:tty");
+const {
+  createRequire
+} = __cjs_getBuiltinModule("node:module");
+import { grey, green, cyan, red, yellow, bold, magenta, underline } from '@visulima/colorize';
+
+const r = String.raw;
+const e = r`\p{Emoji}(?:\p{EMod}|[\u{E0020}-\u{E007E}]+\u{E007F}|\uFE0F?\u20E3?)`;
+const emojiRegex = () => new RegExp(r`\p{RI}{2}|(?![#*\d](?!\uFE0F?\u20E3))${e}(?:\u200D${e})*`, "gu");
+const ESCAPES = /* @__PURE__ */ new Set(["\x1B", "›"]);
+const ANSI_ESCAPE_BELL = "\x07";
+const ANSI_CSI = "[";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_ESCAPE_LINK = `]8;;`;
+const END_CODE = 39;
+const RE_ZERO_WIDTH = /[\u200B\uFEFF\u2060-\u2064]/g;
+const RE_ESCAPE_PATTERN = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`);
+const ANSI_RESET_CODES = Object.freeze(
+  /* @__PURE__ */ new Map([
+    [0, 0],
+    // Reset all
+    [1, 22],
+    // Bold → Not bold
+    [2, 22],
+    // Dim → Not bold
+    [3, 23],
+    // Italic → Not italic
+    [4, 24],
+    // Underline → Not underline
+    [7, 27],
+    // Inverse → Not inverse
+    [8, 28],
+    // Hidden → Not hidden
+    [9, 29],
+    // Strikethrough → Not strikethrough
+    [30, 39],
+    // Foreground colors → Default foreground
+    [31, 39],
+    [32, 39],
+    [33, 39],
+    [34, 39],
+    [35, 39],
+    [36, 39],
+    [37, 39],
+    [40, 49],
+    // Background colors → Default background
+    [41, 49],
+    [42, 49],
+    [43, 49],
+    [44, 49],
+    [45, 49],
+    [46, 49],
+    [47, 49],
+    [90, 39]
+    // Bright foreground → Default foreground
+  ])
+);
+const RE_ANSI = /[\u001B\u009B](?:[[()#;?]{0,10}(?:\d{1,4}(?:;\d{0,4})*)?[0-9A-ORZcf-nqry=><]|\]8;;[^\u0007\u001B]{0,100}(?:\u0007|\u001B\\))/g;
+const RE_CONTROL = /[\u0000-\u0008\n-\u001F\u007F-\u009F]{1,1000}/y;
+const RE_EMOJI = emojiRegex();
+
+const ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+const fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+const halfwidthRanges = [8361, 8361, 65377, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65512, 65518];
+const narrowRanges = [32, 126, 162, 163, 165, 166, 172, 172, 175, 175, 10214, 10221, 10629, 10630];
+const wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+const isInRange = (ranges, codePoint) => {
+  let low = 0;
+  let high = Math.floor(ranges.length / 2) - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const i = mid * 2;
+    if (codePoint < ranges[i]) {
+      high = mid - 1;
+    } else if (codePoint > ranges[i + 1]) {
+      low = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+const minimumAmbiguousCodePoint = ambiguousRanges[0];
+const maximumAmbiguousCodePoint = ambiguousRanges.at(-1);
+const minimumFullWidthCodePoint = fullwidthRanges[0];
+const maximumFullWidthCodePoint = fullwidthRanges.at(-1);
+const minimumHalfWidthCodePoint = halfwidthRanges[0];
+const maximumHalfWidthCodePoint = halfwidthRanges.at(-1);
+const minimumNarrowCodePoint = narrowRanges[0];
+const maximumNarrowCodePoint = narrowRanges.at(-1);
+const minimumWideCodePoint = wideRanges[0];
+const maximumWideCodePoint = wideRanges.at(-1);
+const commonCjkCodePoint = 19968;
+const [wideFastPathStart, wideFastPathEnd] = findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+const isAmbiguous = (codePoint) => {
+  if (codePoint < minimumAmbiguousCodePoint || codePoint > maximumAmbiguousCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+const isFullWidth = (codePoint) => {
+  if (codePoint < minimumFullWidthCodePoint || codePoint > maximumFullWidthCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+const isHalfWidth = (codePoint) => {
+  if (codePoint < minimumHalfWidthCodePoint || codePoint > maximumHalfWidthCodePoint) {
+    return false;
+  }
+  return isInRange(halfwidthRanges, codePoint);
+};
+const isNarrow = (codePoint) => {
+  if (codePoint < minimumNarrowCodePoint || codePoint > maximumNarrowCodePoint) {
+    return false;
+  }
+  return isInRange(narrowRanges, codePoint);
+};
+const isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < minimumWideCodePoint || codePoint > maximumWideCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+function getCategory(codePoint) {
+  if (isAmbiguous(codePoint)) {
+    return "ambiguous";
+  }
+  if (isFullWidth(codePoint)) {
+    return "fullwidth";
+  }
+  if (isHalfWidth(codePoint)) {
+    return "halfwidth";
+  }
+  if (isNarrow(codePoint)) {
+    return "narrow";
+  }
+  if (isWide(codePoint)) {
+    return "wide";
+  }
+  return "neutral";
+}
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidthType(codePoint) {
+  validate(codePoint);
+  return getCategory(codePoint);
+}
+const charWidthCache = /* @__PURE__ */ new Map();
+const RE_LATIN_CHARS = /(?:[\u0020-\u007E\u00A0-\u00FF](?!\uFE0F)){1,1000}/y;
+const getCharType = (codePoint) => {
+  if (codePoint >= 32 && codePoint <= 126) {
+    return "latin";
+  }
+  if (codePoint === 8203 || codePoint === 8204 || codePoint === 8205 || codePoint === 8288) {
+    return "zero";
+  }
+  if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {
+    return "control";
+  }
+  if (codePoint >= 160 && codePoint <= 255) {
+    return "latin";
+  }
+  if (codePoint >= 9472 && codePoint <= 9599) {
+    return "latin";
+  }
+  if (codePoint >= 4352 && codePoint <= 4607 || codePoint >= 11904 && codePoint <= 40959 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65280 && codePoint <= 65519 && !(codePoint >= 65377 && codePoint <= 65439) || codePoint >= 12352 && codePoint <= 12543) {
+    return "wide";
+  }
+  if (codePoint === 8230) {
+    return "latin";
+  }
+  return "other";
+};
+const getCachedCharWidth = (codePoint, config) => {
+  const highBits = Math.floor(codePoint / 65536);
+  const lowBits = codePoint % 65536;
+  let lowMap = charWidthCache.get(highBits);
+  if (!lowMap) {
+    lowMap = /* @__PURE__ */ new Map();
+    charWidthCache.set(highBits, lowMap);
+  }
+  if (lowMap.has(lowBits)) {
+    return lowMap.get(lowBits);
+  }
+  let width;
+  if (getCharType(codePoint) === "latin") {
+    width = config.width.regular;
+  } else if (getCharType(codePoint) === "control") {
+    width = config.width.control;
+  } else if (getCharType(codePoint) === "wide") {
+    width = config.width.wide;
+  } else {
+    const eaw = eastAsianWidthType(codePoint);
+    switch (eaw) {
+      case "ambiguous": {
+        width = config.width.ambiguousIsNarrow ? config.width.regular : config.width.wide;
+        break;
+      }
+      case "fullwidth": {
+        width = config.width.fullWidth;
+        break;
+      }
+      case "wide": {
+        width = config.width.wide;
+        break;
+      }
+      default: {
+        width = config.width.regular;
+      }
+    }
+  }
+  lowMap.set(lowBits, width);
+  return width;
+};
+const isCombiningCharacter = (codePoint) => {
+  if (codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071) {
+    return true;
+  }
+  if (codePoint >= 917760 && codePoint <= 917999 || codePoint >= 65024 && codePoint <= 65039) {
+    return true;
+  }
+  if (codePoint >= 3633 && codePoint <= 3642 || codePoint >= 3655 && codePoint <= 3662 || codePoint >= 3761 && codePoint <= 3769 || codePoint >= 3771 && codePoint <= 3772 || codePoint >= 3784 && codePoint <= 3789) {
+    return true;
+  }
+  if (codePoint >= 2304 && codePoint <= 2307 || codePoint >= 2362 && codePoint <= 2383 || codePoint >= 2385 && codePoint <= 2391 || codePoint >= 2402 && codePoint <= 2403 || codePoint >= 2433 && codePoint <= 2435 || codePoint >= 2492 && codePoint <= 2500 || codePoint >= 2509 && codePoint <= 2509 || codePoint >= 2561 && codePoint <= 2563 || codePoint >= 2620 && codePoint <= 2637) {
+    return true;
+  }
+  if (codePoint >= 1611 && codePoint <= 1631 || codePoint >= 1648 && codePoint <= 1648 || codePoint >= 1750 && codePoint <= 1773 || codePoint >= 2276 && codePoint <= 2302) {
+    return true;
+  }
+  if (codePoint >= 1425 && codePoint <= 1469 || codePoint >= 1471 && codePoint <= 1471 || codePoint >= 1473 && codePoint <= 1474 || codePoint >= 1476 && codePoint <= 1477 || codePoint >= 1479 && codePoint <= 1479) {
+    return true;
+  }
+  if (codePoint >= 3893 && codePoint <= 3893 || codePoint >= 3895 && codePoint <= 3895 || codePoint >= 3897 && codePoint <= 3897 || codePoint >= 3953 && codePoint <= 3966 || codePoint >= 3968 && codePoint <= 3972 || codePoint >= 3974 && codePoint <= 3975) {
+    return true;
+  }
+  return codePoint >= 768 && codePoint <= 777 || codePoint >= 803 && codePoint <= 803;
+};
+const getStringTruncatedWidth = (input, options = {}) => {
+  if (!input || input.length === 0) {
+    return { ellipsed: false, index: 0, truncated: false, width: 0 };
+  }
+  const config = {
+    truncation: {
+      countAnsiEscapeCodes: options.countAnsiEscapeCodes ?? false,
+      ellipsis: options.ellipsis ?? "",
+      ellipsisWidth: options.ellipsisWidth ?? (options.ellipsis ? getStringTruncatedWidth(options.ellipsis, {
+        ...options,
+        ellipsis: "",
+        ellipsisWidth: 0,
+        limit: Number.POSITIVE_INFINITY
+      }).width : 0),
+      limit: options.limit ?? Number.POSITIVE_INFINITY
+    },
+    width: {
+      ambiguousIsNarrow: options.ambiguousIsNarrow ?? false,
+      ansi: options.ansiWidth ?? 0,
+      control: options.controlWidth ?? 0,
+      emoji: options.emojiWidth ?? 2,
+      fullWidth: options.fullWidth ?? 2,
+      halfWidth: options.halfWidth ?? 1,
+      regular: options.regularWidth ?? 1,
+      tab: options.tabWidth ?? 8,
+      wide: options.wideWidth ?? 2
+    }
+  };
+  const truncationLimit = Math.max(0, config.truncation.limit - config.truncation.ellipsisWidth);
+  const { length } = input;
+  const useCaching = length > 1e4;
+  let index = 0;
+  let width = 0;
+  let truncationIndex = length;
+  let truncationEnabled = false;
+  const hasAnsi = input.includes("\x1B") || input.includes("›");
+  while (index < length) {
+    if (hasAnsi && (input[index] === "\x1B" || input[index] === "›")) {
+      if (input.startsWith("\x1B]8;;", index)) {
+        const BELL = "\x07";
+        const OSC8_CLOSER = `\x1B]8;;${BELL}`;
+        const OSC8_CLOSER_LEN = OSC8_CLOSER.length;
+        const endOfParametersIndex = input.indexOf(BELL, index + 5);
+        if (endOfParametersIndex === -1) ;
+        else {
+          const startOfCloserIndex = input.indexOf(OSC8_CLOSER, endOfParametersIndex + 1);
+          if (startOfCloserIndex === -1) ;
+          else {
+            const endOfSequenceIndex = startOfCloserIndex + OSC8_CLOSER_LEN;
+            const linkText = input.slice(endOfParametersIndex + 1, startOfCloserIndex);
+            const strippedLinkText = linkText.replace(RE_ANSI, "");
+            const linkTextWidthResult = getStringTruncatedWidth(strippedLinkText, {
+              ambiguousIsNarrow: config.width.ambiguousIsNarrow,
+              ansiWidth: config.width.ansi,
+              controlWidth: config.width.control,
+              countAnsiEscapeCodes: false,
+              // Never count ANSI in link text width
+              ellipsis: config.truncation.ellipsis,
+              ellipsisWidth: config.truncation.ellipsisWidth,
+              emojiWidth: config.width.emoji,
+              fullWidth: config.width.fullWidth,
+              halfWidth: config.width.halfWidth,
+              limit: Math.max(0, truncationLimit - width),
+              regularWidth: config.width.regular,
+              tabWidth: config.width.tab,
+              wideWidth: config.width.wide
+            });
+            const textWidth = linkTextWidthResult.width;
+            if (linkTextWidthResult.truncated) {
+              truncationEnabled = true;
+              truncationIndex = Math.min(truncationIndex, index);
+            } else if (width + textWidth > truncationLimit) {
+              truncationIndex = Math.min(truncationIndex, index);
+              truncationEnabled = true;
+              if (width + textWidth > config.truncation.limit) {
+                break;
+              }
+            }
+            width += textWidth;
+            index = endOfSequenceIndex;
+            if (truncationEnabled && width >= config.truncation.limit) {
+              break;
+            }
+            continue;
+          }
+        }
+      }
+      RE_ANSI.lastIndex = index;
+      if (RE_ANSI.test(input)) {
+        const ansiLength = RE_ANSI.lastIndex - index;
+        const ansiWidth = config.truncation.countAnsiEscapeCodes ? ansiLength : config.width.ansi;
+        if (width + ansiWidth > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index);
+          if (width + ansiWidth > config.truncation.limit) {
+            truncationEnabled = true;
+            break;
+          }
+        }
+        width += ansiWidth;
+        index = RE_ANSI.lastIndex;
+        continue;
+      }
+    }
+    const charCode = input.codePointAt(index);
+    if (charCode === 8203 || charCode === 65279 || charCode >= 8288 && charCode <= 8292) {
+      index += 1;
+      continue;
+    }
+    if (charCode === 9) {
+      if (width + config.width.tab > truncationLimit) {
+        truncationIndex = Math.min(truncationIndex, index);
+        if (width + config.width.tab > config.truncation.limit) {
+          truncationEnabled = true;
+          break;
+        }
+      }
+      width += config.width.tab;
+      index += 1;
+      continue;
+    }
+    RE_LATIN_CHARS.lastIndex = index;
+    if (RE_LATIN_CHARS.test(input)) {
+      const latinLength = RE_LATIN_CHARS.lastIndex - index;
+      const latinWidth = latinLength * config.width.regular;
+      if (width + latinWidth > truncationLimit) {
+        const charsToLimit = Math.floor((truncationLimit - width) / config.width.regular);
+        truncationIndex = Math.min(truncationIndex, index + charsToLimit);
+        if (width + latinWidth > config.truncation.limit) {
+          truncationEnabled = true;
+          break;
+        }
+      }
+      width += latinWidth;
+      index = RE_LATIN_CHARS.lastIndex;
+      continue;
+    }
+    if (charCode <= 31 || charCode >= 127 && charCode <= 159) {
+      RE_CONTROL.lastIndex = index;
+      if (RE_CONTROL.test(input)) {
+        const controlLength = RE_CONTROL.lastIndex - index;
+        const controlWidth = controlLength * config.width.control;
+        if (width + controlWidth > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / config.width.control));
+          if (width + controlWidth > config.truncation.limit) {
+            truncationEnabled = true;
+            break;
+          }
+        }
+        width += controlWidth;
+        index = RE_CONTROL.lastIndex;
+        continue;
+      }
+    }
+    RE_EMOJI.lastIndex = index;
+    if (RE_EMOJI.test(input)) {
+      if (width + config.width.emoji > truncationLimit) {
+        truncationIndex = Math.min(truncationIndex, index);
+        if (width + config.width.emoji > config.truncation.limit) {
+          truncationEnabled = true;
+          break;
+        }
+      }
+      width += config.width.emoji;
+      index = RE_EMOJI.lastIndex;
+      continue;
+    }
+    const codePoint = input.codePointAt(index) ?? 0;
+    if (isCombiningCharacter(codePoint)) {
+      index += codePoint > 65535 ? 2 : 1;
+      continue;
+    }
+    let charWidth;
+    if (useCaching) {
+      charWidth = getCachedCharWidth(codePoint, config);
+    } else {
+      const charType = getCharType(codePoint);
+      switch (charType) {
+        case "control": {
+          charWidth = config.width.control;
+          break;
+        }
+        case "latin": {
+          charWidth = config.width.regular;
+          break;
+        }
+        case "wide": {
+          charWidth = config.width.wide;
+          break;
+        }
+        case "zero": {
+          charWidth = 0;
+          break;
+        }
+        default: {
+          const eaw = eastAsianWidthType(codePoint);
+          switch (eaw) {
+            case "ambiguous": {
+              charWidth = config.width.ambiguousIsNarrow ? config.width.regular : config.width.wide;
+              break;
+            }
+            case "fullwidth": {
+              charWidth = config.width.fullWidth;
+              break;
+            }
+            case "wide": {
+              charWidth = config.width.wide;
+              break;
+            }
+            default: {
+              charWidth = config.width.regular;
+            }
+          }
+        }
+      }
+    }
+    if (width + charWidth > truncationLimit) {
+      truncationIndex = Math.min(truncationIndex, index);
+      if (width + charWidth > config.truncation.limit) {
+        truncationEnabled = true;
+        break;
+      }
+    }
+    width += charWidth;
+    index += codePoint > 65535 ? 2 : 1;
+  }
+  let finalWidth = width;
+  let ellipsed = false;
+  if (truncationEnabled && config.truncation.limit >= config.truncation.ellipsisWidth) {
+    finalWidth = config.truncation.limit;
+    ellipsed = true;
+  }
+  return {
+    ellipsed,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    width: finalWidth
+  };
+};
+
+const getStringWidth = (input, options = {}) => getStringTruncatedWidth(input, { ...options, ellipsis: "", ellipsisWidth: 0, limit: Number.POSITIVE_INFINITY }).width;
+
+class AnsiStateTracker {
+  activeForeground = void 0;
+  activeBackground = void 0;
+  // Track other formatting (bold, italic, etc.)
+  activeFormatting = [];
+  /**
+   * Processes an escape sequence and updates the internal state
+   * @param sequence The escape sequence to process
+   */
+  processEscape(sequence) {
+    const match = /\x1B\[(\d+)m/.exec(sequence);
+    if (!match) {
+      return;
+    }
+    const code = Number.parseInt(match[1], 10);
+    switch (code) {
+      case 0: {
+        this.activeForeground = void 0;
+        this.activeBackground = void 0;
+        this.activeFormatting = [];
+        break;
+      }
+      case 39: {
+        this.activeForeground = void 0;
+        break;
+      }
+      case 49: {
+        this.activeBackground = void 0;
+        break;
+      }
+      default: {
+        if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+          this.activeForeground = sequence;
+        } else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+          this.activeBackground = sequence;
+        } else if ([1, 2, 3, 4, 7, 8, 9].includes(code)) {
+          this.activeFormatting.push(sequence);
+        } else if ([22, 23, 24, 27, 28, 29].includes(code)) {
+          const formatResetMap = {
+            22: "[1m",
+            // Reset bold
+            23: "[3m",
+            // Reset italic
+            24: "[4m",
+            // Reset underline
+            27: "[7m",
+            // Reset inverse
+            28: "[8m",
+            // Reset hidden
+            29: "[9m"
+            // Reset strikethrough
+          };
+          const formatToRemove = formatResetMap[code];
+          if (formatToRemove) {
+            this.activeFormatting = this.activeFormatting.filter((fmt) => !fmt.includes(formatToRemove));
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Gets all active escape sequences to apply
+   * @returns String with all active escapes
+   */
+  getStartEscapesForAllActiveAttributes() {
+    return [this.activeBackground, this.activeForeground, ...this.activeFormatting].filter(Boolean).join("");
+  }
+  /**
+   * Gets all closing escape sequences for the currently active attributes.
+   * The order is generally reverse of application: formatting, foreground, background.
+   * @returns String with all necessary closing escapes.
+   */
+  getEndEscapesForAllActiveAttributes() {
+    const closingEscapes = [];
+    if (this.activeFormatting.length > 0) {
+      const formatResetMap = {
+        "\x1B[1m": "\x1B[22m",
+        // Bold
+        "\x1B[2m": "\x1B[22m",
+        // Faint/Dim (also reset by 22)
+        "\x1B[3m": "\x1B[23m",
+        // Italic
+        "\x1B[4m": "\x1B[24m",
+        // Underline
+        "\x1B[7m": "\x1B[27m",
+        // Inverse
+        "\x1B[8m": "\x1B[28m",
+        // Hidden/Conceal
+        "\x1B[9m": "\x1B[29m"
+        // Strikethrough
+      };
+      [...this.activeFormatting].toReversed().forEach((formatCode) => {
+        const resetCode = formatResetMap[formatCode];
+        if (resetCode) {
+          closingEscapes.push(resetCode);
+        }
+      });
+    }
+    if (this.activeForeground) {
+      closingEscapes.push("\x1B[39m");
+    }
+    if (this.activeBackground) {
+      closingEscapes.push("\x1B[49m");
+    }
+    return closingEscapes.join("");
+  }
+}
+const checkEscapeSequence = (chars, index) => {
+  if (!ESCAPES.has(chars[index])) {
+    return { isInsideEscape: false, isInsideLinkEscape: false };
+  }
+  const isInsideEscape = true;
+  const possibleLink = chars.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join("");
+  const isInsideLinkEscape = possibleLink === ANSI_ESCAPE_LINK;
+  return { isInsideEscape, isInsideLinkEscape };
+};
+const processAnsiString = (string, options = {}) => {
+  const stateTracker = new AnsiStateTracker();
+  let currentText = "";
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let escapeBuffer = "";
+  let currentUrl = "";
+  let isInHyperlink = false;
+  const chars = [...string];
+  for (let index = 0; index < chars.length; index++) {
+    const character = chars[index];
+    if (character && ESCAPES.has(character)) {
+      if (currentText) {
+        const width2 = options.getWidth?.(currentText) ?? 0;
+        const segment2 = {
+          isEscapeSequence: false,
+          isGrapheme: true,
+          text: currentText,
+          width: width2
+        };
+        if (isInHyperlink) {
+          segment2.isHyperlink = true;
+          segment2.hyperlinkUrl = currentUrl;
+        }
+        if (options.onSegment?.(segment2, stateTracker) === false) {
+          return;
+        }
+        currentText = "";
+      }
+      isInsideEscape = true;
+      escapeBuffer = character;
+      const escapeInfo = checkEscapeSequence(chars, index);
+      isInsideLinkEscape = escapeInfo.isInsideLinkEscape;
+      if (isInsideLinkEscape) {
+        let urlEnd = index + 1;
+        currentUrl = "";
+        while (urlEnd < chars.length) {
+          const nextChar = chars[urlEnd];
+          if (nextChar === ANSI_ESCAPE_BELL) {
+            break;
+          }
+          currentUrl += nextChar;
+          urlEnd += 1;
+        }
+        currentUrl = currentUrl.slice(4);
+        const segment2 = {
+          hyperlinkUrl: currentUrl,
+          isEscapeSequence: true,
+          isGrapheme: false,
+          isHyperlink: true,
+          isHyperlinkStart: true,
+          width: 0
+        };
+        if (options.onSegment?.(segment2, stateTracker) === false) {
+          return;
+        }
+        index = urlEnd;
+        isInHyperlink = true;
+        isInsideEscape = false;
+        isInsideLinkEscape = false;
+        escapeBuffer = "";
+        continue;
+      }
+      if (index + 1 < chars.length && chars[index + 1] === "\\" && isInHyperlink) {
+        const segment2 = {
+          isEscapeSequence: true,
+          isGrapheme: false,
+          isHyperlink: true,
+          isHyperlinkEnd: true,
+          width: 0
+        };
+        if (options.onSegment?.(segment2, stateTracker) === false) {
+          return;
+        }
+        isInHyperlink = false;
+        currentUrl = "";
+        index += 1;
+        isInsideEscape = false;
+        escapeBuffer = "";
+        continue;
+      }
+    }
+    if (isInsideEscape) {
+      if (escapeBuffer !== character) {
+        escapeBuffer += character;
+      }
+      if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+        stateTracker.processEscape(escapeBuffer);
+        const segment2 = {
+          isEscapeSequence: true,
+          isGrapheme: false,
+          text: escapeBuffer,
+          width: 0
+        };
+        if (options.onSegment?.(segment2, stateTracker) === false) {
+          return;
+        }
+        escapeBuffer = "";
+      }
+      continue;
+    }
+    currentText += character;
+    const width = options.getWidth?.(currentText) ?? 0;
+    const segment = {
+      isEscapeSequence: false,
+      isGrapheme: true,
+      text: currentText,
+      width
+    };
+    if (isInHyperlink) {
+      segment.isHyperlink = true;
+      segment.hyperlinkUrl = currentUrl;
+    }
+    if (options.onSegment?.(segment, stateTracker) === false) {
+      return;
+    }
+    currentText = "";
+  }
+  if (currentText) {
+    const width = options.getWidth?.(currentText) ?? 0;
+    const segment = {
+      isEscapeSequence: false,
+      isGrapheme: true,
+      text: currentText,
+      width
+    };
+    if (isInHyperlink) {
+      segment.isHyperlink = true;
+      segment.hyperlinkUrl = currentUrl;
+    }
+    options.onSegment?.(segment, stateTracker);
+  }
+  if (escapeBuffer) {
+    const segment = {
+      isEscapeSequence: true,
+      isGrapheme: false,
+      text: escapeBuffer,
+      width: 0
+    };
+    options.onSegment?.(segment, stateTracker);
+  }
+};
+const wrapAnsiCode = (code) => {
+  const escapeChar = ESCAPES.values().next().value;
+  return `${escapeChar}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+};
+const wrapAnsiHyperlink = (url) => {
+  const escapeChar = ESCAPES.values().next().value;
+  return `${escapeChar}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+};
+const preserveAnsi = (rawLines) => {
+  if (rawLines.length === 0) {
+    return "";
+  }
+  if (rawLines.length === 1) {
+    return rawLines[0];
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const preString = rawLines.join("\n");
+  const pre = [...preString];
+  let preStringIndex = 0;
+  for (const [index, character] of pre.entries()) {
+    returnValue += character;
+    if (ESCAPES.has(character)) {
+      const match = RE_ESCAPE_PATTERN.exec(preString.slice(preStringIndex));
+      const groups = match?.groups ?? {};
+      if (groups.code !== void 0) {
+        const code2 = Number.parseFloat(groups.code);
+        escapeCode = code2 === END_CODE ? void 0 : code2;
+      } else if (groups.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    const code = ANSI_RESET_CODES.get(Number(escapeCode));
+    if (pre[index + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      if (escapeCode && code) {
+        returnValue += wrapAnsiCode(code);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && code) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+    preStringIndex += character.length;
+  }
+  return returnValue;
+};
+const resetAnsiAtLineBreak = (currentLine) => {
+  if (!currentLine.includes("\x1B")) {
+    return currentLine;
+  }
+  let result = currentLine;
+  if (currentLine.includes("\x1B[30m")) {
+    result += "\x1B[39m";
+  }
+  if (currentLine.includes("\x1B[42m")) {
+    result += "\x1B[49m";
+  }
+  return result;
+};
+const stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last > 0 && getStringWidth(words[last - 1]) === 0) {
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+const wrapWithBreakAtWidth = (string, width, trim) => {
+  if (string.length === 0) {
+    return [""];
+  }
+  if (width <= 0) {
+    return [string];
+  }
+  const rows = [];
+  const ansiTracker = new AnsiStateTracker();
+  let currentLine = "";
+  let currentWidth = 0;
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let escapeBuffer = "";
+  let index = 0;
+  while (index < string.length) {
+    const char = string[index];
+    if (ESCAPES.has(char)) {
+      isInsideEscape = true;
+      escapeBuffer = char;
+      currentLine += char;
+      const escapeInfo = checkEscapeSequence([...string], index);
+      isInsideLinkEscape = escapeInfo.isInsideLinkEscape;
+      index += 1;
+      continue;
+    }
+    if (isInsideEscape) {
+      escapeBuffer += char;
+      currentLine += char;
+      if (isInsideLinkEscape) {
+        if (char === ANSI_ESCAPE_BELL) {
+          isInsideEscape = isInsideLinkEscape = false;
+        }
+      } else if (char === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+        ansiTracker.processEscape(escapeBuffer);
+      }
+      index += 1;
+      continue;
+    }
+    const charWidth = getStringWidth(char);
+    const isSpace = char === " ";
+    if (charWidth === 0) {
+      currentLine += char;
+      index += 1;
+      continue;
+    }
+    if (currentWidth + charWidth > width) {
+      if (currentLine) {
+        rows.push(currentLine + ansiTracker.getEndEscapesForAllActiveAttributes());
+      }
+      currentLine = ansiTracker.getStartEscapesForAllActiveAttributes();
+      currentWidth = getStringWidth(currentLine);
+      if (isSpace && trim) {
+        while (index < string.length && string[index] === " ") {
+          index += 1;
+        }
+        continue;
+      }
+    }
+    currentLine += char;
+    currentWidth += charWidth;
+    if (currentWidth === width && index < string.length - 1) {
+      rows.push(currentLine + ansiTracker.getEndEscapesForAllActiveAttributes());
+      currentLine = ansiTracker.getStartEscapesForAllActiveAttributes();
+      currentWidth = getStringWidth(currentLine);
+      if (index + 1 < string.length && string[index + 1] === " " && trim) {
+        index += 1;
+        while (index < string.length && string[index] === " ") {
+          index += 1;
+        }
+        continue;
+      }
+    }
+    index += 1;
+  }
+  if (currentLine) {
+    rows.push(currentLine + ansiTracker.getEndEscapesForAllActiveAttributes());
+  }
+  return trim ? rows.map((element) => stringVisibleTrimSpacesRight(element)) : rows;
+};
+const wrapCharByChar = (string, width, trim) => {
+  if (string.length === 0) {
+    return [];
+  }
+  const inputToProcess = trim ? string.trim() : string;
+  if (inputToProcess.length === 0) {
+    return [];
+  }
+  const rows = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  processAnsiString(inputToProcess, {
+    getWidth: getStringWidth,
+    // eslint-disable-next-line sonarjs/cognitive-complexity,sonarjs/no-invariant-returns
+    onSegment: (segment, stateTracker) => {
+      if (segment.isEscapeSequence) {
+        currentLine += segment.text;
+      } else {
+        const isSpace = segment.text === " ";
+        if (segment.width === 0) {
+          currentLine += segment.text;
+          return true;
+        }
+        if (currentWidth + segment.width > width) {
+          if (currentLine) {
+            rows.push(currentLine);
+          }
+          currentLine = stateTracker.getStartEscapesForAllActiveAttributes();
+          currentWidth = 0;
+          if (isSpace) {
+            if (trim) {
+              return true;
+            }
+            rows.push(stateTracker.getStartEscapesForAllActiveAttributes() + segment.text);
+            return true;
+          }
+        }
+        currentLine += segment.text;
+        currentWidth += segment.width;
+      }
+      return true;
+    }
+  });
+  if (currentLine) {
+    rows.push(currentLine);
+  }
+  return trim ? rows.map((row) => stringVisibleTrimSpacesRight(row)) : rows;
+};
+const wrapWithWordBoundaries = (string, width, trim) => {
+  if (string.length === 0) {
+    return [];
+  }
+  const inputToProcess = trim ? string.trim() : string;
+  if (inputToProcess.length === 0) {
+    return [];
+  }
+  const tokens = inputToProcess.split(/(?=\s)|(?<=\s)/);
+  const rows = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    const isSpace = /^\s+$/.test(token);
+    const tokenVisibleWidth = getStringWidth(token);
+    if (token.length === 0) {
+      index += 1;
+      continue;
+    }
+    if (trim && isSpace && currentWidth === 0) {
+      index += 1;
+      continue;
+    }
+    if (currentWidth + tokenVisibleWidth > width && currentWidth > 0) {
+      if (trim) {
+        rows.push(stringVisibleTrimSpacesRight(currentLine));
+      } else {
+        rows.push(currentLine);
+      }
+      currentLine = "";
+      currentWidth = 0;
+      continue;
+    }
+    currentLine += token;
+    currentWidth += tokenVisibleWidth;
+    index += 1;
+  }
+  if (currentLine) {
+    if (trim) {
+      rows.push(stringVisibleTrimSpacesRight(currentLine));
+    } else {
+      rows.push(currentLine);
+    }
+  }
+  return rows;
+};
+const wrapAndBreakWords = (string, width, trim) => {
+  if (string.length === 0) {
+    return [];
+  }
+  const inputToProcess = trim ? string.trim() : string;
+  if (inputToProcess.length === 0) {
+    return [];
+  }
+  const tokens = inputToProcess.split(/(?=\s)|(?<=\s)/);
+  const rows = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    const isSpace = /^\s+$/.test(token);
+    const tokenVisibleWidth = getStringWidth(token);
+    if (token.length === 0) {
+      index += 1;
+      continue;
+    }
+    if (trim && isSpace && currentWidth === 0) {
+      index += 1;
+      continue;
+    }
+    if (tokenVisibleWidth > width) {
+      if (currentLine) {
+        rows.push(resetAnsiAtLineBreak(trim ? stringVisibleTrimSpacesRight(currentLine) : currentLine));
+      }
+      const brokenLines = wrapWithBreakAtWidth(token, width, trim);
+      if (brokenLines.length > 0) {
+        for (let brokenLineIndex = 0; brokenLineIndex < brokenLines.length - 1; brokenLineIndex += 1) {
+          rows.push(brokenLines[brokenLineIndex]);
+        }
+        currentLine = brokenLines[brokenLines.length - 1];
+        currentWidth = getStringWidth(currentLine);
+      } else {
+        currentLine = "";
+        currentWidth = 0;
+      }
+      index += 1;
+      continue;
+    }
+    if (currentWidth + tokenVisibleWidth > width && currentWidth > 0) {
+      rows.push(resetAnsiAtLineBreak(trim ? stringVisibleTrimSpacesRight(currentLine) : currentLine));
+      currentLine = "";
+      currentWidth = 0;
+      if (trim && isSpace) {
+        index += 1;
+        continue;
+      }
+    }
+    currentLine += token;
+    currentWidth += tokenVisibleWidth;
+    index += 1;
+  }
+  if (currentLine) {
+    rows.push(resetAnsiAtLineBreak(trim ? stringVisibleTrimSpacesRight(currentLine) : currentLine));
+  }
+  return rows;
+};
+const WrapMode = {
+  /**
+   * Breaks words at character boundaries to fit the width
+   */
+  BREAK_AT_CHARACTERS: "BREAK_AT_CHARACTERS",
+  /**
+   * Breaks lines at word boundaries. If a word is longer than the width, it will be broken.
+   */
+  BREAK_WORDS: "BREAK_WORDS",
+  /**
+   * Preserves word boundaries, words are kept intact even if they exceed width
+   */
+  PRESERVE_WORDS: "PRESERVE_WORDS",
+  /**
+   * Enforces strict adherence to the width limit by breaking at exact width
+   */
+  STRICT_WIDTH: "STRICT_WIDTH"
+};
+const wordWrap = (string, options = {}) => {
+  const { removeZeroWidthCharacters = true, trim = true, width = 80, wrapMode = WrapMode.PRESERVE_WORDS } = options;
+  if (trim && string.trim() === "") {
+    return "";
+  }
+  let normalizedString = String(string).normalize("NFC").replaceAll("\r\n", "\n");
+  if (removeZeroWidthCharacters) {
+    normalizedString = normalizedString.replaceAll(RE_ZERO_WIDTH, "");
+  }
+  const result = normalizedString.split("\n").map((line) => {
+    if (trim && line.trim() === "") {
+      return "";
+    }
+    let wrappedLines;
+    switch (wrapMode) {
+      case WrapMode.BREAK_AT_CHARACTERS: {
+        wrappedLines = wrapCharByChar(line, width, trim);
+        break;
+      }
+      case WrapMode.BREAK_WORDS: {
+        wrappedLines = wrapAndBreakWords(line, width, trim);
+        break;
+      }
+      case WrapMode.STRICT_WIDTH: {
+        wrappedLines = wrapWithBreakAtWidth(line, width, trim);
+        break;
+      }
+      default: {
+        wrappedLines = wrapWithWordBoundaries(line, width, trim);
+      }
+    }
+    return preserveAnsi(wrappedLines);
+  });
+  return result.join("\n");
+};
+
+const defaultColumns = 80;
+const defaultRows = 24;
+const exec = (command, arguments_, { shell, env } = {}) => execFileSync(command, arguments_, {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "ignore"],
+  timeout: 500,
+  shell,
+  env
+}).trim();
+const create = (columns, rows) => ({
+  columns: Number.parseInt(columns, 10),
+  rows: Number.parseInt(rows, 10)
+});
+const createIfNotDefault = (maybeColumns, maybeRows) => {
+  const { columns, rows } = create(maybeColumns, maybeRows);
+  if (Number.isNaN(columns) || Number.isNaN(rows)) {
+    return;
+  }
+  if (columns === defaultColumns && rows === defaultRows) {
+    return;
+  }
+  return { columns, rows };
+};
+const isForegroundProcess = () => {
+  if (process$2.platform !== "linux") {
+    return true;
+  }
+  try {
+    const statContents = fs.readFileSync("/proc/self/stat", "utf8");
+    const closingParenthesisIndex = statContents.lastIndexOf(") ");
+    if (closingParenthesisIndex === -1) {
+      return false;
+    }
+    const statFields = statContents.slice(closingParenthesisIndex + 2).trim().split(/\s+/);
+    const processGroupId = Number.parseInt(statFields[2], 10);
+    const foregroundProcessGroupId = Number.parseInt(statFields[5], 10);
+    if (Number.isNaN(processGroupId) || Number.isNaN(foregroundProcessGroupId)) {
+      return false;
+    }
+    if (foregroundProcessGroupId <= 0) {
+      return false;
+    }
+    return processGroupId === foregroundProcessGroupId;
+  } catch {
+    return false;
+  }
+};
+function terminalSize() {
+  const { env, stdout, stderr } = process$2;
+  if (stdout?.columns && stdout?.rows) {
+    return create(stdout.columns, stdout.rows);
+  }
+  if (stderr?.columns && stderr?.rows) {
+    return create(stderr.columns, stderr.rows);
+  }
+  if (env.COLUMNS && env.LINES) {
+    return create(env.COLUMNS, env.LINES);
+  }
+  const fallback = {
+    columns: defaultColumns,
+    rows: defaultRows
+  };
+  if (process$2.platform === "win32") {
+    return tput() ?? fallback;
+  }
+  if (process$2.platform === "darwin") {
+    return devTty() ?? tput() ?? fallback;
+  }
+  return devTty() ?? tput() ?? resize() ?? fallback;
+}
+const devTty = () => {
+  try {
+    const flags = process$2.platform === "darwin" ? fs.constants.O_EVTONLY | fs.constants.O_NONBLOCK : fs.constants.O_NONBLOCK;
+    const { columns, rows } = tty.WriteStream(fs.openSync("/dev/tty", flags));
+    return { columns, rows };
+  } catch {
+  }
+};
+const tput = () => {
+  try {
+    const columns = exec("tput", ["cols"], { env: { TERM: "dumb", ...process$2.env } });
+    const rows = exec("tput", ["lines"], { env: { TERM: "dumb", ...process$2.env } });
+    if (columns && rows) {
+      return createIfNotDefault(columns, rows);
+    }
+  } catch {
+  }
+};
+const resize = () => {
+  try {
+    if (!isForegroundProcess()) {
+      return;
+    }
+    const size = exec("resize", ["-u"]).match(/\d+/g);
+    if (size.length === 2) {
+      return createIfNotDefault(size[0], size[1]);
+    }
+  } catch {
+  }
+};
+
+const EXTENDED_RFC_5424_LOG_LEVELS = {
+  alert: 7,
+  // Action must be taken immediately. Example: Entire website down, database unavailable, etc. This should trigger the SMS alerts and wake you up.
+  critical: 6,
+  // Critical conditions. Example: Application component unavailable, unexpected exception.
+  debug: 1,
+  // Detailed debug information.
+  emergency: 8,
+  // Emergency: system is unusable.
+  error: 5,
+  // Runtime errors that do not require immediate action but should typically be logged and monitored.
+  informational: 2,
+  // Interesting events. Examples: User logs in, SQL logs.
+  notice: 3,
+  // Normal but significant events.
+  trace: 2,
+  // Trace information.
+  warning: 4
+  // Exceptional occurrences that are not errors. Examples: Use of deprecated APIs, poor use of an API, undesirable things that are not necessarily wrong.
+};
+const LOG_TYPES = {
+  alert: {
+    color: "red",
+    label: "alert",
+    logLevel: "alert"
+  },
+  await: {
+    color: "blue",
+    label: "awaiting",
+    logLevel: "informational"
+  },
+  complete: {
+    color: "cyan",
+    label: "complete",
+    logLevel: "informational"
+  },
+  critical: {
+    color: "redBright",
+    label: "critical",
+    logLevel: "critical"
+  },
+  debug: {
+    color: "gray",
+    label: "debug",
+    logLevel: "debug"
+  },
+  emergency: {
+    color: "redBright",
+    label: "emergency",
+    logLevel: "emergency"
+  },
+  error: {
+    color: "red",
+    label: "error",
+    logLevel: "error"
+  },
+  info: {
+    color: "blueBright",
+    label: "info",
+    logLevel: "informational"
+  },
+  log: {
+    label: "",
+    logLevel: "informational"
+  },
+  notice: {
+    color: "magentaBright",
+    label: "notice",
+    logLevel: "notice"
+  },
+  pending: {
+    color: "magenta",
+    label: "pending",
+    logLevel: "informational"
+  },
+  start: {
+    color: "greenBright",
+    label: "start",
+    logLevel: "informational"
+  },
+  stop: {
+    color: "red",
+    label: "stop",
+    logLevel: "informational"
+  },
+  success: {
+    color: "green",
+    label: "success",
+    logLevel: "informational"
+  },
+  trace: {
+    color: "cyanBright",
+    label: "trace",
+    logLevel: "trace"
+  },
+  wait: {
+    color: "blue",
+    label: "waiting",
+    logLevel: "informational"
+  },
+  warn: {
+    color: "yellow",
+    label: "warning",
+    logLevel: "warning"
+  },
+  warning: {
+    color: "yellow",
+    label: "warning",
+    logLevel: "warning"
+  },
+  watch: {
+    color: "yellowBright",
+    label: "watching",
+    logLevel: "informational"
+  }
+};
+const EMPTY_SYMBOL = /* @__PURE__ */ Symbol("EMPTY");
+
+const getLongestLabel = (types) => {
+  const labels = Object.keys(types).map((x) => types[x].label ?? "");
+  if (labels.length === 0) {
+    return "";
+  }
+  return labels.reduce((x, y) => x.length > y.length ? x : y);
+};
+
+const TRUNCATOR = "…";
+const inspectList = (list, from, options, inspect2, inspectItem, separator = ", ") => {
+  const size = list.length;
+  if (size === 0) {
+    return "";
+  }
+  let inspect_ = inspect2;
+  if (inspectItem !== void 0) {
+    inspect_ = inspectItem;
+  }
+  const originalLength = options.truncate;
+  let output = "";
+  let peek = "";
+  let truncated = "";
+  for (let index = 0; index < size; index += 1) {
+    const last = index + 1 === list.length;
+    const secondToLast = index + 2 === list.length;
+    truncated = `${TRUNCATOR}(${list.length - index})`;
+    let value = list[index];
+    options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+    const string = peek || inspect_(value, from, options, inspect2) + (last ? "" : separator);
+    const nextLength = output.length + string.length;
+    const truncatedLength = nextLength + truncated.length;
+    if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+      break;
+    }
+    if (!last && !secondToLast && truncatedLength > originalLength) {
+      break;
+    }
+    value = list[index + 1];
+    peek = last ? "" : inspect_(value, from, options, inspect2) + (secondToLast ? "" : separator);
+    if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
+      break;
+    }
+    output += string;
+    if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+      truncated = `${TRUNCATOR}(${list.length - index - 1})`;
+      break;
+    }
+    truncated = "";
+  }
+  return `${output}${truncated}`;
+};
+const inspectAttribute = ([key, value], _, options) => {
+  options.truncate -= 3;
+  if (!value) {
+    return options.stylize(String(key), "yellow");
+  }
+  return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
+};
+const inspectNode = (node, inspect2, options) => {
+  switch (node.nodeType) {
+    case 1: {
+      return inspectHTMLElement(node, node, options, inspect2);
+    }
+    case 3: {
+      return inspect2(node.data, inspect2, options);
+    }
+    default: {
+      return inspect2(node, inspect2, options);
+    }
+  }
+};
+const inspectNodeCollection = (collection, options, inspect2, _) => inspectList(collection, collection, options, inspect2, inspectNode, "\n");
+const inspectHTMLElement = (element, object, options, inspect2) => {
+  const properties = element.getAttributeNames();
+  const name = element.tagName.toLowerCase();
+  const head = options.stylize(`<${name}`, "special");
+  const headClose = options.stylize(`>`, "special");
+  const tail = options.stylize(`</${name}>`, "special");
+  options.truncate -= name.length * 2 + 5;
+  let propertyContents = "";
+  if (properties.length > 0) {
+    propertyContents += " ";
+    propertyContents += inspectList(
+      properties.map((key) => [key, element.getAttribute(key)]),
+      object,
+      options,
+      inspect2,
+      inspectAttribute,
+      " "
+    );
+  }
+  options.truncate -= propertyContents.length;
+  const { truncate: truncate2 } = options;
+  let children = inspectNodeCollection(element.children, options, inspect2);
+  if (children && children.length > truncate2) {
+    children = `${TRUNCATOR}(${element.children.length})`;
+  }
+  return `${head}${propertyContents}${headClose}${children}${tail}`;
+};
+const inspectArguments = (arguments_, options, inspect2) => {
+  if (arguments_.length === 0) {
+    return "Arguments []";
+  }
+  options.truncate -= 13;
+  return `Arguments [ ${inspectList(arguments_, arguments_, options, inspect2)} ]`;
+};
+const getIndent = (indent, depth) => {
+  let baseIndent;
+  if (indent === "	") {
+    baseIndent = "	";
+  } else if (typeof indent === "number" && indent > 0) {
+    baseIndent = Array.from({ length: indent + 1 }).join(" ");
+  } else {
+    return void 0;
+  }
+  return {
+    base: baseIndent,
+    prev: `
+${Array.from({ length: depth + 1 }).join(baseIndent)}`
+  };
+};
+const indentedJoin = (values, indent) => {
+  if (values.length === 0) {
+    return "";
+  }
+  const lineJoiner = indent.prev + indent.base;
+  return lineJoiner + values.split(", ").join(`,${lineJoiner}`) + indent.prev;
+};
+const quoteComplexKey = (key, options) => {
+  if (/^[a-z_]\w*$/i.test(key)) {
+    return key;
+  }
+  const stringifiedKey = JSON.stringify(key);
+  if (options.quoteStyle === "double") {
+    return stringifiedKey.replaceAll('"', String.raw`\"`);
+  }
+  return stringifiedKey.replaceAll("'", String.raw`\'`).replaceAll(String.raw`\"`, '"').replaceAll(/^"|"$/g, "'");
+};
+const inspectProperty = ([key, value], object, options, inspect2) => {
+  options.truncate -= 2;
+  if (typeof key === "string") {
+    key = quoteComplexKey(key, options);
+  } else if (typeof key !== "number") {
+    key = `[${inspect2(key, object, options)}]`;
+  }
+  options.truncate -= key.length;
+  value = inspect2(value, object, options);
+  return `${key}: ${value}`;
+};
+const multiLineValues = (values) => {
+  for (const value of values) {
+    if (Array.isArray(value) || typeof value === "object" && value !== null) {
+      return true;
+    }
+  }
+  return false;
+};
+const inspectArray = (array, options, inspect2, indent) => {
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (array.length === 0 && nonIndexProperties.length === 0) {
+    return "[]";
+  }
+  options.truncate -= 4;
+  let listContents = inspectList(array, array, options, inspect2);
+  options.truncate -= listContents.length;
+  let propertyContents = "";
+  if (nonIndexProperties.length > 0) {
+    propertyContents = inspectList(
+      nonIndexProperties.map((key) => [key, array[key]]),
+      array,
+      options,
+      inspect2,
+      inspectProperty
+    );
+  }
+  const hasIndent = indent && multiLineValues(array);
+  if (hasIndent) {
+    listContents = indentedJoin(listContents, indent);
+  }
+  return `[${hasIndent ? "" : " "}${listContents}${propertyContents ? `, ${propertyContents}` : ""}${hasIndent ? "" : " "}]`;
+};
+const addNumericSeparator = (number_, string_) => {
+  if (number_ === Number.POSITIVE_INFINITY || number_ === Number.NEGATIVE_INFINITY || string_.includes("e")) {
+    return string_;
+  }
+  const separatorRegex = /\d(?=(?:\d{3})+(?!\d))/g;
+  if (typeof number_ === "number") {
+    const int = number_ < 0 ? -Math.floor(-number_) : Math.floor(number_);
+    if (int !== number_) {
+      const intString = String(int);
+      const dec = string_.slice(intString.length + 1);
+      return (
+        // eslint-disable-next-line unicorn/prefer-string-replace-all
+        `${intString.replace(separatorRegex, "$&_")}.${dec.replace(/\d{3}/g, "$&_").replace(/_$/, "")}`
+      );
+    }
+  }
+  return string_.replace(separatorRegex, "$&_");
+};
+const isHighSurrogate = (char) => char >= "\uD800" && char <= "\uDBFF";
+const truncate = (string, length, tail = TRUNCATOR) => {
+  string = String(string);
+  const tailLength = tail.length;
+  const stringLength = string.length;
+  if (tailLength > length && stringLength > tailLength) {
+    return tail;
+  }
+  if (stringLength > length && stringLength > tailLength) {
+    let end = length - tailLength;
+    if (end > 0 && isHighSurrogate(string[end - 1])) {
+      end -= 1;
+    }
+    return `${string.slice(0, end)}${tail}`;
+  }
+  return string;
+};
+const inspectBigInt = (number, options) => {
+  let nums = truncate(number.toString(), options.truncate - 1);
+  if (nums !== TRUNCATOR) {
+    nums += "n";
+  }
+  return options.stylize(options.numericSeparator ? addNumericSeparator(number, nums) : nums, "bigint");
+};
+const gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
+  return O.__proto__;
+} : null);
+const inspectObject$1 = (object, options, inspect2, indent) => {
+  if (globalThis.window !== void 0 && object === globalThis) {
+    return "{ [object Window] }";
+  }
+  if (typeof globalThis !== "undefined" && object === globalThis || globalThis.global !== void 0 && object === globalThis) {
+    return "{ [object globalThis] }";
+  }
+  const properties = Object.getOwnPropertyNames(object);
+  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+  const isPlainObject = gPO(object) === Object.prototype || object.constructor === Object;
+  const protoTag = object instanceof Object ? "" : "null prototype";
+  const stringTag = !isPlainObject && typeof Symbol !== "undefined" && Symbol.toStringTag in object ? object[Symbol.toStringTag] : protoTag ? "Object" : "";
+  const tag = stringTag || protoTag ? `[${[stringTag, protoTag].filter(Boolean).join(": ")}] ` : "";
+  if (properties.length === 0 && symbols.length === 0) {
+    return `${tag}{}`;
+  }
+  options.truncate -= 4;
+  const propertyContents = inspectList(
+    properties.map((key) => [key, object[key]]),
+    object,
+    options,
+    inspect2,
+    inspectProperty
+  );
+  const symbolContents = inspectList(
+    symbols.map((key) => [key, object[key]]),
+    object,
+    options,
+    inspect2,
+    inspectProperty
+  );
+  let separator = "";
+  if (propertyContents && symbolContents) {
+    separator = ", ";
+  }
+  if (indent) {
+    return `${tag}{${indentedJoin(propertyContents + separator + symbolContents, indent)}}`;
+  }
+  return `${tag}{ ${propertyContents}${separator}${symbolContents} }`;
+};
+const inspectClass = (value, options, inspect2, indent) => {
+  let name = "";
+  name = name || value.constructor.name;
+  if (!name || name === "_class") {
+    name = "<Anonymous Class>";
+  }
+  options.truncate -= name.length;
+  return `${name} ${inspectObject$1(value, options, inspect2, indent)}`;
+};
+const inspectDate = (dateObject, options) => {
+  const stringRepresentation = dateObject.toJSON();
+  if (stringRepresentation === null) {
+    return "Invalid Date";
+  }
+  const split = stringRepresentation.split("T");
+  const date = split[0];
+  return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
+};
+const errorKeys = /* @__PURE__ */ new Set(["column", "columnNumber", "description", "fileName", "line", "lineNumber", "message", "name", "number", "stack"]);
+const inspectObject = (error, options, inspect2) => {
+  const properties = Object.getOwnPropertyNames(error).filter((key) => !errorKeys.has(key));
+  const { name } = error;
+  options.truncate -= name.length;
+  let message = "";
+  if (typeof error.message === "string") {
+    message = truncate(error.message, options.truncate);
+  } else {
+    properties.unshift("message");
+  }
+  message = message ? `: ${message}` : "";
+  options.truncate -= message.length + 5;
+  const propertyContents = inspectList(
+    properties.map((key) => [key, error[key]]),
+    error,
+    options,
+    inspect2,
+    inspectProperty
+  );
+  return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
+};
+const inspectFunction = (function_, options) => {
+  const functionType = function_[Symbol.toStringTag] || "Function";
+  const source = function_.toString();
+  if (source.length < options.truncate - 12) {
+    return options.stylize(`[${functionType}: ${source}]`, "special");
+  }
+  const { name } = function_;
+  if (!name) {
+    return options.stylize(`[${functionType}]`, "special");
+  }
+  return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
+};
+const inspectMapEntry = ([key, value], object, options, inspect2) => {
+  options.truncate -= 4;
+  key = inspect2(key, object, options);
+  options.truncate -= key.length;
+  return `${key} => ${inspect2(value, object, options)}`;
+};
+const inspectMap = (map, options, inspect2, indent) => {
+  if (map.size <= 0) {
+    return "Map (0) {}";
+  }
+  options.truncate -= 7;
+  let returnValue = inspectList([...map.entries()], map, options, inspect2, inspectMapEntry);
+  if (indent) {
+    returnValue = indentedJoin(returnValue, indent);
+  }
+  return `Map (${map.size}) {${indent ? "" : " "}${returnValue}${indent ? "" : " "}}`;
+};
+function inspectNumber(number, options) {
+  if (Number.isNaN(number)) {
+    return options.stylize("NaN", "number");
+  }
+  if (number === Number.POSITIVE_INFINITY) {
+    return options.stylize("Infinity", "number");
+  }
+  if (number === Number.NEGATIVE_INFINITY) {
+    return options.stylize("-Infinity", "number");
+  }
+  if (number === 0) {
+    return options.stylize(1 / number === Number.POSITIVE_INFINITY ? "+0" : "-0", "number");
+  }
+  return options.stylize(truncate(options.numericSeparator ? addNumericSeparator(number, number.toString()) : number.toString(), options.truncate), "number");
+}
+const getPromiseValue = () => "Promise{…}";
+const inspectRegExp = (regExp, options) => {
+  const sourceLength = options.truncate - (2 + regExp.flags.length);
+  return options.stylize(`/${truncate(regExp.source, sourceLength)}/${regExp.flags}`, "regexp");
+};
+const inspectSet = (set, options, inspect2, indent) => {
+  if (set.size === 0) {
+    return "Set (0) {}";
+  }
+  options.truncate -= 7;
+  let returnValue = inspectList([...set], set, options, inspect2);
+  if (indent) {
+    returnValue = indentedJoin(returnValue, indent);
+  }
+  return `Set (${set.size}) {${indent ? "" : " "}${returnValue}${indent ? "" : " "}}`;
+};
+const wrapQuotes = (string_, options) => {
+  const quoteChar = options.quoteStyle === "double" ? '"' : "'";
+  if (options.quoteStyle === "double") {
+    string_ = string_.replaceAll('"', '"');
+  }
+  return quoteChar + string_ + quoteChar;
+};
+const stringEscapeChars = new RegExp(
+  String.raw`['\0-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5` + String.raw`\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]`,
+  "g"
+);
+const escapeCharacters = {
+  "	": String.raw`\t`,
+  "\n": String.raw`\n`,
+  "\f": String.raw`\f`,
+  "\r": String.raw`\r`,
+  "\b": String.raw`\b`,
+  "'": String.raw`\'`,
+  "\\": "\\\\"
+};
+const hex = 16;
+const escape = (char) => escapeCharacters[char] || String.raw`\u${`0000${char.codePointAt(0).toString(hex)}`.slice(-4)}`;
+const inspectString = (string_, options) => {
+  if (stringEscapeChars.test(string_)) {
+    string_ = string_.replaceAll(stringEscapeChars, escape);
+  }
+  return options.stylize(wrapQuotes(truncate(string_, options.truncate - 2), options), "string");
+};
+const inspectSymbol = (value) => {
+  if ("description" in Symbol.prototype) {
+    return value.description ? `Symbol(${value.description})` : "Symbol()";
+  }
+  return value.toString();
+};
+const getArrayName = (array) => {
+  if (typeof Buffer === "function" && array instanceof Buffer) {
+    return "Buffer";
+  }
+  if (array[Symbol.toStringTag]) {
+    return array[Symbol.toStringTag];
+  }
+  return array.constructor.name;
+};
+const inspectTypedArray = (array, options, inspect2) => {
+  const name = getArrayName(array);
+  options.truncate -= name.length + 4;
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (array.length === 0 && nonIndexProperties.length === 0) {
+    return `${name}[]`;
+  }
+  let output = "";
+  for (let index = 0; index < array.length; index++) {
+    const string = `${options.stylize(truncate(array[index], options.truncate), "number")}${index === array.length - 1 ? "" : ", "}`;
+    options.truncate -= string.length;
+    if (array[index] !== array.length && options.truncate <= 3) {
+      output += `${TRUNCATOR}(${array.length - array[index] + 1})`;
+      break;
+    }
+    output += string;
+  }
+  let propertyContents = "";
+  if (nonIndexProperties.length > 0) {
+    propertyContents = inspectList(
+      nonIndexProperties.map((key) => [key, array[key]]),
+      array,
+      options,
+      inspect2,
+      inspectProperty
+    );
+  }
+  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+};
+const constructorMap = /* @__PURE__ */ new WeakMap();
+const stringTagMap = {};
+const baseTypesMap = {
+  Arguments: inspectArguments,
+  Array: inspectArray,
+  ArrayBuffer: () => "",
+  BigInt: inspectBigInt,
+  bigint: inspectBigInt,
+  Boolean: (value, options) => options.stylize(String(value), "boolean"),
+  boolean: (value, options) => options.stylize(String(value), "boolean"),
+  DataView: () => "",
+  Date: inspectDate,
+  Error: inspectObject,
+  Float32Array: inspectTypedArray,
+  Float64Array: inspectTypedArray,
+  Function: inspectFunction,
+  function: inspectFunction,
+  Generator: () => "",
+  HTMLCollection: inspectNodeCollection,
+  Int8Array: inspectTypedArray,
+  Int16Array: inspectTypedArray,
+  Int32Array: inspectTypedArray,
+  Map: inspectMap,
+  NodeList: inspectNodeCollection,
+  null: (_value, options) => options.stylize("null", "null"),
+  Number: inspectNumber,
+  number: inspectNumber,
+  Promise: getPromiseValue,
+  RegExp: inspectRegExp,
+  Set: inspectSet,
+  String: inspectString,
+  string: inspectString,
+  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+  Symbol: inspectSymbol,
+  symbol: inspectSymbol,
+  Uint8Array: inspectTypedArray,
+  Uint8ClampedArray: inspectTypedArray,
+  Uint16Array: inspectTypedArray,
+  Uint32Array: inspectTypedArray,
+  undefined: (_value, options) => options.stylize("undefined", "undefined"),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  WeakMap: (_value, options) => options.stylize("WeakMap{…}", "special"),
+  // WeakSet, WeakMap are totally opaque to us
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  WeakSet: (_value, options) => options.stylize("WeakSet{…}", "special")
+};
+const inspectCustom = (value, options, type, depth) => {
+  if (globalThis.window === void 0 && typeof value[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] === "function") {
+    return value[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](depth, options);
+  }
+  if ("inspect" in value && typeof value.inspect === "function") {
+    return value.inspect(depth, options);
+  }
+  if ("constructor" in value && constructorMap.has(value.constructor)) {
+    return constructorMap.get(value.constructor)?.(value, options) ?? "unknown";
+  }
+  if (stringTagMap[type]) {
+    return stringTagMap[type](value, options);
+  }
+  return "";
+};
+const internalInspect = (value, options, depth, seen) => {
+  if (seen.includes(value)) {
+    return "[Circular]";
+  }
+  if (depth >= options.depth && options.depth > 0 && typeof value === "object") {
+    return Array.isArray(value) ? "[Array]" : "[Object]";
+  }
+  const inspect2 = (object, from, options2) => {
+    if (from) {
+      seen = [...seen, from];
+    }
+    return internalInspect(object, options2, depth + 1, seen);
+  };
+  const indent = options.indent ? getIndent(options.indent, depth) : void 0;
+  let type = value === null ? "null" : typeof value;
+  if (type === "object") {
+    type = Object.prototype.toString.call(value).slice(8, -1);
+  }
+  if (baseTypesMap[type] !== void 0) {
+    return baseTypesMap[type](value, options, inspect2, indent);
+  }
+  if (options.customInspect && value) {
+    const output = inspectCustom(value, options, type, options.depth - depth);
+    if (output) {
+      if (typeof output === "string") {
+        return output;
+      }
+      return inspect2(output, value, options);
+    }
+  }
+  const proto = value ? Object.getPrototypeOf(value) : false;
+  if (proto === Object.prototype || proto === null) {
+    return inspectObject$1(value, options, inspect2, indent);
+  }
+  if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) {
+    return inspectHTMLElement(value, value, options, inspect2);
+  }
+  if ("constructor" in value) {
+    if (value.constructor !== Object) {
+      return inspectClass(value, options, inspect2, indent);
+    }
+    return inspectObject$1(value, options, inspect2, indent);
+  }
+  if (value === Object(value)) {
+    return inspectObject$1(value, options, inspect2, indent);
+  }
+  return options.stylize(String(value), type);
+};
+const inspect = (value, options_ = {}) => {
+  const options = {
+    breakLength: Number.POSITIVE_INFINITY,
+    customInspect: true,
+    depth: 5,
+    indent: void 0,
+    maxArrayLength: Number.POSITIVE_INFINITY,
+    numericSeparator: true,
+    quoteStyle: "single",
+    showHidden: false,
+    showProxy: false,
+    stylize: (s) => s.toString(),
+    truncate: Number.POSITIVE_INFINITY,
+    ...options_
+  };
+  if (options.indent !== void 0 && options.indent !== "	" && !(Number.parseInt(options.indent, 10) === options.indent && options.indent > 0)) {
+    throw new TypeError('option "indent" must be "\\t", an integer > 0, or `undefined`');
+  }
+  return internalInspect(value, options, 0, []);
+};
+
+const writeStream = (data, stream) => {
+  const write = stream.__write ?? stream.write;
+  return write.call(stream, data);
+};
+
+const normalizeLF = (code) => code.replaceAll(/\r\n|\r(?!\n)|\n/gu, "\n");
+const _process = globalThis.process || /* @__PURE__ */ Object.create(null);
+const processShims = {
+  versions: {}
+};
+const process$1 = /* @__PURE__ */ new Proxy(_process, {
+  get(target, property) {
+    if (property in target) {
+      return target[property];
+    }
+    if (property in processShims) {
+      return processShims[property];
+    }
+    return void 0;
+  }
+});
+const getMarkerLines = (loc, source, linesAbove, linesBelow) => {
+  const startLoc = {
+    column: 0,
+    // @ts-expect-error Can be overwritten
+    line: -1,
+    ...loc.start
+  };
+  const endLoc = {
+    ...startLoc,
+    ...loc.end
+  };
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let index = 0; index <= lineDiff; index++) {
+      const lineNumber = index + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (index === 0) {
+        const sourceLength = source[lineNumber - 1]?.length;
+        markerLines[lineNumber] = [startColumn, (sourceLength ?? 0) - startColumn + 1];
+      } else if (index === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - index]?.length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else if (startColumn === endColumn) {
+    markerLines[startLine] = startColumn ? [startColumn, 0] : true;
+  } else {
+    markerLines[startLine] = [startColumn, (endColumn ?? 0) - (startColumn ?? 0)];
+  }
+  return { end, markerLines, start };
+};
+const CODE_FRAME_POINTER = process$1.platform === "win32" && !process$1.env?.WT_SESSION ? ">" : "❯";
+const codeFrame = (source, loc, options) => {
+  const config = {
+    // grab 2 lines before, and 3 lines after focused line
+    linesAbove: 2,
+    linesBelow: 3,
+    prefix: "",
+    showGutter: true,
+    tabWidth: 4,
+    ...options,
+    color: {
+      gutter: (value) => value,
+      marker: (value) => value,
+      message: (value) => value,
+      ...options?.color
+    }
+  };
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  let lines = normalizeLF(source).split("\n");
+  if (typeof config?.tabWidth === "number") {
+    lines = lines.map((ln) => ln.replaceAll("	", " ".repeat(config.tabWidth)));
+  }
+  const { end, markerLines, start } = getMarkerLines(loc, lines, config.linesAbove, config.linesBelow);
+  const numberMaxWidth = String(end).length;
+  const { gutter: colorizeGutter, marker: colorizeMarker, message: colorizeMessage } = config.color;
+  let frame = lines.slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const hasMarker = markerLines[number];
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const lastMarkerLine = !markerLines[number + 1];
+    const gutter = ` ${paddedNumber}${config.showGutter ? " |" : ""}`;
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.replaceAll(/[^\t]/g, " ").slice(0, Math.max(hasMarker[0] - 1, 0));
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = [
+          "\n ",
+          config.prefix + colorizeGutter(gutter.replaceAll(/\d/g, " ")),
+          " ",
+          markerSpacing,
+          colorizeMarker("^").repeat(numberOfMarkers)
+        ].join("");
+        if (lastMarkerLine && config.message) {
+          markerLine += ` ${colorizeMessage(config.message)}`;
+        }
+      }
+      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    }
+    return `${config.prefix} ${colorizeGutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+  }).join("\n");
+  if (config.message && !hasColumns) {
+    frame = `${config.prefix + " ".repeat(numberMaxWidth + 1) + config.message}
+${frame}`;
+  }
+  return frame;
+};
+
+const debugLog = (message, ...arguments_) => {
+  if (process.env.DEBUG && String(process.env.DEBUG) === "true") {
+    console.debug(`error:parse-stacktrace: ${message}`, ...arguments_);
+  }
+};
+const UNKNOWN_FUNCTION = "<unknown>";
+const CHROMIUM_REGEX = /^.*?\s*at\s(?:(.+?\)(?:\s\[.+\])?|\(?.*?)\s?\((?:address\sat\s)?)?(?:async\s)?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+const CHROMIUM_EVAL_REGEX = /\((\S+)\),\s(<[^>]+>)?:(\d+)?:(\d+)?\)?/;
+const CHROMIUM_MAPPED = /(.*?):(\d+):(\d+)(\s<-\s(.+):(\d+):(\d+))?/;
+const WINDOWS_EVAL_REGEX = /(eval)\sat\s(<anonymous>)\s\((.*)\)?:(\d+)?:(\d+)\),\s*(<anonymous>)?:(\d+)?:(\d+)/;
+const NODE_REGEX = /^\s*in\s(?:([^\\/]+(?:\s\[as\s\S+\])?)\s\(?)?\(at?\s?(.*?):(\d+)(?::(\d+))?\)?\s*$/;
+const NODE_NESTED_REGEX = /in\s(.*)\s\(at\s(.+)\)\sat/;
+const REACT_ANDROID_NATIVE_REGEX = /^(?:.*@)?(.*):(\d+):(\d+)$/;
+const GECKO_REGEX = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. \/=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+const GECKO_EVAL_REGEX = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+const FIREFOX_REGEX = /(\S[^\s[]*\[.*\]|.*?)@(.*):(\d+):(\d+)/;
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const extractSafariExtensionDetails = (methodName, url) => {
+  const isSafariExtension = methodName.includes("safari-extension");
+  const isSafariWebExtension = methodName.includes("safari-web-extension");
+  return isSafariExtension || isSafariWebExtension ? [
+    methodName.includes("@") ? methodName.split("@")[0] : UNKNOWN_FUNCTION,
+    isSafariExtension ? `safari-extension:${url}` : `safari-web-extension:${url}`
+  ] : [methodName, url];
+};
+const parseMapped = (trace, maybeMapped) => {
+  const match = CHROMIUM_MAPPED.exec(maybeMapped);
+  if (match) {
+    trace.file = match[1];
+    trace.line = +match[2];
+    trace.column = +match[3];
+  }
+};
+const parseNode = (line) => {
+  const nestedNode = NODE_NESTED_REGEX.exec(line);
+  if (nestedNode) {
+    debugLog(`parse nested node error stack line: "${line}"`, `found: ${JSON.stringify(nestedNode)}`);
+    const split = nestedNode[2].split(":");
+    return {
+      column: split[2] ? +split[2] : void 0,
+      file: split[0],
+      line: split[1] ? +split[1] : void 0,
+      methodName: nestedNode[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  const node = NODE_REGEX.exec(line);
+  if (node) {
+    debugLog(`parse node error stack line: "${line}"`, `found: ${JSON.stringify(node)}`);
+    const trace = {
+      column: node[4] ? +node[4] : void 0,
+      file: node[2] ? node[2].replace(/at\s/, "") : void 0,
+      line: node[3] ? +node[3] : void 0,
+      methodName: node[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: line.startsWith("internal") ? "internal" : void 0
+    };
+    parseMapped(trace, `${node[2]}:${node[3]}:${node[4]}`);
+    return trace;
+  }
+  return void 0;
+};
+const parseChromium = (line) => {
+  const parts = CHROMIUM_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse chrome error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    const isNative = parts[2]?.startsWith("native");
+    const isEval = parts[2]?.startsWith("eval") || parts[1]?.startsWith("eval");
+    let evalOrigin;
+    let windowsParts;
+    if (isEval) {
+      const subMatch = CHROMIUM_EVAL_REGEX.exec(line);
+      if (subMatch) {
+        const split = /^(\S+):(\d+):(\d+)$|^(\S+):(\d+)$/.exec(subMatch[1]);
+        if (split) {
+          parts[2] = split[4] ?? split[1];
+          parts[3] = split[5] ?? split[2];
+          parts[4] = split[3];
+        } else if (subMatch[2]) {
+          parts[2] = subMatch[1];
+        }
+        if (subMatch[2]) {
+          evalOrigin = {
+            column: subMatch[4] ? +subMatch[4] : void 0,
+            file: subMatch[2],
+            line: subMatch[3] ? +subMatch[3] : void 0,
+            methodName: "eval",
+            raw: line,
+            type: "eval"
+          };
+        }
+      } else {
+        const windowsSubMatch = WINDOWS_EVAL_REGEX.exec(line);
+        if (windowsSubMatch) {
+          windowsParts = {
+            column: windowsSubMatch[5] ? +windowsSubMatch[5] : void 0,
+            file: windowsSubMatch[3],
+            line: windowsSubMatch[4] ? +windowsSubMatch[4] : void 0
+          };
+          evalOrigin = {
+            column: windowsSubMatch[8] ? +windowsSubMatch[8] : void 0,
+            file: windowsSubMatch[2],
+            line: windowsSubMatch[7] ? +windowsSubMatch[7] : void 0,
+            methodName: "eval",
+            raw: windowsSubMatch[0],
+            type: "eval"
+          };
+        }
+      }
+    }
+    const [methodName, file] = extractSafariExtensionDetails(
+      // Normalize IE's 'Anonymous function'
+      parts[1] ? parts[1].replace(/^Anonymous function$/, "<anonymous>") : UNKNOWN_FUNCTION,
+      parts[2]
+    );
+    const trace = {
+      column: parts[4] ? +parts[4] : void 0,
+      evalOrigin,
+      file,
+      line: parts[3] ? +parts[3] : void 0,
+      methodName,
+      raw: line,
+      // eslint-disable-next-line sonarjs/no-nested-conditional
+      type: isEval ? "eval" : isNative ? "native" : void 0
+    };
+    if (windowsParts) {
+      trace.column = windowsParts.column;
+      trace.file = windowsParts.file;
+      trace.line = windowsParts.line;
+    } else {
+      parseMapped(trace, `${file}:${parts[3]}:${parts[4]}`);
+    }
+    return trace;
+  }
+  return void 0;
+};
+const parseGecko = (line, topFrameMeta) => {
+  const parts = GECKO_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse gecko error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    const isEval = parts[3]?.includes(" > eval");
+    const subMatch = isEval && parts[3] && GECKO_EVAL_REGEX.exec(parts[3]);
+    let evalOrigin;
+    if (isEval && subMatch) {
+      parts[3] = subMatch[1];
+      evalOrigin = {
+        column: parts[5] ? +parts[5] : void 0,
+        file: parts[3],
+        line: parts[4] ? +parts[4] : void 0,
+        methodName: "eval",
+        raw: line,
+        type: "eval"
+      };
+      parts[4] = subMatch[2];
+    }
+    const [methodName, file] = extractSafariExtensionDetails(
+      // Normalize IE's 'Anonymous function'
+      parts[1] ? parts[1].replace(/^Anonymous function$/, "<anonymous>") : UNKNOWN_FUNCTION,
+      parts[3]
+    );
+    let column;
+    if ((topFrameMeta?.type === "safari" || !isEval && topFrameMeta?.type === "firefox") && topFrameMeta.column) {
+      column = topFrameMeta.column;
+    } else if (!isEval && parts[5]) {
+      column = +parts[5];
+    }
+    let lineNumber;
+    if ((topFrameMeta?.type === "safari" || !isEval && topFrameMeta?.type === "firefox") && topFrameMeta.line) {
+      lineNumber = topFrameMeta.line;
+    } else if (parts[4]) {
+      lineNumber = +parts[4];
+    }
+    return {
+      column,
+      evalOrigin,
+      file,
+      line: lineNumber,
+      methodName,
+      raw: line,
+      // eslint-disable-next-line sonarjs/no-nested-conditional
+      type: isEval ? "eval" : file.includes("[native code]") ? "native" : void 0
+    };
+  }
+  return void 0;
+};
+const parseFirefox = (line, topFrameMeta) => {
+  const parts = FIREFOX_REGEX.exec(line);
+  const isEval = parts ? parts[2].includes(" > eval") : false;
+  if (!isEval && parts) {
+    debugLog(`parse firefox error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    return {
+      column: parts[4] ? +parts[4] : topFrameMeta?.column ?? void 0,
+      file: parts[2],
+      line: parts[3] ? +parts[3] : topFrameMeta?.line ?? void 0,
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  return void 0;
+};
+const parseReactAndroidNative = (line) => {
+  const parts = REACT_ANDROID_NATIVE_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse react android native error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    return {
+      column: parts[3] ? +parts[3] : void 0,
+      file: parts[1],
+      line: parts[2] ? +parts[2] : void 0,
+      methodName: UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  return void 0;
+};
+const parseStacktrace = (error, { filter, frameLimit = 50 } = {}) => {
+  let lines = (error.stacktrace ?? error.stack ?? "").split("\n").map((line) => {
+    const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
+    return cleanedLine.replace(/^\s+|\s+$/g, "");
+  }).filter((line) => !/\S*(?:Error: |AggregateError:)/.test(line) && line !== "eval code");
+  if (filter) {
+    lines = lines.filter((element) => filter(element));
+  }
+  lines = lines.slice(0, frameLimit);
+  return lines.reduce((stack, line, currentIndex) => {
+    if (!line) {
+      return stack;
+    }
+    if (line.length > 1024) {
+      return stack;
+    }
+    let parseResult;
+    if (/^\s*in\s.*/.test(line)) {
+      parseResult = parseNode(line);
+    } else if (/^.*?\s*at\s.*/.test(line)) {
+      parseResult = parseChromium(line);
+    } else if (/^.*?\s*@.*|\[native code\]/.test(line)) {
+      let topFrameMeta;
+      if (currentIndex === 0) {
+        if (error.columnNumber || error.lineNumber) {
+          topFrameMeta = {
+            // @ts-expect-error columnNumber and columnNumber property only exists on Firefox
+            column: error.columnNumber,
+            // @ts-expect-error columnNumber and lineNumber property only exists on Firefox
+            line: error.lineNumber,
+            type: "firefox"
+          };
+        } else if (error.line || error.column) {
+          topFrameMeta = {
+            // @ts-expect-error column property only exists on safari
+            column: error.column,
+            // @ts-expect-error line property only exists on safari
+            line: error.line,
+            type: "safari"
+          };
+        }
+      }
+      parseResult = parseFirefox(line, topFrameMeta) || parseGecko(line, topFrameMeta);
+    } else {
+      parseResult = parseReactAndroidNative(line);
+    }
+    if (parseResult) {
+      stack.push(parseResult);
+    } else {
+      debugLog(`parse error stack line: "${line}"`, "not parser found");
+    }
+    return stack;
+  }, []);
+};
+
+const {
+  existsSync,
+  readFileSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  relative
+} = __cjs_getBuiltinModule("node:path");
+const {
+  cwd
+} = __cjs_getProcess;
+const {
+  fileURLToPath
+} = __cjs_getBuiltinModule("node:url");
+const getPrefix = (prefix, indentation, deep) => {
+  if (deep === 0) {
+    return prefix.toString();
+  }
+  if (indentation === "	") {
+    return prefix + "	".repeat(deep);
+  }
+  return prefix + " ".repeat(indentation * deep);
+};
+const getRelativePath = (filePath, cwdPath) => {
+  const path = filePath.replace("async file:", "file:");
+  return relative(cwdPath, path.startsWith("file:") ? fileURLToPath(path) : path);
+};
+const getTitleText = (error, hideErrorTitle, color) => {
+  if (hideErrorTitle) {
+    return color.title(error.message);
+  }
+  const messagePart = error.message ? `: ${error.message}` : "";
+  return color.title(error.name + messagePart);
+};
+const getMessage = (error, { color, hideErrorTitle, indentation, prefix }, deep) => `${getPrefix(prefix, indentation, deep)}${getTitleText(error, hideErrorTitle, color)}
+`;
+const getHint = (error, { color, indentation, prefix }, deep) => {
+  if (error.hint === void 0) {
+    return void 0;
+  }
+  const spaces = getPrefix(prefix, indentation, deep);
+  let message = "";
+  if (Array.isArray(error.hint)) {
+    for (const line of error.hint) {
+      message += `${(spaces + line).toString()}
+`;
+    }
+  } else {
+    message += spaces + error.hint;
+  }
+  return color.hint(message);
+};
+const getMainFrame = (trace, { color, cwd: cwdPath, displayShortPath, indentation, prefix }, deep = 0) => {
+  const filePath = displayShortPath ? getRelativePath(trace.file, cwdPath) : trace.file;
+  const { fileLine, method } = color;
+  return `${getPrefix(prefix, indentation, deep)}at ${trace.methodName ? `${method(trace.methodName)} ` : ""}${fileLine(filePath)}:${fileLine(
+    trace.line?.toString() ?? ""
+  )}`.toString();
+};
+const getCode = (trace, { color, indentation, linesAbove, linesBelow, prefix, showGutter, showLineNumbers, tabWidth }, deep) => {
+  if (trace.file === void 0) {
+    return void 0;
+  }
+  const filePath = trace.file.replace("file://", "");
+  if (!existsSync(filePath)) {
+    return void 0;
+  }
+  const fileContent = readFileSync(filePath, "utf8");
+  return codeFrame(
+    fileContent,
+    {
+      start: { column: trace.column, line: trace.line }
+    },
+    { color, linesAbove, linesBelow, prefix: getPrefix(prefix, indentation, deep), showGutter, showLineNumbers, tabWidth }
+  );
+};
+const getErrors = (error, options, deep) => {
+  if (error.errors.length === 0) {
+    return void 0;
+  }
+  let message = `${getPrefix(options.prefix, options.indentation, deep)}Errors:
+
+`;
+  let first = true;
+  for (const error_ of error.errors) {
+    if (first) {
+      first = false;
+    } else {
+      message += "\n\n";
+    }
+    message += internalRenderError(error_, { ...options, framesMaxLimit: 1, hideErrorCodeView: options.hideErrorErrorsCodeView }, deep + 1);
+  }
+  return `
+${message}`;
+};
+const getCause = (error, options, deep) => {
+  let message = `${getPrefix(options.prefix, options.indentation, deep)}Caused by:
+
+`;
+  const cause = error.cause;
+  message += getMessage(cause, options, deep);
+  const stacktrace = parseStacktrace(cause);
+  const mainFrame = stacktrace.shift();
+  const hint = getHint(cause, options, deep);
+  if (hint) {
+    message += `${hint}
+`;
+  }
+  if (mainFrame) {
+    message += getMainFrame(mainFrame, options, deep);
+    if (!options.hideErrorCauseCodeView) {
+      const code = getCode(mainFrame, options, deep);
+      if (code !== void 0) {
+        message += `
+${code}`;
+      }
+    }
+  }
+  if (cause.cause) {
+    message += `
+${getCause(cause, options, deep + 1)}`;
+  } else if (cause instanceof AggregateError) {
+    const errors = getErrors(cause, options, deep);
+    if (errors !== void 0) {
+      message += `
+${errors}`;
+    }
+  }
+  return `
+${message}`;
+};
+const getStacktrace = (stack, options) => (stack.length > 0 ? "\n" : "") + stack.map((frame) => getMainFrame(frame, options)).join("\n");
+const internalRenderError = (error, options, deep) => {
+  const config = {
+    cwd: cwd(),
+    displayShortPath: false,
+    filterStacktrace: void 0,
+    framesMaxLimit: Number.POSITIVE_INFINITY,
+    hideErrorCauseCodeView: false,
+    hideErrorCodeView: false,
+    hideErrorErrorsCodeView: false,
+    hideErrorTitle: false,
+    hideMessage: false,
+    indentation: 4,
+    linesAbove: 2,
+    linesBelow: 3,
+    prefix: "",
+    showGutter: true,
+    showLineNumbers: true,
+    tabWidth: 4,
+    ...options,
+    color: {
+      fileLine: (value) => value,
+      gutter: (value) => value,
+      hint: (value) => value,
+      marker: (value) => value,
+      message: (value) => value,
+      method: (value) => value,
+      title: (value) => value,
+      ...options.color
+    }
+  };
+  const stack = parseStacktrace(error, {
+    filter: options.filterStacktrace,
+    frameLimit: config.framesMaxLimit
+  });
+  const mainFrame = stack.shift();
+  return [
+    options.hideMessage ? void 0 : getMessage(error, config, deep),
+    getHint(error, config, deep),
+    mainFrame ? getMainFrame(mainFrame, config, deep) : void 0,
+    mainFrame && !config.hideErrorCodeView ? getCode(mainFrame, config, deep) : void 0,
+    error instanceof AggregateError ? getErrors(error, config, deep) : void 0,
+    error.cause === void 0 ? void 0 : getCause(error, config, deep),
+    stack.length > 0 ? getStacktrace(stack, config) : void 0
+  ].filter(Boolean).join("\n").replaceAll("\\", "/");
+};
+const renderError = (error, options = {}) => {
+  if (options.framesMaxLimit !== void 0 && options.framesMaxLimit <= 0) {
+    throw new RangeError("The 'framesMaxLimit' option must be a positive number");
+  }
+  return internalRenderError(error, options, 0);
+};
+
+const getLongestBadge = (types) => {
+  const badges = Object.keys(types).map((x) => types[x].badge ?? "");
+  if (badges.length === 0) {
+    return "";
+  }
+  return badges.reduce((x, y) => x.length > y.length ? x : y);
+};
+
+const defaultInspectorConfig = {
+  indent: 2,
+  quoteStyle: "single",
+  stylize: (string_, style) => {
+    const styles = {
+      bigint: yellow,
+      boolean: yellow,
+      date: magenta,
+      null: bold,
+      number: yellow,
+      regexp: red,
+      special: cyan,
+      string: green,
+      symbol: green,
+      undefined: grey
+    };
+    if (styles[style] === void 0) {
+      return string_;
+    }
+    return styles[style](string_);
+  }
+};
+
+const formatLabel = (label, styles) => {
+  let formattedLabel = styles.uppercase.label ? label.toUpperCase() : label;
+  formattedLabel = styles.underline.label ? underline(formattedLabel) : formattedLabel;
+  if (styles.bold.label) {
+    formattedLabel = bold(formattedLabel);
+  }
+  return formattedLabel;
+};
+
+const dateFormatter = (date) => [date.getHours(), date.getMinutes(), date.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
+class AbstractPrettyReporter {
+  /** Styling options for pretty formatting */
+  styles;
+  /** Logger type configurations for styling */
+  loggerTypes;
+  /**
+   * Creates a new AbstractPrettyReporter instance.
+   * @param options Styling options for pretty formatting
+   * @protected
+   */
+  constructor(options) {
+    this.styles = {
+      bold: {
+        label: false
+      },
+      dateFormatter,
+      underline: {
+        label: false,
+        message: false,
+        prefix: false,
+        suffix: false
+      },
+      uppercase: {
+        label: false
+      },
+      ...options
+    };
+    this.loggerTypes = LOG_TYPES;
+  }
+  /**
+   * Sets the logger types configuration for styling.
+   * @param types Logger type configurations with colors and labels
+   */
+  setLoggerTypes(types) {
+    this.loggerTypes = types;
+  }
+}
+
+export { AbstractPrettyReporter as A, EXTENDED_RFC_5424_LOG_LEVELS as E, LOG_TYPES as L, WrapMode as W, EMPTY_SYMBOL as a, writeStream as b, getLongestBadge as c, defaultInspectorConfig as d, getStringWidth as e, formatLabel as f, getLongestLabel as g, inspect as i, renderError as r, terminalSize as t, wordWrap as w };