ep_vim 0.6.1 → 0.9.1

package/static/js/index.js

@@ -9,64 +9,53 @@ const {
   wordBackward,
   wordEnd,
   charSearchPos,
-  motionRange,
   charMotionRange,
+  paragraphForward,
+  paragraphBackward,
+  matchingBracketPos,
   textWordRange,
   textQuoteRange,
   textBracketRange,
-  getVisualSelection,
-  paragraphForward,
-  paragraphBackward,
   getTextInRange,
+  getVisualSelection,
+  paragraphTextRange,
+  sentenceTextRange,
+  getFullText,
+  posToAbsolute,
+  absoluteToPos,
+  searchForward,
+  searchBackward,
 } = require("./vim-core");
 
-// --- State variables ---
+// --- State ---
 
 let vimEnabled = localStorage.getItem("ep_vimEnabled") === "true";
-let insertMode = false;
-let visualMode = null;
-let visualAnchor = null;
-let visualCursor = null;
+let mode = "normal";
 let pendingKey = null;
-let pendingOperator = null;
 let pendingCount = null;
 let countBuffer = "";
 let register = null;
 let marks = {};
+let lastCharSearch = null;
+let visualAnchor = null;
+let visualCursor = null;
 let editorDoc = null;
 let currentRep = null;
 let desiredColumn = null;
-let lastCharSearch = null;
-
-const QUOTE_CHARS = new Set(['"', "'"]);
-const BRACKET_CHARS = new Set(["(", ")", "{", "}", "[", "]"]);
-
-const textObjectRange = (key, lineText, char, type) => {
-  if (key === "w") return textWordRange(lineText, char, type);
-  if (QUOTE_CHARS.has(key)) return textQuoteRange(lineText, char, key, type);
-  if (BRACKET_CHARS.has(key))
-    return textBracketRange(lineText, char, key, type);
-};
+let lastCommand = null;
+let searchMode = false;
+let searchBuffer = "";
+let searchDirection = null;
+let lastSearch = null;
 
-// --- Count helpers ---
-
-const consumeCount = () => {
-  if (countBuffer !== "") {
-    pendingCount = parseInt(countBuffer, 10);
-    countBuffer = "";
-  } else if (pendingKey === null && pendingOperator === null) {
-    pendingCount = null;
-  }
-};
-
-const getCount = () => pendingCount || 1;
-
-// --- Side-effectful helpers ---
+// --- Editor operations ---
 
 const setRegister = (value) => {
   register = value;
   const text = Array.isArray(value) ? value.join("\n") + "\n" : value;
-  navigator.clipboard.writeText(text).catch(() => {});
+  if (navigator.clipboard) {
+    navigator.clipboard.writeText(text).catch(() => {});
+  }
 };
 
 const moveCursor = (editorInfo, line, char) => {
@@ -77,22 +66,10 @@ const moveCursor = (editorInfo, line, char) => {
   });
 };
 
-const clearEmptyLineCursor = () => {
-  if (!editorDoc) return;
-  const old = editorDoc.querySelector(".vim-empty-line-cursor");
-  if (old) old.classList.remove("vim-empty-line-cursor");
-};
-
-const moveBlockCursor = (editorInfo, line, char) => {
-  clearEmptyLineCursor();
-  const lineText = currentRep ? getLineText(currentRep, line) : "";
-  if (lineText.length === 0 && editorDoc) {
-    const lineDiv = editorDoc.body.querySelectorAll("div")[line];
-    if (lineDiv) lineDiv.classList.add("vim-empty-line-cursor");
-    selectRange(editorInfo, [line, 0], [line, 0]);
-  } else {
-    selectRange(editorInfo, [line, char], [line, char + 1]);
-  }
+const replaceRange = (editorInfo, start, end, text) => {
+  editorInfo.ace_inCallStackIfNecessary("vim-edit", () => {
+    editorInfo.ace_performDocumentReplaceRange(start, end, text);
+  });
 };
 
 const selectRange = (editorInfo, start, end) => {
@@ -102,37 +79,10 @@ const selectRange = (editorInfo, start, end) => {
   });
 };
 
