pi-vim 0.1.2 → 0.1.4

package/README.md

@@ -50,34 +50,42 @@ Insert-mode shortcuts (stay in Insert mode):
 
 ### Navigation (Normal mode)
 
-| Key   | Action                  |
-|-------|-------------------------|
-| `h`   | Left                    |
-| `l`   | Right                   |
-| `j`   | Down                    |
-| `k`   | Up                      |
-| `0`   | Line start              |
-| `$`   | Line end                |
-| `gg`  | Buffer start (line 1)   |
-| `G`   | Buffer end (last line)  |
-| `w`   | Next word start         |
-| `b`   | Previous word start     |
-| `e`   | Word end (inclusive)    |
+A `{count}` prefix can be prepended to any navigation key (max: `9999`).
+
+| Key           | Action                        |
+|---------------|-------------------------------|
+| `h`           | Left                          |
+| `l`           | Right                         |
+| `j`           | Down                          |
+| `k`           | Up                            |
+| `{count}h/l`  | Move left/right `{count}` cols  |
+| `{count}j/k`  | Move down/up `{count}` lines (clamped to buffer size) |
+| `0`           | Line start                    |
+| `$`           | Line end                      |
+| `gg`          | Buffer start (line 1)         |
+| `G`           | Buffer end (last line)        |
+| `w`           | Next word start               |
+| `b`           | Previous word start           |
+| `e`           | Word end (inclusive)          |
+| `{count}w/b/e`| Move `{count}` words          |
 
 ---
 
 ### Character-find motions (Normal mode)
 
-| Key        | Action                                         |
-|------------|------------------------------------------------|
-| `f{char}`  | Jump forward to `char` (inclusive)             |
-| `F{char}`  | Jump backward to `char` (inclusive)            |
-| `t{char}`  | Jump forward to one before `char` (exclusive)  |
-| `T{char}`  | Jump backward to one after `char` (exclusive)  |
-| `;`        | Repeat last `f/F/t/T` motion                   |
-| `,`        | Repeat last motion in reverse direction         |
+A `{count}` prefix finds the Nth occurrence of `{char}` on the line.
 
-Char-find motions compose with operators: `df{char}`, `ct{char}`, etc.
+| Key              | Action                                         |
+|------------------|------------------------------------------------|
+| `f{char}`        | Jump forward to `char` (inclusive)             |
+| `F{char}`        | Jump backward to `char` (inclusive)            |
+| `t{char}`        | Jump forward to one before `char` (exclusive)  |
+| `T{char}`        | Jump backward to one after `char` (exclusive)  |
+| `{count}f{char}` | Jump to Nth occurrence of `char` forward       |
+| `;`              | Repeat last `f/F/t/T` motion                   |
+| `,`              | Repeat last motion in reverse direction         |
+
+Char-find motions compose with operators: `df{char}`, `ct{char}`, `d{count}t{char}`, etc.
 
 ---
 
@@ -88,47 +96,57 @@ All operators write to the unnamed register and mirror to the system clipboard
 
 #### Delete `d{motion}` / `dd`
 
-| Command    | Deletes                                     |
-|------------|---------------------------------------------|
-| `dw`         | Forward to next word start (exclusive, can cross lines) |
-| `de`         | Forward to word end (inclusive, can cross lines)        |
-| `db`         | Backward to word start (exclusive, can cross lines)     |
-| `d$`         | To end of line                                          |
-| `d0`         | To start of line                                        |
-| `dd`         | Current line (linewise)                                 |
-| `{count}dd`  | `{count}` lines (linewise)                              |
-| `d{count}j`  | Current line + `{count}` lines below (linewise)         |
-| `d{count}k`  | Current line + `{count}` lines above (linewise)         |
-| `dG`         | Current line to end of buffer (linewise)                |
-| `df{char}`   | To and including `char`                                 |
-| `dt{char}`   | Up to (not including) `char`                            |
-| `dF{char}`   | Backward to and including `char`                        |
-| `dT{char}`   | Backward to one after `char`                            |
-| `diw`        | Inner word                                              |
-| `daw`        | Around word (includes surrounding spaces)               |
+A `{count}` or dual-count prefix (`{pfx}d{op}{motion}`) is supported for
+word, char-find, and linewise motions. Maximum total count: `9999`.
+
+| Command           | Deletes                                                   |
+|-------------------|-----------------------------------------------------------|
+| `dw`              | Forward to next word start (exclusive, can cross lines)   |
+| `de`              | Forward to word end (inclusive, can cross lines)          |
+| `db`              | Backward to word start (exclusive, can cross lines)       |
+| `d{count}w/e/b`   | Forward/backward `{count}` words                          |
+| `d$`              | To end of line                                            |
+| `d0`              | To start of line                                          |
+| `dd`              | Current line (linewise)                                   |
+| `{count}dd`       | `{count}` lines (linewise)                                |
+| `d{count}j`       | Current line + `{count}` lines below (linewise)           |
+| `d{count}k`       | Current line + `{count}` lines above (linewise)           |
+| `dG`              | Current line to end of buffer (linewise)                  |
+| `df{char}`        | To and including `char`                                   |
+| `d{count}f{char}` | To and including Nth `char`                               |
+| `dt{char}`        | Up to (not including) `char`                              |
+| `dF{char}`        | Backward to and including `char`                          |
+| `dT{char}`        | Backward to one after `char`                              |
+| `diw`             | Inner word                                                |
+| `daw`             | Around word (includes surrounding spaces)                 |
+| `d{count}aw`      | Around `{count}` words                                    |
 
 #### Change `c{motion}` / `cc`
 
