@oh-my-pi/pi-tui 1.337.0

package/src/components/truncated-text.ts

@@ -0,0 +1,65 @@
+import type { Component } from "../tui.js";
+import { truncateToWidth, visibleWidth } from "../utils.js";
+
+/**
+ * Text component that truncates to fit viewport width
+ */
+export class TruncatedText implements Component {
+	private text: string;
+	private paddingX: number;
+	private paddingY: number;
+
+	constructor(text: string, paddingX: number = 0, paddingY: number = 0) {
+		this.text = text;
+		this.paddingX = paddingX;
+		this.paddingY = paddingY;
+	}
+
+	invalidate(): void {
+		// No cached state to invalidate currently
+	}
+
+	render(width: number): string[] {
+		const result: string[] = [];
+
+		// Empty line padded to width
+		const emptyLine = " ".repeat(width);
+
+		// Add vertical padding above
+		for (let i = 0; i < this.paddingY; i++) {
+			result.push(emptyLine);
+		}
+
+		// Calculate available width after horizontal padding
+		const availableWidth = Math.max(1, width - this.paddingX * 2);
+
+		// Take only the first line (stop at newline)
+		let singleLineText = this.text;
+		const newlineIndex = this.text.indexOf("\n");
+		if (newlineIndex !== -1) {
+			singleLineText = this.text.substring(0, newlineIndex);
+		}
+
+		// Truncate text if needed (accounting for ANSI codes)
+		const displayText = truncateToWidth(singleLineText, availableWidth);
+
+		// Add horizontal padding
+		const leftPadding = " ".repeat(this.paddingX);
+		const rightPadding = " ".repeat(this.paddingX);
+		const lineWithPadding = leftPadding + displayText + rightPadding;
+
+		// Pad line to exactly width characters
+		const lineVisibleWidth = visibleWidth(lineWithPadding);
+		const paddingNeeded = Math.max(0, width - lineVisibleWidth);
+		const finalLine = lineWithPadding + " ".repeat(paddingNeeded);
+
+		result.push(finalLine);
+
+		// Add vertical padding below
+		for (let i = 0; i < this.paddingY; i++) {
+			result.push(emptyLine);
+		}
+
+		return result;
+	}
+}

package/src/index.ts

