@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/chunk-HTQTIKWP.js

@@ -0,0 +1,928 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/ansi-regex@6.4.0/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:(?:\\u001B\\]|\\u009D)[^\\u0007\\u001B\\u009C\\u009D]*${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+__name(ansiRegex, "ansiRegex");
+
+// node_modules/.pnpm/strip-ansi@7.2.0/node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+__name(stripAnsi, "stripAnsi");
+
+// node_modules/.pnpm/get-east-asian-width@1.7.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, 101594, 101631, 101664, 101760, 101874, 101888, 102801, 102816, 102866, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110888, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110952, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127406, 127406, 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, 128729, 128732, 128735, 128747, 128748, 128756, 128764, 128986, 128986, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129734, 129736, 129736, 129740, 129757, 129759, 129771, 129775, 129786, 131072, 196605, 196608, 262141];
+
+// node_modules/.pnpm/get-east-asian-width@1.7.0/node_modules/get-east-asian-width/utilities.js
+var isInRange = /* @__PURE__ */ __name((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;
+}, "isInRange");
+
+// node_modules/.pnpm/get-east-asian-width@1.7.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];
+}
+__name(findWideFastPathRange, "findWideFastPathRange");
+var isAmbiguous = /* @__PURE__ */ __name((codePoint) => {
+  if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+}, "isAmbiguous");
+var isFullwidth = /* @__PURE__ */ __name((codePoint) => {
+  if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+}, "isFullwidth");
+var isWide = /* @__PURE__ */ __name((codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+}, "isWide");
+
+// node_modules/.pnpm/get-east-asian-width@1.7.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}\`.`);
+  }
+}
+__name(validate, "validate");
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullwidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+__name(eastAsianWidth, "eastAsianWidth");
+
+// node_modules/.pnpm/string-width@8.3.0/node_modules/string-width/index.js
+var segmenter = new Intl.Segmenter();
+var visibleCharacterRegex = new RegExp("[^\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Nonspacing_Mark}\\p{Enclosing_Mark}\\p{Surrogate}]", "v");
+var spacingMarkRegex = new RegExp("\\p{Spacing_Mark}", "v");
+var rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+var extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("\u200D")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+__name(isDoubleWidthNonRgiEmojiSequence, "isDoubleWidthNonRgiEmojiSequence");
+function baseVisible(segment) {
+  const index = segment.search(visibleCharacterRegex);
+  return index === -1 ? void 0 : segment.slice(index);
+}
+__name(baseVisible, "baseVisible");
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+__name(isHangulLeadingJamo, "isHangulLeadingJamo");
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+__name(isHangulVowelJamo, "isHangulVowelJamo");
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+__name(isHangulTrailingJamo, "isHangulTrailingJamo");
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+__name(isHangulJamo, "isHangulJamo");
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (!visibleCharacterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return void 0;
+  }
+  let width = 0;
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return void 0;
+      }
+      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;
+}
+__name(hangulClusterWidth, "hangulClusterWidth");
+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 >= "\uFF00" && character <= "\uFFEF") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+__name(trailingWidth, "trailingWidth");
+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("\x9B"))) {
+    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)) {
+    const visibleSegment = baseVisible(segment);
+    if (visibleSegment === void 0) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+      width += 2;
+      continue;
+    }
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== void 0) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+__name(stringWidth, "stringWidth");
+
+// node_modules/.pnpm/ansi-styles@6.2.3/node_modules/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${code + offset}m`, "wrapAnsi16");
+var wrapAnsi256 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, "wrapAnsi256");
+var wrapAnsi16m = /* @__PURE__ */ __name((offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, "wrapAnsi16m");
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    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],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    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],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    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 = /* @__PURE__ */ 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 [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: /* @__PURE__ */ __name((hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)), "value"),
+      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: /* @__PURE__ */ __name((red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), "value"),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: /* @__PURE__ */ __name((hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), "value"),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+__name(assembleStyles, "assembleStyles");
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/.pnpm/wrap-ansi@10.0.2/node_modules/wrap-ansi/index.js
+var ANSI_ESCAPE = "\x1B";
+var ANSI_ESCAPE_BELL = "\x07";
+var C1_CSI = "\x9B";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_SGR_RESET = 0;
+var ANSI_SGR_RESET_FOREGROUND = 39;
+var ANSI_SGR_RESET_BACKGROUND = 49;
+var ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
+var ANSI_SGR_FOREGROUND_EXTENDED = 38;
+var ANSI_SGR_BACKGROUND_EXTENDED = 48;
+var ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
+var ANSI_SGR_COLOR_MODE_RGB = 2;
+var ANSI_SGR_COLOR_MODE_256 = 5;
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;`;
+var ESCAPES = /* @__PURE__ */ new Set([
+  ANSI_ESCAPE,
+  C1_CSI
+]);
+var ESCAPE_CHARACTERS = [...ESCAPES].join("");
+var CSI_INTRODUCER = `(?:${ANSI_ESCAPE}\\${ANSI_CSI}|${C1_CSI})`;
+var CSI_PARAMETERS = "[0-?]*[ -/]*[@-~]";
+var SGR_PARAMETERS = `(?<sgr>[0-9;:]*)${ANSI_SGR_TERMINATOR}`;
+var OSC_STRING_TERMINATOR = `(?:${ANSI_ESCAPE_BELL}|${ANSI_ESCAPE}\\\\)`;
+var OSC_STRING_PAYLOAD = String.raw`[^\u0000-\u001F\u007F-\u009F]*`;
+var LINK_PARAMETERS = String.raw`8;(?<parameters>[^;\u0000-\u001F\u007F-\u009F]*);(?<uri>${OSC_STRING_PAYLOAD})${OSC_STRING_TERMINATOR}`;
+var OSC_STRING = `${OSC_STRING_PAYLOAD}${OSC_STRING_TERMINATOR}`;
+var ANSI_ESCAPE_REGEX = new RegExp(
+  `${CSI_INTRODUCER}(?:${SGR_PARAMETERS}|${CSI_PARAMETERS})|${ANSI_ESCAPE}\\${ANSI_OSC}(?:${LINK_PARAMETERS}|${OSC_STRING})`,
+  "y"
+);
+var ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(ansi_styles_default.codes.values());
+ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
+var segmenter2 = new Intl.Segmenter();
+var getStringWidth = /* @__PURE__ */ __name((string) => stringWidth(string, { countAnsiEscapeCodes: true }), "getStringWidth");
+var TAB_SIZE = 8;
+var ESCAPE_INTRODUCER_REGEX = new RegExp(`[${ESCAPE_CHARACTERS}]`, "g");
+var ROW_BOUNDARY_REGEX = new RegExp(`[\\n${ESCAPE_CHARACTERS}]`, "g");
+var ASCII_PRINTABLE_REGEX = /^[ -~]*$/;
+var wrapAnsiCode = /* @__PURE__ */ __name((code) => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`, "wrapAnsiCode");
+var wrapAnsiHyperlink = /* @__PURE__ */ __name((url, parameters = "") => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${parameters};${url}${ANSI_ESCAPE_BELL}`, "wrapAnsiHyperlink");
+var matchAnsiEscape = /* @__PURE__ */ __name((string, index) => {
+  if (!ESCAPES.has(string[index])) {
+    return;
+  }
+  ANSI_ESCAPE_REGEX.lastIndex = index;
+  return ANSI_ESCAPE_REGEX.exec(string) ?? void 0;
+}, "matchAnsiEscape");
+var forEachSegment = /* @__PURE__ */ __name((string, onPlainText, onEscape = () => {
+}) => {
+  let plainStart = 0;
+  let index = 0;
+  while (index < string.length) {
+    ESCAPE_INTRODUCER_REGEX.lastIndex = index;
+    const introducer = ESCAPE_INTRODUCER_REGEX.exec(string);
+    if (!introducer) {
+      break;
+    }
+    const escape = matchAnsiEscape(string, introducer.index);
+    if (!escape) {
+      index = introducer.index + 1;
+      continue;
+    }
+    if (introducer.index > plainStart) {
+      onPlainText(string.slice(plainStart, introducer.index));
+    }
+    onEscape(escape[0]);
+    index = introducer.index + escape[0].length;
+    plainStart = index;
+  }
+  if (plainStart < string.length) {
+    onPlainText(string.slice(plainStart));
+  }
+}, "forEachSegment");
+var getWidth = /* @__PURE__ */ __name((string) => {
+  let plainText = "";
+  forEachSegment(string, (part) => {
+    plainText += part;
+  });
+  return getStringWidth(plainText);
+}, "getWidth");
+var getTokens = /* @__PURE__ */ __name((string) => {
+  const tokens = [];
+  forEachSegment(string, (plainText) => {
+    if (ASCII_PRINTABLE_REGEX.test(plainText)) {
+      for (const character of plainText) {
+        tokens.push({ value: character, width: 1 });
+      }
+      return;
+    }
+    for (const { segment } of segmenter2.segment(plainText)) {
+      tokens.push({ value: segment, width: getStringWidth(segment) });
+    }
+  }, (escape) => {
+    tokens.push({ value: escape, width: 0 });
+  });
+  return tokens;
+}, "getTokens");
+var splitWords = /* @__PURE__ */ __name((string) => {
+  let currentWord = { value: "", plainText: "" };
+  const words = [currentWord];
+  forEachSegment(string, (plainText) => {
+    const parts = plainText.split(" ");
+    currentWord.value += parts[0];
+    currentWord.plainText += parts[0];
+    for (let index = 1; index < parts.length; index++) {
+      currentWord = { value: parts[index], plainText: parts[index] };
+      words.push(currentWord);
+    }
+  }, (escape) => {
+    currentWord.value += escape;
+  });
+  for (const word of words) {
+    word.width = getStringWidth(word.plainText);
+  }
+  return words;
+}, "splitWords");
+var getColonColorToken = /* @__PURE__ */ __name((parameter) => {
+  const parts = parameter.split(":");
+  const code = Number.parseInt(parts[0], 10);
+  const mode = Number.parseInt(parts[1], 10);
+  if (![ANSI_SGR_FOREGROUND_EXTENDED, ANSI_SGR_BACKGROUND_EXTENDED, ANSI_SGR_UNDERLINE_COLOR_EXTENDED].includes(code)) {
+    return;
+  }
+  if (mode === ANSI_SGR_COLOR_MODE_256 && parts.length === 3 && /^\d+$/.test(parts[2])) {
+    return { code, open: parameter, hasArguments: true };
+  }
+  if (mode !== ANSI_SGR_COLOR_MODE_RGB) {
+    return;
+  }
+  const components = parts.length === 6 ? parts.slice(3) : parts.slice(2);
+  const colorSpace = parts.length === 6 ? parts[2] : void 0;
+  if (components.length === 3 && components.every((component) => /^\d+$/.test(component)) && (colorSpace === void 0 || /^\d*$/.test(colorSpace))) {
+    return { code, open: parameter, hasArguments: true };
+  }
+}, "getColonColorToken");
+var getSgrTokens = /* @__PURE__ */ __name((sgrParameters) => {
+  const parameters = sgrParameters.split(";");
+  const sgrTokens = [];
+  for (let index = 0; index < parameters.length; index++) {
+    const parameter = parameters[index];
+    if (parameter.includes(":")) {
+      const colonColorToken = getColonColorToken(parameter);
+      if (colonColorToken) {
+        sgrTokens.push(colonColorToken);
+      }
+      continue;
+    }
+    const code = parameter === "" ? ANSI_SGR_RESET : Number.parseInt(parameter, 10);
+    if (!Number.isFinite(code)) {
+      continue;
+    }
+    if (code === ANSI_SGR_FOREGROUND_EXTENDED || code === ANSI_SGR_BACKGROUND_EXTENDED || code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED) {
+      if (index + 1 >= parameters.length) {
+        break;
+      }
+      const mode = Number.parseInt(parameters[index + 1], 10);
+      const colorIndex = Number.parseInt(parameters[index + 2], 10);
+      if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(colorIndex)) {
+        sgrTokens.push({ code, open: [code, mode, colorIndex].join(";"), hasArguments: true });
+        index += 2;
+        continue;
+      }
+      const red = Number.parseInt(parameters[index + 2], 10);
+      const green = Number.parseInt(parameters[index + 3], 10);
+      const blue = Number.parseInt(parameters[index + 4], 10);
+      if (mode === ANSI_SGR_COLOR_MODE_RGB && Number.isFinite(red) && Number.isFinite(green) && Number.isFinite(blue)) {
+        sgrTokens.push({ code, open: [code, mode, red, green, blue].join(";"), hasArguments: true });
+        index += 4;
+        continue;
+      }
+      break;
+    }
+    sgrTokens.push({ code, open: String(code), hasArguments: false });
+  }
+  return sgrTokens;
+}, "getSgrTokens");
+var removeActiveStyle = /* @__PURE__ */ __name((activeStyles, family) => {
+  const activeStyleIndex = activeStyles.findIndex((activeStyle) => activeStyle.family === family);
+  if (activeStyleIndex !== -1) {
+    activeStyles.splice(activeStyleIndex, 1);
+  }
+}, "removeActiveStyle");
+var upsertActiveStyle = /* @__PURE__ */ __name((activeStyles, nextActiveStyle) => {
+  removeActiveStyle(activeStyles, nextActiveStyle.family);
+  activeStyles.push(nextActiveStyle);
+}, "upsertActiveStyle");
+var removeModifierStylesByClose = /* @__PURE__ */ __name((activeStyles, closeCode) => {
+  for (let index = activeStyles.length - 1; index >= 0; index--) {
+    const activeStyle = activeStyles[index];
+    if (activeStyle.family.startsWith("modifier-") && activeStyle.close === closeCode) {
+      activeStyles.splice(index, 1);
+    }
+  }
+}, "removeModifierStylesByClose");
+var getColorStyle = /* @__PURE__ */ __name((sgrToken) => {
+  const { code, open, hasArguments } = sgrToken;
+  if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && hasArguments) {
+    return {
+      family: "foreground",
+      open,
+      close: ANSI_SGR_RESET_FOREGROUND
+    };
+  }
+  if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && hasArguments) {
+    return {
+      family: "background",
+      open,
+      close: ANSI_SGR_RESET_BACKGROUND
+    };
+  }
+  if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && hasArguments) {
+    return {
+      family: "underlineColor",
+      open,
+      close: ANSI_SGR_RESET_UNDERLINE_COLOR
+    };
+  }
+}, "getColorStyle");
+var applySgrResetCode = /* @__PURE__ */ __name((code, activeStyles) => {
+  if (code === ANSI_SGR_RESET) {
+    activeStyles.length = 0;
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_FOREGROUND) {
+    removeActiveStyle(activeStyles, "foreground");
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_BACKGROUND) {
+    removeActiveStyle(activeStyles, "background");
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_UNDERLINE_COLOR) {
+    removeActiveStyle(activeStyles, "underlineColor");
+    return true;
+  }
+  if (ANSI_SGR_MODIFIER_CLOSE_CODES.has(code)) {
+    removeModifierStylesByClose(activeStyles, code);
+    return true;
+  }
+  return false;
+}, "applySgrResetCode");
+var applySgrToken = /* @__PURE__ */ __name((sgrToken, activeStyles) => {
+  const { code } = sgrToken;
+  if (applySgrResetCode(code, activeStyles)) {
+    return;
+  }
+  const colorStyle = getColorStyle(sgrToken);
+  if (colorStyle) {
+    upsertActiveStyle(activeStyles, colorStyle);
+    return;
+  }
+  const close = ansi_styles_default.codes.get(code);
+  if (close !== void 0 && close !== ANSI_SGR_RESET) {
+    upsertActiveStyle(activeStyles, {
+      family: `modifier-${code}`,
+      open: sgrToken.open,
+      close
+    });
+  }
+}, "applySgrToken");
+var applySgrParameters = /* @__PURE__ */ __name((sgrParameters, activeStyles) => {
+  for (const sgrToken of getSgrTokens(sgrParameters)) {
+    applySgrToken(sgrToken, activeStyles);
+  }
+}, "applySgrParameters");
+var applySgrResets = /* @__PURE__ */ __name((sgrParameters, activeStyles) => {
+  for (const { code } of getSgrTokens(sgrParameters)) {
+    applySgrResetCode(code, activeStyles);
+  }
+}, "applySgrResets");
+var applyLeadingSgrResets = /* @__PURE__ */ __name((string, startIndex, activeStyles) => {
+  let index = startIndex;
+  while (index < string.length) {
+    const match = matchAnsiEscape(string, index);
+    if (!match) {
+      break;
+    }
+    if (match.groups.sgr !== void 0) {
+      applySgrResets(match.groups.sgr, activeStyles);
+    }
+    index += match[0].length;
+  }
+}, "applyLeadingSgrResets");
+var getClosingSgrSequence = /* @__PURE__ */ __name((activeStyles) => [...activeStyles].reverse().map((activeStyle) => wrapAnsiCode(activeStyle.close)).join(""), "getClosingSgrSequence");
+var getOpeningSgrSequence = /* @__PURE__ */ __name((activeStyles) => activeStyles.map((activeStyle) => wrapAnsiCode(activeStyle.open)).join(""), "getOpeningSgrSequence");
+var wrapWord = /* @__PURE__ */ __name((rows, word, columns, rowWidth) => {
+  const tokens = getTokens(word);
+  let visible = rowWidth;
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.width > 0 && visible > 0 && visible + token.width > columns) {
+      rows.push("");
+      visible = 0;
+    }
+    rows[rows.length - 1] += token.value;
+    visible += token.width;
+    if (visible === columns && index < tokens.length - 1) {
+      rows.push("");
+      visible = 0;
+    }
+  }
+  if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+  return getWidth(rows.at(-1));
+}, "wrapWord");
+var stringVisibleTrimSpacesRight = /* @__PURE__ */ __name((string) => {
+  if (!string.includes(" ")) {
+    return string;
+  }
+  const segments = [];
+  forEachSegment(string, (plainText) => {
+    segments.push({ value: plainText, isEscape: false });
+  }, (escape) => {
+    segments.push({ value: escape, isEscape: true });
+  });
+  for (let index = segments.length - 1; index >= 0; index--) {
+    const segment = segments[index];
+    if (segment.isEscape) {
+      continue;
+    }
+    let end = segment.value.length;
+    while (end > 0 && segment.value[end - 1] === " ") {
+      end--;
+    }
+    segment.value = segment.value.slice(0, end);
+    if (getStringWidth(segment.value) > 0) {
+      break;
+    }
+  }
+  return segments.map((segment) => segment.value).join("");
+}, "stringVisibleTrimSpacesRight");
+var expandTabs = /* @__PURE__ */ __name((line) => {
+  if (!line.includes("	")) {
+    return line;
+  }
+  let visible = 0;
+  let expandedLine = "";
+  let plainTextSinceTab = "";
+  const expandPlainText = /* @__PURE__ */ __name((plainText) => {
+    const segments = plainText.split("	");
+    for (const [index, segment] of segments.entries()) {
+      expandedLine += segment;
+      plainTextSinceTab += segment;
+      if (index < segments.length - 1) {
+        visible += getStringWidth(plainTextSinceTab);
+        plainTextSinceTab = "";
+        const spaces = TAB_SIZE - visible % TAB_SIZE;
+        expandedLine += " ".repeat(spaces);
+        visible += spaces;
+      }
+    }
+  }, "expandPlainText");
+  forEachSegment(line, expandPlainText, (escape) => {
+    expandedLine += escape;
+  });
+  return expandedLine;
+}, "expandTabs");
+var restoreStylesAcrossRows = /* @__PURE__ */ __name((preString) => {
+  let returnValue = "";
+  let activeHyperlink;
+  const activeStyles = [];
+  let index = 0;
+  let copiedIndex = 0;
+  while (index < preString.length) {
+    ROW_BOUNDARY_REGEX.lastIndex = index;
+    const boundary = ROW_BOUNDARY_REGEX.exec(preString);
+    if (!boundary) {
+      break;
+    }
+    index = boundary.index;
+    if (boundary[0] !== "\n") {
+      const escape = matchAnsiEscape(preString, index);
+      if (!escape) {
+        index++;
+        continue;
+      }
+      const { groups } = escape;
+      if (groups.sgr !== void 0) {
+        applySgrParameters(groups.sgr, activeStyles);
+      } else if (groups.uri !== void 0) {
+        activeHyperlink = groups.uri.length === 0 ? void 0 : { parameters: groups.parameters, uri: groups.uri };
+      }
+      index += escape[0].length;
+      continue;
+    }
+    returnValue += preString.slice(copiedIndex, index);
+    if (index > copiedIndex) {
+      if (activeHyperlink) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      returnValue += getClosingSgrSequence(activeStyles);
+    }
+    returnValue += "\n";
+    index++;
+    copiedIndex = index;
+    if (index < preString.length && preString[index] !== "\n") {
+      const openingStyles = [...activeStyles];
+      applyLeadingSgrResets(preString, index, openingStyles);
+      returnValue += getOpeningSgrSequence(openingStyles);
+      if (activeHyperlink) {
+        returnValue += wrapAnsiHyperlink(activeHyperlink.uri, activeHyperlink.parameters);
+      }
+    }
+  }
+  return returnValue + preString.slice(copiedIndex);
+}, "restoreStylesAcrossRows");
+var exec = /* @__PURE__ */ __name((string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  const words = splitWords(string);
+  let rows = [""];
+  let rowLength = 0;
+  let trimmedRowIndex = -1;
+  let isFirstWord = true;
+  for (const word of words) {
+    const rowIndex = rows.length - 1;
+    if (options.trim !== false && trimmedRowIndex !== rowIndex) {
+      const row = rows[rowIndex];
+      const trimmedRow = row.trimStart();
+      if (trimmedRow.length !== row.length) {
+        rows[rowIndex] = trimmedRow;
+        rowLength = getWidth(trimmedRow);
+      }
+      if (trimmedRow.length > 0) {
+        trimmedRowIndex = rowIndex;
+      }
+    }
+    if (isFirstWord) {
+      isFirstWord = false;
+    } else {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength > 0 || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    if (options.hard && options.wordWrap !== false && word.width > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((word.width - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((word.width - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+        rowLength = 0;
+      }
+      rowLength = wrapWord(rows, word.value, columns, rowLength);
+      continue;
+    }
+    if (rowLength + word.width > columns && rowLength > 0 && word.width > 0) {
+      if (options.wordWrap === false && rowLength < columns) {
+        rowLength = wrapWord(rows, word.value, columns, rowLength);
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + word.width > columns && options.wordWrap === false) {
+      rowLength = wrapWord(rows, word.value, columns, rowLength);
+      continue;
+    }
+    rows[rows.length - 1] += word.value;
+    rowLength += word.width;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  return restoreStylesAcrossRows(rows.join("\n"));
+}, "exec");
+var normalizeText = /* @__PURE__ */ __name((string) => {
+  let normalizedString = "";
+  forEachSegment(string, (plainText) => {
+    normalizedString += plainText.normalize();
+  }, (escape) => {
+    normalizedString += escape;
+  });
+  return normalizedString;
+}, "normalizeText");
+function wrapAnsi(string, columns, options) {
+  return normalizeText(String(string)).replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
+}
+__name(wrapAnsi, "wrapAnsi");
+
+export {
+  stringWidth,
+  wrapAnsi
+};