-Same motion set as `d`. Deletes text then enters Insert mode.
+Same motion and count set as `d`. Deletes text then enters Insert mode.
 
-| Command | Alias |
-|---------|-------|
-| `cw`    | delete word + Insert |
-| `ciw`   | change inner word |
-| `caw`   | change around word |
-| `cc`    | delete line + Insert |
-| `c$`    | delete to EOL + Insert |
-| …       | all `d` motions apply |
+| Command         | Action                             |
+|-----------------|------------------------------------|
+| `cw`            | Delete word + Insert               |
+| `c{count}w/e/b` | Delete `{count}` words + Insert    |
+| `ciw`           | Change inner word                  |
+| `caw`           | Change around word                 |
+| `cc`            | Delete line content + Insert       |
+| `c$`            | Delete to EOL + Insert             |
+| …               | All `d` motions apply              |
 
 #### Single-key edits
 
-| Key | Action                                       |
-|-----|----------------------------------------------|
-| `x` | Delete char under cursor (no-op at/past EOL) |
-| `s` | Delete char under cursor + Insert mode       |
-| `S` | Delete line content + Insert mode            |
-| `D` | Delete cursor to EOL (captures `\n` if at EOL with next line) |
-| `C` | Delete cursor to EOL + Insert mode           |
+A `{count}` prefix is supported for `x`, `p`, `P`. Maximum: `9999`.
+
+| Key          | Action                                                        |
+|--------------|---------------------------------------------------------------|
+| `x`          | Delete char under cursor (no-op at/past EOL)                  |
+| `{count}x`   | Delete `{count}` chars                                        |
+| `s`          | Delete char under cursor + Insert mode                        |
+| `S`          | Delete line content + Insert mode                             |
+| `D`          | Delete cursor to EOL (captures `\n` if at EOL with next line) |
+| `C`          | Delete cursor to EOL + Insert mode                            |
 
 ---
 
@@ -156,10 +174,12 @@ Same motion set as `d`. Writes to register, **no text mutation**.
 
 ### Put / Paste
 
-| Key | Action                                                      |
-|-----|-------------------------------------------------------------|
-| `p` | Put after cursor (char-wise) / new line below (line-wise)   |
-| `P` | Put before cursor (char-wise) / new line above (line-wise)  |
+| Key          | Action                                                      |
+|--------------|-------------------------------------------------------------|
+| `p`          | Put after cursor (char-wise) / new line below (line-wise)   |
+| `P`          | Put before cursor (char-wise) / new line above (line-wise)  |
+| `{count}p`   | Put `{count}` times after cursor                            |
+| `{count}P`   | Put `{count}` times before cursor                           |
 
 Put reads from the **unnamed register** (not OS clipboard).  
 Line-wise detection: register content ending in `\n` is treated as line-wise.
