neonctl 2.28.0 → 2.29.0

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

@@ -10,8 +10,8 @@
  * 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') => ({
+import { LineBuffer } from "./buffer.js";
+export const makeState = (history = [], mode = "emacs") => ({
     buffer: new LineBuffer(),
     history: [...history],
     historyIndex: -1,
@@ -20,7 +20,7 @@ export const makeState = (history = [], mode = 'emacs') => ({
     pasting: false,
     mode,
     viPending: null,
-    exBuffer: '',
+    exBuffer: "",
 });
 /**
  * Apply one key event. Returns the resulting action for the outer loop.
@@ -30,193 +30,200 @@ 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') {
+        if (ev.key === "paste-end") {
             state.pasting = false;
-            return { kind: 'paste-end' };
+            return { kind: "paste-end" };
         }
-        if (ev.key === 'char' && ev.char !== undefined && !ev.ctrl && !ev.meta) {
+        if (ev.key === "char" &&
+            ev.char !== undefined &&
+            !ev.ctrl &&
+            !ev.meta) {
             state.buffer.insert(ev.char);
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         }
-        if (ev.key === 'enter') {
-            state.buffer.insert('\n');
-            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' };
+        if (ev.key === "tab") {
+            state.buffer.insert("\t");
+            return { kind: "redraw" };
         }
-        return { kind: 'noop' };
+        return { kind: "noop" };
     }
     // ^C always cancels regardless of mode.
-    if (ev.key === 'char' && ev.ctrl && ev.char === 'c') {
+    if (ev.key === "char" && ev.ctrl && ev.char === "c") {
         state.viPending = null;
-        return { kind: 'cancel' };
+        return { kind: "cancel" };
     }
     // Route to vi dispatch when in vi modes.
-    if (state.mode === 'ex') {
+    if (state.mode === "ex") {
         return dispatchViEx(state, ev);
     }
-    if (state.mode === 'normal') {
+    if (state.mode === "normal") {
         return dispatchViNormal(state, ev);
     }
-    if (state.mode === 'insert') {
+    if (state.mode === "insert") {
         return dispatchViInsert(state, ev);
     }
     switch (ev.key) {
-        case 'paste-start':
+        case "paste-start":
             state.pasting = true;
-            return { kind: 'paste-start' };
-        case 'paste-end':
+            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':
+            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':
+            return { kind: "redraw" };
+        case "delete":
             state.buffer.deleteRight();
-            return { kind: 'redraw' };
-        case 'left':
+            return { kind: "redraw" };
+        case "left":
             if (ev.meta)
                 state.buffer.moveWordLeft();
             else
                 state.buffer.moveLeft();
-            return { kind: 'redraw' };
-        case 'right':
+            return { kind: "redraw" };
+        case "right":
             if (ev.meta)
                 state.buffer.moveWordRight();
             else
                 state.buffer.moveRight();
-            return { kind: 'redraw' };
-        case 'up':
+            return { kind: "redraw" };
+        case "up":
             return navigateHistory(state, -1);
-        case 'down':
+        case "down":
             return navigateHistory(state, +1);
-        case 'home':
+        case "home":
             state.buffer.moveHome();
-            return { kind: 'redraw' };
-        case 'end':
+            return { kind: "redraw" };
+        case "end":
             state.buffer.moveEnd();
-            return { kind: 'redraw' };
-        case 'escape':
+            return { kind: "redraw" };
+        case "escape":
             // Bare Escape: ignore (Alt prefixes are decoded into meta:true).
-            return { kind: 'noop' };
-        case 'char':
+            return { kind: "noop" };
+        case "char":
             return handleChar(state, ev);
-        case 'pageup':
-        case 'pagedown':
-        case 'unknown':
-            return { kind: 'bell' };
+        case "pageup":
+        case "pagedown":
+        case "unknown":
+            return { kind: "bell" };
     }
 };
 const handleChar = (state, ev) => {
-    const ch = ev.char ?? '';
+    const ch = ev.char ?? "";
     if (ch.length === 0)
-        return { kind: 'noop' };
+        return { kind: "noop" };
     if (ev.ctrl) {
         switch (ch) {
-            case 'a':
+            case "a":
                 state.buffer.moveHome();
-                return { kind: 'redraw' };
-            case 'e':
+                return { kind: "redraw" };
+            case "e":
                 state.buffer.moveEnd();
-                return { kind: 'redraw' };
-            case 'b':
+                return { kind: "redraw" };
+            case "b":
                 state.buffer.moveLeft();
-                return { kind: 'redraw' };
-            case 'f':
+                return { kind: "redraw" };
+            case "f":
                 state.buffer.moveRight();
-                return { kind: 'redraw' };
-            case 'p':
+                return { kind: "redraw" };
+            case "p":
                 return navigateHistory(state, -1);
-            case 'n':
+            case "n":
                 return navigateHistory(state, +1);
-            case 'k':
+            case "k":
                 state.buffer.killToEnd();
-                return { kind: 'redraw' };
-            case 'u':
+                return { kind: "redraw" };
+            case "u":
                 state.buffer.killToStart();
-                return { kind: 'redraw' };
-            case 'w':
+                return { kind: "redraw" };
+            case "w":
                 state.buffer.killWordLeft();
-                return { kind: 'redraw' };
-            case 'y': {
+                return { kind: "redraw" };
+            case "y": {
                 const yanked = state.buffer.yank();
                 state.lastYank = yanked ?? null;
-                return yanked === undefined ? { kind: 'bell' } : { kind: 'redraw' };
+                return yanked === undefined
+                    ? { kind: "bell" }
+                    : { kind: "redraw" };
             }
-            case 'c':
-                return { kind: 'cancel' };
-            case 'd':
+            case "c":
+                return { kind: "cancel" };
+            case "d":
                 if (state.buffer.length === 0)
-                    return { kind: 'eof' };
+                    return { kind: "eof" };
                 state.buffer.deleteRight();
-                return { kind: 'redraw' };
-            case 'l':
-                return { kind: 'clear-screen' };
-            case 'h':
+                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': {
+                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' };
+                return { kind: "redraw" };
             }
-            case '_':
-            case '/': // some terminals send ^/ as 0x1f
-                return state.buffer.undo() ? { kind: 'redraw' } : { kind: 'bell' };
-            case 'g':
+            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' };
+                return { kind: "bell" };
             default:
-                return { kind: 'bell' };
+                return { kind: "bell" };
         }
     }
     if (ev.meta) {
         switch (ch) {
-            case 'b':
-            case 'B':
+            case "b":
+            case "B":
                 state.buffer.moveWordLeft();
-                return { kind: 'redraw' };
-            case 'f':
-            case 'F':
+                return { kind: "redraw" };
+            case "f":
+            case "F":
                 state.buffer.moveWordRight();
-                return { kind: 'redraw' };
-            case 'd':
-            case 'D':
+                return { kind: "redraw" };
+            case "d":
+            case "D":
                 state.buffer.killWordRight();
-                return { kind: 'redraw' };
-            case 'y':
-            case 'Y':
+                return { kind: "redraw" };
+            case "y":
+            case "Y":
                 if (state.lastYank === null)
-                    return { kind: 'bell' };
+                    return { kind: "bell" };
                 {
                     const next = state.buffer.yankPop(state.lastYank);
                     if (next === undefined)
-                        return { kind: 'bell' };
+                        return { kind: "bell" };
                     state.lastYank = next;
                 }
-                return { kind: 'redraw' };
+                return { kind: "redraw" };
             default:
-                return { kind: 'bell' };
+                return { kind: "bell" };
         }
     }
     // Plain printable.
     state.buffer.insert(ch);
-    return { kind: 'redraw' };
+    return { kind: "redraw" };
 };
 /**
  * Move history index by delta and load the corresponding entry. Saves
@@ -224,29 +231,29 @@ const handleChar = (state, ev) => {
  */
 const navigateHistory = (state, delta) => {
     if (state.history.length === 0)
-        return { kind: 'bell' };
+        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: "redraw" };
         }
-        return { kind: 'bell' };
+        return { kind: "bell" };
     }
     const next = state.historyIndex + delta;
     if (next < 0)
