@libtmux/workspace-cli 0.1.0-alpha.11

package/dist/progress-n08zapg2.js

@@ -0,0 +1,1649 @@
+import {
+  CliError,
+  colorEnabled,
+  scalarText,
+  styled,
+  write
+} from "./main-gh3pafqb.js";
+import {
+  __commonJS,
+  __toESM
+} from "./main-1de529jm.js";
+
+// ../../node_modules/.bun/ansi-regex@5.0.1/node_modules/ansi-regex/index.js
+var require_ansi_regex = __commonJS(function(exports, module) {
+  module.exports = ({ onlyFirst = false } = {}) => {
+    const pattern = [
+      "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+      "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+    ].join("|");
+    return new RegExp(pattern, onlyFirst ? undefined : "g");
+  };
+});
+
+// ../../node_modules/.bun/ansi-styles@6.2.3/node_modules/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    gray: [90, 39],
+    grey: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    bgGrey: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup-data.js
+var ambiguousMinimalCodePoint = 161;
+var ambiguousMaximumCodePoint = 1114109;
+var 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];
+var fullwidthMinimalCodePoint = 12288;
+var fullwidthMaximumCodePoint = 65510;
+var fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+var wideMinimalCodePoint = 4352;
+var wideMaximumCodePoint = 262141;
+var 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];
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/utilities.js
+var 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;
+};
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup.js
+var commonCjkCodePoint = 19968;
+var [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ 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];
+}
+var isAmbiguous = (codePoint) => {
+  if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+var isFullWidth = (codePoint) => {
+  if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+var isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+// ../../node_modules/.bun/is-fullwidth-code-point@5.1.0/node_modules/is-fullwidth-code-point/index.js
+function isFullwidthCodePoint(codePoint) {
+  if (!Number.isInteger(codePoint)) {
+    return false;
+  }
+  return isFullWidth(codePoint) || isWide(codePoint);
+}
+
+// ../../node_modules/.bun/slice-ansi@9.0.0/node_modules/slice-ansi/tokenize-ansi.js
+var ESCAPE_CODE_POINT = 27;
+var C1_DCS_CODE_POINT = 144;
+var C1_SOS_CODE_POINT = 152;
+var C1_CSI_CODE_POINT = 155;
+var C1_ST_CODE_POINT = 156;
+var C1_OSC_CODE_POINT = 157;
+var C1_PM_CODE_POINT = 158;
+var C1_APC_CODE_POINT = 159;
+var ESCAPES = new Set([
+  ESCAPE_CODE_POINT,
+  C1_DCS_CODE_POINT,
+  C1_SOS_CODE_POINT,
+  C1_CSI_CODE_POINT,
+  C1_ST_CODE_POINT,
+  C1_OSC_CODE_POINT,
+  C1_PM_CODE_POINT,
+  C1_APC_CODE_POINT
+]);
+var ESCAPE = "\x1B";
+var ANSI_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_DCS = "P";
+var ANSI_SOS = "X";
+var ANSI_PM = "^";
+var ANSI_APC = "_";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_OSC_TERMINATOR = "\\";
+var ANSI_STRING_TERMINATOR = `${ESCAPE}${ANSI_OSC_TERMINATOR}`;
+var C1_OSC = "";
+var C1_STRING_TERMINATOR = "œ";
+var ANSI_HYPERLINK_ESC_PREFIX = `${ESCAPE}${ANSI_OSC}8;`;
+var ANSI_HYPERLINK_C1_PREFIX = `${C1_OSC}8;`;
+var ANSI_HYPERLINK_ESC_CLOSE = `${ANSI_HYPERLINK_ESC_PREFIX};`;
+var ANSI_HYPERLINK_C1_CLOSE = `${ANSI_HYPERLINK_C1_PREFIX};`;
+var CODE_POINT_0 = "0".codePointAt(0);
+var CODE_POINT_9 = "9".codePointAt(0);
+var CODE_POINT_SEMICOLON = ";".codePointAt(0);
+var CODE_POINT_COLON = ":".codePointAt(0);
+var CODE_POINT_CSI_PARAMETER_START = "0".codePointAt(0);
+var CODE_POINT_CSI_PARAMETER_END = "?".codePointAt(0);
+var CODE_POINT_CSI_INTERMEDIATE_START = " ".codePointAt(0);
+var CODE_POINT_CSI_INTERMEDIATE_END = "/".codePointAt(0);
+var CODE_POINT_CSI_FINAL_START = "@".codePointAt(0);
+var CODE_POINT_CSI_FINAL_END = "~".codePointAt(0);
+var REGIONAL_INDICATOR_SYMBOL_LETTER_A = 127462;
+var REGIONAL_INDICATOR_SYMBOL_LETTER_Z = 127487;
+var SGR_RESET_CODE = 0;
+var SGR_EXTENDED_FOREGROUND_CODE = 38;
+var SGR_DEFAULT_FOREGROUND_CODE = 39;
+var SGR_EXTENDED_BACKGROUND_CODE = 48;
+var SGR_DEFAULT_BACKGROUND_CODE = 49;
+var SGR_COLOR_TYPE_ANSI_256 = 5;
+var SGR_COLOR_TYPE_TRUECOLOR = 2;
+var SGR_ANSI_256_FRAGMENT_LENGTH = 3;
+var SGR_TRUECOLOR_FRAGMENT_LENGTH = 5;
+var SGR_ANSI_256_LAST_PARAMETER_OFFSET = 2;
+var SGR_TRUECOLOR_LAST_PARAMETER_OFFSET = 4;
+var VARIATION_SELECTOR_16_CODE_POINT = 65039;
+var COMBINING_ENCLOSING_KEYCAP_CODE_POINT = 8419;
+var EMOJI_PRESENTATION_GRAPHEME_REGEX = /\p{Emoji_Presentation}/v;
+var GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+var endCodeNumbers = new Set;
+for (const [, end] of ansi_styles_default.codes) {
+  endCodeNumbers.add(end);
+}
+function isSgrParameterCharacter(codePoint) {
+  return codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9 || codePoint === CODE_POINT_SEMICOLON || codePoint === CODE_POINT_COLON;
+}
+function isCsiParameterCharacter(codePoint) {
+  return codePoint >= CODE_POINT_CSI_PARAMETER_START && codePoint <= CODE_POINT_CSI_PARAMETER_END;
+}
+function isCsiIntermediateCharacter(codePoint) {
+  return codePoint >= CODE_POINT_CSI_INTERMEDIATE_START && codePoint <= CODE_POINT_CSI_INTERMEDIATE_END;
+}
+function isCsiFinalCharacter(codePoint) {
+  return codePoint >= CODE_POINT_CSI_FINAL_START && codePoint <= CODE_POINT_CSI_FINAL_END;
+}
+function isRegionalIndicatorCodePoint(codePoint) {
+  return codePoint >= REGIONAL_INDICATOR_SYMBOL_LETTER_A && codePoint <= REGIONAL_INDICATOR_SYMBOL_LETTER_Z;
+}
+function createControlParseResult(code, endIndex) {
+  return {
+    token: {
+      type: "control",
+      code
+    },
+    endIndex
+  };
+}
+function isEmojiStyleGrapheme(grapheme) {
+  if (EMOJI_PRESENTATION_GRAPHEME_REGEX.test(grapheme)) {
+    return true;
+  }
+  for (const character of grapheme) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === VARIATION_SELECTOR_16_CODE_POINT || codePoint === COMBINING_ENCLOSING_KEYCAP_CODE_POINT) {
+      return true;
+    }
+  }
+  return false;
+}
+function getGraphemeWidth(grapheme) {
+  let regionalIndicatorCount = 0;
+  for (const character of grapheme) {
+    const codePoint = character.codePointAt(0);
+    if (isFullwidthCodePoint(codePoint)) {
+      return 2;
+    }
+    if (isRegionalIndicatorCodePoint(codePoint)) {
+      regionalIndicatorCount++;
+    }
+  }
+  if (regionalIndicatorCount >= 1) {
+    return 2;
+  }
+  if (isEmojiStyleGrapheme(grapheme)) {
+    return 2;
+  }
+  return 1;
+}
+function getSgrPrefix(code) {
+  if (code.startsWith("›")) {
+    return "›";
+  }
+  return `${ESCAPE}${ANSI_CSI}`;
+}
+function createSgrCode(prefix, values) {
+  return `${prefix}${values.join(";")}${ANSI_SGR_TERMINATOR}`;
+}
+function getSgrFragments(code) {
+  const fragments = [];
+  const sgrPrefix = getSgrPrefix(code);
+  let parameterString;
+  if (code.startsWith(`${ESCAPE}${ANSI_CSI}`)) {
+    parameterString = code.slice(2, -1);
+  } else if (code.startsWith("›")) {
+    parameterString = code.slice(1, -1);
+  } else {
+    return fragments;
+  }
+  const rawCodes = parameterString.length === 0 ? [String(SGR_RESET_CODE)] : parameterString.split(";");
+  let index = 0;
+  while (index < rawCodes.length) {
+    const codeNumber = Number.parseInt(rawCodes[index], 10);
+    if (Number.isNaN(codeNumber)) {
+      index++;
+      continue;
+    }
+    if (codeNumber === SGR_RESET_CODE) {
+      fragments.push({ type: "reset" });
+      index++;
+      continue;
+    }
+    if (codeNumber === SGR_EXTENDED_FOREGROUND_CODE || codeNumber === SGR_EXTENDED_BACKGROUND_CODE) {
+      const colorType = Number.parseInt(rawCodes[index + 1], 10);
+      if (colorType === SGR_COLOR_TYPE_ANSI_256 && index + SGR_ANSI_256_LAST_PARAMETER_OFFSET < rawCodes.length) {
+        const openCode3 = createSgrCode(sgrPrefix, rawCodes.slice(index, index + SGR_ANSI_256_FRAGMENT_LENGTH));
+        fragments.push({
+          type: "start",
+          code: openCode3,
+          endCode: ansi_styles_default.color.ansi(codeNumber === SGR_EXTENDED_FOREGROUND_CODE ? SGR_DEFAULT_FOREGROUND_CODE : SGR_DEFAULT_BACKGROUND_CODE)
+        });
+        index += SGR_ANSI_256_FRAGMENT_LENGTH;
+        continue;
+      }
+      if (colorType === SGR_COLOR_TYPE_TRUECOLOR && index + SGR_TRUECOLOR_LAST_PARAMETER_OFFSET < rawCodes.length) {
+        const openCode3 = createSgrCode(sgrPrefix, rawCodes.slice(index, index + SGR_TRUECOLOR_FRAGMENT_LENGTH));
+        fragments.push({
+          type: "start",
+          code: openCode3,
+          endCode: ansi_styles_default.color.ansi(codeNumber === SGR_EXTENDED_FOREGROUND_CODE ? SGR_DEFAULT_FOREGROUND_CODE : SGR_DEFAULT_BACKGROUND_CODE)
+        });
+        index += SGR_TRUECOLOR_FRAGMENT_LENGTH;
+        continue;
+      }
+      const openCode2 = createSgrCode(sgrPrefix, [rawCodes[index]]);
+      fragments.push({
+        type: "start",
+        code: openCode2,
+        endCode: ansi_styles_default.color.ansi(codeNumber === SGR_EXTENDED_FOREGROUND_CODE ? SGR_DEFAULT_FOREGROUND_CODE : SGR_DEFAULT_BACKGROUND_CODE)
+      });
+      index++;
+      continue;
+    }
+    if (endCodeNumbers.has(codeNumber)) {
+      fragments.push({
+        type: "end",
+        endCode: ansi_styles_default.color.ansi(codeNumber)
+      });
+      index++;
+      continue;
+    }
+    const mappedEndCode = ansi_styles_default.codes.get(codeNumber);
+    if (mappedEndCode !== undefined) {
+      const openCode2 = createSgrCode(sgrPrefix, [rawCodes[index]]);
+      fragments.push({
+        type: "start",
+        code: openCode2,
+        endCode: ansi_styles_default.color.ansi(mappedEndCode)
+      });
+      index++;
+      continue;
+    }
+    const openCode = createSgrCode(sgrPrefix, [rawCodes[index]]);
+    fragments.push({
+      type: "start",
+      code: openCode,
+      endCode: ansi_styles_default.reset.open
+    });
+    index++;
+  }
+  if (fragments.length === 0) {
+    fragments.push({ type: "reset" });
+  }
+  return fragments;
+}
+function parseCsiCode(string, index) {
+  const escapeCodePoint = string.codePointAt(index);
+  let sequenceStartIndex;
+  if (escapeCodePoint === ESCAPE_CODE_POINT) {
+    if (string[index + 1] !== ANSI_CSI) {
+      return;
+    }
+    sequenceStartIndex = index + 2;
+  } else if (escapeCodePoint === C1_CSI_CODE_POINT) {
+    sequenceStartIndex = index + 1;
+  } else {
+    return;
+  }
+  let hasCanonicalSgrParameters = true;
+  for (let sequenceIndex = sequenceStartIndex;sequenceIndex < string.length; sequenceIndex++) {
+    const codePoint = string.codePointAt(sequenceIndex);
+    if (isCsiFinalCharacter(codePoint)) {
+      const code = string.slice(index, sequenceIndex + 1);
+      if (string[sequenceIndex] !== ANSI_SGR_TERMINATOR || !hasCanonicalSgrParameters) {
+        return createControlParseResult(code, sequenceIndex + 1);
+      }
+      return {
+        token: {
+          type: "sgr",
+          code,
+          fragments: getSgrFragments(code)
+        },
+        endIndex: sequenceIndex + 1
+      };
+    }
+    if (isCsiParameterCharacter(codePoint)) {
+      if (!isSgrParameterCharacter(codePoint)) {
+        hasCanonicalSgrParameters = false;
+      }
+      continue;
+    }
+    if (isCsiIntermediateCharacter(codePoint)) {
+      hasCanonicalSgrParameters = false;
+      continue;
+    }
+    const endIndex = sequenceIndex;
+    return createControlParseResult(string.slice(index, endIndex), endIndex);
+  }
+  return createControlParseResult(string.slice(index), string.length);
+}
+function parseHyperlinkCode(string, index) {
+  let hyperlinkPrefix;
+  let hyperlinkClose;
+  const codePoint = string.codePointAt(index);
+  if (codePoint === ESCAPE_CODE_POINT && string.startsWith(ANSI_HYPERLINK_ESC_PREFIX, index)) {
+    hyperlinkPrefix = ANSI_HYPERLINK_ESC_PREFIX;
+    hyperlinkClose = ANSI_HYPERLINK_ESC_CLOSE;
+  } else if (codePoint === C1_OSC_CODE_POINT && string.startsWith(ANSI_HYPERLINK_C1_PREFIX, index)) {
+    hyperlinkPrefix = ANSI_HYPERLINK_C1_PREFIX;
+    hyperlinkClose = ANSI_HYPERLINK_C1_CLOSE;
+  } else {
+    return;
+  }
+  const uriStart = string.indexOf(";", index + hyperlinkPrefix.length);
+  if (uriStart === -1) {
+    return createControlParseResult(string.slice(index), string.length);
+  }
+  for (let sequenceIndex = uriStart + 1;sequenceIndex < string.length; sequenceIndex++) {
+    const character = string[sequenceIndex];
+    if (character === ANSI_BELL) {
+      const code = string.slice(index, sequenceIndex + 1);
+      const action = sequenceIndex === uriStart + 1 ? "close" : "open";
+      return {
+        token: {
+          type: "hyperlink",
+          code,
+          action,
+          closePrefix: hyperlinkClose,
+          terminator: ANSI_BELL
+        },
+        endIndex: sequenceIndex + 1
+      };
+    }
+    if (character === ESCAPE && string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR) {
+      const code = string.slice(index, sequenceIndex + 2);
+      const action = sequenceIndex === uriStart + 1 ? "close" : "open";
+      return {
+        token: {
+          type: "hyperlink",
+          code,
+          action,
+          closePrefix: hyperlinkClose,
+          terminator: ANSI_STRING_TERMINATOR
+        },
+        endIndex: sequenceIndex + 2
+      };
+    }
+    if (character === C1_STRING_TERMINATOR) {
+      const code = string.slice(index, sequenceIndex + 1);
+      const action = sequenceIndex === uriStart + 1 ? "close" : "open";
+      return {
+        token: {
+          type: "hyperlink",
+          code,
+          action,
+          closePrefix: hyperlinkClose,
+          terminator: C1_STRING_TERMINATOR
+        },
+        endIndex: sequenceIndex + 1
+      };
+    }
+  }
+  return createControlParseResult(string.slice(index), string.length);
+}
+function parseControlStringCode(string, index) {
+  const codePoint = string.codePointAt(index);
+  let sequenceStartIndex;
+  let supportsBellTerminator = false;
+  switch (codePoint) {
+    case ESCAPE_CODE_POINT: {
+      const command = string[index + 1];
+      switch (command) {
+        case ANSI_OSC: {
+          sequenceStartIndex = index + 2;
+          supportsBellTerminator = true;
+          break;
+        }
+        case ANSI_DCS:
+        case ANSI_SOS:
+        case ANSI_PM:
+        case ANSI_APC: {
+          sequenceStartIndex = index + 2;
+          break;
+        }
+        case ANSI_OSC_TERMINATOR: {
+          return createControlParseResult(ANSI_STRING_TERMINATOR, index + 2);
+        }
+        default: {
+          return;
+        }
+      }
+      break;
+    }
+    case C1_OSC_CODE_POINT: {
+      sequenceStartIndex = index + 1;
+      supportsBellTerminator = true;
+      break;
+    }
+    case C1_DCS_CODE_POINT:
+    case C1_SOS_CODE_POINT:
+    case C1_PM_CODE_POINT:
+    case C1_APC_CODE_POINT: {
+      sequenceStartIndex = index + 1;
+      break;
+    }
+    case C1_ST_CODE_POINT: {
+      return createControlParseResult(C1_STRING_TERMINATOR, index + 1);
+    }
+    default: {
+      return;
+    }
+  }
+  for (let sequenceIndex = sequenceStartIndex;sequenceIndex < string.length; sequenceIndex++) {
+    if (supportsBellTerminator && string[sequenceIndex] === ANSI_BELL) {
+      return createControlParseResult(string.slice(index, sequenceIndex + 1), sequenceIndex + 1);
+    }
+    if (string[sequenceIndex] === ESCAPE && string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR) {
+      return createControlParseResult(string.slice(index, sequenceIndex + 2), sequenceIndex + 2);
+    }
+    if (string[sequenceIndex] === C1_STRING_TERMINATOR) {
+      return createControlParseResult(string.slice(index, sequenceIndex + 1), sequenceIndex + 1);
+    }
+  }
+  return createControlParseResult(string.slice(index), string.length);
+}
+function parseAnsiCode(string, index) {
+  const codePoint = string.codePointAt(index);
+  if (codePoint === ESCAPE_CODE_POINT || codePoint === C1_OSC_CODE_POINT) {
+    const hyperlinkCode = parseHyperlinkCode(string, index);
+    if (hyperlinkCode) {
+      return hyperlinkCode;
+    }
+  }
+  const controlStringCode = parseControlStringCode(string, index);
+  if (controlStringCode) {
+    return controlStringCode;
+  }
+  return parseCsiCode(string, index);
+}
+function appendTrailingAnsiTokens(string, index, tokens) {
+  while (index < string.length) {
+    const nextCodePoint = string.codePointAt(index);
+    if (!ESCAPES.has(nextCodePoint)) {
+      break;
+    }
+    const escapeCode = parseAnsiCode(string, index);
+    if (!escapeCode) {
+      break;
+    }
+    tokens.push(escapeCode.token);
+    index = escapeCode.endIndex;
+  }
+  return index;
+}
+function parseCharacterTokenWithRawSegmentation(string, index, graphemeSegments) {
+  const segment = graphemeSegments.containing(index);
+  if (!segment || segment.index !== index) {
+    return;
+  }
+  return {
+    token: {
+      type: "character",
+      value: segment.segment,
+      visibleWidth: getGraphemeWidth(segment.segment),
+      isGraphemeContinuation: false
+    },
+    endIndex: index + segment.segment.length
+  };
+}
+function collectVisibleCharacters(string) {
+  const visibleCharacters = [];
+  let index = 0;
+  while (index < string.length) {
+    const codePoint = string.codePointAt(index);
+    if (ESCAPES.has(codePoint)) {
+      const code = parseAnsiCode(string, index);
+      if (code) {
+        index = code.endIndex;
+        continue;
+      }
+    }
+    const value = String.fromCodePoint(codePoint);
+    visibleCharacters.push({
+      value,
+      visibleWidth: 1,
+      isGraphemeContinuation: false
+    });
+    index += value.length;
+  }
+  return visibleCharacters;
+}
+function applyGraphemeMetadata(visibleCharacters) {
+  if (visibleCharacters.length === 0) {
+    return;
+  }
+  const visibleString = visibleCharacters.map(({ value }) => value).join("");
+  const scalarOffsets = [];
+  let scalarOffset = 0;
+  for (const visibleCharacter of visibleCharacters) {
+    scalarOffsets.push(scalarOffset);
+    scalarOffset += visibleCharacter.value.length;
+  }
+  let scalarIndex = 0;
+  for (const segment of GRAPHEME_SEGMENTER.segment(visibleString)) {
+    while (scalarIndex < visibleCharacters.length && scalarOffsets[scalarIndex] < segment.index) {
+      scalarIndex++;
+    }
+    let graphemeIndex = scalarIndex;
+    let isFirstInGrapheme = true;
+    while (graphemeIndex < visibleCharacters.length && scalarOffsets[graphemeIndex] < segment.index + segment.segment.length) {
+      visibleCharacters[graphemeIndex].visibleWidth = isFirstInGrapheme ? getGraphemeWidth(segment.segment) : 0;
+      visibleCharacters[graphemeIndex].isGraphemeContinuation = !isFirstInGrapheme;
+      isFirstInGrapheme = false;
+      graphemeIndex++;
+    }
+    scalarIndex = graphemeIndex;
+  }
+}
+function tokenizeAnsiWithVisibleSegmentation(string, { endCharacter = Number.POSITIVE_INFINITY } = {}) {
+  const tokens = [];
+  const visibleCharacters = collectVisibleCharacters(string);
+  applyGraphemeMetadata(visibleCharacters);
+  let index = 0;
+  let visibleCharacterIndex = 0;
+  let visibleCount = 0;
+  while (index < string.length) {
+    const codePoint = string.codePointAt(index);
+    if (ESCAPES.has(codePoint)) {
+      const code = parseAnsiCode(string, index);
+      if (code) {
+        tokens.push(code.token);
+        index = code.endIndex;
+        continue;
+      }
+    }
+    const value = String.fromCodePoint(codePoint);
+    const visibleCharacter = visibleCharacters[visibleCharacterIndex];
+    let visibleWidth = isFullwidthCodePoint(codePoint) ? 2 : value.length;
+    if (visibleCharacter) {
+      visibleWidth = visibleCharacter.visibleWidth;
+    }
+    const token = {
+      type: "character",
+      value,
+      visibleWidth,
+      isGraphemeContinuation: visibleCharacter ? visibleCharacter.isGraphemeContinuation : false
+    };
+    tokens.push(token);
+    index += value.length;
+    visibleCharacterIndex++;
+    visibleCount += token.visibleWidth;
+    if (visibleCount >= endCharacter) {
+      const nextVisibleCharacter = visibleCharacters[visibleCharacterIndex];
+      if (!nextVisibleCharacter || !nextVisibleCharacter.isGraphemeContinuation) {
+        index = appendTrailingAnsiTokens(string, index, tokens);
+        break;
+      }
+    }
+  }
+  return tokens;
+}
+function areValuesInSameGrapheme(leftValue, rightValue) {
+  const pair = `${leftValue}${rightValue}`;
+  const splitIndex = leftValue.length;
+  for (const segment of GRAPHEME_SEGMENTER.segment(pair)) {
+    if (segment.index === splitIndex) {
+      return false;
+    }
+    if (segment.index > splitIndex) {
+      return true;
+    }
+  }
+  return true;
+}
+function hasAnsiSplitContinuationAhead(string, startIndex, previousVisibleValue, graphemeSegments) {
+  if (!previousVisibleValue) {
+    return false;
+  }
+  let index = startIndex;
+  let hasAnsiCode = false;
+  while (index < string.length) {
+    const codePoint = string.codePointAt(index);
+    if (ESCAPES.has(codePoint)) {
+      const code = parseAnsiCode(string, index);
+      if (code) {
+        hasAnsiCode = true;
+        index = code.endIndex;
+        continue;
+      }
+    }
+    if (!hasAnsiCode) {
+      return false;
+    }
+    const characterToken = parseCharacterTokenWithRawSegmentation(string, index, graphemeSegments);
+    if (!characterToken) {
+      return true;
+    }
+    return areValuesInSameGrapheme(previousVisibleValue, characterToken.token.value);
+  }
+  return false;
+}
+function tokenizeAnsi(string, { endCharacter = Number.POSITIVE_INFINITY } = {}) {
+  const tokens = [];
+  const graphemeSegments = GRAPHEME_SEGMENTER.segment(string);
+  let index = 0;
+  let visibleCount = 0;
+  let previousVisibleValue;
+  let hasAnsiSinceLastVisible = false;
+  while (index < string.length) {
+    const codePoint = string.codePointAt(index);
+    if (ESCAPES.has(codePoint)) {
+      const code = parseAnsiCode(string, index);
+      if (code) {
+        tokens.push(code.token);
+        index = code.endIndex;
+        hasAnsiSinceLastVisible = true;
+        continue;
+      }
+    }
+    const characterToken = parseCharacterTokenWithRawSegmentation(string, index, graphemeSegments);
+    if (!characterToken) {
+      return tokenizeAnsiWithVisibleSegmentation(string, { endCharacter });
+    }
+    if (hasAnsiSinceLastVisible && previousVisibleValue && areValuesInSameGrapheme(previousVisibleValue, characterToken.token.value)) {
+      return tokenizeAnsiWithVisibleSegmentation(string, { endCharacter });
+    }
+    tokens.push(characterToken.token);
+    index = characterToken.endIndex;
+    visibleCount += characterToken.token.visibleWidth;
+    hasAnsiSinceLastVisible = false;
+    previousVisibleValue = characterToken.token.value;
+    if (visibleCount >= endCharacter) {
+      if (hasAnsiSplitContinuationAhead(string, index, previousVisibleValue, graphemeSegments)) {
+        return tokenizeAnsiWithVisibleSegmentation(string, { endCharacter });
+      }
+      index = appendTrailingAnsiTokens(string, index, tokens);
+      break;
+    }
+  }
+  return tokens;
+}
+
+// ../../node_modules/.bun/slice-ansi@9.0.0/node_modules/slice-ansi/index.js
+function applySgrFragments(activeStyles, fragments) {
+  for (const fragment of fragments) {
+    switch (fragment.type) {
+      case "reset": {
+        activeStyles.clear();
+        break;
+      }
+      case "end": {
+        activeStyles.delete(fragment.endCode);
+        break;
+      }
+      case "start": {
+        activeStyles.delete(fragment.endCode);
+        activeStyles.set(fragment.endCode, fragment.code);
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  return activeStyles;
+}
+function undoAnsiCodes(activeStyles) {
+  return [...activeStyles.keys()].toReversed().join("");
+}
+function closeHyperlink(hyperlinkToken) {
+  return `${hyperlinkToken.closePrefix}${hyperlinkToken.terminator}`;
+}
+function shouldIncludeSgrAfterEnd(token, activeStyles) {
+  let hasStartFragment = false;
+  let hasClosingEffect = false;
+  for (const fragment of token.fragments) {
+    if (fragment.type === "start") {
+      hasStartFragment = true;
+      continue;
+    }
+    if (fragment.type === "reset" && activeStyles.size > 0) {
+      hasClosingEffect = true;
+      continue;
+    }
+    if (fragment.type === "end" && activeStyles.has(fragment.endCode)) {
+      hasClosingEffect = true;
+    }
+  }
+  return hasClosingEffect && !hasStartFragment;
+}
+function hasSgrStartFragment(token) {
+  return token.fragments.some((fragment) => fragment.type === "start");
+}
+function discardPendingHyperlink(parameters) {
+  if (parameters.activeHyperlink && !parameters.activeHyperlinkHasVisibleText && parameters.activeHyperlinkOutputIndex !== undefined) {
+    const openCodeLength = parameters.activeHyperlink.code.length;
+    parameters.returnValue = parameters.returnValue.slice(0, parameters.activeHyperlinkOutputIndex) + parameters.returnValue.slice(parameters.activeHyperlinkOutputIndex + openCodeLength);
+    if (parameters.pendingSgrOutputIndex !== undefined && parameters.pendingSgrOutputIndex > parameters.activeHyperlinkOutputIndex) {
+      parameters.pendingSgrOutputIndex -= openCodeLength;
+    }
+  }
+  parameters.activeHyperlink = undefined;
+  parameters.activeHyperlinkHasVisibleText = false;
+  parameters.activeHyperlinkOutputIndex = undefined;
+}
+function applySgrToken(parameters) {
+  if (parameters.isPastEnd && !shouldIncludeSgrAfterEnd(parameters.token, parameters.activeStyles)) {
+    return parameters;
+  }
+  if (parameters.include && hasSgrStartFragment(parameters.token) && parameters.pendingSgrOutputIndex === undefined) {
+    parameters.pendingSgrOutputIndex = parameters.returnValue.length;
+    parameters.pendingSgrActiveStyles = new Map(parameters.activeStyles);
+  }
+  parameters.activeStyles = applySgrFragments(parameters.activeStyles, parameters.token.fragments);
+  if (parameters.include) {
+    parameters.returnValue += parameters.token.code;
+  }
+  return parameters;
+}
+function applyHyperlinkToken(parameters) {
+  if (parameters.isPastEnd && (parameters.token.action !== "close" || !parameters.activeHyperlink)) {
+    return parameters;
+  }
+  if (parameters.token.action === "open") {
+    parameters.activeHyperlink = parameters.token;
+    parameters.activeHyperlinkHasVisibleText = false;
+    parameters.activeHyperlinkOutputIndex = undefined;
+    if (parameters.include) {
+      parameters.activeHyperlinkOutputIndex = parameters.returnValue.length;
+    }
+  } else if (parameters.token.action === "close") {
+    if (parameters.include && parameters.activeHyperlink && !parameters.activeHyperlinkHasVisibleText) {
+      discardPendingHyperlink(parameters);
+      return parameters;
+    }
+    parameters.activeHyperlink = undefined;
+    parameters.activeHyperlinkHasVisibleText = false;
+    parameters.activeHyperlinkOutputIndex = undefined;
+  }
+  if (parameters.include) {
+    parameters.returnValue += parameters.token.code;
+  }
+  return parameters;
+}
+function applyControlToken(parameters) {
+  if (!parameters.isPastEnd && parameters.include) {
+    parameters.returnValue += parameters.token.code;
+  }
+  return parameters;
+}
+function applyCharacterToken(parameters) {
+  if (!parameters.include && parameters.position >= parameters.start && !parameters.token.isGraphemeContinuation) {
+    parameters.include = true;
+    parameters.returnValue = [...parameters.activeStyles.values()].join("");
+    if (parameters.activeHyperlink) {
+      parameters.activeHyperlinkOutputIndex = parameters.returnValue.length;
+      parameters.returnValue += parameters.activeHyperlink.code;
+    }
+  }
+  if (parameters.include) {
+    parameters.returnValue += parameters.token.value;
+    parameters.pendingSgrOutputIndex = undefined;
+    parameters.pendingSgrActiveStyles = undefined;
+    if (parameters.activeHyperlink) {
+      parameters.activeHyperlinkHasVisibleText = true;
+    }
+  }
+  parameters.position += parameters.token.visibleWidth;
+  return parameters;
+}
+var tokenHandlers = {
+  sgr: applySgrToken,
+  hyperlink: applyHyperlinkToken,
+  control: applyControlToken,
+  character: applyCharacterToken
+};
+function applyToken(parameters) {
+  const tokenHandler = tokenHandlers[parameters.token.type];
+  if (!tokenHandler) {
+    return parameters;
+  }
+  return tokenHandler(parameters);
+}
+function createHasContinuationAheadMap(tokens) {
+  const hasContinuationAhead = Array.from({ length: tokens.length }, () => false);
+  let nextCharacterIsContinuation = false;
+  for (let tokenIndex = tokens.length - 1;tokenIndex >= 0; tokenIndex--) {
+    const token = tokens[tokenIndex];
+    hasContinuationAhead[tokenIndex] = nextCharacterIsContinuation;
+    if (token.type === "character") {
+      nextCharacterIsContinuation = Boolean(token.isGraphemeContinuation);
+    }
+  }
+  return hasContinuationAhead;
+}
+function isPastEndBoundary(token, position, end) {
+  if (end === undefined) {
+    return false;
+  }
+  if (position >= end) {
+    return true;
+  }
+  return token.type === "character" && !token.isGraphemeContinuation && position + token.visibleWidth > end;
+}
+function sliceAnsi(string, start, end) {
+  const tokens = tokenizeAnsi(string, { endCharacter: end });
+  const hasContinuationAhead = createHasContinuationAheadMap(tokens);
+  let activeStyles = new Map;
+  let activeHyperlink;
+  let activeHyperlinkHasVisibleText = false;
+  let activeHyperlinkOutputIndex;
+  let pendingSgrOutputIndex;
+  let pendingSgrActiveStyles;
+  let position = 0;
+  let returnValue = "";
+  let include = false;
+  for (const [tokenIndex, token] of tokens.entries()) {
+    let isPastEnd = isPastEndBoundary(token, position, end);
+    if (isPastEnd && token.type !== "character" && hasContinuationAhead[tokenIndex]) {
+      isPastEnd = false;
+    }
+    if (isPastEnd && token.type === "character" && !token.isGraphemeContinuation) {
+      if (activeHyperlink && !activeHyperlinkHasVisibleText) {
+        const hyperlinkState = {
+          activeHyperlink,
+          activeHyperlinkHasVisibleText,
+          activeHyperlinkOutputIndex,
+          pendingSgrOutputIndex,
+          returnValue
+        };
+        discardPendingHyperlink(hyperlinkState);
+        ({
+          activeHyperlink,
+          activeHyperlinkHasVisibleText,
+          activeHyperlinkOutputIndex,
+          pendingSgrOutputIndex,
+          returnValue
+        } = hyperlinkState);
+      }
+      if (pendingSgrOutputIndex !== undefined) {
+        returnValue = returnValue.slice(0, pendingSgrOutputIndex);
+        activeStyles = pendingSgrActiveStyles;
+        pendingSgrOutputIndex = undefined;
+        pendingSgrActiveStyles = undefined;
+      }
+      break;
+    }
+    ({ activeStyles, activeHyperlink, activeHyperlinkHasVisibleText, activeHyperlinkOutputIndex, pendingSgrOutputIndex, pendingSgrActiveStyles, position, returnValue, include } = applyToken({
+      token,
+      isPastEnd,
+      start,
+      activeStyles,
+      activeHyperlink,
+      activeHyperlinkHasVisibleText,
+      activeHyperlinkOutputIndex,
+      pendingSgrOutputIndex,
+      pendingSgrActiveStyles,
+      position,
+      returnValue,
+      include
+    }));
+  }
+  if (!include) {
+    return "";
+  }
+  if (activeHyperlink) {
+    returnValue += closeHyperlink(activeHyperlink);
+  }
+  returnValue += undoAnsiCodes(activeStyles);
+  return returnValue;
+}
+
+// ../../node_modules/.bun/strip-ansi@7.2.0/node_modules/strip-ansi/index.js
+var import_ansi_regex = __toESM(require_ansi_regex(), 1);
+var regex = import_ansi_regex.default();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("›")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// ../../node_modules/.bun/string-width@8.2.2/node_modules/string-width/index.js
+var segmenter = new Intl.Segmenter;
+var zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Nonspacing_Mark}|\p{Enclosing_Mark}|\p{Surrogate})+$/v;
+var leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Nonspacing_Mark}\p{Enclosing_Mark}\p{Surrogate}]+/v;
+var spacingMarkRegex = /\p{Spacing_Mark}/v;
+var rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+var extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("‍")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+function baseVisible(segment) {
+  return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+  return zeroWidthClusterRegex.test(segment);
+}
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (zeroWidthClusterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return;
+  }
+  let width = 0;
+  for (let index = 0;index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return;
+      }
+      for (let remaining = index;remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (spacingMarkRegex.test(character) || character >= "＀" && character <= "￯") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+function stringWidth(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("›"))) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  if (/^[\u0020-\u007E]*$/.test(string)) {
+    return string.length;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    if (isZeroWidthCluster(segment)) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+      width += 2;
+      continue;
+    }
+    const visibleSegment = baseVisible(segment);
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== undefined) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+
+// ../../node_modules/.bun/cli-truncate@6.1.1/node_modules/cli-truncate/index.js
+var validPositions = new Set(["start", "middle", "end"]);
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
+  if (string.charAt(wantedIndex) === " ") {
+    return wantedIndex;
+  }
+  const direction = shouldSearchRight ? 1 : -1;
+  for (let index = 0;index <= 3; index++) {
+    const finalIndex = wantedIndex + index * direction;
+    if (string.charAt(finalIndex) === " ") {
+      return finalIndex;
+    }
+  }
+  return wantedIndex;
+}
+function validateInput(text, columns, position, truncationCharacter) {
+  if (typeof text !== "string") {
+    throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
+  }
+  if (typeof columns !== "number") {
+    throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
+  }
+  if (!Number.isFinite(columns)) {
+    throw new TypeError(`Expected \`columns\` to be a finite number, got ${columns}`);
+  }
+  if (!validPositions.has(position)) {
+    throw new TypeError(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+  }
+  if (typeof truncationCharacter !== "string") {
+    throw new TypeError(`Expected \`options.truncationCharacter\` to be a string, got ${typeof truncationCharacter}`);
+  }
+}
+function cliTruncate(text, columns, options = {}) {
+  const {
+    position = "end",
+    space = false,
+    preferTruncationOnSpace = false
+  } = options;
+  let { truncationCharacter = "…" } = options;
+  validateInput(text, columns, position, truncationCharacter);
+  if (columns < 1) {
+    return "";
+  }
+  const length = stringWidth(text);
+  if (length <= columns) {
+    return text;
+  }
+  if (columns === 1) {
+    return truncationCharacter;
+  }
+  const ANSI = {
+    ESC: 27,
+    LEFT_BRACKET: 91,
+    LETTER_M: 109
+  };
+  const isSgrParameter = (code) => code >= 48 && code <= 57 || code === 59;
+  function leadingSgrSpanEndIndex(string) {
+    let index = 0;
+    while (index + 2 < string.length && string.codePointAt(index) === ANSI.ESC && string.codePointAt(index + 1) === ANSI.LEFT_BRACKET) {
+      let j = index + 2;
+      while (j < string.length && isSgrParameter(string.codePointAt(j))) {
+        j++;
+      }
+      if (j < string.length && string.codePointAt(j) === ANSI.LETTER_M) {
+        index = j + 1;
+        continue;
+      }
+      break;
+    }
+    return index;
+  }
+  function trailingSgrSpanStartIndex(string) {
+    let start = string.length;
+    while (start > 1 && string.codePointAt(start - 1) === ANSI.LETTER_M) {
+      let j = start - 2;
+      while (j >= 0 && isSgrParameter(string.codePointAt(j))) {
+        j--;
+      }
+      if (j >= 1 && string.codePointAt(j - 1) === ANSI.ESC && string.codePointAt(j) === ANSI.LEFT_BRACKET) {
+        start = j - 1;
+        continue;
+      }
+      break;
+    }
+    return start;
+  }
+  function appendWithInheritedStyleFromEnd(visible, suffix) {
+    const start = trailingSgrSpanStartIndex(visible);
+    if (start === visible.length) {
+      return visible + suffix;
+    }
+    return visible.slice(0, start) + suffix + visible.slice(start);
+  }
+  function prependWithInheritedStyleFromStart(prefix, visible) {
+    const end = leadingSgrSpanEndIndex(visible);
+    if (end === 0) {
+      return prefix + visible;
+    }
+    return visible.slice(0, end) + prefix + visible.slice(end);
+  }
+  if (position === "start") {
+    if (preferTruncationOnSpace) {
+      const nearestSpace = getIndexOfNearestSpace(text, length - columns + stringWidth(truncationCharacter), true);
+      const right2 = sliceAnsi(text, nearestSpace, length).trim();
+      return prependWithInheritedStyleFromStart(truncationCharacter, right2);
+    }
+    if (space) {
+      truncationCharacter += " ";
+    }
+    const right = sliceAnsi(text, length - columns + stringWidth(truncationCharacter), length);
+    return prependWithInheritedStyleFromStart(truncationCharacter, right);
+  }
+  if (position === "middle") {
+    if (space) {
+      truncationCharacter = ` ${truncationCharacter} `;
+      if (stringWidth(truncationCharacter) >= columns) {
+        truncationCharacter = truncationCharacter.trim();
+      }
+    }
+    const truncationWidth = stringWidth(truncationCharacter);
+    const half = Math.min(Math.floor(columns / 2), Math.max(0, columns - truncationWidth));
+    if (preferTruncationOnSpace) {
+      const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+      const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + truncationWidth, true);
+      return sliceAnsi(text, 0, spaceNearFirstBreakPoint) + truncationCharacter + sliceAnsi(text, spaceNearSecondBreakPoint, length).trim();
+    }
+    return sliceAnsi(text, 0, half) + truncationCharacter + sliceAnsi(text, length - (columns - half) + truncationWidth, length);
+  }
+  if (position === "end") {
+    if (preferTruncationOnSpace) {
+      const nearestSpace = getIndexOfNearestSpace(text, columns - stringWidth(truncationCharacter));
+      const left2 = sliceAnsi(text, 0, nearestSpace);
+      return appendWithInheritedStyleFromEnd(left2, truncationCharacter);
+    }
+    if (space) {
+      truncationCharacter = ` ${truncationCharacter}`;
+    }
+    const left = sliceAnsi(text, 0, columns - stringWidth(truncationCharacter));
+    return appendWithInheritedStyleFromEnd(left, truncationCharacter);
+  }
+}
+
+// src/progress.ts
+var presets = {
+  default: "Loading workspace: {session} {bar} {progress} {window}",
+  minimal: "Loading workspace: {session} [{window_progress}]",
+  window: "Loading workspace: {session} {window_bar} {window_progress_rel}",
+  pane: "Loading workspace: {session} {pane_bar} {session_pane_progress}",
+  verbose: "Loading workspace: {session} [window {window_index} of {window_total} · pane {pane_index} of {pane_total}] {window}"
+};
+var retainedCharacters = 65536;
+
+class LoadProgress {
+  painted = [];
+  lastDraw = -Infinity;
+  active = false;
+  countsKnown = true;
+  windowIndex = 0;
+  windowTotal = 0;
+  windowsDone = 0;
+  paneIndex = 0;
+  paneTotal = 0;
+  panesDone = 0;
+  sessionPaneTotal = 0;
+  sessionPanesDone = 0;
+  session = "";
+  window = "";
+  workspace = "";
+  history = [];
+  pending = {};
+  afterCarriageReturn = { stdout: false, stderr: false };
+  scriptOrder = 0;
+  rawLineOpen = false;
+  pendingWrite = Promise.resolve();
+  context;
+  format;
+  lines;
+  color;
+  constructor(context, format, lines, color) {
+    this.context = context;
+    this.format = format;
+    this.lines = lines;
+    this.color = color;
+  }
+  static create(request, context) {
+    if (request.mode !== "human" || !context.stderr.isTTY || context.env.TERM === "dumb" || request.values.no_progress || context.env.TMUXP_PROGRESS === "0")
+      return;
+    const value = request.values.panel_lines ?? context.env.TMUXP_PROGRESS_LINES ?? 3;
+    if (!/^-?\d+$/.test(scalarText(value)) || !Number.isSafeInteger(Number(value)) || Number(value) < -1)
+      throw new CliError("usage", "Progress lines must be an integer at least -1", 2);
+    const format = scalarText(request.values.progress_format ?? context.env.TMUXP_PROGRESS_FORMAT ?? "default");
+    return new LoadProgress(context, Object.hasOwn(presets, format) ? presets[format] : format, Number(value), colorEnabled(request.mode, request.values.color, context.env, true));
+  }
+  dimensions() {
+    const stream = this.context.stderr;
+    const dimension = (value, fallback) => value !== undefined && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+    return { columns: dimension(stream.columns, 80), rows: dimension(stream.rows, 24) };
+  }
+  panelRows() {
+    const available = Math.max(0, this.dimensions().rows - 2);
+    return this.lines === -1 ? available : Math.min(this.lines, available);
+  }
+  script(stream, text) {
+    if (!text)
+      return;
+    if (this.afterCarriageReturn[stream] && text.startsWith(`
+`))
+      text = text.slice(1);
+    this.afterCarriageReturn[stream] = text.endsWith("\r");
+    const chunks = ((this.pending[stream]?.text ?? "") + text).slice(-retainedCharacters).split(/\r\n|[\r\n]/);
+    const partial = chunks.pop() ?? "";
+    this.history = [
+      ...this.history,
+      ...chunks.map((line) => ({ text: line, order: ++this.scriptOrder }))
+    ].slice(-Math.max(1, this.panelRows()));
+    let remaining = retainedCharacters;
+    for (let index = this.history.length - 1;index >= 0; index--) {
+      const line = this.history[index];
+      line.text = line.text.slice(-remaining);
+      remaining -= line.text.length;
+      if (remaining === 0) {
+        this.history = this.history.slice(index);
+        break;
+      }
+    }
+    if (partial)
+      this.pending[stream] = { text: partial, order: ++this.scriptOrder };
+    else
+      delete this.pending[stream];
+  }
+  tokens() {
+    const ratio = (done, total) => total ? `${done}/${total}` : "";
+    const bar = (done, total) => {
+      const filled = total ? Math.min(10, Math.floor(10 * done / total)) : 0;
+      return styled("success", "█".repeat(filled), this.color) + styled("secondary", "░".repeat(10 - filled), this.color);
+    };
+    const windowProgress = this.windowIndex ? ratio(this.windowIndex, this.windowTotal) : "";
+    const paneProgress = this.paneIndex ? ratio(this.paneIndex, this.paneTotal) : "";
+    return {
+      session: styled("subject", this.session, this.color),
+      workspace_path: styled("info", this.workspace, this.color),
+      window: styled("heading", this.window, this.color),
+      window_index: this.windowIndex,
+      window_total: this.windowTotal,
+      window_progress: windowProgress,
+      pane_index: this.paneIndex,
+      pane_total: this.paneTotal,
+      pane_progress: paneProgress,
+      progress: [windowProgress && `${windowProgress} win`, paneProgress && `${paneProgress} pane`].filter(Boolean).join(" · "),
+      windows_done: this.windowsDone,
+      windows_remaining: Math.max(0, this.windowTotal - this.windowsDone),
+      window_progress_rel: ratio(this.windowsDone, this.windowTotal),
+      pane_done: this.panesDone,
+      pane_remaining: Math.max(0, this.paneTotal - this.panesDone),
+      pane_progress_rel: ratio(this.panesDone, this.paneTotal),
+      session_pane_total: this.sessionPaneTotal,
+      session_panes_done: this.sessionPanesDone,
+      session_panes_remaining: Math.max(0, this.sessionPaneTotal - this.sessionPanesDone),
+      session_pane_progress: ratio(this.sessionPanesDone, this.sessionPaneTotal),
+      overall_percent: this.sessionPaneTotal ? Math.floor(100 * this.sessionPanesDone / this.sessionPaneTotal) : 0,
+      summary: `[${this.windowsDone} win, ${this.sessionPanesDone} panes]`,
+      bar: bar(this.sessionPanesDone, this.sessionPaneTotal),
+      pane_bar: bar(this.sessionPanesDone, this.sessionPaneTotal),
+      window_bar: bar(this.windowsDone, this.windowTotal),
+      status_icon: ""
+    };
+  }
+  erase() {
+    const { columns, rows } = this.dimensions();
+    const height = Math.min(rows, this.painted.reduce((total, width) => total + Math.max(1, Math.ceil(width / columns)), 0));
+    return height ? `\r${height > 1 ? `\x1B[${height - 1}A` : ""}\x1B[0J` : "";
+  }
+  enqueue(operation) {
+    const task = this.pendingWrite.then(operation);
+    this.pendingWrite = task.then(() => {}, () => {});
+    return task;
+  }
+  clear(signal = this.context.signal) {
+    return this.enqueue(async () => {
+      await this.separate(signal);
+      await this.eraseFrame(signal);
+    });
+  }
+  async separate(signal = this.context.signal) {
+    if (this.rawLineOpen)
+      await write(this.context.stderr, `
+`, signal);
+    this.rawLineOpen = false;
+  }
+  async eraseFrame(signal = this.context.signal) {
+    const erase = this.erase();
+    if (erase)
+      await write(this.context.stderr, erase, signal);
+    this.painted = [];
+  }
+  async draw(force = false) {
+    if (!this.active || !force && this.painted.length && performance.now() - this.lastDraw < 50)
+      return;
+    await this.separate();
+    const tokens = this.tokens();
+    const format = this.countsKnown ? this.format : "Loading workspace: {session}";
+    const label = styled("secondary", format, false).replace(/\{\{|\}\}|\{([^{}]+)\}/g, (match, token) => match === "{{" ? "{" : match === "}}" ? "}" : token && Object.hasOwn(tokens, token) ? String(tokens[token]) : match);
+    const count = this.panelRows();
+    const panel = count ? [...this.history, ...Object.values(this.pending)].sort((a, b) => a.order - b.order).slice(-count) : [];
+    const rows = [label, ...panel.map((line) => styled("secondary", line.text, this.color))].map((line) => cliTruncate(line, Math.max(0, this.dimensions().columns - 1)));
+    const erase = this.erase();
+    this.context.signal?.throwIfAborted();
+    this.painted = rows.map((line) => stringWidth(line));
+    this.lastDraw = performance.now();
+    await write(this.context.stderr, erase + rows.join(`
+`), this.context.signal);
+  }
+  event(event, data) {
+    return this.enqueue(() => this.update(event, data));
+  }
+  async update(event, data) {
+    switch (event) {
+      case "workspace-started":
+        this.active = true;
+        this.session = scalarText(data.session_name ?? "");
+        this.workspace = scalarText(data.input ?? "");
+        this.window = "";
+        this.countsKnown = data.window_total !== undefined;
+        this.windowTotal = Number(data.window_total ?? 0);
+        this.sessionPaneTotal = Number(data.session_pane_total ?? 0);
+        this.windowIndex = this.windowsDone = this.paneIndex = this.paneTotal = this.panesDone = this.sessionPanesDone = 0;
+        this.history = [];
+        this.pending = {};
+        this.afterCarriageReturn.stdout = this.afterCarriageReturn.stderr = false;
+        await this.draw(true);
+        break;
+      case "window-created":
+        this.window = scalarText(data.window_name ?? "");
+        this.windowIndex = Number(data.window_index);
+        this.paneTotal = Number(data.pane_total);
+        this.paneIndex = this.panesDone = 0;
+        await this.draw();
+        break;
+      case "pane-created":
+        this.paneIndex = Number(data.pane_index);
+        await this.draw();
+        break;
+      case "pane-completed":
+        this.panesDone++;
+        this.sessionPanesDone++;
+        await this.draw();
+        break;
+      case "window-completed":
+        this.windowsDone++;
+        await this.draw();
+        break;
+      case "script-output":
+        if (this.lines === 0 || this.panelRows() === 0) {
+          await this.eraseFrame();
+          const stream = data.stream === "stderr" ? "stderr" : "stdout";
+          const text = scalarText(data.text ?? "");
+          if (text && this.context[stream].isTTY)
+            this.rawLineOpen = !text.endsWith(`
+`);
+          return false;
+        }
+        {
+          const first = !this.history.length && !this.pending.stdout && !this.pending.stderr;
+          this.script(data.stream === "stderr" ? "stderr" : "stdout", scalarText(data.text ?? ""));
+          await this.draw(first);
+        }
+        return true;
+      case "workspace-completed":
+      case "completed":
+      case "failed":
+        this.active = false;
+        await this.separate();
+        await this.eraseFrame();
+        break;
+      default:
+        await this.draw();
+    }
+    return false;
+  }
+}
+export {
+  LoadProgress
+};