@visulima/pail 4.0.0-alpha.10 → 4.0.0-alpha.11

package/dist/packem_shared/{PrettyReporter-gMqa7j_m.js → PrettyReporter-BCvyNzXO.js}

@@ -17,14 +17,19 @@ const __cjs_getBuiltinModule = (module) => {
     return __cjs_require(module);
 };
 
+const process$2 = __cjs_getProcess;
 const {
   stdout,
   stderr
-} = __cjs_getProcess;
+} = process$2;
 import colorize, { grey, green, cyan, red, yellow, bold, magenta, underline, greenBright, bgGrey, white } from '@visulima/colorize';
-import { t as terminalSize, g as getStringWidth, w as wordWrap, W as WrapMode } from './index-BEfVUy9P.js';
+const {
+  execFileSync
+} = __cjs_getBuiltinModule("node:child_process");
+const fs = __cjs_getBuiltinModule("node:fs");
+const tty = __cjs_getBuiltinModule("node:tty");
 import { L as LOG_TYPES, E as EMPTY_SYMBOL } from './constants-B1RjD_ps.js';
-import { w as writeStream } from './write-stream-BuFtjATz.js';
+import { w as writeStream } from './write-stream-MDqyXmc_.js';
 const {
   createRequire
 } = __cjs_getBuiltinModule("node:module");
@@ -1194,6 +1199,1235 @@ const inspect = (value, options_ = {}) => {
   return internalInspect(value, options, 0, []);
 };
 
+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 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 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;
+
+const RE_ANSI_CODE = /\x1B\[(\d+)m/;
+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 = RE_ANSI_CODE.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 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);
+      const { isInsideLinkEscape } = escapeInfo;
+      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;
+        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}${String(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 RE_SPLIT_WHITESPACE = /(?=\s)|(?<=\s)/;
+const RE_WHITESPACE_ONLY = /^\s+$/;
+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) => {
+      const segText = segment.text ?? "";
+      if (segment.isEscapeSequence) {
+        currentLine += segText;
+      } else {
+        const isSpace = segText === " ";
+        if (segment.width === 0) {
+          currentLine += segText;
+          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() + segText);
+            return true;
+          }
+        }
+        currentLine += segText;
+        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(RE_SPLIT_WHITESPACE);
+  const rows = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    const isSpace = RE_WHITESPACE_ONLY.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(RE_SPLIT_WHITESPACE);
+  const rows = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    const isSpace = RE_WHITESPACE_ONLY.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.at(-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.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 getLongestBadge = (types) => {
   const badges = Object.keys(types).map((x) => types[x].badge ?? "");
   if (badges.length === 0) {
@@ -1226,7 +2460,7 @@ const defaultInspectorConfig = {
       symbol: green,
       undefined: grey
     };
-    if (styles[style] === void 0) {
+    if (!Object.hasOwn(styles, style)) {
       return string_;
     }
     return styles[style](string_);
@@ -1390,9 +2624,7 @@ class PrettyReporter extends AbstractPrettyReporter {
       items.push(` ${grey(`[${scope.join(" > ")}]`)} `);
     }
     if (prefix) {
-      items.push(
-        `${grey(`${Array.isArray(scope) && scope.length > 0 ? ". " : " "}[${this.styles.underline.prefix ? underline(prefix) : prefix}]`)} `
-      );
+      items.push(`${grey(`${Array.isArray(scope) && scope.length > 0 ? ". " : " "}[${this.styles.underline.prefix ? underline(prefix) : prefix}]`)} `);
     }
     const titleSize = getStringWidth(items.join(" "));
     if (file) {