@oh-my-pi/pi-tui 6.8.2 → 6.8.4

package/README.md

@@ -225,7 +225,9 @@ editor.borderColor = (s) => chalk.blue(s); // Change border dynamically
 - `Shift+Enter`, `Ctrl+Enter`, or `Alt+Enter` - New line (terminal-dependent, Alt+Enter most reliable)
 - `Tab` - Autocomplete
 - `Ctrl+K` - Delete line
+- `Alt+D` / `Alt+Delete` - Delete word forward
 - `Ctrl+A` / `Ctrl+E` - Line start/end
+- `Ctrl+-` - Undo last edit
 - Arrow keys, Backspace, Delete work as expected
 
 ### Markdown
@@ -266,7 +268,8 @@ const md = new Markdown(
 	1, // paddingX
 	1, // paddingY
 	theme, // MarkdownTheme
-	defaultStyle // optional DefaultTextStyle
+	defaultStyle, // optional DefaultTextStyle
+	2 // optional code block indent (spaces)
 );
 md.setText("Updated markdown");
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-tui",
-	"version": "6.8.2",
+	"version": "6.8.4",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "src/index.ts",

package/src/components/editor.ts

@@ -306,6 +306,10 @@ export class Editor implements Component, Focusable {
 	private historyIndex: number = -1; // -1 = not browsing, 0 = most recent, 1 = older, etc.
 	private historyStorage?: HistoryStorage;
 
+	// Undo stack for editor state changes
+	private undoStack: EditorState[] = [];
+	private suspendUndo = false;
+
 	public onSubmit?: (text: string) => void;
 	public onAltEnter?: (text: string) => void;
 	public onChange?: (text: string) => void;
@@ -406,6 +410,7 @@ export class Editor implements Component, Focusable {
 
 	/** Internal setText that doesn't reset history state - used by navigateHistory */
 	private setTextInternal(text: string): void {
+		this.clearUndoStack();
 		const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
 		this.state.lines = lines.length === 0 ? [""] : lines;
 		this.state.cursorLine = this.state.lines.length - 1;
@@ -671,6 +676,12 @@ export class Editor implements Component, Focusable {
 			return;
 		}
 
+		// Ctrl+- / Ctrl+_ - Undo last edit
+		if (matchesKey(data, "ctrl+-") || matchesKey(data, "ctrl+_")) {
+			this.applyUndo();
+			return;
+		}
+
 		// Handle autocomplete special keys first (but don't block other input)
 		if (this.isAutocompleting && this.autocompleteList) {
 			// Escape - cancel autocomplete
@@ -794,7 +805,7 @@ export class Editor implements Component, Focusable {
 			this.deleteWordBackwards();
 		}
 		// Option/Alt+D - Delete word forwards
-		else if (matchesKey(data, "alt+d")) {
+		else if (matchesKey(data, "alt+d") || matchesKey(data, "alt+delete")) {
 			this.deleteWordForwards();
 		}
 		// Ctrl+Y - Yank from kill ring
@@ -857,6 +868,7 @@ export class Editor implements Component, Focusable {
 				cursorLine: 0,
 				cursorCol: 0,
 			};
+			this.clearUndoStack();
 			this.pastes.clear();
 			this.pasteCounter = 0;
 			this.historyIndex = -1; // Exit history browsing mode
@@ -1059,6 +1071,7 @@ export class Editor implements Component, Focusable {
 	insertText(text: string): void {
 		this.historyIndex = -1;
 		this.resetKillSequence();
+		this.recordUndoState();
 
 		const line = this.state.lines[this.state.cursorLine] || "";
 		const before = line.slice(0, this.state.cursorCol);
@@ -1076,6 +1089,7 @@ export class Editor implements Component, Focusable {
 	private insertCharacter(char: string): void {
 		this.historyIndex = -1; // Exit history browsing mode
 		this.resetKillSequence();
+		this.recordUndoState();
 
 		const line = this.state.lines[this.state.cursorLine] || "";
 
@@ -1126,107 +1140,105 @@ export class Editor implements Component, Focusable {
 	private handlePaste(pastedText: string): void {
 		this.historyIndex = -1; // Exit history browsing mode
 		this.resetKillSequence();
+		this.recordUndoState();
 
-		// Clean the pasted text
-		const cleanText = pastedText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+		this.withUndoSuspended(() => {
+			// Clean the pasted text
+			const cleanText = pastedText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 
-		// Convert tabs to spaces (4 spaces per tab)
-		const tabExpandedText = cleanText.replace(/\t/g, "    ");
+			// Convert tabs to spaces (4 spaces per tab)
+			const tabExpandedText = cleanText.replace(/\t/g, "    ");
 
-		// Filter out non-printable characters except newlines
-		let filteredText = tabExpandedText
-			.split("")
-			.filter((char) => char === "\n" || char.charCodeAt(0) >= 32)
-			.join("");
+			// Filter out non-printable characters except newlines
+			let filteredText = tabExpandedText
+				.split("")
+				.filter((char) => char === "\n" || char.charCodeAt(0) >= 32)
+				.join("");
 
-		// If pasting a file path (starts with /, ~, or .) and the character before
-		// the cursor is a word character, prepend a space for better readability
-		if (/^[/~.]/.test(filteredText)) {
-			const currentLine = this.state.lines[this.state.cursorLine] || "";
-			const charBeforeCursor = this.state.cursorCol > 0 ? currentLine[this.state.cursorCol - 1] : "";
-			if (charBeforeCursor && /\w/.test(charBeforeCursor)) {
-				filteredText = ` ${filteredText}`;
+			// If pasting a file path (starts with /, ~, or .) and the character before
+			// the cursor is a word character, prepend a space for better readability
+			if (/^[/~.]/.test(filteredText)) {
+				const currentLine = this.state.lines[this.state.cursorLine] || "";
+				const charBeforeCursor = this.state.cursorCol > 0 ? currentLine[this.state.cursorCol - 1] : "";
+				if (charBeforeCursor && /\w/.test(charBeforeCursor)) {
+					filteredText = ` ${filteredText}`;
+				}
 			}
-		}
 
-		// Split into lines
-		const pastedLines = filteredText.split("\n");
-
-		// Check if this is a large paste (> 10 lines or > 1000 characters)
-		const totalChars = filteredText.length;
-		if (pastedLines.length > 10 || totalChars > 1000) {
-			// Store the paste and insert a marker
-			this.pasteCounter++;
-			const pasteId = this.pasteCounter;
-			this.pastes.set(pasteId, filteredText);
-
-			// Insert marker like "[paste #1 +123 lines]" or "[paste #1 1234 chars]"
-			const marker =
-				pastedLines.length > 10
-					? `[paste #${pasteId} +${pastedLines.length} lines]`
-					: `[paste #${pasteId} ${totalChars} chars]`;
-			for (const char of marker) {
-				this.insertCharacter(char);
-			}
+			// Split into lines
+			const pastedLines = filteredText.split("\n");
 
-			return;
-		}
+			// Check if this is a large paste (> 10 lines or > 1000 characters)
+			const totalChars = filteredText.length;
+			if (pastedLines.length > 10 || totalChars > 1000) {
+				// Store the paste and insert a marker
+				this.pasteCounter++;
+				const pasteId = this.pasteCounter;
+				this.pastes.set(pasteId, filteredText);
+
+				// Insert marker like "[paste #1 +123 lines]" or "[paste #1 1234 chars]"
+				const marker =
+					pastedLines.length > 10
+						? `[paste #${pasteId} +${pastedLines.length} lines]`
+						: `[paste #${pasteId} ${totalChars} chars]`;
+				this.insertTextAtCursor(marker);
 
-		if (pastedLines.length === 1) {
-			// Single line - just insert each character
-			const text = pastedLines[0] || "";
-			for (const char of text) {
-				this.insertCharacter(char);
+				return;
 			}
 
-			return;
-		}
+			if (pastedLines.length === 1) {
+				const text = pastedLines[0] || "";
+				this.insertTextAtCursor(text);
+				return;
+			}
 
-		// Multi-line paste - be very careful with array manipulation
-		const currentLine = this.state.lines[this.state.cursorLine] || "";
-		const beforeCursor = currentLine.slice(0, this.state.cursorCol);
-		const afterCursor = currentLine.slice(this.state.cursorCol);
+			// Multi-line paste - be very careful with array manipulation
+			const currentLine = this.state.lines[this.state.cursorLine] || "";
+			const beforeCursor = currentLine.slice(0, this.state.cursorCol);
+			const afterCursor = currentLine.slice(this.state.cursorCol);
 
-		// Build the new lines array step by step
-		const newLines: string[] = [];
+			// Build the new lines array step by step
+			const newLines: string[] = [];
 
-		// Add all lines before current line
-		for (let i = 0; i < this.state.cursorLine; i++) {
-			newLines.push(this.state.lines[i] || "");
-		}
+			// Add all lines before current line
+			for (let i = 0; i < this.state.cursorLine; i++) {
+				newLines.push(this.state.lines[i] || "");
+			}
 
-		// Add the first pasted line merged with before cursor text
-		newLines.push(beforeCursor + (pastedLines[0] || ""));
+			// Add the first pasted line merged with before cursor text
+			newLines.push(beforeCursor + (pastedLines[0] || ""));
 
-		// Add all middle pasted lines
-		for (let i = 1; i < pastedLines.length - 1; i++) {
-			newLines.push(pastedLines[i] || "");
-		}
+			// Add all middle pasted lines
+			for (let i = 1; i < pastedLines.length - 1; i++) {
+				newLines.push(pastedLines[i] || "");
+			}
 
-		// Add the last pasted line with after cursor text
-		newLines.push((pastedLines[pastedLines.length - 1] || "") + afterCursor);
+			// Add the last pasted line with after cursor text
+			newLines.push((pastedLines[pastedLines.length - 1] || "") + afterCursor);
 
-		// Add all lines after current line
-		for (let i = this.state.cursorLine + 1; i < this.state.lines.length; i++) {
-			newLines.push(this.state.lines[i] || "");
-		}
+			// Add all lines after current line
+			for (let i = this.state.cursorLine + 1; i < this.state.lines.length; i++) {
+				newLines.push(this.state.lines[i] || "");
+			}
 
-		// Replace the entire lines array
-		this.state.lines = newLines;
+			// Replace the entire lines array
+			this.state.lines = newLines;
 
-		// Update cursor position to end of pasted content
-		this.state.cursorLine += pastedLines.length - 1;
-		this.state.cursorCol = (pastedLines[pastedLines.length - 1] || "").length;
+			// Update cursor position to end of pasted content
+			this.state.cursorLine += pastedLines.length - 1;
+			this.state.cursorCol = (pastedLines[pastedLines.length - 1] || "").length;
 
-		// Notify of change
-		if (this.onChange) {
-			this.onChange(this.getText());
-		}
+			// Notify of change
+			if (this.onChange) {
+				this.onChange(this.getText());
+			}
+		});
 	}
 
 	private addNewLine(): void {
 		this.historyIndex = -1; // Exit history browsing mode
 		this.resetKillSequence();
+		this.recordUndoState();
 
 		const currentLine = this.state.lines[this.state.cursorLine] || "";
 
@@ -1249,6 +1261,7 @@ export class Editor implements Component, Focusable {
 	private handleBackspace(): void {
 		this.historyIndex = -1; // Exit history browsing mode
 		this.resetKillSequence();
+		this.recordUndoState();
 
 		if (this.state.cursorCol > 0) {
 			// Delete grapheme before cursor (handles emojis, combining characters, etc.)
@@ -1314,6 +1327,73 @@ export class Editor implements Component, Focusable {
 		this.lastKillWasKillCommand = false;
 	}
 
+	private clearUndoStack(): void {
+		this.undoStack = [];
+	}
+
+	private withUndoSuspended<T>(fn: () => T): T {
+		const wasSuspended = this.suspendUndo;
+		this.suspendUndo = true;
+		try {
+			return fn();
+		} finally {
+			this.suspendUndo = wasSuspended;
+		}
+	}
+
+	private recordUndoState(): void {
+		if (this.suspendUndo) return;
+		const snapshot: EditorState = {
+			lines: [...this.state.lines],
+			cursorLine: this.state.cursorLine,
+			cursorCol: this.state.cursorCol,
+		};
+
+		const last = this.undoStack[this.undoStack.length - 1];
+		if (last) {
+			const sameLines =
+				last.cursorLine === snapshot.cursorLine &&
+				last.cursorCol === snapshot.cursorCol &&
+				last.lines.length === snapshot.lines.length &&
+				last.lines.every((line, index) => line === snapshot.lines[index]);
+			if (sameLines) return;
+		}
+
+		this.undoStack.push(snapshot);
+		if (this.undoStack.length > 200) {
+			this.undoStack.shift();
+		}
+	}
+
+	private applyUndo(): void {
+		const snapshot = this.undoStack.pop();
+		if (!snapshot) return;
+
+		this.historyIndex = -1;
+		this.resetKillSequence();
+		this.state = {
+			lines: [...snapshot.lines],
+			cursorLine: snapshot.cursorLine,
+			cursorCol: snapshot.cursorCol,
+		};
+
+		if (this.onChange) {
+			this.onChange(this.getText());
+		}
+
+		if (this.isAutocompleting) {
+			this.updateAutocomplete();
+		} else {
+			const currentLine = this.state.lines[this.state.cursorLine] || "";
+			const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
+			if (textBeforeCursor.trimStart().startsWith("/")) {
+				this.tryTriggerAutocomplete();
+			} else if (textBeforeCursor.match(/(?:^|[\s])@[^\s]*$/)) {
+				this.tryTriggerAutocomplete();
+			}
+		}
+	}
+
 	private recordKill(text: string, direction: "forward" | "backward"): void {
 		if (!text) return;
 		if (this.lastKillWasKillCommand && this.killRing.length > 0) {
@@ -1331,6 +1411,7 @@ export class Editor implements Component, Focusable {
 	private insertTextAtCursor(text: string): void {
 		this.historyIndex = -1;
 		this.resetKillSequence();
+		this.recordUndoState();
 
 		const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 		const lines = normalized.split("\n");
@@ -1378,6 +1459,7 @@ export class Editor implements Component, Focusable {
 
 	private deleteToStartOfLine(): void {
 		this.historyIndex = -1; // Exit history browsing mode
+		this.recordUndoState();
 
 		const currentLine = this.state.lines[this.state.cursorLine] || "";
 		let deletedText = "";
@@ -1406,6 +1488,7 @@ export class Editor implements Component, Focusable {
 
 	private deleteToEndOfLine(): void {
 		this.historyIndex = -1; // Exit history browsing mode
+		this.recordUndoState();
 
 		const currentLine = this.state.lines[this.state.cursorLine] || "";
 		let deletedText = "";
@@ -1431,6 +1514,7 @@ export class Editor implements Component, Focusable {
 
 	private deleteWordBackwards(): void {
 		this.historyIndex = -1; // Exit history browsing mode
+		this.recordUndoState();
 
 		const currentLine = this.state.lines[this.state.cursorLine] || "";
 
@@ -1464,6 +1548,7 @@ export class Editor implements Component, Focusable {
 
 	private deleteWordForwards(): void {
 		this.historyIndex = -1; // Exit history browsing mode
+		this.recordUndoState();
 
 		const currentLine = this.state.lines[this.state.cursorLine] || "";
 
@@ -1493,6 +1578,7 @@ export class Editor implements Component, Focusable {
 	private handleForwardDelete(): void {
 		this.historyIndex = -1; // Exit history browsing mode
 		this.resetKillSequence();
+		this.recordUndoState();
 
 		const currentLine = this.state.lines[this.state.cursorLine] || "";
 

package/src/components/input.ts

@@ -127,6 +127,11 @@ export class Input implements Component, Focusable {
 			return;
 		}
 
+		if (kb.matches(data, "deleteWordForward")) {
+			this.deleteWordForwards();
+			return;
+		}
+
 		if (kb.matches(data, "deleteToLineStart")) {
 			this.value = this.value.slice(this.cursor);
 			this.cursor = 0;
@@ -205,6 +210,19 @@ export class Input implements Component, Focusable {
 		this.cursor = deleteFrom;
 	}
 
+	private deleteWordForwards(): void {
+		if (this.cursor >= this.value.length) {
+			return;
+		}
+
+		const oldCursor = this.cursor;
+		this.moveWordForwards();
+		const deleteTo = this.cursor;
+		this.cursor = oldCursor;
+
+		this.value = this.value.slice(0, oldCursor) + this.value.slice(deleteTo);
+	}
+
 	private moveWordBackwards(): void {
 		if (this.cursor === 0) {
 			return;

package/src/components/markdown.ts

@@ -52,6 +52,8 @@ export class Markdown implements Component {
 	private defaultTextStyle?: DefaultTextStyle;
 	private theme: MarkdownTheme;
 	private defaultStylePrefix?: string;
+	/** Number of spaces used to indent code block content. */
+	private codeBlockIndent: number;
 
 	// Cache for rendered output
 	private cachedText?: string;
@@ -64,12 +66,14 @@ export class Markdown implements Component {
 		paddingY: number,
 		theme: MarkdownTheme,
 		defaultTextStyle?: DefaultTextStyle,
+		codeBlockIndent: number = 2,
 	) {
 		this.text = text;
 		this.paddingX = paddingX;
 		this.paddingY = paddingY;
 		this.theme = theme;
 		this.defaultTextStyle = defaultTextStyle;
+		this.codeBlockIndent = Math.max(0, Math.floor(codeBlockIndent));
 	}
 
 	setText(text: string): void {
@@ -263,17 +267,18 @@ export class Markdown implements Component {
 			}
 
 			case "code": {
+				const codeIndent = " ".repeat(this.codeBlockIndent);
 				lines.push(this.theme.codeBlockBorder(`\`\`\`${token.lang || ""}`));
 				if (this.theme.highlightCode) {
 					const highlightedLines = this.theme.highlightCode(token.text, token.lang);
 					for (const hlLine of highlightedLines) {
-						lines.push(`  ${hlLine}`);
+						lines.push(`${codeIndent}${hlLine}`);
 					}
 				} else {
 					// Split code by newlines and style each line
 					const codeLines = token.text.split("\n");
 					for (const codeLine of codeLines) {
-						lines.push(`  ${this.theme.codeBlock(codeLine)}`);
+						lines.push(`${codeIndent}${this.theme.codeBlock(codeLine)}`);
 					}
 				}
 				lines.push(this.theme.codeBlockBorder("```"));
@@ -493,16 +498,17 @@ export class Markdown implements Component {
 				lines.push(text);
 			} else if (token.type === "code") {
 				// Code block in list item
+				const codeIndent = " ".repeat(this.codeBlockIndent);
 				lines.push(this.theme.codeBlockBorder(`\`\`\`${token.lang || ""}`));
 				if (this.theme.highlightCode) {
 					const highlightedLines = this.theme.highlightCode(token.text, token.lang);
 					for (const hlLine of highlightedLines) {
-						lines.push(`  ${hlLine}`);
+						lines.push(`${codeIndent}${hlLine}`);
 					}
 				} else {
 					const codeLines = token.text.split("\n");
 					for (const codeLine of codeLines) {
-						lines.push(`  ${this.theme.codeBlock(codeLine)}`);
+						lines.push(`${codeIndent}${this.theme.codeBlock(codeLine)}`);
 					}
 				}
 				lines.push(this.theme.codeBlockBorder("```"));

package/src/fuzzy.ts

@@ -9,10 +9,9 @@ export interface FuzzyMatch {
 	score: number;
 }
 
-export function fuzzyMatch(query: string, text: string): FuzzyMatch {
-	const queryLower = query.toLowerCase();
-	const textLower = text.toLowerCase();
+const ALPHANUMERIC_SWAP_PENALTY = 5;
 
+function scoreMatch(queryLower: string, textLower: string): FuzzyMatch {
 	if (queryLower.length === 0) {
 		return { matches: true, score: 0 };
 	}
@@ -62,6 +61,43 @@ export function fuzzyMatch(query: string, text: string): FuzzyMatch {
 	return { matches: true, score };
 }
 
+function buildAlphanumericSwapQueries(queryLower: string): string[] {
+	const variants = new Set<string>();
+	for (let i = 0; i < queryLower.length - 1; i++) {
+		const current = queryLower[i];
+		const next = queryLower[i + 1];
+		const isAlphaNumSwap =
+			(current && /[a-z]/.test(current) && next && /\d/.test(next)) ||
+			(current && /\d/.test(current) && next && /[a-z]/.test(next));
+		if (!isAlphaNumSwap) continue;
+		const swapped = queryLower.slice(0, i) + next + current + queryLower.slice(i + 2);
+		variants.add(swapped);
+	}
+	return [...variants];
+}
+
+export function fuzzyMatch(query: string, text: string): FuzzyMatch {
+	const queryLower = query.toLowerCase();
+	const textLower = text.toLowerCase();
+
+	const direct = scoreMatch(queryLower, textLower);
+	if (direct.matches) {
+		return direct;
+	}
+
+	let bestSwap: FuzzyMatch | null = null;
+	for (const variant of buildAlphanumericSwapQueries(queryLower)) {
+		const match = scoreMatch(variant, textLower);
+		if (!match.matches) continue;
+		const score = match.score + ALPHANUMERIC_SWAP_PENALTY;
+		if (!bestSwap || score < bestSwap.score) {
+			bestSwap = { matches: true, score };
+		}
+	}
+
+	return bestSwap ?? direct;
+}
+
 /**
  * Filter and sort items by fuzzy match quality (best matches first).
  * Supports space-separated tokens: all tokens must match.

package/src/keybindings.ts

@@ -17,6 +17,7 @@ export type EditorAction =
 	| "deleteCharBackward"
 	| "deleteCharForward"
 	| "deleteWordBackward"
+	| "deleteWordForward"
 	| "deleteToLineStart"
 	| "deleteToLineEnd"
 	// Text input
@@ -60,6 +61,7 @@ export const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig> = {
 	deleteCharBackward: "backspace",
 	deleteCharForward: "delete",
 	deleteWordBackward: ["ctrl+w", "alt+backspace"],
+	deleteWordForward: ["alt+delete", "alt+d"],
 	deleteToLineStart: "ctrl+u",
 	deleteToLineEnd: "ctrl+k",
 	// Text input
@@ -100,6 +102,8 @@ const SHIFTED_SYMBOL_KEYS = new Set<string>([
 	"~",
 ]);
 
+const normalizeKeyId = (key: KeyId): KeyId => key.toLowerCase() as KeyId;
+
 /**
  * Manages keybindings for the editor.
  */
@@ -117,14 +121,20 @@ export class EditorKeybindingsManager {
 		// Start with defaults
 		for (const [action, keys] of Object.entries(DEFAULT_EDITOR_KEYBINDINGS)) {
 			const keyArray = Array.isArray(keys) ? keys : [keys];
-			this.actionToKeys.set(action as EditorAction, [...keyArray]);
+			this.actionToKeys.set(
+				action as EditorAction,
+				keyArray.map((key) => normalizeKeyId(key as KeyId)),
+			);
 		}
 
 		// Override with user config
 		for (const [action, keys] of Object.entries(config)) {
 			if (keys === undefined) continue;
 			const keyArray = Array.isArray(keys) ? keys : [keys];
-			this.actionToKeys.set(action as EditorAction, keyArray);
+			this.actionToKeys.set(
+				action as EditorAction,
+				keyArray.map((key) => normalizeKeyId(key as KeyId)),
+			);
 		}
 	}
 

package/src/keys.ts

@@ -290,6 +290,23 @@ const SYMBOL_KEYS = new Set([
 	"?",
 ]);
 
+const CTRL_SYMBOL_MAP: Record<string, string> = {
+	"@": "\x00",
+	"[": "\x1b",
+	"\\": "\x1c",
+	"]": "\x1d",
+	"^": "\x1e",
+	_: "\x1f",
+	"-": "\x1f",
+} as const;
+
+const CTRL_SYMBOL_CODES: Record<number, KeyId> = {
+	28: "ctrl+\\",
+	29: "ctrl+]",
+	30: "ctrl+^",
+	31: "ctrl+_",
+} as const;
+
 const MODIFIERS = {
 	shift: 1,
 	alt: 2,
@@ -966,6 +983,7 @@ export function matchesKey(data: string, keyId: KeyId): boolean {
 	// Handle single letter keys (a-z) and some symbols
 	if (key.length === 1 && ((key >= "a" && key <= "z") || SYMBOL_KEYS.has(key))) {
 		const codepoint = key.charCodeAt(0);
+		const isLetterKey = key >= "a" && key <= "z";
 
 		if (ctrl && alt && !shift && !_kittyProtocolActive && key >= "a" && key <= "z") {
 			return data === `\x1b${rawCtrlChar(key)}`;
@@ -977,9 +995,16 @@ export function matchesKey(data: string, keyId: KeyId): boolean {
 		}
 
 		if (ctrl && !shift && !alt) {
+			if (!isLetterKey) {
+				const legacyCtrl = CTRL_SYMBOL_MAP[key];
+				if (legacyCtrl && data === legacyCtrl) return true;
+				if (matchesModifyOtherKeys(data, codepoint, MODIFIERS.ctrl)) return true;
+				return matchesKittySequence(data, codepoint, MODIFIERS.ctrl);
+			}
 			const raw = rawCtrlChar(key);
 			if (data === raw) return true;
 			if (data.length > 0 && data.charCodeAt(0) === raw.charCodeAt(0)) return true;
+			if (matchesModifyOtherKeys(data, codepoint, MODIFIERS.ctrl)) return true;
 			return matchesKittySequence(data, codepoint, MODIFIERS.ctrl);
 		}
 
@@ -1096,6 +1121,10 @@ export function parseKey(data: string): string | undefined {
 	// Raw Ctrl+letter
 	if (data.length === 1) {
 		const code = data.charCodeAt(0);
+		const ctrlSymbol = CTRL_SYMBOL_CODES[code];
+		if (ctrlSymbol) {
+			return ctrlSymbol;
+		}
 		if (code >= 1 && code <= 26) {
 			return `ctrl+${String.fromCharCode(code + 96)}`;
 		}