@@ -0,0 +1,91 @@
+// Core TUI interfaces and classes
+
+// Autocomplete support
+export {
+	type AutocompleteItem,
+	type AutocompleteProvider,
+	CombinedAutocompleteProvider,
+	type SlashCommand,
+} from "./autocomplete.js";
+// Components
+export { Box } from "./components/box.js";
+export { CancellableLoader } from "./components/cancellable-loader.js";
+export { Editor, type EditorTheme } from "./components/editor.js";
+export { Image, type ImageOptions, type ImageTheme } from "./components/image.js";
+export { Input } from "./components/input.js";
+export { Loader } from "./components/loader.js";
+export { type DefaultTextStyle, Markdown, type MarkdownTheme } from "./components/markdown.js";
+export { type SelectItem, SelectList, type SelectListTheme } from "./components/select-list.js";
+export { type SettingItem, SettingsList, type SettingsListTheme } from "./components/settings-list.js";
+export { Spacer } from "./components/spacer.js";
+export { type Tab, TabBar, type TabBarTheme } from "./components/tab-bar.js";
+export { Text } from "./components/text.js";
+export { TruncatedText } from "./components/truncated-text.js";
+// Kitty keyboard protocol helpers
+export {
+	isAltBackspace,
+	isAltEnter,
+	isAltLeft,
+	isAltRight,
+	isArrowDown,
+	isArrowLeft,
+	isArrowRight,
+	isArrowUp,
+	isBackspace,
+	isCtrlA,
+	isCtrlC,
+	isCtrlD,
+	isCtrlE,
+	isCtrlG,
+	isCtrlK,
+	isCtrlL,
+	isCtrlLeft,
+	isCtrlO,
+	isCtrlP,
+	isCtrlRight,
+	isCtrlT,
+	isCtrlU,
+	isCtrlV,
+	isCtrlW,
+	isCtrlZ,
+	isDelete,
+	isEnd,
+	isEnter,
+	isEscape,
+	isHome,
+	isShiftCtrlD,
+	isShiftCtrlO,
+	isShiftCtrlP,
+	isShiftEnter,
+	isShiftTab,
+	isTab,
+	Keys,
+} from "./keys.js";
+// Terminal interface and implementations
+export { emergencyTerminalRestore, ProcessTerminal, type Terminal } from "./terminal.js";
+// Terminal image support
+export {
+	type CellDimensions,
+	calculateImageRows,
+	detectCapabilities,
+	encodeITerm2,
+	encodeKitty,
+	getCapabilities,
+	getCellDimensions,
+	getGifDimensions,
+	getImageDimensions,
+	getJpegDimensions,
+	getPngDimensions,
+	getWebpDimensions,
+	type ImageDimensions,
+	type ImageProtocol,
+	type ImageRenderOptions,
+	imageFallback,
+	renderImage,
+	resetCapabilitiesCache,
+	setCellDimensions,
+	type TerminalCapabilities,
+} from "./terminal-image.js";
+export { type Component, Container, TUI } from "./tui.js";
+// Utilities
+export { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "./utils.js";

package/src/keys.ts

@@ -0,0 +1,560 @@
+/**
+ * Kitty keyboard protocol key sequence helpers.
+ *
+ * The Kitty keyboard protocol sends enhanced escape sequences in the format:
+ *   \x1b[<codepoint>;<modifier>u
+ *
+ * Modifier bits (before adding 1 for transmission):
+ *   - Shift: 1 (value 2)
+ *   - Alt: 2 (value 3)
+ *   - Ctrl: 4 (value 5)
+ *   - Super: 8 (value 9)
+ *   - Hyper: 16
+ *   - Meta: 32
+ *   - Caps_Lock: 64
+ *   - Num_Lock: 128
+ *
+ * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+ *
+ * NOTE: Some terminals (e.g., Ghostty on Linux) include lock key states
+ * (Caps Lock, Num Lock) in the modifier field. We mask these out when
+ * checking for key combinations since they shouldn't affect behavior.
+ */
+
+// Common codepoints
+const CODEPOINTS = {
+	// Letters (lowercase ASCII)
+	a: 97,
+	c: 99,
+	d: 100,
+	e: 101,
+	g: 103,
+	k: 107,
+	l: 108,
+	o: 111,
+	p: 112,
+	t: 116,
+	u: 117,
+	v: 118,
+	w: 119,
+	z: 122,
+
+	// Special keys
+	escape: 27,
+	tab: 9,
+	enter: 13,
+	backspace: 127,
+} as const;
+
+// Lock key bits to ignore when matching (Caps Lock + Num Lock)
+const LOCK_MASK = 64 + 128; // 192
+
+// Modifier bits (before adding 1)
+const MODIFIERS = {
+	shift: 1,
+	alt: 2,
+	ctrl: 4,
+	super: 8,
+} as const;
+
+/**
+ * Build a Kitty keyboard protocol sequence for a key with modifier.
+ */
+function kittySequence(codepoint: number, modifier: number): string {
+	return `\x1b[${codepoint};${modifier + 1}u`;
+}
+
+/**
+ * Parsed Kitty keyboard protocol sequence.
+ */
+interface ParsedKittySequence {
+	codepoint: number;
+	modifier: number; // Actual modifier bits (after subtracting 1)
+}
+
+/**
+ * Parse a Kitty keyboard protocol sequence.
+ * Handles formats:
+ *   - \x1b[<codepoint>u (no modifier)
+ *   - \x1b[<codepoint>;<modifier>u (with modifier)
+ *   - \x1b[1;<modifier>A/B/C/D (arrow keys with modifier)
+ *
+ * Returns null if not a valid Kitty sequence.
+ */
+// Virtual codepoints for functional keys (negative to avoid conflicts)
+const FUNCTIONAL_CODEPOINTS = {
+	delete: -10,
+	insert: -11,
+	pageUp: -12,
+	pageDown: -13,
+	home: -14,
+	end: -15,
+} as const;
+
+function parseKittySequence(data: string): ParsedKittySequence | null {
+	// Match CSI u format: \x1b[<num>u or \x1b[<num>;<mod>u
+	const csiUMatch = data.match(/^\x1b\[(\d+)(?:;(\d+))?u$/);
+	if (csiUMatch) {
+		const codepoint = parseInt(csiUMatch[1]!, 10);
+		const modValue = csiUMatch[2] ? parseInt(csiUMatch[2], 10) : 1;
+		return { codepoint, modifier: modValue - 1 };
+	}
+
+	// Match arrow keys with modifier: \x1b[1;<mod>A/B/C/D
+	const arrowMatch = data.match(/^\x1b\[1;(\d+)([ABCD])$/);
+	if (arrowMatch) {
+		const modValue = parseInt(arrowMatch[1]!, 10);
+		// Map arrow letters to virtual codepoints for easier matching
+		const arrowCodes: Record<string, number> = { A: -1, B: -2, C: -3, D: -4 };
+		const codepoint = arrowCodes[arrowMatch[2]!]!;
+		return { codepoint, modifier: modValue - 1 };
+	}
+
+	// Match functional keys with ~ terminator: \x1b[<num>~ or \x1b[<num>;<mod>~
+	// DELETE=3, INSERT=2, PAGEUP=5, PAGEDOWN=6, etc.
+	const funcMatch = data.match(/^\x1b\[(\d+)(?:;(\d+))?~$/);
+	if (funcMatch) {
+		const keyNum = parseInt(funcMatch[1]!, 10);
+		const modValue = funcMatch[2] ? parseInt(funcMatch[2], 10) : 1;
+		// Map functional key numbers to virtual codepoints
+		const funcCodes: Record<number, number> = {
+			2: FUNCTIONAL_CODEPOINTS.insert,
+			3: FUNCTIONAL_CODEPOINTS.delete,
+			5: FUNCTIONAL_CODEPOINTS.pageUp,
+			6: FUNCTIONAL_CODEPOINTS.pageDown,
+			7: FUNCTIONAL_CODEPOINTS.home, // Alternative home
+			8: FUNCTIONAL_CODEPOINTS.end, // Alternative end
+		};
+		const codepoint = funcCodes[keyNum];
+		if (codepoint !== undefined) {
+			return { codepoint, modifier: modValue - 1 };
+		}
+	}
+
+	// Match Home/End with modifier: \x1b[1;<mod>H/F
+	const homeEndMatch = data.match(/^\x1b\[1;(\d+)([HF])$/);
+	if (homeEndMatch) {
+		const modValue = parseInt(homeEndMatch[1]!, 10);
+		const codepoint = homeEndMatch[2] === "H" ? FUNCTIONAL_CODEPOINTS.home : FUNCTIONAL_CODEPOINTS.end;
+		return { codepoint, modifier: modValue - 1 };
+	}
+
+	return null;
+}
+
+/**
+ * Check if a Kitty sequence matches the expected codepoint and modifier,
+ * ignoring lock key bits (Caps Lock, Num Lock).
+ */
+function matchesKittySequence(data: string, expectedCodepoint: number, expectedModifier: number): boolean {
+	const parsed = parseKittySequence(data);
+	if (!parsed) return false;
+
+	// Mask out lock bits from both sides for comparison
+	const actualMod = parsed.modifier & ~LOCK_MASK;
+	const expectedMod = expectedModifier & ~LOCK_MASK;
+
+	return parsed.codepoint === expectedCodepoint && actualMod === expectedMod;
+}
+
+// Pre-built sequences for common key combinations
+export const Keys = {
+	// Ctrl+<letter> combinations
+	CTRL_A: kittySequence(CODEPOINTS.a, MODIFIERS.ctrl),
+	CTRL_C: kittySequence(CODEPOINTS.c, MODIFIERS.ctrl),
+	CTRL_D: kittySequence(CODEPOINTS.d, MODIFIERS.ctrl),
+	CTRL_E: kittySequence(CODEPOINTS.e, MODIFIERS.ctrl),
+	CTRL_G: kittySequence(CODEPOINTS.g, MODIFIERS.ctrl),
+	CTRL_K: kittySequence(CODEPOINTS.k, MODIFIERS.ctrl),
+	CTRL_L: kittySequence(CODEPOINTS.l, MODIFIERS.ctrl),
+	CTRL_O: kittySequence(CODEPOINTS.o, MODIFIERS.ctrl),
+	CTRL_P: kittySequence(CODEPOINTS.p, MODIFIERS.ctrl),
+	CTRL_T: kittySequence(CODEPOINTS.t, MODIFIERS.ctrl),
+	CTRL_U: kittySequence(CODEPOINTS.u, MODIFIERS.ctrl),
+	CTRL_V: kittySequence(CODEPOINTS.v, MODIFIERS.ctrl),
+	CTRL_W: kittySequence(CODEPOINTS.w, MODIFIERS.ctrl),
+	CTRL_Z: kittySequence(CODEPOINTS.z, MODIFIERS.ctrl),
+
+	// Enter combinations
+	SHIFT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.shift),
+	ALT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.alt),
+	CTRL_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.ctrl),
+
+	// Tab combinations
+	SHIFT_TAB: kittySequence(CODEPOINTS.tab, MODIFIERS.shift),
+
+	// Backspace combinations
+	ALT_BACKSPACE: kittySequence(CODEPOINTS.backspace, MODIFIERS.alt),
+} as const;
+
+/**
+ * Check if input matches a Kitty protocol Ctrl+<key> sequence.
+ * Ignores lock key bits (Caps Lock, Num Lock).
+ * @param data - The input data to check
+ * @param key - Single lowercase letter (e.g., 'c' for Ctrl+C)
+ */
+export function isKittyCtrl(data: string, key: string): boolean {
+	if (key.length !== 1) return false;
+	const codepoint = key.charCodeAt(0);
+	// Check exact match first (fast path)
+	if (data === kittySequence(codepoint, MODIFIERS.ctrl)) return true;
+	// Check with lock bits masked out
+	return matchesKittySequence(data, codepoint, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches a Kitty protocol key sequence with specific modifier.
+ * Ignores lock key bits (Caps Lock, Num Lock).
+ * @param data - The input data to check
+ * @param codepoint - ASCII codepoint of the key
+ * @param modifier - Modifier value (use MODIFIERS constants)
+ */
+export function isKittyKey(data: string, codepoint: number, modifier: number): boolean {
+	// Check exact match first (fast path)
+	if (data === kittySequence(codepoint, modifier)) return true;
+	// Check with lock bits masked out
+	return matchesKittySequence(data, codepoint, modifier);
+}
+
+// Raw control character codes
+const RAW = {
+	CTRL_A: "\x01",
+	CTRL_C: "\x03",
+	CTRL_D: "\x04",
+	CTRL_E: "\x05",
+	CTRL_G: "\x07",
+	CTRL_K: "\x0b",
+	CTRL_L: "\x0c",
+	CTRL_O: "\x0f",
+	CTRL_P: "\x10",
+	CTRL_T: "\x14",
+	CTRL_U: "\x15",
+	CTRL_V: "\x16",
+	CTRL_W: "\x17",
+	CTRL_Z: "\x1a",
+	ALT_BACKSPACE: "\x1b\x7f",
+	SHIFT_TAB: "\x1b[Z",
+} as const;
+
+/**
+ * Check if input matches Ctrl+A (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlA(data: string): boolean {
+	return data === RAW.CTRL_A || data === Keys.CTRL_A || matchesKittySequence(data, CODEPOINTS.a, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+C (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlC(data: string): boolean {
+	return data === RAW.CTRL_C || data === Keys.CTRL_C || matchesKittySequence(data, CODEPOINTS.c, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+D (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlD(data: string): boolean {
+	return data === RAW.CTRL_D || data === Keys.CTRL_D || matchesKittySequence(data, CODEPOINTS.d, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+E (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlE(data: string): boolean {
+	return data === RAW.CTRL_E || data === Keys.CTRL_E || matchesKittySequence(data, CODEPOINTS.e, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+G (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlG(data: string): boolean {
+	return data === RAW.CTRL_G || data === Keys.CTRL_G || matchesKittySequence(data, CODEPOINTS.g, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+K (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ * Also checks if first byte is 0x0b for compatibility with terminals
+ * that may send trailing bytes.
+ */
+export function isCtrlK(data: string): boolean {
+	return (
+		data === RAW.CTRL_K ||
+		(data.length > 0 && data.charCodeAt(0) === 0x0b) ||
+		data === Keys.CTRL_K ||
+		matchesKittySequence(data, CODEPOINTS.k, MODIFIERS.ctrl)
+	);
+}
+
+/**
+ * Check if input matches Ctrl+L (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlL(data: string): boolean {
+	return data === RAW.CTRL_L || data === Keys.CTRL_L || matchesKittySequence(data, CODEPOINTS.l, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+O (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlO(data: string): boolean {
+	return data === RAW.CTRL_O || data === Keys.CTRL_O || matchesKittySequence(data, CODEPOINTS.o, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Shift+Ctrl+O (Kitty protocol only).
+ * Ignores lock key bits.
+ */
+export function isShiftCtrlO(data: string): boolean {
+	return matchesKittySequence(data, CODEPOINTS.o, MODIFIERS.shift + MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+P (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlP(data: string): boolean {
+	return data === RAW.CTRL_P || data === Keys.CTRL_P || matchesKittySequence(data, CODEPOINTS.p, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Shift+Ctrl+P (Kitty protocol only).
+ * Ignores lock key bits.
+ */
+export function isShiftCtrlP(data: string): boolean {
+	return matchesKittySequence(data, CODEPOINTS.p, MODIFIERS.shift + MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Shift+Ctrl+D (Kitty protocol only, for debug).
+ * Ignores lock key bits.
+ */
+export function isShiftCtrlD(data: string): boolean {
+	return matchesKittySequence(data, CODEPOINTS.d, MODIFIERS.shift + MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+T (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlT(data: string): boolean {
+	return data === RAW.CTRL_T || data === Keys.CTRL_T || matchesKittySequence(data, CODEPOINTS.t, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+U (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlU(data: string): boolean {
+	return data === RAW.CTRL_U || data === Keys.CTRL_U || matchesKittySequence(data, CODEPOINTS.u, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+V (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ * Note: In most terminals, Ctrl+V triggers paste which sends bracketed paste markers,
+ * but raw mode can intercept the key before the terminal processes it.
+ */
+export function isCtrlV(data: string): boolean {
+	return data === RAW.CTRL_V || data === Keys.CTRL_V || matchesKittySequence(data, CODEPOINTS.v, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+W (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlW(data: string): boolean {
+	return data === RAW.CTRL_W || data === Keys.CTRL_W || matchesKittySequence(data, CODEPOINTS.w, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+Z (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlZ(data: string): boolean {
+	return data === RAW.CTRL_Z || data === Keys.CTRL_Z || matchesKittySequence(data, CODEPOINTS.z, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Alt+Backspace (legacy or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isAltBackspace(data: string): boolean {
+	return (
+		data === RAW.ALT_BACKSPACE ||
+		data === Keys.ALT_BACKSPACE ||
+		matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt)
+	);
+}
+
+/**
+ * Check if input matches Shift+Tab (legacy or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isShiftTab(data: string): boolean {
+	return (
+		data === RAW.SHIFT_TAB || data === Keys.SHIFT_TAB || matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift)
+	);
+}
+
+/**
+ * Check if input matches the Escape key (raw byte or Kitty protocol).
+ * Raw: \x1b (single byte)
+ * Kitty: \x1b[27u (codepoint 27 = escape)
+ * Ignores lock key bits.
+ */
+export function isEscape(data: string): boolean {
+	return data === "\x1b" || data === `\x1b[${CODEPOINTS.escape}u` || matchesKittySequence(data, CODEPOINTS.escape, 0);
+}
+
+// Arrow key virtual codepoints (negative to avoid conflicts with real codepoints)
+const ARROW_CODEPOINTS = {
+	up: -1,
+	down: -2,
+	right: -3,
+	left: -4,
+} as const;
+
+/**
+ * Check if input matches Arrow Up key.
+ * Handles both legacy (\x1b[A) and Kitty protocol with modifiers.
+ */
+export function isArrowUp(data: string): boolean {
+	return data === "\x1b[A" || matchesKittySequence(data, ARROW_CODEPOINTS.up, 0);
+}
+
+/**
+ * Check if input matches Arrow Down key.
+ * Handles both legacy (\x1b[B) and Kitty protocol with modifiers.
+ */
+export function isArrowDown(data: string): boolean {
+	return data === "\x1b[B" || matchesKittySequence(data, ARROW_CODEPOINTS.down, 0);
+}
+
+/**
+ * Check if input matches Arrow Right key.
+ * Handles both legacy (\x1b[C) and Kitty protocol with modifiers.
+ */
+export function isArrowRight(data: string): boolean {
+	return data === "\x1b[C" || matchesKittySequence(data, ARROW_CODEPOINTS.right, 0);
+}
+
+/**
+ * Check if input matches Arrow Left key.
+ * Handles both legacy (\x1b[D) and Kitty protocol with modifiers.
+ */
+export function isArrowLeft(data: string): boolean {
+	return data === "\x1b[D" || matchesKittySequence(data, ARROW_CODEPOINTS.left, 0);
+}
+
+/**
+ * Check if input matches plain Tab key (no modifiers).
+ * Handles both legacy (\t) and Kitty protocol.
+ */
+export function isTab(data: string): boolean {
+	return data === "\t" || matchesKittySequence(data, CODEPOINTS.tab, 0);
+}
+
+/**
+ * Check if input matches plain Enter/Return key (no modifiers).
+ * Handles both legacy (\r) and Kitty protocol.
+ */
+export function isEnter(data: string): boolean {
+	return data === "\r" || matchesKittySequence(data, CODEPOINTS.enter, 0);
+}
+
+/**
+ * Check if input matches plain Backspace key (no modifiers).
+ * Handles both legacy (\x7f, \x08) and Kitty protocol.
+ */
+export function isBackspace(data: string): boolean {
+	return data === "\x7f" || data === "\x08" || matchesKittySequence(data, CODEPOINTS.backspace, 0);
+}
+
+/**
+ * Check if input matches Shift+Enter.
+ * Ignores lock key bits.
+ */
+export function isShiftEnter(data: string): boolean {
+	return data === Keys.SHIFT_ENTER || matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift);
+}
+
+/**
+ * Check if input matches Alt+Enter.
+ * Ignores lock key bits.
+ */
+export function isAltEnter(data: string): boolean {
+	return data === Keys.ALT_ENTER || data === "\x1b\r" || matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt);
+}
+
+/**
+ * Check if input matches Option/Alt+Left (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isAltLeft(data: string): boolean {
+	return data === "\x1b[1;3D" || data === "\x1bb" || matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt);
+}
+
+/**
+ * Check if input matches Option/Alt+Right (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isAltRight(data: string): boolean {
+	return data === "\x1b[1;3C" || data === "\x1bf" || matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt);
+}
+
+/**
+ * Check if input matches Ctrl+Left (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isCtrlLeft(data: string): boolean {
+	return data === "\x1b[1;5D" || matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Ctrl+Right (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isCtrlRight(data: string): boolean {
+	return data === "\x1b[1;5C" || matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl);
+}
+
+/**
+ * Check if input matches Home key.
+ * Handles legacy formats and Kitty protocol with lock key modifiers.
+ */
+export function isHome(data: string): boolean {
+	return (
+		data === "\x1b[H" ||
+		data === "\x1b[1~" ||
+		data === "\x1b[7~" ||
+		matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, 0)
+	);
+}
+
+/**
+ * Check if input matches End key.
+ * Handles legacy formats and Kitty protocol with lock key modifiers.
+ */
+export function isEnd(data: string): boolean {
+	return (
+		data === "\x1b[F" ||
+		data === "\x1b[4~" ||
+		data === "\x1b[8~" ||
+		matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, 0)
+	);
+}
+
+/**
+ * Check if input matches Delete key (forward delete).
+ * Handles legacy format and Kitty protocol with lock key modifiers.
+ */
+export function isDelete(data: string): boolean {
+	return data === "\x1b[3~" || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, 0);
+}