@mariozechner/pi-tui 0.57.0 → 0.57.1

package/dist/keys.js

@@ -460,20 +460,24 @@ 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;
 }
 // =============================================================================
 // Generic Key Matching
@@ -499,6 +503,28 @@ function rawCtrlChar(key) {
     }
     return null;
 }
+function isDigitKey(key) {
+    return key >= "0" && key <= "9";
+}
+function matchesPrintableModifyOtherKeys(data, expectedKeycode, expectedModifier) {
+    if (expectedModifier === 0)
+        return false;
+    return matchesModifyOtherKeys(data, expectedKeycode, expectedModifier);
+}
+function formatKeyNameWithModifiers(keyName, modifier) {
+    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");
+    return mods.length > 0 ? `${mods.join("+")}+${keyName}` : keyName;
+}
 function parseKeyId(keyId) {
     const parts = keyId.toLowerCase().split("+");
     const key = parts[parts.length - 1];
@@ -611,7 +637,8 @@ 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 (data === "\x1b\x7f" || data === "\x1b\b") {
@@ -765,16 +792,18 @@ 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);
+        const isLetter = key >= "a" && key <= "z";
+        const isDigit = isDigitKey(key);
         if (ctrl && alt && !shift && !_kittyProtocolActive && rawCtrl) {
             // Legacy: ctrl+alt+key is ESC followed by the control character
             return data === `\x1b${rawCtrl}`;
         }
-        if (alt && !ctrl && !shift && !_kittyProtocolActive && key >= "a" && key <= "z") {
-            // Legacy: alt+letter is ESC followed by the letter
+        if (alt && !ctrl && !shift && !_kittyProtocolActive && (isLetter || isDigit)) {
+            // Legacy: alt+letter/digit is ESC followed by the key
             if (data === `\x1b${key}`)
                 return true;
         }
@@ -782,19 +811,23 @@ export function matchesKey(data, keyId) {
             // 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);
+            return (matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl) ||
+                matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl));
         }
         if (shift && !ctrl && !alt) {
             // 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 +840,65 @@ 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) {
+    // 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 = codepoint >= 97 && codepoint <= 122; // a-z
+    const isDigit = codepoint >= 48 && codepoint <= 57; // 0-9
+    const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(codepoint));
+    const effectiveCodepoint = isLatinLetter || isDigit || 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 >= 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:
@@ -924,8 +955,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)}`;
         }
     }