ep_vim 0.7.1 → 0.9.2

package/static/js/index.js

@@ -9,48 +9,206 @@ const {
   wordBackward,
   wordEnd,
   charSearchPos,
-  motionRange,
   charMotionRange,
+  paragraphForward,
+  paragraphBackward,
+  matchingBracketPos,
   textWordRange,
   textQuoteRange,
   textBracketRange,
-  getVisualSelection,
-  paragraphForward,
-  paragraphBackward,
   getTextInRange,
-  matchingBracketPos,
+  getVisualSelection,
   paragraphTextRange,
   sentenceTextRange,
+  searchForward,
+  searchBackward,
 } = require("./vim-core");
 
-// --- State variables ---
-
-let vimEnabled = localStorage.getItem("ep_vimEnabled") === "true";
-let insertMode = false;
-let visualMode = null;
-let visualAnchor = null;
-let visualCursor = null;
-let pendingKey = null;
-let pendingOperator = null;
-let pendingCount = null;
-let countBuffer = "";
-let register = null;
-let marks = {};
-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);
+// --- State ---
+
+let vimEnabled =
+  typeof localStorage !== "undefined" &&
+  localStorage.getItem("ep_vimEnabled") === "true";
+
+const state = {
+  mode: "normal",
+  pendingKey: null,
+  pendingCount: null,
+  countBuffer: "",
+  register: null,
+  marks: {},
+  lastCharSearch: null,
+  visualAnchor: null,
+  visualCursor: null,
+  editorDoc: null,
+  currentRep: null,
+  desiredColumn: null,
+  lastCommand: null,
+  searchMode: false,
+  searchBuffer: "",
+  searchDirection: null,
+  lastSearch: null,
+};
+
+// --- Editor operations ---
+
+const setRegister = (value) => {
+  state.register = value;
+  const text = Array.isArray(value) ? value.join("\n") + "\n" : value;
+  if (navigator.clipboard) {
+    navigator.clipboard.writeText(text).catch(() => {});
+  }
+};
+
+const moveCursor = (editorInfo, line, char) => {
+  const pos = [line, char];
+  editorInfo.ace_inCallStackIfNecessary("vim-move", () => {
+    editorInfo.ace_performSelectionChange(pos, pos, false);
+    editorInfo.ace_updateBrowserSelectionFromRep();
+  });
+};
+
+const replaceRange = (editorInfo, start, end, text) => {
+  editorInfo.ace_inCallStackIfNecessary("vim-edit", () => {
+    editorInfo.ace_performDocumentReplaceRange(start, end, text);
+  });
+};
+
+const selectRange = (editorInfo, start, end) => {
+  editorInfo.ace_inCallStackIfNecessary("vim-select", () => {
+    editorInfo.ace_performSelectionChange(start, end, false);
+    editorInfo.ace_updateBrowserSelectionFromRep();
+  });
+};
+
+const updateVisualSelection = (editorInfo, rep) => {
+  const vMode = state.mode === "visual-line" ? "line" : "char";
+  const [start, end] = getVisualSelection(
+    vMode,
+    state.visualAnchor,
+    state.visualCursor,
+    rep,
+  );
+  if (vMode === "char") {
+    selectRange(editorInfo, start, [end[0], end[1] + 1]);
+  } else {
+    selectRange(editorInfo, start, end);
+  }
+};
+
+const clearEmptyLineCursor = () => {
+  if (!state.editorDoc) return;
+  const old = state.editorDoc.querySelector(".vim-empty-line-cursor");
+  if (old) old.classList.remove("vim-empty-line-cursor");
+};
+
+const scrollLineIntoView = (line) => {
+  if (!state.editorDoc) return;
+  const lineDiv = state.editorDoc.body.querySelectorAll("div")[line];
+  if (lineDiv) lineDiv.scrollIntoView({ block: "nearest" });
+};
+
+const moveBlockCursor = (editorInfo, line, char) => {
+  clearEmptyLineCursor();
+  const lineText = state.currentRep ? getLineText(state.currentRep, line) : "";
+  if (lineText.length === 0 && state.editorDoc) {
+    const lineDiv = state.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]);
+  }
+  scrollLineIntoView(line);
+};
+
+const moveVisualCursor = (editorInfo, rep, line, char) => {
+  state.visualCursor = [line, char];
+  updateVisualSelection(editorInfo, rep);
+  scrollLineIntoView(line);
 };
 