-const replaceRange = (editorInfo, start, end, text) => {
-  editorInfo.ace_inCallStackIfNecessary("vim-edit", () => {
-    editorInfo.ace_performDocumentReplaceRange(start, end, text);
-  });
-};
-
-const undo = (editorInfo) => {
-  editorInfo.ace_doUndoRedo("undo");
-};
-
-// --- Mode management ---
-
-const setInsertMode = (value) => {
-  insertMode = value;
-  if (value) clearEmptyLineCursor();
-  if (editorDoc) {
-    editorDoc.body.classList.toggle("vim-insert-mode", value);
-  }
-};
-
-const setVisualMode = (value) => {
-  visualMode = value;
-  if (editorDoc) {
-    editorDoc.body.classList.toggle("vim-visual-line-mode", value === "line");
-    editorDoc.body.classList.toggle("vim-visual-char-mode", value === "char");
-  }
-};
-
 const updateVisualSelection = (editorInfo, rep) => {
+  const vMode = mode === "visual-line" ? "line" : "char";
   const [start, end] = getVisualSelection(
-    visualMode,
+    vMode,
     visualAnchor,
     visualCursor,
     rep,
@@ -140,201 +90,38 @@ const updateVisualSelection = (editorInfo, rep) => {
   selectRange(editorInfo, start, end);
 };
 
-// --- Motion resolution (shared between normal and visual) ---
-
-const resolveMotion = (key, line, char, lineText, rep, count) => {
-  if (
-    pendingKey === "f" ||
-    pendingKey === "F" ||
-    pendingKey === "t" ||
-    pendingKey === "T"
-  ) {
-    const direction = pendingKey;
-    pendingKey = null;
-    lastCharSearch = { direction, target: key };
-    const pos = charSearchPos(direction, lineText, char, key, count);
-    if (pos !== -1) {
-      desiredColumn = null;
-      return { line, char: pos };
-    }
-    return { line, char };
-  }
-
-  if (pendingKey === "'" || pendingKey === "`") {
-    const jumpType = pendingKey;
-    pendingKey = null;
-    if (key >= "a" && key <= "z" && marks[key]) {
-      const [markLine, markChar] = marks[key];
-      desiredColumn = null;
-      if (jumpType === "'") {
-        const targetLineText = getLineText(rep, markLine);
-        return { line: markLine, char: firstNonBlank(targetLineText) };
-      }
-      return { line: markLine, char: markChar };
-    }
-    return { line, char };
-  }
-
-  if (pendingKey === "g") {
-    pendingKey = null;
-    if (key === "g") {
-      desiredColumn = null;
-      if (pendingCount !== null) {
-        return { line: clampLine(pendingCount - 1, rep), char: 0 };
-      }
-      return { line: 0, char: 0 };
-    }
-  }
-
-  if (key === "h") {
-    desiredColumn = null;
-    return { line, char: Math.max(0, char - count) };
-  }
-
-  if (key === "l") {
-    desiredColumn = null;
-    return { line, char: clampChar(char + count, lineText) };
-  }
-
-  if (key === "j") {
-    if (desiredColumn === null) desiredColumn = char;
-    const newLine = clampLine(line + count, rep);
-    const newLineText = getLineText(rep, newLine);
-    return { line: newLine, char: clampChar(desiredColumn, newLineText) };
-  }
-
-  if (key === "k") {
-    if (desiredColumn === null) desiredColumn = char;
-    const newLine = clampLine(line - count, rep);
-    const newLineText = getLineText(rep, newLine);
-    return { line: newLine, char: clampChar(desiredColumn, newLineText) };
-  }
-
-  if (key === "w") {
-    desiredColumn = null;
-    let pos = char;
-    for (let i = 0; i < count; i++) pos = wordForward(lineText, pos);
-    return { line, char: clampChar(pos, lineText) };
-  }
-
-  if (key === "b") {
-    desiredColumn = null;
-    let pos = char;
-    for (let i = 0; i < count; i++) pos = wordBackward(lineText, pos);
-    return { line, char: pos };
-  }
-
-  if (key === "e") {
-    desiredColumn = null;
-    let pos = char;
-    for (let i = 0; i < count; i++) pos = wordEnd(lineText, pos);
-    return { line, char: clampChar(pos, lineText) };
-  }
-
-  if (key === "0") {
-    desiredColumn = null;
-    return { line, char: 0 };
-  }
-
-  if (key === "$") {
-    desiredColumn = null;
-    return { line, char: clampChar(lineText.length - 1, lineText) };
-  }
-
-  if (key === "^") {
-    desiredColumn = null;
-    return { line, char: firstNonBlank(lineText) };
-  }
-
-  if (key === "}") {
-    desiredColumn = null;
-    return { line: paragraphForward(rep, line, count), char: 0 };
-  }
-
-  if (key === "{") {
-    desiredColumn = null;
-    return { line: paragraphBackward(rep, line, count), char: 0 };
-  }
-
-  if (key === "G") {
-    desiredColumn = null;
-    if (pendingCount !== null) {
-      return { line: clampLine(pendingCount - 1, rep), char: 0 };
-    }
-    return { line: rep.lines.length() - 1, char: 0 };
-  }
-
-  if (key === ";") {
-    if (lastCharSearch) {
-      const pos = charSearchPos(
-        lastCharSearch.direction,
-        lineText,
-        char,
-        lastCharSearch.target,
-        count,
-      );
-      if (pos !== -1) {
-        desiredColumn = null;
-        return { line, char: pos };
-      }
-    }
-    return { line, char };
-  }
-
-  if (key === ",") {
-    if (lastCharSearch) {
-      const opposite = { f: "F", F: "f", t: "T", T: "t" };
-      const reverseDir = opposite[lastCharSearch.direction];
-      const pos = charSearchPos(
-        reverseDir,
-        lineText,
-        char,
-        lastCharSearch.target,
-        count,
-      );
-      if (pos !== -1) {
-        desiredColumn = null;
-        return { line, char: pos };
-      }
-    }
-    return { line, char };
-  }
-
-  if (key === "f" || key === "F" || key === "t" || key === "T") {
-    pendingKey = key;
-    return "pending";
-  }
-
-  if (key === "'" || key === "`") {
-    pendingKey = key;
-    return "pending";
-  }
-
-  if (key === "g") {
-    pendingKey = "g";
-    return "pending";
-  }
-
-  return null;
+const clearEmptyLineCursor = () => {
+  if (!editorDoc) return;
+  const old = editorDoc.querySelector(".vim-empty-line-cursor");
+  if (old) old.classList.remove("vim-empty-line-cursor");
 };
 
-// --- Apply motion (mode-aware cursor placement) ---
+const scrollLineIntoView = (line) => {
+  if (!editorDoc) return;
+  const lineDiv = editorDoc.body.querySelectorAll("div")[line];
+  if (lineDiv) lineDiv.scrollIntoView({ block: "nearest" });
+};
 
-const applyMotion = (editorInfo, rep, newLine, newChar) => {
-  if (visualMode !== null) {
-    visualCursor = [newLine, newChar];
-    updateVisualSelection(editorInfo, rep);
+const moveBlockCursor = (editorInfo, line, char) => {
+  clearEmptyLineCursor();
+  const lineText = currentRep ? getLineText(currentRep, line) : "";
+  if (lineText.length === 0 && editorDoc) {
+    const lineDiv = editorDoc.body.querySelectorAll("div")[line];
+    if (lineDiv) lineDiv.classList.add("vim-empty-line-cursor");
+    selectRange(editorInfo, [line, 0], [line, 0]);
   } else {
-    moveBlockCursor(editorInfo, newLine, newChar);
+    selectRange(editorInfo, [line, char], [line, char + 1]);
   }
+  scrollLineIntoView(line);
+};
 
-  if (editorDoc) {
-    const lineDiv = editorDoc.body.querySelectorAll("div")[newLine];
-    if (lineDiv) lineDiv.scrollIntoView({ block: "nearest" });
-  }
+const moveVisualCursor = (editorInfo, rep, line, char) => {
+  visualCursor = [line, char];
+  updateVisualSelection(editorInfo, rep);
+  scrollLineIntoView(line);
 };
 
-// --- Line deletion helper ---
+// --- Line helpers ---
 
 const deleteLines = (editorInfo, rep, topLine, bottomLine) => {
   const totalLines = rep.lines.length();
@@ -361,53 +148,22 @@ const deleteLines = (editorInfo, rep, topLine, bottomLine) => {
   return 0;
 };
 
-// --- Operator application ---
-
-const applyCharOperator = (operator, start, end, editorInfo, rep) => {
-  if (start[0] === end[0]) {
-    const lineText = getLineText(rep, start[0]);
-    setRegister(lineText.slice(start[1], end[1]));
-  } else {
-    setRegister(getTextInRange(rep, start, end));
-  }
-  if (operator === "y") {
-    moveBlockCursor(editorInfo, start[0], start[1]);
-    return;
-  }
-  replaceRange(editorInfo, start, end, "");
-  if (operator === "c") {
-    moveCursor(editorInfo, start[0], start[1]);
-    setInsertMode(true);
-  } else {
-    const newLineText = getLineText(rep, start[0]);
-    moveBlockCursor(editorInfo, start[0], clampChar(start[1], newLineText));
-  }
-};
-
-const applyLineOperator = (
-  operator,
-  topLine,
-  bottomLine,
-  editorInfo,
-  rep,
-  char,
-) => {
+const applyLineOperator = (op, topLine, bottomLine, ctx) => {
+  const { editorInfo, rep, char } = ctx;
   const lines = [];
-  for (let i = topLine; i <= bottomLine; i++) {
-    lines.push(getLineText(rep, i));
-  }
+  for (let i = topLine; i <= bottomLine; i++) lines.push(getLineText(rep, i));
   setRegister(lines);
-  if (operator === "y") {
+  if (op === "y") {
     moveBlockCursor(editorInfo, topLine, 0);
     return;
   }
-  if (operator === "c") {
+  if (op === "c") {
     for (let i = topLine; i <= bottomLine; i++) {
       const text = getLineText(rep, i);
       replaceRange(editorInfo, [topLine, 0], [topLine, text.length], "");
     }
     moveCursor(editorInfo, topLine, 0);
-    setInsertMode(true);
+    mode = "insert";
     return;
   }
   const cursorLine = deleteLines(editorInfo, rep, topLine, bottomLine);
@@ -415,390 +171,920 @@ const applyLineOperator = (
   moveBlockCursor(editorInfo, cursorLine, clampChar(char, newLineText));
 };
 
-// --- Unified key handler ---
-
-const handleKey = (rep, editorInfo, key) => {
-  const inVisual = visualMode !== null;
-  const line = inVisual ? visualCursor[0] : rep.selStart[0];
-  const char = inVisual ? visualCursor[1] : rep.selStart[1];
-  const lineText = getLineText(rep, line);
+// --- Operator helper ---
 
-  if (key >= "1" && key <= "9") {
-    countBuffer += key;
-    return true;
+const applyOperator = (op, start, end, ctx) => {
+  const { editorInfo, rep } = ctx;
+  const before =
+    start[0] < end[0] || (start[0] === end[0] && start[1] <= end[1]);
+  const [s, e] = before ? [start, end] : [end, start];
+  setRegister(getTextInRange(rep, s, e));
+  if (op === "y") {
+    moveBlockCursor(editorInfo, s[0], s[1]);
+    return;
   }
-  if (key === "0" && countBuffer !== "") {
-    countBuffer += key;
-    return true;
+  replaceRange(editorInfo, s, e, "");
+  if (op === "c") {
+    moveCursor(editorInfo, s[0], s[1]);
+    mode = "insert";
+  } else {
+    moveBlockCursor(editorInfo, s[0], s[1]);
   }
+};
 
-  consumeCount();
-  const count = getCount();
+// --- Command tables ---
+const commands = {
+  normal: {},
+  "visual-char": {},
+  "visual-line": {},
+};
 
-  // --- Normal-only pending states: r + char, m + letter ---
+// --- Registration helpers ---
+const OPERATORS = ["d", "c", "y"];
 
-  if (pendingKey === "r") {
-    pendingKey = null;
-    if (lineText.length > 0) {
-      replaceRange(editorInfo, [line, char], [line, char + 1], key);
-      moveBlockCursor(editorInfo, line, char);
-    }
-    return true;
+const resolveTextObject = (key, type, line, lineText, char, rep) => {
+  if (key === "p") {
+    return paragraphTextRange(rep, line, type);
   }
-
-  if (pendingKey === "m") {
-    pendingKey = null;
-    if (key >= "a" && key <= "z") {
-      marks[key] = [line, char];
-    }
-    return true;
+  if (key === "s") {
+    const r = sentenceTextRange(lineText, char, type);
+    if (!r) return null;
+    return {
+      startLine: line,
+      startChar: r.start,
+      endLine: line,
+      endChar: r.end,
+    };
   }
+  const r =
+    key === "w"
+      ? textWordRange(lineText, char, type)
+      : ["(", ")", "{", "}", "[", "]"].includes(key)
+        ? textBracketRange(lineText, char, key, type)
+        : ['"', "'", "`"].includes(key)
+          ? textQuoteRange(lineText, char, key, type)
+          : null;
+  if (!r) return null;
+  return { startLine: line, startChar: r.start, endLine: line, endChar: r.end };
+};
 
-  // --- Operator-pending: resolve target ---
+const recordCommand = (key, count, param = null) => {
+  lastCommand = { key, count, param };
+};
 
-  if (pendingOperator !== null) {
-    const op = pendingOperator;
+const registerMotion = (key, getEndPos, inclusive = false) => {
+  commands.normal[key] = (ctx) => {
+    desiredColumn = null;
+    const pos = getEndPos(ctx);
+    if (pos) moveBlockCursor(ctx.editorInfo, pos.line, pos.char);
+  };
+  commands["visual-char"][key] = (ctx) => {
+    desiredColumn = null;
+    const pos = getEndPos(ctx);
+    if (pos) moveVisualCursor(ctx.editorInfo, ctx.rep, pos.line, pos.char);
+  };
+  commands["visual-line"][key] = (ctx) => {
+    desiredColumn = null;
+    const pos = getEndPos(ctx);
+    if (pos) moveVisualCursor(ctx.editorInfo, ctx.rep, pos.line, pos.char);
+  };
+  for (const op of OPERATORS) {
+    commands.normal[op + key] = (ctx) => {
+      desiredColumn = null;
+      const pos = getEndPos(ctx);
+      if (pos) {
+        const endChar = inclusive ? pos.char + 1 : pos.char;
+        applyOperator(op, [ctx.line, ctx.char], [pos.line, endChar], ctx);
+        recordCommand(op + key, ctx.count);
+      }
+    };
+  }
+};
 
-    if (key === op) {
-      pendingOperator = null;
-      const lineCount = rep.lines.length();
-      const opCount = Math.min(count, lineCount - line);
-      const lastLine = line + opCount - 1;
-      applyLineOperator(op, line, lastLine, editorInfo, rep, char);
-      return true;
-    }
+const parameterized = {};
 
-    if (pendingKey === "i" || pendingKey === "a") {
-      const type = pendingKey;
-      pendingKey = null;
-      pendingOperator = null;
-      const range = textObjectRange(key, lineText, char, type);
-      if (range) {
-        applyCharOperator(
-          op,
-          [line, range.start],
-          [line, range.end],
-          editorInfo,
-          rep,
-        );
+const registerParamMotion = (key, getEndChar) => {
+  commands.normal[key] = () => {
+    pendingKey = key;
+  };
+  commands["visual-char"][key] = () => {
+    pendingKey = key;
+  };
+  commands["visual-line"][key] = () => {
+    pendingKey = key;
+  };
+  parameterized[key] = (argKey, ctx) => {
+    lastCharSearch = { direction: key, target: argKey };
+    const pos = getEndChar(argKey, ctx);
+    if (pos !== null) {
+      if (mode.startsWith("visual")) {
+        moveVisualCursor(ctx.editorInfo, ctx.rep, ctx.line, pos);
+      } else {
+        moveBlockCursor(ctx.editorInfo, ctx.line, pos);
       }
-      return true;
+      recordCommand(key, ctx.count, argKey);
     }
-
-    if (
-      pendingKey === "f" ||
-      pendingKey === "F" ||
-      pendingKey === "t" ||
-      pendingKey === "T"
-    ) {
-      const direction = pendingKey;
-      pendingKey = null;
-      pendingOperator = null;
-      lastCharSearch = { direction, target: key };
-      const pos = charSearchPos(direction, lineText, char, key, count);
-      if (pos !== -1) {
-        const range = charMotionRange(direction, char, pos);
-        if (range) {
-          applyCharOperator(
+  };
+  for (const op of OPERATORS) {
+    const combo = op + key;
+    commands.normal[combo] = () => {
+      pendingKey = combo;
+    };
+    parameterized[combo] = (argKey, ctx) => {
+      lastCharSearch = { direction: key, target: argKey };
+      const pos = getEndChar(argKey, ctx);
+      if (pos !== null) {
+        const range = charMotionRange(key, ctx.char, pos);
+        if (range)
+          applyOperator(
             op,
-            [line, range.start],
-            [line, range.end],
-            editorInfo,
-            rep,
+            [ctx.line, range.start],
+            [ctx.line, range.end],
+            ctx,
           );
-        }
+        recordCommand(combo, ctx.count, argKey);
       }
-      return true;
-    }
+    };
+  }
+};
 
-    if (key === "i" || key === "a") {
-      pendingKey = key;
-      return true;
+const registerTextObject = (obj, getRange) => {
+  for (const op of OPERATORS) {
+    for (const type of ["i", "a"]) {
+      commands.normal[`${op}${type}${obj}`] = (ctx) => {
+        const range = getRange(ctx, type);
+        if (range) applyOperator(op, range.start, range.end, ctx);
+      };
     }
+  }
+};
 
-    if (key === "f" || key === "F" || key === "t" || key === "T") {
-      pendingKey = key;
-      return true;
+const getVisibleLineRange = (rep) => {
+  const totalLines = rep.lines.length();
+  if (!editorDoc) return { top: 0, bottom: totalLines - 1 };
+  const lineDivs = editorDoc.body.querySelectorAll("div");
+  const lineCount = Math.min(lineDivs.length, totalLines);
+  const frameEl = editorDoc.defaultView.frameElement;
+  const iframeTop = frameEl ? frameEl.getBoundingClientRect().top : 0;
+  const outerViewportHeight = window.parent ? window.parent.innerHeight : 600;
+  let top = 0;
+  let bottom = lineCount - 1;
+  for (let i = 0; i < lineCount; i++) {
+    const rect = lineDivs[i].getBoundingClientRect();
+    if (iframeTop + rect.bottom > 0) {
+      top = i;
+      break;
     }
-
-    pendingOperator = null;
-    const range = motionRange(key, char, lineText, count);
-    if (range && range.end > range.start) {
-      applyCharOperator(
-        op,
-        [line, range.start],
-        [line, range.end],
-        editorInfo,
-        rep,
-      );
+  }
+  for (let i = lineCount - 1; i >= 0; i--) {
+    const rect = lineDivs[i].getBoundingClientRect();
+    if (iframeTop + rect.top < outerViewportHeight) {
+      bottom = i;
+      break;
     }
-    return true;
   }
-
-  // --- Text object in visual mode (i/a + object key) ---
-
-  if (inVisual && (pendingKey === "i" || pendingKey === "a")) {
-    const type = pendingKey;
-    pendingKey = null;
-    const range = textObjectRange(key, lineText, char, type);
-    if (range) {
-      visualAnchor = [line, range.start];
-      visualCursor = [line, range.end];
-      setVisualMode("char");
-      updateVisualSelection(editorInfo, rep);
+  const visibleTop = iframeTop + lineDivs[top].getBoundingClientRect().top;
+  const visibleBottom =
+    iframeTop + lineDivs[bottom].getBoundingClientRect().bottom;
+  const pixelMidpoint = (visibleTop + visibleBottom) / 2;
+  let mid = top;
+  for (let i = top; i <= bottom; i++) {
+    const rect = lineDivs[i].getBoundingClientRect();
+    if (iframeTop + (rect.top + rect.bottom) / 2 >= pixelMidpoint) {
+      mid = i;
+      break;
     }
-    return true;
   }
+  return { top, mid, bottom };
+};
 
-  // --- Motions (shared between normal and visual) ---
+// --- Motions ---
+registerMotion("h", (ctx) => ({
+  line: ctx.line,
+  char: Math.max(0, ctx.char - ctx.count),
+}));
+
+registerMotion("l", (ctx) => ({
+  line: ctx.line,
+  char: clampChar(ctx.char + ctx.count, ctx.lineText),
+}));
+
+registerMotion("j", (ctx) => {
+  if (desiredColumn === null) desiredColumn = ctx.char;
+  const newLine = clampLine(ctx.line + ctx.count, ctx.rep);
+  const newLineText = getLineText(ctx.rep, newLine);
+  return { line: newLine, char: clampChar(desiredColumn, newLineText) };
+});
+
+registerMotion("k", (ctx) => {
+  if (desiredColumn === null) desiredColumn = ctx.char;
+  const newLine = clampLine(ctx.line - ctx.count, ctx.rep);
+  const newLineText = getLineText(ctx.rep, newLine);
+  return { line: newLine, char: clampChar(desiredColumn, newLineText) };
+});
+
+registerMotion("w", (ctx) => {
+  let pos = ctx.char;
+  for (let i = 0; i < ctx.count; i++) pos = wordForward(ctx.lineText, pos);
+  return { line: ctx.line, char: clampChar(pos, ctx.lineText) };
+});
+
+registerMotion("b", (ctx) => {
+  let pos = ctx.char;
+  for (let i = 0; i < ctx.count; i++) pos = wordBackward(ctx.lineText, pos);
+  return { line: ctx.line, char: pos };
+});
+
+registerMotion(
+  "e",
+  (ctx) => {
+    let pos = ctx.char;
+    for (let i = 0; i < ctx.count; i++) pos = wordEnd(ctx.lineText, pos);
+    return { line: ctx.line, char: clampChar(pos, ctx.lineText) };
+  },
+  true,
+);
+
+registerMotion("0", (_ctx) => ({ line: _ctx.line, char: 0 }));
+
+registerMotion(
+  "$",
+  (ctx) => ({
+    line: ctx.line,
+    char: clampChar(ctx.lineText.length - 1, ctx.lineText),
+  }),
+  true,
+);
+
+registerMotion("^", (ctx) => ({
+  line: ctx.line,
+  char: firstNonBlank(ctx.lineText),
+}));
+
+registerMotion("gg", (ctx) => ({
+  line: ctx.hasCount ? clampLine(ctx.count - 1, ctx.rep) : 0,
+  char: 0,
+}));
+
+registerMotion("G", (ctx) => ({
+  line: ctx.hasCount
+    ? clampLine(ctx.count - 1, ctx.rep)
+    : ctx.rep.lines.length() - 1,
+  char: 0,
+}));
+
+registerMotion("{", (ctx) => ({
+  line: paragraphBackward(ctx.rep, ctx.line, ctx.count),
+  char: 0,
+}));
+
+registerMotion("}", (ctx) => ({
+  line: paragraphForward(ctx.rep, ctx.line, ctx.count),
+  char: 0,
+}));
+
+registerMotion(
+  "%",
+  (ctx) => {
+    const pos = matchingBracketPos(ctx.rep, ctx.line, ctx.char);
+    return pos || { line: ctx.line, char: ctx.char };
+  },
+  true,
+);
+
+registerMotion("H", (ctx) => {
+  const { top } = getVisibleLineRange(ctx.rep);
+  const targetLine = clampLine(top + ctx.count - 1, ctx.rep);
+  return {
+    line: targetLine,
+    char: firstNonBlank(getLineText(ctx.rep, targetLine)),
+  };
+});
+
+registerMotion("M", (ctx) => {
+  const { mid } = getVisibleLineRange(ctx.rep);
+  return {
+    line: mid,
+    char: firstNonBlank(getLineText(ctx.rep, mid)),
+  };
+});
+
+registerMotion("L", (ctx) => {
+  const { bottom } = getVisibleLineRange(ctx.rep);
+  const targetLine = clampLine(bottom - ctx.count + 1, ctx.rep);
+  return {
+    line: targetLine,
+    char: firstNonBlank(getLineText(ctx.rep, targetLine)),
+  };
+});
+
+registerParamMotion("f", (key, ctx) => {
+  const pos = charSearchPos("f", ctx.lineText, ctx.char, key, ctx.count);
+  return pos !== -1 ? pos : null;
+});
+
+registerParamMotion("F", (key, ctx) => {
+  const pos = charSearchPos("F", ctx.lineText, ctx.char, key, ctx.count);
+  return pos !== -1 ? pos : null;
+});
+
+registerParamMotion("t", (key, ctx) => {
+  const pos = charSearchPos("t", ctx.lineText, ctx.char, key, ctx.count);
+  return pos !== -1 ? pos : null;
+});
+
+registerParamMotion("T", (key, ctx) => {
+  const pos = charSearchPos("T", ctx.lineText, ctx.char, key, ctx.count);
+  return pos !== -1 ? pos : null;
+});
+
+commands.normal[";"] = (ctx) => {
+  if (!lastCharSearch) return;
+  const pos = charSearchPos(
+    lastCharSearch.direction,
+    ctx.lineText,
+    ctx.char,
+    lastCharSearch.target,
+    ctx.count,
+  );
+  if (pos !== -1) moveBlockCursor(ctx.editorInfo, ctx.line, pos);
+};
 
-  const motion = resolveMotion(key, line, char, lineText, rep, count);
-  if (motion === "pending") return true;
-  if (motion) {
-    applyMotion(editorInfo, rep, motion.line, motion.char);
-    return true;
+commands.normal[","] = (ctx) => {
+  if (!lastCharSearch) return;
+  const opposite = { f: "F", F: "f", t: "T", T: "t" };
+  const dir = opposite[lastCharSearch.direction];
+  const pos = charSearchPos(
+    dir,
+    ctx.lineText,
+    ctx.char,
+    lastCharSearch.target,
+    ctx.count,
+  );
+  if (pos !== -1) moveBlockCursor(ctx.editorInfo, ctx.line, pos);
+};
+
+commands["visual-char"][";"] = (ctx) => {
+  if (!lastCharSearch) return;
+  const pos = charSearchPos(
+    lastCharSearch.direction,
+    ctx.lineText,
+    ctx.char,
+    lastCharSearch.target,
+    ctx.count,
+  );
+  if (pos !== -1) moveVisualCursor(ctx.editorInfo, ctx.rep, ctx.line, pos);
+};
+
+commands["visual-char"][","] = (ctx) => {
+  if (!lastCharSearch) return;
+  const opposite = { f: "F", F: "f", t: "T", T: "t" };
+  const dir = opposite[lastCharSearch.direction];
+  const pos = charSearchPos(
+    dir,
+    ctx.lineText,
+    ctx.char,
+    lastCharSearch.target,
+    ctx.count,
+  );
+  if (pos !== -1) moveVisualCursor(ctx.editorInfo, ctx.rep, ctx.line, pos);
+};
+
+commands["visual-line"][";"] = (ctx) => {
+  if (!lastCharSearch) return;
+  const pos = charSearchPos(
+    lastCharSearch.direction,
+    ctx.lineText,
+    ctx.char,
+    lastCharSearch.target,
+    ctx.count,
+  );
+  if (pos !== -1) moveVisualCursor(ctx.editorInfo, ctx.rep, ctx.line, pos);
+};
+
+commands["visual-line"][","] = (ctx) => {
+  if (!lastCharSearch) return;
+  const opposite = { f: "F", F: "f", t: "T", T: "t" };
+  const dir = opposite[lastCharSearch.direction];
+  const pos = charSearchPos(
+    dir,
+    ctx.lineText,
+    ctx.char,
+    lastCharSearch.target,
+    ctx.count,
+  );
+  if (pos !== -1) moveVisualCursor(ctx.editorInfo, ctx.rep, ctx.line, pos);
+};
+
+// --- Marks ---
+
+commands.normal["m"] = () => {
+  pendingKey = "m";
+};
+parameterized["m"] = (key, ctx) => {
+  if (key >= "a" && key <= "z") marks[key] = [ctx.line, ctx.char];
+};
+
+commands.normal["'"] = () => {
+  pendingKey = "'";
+};
+commands["visual-char"]["'"] = () => {
+  pendingKey = "'";
+};
+commands["visual-line"]["'"] = () => {
+  pendingKey = "'";
+};
+parameterized["'"] = (key, ctx) => {
+  if (!marks[key]) return;
+  const [markLine] = marks[key];
+  const targetText = getLineText(ctx.rep, markLine);
+  const targetChar = firstNonBlank(targetText);
+  if (mode.startsWith("visual")) {
+    moveVisualCursor(ctx.editorInfo, ctx.rep, markLine, targetChar);
+  } else {
+    moveBlockCursor(ctx.editorInfo, markLine, targetChar);
+  }
+};
+
+commands.normal["`"] = () => {
+  pendingKey = "`";
+};
+commands["visual-char"]["`"] = () => {
+  pendingKey = "`";
+};
+commands["visual-line"]["`"] = () => {
+  pendingKey = "`";
+};
+parameterized["`"] = (key, ctx) => {
+  if (!marks[key]) return;
+  const [markLine, markChar] = marks[key];
+  if (mode.startsWith("visual")) {
+    moveVisualCursor(ctx.editorInfo, ctx.rep, markLine, markChar);
+  } else {
+    moveBlockCursor(ctx.editorInfo, markLine, markChar);
   }
+};
 
-  // --- Operators (d/c/y) ---
+// --- Text objects ---
 
-  if (key === "d" || key === "c" || key === "y") {
-    if (inVisual) {
-      if (visualMode === "char") {
-        const [start, end] = getVisualSelection(
-          visualMode,
-          visualAnchor,
-          visualCursor,
-          rep,
-        );
-        setVisualMode(null);
-        applyCharOperator(key, start, end, editorInfo, rep);
-      } else {
-        const topLine = Math.min(visualAnchor[0], visualCursor[0]);
-        const bottomLine = Math.max(visualAnchor[0], visualCursor[0]);
-        setVisualMode(null);
-        applyLineOperator(key, topLine, bottomLine, editorInfo, rep, 0);
-      }
-      return true;
-    }
-    pendingOperator = key;
-    return true;
+registerTextObject("w", (ctx, type) => {
+  const r = textWordRange(ctx.lineText, ctx.char, type);
+  if (!r) return null;
+  return { start: [ctx.line, r.start], end: [ctx.line, r.end] };
+});
+
+for (const q of ['"', "'", "`"]) {
+  registerTextObject(q, (ctx, type) => {
+    const r = textQuoteRange(ctx.lineText, ctx.char, q, type);
+    if (!r) return null;
+    return { start: [ctx.line, r.start], end: [ctx.line, r.end] };
+  });
+}
+
+for (const bracket of ["(", ")", "{", "}", "[", "]"]) {
+  registerTextObject(bracket, (ctx, type) => {
+    const r = textBracketRange(ctx.lineText, ctx.char, bracket, type);
+    if (!r) return null;
+    return { start: [ctx.line, r.start], end: [ctx.line, r.end] };
+  });
+}
+
+registerTextObject("p", (ctx, type) => {
+  const r = paragraphTextRange(ctx.rep, ctx.line, type);
+  if (!r) return null;
+  return {
+    start: [r.startLine, r.startChar],
+    end: [r.endLine, r.endChar],
+  };
+});
+
+registerTextObject("s", (ctx, type) => {
+  const r = sentenceTextRange(ctx.lineText, ctx.char, type);
+  if (!r) return null;
+  return { start: [ctx.line, r.start], end: [ctx.line, r.end] };
+});
+
+// --- Line operators ---
+
+for (const op of OPERATORS) {
+  commands.normal[op + op] = (ctx) => {
+    const bottomLine = clampLine(ctx.line + ctx.count - 1, ctx.rep);
+    applyLineOperator(op, ctx.line, bottomLine, ctx);
+    recordCommand(op + op, ctx.count);
+  };
+}
+
+// --- Visual modes ---
+
+commands.normal["v"] = ({ editorInfo, rep, line, char }) => {
+  visualAnchor = [line, char];
+  visualCursor = [line, char];
+  mode = "visual-char";
+  updateVisualSelection(editorInfo, rep);
+};
+
+commands.normal["V"] = ({ editorInfo, rep, line }) => {
+  visualAnchor = [line, 0];
+  visualCursor = [line, 0];
+  mode = "visual-line";
+  updateVisualSelection(editorInfo, rep);
+};
+
+for (const op of OPERATORS) {
+  commands["visual-line"][op] = (ctx) => {
+    const topLine = Math.min(visualAnchor[0], visualCursor[0]);
+    const bottomLine = Math.max(visualAnchor[0], visualCursor[0]);
+    mode = "normal";
+    applyLineOperator(op, topLine, bottomLine, ctx);
+  };
+}
+
+for (const op of OPERATORS) {
+  commands["visual-char"][op] = (ctx) => {
+    const [start, end] = getVisualSelection(
+      "char",
+      visualAnchor,
+      visualCursor,
+      ctx.rep,
+    );
+    mode = "normal";
+    applyOperator(op, start, end, ctx);
+  };
+}
+
+commands["visual-char"]["~"] = (ctx) => {
+  const [start, end] = getVisualSelection(
+    "char",
+    visualAnchor,
+    visualCursor,
+    ctx.rep,
+  );
+  const text = getTextInRange(ctx.rep, start, end);
+  let toggled = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    toggled += ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
   }
+  replaceRange(ctx.editorInfo, start, end, toggled);
+  mode = "normal";
+  moveBlockCursor(ctx.editorInfo, start[0], start[1]);
+};
 
-  // --- Visual-mode specific ---
+commands["visual-line"]["~"] = (ctx) => {
+  const [start, end] = getVisualSelection(
+    "line",
+    visualAnchor,
+    visualCursor,
+    ctx.rep,
+  );
+  const text = getTextInRange(ctx.rep, start, end);
+  let toggled = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    toggled += ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
+  }
+  replaceRange(ctx.editorInfo, start, end, toggled);
+  mode = "normal";
+  moveBlockCursor(ctx.editorInfo, start[0], start[1]);
+};
 
-  if (inVisual) {
-    if (key === "i" || key === "a") {
-      pendingKey = key;
-      return true;
-    }
+// --- Miscellaneous ---
 
-    if (key === "~") {
-      const [start, end] = getVisualSelection(
-        visualMode,
-        visualAnchor,
-        visualCursor,
-        rep,
-      );
-      const text = getTextInRange(rep, start, end);
-      let toggled = "";
-      for (let i = 0; i < text.length; i++) {
-        const ch = text[i];
-        toggled +=
-          ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
-      }
-      replaceRange(editorInfo, start, end, toggled);
-      setVisualMode(null);
-      moveBlockCursor(editorInfo, start[0], start[1]);
-      return true;
-    }
+commands.normal["u"] = ({ editorInfo }) => {
+  editorInfo.ace_doUndoRedo("undo");
+};
 
-    pendingKey = null;
-    return false;
+commands.normal["."] = (ctx) => {
+  if (!lastCommand) return;
+  const { key, count, param } = lastCommand;
+  if (param !== null && parameterized[key]) {
+    parameterized[key](param, ctx);
+  } else if (commands[mode] && commands[mode][key]) {
+    const newCtx = { ...ctx, count };
+    commands[mode][key](newCtx);
   }
+};
 
-  // --- Normal-mode only commands ---
+// --- Mode transitions ---
 
-  if (key === "Y") {
-    setRegister([lineText]);
-    return true;
+commands.normal["i"] = ({ editorInfo, line, char }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, char);
+  mode = "insert";
+};
+
+commands.normal["a"] = ({ editorInfo, line, char, lineText }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, Math.min(char + 1, lineText.length));
+  mode = "insert";
+};
+
+commands.normal["A"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, lineText.length);
+  mode = "insert";
+};
+
+commands.normal["I"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, firstNonBlank(lineText));
+  mode = "insert";
+};
+
+commands["visual-char"]["i"] = () => {
+  pendingKey = "i";
+};
+
+commands["visual-char"]["a"] = () => {
+  pendingKey = "a";
+};
+
+commands["visual-line"]["i"] = () => {
+  pendingKey = "i";
+};
+
+commands["visual-line"]["a"] = () => {
+  pendingKey = "a";
+};
+
+commands.normal["o"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
+  replaceRange(
+    editorInfo,
+    [line, lineText.length],
+    [line, lineText.length],
+    "\n",
+  );
+  moveCursor(editorInfo, line + 1, 0);
+  mode = "insert";
+};
+
+commands.normal["O"] = ({ editorInfo, line }) => {
+  clearEmptyLineCursor();
+  replaceRange(editorInfo, [line, 0], [line, 0], "\n");
+  moveCursor(editorInfo, line, 0);
+  mode = "insert";
+};
+
+// --- More normal mode commands ---
+
+commands.normal["r"] = () => {
+  pendingKey = "r";
+};
+parameterized["r"] = (key, { editorInfo, line, char, lineText, count }) => {
+  if (lineText.length > 0) {
+    replaceRange(editorInfo, [line, char], [line, char + 1], key);
+    moveBlockCursor(editorInfo, line, char);
+    recordCommand("r", count, key);
   }
+};
 
-  if (key === "r") {
-    if (lineText.length > 0) pendingKey = "r";
-    return true;
+commands.normal["Y"] = ({ rep, line }) => {
+  setRegister([getLineText(rep, line)]);
+};
+
+commands.normal["x"] = ({ editorInfo, rep, line, char, lineText, count }) => {
+  if (lineText.length > 0) {
+    const deleteCount = Math.min(count, lineText.length - char);
+    setRegister(lineText.slice(char, char + deleteCount));
+    replaceRange(editorInfo, [line, char], [line, char + deleteCount], "");
+    const newLineText = getLineText(rep, line);
+    moveBlockCursor(editorInfo, line, clampChar(char, newLineText));
+    recordCommand("x", count);
   }
+};
 
-  if (key === "m") {
-    pendingKey = "m";
-    return true;
+commands.normal["p"] = ({ editorInfo, line, char, lineText, count }) => {
+  if (register !== null) {
+    if (typeof register === "string") {
+      const insertPos = Math.min(char + 1, lineText.length);
+      const repeated = register.repeat(count);
+      replaceRange(editorInfo, [line, insertPos], [line, insertPos], repeated);
+      moveBlockCursor(editorInfo, line, insertPos);
+    } else {
+      const block = register.join("\n");
+      const parts = [];
+      for (let i = 0; i < count; i++) parts.push(block);
+      const insertText = "\n" + parts.join("\n");
+      replaceRange(
+        editorInfo,
+        [line, lineText.length],
+        [line, lineText.length],
+        insertText,
+      );
+      moveBlockCursor(editorInfo, line + 1, 0);
+    }
+    recordCommand("p", count);
   }
+};
 
-  if (key === "x") {
-    if (lineText.length > 0) {
-      const deleteCount = Math.min(count, lineText.length - char);
-      replaceRange(editorInfo, [line, char], [line, char + deleteCount], "");
-      const newLineText = getLineText(rep, line);
-      moveBlockCursor(editorInfo, line, clampChar(char, newLineText));
+commands.normal["P"] = ({ editorInfo, line, char, count }) => {
+  if (register !== null) {
+    if (typeof register === "string") {
+      const repeated = register.repeat(count);
+      replaceRange(editorInfo, [line, char], [line, char], repeated);
+      moveBlockCursor(editorInfo, line, char);
+    } else {
+      const block = register.join("\n");
+      const parts = [];
+      for (let i = 0; i < count; i++) parts.push(block);
+      const insertText = parts.join("\n") + "\n";
+      replaceRange(editorInfo, [line, 0], [line, 0], insertText);
+      moveBlockCursor(editorInfo, line, 0);
     }
-    return true;
+    recordCommand("P", count);
   }
+};
 
-  if (key === "o") {
+commands.normal["J"] = ({ editorInfo, rep, line, lineText, count }) => {
+  const lineCount = rep.lines.length();
+  const joins = Math.min(count, lineCount - 1 - line);
+  let cursorChar = lineText.length;
+  for (let i = 0; i < joins; i++) {
+    const curLineText = getLineText(rep, line);
+    const nextLineText = getLineText(rep, line + 1);
+    const trimmedNext = nextLineText.replace(/^\s+/, "");
+    const separator = curLineText.length === 0 ? "" : " ";
+    if (i === 0) cursorChar = curLineText.length;
     replaceRange(
       editorInfo,
-      [line, lineText.length],
-      [line, lineText.length],
-      "\n",
+      [line, curLineText.length],
+      [line + 1, nextLineText.length],
+      separator + trimmedNext,
     );
-    moveCursor(editorInfo, line + 1, 0);
-    setInsertMode(true);
-    return true;
   }
+  moveBlockCursor(editorInfo, line, cursorChar);
+  recordCommand("J", count);
+};
 
-  if (key === "O") {
-    replaceRange(editorInfo, [line, 0], [line, 0], "\n");
-    moveCursor(editorInfo, line, 0);
-    setInsertMode(true);
-    return true;
+commands.normal["~"] = ({ editorInfo, rep, line, char, lineText, count }) => {
+  if (lineText.length > 0) {
+    const toggleCount = Math.min(count, lineText.length - char);
+    const slice = lineText.slice(char, char + toggleCount);
+    let toggled = "";
+    for (let i = 0; i < slice.length; i++) {
+      const ch = slice[i];
+      toggled += ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
+    }
+    replaceRange(editorInfo, [line, char], [line, char + toggleCount], toggled);
+    const newChar = Math.min(char + toggleCount, lineText.length - 1);
+    moveBlockCursor(editorInfo, line, newChar);
+    recordCommand("~", count);
   }
+};
 
-  if (key === "u") {
-    undo(editorInfo);
-    return true;
-  }
+commands.normal["D"] = ({ editorInfo, rep, line, char, lineText }) => {
+  setRegister(lineText.slice(char));
+  replaceRange(editorInfo, [line, char], [line, lineText.length], "");
+  const newLineText = getLineText(rep, line);
+  moveBlockCursor(editorInfo, line, clampChar(char, newLineText));
+  recordCommand("D", 1);
+};
 
-  if (key === "p") {
-    if (register !== null) {
-      if (typeof register === "string") {
-        const insertPos = Math.min(char + 1, lineText.length);
-        const repeated = register.repeat(count);
-        replaceRange(
-          editorInfo,
-          [line, insertPos],
-          [line, insertPos],
-          repeated,
-        );
-        moveBlockCursor(editorInfo, line, insertPos);
-      } else {
-        const block = register.join("\n");
-        const parts = [];
-        for (let i = 0; i < count; i++) parts.push(block);
-        const insertText = "\n" + parts.join("\n");
-        replaceRange(
-          editorInfo,
-          [line, lineText.length],
-          [line, lineText.length],
-          insertText,
-        );
-        moveBlockCursor(editorInfo, line + 1, 0);
-      }
-    }
+commands.normal["C"] = ({ editorInfo, line, char, lineText }) => {
+  clearEmptyLineCursor();
+  setRegister(lineText.slice(char));
+  replaceRange(editorInfo, [line, char], [line, lineText.length], "");
+  moveCursor(editorInfo, line, char);
+  mode = "insert";
+  recordCommand("C", 1);
+};
+
+commands.normal["s"] = ({ editorInfo, rep, line, char, lineText, count }) => {
+  clearEmptyLineCursor();
+  setRegister(lineText.slice(char, char + 1));
+  replaceRange(
+    editorInfo,
+    [line, char],
+    [line, Math.min(char + count, lineText.length)],
+    "",
+  );
+  moveCursor(editorInfo, line, char);
+  mode = "insert";
+  recordCommand("s", count);
+};
+
+commands.normal["S"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
+  setRegister(lineText);
+  replaceRange(editorInfo, [line, 0], [line, lineText.length], "");
+  moveCursor(editorInfo, line, 0);
+  mode = "insert";
+  recordCommand("S", 1);
+};
+
+// --- Search ---
+
+commands.normal["/"] = () => {
+  searchMode = true;
+  searchBuffer = "";
+  searchDirection = "/";
+};
+
+commands.normal["?"] = () => {
+  searchMode = true;
+  searchBuffer = "";
+  searchDirection = "?";
+};
+
+commands.normal["n"] = (ctx) => {
+  if (!lastSearch) return;
+  const { pattern, direction } = lastSearch;
+  const searchFunc = direction === "/" ? searchForward : searchBackward;
+  const pos = searchFunc(ctx.rep, ctx.line, ctx.char + 1, pattern, ctx.count);
+  if (pos) moveBlockCursor(ctx.editorInfo, pos[0], pos[1]);
+};
+
+commands.normal["N"] = (ctx) => {
+  if (!lastSearch) return;
+  const { pattern, direction } = lastSearch;
+  const searchFunc = direction === "/" ? searchBackward : searchForward;
+  const pos = searchFunc(ctx.rep, ctx.line, ctx.char, pattern, ctx.count);
+  if (pos) moveBlockCursor(ctx.editorInfo, pos[0], pos[1]);
+};
+
+// --- Dispatch ---
+
+const handleKey = (key, ctx) => {
+  if (key >= "1" && key <= "9") {
+    countBuffer += key;
     return true;
   }
-
-  if (key === "P") {
-    if (register !== null) {
-      if (typeof register === "string") {
-        const repeated = register.repeat(count);
-        replaceRange(editorInfo, [line, char], [line, char], repeated);
-        moveBlockCursor(editorInfo, line, char);
-      } else {
-        const block = register.join("\n");
-        const parts = [];
-        for (let i = 0; i < count; i++) parts.push(block);
-        const insertText = parts.join("\n") + "\n";
-        replaceRange(editorInfo, [line, 0], [line, 0], insertText);
-        moveBlockCursor(editorInfo, line, 0);
-      }
-    }
+  if (key === "0" && countBuffer !== "") {
+    countBuffer += key;
     return true;
   }
 
-  if (key === "J") {
-    const lineCount = rep.lines.length();
-    const joins = Math.min(count, lineCount - 1 - line);
-    let cursorChar = lineText.length;
-    for (let i = 0; i < joins; i++) {
-      const curLineText = getLineText(rep, line);
-      const nextLineText = getLineText(rep, line + 1);
-      const trimmedNext = nextLineText.replace(/^\s+/, "");
-      const separator = curLineText.length === 0 ? "" : " ";
-      if (i === 0) cursorChar = curLineText.length;
-      replaceRange(
-        editorInfo,
-        [line, curLineText.length],
-        [line + 1, nextLineText.length],
-        separator + trimmedNext,
-      );
-    }
-    moveBlockCursor(editorInfo, line, cursorChar);
-    return true;
+  if (countBuffer !== "") {
+    pendingCount = parseInt(countBuffer, 10);
+    countBuffer = "";
   }
+  ctx.count = pendingCount !== null ? pendingCount : 1;
+  ctx.hasCount = pendingCount !== null;
 
-  if (key === "~") {
-    if (lineText.length > 0) {
-      const toggleCount = Math.min(count, lineText.length - char);
-      const slice = lineText.slice(char, char + toggleCount);
-      let toggled = "";
-      for (let i = 0; i < slice.length; i++) {
-        const ch = slice[i];
-        toggled +=
-          ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
-      }
-      replaceRange(
-        editorInfo,
-        [line, char],
-        [line, char + toggleCount],
-        toggled,
-      );
-      const newChar = Math.min(char + toggleCount, lineText.length - 1);
-      moveBlockCursor(editorInfo, line, newChar);
-    }
+  if (pendingKey !== null && parameterized[pendingKey]) {
+    const handler = parameterized[pendingKey];
+    pendingKey = null;
+    handler(key, ctx);
+    pendingCount = null;
     return true;
   }
 
-  if (key === "D") {
-    setRegister(lineText.slice(char));
-    replaceRange(editorInfo, [line, char], [line, lineText.length], "");
-    const newLineText = getLineText(rep, line);
-    moveBlockCursor(editorInfo, line, clampChar(char, newLineText));
+  const map = commands[mode];
+  const seq = pendingKey !== null ? pendingKey + key : key;
+
+  if (map[seq]) {
+    pendingKey = null;
+    map[seq](ctx);
+    if (pendingKey === null) pendingCount = null;
     return true;
   }
 
-  if (key === "C") {
-    setRegister(lineText.slice(char));
-    replaceRange(editorInfo, [line, char], [line, lineText.length], "");
-    moveCursor(editorInfo, line, char);
-    setInsertMode(true);
+  const isPrefix = Object.keys(map).some(
+    (k) => k.startsWith(seq) && k.length > seq.length,
+  );
+  if (isPrefix) {
+    pendingKey = seq;
     return true;
   }
 
-  if (key === "s") {
-    setRegister(lineText.slice(char, char + 1));
-    replaceRange(
-      editorInfo,
-      [line, char],
-      [line, Math.min(char + count, lineText.length)],
-      "",
-    );
-    moveCursor(editorInfo, line, char);
-    setInsertMode(true);
+  if (
+    pendingKey &&
+    (key === "i" || key === "a") &&
+    Object.keys(map).some((k) => k.startsWith(pendingKey + key))
+  ) {
+    pendingKey = pendingKey + key;
     return true;
   }
 
-  if (key === "S") {
-    setRegister(lineText);
-    replaceRange(editorInfo, [line, 0], [line, lineText.length], "");
-    moveCursor(editorInfo, line, 0);
-    setInsertMode(true);
+  if (
+    (mode === "visual-char" || mode === "visual-line") &&
+    (pendingKey === "i" || pendingKey === "a")
+  ) {
+    const type = pendingKey;
+    pendingKey = null;
+    const range = resolveTextObject(
+      key,
+      type,
+      ctx.line,
+      ctx.lineText,
+      ctx.char,
+      ctx.rep,
+    );
+    if (range) {
+      visualAnchor = [range.startLine, range.startChar];
+      visualCursor = [range.endLine, range.endChar];
+      updateVisualSelection(ctx.editorInfo, ctx.rep);
+    }
     return true;
   }
 
   pendingKey = null;
-  return false;
+  pendingCount = null;
+  return true;
 };
 
-// --- Exports ---
+// --- Etherpad hooks ---
 
 exports.aceEditorCSS = () => ["ep_vim/static/css/vim.css"];
 
@@ -827,102 +1113,76 @@ exports.postAceInit = (_hookName, { ace }) => {
 exports.aceKeyEvent = (_hookName, { evt, rep, editorInfo }) => {
   if (!vimEnabled) return false;
   if (evt.type !== "keydown") return false;
+
+  const isBrowserShortcut =
+    (evt.ctrlKey || evt.metaKey) &&
+    (evt.key === "x" || evt.key === "c" || evt.key === "v" || evt.key === "r");
+  if (isBrowserShortcut) return false;
+
   currentRep = rep;
-  if (!editorDoc) {
-    editorDoc = evt.target.ownerDocument;
-    setInsertMode(insertMode);
-  }
+  if (!editorDoc) editorDoc = evt.target.ownerDocument;
 
   if (evt.key === "Escape") {
-    if (insertMode) {
-      setInsertMode(false);
-      const [line, char] = rep.selStart;
-      moveBlockCursor(editorInfo, line, Math.max(0, char - 1));
-    }
-    if (visualMode !== null) {
+    desiredColumn = null;
+    if (mode === "visual-line") {
+      const line = Math.min(visualAnchor[0], visualCursor[0]);
+      mode = "normal";
+      moveBlockCursor(editorInfo, line, 0);
+    } else if (mode === "visual-char") {
       const [vLine, vChar] = visualCursor;
-      setVisualMode(null);
+      mode = "normal";
       moveBlockCursor(editorInfo, vLine, vChar);
+    } else if (mode === "insert") {
+      mode = "normal";
+      const [curLine, curChar] = rep.selStart;
+      moveBlockCursor(editorInfo, curLine, Math.max(0, curChar - 1));
+    } else {
+      mode = "normal";
+      const [curLine, curChar] = rep.selStart;
+      moveBlockCursor(editorInfo, curLine, curChar);
     }
-    countBuffer = "";
     pendingKey = null;
-    pendingOperator = null;
     pendingCount = null;
-    desiredColumn = null;
+    countBuffer = "";
     evt.preventDefault();
     return true;
   }
 
-  if (insertMode) return false;
-
-  if (pendingKey !== null || pendingOperator !== null) {
-    const handled = handleKey(rep, editorInfo, evt.key);
-    evt.preventDefault();
-    return handled || true;
-  }
-
-  if (visualMode === null) {
-    if (evt.key === "i") {
-      const [line, char] = rep.selStart;
-      desiredColumn = null;
-      moveCursor(editorInfo, line, char);
-      setInsertMode(true);
-      evt.preventDefault();
-      return true;
-    }
-
-    if (evt.key === "a") {
-      const [line, char] = rep.selStart;
-      const lineText = getLineText(rep, line);
-      desiredColumn = null;
-      moveCursor(editorInfo, line, Math.min(char + 1, lineText.length));
-      setInsertMode(true);
-      evt.preventDefault();
-      return true;
-    }
-
-    if (evt.key === "A") {
-      const [line] = rep.selStart;
-      const lineText = getLineText(rep, line);
-      desiredColumn = null;
-      moveCursor(editorInfo, line, lineText.length);
-      setInsertMode(true);
-      evt.preventDefault();
-      return true;
-    }
-
-    if (evt.key === "I") {
-      const [line] = rep.selStart;
-      const lineText = getLineText(rep, line);
-      desiredColumn = null;
-      moveCursor(editorInfo, line, firstNonBlank(lineText));
-      setInsertMode(true);
+  if (mode === "insert") return false;
+
+  if (searchMode) {
+    if (evt.key === "Enter") {
+      searchMode = false;
+      const pattern = searchBuffer;
+      lastSearch = { pattern, direction: searchDirection };
+      const [curLine, curChar] = rep.selStart;
+      const searchFunc =
+        searchDirection === "/" ? searchForward : searchBackward;
+      const pos = searchFunc(rep, curLine, curChar + 1, pattern);
+      if (pos) moveBlockCursor(editorInfo, pos[0], pos[1]);
+      searchBuffer = "";
       evt.preventDefault();
       return true;
-    }
-
-    if (evt.key === "V") {
-      const [line] = rep.selStart;
-      visualAnchor = [line, 0];
-      visualCursor = [line, 0];
-      setVisualMode("line");
-      updateVisualSelection(editorInfo, rep);
+    } else if (evt.key === "Escape") {
+      searchMode = false;
+      searchBuffer = "";
       evt.preventDefault();
       return true;
-    }
-
-    if (evt.key === "v") {
-      const [line, char] = rep.selStart;
-      visualAnchor = [line, char];
-      visualCursor = [line, char];
-      setVisualMode("char");
-      updateVisualSelection(editorInfo, rep);
+    } else if (evt.key.length === 1 && !evt.ctrlKey && !evt.metaKey) {
+      searchBuffer += evt.key;
       evt.preventDefault();
       return true;
     }
+    return false;
   }
 
-  const handled = handleKey(rep, editorInfo, evt.key);
-  evt.preventDefault();
-  return handled || true;
+  const [line, char] =
+    mode === "visual-line" || mode === "visual-char"
+      ? visualCursor
+      : rep.selStart;
+  const lineText = rep.lines.atIndex(line).text;
+  const ctx = { rep, editorInfo, line, char, lineText };
+  const handled = handleKey(evt.key, ctx);
+  if (handled) evt.preventDefault();
+  return handled;
 };