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

package/dist/tokenize-AjqbvtiT.js

@@ -0,0 +1,1242 @@
+import { a as foreground, i as codes, n as background, p as styles } from "./sgr-BhwaWAJB.js";
+//#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;
+}
+/**
+Grapheme-cluster width test shared by the tokenizer (slice/clip path): the
+base code point's East Asian Width, plus emoji presentation rules.
+*/
+function isFullwidthGrapheme(grapheme, baseCodePoint) {
+	if (isFullwidthCodePoint(baseCodePoint)) return true;
+	if (grapheme.includes("️")) return true;
+	if (baseCodePoint >= 127462 && baseCodePoint <= 127487) return true;
+	return false;
+}
+/**
+Wide code points not covered by string-width's CJKT script regex or emoji
+regex — the fallback bucket of its block parser. A disjoint decomposition of
+the `wide` table above, kept alongside it so the width data lives in one
+module.
+*/
+const isWideNotCJKTNotEmoji = (x) => {
+	return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+function isFullwidthCodePoint(codePoint) {
+	if (!Number.isInteger(codePoint)) return false;
+	return isFullWidth(codePoint) || isWide(codePoint);
+}
+//#endregion
+//#region src/ansi-tokenizer.ts
+const bellCharacter = "\x07";
+const escapeCharacter = "\x1B";
+const stringTerminatorCharacter = "œ";
+const csiCharacter = "›";
+const oscCharacter = "";
+const dcsCharacter = "";
+const pmCharacter = "ž";
+const apcCharacter = "Ÿ";
+const sosCharacter = "˜";
+const isCsiParameterCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 63;
+};
+const isCsiIntermediateCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isCsiFinalCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 64 && codePoint <= 126;
+};
+const isEscapeIntermediateCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isEscapeFinalCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 126;
+};
+const isC1ControlCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 128 && codePoint <= 159;
+};
+const readCsiSequence = (text, fromIndex) => {
+	let index = fromIndex;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isCsiParameterCharacter(character)) break;
+		index++;
+	}
+	const parameterString = text.slice(fromIndex, index);
+	const intermediateStartIndex = index;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isCsiIntermediateCharacter(character)) break;
+		index++;
+	}
+	const intermediateString = text.slice(intermediateStartIndex, index);
+	const finalCharacter = text[index];
+	if (finalCharacter === void 0 || !isCsiFinalCharacter(finalCharacter)) return;
+	return {
+		endIndex: index + 1,
+		parameterString,
+		intermediateString,
+		finalCharacter
+	};
+};
+const findControlStringTerminatorIndex = (text, fromIndex, allowBellTerminator) => {
+	for (let index = fromIndex; index < text.length; index++) {
+		const character = text[index];
+		if (allowBellTerminator && character === bellCharacter) return index + 1;
+		if (character === stringTerminatorCharacter) return index + 1;
+		if (character === escapeCharacter) {
+			const followingCharacter = text[index + 1];
+			if (followingCharacter === escapeCharacter) {
+				index++;
+				continue;
+			}
+			if (followingCharacter === "\\") return index + 2;
+		}
+	}
+};
+const readEscapeSequence = (text, fromIndex) => {
+	let index = fromIndex;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isEscapeIntermediateCharacter(character)) break;
+		index++;
+	}
+	const intermediateString = text.slice(fromIndex, index);
+	const finalCharacter = text[index];
+	if (finalCharacter === void 0 || !isEscapeFinalCharacter(finalCharacter)) return;
+	return {
+		endIndex: index + 1,
+		intermediateString,
+		finalCharacter
+	};
+};
+const getControlStringFromEscapeIntroducer = (character) => {
+	switch (character) {
+		case "]": return {
+			type: "osc",
+			allowBellTerminator: true
+		};
+		case "P": return {
+			type: "dcs",
+			allowBellTerminator: false
+		};
+		case "^": return {
+			type: "pm",
+			allowBellTerminator: false
+		};
+		case "_": return {
+			type: "apc",
+			allowBellTerminator: false
+		};
+		case "X": return {
+			type: "sos",
+			allowBellTerminator: false
+		};
+		default: return;
+	}
+};
+const getControlStringFromC1Introducer = (character) => {
+	switch (character) {
+		case oscCharacter: return {
+			type: "osc",
+			allowBellTerminator: true
+		};
+		case dcsCharacter: return {
+			type: "dcs",
+			allowBellTerminator: false
+		};
+		case pmCharacter: return {
+			type: "pm",
+			allowBellTerminator: false
+		};
+		case apcCharacter: return {
+			type: "apc",
+			allowBellTerminator: false
+		};
+		case sosCharacter: return {
+			type: "sos",
+			allowBellTerminator: false
+		};
+		default: return;
+	}
+};
+const hasAnsiControlCharacters = (text) => {
+	if (text.includes(escapeCharacter)) return true;
+	for (const character of text) if (isC1ControlCharacter(character)) return true;
+	return false;
+};
+const malformedFromIndex = (tokens, text, textStartIndex, fromIndex) => {
+	if (fromIndex > textStartIndex) tokens.push({
+		type: "text",
+		value: text.slice(textStartIndex, fromIndex)
+	});
+	tokens.push({
+		type: "invalid",
+		value: text.slice(fromIndex)
+	});
+	return tokens;
+};
+const tokenizeAnsi = (text) => {
+	if (!hasAnsiControlCharacters(text)) return [{
+		type: "text",
+		value: text
+	}];
+	const tokens = [];
+	let textStartIndex = 0;
+	for (let index = 0; index < text.length;) {
+		const character = text[index];
+		if (character === void 0) break;
+		if (character === escapeCharacter) {
+			const followingCharacter = text[index + 1];
+			if (followingCharacter === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (followingCharacter === "[") {
+				const csiSequence = readCsiSequence(text, index + 2);
+				if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				tokens.push({
+					type: "csi",
+					value: text.slice(index, csiSequence.endIndex),
+					parameterString: csiSequence.parameterString,
+					intermediateString: csiSequence.intermediateString,
+					finalCharacter: csiSequence.finalCharacter
+				});
+				index = csiSequence.endIndex;
+				textStartIndex = index;
+				continue;
+			}
+			const escapeControlString = getControlStringFromEscapeIntroducer(followingCharacter);
+			if (escapeControlString !== void 0) {
+				const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 2, escapeControlString.allowBellTerminator);
+				if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				tokens.push({
+					type: escapeControlString.type,
+					value: text.slice(index, controlStringTerminatorIndex)
+				});
+				index = controlStringTerminatorIndex;
+				textStartIndex = index;
+				continue;
+			}
+			const escapeSequence = readEscapeSequence(text, index + 1);
+			if (escapeSequence === void 0) {
+				if (isEscapeIntermediateCharacter(followingCharacter)) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				index++;
+				textStartIndex = index;
+				continue;
+			}
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "esc",
+				value: text.slice(index, escapeSequence.endIndex),
+				intermediateString: escapeSequence.intermediateString,
+				finalCharacter: escapeSequence.finalCharacter
+			});
+			index = escapeSequence.endIndex;
+			textStartIndex = index;
+			continue;
+		}
+		if (character === csiCharacter) {
+			const csiSequence = readCsiSequence(text, index + 1);
+			if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "csi",
+				value: text.slice(index, csiSequence.endIndex),
+				parameterString: csiSequence.parameterString,
+				intermediateString: csiSequence.intermediateString,
+				finalCharacter: csiSequence.finalCharacter
+			});
+			index = csiSequence.endIndex;
+			textStartIndex = index;
+			continue;
+		}
+		const c1ControlString = getControlStringFromC1Introducer(character);
+		if (c1ControlString !== void 0) {
+			const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 1, c1ControlString.allowBellTerminator);
+			if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: c1ControlString.type,
+				value: text.slice(index, controlStringTerminatorIndex)
+			});
+			index = controlStringTerminatorIndex;
+			textStartIndex = index;
+			continue;
+		}
+		if (character === stringTerminatorCharacter) {
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "st",
+				value: character
+			});
+			index++;
+			textStartIndex = index;
+			continue;
+		}
+		if (isC1ControlCharacter(character)) {
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "c1",
+				value: character
+			});
+			index++;
+			textStartIndex = index;
+			continue;
+		}
+		index++;
+	}
+	if (textStartIndex < text.length) tokens.push({
+		type: "text",
+		value: text.slice(textStartIndex)
+	});
+	return tokens;
+};
+//#endregion
+//#region src/ansi/graphemes.ts
+const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/** The canonical grapheme segmentation service for measurement and rasterization. */
+function* graphemes(text) {
+	for (const { segment } of segmenter.segment(text)) yield segment;
+}
+//#endregion
+//#region src/ansi/tokenize.ts
+const BACKSLASH = "\\";
+const CSI = "[";
+const OSC = "]";
+const linkCodePrefix = `${OSC}8;`;
+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;
+	if (code.startsWith("58")) return ``;
+	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;
+}
+/**
+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" || rawCode === "58") {
+			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`);
+}
+const SGR_PARAMETERS_RE = /^[\d;:]*$/;
+const c1LinkCodePrefix = "8;";
+function tokenize(string, endChar = Number.POSITIVE_INFINITY) {
+	const result = [];
+	let visible = 0;
+	outer: for (const ansiToken of tokenizeAnsi(string)) {
+		if (ansiToken.type === "text") {
+			for (const segment of graphemes(ansiToken.value)) {
+				const fullWidth = isFullwidthGrapheme(segment, segment.codePointAt(0));
+				result.push({
+					type: "char",
+					value: segment,
+					fullWidth
+				});
+				visible += fullWidth ? 2 : 1;
+				if (visible >= endChar) break outer;
+			}
+			continue;
+		}
+		if (ansiToken.type === "csi") {
+			if (ansiToken.finalCharacter === "m" && ansiToken.intermediateString === "" && SGR_PARAMETERS_RE.test(ansiToken.parameterString)) {
+				const code = `${CSI}${ansiToken.parameterString}m`;
+				for (const individualCode of splitCompoundSgrSequences(code)) result.push({
+					type: "ansi",
+					code: individualCode,
+					endCode: getEndCode(individualCode)
+				});
+			} else result.push({
+				type: "control",
+				code: ansiToken.value
+			});
+			continue;
+		}
+		if (ansiToken.type === "osc") {
+			const { value } = ansiToken;
+			const prefix = value.startsWith(linkCodePrefix) ? linkCodePrefix : value.startsWith(c1LinkCodePrefix) ? c1LinkCodePrefix : void 0;
+			if (prefix !== void 0 && value.includes(";", prefix.length)) {
+				const code = prefix === linkCodePrefix ? value : `${linkCodePrefix}${value.slice(prefix.length)}`;
+				result.push({
+					type: "ansi",
+					code,
+					endCode: getEndCode(code)
+				});
+			} else result.push({
+				type: "control",
+				code: value
+			});
+			continue;
+		}
+		result.push({
+			type: "control",
+			code: ansiToken.value
+		});
+	}
+	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).toReversed().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
+export { isFullwidthCodePoint as A, fullwidthRanges as C, halfwidthRanges as D, halfwidthMinimalCodePoint as E, narrowMinimalCodePoint as F, narrowRanges as I, wideMaximumCodePoint as L, isWide as M, isWideNotCJKTNotEmoji as N, isAmbiguous as O, narrowMaximumCodePoint as P, wideMinimalCodePoint as R, fullwidthMinimalCodePoint as S, halfwidthMaximumCodePoint as T, ambiguousMinimalCodePoint as _, getLinkStartCode as a, eastAsianWidthType as b, reduceAnsiCodesIncremental as c, tokenize as d, undoAnsiCodes as f, ambiguousMaximumCodePoint as g, tokenizeAnsi as h, getEndCode as i, isFullwidthGrapheme as j, isFullWidth as k, styledCharsFromTokens as l, hasAnsiControlCharacters as m, diffAnsiCodes as n, isIntensityCode as o, graphemes as p, endCodesSet as r, reduceAnsiCodes as s, ansiCodesToString as t, styledCharsToString as u, ambiguousRanges as v, getCategory as w, fullwidthMaximumCodePoint as x, eastAsianWidth as y, wideRanges as z };