+// --- Line helpers ---
+
+const deleteLines = (editorInfo, rep, topLine, bottomLine) => {
+  const totalLines = rep.lines.length();
+  if (bottomLine === totalLines - 1 && topLine > 0) {
+    const prevLineLen = getLineText(rep, topLine - 1).length;
+    replaceRange(
+      editorInfo,
+      [topLine - 1, prevLineLen],
+      [bottomLine, getLineText(rep, bottomLine).length],
+      "",
+    );
+    return topLine - 1;
+  }
+  if (bottomLine < totalLines - 1) {
+    replaceRange(editorInfo, [topLine, 0], [bottomLine + 1, 0], "");
+    return topLine;
+  }
+  replaceRange(
+    editorInfo,
+    [0, 0],
+    [bottomLine, getLineText(rep, bottomLine).length],
+    "",
+  );
+  return 0;
+};
+
+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));
+  setRegister(lines);
+  if (op === "y") {
+    moveBlockCursor(editorInfo, topLine, 0);
+    return;
+  }
+  if (op === "c") {
+    if (bottomLine > topLine) {
+      deleteLines(editorInfo, rep, topLine + 1, bottomLine);
+    }
+    const text = getLineText(rep, topLine);
+    replaceRange(editorInfo, [topLine, 0], [topLine, text.length], "");
+    moveCursor(editorInfo, topLine, 0);
+    state.mode = "insert";
+    return;
+  }
+  const cursorLine = deleteLines(editorInfo, rep, topLine, bottomLine);
+  const newLineText = getLineText(rep, cursorLine);
+  moveBlockCursor(editorInfo, cursorLine, clampChar(char, newLineText));
+};
+
+// --- Operator helper ---
+
+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;
+  }
+  replaceRange(editorInfo, s, e, "");
+  if (op === "c") {
+    moveCursor(editorInfo, s[0], s[1]);
+    state.mode = "insert";
+  } else {
+    moveBlockCursor(editorInfo, s[0], s[1]);
+  }
+};
+
+// --- Command tables ---
+const commands = {
+  normal: {},
+  "visual-char": {},
+  "visual-line": {},
+};
+
+// --- Registration helpers ---
+const OPERATORS = ["d", "c", "y"];
+
 const resolveTextObject = (key, type, line, lineText, char, rep) => {
   if (key === "p") {
     return paragraphTextRange(rep, line, type);
@@ -65,25 +223,128 @@ const resolveTextObject = (key, type, line, lineText, char, rep) => {
       endChar: r.end,
     };
   }
-  const r = textObjectRange(key, lineText, char, type);
+  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 };
 };
 
+const recordCommand = (key, count, param = null) => {
+  state.lastCommand = { key, count, param };
+};
+
+const registerMotion = (
+  key,
+  getEndPos,
+  inclusive = false,
+  keepDesiredColumn = false,
+) => {
+  commands.normal[key] = (ctx) => {
+    if (!keepDesiredColumn) state.desiredColumn = null;
+    const pos = getEndPos(ctx);
+    if (pos) {
+      const lineText = getLineText(ctx.rep, pos.line);
+      moveBlockCursor(ctx.editorInfo, pos.line, clampChar(pos.char, lineText));
+    }
+  };
+  commands["visual-char"][key] = (ctx) => {
+    if (!keepDesiredColumn) state.desiredColumn = null;
+    const pos = getEndPos(ctx);
+    if (pos) moveVisualCursor(ctx.editorInfo, ctx.rep, pos.line, pos.char);
+  };
+  commands["visual-line"][key] = (ctx) => {
+    if (!keepDesiredColumn) state.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) => {
+      state.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);
+      }
+    };
+  }
+};
+
+const parameterized = {};
+
+const registerParamMotion = (key, getEndChar) => {
+  commands.normal[key] = () => {
+    state.pendingKey = key;
+  };
+  commands["visual-char"][key] = () => {
+    state.pendingKey = key;
+  };
+  commands["visual-line"][key] = () => {
+    state.pendingKey = key;
+  };
+  parameterized[key] = (argKey, ctx) => {
+    state.lastCharSearch = { direction: key, target: argKey };
+    const pos = getEndChar(argKey, ctx);
+    if (pos !== null) {
+      if (state.mode.startsWith("visual")) {
+        moveVisualCursor(ctx.editorInfo, ctx.rep, ctx.line, pos);
+      } else {
+        moveBlockCursor(ctx.editorInfo, ctx.line, pos);
+      }
+      recordCommand(key, ctx.count, argKey);
+    }
+  };
+  for (const op of OPERATORS) {
+    const combo = op + key;
+    commands.normal[combo] = () => {
+      state.pendingKey = combo;
+    };
+    parameterized[combo] = (argKey, ctx) => {
+      state.lastCharSearch = { direction: key, target: argKey };
+      const pos = getEndChar(argKey, ctx);
+      if (pos !== null) {
+        const range = charMotionRange(key, ctx.char, pos);
+        if (range)
+          applyOperator(
+            op,
+            [ctx.line, range.start],
+            [ctx.line, range.end],
+            ctx,
+          );
+        recordCommand(combo, ctx.count, argKey);
+      }
+    };
+  }
+};
+
+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);
+      };
+    }
+  }
+};
+
 const getVisibleLineRange = (rep) => {
   const totalLines = rep.lines.length();
-  if (!editorDoc) return { top: 0, bottom: totalLines - 1 };
-  const lineDivs = editorDoc.body.querySelectorAll("div");
+  if (!state.editorDoc) {
+    const mid = Math.floor((totalLines - 1) / 2);
+    return { top: 0, mid, bottom: totalLines - 1 };
+  }
+  const lineDivs = state.editorDoc.body.querySelectorAll("div");
   const lineCount = Math.min(lineDivs.length, totalLines);
-
-  // The iframe doesn't scroll — the outer page does. getBoundingClientRect()
-  // inside the iframe is relative to the iframe document top (not the outer
-  // viewport). We need the iframe's own position in the outer viewport to
-  // know which lines are actually visible.
-  const frameEl = editorDoc.defaultView.frameElement;
+  const frameEl = state.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++) {
@@ -100,8 +361,6 @@ const getVisibleLineRange = (rep) => {
       break;
     }
   }
