vim-sim 1.0.5 → 1.0.6

package/dist/index.d.ts

@@ -811,6 +811,13 @@ interface VimConfig {
     undolevels: number;
     clipboard: 'unnamed' | 'unnamedplus' | '';
 }
+/**
+ * Shell filter hook — set this on the ConfigManager instance directly.
+ * Called for :%!cmd and !! operators.
+ * Receives the shell command string and the input text; returns the filtered output.
+ * If not set, shell filter commands are no-ops.
+ */
+type FilterCommandFn = (cmd: string, input: string) => string;
 type VimConfigKey = keyof VimConfig;
 /**
  * Metadata about a config option
@@ -830,6 +837,11 @@ interface VimConfigMetadata {
 declare class ConfigManager {
     private config;
     private listeners;
+    /**
+     * Shell filter callback for :%!cmd and !! operators.
+     * Set this directly: configManager.filterCommand = (cmd, input) => ...
+     */
+    filterCommand: FilterCommandFn | undefined;
     constructor(initialConfig?: Partial<VimConfig>);
     /**
      * Get a config value
@@ -906,6 +918,25 @@ interface LastCommand {
     count?: number;
     register?: string;
 }
+interface LastSubstitute {
+    pattern: string;
+    replacement: string;
+    global: boolean;
+    ignoreCase: boolean;
+}
+interface ConfirmMatch {
+    line: number;
+    startCol: number;
+    endCol: number;
+    matchText: string;
+    replacementText: string;
+}
+interface PendingConfirmSubstitute {
+    matches: ConfirmMatch[];
+    currentIndex: number;
+    appliedIndices: number[];
+    originalContent: string;
+}
 declare class State {
     buffer: Buffer;
     cursor: Cursor;
@@ -929,7 +960,9 @@ declare class State {
     undoTree: UndoTree | null;
     lastCommand: LastCommand | null;
     configManager: ConfigManager | null;
-    constructor(buffer: Buffer, cursor: Cursor, selection: Range | null, mode: Mode, commandLine?: string, desiredColumn?: number | null, viewport?: VimViewport, visualAnchor?: Cursor | null, lastVisualSelection?: LastVisualSelection | null, recordingRegister?: string | null, lastMacroRegister?: string | null, foldManager?: FoldManager, markManager?: MarkManager, jumpListManager?: JumpListManager, fileSystem?: FileSystemManager, windowManager?: WindowManager, lastSearch?: SearchState | null, spellChecker?: SpellChecker, completionManager?: CompletionManager, undoTree?: UndoTree | null, lastCommand?: LastCommand | null, configManager?: ConfigManager | null);
+    lastSubstitute: LastSubstitute | null;
+    pendingConfirm: PendingConfirmSubstitute | null;
+    constructor(buffer: Buffer, cursor: Cursor, selection: Range | null, mode: Mode, commandLine?: string, desiredColumn?: number | null, viewport?: VimViewport, visualAnchor?: Cursor | null, lastVisualSelection?: LastVisualSelection | null, recordingRegister?: string | null, lastMacroRegister?: string | null, foldManager?: FoldManager, markManager?: MarkManager, jumpListManager?: JumpListManager, fileSystem?: FileSystemManager, windowManager?: WindowManager, lastSearch?: SearchState | null, spellChecker?: SpellChecker, completionManager?: CompletionManager, undoTree?: UndoTree | null, lastCommand?: LastCommand | null, configManager?: ConfigManager | null, lastSubstitute?: LastSubstitute | null, pendingConfirm?: PendingConfirmSubstitute | null);
 }
 
 declare abstract class TextObject {
@@ -1026,6 +1059,7 @@ interface CommandContext {
     indentationManager?: IndentationManager;
     args?: string;
     range?: Range;
+    lastSubstitute?: LastSubstitute | null;
 }
 declare abstract class Command {
     abstract key: string;
@@ -1139,6 +1173,28 @@ declare class Session {
     handleKey(key: string): void;
     private handleInsertMode;
     private handleCommandMode;
+    private resolveAddress;
+    /**
+     * Resolve a vim range string to [startLine, endLine] (0-indexed, inclusive).
+     * Returns null when the range string contains no range (use defaults for the command).
+     */
+    private resolveRange;
+    /**
+     * Split a raw ex command string into [rangeStr, commandBody].
+     * Handles: %, ., $, N, N,M, .,$ etc.
+     */
+    private splitRangeAndCommand;
+    private executeMoveLines;
+    private executeSubstitute;
+    private executeGlobal;
+    /** Execute a single ex sub-command (used by :g/:v) with cursor on `currentLine`. */
+    private executeSubCommand;
+    private executeShellFilter;
+    /**
+     * Handle key input while a confirm-substitution is pending.
+     * Keys: y (apply), n (skip), a (apply all), q (quit/cancel remaining), l (apply this + quit)
+     */
+    private handleConfirmMode;
     private executeCommand;
     private match;
     private tryMatch;

