indusagi 0.12.19 → 0.12.20

package/dist/tui/keys.js

@@ -34,17 +34,103 @@ export function setKittyProtocolActive(active) {
 export 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") for single modifier
- * - Key.ctrlShift("p"), Key.ctrlAlt("x") for combined modifiers
- */
-export const Key = {
-    // Special keys
+// =============================================================================
+// Type-Safe Key Identifiers
+// =============================================================================
+const LETTER_VALUES = [
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+];
+const SYMBOL_VALUES = [
+    "`",
+    "-",
+    "=",
+    "[",
+    "]",
+    "\\",
+    ";",
+    "'",
+    ",",
+    ".",
+    "/",
+    "!",
+    "@",
+    "#",
+    "$",
+    "%",
+    "^",
+    "&",
+    "*",
+    "(",
+    ")",
+    "_",
+    "+",
+    "|",
+    "~",
+    "{",
+    "}",
+    ":",
+    "<",
+    ">",
+    "?",
+];
+const SPECIAL_KEY_VALUES = [
+    "escape",
+    "esc",
+    "enter",
+    "return",
+    "tab",
+    "space",
+    "backspace",
+    "delete",
+    "insert",
+    "clear",
+    "home",
+    "end",
+    "pageUp",
+    "pageDown",
+    "up",
+    "down",
+    "left",
+    "right",
+    "f1",
+    "f2",
+    "f3",
+    "f4",
+    "f5",
+    "f6",
+    "f7",
+    "f8",
+    "f9",
+    "f10",
+    "f11",
+    "f12",
+];
+const SPECIAL_KEY_LITERAL_MAP = {
     escape: "escape",
     esc: "esc",
     enter: "enter",
@@ -75,7 +161,8 @@ export const Key = {
     f10: "f10",
     f11: "f11",
     f12: "f12",
-    // Symbol keys
+};
+const SYMBOL_KEY_LITERAL_MAP = {
     backtick: "`",
     hyphen: "-",
     equals: "=",
@@ -107,18 +194,28 @@ export const Key = {
     lessthan: "<",
     greaterthan: ">",
     question: "?",
-    // Single modifiers
+};
+/**
+ * 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") for single modifier
+ * - Key.ctrlShift("p"), Key.ctrlAlt("x") for combined modifiers
+ */
+export const Key = {
+    ...SPECIAL_KEY_LITERAL_MAP,
+    ...SYMBOL_KEY_LITERAL_MAP,
     ctrl: (key) => `ctrl+${key}`,
     shift: (key) => `shift+${key}`,
     alt: (key) => `alt+${key}`,
-    // Combined modifiers
     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}`,
-    // Triple modifiers
     ctrlShiftAlt: (key) => `ctrl+shift+alt+${key}`,
 };
 // =============================================================================
@@ -568,444 +665,429 @@ function parseKeyId(keyId) {
         alt: parts.includes("alt"),
     };
 }
-/**
- * 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"
- * - Combined modifiers: "shift+ctrl+p", "ctrl+alt+x"
- *
- * Use the Key helper for autocomplete: Key.ctrl("c"), Key.escape, Key.ctrlShift("p")
- *
- * @param data - Raw input data from terminal
- * @param keyId - Key identifier (e.g., "ctrl+c", "escape", Key.ctrl("c"))
- */
-export function matchesKey(data, keyId) {
-    const parsed = parseKeyId(keyId);
-    if (!parsed)
-        return false;
-    const { key, ctrl, shift, alt } = parsed;
-    let modifier = 0;
-    if (shift)
-        modifier |= MODIFIERS.shift;
-    if (alt)
-        modifier |= MODIFIERS.alt;
-    if (ctrl)
-        modifier |= MODIFIERS.ctrl;
-    switch (key) {
-        case "escape":
-        case "esc":
-            if (modifier !== 0)
-                return false;
-            return data === "\x1b" || matchesKittySequence(data, CODEPOINTS.escape, 0);
-        case "space":
-            if (!_kittyProtocolActive) {
-                if (ctrl && !alt && !shift && data === "\x00") {
-                    return true;
-                }
-                if (alt && !ctrl && !shift && data === "\x1b ") {
-                    return true;
-                }
-            }
-            if (modifier === 0) {
-                return data === " " || matchesKittySequence(data, CODEPOINTS.space, 0);
-            }
-            return matchesKittySequence(data, CODEPOINTS.space, modifier);
-        case "tab":
-            if (shift && !ctrl && !alt) {
-                return data === "\x1b[Z" || matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift);
-            }
-            if (modifier === 0) {
-                return data === "\t" || matchesKittySequence(data, CODEPOINTS.tab, 0);
-            }
-            return matchesKittySequence(data, CODEPOINTS.tab, modifier);
-        case "enter":
-        case "return":
-            if (shift && !ctrl && !alt) {
-                // CSI u sequences (standard Kitty protocol)
-                if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift) ||
-                    matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.shift)) {
-                    return true;
-                }
-                // xterm modifyOtherKeys format (fallback when Kitty protocol not enabled)
-                if (matchesModifyOtherKeys(data, CODEPOINTS.enter, MODIFIERS.shift)) {
-                    return true;
-                }
-                // When Kitty protocol is active, legacy sequences are custom terminal mappings
-                // \x1b\r = Kitty's "map shift+enter send_text all \e\r"
-                // \n = Ghostty's "keybind = shift+enter=text:\n"
-                if (_kittyProtocolActive) {
-                    return data === "\x1b\r" || data === "\n";
-                }
-                return false;
-            }
-            if (alt && !ctrl && !shift) {
-                // CSI u sequences (standard Kitty protocol)
-                if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt) ||
-                    matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.alt)) {
-                    return true;
+class KeyMatchEngine {
+    specialKeyResolverRegistry;
+    constructor() {
+        this.specialKeyResolverRegistry = {
+            escape: (data, _decodedKeyId, modifierBits) => {
+                if (modifierBits !== 0)
+                    return false;
+                return data === "\x1b" || matchesKittySequence(data, CODEPOINTS.escape, 0);
+            },
+            esc: (data, _decodedKeyId, modifierBits) => {
+                if (modifierBits !== 0)
+                    return false;
+                return data === "\x1b" || matchesKittySequence(data, CODEPOINTS.escape, 0);
+            },
+            space: (data, decodedKeyId, modifierBits) => {
+                const { ctrl, shift, alt } = decodedKeyId;
+                if (!_kittyProtocolActive) {
+                    if (ctrl && !alt && !shift && data === "\x00")
+                        return true;
+                    if (alt && !ctrl && !shift && data === "\x1b ")
+                        return true;
                 }
-                // xterm modifyOtherKeys format (fallback when Kitty protocol not enabled)
-                if (matchesModifyOtherKeys(data, CODEPOINTS.enter, MODIFIERS.alt)) {
-                    return true;
+                if (modifierBits === 0)
+                    return data === " " || matchesKittySequence(data, CODEPOINTS.space, 0);
+                return matchesKittySequence(data, CODEPOINTS.space, modifierBits);
+            },
+            tab: (data, decodedKeyId, modifierBits) => {
+                const { ctrl, shift, alt } = decodedKeyId;
+                if (shift && !ctrl && !alt) {
+                    return data === "\x1b[Z" || matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift);
                 }
-                // \x1b\r is alt+enter only in legacy mode (no Kitty protocol)
-                // When Kitty protocol is active, alt+enter comes as CSI u sequence
-                if (!_kittyProtocolActive) {
-                    return data === "\x1b\r";
+                if (modifierBits === 0)
+                    return data === "\t" || matchesKittySequence(data, CODEPOINTS.tab, 0);
+                return matchesKittySequence(data, CODEPOINTS.tab, modifierBits);
+            },
+            enter: (data, decodedKeyId, modifierBits) => this.matchEnterLikeKey(data, decodedKeyId, modifierBits),
+            return: (data, decodedKeyId, modifierBits) => this.matchEnterLikeKey(data, decodedKeyId, modifierBits),
+            backspace: (data, decodedKeyId, modifierBits) => {
+                const { ctrl, shift, alt } = decodedKeyId;
+                if (alt && !ctrl && !shift) {
+                    if (data === "\x1b\x7f" || data === "\x1b\b")
+                        return true;
+                    return matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt);
                 }
-                return false;
-            }
-            if (modifier === 0) {
-                return (data === "\r" ||
-                    (!_kittyProtocolActive && data === "\n") ||
-                    data === "\x1bOM" || // SS3 M (numpad enter in some terminals)
-                    matchesKittySequence(data, CODEPOINTS.enter, 0) ||
-                    matchesKittySequence(data, CODEPOINTS.kpEnter, 0));
-            }
-            return (matchesKittySequence(data, CODEPOINTS.enter, modifier) ||
-                matchesKittySequence(data, CODEPOINTS.kpEnter, modifier));
-        case "backspace":
-            if (alt && !ctrl && !shift) {
-                if (data === "\x1b\x7f" || data === "\x1b\b") {
-                    return true;
+                if (modifierBits === 0) {
+                    return data === "\x7f" || data === "\x08" || matchesKittySequence(data, CODEPOINTS.backspace, 0);
                 }
-                return matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt);
-            }
-            if (modifier === 0) {
-                return data === "\x7f" || data === "\x08" || matchesKittySequence(data, CODEPOINTS.backspace, 0);
-            }
-            return matchesKittySequence(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 (alt && !ctrl && !shift) {
-                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 matchesKittySequence(data, CODEPOINTS.backspace, modifierBits);
+            },
+            insert: (data, _decodedKeyId, modifierBits) => this.matchFunctionalKey(data, "insert", FUNCTIONAL_CODEPOINTS.insert, modifierBits),
+            delete: (data, _decodedKeyId, modifierBits) => this.matchFunctionalKey(data, "delete", FUNCTIONAL_CODEPOINTS.delete, modifierBits),
+            clear: (data, _decodedKeyId, modifierBits) => {
+                if (modifierBits === 0)
+                    return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.clear);
+                return matchesLegacyModifierSequence(data, "clear", modifierBits);
+            },
+            home: (data, _decodedKeyId, modifierBits) => this.matchFunctionalKey(data, "home", FUNCTIONAL_CODEPOINTS.home, modifierBits),
+            end: (data, _decodedKeyId, modifierBits) => this.matchFunctionalKey(data, "end", FUNCTIONAL_CODEPOINTS.end, modifierBits),
+            pageup: (data, _decodedKeyId, modifierBits) => this.matchFunctionalKey(data, "pageUp", FUNCTIONAL_CODEPOINTS.pageUp, modifierBits),
+            pagedown: (data, _decodedKeyId, modifierBits) => this.matchFunctionalKey(data, "pageDown", FUNCTIONAL_CODEPOINTS.pageDown, modifierBits),
+            up: (data, decodedKeyId, modifierBits) => this.matchArrowKey(data, "up", ARROW_CODEPOINTS.up, decodedKeyId, modifierBits),
+            down: (data, decodedKeyId, modifierBits) => this.matchArrowKey(data, "down", ARROW_CODEPOINTS.down, decodedKeyId, modifierBits),
+            left: (data, decodedKeyId, modifierBits) => this.matchLeftArrow(data, decodedKeyId, modifierBits),
+            right: (data, decodedKeyId, modifierBits) => this.matchRightArrow(data, decodedKeyId, modifierBits),
+            f1: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f1", modifierBits),
+            f2: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f2", modifierBits),
+            f3: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f3", modifierBits),
+            f4: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f4", modifierBits),
+            f5: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f5", modifierBits),
+            f6: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f6", modifierBits),
+            f7: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f7", modifierBits),
+            f8: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f8", modifierBits),
+            f9: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f9", modifierBits),
+            f10: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f10", modifierBits),
+            f11: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f11", modifierBits),
+            f12: (data, _decodedKeyId, modifierBits) => this.matchFunctionKey(data, "f12", modifierBits),
+        };
+    }
+    matches(data, keyId) {
+        const decodedKeyId = parseKeyId(keyId);
+        if (!decodedKeyId)
+            return false;
+        const modifierBits = this.computeModifierMask(decodedKeyId);
+        const specialKeyResolver = this.specialKeyResolverRegistry[decodedKeyId.key];
+        if (specialKeyResolver) {
+            return specialKeyResolver(data, decodedKeyId, modifierBits);
+        }
+        return this.matchPrintableKey(data, decodedKeyId, modifierBits);
+    }
+    computeModifierMask(decodedKeyId) {
+        let modifierBits = 0;
+        if (decodedKeyId.shift)
+            modifierBits |= MODIFIERS.shift;
+        if (decodedKeyId.alt)
+            modifierBits |= MODIFIERS.alt;
+        if (decodedKeyId.ctrl)
+            modifierBits |= MODIFIERS.ctrl;
+        return modifierBits;
+    }
+    matchFunctionKey(data, functionKey, modifierBits) {
+        if (modifierBits !== 0)
+            return false;
+        return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES[functionKey]);
+    }
+    matchEnterLikeKey(data, decodedKeyId, modifierBits) {
+        const { ctrl, shift, alt } = decodedKeyId;
+        if (shift && !ctrl && !alt) {
+            if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift) ||
+                matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.shift)) {
                 return true;
             }
-            return matchesKittySequence(data, ARROW_CODEPOINTS.up, modifier);
-        case "down":
-            if (alt && !ctrl && !shift) {
-                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)) {
+            if (matchesModifyOtherKeys(data, CODEPOINTS.enter, MODIFIERS.shift)) {
                 return true;
             }
-            return matchesKittySequence(data, ARROW_CODEPOINTS.down, modifier);
-        case "left":
-            if (alt && !ctrl && !shift) {
-                return (data === "\x1b[1;3D" ||
-                    (!_kittyProtocolActive && data === "\x1bB") ||
-                    data === "\x1bb" ||
-                    matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt));
-            }
-            if (ctrl && !alt && !shift) {
-                return (data === "\x1b[1;5D" ||
-                    matchesLegacyModifierSequence(data, "left", MODIFIERS.ctrl) ||
-                    matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl));
+            if (_kittyProtocolActive) {
+                return data === "\x1b\r" || data === "\n";
             }
-            if (modifier === 0) {
-                return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.left) ||
-                    matchesKittySequence(data, ARROW_CODEPOINTS.left, 0));
-            }
-            if (matchesLegacyModifierSequence(data, "left", modifier)) {
+            return false;
+        }
+        if (alt && !ctrl && !shift) {
+            if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt) ||
+                matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.alt)) {
                 return true;
             }
-            return matchesKittySequence(data, ARROW_CODEPOINTS.left, modifier);
-        case "right":
-            if (alt && !ctrl && !shift) {
-                return (data === "\x1b[1;3C" ||
-                    (!_kittyProtocolActive && data === "\x1bF") ||
-                    data === "\x1bf" ||
-                    matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt));
-            }
-            if (ctrl && !alt && !shift) {
-                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)) {
+            if (matchesModifyOtherKeys(data, CODEPOINTS.enter, MODIFIERS.alt)) {
                 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;
+            if (!_kittyProtocolActive) {
+                return data === "\x1b\r";
             }
-            const functionKey = key;
-            return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES[functionKey]);
+            return false;
+        }
+        if (modifierBits === 0) {
+            return (data === "\r" ||
+                (!_kittyProtocolActive && data === "\n") ||
+                data === "\x1bOM" ||
+                matchesKittySequence(data, CODEPOINTS.enter, 0) ||
+                matchesKittySequence(data, CODEPOINTS.kpEnter, 0));
+        }
+        return (matchesKittySequence(data, CODEPOINTS.enter, modifierBits) ||
+            matchesKittySequence(data, CODEPOINTS.kpEnter, modifierBits));
+    }
+    matchFunctionalKey(data, legacyName, codepoint, modifierBits) {
+        if (modifierBits === 0) {
+            return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES[legacyName]) || matchesKittySequence(data, codepoint, 0);
+        }
+        if (matchesLegacyModifierSequence(data, legacyName, modifierBits)) {
+            return true;
+        }
+        return matchesKittySequence(data, codepoint, modifierBits);
+    }
+    matchArrowKey(data, arrowName, codepoint, decodedKeyId, modifierBits) {
+        const { ctrl, shift, alt } = decodedKeyId;
+        if (alt && !ctrl && !shift) {
+            const altLegacy = arrowName === "up" ? "\x1bp" : "\x1bn";
+            return data === altLegacy || matchesKittySequence(data, codepoint, MODIFIERS.alt);
+        }
+        if (modifierBits === 0) {
+            return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES[arrowName]) || matchesKittySequence(data, codepoint, 0);
+        }
+        if (matchesLegacyModifierSequence(data, arrowName, modifierBits)) {
+            return true;
+        }
+        return matchesKittySequence(data, codepoint, modifierBits);
+    }
+    matchLeftArrow(data, decodedKeyId, modifierBits) {
+        const { ctrl, shift, alt } = decodedKeyId;
+        if (alt && !ctrl && !shift) {
+            return (data === "\x1b[1;3D" ||
+                (!_kittyProtocolActive && data === "\x1bB") ||
+                data === "\x1bb" ||
+                matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt));
+        }
+        if (ctrl && !alt && !shift) {
+            return (data === "\x1b[1;5D" ||
+                matchesLegacyModifierSequence(data, "left", MODIFIERS.ctrl) ||
+                matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl));
+        }
+        if (modifierBits === 0) {
+            return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.left) ||
+                matchesKittySequence(data, ARROW_CODEPOINTS.left, 0));
+        }
+        if (matchesLegacyModifierSequence(data, "left", modifierBits)) {
+            return true;
         }
+        return matchesKittySequence(data, ARROW_CODEPOINTS.left, modifierBits);
     }
-    // Handle single letter keys (a-z) and some symbols
-    if (key.length === 1 && ((key >= "a" && key <= "z") || SYMBOL_KEYS.has(key))) {
+    matchRightArrow(data, decodedKeyId, modifierBits) {
+        const { ctrl, shift, alt } = decodedKeyId;
+        if (alt && !ctrl && !shift) {
+            return (data === "\x1b[1;3C" ||
+                (!_kittyProtocolActive && data === "\x1bF") ||
+                data === "\x1bf" ||
+                matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt));
+        }
+        if (ctrl && !alt && !shift) {
+            return (data === "\x1b[1;5C" ||
+                matchesLegacyModifierSequence(data, "right", MODIFIERS.ctrl) ||
+                matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl));
+        }
+        if (modifierBits === 0) {
+            return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.right) ||
+                matchesKittySequence(data, ARROW_CODEPOINTS.right, 0));
+        }
+        if (matchesLegacyModifierSequence(data, "right", modifierBits)) {
+            return true;
+        }
+        return matchesKittySequence(data, ARROW_CODEPOINTS.right, modifierBits);
+    }
+    matchPrintableKey(data, decodedKeyId, modifierBits) {
+        const { key, ctrl, shift, alt } = decodedKeyId;
+        if (!(key.length === 1 && ((key >= "a" && key <= "z") || SYMBOL_KEYS.has(key)))) {
+            return false;
+        }
         const codepoint = key.charCodeAt(0);
-        const rawCtrl = rawCtrlChar(key);
-        if (ctrl && alt && !shift && !_kittyProtocolActive && rawCtrl) {
-            // Legacy: ctrl+alt+key is ESC followed by the control character
-            return data === `\x1b${rawCtrl}`;
+        const controlCharacter = rawCtrlChar(key);
+        if (ctrl && alt && !shift && !_kittyProtocolActive && controlCharacter) {
+            return data === `\x1b${controlCharacter}`;
         }
         if (alt && !ctrl && !shift && !_kittyProtocolActive && key >= "a" && key <= "z") {
-            // Legacy: alt+letter is ESC followed by the letter
-            if (data === `\x1b${key}`)
+            if (data === `\x1b${key}`) {
                 return true;
+            }
         }
         if (ctrl && !shift && !alt) {
-            // Legacy: ctrl+key sends the control character
-            if (rawCtrl && data === rawCtrl)
+            if (controlCharacter && data === controlCharacter) {
                 return true;
+            }
             return matchesKittySequence(data, codepoint, MODIFIERS.ctrl);
         }
         if (ctrl && shift && !alt) {
             return matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl);
         }
         if (shift && !ctrl && !alt) {
-            // Legacy: shift+letter produces uppercase
-            if (data === key.toUpperCase())
+            if (data === key.toUpperCase()) {
                 return true;
+            }
             return matchesKittySequence(data, codepoint, MODIFIERS.shift);
         }
-        if (modifier !== 0) {
-            return matchesKittySequence(data, codepoint, modifier);
+        if (modifierBits !== 0) {
+            return matchesKittySequence(data, codepoint, modifierBits);
         }
-        // Check both raw char and Kitty sequence (needed for release events)
         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
- */
-export function parseKey(data) {
-    const kitty = parseKittySequence(data);
-    if (kitty) {
-        const { codepoint, baseLayoutKey, modifier } = kitty;
-        const mods = [];
-        const effectiveMod = modifier & ~LOCK_MASK;
-        if (effectiveMod & MODIFIERS.shift)
-            mods.push("shift");
-        if (effectiveMod & MODIFIERS.ctrl)
-            mods.push("ctrl");
-        if (effectiveMod & MODIFIERS.alt)
-            mods.push("alt");
-        // Prefer base layout key for consistent shortcut naming across keyboard layouts
-        // This ensures Ctrl+С (Cyrillic) is reported as "ctrl+c" (Latin)
-        const effectiveCodepoint = baseLayoutKey ?? codepoint;
-        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 >= 97 && effectiveCodepoint <= 122)
-            keyName = String.fromCharCode(effectiveCodepoint);
-        else if (SYMBOL_KEYS.has(String.fromCharCode(effectiveCodepoint)))
-            keyName = String.fromCharCode(effectiveCodepoint);
-        if (keyName) {
-            return mods.length > 0 ? `${mods.join("+")}+${keyName}` : keyName;
+class KeyParseEngine {
+    legacyLiteralParseTable = {
+        "\x1b": "escape",
+        "\x1c": "ctrl+\\",
+        "\x1d": "ctrl+]",
+        "\x1f": "ctrl+-",
+        "\x1b\x1b": "ctrl+alt+[",
+        "\x1b\x1c": "ctrl+alt+\\",
+        "\x1b\x1d": "ctrl+alt+]",
+        "\x1b\x1f": "ctrl+alt+-",
+        "\t": "tab",
+        "\x00": "ctrl+space",
+        " ": "space",
+        "\x1b[Z": "shift+tab",
+        "\x1b[A": "up",
+        "\x1b[B": "down",
+        "\x1b[C": "right",
+        "\x1b[D": "left",
+        "\x1b[3~": "delete",
+        "\x1b[5~": "pageUp",
+        "\x1b[6~": "pageDown",
+    };
+    parse(data) {
+        const kittyDerivedKeyId = this.parseFromKitty(data);
+        if (kittyDerivedKeyId) {
+            return kittyDerivedKeyId;
         }
+        return this.parseFromLegacy(data);
     }
-    // Mode-aware legacy sequences
-    // When Kitty protocol is active, ambiguous sequences are interpreted as custom terminal mappings:
-    // - \x1b\r = shift+enter (Kitty mapping), not alt+enter
-    // - \n = shift+enter (Ghostty mapping)
-    if (_kittyProtocolActive) {
-        if (data === "\x1b\r" || data === "\n")
-            return "shift+enter";
+    parseFromKitty(data) {
+        const parsedKitty = parseKittySequence(data);
+        if (!parsedKitty) {
+            return undefined;
+        }
+        const orderedModifiers = this.formatModifierNames(parsedKitty.modifier & ~LOCK_MASK);
+        const lookupCodepoint = parsedKitty.baseLayoutKey ?? parsedKitty.codepoint;
+        const keyName = this.resolveKeyName(lookupCodepoint);
+        if (!keyName)
+            return undefined;
+        return orderedModifiers.length > 0 ? `${orderedModifiers.join("+")}+${keyName}` : keyName;
     }
-    const legacySequenceKeyId = LEGACY_SEQUENCE_KEY_IDS[data];
-    if (legacySequenceKeyId)
-        return legacySequenceKeyId;
-    // Legacy sequences (used when Kitty protocol is not active, or for unambiguous sequences)
-    if (data === "\x1b")
-        return "escape";
-    if (data === "\x1c")
-        return "ctrl+\\";
-    if (data === "\x1d")
-        return "ctrl+]";
-    if (data === "\x1f")
-        return "ctrl+-";
-    if (data === "\x1b\x1b")
-        return "ctrl+alt+[";
-    if (data === "\x1b\x1c")
-        return "ctrl+alt+\\";
-    if (data === "\x1b\x1d")
-        return "ctrl+alt+]";
-    if (data === "\x1b\x1f")
-        return "ctrl+alt+-";
-    if (data === "\t")
-        return "tab";
-    if (data === "\r" || (!_kittyProtocolActive && data === "\n") || data === "\x1bOM")
-        return "enter";
-    if (data === "\x00")
-        return "ctrl+space";
-    if (data === " ")
-        return "space";
-    if (data === "\x7f" || data === "\x08")
-        return "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\x7f" || 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)}`;
-        }
-        // Legacy alt+letter (ESC followed by letter a-z)
-        if (code >= 97 && code <= 122) {
-            return `alt+${String.fromCharCode(code)}`;
+    parseFromLegacy(data) {
+        if (_kittyProtocolActive && (data === "\x1b\r" || data === "\n")) {
+            return "shift+enter";
         }
+        const mappedLegacyIdentifier = LEGACY_SEQUENCE_KEY_IDS[data];
+        if (mappedLegacyIdentifier) {
+            return mappedLegacyIdentifier;
+        }
+        if (data === "\r" || (!_kittyProtocolActive && data === "\n") || data === "\x1bOM") {
+            return "enter";
+        }
+        if (data === "\x7f" || data === "\x08") {
+            return "backspace";
+        }
+        if (!_kittyProtocolActive && data === "\x1b\r") {
+            return "alt+enter";
+        }
+        if (!_kittyProtocolActive && data === "\x1b ") {
+            return "alt+space";
+        }
+        if (data === "\x1b\x7f" || data === "\x1b\b") {
+            return "alt+backspace";
+        }
+        if (!_kittyProtocolActive && data === "\x1bB") {
+            return "alt+left";
+        }
+        if (!_kittyProtocolActive && data === "\x1bF") {
+            return "alt+right";
+        }
+        if (data === "\x1b[H" || data === "\x1bOH") {
+            return "home";
+        }
+        if (data === "\x1b[F" || data === "\x1bOF") {
+            return "end";
+        }
+        const exactMatch = this.legacyLiteralParseTable[data];
+        if (exactMatch) {
+            return exactMatch;
+        }
+        if (!_kittyProtocolActive && data.length === 2 && data[0] === "\x1b") {
+            const legacyCode = data.charCodeAt(1);
+            if (legacyCode >= 1 && legacyCode <= 26) {
+                return `ctrl+alt+${String.fromCharCode(legacyCode + 96)}`;
+            }
+            if (legacyCode >= 97 && legacyCode <= 122) {
+                return `alt+${String.fromCharCode(legacyCode)}`;
+            }
+        }
+        if (data.length === 1) {
+            const rawCode = data.charCodeAt(0);
+            if (rawCode >= 1 && rawCode <= 26) {
+                return `ctrl+${String.fromCharCode(rawCode + 96)}`;
+            }
+            if (rawCode >= 32 && rawCode <= 126) {
+                return data;
+            }
+        }
+        return undefined;
     }
-    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";
-    // Raw Ctrl+letter
-    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;
+    resolveKeyName(codepoint) {
+        if (codepoint === CODEPOINTS.escape)
+            return "escape";
+        if (codepoint === CODEPOINTS.tab)
+            return "tab";
+        if (codepoint === CODEPOINTS.enter || codepoint === CODEPOINTS.kpEnter)
+            return "enter";
+        if (codepoint === CODEPOINTS.space)
+            return "space";
+        if (codepoint === CODEPOINTS.backspace)
+            return "backspace";
+        if (codepoint === FUNCTIONAL_CODEPOINTS.delete)
+            return "delete";
+        if (codepoint === FUNCTIONAL_CODEPOINTS.insert)
+            return "insert";
+        if (codepoint === FUNCTIONAL_CODEPOINTS.home)
+            return "home";
+        if (codepoint === FUNCTIONAL_CODEPOINTS.end)
+            return "end";
+        if (codepoint === FUNCTIONAL_CODEPOINTS.pageUp)
+            return "pageUp";
+        if (codepoint === FUNCTIONAL_CODEPOINTS.pageDown)
+            return "pageDown";
+        if (codepoint === ARROW_CODEPOINTS.up)
+            return "up";
+        if (codepoint === ARROW_CODEPOINTS.down)
+            return "down";
+        if (codepoint === ARROW_CODEPOINTS.left)
+            return "left";
+        if (codepoint === ARROW_CODEPOINTS.right)
+            return "right";
+        if (codepoint >= 97 && codepoint <= 122)
+            return String.fromCharCode(codepoint);
+        const char = String.fromCharCode(codepoint);
+        if (SYMBOL_KEYS.has(char)) {
+            return char;
         }
+        return undefined;
     }
-    return undefined;
+    formatModifierNames(modifierBits) {
+        const orderedModifiers = [];
+        if (modifierBits & MODIFIERS.shift)
+            orderedModifiers.push("shift");
+        if (modifierBits & MODIFIERS.ctrl)
+            orderedModifiers.push("ctrl");
+        if (modifierBits & MODIFIERS.alt)
+            orderedModifiers.push("alt");
+        return orderedModifiers;
+    }
+}
+const keyMatcherEngine = new KeyMatchEngine();
+const keyParserEngine = new KeyParseEngine();
+/**
+ * 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"
+ * - Combined modifiers: "shift+ctrl+p", "ctrl+alt+x"
+ *
+ * Use the Key helper for autocomplete: Key.ctrl("c"), Key.escape, Key.ctrlShift("p")
+ *
+ * @param data - Raw input data from terminal
+ * @param keyId - Key identifier (e.g., "ctrl+c", "escape", Key.ctrl("c"))
+ */
+export function matchesKey(data, keyId) {
+    return keyMatcherEngine.matches(data, keyId);
+}
+/**
+ * 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
+ */
+export function parseKey(data) {
+    return keyParserEngine.parse(data);
 }
 //# sourceMappingURL=keys.js.map