-
-  // Lines can wrap, so find the middle by pixel position rather than index.
   const visibleTop = iframeTop + lineDivs[top].getBoundingClientRect().top;
   const visibleBottom =
     iframeTop + lineDivs[bottom].getBoundingClientRect().bottom;
@@ -114,815 +373,710 @@ const getVisibleLineRange = (rep) => {
       break;
     }
   }
-
   return { top, mid, bottom };
 };
 
-// --- Count helpers ---
+// --- 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 (state.desiredColumn === null) state.desiredColumn = ctx.char;
+    const newLine = clampLine(ctx.line + ctx.count, ctx.rep);
+    const newLineText = getLineText(ctx.rep, newLine);
+    return {
+      line: newLine,
+      char: clampChar(state.desiredColumn, newLineText),
+    };
+  },
+  false,
+  true,
+);
+
+registerMotion(
+  "k",
+  (ctx) => {
+    if (state.desiredColumn === null) state.desiredColumn = ctx.char;
+    const newLine = clampLine(ctx.line - ctx.count, ctx.rep);
+    const newLineText = getLineText(ctx.rep, newLine);
+    return {
+      line: newLine,
+      char: clampChar(state.desiredColumn, newLineText),
+    };
+  },
+  false,
+  true,
+);
+
+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: pos };
+});
+
+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;
+});
+
+const registerCharRepeat = (key, getDirection) => {
+  const handler = (ctx) => {
+    if (!state.lastCharSearch) return;
+    const dir = getDirection(state.lastCharSearch.direction);
+    const pos = charSearchPos(
+      dir,
+      ctx.lineText,
+      ctx.char,
+      state.lastCharSearch.target,
+      ctx.count,
+    );
+    if (pos === -1) return;
+    if (state.mode.startsWith("visual")) {
+      moveVisualCursor(ctx.editorInfo, ctx.rep, ctx.line, pos);
+    } else {
+      moveBlockCursor(ctx.editorInfo, ctx.line, pos);
+    }
+  };
+  commands.normal[key] = handler;
+  commands["visual-char"][key] = handler;
+  commands["visual-line"][key] = handler;
+};
 
-const consumeCount = () => {
-  if (countBuffer !== "") {
-    pendingCount = parseInt(countBuffer, 10);
-    countBuffer = "";
-  } else if (pendingKey === null && pendingOperator === null) {
-    pendingCount = null;
-  }
+const sameDirection = (dir) => dir;
+const oppositeDirection = {
+  f: "F",
+  F: "f",
+  t: "T",
+  T: "t",
 };
+const reverseDirection = (dir) => oppositeDirection[dir];
 
-const getCount = () => pendingCount || 1;
+registerCharRepeat(";", sameDirection);
+registerCharRepeat(",", reverseDirection);
 
-// --- Side-effectful helpers ---
+// --- Marks ---
 
-const setRegister = (value) => {
-  register = value;
-  const text = Array.isArray(value) ? value.join("\n") + "\n" : value;
-  if (navigator.clipboard) {
-    navigator.clipboard.writeText(text).catch(() => {});
-  }
+commands.normal["m"] = () => {
+  state.pendingKey = "m";
 };
-
-const moveCursor = (editorInfo, line, char) => {
-  const pos = [line, char];
-  editorInfo.ace_inCallStackIfNecessary("vim-move", () => {
-    editorInfo.ace_performSelectionChange(pos, pos, false);
-    editorInfo.ace_updateBrowserSelectionFromRep();
-  });
+parameterized["m"] = (key, ctx) => {
+  if (key >= "a" && key <= "z") state.marks[key] = [ctx.line, ctx.char];
 };
 
-const clearEmptyLineCursor = () => {
-  if (!editorDoc) return;
-  const old = editorDoc.querySelector(".vim-empty-line-cursor");
-  if (old) old.classList.remove("vim-empty-line-cursor");
+commands.normal["'"] = () => {
+  state.pendingKey = "'";
 };
-
-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]);
+commands["visual-char"]["'"] = () => {
+  state.pendingKey = "'";
+};
+commands["visual-line"]["'"] = () => {
+  state.pendingKey = "'";
+};
+parameterized["'"] = (key, ctx) => {
+  if (!state.marks[key]) return;
+  const [markLine] = state.marks[key];
+  const targetText = getLineText(ctx.rep, markLine);
+  const targetChar = firstNonBlank(targetText);
+  if (state.mode.startsWith("visual")) {
+    moveVisualCursor(ctx.editorInfo, ctx.rep, markLine, targetChar);
   } else {
-    selectRange(editorInfo, [line, char], [line, char + 1]);
+    moveBlockCursor(ctx.editorInfo, markLine, targetChar);
   }
 };
 
-const selectRange = (editorInfo, start, end) => {
-  editorInfo.ace_inCallStackIfNecessary("vim-select", () => {
-    editorInfo.ace_performSelectionChange(start, end, false);
-    editorInfo.ace_updateBrowserSelectionFromRep();
-  });
+commands.normal["`"] = () => {
+  state.pendingKey = "`";
 };
-
-const replaceRange = (editorInfo, start, end, text) => {
-  editorInfo.ace_inCallStackIfNecessary("vim-edit", () => {
-    editorInfo.ace_performDocumentReplaceRange(start, end, text);
-  });
+commands["visual-char"]["`"] = () => {
+  state.pendingKey = "`";
 };
-
-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);
-  }
+commands["visual-line"]["`"] = () => {
+  state.pendingKey = "`";
 };
-
-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");
+parameterized["`"] = (key, ctx) => {
+  if (!state.marks[key]) return;
+  const [markLine, markChar] = state.marks[key];
+  if (state.mode.startsWith("visual")) {
+    moveVisualCursor(ctx.editorInfo, ctx.rep, markLine, markChar);
+  } else {
+    moveBlockCursor(ctx.editorInfo, markLine, markChar);
   }
 };
 
-const updateVisualSelection = (editorInfo, rep) => {
-  const [start, end] = getVisualSelection(
-    visualMode,
-    visualAnchor,
-    visualCursor,
-    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 };
-  }
+// --- Text objects ---
 
-  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 };
-  }
+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] };
+});
 