-        return { kind: 'bell' };
+        return { kind: "bell" };
     if (next >= state.history.length) {
         // Stepped past newest: restore the live snapshot.
         state.historyIndex = -1;
-        state.buffer.setText(state.liveSnapshot ?? '');
+        state.buffer.setText(state.liveSnapshot ?? "");
         state.liveSnapshot = null;
-        return { kind: 'redraw' };
+        return { kind: "redraw" };
     }
     state.historyIndex = next;
     state.buffer.setText(state.history[next]);
-    return { kind: 'redraw' };
+    return { kind: "redraw" };
 };
 // ---------------------------------------------------------------------------
 // vi mode
@@ -259,64 +266,64 @@ const navigateHistory = (state, delta) => {
  */
 const dispatchViInsert = (state, ev) => {
     switch (ev.key) {
-        case 'paste-start':
+        case "paste-start":
             state.pasting = true;
-            return { kind: 'paste-start' };
-        case 'paste-end':
+            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':
+            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.mode = "normal";
             state.viPending = null;
             if (state.buffer.cursor > 0)
                 state.buffer.moveLeft();
-            return { kind: 'redraw' };
-        case 'backspace':
+            return { kind: "redraw" };
+        case "backspace":
             state.buffer.deleteLeft();
-            return { kind: 'redraw' };
-        case 'delete':
+            return { kind: "redraw" };
+        case "delete":
             state.buffer.deleteRight();
-            return { kind: 'redraw' };
-        case 'left':
+            return { kind: "redraw" };
+        case "left":
             state.buffer.moveLeft();
-            return { kind: 'redraw' };
-        case 'right':
+            return { kind: "redraw" };
+        case "right":
             state.buffer.moveRight();
-            return { kind: 'redraw' };
-        case 'up':
+            return { kind: "redraw" };
+        case "up":
             return navigateHistory(state, -1);
-        case 'down':
+        case "down":
             return navigateHistory(state, +1);
-        case 'home':
+        case "home":
             state.buffer.moveHome();
-            return { kind: 'redraw' };
-        case 'end':
+            return { kind: "redraw" };
+        case "end":
             state.buffer.moveEnd();
-            return { kind: 'redraw' };
-        case 'char': {
-            const ch = ev.char ?? '';
+            return { kind: "redraw" };
+        case "char": {
+            const ch = ev.char ?? "";
             if (ch.length === 0)
-                return { kind: 'noop' };
+                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' };
+            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' };
+                return { kind: "noop" };
             state.buffer.insert(ch);
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         }
-        case 'pageup':
-        case 'pagedown':
-        case 'unknown':
-            return { kind: 'bell' };
+        case "pageup":
+        case "pagedown":
+        case "unknown":
+            return { kind: "bell" };
     }
 };
 /**
@@ -331,147 +338,147 @@ const dispatchViNormal = (state, ev) => {
         return continueViPending(state, ev);
     }
     switch (ev.key) {
-        case 'enter':
-            return { kind: 'submit' };
-        case 'tab':
+        case "enter":
+            return { kind: "submit" };
+        case "tab":
             // No completion in normal mode (matches vim/readline-vi).
-            return { kind: 'bell' };
-        case 'escape':
+            return { kind: "bell" };
+        case "escape":
             // Already normal; clear any half-formed operator.
             state.viPending = null;
-            return { kind: 'noop' };
-        case 'backspace':
+            return { kind: "noop" };
+        case "backspace":
             // In normal mode bare backspace is "move left" per readline-vi.
             state.buffer.moveLeft();
-            return { kind: 'redraw' };
-        case 'delete':
+            return { kind: "redraw" };
+        case "delete":
             state.buffer.deleteRight();
-            return { kind: 'redraw' };
-        case 'left':
+            return { kind: "redraw" };
+        case "left":
             state.buffer.moveLeft();
-            return { kind: 'redraw' };
-        case 'right':
+            return { kind: "redraw" };
+        case "right":
             state.buffer.moveRight();
-            return { kind: 'redraw' };
-        case 'up':
+            return { kind: "redraw" };
+        case "up":
             return navigateHistory(state, -1);
-        case 'down':
+        case "down":
             return navigateHistory(state, +1);
-        case 'home':
+        case "home":
             state.buffer.moveHome();
-            return { kind: 'redraw' };
-        case 'end':
+            return { kind: "redraw" };
+        case "end":
             state.buffer.moveEnd();
-            return { kind: 'redraw' };
-        case 'char':
+            return { kind: "redraw" };
+        case "char":
             return handleViNormalChar(state, ev);
-        case 'paste-start':
+        case "paste-start":
             state.pasting = true;
-            return { kind: 'paste-start' };
-        case 'paste-end':
+            return { kind: "paste-start" };
+        case "paste-end":
             state.pasting = false;
-            return { kind: 'paste-end' };
-        case 'pageup':
-        case 'pagedown':
-        case 'unknown':
-            return { kind: 'bell' };
+            return { kind: "paste-end" };
+        case "pageup":
+        case "pagedown":
+        case "unknown":
+            return { kind: "bell" };
     }
 };
 const handleViNormalChar = (state, ev) => {
-    const ch = ev.char ?? '';
+    const ch = ev.char ?? "";
     if (ch.length === 0)
-        return { kind: 'noop' };
+        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' };
+    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' };
+        return { kind: "bell" };
     switch (ch) {
         // Movement
-        case 'h':
+        case "h":
             state.buffer.moveLeft();
-            return { kind: 'redraw' };
-        case 'l':
+            return { kind: "redraw" };
+        case "l":
             state.buffer.moveRight();
-            return { kind: 'redraw' };
-        case 'b':
+            return { kind: "redraw" };
+        case "b":
             state.buffer.moveWordLeft();
-            return { kind: 'redraw' };
-        case 'w':
+            return { kind: "redraw" };
+        case "w":
             state.buffer.moveWordRight();
-            return { kind: 'redraw' };
-        case 'e':
+            return { kind: "redraw" };
+        case "e":
             viMoveEndOfWord(state.buffer);
-            return { kind: 'redraw' };
-        case '0':
+            return { kind: "redraw" };
+        case "0":
             state.buffer.moveHome();
-            return { kind: 'redraw' };
-        case '$':
+            return { kind: "redraw" };
+        case "$":
             state.buffer.moveEnd();
-            return { kind: 'redraw' };
-        case '^':
+            return { kind: "redraw" };
+        case "^":
             viMoveFirstNonBlank(state.buffer);
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         // History (vi-style j/k).
-        case 'j':
+        case "j":
             return navigateHistory(state, +1);
-        case 'k':
+        case "k":
             return navigateHistory(state, -1);
         // Mode switches.
-        case 'i':
-            state.mode = 'insert';
-            return { kind: 'redraw' };
-        case 'a':
+        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.mode = "insert";
+            return { kind: "redraw" };
+        case "I":
             state.buffer.moveHome();
-            state.mode = 'insert';
-            return { kind: 'redraw' };
-        case 'A':
+            state.mode = "insert";
+            return { kind: "redraw" };
+        case "A":
             state.buffer.moveEnd();
-            state.mode = 'insert';
-            return { kind: 'redraw' };
+            state.mode = "insert";
+            return { kind: "redraw" };
         // Edits.
-        case 'x':
+        case "x":
             state.buffer.deleteRight();
-            return { kind: 'redraw' };
-        case 'X':
+            return { kind: "redraw" };
+        case "X":
             state.buffer.deleteLeft();
-            return { kind: 'redraw' };
-        case 'D':
+            return { kind: "redraw" };
+        case "D":
             state.buffer.killToEnd();
-            return { kind: 'redraw' };
-        case '~':
+            return { kind: "redraw" };
+        case "~":
             viToggleCaseAtCursor(state.buffer);
-            return { kind: 'redraw' };
+            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':
+        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 ':':
+            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' };
+            state.mode = "ex";
+            state.exBuffer = "";
+            return { kind: "ex-update" };
         default:
-            return { kind: 'bell' };
+            return { kind: "bell" };
     }
 };
 /**
@@ -488,44 +495,44 @@ const handleViNormalChar = (state, ev) => {
  */
 const dispatchViEx = (state, ev) => {
     switch (ev.key) {
-        case 'escape':
+        case "escape":
             // Abort ex; back to normal without executing anything.
-            state.mode = 'normal';
-            state.exBuffer = '';
-            return { kind: 'redraw' };
-        case 'enter':
+            state.mode = "normal";
+            state.exBuffer = "";
+            return { kind: "redraw" };
+        case "enter":
             return executeExCommand(state);
-        case 'backspace':
+        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.mode = "normal";
+                return { kind: "redraw" };
             }
             state.exBuffer = state.exBuffer.slice(0, -1);
-            return { kind: 'ex-update' };
-        case 'char': {
-            const ch = ev.char ?? '';
+            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' };
+                return { kind: "bell" };
             state.exBuffer += ch;
-            return { kind: 'ex-update' };
+            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' };
+        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" };
     }
 };
 /**
@@ -536,22 +543,22 @@ const dispatchViEx = (state, ev) => {
 const executeExCommand = (state) => {
     const cmd = state.exBuffer.trim();
     // Always leave ex mode after Enter, even on unknown commands.
-    state.exBuffer = '';
-    state.mode = 'normal';
+    state.exBuffer = "";
+    state.mode = "normal";
     switch (cmd) {
-        case 'q':
-        case 'q!':
-        case 'quit':
+        case "q":
+        case "q!":
+        case "quit":
             // Abort the readLine. Same outcome as ^C — driver throws SignalError.
-            return { kind: 'cancel' };
-        case 'w':
+            return { kind: "cancel" };
+        case "w":
             // We don't have a file to write to; bell and return to normal.
-            return { kind: 'bell' };
-        case '':
+            return { kind: "bell" };
+        case "":
             // Bare `:` then Enter — just return to normal silently.
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         default:
-            return { kind: 'bell' };
+            return { kind: "bell" };
     }
 };
 /**
@@ -563,83 +570,83 @@ 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') {
+    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 (ev.key !== "char" || ev.char === undefined || ev.ctrl || ev.meta) {
+            return { kind: "bell" };
         }
         if (state.buffer.cursor >= state.buffer.length)
-            return { kind: 'bell' };
+            return { kind: "bell" };
         viReplaceCharAtCursor(state.buffer, ev.char);
-        return { kind: 'redraw' };
+        return { kind: "redraw" };
     }
-    if (pending === 'g') {
+    if (pending === "g") {
         // Only 'gg' is recognised; we don't actually implement first-history yet.
-        return { kind: 'bell' };
+        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' };
+    if (ev.key !== "char" || ev.char === undefined || ev.ctrl || ev.meta) {
+        return { kind: "bell" };
     }
     const c = ev.char;
-    if (pending === 'd') {
-        if (c === 'd') {
+    if (pending === "d") {
+        if (c === "d") {
             // dd: kill whole line.
             state.buffer.moveHome();
             state.buffer.killToEnd();
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         }
-        if (c === 'w') {
+        if (c === "w") {
             state.buffer.killWordRight();
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         }
-        if (c === 'b') {
+        if (c === "b") {
             state.buffer.killWordLeft();
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         }
-        if (c === '$') {
+        if (c === "$") {
             state.buffer.killToEnd();
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         }
-        if (c === '0') {
+        if (c === "0") {
             state.buffer.killToStart();
-            return { kind: 'redraw' };
+            return { kind: "redraw" };
         }
-        return { kind: 'bell' };
+        return { kind: "bell" };
     }
-    if (pending === 'c') {
-        if (c === 'c') {
+    if (pending === "c") {
+        if (c === "c") {
             // cc: kill whole line, enter insert.
             state.buffer.moveHome();
             state.buffer.killToEnd();
-            state.mode = 'insert';
-            return { kind: 'redraw' };
+            state.mode = "insert";
+            return { kind: "redraw" };
         }
-        if (c === 'w') {
+        if (c === "w") {
             state.buffer.killWordRight();
-            state.mode = 'insert';
-            return { kind: 'redraw' };
+            state.mode = "insert";
+            return { kind: "redraw" };
         }
-        if (c === 'b') {
+        if (c === "b") {
             state.buffer.killWordLeft();
-            state.mode = 'insert';
-            return { kind: 'redraw' };
+            state.mode = "insert";
+            return { kind: "redraw" };
         }
-        if (c === '$') {
+        if (c === "$") {
             state.buffer.killToEnd();
-            state.mode = 'insert';
-            return { kind: 'redraw' };
+            state.mode = "insert";
+            return { kind: "redraw" };
         }
-        if (c === '0') {
+        if (c === "0") {
             state.buffer.killToStart();
-            state.mode = 'insert';
-            return { kind: 'redraw' };
+            state.mode = "insert";
+            return { kind: "redraw" };
         }
-        return { kind: 'bell' };
+        return { kind: "bell" };
     }
-    return { kind: 'bell' };
+    return { kind: "bell" };
 };
 /** `e` motion: jump to the end of the current word (or the next word). */
 const viMoveEndOfWord = (buf) => {
@@ -666,7 +673,7 @@ const viMoveFirstNonBlank = (buf) => {
     const text = buf.text;
     const cps = Array.from(text);
     let i = 0;
-    while (i < cps.length && (cps[i] === ' ' || cps[i] === '\t'))
+    while (i < cps.length && (cps[i] === " " || cps[i] === "\t"))
         i++;
     buf.setText(text, i);
 };
@@ -686,7 +693,7 @@ const viToggleCaseAtCursor = (buf) => {
     }
     buf.pushUndo();
     cps[i] = flipped;
-    buf.setText(cps.join(''), Math.min(i + 1, cps.length));
+    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) => {
@@ -697,7 +704,7 @@ const viReplaceCharAtCursor = (buf, ch) => {
         return;
     buf.pushUndo();
     cps[i] = ch;
-    buf.setText(cps.join(''), i);
+    buf.setText(cps.join(""), i);
 };
 // Re-export for vi helpers that need word classification (matches buffer.ts).
 const isWordChar = (ch) => {
@@ -734,5 +741,5 @@ const transpose = (buf) => {
     const tmp = cps[i - 1];
     cps[i - 1] = cps[i];
     cps[i] = tmp;
-    buf.setText(cps.join(''), Math.min(i + 1, len));
+    buf.setText(cps.join(""), Math.min(i + 1, len));
 };