@@ -199,7 +219,7 @@ Redo (`<C-r>`) is **not implemented** — see [Out of scope](#out-of-scope).
 | Redo                  | Not implemented                        | `<C-r>`                       |
 | Visual mode           | Not implemented                        | `v`, `V`, `<C-v>`            |
 | Text objects          | Supports `iw`/`aw` only               | Full text-object set           |
-| Count prefix          | Partial: linewise `dd`/`yy` and `d/y{count}j/k` only | Supported                     |
+| Count prefix          | Supported for operators, word/char motions, navigation, and edits (`x`, `p`/`P`); capped at `MAX_COUNT=9999` to prevent abuse | Full support |
 | Named registers       | Not implemented (`"a`, etc.)           | Supported                     |
 | Macros                | Not implemented (`q`, `@`)             | Supported                     |
 | Search                | Not implemented (`/`, `?`, `n`, `N`)   | Supported                     |
@@ -219,7 +239,7 @@ These are **explicitly deferred** and not planned for this feature:
 - Ex command surface (`:s`, `:g`, `:r`, …)
 - Search mode (`/`, `?`, `n`, `N`)
 - Repeat (`.`)
-- General count prefixes beyond current linewise scope (`3dw`, `2j`, …)
+- Extended count prefix beyond currently supported motions (e.g. counted `gg`, `:`, global operator counts)
 - Redo (`<C-r>`) — no native redo primitive in the underlying readline editor;
   deferred until a suitable hook is available.
 - Window / tab / buffer management

package/index.ts

@@ -88,14 +88,15 @@ import {
 const BRACKETED_PASTE_START = "\x1b[200~";
 const BRACKETED_PASTE_END = "\x1b[201~";
 const BRACKETED_PASTE_END_TAIL = BRACKETED_PASTE_END.slice(1);
+const MAX_COUNT = 9999;
 
 export class ModalEditor extends CustomEditor {
   private mode: Mode = "insert";
   private pendingMotion: PendingMotion = null;
   private pendingTextObject: "i" | "a" | null = null;
   private pendingOperator: PendingOperator = null;
-  private pendingCount: string = "";
-  private pendingCountKind: "prefix" | "operator" | null = null;
+  private prefixCount: string = "";
+  private operatorCount: string = "";
   private pendingG: boolean = false;
   private lastCharMotion: LastCharMotion | null = null;
   private discardingBracketedPasteInNormalMode: boolean = false;
@@ -119,8 +120,8 @@ export class ModalEditor extends CustomEditor {
     this.pendingMotion = null;
     this.pendingTextObject = null;
     this.pendingOperator = null;
-    this.pendingCount = "";
-    this.pendingCountKind = null;
+    this.prefixCount = "";
+    this.operatorCount = "";
     this.pendingG = false;
   }
 
@@ -272,7 +273,8 @@ export class ModalEditor extends CustomEditor {
       this.pendingMotion
       || this.pendingTextObject
       || this.pendingOperator
-      || this.pendingCount
+      || this.prefixCount
+      || this.operatorCount
       || this.pendingG
     ) {
       this.clearPendingState();
@@ -307,21 +309,38 @@ export class ModalEditor extends CustomEditor {
     return data.length === 1 && data >= "1" && data <= "9";
   }
 
-  private takePendingCount(defaultValue: number = 1): number {
-    if (!this.pendingCount) return defaultValue;
+  private takeTotalCount(defaultValue: number = 1): number {
+    const prefixRaw = this.prefixCount;
+    const operatorRaw = this.operatorCount;
+    this.prefixCount = "";
+    this.operatorCount = "";
 
-    const parsed = Number.parseInt(this.pendingCount, 10);
-    this.pendingCount = "";
-    this.pendingCountKind = null;
+    if (!prefixRaw && !operatorRaw) return defaultValue;
 
-    if (!Number.isFinite(parsed) || parsed <= 0) return defaultValue;
-    return parsed;
+    const parse = (raw: string): number | null => {
+      if (!raw) return null;
+      const parsed = Number.parseInt(raw, 10);
+      if (!Number.isFinite(parsed) || parsed <= 0) return null;
+      return parsed;
+    };
+
+    const prefix = parse(prefixRaw);
+    const operator = parse(operatorRaw);
+
+    if (prefix === null && operator === null) return defaultValue;
+
+    const total = prefix !== null && operator !== null
+      ? prefix * operator
+      : prefix ?? operator ?? defaultValue;
+
+    if (!Number.isFinite(total) || total <= 0) return defaultValue;
+    return Math.min(MAX_COUNT, total);
   }
 
   private cancelPendingOperator(data: string): void {
     this.pendingOperator = null;
-    this.pendingCount = "";
-    this.pendingCountKind = null;
+    this.prefixCount = "";
+    this.operatorCount = "";
     if (!this.isPrintableChunk(data)) {
       super.handleInput(data);
     }
@@ -358,7 +377,8 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    const range = this.getWordObjectRange(this.pendingTextObject!);
+    const count = this.takeTotalCount(1);
+    const range = this.getWordObjectRange(this.pendingTextObject!, count);
     this.pendingTextObject = null;
     if (!range || !this.pendingOperator) {
       this.pendingOperator = null;
@@ -390,43 +410,35 @@ export class ModalEditor extends CustomEditor {
 
   private handlePendingDelete(data: string): void {
     if (this.isDigit(data)) {
-      if (this.pendingCount.length === 0) {
+      if (this.operatorCount.length === 0) {
         if (data !== "0") {
-          this.pendingCount = data;
-          this.pendingCountKind = "operator";
+          this.operatorCount = data;
           return;
         }
-      } else if (this.pendingCountKind === "operator") {
-        this.pendingCount += data;
-        return;
       } else {
-        // Dual counts like 2d3j are out of scope; fail closed.
-        this.cancelPendingOperator(data);
+        this.operatorCount += data;
         return;
       }
     }
 
     if (data === "d") {
-      const count = this.takePendingCount(1);
+      const count = this.takeTotalCount(1);
       this.deleteLinewiseByDelta(count - 1);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "j" || data === "k") {
-      if (this.pendingCountKind === "prefix") {
-        this.cancelPendingOperator(data);
-        return;
-      }
-
-      const count = this.takePendingCount(1);
-      this.deleteLinewiseByDelta(data === "j" ? count : -count);
+      const hasDualCount = this.prefixCount.length > 0 && this.operatorCount.length > 0;
+      const count = this.takeTotalCount(1);
+      const delta = hasDualCount ? Math.max(0, count - 1) : count;
+      this.deleteLinewiseByDelta(data === "j" ? delta : -delta);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "G") {
-      if (this.pendingCount.length > 0) {
+      if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
         this.cancelPendingOperator(data);
         return;
       }
@@ -436,22 +448,29 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (this.pendingCount.length > 0) {
-      // Counted forms beyond dd and d{count}j/k are intentionally out of scope.
-      this.cancelPendingOperator(data);
+    if (CHAR_MOTION_KEYS.has(data)) {
+      this.pendingMotion = data as PendingMotion;
       return;
     }
 
-    if (data === "i" || data === "a") {
-      this.pendingTextObject = data;
+    const hasCount = this.prefixCount.length > 0 || this.operatorCount.length > 0;
+    const supportsCountedWordMotion = data === "w" || data === "e" || data === "b";
+    const supportsCountedTextObject = data === "i" || data === "a";
+
+    if (hasCount && !supportsCountedWordMotion && !supportsCountedTextObject) {
+      // Counted forms beyond dd, d{count}j/k, d{count}{f/F/t/T}, and
+      // d{count}{w/e/b}/{i/a}w are out of scope.
+      this.cancelPendingOperator(data);
       return;
     }
-    if (CHAR_MOTION_KEYS.has(data)) {
-      this.pendingMotion = data as PendingMotion;
+
+    if (supportsCountedTextObject) {
+      this.pendingTextObject = data;
       return;
     }
 
-    if (this.deleteWithMotion(data)) {
+    const motionCount = supportsCountedWordMotion ? this.takeTotalCount(1) : 1;
+    if (this.deleteWithMotion(data, motionCount)) {
       this.pendingOperator = null;
       return;
     }
@@ -461,21 +480,50 @@ export class ModalEditor extends CustomEditor {
   }
 
   private handlePendingChange(data: string): void {
+    if (this.isDigit(data)) {
+      if (this.operatorCount.length === 0) {
+        if (data !== "0") {
+          this.operatorCount = data;
+          return;
+        }
+      } else {
+        this.operatorCount += data;
+        return;
+      }
+    }
+
     if (data === "c") {
+      if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
+        this.cancelPendingOperator(data);
+        return;
+      }
+
       this.cutLine();
       this.pendingOperator = null;
       this.mode = "insert";
       return;
     }
-    if (data === "i" || data === "a") {
-      this.pendingTextObject = data;
-      return;
-    }
     if (CHAR_MOTION_KEYS.has(data)) {
       this.pendingMotion = data as PendingMotion;
       return;
     }
-    if (this.deleteWithMotion(data)) {
+
+    const hasCount = this.prefixCount.length > 0 || this.operatorCount.length > 0;
+    const supportsCountedWordMotion = data === "w" || data === "e" || data === "b";
+    const supportsCountedTextObject = data === "i" || data === "a";
+
+    if (hasCount && !supportsCountedWordMotion && !supportsCountedTextObject) {
+      this.cancelPendingOperator(data);
+      return;
+    }
+
+    if (supportsCountedTextObject) {
+      this.pendingTextObject = data;
+      return;
+    }
+
+    const motionCount = supportsCountedWordMotion ? this.takeTotalCount(1) : 1;
+    if (this.deleteWithMotion(data, motionCount)) {
       this.pendingOperator = null;
       this.mode = "insert";
       return;
@@ -495,23 +543,77 @@ export class ModalEditor extends CustomEditor {
       // Unsupported g-prefix command: discard prefix and keep processing input.
     }
 
-    if (this.pendingCount.length > 0) {
-      if (this.isDigit(data) && this.pendingCountKind === "prefix") {
-        this.pendingCount += data;
+    if (this.prefixCount.length > 0) {
+      if (this.isDigit(data)) {
+        this.prefixCount += data;
         return;
       }
 
-      if ((data === "d" || data === "y") && this.pendingCountKind === "prefix") {
+      if (data === "d" || data === "y") {
         this.pendingOperator = data;
         return;
       }
 
-      // Count prefixes are currently supported for dd/yy only.
-      this.pendingCount = "";
-      this.pendingCountKind = null;
+      if (data === "c") {
+        this.pendingOperator = "c";
+        return;
+      }
+
+      const supportsCountedStandaloneEdit = (
+        data === "x"
+        || data === "s"
+        || data === "S"
+        || data === "D"
+        || data === "C"
+        || data === "p"
+        || data === "P"
+      );
+      const supportsCountedCharMotion = (
+        CHAR_MOTION_KEYS.has(data)
+        || data === ";"
+        || data === ","
+      );
+      const supportsCountedWordMotion = (
+        data === "w"
+        || data === "e"
+        || data === "b"
+      );
+      const supportsCountedNav = (
+        data === "h"
+        || data === "j"
+        || data === "k"
+        || data === "l"
+      );
+
+      if (supportsCountedNav) {
+        const count = this.takeTotalCount(1);
+        const clamped = Math.min(count, MAX_COUNT);
+        if (data === "h") {
+          this.moveCursorBy(-clamped);
+        } else if (data === "l") {
+          this.moveCursorBy(clamped);
+        } else {
+          // j/k: clamp vertical nav to buffer size to prevent TUI stalls
+          const lines = this.getLines();
+          const cursorLine = this.getCursor().line;
+          const safeCount = data === "j"
+            ? Math.min(clamped, lines.length - 1 - cursorLine)
+            : Math.min(clamped, cursorLine);
+          const seq = data === "j" ? ESC_DOWN : ESC_UP;
+          for (let i = 0; i < safeCount; i++) {
+            super.handleInput(seq);
+          }
+        }
+        return;
+      }
+
+      if (!supportsCountedStandaloneEdit && !supportsCountedCharMotion && !supportsCountedWordMotion) {
+        // Unsupported prefixed forms: drop count and keep processing this key.
+        this.prefixCount = "";
+        this.operatorCount = "";
+      }
     } else if (this.isCountStarter(data)) {
-      this.pendingCount = data;
-      this.pendingCountKind = "prefix";
+      this.prefixCount = data;
       return;
     }
 
@@ -573,9 +675,12 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (data === "w") return this.moveWord("forward", "start");
-    if (data === "b") return this.moveWord("backward", "start");
-    if (data === "e") return this.moveWord("forward", "end");
+    if (data === "w") {
+      const count = this.takeTotalCount(1);
+      return this.moveWord("forward", "start", count);
+    }
+    if (data === "b") return this.moveWord("backward", "start", this.takeTotalCount(1));
+    if (data === "e") return this.moveWord("forward", "end", this.takeTotalCount(1));
 
     if (Object.hasOwn(NORMAL_KEYS, data)) {
       return this.handleMappedKey(data);
@@ -618,13 +723,16 @@ export class ModalEditor extends CustomEditor {
         this.mode = "insert";
         break;
       case "D":
+        this.takeTotalCount(1);
         this.cutToEndOfLine();
         break;
       case "C":
+        this.takeTotalCount(1);
         this.cutToEndOfLine();
         this.mode = "insert";
         break;
       case "S":
+        this.takeTotalCount(1);
         this.cutCurrentLineContent();
         this.mode = "insert";
         break;
@@ -643,7 +751,8 @@ export class ModalEditor extends CustomEditor {
   private executeCharMotion(motion: CharMotion, targetChar: string, saveMotion: boolean = true): void {
     const line = this.getLines()[this.getCursor().line] ?? "";
     const col = this.getCursor().col;
-    const targetCol = findCharMotionTarget(line, col, motion, targetChar, !saveMotion);
+    const count = this.takeTotalCount(1);
+    const targetCol = findCharMotionTarget(line, col, motion, targetChar, !saveMotion, count);
 
     if (targetCol !== null && saveMotion) {
       this.lastCharMotion = { motion, char: targetChar };
@@ -755,74 +864,73 @@ export class ModalEditor extends CustomEditor {
     abs: number,
     direction: "forward" | "backward",
     target: "start" | "end",
+    count: number = 1,
   ): number {
     const len = text.length;
     if (len === 0) return 0;
 
+    const steps = Math.max(1, Math.min(MAX_COUNT, count));
     let i = Math.max(0, Math.min(abs, len));
 
-    if (direction === "forward") {
-      if (i >= len) return len;
+    for (let step = 0; step < steps; step++) {
+      let next = i;
 
-      if (target === "start") {
-        const startType = this.charType(text[i]);
-        if (startType !== "space") {
-          while (i < len && this.charType(text[i]) === startType) i++;
+      if (direction === "forward") {
+        if (next >= len) {
+          next = len;
+        } else if (target === "start") {
+          const startType = this.charType(text[next]);
+          if (startType !== "space") {
+            while (next < len && this.charType(text[next]) === startType) next++;
+          }
+          while (next < len && this.charType(text[next]) === "space") next++;
+        } else {
+          if (next < len - 1) next++;
+          while (next < len && this.charType(text[next]) === "space") next++;
+          if (next >= len) {
+            next = len;
+          } else {
+            const t = this.charType(text[next]);
+            while (next < len - 1 && this.charType(text[next + 1]) === t) next++;
+          }
         }
-        while (i < len && this.charType(text[i]) === "space") i++;
-        return i;
+      } else {
+        if (next >= len) next = len - 1;
+        if (next > 0) next--;
+        while (next > 0 && this.charType(text[next]) === "space") next--;
+        const t = this.charType(text[next]);
+        while (next > 0 && this.charType(text[next - 1]) === t) next--;
       }
 
-      if (i < len - 1) i++;
-      while (i < len && this.charType(text[i]) === "space") i++;
-      if (i >= len) return len;
-      const t = this.charType(text[i]);
-      while (i < len - 1 && this.charType(text[i + 1]) === t) i++;
-      return i;
+      if (next === i) break;
+      i = next;
     }
 
-    if (i >= len) i = len - 1;
-    if (i > 0) i--;
-    while (i > 0 && this.charType(text[i]) === "space") i--;
-    const t = this.charType(text[i]);
-    while (i > 0 && this.charType(text[i - 1]) === t) i--;
     return i;
   }
 
-  private tryFindWordTargetLineLocal(
+  private tryFindWordTargetInLine(
+    line: string,
+    col: number,
     direction: WordMotionDirection,
     target: WordMotionTarget,
     allowSameColumn: boolean = false,
   ): number | null {
-    const cursor = this.getCursor();
-    const lineIndex = cursor.line;
-    const col = cursor.col;
-    const lineSnapshot = this.getLines()[lineIndex] ?? "";
-
-    if (lineSnapshot.length === 0) return null;
-    if (col < 0 || col > lineSnapshot.length) return null;
+    if (line.length === 0) return null;
+    if (col < 0 || col > line.length) return null;
 
     if (direction === "forward") {
-      if (col >= lineSnapshot.length) return null;
+      if (col >= line.length) return null;
     } else {
       if (col <= 0) return null;
-      if (!/\S/.test(lineSnapshot.slice(0, col))) return null;
+      if (!/\S/.test(line.slice(0, col))) return null;
     }
 
-    const targetCol = this.wordBoundaryCache.tryFindTarget(
-      lineSnapshot,
-      col,
-      direction,
-      target,
-    );
+    const targetCol = this.wordBoundaryCache.tryFindTarget(line, col, direction, target);
     if (targetCol === null) return null;
 
-    const liveLine = this.getLines()[lineIndex] ?? "";
-    const liveCol = this.getCursor().col;
-    if (liveLine !== lineSnapshot || liveCol !== col) return null;
-
     if (direction === "forward") {
-      if (targetCol >= lineSnapshot.length) return null;
+      if (targetCol >= line.length) return null;
       if (allowSameColumn) {
         if (targetCol < col) return null;
       } else if (targetCol <= col) {
@@ -840,6 +948,32 @@ export class ModalEditor extends CustomEditor {
     return targetCol;
   }
 
+  private tryFindWordTargetLineLocal(
+    direction: WordMotionDirection,
+    target: WordMotionTarget,
+    allowSameColumn: boolean = false,
+  ): number | null {
+    const cursor = this.getCursor();
+    const lineIndex = cursor.line;
+    const col = cursor.col;
+    const lineSnapshot = this.getLines()[lineIndex] ?? "";
+
+    const targetCol = this.tryFindWordTargetInLine(
+      lineSnapshot,
+      col,
+      direction,
+      target,
+      allowSameColumn,
+    );
+    if (targetCol === null) return null;
+
+    const liveLine = this.getLines()[lineIndex] ?? "";
+    const liveCol = this.getCursor().col;
+    if (liveLine !== lineSnapshot || liveCol !== col) return null;
+
+    return targetCol;
+  }
+
   private tryMoveWordLineLocal(
     direction: "forward" | "backward",
     target: "start" | "end",
@@ -854,29 +988,61 @@ export class ModalEditor extends CustomEditor {
 
   private tryWordMotionLineLocalRange(
     motion: "w" | "e" | "b",
+    count: number = 1,
   ): { col: number; targetCol: number; inclusive: boolean } | null {
-    const col = this.getCursor().col;
+    const cursor = this.getCursor();
+    const lineIndex = cursor.line;
+    const col = cursor.col;
+    const lineSnapshot = this.getLines()[lineIndex] ?? "";
     const direction: WordMotionDirection = motion === "b" ? "backward" : "forward";
     const target: WordMotionTarget = motion === "e" ? "end" : "start";
-    const targetCol = this.tryFindWordTargetLineLocal(direction, target, motion === "e");
+    const steps = Math.max(1, Math.min(MAX_COUNT, count));
+
+    let currentCol = col;
+    for (let step = 0; step < steps; step++) {
+      const nextCol = this.tryFindWordTargetInLine(
+        lineSnapshot,
+        currentCol,
+        direction,
+        target,
+        motion === "e",
+      );
+      if (nextCol === null) return null;
+      if (nextCol === currentCol && step < steps - 1) return null;
+      currentCol = nextCol;
+    }
 
-    if (targetCol === null) return null;
+    const liveLine = this.getLines()[lineIndex] ?? "";
+    const liveCol = this.getCursor().col;
+    if (liveLine !== lineSnapshot || liveCol !== col) return null;
 
     return {
       col,
-      targetCol,
+      targetCol: currentCol,
       inclusive: motion === "e",
     };
   }
 
-  private moveWord(direction: "forward" | "backward", target: "start" | "end"): void {
-    if (this.tryMoveWordLineLocal(direction, target)) return;
+  private moveWord(
+    direction: "forward" | "backward",
+    target: "start" | "end",
+    count: number = 1,
+  ): void {
+    let remaining = Math.max(1, Math.min(MAX_COUNT, count));
+
+    while (remaining > 0) {
+      if (this.tryMoveWordLineLocal(direction, target)) {
+        remaining--;
+        continue;
+      }
 
-    const text = this.getText();
-    const currentAbs = this.getAbsoluteIndexFromCursor();
-    const targetAbs = this.findWordTargetInText(text, currentAbs, direction, target);
-    if (targetAbs !== currentAbs) {
-      this.moveCursorBy(targetAbs - currentAbs);
+      const text = this.getText();
+      const currentAbs = this.getAbsoluteIndexFromCursor();
+      const targetAbs = this.findWordTargetInText(text, currentAbs, direction, target, remaining);
+      if (targetAbs !== currentAbs) {
+        this.moveCursorBy(targetAbs - currentAbs);
+      }
+      return;
     }
   }
 
@@ -898,13 +1064,13 @@ export class ModalEditor extends CustomEditor {
   }
 
   private cutCharUnderCursor(): void {
+    const count = this.takeTotalCount(1);
     const { line, col } = this.getCurrentLineAndCol();
     if (line.length === 0) return; // Don't merge empty lines with x
     if (col >= line.length) return; // Don't delete past end of line
 
-    const deleted = line.slice(col, col + 1);
-    this.writeToRegister(deleted);
-    super.handleInput(ESC_DELETE);
+    const boundedCount = Math.max(1, Math.min(MAX_COUNT, count));
+    this.deleteRange(col, col + boundedCount, false);
   }
 
   private cutToEndOfLine(): void {
@@ -1023,9 +1189,8 @@ export class ModalEditor extends CustomEditor {
     this.yankLineRange(this.getCursor().line, this.getLines().length - 1);
   }
 
-  private deleteWithMotion(motion: string): boolean {
+  private deleteWithMotion(motion: string, count: number = 1): boolean {
     const cursor = this.getCursor();
-    const line = this.getLines()[cursor.line] ?? "";
     const col = cursor.col;
 
     if (motion === "$") {
@@ -1040,7 +1205,7 @@ export class ModalEditor extends CustomEditor {
     }
 
     if (motion === "w" || motion === "e" || motion === "b") {
-      const lineLocalRange = this.tryWordMotionLineLocalRange(motion);
+      const lineLocalRange = this.tryWordMotionLineLocalRange(motion, count);
       if (lineLocalRange) {
         this.deleteRange(
           lineLocalRange.col,
@@ -1057,6 +1222,7 @@ export class ModalEditor extends CustomEditor {
         currentAbs,
         motion === "b" ? "backward" : "forward",
         motion === "e" ? "end" : "start",
+        count,
       );
       this.deleteRangeByAbsolute(currentAbs, targetAbs, motion === "e");
       return true;
@@ -1068,7 +1234,8 @@ export class ModalEditor extends CustomEditor {
   private deleteWithCharMotion(motion: CharMotion, targetChar: string): void {
     const line = this.getLines()[this.getCursor().line] ?? "";
     const col = this.getCursor().col;
-    const targetCol = findCharMotionTarget(line, col, motion, targetChar);
+    const count = this.takeTotalCount(1);
+    const targetCol = findCharMotionTarget(line, col, motion, targetChar, false, count);
 
     if (targetCol === null) return;
 
@@ -1078,43 +1245,35 @@ export class ModalEditor extends CustomEditor {
 
   private handlePendingYank(data: string): void {
     if (this.isDigit(data)) {
-      if (this.pendingCount.length === 0) {
+      if (this.operatorCount.length === 0) {
         if (data !== "0") {
-          this.pendingCount = data;
-          this.pendingCountKind = "operator";
+          this.operatorCount = data;
           return;
         }
-      } else if (this.pendingCountKind === "operator") {
-        this.pendingCount += data;
-        return;
       } else {
-        // Dual counts like 2y3k are out of scope; fail closed.
-        this.cancelPendingOperator(data);
+        this.operatorCount += data;
         return;
       }
     }
 
     if (data === "y") {
-      const count = this.takePendingCount(1);
+      const count = this.takeTotalCount(1);
       this.yankLinewiseByDelta(count - 1);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "j" || data === "k") {
-      if (this.pendingCountKind === "prefix") {
-        this.cancelPendingOperator(data);
-        return;
-      }
-
-      const count = this.takePendingCount(1);
-      this.yankLinewiseByDelta(data === "j" ? count : -count);
+      const hasDualCount = this.prefixCount.length > 0 && this.operatorCount.length > 0;
+      const count = this.takeTotalCount(1);
+      const delta = hasDualCount ? Math.max(0, count - 1) : count;
+      this.yankLinewiseByDelta(data === "j" ? delta : -delta);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "G") {
-      if (this.pendingCount.length > 0) {
+      if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
         this.cancelPendingOperator(data);
         return;
       }
@@ -1124,8 +1283,13 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (this.pendingCount.length > 0) {
-      // Counted forms beyond yy and y{count}j/k are intentionally out of scope.
+    if (CHAR_MOTION_KEYS.has(data)) {
+      this.pendingMotion = data as PendingMotion;
+      return;
+    }
+
+    if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
+      // Counted forms beyond yy, y{count}j/k, and y{count}{f/F/t/T} are out of scope.
       this.cancelPendingOperator(data);
       return;
     }
@@ -1134,10 +1298,6 @@ export class ModalEditor extends CustomEditor {
       this.pendingTextObject = data;
       return;
     }
-    if (CHAR_MOTION_KEYS.has(data)) {
-      this.pendingMotion = data as PendingMotion;
-      return;
-    }
 
     if (this.yankWithMotion(data)) {
       this.pendingOperator = null;
@@ -1190,7 +1350,8 @@ export class ModalEditor extends CustomEditor {
   private yankWithCharMotion(motion: CharMotion, targetChar: string): void {
     const line = this.getLines()[this.getCursor().line] ?? "";
     const col = this.getCursor().col;
-    const targetCol = findCharMotionTarget(line, col, motion, targetChar);
+    const count = this.takeTotalCount(1);
+    const targetCol = findCharMotionTarget(line, col, motion, targetChar, false, count);
 
     if (targetCol === null) return;
 
@@ -1241,16 +1402,20 @@ export class ModalEditor extends CustomEditor {
     }
   }
 
-  private getWordObjectRange(kind: "i" | "a"): { startAbs: number; endAbs: number } | null {
+  private getWordObjectRange(
+    kind: "i" | "a",
+    count: number = 1,
+  ): { startAbs: number; endAbs: number } | null {
     const lines = this.getLines();
     const cursor = this.getCursor();
     const line = lines[cursor.line] ?? "";
     if (!line) return null;
 
-    let col = Math.min(cursor.col, Math.max(0, line.length - 1));
-
+    const steps = Math.max(1, Math.min(MAX_COUNT, count));
     const hasWordChar = (idx: number) => idx >= 0 && idx < line.length && this.isWordChar(line[idx]!);
 
+    let col = Math.min(cursor.col, Math.max(0, line.length - 1));
+
     if (!hasWordChar(col)) {
       let right = col;
       while (right < line.length && !hasWordChar(right)) right++;
@@ -1270,17 +1435,28 @@ export class ModalEditor extends CustomEditor {
     let end = col + 1;
     while (end < line.length && hasWordChar(end)) end++;
 
+    let remaining = steps - 1;
+    while (remaining > 0) {
+      let nextWordStart = end;
+      while (nextWordStart < line.length && !hasWordChar(nextWordStart)) nextWordStart++;
+      if (nextWordStart >= line.length) break;
+
+      let nextWordEnd = nextWordStart + 1;
+      while (nextWordEnd < line.length && hasWordChar(nextWordEnd)) nextWordEnd++;
+
+      end = nextWordEnd;
+      remaining--;
+    }
+
     if (kind === "a") {
-      let aroundStart = start;
       let aroundEnd = end;
-
       while (aroundEnd < line.length && /\s/.test(line[aroundEnd]!)) aroundEnd++;
-      if (aroundEnd === end) {
-        while (aroundStart > 0 && /\s/.test(line[aroundStart - 1]!)) aroundStart--;
-      }
 
-      start = aroundStart;
-      end = aroundEnd;
+      if (aroundEnd > end) {
+        end = aroundEnd;
+      } else {
+        while (start > 0 && /\s/.test(line[start - 1]!)) start--;
+      }
     }
 
     return {
@@ -1289,23 +1465,32 @@ export class ModalEditor extends CustomEditor {
     };
   }
 
+  private static readonly PUT_SIZE_LIMIT = 512 * 1024; // 512 KB safety cap
+
   private putAfter(): void {
+    const count = this.takeTotalCount(1);
     const text = this.unnamedRegister;
     if (!text) return;
+    const safeCount = Math.min(count, Math.max(1, Math.floor(ModalEditor.PUT_SIZE_LIMIT / text.length)));
 
     if (text.endsWith("\n")) {
-      // Line-wise: insert new line below and fill it
-      super.handleInput(CTRL_E);
-      super.handleInput(NEWLINE);
       const content = text.slice(0, -1);
-      for (const char of content) {
-        super.handleInput(char === "\n" ? NEWLINE : char);
-      }
-    } else {
-      // Character-wise: insert after cursor
-      if (!this.isCursorAtOrPastEol()) {
-        super.handleInput(ESC_RIGHT);
+      for (let i = 0; i < safeCount; i++) {
+        // Line-wise: insert new line below and fill it
+        super.handleInput(CTRL_E);
+        super.handleInput(NEWLINE);
+        for (const char of content) {
+          super.handleInput(char === "\n" ? NEWLINE : char);
+        }
       }
+      return;
+    }
+
+    // Character-wise: insert after cursor
+    if (!this.isCursorAtOrPastEol()) {
+      super.handleInput(ESC_RIGHT);
+    }
+    for (let i = 0; i < safeCount; i++) {
       for (const char of text) {
         super.handleInput(char === "\n" ? NEWLINE : char);
       }
@@ -1313,20 +1498,27 @@ export class ModalEditor extends CustomEditor {
   }
 
   private putBefore(): void {
+    const count = this.takeTotalCount(1);
     const text = this.unnamedRegister;
     if (!text) return;
+    const safeCount = Math.min(count, Math.max(1, Math.floor(ModalEditor.PUT_SIZE_LIMIT / text.length)));
 
     if (text.endsWith("\n")) {
-      // Line-wise: insert new line above and fill it
-      super.handleInput(CTRL_A);
-      super.handleInput(NEWLINE);
-      super.handleInput(ESC_UP);
       const content = text.slice(0, -1);
-      for (const char of content) {
-        super.handleInput(char === "\n" ? NEWLINE : char);
+      for (let i = 0; i < safeCount; i++) {
+        // Line-wise: insert new line above and fill it
+        super.handleInput(CTRL_A);
+        super.handleInput(NEWLINE);
+        super.handleInput(ESC_UP);
+        for (const char of content) {
+          super.handleInput(char === "\n" ? NEWLINE : char);
+        }
       }
-    } else {
-      // Character-wise: insert before cursor (just type it)
+      return;
+    }
+
+    // Character-wise: insert before cursor (just type it)
+    for (let i = 0; i < safeCount; i++) {
       for (const char of text) {
         super.handleInput(char === "\n" ? NEWLINE : char);
       }
@@ -1369,20 +1561,19 @@ export class ModalEditor extends CustomEditor {
   private getModeLabel(): string {
     if (this.mode === "insert") return " INSERT ";
 
-    const count = this.pendingCount;
+    const prefixCount = this.prefixCount;
+    const operatorCount = this.operatorCount;
 
     if (this.pendingOperator && this.pendingMotion) {
-      const prefix = this.pendingCountKind === "prefix" ? count : "";
-      const opCount = this.pendingCountKind === "operator" ? count : "";
-      return ` NORMAL ${prefix}${this.pendingOperator}${opCount}${this.pendingMotion}_ `;
+      return ` NORMAL ${prefixCount}${this.pendingOperator}${operatorCount}${this.pendingMotion}_ `;
     }
     if (this.pendingOperator) {
-      const prefix = this.pendingCountKind === "prefix" ? count : "";
-      const opCount = this.pendingCountKind === "operator" ? count : "";
-      return ` NORMAL ${prefix}${this.pendingOperator}${opCount}_ `;
+      return ` NORMAL ${prefixCount}${this.pendingOperator}${operatorCount}_ `;
     }
     if (this.pendingMotion) return ` NORMAL ${this.pendingMotion}_ `;
     if (this.pendingG) return " NORMAL g_ ";
+
+    const count = `${prefixCount}${operatorCount}`;
     if (count) return ` NORMAL ${count}_ `;
     return " NORMAL ";
   }

package/motions.ts

@@ -40,26 +40,35 @@ export function findCharMotionTarget(
   motion: CharMotion,
   targetChar: string,
   isRepeat: boolean = false,
+  count: number = 1,
 ): number | null {
   const isForward = motion === "f" || motion === "t";
   const isTill = motion === "t" || motion === "T";
-
-  // For till repeats (;/,), we need extra offset to skip past the character we stopped before/after
-  const tillRepeatOffset = isTill && isRepeat ? 1 : 0;
-
-  if (isForward) {
-    const searchStart = col + 1 + tillRepeatOffset;
-    const idx = line.indexOf(targetChar, searchStart);
-    if (idx !== -1) {
-      return isTill ? idx - 1 : idx;
+  const steps = Number.isFinite(count) && count > 0 ? Math.floor(count) : 1;
+
+  let currentPos = col;
+
+  for (let i = 0; i < steps; i++) {
+    const isFirst = i === 0;
+    const isFinal = i === steps - 1;
+    const tillRepeatOffset = isFirst && isTill && isRepeat ? 1 : 0;
+
+    if (isForward) {
+      const searchStart = currentPos + 1 + tillRepeatOffset;
+      const idx = line.indexOf(targetChar, searchStart);
+      if (idx === -1) return null;
+      if (isFinal) return isTill ? idx - 1 : idx;
+      currentPos = idx;
+      continue;
     }
-  } else {
-    const searchStart = col - 1 - tillRepeatOffset;
+
+    const searchStart = currentPos - 1 - tillRepeatOffset;
     const idx = line.lastIndexOf(targetChar, searchStart);
-    if (idx !== -1) {
-      return isTill ? idx + 1 : idx;
-    }
+    if (idx === -1) return null;
+    if (isFinal) return isTill ? idx + 1 : idx;
+    currentPos = idx;
   }
+
   return null;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vim",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Vim-style modal editing for Pi's TUI editor",
   "type": "module",
   "keywords": [