-  if (key === "$") {
-    desiredColumn = null;
-    return { line, char: clampChar(lineText.length - 1, lineText) };
-  }
+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] };
+  });
+}
 
-  if (key === "^") {
-    desiredColumn = null;
-    return { line, char: firstNonBlank(lineText) };
-  }
+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] };
+  });
+}
 
-  if (key === "}") {
-    desiredColumn = null;
-    return { line: paragraphForward(rep, line, count), char: 0 };
-  }
+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 }) => {
+  state.visualAnchor = [line, char];
+  state.visualCursor = [line, char];
+  state.mode = "visual-char";
+  updateVisualSelection(editorInfo, rep);
+};
 
-  if (key === "{") {
-    desiredColumn = null;
-    return { line: paragraphBackward(rep, line, count), char: 0 };
-  }
+commands.normal["V"] = ({ editorInfo, rep, line }) => {
+  state.visualAnchor = [line, 0];
+  state.visualCursor = [line, 0];
+  state.mode = "visual-line";
+  updateVisualSelection(editorInfo, rep);
+};
 
-  if (key === "G") {
-    desiredColumn = null;
-    if (pendingCount !== null) {
-      return { line: clampLine(pendingCount - 1, rep), char: 0 };
-    }
-    return { line: rep.lines.length() - 1, char: 0 };
-  }
+for (const op of OPERATORS) {
+  commands["visual-line"][op] = (ctx) => {
+    const topLine = Math.min(state.visualAnchor[0], state.visualCursor[0]);
+    const bottomLine = Math.max(state.visualAnchor[0], state.visualCursor[0]);
+    state.mode = "normal";
+    applyLineOperator(op, topLine, bottomLine, ctx);
+  };
+}
+
+for (const op of OPERATORS) {
+  commands["visual-char"][op] = (ctx) => {
+    const [start, end] = getVisualSelection(
+      "char",
+      state.visualAnchor,
+      state.visualCursor,
+      ctx.rep,
+    );
+    state.mode = "normal";
+    applyOperator(op, start, [end[0], end[1] + 1], ctx);
+  };
+}
 
-  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 };
-  }
+commands["visual-char"]["~"] = (ctx) => {
+  const [start, end] = getVisualSelection(
+    "char",
+    state.visualAnchor,
+    state.visualCursor,
+    ctx.rep,
+  );
+  const adjustedEnd = [end[0], end[1] + 1];
+  const text = getTextInRange(ctx.rep, start, adjustedEnd);
+  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, adjustedEnd, toggled);
+  state.mode = "normal";
+  moveBlockCursor(ctx.editorInfo, start[0], start[1]);
+};
 
-  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 };
-  }
+commands["visual-line"]["~"] = (ctx) => {
+  const [start, end] = getVisualSelection(
+    "line",
+    state.visualAnchor,
+    state.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);
+  state.mode = "normal";
+  moveBlockCursor(ctx.editorInfo, start[0], start[1]);
+};
 
-  if (key === "f" || key === "F" || key === "t" || key === "T") {
-    pendingKey = key;
-    return "pending";
-  }
+// --- Miscellaneous ---
 
-  if (key === "'" || key === "`") {
-    pendingKey = key;
-    return "pending";
-  }
+commands.normal["u"] = ({ editorInfo }) => {
+  editorInfo.ace_doUndoRedo("undo");
+};
 
