@google/gemini-cli 0.14.0-preview.0 → 0.15.0-nightly.20251110.c0b766ad

package/dist/src/ui/contexts/KeypressContext.js

@@ -1,382 +1,461 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { debugLogger, KittySequenceOverflowEvent, logKittySequenceOverflow, } from '@google/gemini-cli-core';
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
 import { useStdin } from 'ink';
 import { createContext, useCallback, useContext, useEffect, useRef, } from 'react';
-import readline from 'node:readline';
-import { PassThrough } from 'node:stream';
-import { BACKSLASH_ENTER_DETECTION_WINDOW_MS, CHAR_CODE_ESC, KITTY_CTRL_C, KITTY_KEYCODE_BACKSPACE, KITTY_KEYCODE_ENTER, KITTY_KEYCODE_NUMPAD_ENTER, KITTY_KEYCODE_TAB, MAX_KITTY_SEQUENCE_LENGTH, KITTY_MODIFIER_BASE, KITTY_MODIFIER_EVENT_TYPES_OFFSET, MODIFIER_SHIFT_BIT, MODIFIER_ALT_BIT, MODIFIER_CTRL_BIT, } from '../utils/platformConstants.js';
-import { ESC, couldBeMouseSequence } from '../utils/input.js';
+import { ESC } from '../utils/input.js';
+import { parseMouseEvent } from '../utils/mouse.js';
 import { FOCUS_IN, FOCUS_OUT } from '../hooks/useFocus.js';
-import { isIncompleteMouseSequence, parseMouseEvent } from '../utils/mouse.js';
-export const PASTE_MODE_START = `${ESC}[200~`;
-export const PASTE_MODE_END = `${ESC}[201~`;
-export const DRAG_COMPLETION_TIMEOUT_MS = 100; // Broadcast full path after 100ms if no more input
-export const KITTY_SEQUENCE_TIMEOUT_MS = 50; // Flush incomplete kitty sequences after 50ms
-export const PASTE_CODE_TIMEOUT_MS = 50; // Flush incomplete paste code after 50ms
-export const SINGLE_QUOTE = "'";
-export const DOUBLE_QUOTE = '"';
-// On Mac, hitting alt+char will yield funny characters.
-// Remap these three since we listen for them.
+export const BACKSLASH_ENTER_TIMEOUT = 5;
+export const ESC_TIMEOUT = 50;
+export const PASTE_TIMEOUT = 50;
+// Parse the key itself
+const KEY_INFO_MAP = {
+    '[200~': { name: 'paste-start' },
+    '[201~': { name: 'paste-end' },
+    '[[A': { name: 'f1' },
+    '[[B': { name: 'f2' },
+    '[[C': { name: 'f3' },
+    '[[D': { name: 'f4' },
+    '[[E': { name: 'f5' },
+    '[1~': { name: 'home' },
+    '[2~': { name: 'insert' },
+    '[3~': { name: 'delete' },
+    '[4~': { name: 'end' },
+    '[5~': { name: 'pageup' },
+    '[6~': { name: 'pagedown' },
+    '[7~': { name: 'home' },
+    '[8~': { name: 'end' },
+    '[11~': { name: 'f1' },
+    '[12~': { name: 'f2' },
+    '[13~': { name: 'f3' },
+    '[14~': { name: 'f4' },
+    '[15~': { name: 'f5' },
+    '[17~': { name: 'f6' },
+    '[18~': { name: 'f7' },
+    '[19~': { name: 'f8' },
+    '[20~': { name: 'f9' },
+    '[21~': { name: 'f10' },
+    '[23~': { name: 'f11' },
+    '[24~': { name: 'f12' },
+    '[A': { name: 'up' },
+    '[B': { name: 'down' },
+    '[C': { name: 'right' },
+    '[D': { name: 'left' },
+    '[E': { name: 'clear' },
+    '[F': { name: 'end' },
+    '[H': { name: 'home' },
+    '[P': { name: 'f1' },
+    '[Q': { name: 'f2' },
+    '[R': { name: 'f3' },
+    '[S': { name: 'f4' },
+    OA: { name: 'up' },
+    OB: { name: 'down' },
+    OC: { name: 'right' },
+    OD: { name: 'left' },
+    OE: { name: 'clear' },
+    OF: { name: 'end' },
+    OH: { name: 'home' },
+    OP: { name: 'f1' },
+    OQ: { name: 'f2' },
+    OR: { name: 'f3' },
+    OS: { name: 'f4' },
+    '[[5~': { name: 'pageup' },
+    '[[6~': { name: 'pagedown' },
+    '[9u': { name: 'tab' },
+    '[13u': { name: 'return' },
+    '[27u': { name: 'escape' },
+    '[127u': { name: 'backspace' },
+    '[57414u': { name: 'return' }, // Numpad Enter
+    '[a': { name: 'up', shift: true },
+    '[b': { name: 'down', shift: true },
+    '[c': { name: 'right', shift: true },
+    '[d': { name: 'left', shift: true },
+    '[e': { name: 'clear', shift: true },
+    '[2$': { name: 'insert', shift: true },
+    '[3$': { name: 'delete', shift: true },
+    '[5$': { name: 'pageup', shift: true },
+    '[6$': { name: 'pagedown', shift: true },
+    '[7$': { name: 'home', shift: true },
+    '[8$': { name: 'end', shift: true },
+    '[Z': { name: 'tab', shift: true },
+    Oa: { name: 'up', ctrl: true },
+    Ob: { name: 'down', ctrl: true },
+    Oc: { name: 'right', ctrl: true },
+    Od: { name: 'left', ctrl: true },
+    Oe: { name: 'clear', ctrl: true },
+    '[2^': { name: 'insert', ctrl: true },
+    '[3^': { name: 'delete', ctrl: true },
+    '[5^': { name: 'pageup', ctrl: true },
+    '[6^': { name: 'pagedown', ctrl: true },
+    '[7^': { name: 'home', ctrl: true },
+    '[8^': { name: 'end', ctrl: true },
+};
+const kUTF16SurrogateThreshold = 0x10000; // 2 ** 16
+function charLengthAt(str, i) {
+    if (str.length <= i) {
+        // Pretend to move to the right. This is necessary to autocomplete while
+        // moving to the right.
+        return 1;
+    }
+    const code = str.codePointAt(i);
+    return code !== undefined && code >= kUTF16SurrogateThreshold ? 2 : 1;
+}
 const MAC_ALT_KEY_CHARACTER_MAP = {
     '\u222B': 'b', // "∫" back one word
     '\u0192': 'f', // "ƒ" forward one word
     '\u00B5': 'm', // "µ" toggle markup view
 };
