@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.2

package/dist/truncate-CBiyyZzw.js

@@ -0,0 +1,2156 @@
+import process from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+//#region src/ansi/escapes.ts
+const ESC = "\x1B";
+const BEL = "\x07";
+const DEL = "";
+/** Control Sequence Introducer. */
+const CSI$1 = `[`;
+/** Operating System Command. */
+const OSC$1 = `]`;
+/** String Terminator. */
+const ST = `\\`;
+/** Single-byte C1 forms of CSI and ST. */
+const C1_CSI = "›";
+const C1_ST = "œ";
+const sep = ";";
+const cursorTo = (x, y) => {
+	if (typeof y !== "number") return CSI$1 + (x + 1) + "G";
+	return CSI$1 + (y + 1) + sep + (x + 1) + "H";
+};
+const cursorUp = (count = 1) => CSI$1 + count + "A";
+const cursorDown = (count = 1) => CSI$1 + count + "B";
+const cursorLeft = CSI$1 + "G";
+const cursorNextLine = CSI$1 + "E";
+const eraseEndLine = CSI$1 + "K";
+const eraseLine = CSI$1 + "2K";
+const eraseScreen = CSI$1 + "2J";
+const eraseLines = (count) => {
+	let clear = "";
+	for (let i = 0; i < count; i++) clear += eraseLine + (i < count - 1 ? cursorUp() : "");
+	if (count) clear += cursorLeft;
+	return clear;
+};
+const isOldWindows = () => {
+	if (process.platform !== "win32") return false;
+	const parts = os.release().split(".");
+	const major = Number(parts[0]);
+	const build = Number(parts[2] ?? 0);
+	if (major < 10) return true;
+	return major === 10 && build < 10586;
+};
+const clearTerminal = isOldWindows() ? `${eraseScreen}${CSI$1}0f` : `${eraseScreen}${CSI$1}3J${CSI$1}H`;
+const enterAlternativeScreen = CSI$1 + "?1049h";
+const exitAlternativeScreen = CSI$1 + "?1049l";
+const cursorShow = CSI$1 + "?25h";
+const cursorHide = CSI$1 + "?25l";
+const enableBracketedPaste = CSI$1 + "?2004h";
+const disableBracketedPaste = CSI$1 + "?2004l";
+const pasteStart = CSI$1 + "200~";
+const pasteEnd = CSI$1 + "201~";
+const bsu = CSI$1 + "?2026h";
+const esu = CSI$1 + "?2026l";
+const kittyQuery = CSI$1 + "?u";
+const pushKittyKeyboard = (flags) => `${CSI$1}>${flags}u`;
+const popKittyKeyboard = CSI$1 + "<u";
+const link = (text, url) => [
+	OSC$1,
+	"8",
+	sep,
+	sep,
+	url,
+	"\x07",
+	text,
+	OSC$1,
+	"8",
+	sep,
+	sep,
+	"\x07"
+].join("");
+const ansiEscapes = {
+	cursorTo,
+	cursorUp,
+	cursorDown,
+	cursorLeft,
+	cursorNextLine,
+	eraseEndLine,
+	eraseLine,
+	eraseScreen,
+	eraseLines,
+	clearTerminal,
+	enterAlternativeScreen,
+	exitAlternativeScreen,
+	cursorShow,
+	cursorHide,
+	enableBracketedPaste,
+	disableBracketedPaste,
+	pasteStart,
+	pasteEnd,
+	bsu,
+	esu,
+	kittyQuery,
+	pushKittyKeyboard,
+	popKittyKeyboard,
+	link
+};
+//#endregion
+//#region src/ansi/sgr.ts
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `${CSI$1}${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `${CSI$1}${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `${CSI$1}${38 + offset};2;${red};${green};${blue}m`;
+const modifierCodes = {
+	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]
+};
+const colorCodes = {
+	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]
+};
+const bgColorCodes = {
+	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]
+};
+const modifierNames = Object.keys(modifierCodes);
+const foregroundColorNames = Object.keys(colorCodes);
+const backgroundColorNames = Object.keys(bgColorCodes);
+const toPairs = (codes) => {
+	const result = {};
+	for (const [name, [open, close]] of Object.entries(codes)) result[name] = {
+		open: `${CSI$1}${open}m`,
+		close: `${CSI$1}${close}m`
+	};
+	return result;
+};
+/**
+Named SGR styles as `{open, close}` escape sequence pairs.
+*/
+const styles = {
+	...toPairs(modifierCodes),
+	...toPairs(colorCodes),
+	...toPairs(bgColorCodes)
+};
+/**
+Raw SGR code numbers: open code → close code.
+*/
+const codes = new Map([
+	...Object.values(modifierCodes),
+	...Object.values(colorCodes),
+	...Object.values(bgColorCodes)
+].map(([open, close]) => [open, close]));
+const foreground = {
+	close: `${CSI$1}39m`,
+	ansi: wrapAnsi16(),
+	ansi256: wrapAnsi256(),
+	ansi16m: wrapAnsi16m()
+};
+const background = {
+	close: `${CSI$1}49m`,
+	ansi: wrapAnsi16(ANSI_BACKGROUND_OFFSET),
+	ansi256: wrapAnsi256(ANSI_BACKGROUND_OFFSET),
+	ansi16m: wrapAnsi16m(ANSI_BACKGROUND_OFFSET)
+};
+const rgbToAnsi256 = (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);
+};
+const hexToRgb = (hex) => {
+	const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex);
+	if (!matches) return [
+		0,
+		0,
+		0
+	];
+	let [colorString] = matches;
+	if (colorString.length === 3) colorString = colorString.split("").map((character) => character + character).join("");
+	const integer = Number.parseInt(colorString, 16);
+	return [
+		integer >> 16 & 255,
+		integer >> 8 & 255,
+		integer & 255
+	];
+};
+const hexToAnsi256 = (hex) => rgbToAnsi256(...hexToRgb(hex));
+const ansi256ToAnsi = (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;
+};
+const rgbToAnsi = (red, green, blue) => ansi256ToAnsi(rgbToAnsi256(red, green, blue));
+const hexToAnsi = (hex) => ansi256ToAnsi(hexToAnsi256(hex));
+//#endregion
+//#region src/ansi/east-asian-width.ts
+const isInRange = (ranges, codePoint) => {
+	let low = 0;
+	let high = Math.floor(ranges.length / 2) - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const i = mid * 2;
+		if (codePoint < ranges[i]) high = mid - 1;
+		else if (codePoint > ranges[i + 1]) low = mid + 1;
+		else return true;
+	}
+	return false;
+};
+const ambiguousMinimalCodePoint = 161;
+const ambiguousMaximumCodePoint = 1114109;
+const ambiguousRanges = [
+	161,
+	161,
+	164,
+	164,
+	167,
+	168,
+	170,
+	170,
+	173,
+	174,
+	176,
+	180,
+	182,
+	186,
+	188,
+	191,
+	198,
+	198,
+	208,
+	208,
+	215,
+	216,
+	222,
+	225,
+	230,
+	230,
+	232,
+	234,
+	236,
+	237,
+	240,
+	240,
+	242,
+	243,
+	247,
+	250,
+	252,
+	252,
+	254,
+	254,
+	257,
+	257,
+	273,
+	273,
+	275,
+	275,
+	283,
+	283,
+	294,
+	295,
+	299,
+	299,
+	305,
+	307,
+	312,
+	312,
+	319,
+	322,
+	324,
+	324,
+	328,
+	331,
+	333,
+	333,
+	338,
+	339,
+	358,
+	359,
+	363,
+	363,
+	462,
+	462,
+	464,
+	464,
+	466,
+	466,
+	468,
+	468,
+	470,
+	470,
+	472,
+	472,
+	474,
+	474,
+	476,
+	476,
+	593,
+	593,
+	609,
+	609,
+	708,
+	708,
+	711,
+	711,
+	713,
+	715,
+	717,
+	717,
+	720,
+	720,
+	728,
+	731,
+	733,
+	733,
+	735,
+	735,
+	768,
+	879,
+	913,
+	929,
+	931,
+	937,
+	945,
+	961,
+	963,
+	969,
+	1025,
+	1025,
+	1040,
+	1103,
+	1105,
+	1105,
+	8208,
+	8208,
+	8211,
+	8214,
+	8216,
+	8217,
+	8220,
+	8221,
+	8224,
+	8226,
+	8228,
+	8231,
+	8240,
+	8240,
+	8242,
+	8243,
+	8245,
+	8245,
+	8251,
+	8251,
+	8254,
+	8254,
+	8308,
+	8308,
+	8319,
+	8319,
+	8321,
+	8324,
+	8364,
+	8364,
+	8451,
+	8451,
+	8453,
+	8453,
+	8457,
+	8457,
+	8467,
+	8467,
+	8470,
+	8470,
+	8481,
+	8482,
+	8486,
+	8486,
+	8491,
+	8491,
+	8531,
+	8532,
+	8539,
+	8542,
+	8544,
+	8555,
+	8560,
+	8569,
+	8585,
+	8585,
+	8592,
+	8601,
+	8632,
+	8633,
+	8658,
+	8658,
+	8660,
+	8660,
+	8679,
+	8679,
+	8704,
+	8704,
+	8706,
+	8707,
+	8711,
+	8712,
+	8715,
+	8715,
+	8719,
+	8719,
+	8721,
+	8721,
+	8725,
+	8725,
+	8730,
+	8730,
+	8733,
+	8736,
+	8739,
+	8739,
+	8741,
+	8741,
+	8743,
+	8748,
+	8750,
+	8750,
+	8756,
+	8759,
+	8764,
+	8765,
+	8776,
+	8776,
+	8780,
+	8780,
+	8786,
+	8786,
+	8800,
+	8801,
+	8804,
+	8807,
+	8810,
+	8811,
+	8814,
+	8815,
+	8834,
+	8835,
+	8838,
+	8839,
+	8853,
+	8853,
+	8857,
+	8857,
+	8869,
+	8869,
+	8895,
+	8895,
+	8978,
+	8978,
+	9312,
+	9449,
+	9451,
+	9547,
+	9552,
+	9587,
+	9600,
+	9615,
+	9618,
+	9621,
+	9632,
+	9633,
+	9635,
+	9641,
+	9650,
+	9651,
+	9654,
+	9655,
+	9660,
+	9661,
+	9664,
+	9665,
+	9670,
+	9672,
+	9675,
+	9675,
+	9678,
+	9681,
+	9698,
+	9701,
+	9711,
+	9711,
+	9733,
+	9734,
+	9737,
+	9737,
+	9742,
+	9743,
+	9756,
+	9756,
+	9758,
+	9758,
+	9792,
+	9792,
+	9794,
+	9794,
+	9824,
+	9825,
+	9827,
+	9829,
+	9831,
+	9834,
+	9836,
+	9837,
+	9839,
+	9839,
+	9886,
+	9887,
+	9919,
+	9919,
+	9926,
+	9933,
+	9935,
+	9939,
+	9941,
+	9953,
+	9955,
+	9955,
+	9960,
+	9961,
+	9963,
+	9969,
+	9972,
+	9972,
+	9974,
+	9977,
+	9979,
+	9980,
+	9982,
+	9983,
+	10045,
+	10045,
+	10102,
+	10111,
+	11094,
+	11097,
+	12872,
+	12879,
+	57344,
+	63743,
+	65024,
+	65039,
+	65533,
+	65533,
+	127232,
+	127242,
+	127248,
+	127277,
+	127280,
+	127337,
+	127344,
+	127373,
+	127375,
+	127376,
+	127387,
+	127404,
+	917760,
+	917999,
+	983040,
+	1048573,
+	1048576,
+	1114109
+];
+const fullwidthMinimalCodePoint = 12288;
+const fullwidthMaximumCodePoint = 65510;
+const fullwidthRanges = [
+	12288,
+	12288,
+	65281,
+	65376,
+	65504,
+	65510
+];
+const halfwidthMinimalCodePoint = 8361;
+const halfwidthMaximumCodePoint = 65518;
+const halfwidthRanges = [
+	8361,
+	8361,
+	65377,
+	65470,
+	65474,
+	65479,
+	65482,
+	65487,
+	65490,
+	65495,
+	65498,
+	65500,
+	65512,
+	65518
+];
+const narrowMinimalCodePoint = 32;
+const narrowMaximumCodePoint = 10630;
+const narrowRanges = [
+	32,
+	126,
+	162,
+	163,
+	165,
+	166,
+	172,
+	172,
+	175,
+	175,
+	10214,
+	10221,
+	10629,
+	10630
+];
+const wideMinimalCodePoint = 4352;
+const wideMaximumCodePoint = 262141;
+const wideRanges = [
+	4352,
+	4447,
+	8986,
+	8987,
+	9001,
+	9002,
+	9193,
+	9196,
+	9200,
+	9200,
+	9203,
+	9203,
+	9725,
+	9726,
+	9748,
+	9749,
+	9776,
+	9783,
+	9800,
+	9811,
+	9855,
+	9855,
+	9866,
+	9871,
+	9875,
+	9875,
+	9889,
+	9889,
+	9898,
+	9899,
+	9917,
+	9918,
+	9924,
+	9925,
+	9934,
+	9934,
+	9940,
+	9940,
+	9962,
+	9962,
+	9970,
+	9971,
+	9973,
+	9973,
+	9978,
+	9978,
+	9981,
+	9981,
+	9989,
+	9989,
+	9994,
+	9995,
+	10024,
+	10024,
+	10060,
+	10060,
+	10062,
+	10062,
+	10067,
+	10069,
+	10071,
+	10071,
+	10133,
+	10135,
+	10160,
+	10160,
+	10175,
+	10175,
+	11035,
+	11036,
+	11088,
+	11088,
+	11093,
+	11093,
+	11904,
+	11929,
+	11931,
+	12019,
+	12032,
+	12245,
+	12272,
+	12287,
+	12289,
+	12350,
+	12353,
+	12438,
+	12441,
+	12543,
+	12549,
+	12591,
+	12593,
+	12686,
+	12688,
+	12773,
+	12783,
+	12830,
+	12832,
+	12871,
+	12880,
+	42124,
+	42128,
+	42182,
+	43360,
+	43388,
+	44032,
+	55203,
+	63744,
+	64255,
+	65040,
+	65049,
+	65072,
+	65106,
+	65108,
+	65126,
+	65128,
+	65131,
+	94176,
+	94180,
+	94192,
+	94198,
+	94208,
+	101589,
+	101631,
+	101662,
+	101760,
+	101874,
+	110576,
+	110579,
+	110581,
+	110587,
+	110589,
+	110590,
+	110592,
+	110882,
+	110898,
+	110898,
+	110928,
+	110930,
+	110933,
+	110933,
+	110948,
+	110951,
+	110960,
+	111355,
+	119552,
+	119638,
+	119648,
+	119670,
+	126980,
+	126980,
+	127183,
+	127183,
+	127374,
+	127374,
+	127377,
+	127386,
+	127488,
+	127490,
+	127504,
+	127547,
+	127552,
+	127560,
+	127568,
+	127569,
+	127584,
+	127589,
+	127744,
+	127776,
+	127789,
+	127797,
+	127799,
+	127868,
+	127870,
+	127891,
+	127904,
+	127946,
+	127951,
+	127955,
+	127968,
+	127984,
+	127988,
+	127988,
+	127992,
+	128062,
+	128064,
+	128064,
+	128066,
+	128252,
+	128255,
+	128317,
+	128331,
+	128334,
+	128336,
+	128359,
+	128378,
+	128378,
+	128405,
+	128406,
+	128420,
+	128420,
+	128507,
+	128591,
+	128640,
+	128709,
+	128716,
+	128716,
+	128720,
+	128722,
+	128725,
+	128728,
+	128732,
+	128735,
+	128747,
+	128748,
+	128756,
+	128764,
+	128992,
+	129003,
+	129008,
+	129008,
+	129292,
+	129338,
+	129340,
+	129349,
+	129351,
+	129535,
+	129648,
+	129660,
+	129664,
+	129674,
+	129678,
+	129734,
+	129736,
+	129736,
+	129741,
+	129756,
+	129759,
+	129770,
+	129775,
+	129784,
+	131072,
+	196605,
+	196608,
+	262141
+];
+const commonCjkCodePoint = 19968;
+const [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];
+}
+const isAmbiguous = (codePoint) => {
+	if (codePoint < 161 || codePoint > 1114109) return false;
+	return isInRange(ambiguousRanges, codePoint);
+};
+const isFullWidth = (codePoint) => {
+	if (codePoint < 12288 || codePoint > 65510) return false;
+	return isInRange(fullwidthRanges, codePoint);
+};
+const isHalfWidth = (codePoint) => {
+	if (codePoint < 8361 || codePoint > 65518) return false;
+	return isInRange(halfwidthRanges, codePoint);
+};
+const isNarrow = (codePoint) => {
+	if (codePoint < 32 || codePoint > 10630) return false;
+	return isInRange(narrowRanges, codePoint);
+};
+const isWide = (codePoint) => {
+	if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) return true;
+	if (codePoint < 4352 || codePoint > 262141) return false;
+	return isInRange(wideRanges, codePoint);
+};
+function getCategory(codePoint) {
+	if (isAmbiguous(codePoint)) return "ambiguous";
+	if (isFullWidth(codePoint)) return "fullwidth";
+	if (isHalfWidth(codePoint)) return "halfwidth";
+	if (isNarrow(codePoint)) return "narrow";
+	if (isWide(codePoint)) return "wide";
+	return "neutral";
+}
+function eastAsianWidthType(codePoint) {
+	return getCategory(codePoint);
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+	if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) return 2;
+	return 1;
+}
+function isFullwidthCodePoint(codePoint) {
+	if (!Number.isInteger(codePoint)) return false;
+	return isFullWidth(codePoint) || isWide(codePoint);
+}
+//#endregion
+//#region src/ansi/strip.ts
+function ansiRegex({ onlyFirst = false } = {}) {
+	return new RegExp(`(?:\\][^œ]*(?:|\\\\|œ))|[›][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]`, onlyFirst ? void 0 : "g");
+}
+const regex = ansiRegex();
+function stripAnsi(string) {
+	if (!string.includes("\x1B") && !string.includes("›")) return string;
+	return string.replace(regex, "");
+}
+//#endregion
+//#region src/ansi/string-width.ts
+const segmenter$2 = new Intl.Segmenter();
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Nonspacing_Mark}|\p{Enclosing_Mark}|\p{Surrogate})+$/v;
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Nonspacing_Mark}\p{Enclosing_Mark}\p{Surrogate}]+/v;
+const spacingMarkRegex = /\p{Spacing_Mark}/v;
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+const unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+const 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 !== void 0 && (codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388);
+}
+function isHangulVowelJamo(codePoint) {
+	return codePoint !== void 0 && (codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238);
+}
+function isHangulTrailingJamo(codePoint) {
+	return codePoint !== void 0 && (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 (/^[ -~]*$/.test(string)) return string.length;
+	let width = 0;
+	const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+	for (const { segment } of segmenter$2.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 !== void 0) {
+			width += hangulWidth;
+			continue;
+		}
+		const codePoint = visibleSegment.codePointAt(0);
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+		width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+	}
+	return width;
+}
+//#endregion
+//#region src/ansi/wrap.ts
+const ANSI_ESCAPE = "\x1B";
+const ANSI_ESCAPE_BELL = "\x07";
+const ANSI_CSI = "[";
+const ANSI_OSC = "]";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_SGR_RESET = 0;
+const ANSI_SGR_RESET_FOREGROUND = 39;
+const ANSI_SGR_RESET_BACKGROUND = 49;
+const ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
+const ANSI_SGR_FOREGROUND_EXTENDED = 38;
+const ANSI_SGR_BACKGROUND_EXTENDED = 48;
+const ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
+const ANSI_SGR_COLOR_MODE_RGB = 2;
+const ANSI_SGR_COLOR_MODE_256 = 5;
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;`;
+const ESCAPES$1 = /* @__PURE__ */ new Set([ANSI_ESCAPE, "›"]);
+const ESCAPE_CHARACTERS = [...ESCAPES$1].join("");
+const CSI_INTRODUCER = `(?:${ANSI_ESCAPE}\\${ANSI_CSI}|›)`;
+const CSI_PARAMETERS = "[0-?]*[ -/]*[@-~]";
+const SGR_PARAMETERS = `(?<sgr>[0-9;:]*)${ANSI_SGR_TERMINATOR}`;
+const OSC_STRING_TERMINATOR = `(?:${ANSI_ESCAPE_BELL}|${ANSI_ESCAPE}\\\\)`;
+const OSC_STRING_PAYLOAD = String.raw`[^\u0000-\u001F\u007F-\u009F]*`;
+const LINK_PARAMETERS = String.raw`8;(?<parameters>[^;\u0000-\u001F\u007F-\u009F]*);(?<uri>${OSC_STRING_PAYLOAD})${OSC_STRING_TERMINATOR}`;
+const OSC_STRING = `${OSC_STRING_PAYLOAD}${OSC_STRING_TERMINATOR}`;
+const ANSI_ESCAPE_REGEX = new RegExp(`${CSI_INTRODUCER}(?:${SGR_PARAMETERS}|${CSI_PARAMETERS})|${ANSI_ESCAPE}\\${ANSI_OSC}(?:${LINK_PARAMETERS}|${OSC_STRING})`, "y");
+const ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(codes.values());
+ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
+const segmenter$1 = new Intl.Segmenter();
+const getStringWidth = (string) => stringWidth(string, { countAnsiEscapeCodes: true });
+const TAB_SIZE = 8;
+const ESCAPE_INTRODUCER_REGEX = new RegExp(`[${ESCAPE_CHARACTERS}]`, "g");
+const ROW_BOUNDARY_REGEX = new RegExp(`[\\n${ESCAPE_CHARACTERS}]`, "g");
+const ASCII_PRINTABLE_REGEX = /^[ -~]*$/;
+const wrapAnsiCode = (code) => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url, parameters = "") => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${parameters};${url}${ANSI_ESCAPE_BELL}`;
+const matchAnsiEscape = (string, index) => {
+	if (!ESCAPES$1.has(string[index])) return;
+	ANSI_ESCAPE_REGEX.lastIndex = index;
+	return ANSI_ESCAPE_REGEX.exec(string) ?? void 0;
+};
+const forEachSegment = (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));
+};
+const getWidth = (string) => {
+	let plainText = "";
+	forEachSegment(string, (part) => {
+		plainText += part;
+	});
+	return getStringWidth(plainText);
+};
+const getTokens = (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 segmenter$1.segment(plainText)) tokens.push({
+			value: segment,
+			width: getStringWidth(segment)
+		});
+	}, (escape) => {
+		tokens.push({
+			value: escape,
+			width: 0
+		});
+	});
+	return tokens;
+};
+const splitWords = (string) => {
+	let currentWord = {
+		value: "",
+		plainText: "",
+		width: 0
+	};
+	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],
+				width: 0
+			};
+			words.push(currentWord);
+		}
+	}, (escape) => {
+		currentWord.value += escape;
+	});
+	for (const word of words) word.width = getStringWidth(word.plainText);
+	return words;
+};
+const getColonColorToken = (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
+	};
+};
+const getSgrTokens = (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;
+};
+const removeActiveStyle = (activeStyles, family) => {
+	const activeStyleIndex = activeStyles.findIndex((activeStyle) => activeStyle.family === family);
+	if (activeStyleIndex !== -1) activeStyles.splice(activeStyleIndex, 1);
+};
+const upsertActiveStyle = (activeStyles, nextActiveStyle) => {
+	removeActiveStyle(activeStyles, nextActiveStyle.family);
+	activeStyles.push(nextActiveStyle);
+};
+const removeModifierStylesByClose = (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);
+	}
+};
+const getColorStyle = (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
+	};
+};
+const applySgrResetCode = (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;
+};
+const applySgrToken = (sgrToken, activeStyles) => {
+	const { code } = sgrToken;
+	if (applySgrResetCode(code, activeStyles)) return;
+	const colorStyle = getColorStyle(sgrToken);
+	if (colorStyle) {
+		upsertActiveStyle(activeStyles, colorStyle);
+		return;
+	}
+	const close = codes.get(code);
+	if (close !== void 0 && close !== ANSI_SGR_RESET) upsertActiveStyle(activeStyles, {
+		family: `modifier-${code}`,
+		open: sgrToken.open,
+		close
+	});
+};
+const applySgrParameters = (sgrParameters, activeStyles) => {
+	for (const sgrToken of getSgrTokens(sgrParameters)) applySgrToken(sgrToken, activeStyles);
+};
+const applySgrResets = (sgrParameters, activeStyles) => {
+	for (const { code } of getSgrTokens(sgrParameters)) applySgrResetCode(code, activeStyles);
+};
+const applyLeadingSgrResets = (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;
+	}
+};
+const getClosingSgrSequence = (activeStyles) => [...activeStyles].reverse().map((activeStyle) => wrapAnsiCode(activeStyle.close)).join("");
+const getOpeningSgrSequence = (activeStyles) => activeStyles.map((activeStyle) => wrapAnsiCode(activeStyle.open)).join("");
+const wrapWord = (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) {
+		const lastRow = rows.pop();
+		rows[rows.length - 1] = rows[rows.length - 1] + lastRow;
+	}
+	return getWidth(rows.at(-1));
+};
+const stringVisibleTrimSpacesRight = (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("");
+};
+const expandTabs = (line) => {
+	if (!line.includes("	")) return line;
+	let visible = 0;
+	let expandedLine = "";
+	let plainTextSinceTab = "";
+	const expandPlainText = (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;
+			}
+		}
+	};
+	forEachSegment(line, expandPlainText, (escape) => {
+		expandedLine += escape;
+	});
+	return expandedLine;
+};
+const restoreStylesAcrossRows = (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.groups ?? {};
+			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);
+};
+const exec = (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);
+			if (Math.floor((word.width - 1) / columns) < 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"));
+};
+function wrapAnsi(string, columns, options) {
+	return string.normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
+}
+//#endregion
+//#region src/signal-exit.ts
+const signals = process.platform === "win32" ? [
+	"SIGHUP",
+	"SIGINT",
+	"SIGTERM",
+	"SIGBREAK"
+] : [
+	"SIGHUP",
+	"SIGINT",
+	"SIGTERM",
+	"SIGQUIT",
+	"SIGUSR2"
+];
+const registrations = /* @__PURE__ */ new Set();
+const signalListeners = /* @__PURE__ */ new Map();
+let loaded = false;
+let emitted = false;
+const emitExit = (code, signal) => {
+	if (emitted) return;
+	emitted = true;
+	const ordered = [...registrations].toSorted((a, b) => Number(a.alwaysLast) - Number(b.alwaysLast));
+	for (const registration of ordered) registration.handler(code, signal);
+};
+const onExitEvent = (code) => {
+	emitExit(code, null);
+};
+const unload = () => {
+	if (!loaded) return;
+	loaded = false;
+	process.off("exit", onExitEvent);
+	for (const [signal, listener] of signalListeners) process.off(signal, listener);
+	signalListeners.clear();
+};
+const load = () => {
+	if (loaded) return;
+	loaded = true;
+	process.on("exit", onExitEvent);
+	for (const signal of signals) {
+		const listener = () => {
+			if (process.listenerCount(signal) === 1) {
+				unload();
+				emitExit(null, signal);
+				process.kill(process.pid, signal);
+			}
+		};
+		try {
+			process.on(signal, listener);
+			signalListeners.set(signal, listener);
+		} catch {}
+	}
+};
+const signalExit = (handler, options = {}) => {
+	const registration = {
+		handler,
+		alwaysLast: options.alwaysLast ?? false
+	};
+	registrations.add(registration);
+	load();
+	return () => {
+		registrations.delete(registration);
+		if (registrations.size === 0) unload();
+	};
+};
+//#endregion
+//#region src/ansi/cursor.ts
+let restoreRegistered = false;
+const registerRestore = () => {
+	if (restoreRegistered) return;
+	restoreRegistered = true;
+	signalExit(() => {
+		process.stderr.write(cursorShow);
+	}, { alwaysLast: true });
+};
+const cliCursor = {
+	show(writableStream = process.stderr) {
+		if (!writableStream.isTTY) return;
+		writableStream.write(cursorShow);
+	},
+	hide(writableStream = process.stderr) {
+		if (!writableStream.isTTY) return;
+		registerRestore();
+		writableStream.write(cursorHide);
+	}
+};
+//#endregion
+//#region src/ansi/supports-color.ts
+function hasFlag(flag, argv = process.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = process;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+	if (!("FORCE_COLOR" in env)) return;
+	if (env["FORCE_COLOR"] === "true") return 1;
+	if (env["FORCE_COLOR"] === "false") return 0;
+	return env["FORCE_COLOR"].length === 0 ? 1 : Math.min(Number.parseInt(env["FORCE_COLOR"], 10), 3);
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function supportsColorLevel(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor ?? 0;
+	if (env["TERM"] === "dumb") return min;
+	if (process.platform === "win32") {
+		const osRelease = os.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env["CI_NAME"] === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env["TEAMCITY_VERSION"]) ? 1 : 0;
+	if (env["COLORTERM"] === "truecolor") return 3;
+	if (env["TERM"] === "xterm-kitty") return 3;
+	if (env["TERM"] === "xterm-ghostty") return 3;
+	if (env["TERM"] === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env["TERM_PROGRAM_VERSION"] ?? "").split(".")[0], 10);
+		switch (env["TERM_PROGRAM"]) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env["TERM"] ?? "")) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env["TERM"] ?? "")) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(supportsColorLevel(Boolean(stream), {
+		streamIsTTY: Boolean(stream?.isTTY),
+		...options
+	}));
+}
+const supportsColor = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+//#endregion
+//#region src/ansi/chalk.ts
+const { stdout: stdoutColor } = supportsColor;
+const levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+const state = { level: stdoutColor ? stdoutColor.level : 0 };
+const stringReplaceAll = (string, substring, replacer) => {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+};
+const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+};
+const applyStyle = (open, close, text) => {
+	if (state.level <= 0 || !text) return text;
+	let string = text;
+	if (string.includes("\x1B")) string = stringReplaceAll(string, close, open);
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, close, open, lfIndex);
+	return open + string + close;
+};
+const styleFunction = (open, close) => {
+	return (text) => applyStyle(open, close, text);
+};
+const foregroundOpen = (model, args) => {
+	return colorOpen(model, args, foreground, rgbToAnsi256, rgbToAnsi);
+};
+const backgroundOpen = (model, args) => {
+	return colorOpen(model, args, background, rgbToAnsi256, rgbToAnsi);
+};
+const colorOpen = (model, args, space, toAnsi256, toAnsi) => {
+	const rgb = typeof args[0] === "string" ? hexToRgb(args[0]) : args;
+	if (model === "ansi16m") return space.ansi16m(...rgb);
+	if (model === "ansi256") return space.ansi256(toAnsi256(...rgb));
+	return space.ansi(toAnsi(...rgb));
+};
+const named = {};
+for (const name of [
+	...modifierNames,
+	...foregroundColorNames,
+	...backgroundColorNames
+]) named[name] = styleFunction(styles[name].open, styles[name].close);
+const chalk = {
+	...named,
+	get level() {
+		return state.level;
+	},
+	set level(level) {
+		state.level = level;
+	},
+	hex: (color) => styleFunction(foregroundOpen(levelMapping[state.level], [color]), foreground.close),
+	bgHex: (color) => styleFunction(backgroundOpen(levelMapping[state.level], [color]), background.close),
+	rgb: (red, green, blue) => styleFunction(foregroundOpen(levelMapping[state.level], [
+		red,
+		green,
+		blue
+	]), foreground.close),
+	bgRgb: (red, green, blue) => styleFunction(backgroundOpen(levelMapping[state.level], [
+		red,
+		green,
+		blue
+	]), background.close),
+	ansi256: (code) => styleFunction(foreground.ansi256(code), foreground.close),
+	bgAnsi256: (code) => styleFunction(background.ansi256(code), background.close)
+};
+//#endregion
+//#region src/ansi/widest-line.ts
+const widestLine = (string) => {
+	let lineWidth = 0;
+	for (const line of string.split("\n")) lineWidth = Math.max(lineWidth, stringWidth(line));
+	return lineWidth;
+};
+//#endregion
+//#region src/ansi/tokenize.ts
+const BACKSLASH = "\\";
+const CSI = "[";
+const OSC = "]";
+const CC_BEL = "\x07".charCodeAt(0);
+const CC_ESC = "\x1B".charCodeAt(0);
+const CC_BACKSLASH = BACKSLASH.charCodeAt(0);
+const CC_CSI = CSI.charCodeAt(0);
+const CC_OSC = OSC.charCodeAt(0);
+const CC_C1_ST = "œ".charCodeAt(0);
+const CC_0 = "0".charCodeAt(0);
+const CC_9 = "9".charCodeAt(0);
+const CC_SEMI = ";".charCodeAt(0);
+const CC_M = "m".charCodeAt(0);
+const ESCAPES = /* @__PURE__ */ new Set([CC_ESC, 155]);
+const linkCodePrefix = `${OSC}8;`;
+const linkCodePrefixCharCodes = linkCodePrefix.split("").map((char) => char.charCodeAt(0));
+const linkCodeSuffix = "\x07";
+const linkEndCode = `${OSC}8;;`;
+const linkEndCodeST = `${OSC}8;;${BACKSLASH}`;
+const linkEndCodeC1ST = `${OSC}8;;œ`;
+const endCodesSet = /* @__PURE__ */ new Set();
+const endCodesMap = /* @__PURE__ */ new Map();
+for (const [start, end] of codes) {
+	endCodesSet.add(foreground.ansi(end));
+	endCodesMap.set(foreground.ansi(start), foreground.ansi(end));
+}
+function getLinkStartCode(url, params) {
+	const paramsString = params ? Object.entries(params).map(([key, value]) => `${key}=${value}`).join(":") : "";
+	return `${linkCodePrefix}${paramsString};${url}${linkCodeSuffix}`;
+}
+function getEndCode(code) {
+	if (endCodesSet.has(code)) return code;
+	if (endCodesMap.has(code)) return endCodesMap.get(code);
+	if (code.startsWith(linkCodePrefix)) {
+		if (code.endsWith(`${BACKSLASH}`)) return linkEndCodeST;
+		if (code.endsWith("œ")) return linkEndCodeC1ST;
+		return linkEndCode;
+	}
+	code = code.slice(2);
+	if (code.startsWith("38")) return foreground.close;
+	if (code.startsWith("48")) return background.close;
+	const endCode = codes.get(Number.parseInt(code, 10));
+	if (endCode !== void 0) return foreground.ansi(endCode);
+	return styles.reset.open;
+}
+function ansiCodesToString(codes) {
+	return [...new Set(codes.map((code) => code.code))].join("");
+}
+/**
+Check if a code is an intensity code (bold or dim) — these share the end code
+`22m` but can coexist.
+*/
+function isIntensityCode(code) {
+	return code.code === styles.bold.open || code.code === styles.dim.open;
+}
+const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function isFullwidthGrapheme(grapheme, baseCodePoint) {
+	if (isFullwidthCodePoint(baseCodePoint)) return true;
+	if (grapheme.includes("️")) return true;
+	if (baseCodePoint >= 127462 && baseCodePoint <= 127487) return true;
+	return false;
+}
+function parseLinkCode(string, offset) {
+	string = string.slice(offset);
+	for (let index = 1; index < linkCodePrefixCharCodes.length; index++) if (string.charCodeAt(index) !== linkCodePrefixCharCodes[index]) return;
+	const paramsEndIndex = string.indexOf(";", linkCodePrefix.length);
+	if (paramsEndIndex === -1) return;
+	const endIndex = findOscTerminatorIndex(string, paramsEndIndex + 1);
+	if (endIndex === -1) return;
+	return string.slice(0, endIndex + 1);
+}
+function parseOscSequence(string, offset) {
+	string = string.slice(offset);
+	const endIndex = findOscTerminatorIndex(string, 2);
+	if (endIndex === -1) return;
+	return string.slice(0, endIndex + 1);
+}
+/**
+Finds the index of the last character of the first OSC terminator at or after
+`startIndex`. Recognizes BEL (\u0007), C1 ST (\u009C), and ESC+backslash.
+Returns -1 if no terminator is found.
+*/
+function findOscTerminatorIndex(string, startIndex) {
+	for (let index = startIndex; index < string.length; index++) {
+		const charCode = string.charCodeAt(index);
+		if (charCode === CC_BEL) return index;
+		if (charCode === CC_C1_ST) return index;
+		if (charCode === CC_ESC && index + 1 < string.length && string.charCodeAt(index + 1) === CC_BACKSLASH) return index + 1;
+	}
+	return -1;
+}
+/**
+Scans through the given string and finds the index of the last character of an
+SGR sequence like `\u001B[38;2;123;123;123m`. This assumes that the string has
+been checked to start with `\u001B[`. Returns -1 if no valid SGR sequence is
+found.
+*/
+function findSgrSequenceEndIndex(string) {
+	for (let index = 2; index < string.length; index++) {
+		const charCode = string.charCodeAt(index);
+		if (charCode === CC_M) return index;
+		if (charCode === CC_SEMI) continue;
+		if (charCode >= CC_0 && charCode <= CC_9) continue;
+		break;
+	}
+	return -1;
+}
+function parseSgrSequence(string, offset) {
+	string = string.slice(offset);
+	const endIndex = findSgrSequenceEndIndex(string);
+	if (endIndex === -1) return;
+	return string.slice(0, endIndex + 1);
+}
+/**
+Splits compound SGR sequences like `\u001B[1;3;31m` into individual components.
+*/
+function splitCompoundSgrSequences(code) {
+	if (!code.includes(";")) return [code];
+	const codeParts = code.slice(2, -1).split(";");
+	const result = [];
+	for (let index = 0; index < codeParts.length; index++) {
+		const rawCode = codeParts[index];
+		if (rawCode === "38" || rawCode === "48") {
+			if (index + 2 < codeParts.length && codeParts[index + 1] === "5") {
+				result.push(codeParts.slice(index, index + 3).join(";"));
+				index += 2;
+				continue;
+			} else if (index + 4 < codeParts.length && codeParts[index + 1] === "2") {
+				result.push(codeParts.slice(index, index + 5).join(";"));
+				index += 4;
+				continue;
+			}
+		}
+		result.push(rawCode);
+	}
+	return result.map((part) => `[${part}m`);
+}
+function tokenize(string, endChar = Number.POSITIVE_INFINITY) {
+	const result = [];
+	let visible = 0;
+	let codeEndIndex = 0;
+	for (const { segment, index } of segmenter.segment(string)) {
+		if (index < codeEndIndex) continue;
+		const codePoint = segment.codePointAt(0);
+		if (ESCAPES.has(codePoint)) {
+			let code;
+			const nextCodePoint = string.codePointAt(index + 1);
+			if (nextCodePoint === CC_OSC) {
+				code = parseLinkCode(string, index);
+				if (code) result.push({
+					type: "ansi",
+					code,
+					endCode: getEndCode(code)
+				});
+				else {
+					code = parseOscSequence(string, index);
+					if (code) result.push({
+						type: "control",
+						code
+					});
+				}
+			} else if (nextCodePoint === CC_CSI) {
+				code = parseSgrSequence(string, index);
+				if (code) for (const individualCode of splitCompoundSgrSequences(code)) result.push({
+					type: "ansi",
+					code: individualCode,
+					endCode: getEndCode(individualCode)
+				});
+			}
+			if (code) {
+				codeEndIndex = index + code.length;
+				continue;
+			}
+		}
+		const fullWidth = isFullwidthGrapheme(segment, codePoint);
+		result.push({
+			type: "char",
+			value: segment,
+			fullWidth
+		});
+		visible += fullWidth ? 2 : 1;
+		if (visible >= endChar) break;
+	}
+	return result;
+}
+/**
+Reduces the given array of ANSI codes to the minimum necessary to render with
+the same style.
+*/
+function reduceAnsiCodes(codes) {
+	return reduceAnsiCodesIncremental([], codes);
+}
+/**
+Like {@link reduceAnsiCodes}, but assumes that `codes` is already reduced.
+Further reductions are only done for the items in `newCodes`.
+*/
+function reduceAnsiCodesIncremental(codes, newCodes) {
+	let result = [...codes];
+	for (const code of newCodes) if (code.code === styles.reset.open) result = [];
+	else if (endCodesSet.has(code.code)) result = result.filter((existing) => existing.endCode !== code.code);
+	else if (isIntensityCode(code)) {
+		if (!result.some((existing) => existing.code === code.code && existing.endCode === code.endCode)) result.push(code);
+	} else {
+		result = result.filter((existing) => existing.endCode !== code.endCode);
+		result.push(code);
+	}
+	return result;
+}
+/**
+Returns the combination of ANSI codes needed to undo the given ANSI codes.
+*/
+function undoAnsiCodes(codes) {
+	return reduceAnsiCodes(codes).reverse().map((code) => ({
+		...code,
+		code: code.endCode
+	}));
+}
+/**
+Returns the minimum amount of ANSI codes necessary to get from the compound
+style `from` to `to`. Both are expected to be reduced.
+*/
+function diffAnsiCodes(from, to) {
+	const endCodesInTo = new Set(to.map((code) => code.endCode));
+	const startCodesInTo = new Set(to.map((code) => code.code));
+	const startCodesInFrom = new Set(from.map((code) => code.code));
+	return [...undoAnsiCodes(from.filter((code) => {
+		if (isIntensityCode(code)) return !startCodesInTo.has(code.code);
+		return !endCodesInTo.has(code.endCode);
+	})), ...to.filter((code) => !startCodesInFrom.has(code.code))];
+}
+function styledCharsFromTokens(tokens) {
+	let codes = [];
+	const result = [];
+	for (const token of tokens) if (token.type === "ansi") codes = reduceAnsiCodesIncremental(codes, [token]);
+	else if (token.type === "char") result.push({
+		...token,
+		styles: [...codes]
+	});
+	return result;
+}
+function styledCharsToString(chars) {
+	let result = "";
+	for (let index = 0; index < chars.length; index++) {
+		const char = chars[index];
+		if (index === 0) result += ansiCodesToString(char.styles);
+		else result += ansiCodesToString(diffAnsiCodes(chars[index - 1].styles, char.styles));
+		result += char.value;
+		if (index === chars.length - 1) result += ansiCodesToString(diffAnsiCodes(char.styles, []));
+	}
+	return result;
+}
+//#endregion
+//#region src/ansi/slice.ts
+function sliceAnsi(string, start, end) {
+	const sliceEnd = end ?? Number.POSITIVE_INFINITY;
+	if (start >= sliceEnd || string === "") return "";
+	if (start === 0 && sliceEnd === Number.POSITIVE_INFINITY) return string;
+	const chars = styledCharsFromTokens(tokenize(string));
+	const included = [];
+	let column = 0;
+	for (const char of chars) {
+		const width = char.fullWidth ? 2 : 1;
+		if (column + width > sliceEnd) break;
+		if (column >= start) included.push(char);
+		column += width;
+	}
+	return styledCharsToString(included);
+}
+//#endregion
+//#region src/ansi/truncate.ts
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight = false) {
+	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;
+}
+const ANSI_ESC = 27;
+const ANSI_LEFT_BRACKET = 91;
+const ANSI_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 scan = index + 2;
+		while (scan < string.length && isSgrParameter(string.codePointAt(scan))) scan++;
+		if (scan < string.length && string.codePointAt(scan) === ANSI_LETTER_M) {
+			index = scan + 1;
+			continue;
+		}
+		break;
+	}
+	return index;
+}
+function trailingSgrSpanStartIndex(string) {
+	let start = string.length;
+	while (start > 1 && string.codePointAt(start - 1) === ANSI_LETTER_M) {
+		let scan = start - 2;
+		while (scan >= 0 && isSgrParameter(string.codePointAt(scan))) scan--;
+		if (scan >= 1 && string.codePointAt(scan - 1) === ANSI_ESC && string.codePointAt(scan) === ANSI_LEFT_BRACKET) {
+			start = scan - 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);
+}
+function cliTruncate(text, columns, options = {}) {
+	const { position = "end", space = false, preferTruncationOnSpace = false } = options;
+	let { truncationCharacter = "…" } = options;
+	if (columns < 1) return "";
+	const length = stringWidth(text);
+	if (length <= columns) return text;
+	if (columns === 1) return truncationCharacter;
+	if (position === "start") {
+		if (preferTruncationOnSpace) {
+			const right = sliceAnsi(text, getIndexOfNearestSpace(text, length - columns + stringWidth(truncationCharacter), true), length).trim();
+			return prependWithInheritedStyleFromStart(truncationCharacter, right);
+		}
+		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 (preferTruncationOnSpace) return appendWithInheritedStyleFromEnd(sliceAnsi(text, 0, getIndexOfNearestSpace(text, columns - stringWidth(truncationCharacter))), truncationCharacter);
+	if (space) truncationCharacter = ` ${truncationCharacter}`;
+	return appendWithInheritedStyleFromEnd(sliceAnsi(text, 0, columns - stringWidth(truncationCharacter)), truncationCharacter);
+}
+//#endregion
+export { hexToAnsi256 as $, fullwidthMinimalCodePoint as A, esu as At, narrowMaximumCodePoint as B, stripAnsi as C, disableBracketedPaste as Ct, eastAsianWidth as D, eraseLine as Dt, ambiguousRanges as E, eraseEndLine as Et, halfwidthRanges as F, pasteStart as Ft, wideRanges as G, narrowRanges as H, isAmbiguous as I, popKittyKeyboard as It, backgroundColorNames as J, ansi256ToAnsi as K, isFullWidth as L, pushKittyKeyboard as Lt, getCategory as M, kittyQuery as Mt, halfwidthMaximumCodePoint as N, link as Nt, eastAsianWidthType as O, eraseLines as Ot, halfwidthMinimalCodePoint as P, pasteEnd as Pt, hexToAnsi as Q, isFullwidthCodePoint as R, ansiRegex as S, cursorUp as St, ambiguousMinimalCodePoint as T, enterAlternativeScreen as Tt, wideMaximumCodePoint as U, narrowMinimalCodePoint as V, wideMinimalCodePoint as W, foreground as X, codes as Y, foregroundColorNames as Z, supportsColor as _, cursorHide as _t, endCodesSet as a, BEL as at, wrapAnsi as b, cursorShow as bt, isIntensityCode as c, CSI$1 as ct, styledCharsFromTokens as d, OSC$1 as dt, hexToRgb as et, styledCharsToString as f, ST as ft, chalk as g, cursorDown as gt, widestLine as h, clearTerminal as ht, diffAnsiCodes as i, styles as it, fullwidthRanges as j, exitAlternativeScreen as jt, fullwidthMaximumCodePoint as k, eraseScreen as kt, reduceAnsiCodes as l, DEL as lt, undoAnsiCodes as m, bsu as mt, sliceAnsi as n, rgbToAnsi as nt, getEndCode as o, C1_CSI as ot, tokenize as p, ansiEscapes as pt, background as q, ansiCodesToString as r, rgbToAnsi256 as rt, getLinkStartCode as s, C1_ST as st, cliTruncate as t, modifierNames as tt, reduceAnsiCodesIncremental as u, ESC as ut, cliCursor as v, cursorLeft as vt, ambiguousMaximumCodePoint as w, enableBracketedPaste as wt, stringWidth as x, cursorTo as xt, signalExit as y, cursorNextLine as yt, isWide as z };