-  if (key === "g") {
-    pendingKey = "g";
-    return "pending";
+commands.normal["."] = (ctx) => {
+  if (!state.lastCommand) return;
+  const { key, count, param } = state.lastCommand;
+  if (param !== null && parameterized[key]) {
+    parameterized[key](param, ctx);
+  } else if (commands[state.mode] && commands[state.mode][key]) {
+    const newCtx = { ...ctx, count };
+    commands[state.mode][key](newCtx);
   }
+};
 
-  if (key === "%") {
-    const pos = matchingBracketPos(rep, line, char);
-    if (pos) {
-      desiredColumn = null;
-      return { line: pos.line, char: pos.char };
-    }
-    return { line, char };
-  }
+// --- Mode transitions ---
 
-  if (key === "H") {
-    desiredColumn = null;
-    const { top } = getVisibleLineRange(rep);
-    const targetLine = clampLine(top + count - 1, rep);
-    const targetText = getLineText(rep, targetLine);
-    return { line: targetLine, char: firstNonBlank(targetText) };
-  }
+commands.normal["i"] = ({ editorInfo, line, char }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, char);
+  state.mode = "insert";
+};
 
-  if (key === "M") {
-    desiredColumn = null;
-    const { mid } = getVisibleLineRange(rep);
-    const targetText = getLineText(rep, mid);
-    return { line: mid, char: firstNonBlank(targetText) };
-  }
+commands.normal["a"] = ({ editorInfo, line, char, lineText }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, Math.min(char + 1, lineText.length));
+  state.mode = "insert";
+};
 
-  if (key === "L") {
-    desiredColumn = null;
-    const { bottom } = getVisibleLineRange(rep);
-    const targetLine = clampLine(bottom - count + 1, rep);
-    const targetText = getLineText(rep, targetLine);
-    return { line: targetLine, char: firstNonBlank(targetText) };
-  }
+commands.normal["A"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, lineText.length);
+  state.mode = "insert";
+};
 
-  return null;
+commands.normal["I"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
+  moveCursor(editorInfo, line, firstNonBlank(lineText));
+  state.mode = "insert";
 };
 
-// --- Apply motion (mode-aware cursor placement) ---
+commands["visual-char"]["i"] = () => {
+  state.pendingKey = "i";
+};
 
-const applyMotion = (editorInfo, rep, newLine, newChar) => {
-  if (visualMode !== null) {
-    visualCursor = [newLine, newChar];
-    updateVisualSelection(editorInfo, rep);
-  } else {
-    moveBlockCursor(editorInfo, newLine, newChar);
-  }
+commands["visual-char"]["a"] = () => {
+  state.pendingKey = "a";
+};
 
-  if (editorDoc) {
-    const lineDiv = editorDoc.body.querySelectorAll("div")[newLine];
-    if (lineDiv) lineDiv.scrollIntoView({ block: "nearest" });
-  }
+commands["visual-line"]["i"] = () => {
+  state.pendingKey = "i";
 };
 
-// --- Line deletion helper ---
+commands["visual-line"]["a"] = () => {
+  state.pendingKey = "a";
+};
 
-const deleteLines = (editorInfo, rep, topLine, bottomLine) => {
-  const totalLines = rep.lines.length();
-  if (bottomLine === totalLines - 1 && topLine > 0) {
-    const prevLineLen = getLineText(rep, topLine - 1).length;
-    replaceRange(
-      editorInfo,
-      [topLine - 1, prevLineLen],
-      [bottomLine, getLineText(rep, bottomLine).length],
-      "",
-    );
-    return topLine - 1;
-  }
-  if (bottomLine < totalLines - 1) {
-    replaceRange(editorInfo, [topLine, 0], [bottomLine + 1, 0], "");
-    return topLine;
-  }
+commands.normal["o"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
   replaceRange(
     editorInfo,
-    [0, 0],
-    [bottomLine, getLineText(rep, bottomLine).length],
-    "",
+    [line, lineText.length],
+    [line, lineText.length],
+    "\n",
   );
-  return 0;
+  moveCursor(editorInfo, line + 1, 0);
+  state.mode = "insert";
 };
 
-// --- 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 lines = [];
-  for (let i = topLine; i <= bottomLine; i++) {
-    lines.push(getLineText(rep, i));
-  }
-  setRegister(lines);
-  if (operator === "y") {
-    moveBlockCursor(editorInfo, topLine, 0);
-    return;
-  }
-  if (operator === "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);
-    return;
-  }
-  const cursorLine = deleteLines(editorInfo, rep, topLine, bottomLine);
-  const newLineText = getLineText(rep, cursorLine);
-  moveBlockCursor(editorInfo, cursorLine, clampChar(char, newLineText));
+commands.normal["O"] = ({ editorInfo, line }) => {
+  clearEmptyLineCursor();
+  replaceRange(editorInfo, [line, 0], [line, 0], "\n");
+  moveCursor(editorInfo, line, 0);
+  state.mode = "insert";
 };
 
-// --- Unified key handler ---
+// --- More normal mode commands ---
 
-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);
-
-  if (key >= "1" && key <= "9") {
-    countBuffer += key;
-    return true;
-  }
-  if (key === "0" && countBuffer !== "") {
-    countBuffer += key;
-    return true;
+commands.normal["r"] = () => {
+  state.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);
   }
+};
 