-/**
- * Maps symbols from parameterized functional keys `\x1b[1;1<letter>`
- * to their corresponding key names (e.g., 'up', 'f1').
- */
-const LEGACY_FUNC_TO_NAME = {
-    A: 'up',
-    B: 'down',
-    C: 'right',
-    D: 'left',
-    H: 'home',
-    F: 'end',
-    P: 'f1',
-    Q: 'f2',
-    R: 'f3',
-    S: 'f4',
-};
-/**
- * Maps key codes from tilde-coded functional keys `\x1b[<code>~`
- * to their corresponding key names.
- */
-const TILDE_KEYCODE_TO_NAME = {
-    1: 'home',
-    2: 'insert',
-    3: 'delete',
-    4: 'end',
-    5: 'pageup',
-    6: 'pagedown',
-    11: 'f1',
-    12: 'f2',
-    13: 'f3',
-    14: 'f4',
-    15: 'f5',
-    17: 'f6', // skipping 16 is intentional
-    18: 'f7',
-    19: 'f8',
-    20: 'f9',
-    21: 'f10',
-    23: 'f11', // skipping 22 is intentional
-    24: 'f12',
-};
-/**
- * Check if a buffer could potentially be a valid kitty sequence or its prefix.
- */
-function couldBeKittySequence(buffer) {
-    // Kitty sequences always start with ESC[.
-    if (buffer.length === 0)
-        return true;
-    if (buffer === ESC || buffer === `${ESC}[`)
-        return true;
-    if (!buffer.startsWith(`${ESC}[`))
-        return false;
-    if (couldBeMouseSequence(buffer))
-        return true;
-    // Check for known kitty sequence patterns:
-    // 1. ESC[<digit> - could be CSI-u or tilde-coded
-    // 2. ESC[1;<digit> - parameterized functional
-    // 3. ESC[<letter> - legacy functional keys
-    // 4. ESC[Z - reverse tab
-    const afterCSI = buffer.slice(2);
-    // Check if it starts with a digit (could be CSI-u or parameterized)
-    if (/^\d/.test(afterCSI))
-        return true;
-    // Check for known single-letter sequences
-    if (/^[ABCDHFPQRSZ]/.test(afterCSI))
-        return true;
-    // Check for 1; pattern (parameterized sequences)
-    if (/^1;\d/.test(afterCSI))
-        return true;
-    // Anything else starting with ESC[ that doesn't match our patterns
-    // is likely not a kitty sequence we handle
-    return false;
-}
-/**
- * Parses a single complete kitty/parameterized/legacy sequence from the start
- * of the buffer.
- *
- * This enables peel-and-continue parsing for batched input, allowing us to
- * "peel off" one complete event when multiple sequences arrive in a single
- * chunk, preventing buffer overflow and fragmentation.
- *
- * @param buffer - The input buffer string to parse.
- * @returns The parsed Key and the number of characters consumed, or null if
- * no complete sequence is found at the start of the buffer.
- */
-function parseKittyPrefix(buffer) {
-    // In older terminals ESC [ Z was used as Cursor Backward Tabulation (CBT)
-    // In newer terminals the same functionality of key combination for moving
-    // backward through focusable elements is Shift+Tab, hence we will
-    // map ESC [ Z to Shift+Tab
-    // 0) Reverse Tab (legacy): ESC [ Z
-    //    Treat as Shift+Tab for UI purposes.
-    //    Regex parts:
-    //    ^     - start of buffer
-    //    ESC [ - CSI introducer
-    //    Z     - legacy reverse tab
-    const revTabLegacy = new RegExp(`^${ESC}\\[Z`);
-    let m = buffer.match(revTabLegacy);
-    if (m) {
-        return {
-            key: {
-                name: 'tab',
-                ctrl: false,
-                meta: false,
-                shift: true,
-                paste: false,
-                sequence: buffer.slice(0, m[0].length),
-                kittyProtocol: false,
-            },
-            length: m[0].length,
-        };
-    }
-    // 1) Reverse Tab (parameterized): ESC [ 1 ; <mods> Z
-    //    Parameterized reverse Tab: ESC [ 1 ; <mods> Z
-    const revTabParam = new RegExp(`^${ESC}\\[1;(\\d+)Z`);
-    m = buffer.match(revTabParam);
-    if (m) {
-        let mods = parseInt(m[1], 10);
-        if (mods >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
-            mods -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
-        }
-        const bits = mods - KITTY_MODIFIER_BASE;
-        const alt = (bits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
-        const ctrl = (bits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
-        return {
-            key: {
-                name: 'tab',
-                ctrl,
-                meta: alt,
-                // Reverse tab implies Shift behavior; force shift regardless of mods
-                shift: true,
-                paste: false,
-                sequence: buffer.slice(0, m[0].length),
-                kittyProtocol: true,
-            },
-            length: m[0].length,
-        };
-    }
-    // 2) Parameterized functional: ESC [ 1 ; <mods> (A|B|C|D|H|F|P|Q|R|S)
-    // 2) Parameterized functional: ESC [ 1 ; <mods> (A|B|C|D|H|F|P|Q|R|S)
-    //    Arrows, Home/End, F1–F4 with modifiers encoded in <mods>.
-    const arrowPrefix = new RegExp(`^${ESC}\\[1;(\\d+)([ABCDHFPQSR])`);
-    m = buffer.match(arrowPrefix);
-    if (m) {
-        let mods = parseInt(m[1], 10);
-        if (mods >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
-            mods -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
+function nonKeyboardEventFilter(keypressHandler) {
+    return (key) => {
+        if (!parseMouseEvent(key.sequence) &&
+            key.sequence !== FOCUS_IN &&
+            key.sequence !== FOCUS_OUT) {
+            keypressHandler(key);
         }
-        const bits = mods - KITTY_MODIFIER_BASE;
-        const shift = (bits & MODIFIER_SHIFT_BIT) === MODIFIER_SHIFT_BIT;
-        const alt = (bits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
-        const ctrl = (bits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
-        const sym = m[2];
-        const name = LEGACY_FUNC_TO_NAME[sym] || '';
-        if (!name)
-            return null;
-        return {
-            key: {
-                name,
-                ctrl,
-                meta: alt,
-                shift,
-                paste: false,
-                sequence: buffer.slice(0, m[0].length),
-                kittyProtocol: true,
-            },
-            length: m[0].length,
-        };
-    }
-    // 3) CSI-u form: ESC [ <code> ; <mods> (u|~)
-    // 3) CSI-u and tilde-coded functional keys: ESC [ <code> ; <mods> (u|~)
-    //    'u' terminator: Kitty CSI-u; '~' terminator: tilde-coded function keys.
-    const csiUPrefix = new RegExp(`^${ESC}\\[(\\d+)(;(\\d+))?([u~])`);
-    m = buffer.match(csiUPrefix);
-    if (m) {
-        const keyCode = parseInt(m[1], 10);
-        let modifiers = m[3] ? parseInt(m[3], 10) : KITTY_MODIFIER_BASE;
-        if (modifiers >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
-            modifiers -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
-        }
-        const modifierBits = modifiers - KITTY_MODIFIER_BASE;
-        const shift = (modifierBits & MODIFIER_SHIFT_BIT) === MODIFIER_SHIFT_BIT;
-        const alt = (modifierBits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
-        const ctrl = (modifierBits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
-        const terminator = m[4];
-        // Tilde-coded functional keys (Delete, Insert, PageUp/Down, Home/End)
-        if (terminator === '~') {
-            const name = TILDE_KEYCODE_TO_NAME[keyCode];
-            if (name) {
-                return {
-                    key: {
-                        name,
-                        ctrl,
-                        meta: alt,
-                        shift,
-                        paste: false,
-                        sequence: buffer.slice(0, m[0].length),
-                        kittyProtocol: false,
-                    },
-                    length: m[0].length,
-                };
-            }
-        }
-        const kittyKeyCodeToName = {
-            [CHAR_CODE_ESC]: 'escape',
-            [KITTY_KEYCODE_TAB]: 'tab',
-            [KITTY_KEYCODE_BACKSPACE]: 'backspace',
-            [KITTY_KEYCODE_ENTER]: 'return',
-            [KITTY_KEYCODE_NUMPAD_ENTER]: 'return',
-        };
-        const name = kittyKeyCodeToName[keyCode];
-        if (name) {
-            return {
-                key: {
-                    name,
-                    ctrl,
-                    meta: alt,
-                    shift,
-                    paste: false,
-                    sequence: buffer.slice(0, m[0].length),
-                    kittyProtocol: true,
-                },
-                length: m[0].length,
-            };
-        }
-        // Ctrl+letters and Alt+letters
-        if ((ctrl || alt) &&
-            keyCode >= 'a'.charCodeAt(0) &&
-            keyCode <= 'z'.charCodeAt(0)) {
-            const letter = String.fromCharCode(keyCode);
-            return {
-                key: {
-                    name: letter,
-                    ctrl,
-                    meta: alt,
-                    shift,
-                    paste: false,
-                    sequence: buffer.slice(0, m[0].length),
-                    kittyProtocol: true,
-                },
-                length: m[0].length,
-            };
-        }
-    }
-    // 4) Legacy function keys (no parameters): ESC [ (A|B|C|D|H|F)
-    //    Arrows + Home/End without modifiers.
-    const legacyFuncKey = new RegExp(`^${ESC}\\[([ABCDHF])`);
-    m = buffer.match(legacyFuncKey);
-    if (m) {
-        const sym = m[1];
-        const name = LEGACY_FUNC_TO_NAME[sym];
-        return {
-            key: {
-                name,
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: buffer.slice(0, m[0].length),
-                kittyProtocol: false,
-            },
-            length: m[0].length,
-        };
-    }
-    return null;
+    };
 }
 /**
- * Returns the first index before which we are certain there is no paste marker.
+ * Buffers "/" keys to see if they are followed return.
+ * Will flush the buffer if no data is received for DRAG_COMPLETION_TIMEOUT_MS
+ * or when a null key is received.
  */
-function earliestPossiblePasteMarker(data) {
-    // Check data for full start-paste or end-paste markers.
-    const startIndex = data.indexOf(PASTE_MODE_START);
-    const endIndex = data.indexOf(PASTE_MODE_END);
-    if (startIndex !== -1 && endIndex !== -1) {
-        return Math.min(startIndex, endIndex);
-    }
-    else if (startIndex !== -1) {
-        return startIndex;
-    }
-    else if (endIndex !== -1) {
-        return endIndex;
-    }
-    // data contains no full start-paste or end-paste.
-    // Check if data ends with a prefix of start-paste or end-paste.
-    const codeLength = PASTE_MODE_START.length;
-    for (let i = Math.min(data.length, codeLength - 1); i > 0; i--) {
-        const candidate = data.slice(data.length - i);
-        if (PASTE_MODE_START.indexOf(candidate) === 0 ||
-            PASTE_MODE_END.indexOf(candidate) === 0) {
-            return data.length - i;
+function bufferBackslashEnter(keypressHandler) {
+    const bufferer = (function* () {
+        while (true) {
+            const key = yield;
+            if (key == null) {
+                continue;
+            }
+            else if (key.sequence !== '\\') {
+                keypressHandler(key);
+                continue;
+            }
+            const timeoutId = setTimeout(() => bufferer.next(null), BACKSLASH_ENTER_TIMEOUT);
+            const nextKey = yield;
+            clearTimeout(timeoutId);
+            if (nextKey === null) {
+                keypressHandler(key);
+            }
+            else if (nextKey.name === 'return') {
+                keypressHandler({
+                    ...nextKey,
+                    shift: true,
+                    sequence: '\r', // Corrected escaping for newline
+                });
+            }
+            else {
+                keypressHandler(key);
+                keypressHandler(nextKey);
+            }
         }
-    }
-    return data.length;
+    })();
+    bufferer.next(); // prime the generator so it starts listening.
+    return (key) => bufferer.next(key);
 }
 /**
- * A generator that takes in data chunks and spits out paste-start and
- * paste-end keypresses. All non-paste marker data is passed to passthrough.
+ * Buffers paste events between paste-start and paste-end sequences.
+ * Will flush the buffer if no data is received for PASTE_TIMEOUT ms or
+ * when a null key is received.
  */
-function* pasteMarkerParser(passthrough, keypressHandler) {
-    while (true) {
-        let data = yield;
-        if (data.length === 0) {
-            continue; // we timed out
-        }
+function bufferPaste(keypressHandler) {
+    const bufferer = (function* () {
         while (true) {
-            const index = earliestPossiblePasteMarker(data);
-            if (index === data.length) {
-                // no possible paste markers were found
-                passthrough.write(data);
-                break;
+            let key = yield;
+            if (key === null) {
+                continue;
             }
-            if (index > 0) {
-                // snip off and send the part that doesn't have a paste marker
-                passthrough.write(data.slice(0, index));
-                data = data.slice(index);
+            else if (key.name !== 'paste-start') {
+                keypressHandler(key);
+                continue;
             }
-            // data starts with a possible paste marker
-            const codeLength = PASTE_MODE_START.length;
-            if (data.length < codeLength) {
-                // we have a prefix. Concat the next data and try again.
-                const newData = yield;
-                if (newData.length === 0) {
-                    // we timed out. Just dump what we have and start over.
-                    passthrough.write(data);
+            let buffer = '';
+            while (true) {
+                const timeoutId = setTimeout(() => bufferer.next(null), PASTE_TIMEOUT);
+                key = yield;
+                clearTimeout(timeoutId);
+                if (key === null || key.name === 'paste-end') {
                     break;
                 }
-                data += newData;
+                buffer += key.sequence;
             }
-            else if (data.startsWith(PASTE_MODE_START)) {
-                keypressHandler(undefined, {
-                    name: 'paste-start',
+            if (buffer.length > 0) {
+                keypressHandler({
+                    name: '',
                     ctrl: false,
                     meta: false,
                     shift: false,
-                    paste: false,
-                    sequence: '',
+                    paste: true,
+                    sequence: buffer,
                 });
-                data = data.slice(PASTE_MODE_START.length);
             }
-            else if (data.startsWith(PASTE_MODE_END)) {
-                keypressHandler(undefined, {
-                    name: 'paste-end',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: '',
-                });
-                data = data.slice(PASTE_MODE_END.length);
+        }
+    })();
+    bufferer.next(); // prime the generator so it starts listening.
+    return (key) => bufferer.next(key);
+}
+/**
+ * Turns raw data strings into keypress events sent to the provided handler.
+ * Buffers escape sequences until a full sequence is received or
+ * until a timeout occurs.
+ */
+function createDataListener(keypressHandler) {
+    const parser = emitKeys(keypressHandler);
+    parser.next(); // prime the generator so it starts listening.
+    let timeoutId;
+    return (data) => {
+        clearTimeout(timeoutId);
+        for (const char of data) {
+            parser.next(char);
+        }
+        if (data.length !== 0) {
+            timeoutId = setTimeout(() => parser.next(''), ESC_TIMEOUT);
+        }
+    };
+}
+/**
+ * Translates raw keypress characters into key events.
+ * Buffers escape sequences until a full sequence is received or
+ * until an empty string is sent to indicate a timeout.
+ */
+function* emitKeys(keypressHandler) {
+    while (true) {
+        let ch = yield;
+        let sequence = ch;
+        let escaped = false;
+        let name = undefined;
+        let ctrl = false;
+        let meta = false;
+        let shift = false;
+        let code = undefined;
+        if (ch === ESC) {
+            escaped = true;
+            ch = yield;
+            sequence += ch;
+            if (ch === ESC) {
+                ch = yield;
+                sequence += ch;
+            }
+        }
+        if (escaped && (ch === 'O' || ch === '[')) {
+            // ANSI escape sequence
+            code = ch;
+            let modifier = 0;
+            if (ch === 'O') {
+                // ESC O letter
+                // ESC O modifier letter
+                ch = yield;
+                sequence += ch;
+                if (ch >= '0' && ch <= '9') {
+                    modifier = parseInt(ch, 10) - 1;
+                    ch = yield;
+                    sequence += ch;
+                }
+                code += ch;
+            }
+            else if (ch === '[') {
+                // ESC [ letter
+                // ESC [ modifier letter
+                // ESC [ [ modifier letter
+                // ESC [ [ num char
+                ch = yield;
+                sequence += ch;
+                if (ch === '[') {
+                    // \x1b[[A
+                    //      ^--- escape codes might have a second bracket
+                    code += ch;
+                    ch = yield;
+                    sequence += ch;
+                }
+                /*
+                 * Here and later we try to buffer just enough data to get
+                 * a complete ascii sequence.
+                 *
+                 * We have basically two classes of ascii characters to process:
+                 *
+                 *
+                 * 1. `\x1b[24;5~` should be parsed as { code: '[24~', modifier: 5 }
+                 *
+                 * This particular example is featuring Ctrl+F12 in xterm.
+                 *
+                 *  - `;5` part is optional, e.g. it could be `\x1b[24~`
+                 *  - first part can contain one or two digits
+                 *  - there is also special case when there can be 3 digits
+                 *    but without modifier. They are the case of paste bracket mode
+                 *
+                 * So the generic regexp is like /^(?:\d\d?(;\d)?[~^$]|\d{3}~)$/
+                 *
+                 *
+                 * 2. `\x1b[1;5H` should be parsed as { code: '[H', modifier: 5 }
+                 *
+                 * This particular example is featuring Ctrl+Home in xterm.
+                 *
+                 *  - `1;5` part is optional, e.g. it could be `\x1b[H`
+                 *  - `1;` part is optional, e.g. it could be `\x1b[5H`
+                 *
+                 * So the generic regexp is like /^((\d;)?\d)?[A-Za-z]$/
+                 *
+                 */
+                const cmdStart = sequence.length - 1;
+                // collect as many digits as possible
+                while (ch >= '0' && ch <= '9') {
+                    ch = yield;
+                    sequence += ch;
+                }
+                // skip modifier
+                if (ch === ';') {
+                    ch = yield;
+                    sequence += ch;
+                    // collect as many digits as possible
+                    while (ch >= '0' && ch <= '9') {
+                        ch = yield;
+                        sequence += ch;
+                    }
+                }
+                else if (ch === '<') {
+                    // SGR mouse mode
+                    ch = yield;
+                    sequence += ch;
+                    // Don't skip on empty string here to avoid timeouts on slow events.
+                    while (ch === '' || ch === ';' || (ch >= '0' && ch <= '9')) {
+                        ch = yield;
+                        sequence += ch;
+                    }
+                }
+                else if (ch === 'M') {
+                    // X11 mouse mode
+                    // three characters after 'M'
+                    ch = yield;
+                    sequence += ch;
+                    ch = yield;
+                    sequence += ch;
+                    ch = yield;
+                    sequence += ch;
+                }
+                /*
+                 * We buffered enough data, now trying to extract code
+                 * and modifier from it
+                 */
+                const cmd = sequence.slice(cmdStart);
+                let match;
+                if ((match = /^(\d+)(?:;(\d+))?([~^$u])$/.exec(cmd))) {
+                    code += match[1] + match[3];
+                    // Defaults to '1' if no modifier exists, resulting in a 0 modifier value
+                    modifier = parseInt(match[2] ?? '1', 10) - 1;
+                }
+                else if ((match = /^((\d;)?(\d))?([A-Za-z])$/.exec(cmd))) {
+                    code += match[4];
+                    modifier = parseInt(match[3] ?? '1', 10) - 1;
+                }
+                else {
+                    code += cmd;
+                }
+            }
+            // Parse the key modifier
+            ctrl = !!(modifier & 4);
+            meta = !!(modifier & 10); // use 10 to catch both alt (2) and meta (8).
+            shift = !!(modifier & 1);
+            const keyInfo = KEY_INFO_MAP[code];
+            if (keyInfo) {
+                name = keyInfo.name;
+                if (keyInfo.shift) {
+                    shift = true;
+                }
+                if (keyInfo.ctrl) {
+                    ctrl = true;
+                }
             }
             else {
-                // This should never happen.
-                passthrough.write(data);
-                break;
+                name = 'undefined';
+                if ((ctrl || meta) && (code.endsWith('u') || code.endsWith('~'))) {
+                    // CSI-u or tilde-coded functional keys: ESC [ <code> ; <mods> (u|~)
+                    const codeNumber = parseInt(code.slice(1, -1), 10);
+                    if (codeNumber >= 'a'.charCodeAt(0) &&
+                        codeNumber <= 'z'.charCodeAt(0)) {
+                        name = String.fromCharCode(codeNumber);
+                    }
+                }
             }
         }
+        else if (ch === '\r') {
+            // carriage return
+            name = 'return';
+            meta = escaped;
+        }
+        else if (ch === '\n') {
+            // Enter, should have been called linefeed
+            name = 'enter';
+            meta = escaped;
+        }
+        else if (ch === '\t') {
+            // tab
+            name = 'tab';
+            meta = escaped;
+        }
+        else if (ch === '\b' || ch === '\x7f') {
+            // backspace or ctrl+h
+            name = 'backspace';
+            meta = escaped;
+        }
+        else if (ch === ESC) {
+            // escape key
+            name = 'escape';
+            meta = escaped;
+        }
+        else if (ch === ' ') {
+            name = 'space';
+            meta = escaped;
+        }
+        else if (!escaped && ch <= '\x1a') {
+            // ctrl+letter
+            name = String.fromCharCode(ch.charCodeAt(0) + 'a'.charCodeAt(0) - 1);
+            ctrl = true;
+        }
+        else if (/^[0-9A-Za-z]$/.exec(ch) !== null) {
+            // Letter, number, shift+letter
+            name = ch.toLowerCase();
+            shift = /^[A-Z]$/.exec(ch) !== null;
+            meta = escaped;
+        }
+        else if (MAC_ALT_KEY_CHARACTER_MAP[ch] && process.platform === 'darwin') {
+            name = MAC_ALT_KEY_CHARACTER_MAP[ch];
+            meta = true;
+        }
+        else if (sequence === `${ESC}${ESC}`) {
+            // Double escape
+            name = 'escape';
+            meta = true;
+            // Emit first escape key here, then continue processing
+            keypressHandler({
+                name: 'escape',
+                ctrl,
+                meta,
+                shift,
+                paste: false,
+                sequence: ESC,
+            });
+        }
+        else if (escaped) {
+            // Escape sequence timeout
+            name = ch.length ? undefined : 'escape';
+            meta = true;
+        }
+        if ((sequence.length !== 0 && (name !== undefined || escaped)) ||
+            charLengthAt(sequence, 0) === sequence.length) {
+            keypressHandler({
+                name: name || '',
+                ctrl,
+                meta,
+                shift,
+                paste: false,
+                sequence,
+            });
+        }
+        // Unrecognized or broken escape sequence, don't emit anything
     }
 }
 const KeypressContext = createContext(undefined);
@@ -387,10 +466,7 @@ export function useKeypressContext() {
     }
     return context;
 }
-function shouldUsePassthrough() {
-    return process.env['PASTE_WORKAROUND'] !== 'false';
-}
-export function KeypressProvider({ children, kittyProtocolEnabled, config, debugKeystrokeLogging, }) {
+export function KeypressProvider({ children, config, debugKeystrokeLogging, }) {
     const { stdin, setRawMode } = useStdin();
     const subscribers = useRef(new Set()).current;
     const subscribe = useCallback((handler) => subscribers.add(handler), [subscribers]);
@@ -401,419 +477,34 @@ export function KeypressProvider({ children, kittyProtocolEnabled, config, debug
         if (wasRaw === false) {
             setRawMode(true);
         }
-        const keypressStream = shouldUsePassthrough() ? new PassThrough() : null;
-        // If non-null that means we are in paste mode
-        let pasteBuffer = null;
-        // Used to turn "\" quickly followed by a "enter" into a shift enter
-        let backslashTimeout = null;
-        // Buffers incomplete sequences (Kitty or Mouse) and timer to flush it
-        let inputBuffer = '';
-        let inputTimeout = null;
-        // Used to detect filename drag-and-drops.
-        let dragBuffer = '';
-        let draggingTimer = null;
-        const clearDraggingTimer = () => {
-            if (draggingTimer) {
-                clearTimeout(draggingTimer);
-                draggingTimer = null;
-            }
-        };
-        const flushInputBufferOnInterrupt = (reason) => {
-            if (inputBuffer) {
-                if (debugKeystrokeLogging) {
-                    debugLogger.log(`[DEBUG] Input sequence flushed due to ${reason}:`, JSON.stringify(inputBuffer));
-                }
-                broadcast({
-                    name: '',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: inputBuffer,
-                });
-                inputBuffer = '';
-            }
-            if (inputTimeout) {
-                clearTimeout(inputTimeout);
-                inputTimeout = null;
-            }
-        };
-        const handleKeypress = (_, key) => {
-            if (key.sequence === FOCUS_IN || key.sequence === FOCUS_OUT) {
-                flushInputBufferOnInterrupt('focus event');
-                return;
-            }
-            if (key.name === 'paste-start') {
-                flushInputBufferOnInterrupt('paste start');
-                pasteBuffer = Buffer.alloc(0);
-                return;
-            }
-            if (key.name === 'paste-end') {
-                if (pasteBuffer !== null) {
-                    broadcast({
-                        name: '',
-                        ctrl: false,
-                        meta: false,
-                        shift: false,
-                        paste: true,
-                        sequence: pasteBuffer.toString(),
-                    });
-                }
-                pasteBuffer = null;
-                return;
-            }
-            if (pasteBuffer !== null) {
-                pasteBuffer = Buffer.concat([pasteBuffer, Buffer.from(key.sequence)]);
-                return;
-            }
-            if (key.sequence === SINGLE_QUOTE ||
-                key.sequence === DOUBLE_QUOTE ||
-                draggingTimer !== null) {
-                dragBuffer += key.sequence;
-                clearDraggingTimer();
-                draggingTimer = setTimeout(() => {
-                    draggingTimer = null;
-                    const seq = dragBuffer;
-                    dragBuffer = '';
-                    if (seq) {
-                        broadcast({ ...key, name: '', paste: true, sequence: seq });
-                    }
-                }, DRAG_COMPLETION_TIMEOUT_MS);
-                return;
-            }
-            const mappedLetter = MAC_ALT_KEY_CHARACTER_MAP[key.sequence];
-            if (process.platform === 'darwin' && mappedLetter && !key.meta) {
-                broadcast({
-                    name: mappedLetter,
-                    ctrl: false,
-                    meta: true,
-                    shift: false,
-                    paste: pasteBuffer !== null,
-                    sequence: key.sequence,
-                });
-                return;
-            }
-            if (key.name === 'return' && backslashTimeout !== null) {
-                clearTimeout(backslashTimeout);
-                backslashTimeout = null;
-                broadcast({
-                    ...key,
-                    shift: true,
-                    sequence: '\r', // Corrected escaping for newline
-                });
-                return;
-            }
-            if (key.sequence === '\\' && !key.name) {
-                // Corrected escaping for backslash
-                backslashTimeout = setTimeout(() => {
-                    backslashTimeout = null;
-                    broadcast(key);
-                }, BACKSLASH_ENTER_DETECTION_WINDOW_MS);
-                return;
-            }
-            if (backslashTimeout !== null && key.name !== 'return') {
-                clearTimeout(backslashTimeout);
-                backslashTimeout = null;
-                broadcast({
-                    name: '',
-                    sequence: '\\',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                });
-            }
-            if (['up', 'down', 'left', 'right'].includes(key.name)) {
-                broadcast(key);
-                return;
-            }
-            if ((key.ctrl && key.name === 'c') ||
-                key.sequence === `${ESC}${KITTY_CTRL_C}`) {
-                if (inputBuffer && debugKeystrokeLogging) {
-                    debugLogger.log('[DEBUG] Input buffer cleared on Ctrl+C:', inputBuffer);
-                }
-                inputBuffer = '';
-                if (inputTimeout) {
-                    clearTimeout(inputTimeout);
-                    inputTimeout = null;
-                }
-                if (key.sequence === `${ESC}${KITTY_CTRL_C}`) {
-                    broadcast({
-                        name: 'c',
-                        ctrl: true,
-                        meta: false,
-                        shift: false,
-                        paste: false,
-                        sequence: key.sequence,
-                        kittyProtocol: true,
-                    });
-                }
-                else {
-                    broadcast(key);
-                }
-                return;
-            }
-            // Clear any pending timeout when new input arrives
-            if (inputTimeout) {
-                clearTimeout(inputTimeout);
-                inputTimeout = null;
-            }
-            // Always check if this could start a sequence we need to buffer (Kitty or Mouse)
-            // Other ESC sequences (like Alt+Key which is ESC+Key) should be let through if readline parsed them.
-            const shouldBuffer = couldBeKittySequence(key.sequence);
-            const isExcluded = [
-                PASTE_MODE_START,
-                PASTE_MODE_END,
-                FOCUS_IN,
-                FOCUS_OUT,
-            ].some((prefix) => key.sequence.startsWith(prefix));
-            if (inputBuffer || (shouldBuffer && !isExcluded)) {
-                inputBuffer += key.sequence;
-                if (debugKeystrokeLogging && !couldBeMouseSequence(inputBuffer)) {
-                    debugLogger.log('[DEBUG] Input buffer accumulating:', JSON.stringify(inputBuffer));
+        process.stdin.setEncoding('utf8'); // Make data events emit strings
+        const mouseFilterer = nonKeyboardEventFilter(broadcast);
+        const backslashBufferer = bufferBackslashEnter(mouseFilterer);
+        const pasteBufferer = bufferPaste(backslashBufferer);
+        let dataListener = createDataListener(pasteBufferer);
+        if (debugKeystrokeLogging) {
+            const old = dataListener;
+            dataListener = (data) => {
+                if (data.length > 0) {
+                    debugLogger.log(`[DEBUG] Raw StdIn: ${JSON.stringify(data)}`);
                 }
-                // Try immediate parsing
-                let remainingBuffer = inputBuffer;
-                let parsedAny = false;
-                while (remainingBuffer) {
-                    const parsed = parseKittyPrefix(remainingBuffer);
-                    if (parsed) {
-                        // If kitty protocol is disabled, only allow legacy/standard sequences.
-                        // parseKittyPrefix returns true for kittyProtocol if it's a modern kitty sequence.
-                        if (kittyProtocolEnabled || !parsed.key.kittyProtocol) {
-                            if (debugKeystrokeLogging) {
-                                const parsedSequence = remainingBuffer.slice(0, parsed.length);
-                                debugLogger.log('[DEBUG] Sequence parsed successfully:', JSON.stringify(parsedSequence));
-                            }
-                            broadcast(parsed.key);
-                            remainingBuffer = remainingBuffer.slice(parsed.length);
-                            parsedAny = true;
-                            continue;
-                        }
-                    }
-                    const mouseParsed = parseMouseEvent(remainingBuffer);
-                    if (mouseParsed) {
-                        // These are handled by the separate mouse sequence parser.
-                        // All we need to do is make sure we don't get confused by these
-                        // sequences.
-                        remainingBuffer = remainingBuffer.slice(mouseParsed.length);
-                        parsedAny = true;
-                        continue;
-                    }
-                    // If we can't parse a sequence at the start, check if there's
-                    // another ESC later in the buffer. If so, the data before it
-                    // is garbage/incomplete and should be dropped so we can
-                    // process the next sequence.
-                    const nextEscIndex = remainingBuffer.indexOf(ESC, 1);
-                    if (nextEscIndex !== -1) {
-                        const garbage = remainingBuffer.slice(0, nextEscIndex);
-                        // Special case: if garbage is exactly ESC, it's likely a rapid ESC press.
-                        if (garbage === ESC) {
-                            if (debugKeystrokeLogging) {
-                                debugLogger.log('[DEBUG] Flushing rapid ESC before next ESC:', JSON.stringify(garbage));
-                            }
-                            broadcast({
-                                name: 'escape',
-                                ctrl: false,
-                                meta: true,
-                                shift: false,
-                                paste: false,
-                                sequence: garbage,
-                            });
-                        }
-                        else {
-                            if (debugKeystrokeLogging) {
-                                debugLogger.log('[DEBUG] Dropping incomplete sequence before next ESC:', JSON.stringify(garbage));
-                            }
-                        }
-                        // Continue parsing from next ESC
-                        remainingBuffer = remainingBuffer.slice(nextEscIndex);
-                        // We made progress, so we can continue the loop to parse the next sequence
-                        continue;
-                    }
-                    // Check if buffer could become a valid sequence
-                    const couldBeValidKitty = kittyProtocolEnabled && couldBeKittySequence(remainingBuffer);
-                    const isMouse = isIncompleteMouseSequence(remainingBuffer);
-                    const couldBeValid = couldBeValidKitty || isMouse;
-                    if (!couldBeValid) {
-                        // Not a valid sequence - flush as regular input immediately
-                        if (debugKeystrokeLogging) {
-                            debugLogger.log('[DEBUG] Not a valid sequence, flushing:', JSON.stringify(remainingBuffer));
-                        }
-                        broadcast({
-                            name: '',
-                            ctrl: false,
-                            meta: false,
-                            shift: false,
-                            paste: false,
-                            sequence: remainingBuffer,
-                        });
-                        remainingBuffer = '';
-                        parsedAny = true;
-                    }
-                    else if (remainingBuffer.length > MAX_KITTY_SEQUENCE_LENGTH) {
-                        // Buffer overflow - log and clear
-                        if (debugKeystrokeLogging) {
-                            debugLogger.log('[DEBUG] Input buffer overflow, clearing:', JSON.stringify(remainingBuffer));
-                        }
-                        if (config && kittyProtocolEnabled) {
-                            const event = new KittySequenceOverflowEvent(remainingBuffer.length, remainingBuffer);
-                            logKittySequenceOverflow(config, event);
-                        }
-                        // Flush as regular input
-                        broadcast({
-                            name: '',
-                            ctrl: false,
-                            meta: false,
-                            shift: false,
-                            paste: false,
-                            sequence: remainingBuffer,
-                        });
-                        remainingBuffer = '';
-                        parsedAny = true;
-                    }
-                    else {
-                        if ((config?.getDebugMode() || debugKeystrokeLogging) &&
-                            !couldBeMouseSequence(inputBuffer)) {
-                            debugLogger.warn('Input sequence buffer has content:', JSON.stringify(inputBuffer));
-                        }
-                        // Could be valid but incomplete - set timeout
-                        // Only set timeout if it's NOT a mouse sequence.
-                        // Mouse sequences might be slow (e.g. over network) and we don't want to
-                        // flush them as garbage keypresses.
-                        // However, if it's just ESC or ESC[, it might be a user typing slowly,
-                        // so we should still timeout in that case.
-                        const isAmbiguousPrefix = remainingBuffer === ESC || remainingBuffer === `${ESC}[`;
-                        if (!isMouse || isAmbiguousPrefix) {
-                            inputTimeout = setTimeout(() => {
-                                if (inputBuffer) {
-                                    if (debugKeystrokeLogging) {
-                                        debugLogger.log('[DEBUG] Input sequence timeout, flushing:', JSON.stringify(inputBuffer));
-                                    }
-                                    const isEscape = inputBuffer === ESC;
-                                    broadcast({
-                                        name: isEscape ? 'escape' : '',
-                                        ctrl: false,
-                                        meta: isEscape,
-                                        shift: false,
-                                        paste: false,
-                                        sequence: inputBuffer,
-                                    });
-                                    inputBuffer = '';
-                                }
-                                inputTimeout = null;
-                            }, KITTY_SEQUENCE_TIMEOUT_MS);
-                        }
-                        else {
-                            // It IS a mouse sequence and it's long enough to be unambiguously NOT just a user hitting ESC slowly.
-                            // We just wait for more data.
-                            if (inputTimeout) {
-                                clearTimeout(inputTimeout);
-                                inputTimeout = null;
-                            }
-                        }
-                        break;
-                    }
-                }
-                inputBuffer = remainingBuffer;
-                if (parsedAny || inputBuffer)
-                    return;
-            }
-            if (key.name === 'return' && key.sequence === `${ESC}\r`) {
-                key.meta = true;
-            }
-            broadcast({ ...key, paste: pasteBuffer !== null });
-        };
-        let cleanup = () => { };
-        let rl;
-        if (keypressStream !== null) {
-            rl = readline.createInterface({
-                input: keypressStream,
-                escapeCodeTimeout: 0,
-            });
-            readline.emitKeypressEvents(keypressStream, rl);
-            const parser = pasteMarkerParser(keypressStream, handleKeypress);
-            parser.next(); // prime the generator so it starts listening.
-            let timeoutId;
-            const handleRawKeypress = (data) => {
-                clearTimeout(timeoutId);
-                parser.next(data);
-                timeoutId = setTimeout(() => parser.next(''), PASTE_CODE_TIMEOUT_MS);
+                old(data);
             };
-            keypressStream.on('keypress', handleKeypress);
-            process.stdin.setEncoding('utf8'); // so handleRawKeypress gets strings
-            stdin.on('data', handleRawKeypress);
-            cleanup = () => {
-                keypressStream.removeListener('keypress', handleKeypress);
-                stdin.removeListener('data', handleRawKeypress);
-            };
-        }
-        else {
-            rl = readline.createInterface({ input: stdin, escapeCodeTimeout: 0 });
-            readline.emitKeypressEvents(stdin, rl);
-            stdin.on('keypress', handleKeypress);
-            cleanup = () => stdin.removeListener('keypress', handleKeypress);
         }
+        stdin.on('data', dataListener);
         return () => {
-            cleanup();
-            rl.close();
+            // flush buffers by sending null key
+            backslashBufferer(null);
+            pasteBufferer(null);
+            // flush by sending empty string to the data listener
+            dataListener('');
+            stdin.removeListener('data', dataListener);
             // Restore the terminal to its original state.
             if (wasRaw === false) {
                 setRawMode(false);
             }
-            if (backslashTimeout) {
-                clearTimeout(backslashTimeout);
-                backslashTimeout = null;
-            }
-            if (inputTimeout) {
-                clearTimeout(inputTimeout);
-                inputTimeout = null;
-            }
-            // Flush any pending kitty sequence data to avoid data loss on exit.
-            if (inputBuffer) {
-                broadcast({
-                    name: '',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: false,
-                    sequence: inputBuffer,
-                });
-                inputBuffer = '';
-            }
-            // Flush any pending paste data to avoid data loss on exit.
-            if (pasteBuffer !== null) {
-                broadcast({
-                    name: '',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: true,
-                    sequence: pasteBuffer.toString(),
-                });
-                pasteBuffer = null;
-            }
-            clearDraggingTimer();
-            if (dragBuffer) {
-                broadcast({
-                    name: '',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    paste: true,
-                    sequence: dragBuffer,
-                });
-                dragBuffer = '';
-            }
         };
-    }, [
-        stdin,
-        setRawMode,
-        kittyProtocolEnabled,
-        config,
-        debugKeystrokeLogging,
-        broadcast,
-    ]);
+    }, [stdin, setRawMode, config, debugKeystrokeLogging, broadcast]);
     return (_jsx(KeypressContext.Provider, { value: { subscribe, unsubscribe }, children: children }));
 }
 //# sourceMappingURL=KeypressContext.js.map