@mariozechner/pi-tui 0.32.3 → 0.33.0

package/dist/keybindings.d.ts

@@ -0,0 +1,39 @@
+import { type KeyId } from "./keys.js";
+/**
+ * Editor actions that can be bound to keys.
+ */
+export type EditorAction = "cursorUp" | "cursorDown" | "cursorLeft" | "cursorRight" | "cursorWordLeft" | "cursorWordRight" | "cursorLineStart" | "cursorLineEnd" | "deleteCharBackward" | "deleteCharForward" | "deleteWordBackward" | "deleteToLineStart" | "deleteToLineEnd" | "newLine" | "submit" | "tab" | "selectUp" | "selectDown" | "selectConfirm" | "selectCancel" | "copy";
+export type { KeyId };
+/**
+ * Editor keybindings configuration.
+ */
+export type EditorKeybindingsConfig = {
+    [K in EditorAction]?: KeyId | KeyId[];
+};
+/**
+ * Default editor keybindings.
+ */
+export declare const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig>;
+/**
+ * Manages keybindings for the editor.
+ */
+export declare class EditorKeybindingsManager {
+    private actionToKeys;
+    constructor(config?: EditorKeybindingsConfig);
+    private buildMaps;
+    /**
+     * Check if input matches a specific action.
+     */
+    matches(data: string, action: EditorAction): boolean;
+    /**
+     * Get keys bound to an action.
+     */
+    getKeys(action: EditorAction): KeyId[];
+    /**
+     * Update configuration.
+     */
+    setConfig(config: EditorKeybindingsConfig): void;
+}
+export declare function getEditorKeybindings(): EditorKeybindingsManager;
+export declare function setEditorKeybindings(manager: EditorKeybindingsManager): void;
+//# sourceMappingURL=keybindings.d.ts.map

package/dist/keybindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keybindings.d.ts","sourceRoot":"","sources":["../src/keybindings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAc,MAAM,WAAW,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,YAAY,GAErB,UAAU,GACV,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,gBAAgB,GAChB,iBAAiB,GACjB,iBAAiB,GACjB,eAAe,GAEf,oBAAoB,GACpB,mBAAmB,GACnB,oBAAoB,GACpB,mBAAmB,GACnB,iBAAiB,GAEjB,SAAS,GACT,QAAQ,GACR,KAAK,GAEL,UAAU,GACV,YAAY,GACZ,eAAe,GACf,cAAc,GAEd,MAAM,CAAC;AAGV,YAAY,EAAE,KAAK,EAAE,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;KACpC,CAAC,IAAI,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,EAAE;CACrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,uBAAuB,CA2BxE,CAAC;AAEF;;GAEG;AACH,qBAAa,wBAAwB;IACpC,OAAO,CAAC,YAAY,CAA6B;IAEjD,YAAY,MAAM,GAAE,uBAA4B,EAG/C;IAED,OAAO,CAAC,SAAS;IAiBjB;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAOnD;IAED;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,KAAK,EAAE,CAErC;IAED;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI,CAE/C;CACD;AAKD,wBAAgB,oBAAoB,IAAI,wBAAwB,CAK/D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CAE5E","sourcesContent":["import { type KeyId, matchesKey } from \"./keys.js\";\n\n/**\n * Editor actions that can be bound to keys.\n */\nexport type EditorAction =\n\t// Cursor movement\n\t| \"cursorUp\"\n\t| \"cursorDown\"\n\t| \"cursorLeft\"\n\t| \"cursorRight\"\n\t| \"cursorWordLeft\"\n\t| \"cursorWordRight\"\n\t| \"cursorLineStart\"\n\t| \"cursorLineEnd\"\n\t// Deletion\n\t| \"deleteCharBackward\"\n\t| \"deleteCharForward\"\n\t| \"deleteWordBackward\"\n\t| \"deleteToLineStart\"\n\t| \"deleteToLineEnd\"\n\t// Text input\n\t| \"newLine\"\n\t| \"submit\"\n\t| \"tab\"\n\t// Selection/autocomplete\n\t| \"selectUp\"\n\t| \"selectDown\"\n\t| \"selectConfirm\"\n\t| \"selectCancel\"\n\t// Clipboard\n\t| \"copy\";\n\n// Re-export KeyId from keys.ts\nexport type { KeyId };\n\n/**\n * Editor keybindings configuration.\n */\nexport type EditorKeybindingsConfig = {\n\t[K in EditorAction]?: KeyId | KeyId[];\n};\n\n/**\n * Default editor keybindings.\n */\nexport const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig> = {\n\t// Cursor movement\n\tcursorUp: \"up\",\n\tcursorDown: \"down\",\n\tcursorLeft: \"left\",\n\tcursorRight: \"right\",\n\tcursorWordLeft: [\"alt+left\", \"ctrl+left\"],\n\tcursorWordRight: [\"alt+right\", \"ctrl+right\"],\n\tcursorLineStart: [\"home\", \"ctrl+a\"],\n\tcursorLineEnd: [\"end\", \"ctrl+e\"],\n\t// Deletion\n\tdeleteCharBackward: \"backspace\",\n\tdeleteCharForward: \"delete\",\n\tdeleteWordBackward: [\"ctrl+w\", \"alt+backspace\"],\n\tdeleteToLineStart: \"ctrl+u\",\n\tdeleteToLineEnd: \"ctrl+k\",\n\t// Text input\n\tnewLine: [\"shift+enter\", \"alt+enter\"],\n\tsubmit: \"enter\",\n\ttab: \"tab\",\n\t// Selection/autocomplete\n\tselectUp: \"up\",\n\tselectDown: \"down\",\n\tselectConfirm: \"enter\",\n\tselectCancel: [\"escape\", \"ctrl+c\"],\n\t// Clipboard\n\tcopy: \"ctrl+c\",\n};\n\n/**\n * Manages keybindings for the editor.\n */\nexport class EditorKeybindingsManager {\n\tprivate actionToKeys: Map<EditorAction, KeyId[]>;\n\n\tconstructor(config: EditorKeybindingsConfig = {}) {\n\t\tthis.actionToKeys = new Map();\n\t\tthis.buildMaps(config);\n\t}\n\n\tprivate buildMaps(config: EditorKeybindingsConfig): void {\n\t\tthis.actionToKeys.clear();\n\n\t\t// Start with defaults\n\t\tfor (const [action, keys] of Object.entries(DEFAULT_EDITOR_KEYBINDINGS)) {\n\t\t\tconst keyArray = Array.isArray(keys) ? keys : [keys];\n\t\t\tthis.actionToKeys.set(action as EditorAction, [...keyArray]);\n\t\t}\n\n\t\t// Override with user config\n\t\tfor (const [action, keys] of Object.entries(config)) {\n\t\t\tif (keys === undefined) continue;\n\t\t\tconst keyArray = Array.isArray(keys) ? keys : [keys];\n\t\t\tthis.actionToKeys.set(action as EditorAction, keyArray);\n\t\t}\n\t}\n\n\t/**\n\t * Check if input matches a specific action.\n\t */\n\tmatches(data: string, action: EditorAction): boolean {\n\t\tconst keys = this.actionToKeys.get(action);\n\t\tif (!keys) return false;\n\t\tfor (const key of keys) {\n\t\t\tif (matchesKey(data, key)) return true;\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Get keys bound to an action.\n\t */\n\tgetKeys(action: EditorAction): KeyId[] {\n\t\treturn this.actionToKeys.get(action) ?? [];\n\t}\n\n\t/**\n\t * Update configuration.\n\t */\n\tsetConfig(config: EditorKeybindingsConfig): void {\n\t\tthis.buildMaps(config);\n\t}\n}\n\n// Global instance\nlet globalEditorKeybindings: EditorKeybindingsManager | null = null;\n\nexport function getEditorKeybindings(): EditorKeybindingsManager {\n\tif (!globalEditorKeybindings) {\n\t\tglobalEditorKeybindings = new EditorKeybindingsManager();\n\t}\n\treturn globalEditorKeybindings;\n}\n\nexport function setEditorKeybindings(manager: EditorKeybindingsManager): void {\n\tglobalEditorKeybindings = manager;\n}\n"]}

package/dist/keybindings.js