-  consumeCount();
-  const count = getCount();
-
-  // --- Normal-only pending states: r + char, m + letter ---
-
-  if (pendingKey === "r") {
-    pendingKey = null;
-    if (lineText.length > 0) {
-      replaceRange(editorInfo, [line, char], [line, char + 1], key);
-      moveBlockCursor(editorInfo, line, char);
-    }
-    return true;
-  }
+commands.normal["Y"] = ({ rep, line }) => {
+  setRegister([getLineText(rep, line)]);
+};
 
-  if (pendingKey === "m") {
-    pendingKey = null;
-    if (key >= "a" && key <= "z") {
-      marks[key] = [line, char];
-    }
-    return true;
+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);
   }
+};
 
-  // --- Operator-pending: resolve target ---
-
-  if (pendingOperator !== null) {
-    const op = pendingOperator;
-
-    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;
-    }
-
-    if (pendingKey === "i" || pendingKey === "a") {
-      const type = pendingKey;
-      pendingKey = null;
-      pendingOperator = null;
-      const range = resolveTextObject(key, type, line, lineText, char, rep);
-      if (range) {
-        applyCharOperator(
-          op,
-          [range.startLine, range.startChar],
-          [range.endLine, range.endChar],
-          editorInfo,
-          rep,
-        );
-      }
-      return true;
-    }
-
-    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(
-            op,
-            [line, range.start],
-            [line, range.end],
-            editorInfo,
-            rep,
-          );
-        }
-      }
-      return true;
-    }
-
-    if (key === "i" || key === "a") {
-      pendingKey = key;
-      return true;
-    }
-
-    if (key === "f" || key === "F" || key === "t" || key === "T") {
-      pendingKey = key;
-      return true;
-    }
-
-    if (key === "%") {
-      pendingOperator = null;
-      const matchPos = matchingBracketPos(rep, line, char);
-      if (matchPos) {
-        let start, end;
-        if (
-          matchPos.line > line ||
-          (matchPos.line === line && matchPos.char > char)
-        ) {
-          start = [line, char];
-          end = [matchPos.line, matchPos.char + 1];
-        } else {
-          start = [matchPos.line, matchPos.char];
-          end = [line, char + 1];
-        }
-        applyCharOperator(op, start, end, editorInfo, rep);
-      }
-      return true;
-    }
-
-    pendingOperator = null;
-    const range = motionRange(key, char, lineText, count);
-    if (range && range.end > range.start) {
-      applyCharOperator(
-        op,
-        [line, range.start],
-        [line, range.end],
+commands.normal["p"] = ({ editorInfo, line, char, lineText, count }) => {
+  if (state.register !== null) {
+    if (typeof state.register === "string") {
+      const insertPos = Math.min(char + 1, lineText.length);
+      const repeated = state.register.repeat(count);
+      replaceRange(editorInfo, [line, insertPos], [line, insertPos], repeated);
+      moveBlockCursor(editorInfo, line, insertPos);
+    } else {
+      const block = state.register.join("\n");
+      const parts = [];
+      for (let i = 0; i < count; i++) parts.push(block);
+      const insertText = "\n" + parts.join("\n");
+      replaceRange(
         editorInfo,
-        rep,
+        [line, lineText.length],
+        [line, lineText.length],
+        insertText,
       );
+      moveBlockCursor(editorInfo, line + 1, 0);
     }
-    return true;
+    recordCommand("p", count);
   }
+};
 
-  // --- Text object in visual mode (i/a + object key) ---
-
-  if (inVisual && (pendingKey === "i" || pendingKey === "a")) {
-    const type = pendingKey;
-    pendingKey = null;
-    const range = resolveTextObject(key, type, line, lineText, char, rep);
-    if (range) {
-      visualAnchor = [range.startLine, range.startChar];
-      visualCursor = [range.endLine, range.endChar];
-      setVisualMode("char");
-      updateVisualSelection(editorInfo, rep);
+commands.normal["P"] = ({ editorInfo, line, char, count }) => {
+  if (state.register !== null) {
+    if (typeof state.register === "string") {
+      const repeated = state.register.repeat(count);
+      replaceRange(editorInfo, [line, char], [line, char], repeated);
+      moveBlockCursor(editorInfo, line, char);
+    } else {
+      const block = state.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);
   }
+};
 
-  // --- Motions (shared between normal and visual) ---
-
-  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["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, curLineText.length],
+      [line + 1, nextLineText.length],
+      separator + trimmedNext,
+    );
   }
+  moveBlockCursor(editorInfo, line, cursorChar);
+  recordCommand("J", count);
+};
 
-  // --- Operators (d/c/y) ---
-
-  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;
+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();
     }
-    pendingOperator = key;
-    return true;
+    replaceRange(editorInfo, [line, char], [line, char + toggleCount], toggled);
+    const newChar = Math.min(char + toggleCount, lineText.length - 1);
+    moveBlockCursor(editorInfo, line, newChar);
+    recordCommand("~", count);
   }
