neon 2.47.0 → 3.1.0

package/dist/psql/io/lineEditor/keymap.js

@@ -1,745 +1,587 @@
-/**
- * Emacs keymap dispatch.
- *
- * Pure function: take a `KeyEvent` plus the current editor state, mutate
- * the state, and return an `Action` describing what the renderer / outer
- * loop should do (redraw, submit, signal cancel, request completion, …).
- *
- * The state lives in `EditorState`, which wraps a `LineBuffer` plus a
- * little extra context (history navigation, last-tab timestamp, search
- * mode). Keeping dispatch separate from rendering means we can write
- * deterministic key-by-key tests without touching a TTY.
- */
 import { LineBuffer } from "./buffer.js";
-export const makeState = (history = [], mode = "emacs") => ({
-    buffer: new LineBuffer(),
-    history: [...history],
-    historyIndex: -1,
-    liveSnapshot: null,
-    lastYank: null,
-    pasting: false,
-    mode,
-    viPending: null,
-    exBuffer: "",
+//#region src/psql/io/lineEditor/keymap.ts
+/**
+* Emacs keymap dispatch.
+*
+* Pure function: take a `KeyEvent` plus the current editor state, mutate
+* the state, and return an `Action` describing what the renderer / outer
+* loop should do (redraw, submit, signal cancel, request completion, …).
+*
+* The state lives in `EditorState`, which wraps a `LineBuffer` plus a
+* little extra context (history navigation, last-tab timestamp, search
+* mode). Keeping dispatch separate from rendering means we can write
+* deterministic key-by-key tests without touching a TTY.
+*/
+const makeState = (history = [], mode = "emacs") => ({
+	buffer: new LineBuffer(),
+	history: [...history],
+	historyIndex: -1,
+	liveSnapshot: null,
+	lastYank: null,
+	pasting: false,
+	mode,
+	viPending: null,
+	exBuffer: ""
 });
 /**
- * Apply one key event. Returns the resulting action for the outer loop.
- * All mutation happens in `state.buffer` (or the navigation fields).
- */
-export const dispatch = (state, ev) => {
-    if (state.pasting) {
-        // Inside a bracketed-paste block we treat every event as a literal char,
-        // except the closing marker.
-        if (ev.key === "paste-end") {
-            state.pasting = false;
-            return { kind: "paste-end" };
-        }
-        if (ev.key === "char" &&
-            ev.char !== undefined &&
-            !ev.ctrl &&
-            !ev.meta) {
-            state.buffer.insert(ev.char);
-            return { kind: "redraw" };
-        }
-        if (ev.key === "enter") {
-            state.buffer.insert("\n");
-            return { kind: "redraw" };
-        }
-        if (ev.key === "tab") {
-            state.buffer.insert("\t");
-            return { kind: "redraw" };
-        }
-        return { kind: "noop" };
-    }
-    // ^C always cancels regardless of mode.
-    if (ev.key === "char" && ev.ctrl && ev.char === "c") {
-        state.viPending = null;
-        return { kind: "cancel" };
-    }
-    // Route to vi dispatch when in vi modes.
-    if (state.mode === "ex") {
-        return dispatchViEx(state, ev);
-    }
-    if (state.mode === "normal") {
-        return dispatchViNormal(state, ev);
-    }
-    if (state.mode === "insert") {
-        return dispatchViInsert(state, ev);
-    }
-    switch (ev.key) {
-        case "paste-start":
-            state.pasting = true;
-            return { kind: "paste-start" };
-        case "paste-end":
-            state.pasting = false;
-            return { kind: "paste-end" };
-        case "enter":
-            return { kind: "submit" };
-        case "tab":
-            return { kind: "complete" };
-        case "backspace":
-            if (ev.meta) {
-                state.buffer.killWordLeft();
-            }
-            else {
-                state.buffer.deleteLeft();
-            }
-            return { kind: "redraw" };
-        case "delete":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "left":
-            if (ev.meta)
-                state.buffer.moveWordLeft();
-            else
-                state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "right":
-            if (ev.meta)
-                state.buffer.moveWordRight();
-            else
-                state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "up":
-            return navigateHistory(state, -1);
-        case "down":
-            return navigateHistory(state, +1);
-        case "home":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "end":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "escape":
-            // Bare Escape: ignore (Alt prefixes are decoded into meta:true).
-            return { kind: "noop" };
-        case "char":
-            return handleChar(state, ev);
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
+* Apply one key event. Returns the resulting action for the outer loop.
+* All mutation happens in `state.buffer` (or the navigation fields).
+*/
+const dispatch = (state, ev) => {
+	if (state.pasting) {
+		if (ev.key === "paste-end") {
+			state.pasting = false;
+			return { kind: "paste-end" };
+		}
+		if (ev.key === "char" && ev.char !== void 0 && !ev.ctrl && !ev.meta) {
+			state.buffer.insert(ev.char);
+			return { kind: "redraw" };
+		}
+		if (ev.key === "enter") {
+			state.buffer.insert("\n");
+			return { kind: "redraw" };
+		}
+		if (ev.key === "tab") {
+			state.buffer.insert("	");
+			return { kind: "redraw" };
+		}
+		return { kind: "noop" };
+	}
+	if (ev.key === "char" && ev.ctrl && ev.char === "c") {
+		state.viPending = null;
+		return { kind: "cancel" };
+	}
+	if (state.mode === "ex") return dispatchViEx(state, ev);
+	if (state.mode === "normal") return dispatchViNormal(state, ev);
+	if (state.mode === "insert") return dispatchViInsert(state, ev);
+	switch (ev.key) {
+		case "paste-start":
+			state.pasting = true;
+			return { kind: "paste-start" };
+		case "paste-end":
+			state.pasting = false;
+			return { kind: "paste-end" };
+		case "enter": return { kind: "submit" };
+		case "tab": return { kind: "complete" };
+		case "backspace":
+			if (ev.meta) state.buffer.killWordLeft();
+			else state.buffer.deleteLeft();
+			return { kind: "redraw" };
+		case "delete":
+			state.buffer.deleteRight();
+			return { kind: "redraw" };
+		case "left":
+			if (ev.meta) state.buffer.moveWordLeft();
+			else state.buffer.moveLeft();
+			return { kind: "redraw" };
+		case "right":
+			if (ev.meta) state.buffer.moveWordRight();
+			else state.buffer.moveRight();
+			return { kind: "redraw" };
+		case "up": return navigateHistory(state, -1);
+		case "down": return navigateHistory(state, 1);
+		case "home":
+			state.buffer.moveHome();
+			return { kind: "redraw" };
+		case "end":
+			state.buffer.moveEnd();
+			return { kind: "redraw" };
+		case "escape": return { kind: "noop" };
+		case "char": return handleChar(state, ev);
+		case "pageup":
+		case "pagedown":
+		case "unknown": return { kind: "bell" };
+	}
 };
 const handleChar = (state, ev) => {
-    const ch = ev.char ?? "";
-    if (ch.length === 0)
-        return { kind: "noop" };
-    if (ev.ctrl) {
-        switch (ch) {
-            case "a":
-                state.buffer.moveHome();
-                return { kind: "redraw" };
-            case "e":
-                state.buffer.moveEnd();
-                return { kind: "redraw" };
-            case "b":
-                state.buffer.moveLeft();
-                return { kind: "redraw" };
-            case "f":
-                state.buffer.moveRight();
-                return { kind: "redraw" };
-            case "p":
-                return navigateHistory(state, -1);
-            case "n":
-                return navigateHistory(state, +1);
-            case "k":
-                state.buffer.killToEnd();
-                return { kind: "redraw" };
-            case "u":
-                state.buffer.killToStart();
-                return { kind: "redraw" };
-            case "w":
-                state.buffer.killWordLeft();
-                return { kind: "redraw" };
-            case "y": {
-                const yanked = state.buffer.yank();
-                state.lastYank = yanked ?? null;
-                return yanked === undefined
-                    ? { kind: "bell" }
-                    : { kind: "redraw" };
-            }
-            case "c":
-                return { kind: "cancel" };
-            case "d":
-                if (state.buffer.length === 0)
-                    return { kind: "eof" };
-                state.buffer.deleteRight();
-                return { kind: "redraw" };
-            case "l":
-                return { kind: "clear-screen" };
-            case "h":
-                state.buffer.deleteLeft();
-                return { kind: "redraw" };
-            case "r":
-                return { kind: "search-start" };
-            case "t": {
-                // Transpose two chars before cursor. Edge cases per readline:
-                //  - at end-of-line, transpose the two chars before cursor
-                //  - at the very start with <2 chars, bell
-                transpose(state.buffer);
-                return { kind: "redraw" };
-            }
-            case "_":
-            case "/": // some terminals send ^/ as 0x1f
-                return state.buffer.undo()
-                    ? { kind: "redraw" }
-                    : { kind: "bell" };
-            case "g":
-                // ^G outside of search is a no-op bell.
-                return { kind: "bell" };
-            default:
-                return { kind: "bell" };
-        }
-    }
-    if (ev.meta) {
-        switch (ch) {
-            case "b":
-            case "B":
-                state.buffer.moveWordLeft();
-                return { kind: "redraw" };
-            case "f":
-            case "F":
-                state.buffer.moveWordRight();
-                return { kind: "redraw" };
-            case "d":
-            case "D":
-                state.buffer.killWordRight();
-                return { kind: "redraw" };
-            case "y":
-            case "Y":
-                if (state.lastYank === null)
-                    return { kind: "bell" };
-                {
-                    const next = state.buffer.yankPop(state.lastYank);
-                    if (next === undefined)
-                        return { kind: "bell" };
-                    state.lastYank = next;
-                }
-                return { kind: "redraw" };
-            default:
-                return { kind: "bell" };
-        }
-    }
-    // Plain printable.
-    state.buffer.insert(ch);
-    return { kind: "redraw" };
+	const ch = ev.char ?? "";
+	if (ch.length === 0) return { kind: "noop" };
+	if (ev.ctrl) switch (ch) {
+		case "a":
+			state.buffer.moveHome();
+			return { kind: "redraw" };
+		case "e":
+			state.buffer.moveEnd();
+			return { kind: "redraw" };
+		case "b":
+			state.buffer.moveLeft();
+			return { kind: "redraw" };
+		case "f":
+			state.buffer.moveRight();
+			return { kind: "redraw" };
+		case "p": return navigateHistory(state, -1);
+		case "n": return navigateHistory(state, 1);
+		case "k":
+			state.buffer.killToEnd();
+			return { kind: "redraw" };
+		case "u":
+			state.buffer.killToStart();
+			return { kind: "redraw" };
+		case "w":
+			state.buffer.killWordLeft();
+			return { kind: "redraw" };
+		case "y": {
+			const yanked = state.buffer.yank();
+			state.lastYank = yanked ?? null;
+			return yanked === void 0 ? { kind: "bell" } : { kind: "redraw" };
+		}
+		case "c": return { kind: "cancel" };
+		case "d":
+			if (state.buffer.length === 0) return { kind: "eof" };
+			state.buffer.deleteRight();
+			return { kind: "redraw" };
+		case "l": return { kind: "clear-screen" };
+		case "h":
+			state.buffer.deleteLeft();
+			return { kind: "redraw" };
+		case "r": return { kind: "search-start" };
+		case "t":
+			transpose(state.buffer);
+			return { kind: "redraw" };
+		case "_":
+		case "/": return state.buffer.undo() ? { kind: "redraw" } : { kind: "bell" };
+		case "g": return { kind: "bell" };
+		default: return { kind: "bell" };
+	}
+	if (ev.meta) switch (ch) {
+		case "b":
+		case "B":
+			state.buffer.moveWordLeft();
+			return { kind: "redraw" };
+		case "f":
+		case "F":
+			state.buffer.moveWordRight();
+			return { kind: "redraw" };
+		case "d":
+		case "D":
+			state.buffer.killWordRight();
+			return { kind: "redraw" };
+		case "y":
+		case "Y":
+			if (state.lastYank === null) return { kind: "bell" };
+			{
+				const next = state.buffer.yankPop(state.lastYank);
+				if (next === void 0) return { kind: "bell" };
+				state.lastYank = next;
+			}
+			return { kind: "redraw" };
+		default: return { kind: "bell" };
+	}
+	state.buffer.insert(ch);
+	return { kind: "redraw" };
 };
 /**
- * Move history index by delta and load the corresponding entry. Saves
- * the live line on the first upward step so the user can return to it.
- */
+* Move history index by delta and load the corresponding entry. Saves
+* the live line on the first upward step so the user can return to it.
+*/
 const navigateHistory = (state, delta) => {
-    if (state.history.length === 0)
-        return { kind: "bell" };
-    if (state.historyIndex === -1) {
-        if (delta < 0) {
-            state.liveSnapshot = state.buffer.text;
-            state.historyIndex = state.history.length - 1;
-            state.buffer.setText(state.history[state.historyIndex]);
-            return { kind: "redraw" };
-        }
-        return { kind: "bell" };
-    }
-    const next = state.historyIndex + delta;
-    if (next < 0)
-        return { kind: "bell" };
-    if (next >= state.history.length) {
-        // Stepped past newest: restore the live snapshot.
-        state.historyIndex = -1;
-        state.buffer.setText(state.liveSnapshot ?? "");
-        state.liveSnapshot = null;
-        return { kind: "redraw" };
-    }
-    state.historyIndex = next;
-    state.buffer.setText(state.history[next]);
-    return { kind: "redraw" };
+	if (state.history.length === 0) return { kind: "bell" };
+	if (state.historyIndex === -1) {
+		if (delta < 0) {
+			state.liveSnapshot = state.buffer.text;
+			state.historyIndex = state.history.length - 1;
+			state.buffer.setText(state.history[state.historyIndex]);
+			return { kind: "redraw" };
+		}
+		return { kind: "bell" };
+	}
+	const next = state.historyIndex + delta;
+	if (next < 0) return { kind: "bell" };
+	if (next >= state.history.length) {
+		state.historyIndex = -1;
+		state.buffer.setText(state.liveSnapshot ?? "");
+		state.liveSnapshot = null;
+		return { kind: "redraw" };
+	}
+	state.historyIndex = next;
+	state.buffer.setText(state.history[next]);
+	return { kind: "redraw" };
 };
-// ---------------------------------------------------------------------------
-// vi mode
-// ---------------------------------------------------------------------------
 /**
- * Vi insert-mode dispatch. Behaves mostly like emacs for editing primitives —
- * printable keys insert, backspace/delete/arrows work the same way — but Esc
- * switches into normal mode. Ctrl keys are intentionally NOT vi commands here
- * (^C is handled at the top of `dispatch`).
- */
+* Vi insert-mode dispatch. Behaves mostly like emacs for editing primitives —
+* printable keys insert, backspace/delete/arrows work the same way — but Esc
+* switches into normal mode. Ctrl keys are intentionally NOT vi commands here
+* (^C is handled at the top of `dispatch`).
+*/
 const dispatchViInsert = (state, ev) => {
-    switch (ev.key) {
-        case "paste-start":
-            state.pasting = true;
-            return { kind: "paste-start" };
-        case "paste-end":
-            state.pasting = false;
-            return { kind: "paste-end" };
-        case "enter":
-            return { kind: "submit" };
-        case "tab":
-            return { kind: "complete" };
-        case "escape":
-            // Leave insert mode; vi convention: cursor steps left so it sits on the
-            // last inserted char (unless we were already at column 0).
-            state.mode = "normal";
-            state.viPending = null;
-            if (state.buffer.cursor > 0)
-                state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "backspace":
-            state.buffer.deleteLeft();
-            return { kind: "redraw" };
-        case "delete":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "left":
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "right":
-            state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "up":
-            return navigateHistory(state, -1);
-        case "down":
-            return navigateHistory(state, +1);
-        case "home":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "end":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "char": {
-            const ch = ev.char ?? "";
-            if (ch.length === 0)
-                return { kind: "noop" };
-            // ^D on empty buffer still acts as EOF in either vi mode.
-            if (ev.ctrl && ch === "d" && state.buffer.length === 0) {
-                return { kind: "eof" };
-            }
-            // Ignore other control combos in vi insert; just insert plain printables.
-            if (ev.ctrl || ev.meta)
-                return { kind: "noop" };
-            state.buffer.insert(ch);
-            return { kind: "redraw" };
-        }
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
+	switch (ev.key) {
+		case "paste-start":
+			state.pasting = true;
+			return { kind: "paste-start" };
+		case "paste-end":
+			state.pasting = false;
+			return { kind: "paste-end" };
+		case "enter": return { kind: "submit" };
+		case "tab": return { kind: "complete" };
+		case "escape":
+			state.mode = "normal";
+			state.viPending = null;
+			if (state.buffer.cursor > 0) state.buffer.moveLeft();
+			return { kind: "redraw" };
+		case "backspace":
+			state.buffer.deleteLeft();
+			return { kind: "redraw" };
+		case "delete":
+			state.buffer.deleteRight();
+			return { kind: "redraw" };
+		case "left":
+			state.buffer.moveLeft();
+			return { kind: "redraw" };
+		case "right":
+			state.buffer.moveRight();
+			return { kind: "redraw" };
+		case "up": return navigateHistory(state, -1);
+		case "down": return navigateHistory(state, 1);
+		case "home":
+			state.buffer.moveHome();
+			return { kind: "redraw" };
+		case "end":
+			state.buffer.moveEnd();
+			return { kind: "redraw" };
+		case "char": {
+			const ch = ev.char ?? "";
+			if (ch.length === 0) return { kind: "noop" };
+			if (ev.ctrl && ch === "d" && state.buffer.length === 0) return { kind: "eof" };
+			if (ev.ctrl || ev.meta) return { kind: "noop" };
+			state.buffer.insert(ch);
+			return { kind: "redraw" };
+		}
+		case "pageup":
+		case "pagedown":
+		case "unknown": return { kind: "bell" };
+	}
 };
 /**
- * Vi normal-mode dispatch. Implements the core motion + edit subset documented
- * in the WP-24 plan: hjkl/0$^/bwe movement, x/X/dd/D/cc/cw/r/~ edits, i/a/I/A
- * to switch back to insert. Multi-key sequences (dd, cw, r<char>) are tracked
- * via `state.viPending`.
- */
+* Vi normal-mode dispatch. Implements the core motion + edit subset documented
+* in the WP-24 plan: hjkl/0$^/bwe movement, x/X/dd/D/cc/cw/r/~ edits, i/a/I/A
+* to switch back to insert. Multi-key sequences (dd, cw, r<char>) are tracked
+* via `state.viPending`.
+*/
 const dispatchViNormal = (state, ev) => {
-    // Pending operator awaiting its next char.
-    if (state.viPending !== null) {
-        return continueViPending(state, ev);
-    }
-    switch (ev.key) {
-        case "enter":
-            return { kind: "submit" };
-        case "tab":
-            // No completion in normal mode (matches vim/readline-vi).
-            return { kind: "bell" };
-        case "escape":
-            // Already normal; clear any half-formed operator.
-            state.viPending = null;
-            return { kind: "noop" };
-        case "backspace":
-            // In normal mode bare backspace is "move left" per readline-vi.
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "delete":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "left":
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "right":
-            state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "up":
-            return navigateHistory(state, -1);
-        case "down":
-            return navigateHistory(state, +1);
-        case "home":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "end":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "char":
-            return handleViNormalChar(state, ev);
-        case "paste-start":
-            state.pasting = true;
-            return { kind: "paste-start" };
-        case "paste-end":
-            state.pasting = false;
-            return { kind: "paste-end" };
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
+	if (state.viPending !== null) return continueViPending(state, ev);
+	switch (ev.key) {
+		case "enter": return { kind: "submit" };
+		case "tab": return { kind: "bell" };
+		case "escape":
+			state.viPending = null;
+			return { kind: "noop" };
+		case "backspace":
+			state.buffer.moveLeft();
+			return { kind: "redraw" };
+		case "delete":
+			state.buffer.deleteRight();
+			return { kind: "redraw" };
+		case "left":
+			state.buffer.moveLeft();
+			return { kind: "redraw" };
+		case "right":
+			state.buffer.moveRight();
+			return { kind: "redraw" };
+		case "up": return navigateHistory(state, -1);
+		case "down": return navigateHistory(state, 1);
+		case "home":
+			state.buffer.moveHome();
+			return { kind: "redraw" };
+		case "end":
+			state.buffer.moveEnd();
+			return { kind: "redraw" };
+		case "char": return handleViNormalChar(state, ev);
+		case "paste-start":
+			state.pasting = true;
+			return { kind: "paste-start" };
+		case "paste-end":
+			state.pasting = false;
+			return { kind: "paste-end" };
+		case "pageup":
+		case "pagedown":
+		case "unknown": return { kind: "bell" };
+	}
 };
 const handleViNormalChar = (state, ev) => {
-    const ch = ev.char ?? "";
-    if (ch.length === 0)
-        return { kind: "noop" };
-    // ^D on empty buffer is EOF in vi normal mode too.
-    if (ev.ctrl && ch === "d" && state.buffer.length === 0) {
-        return { kind: "eof" };
-    }
-    // Other ctrl/meta sequences: not bound in normal mode → bell.
-    if (ev.ctrl || ev.meta)
-        return { kind: "bell" };
-    switch (ch) {
-        // Movement
-        case "h":
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "l":
-            state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "b":
-            state.buffer.moveWordLeft();
-            return { kind: "redraw" };
-        case "w":
-            state.buffer.moveWordRight();
-            return { kind: "redraw" };
-        case "e":
-            viMoveEndOfWord(state.buffer);
-            return { kind: "redraw" };
-        case "0":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "$":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "^":
-            viMoveFirstNonBlank(state.buffer);
-            return { kind: "redraw" };
-        // History (vi-style j/k).
-        case "j":
-            return navigateHistory(state, +1);
-        case "k":
-            return navigateHistory(state, -1);
-        // Mode switches.
-        case "i":
-            state.mode = "insert";
-            return { kind: "redraw" };
-        case "a":
-            if (state.buffer.cursor < state.buffer.length)
-                state.buffer.moveRight();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        case "I":
-            state.buffer.moveHome();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        case "A":
-            state.buffer.moveEnd();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        // Edits.
-        case "x":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "X":
-            state.buffer.deleteLeft();
-            return { kind: "redraw" };
-        case "D":
-            state.buffer.killToEnd();
-            return { kind: "redraw" };
-        case "~":
-            viToggleCaseAtCursor(state.buffer);
-            return { kind: "redraw" };
-        // Multi-key operators: wait for next char.
-        case "r":
-            state.viPending = "r";
-            return { kind: "noop" };
-        case "d":
-            state.viPending = "d";
-            return { kind: "noop" };
-        case "c":
-            state.viPending = "c";
-            return { kind: "noop" };
-        case "g":
-            // Stub: only 'gg' (go to first history) might be desirable; for now,
-            // just consume the prefix and bell on the follow-up.
-            state.viPending = "g";
-            return { kind: "noop" };
-        case ":":
-            // Enter ex-prompt mode. The renderer draws a `:` line; printable keys
-            // accumulate in `exBuffer`; Enter executes; Esc returns to normal.
-            state.mode = "ex";
-            state.exBuffer = "";
-            return { kind: "ex-update" };
-        default:
-            return { kind: "bell" };
-    }
+	const ch = ev.char ?? "";
+	if (ch.length === 0) return { kind: "noop" };
+	if (ev.ctrl && ch === "d" && state.buffer.length === 0) return { kind: "eof" };
+	if (ev.ctrl || ev.meta) return { kind: "bell" };
+	switch (ch) {
+		case "h":
+			state.buffer.moveLeft();
+			return { kind: "redraw" };
+		case "l":
+			state.buffer.moveRight();
+			return { kind: "redraw" };
+		case "b":
+			state.buffer.moveWordLeft();
+			return { kind: "redraw" };
+		case "w":
+			state.buffer.moveWordRight();
+			return { kind: "redraw" };
+		case "e":
+			viMoveEndOfWord(state.buffer);
+			return { kind: "redraw" };
+		case "0":
+			state.buffer.moveHome();
+			return { kind: "redraw" };
+		case "$":
+			state.buffer.moveEnd();
+			return { kind: "redraw" };
+		case "^":
+			viMoveFirstNonBlank(state.buffer);
+			return { kind: "redraw" };
+		case "j": return navigateHistory(state, 1);
+		case "k": return navigateHistory(state, -1);
+		case "i":
+			state.mode = "insert";
+			return { kind: "redraw" };
+		case "a":
+			if (state.buffer.cursor < state.buffer.length) state.buffer.moveRight();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		case "I":
+			state.buffer.moveHome();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		case "A":
+			state.buffer.moveEnd();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		case "x":
+			state.buffer.deleteRight();
+			return { kind: "redraw" };
+		case "X":
+			state.buffer.deleteLeft();
+			return { kind: "redraw" };
+		case "D":
+			state.buffer.killToEnd();
+			return { kind: "redraw" };
+		case "~":
+			viToggleCaseAtCursor(state.buffer);
+			return { kind: "redraw" };
+		case "r":
+			state.viPending = "r";
+			return { kind: "noop" };
+		case "d":
+			state.viPending = "d";
+			return { kind: "noop" };
+		case "c":
+			state.viPending = "c";
+			return { kind: "noop" };
+		case "g":
+			state.viPending = "g";
+			return { kind: "noop" };
+		case ":":
+			state.mode = "ex";
+			state.exBuffer = "";
+			return { kind: "ex-update" };
+		default: return { kind: "bell" };
+	}
 };
 /**
- * Vi ex-prompt dispatch (`:`-line). Mirrors a tiny slice of vim's ex grammar:
- *
- *   - `q`, `quit`, `q!` — abort the current readLine (same as ^C).
- *   - `w` (no arg)     — bell + ignore (we don't have a file to write to).
- *   - Esc              — abort ex; return to normal mode.
- *   - Enter            — execute the accumulated command.
- *
- * Printable characters extend `state.exBuffer`; Backspace shrinks it. Anything
- * else bells. The renderer is responsible for drawing `: ` + exBuffer on its
- * own row; we expose `ex-update` actions so it knows when to redraw.
- */
+* Vi ex-prompt dispatch (`:`-line). Mirrors a tiny slice of vim's ex grammar:
+*
+*   - `q`, `quit`, `q!` — abort the current readLine (same as ^C).
+*   - `w` (no arg)     — bell + ignore (we don't have a file to write to).
+*   - Esc              — abort ex; return to normal mode.
+*   - Enter            — execute the accumulated command.
+*
+* Printable characters extend `state.exBuffer`; Backspace shrinks it. Anything
+* else bells. The renderer is responsible for drawing `: ` + exBuffer on its
+* own row; we expose `ex-update` actions so it knows when to redraw.
+*/
 const dispatchViEx = (state, ev) => {
-    switch (ev.key) {
-        case "escape":
-            // Abort ex; back to normal without executing anything.
-            state.mode = "normal";
-            state.exBuffer = "";
-            return { kind: "redraw" };
-        case "enter":
-            return executeExCommand(state);
-        case "backspace":
-            if (state.exBuffer.length === 0) {
-                // Backspace through the implicit `:` returns to normal mode (matches
-                // vim's "backspace at column 1 of ex line").
-                state.mode = "normal";
-                return { kind: "redraw" };
-            }
-            state.exBuffer = state.exBuffer.slice(0, -1);
-            return { kind: "ex-update" };
-        case "char": {
-            const ch = ev.char ?? "";
-            // Ctrl/Meta combos aren't bound in ex.
-            if (ch.length === 0 || ev.ctrl || ev.meta)
-                return { kind: "bell" };
-            state.exBuffer += ch;
-            return { kind: "ex-update" };
-        }
-        case "paste-start":
-        case "paste-end":
-        case "tab":
-        case "delete":
-        case "left":
-        case "right":
-        case "up":
-        case "down":
-        case "home":
-        case "end":
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
+	switch (ev.key) {
+		case "escape":
+			state.mode = "normal";
+			state.exBuffer = "";
+			return { kind: "redraw" };
+		case "enter": return executeExCommand(state);
+		case "backspace":
+			if (state.exBuffer.length === 0) {
+				state.mode = "normal";
+				return { kind: "redraw" };
+			}
+			state.exBuffer = state.exBuffer.slice(0, -1);
+			return { kind: "ex-update" };
+		case "char": {
+			const ch = ev.char ?? "";
+			if (ch.length === 0 || ev.ctrl || ev.meta) return { kind: "bell" };
+			state.exBuffer += ch;
+			return { kind: "ex-update" };
+		}
+		case "paste-start":
+		case "paste-end":
+		case "tab":
+		case "delete":
+		case "left":
+		case "right":
+		case "up":
+		case "down":
+		case "home":
+		case "end":
+		case "pageup":
+		case "pagedown":
+		case "unknown": return { kind: "bell" };
+	}
 };
 /**
- * Interpret the accumulated ex buffer. Returns the action the driver should
- * apply (cancel = abort current readLine; bell = unknown command; redraw =
- * fall back to normal mode without side effects).
- */
+* Interpret the accumulated ex buffer. Returns the action the driver should
+* apply (cancel = abort current readLine; bell = unknown command; redraw =
+* fall back to normal mode without side effects).
+*/
 const executeExCommand = (state) => {
-    const cmd = state.exBuffer.trim();
-    // Always leave ex mode after Enter, even on unknown commands.
-    state.exBuffer = "";
-    state.mode = "normal";
-    switch (cmd) {
-        case "q":
-        case "q!":
-        case "quit":
-            // Abort the readLine. Same outcome as ^C — driver throws SignalError.
-            return { kind: "cancel" };
-        case "w":
-            // We don't have a file to write to; bell and return to normal.
-            return { kind: "bell" };
-        case "":
-            // Bare `:` then Enter — just return to normal silently.
-            return { kind: "redraw" };
-        default:
-            return { kind: "bell" };
-    }
+	const cmd = state.exBuffer.trim();
+	state.exBuffer = "";
+	state.mode = "normal";
+	switch (cmd) {
+		case "q":
+		case "q!":
+		case "quit": return { kind: "cancel" };
+		case "w": return { kind: "bell" };
+		case "": return { kind: "redraw" };
+		default: return { kind: "bell" };
+	}
 };
 /**
- * Resolve a pending vi operator using the next key event. `r<char>` replaces
- * one char; `dd` / `cc` operate on the whole line; `dw` / `cw` operate on a
- * word; anything else bells.
- */
+* Resolve a pending vi operator using the next key event. `r<char>` replaces
+* one char; `dd` / `cc` operate on the whole line; `dw` / `cw` operate on a
+* word; anything else bells.
+*/
 const continueViPending = (state, ev) => {
-    const pending = state.viPending;
-    state.viPending = null;
-    // Escape cancels a pending operator without bell (matches vi convention).
-    if (ev.key === "escape")
-        return { kind: "noop" };
-    if (pending === "r") {
-        // r<char> replaces one char at cursor with <char>.
-        if (ev.key !== "char" || ev.char === undefined || ev.ctrl || ev.meta) {
-            return { kind: "bell" };
-        }
-        if (state.buffer.cursor >= state.buffer.length)
-            return { kind: "bell" };
-        viReplaceCharAtCursor(state.buffer, ev.char);
-        return { kind: "redraw" };
-    }
-    if (pending === "g") {
-        // Only 'gg' is recognised; we don't actually implement first-history yet.
-        return { kind: "bell" };
-    }
-    // dd / cc / dw / cw all key off ev.char.
-    if (ev.key !== "char" || ev.char === undefined || ev.ctrl || ev.meta) {
-        return { kind: "bell" };
-    }
-    const c = ev.char;
-    if (pending === "d") {
-        if (c === "d") {
-            // dd: kill whole line.
-            state.buffer.moveHome();
-            state.buffer.killToEnd();
-            return { kind: "redraw" };
-        }
-        if (c === "w") {
-            state.buffer.killWordRight();
-            return { kind: "redraw" };
-        }
-        if (c === "b") {
-            state.buffer.killWordLeft();
-            return { kind: "redraw" };
-        }
-        if (c === "$") {
-            state.buffer.killToEnd();
-            return { kind: "redraw" };
-        }
-        if (c === "0") {
-            state.buffer.killToStart();
-            return { kind: "redraw" };
-        }
-        return { kind: "bell" };
-    }
-    if (pending === "c") {
-        if (c === "c") {
-            // cc: kill whole line, enter insert.
-            state.buffer.moveHome();
-            state.buffer.killToEnd();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "w") {
-            state.buffer.killWordRight();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "b") {
-            state.buffer.killWordLeft();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "$") {
-            state.buffer.killToEnd();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "0") {
-            state.buffer.killToStart();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        return { kind: "bell" };
-    }
-    return { kind: "bell" };
+	const pending = state.viPending;
+	state.viPending = null;
+	if (ev.key === "escape") return { kind: "noop" };
+	if (pending === "r") {
+		if (ev.key !== "char" || ev.char === void 0 || ev.ctrl || ev.meta) return { kind: "bell" };
+		if (state.buffer.cursor >= state.buffer.length) return { kind: "bell" };
+		viReplaceCharAtCursor(state.buffer, ev.char);
+		return { kind: "redraw" };
+	}
+	if (pending === "g") return { kind: "bell" };
+	if (ev.key !== "char" || ev.char === void 0 || ev.ctrl || ev.meta) return { kind: "bell" };
+	const c = ev.char;
+	if (pending === "d") {
+		if (c === "d") {
+			state.buffer.moveHome();
+			state.buffer.killToEnd();
+			return { kind: "redraw" };
+		}
+		if (c === "w") {
+			state.buffer.killWordRight();
+			return { kind: "redraw" };
+		}
+		if (c === "b") {
+			state.buffer.killWordLeft();
+			return { kind: "redraw" };
+		}
+		if (c === "$") {
+			state.buffer.killToEnd();
+			return { kind: "redraw" };
+		}
+		if (c === "0") {
+			state.buffer.killToStart();
+			return { kind: "redraw" };
+		}
+		return { kind: "bell" };
+	}
+	if (pending === "c") {
+		if (c === "c") {
+			state.buffer.moveHome();
+			state.buffer.killToEnd();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		}
+		if (c === "w") {
+			state.buffer.killWordRight();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		}
+		if (c === "b") {
+			state.buffer.killWordLeft();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		}
+		if (c === "$") {
+			state.buffer.killToEnd();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		}
+		if (c === "0") {
+			state.buffer.killToStart();
+			state.mode = "insert";
+			return { kind: "redraw" };
+		}
+		return { kind: "bell" };
+	}
+	return { kind: "bell" };
 };
 /** `e` motion: jump to the end of the current word (or the next word). */
 const viMoveEndOfWord = (buf) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    let i = buf.cursor;
-    // If we're between/inside a word, move to the last char of the word that
-    // ends at or after cursor.
-    // Step 1: if cursor is at a non-word, skip to the next word's first char.
-    while (i < cps.length && !isWordChar(cps[i]))
-        i++;
-    // Step 2: if we landed inside a word, advance to its last char (one before
-    // the next non-word boundary).
-    while (i < cps.length - 1 && isWordChar(cps[i + 1]))
-        i++;
-    // Vi's `e` leaves the cursor ON the last char, not past it. Our buffer uses
-    // cursor "between code points", so put it after that last char.
-    if (i < cps.length)
-        i++;
-    buf.setText(text, i);
+	const text = buf.text;
+	const cps = Array.from(text);
+	let i = buf.cursor;
+	while (i < cps.length && !isWordChar(cps[i])) i++;
+	while (i < cps.length - 1 && isWordChar(cps[i + 1])) i++;
+	if (i < cps.length) i++;
+	buf.setText(text, i);
 };
 /** `^` motion: first non-blank char on the line. */
 const viMoveFirstNonBlank = (buf) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    let i = 0;
-    while (i < cps.length && (cps[i] === " " || cps[i] === "\t"))
-        i++;
-    buf.setText(text, i);
+	const text = buf.text;
+	const cps = Array.from(text);
+	let i = 0;
+	while (i < cps.length && (cps[i] === " " || cps[i] === "	")) i++;
+	buf.setText(text, i);
 };
 /** `~` toggles the case of the character at the cursor; advances cursor. */
 const viToggleCaseAtCursor = (buf) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    const i = buf.cursor;
-    if (i >= cps.length)
-        return;
-    const ch = cps[i];
-    const flipped = ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
-    if (flipped === ch) {
-        // Non-alpha: just advance.
-        buf.setText(text, Math.min(i + 1, cps.length));
-        return;
-    }
-    buf.pushUndo();
-    cps[i] = flipped;
-    buf.setText(cps.join(""), Math.min(i + 1, cps.length));
+	const text = buf.text;
+	const cps = Array.from(text);
+	const i = buf.cursor;
+	if (i >= cps.length) return;
+	const ch = cps[i];
+	const flipped = ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
+	if (flipped === ch) {
+		buf.setText(text, Math.min(i + 1, cps.length));
+		return;
+	}
+	buf.pushUndo();
+	cps[i] = flipped;
+	buf.setText(cps.join(""), Math.min(i + 1, cps.length));
 };
 /** `r<char>` replaces the character at cursor and leaves cursor in place. */
 const viReplaceCharAtCursor = (buf, ch) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    const i = buf.cursor;
-    if (i >= cps.length)
-        return;
-    buf.pushUndo();
-    cps[i] = ch;
-    buf.setText(cps.join(""), i);
+	const text = buf.text;
+	const cps = Array.from(text);
+	const i = buf.cursor;
+	if (i >= cps.length) return;
+	buf.pushUndo();
+	cps[i] = ch;
+	buf.setText(cps.join(""), i);
 };
-// Re-export for vi helpers that need word classification (matches buffer.ts).
 const isWordChar = (ch) => {
-    if (ch.length === 0)
-        return false;
-    const cp = ch.codePointAt(0) ?? 0;
-    if (cp >= 0x30 && cp <= 0x39)
-        return true; // 0-9
-    if (cp >= 0x41 && cp <= 0x5a)
-        return true; // A-Z
-    if (cp >= 0x61 && cp <= 0x7a)
-        return true; // a-z
-    if (cp === 0x5f)
-        return true; // _
-    if (cp > 0x7f)
-        return cp >= 0xa0;
-    return false;
+	if (ch.length === 0) return false;
+	const cp = ch.codePointAt(0) ?? 0;
+	if (cp >= 48 && cp <= 57) return true;
+	if (cp >= 65 && cp <= 90) return true;
+	if (cp >= 97 && cp <= 122) return true;
+	if (cp === 95) return true;
+	if (cp > 127) return cp >= 160;
+	return false;
 };
 /** ^T: swap the character before the cursor with the one before it. */
 const transpose = (buf) => {
-    const len = buf.length;
-    if (len < 2)
-        return;
-    const text = buf.text;
-    const cps = Array.from(text);
-    let i = buf.cursor;
-    if (i === 0)
-        return;
-    if (i === len)
-        i--; // at EOL: act on the last two chars
-    if (i < 1)
-        return;
-    buf.pushUndo();
-    const tmp = cps[i - 1];
-    cps[i - 1] = cps[i];
-    cps[i] = tmp;
-    buf.setText(cps.join(""), Math.min(i + 1, len));
+	const len = buf.length;
+	if (len < 2) return;
+	const text = buf.text;
+	const cps = Array.from(text);
+	let i = buf.cursor;
+	if (i === 0) return;
+	if (i === len) i--;
+	if (i < 1) return;
+	buf.pushUndo();
+	const tmp = cps[i - 1];
+	cps[i - 1] = cps[i];
+	cps[i] = tmp;
+	buf.setText(cps.join(""), Math.min(i + 1, len));
 };
+//#endregion
+export { dispatch, makeState };