@dungle-scrubs/tallow 0.9.4 → 0.9.7

package/node_modules/@mariozechner/pi-tui/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,38 @@ 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;
+}
 const LEGACY_KEY_SEQUENCES = {
     up: ["\x1b[A", "\x1bOA"],
     down: ["\x1b[B", "\x1bOB"],
@@ -306,15 +347,11 @@ const matchesLegacyModifierSequence = (data, key, modifier) => {
     }
     return false;
 };
-// Tracks the event type from the most recent parseKey() call.
+// Store the last parsed event type for isKeyRelease() to query
 let _lastEventType = "press";
 /**
- * Check if the given input data represents a key release event.
- * Performs fast pattern matching on raw terminal escape sequences.
+ * Check if the last parsed key event was a key release.
  * Only meaningful when Kitty keyboard protocol with flag 2 is active.
- *
- * @param data - Raw terminal input string
- * @returns true if the data contains a key release escape sequence
  */
 export function isKeyRelease(data) {
     // Don't treat bracketed paste content as key release, even if it contains
@@ -339,12 +376,8 @@ export function isKeyRelease(data) {
     return false;
 }
 /**
- * Check if the given input data represents a key repeat event.
- * Performs fast pattern matching on raw terminal escape sequences.
+ * Check if the last parsed key event was a key repeat.
  * Only meaningful when Kitty keyboard protocol with flag 2 is active.
- *
- * @param data - Raw terminal input string
- * @returns true if the data contains a key repeat escape sequence
  */
 export function isKeyRepeat(data) {
     // Don't treat bracketed paste content as key repeat, even if it contains
@@ -444,8 +477,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 = normalizeKittyFunctionalCodepoint(parsed.codepoint);
+    const normalizedExpectedCodepoint = normalizeKittyFunctionalCodepoint(expectedCodepoint);
+    // 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
@@ -460,7 +495,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)
@@ -468,27 +503,25 @@ 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;
 }