+};
 
-  // --- Visual-mode specific ---
+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 (inVisual) {
-    if (key === "i" || key === "a") {
-      pendingKey = key;
-      return true;
-    }
+commands.normal["C"] = ({ editorInfo, line, char, lineText }) => {
+  clearEmptyLineCursor();
+  setRegister(lineText.slice(char));
+  replaceRange(editorInfo, [line, char], [line, lineText.length], "");
+  moveCursor(editorInfo, line, char);
+  state.mode = "insert";
+  recordCommand("C", 1);
+};
 
-    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["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);
+  state.mode = "insert";
+  recordCommand("s", count);
+};
 
-    pendingKey = null;
-    return false;
-  }
+commands.normal["S"] = ({ editorInfo, line, lineText }) => {
+  clearEmptyLineCursor();
+  setRegister(lineText);
+  replaceRange(editorInfo, [line, 0], [line, lineText.length], "");
+  moveCursor(editorInfo, line, 0);
+  state.mode = "insert";
+  recordCommand("S", 1);
+};
 
-  // --- Normal-mode only commands ---
+// --- Search ---
 
-  if (key === "Y") {
-    setRegister([lineText]);
-    return true;
-  }
+commands.normal["/"] = () => {
+  state.searchMode = true;
+  state.searchBuffer = "";
+  state.searchDirection = "/";
+};
 
-  if (key === "r") {
-    if (lineText.length > 0) pendingKey = "r";
-    return true;
-  }
+commands.normal["?"] = () => {
+  state.searchMode = true;
+  state.searchBuffer = "";
+  state.searchDirection = "?";
+};
 
-  if (key === "m") {
-    pendingKey = "m";
-    return true;
-  }
+commands.normal["n"] = (ctx) => {
+  if (!state.lastSearch) return;
+  const { pattern, direction } = state.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]);
+};
 
-  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));
-    }
-    return true;
-  }
+commands.normal["N"] = (ctx) => {
+  if (!state.lastSearch) return;
+  const { pattern, direction } = state.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]);
+};
 
-  if (key === "o") {
-    replaceRange(
-      editorInfo,
-      [line, lineText.length],
-      [line, lineText.length],
-      "\n",
-    );
-    moveCursor(editorInfo, line + 1, 0);
-    setInsertMode(true);
-    return true;
-  }
+// --- Dispatch ---
 
-  if (key === "O") {
-    replaceRange(editorInfo, [line, 0], [line, 0], "\n");
-    moveCursor(editorInfo, line, 0);
-    setInsertMode(true);
+const handleKey = (key, ctx) => {
+  if (key >= "1" && key <= "9") {
+    state.countBuffer += key;
     return true;
   }
-
-  if (key === "u") {
-    undo(editorInfo);
+  if (key === "0" && state.countBuffer !== "") {
+    state.countBuffer += key;
     return true;
   }
 
-  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);
-      }
-    }
-    return true;
+  if (state.countBuffer !== "") {
+    state.pendingCount = parseInt(state.countBuffer, 10);
+    state.countBuffer = "";
   }
+  ctx.count = state.pendingCount !== null ? state.pendingCount : 1;
+  ctx.hasCount = state.pendingCount !== null;
 
-  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 (state.pendingKey !== null && parameterized[state.pendingKey]) {
+    const handler = parameterized[state.pendingKey];
+    state.pendingKey = null;
+    handler(key, ctx);
+    state.pendingCount = null;
     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;
-  }
+  const map = commands[state.mode];
+  const seq = state.pendingKey !== null ? state.pendingKey + key : key;
 