package/dist/index.js

@@ -1525,6 +1525,11 @@ var CompletionManager = class _CompletionManager {
 var ConfigManager = class _ConfigManager {
   config;
   listeners = /* @__PURE__ */ new Map();
+  /**
+   * Shell filter callback for :%!cmd and !! operators.
+   * Set this directly: configManager.filterCommand = (cmd, input) => ...
+   */
+  filterCommand = void 0;
   constructor(initialConfig) {
     this.config = {
       // Display
@@ -1856,7 +1861,7 @@ var CONFIG_METADATA = {
 
 // src/core/state.ts
 var State = class {
-  constructor(buffer, cursor, selection, mode, commandLine = "", desiredColumn = null, viewport = new VimViewport(), visualAnchor = null, lastVisualSelection = null, recordingRegister = null, lastMacroRegister = null, foldManager = new FoldManager(), markManager = new MarkManager(), jumpListManager = new JumpListManager(), fileSystem = new FileSystemManager(), windowManager = new WindowManager(), lastSearch = null, spellChecker = new SpellChecker(), completionManager = new CompletionManager(), undoTree = null, lastCommand = null, configManager = null) {
+  constructor(buffer, cursor, selection, mode, commandLine = "", desiredColumn = null, viewport = new VimViewport(), visualAnchor = null, lastVisualSelection = null, recordingRegister = null, lastMacroRegister = null, foldManager = new FoldManager(), markManager = new MarkManager(), jumpListManager = new JumpListManager(), fileSystem = new FileSystemManager(), windowManager = new WindowManager(), lastSearch = null, spellChecker = new SpellChecker(), completionManager = new CompletionManager(), undoTree = null, lastCommand = null, configManager = null, lastSubstitute = null, pendingConfirm = null) {
     this.buffer = buffer;
     this.cursor = cursor;
     this.selection = selection;
@@ -1879,6 +1884,8 @@ var State = class {
     this.undoTree = undoTree;
     this.lastCommand = lastCommand;
     this.configManager = configManager;
+    this.lastSubstitute = lastSubstitute;
+    this.pendingConfirm = pendingConfirm;
   }
 };
 function createEmptyState() {
@@ -5525,6 +5532,152 @@ var ParagraphTextObject = class extends TextObject {
   }
 };
 
+// src/utils/substitute.ts
+function substitute(content, startLine, endLine, options) {
+  const lines = content.split("\n");
+  const modifiedLines = [];
+  let totalReplacements = 0;
+  const flags = (options.global ? "g" : "") + (options.ignoreCase ? "i" : "");
+  const jsPattern = vimPatternToRegex(options.pattern);
+  const regex = new RegExp(jsPattern, flags);
+  for (let i = startLine; i <= endLine && i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const newLine = line.replace(regex, (match, ...args) => {
+      totalReplacements++;
+      return expandReplacement(options.replacement, match, args);
+    });
+    if (newLine !== line) {
+      lines[i] = newLine;
+      modifiedLines.push(i);
+    }
+  }
+  return {
+    newContent: lines.join("\n"),
+    replacements: totalReplacements,
+    lines: modifiedLines
+  };
+}
+function findSubstituteMatches(content, startLine, endLine, options) {
+  const lines = content.split("\n");
+  const matches = [];
+  const flags = "g" + (options.ignoreCase ? "i" : "");
+  const jsPattern = vimPatternToRegex(options.pattern);
+  const regex = new RegExp(jsPattern, flags);
+  for (let i = startLine; i <= endLine && i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    regex.lastIndex = 0;
+    let match;
+    let foundOnLine = false;
+    while ((match = regex.exec(line)) !== null) {
+      if (foundOnLine && !options.global) break;
+      const groups = match.slice(1);
+      matches.push({
+        line: i,
+        startCol: match.index,
+        endCol: match.index + match[0].length,
+        matchText: match[0],
+        replacementText: expandReplacement(options.replacement, match[0], groups)
+      });
+      foundOnLine = true;
+      if (match[0].length === 0) regex.lastIndex++;
+    }
+  }
+  return matches;
+}
+function applySubstituteMatches(content, matches, appliedIndices) {
+  const lines = content.split("\n");
+  const sorted = Array.from(appliedIndices).sort((a, b2) => {
+    const ma = matches[a];
+    const mb = matches[b2];
+    if (ma.line !== mb.line) return mb.line - ma.line;
+    return mb.startCol - ma.startCol;
+  });
+  for (const idx of sorted) {
+    const m = matches[idx];
+    const line = lines[m.line] ?? "";
+    lines[m.line] = line.slice(0, m.startCol) + m.replacementText + line.slice(m.endCol);
+  }
+  return lines.join("\n");
+}
+function evaluateVimExpr(expr, match, groups) {
+  expr = expr.trim();
+  const submatchRe = /^submatch\((\d+)\)$/;
+  const submatchM = submatchRe.exec(expr);
+  if (submatchM) {
+    const n2 = parseInt(submatchM[1], 10);
+    if (n2 === 0) return match;
+    const g = groups[n2 - 1];
+    return typeof g === "string" ? g : "";
+  }
+  const toupperM = /^toupper\((.+)\)$/.exec(expr);
+  if (toupperM) return evaluateVimExpr(toupperM[1], match, groups).toUpperCase();
+  const tolowerM = /^tolower\((.+)\)$/.exec(expr);
+  if (tolowerM) return evaluateVimExpr(tolowerM[1], match, groups).toLowerCase();
+  const strM = /^['"](.*)['"]$/.exec(expr);
+  if (strM) return strM[1];
+  return "";
+}
+function expandReplacement(replacement, match, groups) {
+  let result = replacement;
+  result = result.replace(/\\=([^\\]+)/g, (_, expr) => evaluateVimExpr(expr, match, groups));
+  result = result.replace(/\\0/g, match);
+  for (let i = 1; i <= 9; i++) {
+    const group = groups[i - 1];
+    if (group !== void 0) {
+      result = result.replace(new RegExp(`\\\\${i}`, "g"), String(group));
+    }
+  }
+  result = result.replace(/\\u(.)/g, (_, char) => char.toUpperCase());
+  result = result.replace(/\\U(.*?)(?:\\E|$)/g, (_, text) => text.toUpperCase());
+  result = result.replace(/\\l(.)/g, (_, char) => char.toLowerCase());
+  result = result.replace(/\\L(.*?)(?:\\E|$)/g, (_, text) => text.toLowerCase());
+  result = result.replace(/\\n/g, "\n");
+  result = result.replace(/\\t/g, "	");
+  result = result.replace(/\\r/g, "\r");
+  result = result.replace(/\\\\/g, "\\");
+  return result;
+}
+function parseSubstituteCommand(command) {
+  const match = command.match(/^s(.)(.*?)\1(.*?)\1?([gicGIC]*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, , pattern, replacement, flags] = match;
+  return {
+    pattern: pattern ?? "",
+    replacement: replacement ?? "",
+    global: (flags ?? "").toLowerCase().includes("g"),
+    ignoreCase: (flags ?? "").toLowerCase().includes("i"),
+    confirmEach: (flags ?? "").toLowerCase().includes("c")
+  };
+}
+function vimPatternToRegex(vimPattern) {
+  let p2 = vimPattern;
+  p2 = p2.replace(/\\\(/g, "(");
+  p2 = p2.replace(/\\\)/g, ")");
+  p2 = p2.replace(/\\\|/g, "|");
+  p2 = p2.replace(/\\=/g, "?");
+  p2 = p2.replace(/\\\+/g, "+");
+  p2 = p2.replace(/\\\{/g, "{");
+  p2 = p2.replace(/\\\}/g, "}");
+  p2 = p2.replace(/\\</g, "\\b");
+  p2 = p2.replace(/\\>/g, "\\b");
+  p2 = p2.replace(/\\s/g, "\\s");
+  p2 = p2.replace(/\\S/g, "\\S");
+  p2 = p2.replace(/\\d/g, "\\d");
+  p2 = p2.replace(/\\D/g, "\\D");
+  p2 = p2.replace(/\\w/g, "\\w");
+  p2 = p2.replace(/\\W/g, "\\W");
+  p2 = p2.replace(/\\a/g, "[a-zA-Z]");
+  p2 = p2.replace(/\\A/g, "[^a-zA-Z]");
+  p2 = p2.replace(/\\l/g, "[a-z]");
+  p2 = p2.replace(/\\u/g, "[A-Z]");
+  p2 = p2.replace(/\\n/g, "\\n");
+  return p2;
+}
+
 // src/commands/misc.ts
 var JumpForward = class extends Command {
   key = "<C-i>";
@@ -6534,6 +6687,10 @@ var Session = class _Session {
   }
   handleKey(key) {
     key = _Session.normalizeKey(key);
+    if (this.state.pendingConfirm !== null) {
+      this.handleConfirmMode(key);
+      return;
+    }
     if (this.state.mode === 1 /* INSERT */) {
       this.handleInsertMode(key);
       return;
@@ -6565,6 +6722,7 @@ var Session = class _Session {
       const stateBefore = this.state;
       result.context.registerManager = this.registerManager;
       result.context.indentationManager = this.indentationManager;
+      result.context.lastSubstitute = this.state.lastSubstitute;
       this.state = result.command.execute(this.state, result.context);
       if ((stateBefore.mode === 2 /* VISUAL */ || stateBefore.mode === 3 /* VISUAL_LINE */ || stateBefore.mode === 4 /* VISUAL_BLOCK */) && this.state.mode === stateBefore.mode && // Still in same visual mode
       stateBefore.visualAnchor && (this.state.cursor.line !== stateBefore.cursor.line || this.state.cursor.column !== stateBefore.cursor.column)) {
@@ -6714,24 +6872,331 @@ var Session = class _Session {
       };
     }
   }
+  // ── Ex-command range helpers ──────────────────────────────────────────────
+  resolveAddress(addr, lines, currentLine2) {
+    addr = addr.trim();
+    if (addr === "" || addr === ".") return currentLine2;
+    if (addr === "$") return lines.length - 1;
+    const n2 = parseInt(addr, 10);
+    if (!isNaN(n2)) return Math.max(0, Math.min(n2 - 1, lines.length - 1));
+    return currentLine2;
+  }
+  /**
+   * Resolve a vim range string to [startLine, endLine] (0-indexed, inclusive).
+   * Returns null when the range string contains no range (use defaults for the command).
+   */
+  resolveRange(rangeStr, lines, currentLine2) {
+    if (rangeStr === "") return null;
+    if (rangeStr === "%") return [0, lines.length - 1];
+    if (rangeStr === ".") return [currentLine2, currentLine2];
+    if (rangeStr === "$") return [lines.length - 1, lines.length - 1];
+    const commaIdx = rangeStr.indexOf(",");
+    if (commaIdx !== -1) {
+      const start = this.resolveAddress(rangeStr.slice(0, commaIdx), lines, currentLine2);
+      const end = this.resolveAddress(rangeStr.slice(commaIdx + 1), lines, currentLine2);
+      return [Math.min(start, end), Math.max(start, end)];
+    }
+    const single = this.resolveAddress(rangeStr, lines, currentLine2);
+    return [single, single];
+  }
+  /**
+   * Split a raw ex command string into [rangeStr, commandBody].
+   * Handles: %, ., $, N, N,M, .,$ etc.
+   */
+  splitRangeAndCommand(cmd) {
+    const rangeRe = /^(%|\.|(?:\d+|\.|\.?\$?)(?:,(?:\d+|\.|\.?\$?))?)/;
+    const m = rangeRe.exec(cmd);
+    if (m) {
+      const range = m[0];
+      const rest = cmd.slice(range.length).trimStart();
+      return [range, rest];
+    }
+    return ["", cmd];
+  }
+  // ── :m (move) ──────────────────────────────────────────────────────────────
+  executeMoveLines(startLine, endLine, dest) {
+    const lines = this.state.buffer.content.split("\n");
+    const count = endLine - startLine + 1;
+    const toMove = lines.splice(startLine, count);
+    let adjustedDest = dest;
+    if (dest >= startLine) adjustedDest -= count;
+    adjustedDest = Math.max(-1, Math.min(adjustedDest, lines.length - 1));
+    lines.splice(adjustedDest + 1, 0, ...toMove);
+    const newCursorLine = Math.min(adjustedDest + count, lines.length - 1);
+    this.state = {
+      ...this.state,
+      buffer: new Buffer(lines.join("\n")),
+      cursor: new Cursor(Math.max(0, newCursorLine), 0),
+      desiredColumn: null
+    };
+  }
+  // ── :s (substitute) ────────────────────────────────────────────────────────
+  executeSubstitute(rangeStr, subcmd) {
+    const parsed = parseSubstituteCommand(subcmd);
+    if (!parsed) return;
+    const lines = this.state.buffer.content.split("\n");
+    const currentLine2 = this.state.cursor.line;
+    let startLine = currentLine2;
+    let endLine = currentLine2;
+    if (rangeStr !== "") {
+      const resolved = this.resolveRange(rangeStr, lines, currentLine2);
+      if (resolved) {
+        [startLine, endLine] = resolved;
+      }
+    }
+    const lastSub = {
+      pattern: parsed.pattern,
+      replacement: parsed.replacement,
+      global: parsed.global,
+      ignoreCase: parsed.ignoreCase
+    };
+    if (parsed.confirmEach) {
+      const matches = findSubstituteMatches(
+        this.state.buffer.content,
+        startLine,
+        endLine,
+        { pattern: parsed.pattern, replacement: parsed.replacement, global: parsed.global, ignoreCase: parsed.ignoreCase }
+      );
+      if (matches.length === 0) return;
+      const pendingConfirm = {
+        matches,
+        currentIndex: 0,
+        appliedIndices: [],
+        originalContent: this.state.buffer.content
+      };
+      this.state = { ...this.state, lastSubstitute: lastSub, pendingConfirm };
+      return;
+    }
+    const result = substitute(
+      this.state.buffer.content,
+      startLine,
+      endLine,
+      { pattern: parsed.pattern, replacement: parsed.replacement, global: parsed.global, ignoreCase: parsed.ignoreCase }
+    );
+    if (result.replacements === 0) {
+      this.state = { ...this.state, lastSubstitute: lastSub };
+      return;
+    }
+    const lastModifiedLine = result.lines[result.lines.length - 1] ?? currentLine2;
+    this.state = {
+      ...this.state,
+      buffer: new Buffer(result.newContent),
+      cursor: new Cursor(lastModifiedLine, 0),
+      desiredColumn: null,
+      lastSubstitute: lastSub
+    };
+  }
+  // ── :g / :v (global) ───────────────────────────────────────────────────────
+  executeGlobal(rangeStr, subcmd, invert) {
+    const firstChar = subcmd[0];
+    if (!firstChar) return;
+    const parts = subcmd.slice(1).split(firstChar);
+    if (parts.length < 2) return;
+    const [pattern, ...cmdParts] = parts;
+    const cmd = cmdParts.join(firstChar);
+    const lines = this.state.buffer.content.split("\n");
+    const currentLine2 = this.state.cursor.line;
+    const resolved = this.resolveRange(rangeStr, lines, currentLine2) ?? [0, lines.length - 1];
+    const [startLine, endLine] = resolved;
+    let regex;
+    try {
+      regex = new RegExp(pattern ?? "", "g");
+    } catch {
+      return;
+    }
+    const matchingLines = [];
+    for (let i = startLine; i <= endLine; i++) {
+      const line = lines[i] ?? "";
+      regex.lastIndex = 0;
+      const matches = regex.test(line);
+      if (matches !== invert) {
+        matchingLines.push(i);
+      }
+    }
+    let lineOffset = 0;
+    for (const origLine of matchingLines) {
+      const adjustedLine = origLine + lineOffset;
+      const prevLineCount = this.state.buffer.content.split("\n").length;
+      const currentLines = this.state.buffer.content.split("\n");
+      const safeAdjusted = Math.max(0, Math.min(adjustedLine, currentLines.length - 1));
+      this.state = {
+        ...this.state,
+        cursor: new Cursor(safeAdjusted, 0)
+      };
+      this.executeSubCommand(cmd, safeAdjusted);
+      const newLineCount = this.state.buffer.content.split("\n").length;
+      lineOffset += newLineCount - prevLineCount;
+    }
+  }
+  /** Execute a single ex sub-command (used by :g/:v) with cursor on `currentLine`. */
+  executeSubCommand(subcmd, currentLine2) {
+    const trimmed = subcmd.trim();
+    if (trimmed === "") return;
+    if (trimmed === "d" || trimmed === "delete") {
+      const lines = this.state.buffer.content.split("\n");
+      if (currentLine2 >= lines.length) return;
+      lines.splice(currentLine2, 1);
+      const newLine = Math.min(currentLine2, lines.length - 1);
+      this.state = {
+        ...this.state,
+        buffer: new Buffer(lines.join("\n")),
+        cursor: new Cursor(Math.max(0, newLine), 0),
+        desiredColumn: null
+      };
+      return;
+    }
+    const moveM = /^m(?:ove)?\s*(.*)$/.exec(trimmed);
+    if (moveM) {
+      const addrStr = (moveM[1] ?? "").trim();
+      const lines = this.state.buffer.content.split("\n");
+      const dest = addrStr === "0" ? -1 : this.resolveAddress(addrStr, lines, currentLine2);
+      this.executeMoveLines(currentLine2, currentLine2, dest === -1 ? -1 : dest);
+      return;
+    }
+    const subsM = /^s(.)/.exec(trimmed);
+    if (subsM) {
+      this.executeSubstitute(".", trimmed);
+      return;
+    }
+    if (trimmed === "p" || trimmed === "print") return;
+  }
+  // ── Shell filter (%!cmd) ───────────────────────────────────────────────────
+  executeShellFilter(rangeStr, shellCmd) {
+    const filterFn = this.configManager.filterCommand;
+    if (!filterFn) return;
+    const lines = this.state.buffer.content.split("\n");
+    const currentLine2 = this.state.cursor.line;
+    const [startLine, endLine] = this.resolveRange(rangeStr, lines, currentLine2) ?? [0, lines.length - 1];
+    const input = lines.slice(startLine, endLine + 1).join("\n");
+    let output;
+    try {
+      output = filterFn(shellCmd, input);
+    } catch {
+      return;
+    }
+    const outputLines = output.split("\n");
+    const newLines = [
+      ...lines.slice(0, startLine),
+      ...outputLines,
+      ...lines.slice(endLine + 1)
+    ];
+    this.state = {
+      ...this.state,
+      buffer: new Buffer(newLines.join("\n")),
+      cursor: new Cursor(Math.min(startLine + outputLines.length - 1, newLines.length - 1), 0),
+      desiredColumn: null
+    };
+  }
+  // ── Confirm-substitution mode ─────────────────────────────────────────────
+  /**
+   * Handle key input while a confirm-substitution is pending.
+   * Keys: y (apply), n (skip), a (apply all), q (quit/cancel remaining), l (apply this + quit)
+   */
+  handleConfirmMode(key) {
+    const pending = this.state.pendingConfirm;
+    const { matches, currentIndex, appliedIndices } = pending;
+    const advance = (applied) => {
+      const nextIndex = currentIndex + 1;
+      if (nextIndex >= matches.length) {
+        const newContent = applySubstituteMatches(
+          pending.originalContent,
+          matches,
+          new Set(applied)
+        );
+        this.state = {
+          ...this.state,
+          buffer: new Buffer(newContent),
+          pendingConfirm: null,
+          cursor: new Cursor(matches[applied[applied.length - 1] ?? 0]?.line ?? this.state.cursor.line, 0),
+          desiredColumn: null
+        };
+      } else {
+        this.state = {
+          ...this.state,
+          pendingConfirm: { ...pending, currentIndex: nextIndex, appliedIndices: applied }
+        };
+      }
+    };
+    const finishNow = (applied) => {
+      const newContent = applySubstituteMatches(
+        pending.originalContent,
+        matches,
+        new Set(applied)
+      );
+      const lastApplied = applied[applied.length - 1];
+      this.state = {
+        ...this.state,
+        buffer: new Buffer(newContent),
+        pendingConfirm: null,
+        cursor: new Cursor(lastApplied !== void 0 ? matches[lastApplied]?.line ?? this.state.cursor.line : this.state.cursor.line, 0),
+        desiredColumn: null
+      };
+    };
+    if (key === "y") {
+      advance([...appliedIndices, currentIndex]);
+    } else if (key === "n") {
+      advance([...appliedIndices]);
+    } else if (key === "a") {
+      const allApplied = [...appliedIndices];
+      for (let i = currentIndex; i < matches.length; i++) allApplied.push(i);
+      finishNow(allApplied);
+    } else if (key === "l") {
+      finishNow([...appliedIndices, currentIndex]);
+    } else if (key === "q" || key === "<Esc>") {
+      finishNow([...appliedIndices]);
+    }
+  }
+  // ── Main ex-command dispatcher ─────────────────────────────────────────────
   executeCommand(command) {
-    const cmd = command.trim();
+    const raw = command.trim();
+    const [rangeStr, cmd] = this.splitRangeAndCommand(raw);
     const setMatch = cmd.match(/^set\s+(.+)$/);
     if (setMatch) {
-      const setCommand = setMatch[1].trim();
-      this.configManager.parseSetCommand(setCommand);
+      this.configManager.parseSetCommand(setMatch[1].trim());
       return;
     }
-    if (cmd === "q" || cmd === "quit") {
+    if (/^s[^a-zA-Z]/.test(cmd)) {
+      this.executeSubstitute(rangeStr, cmd);
       return;
     }
-    if (cmd === "w" || cmd === "write") {
+    const globalM = /^(g|v)([^a-zA-Z].+)$/.exec(cmd);
+    if (globalM) {
+      const invert = globalM[1] === "v";
+      this.executeGlobal(rangeStr, globalM[2], invert);
       return;
     }
-    if (cmd === "wq" || cmd === "x") {
+    const moveM = /^m(?:ove)?\s*(.*)$/.exec(cmd);
+    if (moveM) {
+      const addrStr = (moveM[1] ?? "").trim();
+      const lines = this.state.buffer.content.split("\n");
+      const currentLine2 = this.state.cursor.line;
+      const [startLine, endLine] = this.resolveRange(rangeStr, lines, currentLine2) ?? [currentLine2, currentLine2];
+      const dest = addrStr === "0" ? -1 : this.resolveAddress(addrStr, lines, currentLine2);
+      this.executeMoveLines(startLine, endLine, dest);
+      return;
+    }
+    if (cmd.startsWith("!")) {
+      this.executeShellFilter(rangeStr || "%", cmd.slice(1).trim());
+      return;
+    }
+    if (cmd === "d" || cmd === "delete") {
+      const lines = this.state.buffer.content.split("\n");
+      const currentLine2 = this.state.cursor.line;
+      const [startLine, endLine] = this.resolveRange(rangeStr, lines, currentLine2) ?? [currentLine2, currentLine2];
+      lines.splice(startLine, endLine - startLine + 1);
+      this.state = {
+        ...this.state,
+        buffer: new Buffer(lines.join("\n")),
+        cursor: new Cursor(Math.max(0, Math.min(startLine, lines.length - 1)), 0),
+        desiredColumn: null
+      };
       return;
     }
-    const lineMatch = cmd.match(/^(\d+)$/);
+    if (cmd === "q" || cmd === "quit") return;
+    if (cmd === "w" || cmd === "write") return;
+    if (cmd === "wq" || cmd === "x") return;
+    const lineNavStr = cmd !== "" ? cmd : rangeStr;
+    const lineMatch = lineNavStr.match(/^(\d+)$/);
     if (lineMatch) {
       const targetLine = parseInt(lineMatch[1], 10) - 1;
       const lines = this.state.buffer.content.split("\n");