@@ -0,0 +1,94 @@
+import { matchesKey } from "./keys.js";
+/**
+ * Default editor keybindings.
+ */
+export const DEFAULT_EDITOR_KEYBINDINGS = {
+    // Cursor movement
+    cursorUp: "up",
+    cursorDown: "down",
+    cursorLeft: "left",
+    cursorRight: "right",
+    cursorWordLeft: ["alt+left", "ctrl+left"],
+    cursorWordRight: ["alt+right", "ctrl+right"],
+    cursorLineStart: ["home", "ctrl+a"],
+    cursorLineEnd: ["end", "ctrl+e"],
+    // Deletion
+    deleteCharBackward: "backspace",
+    deleteCharForward: "delete",
+    deleteWordBackward: ["ctrl+w", "alt+backspace"],
+    deleteToLineStart: "ctrl+u",
+    deleteToLineEnd: "ctrl+k",
+    // Text input
+    newLine: ["shift+enter", "alt+enter"],
+    submit: "enter",
+    tab: "tab",
+    // Selection/autocomplete
+    selectUp: "up",
+    selectDown: "down",
+    selectConfirm: "enter",
+    selectCancel: ["escape", "ctrl+c"],
+    // Clipboard
+    copy: "ctrl+c",
+};
+/**
+ * Manages keybindings for the editor.
+ */
+export class EditorKeybindingsManager {
+    actionToKeys;
+    constructor(config = {}) {
+        this.actionToKeys = new Map();
+        this.buildMaps(config);
+    }
+    buildMaps(config) {
+        this.actionToKeys.clear();
+        // Start with defaults
+        for (const [action, keys] of Object.entries(DEFAULT_EDITOR_KEYBINDINGS)) {
+            const keyArray = Array.isArray(keys) ? keys : [keys];
+            this.actionToKeys.set(action, [...keyArray]);
+        }
+        // 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, keyArray);
+        }
+    }
+    /**
+     * Check if input matches a specific action.
+     */
+    matches(data, action) {
+        const keys = this.actionToKeys.get(action);
+        if (!keys)
+            return false;
+        for (const key of keys) {
+            if (matchesKey(data, key))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Get keys bound to an action.
+     */
+    getKeys(action) {
+        return this.actionToKeys.get(action) ?? [];
+    }
+    /**
+     * Update configuration.
+     */
+    setConfig(config) {
+        this.buildMaps(config);
+    }
+}
+// Global instance
+let globalEditorKeybindings = null;
+export function getEditorKeybindings() {
+    if (!globalEditorKeybindings) {
+        globalEditorKeybindings = new EditorKeybindingsManager();
+    }
+    return globalEditorKeybindings;
+}
+export function setEditorKeybindings(manager) {
+    globalEditorKeybindings = manager;
+}
+//# sourceMappingURL=keybindings.js.map

package/dist/keybindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keybindings.js","sourceRoot":"","sources":["../src/keybindings.ts"],"names":[],"mappings":"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","sourcesContent":["import { type KeyId, matchesKey } from \"./keys.js\";\n\n/**\n * Editor actions that can be bound to keys.\n */\nexport type EditorAction =\n\t// Cursor movement\n\t| \"cursorUp\"\n\t| \"cursorDown\"\n\t| \"cursorLeft\"\n\t| \"cursorRight\"\n\t| \"cursorWordLeft\"\n\t| \"cursorWordRight\"\n\t| \"cursorLineStart\"\n\t| \"cursorLineEnd\"\n\t// Deletion\n\t| \"deleteCharBackward\"\n\t| \"deleteCharForward\"\n\t| \"deleteWordBackward\"\n\t| \"deleteToLineStart\"\n\t| \"deleteToLineEnd\"\n\t// Text input\n\t| \"newLine\"\n\t| \"submit\"\n\t| \"tab\"\n\t// Selection/autocomplete\n\t| \"selectUp\"\n\t| \"selectDown\"\n\t| \"selectConfirm\"\n\t| \"selectCancel\"\n\t// Clipboard\n\t| \"copy\";\n\n// Re-export KeyId from keys.ts\nexport type { KeyId };\n\n/**\n * Editor keybindings configuration.\n */\nexport type EditorKeybindingsConfig = {\n\t[K in EditorAction]?: KeyId | KeyId[];\n};\n\n/**\n * Default editor keybindings.\n */\nexport const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig> = {\n\t// Cursor movement\n\tcursorUp: \"up\",\n\tcursorDown: \"down\",\n\tcursorLeft: \"left\",\n\tcursorRight: \"right\",\n\tcursorWordLeft: [\"alt+left\", \"ctrl+left\"],\n\tcursorWordRight: [\"alt+right\", \"ctrl+right\"],\n\tcursorLineStart: [\"home\", \"ctrl+a\"],\n\tcursorLineEnd: [\"end\", \"ctrl+e\"],\n\t// Deletion\n\tdeleteCharBackward: \"backspace\",\n\tdeleteCharForward: \"delete\",\n\tdeleteWordBackward: [\"ctrl+w\", \"alt+backspace\"],\n\tdeleteToLineStart: \"ctrl+u\",\n\tdeleteToLineEnd: \"ctrl+k\",\n\t// Text input\n\tnewLine: [\"shift+enter\", \"alt+enter\"],\n\tsubmit: \"enter\",\n\ttab: \"tab\",\n\t// Selection/autocomplete\n\tselectUp: \"up\",\n\tselectDown: \"down\",\n\tselectConfirm: \"enter\",\n\tselectCancel: [\"escape\", \"ctrl+c\"],\n\t// Clipboard\n\tcopy: \"ctrl+c\",\n};\n\n/**\n * Manages keybindings for the editor.\n */\nexport class EditorKeybindingsManager {\n\tprivate actionToKeys: Map<EditorAction, KeyId[]>;\n\n\tconstructor(config: EditorKeybindingsConfig = {}) {\n\t\tthis.actionToKeys = new Map();\n\t\tthis.buildMaps(config);\n\t}\n\n\tprivate buildMaps(config: EditorKeybindingsConfig): void {\n\t\tthis.actionToKeys.clear();\n\n\t\t// Start with defaults\n\t\tfor (const [action, keys] of Object.entries(DEFAULT_EDITOR_KEYBINDINGS)) {\n\t\t\tconst keyArray = Array.isArray(keys) ? keys : [keys];\n\t\t\tthis.actionToKeys.set(action as EditorAction, [...keyArray]);\n\t\t}\n\n\t\t// Override with user config\n\t\tfor (const [action, keys] of Object.entries(config)) {\n\t\t\tif (keys === undefined) continue;\n\t\t\tconst keyArray = Array.isArray(keys) ? keys : [keys];\n\t\t\tthis.actionToKeys.set(action as EditorAction, keyArray);\n\t\t}\n\t}\n\n\t/**\n\t * Check if input matches a specific action.\n\t */\n\tmatches(data: string, action: EditorAction): boolean {\n\t\tconst keys = this.actionToKeys.get(action);\n\t\tif (!keys) return false;\n\t\tfor (const key of keys) {\n\t\t\tif (matchesKey(data, key)) return true;\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Get keys bound to an action.\n\t */\n\tgetKeys(action: EditorAction): KeyId[] {\n\t\treturn this.actionToKeys.get(action) ?? [];\n\t}\n\n\t/**\n\t * Update configuration.\n\t */\n\tsetConfig(config: EditorKeybindingsConfig): void {\n\t\tthis.buildMaps(config);\n\t}\n}\n\n// Global instance\nlet globalEditorKeybindings: EditorKeybindingsManager | null = null;\n\nexport function getEditorKeybindings(): EditorKeybindingsManager {\n\tif (!globalEditorKeybindings) {\n\t\tglobalEditorKeybindings = new EditorKeybindingsManager();\n\t}\n\treturn globalEditorKeybindings;\n}\n\nexport function setEditorKeybindings(manager: EditorKeybindingsManager): void {\n\tglobalEditorKeybindings = manager;\n}\n"]}

package/dist/keys.d.ts