-  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 (map[seq]) {
+    state.pendingKey = null;
+    map[seq](ctx);
+    if (state.pendingKey === null) state.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 isPrefix = Object.keys(map).some(
+    (k) => k.startsWith(seq) && k.length > seq.length,
+  );
+  if (isPrefix) {
+    state.pendingKey = seq;
     return true;
   }
 
-  if (key === "C") {
-    setRegister(lineText.slice(char));
-    replaceRange(editorInfo, [line, char], [line, lineText.length], "");
-    moveCursor(editorInfo, line, char);
-    setInsertMode(true);
+  if (
+    state.pendingKey &&
+    (key === "i" || key === "a") &&
+    Object.keys(map).some((k) => k.startsWith(state.pendingKey + key))
+  ) {
+    state.pendingKey = state.pendingKey + key;
     return true;
   }
 
-  if (key === "s") {
-    setRegister(lineText.slice(char, char + 1));
-    replaceRange(
-      editorInfo,
-      [line, char],
-      [line, Math.min(char + count, lineText.length)],
-      "",
+  if (
+    (state.mode === "visual-char" || state.mode === "visual-line") &&
+    (state.pendingKey === "i" || state.pendingKey === "a")
+  ) {
+    const type = state.pendingKey;
+    state.pendingKey = null;
+    const range = resolveTextObject(
+      key,
+      type,
+      ctx.line,
+      ctx.lineText,
+      ctx.char,
+      ctx.rep,
     );
-    moveCursor(editorInfo, line, char);
-    setInsertMode(true);
-    return true;
-  }
-
-  if (key === "S") {
-    setRegister(lineText);
-    replaceRange(editorInfo, [line, 0], [line, lineText.length], "");
-    moveCursor(editorInfo, line, 0);
-    setInsertMode(true);
+    if (range) {
+      state.visualAnchor = [range.startLine, range.startChar];
+      state.visualCursor = [range.endLine, range.endChar];
+      updateVisualSelection(ctx.editorInfo, ctx.rep);
+    }
     return true;
   }
 
-  pendingKey = null;
-  return false;
+  state.pendingKey = null;
+  state.pendingCount = null;
+  return true;
 };
 
-// --- Exports ---
+// --- Etherpad hooks ---
 
 exports.aceEditorCSS = () => ["ep_vim/static/css/vim.css"];
 
@@ -942,7 +1096,7 @@ exports.postAceInit = (_hookName, { ace }) => {
   ace.callWithAce((aceTop) => {
     const rep = aceTop.ace_getRep();
     if (rep && rep.selStart) {
-      currentRep = rep;
+      state.currentRep = rep;
       selectRange(aceTop, rep.selStart, [rep.selStart[0], rep.selStart[1] + 1]);
     }
   });
@@ -951,102 +1105,82 @@ exports.postAceInit = (_hookName, { ace }) => {
 exports.aceKeyEvent = (_hookName, { evt, rep, editorInfo }) => {
   if (!vimEnabled) return false;
   if (evt.type !== "keydown") return false;
-  currentRep = rep;
-  if (!editorDoc) {
-    editorDoc = evt.target.ownerDocument;
-    setInsertMode(insertMode);
-  }
+
+  const isBrowserShortcut =
+    (evt.ctrlKey || evt.metaKey) &&
+    (evt.key === "x" || evt.key === "c" || evt.key === "v" || evt.key === "r");
+  if (isBrowserShortcut) return false;
+
+  state.currentRep = rep;
+  if (!state.editorDoc) state.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) {
-      const [vLine, vChar] = visualCursor;
-      setVisualMode(null);
+    state.desiredColumn = null;
+    if (state.mode === "visual-line") {
+      const line = Math.min(state.visualAnchor[0], state.visualCursor[0]);
+      state.mode = "normal";
+      moveBlockCursor(editorInfo, line, 0);
+    } else if (state.mode === "visual-char") {
+      const [vLine, vChar] = state.visualCursor;
+      state.mode = "normal";
       moveBlockCursor(editorInfo, vLine, vChar);
+    } else if (state.mode === "insert") {
+      state.mode = "normal";
+      const [curLine, curChar] = rep.selStart;
+      moveBlockCursor(editorInfo, curLine, Math.max(0, curChar - 1));
+    } else {
+      state.mode = "normal";
+      const [curLine, curChar] = rep.selStart;
+      moveBlockCursor(editorInfo, curLine, curChar);
     }
-    countBuffer = "";
-    pendingKey = null;
-    pendingOperator = null;
-    pendingCount = null;
-    desiredColumn = null;
+    state.pendingKey = null;
+    state.pendingCount = null;
+    state.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 (state.mode === "insert") return false;
 
-    if (evt.key === "A") {
-      const [line] = rep.selStart;
-      const lineText = getLineText(rep, line);
-      desiredColumn = null;
-      moveCursor(editorInfo, line, lineText.length);
-      setInsertMode(true);
+  if (state.searchMode) {
+    if (evt.key === "Enter") {
+      state.searchMode = false;
+      const pattern = state.searchBuffer;
+      state.lastSearch = { pattern, direction: state.searchDirection };
+      const [curLine, curChar] = rep.selStart;
+      const searchFunc =
+        state.searchDirection === "/" ? searchForward : searchBackward;
+      const pos = searchFunc(rep, curLine, curChar + 1, pattern);
+      if (pos) moveBlockCursor(editorInfo, pos[0], pos[1]);
+      state.searchBuffer = "";
       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);
+    } else if (evt.key === "Escape") {
+      state.searchMode = false;
+      state.searchBuffer = "";
       evt.preventDefault();
       return true;
-    }
-
-    if (evt.key === "V") {
-      const [line] = rep.selStart;
-      visualAnchor = [line, 0];
-      visualCursor = [line, 0];
-      setVisualMode("line");
-      updateVisualSelection(editorInfo, rep);
-      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) {
+      state.searchBuffer += evt.key;
       evt.preventDefault();
       return true;
     }
+    return false;
   }
 
-  const handled = handleKey(rep, editorInfo, evt.key);
-  evt.preventDefault();
-  return handled || true;
+  const [line, char] =
+    state.mode === "visual-line" || state.mode === "visual-char"
+      ? state.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;
 };
+
+// Exports for testing
+exports._state = state;
+exports._handleKey = handleKey;
+exports._commands = commands;
+exports._parameterized = parameterized;