pi2dsh 0.2.0

package/dist/compat/pi-tui.mjs

@@ -0,0 +1,3622 @@
+
+import { _ as wrapTextWithAnsi, a as getGraphemeCellRange, c as getWordSegmenter, d as normalizeTerminalOutput, f as sliceByColumn, g as visibleWidth, h as truncateToWidth, i as extractAnsiCode, l as isPunctuationChar, m as stripTerminalSequences, n as applyBackgroundToLine, o as getGraphemeSegmenter, p as sliceWithWidth, r as cjkBreakRegex, s as getOsc8LinkAtColumn, t as PUNCTUATION_REGEX, u as isWhitespaceChar } from "../pi-tui-utils-CcaVtm-3.mjs";
+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 { 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-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 { Box, CURSOR_MARKER, CancellableLoader, CombinedAutocompleteProvider, Container, Editor, HStack, Image, Input, Key, KeybindingsManager, Loader, Markdown, Marked, PUNCTUATION_REGEX, ScrollView, SelectList, SettingsList, Spacer, TUI_KEYBINDINGS, Text, TruncatedText, VStack, allocateImageId, applyBackgroundToLine, calculateImageRows, cjkBreakRegex, decodeKittyPrintable, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, extractAnsiCode, fuzzyFilter, fuzzyMatch, getCapabilities, getCellDimensions, getGifDimensions, getGraphemeCellRange, getGraphemeSegmenter, getImageDimensions, getJpegDimensions, getKeybindings, getOsc8LinkAtColumn, getPngDimensions, getWebpDimensions, getWordSegmenter, hyperlink, imageFallback, isFocusable, isKeyRelease, isKeyRepeat, isKittyProtocolActive, isPunctuationChar, isViewportTUI, isWhitespaceChar, matchesKey, normalizeTerminalOutput, parseKey, parseOsc11BackgroundColor, parseTerminalColorSchemeReport, renderLatex, resetCapabilitiesCache, setCapabilities, setCellDimensions, setKeybindings, setKittyProtocolActive, sliceByColumn, sliceWithWidth, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi };
+
+//# sourceMappingURL=pi-tui.mjs.map