@@ -1,255 +1,79 @@
 /**
- * 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
+ * Keyboard input handling for terminal applications.
  *
+ * Supports both legacy terminal sequences and Kitty keyboard protocol.
  * 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.
- */
-export declare const Keys: {
-    readonly CTRL_A: string;
-    readonly CTRL_C: string;
-    readonly CTRL_D: string;
-    readonly CTRL_E: string;
-    readonly CTRL_G: string;
-    readonly CTRL_K: string;
-    readonly CTRL_L: string;
-    readonly CTRL_O: string;
-    readonly CTRL_P: string;
-    readonly CTRL_T: string;
-    readonly CTRL_U: string;
-    readonly CTRL_W: string;
-    readonly CTRL_Z: string;
-    readonly SHIFT_ENTER: string;
-    readonly ALT_ENTER: string;
-    readonly CTRL_ENTER: string;
-    readonly SHIFT_TAB: string;
-    readonly ALT_BACKSPACE: string;
-};
-/**
- * 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 declare function isKittyCtrl(data: string, key: string): boolean;
-/**
- * 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 declare function isKittyKey(data: string, codepoint: number, modifier: number): boolean;
-/**
- * Check if input matches Ctrl+A (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlA(data: string): boolean;
-/**
- * Check if input matches Ctrl+C (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlC(data: string): boolean;
-/**
- * Check if input matches Ctrl+D (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlD(data: string): boolean;
-/**
- * Check if input matches Ctrl+E (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlE(data: string): boolean;
-/**
- * Check if input matches Ctrl+G (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlG(data: string): boolean;
-/**
- * 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 declare function isCtrlK(data: string): boolean;
-/**
- * Check if input matches Ctrl+L (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlL(data: string): boolean;
-/**
- * Check if input matches Ctrl+O (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlO(data: string): boolean;
-/**
- * Check if input matches Shift+Ctrl+O (Kitty protocol only).
- * Ignores lock key bits.
- */
-export declare function isShiftCtrlO(data: string): boolean;
-/**
- * Check if input matches Ctrl+P (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlP(data: string): boolean;
-/**
- * Check if input matches Shift+Ctrl+P (Kitty protocol only).
- * Ignores lock key bits.
- */
-export declare function isShiftCtrlP(data: string): boolean;
-/**
- * Check if input matches Shift+Ctrl+D (Kitty protocol only, for debug).
- * Ignores lock key bits.
- */
-export declare function isShiftCtrlD(data: string): boolean;
-/**
- * Check if input matches Ctrl+T (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlT(data: string): boolean;
-/**
- * Check if input matches Ctrl+U (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlU(data: string): boolean;
-/**
- * Check if input matches Ctrl+W (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlW(data: string): boolean;
-/**
- * Check if input matches Ctrl+Z (raw byte or Kitty protocol).
- * Ignores lock key bits.
- */
-export declare function isCtrlZ(data: string): boolean;
-/**
- * Check if input matches Alt+Backspace (legacy or Kitty protocol).
- * Ignores lock key bits.
+ * 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
  */
-export declare function isAltBackspace(data: string): boolean;
+type Letter = "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";
+type SpecialKey = "escape" | "esc" | "enter" | "return" | "tab" | "space" | "backspace" | "delete" | "home" | "end" | "up" | "down" | "left" | "right";
+type BaseKey = Letter | SpecialKey;
 /**
- * Check if input matches Shift+Tab (legacy or Kitty protocol).
- * Ignores lock key bits.
+ * Union type of all valid key identifiers.
+ * Provides autocomplete and catches typos at compile time.
  */