-/**
- * Detect Windows Terminal by session environment variable.
- * Excludes SSH sessions where WT_SESSION may leak from the host.
- *
- * @returns true when running directly inside Windows Terminal
- */
 function isWindowsTerminalSession() {
     return (Boolean(process.env.WT_SESSION) &&
         !process.env.SSH_CONNECTION &&
@@ -503,10 +536,6 @@ function isWindowsTerminalSession() {
  *
  * Prefer explicit Kitty / CSI-u / modifyOtherKeys sequences whenever they are
  * available. Fall back to a Windows Terminal heuristic only for raw BS bytes.
- *
- * @param data - Raw terminal input byte
- * @param expectedModifier - Modifier bitmask to match against
- * @returns true if the data matches backspace with the given modifier
  */
 function matchesRawBackspace(data, expectedModifier) {
     if (data === "\x7f")
@@ -543,6 +572,30 @@ 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 | 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];
@@ -553,6 +606,7 @@ function parseKeyId(keyId) {
         ctrl: parts.includes("ctrl"),
         shift: parts.includes("shift"),
         alt: parts.includes("alt"),
+        super: parts.includes("super"),
     };
 }
 /**
@@ -564,9 +618,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"))
@@ -575,7 +630,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;
@@ -583,6 +638,8 @@ export function matchesKey(data, keyId) {
         modifier |= MODIFIERS.alt;
     if (ctrl)
         modifier |= MODIFIERS.ctrl;
+    if (superModifier)
+        modifier |= MODIFIERS.super;
     switch (key) {
         case "escape":
         case "esc":
@@ -593,10 +650,10 @@ export function matchesKey(data, keyId) {
                 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;
                 }
             }
@@ -608,8 +665,10 @@ export function matchesKey(data, keyId) {
             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);
@@ -618,7 +677,7 @@ export function matchesKey(data, keyId) {
                 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)) {
@@ -636,7 +695,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)) {
@@ -664,14 +723,14 @@ export function matchesKey(data, keyId) {
                 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) ||
                     matchesModifyOtherKeys(data, CODEPOINTS.backspace, MODIFIERS.alt));
             }
-            if (ctrl && !alt && !shift) {
+            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.
@@ -747,7 +806,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) {
@@ -759,7 +818,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) {
@@ -771,13 +830,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));
@@ -791,13 +850,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));
@@ -829,40 +888,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) ||
-                matchesModifyOtherKeys(data, codepoint, MODIFIERS.ctrl));
+                matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.ctrl));
         }
-        if (ctrl && shift && !alt) {
+        if (modifier === MODIFIERS.shift + MODIFIERS.ctrl) {
             return (matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl) ||
-                matchesModifyOtherKeys(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) ||
-                matchesModifyOtherKeys(data, codepoint, MODIFIERS.shift));
+                matchesPrintableModifyOtherKeys(data, codepoint, MODIFIERS.shift));
         }
         if (modifier !== 0) {
             return (matchesKittySequence(data, codepoint, modifier) ||
-                matchesModifyOtherKeys(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);
@@ -875,64 +939,68 @@ 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);
+    // 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 = normalizedCodepoint >= 97 && normalizedCodepoint <= 122; // a-z
+    const isDigit = normalizedCodepoint >= 48 && normalizedCodepoint <= 57; // 0-9
+    const isKnownSymbol = SYMBOL_KEYS.has(String.fromCharCode(normalizedCodepoint));
+    const effectiveCodepoint = isLatinLetter || isDigit || isKnownSymbol
+        ? normalizedCodepoint
+        : (baseLayoutKey ?? normalizedCodepoint);
+    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;
-        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:
@@ -991,8 +1059,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)}`;
         }
     }
@@ -1026,42 +1094,58 @@ export function parseKey(data) {
     }
     return undefined;
 }
-/** SGR extended mouse format: \x1b[<button;x;y[Mm] */
-const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
+// =============================================================================
+// Kitty CSI-u Printable Decoding
+// =============================================================================
+const KITTY_CSI_U_REGEX = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u$/;
+const KITTY_PRINTABLE_ALLOWED_MODIFIERS = MODIFIERS.shift | LOCK_MASK;
 /**
- * Parse an SGR mouse event from raw terminal input.
+ * Decode a Kitty CSI-u sequence into a printable character, if applicable.
  *
- * @param data - Raw terminal input
- * @returns Parsed mouse event, or null if not a mouse sequence
- */
-export function parseMouseEvent(data) {
-    const match = data.match(SGR_MOUSE_RE);
-    if (!match)
-        return null;
-    const code = parseInt(match[1], 10);
-    const x = parseInt(match[2], 10);
-    const y = parseInt(match[3], 10);
-    const isRelease = match[4] === "m";
-    // Scroll wheel: codes 64 (up) and 65 (down)
-    if (code === 64)
-        return { type: "scroll-up", button: 0, x, y };
-    if (code === 65)
-        return { type: "scroll-down", button: 0, x, y };
-    // Button number is in the low 2 bits
-    const button = code & 0x03;
-    // Bit 5 (32) = motion/drag
-    if (code & 32)
-        return { type: "drag", button, x, y };
-    return { type: isRelease ? "release" : "press", button, x, y };
-}
-/**
- * Fast check: is this data an SGR mouse event?
- * Avoids regex for non-mouse input.
+ * When Kitty keyboard protocol flag 1 (disambiguate) is active, terminals send
+ * CSI-u sequences for all keys, including plain printable characters. This
+ * function extracts the printable character from such sequences.
  *
- * @param data - Raw terminal input
- * @returns true if the input is an SGR mouse sequence
+ * Only accepts plain or Shift-modified keys. Rejects Ctrl, Alt, and unsupported
+ * modifier combinations (those are handled by keybinding matching instead).
+ * Prefers the shifted keycode when Shift is held and a shifted key is reported.
+ *
+ * @param data - Raw input data from terminal
+ * @returns The printable character, or undefined if not a printable CSI-u sequence
  */
-export function isMouseEvent(data) {
-    return data.length >= 9 && data.startsWith("\x1b[<");
+export function decodeKittyPrintable(data) {
+    const match = data.match(KITTY_CSI_U_REGEX);
+    if (!match)
+        return undefined;
+    // CSI-u groups: <codepoint>[:<shifted>[:<base>]];<mod>[:<event>]u
+    const codepoint = Number.parseInt(match[1] ?? "", 10);
+    if (!Number.isFinite(codepoint))
+        return undefined;
+    const shiftedKey = match[2] && match[2].length > 0 ? Number.parseInt(match[2], 10) : undefined;
+    const modValue = match[4] ? Number.parseInt(match[4], 10) : 1;
+    // Modifiers are 1-indexed in CSI-u; normalize to our bitmask.
+    const modifier = Number.isFinite(modValue) ? modValue - 1 : 0;
+    // Only accept printable CSI-u input for plain or Shift-modified text keys.
+    // Reject unsupported modifier bits (e.g. Super/Meta) to avoid inserting
+    // characters from modifier-only terminal events.
+    if ((modifier & ~KITTY_PRINTABLE_ALLOWED_MODIFIERS) !== 0)
+        return undefined;
+    if (modifier & (MODIFIERS.alt | MODIFIERS.ctrl))
+        return undefined;
+    // Prefer the shifted keycode when Shift is held.
+    let effectiveCodepoint = codepoint;
+    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;
+    try {
+        return String.fromCodePoint(effectiveCodepoint);
+    }
+    catch {
+        return undefined;
+    }
 }
 //# sourceMappingURL=keys.js.map