takt 0.35.3 → 0.36.0

package/dist/features/interactive/lineEditor.js

@@ -9,6 +9,7 @@
 import * as readline from 'node:readline';
 import { StringDecoder } from 'node:string_decoder';
 import { stripAnsi, getDisplayWidth } from '../../shared/utils/text.js';
+import { createCompletionController } from './completionController.js';
 /** Escape sequences for terminal protocol control */
 const PASTE_BRACKET_ENABLE = '\x1B[?2004h';
 const PASTE_BRACKET_DISABLE = '\x1B[?2004l';
@@ -57,6 +58,99 @@ function decodeCtrlKey(rest) {
     const controlCode = upper.charCodeAt(0) & 0x1f;
     return { ch: String.fromCharCode(controlCode), consumed: xtermMatch[0].length };
 }
+/**
+ * Try to consume an escape sequence starting after the leading \x1B.
+ *
+ * Returns the number of characters consumed (excluding the \x1B itself),
+ * or -1 if the rest is a potential incomplete CSI/SS3 prefix that needs
+ * more data, or 0 if the \x1B is a bare Esc.
+ */
+const tryConsumeEscapeSequence = (rest, callbacks) => {
+    if (rest.startsWith(ESC_PASTE_START)) {
+        callbacks.onPasteStart();
+        return ESC_PASTE_START.length;
+    }
+    if (rest.startsWith(ESC_PASTE_END)) {
+        callbacks.onPasteEnd();
+        return ESC_PASTE_END.length;
+    }
+    if (rest.startsWith(ESC_SHIFT_ENTER)) {
+        callbacks.onShiftEnter();
+        return ESC_SHIFT_ENTER.length;
+    }
+    const ctrlKey = decodeCtrlKey(rest);
+    if (ctrlKey) {
+        callbacks.onChar(ctrlKey.ch);
+        return ctrlKey.consumed;
+    }
+    // Arrow keys
+    if (rest.startsWith('[D')) {
+        callbacks.onArrowLeft();
+        return 2;
+    }
+    if (rest.startsWith('[C')) {
+        callbacks.onArrowRight();
+        return 2;
+    }
+    if (rest.startsWith('[A')) {
+        callbacks.onArrowUp();
+        return 2;
+    }
+    if (rest.startsWith('[B')) {
+        callbacks.onArrowDown();
+        return 2;
+    }
+    // Option+Arrow (CSI modified): \x1B[1;3D (left), \x1B[1;3C (right)
+    if (rest.startsWith('[1;3D')) {
+        callbacks.onWordLeft();
+        return 5;
+    }
+    if (rest.startsWith('[1;3C')) {
+        callbacks.onWordRight();
+        return 5;
+    }
+    // Option+Arrow (SS3/alt): \x1Bb (left), \x1Bf (right)
+    if (rest.startsWith('b')) {
+        callbacks.onWordLeft();
+        return 1;
+    }
+    if (rest.startsWith('f')) {
+        callbacks.onWordRight();
+        return 1;
+    }
+    // Home: \x1B[H (CSI) or \x1BOH (SS3/application mode)
+    if (rest.startsWith('[H') || rest.startsWith('OH')) {
+        callbacks.onHome();
+        return 2;
+    }
+    // End: \x1B[F (CSI) or \x1BOF (SS3/application mode)
+    if (rest.startsWith('[F') || rest.startsWith('OF')) {
+        callbacks.onEnd();
+        return 2;
+    }
+    // Kitty keyboard protocol: ESC key → \x1B[27u or \x1B[27;1u
+    const kittyEscMatch = rest.match(/^\[27(?:;1)?u/);
+    if (kittyEscMatch) {
+        callbacks.onEsc();
+        return kittyEscMatch[0].length;
+    }
+    // Unknown CSI sequences: skip
+    if (rest.startsWith('[')) {
+        const csiMatch = rest.match(/^\[[0-9;]*[A-Za-z~]/);
+        if (csiMatch)
+            return csiMatch[0].length;
+        // Incomplete CSI — need more data
+        return -1;
+    }
+    // SS3 prefix ('O') without a recognized follower — could be incomplete
+    if (rest.startsWith('O') && rest.length === 1)
+        return -1;
+    // Bare Esc (followed by a non-sequence character or nothing)
+    if (rest.length === 0)
+        return -1;
+    callbacks.onEsc();
+    return 0;
+};
 /**
  * Parse raw stdin data into semantic input events.
  *
@@ -69,111 +163,88 @@ export function parseInputData(data, callbacks) {
         const ch = data[i];
         if (ch === '\x1B') {
             const rest = data.slice(i + 1);
-            if (rest.startsWith(ESC_PASTE_START)) {
-                callbacks.onPasteStart();
-                i += 1 + ESC_PASTE_START.length;
-                continue;
-            }
-            if (rest.startsWith(ESC_PASTE_END)) {
-                callbacks.onPasteEnd();
-                i += 1 + ESC_PASTE_END.length;
-                continue;
-            }
-            if (rest.startsWith(ESC_SHIFT_ENTER)) {
-                callbacks.onShiftEnter();
-                i += 1 + ESC_SHIFT_ENTER.length;
-                continue;
-            }
-            const ctrlKey = decodeCtrlKey(rest);
-            if (ctrlKey) {
-                callbacks.onChar(ctrlKey.ch);
-                i += 1 + ctrlKey.consumed;
-                continue;
-            }
-            // Arrow keys
-            if (rest.startsWith('[D')) {
-                callbacks.onArrowLeft();
-                i += 3;
-                continue;
-            }
-            if (rest.startsWith('[C')) {
-                callbacks.onArrowRight();
-                i += 3;
-                continue;
-            }
-            if (rest.startsWith('[A')) {
-                callbacks.onArrowUp();
-                i += 3;
+            const consumed = tryConsumeEscapeSequence(rest, callbacks);
+            if (consumed === -1) {
+                // Incomplete escape sequence at end of chunk — treat as bare Esc
+                callbacks.onEsc();
+                i++;
                 continue;
             }
-            if (rest.startsWith('[B')) {
-                callbacks.onArrowDown();
-                i += 3;
-                continue;
-            }
-            // Option+Arrow (CSI modified): \x1B[1;3D (left), \x1B[1;3C (right)
-            if (rest.startsWith('[1;3D')) {
-                callbacks.onWordLeft();
-                i += 6;
-                continue;
-            }
-            if (rest.startsWith('[1;3C')) {
-                callbacks.onWordRight();
-                i += 6;
-                continue;
-            }
-            // Option+Arrow (SS3/alt): \x1Bb (left), \x1Bf (right)
-            if (rest.startsWith('b')) {
-                callbacks.onWordLeft();
-                i += 2;
-                continue;
-            }
-            if (rest.startsWith('f')) {
-                callbacks.onWordRight();
-                i += 2;
-                continue;
-            }
-            // Home: \x1B[H (CSI) or \x1BOH (SS3/application mode)
-            if (rest.startsWith('[H') || rest.startsWith('OH')) {
-                callbacks.onHome();
-                i += 3;
-                continue;
-            }
-            // End: \x1B[F (CSI) or \x1BOF (SS3/application mode)
-            if (rest.startsWith('[F') || rest.startsWith('OF')) {
-                callbacks.onEnd();
-                i += 3;
-                continue;
-            }
-            // Unknown CSI sequences: skip
-            if (rest.startsWith('[')) {
-                const csiMatch = rest.match(/^\[[0-9;]*[A-Za-z~]/);
-                if (csiMatch) {
-                    i += 1 + csiMatch[0].length;
-                    continue;
-                }
-            }
-            // Unrecognized escape: skip the \x1B
-            i++;
+            i += 1 + consumed;
             continue;
         }
         callbacks.onChar(ch);
         i++;
     }
 }
+const ESC_AMBIGUITY_TIMEOUT_MS = 50;
+/**
+ * Stateful escape sequence parser for chunked stdin input.
+ *
+ * Holds an incomplete trailing \x1B across chunks and resolves it
+ * when the next chunk arrives or after a timeout.
+ */
+export const createEscapeParser = (callbacks) => {
+    let pendingFragment = '';
+    let escTimer = null;
+    const clearEscTimer = () => {
+        if (escTimer !== null) {
+            clearTimeout(escTimer);
+            escTimer = null;
+        }
+    };
+    const flush = () => {
+        clearEscTimer();
+        if (pendingFragment.length > 0) {
+            pendingFragment = '';
+            callbacks.onEsc();
+        }
+    };
+    const feed = (data) => {
+        let input = data;
+        if (pendingFragment.length > 0) {
+            clearEscTimer();
+            input = `${pendingFragment}${input}`;
+            pendingFragment = '';
+        }
+        let i = 0;
+        while (i < input.length) {
+            const ch = input[i];
+            if (ch === '\x1B') {
+                const rest = input.slice(i + 1);
+                if (rest.length === 0) {
+                    pendingFragment = '\x1B';
+                    escTimer = setTimeout(flush, ESC_AMBIGUITY_TIMEOUT_MS);
+                    return;
+                }
+                const consumed = tryConsumeEscapeSequence(rest, callbacks);
+                if (consumed === -1) {
+                    pendingFragment = input.slice(i);
+                    escTimer = setTimeout(flush, ESC_AMBIGUITY_TIMEOUT_MS);
+                    return;
+                }
+                i += 1 + consumed;
+                continue;
+            }
+            callbacks.onChar(ch);
+            i++;
+        }
+    };
+    return { feed, flush };
+};
 /**
  * Read multiline input from the user using raw mode with cursor management.
  *
  * Supports:
  * - Enter to submit, Shift+Enter to insert newline
  * - Paste bracket mode for pasted text with newlines
- * - Left/Right arrows, Home/End for cursor movement
+ * - Left/Right arrows, Home/End for cursor navigation
  * - Ctrl+A/E (line start/end), Ctrl+K/U (kill line), Ctrl+W (delete word)
  * - Backspace / Ctrl+H, Ctrl+C / Ctrl+D (cancel)
  *
  * Falls back to readline.question() in non-TTY environments.
  */
-export function readMultilineInput(prompt) {
+export function readMultilineInput(prompt, options) {
     if (!process.stdin.isTTY) {
         return new Promise((resolve) => {
             if (process.stdin.readable && !process.stdin.destroyed) {
@@ -250,6 +321,50 @@ export function readMultilineInput(prompt) {
         function getTermWidth() {
             return process.stdout.columns || 80;
         }
+        // --- Completion menu helpers ---
+        /**
+         * Count display rows between two arbitrary buffer positions.
+         */
+        function countDisplayRowsAcrossLines(from, to) {
+            if (from >= to)
+                return 0;
+            let rows = 0;
+            let pos = from;
+            while (pos < to) {
+                const rowEnd = getDisplayRowEnd(pos);
+                if (rowEnd >= to)
+                    break;
+                const nextChar = buffer[rowEnd];
+                if (nextChar === '\n') {
+                    rows++;
+                    pos = rowEnd + 1;
+                }
+                else {
+                    rows++;
+                    pos = rowEnd;
+                }
+            }
+            return rows;
+        }
+        /**
+         * Count display rows from cursor position to end of buffer.
+         */
+        function countRowsBelowCursor() {
+            const cursorRow = countDisplayRowsAcrossLines(0, cursorPos);
+            const totalRows = countDisplayRowsAcrossLines(0, buffer.length);
+            return totalRows - cursorRow;
+        }
+        const completion = createCompletionController({
+            getBuffer: () => buffer,
+            getCursorPos: () => cursorPos,
+            getTermWidth,
+            getTerminalColumn,
+            countRowsBelowCursor,
+            getCursorRow: () => countDisplayRowsAcrossLines(0, cursorPos),
+        }, {
+            setBuffer: (v) => { buffer = v; },
+            setCursorPos: (v) => { cursorPos = v; },
+        }, promptWidth, options?.completionProvider);
         /** Buffer position of the display row start that contains `pos` */
         function getDisplayRowStart(pos) {
             const logicalStart = getLineStartAt(pos);
@@ -339,13 +454,15 @@ export function readMultilineInput(prompt) {
             }
         }
         function cleanup() {
+            escParser.flush();
+            completion.hide();
             process.stdin.removeListener('data', onData);
             process.stdout.write(PASTE_BRACKET_DISABLE);
             process.stdout.write(KITTY_KB_DISABLE);
             process.stdin.setRawMode(wasRaw ?? false);
             process.stdin.pause();
         }
-        // --- Cursor movement ---
+        // --- Cursor navigation ---
         function moveCursorToDisplayRowStart() {
             const displayRowStart = getDisplayRowStart(cursorPos);
             const displayOffset = getDisplayRowColumn(cursorPos);
@@ -369,28 +486,11 @@ export function readMultilineInput(prompt) {
             process.stdout.write(`\x1B[${direction}`);
             process.stdout.write(`\x1B[${termCol}G`);
         }
-        /** Count how many display rows lie between two buffer positions in the same logical line */
-        function countDisplayRowsBetween(from, to) {
-            if (from === to)
-                return 0;
-            const start = Math.min(from, to);
-            const end = Math.max(from, to);
-            let count = 0;
-            let pos = start;
-            while (pos < end) {
-                const nextRowStart = getDisplayRowEnd(pos);
-                if (nextRowStart >= end)
-                    break;
-                pos = nextRowStart;
-                count++;
-            }
-            return count;
-        }
         function moveCursorToLogicalLineStart() {
             const lineStart = getLineStart();
             if (cursorPos === lineStart)
                 return;
-            const rowDiff = countDisplayRowsBetween(lineStart, cursorPos);
+            const rowDiff = countDisplayRowsAcrossLines(lineStart, cursorPos);
             cursorPos = lineStart;
             if (rowDiff > 0) {
                 process.stdout.write(`\x1B[${rowDiff}A`);
@@ -402,7 +502,7 @@ export function readMultilineInput(prompt) {
             const lineEnd = getLineEnd();
             if (cursorPos === lineEnd)
                 return;
-            const rowDiff = countDisplayRowsBetween(cursorPos, lineEnd);
+            const rowDiff = countDisplayRowsAcrossLines(cursorPos, lineEnd);
             cursorPos = lineEnd;
             if (rowDiff > 0) {
                 process.stdout.write(`\x1B[${rowDiff}B`);
@@ -485,193 +585,248 @@ export function readMultilineInput(prompt) {
         }
         // --- Input dispatch ---
         const utf8Decoder = new StringDecoder('utf8');
+        const escParser = createEscapeParser({
+            onPasteStart() { state = 'paste'; completion.hide(); },
+            onPasteEnd() {
+                state = 'normal';
+                rerenderFromCursor();
+            },
+            onShiftEnter() { completion.hide(); insertNewline(); },
+            onArrowLeft() {
+                if (state !== 'normal')
+                    return;
+                const previousCursorPos = cursorPos;
+                if (cursorPos > getLineStart()) {
+                    const len = charLengthBefore(cursorPos);
+                    const charWidth = getDisplayWidth(buffer.slice(cursorPos - len, cursorPos));
+                    cursorPos -= len;
+                    process.stdout.write(`\x1B[${charWidth}D`);
+                }
+                else if (getLineStart() > 0) {
+                    cursorPos = getLineStart() - 1;
+                    const col = getTerminalColumn(cursorPos);
+                    process.stdout.write('\x1B[A');
+                    process.stdout.write(`\x1B[${col}G`);
+                }
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onArrowRight() {
+                if (state !== 'normal')
+                    return;
+                const previousCursorPos = cursorPos;
+                if (cursorPos < getLineEnd()) {
+                    const len = charLengthAt(cursorPos);
+                    const charWidth = getDisplayWidth(buffer.slice(cursorPos, cursorPos + len));
+                    cursorPos += len;
+                    process.stdout.write(`\x1B[${charWidth}C`);
+                }
+                else if (cursorPos < buffer.length && buffer[cursorPos] === '\n') {
+                    cursorPos++;
+                    const col = getTerminalColumn(cursorPos);
+                    process.stdout.write('\x1B[B');
+                    process.stdout.write(`\x1B[${col}G`);
+                }
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onArrowUp() {
+                if (state !== 'normal')
+                    return;
+                if (completion.getState()) {
+                    completion.moveSelection(-1);
+                    return;
+                }
+                const previousCursorPos = cursorPos;
+                const logicalLineStart = getLineStart();
+                const displayRowStart = getDisplayRowStart(cursorPos);
+                const displayCol = getDisplayRowColumn(cursorPos);
+                if (displayRowStart > logicalLineStart) {
+                    // Move to previous display row within the same logical line
+                    const prevRowStart = getDisplayRowStart(displayRowStart - 1);
+                    const prevRowEnd = getDisplayRowEnd(displayRowStart - 1);
+                    moveCursorToDisplayRow(prevRowStart, prevRowEnd, displayCol, 'A');
+                }
+                else if (logicalLineStart > 0) {
+                    // Move to the last display row of the previous logical line
+                    const prevLogicalLineEnd = logicalLineStart - 1;
+                    const prevRowStart = getDisplayRowStart(prevLogicalLineEnd);
+                    const prevRowEnd = getDisplayRowEnd(prevLogicalLineEnd);
+                    moveCursorToDisplayRow(prevRowStart, prevRowEnd, displayCol, 'A');
+                }
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onArrowDown() {
+                if (state !== 'normal')
+                    return;
+                if (completion.getState()) {
+                    completion.moveSelection(1);
+                    return;
+                }
+                const previousCursorPos = cursorPos;
+                const logicalLineEnd = getLineEnd();
+                const displayRowEnd = getDisplayRowEnd(cursorPos);
+                const displayCol = getDisplayRowColumn(cursorPos);
+                if (displayRowEnd < logicalLineEnd) {
+                    // Move to next display row within the same logical line
+                    const nextRowStart = displayRowEnd;
+                    const nextRowEnd = getDisplayRowEnd(displayRowEnd);
+                    moveCursorToDisplayRow(nextRowStart, nextRowEnd, displayCol, 'B');
+                }
+                else if (logicalLineEnd < buffer.length) {
+                    // Move to the first display row of the next logical line
+                    const nextLineStart = logicalLineEnd + 1;
+                    const nextRowEnd = getDisplayRowEnd(nextLineStart);
+                    moveCursorToDisplayRow(nextLineStart, nextRowEnd, displayCol, 'B');
+                }
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onWordLeft() {
+                if (state !== 'normal')
+                    return;
+                const previousCursorPos = cursorPos;
+                const lineStart = getLineStart();
+                if (cursorPos <= lineStart)
+                    return;
+                let pos = cursorPos;
+                while (pos > lineStart && buffer[pos - 1] === ' ')
+                    pos--;
+                while (pos > lineStart && buffer[pos - 1] !== ' ')
+                    pos--;
+                const moveWidth = getDisplayWidth(buffer.slice(pos, cursorPos));
+                cursorPos = pos;
+                process.stdout.write(`\x1B[${moveWidth}D`);
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onWordRight() {
+                if (state !== 'normal')
+                    return;
+                const previousCursorPos = cursorPos;
+                const lineEnd = getLineEnd();
+                if (cursorPos >= lineEnd)
+                    return;
+                let pos = cursorPos;
+                while (pos < lineEnd && buffer[pos] !== ' ')
+                    pos++;
+                while (pos < lineEnd && buffer[pos] === ' ')
+                    pos++;
+                const moveWidth = getDisplayWidth(buffer.slice(cursorPos, pos));
+                cursorPos = pos;
+                process.stdout.write(`\x1B[${moveWidth}C`);
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onHome() {
+                if (state !== 'normal')
+                    return;
+                const previousCursorPos = cursorPos;
+                moveCursorToLogicalLineStart();
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onEnd() {
+                if (state !== 'normal')
+                    return;
+                const previousCursorPos = cursorPos;
+                moveCursorToLogicalLineEnd();
+                if (cursorPos !== previousCursorPos)
+                    completion.update();
+            },
+            onEsc() {
+                completion.hide();
+            },
+            onChar(ch) {
+                if (state === 'paste') {
+                    if (ch === '\r' || ch === '\n') {
+                        insertAt(cursorPos, '\n');
+                        cursorPos++;
+                        process.stdout.write('\n');
+                    }
+                    else {
+                        insertAt(cursorPos, ch);
+                        cursorPos++;
+                        process.stdout.write(ch);
+                    }
+                    return;
+                }
+                if (ch === '\t') {
+                    if (completion.getState()) {
+                        completion.apply();
+                    }
+                    return;
+                }
+                // Submit
+                if (ch === '\r') {
+                    completion.acceptSelection();
+                    process.stdout.write('\n');
+                    cleanup();
+                    resolve(buffer);
+                    return;
+                }
+                // Cancel
+                if (ch === '\x03' || ch === '\x04') {
+                    process.stdout.write('\n');
+                    cleanup();
+                    resolve(null);
+                    return;
+                }
+                // Editing
+                if (ch === '\x7F' || ch === '\x08') {
+                    deleteCharBefore();
+                    completion.update();
+                    return;
+                }
+                if (ch === '\x01') {
+                    const previousCursorPos = cursorPos;
+                    moveCursorToDisplayRowStart();
+                    if (cursorPos !== previousCursorPos)
+                        completion.update();
+                    return;
+                }
+                if (ch === '\x05') {
+                    const previousCursorPos = cursorPos;
+                    moveCursorToDisplayRowEnd();
+                    if (cursorPos !== previousCursorPos)
+                        completion.update();
+                    return;
+                }
+                if (ch === '\x0B') {
+                    deleteToLineEnd();
+                    completion.update();
+                    return;
+                }
+                if (ch === '\x15') {
+                    deleteToLineStart();
+                    completion.update();
+                    return;
+                }
+                if (ch === '\x17') {
+                    deleteWord();
+                    completion.update();
+                    return;
+                }
+                if (ch === '\x0A') {
+                    completion.hide();
+                    insertNewline();
+                    return;
+                }
+                // Ignore unknown control characters
+                if (ch.charCodeAt(0) < 0x20)
+                    return;
+                // Regular character
+                insertChar(ch);
+                completion.update();
+            },
+        });
         function onData(data) {
             try {
                 const str = utf8Decoder.write(data);
                 if (!str)
                     return;
-                parseInputData(str, {
-                    onPasteStart() { state = 'paste'; },
-                    onPasteEnd() {
-                        state = 'normal';
-                        rerenderFromCursor();
-                    },
-                    onShiftEnter() { insertNewline(); },
-                    onArrowLeft() {
-                        if (state !== 'normal')
-                            return;
-                        if (cursorPos > getLineStart()) {
-                            const len = charLengthBefore(cursorPos);
-                            const charWidth = getDisplayWidth(buffer.slice(cursorPos - len, cursorPos));
-                            cursorPos -= len;
-                            process.stdout.write(`\x1B[${charWidth}D`);
-                        }
-                        else if (getLineStart() > 0) {
-                            cursorPos = getLineStart() - 1;
-                            const col = getTerminalColumn(cursorPos);
-                            process.stdout.write('\x1B[A');
-                            process.stdout.write(`\x1B[${col}G`);
-                        }
-                    },
-                    onArrowRight() {
-                        if (state !== 'normal')
-                            return;
-                        if (cursorPos < getLineEnd()) {
-                            const len = charLengthAt(cursorPos);
-                            const charWidth = getDisplayWidth(buffer.slice(cursorPos, cursorPos + len));
-                            cursorPos += len;
-                            process.stdout.write(`\x1B[${charWidth}C`);
-                        }
-                        else if (cursorPos < buffer.length && buffer[cursorPos] === '\n') {
-                            cursorPos++;
-                            const col = getTerminalColumn(cursorPos);
-                            process.stdout.write('\x1B[B');
-                            process.stdout.write(`\x1B[${col}G`);
-                        }
-                    },
-                    onArrowUp() {
-                        if (state !== 'normal')
-                            return;
-                        const logicalLineStart = getLineStart();
-                        const displayRowStart = getDisplayRowStart(cursorPos);
-                        const displayCol = getDisplayRowColumn(cursorPos);
-                        if (displayRowStart > logicalLineStart) {
-                            // Move to previous display row within the same logical line
-                            const prevRowStart = getDisplayRowStart(displayRowStart - 1);
-                            const prevRowEnd = getDisplayRowEnd(displayRowStart - 1);
-                            moveCursorToDisplayRow(prevRowStart, prevRowEnd, displayCol, 'A');
-                        }
-                        else if (logicalLineStart > 0) {
-                            // Move to the last display row of the previous logical line
-                            const prevLogicalLineEnd = logicalLineStart - 1;
-                            const prevRowStart = getDisplayRowStart(prevLogicalLineEnd);
-                            const prevRowEnd = getDisplayRowEnd(prevLogicalLineEnd);
-                            moveCursorToDisplayRow(prevRowStart, prevRowEnd, displayCol, 'A');
-                        }
-                    },
-                    onArrowDown() {
-                        if (state !== 'normal')
-                            return;
-                        const logicalLineEnd = getLineEnd();
-                        const displayRowEnd = getDisplayRowEnd(cursorPos);
-                        const displayCol = getDisplayRowColumn(cursorPos);
-                        if (displayRowEnd < logicalLineEnd) {
-                            // Move to next display row within the same logical line
-                            const nextRowStart = displayRowEnd;
-                            const nextRowEnd = getDisplayRowEnd(displayRowEnd);
-                            moveCursorToDisplayRow(nextRowStart, nextRowEnd, displayCol, 'B');
-                        }
-                        else if (logicalLineEnd < buffer.length) {
-                            // Move to the first display row of the next logical line
-                            const nextLineStart = logicalLineEnd + 1;
-                            const nextRowEnd = getDisplayRowEnd(nextLineStart);
-                            moveCursorToDisplayRow(nextLineStart, nextRowEnd, displayCol, 'B');
-                        }
-                    },
-                    onWordLeft() {
-                        if (state !== 'normal')
-                            return;
-                        const lineStart = getLineStart();
-                        if (cursorPos <= lineStart)
-                            return;
-                        let pos = cursorPos;
-                        while (pos > lineStart && buffer[pos - 1] === ' ')
-                            pos--;
-                        while (pos > lineStart && buffer[pos - 1] !== ' ')
-                            pos--;
-                        const moveWidth = getDisplayWidth(buffer.slice(pos, cursorPos));
-                        cursorPos = pos;
-                        process.stdout.write(`\x1B[${moveWidth}D`);
-                    },
-                    onWordRight() {
-                        if (state !== 'normal')
-                            return;
-                        const lineEnd = getLineEnd();
-                        if (cursorPos >= lineEnd)
-                            return;
-                        let pos = cursorPos;
-                        while (pos < lineEnd && buffer[pos] !== ' ')
-                            pos++;
-                        while (pos < lineEnd && buffer[pos] === ' ')
-                            pos++;
-                        const moveWidth = getDisplayWidth(buffer.slice(cursorPos, pos));
-                        cursorPos = pos;
-                        process.stdout.write(`\x1B[${moveWidth}C`);
-                    },
-                    onHome() {
-                        if (state !== 'normal')
-                            return;
-                        moveCursorToLogicalLineStart();
-                    },
-                    onEnd() {
-                        if (state !== 'normal')
-                            return;
-                        moveCursorToLogicalLineEnd();
-                    },
-                    onChar(ch) {
-                        if (state === 'paste') {
-                            if (ch === '\r' || ch === '\n') {
-                                insertAt(cursorPos, '\n');
-                                cursorPos++;
-                                process.stdout.write('\n');
-                            }
-                            else {
-                                insertAt(cursorPos, ch);
-                                cursorPos++;
-                                process.stdout.write(ch);
-                            }
-                            return;
-                        }
-                        // Submit
-                        if (ch === '\r') {
-                            process.stdout.write('\n');
-                            cleanup();
-                            resolve(buffer);
-                            return;
-                        }
-                        // Cancel
-                        if (ch === '\x03' || ch === '\x04') {
-                            process.stdout.write('\n');
-                            cleanup();
-                            resolve(null);
-                            return;
-                        }
-                        // Editing
-                        if (ch === '\x7F' || ch === '\x08') {
-                            deleteCharBefore();
-                            return;
-                        }
-                        if (ch === '\x01') {
-                            moveCursorToDisplayRowStart();
-                            return;
-                        }
-                        if (ch === '\x05') {
-                            moveCursorToDisplayRowEnd();
-                            return;
-                        }
-                        if (ch === '\x0B') {
-                            deleteToLineEnd();
-                            return;
-                        }
-                        if (ch === '\x15') {
-                            deleteToLineStart();
-                            return;
-                        }
-                        if (ch === '\x17') {
-                            deleteWord();
-                            return;
-                        }
-                        if (ch === '\x0A') {
-                            insertNewline();
-                            return;
-                        }
-                        // Ignore unknown control characters
-                        if (ch.charCodeAt(0) < 0x20)
-                            return;
-                        // Regular character
-                        insertChar(ch);
-                    },
-                });
+                escParser.feed(str);
             }
             catch {
                 cleanup();