-export declare function isShiftTab(data: string): boolean;
+export type KeyId = BaseKey | `ctrl+${BaseKey}` | `shift+${BaseKey}` | `alt+${BaseKey}` | `ctrl+shift+${BaseKey}` | `shift+ctrl+${BaseKey}` | `ctrl+alt+${BaseKey}` | `alt+ctrl+${BaseKey}` | `shift+alt+${BaseKey}` | `alt+shift+${BaseKey}` | `ctrl+shift+alt+${BaseKey}` | `ctrl+alt+shift+${BaseKey}` | `shift+ctrl+alt+${BaseKey}` | `shift+alt+ctrl+${BaseKey}` | `alt+ctrl+shift+${BaseKey}` | `alt+shift+ctrl+${BaseKey}`;
 /**
- * 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 declare function isEscape(data: string): boolean;
-/**
- * Check if input matches Arrow Up key.
- * Handles both legacy (\x1b[A) and Kitty protocol with modifiers.
- */
-export declare function isArrowUp(data: string): boolean;
-/**
- * Check if input matches Arrow Down key.
- * Handles both legacy (\x1b[B) and Kitty protocol with modifiers.
- */
-export declare function isArrowDown(data: string): boolean;
-/**
- * Check if input matches Arrow Right key.
- * Handles both legacy (\x1b[C) and Kitty protocol with modifiers.
- */
-export declare function isArrowRight(data: string): boolean;
-/**
- * Check if input matches Arrow Left key.
- * Handles both legacy (\x1b[D) and Kitty protocol with modifiers.
- */
-export declare function isArrowLeft(data: string): boolean;
-/**
- * Check if input matches plain Tab key (no modifiers).
- * Handles both legacy (\t) and Kitty protocol.
- */
-export declare function isTab(data: string): boolean;
-/**
- * Check if input matches plain Enter/Return key (no modifiers).
- * Handles both legacy (\r) and Kitty protocol.
- */
-export declare function isEnter(data: string): boolean;
-/**
- * Check if input matches plain Backspace key (no modifiers).
- * Handles both legacy (\x7f, \x08) and Kitty protocol.
- */
-export declare function isBackspace(data: string): boolean;
-/**
- * Check if input matches Shift+Backspace (Kitty protocol).
- * Returns true so caller can treat it as regular backspace.
- * Ignores lock key bits.
- */
-export declare function isShiftBackspace(data: string): boolean;
-/**
- * Check if input matches Shift+Enter.
- * Ignores lock key bits.
- */
-export declare function isShiftEnter(data: string): boolean;
-/**
- * Check if input matches Alt+Enter.
- * Ignores lock key bits.
- */
-export declare function isAltEnter(data: string): boolean;
-/**
- * Check if input matches Shift+Space (Kitty protocol).
- * Returns true so caller can insert a regular space.
- * Ignores lock key bits.
- */
-export declare function isShiftSpace(data: string): boolean;
-/**
- * Check if input matches Option/Alt+Left (word navigation).
- * Handles multiple formats including Kitty protocol.
- */
-export declare function isAltLeft(data: string): boolean;
-/**
- * Check if input matches Option/Alt+Right (word navigation).
- * Handles multiple formats including Kitty protocol.
- */
-export declare function isAltRight(data: string): boolean;
-/**
- * Check if input matches Ctrl+Left (word navigation).
- * Handles multiple formats including Kitty protocol.
- */
-export declare function isCtrlLeft(data: string): boolean;
-/**
- * Check if input matches Ctrl+Right (word navigation).
- * Handles multiple formats including Kitty protocol.
- */
-export declare function isCtrlRight(data: string): boolean;
-/**
- * Check if input matches Home key.
- * Handles legacy formats and Kitty protocol with lock key modifiers.
- */
-export declare function isHome(data: string): boolean;
-/**
- * Check if input matches End key.
- * Handles legacy formats and Kitty protocol with lock key modifiers.
- */
-export declare function isEnd(data: string): boolean;
+ * Helper object for creating typed key identifiers with autocomplete.
+ *
+ * Usage:
+ * - Key.escape, Key.enter, Key.tab, etc. for special keys
+ * - Key.ctrl("c"), Key.alt("x") for single modifier
+ * - Key.ctrlShift("p"), Key.ctrlAlt("x") for combined modifiers
+ */
+export declare const Key: {
+    readonly escape: "escape";
+    readonly esc: "esc";
+    readonly enter: "enter";
+    readonly return: "return";
+    readonly tab: "tab";
+    readonly space: "space";
+    readonly backspace: "backspace";
+    readonly delete: "delete";
+    readonly home: "home";
+    readonly end: "end";
+    readonly up: "up";
+    readonly down: "down";
+    readonly left: "left";
+    readonly right: "right";
+    readonly ctrl: <K extends BaseKey>(key: K) => `ctrl+${K}`;
+    readonly shift: <K extends BaseKey>(key: K) => `shift+${K}`;
+    readonly alt: <K extends BaseKey>(key: K) => `alt+${K}`;
+    readonly ctrlShift: <K extends BaseKey>(key: K) => `ctrl+shift+${K}`;
+    readonly shiftCtrl: <K extends BaseKey>(key: K) => `shift+ctrl+${K}`;
+    readonly ctrlAlt: <K extends BaseKey>(key: K) => `ctrl+alt+${K}`;
+    readonly altCtrl: <K extends BaseKey>(key: K) => `alt+ctrl+${K}`;
+    readonly shiftAlt: <K extends BaseKey>(key: K) => `shift+alt+${K}`;
+    readonly altShift: <K extends BaseKey>(key: K) => `alt+shift+${K}`;
+    readonly ctrlShiftAlt: <K extends BaseKey>(key: K) => `ctrl+shift+alt+${K}`;
+};
 /**
- * Check if input matches Delete key (forward delete).
- * Handles legacy format and Kitty protocol with lock key modifiers.
+ * 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 declare function isDelete(data: string): boolean;
+export declare function matchesKey(data: string, keyId: KeyId): boolean;
 /**
- * Check if input matches Shift+Delete (Kitty protocol).
- * Returns true so caller can treat it as regular delete.
- * Ignores lock key bits.
+ * 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 declare function isShiftDelete(data: string): boolean;
+export declare function parseKey(data: string): string | undefined;
+export {};
 //# sourceMappingURL=keys.d.ts.map

package/dist/keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Kitty keyboard protocol key sequence helpers.\n *\n * The Kitty keyboard protocol sends enhanced escape sequences in the format:\n *   \\x1b[<codepoint>;<modifier>u\n *\n * Modifier bits (before adding 1 for transmission):\n *   - Shift: 1 (value 2)\n *   - Alt: 2 (value 3)\n *   - Ctrl: 4 (value 5)\n *   - Super: 8 (value 9)\n *   - Hyper: 16\n *   - Meta: 32\n *   - Caps_Lock: 64\n *   - Num_Lock: 128\n *\n * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/\n *\n * NOTE: Some terminals (e.g., Ghostty on Linux) include lock key states\n * (Caps Lock, Num Lock) in the modifier field. We mask these out when\n * checking for key combinations since they shouldn't affect behavior.\n */\n\n// Common codepoints\nconst CODEPOINTS = {\n\t// Letters (lowercase ASCII)\n\ta: 97,\n\tc: 99,\n\td: 100,\n\te: 101,\n\tg: 103,\n\tk: 107,\n\tl: 108,\n\to: 111,\n\tp: 112,\n\tt: 116,\n\tu: 117,\n\tw: 119,\n\tz: 122,\n\n\t// Special keys\n\tescape: 27,\n\ttab: 9,\n\tenter: 13,\n\tspace: 32,\n\tbackspace: 127,\n} as const;\n\n// Lock key bits to ignore when matching (Caps Lock + Num Lock)\nconst LOCK_MASK = 64 + 128; // 192\n\n// Modifier bits (before adding 1)\nconst MODIFIERS = {\n\tshift: 1,\n\talt: 2,\n\tctrl: 4,\n\tsuper: 8,\n} as const;\n\n/**\n * Build a Kitty keyboard protocol sequence for a key with modifier.\n */\nfunction kittySequence(codepoint: number, modifier: number): string {\n\treturn `\\x1b[${codepoint};${modifier + 1}u`;\n}\n\n/**\n * Parsed Kitty keyboard protocol sequence.\n */\ninterface ParsedKittySequence {\n\tcodepoint: number;\n\tmodifier: number; // Actual modifier bits (after subtracting 1)\n}\n\n/**\n * Parse a Kitty keyboard protocol sequence.\n * Handles formats:\n *   - \\x1b[<codepoint>u (no modifier)\n *   - \\x1b[<codepoint>;<modifier>u (with modifier)\n *   - \\x1b[1;<modifier>A/B/C/D (arrow keys with modifier)\n *\n * Returns null if not a valid Kitty sequence.\n */\n// Virtual codepoints for functional keys (negative to avoid conflicts)\nconst FUNCTIONAL_CODEPOINTS = {\n\tdelete: -10,\n\tinsert: -11,\n\tpageUp: -12,\n\tpageDown: -13,\n\thome: -14,\n\tend: -15,\n} as const;\n\nfunction parseKittySequence(data: string): ParsedKittySequence | null {\n\t// Match CSI u format: \\x1b[<num>u or \\x1b[<num>;<mod>u\n\tconst csiUMatch = data.match(/^\\x1b\\[(\\d+)(?:;(\\d+))?u$/);\n\tif (csiUMatch) {\n\t\tconst codepoint = parseInt(csiUMatch[1]!, 10);\n\t\tconst modValue = csiUMatch[2] ? parseInt(csiUMatch[2], 10) : 1;\n\t\treturn { codepoint, modifier: modValue - 1 };\n\t}\n\n\t// Match arrow keys with modifier: \\x1b[1;<mod>A/B/C/D\n\tconst arrowMatch = data.match(/^\\x1b\\[1;(\\d+)([ABCD])$/);\n\tif (arrowMatch) {\n\t\tconst modValue = parseInt(arrowMatch[1]!, 10);\n\t\t// Map arrow letters to virtual codepoints for easier matching\n\t\tconst arrowCodes: Record<string, number> = { A: -1, B: -2, C: -3, D: -4 };\n\t\tconst codepoint = arrowCodes[arrowMatch[2]!]!;\n\t\treturn { codepoint, modifier: modValue - 1 };\n\t}\n\n\t// Match functional keys with ~ terminator: \\x1b[<num>~ or \\x1b[<num>;<mod>~\n\t// DELETE=3, INSERT=2, PAGEUP=5, PAGEDOWN=6, etc.\n\tconst funcMatch = data.match(/^\\x1b\\[(\\d+)(?:;(\\d+))?~$/);\n\tif (funcMatch) {\n\t\tconst keyNum = parseInt(funcMatch[1]!, 10);\n\t\tconst modValue = funcMatch[2] ? parseInt(funcMatch[2], 10) : 1;\n\t\t// Map functional key numbers to virtual codepoints\n\t\tconst funcCodes: Record<number, number> = {\n\t\t\t2: FUNCTIONAL_CODEPOINTS.insert,\n\t\t\t3: FUNCTIONAL_CODEPOINTS.delete,\n\t\t\t5: FUNCTIONAL_CODEPOINTS.pageUp,\n\t\t\t6: FUNCTIONAL_CODEPOINTS.pageDown,\n\t\t\t7: FUNCTIONAL_CODEPOINTS.home, // Alternative home\n\t\t\t8: FUNCTIONAL_CODEPOINTS.end, // Alternative end\n\t\t};\n\t\tconst codepoint = funcCodes[keyNum];\n\t\tif (codepoint !== undefined) {\n\t\t\treturn { codepoint, modifier: modValue - 1 };\n\t\t}\n\t}\n\n\t// Match Home/End with modifier: \\x1b[1;<mod>H/F\n\tconst homeEndMatch = data.match(/^\\x1b\\[1;(\\d+)([HF])$/);\n\tif (homeEndMatch) {\n\t\tconst modValue = parseInt(homeEndMatch[1]!, 10);\n\t\tconst codepoint = homeEndMatch[2] === \"H\" ? FUNCTIONAL_CODEPOINTS.home : FUNCTIONAL_CODEPOINTS.end;\n\t\treturn { codepoint, modifier: modValue - 1 };\n\t}\n\n\treturn null;\n}\n\n/**\n * Check if a Kitty sequence matches the expected codepoint and modifier,\n * ignoring lock key bits (Caps Lock, Num Lock).\n */\nfunction matchesKittySequence(data: string, expectedCodepoint: number, expectedModifier: number): boolean {\n\tconst parsed = parseKittySequence(data);\n\tif (!parsed) return false;\n\n\t// Mask out lock bits from both sides for comparison\n\tconst actualMod = parsed.modifier & ~LOCK_MASK;\n\tconst expectedMod = expectedModifier & ~LOCK_MASK;\n\n\treturn parsed.codepoint === expectedCodepoint && actualMod === expectedMod;\n}\n\n// Pre-built sequences for common key combinations\nexport const Keys = {\n\t// Ctrl+<letter> combinations\n\tCTRL_A: kittySequence(CODEPOINTS.a, MODIFIERS.ctrl),\n\tCTRL_C: kittySequence(CODEPOINTS.c, MODIFIERS.ctrl),\n\tCTRL_D: kittySequence(CODEPOINTS.d, MODIFIERS.ctrl),\n\tCTRL_E: kittySequence(CODEPOINTS.e, MODIFIERS.ctrl),\n\tCTRL_G: kittySequence(CODEPOINTS.g, MODIFIERS.ctrl),\n\tCTRL_K: kittySequence(CODEPOINTS.k, MODIFIERS.ctrl),\n\tCTRL_L: kittySequence(CODEPOINTS.l, MODIFIERS.ctrl),\n\tCTRL_O: kittySequence(CODEPOINTS.o, MODIFIERS.ctrl),\n\tCTRL_P: kittySequence(CODEPOINTS.p, MODIFIERS.ctrl),\n\tCTRL_T: kittySequence(CODEPOINTS.t, MODIFIERS.ctrl),\n\tCTRL_U: kittySequence(CODEPOINTS.u, MODIFIERS.ctrl),\n\tCTRL_W: kittySequence(CODEPOINTS.w, MODIFIERS.ctrl),\n\tCTRL_Z: kittySequence(CODEPOINTS.z, MODIFIERS.ctrl),\n\n\t// Enter combinations\n\tSHIFT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.shift),\n\tALT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.alt),\n\tCTRL_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.ctrl),\n\n\t// Tab combinations\n\tSHIFT_TAB: kittySequence(CODEPOINTS.tab, MODIFIERS.shift),\n\n\t// Backspace combinations\n\tALT_BACKSPACE: kittySequence(CODEPOINTS.backspace, MODIFIERS.alt),\n} as const;\n\n/**\n * Check if input matches a Kitty protocol Ctrl+<key> sequence.\n * Ignores lock key bits (Caps Lock, Num Lock).\n * @param data - The input data to check\n * @param key - Single lowercase letter (e.g., 'c' for Ctrl+C)\n */\nexport function isKittyCtrl(data: string, key: string): boolean {\n\tif (key.length !== 1) return false;\n\tconst codepoint = key.charCodeAt(0);\n\t// Check exact match first (fast path)\n\tif (data === kittySequence(codepoint, MODIFIERS.ctrl)) return true;\n\t// Check with lock bits masked out\n\treturn matchesKittySequence(data, codepoint, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches a Kitty protocol key sequence with specific modifier.\n * Ignores lock key bits (Caps Lock, Num Lock).\n * @param data - The input data to check\n * @param codepoint - ASCII codepoint of the key\n * @param modifier - Modifier value (use MODIFIERS constants)\n */\nexport function isKittyKey(data: string, codepoint: number, modifier: number): boolean {\n\t// Check exact match first (fast path)\n\tif (data === kittySequence(codepoint, modifier)) return true;\n\t// Check with lock bits masked out\n\treturn matchesKittySequence(data, codepoint, modifier);\n}\n\n// Raw control character codes\nconst RAW = {\n\tCTRL_A: \"\\x01\",\n\tCTRL_C: \"\\x03\",\n\tCTRL_D: \"\\x04\",\n\tCTRL_E: \"\\x05\",\n\tCTRL_G: \"\\x07\",\n\tCTRL_K: \"\\x0b\",\n\tCTRL_L: \"\\x0c\",\n\tCTRL_O: \"\\x0f\",\n\tCTRL_P: \"\\x10\",\n\tCTRL_T: \"\\x14\",\n\tCTRL_U: \"\\x15\",\n\tCTRL_W: \"\\x17\",\n\tCTRL_Z: \"\\x1a\",\n\tALT_BACKSPACE: \"\\x1b\\x7f\",\n\tSHIFT_TAB: \"\\x1b[Z\",\n} as const;\n\n/**\n * Check if input matches Ctrl+A (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlA(data: string): boolean {\n\treturn data === RAW.CTRL_A || data === Keys.CTRL_A || matchesKittySequence(data, CODEPOINTS.a, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+C (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlC(data: string): boolean {\n\treturn data === RAW.CTRL_C || data === Keys.CTRL_C || matchesKittySequence(data, CODEPOINTS.c, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+D (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlD(data: string): boolean {\n\treturn data === RAW.CTRL_D || data === Keys.CTRL_D || matchesKittySequence(data, CODEPOINTS.d, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+E (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlE(data: string): boolean {\n\treturn data === RAW.CTRL_E || data === Keys.CTRL_E || matchesKittySequence(data, CODEPOINTS.e, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+G (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlG(data: string): boolean {\n\treturn data === RAW.CTRL_G || data === Keys.CTRL_G || matchesKittySequence(data, CODEPOINTS.g, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+K (raw byte or Kitty protocol).\n * Ignores lock key bits.\n * Also checks if first byte is 0x0b for compatibility with terminals\n * that may send trailing bytes.\n */\nexport function isCtrlK(data: string): boolean {\n\treturn (\n\t\tdata === RAW.CTRL_K ||\n\t\t(data.length > 0 && data.charCodeAt(0) === 0x0b) ||\n\t\tdata === Keys.CTRL_K ||\n\t\tmatchesKittySequence(data, CODEPOINTS.k, MODIFIERS.ctrl)\n\t);\n}\n\n/**\n * Check if input matches Ctrl+L (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlL(data: string): boolean {\n\treturn data === RAW.CTRL_L || data === Keys.CTRL_L || matchesKittySequence(data, CODEPOINTS.l, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+O (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlO(data: string): boolean {\n\treturn data === RAW.CTRL_O || data === Keys.CTRL_O || matchesKittySequence(data, CODEPOINTS.o, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Shift+Ctrl+O (Kitty protocol only).\n * Ignores lock key bits.\n */\nexport function isShiftCtrlO(data: string): boolean {\n\treturn matchesKittySequence(data, CODEPOINTS.o, MODIFIERS.shift + MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+P (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlP(data: string): boolean {\n\treturn data === RAW.CTRL_P || data === Keys.CTRL_P || matchesKittySequence(data, CODEPOINTS.p, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Shift+Ctrl+P (Kitty protocol only).\n * Ignores lock key bits.\n */\nexport function isShiftCtrlP(data: string): boolean {\n\treturn matchesKittySequence(data, CODEPOINTS.p, MODIFIERS.shift + MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Shift+Ctrl+D (Kitty protocol only, for debug).\n * Ignores lock key bits.\n */\nexport function isShiftCtrlD(data: string): boolean {\n\treturn matchesKittySequence(data, CODEPOINTS.d, MODIFIERS.shift + MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+T (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlT(data: string): boolean {\n\treturn data === RAW.CTRL_T || data === Keys.CTRL_T || matchesKittySequence(data, CODEPOINTS.t, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+U (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlU(data: string): boolean {\n\treturn data === RAW.CTRL_U || data === Keys.CTRL_U || matchesKittySequence(data, CODEPOINTS.u, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+W (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlW(data: string): boolean {\n\treturn data === RAW.CTRL_W || data === Keys.CTRL_W || matchesKittySequence(data, CODEPOINTS.w, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+Z (raw byte or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isCtrlZ(data: string): boolean {\n\treturn data === RAW.CTRL_Z || data === Keys.CTRL_Z || matchesKittySequence(data, CODEPOINTS.z, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Alt+Backspace (legacy or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isAltBackspace(data: string): boolean {\n\treturn (\n\t\tdata === RAW.ALT_BACKSPACE ||\n\t\tdata === Keys.ALT_BACKSPACE ||\n\t\tmatchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt)\n\t);\n}\n\n/**\n * Check if input matches Shift+Tab (legacy or Kitty protocol).\n * Ignores lock key bits.\n */\nexport function isShiftTab(data: string): boolean {\n\treturn (\n\t\tdata === RAW.SHIFT_TAB || data === Keys.SHIFT_TAB || matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift)\n\t);\n}\n\n/**\n * Check if input matches the Escape key (raw byte or Kitty protocol).\n * Raw: \\x1b (single byte)\n * Kitty: \\x1b[27u (codepoint 27 = escape)\n * Ignores lock key bits.\n */\nexport function isEscape(data: string): boolean {\n\treturn data === \"\\x1b\" || data === `\\x1b[${CODEPOINTS.escape}u` || matchesKittySequence(data, CODEPOINTS.escape, 0);\n}\n\n// Arrow key virtual codepoints (negative to avoid conflicts with real codepoints)\nconst ARROW_CODEPOINTS = {\n\tup: -1,\n\tdown: -2,\n\tright: -3,\n\tleft: -4,\n} as const;\n\n/**\n * Check if input matches Arrow Up key.\n * Handles both legacy (\\x1b[A) and Kitty protocol with modifiers.\n */\nexport function isArrowUp(data: string): boolean {\n\treturn data === \"\\x1b[A\" || matchesKittySequence(data, ARROW_CODEPOINTS.up, 0);\n}\n\n/**\n * Check if input matches Arrow Down key.\n * Handles both legacy (\\x1b[B) and Kitty protocol with modifiers.\n */\nexport function isArrowDown(data: string): boolean {\n\treturn data === \"\\x1b[B\" || matchesKittySequence(data, ARROW_CODEPOINTS.down, 0);\n}\n\n/**\n * Check if input matches Arrow Right key.\n * Handles both legacy (\\x1b[C) and Kitty protocol with modifiers.\n */\nexport function isArrowRight(data: string): boolean {\n\treturn data === \"\\x1b[C\" || matchesKittySequence(data, ARROW_CODEPOINTS.right, 0);\n}\n\n/**\n * Check if input matches Arrow Left key.\n * Handles both legacy (\\x1b[D) and Kitty protocol with modifiers.\n */\nexport function isArrowLeft(data: string): boolean {\n\treturn data === \"\\x1b[D\" || matchesKittySequence(data, ARROW_CODEPOINTS.left, 0);\n}\n\n/**\n * Check if input matches plain Tab key (no modifiers).\n * Handles both legacy (\\t) and Kitty protocol.\n */\nexport function isTab(data: string): boolean {\n\treturn data === \"\\t\" || matchesKittySequence(data, CODEPOINTS.tab, 0);\n}\n\n/**\n * Check if input matches plain Enter/Return key (no modifiers).\n * Handles both legacy (\\r) and Kitty protocol.\n */\nexport function isEnter(data: string): boolean {\n\treturn data === \"\\r\" || matchesKittySequence(data, CODEPOINTS.enter, 0);\n}\n\n/**\n * Check if input matches plain Backspace key (no modifiers).\n * Handles both legacy (\\x7f, \\x08) and Kitty protocol.\n */\nexport function isBackspace(data: string): boolean {\n\treturn data === \"\\x7f\" || data === \"\\x08\" || matchesKittySequence(data, CODEPOINTS.backspace, 0);\n}\n\n/**\n * Check if input matches Shift+Backspace (Kitty protocol).\n * Returns true so caller can treat it as regular backspace.\n * Ignores lock key bits.\n */\nexport function isShiftBackspace(data: string): boolean {\n\treturn matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.shift);\n}\n\n/**\n * Check if input matches Shift+Enter.\n * Ignores lock key bits.\n */\nexport function isShiftEnter(data: string): boolean {\n\treturn data === Keys.SHIFT_ENTER || matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift);\n}\n\n/**\n * Check if input matches Alt+Enter.\n * Ignores lock key bits.\n */\nexport function isAltEnter(data: string): boolean {\n\treturn data === Keys.ALT_ENTER || data === \"\\x1b\\r\" || matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt);\n}\n\n/**\n * Check if input matches Shift+Space (Kitty protocol).\n * Returns true so caller can insert a regular space.\n * Ignores lock key bits.\n */\nexport function isShiftSpace(data: string): boolean {\n\treturn matchesKittySequence(data, CODEPOINTS.space, MODIFIERS.shift);\n}\n\n/**\n * Check if input matches Option/Alt+Left (word navigation).\n * Handles multiple formats including Kitty protocol.\n */\nexport function isAltLeft(data: string): boolean {\n\treturn data === \"\\x1b[1;3D\" || data === \"\\x1bb\" || matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt);\n}\n\n/**\n * Check if input matches Option/Alt+Right (word navigation).\n * Handles multiple formats including Kitty protocol.\n */\nexport function isAltRight(data: string): boolean {\n\treturn data === \"\\x1b[1;3C\" || data === \"\\x1bf\" || matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt);\n}\n\n/**\n * Check if input matches Ctrl+Left (word navigation).\n * Handles multiple formats including Kitty protocol.\n */\nexport function isCtrlLeft(data: string): boolean {\n\treturn data === \"\\x1b[1;5D\" || matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Ctrl+Right (word navigation).\n * Handles multiple formats including Kitty protocol.\n */\nexport function isCtrlRight(data: string): boolean {\n\treturn data === \"\\x1b[1;5C\" || matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl);\n}\n\n/**\n * Check if input matches Home key.\n * Handles legacy formats and Kitty protocol with lock key modifiers.\n */\nexport function isHome(data: string): boolean {\n\treturn (\n\t\tdata === \"\\x1b[H\" ||\n\t\tdata === \"\\x1b[1~\" ||\n\t\tdata === \"\\x1b[7~\" ||\n\t\tmatchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, 0)\n\t);\n}\n\n/**\n * Check if input matches End key.\n * Handles legacy formats and Kitty protocol with lock key modifiers.\n */\nexport function isEnd(data: string): boolean {\n\treturn (\n\t\tdata === \"\\x1b[F\" ||\n\t\tdata === \"\\x1b[4~\" ||\n\t\tdata === \"\\x1b[8~\" ||\n\t\tmatchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, 0)\n\t);\n}\n\n/**\n * Check if input matches Delete key (forward delete).\n * Handles legacy format and Kitty protocol with lock key modifiers.\n */\nexport function isDelete(data: string): boolean {\n\treturn data === \"\\x1b[3~\" || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, 0);\n}\n\n/**\n * Check if input matches Shift+Delete (Kitty protocol).\n * Returns true so caller can treat it as regular delete.\n * Ignores lock key bits.\n */\nexport function isShiftDelete(data: string): boolean {\n\treturn matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, MODIFIERS.shift);\n}\n"]}
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,KAAK,MAAM,GACR,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,CAAC;AAEP,KAAK,UAAU,GACZ,QAAQ,GACR,KAAK,GACL,OAAO,GACP,QAAQ,GACR,KAAK,GACL,OAAO,GACP,WAAW,GACX,QAAQ,GACR,MAAM,GACN,KAAK,GACL,IAAI,GACJ,MAAM,GACN,MAAM,GACN,OAAO,CAAC;AAEX,KAAK,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC;AAEnC;;;GAGG;AACH,MAAM,MAAM,KAAK,GACd,OAAO,GACP,QAAQ,OAAO,EAAE,GACjB,SAAS,OAAO,EAAE,GAClB,OAAO,OAAO,EAAE,GAChB,cAAc,OAAO,EAAE,GACvB,cAAc,OAAO,EAAE,GACvB,YAAY,OAAO,EAAE,GACrB,YAAY,OAAO,EAAE,GACrB,aAAa,OAAO,EAAE,GACtB,aAAa,OAAO,EAAE,GACtB,kBAAkB,OAAO,EAAE,GAC3B,kBAAkB,OAAO,EAAE,GAC3B,kBAAkB,OAAO,EAAE,GAC3B,kBAAkB,OAAO,EAAE,GAC3B,kBAAkB,OAAO,EAAE,GAC3B,kBAAkB,OAAO,EAAE,CAAC;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;oBAkBR,CAAC;qBACA,CAAC;mBACH,CAAC;yBAGK,CAAC;yBACD,CAAC;uBACH,CAAC;uBACD,CAAC;wBACA,CAAC;wBACD,CAAC;4BAGG,CAAC;CACP,CAAC;AA4HX;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAoK9D;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA2DzD","sourcesContent":["/**\n * Keyboard input handling for terminal applications.\n *\n * Supports both legacy terminal sequences and Kitty keyboard protocol.\n * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/\n *\n * API:\n * - matchesKey(data, keyId) - Check if input matches a key identifier\n * - parseKey(data) - Parse input and return the key identifier\n * - Key - Helper object for creating typed key identifiers\n */\n\n// =============================================================================\n// Type-Safe Key Identifiers\n// =============================================================================\n\ntype Letter =\n\t| \"a\"\n\t| \"b\"\n\t| \"c\"\n\t| \"d\"\n\t| \"e\"\n\t| \"f\"\n\t| \"g\"\n\t| \"h\"\n\t| \"i\"\n\t| \"j\"\n\t| \"k\"\n\t| \"l\"\n\t| \"m\"\n\t| \"n\"\n\t| \"o\"\n\t| \"p\"\n\t| \"q\"\n\t| \"r\"\n\t| \"s\"\n\t| \"t\"\n\t| \"u\"\n\t| \"v\"\n\t| \"w\"\n\t| \"x\"\n\t| \"y\"\n\t| \"z\";\n\ntype SpecialKey =\n\t| \"escape\"\n\t| \"esc\"\n\t| \"enter\"\n\t| \"return\"\n\t| \"tab\"\n\t| \"space\"\n\t| \"backspace\"\n\t| \"delete\"\n\t| \"home\"\n\t| \"end\"\n\t| \"up\"\n\t| \"down\"\n\t| \"left\"\n\t| \"right\";\n\ntype BaseKey = Letter | SpecialKey;\n\n/**\n * Union type of all valid key identifiers.\n * Provides autocomplete and catches typos at compile time.\n */\nexport type KeyId =\n\t| BaseKey\n\t| `ctrl+${BaseKey}`\n\t| `shift+${BaseKey}`\n\t| `alt+${BaseKey}`\n\t| `ctrl+shift+${BaseKey}`\n\t| `shift+ctrl+${BaseKey}`\n\t| `ctrl+alt+${BaseKey}`\n\t| `alt+ctrl+${BaseKey}`\n\t| `shift+alt+${BaseKey}`\n\t| `alt+shift+${BaseKey}`\n\t| `ctrl+shift+alt+${BaseKey}`\n\t| `ctrl+alt+shift+${BaseKey}`\n\t| `shift+ctrl+alt+${BaseKey}`\n\t| `shift+alt+ctrl+${BaseKey}`\n\t| `alt+ctrl+shift+${BaseKey}`\n\t| `alt+shift+ctrl+${BaseKey}`;\n\n/**\n * Helper object for creating typed key identifiers with autocomplete.\n *\n * Usage:\n * - Key.escape, Key.enter, Key.tab, etc. for special keys\n * - Key.ctrl(\"c\"), Key.alt(\"x\") for single modifier\n * - Key.ctrlShift(\"p\"), Key.ctrlAlt(\"x\") for combined modifiers\n */\nexport const Key = {\n\t// Special keys\n\tescape: \"escape\" as const,\n\tesc: \"esc\" as const,\n\tenter: \"enter\" as const,\n\treturn: \"return\" as const,\n\ttab: \"tab\" as const,\n\tspace: \"space\" as const,\n\tbackspace: \"backspace\" as const,\n\tdelete: \"delete\" as const,\n\thome: \"home\" as const,\n\tend: \"end\" as const,\n\tup: \"up\" as const,\n\tdown: \"down\" as const,\n\tleft: \"left\" as const,\n\tright: \"right\" as const,\n\n\t// Single modifiers\n\tctrl: <K extends BaseKey>(key: K): `ctrl+${K}` => `ctrl+${key}`,\n\tshift: <K extends BaseKey>(key: K): `shift+${K}` => `shift+${key}`,\n\talt: <K extends BaseKey>(key: K): `alt+${K}` => `alt+${key}`,\n\n\t// Combined modifiers\n\tctrlShift: <K extends BaseKey>(key: K): `ctrl+shift+${K}` => `ctrl+shift+${key}`,\n\tshiftCtrl: <K extends BaseKey>(key: K): `shift+ctrl+${K}` => `shift+ctrl+${key}`,\n\tctrlAlt: <K extends BaseKey>(key: K): `ctrl+alt+${K}` => `ctrl+alt+${key}`,\n\taltCtrl: <K extends BaseKey>(key: K): `alt+ctrl+${K}` => `alt+ctrl+${key}`,\n\tshiftAlt: <K extends BaseKey>(key: K): `shift+alt+${K}` => `shift+alt+${key}`,\n\taltShift: <K extends BaseKey>(key: K): `alt+shift+${K}` => `alt+shift+${key}`,\n\n\t// Triple modifiers\n\tctrlShiftAlt: <K extends BaseKey>(key: K): `ctrl+shift+alt+${K}` => `ctrl+shift+alt+${key}`,\n} as const;\n\n// =============================================================================\n// Constants\n// =============================================================================\n\nconst MODIFIERS = {\n\tshift: 1,\n\talt: 2,\n\tctrl: 4,\n} as const;\n\nconst LOCK_MASK = 64 + 128; // Caps Lock + Num Lock\n\nconst CODEPOINTS = {\n\tescape: 27,\n\ttab: 9,\n\tenter: 13,\n\tspace: 32,\n\tbackspace: 127,\n\tkpEnter: 57414, // Numpad Enter (Kitty protocol)\n} as const;\n\nconst ARROW_CODEPOINTS = {\n\tup: -1,\n\tdown: -2,\n\tright: -3,\n\tleft: -4,\n} as const;\n\nconst FUNCTIONAL_CODEPOINTS = {\n\tdelete: -10,\n\tinsert: -11,\n\tpageUp: -12,\n\tpageDown: -13,\n\thome: -14,\n\tend: -15,\n} as const;\n\n// =============================================================================\n// Kitty Protocol Parsing\n// =============================================================================\n\ninterface ParsedKittySequence {\n\tcodepoint: number;\n\tmodifier: number;\n}\n\nfunction parseKittySequence(data: string): ParsedKittySequence | null {\n\t// CSI u format: \\x1b[<num>u or \\x1b[<num>;<mod>u\n\tconst csiUMatch = data.match(/^\\x1b\\[(\\d+)(?:;(\\d+))?u$/);\n\tif (csiUMatch) {\n\t\tconst codepoint = parseInt(csiUMatch[1]!, 10);\n\t\tconst modValue = csiUMatch[2] ? parseInt(csiUMatch[2], 10) : 1;\n\t\treturn { codepoint, modifier: modValue - 1 };\n\t}\n\n\t// Arrow keys with modifier: \\x1b[1;<mod>A/B/C/D\n\tconst arrowMatch = data.match(/^\\x1b\\[1;(\\d+)([ABCD])$/);\n\tif (arrowMatch) {\n\t\tconst modValue = parseInt(arrowMatch[1]!, 10);\n\t\tconst arrowCodes: Record<string, number> = { A: -1, B: -2, C: -3, D: -4 };\n\t\treturn { codepoint: arrowCodes[arrowMatch[2]!]!, modifier: modValue - 1 };\n\t}\n\n\t// Functional keys: \\x1b[<num>~ or \\x1b[<num>;<mod>~\n\tconst funcMatch = data.match(/^\\x1b\\[(\\d+)(?:;(\\d+))?~$/);\n\tif (funcMatch) {\n\t\tconst keyNum = parseInt(funcMatch[1]!, 10);\n\t\tconst modValue = funcMatch[2] ? parseInt(funcMatch[2], 10) : 1;\n\t\tconst funcCodes: Record<number, number> = {\n\t\t\t2: FUNCTIONAL_CODEPOINTS.insert,\n\t\t\t3: FUNCTIONAL_CODEPOINTS.delete,\n\t\t\t5: FUNCTIONAL_CODEPOINTS.pageUp,\n\t\t\t6: FUNCTIONAL_CODEPOINTS.pageDown,\n\t\t\t7: FUNCTIONAL_CODEPOINTS.home,\n\t\t\t8: FUNCTIONAL_CODEPOINTS.end,\n\t\t};\n\t\tconst codepoint = funcCodes[keyNum];\n\t\tif (codepoint !== undefined) {\n\t\t\treturn { codepoint, modifier: modValue - 1 };\n\t\t}\n\t}\n\n\t// Home/End with modifier: \\x1b[1;<mod>H/F\n\tconst homeEndMatch = data.match(/^\\x1b\\[1;(\\d+)([HF])$/);\n\tif (homeEndMatch) {\n\t\tconst modValue = parseInt(homeEndMatch[1]!, 10);\n\t\tconst codepoint = homeEndMatch[2] === \"H\" ? FUNCTIONAL_CODEPOINTS.home : FUNCTIONAL_CODEPOINTS.end;\n\t\treturn { codepoint, modifier: modValue - 1 };\n\t}\n\n\treturn null;\n}\n\nfunction matchesKittySequence(data: string, expectedCodepoint: number, expectedModifier: number): boolean {\n\tconst parsed = parseKittySequence(data);\n\tif (!parsed) return false;\n\tconst actualMod = parsed.modifier & ~LOCK_MASK;\n\tconst expectedMod = expectedModifier & ~LOCK_MASK;\n\treturn parsed.codepoint === expectedCodepoint && actualMod === expectedMod;\n}\n\n// =============================================================================\n// Generic Key Matching\n// =============================================================================\n\nfunction rawCtrlChar(letter: string): string {\n\tconst code = letter.toLowerCase().charCodeAt(0) - 96;\n\treturn String.fromCharCode(code);\n}\n\nfunction parseKeyId(keyId: string): { key: string; ctrl: boolean; shift: boolean; alt: boolean } | null {\n\tconst parts = keyId.toLowerCase().split(\"+\");\n\tconst key = parts[parts.length - 1];\n\tif (!key) return null;\n\treturn {\n\t\tkey,\n\t\tctrl: parts.includes(\"ctrl\"),\n\t\tshift: parts.includes(\"shift\"),\n\t\talt: parts.includes(\"alt\"),\n\t};\n}\n\n/**\n * Match input data against a key identifier string.\n *\n * Supported key identifiers:\n * - Single keys: \"escape\", \"tab\", \"enter\", \"backspace\", \"delete\", \"home\", \"end\", \"space\"\n * - Arrow keys: \"up\", \"down\", \"left\", \"right\"\n * - Ctrl combinations: \"ctrl+c\", \"ctrl+z\", etc.\n * - Shift combinations: \"shift+tab\", \"shift+enter\"\n * - Alt combinations: \"alt+enter\", \"alt+backspace\"\n * - Combined modifiers: \"shift+ctrl+p\", \"ctrl+alt+x\"\n *\n * Use the Key helper for autocomplete: Key.ctrl(\"c\"), Key.escape, Key.ctrlShift(\"p\")\n *\n * @param data - Raw input data from terminal\n * @param keyId - Key identifier (e.g., \"ctrl+c\", \"escape\", Key.ctrl(\"c\"))\n */\nexport function matchesKey(data: string, keyId: KeyId): boolean {\n\tconst parsed = parseKeyId(keyId);\n\tif (!parsed) return false;\n\n\tconst { key, ctrl, shift, alt } = parsed;\n\tlet modifier = 0;\n\tif (shift) modifier |= MODIFIERS.shift;\n\tif (alt) modifier |= MODIFIERS.alt;\n\tif (ctrl) modifier |= MODIFIERS.ctrl;\n\n\tswitch (key) {\n\t\tcase \"escape\":\n\t\tcase \"esc\":\n\t\t\tif (modifier !== 0) return false;\n\t\t\treturn data === \"\\x1b\" || matchesKittySequence(data, CODEPOINTS.escape, 0);\n\n\t\tcase \"space\":\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \" \" || matchesKittySequence(data, CODEPOINTS.space, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, CODEPOINTS.space, modifier);\n\n\t\tcase \"tab\":\n\t\t\tif (shift && !ctrl && !alt) {\n\t\t\t\treturn data === \"\\x1b[Z\" || matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift);\n\t\t\t}\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \"\\t\" || matchesKittySequence(data, CODEPOINTS.tab, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, CODEPOINTS.tab, modifier);\n\n\t\tcase \"enter\":\n\t\tcase \"return\":\n\t\t\tif (shift && !ctrl && !alt) {\n\t\t\t\treturn (\n\t\t\t\t\tmatchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift) ||\n\t\t\t\t\tmatchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.shift)\n\t\t\t\t);\n\t\t\t}\n\t\t\tif (alt && !ctrl && !shift) {\n\t\t\t\treturn (\n\t\t\t\t\tdata === \"\\x1b\\r\" ||\n\t\t\t\t\tmatchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt) ||\n\t\t\t\t\tmatchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.alt)\n\t\t\t\t);\n\t\t\t}\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn (\n\t\t\t\t\tdata === \"\\r\" ||\n\t\t\t\t\tdata === \"\\x1bOM\" || // SS3 M (numpad enter in some terminals)\n\t\t\t\t\tmatchesKittySequence(data, CODEPOINTS.enter, 0) ||\n\t\t\t\t\tmatchesKittySequence(data, CODEPOINTS.kpEnter, 0)\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn (\n\t\t\t\tmatchesKittySequence(data, CODEPOINTS.enter, modifier) ||\n\t\t\t\tmatchesKittySequence(data, CODEPOINTS.kpEnter, modifier)\n\t\t\t);\n\n\t\tcase \"backspace\":\n\t\t\tif (alt && !ctrl && !shift) {\n\t\t\t\treturn data === \"\\x1b\\x7f\" || matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt);\n\t\t\t}\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \"\\x7f\" || data === \"\\x08\" || matchesKittySequence(data, CODEPOINTS.backspace, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, CODEPOINTS.backspace, modifier);\n\n\t\tcase \"delete\":\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \"\\x1b[3~\" || matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, modifier);\n\n\t\tcase \"home\":\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn (\n\t\t\t\t\tdata === \"\\x1b[H\" ||\n\t\t\t\t\tdata === \"\\x1b[1~\" ||\n\t\t\t\t\tdata === \"\\x1b[7~\" ||\n\t\t\t\t\tmatchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, 0)\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, modifier);\n\n\t\tcase \"end\":\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn (\n\t\t\t\t\tdata === \"\\x1b[F\" ||\n\t\t\t\t\tdata === \"\\x1b[4~\" ||\n\t\t\t\t\tdata === \"\\x1b[8~\" ||\n\t\t\t\t\tmatchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, 0)\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, modifier);\n\n\t\tcase \"up\":\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \"\\x1b[A\" || matchesKittySequence(data, ARROW_CODEPOINTS.up, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, ARROW_CODEPOINTS.up, modifier);\n\n\t\tcase \"down\":\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \"\\x1b[B\" || matchesKittySequence(data, ARROW_CODEPOINTS.down, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, ARROW_CODEPOINTS.down, modifier);\n\n\t\tcase \"left\":\n\t\t\tif (alt && !ctrl && !shift) {\n\t\t\t\treturn (\n\t\t\t\t\tdata === \"\\x1b[1;3D\" ||\n\t\t\t\t\tdata === \"\\x1bb\" ||\n\t\t\t\t\tmatchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt)\n\t\t\t\t);\n\t\t\t}\n\t\t\tif (ctrl && !alt && !shift) {\n\t\t\t\treturn data === \"\\x1b[1;5D\" || matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl);\n\t\t\t}\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \"\\x1b[D\" || matchesKittySequence(data, ARROW_CODEPOINTS.left, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, ARROW_CODEPOINTS.left, modifier);\n\n\t\tcase \"right\":\n\t\t\tif (alt && !ctrl && !shift) {\n\t\t\t\treturn (\n\t\t\t\t\tdata === \"\\x1b[1;3C\" ||\n\t\t\t\t\tdata === \"\\x1bf\" ||\n\t\t\t\t\tmatchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt)\n\t\t\t\t);\n\t\t\t}\n\t\t\tif (ctrl && !alt && !shift) {\n\t\t\t\treturn data === \"\\x1b[1;5C\" || matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl);\n\t\t\t}\n\t\t\tif (modifier === 0) {\n\t\t\t\treturn data === \"\\x1b[C\" || matchesKittySequence(data, ARROW_CODEPOINTS.right, 0);\n\t\t\t}\n\t\t\treturn matchesKittySequence(data, ARROW_CODEPOINTS.right, modifier);\n\t}\n\n\t// Handle single letter keys (a-z)\n\tif (key.length === 1 && key >= \"a\" && key <= \"z\") {\n\t\tconst codepoint = key.charCodeAt(0);\n\n\t\tif (ctrl && !shift && !alt) {\n\t\t\tconst raw = rawCtrlChar(key);\n\t\t\tif (data === raw) return true;\n\t\t\tif (data.length > 0 && data.charCodeAt(0) === raw.charCodeAt(0)) return true;\n\t\t\treturn matchesKittySequence(data, codepoint, MODIFIERS.ctrl);\n\t\t}\n\n\t\tif (ctrl && shift && !alt) {\n\t\t\treturn matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl);\n\t\t}\n\n\t\tif (modifier !== 0) {\n\t\t\treturn matchesKittySequence(data, codepoint, modifier);\n\t\t}\n\n\t\treturn data === key;\n\t}\n\n\treturn false;\n}\n\n/**\n * Parse input data and return the key identifier if recognized.\n *\n * @param data - Raw input data from terminal\n * @returns Key identifier string (e.g., \"ctrl+c\") or undefined\n */\nexport function parseKey(data: string): string | undefined {\n\tconst kitty = parseKittySequence(data);\n\tif (kitty) {\n\t\tconst { codepoint, modifier } = kitty;\n\t\tconst mods: string[] = [];\n\t\tconst effectiveMod = modifier & ~LOCK_MASK;\n\t\tif (effectiveMod & MODIFIERS.shift) mods.push(\"shift\");\n\t\tif (effectiveMod & MODIFIERS.ctrl) mods.push(\"ctrl\");\n\t\tif (effectiveMod & MODIFIERS.alt) mods.push(\"alt\");\n\n\t\tlet keyName: string | undefined;\n\t\tif (codepoint === CODEPOINTS.escape) keyName = \"escape\";\n\t\telse if (codepoint === CODEPOINTS.tab) keyName = \"tab\";\n\t\telse if (codepoint === CODEPOINTS.enter || codepoint === CODEPOINTS.kpEnter) keyName = \"enter\";\n\t\telse if (codepoint === CODEPOINTS.space) keyName = \"space\";\n\t\telse if (codepoint === CODEPOINTS.backspace) keyName = \"backspace\";\n\t\telse if (codepoint === FUNCTIONAL_CODEPOINTS.delete) keyName = \"delete\";\n\t\telse if (codepoint === FUNCTIONAL_CODEPOINTS.home) keyName = \"home\";\n\t\telse if (codepoint === FUNCTIONAL_CODEPOINTS.end) keyName = \"end\";\n\t\telse if (codepoint === ARROW_CODEPOINTS.up) keyName = \"up\";\n\t\telse if (codepoint === ARROW_CODEPOINTS.down) keyName = \"down\";\n\t\telse if (codepoint === ARROW_CODEPOINTS.left) keyName = \"left\";\n\t\telse if (codepoint === ARROW_CODEPOINTS.right) keyName = \"right\";\n\t\telse if (codepoint >= 97 && codepoint <= 122) keyName = String.fromCharCode(codepoint);\n\n\t\tif (keyName) {\n\t\t\treturn mods.length > 0 ? `${mods.join(\"+\")}+${keyName}` : keyName;\n\t\t}\n\t}\n\n\t// Legacy sequences\n\tif (data === \"\\x1b\") return \"escape\";\n\tif (data === \"\\t\") return \"tab\";\n\tif (data === \"\\r\" || data === \"\\x1bOM\") return \"enter\";\n\tif (data === \" \") return \"space\";\n\tif (data === \"\\x7f\" || data === \"\\x08\") return \"backspace\";\n\tif (data === \"\\x1b[Z\") return \"shift+tab\";\n\tif (data === \"\\x1b\\r\") return \"alt+enter\";\n\tif (data === \"\\x1b\\x7f\") return \"alt+backspace\";\n\tif (data === \"\\x1b[A\") return \"up\";\n\tif (data === \"\\x1b[B\") return \"down\";\n\tif (data === \"\\x1b[C\") return \"right\";\n\tif (data === \"\\x1b[D\") return \"left\";\n\tif (data === \"\\x1b[H\") return \"home\";\n\tif (data === \"\\x1b[F\") return \"end\";\n\tif (data === \"\\x1b[3~\") return \"delete\";\n\n\t// Raw Ctrl+letter\n\tif (data.length === 1) {\n\t\tconst code = data.charCodeAt(0);\n\t\tif (code >= 1 && code <= 26) {\n\t\t\treturn `ctrl+${String.fromCharCode(code + 96)}`;\n\t\t}\n\t\tif (code >= 32 && code <= 126) {\n\t\t\treturn data;\n\t\t}\n\t}\n\n\treturn undefined;\n}\n"]}