phi-code-tui 0.56.3 → 0.74.1

package/dist/keys.js

@@ -40,8 +40,8 @@ export function isKittyProtocolActive() {
  * 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
+ * - Key.ctrl("c"), Key.alt("x"), Key.super("k") for single modifiers
+ * - Key.ctrlShift("p"), Key.ctrlAlt("x"), Key.ctrlSuper("k") for combined modifiers
  */
 export const Key = {
     // Special keys
@@ -111,6 +111,7 @@ export const Key = {
     ctrl: (key) => `ctrl+${key}`,
     shift: (key) => `shift+${key}`,
     alt: (key) => `alt+${key}`,
+    super: (key) => `super+${key}`,
     // Combined modifiers
     ctrlShift: (key) => `ctrl+shift+${key}`,
     shiftCtrl: (key) => `shift+ctrl+${key}`,
@@ -118,8 +119,15 @@ export const Key = {
     altCtrl: (key) => `alt+ctrl+${key}`,
     shiftAlt: (key) => `shift+alt+${key}`,
     altShift: (key) => `alt+shift+${key}`,
+    ctrlSuper: (key) => `ctrl+super+${key}`,
+    superCtrl: (key) => `super+ctrl+${key}`,
+    shiftSuper: (key) => `shift+super+${key}`,
+    superShift: (key) => `super+shift+${key}`,
+    altSuper: (key) => `alt+super+${key}`,
+    superAlt: (key) => `super+alt+${key}`,
     // Triple modifiers
     ctrlShiftAlt: (key) => `ctrl+shift+alt+${key}`,
+    ctrlShiftSuper: (key) => `ctrl+shift+super+${key}`,
 };
 // =============================================================================
 // Constants
@@ -161,6 +169,7 @@ const MODIFIERS = {
     shift: 1,
     alt: 2,
     ctrl: 4,
+    super: 8,
 };
 const LOCK_MASK = 64 + 128; // Caps Lock + Num Lock
 const CODEPOINTS = {
@@ -185,6 +194,45 @@ const FUNCTIONAL_CODEPOINTS = {
     home: -14,
     end: -15,
 };
+const KITTY_FUNCTIONAL_KEY_EQUIVALENTS = new Map([
+    [57399, 48], // KP_0 -> 0
+    [57400, 49], // KP_1 -> 1
+    [57401, 50], // KP_2 -> 2
+    [57402, 51], // KP_3 -> 3
+    [57403, 52], // KP_4 -> 4
+    [57404, 53], // KP_5 -> 5
+    [57405, 54], // KP_6 -> 6
+    [57406, 55], // KP_7 -> 7
+    [57407, 56], // KP_8 -> 8
+    [57408, 57], // KP_9 -> 9
+    [57409, 46], // KP_DECIMAL -> .
+    [57410, 47], // KP_DIVIDE -> /
+    [57411, 42], // KP_MULTIPLY -> *
+    [57412, 45], // KP_SUBTRACT -> -
+    [57413, 43], // KP_ADD -> +
+    [57415, 61], // KP_EQUAL -> =
+    [57416, 44], // KP_SEPARATOR -> ,
+    [57417, ARROW_CODEPOINTS.left],
+    [57418, ARROW_CODEPOINTS.right],
+    [57419, ARROW_CODEPOINTS.up],
+    [57420, ARROW_CODEPOINTS.down],
+    [57421, FUNCTIONAL_CODEPOINTS.pageUp],
+    [57422, FUNCTIONAL_CODEPOINTS.pageDown],
+    [57423, FUNCTIONAL_CODEPOINTS.home],
+    [57424, FUNCTIONAL_CODEPOINTS.end],
+    [57425, FUNCTIONAL_CODEPOINTS.insert],
+    [57426, FUNCTIONAL_CODEPOINTS.delete],
+]);
+function normalizeKittyFunctionalCodepoint(codepoint) {
+    return KITTY_FUNCTIONAL_KEY_EQUIVALENTS.get(codepoint) ?? codepoint;
+}
+function normalizeShiftedLetterIdentityCodepoint(codepoint, modifier) {
+    const effectiveModifier = modifier & ~LOCK_MASK;
+    if ((effectiveModifier & MODIFIERS.shift) !== 0 && codepoint >= 65 && codepoint <= 90) {
+        return codepoint + 32;
+    }
+    return codepoint;
+}
 const LEGACY_KEY_SEQUENCES = {
     up: ["\x1b[A", "\x1bOA"],
     down: ["\x1b[B", "\x1bOB"],
@@ -436,8 +484,10 @@ function matchesKittySequence(data, expectedCodepoint, expectedModifier) {
     // Check if modifiers match
     if (actualMod !== expectedMod)
         return false;
-    // Primary match: codepoint matches directly
-    if (parsed.codepoint === expectedCodepoint)
+    const normalizedCodepoint = normalizeShiftedLetterIdentityCodepoint(normalizeKittyFunctionalCodepoint(parsed.codepoint), parsed.modifier);
+    const normalizedExpectedCodepoint = normalizeShiftedLetterIdentityCodepoint(normalizeKittyFunctionalCodepoint(expectedCodepoint), expectedModifier);
+    // Primary match: codepoint matches directly after normalizing functional keys
+    if (normalizedCodepoint === normalizedExpectedCodepoint)
         return true;
     // Alternate match: use base layout key for non-Latin keyboard layouts.
     // This allows Ctrl+С (Cyrillic) to match Ctrl+c (Latin) when terminal reports
@@ -452,7 +502,7 @@ function matchesKittySequence(data, expectedCodepoint, expectedModifier) {
     // (letter remapping) and Ctrl+/ could falsely match Ctrl+[ (symbol remapping)
     // if the base layout key were always considered.
     if (parsed.baseLayoutKey !== undefined && parsed.baseLayoutKey === expectedCodepoint) {
-        const cp = parsed.codepoint;
+        const cp = normalizedCodepoint;
         const isLatinLetter = cp >= 97 && cp <= 122; // a-z
         const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(cp));
         if (!isLatinLetter && !isKnownSymbol)
@@ -460,20 +510,43 @@ function matchesKittySequence(data, expectedCodepoint, expectedModifier) {
     }
     return false;
 }
+function parseModifyOtherKeysSequence(data) {
+    const match = data.match(/^\x1b\[27;(\d+);(\d+)~$/);
+    if (!match)
+        return null;
+    const modValue = parseInt(match[1], 10);
+    const codepoint = parseInt(match[2], 10);
+    return { codepoint, modifier: modValue - 1 };
+}
 /**
  * Match xterm modifyOtherKeys format: CSI 27 ; modifiers ; keycode ~
  * This is used by terminals when Kitty protocol is not enabled.
  * Modifier values are 1-indexed: 2=shift, 3=alt, 5=ctrl, etc.
  */
 function matchesModifyOtherKeys(data, expectedKeycode, expectedModifier) {
-    const match = data.match(/^\x1b\[27;(\d+);(\d+)~$/);
-    if (!match)
+    const parsed = parseModifyOtherKeysSequence(data);
+    if (!parsed)
         return false;
-    const modValue = parseInt(match[1], 10);
-    const keycode = parseInt(match[2], 10);
-    // Convert from 1-indexed xterm format to our 0-indexed format
-    const actualMod = modValue - 1;
-    return keycode === expectedKeycode && actualMod === expectedModifier;
+    return parsed.codepoint === expectedKeycode && parsed.modifier === expectedModifier;
+}
+function isWindowsTerminalSession() {
+    return (Boolean(process.env.WT_SESSION) && !process.env.SSH_CONNECTION && !process.env.SSH_CLIENT && !process.env.SSH_TTY);
+}
+/**
+ * Raw 0x08 (BS) is ambiguous in legacy terminals.
+ *
+ * - Windows Terminal uses it for Ctrl+Backspace.
+ * - Some legacy terminals and tmux setups send it for plain Backspace.
+ *
+ * Prefer explicit Kitty / CSI-u / modifyOtherKeys sequences whenever they are
+ * available. Fall back to a Windows Terminal heuristic only for raw BS bytes.
+ */
+function matchesRawBackspace(data, expectedModifier) {
+    if (data === "\x7f")
+        return expectedModifier === 0;
+    if (data !== "\x08")
+        return false;
+    return isWindowsTerminalSession() ? expectedModifier === MODIFIERS.ctrl : expectedModifier === 0;
 }
 // =============================================================================
 // Generic Key Matching
@@ -499,6 +572,34 @@ function rawCtrlChar(key) {
     }
     return null;
 }
+function isDigitKey(key) {
+    return key >= "0" && key <= "9";
+}
+function matchesPrintableModifyOtherKeys(data, expectedKeycode, expectedModifier) {
+    if (expectedModifier === 0)
+        return false;
+    const parsed = parseModifyOtherKeysSequence(data);
+    if (!parsed || parsed.modifier !== expectedModifier)
+        return false;
+    return (normalizeShiftedLetterIdentityCodepoint(parsed.codepoint, parsed.modifier) ===
+        normalizeShiftedLetterIdentityCodepoint(expectedKeycode, expectedModifier));
+}
+function formatKeyNameWithModifiers(keyName, modifier) {
+    const mods = [];
+    const effectiveMod = modifier & ~LOCK_MASK;
+    const supportedModifierMask = MODIFIERS.shift | MODIFIERS.ctrl | MODIFIERS.alt | MODIFIERS.super;
+    if ((effectiveMod & ~supportedModifierMask) !== 0)
+        return undefined;
+    if (effectiveMod & MODIFIERS.shift)
+        mods.push("shift");
+    if (effectiveMod & MODIFIERS.ctrl)
+        mods.push("ctrl");
+    if (effectiveMod & MODIFIERS.alt)
+        mods.push("alt");
+    if (effectiveMod & MODIFIERS.super)
+        mods.push("super");
+    return mods.length > 0 ? `${mods.join("+")}+${keyName}` : keyName;
+}
 function parseKeyId(keyId) {
     const parts = keyId.toLowerCase().split("+");
     const key = parts[parts.length - 1];
@@ -509,6 +610,7 @@ function parseKeyId(keyId) {
         ctrl: parts.includes("ctrl"),
         shift: parts.includes("shift"),
         alt: parts.includes("alt"),
+        super: parts.includes("super"),
     };
 }
 /**
@@ -520,9 +622,10 @@ function parseKeyId(keyId) {
  * - 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"
+ * - Super combinations: "super+k", "super+enter"
+ * - Combined modifiers: "shift+ctrl+p", "ctrl+alt+x", "ctrl+super+k"
  *
- * Use the Key helper for autocomplete: Key.ctrl("c"), Key.escape, Key.ctrlShift("p")
+ * Use the Key helper for autocomplete: Key.ctrl("c"), Key.escape, Key.ctrlShift("p"), Key.super("k")
  *
  * @param data - Raw input data from terminal
  * @param keyId - Key identifier (e.g., "ctrl+c", "escape", Key.ctrl("c"))
@@ -531,7 +634,7 @@ export function matchesKey(data, keyId) {
     const parsed = parseKeyId(keyId);
     if (!parsed)
         return false;
-    const { key, ctrl, shift, alt } = parsed;
+    const { key, ctrl, shift, alt, super: superModifier } = parsed;
     let modifier = 0;
     if (shift)
         modifier |= MODIFIERS.shift;
@@ -539,36 +642,46 @@ export function matchesKey(data, keyId) {
         modifier |= MODIFIERS.alt;
     if (ctrl)
         modifier |= MODIFIERS.ctrl;
+    if (superModifier)
+        modifier |= MODIFIERS.super;
     switch (key) {
         case "escape":
         case "esc":
             if (modifier !== 0)
                 return false;
-            return data === "\x1b" || matchesKittySequence(data, CODEPOINTS.escape, 0);
+            return (data === "\x1b" ||
+                matchesKittySequence(data, CODEPOINTS.escape, 0) ||
+                matchesModifyOtherKeys(data, CODEPOINTS.escape, 0));
         case "space":
             if (!_kittyProtocolActive) {
-                if (ctrl && !alt && !shift && data === "\x00") {
+                if (modifier === MODIFIERS.ctrl && data === "\x00") {
                     return true;
                 }
-                if (alt && !ctrl && !shift && data === "\x1b ") {
+                if (modifier === MODIFIERS.alt && data === "\x1b ") {
                     return true;
                 }
             }
             if (modifier === 0) {
-                return data === " " || matchesKittySequence(data, CODEPOINTS.space, 0);
+                return (data === " " ||
+                    matchesKittySequence(data, CODEPOINTS.space, 0) ||
+                    matchesModifyOtherKeys(data, CODEPOINTS.space, 0));
             }
-            return matchesKittySequence(data, CODEPOINTS.space, modifier);
+            return (matchesKittySequence(data, CODEPOINTS.space, modifier) ||
+                matchesModifyOtherKeys(data, CODEPOINTS.space, modifier));
         case "tab":
-            if (shift && !ctrl && !alt) {
-                return data === "\x1b[Z" || matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift);
+            if (modifier === MODIFIERS.shift) {
+                return (data === "\x1b[Z" ||
+                    matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift) ||
+                    matchesModifyOtherKeys(data, CODEPOINTS.tab, MODIFIERS.shift));
             }
             if (modifier === 0) {
                 return data === "\t" || matchesKittySequence(data, CODEPOINTS.tab, 0);
             }
-            return matchesKittySequence(data, CODEPOINTS.tab, modifier);
+            return (matchesKittySequence(data, CODEPOINTS.tab, modifier) ||
+                matchesModifyOtherKeys(data, CODEPOINTS.tab, modifier));
         case "enter":
         case "return":
-            if (shift && !ctrl && !alt) {
+            if (modifier === MODIFIERS.shift) {
                 // CSI u sequences (standard Kitty protocol)
                 if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift) ||
                     matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.shift)) {
@@ -586,7 +699,7 @@ export function matchesKey(data, keyId) {
                 }
                 return false;
             }
-            if (alt && !ctrl && !shift) {
+            if (modifier === MODIFIERS.alt) {
                 // CSI u sequences (standard Kitty protocol)
                 if (matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt) ||
                     matchesKittySequence(data, CODEPOINTS.kpEnter, MODIFIERS.alt)) {
@@ -611,18 +724,32 @@ export function matchesKey(data, keyId) {
                     matchesKittySequence(data, CODEPOINTS.kpEnter, 0));
             }
             return (matchesKittySequence(data, CODEPOINTS.enter, modifier) ||
-                matchesKittySequence(data, CODEPOINTS.kpEnter, modifier));
+                matchesKittySequence(data, CODEPOINTS.kpEnter, modifier) ||
+                matchesModifyOtherKeys(data, CODEPOINTS.enter, modifier));
         case "backspace":
-            if (alt && !ctrl && !shift) {
+            if (modifier === MODIFIERS.alt) {
                 if (data === "\x1b\x7f" || data === "\x1b\b") {
                     return true;
                 }
-                return matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt);
+                return (matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt) ||
+                    matchesModifyOtherKeys(data, CODEPOINTS.backspace, MODIFIERS.alt));
+            }
+            if (modifier === MODIFIERS.ctrl) {
+                // Legacy raw 0x08 is ambiguous: it can be Ctrl+Backspace on Windows
+                // Terminal or plain Backspace on other terminals, while also
+                // overlapping with Ctrl+H.
+                if (matchesRawBackspace(data, MODIFIERS.ctrl))
+                    return true;
+                return (matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.ctrl) ||
+                    matchesModifyOtherKeys(data, CODEPOINTS.backspace, MODIFIERS.ctrl));
             }
             if (modifier === 0) {
-                return data === "\x7f" || data === "\x08" || matchesKittySequence(data, CODEPOINTS.backspace, 0);
+                return (matchesRawBackspace(data, 0) ||
+                    matchesKittySequence(data, CODEPOINTS.backspace, 0) ||
+                    matchesModifyOtherKeys(data, CODEPOINTS.backspace, 0));
             }
-            return matchesKittySequence(data, CODEPOINTS.backspace, modifier);
+            return (matchesKittySequence(data, CODEPOINTS.backspace, modifier) ||
+                matchesModifyOtherKeys(data, CODEPOINTS.backspace, modifier));
         case "insert":
             if (modifier === 0) {
                 return (matchesLegacySequence(data, LEGACY_KEY_SEQUENCES.insert) ||
@@ -683,7 +810,7 @@ export function matchesKey(data, keyId) {
             }
             return matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageDown, modifier);
         case "up":
-            if (alt && !ctrl && !shift) {
+            if (modifier === MODIFIERS.alt) {
                 return data === "\x1bp" || matchesKittySequence(data, ARROW_CODEPOINTS.up, MODIFIERS.alt);
             }
             if (modifier === 0) {
@@ -695,7 +822,7 @@ export function matchesKey(data, keyId) {
             }
             return matchesKittySequence(data, ARROW_CODEPOINTS.up, modifier);
         case "down":
-            if (alt && !ctrl && !shift) {
+            if (modifier === MODIFIERS.alt) {
                 return data === "\x1bn" || matchesKittySequence(data, ARROW_CODEPOINTS.down, MODIFIERS.alt);
             }
             if (modifier === 0) {
@@ -707,13 +834,13 @@ export function matchesKey(data, keyId) {
             }
             return matchesKittySequence(data, ARROW_CODEPOINTS.down, modifier);
         case "left":
-            if (alt && !ctrl && !shift) {
+            if (modifier === MODIFIERS.alt) {
                 return (data === "\x1b[1;3D" ||
                     (!_kittyProtocolActive && data === "\x1bB") ||
                     data === "\x1bb" ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt));
             }
-            if (ctrl && !alt && !shift) {
+            if (modifier === MODIFIERS.ctrl) {
                 return (data === "\x1b[1;5D" ||
                     matchesLegacyModifierSequence(data, "left", MODIFIERS.ctrl) ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl));
@@ -727,13 +854,13 @@ export function matchesKey(data, keyId) {
             }
             return matchesKittySequence(data, ARROW_CODEPOINTS.left, modifier);
         case "right":
-            if (alt && !ctrl && !shift) {
+            if (modifier === MODIFIERS.alt) {
                 return (data === "\x1b[1;3C" ||
                     (!_kittyProtocolActive && data === "\x1bF") ||
                     data === "\x1bf" ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt));
             }
-            if (ctrl && !alt && !shift) {
+            if (modifier === MODIFIERS.ctrl) {
                 return (data === "\x1b[1;5C" ||
                     matchesLegacyModifierSequence(data, "right", MODIFIERS.ctrl) ||
                     matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl));
@@ -765,36 +892,45 @@ export function matchesKey(data, keyId) {
             return matchesLegacySequence(data, LEGACY_KEY_SEQUENCES[functionKey]);
         }
     }
-    // Handle single letter keys (a-z) and some symbols
-    if (key.length === 1 && ((key >= "a" && key <= "z") || SYMBOL_KEYS.has(key))) {
+    // Handle single letter/digit keys and symbols
+    if (key.length === 1 && ((key >= "a" && key <= "z") || isDigitKey(key) || SYMBOL_KEYS.has(key))) {
         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 isLetter = key >= "a" && key <= "z";
+        const isDigit = isDigitKey(key);
+        if (modifier === MODIFIERS.ctrl + MODIFIERS.alt && !_kittyProtocolActive && rawCtrl) {
+            // Legacy: ctrl+alt+key is ESC followed by the control character.
+            // If that legacy form does not match, continue so CSI-u and
+            // modifyOtherKeys sequences from tmux can still be recognized.
+            if (data === `\x1b${rawCtrl}`)
+                return true;
         }
-        if (alt && !ctrl && !shift && !_kittyProtocolActive && key >= "a" && key <= "z") {
-            // Legacy: alt+letter is ESC followed by the letter
+        if (modifier === MODIFIERS.alt && !_kittyProtocolActive && (isLetter || isDigit)) {
+            // Legacy: alt+letter/digit is ESC followed by the key
             if (data === `\x1b${key}`)
                 return true;
         }
-        if (ctrl && !shift && !alt) {
+        if (modifier === MODIFIERS.ctrl) {
             // Legacy: ctrl+key sends the control character
             if (rawCtrl && data === rawCtrl)
                 return true;
-            return matchesKittySequence(data, codepoint, MODIFIERS.ctrl);
+            return (matchesKittySequence(data, codepoint, MODIFIERS.ctrl) ||
+                matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.ctrl));
         }
-        if (ctrl && shift && !alt) {
-            return matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl);
+        if (modifier === MODIFIERS.shift + MODIFIERS.ctrl) {
+            return (matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl) ||
+                matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl));
         }
-        if (shift && !ctrl && !alt) {
+        if (modifier === MODIFIERS.shift) {
             // Legacy: shift+letter produces uppercase
-            if (data === key.toUpperCase())
+            if (isLetter && data === key.toUpperCase())
                 return true;
-            return matchesKittySequence(data, codepoint, MODIFIERS.shift);
+            return (matchesKittySequence(data, codepoint, MODIFIERS.shift) ||
+                matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.shift));
         }
         if (modifier !== 0) {
-            return matchesKittySequence(data, codepoint, modifier);
+            return (matchesKittySequence(data, codepoint, modifier) ||
+                matchesPrintableModifyOtherKeys(data, codepoint, modifier));
         }
         // Check both raw char and Kitty sequence (needed for release events)
         return data === key || matchesKittySequence(data, codepoint, 0);
@@ -807,67 +943,67 @@ export function matchesKey(data, keyId) {
  * @param data - Raw input data from terminal
  * @returns Key identifier string (e.g., "ctrl+c") or undefined
  */
+function formatParsedKey(codepoint, modifier, baseLayoutKey) {
+    const normalizedCodepoint = normalizeKittyFunctionalCodepoint(codepoint);
+    const identityCodepoint = normalizeShiftedLetterIdentityCodepoint(normalizedCodepoint, modifier);
+    // Use base layout key only when codepoint is not a recognized Latin
+    // letter (a-z), digit (0-9), or symbol (/, -, [, ;, etc.). For those,
+    // the codepoint is authoritative regardless of physical key position.
+    // This prevents remapped layouts (Dvorak, Colemak, xremap, etc.) from
+    // reporting the wrong key name based on the QWERTY physical position.
+    const isLatinLetter = identityCodepoint >= 97 && identityCodepoint <= 122; // a-z
+    const isDigit = identityCodepoint >= 48 && identityCodepoint <= 57; // 0-9
+    const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(identityCodepoint));
+    const effectiveCodepoint = isLatinLetter || isDigit || isKnownSymbol ? identityCodepoint : (baseLayoutKey ?? identityCodepoint);
+    let keyName;
+    if (effectiveCodepoint === CODEPOINTS.escape)
+        keyName = "escape";
+    else if (effectiveCodepoint === CODEPOINTS.tab)
+        keyName = "tab";
+    else if (effectiveCodepoint === CODEPOINTS.enter || effectiveCodepoint === CODEPOINTS.kpEnter)
+        keyName = "enter";
+    else if (effectiveCodepoint === CODEPOINTS.space)
+        keyName = "space";
+    else if (effectiveCodepoint === CODEPOINTS.backspace)
+        keyName = "backspace";
+    else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.delete)
+        keyName = "delete";
+    else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.insert)
+        keyName = "insert";
+    else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.home)
+        keyName = "home";
+    else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.end)
+        keyName = "end";
+    else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.pageUp)
+        keyName = "pageUp";
+    else if (effectiveCodepoint === FUNCTIONAL_CODEPOINTS.pageDown)
+        keyName = "pageDown";
+    else if (effectiveCodepoint === ARROW_CODEPOINTS.up)
+        keyName = "up";
+    else if (effectiveCodepoint === ARROW_CODEPOINTS.down)
+        keyName = "down";
+    else if (effectiveCodepoint === ARROW_CODEPOINTS.left)
+        keyName = "left";
+    else if (effectiveCodepoint === ARROW_CODEPOINTS.right)
+        keyName = "right";
+    else if (effectiveCodepoint >= 48 && effectiveCodepoint <= 57)
+        keyName = String.fromCharCode(effectiveCodepoint);
+    else if (effectiveCodepoint >= 97 && effectiveCodepoint <= 122)
+        keyName = String.fromCharCode(effectiveCodepoint);
+    else if (SYMBOL_KEYS.has(String.fromCharCode(effectiveCodepoint)))
+        keyName = String.fromCharCode(effectiveCodepoint);
+    if (!keyName)
+        return undefined;
+    return formatKeyNameWithModifiers(keyName, modifier);
+}
 export function parseKey(data) {
     const kitty = parseKittySequence(data);
     if (kitty) {
-        const { codepoint, baseLayoutKey, modifier } = kitty;
-        const mods = [];
-        const effectiveMod = modifier & ~LOCK_MASK;
-        const supportedModifierMask = MODIFIERS.shift | MODIFIERS.ctrl | MODIFIERS.alt;
-        if ((effectiveMod & ~supportedModifierMask) !== 0)
-            return undefined;
-        if (effectiveMod & MODIFIERS.shift)
-            mods.push("shift");
-        if (effectiveMod & MODIFIERS.ctrl)
-            mods.push("ctrl");
-        if (effectiveMod & MODIFIERS.alt)
-            mods.push("alt");
-        // Use base layout key only when codepoint is not a recognized Latin
-        // letter (a-z) or symbol (/, -, [, ;, etc.). For those, the codepoint
-        // is authoritative regardless of physical key position. This prevents
-        // remapped layouts (Dvorak, Colemak, xremap, etc.) from reporting the
-        // wrong key name based on the QWERTY physical position.
-        const isLatinLetter = codepoint >= 97 && codepoint <= 122; // a-z
-        const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(codepoint));
-        const effectiveCodepoint = isLatinLetter || isKnownSymbol ? codepoint : (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;
-        }
+        return formatParsedKey(kitty.codepoint, kitty.modifier, kitty.baseLayoutKey);
+    }
+    const modifyOtherKeys = parseModifyOtherKeysSequence(data);
+    if (modifyOtherKeys) {
+        return formatParsedKey(modifyOtherKeys.codepoint, modifyOtherKeys.modifier);
     }
     // Mode-aware legacy sequences
     // When Kitty protocol is active, ambiguous sequences are interpreted as custom terminal mappings:
@@ -905,8 +1041,10 @@ export function parseKey(data) {
         return "ctrl+space";
     if (data === " ")
         return "space";
-    if (data === "\x7f" || data === "\x08")
+    if (data === "\x7f")
         return "backspace";
+    if (data === "\x08")
+        return isWindowsTerminalSession() ? "ctrl+backspace" : "backspace";
     if (data === "\x1b[Z")
         return "shift+tab";
     if (!_kittyProtocolActive && data === "\x1b\r")
@@ -924,8 +1062,8 @@ export function parseKey(data) {
         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) {
+        // Legacy alt+letter/digit (ESC followed by the key)
+        if ((code >= 97 && code <= 122) || (code >= 48 && code <= 57)) {
             return `alt+${String.fromCharCode(code)}`;
         }
     }
@@ -1002,6 +1140,7 @@ export function decodeKittyPrintable(data) {
     if (modifier & MODIFIERS.shift && typeof shiftedKey === "number") {
         effectiveCodepoint = shiftedKey;
     }
+    effectiveCodepoint = normalizeKittyFunctionalCodepoint(effectiveCodepoint);
     // Drop control characters or invalid codepoints.
     if (!Number.isFinite(effectiveCodepoint) || effectiveCodepoint < 32)
         return undefined;
@@ -1012,4 +1151,23 @@ export function decodeKittyPrintable(data) {
         return undefined;
     }
 }
+function decodeModifyOtherKeysPrintable(data) {
+    const parsed = parseModifyOtherKeysSequence(data);
+    if (!parsed)
+        return undefined;
+    const modifier = parsed.modifier & ~LOCK_MASK;
+    if ((modifier & ~MODIFIERS.shift) !== 0)
+        return undefined;
+    if (!Number.isFinite(parsed.codepoint) || parsed.codepoint < 32)
+        return undefined;
+    try {
+        return String.fromCodePoint(parsed.codepoint);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function decodePrintableKey(data) {
+    return decodeKittyPrintable(data) ?? decodeModifyOtherKeysPrintable(data);
+}
 //# sourceMappingURL=keys.js.map