pi2dsh 0.2.0 → 0.3.1

package/dist/pi-tui-5CYLcj-_.mjs

@@ -0,0 +1,4512 @@
+
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+import { homedir } from "node:os";
+import { readdirSync, statSync } from "fs";
+import { basename as basename$1, dirname as dirname$1, join as join$1 } from "path";
+import { eastAsianWidth } from "get-east-asian-width";
+import { execSync } from "node:child_process";
+import { spawn } from "child_process";
+import { homedir as homedir$1 } from "os";
+import { Marked } from "marked";
+//#region src/compat/vendor/pi-tui-utils.ts
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+const wordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+/**
+* Get the shared grapheme segmenter instance.
+*/
+function getGraphemeSegmenter() {
+	return graphemeSegmenter;
+}
+/**
+* Get the shared word segmenter instance.
+*/
+function getWordSegmenter() {
+	return wordSegmenter;
+}
+/**
+* Check if a grapheme cluster (after segmentation) could possibly be an RGI emoji.
+* This is a fast heuristic to avoid the expensive rgiEmojiRegex test.
+* The tested Unicode blocks are deliberately broad to account for future
+* Unicode additions.
+*/
+function couldBeEmoji(segment) {
+	const cp = segment.codePointAt(0);
+	return cp >= 126976 && cp <= 130047 || cp >= 8960 && cp <= 9215 || cp >= 9728 && cp <= 10175 || cp >= 11088 && cp <= 11093 || segment.includes("️") || segment.length > 2;
+}
+const zeroWidthRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+const nonPrintingCharRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})$/v;
+const markCharRegex = /^\p{Mark}$/v;
+const terminalSpacingMarkRegex = /^(?:[\p{Spacing_Mark}--[\u1734\u302E\u302F]]|[\u065F\u0F7F\u102B\u102C\u1031\u1033-\u1035\u1038\u103A-\u103E])+$/v;
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+const WIDTH_CACHE_SIZE = 512;
+const widthCache = /* @__PURE__ */ new Map();
+const cjkBreakRegex = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+function isPrintableAscii(str) {
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code < 32 || code > 126) return false;
+	}
+	return true;
+}
+function truncateFragmentToWidth(text, maxWidth) {
+	if (maxWidth <= 0 || text.length === 0) return {
+		text: "",
+		width: 0
+	};
+	if (isPrintableAscii(text)) {
+		const clipped = text.slice(0, maxWidth);
+		return {
+			text: clipped,
+			width: clipped.length
+		};
+	}
+	const hasAnsi = text.includes("\x1B");
+	const hasTabs = text.includes("	");
+	if (!hasAnsi && !hasTabs) {
+		let result = "";
+		let width = 0;
+		for (const { segment } of graphemeSegmenter.segment(text)) {
+			const w = graphemeWidth(segment);
+			if (width + w > maxWidth) break;
+			result += segment;
+			width += w;
+		}
+		return {
+			text: result,
+			width
+		};
+	}
+	let result = "";
+	let width = 0;
+	let i = 0;
+	let pendingAnsi = "";
+	while (i < text.length) {
+		const ansi = extractAnsiCode(text, i);
+		if (ansi) {
+			pendingAnsi += ansi.code;
+			i += ansi.length;
+			continue;
+		}
+		if (text[i] === "	") {
+			if (width + 3 > maxWidth) break;
+			if (pendingAnsi) {
+				result += pendingAnsi;
+				pendingAnsi = "";
+			}
+			result += "	";
+			width += 3;
+			i++;
+			continue;
+		}
+		let end = i;
+		while (end < text.length && text[end] !== "	") {
+			if (extractAnsiCode(text, end)) break;
+			end++;
+		}
+		for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+			const w = graphemeWidth(segment);
+			if (width + w > maxWidth) return {
+				text: result,
+				width
+			};
+			if (pendingAnsi) {
+				result += pendingAnsi;
+				pendingAnsi = "";
+			}
+			result += segment;
+			width += w;
+		}
+		i = end;
+	}
+	return {
+		text: result,
+		width
+	};
+}
+function finalizeTruncatedResult(prefix, prefixWidth, ellipsis, ellipsisWidth, maxWidth, pad) {
+	const reset = "\x1B[0m";
+	const hyperlinkClose = getActiveOsc8Close(prefix);
+	const visibleWidth = prefixWidth + ellipsisWidth;
+	let result;
+	if (ellipsis.length > 0) result = `${prefix}${hyperlinkClose}${reset}${ellipsis}${reset}`;
+	else result = `${prefix}${hyperlinkClose}${reset}`;
+	return pad ? result + " ".repeat(Math.max(0, maxWidth - visibleWidth)) : result;
+}
+/**
+* Calculate the terminal width of a single grapheme cluster.
+* Based on code from the string-width library, but includes a possible-emoji
+* check to avoid running the RGI_Emoji regex unnecessarily.
+*/
+function graphemeWidth(segment) {
+	if (segment === "	") return 3;
+	if (terminalSpacingMarkRegex.test(segment)) return [...segment].length;
+	if (zeroWidthRegex.test(segment)) return 0;
+	if (couldBeEmoji(segment) && rgiEmojiRegex.test(segment)) return 2;
+	const base = segment.replace(leadingNonPrintingRegex, "");
+	const cp = base.codePointAt(0);
+	if (cp === void 0) return 0;
+	if (cp >= 127462 && cp <= 127487) return 2;
+	let width = eastAsianWidth(cp);
+	let followsMark = false;
+	const chars = [...base];
+	for (const char of chars.slice(1)) if (terminalSpacingMarkRegex.test(char)) {
+		width += 1;
+		followsMark = false;
+	} else if (markCharRegex.test(char)) followsMark = true;
+	else if (!nonPrintingCharRegex.test(char)) {
+		const c = char.codePointAt(0);
+		if (followsMark || c >= 65280 && c <= 65519) width += eastAsianWidth(c);
+		else if (c === 3635 || c === 3763) width += 1;
+		followsMark = false;
+	}
+	return width;
+}
+/**
+* Calculate the visible width of a string in terminal columns.
+*/
+function visibleWidth(str) {
+	if (str.length === 0) return 0;
+	if (isPrintableAscii(str)) return str.length;
+	const cached = widthCache.get(str);
+	if (cached !== void 0) return cached;
+	let clean = str;
+	if (str.includes("	")) clean = clean.replace(/\t/g, "   ");
+	if (clean.includes("\x1B")) {
+		let stripped = "";
+		let i = 0;
+		while (i < clean.length) {
+			const ansi = extractAnsiCode(clean, i);
+			if (ansi) {
+				i += ansi.length;
+				continue;
+			}
+			stripped += clean[i];
+			i++;
+		}
+		clean = stripped;
+	}
+	let width = 0;
+	for (const { segment } of graphemeSegmenter.segment(clean)) width += graphemeWidth(segment);
+	if (widthCache.size >= WIDTH_CACHE_SIZE) {
+		const firstKey = widthCache.keys().next().value;
+		if (firstKey !== void 0) widthCache.delete(firstKey);
+	}
+	widthCache.set(str, width);
+	return width;
+}
+/** Remove ANSI, OSC, and APC control sequences while preserving visible text. */
+function stripTerminalSequences(str) {
+	if (!str.includes("\x1B")) return str;
+	let result = "";
+	let i = 0;
+	while (i < str.length) {
+		const ansi = extractAnsiCode(str, i);
+		if (ansi) {
+			i += ansi.length;
+			continue;
+		}
+		result += str[i];
+		i++;
+	}
+	return result;
+}
+/** Return the terminal-cell range occupied by the grapheme at a visible column. */
+function getGraphemeCellRange(line, column) {
+	let currentCol = 0;
+	let i = 0;
+	while (i < line.length) {
+		const ansi = extractAnsiCode(line, i);
+		if (ansi) {
+			i += ansi.length;
+			continue;
+		}
+		let textEnd = i;
+		while (textEnd < line.length && !extractAnsiCode(line, textEnd)) textEnd++;
+		for (const { segment } of graphemeSegmenter.segment(line.slice(i, textEnd))) {
+			const width = graphemeWidth(segment);
+			if (width > 0 && column >= currentCol && column < currentCol + width) return {
+				start: currentCol,
+				end: currentCol + width
+			};
+			currentCol += width;
+		}
+		i = textEnd;
+	}
+}
+/** Return the OSC 8 hyperlink covering a visible terminal column. */
+function getOsc8LinkAtColumn(line, column) {
+	let activeUrl;
+	let currentCol = 0;
+	let i = 0;
+	while (i < line.length) {
+		const ansi = extractAnsiCode(line, i);
+		if (ansi) {
+			const hyperlink = /^\x1b\]8;[^;]*;([^\x07\x1b]*)(?:\x07|\x1b\\)$/.exec(ansi.code);
+			if (hyperlink) activeUrl = hyperlink[1] || void 0;
+			i += ansi.length;
+			continue;
+		}
+		let textEnd = i;
+		while (textEnd < line.length && !extractAnsiCode(line, textEnd)) textEnd++;
+		for (const { segment } of graphemeSegmenter.segment(line.slice(i, textEnd))) {
+			const width = segment === "	" ? 3 : graphemeWidth(segment);
+			if (column >= currentCol && column < currentCol + width) return activeUrl;
+			currentCol += width;
+		}
+		i = textEnd;
+	}
+}
+/**
+* Normalize text for terminal output without changing logical editor content.
+* Some terminals render precomposed Thai/Lao AM vowels inconsistently during
+* differential repaint. Their compatibility decompositions have the same cell
+* width but avoid stale-cell artifacts in terminal renderers. Visible tabs are
+* expanded to the fixed width used by layout so terminal tab stops cannot wrap
+* a logical line, while tabs inside terminal string sequences stay untouched.
+*/
+const THAI_LAO_AM_REGEX = /[\u0e33\u0eb3]/;
+const THAI_LAO_AM_GLOBAL_REGEX = /[\u0e33\u0eb3]/g;
+function normalizeTerminalOutput(str) {
+	let normalized = str;
+	if (THAI_LAO_AM_REGEX.test(normalized)) normalized = normalized.replace(THAI_LAO_AM_GLOBAL_REGEX, (char) => char === "ำ" ? "ํา" : "ໍາ");
+	if (!normalized.includes("	")) return normalized;
+	let result = "";
+	let i = 0;
+	while (i < normalized.length) {
+		const ansi = extractAnsiCode(normalized, i);
+		if (ansi) {
+			result += ansi.code;
+			i += ansi.length;
+			continue;
+		}
+		result += normalized[i] === "	" ? "   " : normalized[i];
+		i++;
+	}
+	return result;
+}
+/**
+* Extract ANSI escape sequences from a string at the given position.
+*/
+function extractAnsiCode(str, pos) {
+	if (pos >= str.length || str[pos] !== "\x1B") return null;
+	const next = str[pos + 1];
+	if (next === "[") {
+		let j = pos + 2;
+		while (j < str.length && !/[mGKHJ]/.test(str[j])) j++;
+		if (j < str.length) return {
+			code: str.substring(pos, j + 1),
+			length: j + 1 - pos
+		};
+		return null;
+	}
+	if (next === "]") {
+		let j = pos + 2;
+		while (j < str.length) {
+			if (str[j] === "\x07") return {
+				code: str.substring(pos, j + 1),
+				length: j + 1 - pos
+			};
+			if (str[j] === "\x1B" && str[j + 1] === "\\") return {
+				code: str.substring(pos, j + 2),
+				length: j + 2 - pos
+			};
+			j++;
+		}
+		return null;
+	}
+	if (next === "_") {
+		let j = pos + 2;
+		while (j < str.length) {
+			if (str[j] === "\x07") return {
+				code: str.substring(pos, j + 1),
+				length: j + 1 - pos
+			};
+			if (str[j] === "\x1B" && str[j + 1] === "\\") return {
+				code: str.substring(pos, j + 2),
+				length: j + 2 - pos
+			};
+			j++;
+		}
+		return null;
+	}
+	return null;
+}
+function parseOsc8Hyperlink(ansiCode) {
+	if (!ansiCode.startsWith("\x1B]8;")) return;
+	const terminator = ansiCode.endsWith("\x07") ? "\x07" : "\x1B\\";
+	const body = ansiCode.slice(4, terminator === "\x07" ? -1 : -2);
+	const separatorIndex = body.indexOf(";");
+	if (separatorIndex === -1) return;
+	const params = body.slice(0, separatorIndex);
+	const url = body.slice(separatorIndex + 1);
+	if (!url) return null;
+	return {
+		params,
+		url,
+		terminator
+	};
+}
+function formatOsc8Hyperlink(hyperlink) {
+	return `\x1b]8;${hyperlink.params};${hyperlink.url}${hyperlink.terminator}`;
+}
+function formatOsc8Close(terminator) {
+	return `\x1b]8;;${terminator}`;
+}
+function getActiveOsc8Close(prefix) {
+	if (!prefix.includes("\x1B]8;")) return "";
+	let activeHyperlink = null;
+	let i = 0;
+	while (i < prefix.length) {
+		const ansi = extractAnsiCode(prefix, i);
+		if (ansi) {
+			const hyperlink = parseOsc8Hyperlink(ansi.code);
+			if (hyperlink !== void 0) activeHyperlink = hyperlink;
+			i += ansi.length;
+		} else i++;
+	}
+	return activeHyperlink ? formatOsc8Close(activeHyperlink.terminator) : "";
+}
+/**
+* Track active ANSI SGR codes to preserve styling across line breaks.
+*/
+var AnsiCodeTracker = class {
+	bold = false;
+	dim = false;
+	italic = false;
+	underline = false;
+	blink = false;
+	inverse = false;
+	hidden = false;
+	strikethrough = false;
+	fgColor = null;
+	bgColor = null;
+	activeHyperlink = null;
+	process(ansiCode) {
+		const hyperlink = parseOsc8Hyperlink(ansiCode);
+		if (hyperlink !== void 0) {
+			this.activeHyperlink = hyperlink;
+			return;
+		}
+		if (!ansiCode.endsWith("m")) return;
+		const match = ansiCode.match(/\x1b\[([\d;]*)m/);
+		if (!match) return;
+		const params = match[1];
+		if (params === "" || params === "0") {
+			this.reset();
+			return;
+		}
+		const parts = params.split(";");
+		let i = 0;
+		while (i < parts.length) {
+			const code = Number.parseInt(parts[i], 10);
+			if (code === 38 || code === 48) {
+				if (parts[i + 1] === "5" && parts[i + 2] !== void 0) {
+					const colorCode = `${parts[i]};${parts[i + 1]};${parts[i + 2]}`;
+					if (code === 38) this.fgColor = colorCode;
+					else this.bgColor = colorCode;
+					i += 3;
+					continue;
+				} else if (parts[i + 1] === "2" && parts[i + 4] !== void 0) {
+					const colorCode = `${parts[i]};${parts[i + 1]};${parts[i + 2]};${parts[i + 3]};${parts[i + 4]}`;
+					if (code === 38) this.fgColor = colorCode;
+					else this.bgColor = colorCode;
+					i += 5;
+					continue;
+				}
+			}
+			switch (code) {
+				case 0:
+					this.reset();
+					break;
+				case 1:
+					this.bold = true;
+					break;
+				case 2:
+					this.dim = true;
+					break;
+				case 3:
+					this.italic = true;
+					break;
+				case 4:
+					this.underline = true;
+					break;
+				case 5:
+					this.blink = true;
+					break;
+				case 7:
+					this.inverse = true;
+					break;
+				case 8:
+					this.hidden = true;
+					break;
+				case 9:
+					this.strikethrough = true;
+					break;
+				case 21:
+					this.bold = false;
+					break;
+				case 22:
+					this.bold = false;
+					this.dim = false;
+					break;
+				case 23:
+					this.italic = false;
+					break;
+				case 24:
+					this.underline = false;
+					break;
+				case 25:
+					this.blink = false;
+					break;
+				case 27:
+					this.inverse = false;
+					break;
+				case 28:
+					this.hidden = false;
+					break;
+				case 29:
+					this.strikethrough = false;
+					break;
+				case 39:
+					this.fgColor = null;
+					break;
+				case 49:
+					this.bgColor = null;
+					break;
+				default: if (code >= 30 && code <= 37 || code >= 90 && code <= 97) this.fgColor = String(code);
+				else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) this.bgColor = String(code);
+			}
+			i++;
+		}
+	}
+	reset() {
+		this.bold = false;
+		this.dim = false;
+		this.italic = false;
+		this.underline = false;
+		this.blink = false;
+		this.inverse = false;
+		this.hidden = false;
+		this.strikethrough = false;
+		this.fgColor = null;
+		this.bgColor = null;
+	}
+	/** Clear all state for reuse. */
+	clear() {
+		this.reset();
+		this.activeHyperlink = null;
+	}
+	getActiveCodes() {
+		const codes = [];
+		if (this.bold) codes.push("1");
+		if (this.dim) codes.push("2");
+		if (this.italic) codes.push("3");
+		if (this.underline) codes.push("4");
+		if (this.blink) codes.push("5");
+		if (this.inverse) codes.push("7");
+		if (this.hidden) codes.push("8");
+		if (this.strikethrough) codes.push("9");
+		if (this.fgColor) codes.push(this.fgColor);
+		if (this.bgColor) codes.push(this.bgColor);
+		let result = codes.length > 0 ? `\x1b[${codes.join(";")}m` : "";
+		if (this.activeHyperlink) result += formatOsc8Hyperlink(this.activeHyperlink);
+		return result;
+	}
+	hasActiveCodes() {
+		return this.bold || this.dim || this.italic || this.underline || this.blink || this.inverse || this.hidden || this.strikethrough || this.fgColor !== null || this.bgColor !== null || this.activeHyperlink !== null;
+	}
+	/**
+	* Get reset codes for attributes that need to be turned off at line end.
+	* Underline must be closed to prevent bleeding into padding.
+	* Active OSC 8 hyperlinks must be closed and re-opened on the next line.
+	* Returns empty string if no attributes need closing.
+	*/
+	getLineEndReset() {
+		let result = "";
+		if (this.underline) result += "\x1B[24m";
+		if (this.activeHyperlink) result += formatOsc8Close(this.activeHyperlink.terminator);
+		return result;
+	}
+};
+function updateTrackerFromText(text, tracker) {
+	let i = 0;
+	while (i < text.length) {
+		const ansiResult = extractAnsiCode(text, i);
+		if (ansiResult) {
+			tracker.process(ansiResult.code);
+			i += ansiResult.length;
+		} else i++;
+	}
+}
+/**
+* Split text into words while keeping ANSI codes attached.
+*/
+function splitIntoTokensWithAnsi(text) {
+	const tokens = [];
+	let current = "";
+	let pendingAnsi = "";
+	let currentKind = null;
+	let i = 0;
+	const flushCurrent = () => {
+		if (!current) return;
+		tokens.push(current);
+		current = "";
+		currentKind = null;
+	};
+	while (i < text.length) {
+		const ansiResult = extractAnsiCode(text, i);
+		if (ansiResult) {
+			pendingAnsi += ansiResult.code;
+			i += ansiResult.length;
+			continue;
+		}
+		let end = i;
+		while (end < text.length && !extractAnsiCode(text, end)) end++;
+		for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+			const segmentIsSpace = segment === " ";
+			if (!segmentIsSpace && cjkBreakRegex.test(segment)) {
+				flushCurrent();
+				const token = pendingAnsi + segment;
+				pendingAnsi = "";
+				tokens.push(token);
+				continue;
+			}
+			const segmentKind = segmentIsSpace ? "space" : "word";
+			if (current && currentKind !== segmentKind) flushCurrent();
+			if (pendingAnsi) {
+				current += pendingAnsi;
+				pendingAnsi = "";
+			}
+			currentKind = segmentKind;
+			current += segment;
+		}
+		i = end;
+	}
+	if (pendingAnsi) {
+		if (current) current += pendingAnsi;
+		else if (tokens.length > 0) tokens[tokens.length - 1] += pendingAnsi;
+		else current = pendingAnsi;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+}
+/**
+* Wrap text with ANSI codes preserved.
+*
+* ONLY does word wrapping - NO padding, NO background colors.
+* Returns lines where each line is <= width visible chars.
+* Active ANSI codes are preserved across line breaks.
+*
+* @param text - Text to wrap (may contain ANSI codes and newlines)
+* @param width - Maximum visible width per line
+* @returns Array of wrapped lines (NOT padded to width)
+*/
+function wrapTextWithAnsi(text, width) {
+	if (!text) return [""];
+	const inputLines = text.split(/\r\n|\r|\n/);
+	const result = [];
+	const tracker = new AnsiCodeTracker();
+	for (const inputLine of inputLines) {
+		const wrappedLines = wrapSingleLine((result.length > 0 ? tracker.getActiveCodes() : "") + inputLine, width);
+		for (const wrappedLine of wrappedLines) result.push(wrappedLine);
+		updateTrackerFromText(inputLine, tracker);
+	}
+	return result.length > 0 ? result : [""];
+}
+function wrapSingleLine(line, width) {
+	if (!line) return [""];
+	if (visibleWidth(line) <= width) return [line];
+	const wrapped = [];
+	const tracker = new AnsiCodeTracker();
+	const tokens = splitIntoTokensWithAnsi(line);
+	let currentLine = "";
+	let currentVisibleLength = 0;
+	for (const token of tokens) {
+		const tokenVisibleLength = visibleWidth(token);
+		const isWhitespace = token.trim() === "";
+		if (tokenVisibleLength > width && !isWhitespace) {
+			if (currentLine) {
+				const lineEndReset = tracker.getLineEndReset();
+				if (lineEndReset) currentLine += lineEndReset;
+				wrapped.push(currentLine);
+				currentLine = "";
+				currentVisibleLength = 0;
+			}
+			const broken = breakLongWord(token, width, tracker);
+			for (let i = 0; i < broken.length - 1; i++) wrapped.push(broken[i]);
+			currentLine = broken[broken.length - 1];
+			currentVisibleLength = visibleWidth(currentLine);
+			continue;
+		}
+		if (currentVisibleLength + tokenVisibleLength > width && currentVisibleLength > 0) {
+			let lineToWrap = currentLine.trimEnd();
+			const lineEndReset = tracker.getLineEndReset();
+			if (lineEndReset) lineToWrap += lineEndReset;
+			wrapped.push(lineToWrap);
+			if (isWhitespace) {
+				currentLine = tracker.getActiveCodes();
+				currentVisibleLength = 0;
+			} else {
+				currentLine = tracker.getActiveCodes() + token;
+				currentVisibleLength = tokenVisibleLength;
+			}
+		} else {
+			currentLine += token;
+			currentVisibleLength += tokenVisibleLength;
+		}
+		updateTrackerFromText(token, tracker);
+	}
+	if (currentLine) wrapped.push(currentLine);
+	return wrapped.length > 0 ? wrapped.map((line) => line.trimEnd()) : [""];
+}
+const PUNCTUATION_REGEX = /[(){}[\]<>.,;:'"!?+\-=*/\\|&%^$#@~`]/;
+/**
+* Check if a character is whitespace.
+*/
+function isWhitespaceChar(char) {
+	return /\s/.test(char);
+}
+/**
+* Check if a character is punctuation.
+*/
+function isPunctuationChar(char) {
+	return PUNCTUATION_REGEX.test(char);
+}
+function breakLongWord(word, width, tracker) {
+	const lines = [];
+	let currentLine = tracker.getActiveCodes();
+	let currentWidth = 0;
+	let i = 0;
+	const segments = [];
+	while (i < word.length) {
+		const ansiResult = extractAnsiCode(word, i);
+		if (ansiResult) {
+			segments.push({
+				type: "ansi",
+				value: ansiResult.code
+			});
+			i += ansiResult.length;
+		} else {
+			let end = i;
+			while (end < word.length) {
+				if (extractAnsiCode(word, end)) break;
+				end++;
+			}
+			const textPortion = word.slice(i, end);
+			for (const seg of graphemeSegmenter.segment(textPortion)) segments.push({
+				type: "grapheme",
+				value: seg.segment
+			});
+			i = end;
+		}
+	}
+	for (const seg of segments) {
+		if (seg.type === "ansi") {
+			currentLine += seg.value;
+			tracker.process(seg.value);
+			continue;
+		}
+		const grapheme = seg.value;
+		if (!grapheme) continue;
+		const graphemeWidth = visibleWidth(grapheme);
+		if (currentWidth + graphemeWidth > width) {
+			const lineEndReset = tracker.getLineEndReset();
+			if (lineEndReset) currentLine += lineEndReset;
+			lines.push(currentLine);
+			currentLine = tracker.getActiveCodes();
+			currentWidth = 0;
+		}
+		currentLine += grapheme;
+		currentWidth += graphemeWidth;
+	}
+	if (currentLine) lines.push(currentLine);
+	return lines.length > 0 ? lines : [""];
+}
+/**
+* Apply background color to a line, padding to full width.
+*
+* @param line - Line of text (may contain ANSI codes)
+* @param width - Total width to pad to
+* @param bgFn - Background color function
+* @returns Line with background applied and padded to width
+*/
+function applyBackgroundToLine(line, width, bgFn) {
+	const visibleLen = visibleWidth(line);
+	const paddingNeeded = Math.max(0, width - visibleLen);
+	return bgFn(line + " ".repeat(paddingNeeded));
+}
+/**
+* Truncate text to fit within a maximum visible width, adding ellipsis if needed.
+* Optionally pad with spaces to reach exactly maxWidth.
+* Properly handles ANSI escape codes (they don't count toward width).
+*
+* @param text - Text to truncate (may contain ANSI codes)
+* @param maxWidth - Maximum visible width
+* @param ellipsis - Ellipsis string to append when truncating (default: "...")
+* @param pad - If true, pad result with spaces to exactly maxWidth (default: false)
+* @returns Truncated text, optionally padded to exactly maxWidth
+*/
+function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
+	if (maxWidth <= 0) return "";
+	if (text.length === 0) return pad ? " ".repeat(maxWidth) : "";
+	const ellipsisWidth = visibleWidth(ellipsis);
+	if (ellipsisWidth >= maxWidth) {
+		const textWidth = visibleWidth(text);
+		if (textWidth <= maxWidth) return pad ? text + " ".repeat(maxWidth - textWidth) : text;
+		const clippedEllipsis = truncateFragmentToWidth(ellipsis, maxWidth);
+		if (clippedEllipsis.width === 0) return pad ? " ".repeat(maxWidth) : "";
+		return finalizeTruncatedResult("", 0, clippedEllipsis.text, clippedEllipsis.width, maxWidth, pad);
+	}
+	if (isPrintableAscii(text)) {
+		if (text.length <= maxWidth) return pad ? text + " ".repeat(maxWidth - text.length) : text;
+		const targetWidth = maxWidth - ellipsisWidth;
+		return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+	}
+	const targetWidth = maxWidth - ellipsisWidth;
+	let result = "";
+	let pendingAnsi = "";
+	let visibleSoFar = 0;
+	let keptWidth = 0;
+	let keepContiguousPrefix = true;
+	let overflowed = false;
+	let exhaustedInput = false;
+	const hasAnsi = text.includes("\x1B");
+	const hasTabs = text.includes("	");
+	if (!hasAnsi && !hasTabs) {
+		for (const { segment } of graphemeSegmenter.segment(text)) {
+			const width = graphemeWidth(segment);
+			if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+				result += segment;
+				keptWidth += width;
+			} else keepContiguousPrefix = false;
+			visibleSoFar += width;
+			if (visibleSoFar > maxWidth) {
+				overflowed = true;
+				break;
+			}
+		}
+		exhaustedInput = !overflowed;
+	} else {
+		let i = 0;
+		while (i < text.length) {
+			const ansi = extractAnsiCode(text, i);
+			if (ansi) {
+				pendingAnsi += ansi.code;
+				i += ansi.length;
+				continue;
+			}
+			if (text[i] === "	") {
+				if (keepContiguousPrefix && keptWidth + 3 <= targetWidth) {
+					if (pendingAnsi) {
+						result += pendingAnsi;
+						pendingAnsi = "";
+					}
+					result += "	";
+					keptWidth += 3;
+				} else {
+					keepContiguousPrefix = false;
+					pendingAnsi = "";
+				}
+				visibleSoFar += 3;
+				if (visibleSoFar > maxWidth) {
+					overflowed = true;
+					break;
+				}
+				i++;
+				continue;
+			}
+			let end = i;
+			while (end < text.length && text[end] !== "	") {
+				if (extractAnsiCode(text, end)) break;
+				end++;
+			}
+			for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+				const width = graphemeWidth(segment);
+				if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+					if (pendingAnsi) {
+						result += pendingAnsi;
+						pendingAnsi = "";
+					}
+					result += segment;
+					keptWidth += width;
+				} else {
+					keepContiguousPrefix = false;
+					pendingAnsi = "";
+				}
+				visibleSoFar += width;
+				if (visibleSoFar > maxWidth) {
+					overflowed = true;
+					break;
+				}
+			}
+			if (overflowed) break;
+			i = end;
+		}
+		exhaustedInput = i >= text.length;
+	}
+	if (!overflowed && exhaustedInput) return pad ? text + " ".repeat(Math.max(0, maxWidth - visibleSoFar)) : text;
+	return finalizeTruncatedResult(result, keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+}
+/**
+* Extract a range of visible columns from a line. Handles ANSI codes and wide chars.
+* @param strict - If true, exclude wide chars at boundary that would extend past the range
+*/
+function sliceByColumn(line, startCol, length, strict = false) {
+	return sliceWithWidth(line, startCol, length, strict).text;
+}
+/** Like sliceByColumn but also returns the actual visible width of the result. */
+function sliceWithWidth(line, startCol, length, strict = false) {
+	if (length <= 0) return {
+		text: "",
+		width: 0
+	};
+	const endCol = startCol + length;
+	let result = "", resultWidth = 0, currentCol = 0, i = 0, pendingAnsi = "";
+	while (i < line.length) {
+		const ansi = extractAnsiCode(line, i);
+		if (ansi) {
+			if (currentCol >= startCol && currentCol < endCol) result += ansi.code;
+			else if (currentCol < startCol) pendingAnsi += ansi.code;
+			i += ansi.length;
+			continue;
+		}
+		let textEnd = i;
+		while (textEnd < line.length && !extractAnsiCode(line, textEnd)) textEnd++;
+		for (const { segment } of graphemeSegmenter.segment(line.slice(i, textEnd))) {
+			const w = graphemeWidth(segment);
+			const inRange = currentCol >= startCol && currentCol < endCol;
+			const fits = !strict || currentCol + w <= endCol;
+			if (inRange && fits) {
+				if (pendingAnsi) {
+					result += pendingAnsi;
+					pendingAnsi = "";
+				}
+				result += segment;
+				resultWidth += w;
+			}
+			currentCol += w;
+			if (currentCol >= endCol) break;
+		}
+		i = textEnd;
+		if (currentCol >= endCol) break;
+	}
+	return {
+		text: result,
+		width: resultWidth
+	};
+}
+new AnsiCodeTracker();
+//#endregion
+//#region src/compat/vendor/pi-tui-fuzzy.ts
+function fuzzyMatch(query, text) {
+	const queryLower = query.toLowerCase();
+	const textLower = text.toLowerCase();
+	const matchQuery = (normalizedQuery) => {
+		if (normalizedQuery.length === 0) return {
+			matches: true,
+			score: 0
+		};
+		if (normalizedQuery.length > textLower.length) return {
+			matches: false,
+			score: 0
+		};
+		let queryIndex = 0;
+		let score = 0;
+		let lastMatchIndex = -1;
+		let consecutiveMatches = 0;
+		for (let i = 0; i < textLower.length && queryIndex < normalizedQuery.length; i++) if (textLower[i] === normalizedQuery[queryIndex]) {
+			const isWordBoundary = i === 0 || /[\s\-_./:]/.test(textLower[i - 1]);
+			if (lastMatchIndex === i - 1) {
+				consecutiveMatches++;
+				score -= consecutiveMatches * 5;
+			} else {
+				consecutiveMatches = 0;
+				if (lastMatchIndex >= 0) score += (i - lastMatchIndex - 1) * 2;
+			}
+			if (isWordBoundary) score -= 10;
+			score += i * .1;
+			lastMatchIndex = i;
+			queryIndex++;
+		}
+		if (queryIndex < normalizedQuery.length) return {
+			matches: false,
+			score: 0
+		};
+		if (normalizedQuery === textLower) score -= 100;
+		return {
+			matches: true,
+			score
+		};
+	};
+	const primaryMatch = matchQuery(queryLower);
+	if (primaryMatch.matches) return primaryMatch;
+	const alphaNumericMatch = queryLower.match(/^(?<letters>[a-z]+)(?<digits>[0-9]+)$/);
+	const numericAlphaMatch = queryLower.match(/^(?<digits>[0-9]+)(?<letters>[a-z]+)$/);
+	const swappedQuery = alphaNumericMatch ? `${alphaNumericMatch.groups?.digits ?? ""}${alphaNumericMatch.groups?.letters ?? ""}` : numericAlphaMatch ? `${numericAlphaMatch.groups?.letters ?? ""}${numericAlphaMatch.groups?.digits ?? ""}` : "";
+	if (!swappedQuery) return primaryMatch;
+	const swappedMatch = matchQuery(swappedQuery);
+	if (!swappedMatch.matches) return primaryMatch;
+	return {
+		matches: true,
+		score: swappedMatch.score + 5
+	};
+}
+/**
+* Filter and sort items by fuzzy match quality (best matches first).
+* Supports whitespace- and slash-separated tokens: all tokens must match.
+*/
+function fuzzyFilter(items, query, getText) {
+	if (!query.trim()) return items;
+	const tokens = query.trim().split(/[\s/]+/).filter((t) => t.length > 0);
+	if (tokens.length === 0) return items;
+	const results = [];
+	for (const item of items) {
+		const text = getText(item);
+		let totalScore = 0;
+		let allMatch = true;
+		for (const token of tokens) {
+			const match = fuzzyMatch(token, text);
+			if (match.matches) totalScore += match.score;
+			else {
+				allMatch = false;
+				break;
+			}
+		}
+		if (allMatch) results.push({
+			item,
+			totalScore
+		});
+	}
+	results.sort((a, b) => a.totalScore - b.totalScore);
+	return results.map((r) => r.item);
+}
+//#endregion
+//#region src/compat/vendor/pi-tui-keys.ts
+/**
+* Keyboard input handling for terminal applications.
+*
+* Supports both legacy terminal sequences and Kitty keyboard protocol.
+* See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+* Reference: https://github.com/sst/opentui/blob/7da92b4088aebfe27b9f691c04163a48821e49fd/packages/core/src/lib/parse.keypress.ts
+*
+* Symbol keys are also supported, however some ctrl+symbol combos
+* overlap with ASCII codes, e.g. ctrl+[ = ESC.
+* See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/#legacy-ctrl-mapping-of-ascii-keys
+* Those can still be * used for ctrl+shift combos
+*
+* API:
+* - matchesKey(data, keyId) - Check if input matches a key identifier
+* - parseKey(data) - Parse input and return the key identifier
+* - Key - Helper object for creating typed key identifiers
+* - setKittyProtocolActive(active) - Set global Kitty protocol state
+* - isKittyProtocolActive() - Query global Kitty protocol state
+*/
+let _kittyProtocolActive = false;
+/**
+* Set the global Kitty keyboard protocol state.
+* Called by ProcessTerminal after detecting protocol support.
+*/
+function setKittyProtocolActive(active) {
+	_kittyProtocolActive = active;
+}
+/**
+* Query whether Kitty keyboard protocol is currently active.
+*/
+function isKittyProtocolActive() {
+	return _kittyProtocolActive;
+}
+/**
+* Helper object for creating typed key identifiers with autocomplete.
+*
+* Usage:
+* - Key.escape, Key.enter, Key.tab, etc. for special keys
+* - Key.backtick, Key.comma, Key.period, etc. for symbol keys
+* - Key.ctrl("c"), Key.alt("x"), Key.super("k") for single modifiers
+* - Key.ctrlShift("p"), Key.ctrlAlt("x"), Key.ctrlSuper("k") for combined modifiers
+*/
+const Key = {
+	escape: "escape",
+	esc: "esc",
+	enter: "enter",
+	return: "return",
+	tab: "tab",
+	space: "space",
+	backspace: "backspace",
+	delete: "delete",
+	insert: "insert",
+	clear: "clear",
+	home: "home",
+	end: "end",
+	pageUp: "pageUp",
+	pageDown: "pageDown",
+	up: "up",
+	down: "down",
+	left: "left",
+	right: "right",
+	f1: "f1",
+	f2: "f2",
+	f3: "f3",
+	f4: "f4",
+	f5: "f5",
+	f6: "f6",
+	f7: "f7",
+	f8: "f8",
+	f9: "f9",
+	f10: "f10",
+	f11: "f11",
+	f12: "f12",
+	backtick: "`",
+	hyphen: "-",
+	equals: "=",
+	leftbracket: "[",
+	rightbracket: "]",
+	backslash: "\\",
+	semicolon: ";",
+	quote: "'",
+	comma: ",",
+	period: ".",
+	slash: "/",
+	exclamation: "!",
+	at: "@",
+	hash: "#",
+	dollar: "$",
+	percent: "%",
+	caret: "^",
+	ampersand: "&",
+	asterisk: "*",
+	leftparen: "(",
+	rightparen: ")",
+	underscore: "_",
+	plus: "+",
+	pipe: "|",
+	tilde: "~",
+	leftbrace: "{",
+	rightbrace: "}",
+	colon: ":",
+	lessthan: "<",
+	greaterthan: ">",
+	question: "?",
+	ctrl: (key) => `ctrl+${key}`,
+	shift: (key) => `shift+${key}`,
+	alt: (key) => `alt+${key}`,
+	super: (key) => `super+${key}`,
+	ctrlShift: (key) => `ctrl+shift+${key}`,
+	shiftCtrl: (key) => `shift+ctrl+${key}`,
+	ctrlAlt: (key) => `ctrl+alt+${key}`,
+	altCtrl: (key) => `alt+ctrl+${key}`,
+	shiftAlt: (key) => `shift+alt+${key}`,
+	altShift: (key) => `alt+shift+${key}`,
+	ctrlSuper: (key) => `ctrl+super+${key}`,
+	superCtrl: (key) => `super+ctrl+${key}`,
+	shiftSuper: (key) => `shift+super+${key}`,
+	superShift: (key) => `super+shift+${key}`,
+	altSuper: (key) => `alt+super+${key}`,
+	superAlt: (key) => `super+alt+${key}`,
+	ctrlShiftAlt: (key) => `ctrl+shift+alt+${key}`,
+	ctrlShiftSuper: (key) => `ctrl+shift+super+${key}`
+};
+const SYMBOL_KEYS = /* @__PURE__ */ new Set([
+	"`",
+	"-",
+	"=",
+	"[",
+	"]",
+	"\\",
+	";",
+	"'",
+	",",
+	".",
+	"/",
+	"!",
+	"@",
+	"#",
+	"$",
+	"%",
+	"^",
+	"&",
+	"*",
+	"(",
+	")",
+	"_",
+	"+",
+	"|",
+	"~",
+	"{",
+	"}",
+	":",
+	"<",
+	">",
+	"?"
+]);
+const MODIFIERS = {
+	shift: 1,
+	alt: 2,
+	ctrl: 4,
+	super: 8
+};
+const LOCK_MASK = 192;
+const CODEPOINTS = {
+	escape: 27,
+	tab: 9,
+	enter: 13,
+	space: 32,
+	backspace: 127,
+	kpEnter: 57414
+};
+const ARROW_CODEPOINTS = {
+	up: -1,
+	down: -2,
+	right: -3,
+	left: -4
+};
+const FUNCTIONAL_CODEPOINTS = {
+	delete: -10,
+	insert: -11,
+	pageUp: -12,
+	pageDown: -13,
+	home: -14,
+	end: -15
+};
+const KITTY_FUNCTIONAL_KEY_EQUIVALENTS = /* @__PURE__ */ new Map([
+	[57399, 48],
+	[57400, 49],
+	[57401, 50],
+	[57402, 51],
+	[57403, 52],
+	[57404, 53],
+	[57405, 54],
+	[57406, 55],
+	[57407, 56],
+	[57408, 57],
+	[57409, 46],
+	[57410, 47],
+	[57411, 42],
+	[57412, 45],
+	[57413, 43],
+	[57415, 61],
+	[57416, 44],
+	[57417, ARROW_CODEPOINTS.left],
+	[57418, ARROW_CODEPOINTS.right],
+	[57419, ARROW_CODEPOINTS.up],
+	[57420, ARROW_CODEPOINTS.down],
+	[57421, FUNCTIONAL_CODEPOINTS.pageUp],
+	[57422, FUNCTIONAL_CODEPOINTS.pageDown],
+	[57423, FUNCTIONAL_CODEPOINTS.home],
+	[57424, FUNCTIONAL_CODEPOINTS.end],
+	[57425, FUNCTIONAL_CODEPOINTS.insert],
+	[57426, FUNCTIONAL_CODEPOINTS.delete]
+]);
+function normalizeKittyFunctionalCodepoint(codepoint) {
+	return KITTY_FUNCTIONAL_KEY_EQUIVALENTS.get(codepoint) ?? codepoint;
+}
+function normalizeShiftedLetterIdentityCodepoint(codepoint, modifier) {
+	if ((modifier & -193 & MODIFIERS.shift) !== 0 && codepoint >= 65 && codepoint <= 90) return codepoint + 32;
+	return codepoint;
+}
+const LEGACY_KEY_SEQUENCES = {
+	up: ["\x1B[A", "\x1BOA"],
+	down: ["\x1B[B", "\x1BOB"],
+	right: ["\x1B[C", "\x1BOC"],
+	left: ["\x1B[D", "\x1BOD"],
+	home: [
+		"\x1B[H",
+		"\x1BOH",
+		"\x1B[1~",
+		"\x1B[7~"
+	],
+	end: [
+		"\x1B[F",
+		"\x1BOF",
+		"\x1B[4~",
+		"\x1B[8~"
+	],
+	insert: ["\x1B[2~"],
+	delete: ["\x1B[3~"],
+	pageUp: ["\x1B[5~", "\x1B[[5~"],
+	pageDown: ["\x1B[6~", "\x1B[[6~"],
+	clear: ["\x1B[E", "\x1BOE"],
+	f1: [
+		"\x1BOP",
+		"\x1B[11~",
+		"\x1B[[A"
+	],
+	f2: [
+		"\x1BOQ",
+		"\x1B[12~",
+		"\x1B[[B"
+	],
+	f3: [
+		"\x1BOR",
+		"\x1B[13~",
+		"\x1B[[C"
+	],
+	f4: [
+		"\x1BOS",
+		"\x1B[14~",
+		"\x1B[[D"
+	],
+	f5: ["\x1B[15~", "\x1B[[E"],
+	f6: ["\x1B[17~"],
+	f7: ["\x1B[18~"],
+	f8: ["\x1B[19~"],
+	f9: ["\x1B[20~"],
+	f10: ["\x1B[21~"],
+	f11: ["\x1B[23~"],
+	f12: ["\x1B[24~"]
+};
+const LEGACY_SHIFT_SEQUENCES = {
+	up: ["\x1B[a"],
+	down: ["\x1B[b"],
+	right: ["\x1B[c"],
+	left: ["\x1B[d"],
+	clear: ["\x1B[e"],
+	insert: ["\x1B[2$"],
+	delete: ["\x1B[3$"],
+	pageUp: ["\x1B[5$"],
+	pageDown: ["\x1B[6$"],
+	home: ["\x1B[7$"],
+	end: ["\x1B[8$"]
+};
+const LEGACY_CTRL_SEQUENCES = {
+	up: ["\x1BOa"],
+	down: ["\x1BOb"],
+	right: ["\x1BOc"],
+	left: ["\x1BOd"],
+	clear: ["\x1BOe"],
+	insert: ["\x1B[2^"],
+	delete: ["\x1B[3^"],
+	pageUp: ["\x1B[5^"],
+	pageDown: ["\x1B[6^"],
+	home: ["\x1B[7^"],
+	end: ["\x1B[8^"]
+};
+const LEGACY_SEQUENCE_KEY_IDS = {
+	"\x1BOA": "up",
+	"\x1BOB": "down",
+	"\x1BOC": "right",
+	"\x1BOD": "left",
+	"\x1BOH": "home",
+	"\x1BOF": "end",
+	"\x1B[E": "clear",
+	"\x1BOE": "clear",
+	"\x1BOe": "ctrl+clear",
+	"\x1B[e": "shift+clear",
+	"\x1B[2~": "insert",
+	"\x1B[2$": "shift+insert",
+	"\x1B[2^": "ctrl+insert",
+	"\x1B[3$": "shift+delete",
+	"\x1B[3^": "ctrl+delete",
+	"\x1B[[5~": "pageUp",
+	"\x1B[[6~": "pageDown",
+	"\x1B[a": "shift+up",
+	"\x1B[b": "shift+down",
+	"\x1B[c": "shift+right",
+	"\x1B[d": "shift+left",
+	"\x1BOa": "ctrl+up",
+	"\x1BOb": "ctrl+down",
+	"\x1BOc": "ctrl+right",
+	"\x1BOd": "ctrl+left",
+	"\x1B[5$": "shift+pageUp",
+	"\x1B[6$": "shift+pageDown",
+	"\x1B[7$": "shift+home",
+	"\x1B[8$": "shift+end",
+	"\x1B[5^": "ctrl+pageUp",
+	"\x1B[6^": "ctrl+pageDown",
+	"\x1B[7^": "ctrl+home",
+	"\x1B[8^": "ctrl+end",
+	"\x1BOP": "f1",
+	"\x1BOQ": "f2",
+	"\x1BOR": "f3",
+	"\x1BOS": "f4",
+	"\x1B[11~": "f1",
+	"\x1B[12~": "f2",
+	"\x1B[13~": "f3",
+	"\x1B[14~": "f4",
+	"\x1B[[A": "f1",
+	"\x1B[[B": "f2",
+	"\x1B[[C": "f3",
+	"\x1B[[D": "f4",
+	"\x1B[[E": "f5",
+	"\x1B[15~": "f5",
+	"\x1B[17~": "f6",
+	"\x1B[18~": "f7",
+	"\x1B[19~": "f8",
+	"\x1B[20~": "f9",
+	"\x1B[21~": "f10",
+	"\x1B[23~": "f11",
+	"\x1B[24~": "f12",
+	"\x1Bb": "alt+left",
+	"\x1Bf": "alt+right",
+	"\x1Bp": "alt+up",
+	"\x1Bn": "alt+down"
+};
+const matchesLegacySequence = (data, sequences) => sequences.includes(data);
+const matchesLegacyModifierSequence = (data, key, modifier) => {
+	if (modifier === MODIFIERS.shift) return matchesLegacySequence(data, LEGACY_SHIFT_SEQUENCES[key]);
+	if (modifier === MODIFIERS.ctrl) return matchesLegacySequence(data, LEGACY_CTRL_SEQUENCES[key]);
+	return false;
+};
+/**
+* Check if the last parsed key event was a key release.
+* Only meaningful when Kitty keyboard protocol with flag 2 is active.
+*/
+function isKeyRelease(data) {
+	if (data.includes("\x1B[200~")) return false;
+	if (data.includes(":3u") || data.includes(":3~") || data.includes(":3A") || data.includes(":3B") || data.includes(":3C") || data.includes(":3D") || data.includes(":3H") || data.includes(":3F")) return true;
+	return false;
+}
+/**
+* Check if the last parsed key event was a key repeat.
+* Only meaningful when Kitty keyboard protocol with flag 2 is active.
+*/
+function isKeyRepeat(data) {
+	if (data.includes("\x1B[200~")) return false;
+	if (data.includes(":2u") || data.includes(":2~") || data.includes(":2A") || data.includes(":2B") || data.includes(":2C") || data.includes(":2D") || data.includes(":2H") || data.includes(":2F")) return true;
+	return false;
+}
+function parseEventType(eventTypeStr) {
+	if (!eventTypeStr) return "press";
+	const eventType = parseInt(eventTypeStr, 10);
+	if (eventType === 2) return "repeat";
+	if (eventType === 3) return "release";
+	return "press";
+}
+function parseKittySequence(data) {
+	const csiUMatch = data.match(/^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u$/);
+	if (csiUMatch) {
+		const codepoint = parseInt(csiUMatch[1], 10);
+		const shiftedKey = csiUMatch[2] && csiUMatch[2].length > 0 ? parseInt(csiUMatch[2], 10) : void 0;
+		const baseLayoutKey = csiUMatch[3] ? parseInt(csiUMatch[3], 10) : void 0;
+		const modValue = csiUMatch[4] ? parseInt(csiUMatch[4], 10) : 1;
+		const eventType = parseEventType(csiUMatch[5]);
+		return {
+			codepoint,
+			shiftedKey,
+			baseLayoutKey,
+			modifier: modValue - 1,
+			eventType
+		};
+	}
+	const arrowMatch = data.match(/^\x1b\[1;(\d+)(?::(\d+))?([ABCD])$/);
+	if (arrowMatch) {
+		const modValue = parseInt(arrowMatch[1], 10);
+		const eventType = parseEventType(arrowMatch[2]);
+		return {
+			codepoint: {
+				A: -1,
+				B: -2,
+				C: -3,
+				D: -4
+			}[arrowMatch[3]],
+			modifier: modValue - 1,
+			eventType
+		};
+	}
+	const funcMatch = data.match(/^\x1b\[(\d+)(?:;(\d+))?(?::(\d+))?~$/);
+	if (funcMatch) {
+		const keyNum = parseInt(funcMatch[1], 10);
+		const modValue = funcMatch[2] ? parseInt(funcMatch[2], 10) : 1;
+		const eventType = parseEventType(funcMatch[3]);
+		const codepoint = {
+			2: FUNCTIONAL_CODEPOINTS.insert,
+			3: FUNCTIONAL_CODEPOINTS.delete,
+			5: FUNCTIONAL_CODEPOINTS.pageUp,
+			6: FUNCTIONAL_CODEPOINTS.pageDown,
+			7: FUNCTIONAL_CODEPOINTS.home,
+			8: FUNCTIONAL_CODEPOINTS.end
+		}[keyNum];
+		if (codepoint !== void 0) return {
+			codepoint,
+			modifier: modValue - 1,
+			eventType
+		};
+	}
+	const homeEndMatch = data.match(/^\x1b\[1;(\d+)(?::(\d+))?([HF])$/);
+	if (homeEndMatch) {
+		const modValue = parseInt(homeEndMatch[1], 10);
+		const eventType = parseEventType(homeEndMatch[2]);
+		return {
+			codepoint: homeEndMatch[3] === "H" ? FUNCTIONAL_CODEPOINTS.home : FUNCTIONAL_CODEPOINTS.end,
+			modifier: modValue - 1,
+			eventType
+		};
+	}
+	return null;
+}
+function matchesKittySequence(data, expectedCodepoint, expectedModifier) {
+	const parsed = parseKittySequence(data);
+	if (!parsed) return false;
+	if ((parsed.modifier & -193) !== (expectedModifier & -193)) return false;
+	const normalizedCodepoint = normalizeShiftedLetterIdentityCodepoint(normalizeKittyFunctionalCodepoint(parsed.codepoint), parsed.modifier);
+	if (normalizedCodepoint === normalizeShiftedLetterIdentityCodepoint(normalizeKittyFunctionalCodepoint(expectedCodepoint), expectedModifier)) return true;
+	if (parsed.baseLayoutKey !== void 0 && parsed.baseLayoutKey === expectedCodepoint) {
+		const cp = normalizedCodepoint;
+		const isLatinLetter = cp >= 97 && cp <= 122;
+		const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(cp));
+		if (!isLatinLetter && !isKnownSymbol) return true;
+	}
+	return false;
+}
+function parseModifyOtherKeysSequence(data) {
+	const match = data.match(/^\x1b\[27;(\d+);(\d+)~$/);
+	if (!match) return null;
+	const modValue = parseInt(match[1], 10);
+	return {
+		codepoint: parseInt(match[2], 10),
+		modifier: modValue - 1
+	};
+}
+/**
+* Match xterm modifyOtherKeys format: CSI 27 ; modifiers ; keycode ~
+* This is used by terminals when Kitty protocol is not enabled.
+* Modifier values are 1-indexed: 2=shift, 3=alt, 5=ctrl, etc.
+*/
+function matchesModifyOtherKeys(data, expectedKeycode, expectedModifier) {
+	const parsed = parseModifyOtherKeysSequence(data);
+	if (!parsed) return false;
+	return parsed.codepoint === expectedKeycode && parsed.modifier === expectedModifier;
+}
+function isWindowsTerminalSession() {
+	return Boolean(process.env.WT_SESSION) && !process.env.SSH_CONNECTION && !process.env.SSH_CLIENT && !process.env.SSH_TTY;
+}
+/**
+* Raw 0x08 (BS) is ambiguous in legacy terminals.
+*
+* - Windows Terminal uses it for Ctrl+Backspace.
+* - Some legacy terminals and tmux setups send it for plain Backspace.
+*
+* Prefer explicit Kitty / CSI-u / modifyOtherKeys sequences whenever they are
+* available. Fall back to a Windows Terminal heuristic only for raw BS bytes.
+*/
+function matchesRawBackspace(data, expectedModifier) {
+	if (data === "") return expectedModifier === 0;
+	if (data !== "\b") return false;
+	return isWindowsTerminalSession() ? expectedModifier === MODIFIERS.ctrl : expectedModifier === 0;
+}
+/**
+* Get the control character for a key.
+* Uses the universal formula: code & 0x1f (mask to lower 5 bits)
+*
+* Works for:
+* - Letters a-z → 1-26
+* - Symbols [\]_ → 27, 28, 29, 31
+* - Also maps - to same as _ (same physical key on US keyboards)
+*/
+function rawCtrlChar(key) {
+	const char = key.toLowerCase();
+	const code = char.charCodeAt(0);
+	if (code >= 97 && code <= 122 || char === "[" || char === "\\" || char === "]" || char === "_") return String.fromCharCode(code & 31);
+	if (char === "-") return String.fromCharCode(31);
+	return null;
+}
+function isDigitKey(key) {
+	return key >= "0" && key <= "9";
+}
+function matchesPrintableModifyOtherKeys(data, expectedKeycode, expectedModifier) {
+	if (expectedModifier === 0) return false;
+	const parsed = parseModifyOtherKeysSequence(data);
+	if (!parsed || parsed.modifier !== expectedModifier) return false;
+	return normalizeShiftedLetterIdentityCodepoint(parsed.codepoint, parsed.modifier) === normalizeShiftedLetterIdentityCodepoint(expectedKeycode, expectedModifier);
+}
+function formatKeyNameWithModifiers(keyName, modifier) {
+	const mods = [];
+	const effectiveMod = modifier & -193;
+	if ((effectiveMod & ~(MODIFIERS.shift | MODIFIERS.ctrl | MODIFIERS.alt | MODIFIERS.super)) !== 0) return void 0;
+	if (effectiveMod & MODIFIERS.shift) mods.push("shift");
+	if (effectiveMod & MODIFIERS.ctrl) mods.push("ctrl");
+	if (effectiveMod & MODIFIERS.alt) mods.push("alt");
+	if (effectiveMod & MODIFIERS.super) mods.push("super");
+	return mods.length > 0 ? `${mods.join("+")}+${keyName}` : keyName;
+}
+function parseKeyId(keyId) {
+	const parts = keyId.toLowerCase().split("+");
+	const key = parts[parts.length - 1];
+	if (!key) return null;
+	return {
+		key,
+		ctrl: parts.includes("ctrl"),
+		shift: parts.includes("shift"),
+		alt: parts.includes("alt"),
+		super: parts.includes("super")
+	};
+}
+/**
+* Match input data against a key identifier string.
+*
+* Supported key identifiers:
+* - Single keys: "escape", "tab", "enter", "backspace", "delete", "home", "end", "space"
+* - Arrow keys: "up", "down", "left", "right"
+* - Ctrl combinations: "ctrl+c", "ctrl+z", etc.
+* - Shift combinations: "shift+tab", "shift+enter"
+* - Alt combinations: "alt+enter", "alt+backspace"
+* - Super combinations: "super+k", "super+enter"
+* - Combined modifiers: "shift+ctrl+p", "ctrl+alt+x", "ctrl+super+k"
+*
+* Use the Key helper for autocomplete: Key.ctrl("c"), Key.escape, Key.ctrlShift("p"), Key.super("k")
+*
+* @param data - Raw input data from terminal
+* @param keyId - Key identifier (e.g., "ctrl+c", "escape", Key.ctrl("c"))
+*/
+function matchesKey(data, keyId) {
+	const parsed = parseKeyId(keyId);
+	if (!parsed) return false;
+	const { key, ctrl, shift, alt, super: superModifier } = parsed;
+	let modifier = 0;
+	if (shift) modifier |= MODIFIERS.shift;
+	if (alt) modifier |= MODIFIERS.alt;
+	if (ctrl) modifier |= MODIFIERS.ctrl;
+	if (superModifier) modifier |= MODIFIERS.super;
+	switch (key) {
+		case "escape":
+		case "esc":
+			if (modifier !== 0) return false;
+			return data === "\x1B" || matchesKittySequence(data, CODEPOINTS.escape, 0) || matchesModifyOtherKeys(data, CODEPOINTS.escape, 0);
+		case "space":
+			if (!_kittyProtocolActive) {
+				if (modifier === MODIFIERS.ctrl && data === "\0") return true;
+				if (modifier === MODIFIERS.alt && data === "\x1B ") return true;
+			}
+			if (modifier === 0) return data === " " || matchesKittySequence(data, CODEPOINTS.space, 0) || matchesModifyOtherKeys(data, CODEPOINTS.space, 0);
+			return matchesKittySequence(data, CODEPOINTS.space, modifier) || matchesModifyOtherKeys(data, CODEPOINTS.space, modifier);
+		case "tab":
+			if (modifier === MODIFIERS.shift) return data === "\x1B[Z" || matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift) || matchesModifyOtherKeys(data, CODEPOINTS.tab, MODIFIERS.shift);
+			if (modifier === 0) return data === "	" || matchesKittySequence(data, CODEPOINTS.tab, 0);
+			return matchesKittySequence(data, CODEPOINTS.tab, modifier) || matchesModifyOtherKeys(data, CODEPOINTS.tab, modifier);
+		case "enter":
+		case "return":
+			if (modifier === MODIFIERS.shift) {
+				if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift) || matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.shift)) return true;
+				if (matchesModifyOtherKeys(data, CODEPOINTS.enter, MODIFIERS.shift)) return true;
+				if (_kittyProtocolActive) return data === "\x1B\r" || data === "\n";
+				return false;
+			}
+			if (modifier === MODIFIERS.alt) {
+				if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt) || matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.alt)) return true;
+				if (matchesModifyOtherKeys(data, CODEPOINTS.enter, MODIFIERS.alt)) return true;
+				if (!_kittyProtocolActive) return data === "\x1B\r";
+				return false;
+			}
+			if (modifier === 0) return data === "\r" || !_kittyProtocolActive && data === "\n" || data === "\x1BOM" || matchesKittySequence(data, CODEPOINTS.enter, 0) || matchesKittySequence(data, CODEPOINTS.kpEnter, 0);
+			return matchesKittySequence(data, CODEPOINTS.enter, modifier) || matchesKittySequence(data, CODEPOINTS.kpEnter, modifier) || matchesModifyOtherKeys(data, CODEPOINTS.enter, modifier);
+		case "backspace":
+			if (modifier === MODIFIERS.alt) {
+				if (data === "\x1B" || data === "\x1B\b") return true;
+				return matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt) || matchesModifyOtherKeys(data, CODEPOINTS.backspace, MODIFIERS.alt);
+			}
+			if (modifier === MODIFIERS.ctrl) {
+				if (matchesRawBackspace(data, MODIFIERS.ctrl)) return true;
+				return matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.ctrl) || matchesModifyOtherKeys(data, CODEPOINTS.backspace, MODIFIERS.ctrl);
+			}
+			if (modifier === 0) return matchesRawBackspace(data, 0) || matchesKittySequence(data, CODEPOINTS.backspace, 0) || matchesModifyOtherKeys(data, CODEPOINTS.backspace, 0);
+			return matchesKittySequence(data, CODEPOINTS.backspace, modifier) || matchesModifyOtherKeys(data, CODEPOINTS.backspace, modifier);
+		case "insert":
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.insert) || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.insert, 0);
+			if (matchesLegacyModifierSequence(data, "insert", modifier)) return true;
+			return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.insert, modifier);
+		case "delete":
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.delete) || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, 0);
+			if (matchesLegacyModifierSequence(data, "delete", modifier)) return true;
+			return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, modifier);
+		case "clear":
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.clear);
+			return matchesLegacyModifierSequence(data, "clear", modifier);
+		case "home":
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.home) || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, 0);
+			if (matchesLegacyModifierSequence(data, "home", modifier)) return true;
+			return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, modifier);
+		case "end":
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.end) || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, 0);
+			if (matchesLegacyModifierSequence(data, "end", modifier)) return true;
+			return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, modifier);
+		case "pageup":
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.pageUp) || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageUp, 0);
+			if (matchesLegacyModifierSequence(data, "pageUp", modifier)) return true;
+			return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageUp, modifier);
+		case "pagedown":
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.pageDown) || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageDown, 0);
+			if (matchesLegacyModifierSequence(data, "pageDown", modifier)) return true;
+			return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageDown, modifier);
+		case "up":
+			if (modifier === MODIFIERS.alt) return data === "\x1Bp" || matchesKittySequence(data, ARROW_CODEPOINTS.up, MODIFIERS.alt);
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.up) || matchesKittySequence(data, ARROW_CODEPOINTS.up, 0);
+			if (matchesLegacyModifierSequence(data, "up", modifier)) return true;
+			return matchesKittySequence(data, ARROW_CODEPOINTS.up, modifier);
+		case "down":
+			if (modifier === MODIFIERS.alt) return data === "\x1Bn" || matchesKittySequence(data, ARROW_CODEPOINTS.down, MODIFIERS.alt);
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.down) || matchesKittySequence(data, ARROW_CODEPOINTS.down, 0);
+			if (matchesLegacyModifierSequence(data, "down", modifier)) return true;
+			return matchesKittySequence(data, ARROW_CODEPOINTS.down, modifier);
+		case "left":
+			if (modifier === MODIFIERS.alt) return data === "\x1B[1;3D" || !_kittyProtocolActive && data === "\x1BB" || data === "\x1Bb" || matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt);
+			if (modifier === MODIFIERS.ctrl) return data === "\x1B[1;5D" || matchesLegacyModifierSequence(data, "left", MODIFIERS.ctrl) || matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl);
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.left) || matchesKittySequence(data, ARROW_CODEPOINTS.left, 0);
+			if (matchesLegacyModifierSequence(data, "left", modifier)) return true;
+			return matchesKittySequence(data, ARROW_CODEPOINTS.left, modifier);
+		case "right":
+			if (modifier === MODIFIERS.alt) return data === "\x1B[1;3C" || !_kittyProtocolActive && data === "\x1BF" || data === "\x1Bf" || matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt);
+			if (modifier === MODIFIERS.ctrl) return data === "\x1B[1;5C" || matchesLegacyModifierSequence(data, "right", MODIFIERS.ctrl) || matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl);
+			if (modifier === 0) return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.right) || matchesKittySequence(data, ARROW_CODEPOINTS.right, 0);
+			if (matchesLegacyModifierSequence(data, "right", modifier)) return true;
+			return matchesKittySequence(data, ARROW_CODEPOINTS.right, modifier);
+		case "f1":
+		case "f2":
+		case "f3":
+		case "f4":
+		case "f5":
+		case "f6":
+		case "f7":
+		case "f8":
+		case "f9":
+		case "f10":
+		case "f11":
+		case "f12":
+			if (modifier !== 0) return false;
+			return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES[key]);
+	}
+	if (key.length === 1 && (key >= "a" && key <= "z" || isDigitKey(key) || SYMBOL_KEYS.has(key))) {
+		const codepoint = key.charCodeAt(0);
+		const rawCtrl = rawCtrlChar(key);
+		const isLetter = key >= "a" && key <= "z";
+		const isDigit = isDigitKey(key);
+		if (modifier === MODIFIERS.ctrl + MODIFIERS.alt && !_kittyProtocolActive && rawCtrl) {
+			if (data === `\x1b${rawCtrl}`) return true;
+		}
+		if (modifier === MODIFIERS.alt && !_kittyProtocolActive && (isLetter || isDigit || SYMBOL_KEYS.has(key))) {
+			if (data === `\x1b${key}`) return true;
+		}
+		if (modifier === MODIFIERS.ctrl) {
+			if (rawCtrl && data === rawCtrl) return true;
+			return matchesKittySequence(data, codepoint, MODIFIERS.ctrl) || matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.ctrl);
+		}
+		if (modifier === MODIFIERS.shift + MODIFIERS.ctrl) return matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl) || matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl);
+		if (modifier === MODIFIERS.shift) {
+			if (isLetter && data === key.toUpperCase()) return true;
+			return matchesKittySequence(data, codepoint, MODIFIERS.shift) || matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.shift);
+		}
+		if (modifier !== 0) return matchesKittySequence(data, codepoint, modifier) || matchesPrintableModifyOtherKeys(data, codepoint, modifier);
+		return data === key || matchesKittySequence(data, codepoint, 0);
+	}
+	return false;
+}
+/**
+* Parse input data and return the key identifier if recognized.
+*
+* @param data - Raw input data from terminal
+* @returns Key identifier string (e.g., "ctrl+c") or undefined
+*/
+function formatParsedKey(codepoint, modifier, baseLayoutKey) {
+	const identityCodepoint = normalizeShiftedLetterIdentityCodepoint(normalizeKittyFunctionalCodepoint(codepoint), modifier);
+	const isLatinLetter = identityCodepoint >= 97 && identityCodepoint <= 122;
+	const isDigit = identityCodepoint >= 48 && identityCodepoint <= 57;
+	const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(identityCodepoint));
+	const effectiveCodepoint = isLatinLetter || isDigit || isKnownSymbol ? identityCodepoint : baseLayoutKey ?? identityCodepoint;
+	let keyName;
+	if (effectiveCodepoint === CODEPOINTS.escape) keyName = "escape";
+	else if (effectiveCodepoint === CODEPOINTS.tab) keyName = "tab";
+	else if (effectiveCodepoint === CODEPOINTS.enter || effectiveCodepoint === CODEPOINTS.kpEnter) keyName = "enter";
+	else if (effectiveCodepoint === CODEPOINTS.space) keyName = "space";
+	else if (effectiveCodepoint === CODEPOINTS.backspace) keyName = "backspace";
+	else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.delete) keyName = "delete";
+	else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.insert) keyName = "insert";
+	else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.home) keyName = "home";
+	else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.end) keyName = "end";
+	else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.pageUp) keyName = "pageUp";
+	else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.pageDown) keyName = "pageDown";
+	else if (effectiveCodepoint === ARROW_CODEPOINTS.up) keyName = "up";
+	else if (effectiveCodepoint === ARROW_CODEPOINTS.down) keyName = "down";
+	else if (effectiveCodepoint === ARROW_CODEPOINTS.left) keyName = "left";
+	else if (effectiveCodepoint === ARROW_CODEPOINTS.right) keyName = "right";
+	else if (effectiveCodepoint >= 48 && effectiveCodepoint <= 57) keyName = String.fromCharCode(effectiveCodepoint);
+	else if (effectiveCodepoint >= 97 && effectiveCodepoint <= 122) keyName = String.fromCharCode(effectiveCodepoint);
+	else if (SYMBOL_KEYS.has(String.fromCharCode(effectiveCodepoint))) keyName = String.fromCharCode(effectiveCodepoint);
+	if (!keyName) return void 0;
+	return formatKeyNameWithModifiers(keyName, modifier);
+}
+function parseKey(data) {
+	const kitty = parseKittySequence(data);
+	if (kitty) return formatParsedKey(kitty.codepoint, kitty.modifier, kitty.baseLayoutKey);
+	const modifyOtherKeys = parseModifyOtherKeysSequence(data);
+	if (modifyOtherKeys) return formatParsedKey(modifyOtherKeys.codepoint, modifyOtherKeys.modifier);
+	if (_kittyProtocolActive) {
+		if (data === "\x1B\r" || data === "\n") return "shift+enter";
+	}
+	const legacySequenceKeyId = LEGACY_SEQUENCE_KEY_IDS[data];
+	if (legacySequenceKeyId) return legacySequenceKeyId;
+	if (data === "\x1B") return "escape";
+	if (data === "") return "ctrl+\\";
+	if (data === "") return "ctrl+]";
+	if (data === "") return "ctrl+-";
+	if (data === "\x1B\x1B") return "ctrl+alt+[";
+	if (data === "\x1B") return "ctrl+alt+\\";
+	if (data === "\x1B") return "ctrl+alt+]";
+	if (data === "\x1B") return "ctrl+alt+-";
+	if (data === "	") return "tab";
+	if (data === "\r" || !_kittyProtocolActive && data === "\n" || data === "\x1BOM") return "enter";
+	if (data === "\0") return "ctrl+space";
+	if (data === " ") return "space";
+	if (data === "") return "backspace";
+	if (data === "\b") return isWindowsTerminalSession() ? "ctrl+backspace" : "backspace";
+	if (data === "\x1B[Z") return "shift+tab";
+	if (!_kittyProtocolActive && data === "\x1B\r") return "alt+enter";
+	if (!_kittyProtocolActive && data === "\x1B ") return "alt+space";
+	if (data === "\x1B" || data === "\x1B\b") return "alt+backspace";
+	if (!_kittyProtocolActive && data === "\x1BB") return "alt+left";
+	if (!_kittyProtocolActive && data === "\x1BF") return "alt+right";
+	if (!_kittyProtocolActive && data.length === 2 && data[0] === "\x1B") {
+		const code = data.charCodeAt(1);
+		if (code >= 1 && code <= 26) return `ctrl+alt+${String.fromCharCode(code + 96)}`;
+		const key = String.fromCharCode(code);
+		if (code >= 97 && code <= 122 || code >= 48 && code <= 57 || SYMBOL_KEYS.has(key)) return `alt+${key}`;
+	}
+	if (data === "\x1B[A") return "up";
+	if (data === "\x1B[B") return "down";
+	if (data === "\x1B[C") return "right";
+	if (data === "\x1B[D") return "left";
+	if (data === "\x1B[H" || data === "\x1BOH") return "home";
+	if (data === "\x1B[F" || data === "\x1BOF") return "end";
+	if (data === "\x1B[3~") return "delete";
+	if (data === "\x1B[5~") return "pageUp";
+	if (data === "\x1B[6~") return "pageDown";
+	if (data.length === 1) {
+		const code = data.charCodeAt(0);
+		if (code >= 1 && code <= 26) return `ctrl+${String.fromCharCode(code + 96)}`;
+		if (code >= 32 && code <= 126) return data;
+	}
+}
+const KITTY_CSI_U_REGEX = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u$/;
+const KITTY_PRINTABLE_ALLOWED_MODIFIERS = MODIFIERS.shift | LOCK_MASK;
+/**
+* Decode a Kitty CSI-u sequence into a printable character, if applicable.
+*
+* When Kitty keyboard protocol flag 1 (disambiguate) is active, terminals send
+* CSI-u sequences for all keys, including plain printable characters. This
+* function extracts the printable character from such sequences.
+*
+* Only accepts plain or Shift-modified keys. Rejects Ctrl, Alt, and unsupported
+* modifier combinations (those are handled by keybinding matching instead).
+* Prefers the shifted keycode when Shift is held and a shifted key is reported.
+*
+* @param data - Raw input data from terminal
+* @returns The printable character, or undefined if not a printable CSI-u sequence
+*/
+function decodeKittyPrintable(data) {
+	const match = data.match(KITTY_CSI_U_REGEX);
+	if (!match) return void 0;
+	const codepoint = Number.parseInt(match[1] ?? "", 10);
+	if (!Number.isFinite(codepoint)) return void 0;
+	const shiftedKey = match[2] && match[2].length > 0 ? Number.parseInt(match[2], 10) : void 0;
+	const modValue = match[4] ? Number.parseInt(match[4], 10) : 1;
+	const modifier = Number.isFinite(modValue) ? modValue - 1 : 0;
+	if ((modifier & ~KITTY_PRINTABLE_ALLOWED_MODIFIERS) !== 0) return void 0;
+	if (modifier & (MODIFIERS.alt | MODIFIERS.ctrl)) return void 0;
+	let effectiveCodepoint = codepoint;
+	if (modifier & MODIFIERS.shift && typeof shiftedKey === "number") effectiveCodepoint = shiftedKey;
+	effectiveCodepoint = normalizeKittyFunctionalCodepoint(effectiveCodepoint);
+	if (!Number.isFinite(effectiveCodepoint) || effectiveCodepoint < 32) return void 0;
+	try {
+		return String.fromCodePoint(effectiveCodepoint);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/compat/vendor/pi-tui-terminal-colors.ts
+function hexToRgb(hex) {
+	const normalized = hex.startsWith("#") ? hex.slice(1) : hex;
+	return {
+		r: parseInt(normalized.slice(0, 2), 16),
+		g: parseInt(normalized.slice(2, 4), 16),
+		b: parseInt(normalized.slice(4, 6), 16)
+	};
+}
+function parseOscHexChannel(channel) {
+	if (!/^[0-9a-f]+$/i.test(channel)) return;
+	const max = 16 ** channel.length - 1;
+	if (max <= 0) return;
+	return Math.round(parseInt(channel, 16) / max * 255);
+}
+const OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN = /^\x1b\]11;([^\x07\x1b]*)(?:\x07|\x1b\\)$/i;
+const COLOR_SCHEME_REPORT_PATTERN = /^(?:\x1b\[\?997;(1|2)n)+$/;
+function parseOsc11BackgroundColor(data) {
+	const match = data.match(OSC11_BACKGROUND_COLOR_RESPONSE_PATTERN);
+	if (!match) return;
+	const value = match[1].trim();
+	if (value.startsWith("#")) {
+		const hex = value.slice(1);
+		if (/^[0-9a-f]{6}$/i.test(hex)) return hexToRgb(value);
+		if (/^[0-9a-f]{12}$/i.test(hex)) {
+			const r = parseOscHexChannel(hex.slice(0, 4));
+			const g = parseOscHexChannel(hex.slice(4, 8));
+			const b = parseOscHexChannel(hex.slice(8, 12));
+			return r !== void 0 && g !== void 0 && b !== void 0 ? {
+				r,
+				g,
+				b
+			} : void 0;
+		}
+		return;
+	}
+	const [red, green, blue] = value.replace(/^rgba?:/i, "").split("/");
+	if (red === void 0 || green === void 0 || blue === void 0) return;
+	const r = parseOscHexChannel(red);
+	const g = parseOscHexChannel(green);
+	const b = parseOscHexChannel(blue);
+	return r !== void 0 && g !== void 0 && b !== void 0 ? {
+		r,
+		g,
+		b
+	} : void 0;
+}
+function parseTerminalColorSchemeReport(data) {
+	const match = data.match(COLOR_SCHEME_REPORT_PATTERN);
+	if (!match) return;
+	return match[1] === "2" ? "light" : "dark";
+}
+//#endregion
+//#region src/compat/vendor/pi-tui-keybindings.ts
+const TUI_KEYBINDINGS = {
+	"tui.editor.cursorUp": {
+		defaultKeys: "up",
+		description: "Move cursor up"
+	},
+	"tui.editor.cursorDown": {
+		defaultKeys: "down",
+		description: "Move cursor down"
+	},
+	"tui.editor.historyPrevious": {
+		defaultKeys: [],
+		description: "Select previous prompt history entry"
+	},
+	"tui.editor.historyNext": {
+		defaultKeys: [],
+		description: "Select next prompt history entry"
+	},
+	"tui.editor.cursorLeft": {
+		defaultKeys: ["left", "ctrl+b"],
+		description: "Move cursor left"
+	},
+	"tui.editor.cursorRight": {
+		defaultKeys: ["right", "ctrl+f"],
+		description: "Move cursor right"
+	},
+	"tui.editor.cursorWordLeft": {
+		defaultKeys: [
+			"alt+left",
+			"ctrl+left",
+			"alt+b"
+		],
+		description: "Move cursor word left"
+	},
+	"tui.editor.cursorWordRight": {
+		defaultKeys: [
+			"alt+right",
+			"ctrl+right",
+			"alt+f"
+		],
+		description: "Move cursor word right"
+	},
+	"tui.editor.cursorLineStart": {
+		defaultKeys: [
+			"home",
+			"ctrl+home",
+			"ctrl+a"
+		],
+		description: "Move to line start"
+	},
+	"tui.editor.cursorLineEnd": {
+		defaultKeys: [
+			"end",
+			"ctrl+end",
+			"ctrl+e"
+		],
+		description: "Move to line end"
+	},
+	"tui.editor.jumpForward": {
+		defaultKeys: "ctrl+]",
+		description: "Jump forward to character"
+	},
+	"tui.editor.jumpBackward": {
+		defaultKeys: "ctrl+alt+]",
+		description: "Jump backward to character"
+	},
+	"tui.editor.pageUp": {
+		defaultKeys: ["pageUp", "ctrl+pageUp"],
+		description: "Page up"
+	},
+	"tui.editor.pageDown": {
+		defaultKeys: ["pageDown", "ctrl+pageDown"],
+		description: "Page down"
+	},
+	"tui.editor.deleteCharBackward": {
+		defaultKeys: "backspace",
+		description: "Delete character backward"
+	},
+	"tui.editor.deleteCharForward": {
+		defaultKeys: ["delete", "ctrl+d"],
+		description: "Delete character forward"
+	},
+	"tui.editor.deleteWordBackward": {
+		defaultKeys: ["ctrl+w", "alt+backspace"],
+		description: "Delete word backward"
+	},
+	"tui.editor.deleteWordForward": {
+		defaultKeys: ["alt+d", "alt+delete"],
+		description: "Delete word forward"
+	},
+	"tui.editor.deleteToLineStart": {
+		defaultKeys: "ctrl+u",
+		description: "Delete to line start"
+	},
+	"tui.editor.deleteToLineEnd": {
+		defaultKeys: "ctrl+k",
+		description: "Delete to line end"
+	},
+	"tui.editor.yank": {
+		defaultKeys: "ctrl+y",
+		description: "Yank"
+	},
+	"tui.editor.yankPop": {
+		defaultKeys: "alt+y",
+		description: "Yank pop"
+	},
+	"tui.editor.undo": {
+		defaultKeys: "ctrl+-",
+		description: "Undo"
+	},
+	"tui.input.newLine": {
+		defaultKeys: ["shift+enter", "ctrl+j"],
+		description: "Insert newline"
+	},
+	"tui.input.submit": {
+		defaultKeys: "enter",
+		description: "Submit input"
+	},
+	"tui.input.tab": {
+		defaultKeys: "tab",
+		description: "Tab / autocomplete"
+	},
+	"tui.input.copy": {
+		defaultKeys: "ctrl+c",
+		description: "Copy selection"
+	},
+	"tui.select.up": {
+		defaultKeys: "up",
+		description: "Move selection up"
+	},
+	"tui.select.down": {
+		defaultKeys: "down",
+		description: "Move selection down"
+	},
+	"tui.select.pageUp": {
+		defaultKeys: "pageUp",
+		description: "Selection page up"
+	},
+	"tui.select.pageDown": {
+		defaultKeys: "pageDown",
+		description: "Selection page down"
+	},
+	"tui.select.confirm": {
+		defaultKeys: "enter",
+		description: "Confirm selection"
+	},
+	"tui.select.cancel": {
+		defaultKeys: ["escape", "ctrl+c"],
+		description: "Cancel selection"
+	},
+	"tui.altScreen.pageUp": {
+		defaultKeys: "pageUp",
+		description: "Scroll viewport up one page"
+	},
+	"tui.altScreen.pageDown": {
+		defaultKeys: "pageDown",
+		description: "Scroll viewport down one page"
+	},
+	"tui.altScreen.halfPageUp": {
+		defaultKeys: [],
+		description: "Scroll viewport up half a page"
+	},
+	"tui.altScreen.halfPageDown": {
+		defaultKeys: [],
+		description: "Scroll viewport down half a page"
+	},
+	"tui.altScreen.lineUp": {
+		defaultKeys: [],
+		description: "Scroll viewport up one line"
+	},
+	"tui.altScreen.lineDown": {
+		defaultKeys: [],
+		description: "Scroll viewport down one line"
+	},
+	"tui.altScreen.previousPrompt": {
+		defaultKeys: "ctrl+shift+up",
+		description: "Jump to previous semantic prompt"
+	},
+	"tui.altScreen.nextPrompt": {
+		defaultKeys: "ctrl+shift+down",
+		description: "Jump to next semantic prompt"
+	},
+	"tui.altScreen.search": {
+		defaultKeys: "ctrl+shift+f",
+		description: "Search the primary scroll view"
+	},
+	"tui.altScreen.searchNext": {
+		defaultKeys: ["enter", "ctrl+g"],
+		description: "Select the next search match"
+	},
+	"tui.altScreen.searchPrevious": {
+		defaultKeys: ["shift+enter", "ctrl+shift+g"],
+		description: "Select the previous search match"
+	},
+	"tui.altScreen.searchClose": {
+		defaultKeys: "escape",
+		description: "Close transcript search"
+	},
+	"tui.altScreen.top": {
+		defaultKeys: "home",
+		description: "Scroll viewport to top"
+	},
+	"tui.altScreen.bottom": {
+		defaultKeys: "end",
+		description: "Scroll viewport to bottom"
+	}
+};
+function normalizeKeys(keys) {
+	if (keys === void 0) return [];
+	const keyList = Array.isArray(keys) ? keys : [keys];
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const key of keyList) if (!seen.has(key)) {
+		seen.add(key);
+		result.push(key);
+	}
+	return result;
+}
+var KeybindingsManager = class {
+	definitions;
+	userBindings;
+	keysById = /* @__PURE__ */ new Map();
+	conflicts = [];
+	constructor(definitions, userBindings = {}) {
+		this.definitions = definitions;
+		this.userBindings = userBindings;
+		this.rebuild();
+	}
+	rebuild() {
+		this.keysById.clear();
+		this.conflicts = [];
+		const userClaims = /* @__PURE__ */ new Map();
+		for (const [keybinding, keys] of Object.entries(this.userBindings)) {
+			if (!(keybinding in this.definitions)) continue;
+			for (const key of normalizeKeys(keys)) {
+				const claimants = userClaims.get(key) ?? /* @__PURE__ */ new Set();
+				claimants.add(keybinding);
+				userClaims.set(key, claimants);
+			}
+		}
+		for (const [key, keybindings] of userClaims) if (keybindings.size > 1) this.conflicts.push({
+			key,
+			keybindings: [...keybindings]
+		});
+		for (const [id, definition] of Object.entries(this.definitions)) {
+			const userKeys = this.userBindings[id];
+			const keys = userKeys === void 0 ? normalizeKeys(definition.defaultKeys) : normalizeKeys(userKeys);
+			this.keysById.set(id, keys);
+		}
+	}
+	matches(data, keybinding) {
+		const keys = this.keysById.get(keybinding) ?? [];
+		for (const key of keys) if (matchesKey(data, key)) return true;
+		return false;
+	}
+	getKeys(keybinding) {
+		return [...this.keysById.get(keybinding) ?? []];
+	}
+	getDefinition(keybinding) {
+		return this.definitions[keybinding];
+	}
+	getConflicts() {
+		return this.conflicts.map((conflict) => ({
+			...conflict,
+			keybindings: [...conflict.keybindings]
+		}));
+	}
+	setUserBindings(userBindings) {
+		this.userBindings = userBindings;
+		this.rebuild();
+	}
+	getUserBindings() {
+		return { ...this.userBindings };
+	}
+	getResolvedBindings() {
+		const resolved = {};
+		for (const id of Object.keys(this.definitions)) {
+			const keys = this.keysById.get(id) ?? [];
+			resolved[id] = keys.length === 1 ? keys[0] : [...keys];
+		}
+		return resolved;
+	}
+};
+let globalKeybindings = null;
+function setKeybindings(keybindings) {
+	globalKeybindings = keybindings;
+}
+function getKeybindings() {
+	if (!globalKeybindings) globalKeybindings = new KeybindingsManager(TUI_KEYBINDINGS);
+	return globalKeybindings;
+}
+//#endregion
+//#region src/compat/vendor/pi-tui-latex.ts
+const SYMBOLS = {
+	alpha: "α",
+	beta: "β",
+	gamma: "γ",
+	delta: "δ",
+	epsilon: "ϵ",
+	varepsilon: "ε",
+	zeta: "ζ",
+	eta: "η",
+	theta: "θ",
+	vartheta: "ϑ",
+	iota: "ι",
+	kappa: "κ",
+	varkappa: "ϰ",
+	lambda: "λ",
+	mu: "μ",
+	nu: "ν",
+	xi: "ξ",
+	pi: "π",
+	varpi: "ϖ",
+	rho: "ρ",
+	varrho: "ϱ",
+	sigma: "σ",
+	varsigma: "ς",
+	tau: "τ",
+	upsilon: "υ",
+	phi: "ϕ",
+	varphi: "φ",
+	chi: "χ",
+	psi: "ψ",
+	omega: "ω",
+	Gamma: "Γ",
+	Delta: "Δ",
+	Theta: "Θ",
+	Lambda: "Λ",
+	Xi: "Ξ",
+	Pi: "Π",
+	Sigma: "Σ",
+	Upsilon: "Υ",
+	Phi: "Φ",
+	Psi: "Ψ",
+	Omega: "Ω",
+	pm: "±",
+	mp: "∓",
+	times: "×",
+	div: "÷",
+	cdot: "·",
+	ast: "∗",
+	star: "⋆",
+	circ: "∘",
+	bullet: "•",
+	oplus: "⊕",
+	ominus: "⊖",
+	otimes: "⊗",
+	oslash: "⊘",
+	odot: "⊙",
+	bigcirc: "○",
+	dagger: "†",
+	ddagger: "‡",
+	amalg: "⨿",
+	uplus: "⊎",
+	sqcap: "⊓",
+	sqcup: "⊔",
+	triangleleft: "◁",
+	triangleright: "▷",
+	wr: "≀",
+	cap: "∩",
+	cup: "∪",
+	bigcap: "⋂",
+	bigcup: "⋃",
+	bigwedge: "⋀",
+	bigvee: "⋁",
+	bigsqcup: "⨆",
+	biguplus: "⨄",
+	bigoplus: "⨁",
+	bigotimes: "⨂",
+	bigodot: "⨀",
+	setminus: "∖",
+	in: "∈",
+	notin: "∉",
+	ni: "∋",
+	subset: "⊂",
+	supset: "⊃",
+	subseteq: "⊆",
+	supseteq: "⊇",
+	sqsubset: "⊏",
+	sqsupset: "⊐",
+	sqsubseteq: "⊑",
+	sqsupseteq: "⊒",
+	prec: "≺",
+	preceq: "≼",
+	succ: "≻",
+	succeq: "≽",
+	ll: "≪",
+	gg: "≫",
+	le: "≤",
+	leq: "≤",
+	leqslant: "≤",
+	ge: "≥",
+	geq: "≥",
+	geqslant: "≥",
+	ne: "≠",
+	neq: "≠",
+	equiv: "≡",
+	approx: "≈",
+	sim: "∼",
+	simeq: "≃",
+	cong: "≅",
+	asymp: "≍",
+	doteq: "≐",
+	propto: "∝",
+	parallel: "∥",
+	perp: "⊥",
+	mid: "∣",
+	vdash: "⊢",
+	dashv: "⊣",
+	models: "⊨",
+	Vdash: "⊩",
+	Vvdash: "⊪",
+	nvdash: "⊬",
+	nvDash: "⊭",
+	forall: "∀",
+	exists: "∃",
+	nexists: "∄",
+	neg: "¬",
+	land: "∧",
+	wedge: "∧",
+	lor: "∨",
+	vee: "∨",
+	to: "→",
+	rightarrow: "→",
+	longrightarrow: "→",
+	leftarrow: "←",
+	longleftarrow: "←",
+	gets: "←",
+	leftrightarrow: "↔",
+	longleftrightarrow: "↔",
+	hookleftarrow: "↩",
+	hookrightarrow: "↪",
+	twoheadleftarrow: "↞",
+	twoheadrightarrow: "↠",
+	leftharpoonup: "↼",
+	leftharpoondown: "↽",
+	rightharpoonup: "⇀",
+	rightharpoondown: "⇁",
+	rightleftharpoons: "⇌",
+	leftrightharpoons: "⇋",
+	nearrow: "↗",
+	searrow: "↘",
+	swarrow: "↙",
+	nwarrow: "↖",
+	rightsquigarrow: "⇝",
+	leadsto: "⇝",
+	Rightarrow: "⇒",
+	Longrightarrow: "⇒",
+	Leftarrow: "⇐",
+	Longleftarrow: "⇐",
+	Leftrightarrow: "⇔",
+	Longleftrightarrow: "⇔",
+	implies: "⇒",
+	iff: "⇔",
+	mapsto: "↦",
+	longmapsto: "↦",
+	uparrow: "↑",
+	downarrow: "↓",
+	partial: "∂",
+	nabla: "∇",
+	int: "∫",
+	iint: "∬",
+	iiint: "∭",
+	oint: "∮",
+	sum: "∑",
+	prod: "∏",
+	coprod: "∐",
+	infty: "∞",
+	emptyset: "∅",
+	varnothing: "∅",
+	angle: "∠",
+	therefore: "∴",
+	because: "∵",
+	aleph: "ℵ",
+	beth: "ℶ",
+	gimel: "ℷ",
+	daleth: "ℸ",
+	top: "⊤",
+	bot: "⊥",
+	triangle: "△",
+	square: "□",
+	lozenge: "◊",
+	checkmark: "✓",
+	complement: "∁",
+	wp: "℘",
+	prime: "′",
+	ldots: "…",
+	dots: "…",
+	cdots: "⋯",
+	vdots: "⋮",
+	ddots: "⋱",
+	ell: "ℓ",
+	hbar: "ℏ",
+	Im: "ℑ",
+	Re: "ℜ",
+	langle: "⟨",
+	rangle: "⟩",
+	vert: "|",
+	lvert: "|",
+	rvert: "|",
+	Vert: "‖",
+	lVert: "‖",
+	rVert: "‖",
+	lbrace: "{",
+	rbrace: "}",
+	backslash: "\\",
+	lfloor: "⌊",
+	rfloor: "⌋",
+	lceil: "⌈",
+	rceil: "⌉",
+	colon: ":"
+};
+const NAMED_OPERATORS = /* @__PURE__ */ new Set([
+	"arccos",
+	"arcsin",
+	"arctan",
+	"arg",
+	"cos",
+	"cosh",
+	"cot",
+	"coth",
+	"csc",
+	"deg",
+	"det",
+	"dim",
+	"exp",
+	"gcd",
+	"hom",
+	"inf",
+	"ker",
+	"lg",
+	"lim",
+	"liminf",
+	"limsup",
+	"ln",
+	"log",
+	"max",
+	"min",
+	"Pr",
+	"sec",
+	"sin",
+	"sinh",
+	"sup",
+	"tan",
+	"tanh"
+]);
+const LIMIT_OPERATORS = /* @__PURE__ */ new Set([
+	"argmax",
+	"argmin",
+	"inf",
+	"injlim",
+	"lim",
+	"liminf",
+	"limsup",
+	"max",
+	"min",
+	"projlim",
+	"sup"
+]);
+const DISPLAY_LIMIT_SYMBOLS = /* @__PURE__ */ new Set([
+	"bigcap",
+	"bigcup",
+	"bigodot",
+	"bigoplus",
+	"bigotimes",
+	"bigsqcup",
+	"biguplus",
+	"bigvee",
+	"bigwedge",
+	"coprod",
+	"int",
+	"iint",
+	"iiint",
+	"oint",
+	"prod",
+	"sum"
+]);
+const RELATION_COMMANDS = /* @__PURE__ */ new Set([
+	"Leftarrow",
+	"Leftrightarrow",
+	"Longleftarrow",
+	"Longleftrightarrow",
+	"Longrightarrow",
+	"Rightarrow",
+	"Vdash",
+	"Vvdash",
+	"approx",
+	"asymp",
+	"cong",
+	"dashv",
+	"doteq",
+	"downarrow",
+	"equiv",
+	"ge",
+	"geq",
+	"geqslant",
+	"gets",
+	"gg",
+	"hookleftarrow",
+	"hookrightarrow",
+	"iff",
+	"implies",
+	"in",
+	"leadsto",
+	"le",
+	"leftarrow",
+	"leftharpoondown",
+	"leftharpoonup",
+	"leftrightarrow",
+	"leftrightharpoons",
+	"leq",
+	"leqslant",
+	"ll",
+	"longleftarrow",
+	"longleftrightarrow",
+	"longmapsto",
+	"longrightarrow",
+	"mapsto",
+	"mid",
+	"models",
+	"ne",
+	"nearrow",
+	"neq",
+	"ni",
+	"notin",
+	"nvdash",
+	"nvDash",
+	"nwarrow",
+	"parallel",
+	"perp",
+	"prec",
+	"preceq",
+	"propto",
+	"rightharpoondown",
+	"rightharpoonup",
+	"rightleftharpoons",
+	"rightarrow",
+	"rightsquigarrow",
+	"searrow",
+	"sim",
+	"simeq",
+	"sqsubset",
+	"sqsubseteq",
+	"sqsupset",
+	"sqsupseteq",
+	"subset",
+	"subseteq",
+	"succ",
+	"succeq",
+	"supset",
+	"supseteq",
+	"swarrow",
+	"to",
+	"triangleleft",
+	"triangleright",
+	"twoheadleftarrow",
+	"twoheadrightarrow",
+	"uparrow",
+	"vdash"
+]);
+const NEGATED_SYMBOLS = {
+	"<": "≮",
+	">": "≯",
+	"=": "≠",
+	"∈": "∉",
+	"∋": "∌",
+	"∣": "∤",
+	"∥": "∦",
+	"∼": "≁",
+	"≃": "≄",
+	"≅": "≇",
+	"≈": "≉",
+	"≡": "≢",
+	"≤": "≰",
+	"≥": "≱",
+	"≺": "⊀",
+	"≻": "⊁",
+	"⊂": "⊄",
+	"⊃": "⊅",
+	"⊆": "⊈",
+	"⊇": "⊉",
+	"⊢": "⊬",
+	"⊨": "⊭",
+	"↔": "↮",
+	"←": "↚",
+	"→": "↛",
+	"⇒": "⇏",
+	"⇐": "⇍",
+	"⇔": "⇎",
+	"≼": "⋠",
+	"≽": "⋡"
+};
+const BLACKBOARD = {
+	C: "ℂ",
+	H: "ℍ",
+	N: "ℕ",
+	P: "ℙ",
+	Q: "ℚ",
+	R: "ℝ",
+	Z: "ℤ"
+};
+const SUPERSCRIPTS = {
+	"0": "⁰",
+	"1": "¹",
+	"2": "²",
+	"3": "³",
+	"4": "⁴",
+	"5": "⁵",
+	"6": "⁶",
+	"7": "⁷",
+	"8": "⁸",
+	"9": "⁹",
+	"+": "⁺",
+	"-": "⁻",
+	"=": "⁼",
+	"(": "⁽",
+	")": "⁾",
+	a: "ᵃ",
+	b: "ᵇ",
+	c: "ᶜ",
+	d: "ᵈ",
+	e: "ᵉ",
+	f: "ᶠ",
+	g: "ᵍ",
+	h: "ʰ",
+	i: "ⁱ",
+	j: "ʲ",
+	k: "ᵏ",
+	l: "ˡ",
+	m: "ᵐ",
+	n: "ⁿ",
+	o: "ᵒ",
+	p: "ᵖ",
+	r: "ʳ",
+	s: "ˢ",
+	t: "ᵗ",
+	u: "ᵘ",
+	v: "ᵛ",
+	w: "ʷ",
+	x: "ˣ",
+	y: "ʸ",
+	z: "ᶻ"
+};
+const SUBSCRIPTS = {
+	"0": "₀",
+	"1": "₁",
+	"2": "₂",
+	"3": "₃",
+	"4": "₄",
+	"5": "₅",
+	"6": "₆",
+	"7": "₇",
+	"8": "₈",
+	"9": "₉",
+	"+": "₊",
+	"-": "₋",
+	"=": "₌",
+	"(": "₍",
+	")": "₎",
+	a: "ₐ",
+	e: "ₑ",
+	h: "ₕ",
+	i: "ᵢ",
+	j: "ⱼ",
+	k: "ₖ",
+	l: "ₗ",
+	m: "ₘ",
+	n: "ₙ",
+	o: "ₒ",
+	p: "ₚ",
+	r: "ᵣ",
+	s: "ₛ",
+	t: "ₜ",
+	u: "ᵤ",
+	v: "ᵥ",
+	x: "ₓ"
+};
+const SPACING_COMMANDS = /* @__PURE__ */ new Set([
+	",",
+	":",
+	";",
+	" ",
+	">",
+	"enspace",
+	"enskip",
+	"medspace",
+	"quad",
+	"qquad",
+	"thickspace",
+	"thinspace"
+]);
+const NEGATIVE_SPACING_COMMANDS = /* @__PURE__ */ new Set([
+	"!",
+	"negmedspace",
+	"negthickspace",
+	"negthinspace"
+]);
+const NEGATIVE_SPACE = "\0";
+const IGNORED_COMMANDS = /* @__PURE__ */ new Set([
+	"displaystyle",
+	"limits",
+	"nolimits",
+	"scriptstyle",
+	"scriptscriptstyle",
+	"textstyle"
+]);
+const SIZE_COMMANDS = /* @__PURE__ */ new Set([
+	"big",
+	"Big",
+	"bigg",
+	"Bigg",
+	"bigl",
+	"Bigl",
+	"biggl",
+	"Biggl",
+	"bigr",
+	"Bigr",
+	"biggr",
+	"Biggr"
+]);
+const PLAIN_WRAPPERS = /* @__PURE__ */ new Set([
+	"emph",
+	"mathcal",
+	"mathbf",
+	"mathfrak",
+	"mathit",
+	"mathrm",
+	"mathnormal",
+	"mathscr",
+	"mathsf",
+	"mathtt",
+	"mathup",
+	"mbox",
+	"overbrace",
+	"pmb",
+	"smash",
+	"substack",
+	"text",
+	"textbf",
+	"textit",
+	"textmd",
+	"textnormal",
+	"textrm",
+	"textsc",
+	"textsf",
+	"textsl",
+	"texttt",
+	"textup",
+	"underbrace",
+	"bm",
+	"boldsymbol"
+]);
+const ACCENTS = {
+	acute: "́",
+	bar: "̅",
+	breve: "̆",
+	check: "̌",
+	ddot: "̈",
+	dot: "̇",
+	grave: "̀",
+	hat: "̂",
+	mathring: "̊",
+	overleftarrow: "⃖",
+	overleftrightarrow: "⃡",
+	overline: "̅",
+	overrightarrow: "⃗",
+	tilde: "̃",
+	underline: "̲",
+	vec: "⃗",
+	widehat: "̂",
+	widetilde: "̃"
+};
+function replaceCharacters(value, replacements) {
+	let result = "";
+	for (const character of value) {
+		const replacement = replacements[character];
+		if (replacement === void 0) return;
+		result += replacement;
+	}
+	return result;
+}
+function formatScript(value, kind) {
+	value = value.trim();
+	const replacements = kind === "sub" ? SUBSCRIPTS : SUPERSCRIPTS;
+	const unicode = replaceCharacters(value.replace(/\s*([=+-])\s*/g, "$1"), replacements);
+	if (unicode !== void 0) return unicode;
+	const prefix = kind === "sub" ? "_" : "^";
+	if (Array.from(value).length === 1 || kind === "sub" && /^[A-Za-z]+$/.test(value)) return `${prefix}${value}`;
+	return `${prefix}(${value})`;
+}
+function formatFraction(numerator, denominator) {
+	numerator = numerator.trim();
+	denominator = denominator.trim();
+	const simpleNumerator = /^[\p{L}\p{N}.]+$/u.test(numerator);
+	const simpleDenominator = /^[\p{N}.]+$/u.test(denominator) || Array.from(denominator).length === 1;
+	return `${simpleNumerator ? numerator : `(${numerator})`}/${simpleDenominator ? denominator : `(${denominator})`}`;
+}
+function formatRoot(value, symbol = "√") {
+	value = value.trim();
+	return /^[\p{L}\p{N}.]+$/u.test(value) ? `${symbol}${value}` : `${symbol}(${value})`;
+}
+const NAMED_OPERATOR_START = "󰀄";
+const NAMED_OPERATOR_END = "󰀅";
+const NAMED_OPERATOR_LEFT_SPACING_PATTERN = /(?<=[\p{L}\p{N})\]}\u{f0001}])\u{f0004}/gu;
+const NAMED_OPERATOR_RIGHT_SPACING_PATTERN = /\u{f0005}(?=[\p{L}\p{N}√\u{f0000}])/gu;
+function normalizeOutput(value) {
+	return value.replace(NAMED_OPERATOR_LEFT_SPACING_PATTERN, " ").replaceAll(NAMED_OPERATOR_START, "").replace(NAMED_OPERATOR_RIGHT_SPACING_PATTERN, " ").replaceAll(NAMED_OPERATOR_END, "").split("\n").map((line) => line.replace(/[ \t]+/g, " ").trim()).filter((line, index, lines) => line.length > 0 || index > 0 && index < lines.length - 1).join("\n").trim();
+}
+const LAYOUT_MARKER_START = "󰀀";
+const LAYOUT_MARKER_END = "󰀁";
+const LAYOUT_MARKER_PATTERN = /\u{f0000}(\d+)\u{f0001}/gu;
+const TRAILING_LAYOUT_MARKER_PATTERN = /\u{f0000}(\d+)\u{f0001}$/u;
+const PROTECTED_SPACE = "󰀂";
+function padLayoutLine(line, width, centered = false) {
+	const padding = Math.max(0, width - visibleWidth(line));
+	const left = centered ? Math.floor(padding / 2) : 0;
+	return `${" ".repeat(left)}${line}${" ".repeat(padding - left)}`;
+}
+function joinLayouts(layouts) {
+	if (layouts.length === 0) return {
+		lines: [""],
+		width: 0,
+		baseline: 0
+	};
+	const baseline = Math.max(...layouts.map((layout) => layout.baseline));
+	const below = Math.max(...layouts.map((layout) => layout.lines.length - layout.baseline - 1));
+	const lines = [];
+	for (let row = 0; row <= baseline + below; row++) {
+		let line = "";
+		for (const layout of layouts) {
+			const sourceRow = row - baseline + layout.baseline;
+			line += sourceRow >= 0 && sourceRow < layout.lines.length ? padLayoutLine(layout.lines[sourceRow] ?? "", layout.width) : " ".repeat(layout.width);
+		}
+		lines.push(line.trimEnd());
+	}
+	return {
+		lines,
+		width: layouts.reduce((width, layout) => width + layout.width, 0),
+		baseline
+	};
+}
+function renderLayout(source, nodes) {
+	const renderedLines = [];
+	let firstBaseline = 0;
+	for (const sourceLine of source.split("\n")) {
+		const layouts = [];
+		let position = 0;
+		let previousNode;
+		for (const match of sourceLine.matchAll(LAYOUT_MARKER_PATTERN)) {
+			const index = match.index;
+			const node = nodes[Number(match[1])];
+			if (!node) continue;
+			if (index > position) {
+				const sliced = sourceLine.slice(position, index);
+				const trimmed = (previousNode ? sliced.trimStart() : sliced).trimEnd();
+				const preserveLeadingSpace = previousNode?.type === "matrix" && /^\s/.test(sliced);
+				const preserveTrailingSpace = node.type === "matrix" && /\s$/.test(sliced);
+				const text = trimmed ? `${preserveLeadingSpace ? " " : ""}${trimmed}${preserveTrailingSpace ? " " : ""}` : preserveLeadingSpace || preserveTrailingSpace ? " " : "";
+				layouts.push({
+					lines: [text],
+					width: visibleWidth(text),
+					baseline: 0
+				});
+			}
+			if (node.type === "fraction") {
+				const numerator = renderLayout(node.numerator, nodes);
+				const denominator = renderLayout(node.denominator, nodes);
+				const contentWidth = Math.max(numerator.width, denominator.width, 1);
+				const width = contentWidth + 2;
+				layouts.push({
+					lines: [
+						...numerator.lines.map((line) => padLayoutLine(line, width, true)),
+						` ${"─".repeat(contentWidth)} `,
+						...denominator.lines.map((line) => padLayoutLine(line, width, true))
+					],
+					width,
+					baseline: numerator.lines.length
+				});
+			} else if (node.type === "operator") {
+				const contentWidth = Math.max(visibleWidth(node.operator), node.lower === void 0 ? 0 : visibleWidth(node.lower), node.upper === void 0 ? 0 : visibleWidth(node.upper));
+				const lines = [];
+				if (node.upper !== void 0) lines.push(`${padLayoutLine(node.upper, contentWidth, true)} `);
+				lines.push(`${padLayoutLine(node.operator, contentWidth, true)} `);
+				if (node.lower !== void 0) lines.push(`${padLayoutLine(node.lower, contentWidth, true)} `);
+				layouts.push({
+					lines,
+					width: contentWidth + 1,
+					baseline: node.upper === void 0 ? 0 : 1
+				});
+			} else {
+				const width = Math.max(0, ...node.lines.map((line) => visibleWidth(line)));
+				layouts.push({
+					lines: node.lines.map((line) => padLayoutLine(line, width)),
+					width,
+					baseline: node.baseline
+				});
+			}
+			position = index + match[0].length;
+			previousNode = node;
+		}
+		if (position < sourceLine.length) {
+			const sliced = sourceLine.slice(position);
+			const trimmed = previousNode ? sliced.trimStart() : sliced;
+			const text = previousNode?.type === "matrix" && /^\s/.test(sliced) ? ` ${trimmed}` : trimmed;
+			layouts.push({
+				lines: [text],
+				width: visibleWidth(text),
+				baseline: 0
+			});
+		}
+		const lineLayout = joinLayouts(layouts);
+		if (renderedLines.length === 0) firstBaseline = lineLayout.baseline;
+		renderedLines.push(...lineLayout.lines);
+	}
+	return {
+		lines: renderedLines,
+		width: Math.max(0, ...renderedLines.map((line) => visibleWidth(line))),
+		baseline: firstBaseline
+	};
+}
+var LatexParser = class LatexParser {
+	source;
+	layoutNodes;
+	display;
+	position = 0;
+	supported = true;
+	stackFractions = true;
+	constructor(source, layoutNodes, display) {
+		this.source = source;
+		this.layoutNodes = layoutNodes;
+		this.display = display;
+	}
+	render() {
+		const rendered = this.parseSequence();
+		if (!this.supported || this.position !== this.source.length) return;
+		return normalizeOutput(rendered);
+	}
+	parseSequence(endCharacter) {
+		let result = "";
+		while (this.position < this.source.length) {
+			const character = this.source[this.position];
+			if (endCharacter && character === endCharacter) {
+				this.position++;
+				return result;
+			}
+			if (character === "}") {
+				this.supported = false;
+				return result;
+			}
+			if (character === "{") {
+				this.position++;
+				result += this.parseSequence("}");
+				continue;
+			}
+			if (character === "\\") {
+				const command = this.parseCommand();
+				if (command === NEGATIVE_SPACE) {
+					result = result.trimEnd();
+					if (result.endsWith(NAMED_OPERATOR_END)) result = result.slice(0, -2);
+				} else result += command;
+				continue;
+			}
+			if (character === "^" || character === "_") {
+				this.position++;
+				result = result.trimEnd();
+				const script = formatScript(this.parseRequiredArgument(false), character === "_" ? "sub" : "sup");
+				if (result.endsWith(NAMED_OPERATOR_END)) result = `${result.slice(0, -2)}${script}${NAMED_OPERATOR_END}`;
+				else result += script;
+				continue;
+			}
+			if (/\s/.test(character)) {
+				result += this.parseWhitespace();
+				continue;
+			}
+			if (character === "=" || character === "<" || character === ">") {
+				result = `${result.trimEnd()} ${character} `;
+				this.position++;
+				continue;
+			}
+			if (character === "&") {
+				this.position++;
+				continue;
+			}
+			if (character === "~") {
+				this.position++;
+				result += " ";
+				continue;
+			}
+			if (character === ".") {
+				const marker = TRAILING_LAYOUT_MARKER_PATTERN.exec(result);
+				const node = marker ? this.layoutNodes[Number(marker[1])] : void 0;
+				if (node?.type === "matrix") {
+					const lastLine = node.lines.length - 1;
+					node.lines[lastLine] = `${node.lines[lastLine] ?? ""}${character}`;
+					this.position++;
+					continue;
+				}
+			}
+			result += character;
+			this.position++;
+		}
+		if (endCharacter) this.supported = false;
+		return result;
+	}
+	parseWhitespace() {
+		while (this.position < this.source.length && /\s/.test(this.source[this.position] ?? "")) this.position++;
+		return " ";
+	}
+	parseCommand() {
+		this.position++;
+		if (this.position >= this.source.length) {
+			this.supported = false;
+			return "";
+		}
+		let command = "";
+		const first = this.source[this.position] ?? "";
+		if (first === "\n" || first === "\r") {
+			this.position++;
+			if (first === "\r" && this.source[this.position] === "\n") this.position++;
+			return " ";
+		}
+		if (/[A-Za-z]/.test(first)) {
+			const start = this.position;
+			while (this.position < this.source.length && /[A-Za-z]/.test(this.source[this.position] ?? "")) this.position++;
+			command = this.source.slice(start, this.position);
+		} else {
+			command = first;
+			this.position++;
+		}
+		if (command === "\\") return "\n";
+		if (SPACING_COMMANDS.has(command)) return " ";
+		if (NEGATIVE_SPACING_COMMANDS.has(command)) return NEGATIVE_SPACE;
+		if (IGNORED_COMMANDS.has(command)) return "";
+		if (command === "{" || command === "}" || command === "$" || command === "%" || command === "#" || command === "_" || command === "&") return command;
+		if (command === "|") return "‖";
+		if (command === "not") {
+			const value = this.parseRequiredArgument(false).trim();
+			const negated = NEGATED_SYMBOLS[value];
+			if (negated !== void 0) return ` ${negated} `;
+			const characters = Array.from(value);
+			if (characters.length === 0) {
+				this.supported = false;
+				return "";
+			}
+			return ` ${characters[0]}\u0338${characters.slice(1).join("")} `;
+		}
+		if (LIMIT_OPERATORS.has(command)) return this.parseOperator(command, "bracket", true, true);
+		const symbol = SYMBOLS[command];
+		if (symbol !== void 0) {
+			if (DISPLAY_LIMIT_SYMBOLS.has(command)) return this.parseOperator(symbol, "script", true);
+			return command === "cdot" || command === "times" || RELATION_COMMANDS.has(command) ? ` ${symbol} ` : symbol;
+		}
+		if (NAMED_OPERATORS.has(command)) return `${NAMED_OPERATOR_START}${command}${NAMED_OPERATOR_END}`;
+		if (SIZE_COMMANDS.has(command)) return "";
+		if (command === "left" || command === "middle" || command === "right") {
+			if (this.source[this.position] === ".") this.position++;
+			return "";
+		}
+		if (command === "frac" || command === "dfrac" || command === "tfrac") {
+			const shouldStack = this.display && this.stackFractions && command !== "tfrac";
+			const numerator = this.parseRequiredArgument(!shouldStack);
+			const denominator = this.parseRequiredArgument(!shouldStack);
+			if (shouldStack) {
+				const index = this.layoutNodes.push({
+					type: "fraction",
+					numerator: normalizeOutput(numerator),
+					denominator: normalizeOutput(denominator)
+				}) - 1;
+				return `${LAYOUT_MARKER_START}${index}${LAYOUT_MARKER_END}`;
+			}
+			return formatFraction(numerator, denominator);
+		}
+		if (command === "sqrt") {
+			const degree = this.parseOptionalArgument()?.trim();
+			const value = this.parseRequiredArgument();
+			if (degree === void 0 || degree === "2") return formatRoot(value);
+			if (degree === "3") return formatRoot(value, "∛");
+			if (degree === "4") return formatRoot(value, "∜");
+			return `${formatScript(degree, "sup")}${formatRoot(value)}`;
+		}
+		if (command === "boxed" || command === "fbox") return `[${this.parseRequiredArgument().trim()}]`;
+		if (command === "binom" || command === "dbinom" || command === "tbinom") return `(${this.parseRequiredArgument()} choose ${this.parseRequiredArgument()})`;
+		const accent = ACCENTS[command];
+		if (accent !== void 0) {
+			const value = this.parseRequiredArgument();
+			return Array.from(value).length === 1 ? `${value}${accent}` : `${command}(${value})`;
+		}
+		if (command === "mathbb") {
+			const value = this.parseRequiredArgument();
+			return Array.from(value, (character) => BLACKBOARD[character] ?? character).join("");
+		}
+		if (command === "operatorname") {
+			const starred = this.source[this.position] === "*";
+			if (starred) this.position++;
+			const operator = normalizeOutput(this.parseRequiredArgument()).trim();
+			return this.parseOperator(operator, "bracket", starred, true);
+		}
+		if (command === "mod" || command === "bmod") return " mod ";
+		if (command === "pmod" || command === "pod") {
+			const value = this.parseRequiredArgument().trim();
+			return command === "pmod" ? ` (mod ${value})` : ` (${value})`;
+		}
+		if (command === "overset" || command === "stackrel") {
+			const upper = this.parseRequiredArgument();
+			return `${this.parseRequiredArgument().trim()}${formatScript(upper, "sup")}`;
+		}
+		if (command === "underset") {
+			const lower = this.parseRequiredArgument();
+			return `${this.parseRequiredArgument().trim()}${formatScript(lower, "sub")}`;
+		}
+		if (PLAIN_WRAPPERS.has(command)) {
+			const value = this.parseRequiredArgument();
+			return command.startsWith("text") || command === "mbox" ? value : value.trim();
+		}
+		if (command === "begin") return this.parseEnvironment();
+		if (command === "end") {
+			this.supported = false;
+			return "";
+		}
+		this.supported = false;
+		return `\\${command}`;
+	}
+	parseOperator(operator, inlineLowerStyle, displayLimits, spaced = false) {
+		let useDisplayLimits = displayLimits;
+		let modifierPosition = this.position;
+		while (modifierPosition < this.source.length && /[ \t]/.test(this.source[modifierPosition] ?? "")) modifierPosition++;
+		const modifier = /^\\(limits|nolimits)(?![A-Za-z])/.exec(this.source.slice(modifierPosition));
+		if (modifier) {
+			useDisplayLimits = modifier[1] === "limits";
+			this.position = modifierPosition + modifier[0].length;
+		}
+		let lower;
+		let upper;
+		while (true) {
+			let scriptPosition = this.position;
+			while (scriptPosition < this.source.length && /[ \t]/.test(this.source[scriptPosition] ?? "")) scriptPosition++;
+			const kind = this.source[scriptPosition];
+			if (kind !== "_" && kind !== "^") break;
+			this.position = scriptPosition + 1;
+			const value = normalizeOutput(this.parseRequiredArgument(false)).replaceAll(" ", "");
+			if (kind === "_") {
+				if (lower !== void 0) this.supported = false;
+				lower = value;
+			} else {
+				if (upper !== void 0) this.supported = false;
+				upper = value;
+			}
+		}
+		if (this.display && useDisplayLimits && (lower !== void 0 || upper !== void 0)) {
+			const index = this.layoutNodes.push({
+				type: "operator",
+				operator,
+				lower,
+				upper
+			}) - 1;
+			return `${LAYOUT_MARKER_START}${index}${LAYOUT_MARKER_END}`;
+		}
+		let rendered = operator;
+		if (lower !== void 0) rendered += inlineLowerStyle === "bracket" ? `[${lower}]` : formatScript(lower, "sub");
+		if (upper !== void 0) rendered += formatScript(upper, "sup");
+		return spaced ? ` ${rendered} ` : rendered;
+	}
+	parseRequiredArgument(stackFractions = true) {
+		const previousStackFractions = this.stackFractions;
+		this.stackFractions = previousStackFractions && stackFractions;
+		const value = this.parseRequiredArgumentValue();
+		this.stackFractions = previousStackFractions;
+		return value;
+	}
+	parseRequiredArgumentValue() {
+		while (this.position < this.source.length && /\s/.test(this.source[this.position] ?? "")) this.position++;
+		if (this.position >= this.source.length) {
+			this.supported = false;
+			return "";
+		}
+		if (this.source[this.position] === "{") {
+			this.position++;
+			return this.parseSequence("}");
+		}
+		if (this.source[this.position] === "\\") return this.parseCommand();
+		const value = this.source[this.position] ?? "";
+		this.position++;
+		return value;
+	}
+	parseOptionalArgument() {
+		while (this.position < this.source.length && /[ \t]/.test(this.source[this.position] ?? "")) this.position++;
+		if (this.source[this.position] !== "[") return;
+		const end = this.source.indexOf("]", this.position + 1);
+		if (end < 0) {
+			this.supported = false;
+			return;
+		}
+		const value = this.source.slice(this.position + 1, end);
+		this.position = end + 1;
+		return this.renderNested(value);
+	}
+	readRawGroup() {
+		while (this.position < this.source.length && /[ \t]/.test(this.source[this.position] ?? "")) this.position++;
+		if (this.source[this.position] !== "{") {
+			this.supported = false;
+			return;
+		}
+		const start = ++this.position;
+		let depth = 1;
+		while (this.position < this.source.length) {
+			const character = this.source[this.position];
+			if (character === "\\") {
+				this.position += 2;
+				continue;
+			}
+			if (character === "{") depth++;
+			if (character === "}") depth--;
+			if (depth === 0) {
+				const value = this.source.slice(start, this.position);
+				this.position++;
+				return value;
+			}
+			this.position++;
+		}
+		this.supported = false;
+	}
+	splitEnvironmentRows(body) {
+		return body.split(/\\\\(?:\[[^\]\n]*\])?/);
+	}
+	parseEnvironment() {
+		const environment = this.readRawGroup();
+		if (!environment) return "";
+		const endMarker = `\\end{${environment}}`;
+		const end = this.source.indexOf(endMarker, this.position);
+		if (end < 0) {
+			this.supported = false;
+			return "";
+		}
+		const body = this.source.slice(this.position, end);
+		this.position = end + endMarker.length;
+		if (environment === "equation" || environment === "equation*" || environment === "displaymath") return this.renderNested(body).trim();
+		if (environment === "aligned" || environment === "align" || environment === "align*" || environment === "alignedat" || environment === "alignat" || environment === "alignat*" || environment === "gather" || environment === "gathered" || environment === "multline" || environment === "multline*" || environment === "split") {
+			const alignedAt = [
+				"alignedat",
+				"alignat",
+				"alignat*"
+			].includes(environment);
+			const alignedBody = alignedAt ? body.replace(/^\s*\{[^}]*\}/, "") : body;
+			return this.splitEnvironmentRows(alignedBody).map((row) => {
+				const cells = row.split("&");
+				const source = alignedAt ? Array.from({ length: Math.ceil(cells.length / 2) }, (_, index) => cells.slice(index * 2, index * 2 + 2).join("")).join(" ") : cells.join("");
+				return this.renderNested(source).trim();
+			}).filter(Boolean).join("\n");
+		}
+		if (environment === "cases" || environment === "cases*") {
+			const rows = this.splitEnvironmentRows(body).map((row) => row.split("&").map((cell) => this.renderNested(cell, false).trim())).filter((row) => row.some(Boolean));
+			return rows.map((row, index) => {
+				const value = (row[0] ?? "").replace(/,\s*$/, "");
+				const condition = row[1] ?? "";
+				const delimiter = index === 0 ? "⎧" : index === rows.length - 1 ? "⎩" : "⎨";
+				const conditionPrefix = /^(?:if|when|for|otherwise)\b/i.test(condition) ? " " : " if ";
+				return `${delimiter} ${value}${condition ? `${conditionPrefix}${condition}` : ""}`;
+			}).join("\n");
+		}
+		if ([
+			"array",
+			"matrix",
+			"smallmatrix",
+			"pmatrix",
+			"bmatrix",
+			"Bmatrix",
+			"vmatrix",
+			"Vmatrix"
+		].includes(environment)) {
+			const matrixBody = environment === "array" ? body.replace(/^\s*\{[^}]*\}/, "") : body;
+			return this.renderMatrix(environment, matrixBody);
+		}
+		this.supported = false;
+		return body;
+	}
+	renderMatrix(environment, body) {
+		const matrix = this.splitEnvironmentRows(body).map((row) => row.split("&").map((cell) => this.renderNested(cell, false).trim())).filter((row) => row.some(Boolean));
+		const columnCount = Math.max(0, ...matrix.map((row) => row.length));
+		const columnWidths = Array.from({ length: columnCount }, (_, column) => Math.max(0, ...matrix.map((row) => visibleWidth(row[column] ?? ""))));
+		const rows = matrix.map((row) => Array.from({ length: columnCount }, (_, column) => {
+			const cell = row[column] ?? "";
+			return `${cell}${PROTECTED_SPACE.repeat(Math.max(0, (columnWidths[column] ?? 0) - visibleWidth(cell)))}`;
+		}).join(" │ "));
+		let lines;
+		if (environment === "array" || environment === "matrix" || environment === "smallmatrix") lines = rows;
+		else {
+			const delimiter = {
+				pmatrix: [
+					"⎛",
+					"⎞",
+					"⎜",
+					"⎟",
+					"⎝",
+					"⎠"
+				],
+				bmatrix: [
+					"⎡",
+					"⎤",
+					"⎢",
+					"⎥",
+					"⎣",
+					"⎦"
+				],
+				Bmatrix: [
+					"⎧",
+					"⎫",
+					"⎨",
+					"⎬",
+					"⎩",
+					"⎭"
+				],
+				vmatrix: [
+					"│",
+					"│",
+					"│",
+					"│",
+					"│",
+					"│"
+				],
+				Vmatrix: [
+					"║",
+					"║",
+					"║",
+					"║",
+					"║",
+					"║"
+				]
+			}[environment];
+			if (!delimiter) {
+				this.supported = false;
+				return rows.join("\n");
+			}
+			lines = rows.map((row, index) => {
+				return `${index === 0 ? delimiter[0] : index === rows.length - 1 ? delimiter[4] : delimiter[2]} ${row} ${index === 0 ? delimiter[1] : index === rows.length - 1 ? delimiter[5] : delimiter[3]}`;
+			});
+		}
+		if (lines.length <= 1) return lines[0] ?? "";
+		const index = this.layoutNodes.push({
+			type: "matrix",
+			lines,
+			baseline: 0
+		}) - 1;
+		return `${LAYOUT_MARKER_START}${index}${LAYOUT_MARKER_END}`;
+	}
+	renderNested(source, stackFractions = true) {
+		const rendered = new LatexParser(source, this.layoutNodes, this.display && stackFractions).render();
+		if (rendered === void 0) {
+			this.supported = false;
+			return source;
+		}
+		return rendered;
+	}
+};
+/**
+* Render a basic LaTeX math expression as terminal-friendly Unicode text.
+* Returns undefined when the expression contains unsupported or malformed syntax.
+*/
+function renderLatex(source, options = {}) {
+	const layoutNodes = [];
+	const rendered = new LatexParser(source, layoutNodes, options.display === true).render();
+	if (rendered === void 0) return;
+	if (layoutNodes.length === 0) return rendered.replaceAll(PROTECTED_SPACE, " ");
+	const lines = renderLayout(rendered, layoutNodes).lines;
+	const indentation = Math.min(...lines.filter((line) => line.trim()).map((line) => line.length - line.trimStart().length));
+	return lines.map((line) => line.slice(indentation).trimEnd()).join("\n").trimEnd().replaceAll(PROTECTED_SPACE, " ");
+}
+//#endregion
+//#region src/compat/vendor/pi-tui-terminal-image.ts
+let cachedCapabilities = null;
+let cellDimensions = {
+	widthPx: 9,
+	heightPx: 18
+};
+function getCellDimensions() {
+	return cellDimensions;
+}
+function setCellDimensions(dims) {
+	cellDimensions = dims;
+}
+/**
+* Checks whether the attached tmux client forwards OSC 8 hyperlinks to the
+* outer terminal. tmux only re-emits them when its `client_termfeatures` lists
+* `hyperlinks`, and strips them otherwise. On any error fallbacks `false`.
+*/
+function probeTmuxHyperlinks() {
+	try {
+		return execSync("tmux display-message -p '#{client_termfeatures}'", {
+			encoding: "utf8",
+			timeout: 250,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).split(",").map((feature) => feature.trim()).includes("hyperlinks");
+	} catch {
+		return false;
+	}
+}
+function detectCapabilities(tmuxForwardsHyperlink = probeTmuxHyperlinks) {
+	const termProgram = process.env.TERM_PROGRAM?.toLowerCase() || "";
+	const terminalEmulator = process.env.TERMINAL_EMULATOR?.toLowerCase() || "";
+	const term = process.env.TERM?.toLowerCase() || "";
+	const colorTerm = process.env.COLORTERM?.toLowerCase() || "";
+	const hasTrueColorHint = colorTerm === "truecolor" || colorTerm === "24bit";
+	const isWindowsConsole = process.platform === "win32";
+	if (process.env.TMUX || term.startsWith("tmux")) return {
+		images: null,
+		trueColor: hasTrueColorHint,
+		hyperlinks: tmuxForwardsHyperlink()
+	};
+	if (term.startsWith("screen")) return {
+		images: null,
+		trueColor: hasTrueColorHint,
+		hyperlinks: false
+	};
+	if (process.env.KITTY_WINDOW_ID || termProgram === "kitty") return {
+		images: "kitty",
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (termProgram === "ghostty" || term.includes("ghostty") || process.env.GHOSTTY_RESOURCES_DIR) return {
+		images: "kitty",
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (process.env.WEZTERM_PANE || termProgram === "wezterm") return {
+		images: "kitty",
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (termProgram === "warpterminal" || process.env.WARP_SESSION_ID || process.env.WARP_TERMINAL_SESSION_UUID) return {
+		images: "kitty",
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (process.env.ITERM_SESSION_ID || termProgram === "iterm.app") return {
+		images: "iterm2",
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (process.env.WT_SESSION) return {
+		images: null,
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (termProgram === "vscode") return {
+		images: null,
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (termProgram === "alacritty") return {
+		images: null,
+		trueColor: true,
+		hyperlinks: true
+	};
+	if (terminalEmulator === "jetbrains-jediterm") return {
+		images: null,
+		trueColor: true,
+		hyperlinks: false
+	};
+	if (isWindowsConsole) return {
+		images: null,
+		trueColor: true,
+		hyperlinks: false
+	};
+	return {
+		images: null,
+		trueColor: hasTrueColorHint,
+		hyperlinks: false
+	};
+}
+function getCapabilities() {
+	if (!cachedCapabilities) cachedCapabilities = detectCapabilities();
+	return cachedCapabilities;
+}
+function resetCapabilitiesCache() {
+	cachedCapabilities = null;
+}
+/** Override the cached capabilities. Useful in tests to exercise both code paths. */
+function setCapabilities(caps) {
+	cachedCapabilities = caps;
+}
+/**
+* Generate a random image ID for Kitty graphics protocol.
+* Uses random IDs to avoid collisions between different module instances
+* (e.g., main app vs extensions).
+*/
+function allocateImageId() {
+	return Math.floor(Math.random() * 4294967294) + 1;
+}
+function encodeKitty(base64Data, options = {}) {
+	const CHUNK_SIZE = 4096;
+	const params = [
+		"a=T",
+		"f=100",
+		"q=2"
+	];
+	if (options.moveCursor === false) params.push("C=1");
+	if (options.columns) params.push(`c=${options.columns}`);
+	if (options.rows) params.push(`r=${options.rows}`);
+	if (options.imageId) params.push(`i=${options.imageId}`);
+	if (base64Data.length <= CHUNK_SIZE) return `\x1b_G${params.join(",")};${base64Data}\x1b\\`;
+	const chunks = [];
+	let offset = 0;
+	let isFirst = true;
+	while (offset < base64Data.length) {
+		const chunk = base64Data.slice(offset, offset + CHUNK_SIZE);
+		const isLast = offset + CHUNK_SIZE >= base64Data.length;
+		if (isFirst) {
+			chunks.push(`\x1b_G${params.join(",")},m=1;${chunk}\x1b\\`);
+			isFirst = false;
+		} else if (isLast) chunks.push(`\x1b_Gm=0;${chunk}\x1b\\`);
+		else chunks.push(`\x1b_Gm=1;${chunk}\x1b\\`);
+		offset += CHUNK_SIZE;
+	}
+	return chunks.join("");
+}
+/**
+* Delete a Kitty graphics image by ID.
+* Uses uppercase 'I' to also free the image data.
+*/
+function deleteKittyImage(imageId) {
+	return `\x1b_Ga=d,d=I,i=${imageId},q=2\x1b\\`;
+}
+/**
+* Delete all visible Kitty graphics images.
+* Uses uppercase 'A' to also free the image data.
+*/
+function deleteAllKittyImages() {
+	return "\x1B_Ga=d,d=A,q=2\x1B\\";
+}
+function encodeITerm2(base64Data, options = {}) {
+	const params = [`inline=${options.inline !== false ? 1 : 0}`, `size=${Buffer.byteLength(base64Data, "base64")}`];
+	if (options.width !== void 0) params.push(`width=${options.width}`);
+	if (options.height !== void 0) params.push(`height=${options.height}`);
+	if (options.name) {
+		const nameBase64 = Buffer.from(options.name).toString("base64");
+		params.push(`name=${nameBase64}`);
+	}
+	if (options.preserveAspectRatio === false) params.push("preserveAspectRatio=0");
+	return `\x1b]1337;File=${params.join(";")}:${base64Data}\x07`;
+}
+function calculateImageCellSize(imageDimensions, maxWidthCells, maxHeightCells, cellDimensions = {
+	widthPx: 9,
+	heightPx: 18
+}) {
+	const maxWidth = Math.max(1, Math.floor(maxWidthCells));
+	const maxHeight = maxHeightCells === void 0 ? void 0 : Math.max(1, Math.floor(maxHeightCells));
+	const imageWidth = Math.max(1, imageDimensions.widthPx);
+	const imageHeight = Math.max(1, imageDimensions.heightPx);
+	const widthScale = maxWidth * cellDimensions.widthPx / imageWidth;
+	const heightScale = maxHeight === void 0 ? widthScale : maxHeight * cellDimensions.heightPx / imageHeight;
+	const scale = Math.min(widthScale, heightScale);
+	const scaledWidthPx = imageWidth * scale;
+	const scaledHeightPx = imageHeight * scale;
+	const columns = Math.ceil(scaledWidthPx / cellDimensions.widthPx);
+	const rows = Math.ceil(scaledHeightPx / cellDimensions.heightPx);
+	return {
+		columns: Math.max(1, Math.min(maxWidth, columns)),
+		rows: Math.max(1, maxHeight === void 0 ? rows : Math.min(maxHeight, rows))
+	};
+}
+function calculateImageRows(imageDimensions, targetWidthCells, cellDimensions = {
+	widthPx: 9,
+	heightPx: 18
+}) {
+	return calculateImageCellSize(imageDimensions, targetWidthCells, void 0, cellDimensions).rows;
+}
+function getPngDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 24) return null;
+		if (buffer[0] !== 137 || buffer[1] !== 80 || buffer[2] !== 78 || buffer[3] !== 71) return null;
+		return {
+			widthPx: buffer.readUInt32BE(16),
+			heightPx: buffer.readUInt32BE(20)
+		};
+	} catch {
+		return null;
+	}
+}
+function getJpegDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 2) return null;
+		if (buffer[0] !== 255 || buffer[1] !== 216) return null;
+		let offset = 2;
+		while (offset < buffer.length - 9) {
+			if (buffer[offset] !== 255) {
+				offset++;
+				continue;
+			}
+			const marker = buffer[offset + 1];
+			if (marker >= 192 && marker <= 194) {
+				const height = buffer.readUInt16BE(offset + 5);
+				return {
+					widthPx: buffer.readUInt16BE(offset + 7),
+					heightPx: height
+				};
+			}
+			if (offset + 3 >= buffer.length) return null;
+			const length = buffer.readUInt16BE(offset + 2);
+			if (length < 2) return null;
+			offset += 2 + length;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+function getGifDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 10) return null;
+		const sig = buffer.slice(0, 6).toString("ascii");
+		if (sig !== "GIF87a" && sig !== "GIF89a") return null;
+		return {
+			widthPx: buffer.readUInt16LE(6),
+			heightPx: buffer.readUInt16LE(8)
+		};
+	} catch {
+		return null;
+	}
+}
+function getWebpDimensions(base64Data) {
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		if (buffer.length < 30) return null;
+		const riff = buffer.slice(0, 4).toString("ascii");
+		const webp = buffer.slice(8, 12).toString("ascii");
+		if (riff !== "RIFF" || webp !== "WEBP") return null;
+		const chunk = buffer.slice(12, 16).toString("ascii");
+		if (chunk === "VP8 ") {
+			if (buffer.length < 30) return null;
+			return {
+				widthPx: buffer.readUInt16LE(26) & 16383,
+				heightPx: buffer.readUInt16LE(28) & 16383
+			};
+		} else if (chunk === "VP8L") {
+			if (buffer.length < 25) return null;
+			const bits = buffer.readUInt32LE(21);
+			return {
+				widthPx: (bits & 16383) + 1,
+				heightPx: (bits >> 14 & 16383) + 1
+			};
+		} else if (chunk === "VP8X") {
+			if (buffer.length < 30) return null;
+			return {
+				widthPx: (buffer[24] | buffer[25] << 8 | buffer[26] << 16) + 1,
+				heightPx: (buffer[27] | buffer[28] << 8 | buffer[29] << 16) + 1
+			};
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+function getImageDimensions(base64Data, mimeType) {
+	if (mimeType === "image/png") return getPngDimensions(base64Data);
+	if (mimeType === "image/jpeg") return getJpegDimensions(base64Data);
+	if (mimeType === "image/gif") return getGifDimensions(base64Data);
+	if (mimeType === "image/webp") return getWebpDimensions(base64Data);
+	return null;
+}
+/**
+* Wrap text in an OSC 8 hyperlink sequence.
+* The text is rendered as a clickable hyperlink in terminals that support OSC 8
+* (Ghostty, Kitty, WezTerm, iTerm2, VSCode, and others).
+* In terminals that do not support OSC 8, the escape sequences are ignored
+* and only the plain text is displayed.
+*
+* @param text - The visible text to display
+* @param url - The URL to link to
+*/
+function hyperlink(text, url) {
+	return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
+}
+/** Shorten home-prefixed absolute paths to ~/... for compact display. */
+function shortenImagePath(filename) {
+	const home = homedir();
+	if (home && (filename === home || filename.startsWith(`${home}/`) || filename.startsWith(`${home}\\`))) return `~${filename.slice(home.length)}`;
+	return filename;
+}
+/**
+* Text fallback when the terminal cannot render inline images.
+* Absolute paths are shown shortened (~/...) and, when OSC 8 hyperlinks are
+* available, linked to file:// so the full path remains openable.
+*/
+function imageFallback(mimeType, dimensions, filename) {
+	const parts = [];
+	if (filename) {
+		const display = shortenImagePath(filename);
+		if (getCapabilities().hyperlinks && isAbsolute(filename)) parts.push(hyperlink(display, pathToFileURL(filename).href));
+		else parts.push(display);
+	}
+	parts.push(`[${mimeType}]`);
+	if (dimensions) parts.push(`${dimensions.widthPx}x${dimensions.heightPx}`);
+	return `[Image: ${parts.join(" ")}]`;
+}
+//#endregion
+//#region src/compat/vendor/pi-tui-autocomplete.ts
+const PATH_DELIMITERS = /* @__PURE__ */ new Set([
+	" ",
+	"	",
+	"\"",
+	"'",
+	"="
+]);
+function toDisplayPath(value) {
+	return value.replace(/\\/g, "/");
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildFdPathQuery(query) {
+	const normalized = toDisplayPath(query);
+	if (!normalized.includes("/")) return normalized;
+	const hasTrailingSeparator = normalized.endsWith("/");
+	const trimmed = normalized.replace(/^\/+|\/+$/g, "");
+	if (!trimmed) return normalized;
+	const separatorPattern = "[\\\\/]";
+	const segments = trimmed.split("/").filter(Boolean).map((segment) => escapeRegex(segment));
+	if (segments.length === 0) return normalized;
+	let pattern = segments.join(separatorPattern);
+	if (hasTrailingSeparator) pattern += separatorPattern;
+	return pattern;
+}
+function findLastDelimiter(text) {
+	for (let i = text.length - 1; i >= 0; i -= 1) if (PATH_DELIMITERS.has(text[i] ?? "")) return i;
+	return -1;
+}
+function findUnclosedQuoteStart(text) {
+	let inQuotes = false;
+	let quoteStart = -1;
+	for (let i = 0; i < text.length; i += 1) if (text[i] === "\"") {
+		inQuotes = !inQuotes;
+		if (inQuotes) quoteStart = i;
+	}
+	return inQuotes ? quoteStart : null;
+}
+function isTokenStart(text, index) {
+	return index === 0 || PATH_DELIMITERS.has(text[index - 1] ?? "");
+}
+function extractQuotedPrefix(text) {
+	const quoteStart = findUnclosedQuoteStart(text);
+	if (quoteStart === null) return null;
+	if (quoteStart > 0 && text[quoteStart - 1] === "@") {
+		if (!isTokenStart(text, quoteStart - 1)) return null;
+		return text.slice(quoteStart - 1);
+	}
+	if (!isTokenStart(text, quoteStart)) return null;
+	return text.slice(quoteStart);
+}
+function parsePathPrefix(prefix) {
+	if (prefix.startsWith("@\"")) return {
+		rawPrefix: prefix.slice(2),
+		isAtPrefix: true,
+		isQuotedPrefix: true
+	};
+	if (prefix.startsWith("\"")) return {
+		rawPrefix: prefix.slice(1),
+		isAtPrefix: false,
+		isQuotedPrefix: true
+	};
+	if (prefix.startsWith("@")) return {
+		rawPrefix: prefix.slice(1),
+		isAtPrefix: true,
+		isQuotedPrefix: false
+	};
+	return {
+		rawPrefix: prefix,
+		isAtPrefix: false,
+		isQuotedPrefix: false
+	};
+}
+function buildCompletionValue(path, options) {
+	const needsQuotes = options.isQuotedPrefix || path.includes(" ");
+	const prefix = options.isAtPrefix ? "@" : "";
+	if (!needsQuotes) return `${prefix}${path}`;
+	return `${`${prefix}"`}${path}"`;
+}
+async function walkDirectoryWithFd(baseDir, fdPath, query, maxResults, signal) {
+	const args = [
+		"--base-directory",
+		baseDir,
+		"--max-results",
+		String(maxResults),
+		"--type",
+		"f",
+		"--type",
+		"d",
+		"--follow",
+		"--hidden",
+		"--exclude",
+		".git",
+		"--exclude",
+		".git/*",
+		"--exclude",
+		".git/**"
+	];
+	if (toDisplayPath(query).includes("/")) args.push("--full-path");
+	if (query) args.push(buildFdPathQuery(query));
+	return await new Promise((resolve) => {
+		if (signal.aborted) {
+			resolve([]);
+			return;
+		}
+		const child = spawn(fdPath, args, { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let resolved = false;
+		const finish = (results) => {
+			if (resolved) return;
+			resolved = true;
+			signal.removeEventListener("abort", onAbort);
+			resolve(results);
+		};
+		const onAbort = () => {
+			if (child.exitCode === null) child.kill("SIGKILL");
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		child.stdout.setEncoding("utf-8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.on("error", () => {
+			finish([]);
+		});
+		child.on("close", (code) => {
+			if (signal.aborted || code !== 0 || !stdout) {
+				finish([]);
+				return;
+			}
+			const lines = stdout.trim().split("\n").filter(Boolean);
+			const results = [];
+			for (const line of lines) {
+				const displayLine = toDisplayPath(line);
+				const hasTrailingSeparator = displayLine.endsWith("/");
+				const normalizedPath = hasTrailingSeparator ? displayLine.slice(0, -1) : displayLine;
+				if (normalizedPath === ".git" || normalizedPath.startsWith(".git/") || normalizedPath.includes("/.git/")) continue;
+				results.push({
+					path: displayLine,
+					isDirectory: hasTrailingSeparator
+				});
+			}
+			finish(results);
+		});
+	});
+}
+var CombinedAutocompleteProvider = class {
+	commands;
+	basePath;
+	fdPath;
+	constructor(commands = [], basePath, fdPath = null) {
+		this.commands = commands;
+		this.basePath = basePath;
+		this.fdPath = fdPath;
+	}
+	async getSuggestions(lines, cursorLine, cursorCol, options) {
+		const textBeforeCursor = (lines[cursorLine] || "").slice(0, cursorCol);
+		const atPrefix = this.extractAtPrefix(textBeforeCursor);
+		if (atPrefix) {
+			const { rawPrefix, isQuotedPrefix } = parsePathPrefix(atPrefix);
+			const suggestions = await this.getFuzzyFileSuggestions(rawPrefix, {
+				isQuotedPrefix,
+				signal: options.signal
+			});
+			if (suggestions.length === 0) return null;
+			return {
+				items: suggestions,
+				prefix: atPrefix
+			};
+		}
+		if (!options.force && textBeforeCursor.startsWith("/")) {
+			const spaceIndex = textBeforeCursor.indexOf(" ");
+			if (spaceIndex === -1) {
+				const prefix = textBeforeCursor.slice(1);
+				const filtered = fuzzyFilter(this.commands.map((cmd) => {
+					const name = "name" in cmd ? cmd.name : cmd.value;
+					const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : void 0;
+					const desc = cmd.description ?? "";
+					return {
+						name,
+						label: name,
+						description: (hint ? desc ? `${hint} — ${desc}` : hint : desc) || void 0
+					};
+				}), prefix, (item) => item.name).map((item) => ({
+					value: item.name,
+					label: item.label,
+					...item.description && { description: item.description }
+				}));
+				if (filtered.length === 0) return null;
+				return {
+					items: filtered,
+					prefix: textBeforeCursor
+				};
+			}
+			const commandName = textBeforeCursor.slice(1, spaceIndex);
+			const argumentText = textBeforeCursor.slice(spaceIndex + 1);
+			const command = this.commands.find((cmd) => {
+				return ("name" in cmd ? cmd.name : cmd.value) === commandName;
+			});
+			if (!command || !("getArgumentCompletions" in command) || !command.getArgumentCompletions) return null;
+			const argumentSuggestions = await command.getArgumentCompletions(argumentText);
+			if (!Array.isArray(argumentSuggestions) || argumentSuggestions.length === 0) return null;
+			return {
+				items: argumentSuggestions,
+				prefix: argumentText
+			};
+		}
+		const pathMatch = this.extractPathPrefix(textBeforeCursor, options.force ?? false);
+		if (pathMatch === null) return null;
+		const suggestions = this.getFileSuggestions(pathMatch);
+		if (suggestions.length === 0) return null;
+		return {
+			items: suggestions,
+			prefix: pathMatch
+		};
+	}
+	applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+		const currentLine = lines[cursorLine] || "";
+		const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+		const afterCursor = currentLine.slice(cursorCol);
+		const isQuotedPrefix = prefix.startsWith("\"") || prefix.startsWith("@\"");
+		const hasLeadingQuoteAfterCursor = afterCursor.startsWith("\"");
+		const hasTrailingQuoteInItem = item.value.endsWith("\"");
+		const adjustedAfterCursor = isQuotedPrefix && hasTrailingQuoteInItem && hasLeadingQuoteAfterCursor ? afterCursor.slice(1) : afterCursor;
+		if (prefix.startsWith("/") && beforePrefix.trim() === "" && !prefix.slice(1).includes("/")) {
+			const newLine = `${beforePrefix}/${item.value} ${adjustedAfterCursor}`;
+			const newLines = [...lines];
+			newLines[cursorLine] = newLine;
+			return {
+				lines: newLines,
+				cursorLine,
+				cursorCol: beforePrefix.length + item.value.length + 2
+			};
+		}
+		if (prefix.startsWith("@")) {
+			const isDirectory = item.label.endsWith("/");
+			const suffix = isDirectory ? "" : " ";
+			const newLine = `${beforePrefix + item.value}${suffix}${adjustedAfterCursor}`;
+			const newLines = [...lines];
+			newLines[cursorLine] = newLine;
+			const hasTrailingQuote = item.value.endsWith("\"");
+			const cursorOffset = isDirectory && hasTrailingQuote ? item.value.length - 1 : item.value.length;
+			return {
+				lines: newLines,
+				cursorLine,
+				cursorCol: beforePrefix.length + cursorOffset + suffix.length
+			};
+		}
+		const textBeforeCursor = currentLine.slice(0, cursorCol);
+		if (textBeforeCursor.includes("/") && textBeforeCursor.includes(" ")) {
+			const newLine = beforePrefix + item.value + adjustedAfterCursor;
+			const newLines = [...lines];
+			newLines[cursorLine] = newLine;
+			const isDirectory = item.label.endsWith("/");
+			const hasTrailingQuote = item.value.endsWith("\"");
+			const cursorOffset = isDirectory && hasTrailingQuote ? item.value.length - 1 : item.value.length;
+			return {
+				lines: newLines,
+				cursorLine,
+				cursorCol: beforePrefix.length + cursorOffset
+			};
+		}
+		const newLine = beforePrefix + item.value + adjustedAfterCursor;
+		const newLines = [...lines];
+		newLines[cursorLine] = newLine;
+		const isDirectory = item.label.endsWith("/");
+		const hasTrailingQuote = item.value.endsWith("\"");
+		const cursorOffset = isDirectory && hasTrailingQuote ? item.value.length - 1 : item.value.length;
+		return {
+			lines: newLines,
+			cursorLine,
+			cursorCol: beforePrefix.length + cursorOffset
+		};
+	}
+	extractAtPrefix(text) {
+		const quotedPrefix = extractQuotedPrefix(text);
+		if (quotedPrefix?.startsWith("@\"")) return quotedPrefix;
+		const lastDelimiterIndex = findLastDelimiter(text);
+		const tokenStart = lastDelimiterIndex === -1 ? 0 : lastDelimiterIndex + 1;
+		if (text[tokenStart] === "@") return text.slice(tokenStart);
+		return null;
+	}
+	extractPathPrefix(text, forceExtract = false) {
+		const quotedPrefix = extractQuotedPrefix(text);
+		if (quotedPrefix) return quotedPrefix;
+		const lastDelimiterIndex = findLastDelimiter(text);
+		const pathPrefix = lastDelimiterIndex === -1 ? text : text.slice(lastDelimiterIndex + 1);
+		if (forceExtract) return pathPrefix;
+		if (pathPrefix.includes("/") || pathPrefix.startsWith(".") || pathPrefix.startsWith("~/")) return pathPrefix;
+		if (pathPrefix === "" && text.endsWith(" ")) return pathPrefix;
+		return null;
+	}
+	expandHomePath(path) {
+		if (path.startsWith("~/")) {
+			const expandedPath = join$1(homedir$1(), path.slice(2));
+			return path.endsWith("/") && !expandedPath.endsWith("/") ? `${expandedPath}/` : expandedPath;
+		} else if (path === "~") return homedir$1();
+		return path;
+	}
+	resolveScopedFuzzyQuery(rawQuery) {
+		const normalizedQuery = toDisplayPath(rawQuery);
+		const slashIndex = normalizedQuery.lastIndexOf("/");
+		if (slashIndex === -1) return null;
+		const displayBase = normalizedQuery.slice(0, slashIndex + 1);
+		const query = normalizedQuery.slice(slashIndex + 1);
+		let baseDir;
+		if (displayBase.startsWith("~/")) baseDir = this.expandHomePath(displayBase);
+		else if (displayBase.startsWith("/")) baseDir = displayBase;
+		else baseDir = join$1(this.basePath, displayBase);
+		try {
+			if (!statSync(baseDir).isDirectory()) return null;
+		} catch {
+			return null;
+		}
+		return {
+			baseDir,
+			query,
+			displayBase
+		};
+	}
+	scopedPathForDisplay(displayBase, relativePath) {
+		const normalizedRelativePath = toDisplayPath(relativePath);
+		if (displayBase === "/") return `/${normalizedRelativePath}`;
+		return `${toDisplayPath(displayBase)}${normalizedRelativePath}`;
+	}
+	getFileSuggestions(prefix) {
+		try {
+			let searchDir;
+			let searchPrefix;
+			const { rawPrefix, isAtPrefix, isQuotedPrefix } = parsePathPrefix(prefix);
+			let expandedPrefix = rawPrefix;
+			if (expandedPrefix.startsWith("~")) expandedPrefix = this.expandHomePath(expandedPrefix);
+			if (rawPrefix === "" || rawPrefix === "./" || rawPrefix === "../" || rawPrefix === "~" || rawPrefix === "~/" || rawPrefix === "/" || isAtPrefix && rawPrefix === "") {
+				if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) searchDir = expandedPrefix;
+				else searchDir = join$1(this.basePath, expandedPrefix);
+				searchPrefix = "";
+			} else if (rawPrefix.endsWith("/")) {
+				if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) searchDir = expandedPrefix;
+				else searchDir = join$1(this.basePath, expandedPrefix);
+				searchPrefix = "";
+			} else {
+				const dir = dirname$1(expandedPrefix);
+				const file = basename$1(expandedPrefix);
+				if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) searchDir = dir;
+				else searchDir = join$1(this.basePath, dir);
+				searchPrefix = file;
+			}
+			const entries = readdirSync(searchDir, { withFileTypes: true });
+			const suggestions = [];
+			for (const entry of entries) {
+				if (!entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase())) continue;
+				let isDirectory = entry.isDirectory();
+				if (!isDirectory && entry.isSymbolicLink()) try {
+					const fullPath = join$1(searchDir, entry.name);
+					isDirectory = statSync(fullPath).isDirectory();
+				} catch {}
+				let relativePath;
+				const name = entry.name;
+				const displayPrefix = rawPrefix;
+				if (displayPrefix.endsWith("/")) relativePath = displayPrefix + name;
+				else if (displayPrefix.includes("/") || displayPrefix.includes("\\")) {
+					if (displayPrefix.startsWith("~/")) {
+						const homeRelativeDir = displayPrefix.slice(2);
+						const dir = dirname$1(homeRelativeDir);
+						relativePath = `~/${dir === "." ? name : join$1(dir, name)}`;
+					} else if (displayPrefix.startsWith("/")) {
+						const dir = dirname$1(displayPrefix);
+						if (dir === "/") relativePath = `/${name}`;
+						else relativePath = `${dir}/${name}`;
+					} else {
+						relativePath = join$1(dirname$1(displayPrefix), name);
+						if (displayPrefix.startsWith("./") && !relativePath.startsWith("./")) relativePath = `./${relativePath}`;
+					}
+				} else if (displayPrefix.startsWith("~")) relativePath = `~/${name}`;
+				else relativePath = name;
+				relativePath = toDisplayPath(relativePath);
+				const value = buildCompletionValue(isDirectory ? `${relativePath}/` : relativePath, {
+					isDirectory,
+					isAtPrefix,
+					isQuotedPrefix
+				});
+				suggestions.push({
+					value,
+					label: name + (isDirectory ? "/" : "")
+				});
+			}
+			suggestions.sort((a, b) => {
+				const aIsDir = a.value.endsWith("/");
+				const bIsDir = b.value.endsWith("/");
+				if (aIsDir && !bIsDir) return -1;
+				if (!aIsDir && bIsDir) return 1;
+				return a.label.localeCompare(b.label);
+			});
+			return suggestions;
+		} catch (_e) {
+			return [];
+		}
+	}
+	scoreEntry(filePath, query, isDirectory) {
+		const lowerFileName = basename$1(filePath).toLowerCase();
+		const lowerQuery = query.toLowerCase();
+		let score = 0;
+		if (lowerFileName === lowerQuery) score = 100;
+		else if (lowerFileName.startsWith(lowerQuery)) score = 80;
+		else if (lowerFileName.includes(lowerQuery)) score = 50;
+		else if (filePath.toLowerCase().includes(lowerQuery)) score = 30;
+		if (isDirectory && score > 0) score += 10;
+		return score;
+	}
+	async getFuzzyFileSuggestions(query, options) {
+		if (!this.fdPath || options.signal.aborted) return [];
+		try {
+			const scopedQuery = this.resolveScopedFuzzyQuery(query);
+			const fdBaseDir = scopedQuery?.baseDir ?? this.basePath;
+			const fdQuery = scopedQuery?.query ?? query;
+			const entries = await walkDirectoryWithFd(fdBaseDir, this.fdPath, fdQuery, 100, options.signal);
+			if (options.signal.aborted) return [];
+			const scoredEntries = entries.map((entry) => ({
+				...entry,
+				score: fdQuery ? this.scoreEntry(entry.path, fdQuery, entry.isDirectory) : 1
+			})).filter((entry) => entry.score > 0);
+			scoredEntries.sort((a, b) => b.score - a.score);
+			const topEntries = scoredEntries.slice(0, 20);
+			const suggestions = [];
+			for (const { path: entryPath, isDirectory } of topEntries) {
+				const pathWithoutSlash = isDirectory ? entryPath.slice(0, -1) : entryPath;
+				const displayPath = scopedQuery ? this.scopedPathForDisplay(scopedQuery.displayBase, pathWithoutSlash) : pathWithoutSlash;
+				const entryName = basename$1(pathWithoutSlash);
+				const value = buildCompletionValue(isDirectory ? `${displayPath}/` : displayPath, {
+					isDirectory,
+					isAtPrefix: true,
+					isQuotedPrefix: options.isQuotedPrefix
+				});
+				suggestions.push({
+					value,
+					label: entryName + (isDirectory ? "/" : ""),
+					description: displayPath
+				});
+			}
+			return suggestions;
+		} catch {
+			return [];
+		}
+	}
+	shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+		const textBeforeCursor = (lines[cursorLine] || "").slice(0, cursorCol);
+		if (textBeforeCursor.trim().startsWith("/") && !textBeforeCursor.trim().includes(" ")) return false;
+		return true;
+	}
+};
+//#endregion
+//#region src/compat/pi-tui.ts
+const CURSOR_MARKER = "\x1B_pi:c\x07";
+function isFocusable(value) {
+	return typeof value === "object" && value !== null && "focused" in value;
+}
+function blankLines(count) {
+	return Array.from({ length: Math.max(0, count) }, () => "");
+}
+var Container = class {
+	children = [];
+	addChild(child) {
+		this.children.push(child);
+	}
+	removeChild(child) {
+		this.children = this.children.filter((candidate) => candidate !== child);
+	}
+	clear() {
+		this.children = [];
+	}
+	invalidate() {
+		for (const child of this.children) child.invalidate();
+	}
+	render(width) {
+		return this.children.flatMap((child) => child.render(width));
+	}
+};
+var Text = class {
+	text;
+	paddingX;
+	paddingY;
+	customBgFn;
+	constructor(text = "", paddingX = 1, paddingY = 1, customBgFn) {
+		this.text = text;
+		this.paddingX = paddingX;
+		this.paddingY = paddingY;
+		this.customBgFn = customBgFn;
+	}
+	setText(text) {
+		this.text = text;
+	}
+	setCustomBgFn(customBgFn) {
+		this.customBgFn = customBgFn;
+	}
+	invalidate() {}
+	render(width) {
+		const pad = " ".repeat(Math.max(0, this.paddingX));
+		const inner = Math.max(1, width - this.paddingX * 2);
+		const rendered = this.text.split("\n").flatMap((line) => wrapTextWithAnsi(line, inner)).map((line) => {
+			const value = `${pad}${line}${pad}`;
+			return this.customBgFn === void 0 ? value : this.customBgFn(value);
+		});
+		return [
+			...blankLines(this.paddingY),
+			...rendered,
+			...blankLines(this.paddingY)
+		];
+	}
+};
+var TruncatedText = class {
+	text;
+	paddingX;
+	paddingY;
+	constructor(text, paddingX = 0, paddingY = 0) {
+		this.text = text;
+		this.paddingX = paddingX;
+		this.paddingY = paddingY;
+	}
+	invalidate() {}
+	render(width) {
+		const pad = " ".repeat(Math.max(0, this.paddingX));
+		const inner = Math.max(1, width - this.paddingX * 2);
+		const lines = this.text.split("\n").map((line) => `${pad}${truncateToWidth(line, inner)}${pad}`);
+		return [
+			...blankLines(this.paddingY),
+			...lines,
+			...blankLines(this.paddingY)
+		];
+	}
+};
+var Spacer = class {
+	lines;
+	constructor(lines = 1) {
+		this.lines = lines;
+	}
+	setLines(lines) {
+		this.lines = lines;
+	}
+	invalidate() {}
+	render(_width) {
+		return blankLines(this.lines);
+	}
+};
+var Box = class {
+	paddingX;
+	paddingY;
+	children = [];
+	bgFn;
+	constructor(paddingX = 1, paddingY = 1, bgFn) {
+		this.paddingX = paddingX;
+		this.paddingY = paddingY;
+		this.bgFn = bgFn;
+	}
+	addChild(component) {
+		this.children.push(component);
+	}
+	removeChild(component) {
+		this.children = this.children.filter((candidate) => candidate !== component);
+	}
+	clear() {
+		this.children = [];
+	}
+	setBgFn(bgFn) {
+		this.bgFn = bgFn;
+	}
+	invalidate() {
+		for (const child of this.children) child.invalidate();
+	}
+	render(width) {
+		const pad = " ".repeat(Math.max(0, this.paddingX));
+		const inner = Math.max(1, width - this.paddingX * 2);
+		const lines = this.children.flatMap((child) => child.render(inner));
+		const rendered = [
+			...blankLines(this.paddingY),
+			...lines.map((line) => `${pad}${line}${pad}`),
+			...blankLines(this.paddingY)
+		];
+		return this.bgFn === void 0 ? rendered : rendered.map((line) => this.bgFn(line));
+	}
+};
+var Markdown = class {
+	text;
+	paddingX;
+	paddingY;
+	theme;
+	options;
+	constructor(text = "", paddingX = 1, paddingY = 1, theme, options) {
+		this.text = text;
+		this.paddingX = paddingX;
+		this.paddingY = paddingY;
+		this.theme = theme;
+		this.options = options;
+	}
+	setText(text) {
+		this.text = text;
+	}
+	invalidate() {}
+	render(width) {
+		const pad = " ".repeat(Math.max(0, this.paddingX));
+		const inner = Math.max(1, width - this.paddingX * 2);
+		const lines = this.text.split("\n").flatMap((line) => wrapTextWithAnsi(line, inner));
+		return [
+			...blankLines(this.paddingY),
+			...lines.map((line) => `${pad}${line}${pad}`),
+			...blankLines(this.paddingY)
+		];
+	}
+};
+var SelectList = class {
+	items;
+	maxVisible;
+	theme;
+	layout;
+	onSelect;
+	onCancel;
+	onSelectionChange;
+	filtered;
+	selectedIndex = 0;
+	constructor(items, maxVisible, theme, layout = {}) {
+		this.items = items;
+		this.maxVisible = maxVisible;
+		this.theme = theme;
+		this.layout = layout;
+		this.filtered = [...items];
+	}
+	setFilter(filter) {
+		const query = filter.toLowerCase();
+		this.filtered = this.items.filter((item) => item.label.toLowerCase().includes(query) || item.value.toLowerCase().includes(query));
+		this.selectedIndex = 0;
+	}
+	setSelectedIndex(index) {
+		this.selectedIndex = Math.max(0, Math.min(index, this.filtered.length - 1));
+	}
+	getSelectedItem() {
+		return this.filtered[this.selectedIndex] ?? null;
+	}
+	invalidate() {}
+	handleInput(_keyData) {}
+	render(width) {
+		return this.filtered.slice(0, this.maxVisible).map((item, index) => truncateToWidth(`${index === this.selectedIndex ? "→ " : "  "}${item.label}`, Math.max(1, width)));
+	}
+};
+var SettingsList = class {
+	items;
+	maxVisible;
+	theme;
+	onChange;
+	onCancel;
+	options;
+	constructor(items, maxVisible, theme, onChange, onCancel, options = {}) {
+		this.items = items;
+		this.maxVisible = maxVisible;
+		this.theme = theme;
+		this.onChange = onChange;
+		this.onCancel = onCancel;
+		this.options = options;
+	}
+	updateValue(id, newValue) {
+		const item = this.items.find((candidate) => candidate.id === id);
+		if (item !== void 0) item.currentValue = newValue;
+	}
+	invalidate() {}
+	handleInput(_data) {}
+	render(width) {
+		return this.items.slice(0, this.maxVisible).map((item) => truncateToWidth(`${item.label}: ${item.currentValue}`, Math.max(1, width)));
+	}
+};
+var Input = class {
+	focused = false;
+	onSubmit;
+	onEscape;
+	value = "";
+	getValue() {
+		return this.value;
+	}
+	setValue(value) {
+		this.value = value;
+	}
+	handleInput(data) {
+		if (data === "\r" || data === "\n") {
+			this.onSubmit?.(this.value);
+			return;
+		}
+		if (data === "\x1B") {
+			this.onEscape?.();
+			return;
+		}
+		if (data >= " ") this.value += data;
+	}
+	invalidate() {}
+	render(width) {
+		return [truncateToWidth(this.value, Math.max(1, width))];
+	}
+};
+var Editor = class {
+	tui;
+	theme;
+	options;
+	focused = false;
+	borderColor = (str) => str;
+	onSubmit;
+	onChange;
+	disableSubmit = false;
+	text = "";
+	history = [];
+	autocompleteProvider;
+	constructor(tui, theme = {}, options = {}) {
+		this.tui = tui;
+		this.theme = theme;
+		this.options = options;
+	}
+	getText() {
+		return this.text;
+	}
+	setText(text) {
+		this.text = text;
+		this.onChange?.(text);
+	}
+	getExpandedText() {
+		return this.text;
+	}
+	insertTextAtCursor(text) {
+		this.setText(this.text + text);
+	}
+	addToHistory(text) {
+		this.history.push(text);
+	}
+	setAutocompleteProvider(provider) {
+		this.autocompleteProvider = provider;
+	}
+	getPaddingX() {
+		return this.options.paddingX ?? 0;
+	}
+	setPaddingX(padding) {
+		this.options.paddingX = padding;
+	}
+	getAutocompleteMaxVisible() {
+		return this.options.autocompleteMaxVisible ?? 5;
+	}
+	setAutocompleteMaxVisible(maxVisible) {
+		this.options.autocompleteMaxVisible = maxVisible;
+	}
+	handleInput(data) {
+		if (data === "\r" || data === "\n") {
+			if (!this.disableSubmit) this.onSubmit?.(this.text);
+			return;
+		}
+		if (data >= " ") this.setText(this.text + data);
+	}
+	invalidate() {}
+	render(width) {
+		return this.text.split("\n").flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width)));
+	}
+};
+var Stack = class extends Container {
+	options;
+	constructor(children = [], options = {}) {
+		super();
+		this.options = options;
+		for (const child of children) this.addChild("component" in child ? child.component : child);
+	}
+};
+var VStack = class extends Stack {};
+var HStack = class extends Stack {
+	render(width) {
+		const columns = this.children.map((child) => child.render(width));
+		const height = Math.max(0, ...columns.map((column) => column.length));
+		const lines = [];
+		for (let row = 0; row < height; row += 1) lines.push(columns.map((column) => column[row] ?? "").join(" "));
+		return lines;
+	}
+};
+var Loader = class extends Text {
+	constructor(message = "", indicator) {
+		super(message, 0, 0);
+	}
+	start() {}
+	stop() {}
+	setMessage(message) {
+		this.setText(message);
+	}
+	setIndicator(_indicator) {}
+};
+var CancellableLoader = class extends Loader {
+	onCancel;
+	handleInput(data) {
+		if (data === "\x1B" || data === "") this.onCancel?.();
+	}
+	dispose() {}
+};
+var Image = class {
+	base64Data;
+	mimeType;
+	options;
+	constructor(base64Data = "", mimeType = "image/png", options = {}) {
+		this.base64Data = base64Data;
+		this.mimeType = mimeType;
+		this.options = options;
+	}
+	getImageId() {}
+	invalidate() {}
+	render(width) {
+		return [truncateToWidth(`[image ${this.mimeType}]`, Math.max(1, width))];
+	}
+};
+var ScrollView = class extends Container {
+	options;
+	scrollTop = 0;
+	constructor(component, options = {}) {
+		super();
+		this.options = options;
+		this.addChild(component);
+	}
+	setScrollbar(_scrollbar) {}
+	getContentWidth(width) {
+		return Math.max(1, width - 1);
+	}
+	setScrollbarActive(_active) {}
+	scrollTo(scrollTop, _options = {}) {
+		this.scrollTop = Math.max(0, scrollTop);
+	}
+	scrollBy(lines) {
+		this.scrollTop = Math.max(0, this.scrollTop + lines);
+		return this.scrollTop;
+	}
+	scrollToStart() {
+		this.scrollTop = 0;
+	}
+	scrollToEnd() {}
+	updateLayout(_contentHeight, _viewportHeight, _requestRender) {}
+};
+function isViewportTUI(value) {
+	return false;
+}
+//#endregion
+export { matchesKey as $, getCellDimensions as A, setCellDimensions as B, calculateImageRows as C, encodeITerm2 as D, detectCapabilities as E, getWebpDimensions as F, setKeybindings as G, KeybindingsManager as H, hyperlink as I, Key as J, parseOsc11BackgroundColor as K, imageFallback as L, getImageDimensions as M, getJpegDimensions as N, encodeKitty as O, getPngDimensions as P, isKittyProtocolActive as Q, resetCapabilitiesCache as R, allocateImageId as S, deleteKittyImage as T, TUI_KEYBINDINGS as U, renderLatex as V, getKeybindings as W, isKeyRelease as X, decodeKittyPrintable as Y, isKeyRepeat as Z, TruncatedText as _, stripTerminalSequences as _t, Editor as a, applyBackgroundToLine as at, isViewportTUI as b, wrapTextWithAnsi as bt, Input as c, getGraphemeCellRange as ct, Marked as d, getWordSegmenter as dt, parseKey as et, ScrollView as f, isPunctuationChar as ft, Text as g, sliceWithWidth as gt, Spacer as h, sliceByColumn as ht, Container as i, PUNCTUATION_REGEX as it, getGifDimensions as j, getCapabilities as k, Loader as l, getGraphemeSegmenter as lt, SettingsList as m, normalizeTerminalOutput as mt, CURSOR_MARKER as n, fuzzyFilter as nt, HStack as o, cjkBreakRegex as ot, SelectList as p, isWhitespaceChar as pt, parseTerminalColorSchemeReport as q, CancellableLoader as r, fuzzyMatch as rt, Image as s, extractAnsiCode as st, Box as t, setKittyProtocolActive as tt, Markdown as u, getOsc8LinkAtColumn as ut, VStack as v, truncateToWidth as vt, deleteAllKittyImages as w, CombinedAutocompleteProvider as x, isFocusable as y, visibleWidth as yt, setCapabilities as z };
+
+//# sourceMappingURL=pi-tui-5CYLcj-_.mjs.map