blots-editor 0.0.16 → 0.0.18

package/asset/language/en.json

@@ -9,7 +9,7 @@
   "settings.language.zh": "中文",
   "settings.sensitivity.cursor": "Cursor Wheel Sensitivity",
   "settings.sensitivity.view": "View Scroll Sensitivity",
-  "settings.sensitivity.hint": "Click or drag to adjust",
+  "settings.slider.hint": "Click or drag to adjust",
   "settings.back": "Back",
   "editor.mode.insert": "INSERT",
   "editor.mode.normal": "NORMAL",
@@ -20,7 +20,6 @@
   "toolbar.save": "Save",
   "toolbar.settings": "Settings",
   "fileTree.scanning": "Scanning...",
-  "fileTree.noDir": "No directory",
   "fileTree.fail": "Scan failed",
   "fileTree.unsaved": "Unsaved changes",
   "editor.setting.title": "Menu",
@@ -32,6 +31,8 @@
   "settings.fileTreeRoot": "FileTree Root",
   "settings.fileTreeRoot.startup": "Startup directory",
   "settings.fileTreeRoot.custom": "Custom path",
+  "settings.mergeWindow": "Undo Merge Window",
+  "settings.mergeWindow.off": "Off",
   "settings.ok": "OK",
   "settings.cancel": "Cancel"
 }

package/asset/language/zh.json

@@ -9,7 +9,7 @@
   "settings.language.zh": "中文",
   "settings.sensitivity.cursor": "光标滚动灵敏度",
   "settings.sensitivity.view": "视图滚动灵敏度",
-  "settings.sensitivity.hint": "点击或拖动调整",
+  "settings.slider.hint": "点击或拖动调整",
   "settings.back": "返回",
   "editor.mode.insert": "插入",
   "editor.mode.normal": "普通",
@@ -20,7 +20,6 @@
   "toolbar.save": "保存",
   "toolbar.settings": "设置",
   "fileTree.scanning": "正在扫描...",
-  "fileTree.noDir": "没有目录",
   "fileTree.fail": "扫描失败",
   "fileTree.unsaved": "未保存的更改",
   "editor.setting.title": "菜单",
@@ -32,6 +31,8 @@
   "settings.fileTreeRoot": "文件树根目录",
   "settings.fileTreeRoot.startup": "启动目录",
   "settings.fileTreeRoot.custom": "自定义路径",
+  "settings.mergeWindow": "撤销合并时间",
+  "settings.mergeWindow.off": "关闭",
   "settings.ok": "确定",
   "settings.cancel": "取消"
 }

package/dist/core/document/document.d.ts

@@ -131,9 +131,17 @@ export declare class Document {
     visualAtLogical(line: number, logical: number): number;
     moveLeft(): void;
     moveRight(): void;
-    /** Vertical movement aligns by visual column, so wide-character lines do not drift. */
-    moveUp(): void;
-    moveDown(): void;
+    /**
+     * Move up by `count` visual lines (default 1), aligning by visual column so
+     * wide-character lines do not drift. Overshooting the top clamps to the
+     * first visual line.
+     */
+    moveUp(count?: number): void;
+    /**
+     * Move down by `count` visual lines (default 1), aligning by visual column.
+     * Overshooting the bottom clamps to the last visual line.
+     */
+    moveDown(count?: number): void;
     moveToLineStart(): void;
     moveToLineEnd(): void;
     moveToDocumentStart(): void;

package/dist/core/document/document.js

@@ -325,10 +325,15 @@ export class Document {
             this.setCursor(line, target);
         }
     }
-    /** Vertical movement aligns by visual column, so wide-character lines do not drift. */
-    moveUp() {
+    /**
+     * Move up by `count` visual lines (default 1), aligning by visual column so
+     * wide-character lines do not drift. Overshooting the top clamps to the
+     * first visual line.
+     */
+    moveUp(count = 1) {
         const { line, logical } = this._cursor;
-        if (this.cursorVisualLine === 0) {
+        const current = this.cursorVisualLine;
+        if (current === 0) {
             // Already on the first visual line: still move to the start of the
             // current segment (like up-to-line-start in vim).
             const segs = this.lineSegments(line);
@@ -339,17 +344,25 @@ export class Document {
             this.setCursor(line, segs[idx].start);
             return;
         }
-        const prev = this.visualLineAt(this.cursorVisualLine - 1);
+        const step = Math.max(1, Math.round(count));
+        const prev = this.visualLineAt(Math.max(0, current - step));
         if (!prev) {
             return;
         }
         this.moveToSegment(prev);
     }
-    moveDown() {
-        if (this.cursorVisualLine >= this.visualLineCount - 1) {
+    /**
+     * Move down by `count` visual lines (default 1), aligning by visual column.
+     * Overshooting the bottom clamps to the last visual line.
+     */
+    moveDown(count = 1) {
+        const current = this.cursorVisualLine;
+        const last = this.visualLineCount - 1;
+        if (current >= last) {
             return;
         }
-        const next = this.visualLineAt(this.cursorVisualLine + 1);
+        const step = Math.max(1, Math.round(count));
+        const next = this.visualLineAt(Math.min(last, current + step));
         if (!next) {
             return;
         }

package/dist/core/document/history.d.ts

@@ -0,0 +1,74 @@
+import type { Document } from "./document.js";
+import type { EditOperation } from "./operations.js";
+import type { Position } from "./position.js";
+/** One undoable edit: the operation plus the cursor before and after it ran. */
+export type HistoryEntry = {
+    op: EditOperation;
+    /** Cursor before `apply`; undo leaves the cursor here. */
+    cursorBefore: Position;
+    /** Cursor after `apply`; redo leaves the cursor here, and undo starts here. */
+    cursorAfter: Position;
+    /** When the edit ran, used to group consecutive edits into one undo step. */
+    time: number;
+};
+/**
+ * Linear undo/redo stack over {@link EditOperation}s.
+ *
+ * Stores each operation together with the cursor positions around it. The
+ * cursor is part of the record — not reconstructed from the operation —
+ * because editing and cursor movement are independent: the user may move the
+ * cursor (an action that is not itself undoable) before pressing undo, so the
+ * position `invert` expects cannot be assumed to still hold.
+ *
+ * A burst of mergeable edits (see {@link EditOperation.merge}) that land next
+ * to each other within the merge window collapses into one entry, so typing a
+ * word undoes as a word rather than a character. Any other edit, a cursor
+ * move, or a pause longer than the window starts a new entry. The window is a
+ * user setting (see `setMergeWindow`); `0` disables merging.
+ */
+export declare class History {
+    private readonly _undo;
+    private readonly _redo;
+    private readonly _limit;
+    private readonly _now;
+    private _mergeWindow;
+    constructor(limit?: number, now?: () => number);
+    /**
+     * Set the coalescing window in ms. Edits closer together than this share an
+     * undo step; `0` disables merging, so every edit stands alone.
+     */
+    setMergeWindow(ms: number): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /**
+     * Apply `op` and record it. Capturing the cursor here (rather than in the
+     * caller) keeps the entry and the operation's effects in sync by
+     * construction. A new edit discards the redo branch, since the document
+     * has diverged from the state those entries would replay onto.
+     *
+     * A no-op edit (e.g. backspace at the document start) is not recorded: its
+     * inverse would do nothing, so an entry for it would only make the user
+     * press undo twice to skip past it and would evict real history at the
+     * limit. Leaving the redo branch intact is correct too — the document did
+     * not diverge from the state those entries replay onto.
+     */
+    run(op: EditOperation, doc: Document): void;
+    /**
+     * Fold `entry` into `top` when it continues the same edit: the newer
+     * cursor picks up where the older left off, the operation agrees to merge,
+     * and the gap is within the time window. Returns false when `entry` must
+     * start its own step. Mutating `top.op` only happens on success, since
+     * {@link EditOperation.merge} is a no-op when it returns false.
+     */
+    private _merge;
+    /** Undo the last edit; returns false when the undo stack is empty. */
+    undo(doc: Document): boolean;
+    /** Redo the last undone edit; returns false when the redo stack is empty. */
+    redo(doc: Document): boolean;
+    /**
+     * Drop all history. Required after replacing the document wholesale
+     * (`Document.setText`), since the recorded positions then refer to a
+     * different text.
+     */
+    clear(): void;
+}

package/dist/core/document/history.js

@@ -0,0 +1,136 @@
+import { MERGE_WINDOW_DEFAULT } from "../settings/schema.js";
+/**
+ * Linear undo/redo stack over {@link EditOperation}s.
+ *
+ * Stores each operation together with the cursor positions around it. The
+ * cursor is part of the record — not reconstructed from the operation —
+ * because editing and cursor movement are independent: the user may move the
+ * cursor (an action that is not itself undoable) before pressing undo, so the
+ * position `invert` expects cannot be assumed to still hold.
+ *
+ * A burst of mergeable edits (see {@link EditOperation.merge}) that land next
+ * to each other within the merge window collapses into one entry, so typing a
+ * word undoes as a word rather than a character. Any other edit, a cursor
+ * move, or a pause longer than the window starts a new entry. The window is a
+ * user setting (see `setMergeWindow`); `0` disables merging.
+ */
+export class History {
+    _undo = [];
+    _redo = [];
+    _limit;
+    _now;
+    _mergeWindow = MERGE_WINDOW_DEFAULT;
+    constructor(limit = 200, now = Date.now) {
+        this._limit = limit;
+        this._now = now;
+    }
+    /**
+     * Set the coalescing window in ms. Edits closer together than this share an
+     * undo step; `0` disables merging, so every edit stands alone.
+     */
+    setMergeWindow(ms) {
+        this._mergeWindow = ms;
+    }
+    canUndo() {
+        return this._undo.length > 0;
+    }
+    canRedo() {
+        return this._redo.length > 0;
+    }
+    /**
+     * Apply `op` and record it. Capturing the cursor here (rather than in the
+     * caller) keeps the entry and the operation's effects in sync by
+     * construction. A new edit discards the redo branch, since the document
+     * has diverged from the state those entries would replay onto.
+     *
+     * A no-op edit (e.g. backspace at the document start) is not recorded: its
+     * inverse would do nothing, so an entry for it would only make the user
+     * press undo twice to skip past it and would evict real history at the
+     * limit. Leaving the redo branch intact is correct too — the document did
+     * not diverge from the state those entries replay onto.
+     */
+    run(op, doc) {
+        const before = doc.cursor;
+        if (!op.apply(doc)) {
+            return;
+        }
+        const after = doc.cursor;
+        const entry = {
+            op,
+            cursorBefore: { line: before.line, logical: before.logical },
+            cursorAfter: { line: after.line, logical: after.logical },
+            time: this._now(),
+        };
+        const top = this._undo[this._undo.length - 1];
+        if (!(top && this._merge(top, entry))) {
+            this._undo.push(entry);
+            if (this._undo.length > this._limit) {
+                this._undo.shift();
+            }
+        }
+        this._redo.length = 0;
+    }
+    /**
+     * Fold `entry` into `top` when it continues the same edit: the newer
+     * cursor picks up where the older left off, the operation agrees to merge,
+     * and the gap is within the time window. Returns false when `entry` must
+     * start its own step. Mutating `top.op` only happens on success, since
+     * {@link EditOperation.merge} is a no-op when it returns false.
+     */
+    _merge(top, entry) {
+        if (entry.time - top.time >= this._mergeWindow) {
+            return false;
+        }
+        if (entry.cursorBefore.line !== top.cursorAfter.line ||
+            entry.cursorBefore.logical !== top.cursorAfter.logical) {
+            return false;
+        }
+        if (!top.op.merge?.(entry.op)) {
+            return false;
+        }
+        // The merged operation now spans both edits: its end cursor moves to
+        // the newer entry's, and the timestamp advances so a pause after this
+        // edit still ends the group.
+        top.cursorAfter = entry.cursorAfter;
+        top.time = entry.time;
+        return true;
+    }
+    /** Undo the last edit; returns false when the undo stack is empty. */
+    undo(doc) {
+        const entry = this._undo.pop();
+        if (!entry) {
+            return false;
+        }
+        // invert() assumes the cursor sits where apply() left it — restore
+        // cursorAfter first, or a since-moved cursor makes it delete the wrong
+        // span. cursorBefore after the invert is the position the user expects.
+        doc.setCursor(entry.cursorAfter.line, entry.cursorAfter.logical);
+        entry.op.invert(doc);
+        doc.setCursor(entry.cursorBefore.line, entry.cursorBefore.logical);
+        this._redo.push(entry);
+        return true;
+    }
+    /** Redo the last undone edit; returns false when the redo stack is empty. */
+    redo(doc) {
+        const entry = this._redo.pop();
+        if (!entry) {
+            return false;
+        }
+        // apply() runs against the pre-edit document, so restore cursorBefore
+        // first; apply() then reproduces cursorAfter on its own.
+        doc.setCursor(entry.cursorBefore.line, entry.cursorBefore.logical);
+        entry.op.apply(doc);
+        doc.setCursor(entry.cursorAfter.line, entry.cursorAfter.logical);
+        this._undo.push(entry);
+        return true;
+    }
+    /**
+     * Drop all history. Required after replacing the document wholesale
+     * (`Document.setText`), since the recorded positions then refer to a
+     * different text.
+     */
+    clear() {
+        this._undo.length = 0;
+        this._redo.length = 0;
+    }
+}

package/dist/core/document/operations.d.ts

@@ -9,33 +9,47 @@ import type { Document } from "./document.js";
  * cursor before inverting.
  */
 export type EditOperation = {
-    apply(doc: Document): void;
+    /**
+     * Apply the edit in place. Returns false when the edit was a no-op (the
+     * document is unchanged), so history can skip recording a dead step.
+     */
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
+    /**
+     * Absorb a following edit into this one so the two share a single undo
+     * step (e.g. two adjacent insertions form one typed run). Returns true
+     * after folding `next` in, or false when the edit kind differs and they
+     * must stay separate. History calls this only for edits whose cursors are
+     * adjacent and within its merge window, so contiguity can be assumed.
+     */
+    merge?(next: EditOperation): boolean;
 };
 /** Insert a string at the cursor; invert deletes exactly the inserted text. */
 export declare class InsertTextOp implements EditOperation {
-    private readonly text;
+    private text;
     constructor(text: string);
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
+    /** Merge only with another insertion; anything else ends the typed run. */
+    merge(next: EditOperation): boolean;
 }
 /** Backspace: delete the char before the cursor, or join with the previous line at column 0. */
 export declare class DeleteBeforeOp implements EditOperation {
     private _deletedChar;
     private _joined;
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Delete key: remove the char after the cursor, or join with the next line at end of line. */
 export declare class DeleteAfterOp implements EditOperation {
     private _deletedChar;
     private _joined;
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Enter: split the current line at the cursor; invert rejoins the two lines. */
 export declare class SplitLineOp implements EditOperation {
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /**
@@ -45,17 +59,18 @@ export declare class SplitLineOp implements EditOperation {
  */
 export declare class JoinLineOp implements EditOperation {
     private _joinAt;
-    apply(doc: Document): void;
+    private _joined;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Indent the current line by `indentWidth` spaces, moving the cursor along. */
 export declare class IndentOp implements EditOperation {
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Outdent up to `indentWidth` leading spaces; invert re-adds exactly what was removed. */
 export declare class OutdentOp implements EditOperation {
     private _removed;
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }

package/dist/core/document/operations.js

@@ -9,6 +9,7 @@ export class InsertTextOp {
         const cur = doc.getLine(line);
         doc.setLine(line, cur.slice(0, logical) + this.text + cur.slice(logical));
         doc.setCursor(line, logical + this.text.length);
+        return true;
     }
     invert(doc) {
         const { line, logical } = doc.cursor;
@@ -17,6 +18,14 @@ export class InsertTextOp {
         doc.setLine(line, cur.slice(0, start) + cur.slice(logical));
         doc.setCursor(line, start);
     }
+    /** Merge only with another insertion; anything else ends the typed run. */
+    merge(next) {
+        if (!(next instanceof InsertTextOp)) {
+            return false;
+        }
+        this.text += next.text;
+        return true;
+    }
 }
 /** Backspace: delete the char before the cursor, or join with the previous line at column 0. */
 export class DeleteBeforeOp {
@@ -35,6 +44,7 @@ export class DeleteBeforeOp {
             this._joined = false;
             doc.setLine(line, cur.slice(0, logical - units) + cur.slice(logical));
             doc.setCursor(line, logical - units);
+            return true;
         }
         else if (line > 0) {
             const prev = doc.getLine(line - 1);
@@ -43,7 +53,9 @@ export class DeleteBeforeOp {
             doc.removeLineAt(line);
             doc.setCursor(line - 1, prev.length);
             this._joined = true;
+            return true;
         }
+        return false;
     }
     invert(doc) {
         if (!this._joined) {
@@ -78,13 +90,16 @@ export class DeleteAfterOp {
             this._deletedChar = cur.slice(logical, logical + units);
             this._joined = false;
             doc.setLine(line, cur.slice(0, logical) + cur.slice(logical + units));
+            return true;
         }
         else if (line < doc.lineCount - 1) {
             const next = doc.getLine(line + 1);
             doc.setLine(line, cur + next);
             doc.removeLineAt(line + 1);
             this._joined = true;
+            return true;
         }
+        return false;
     }
     invert(doc) {
         if (!this._joined) {
@@ -108,6 +123,7 @@ export class SplitLineOp {
         doc.setLine(line, cur.slice(0, logical));
         doc.insertLineAt(line + 1, cur.slice(logical));
         doc.setCursor(line + 1, 0);
+        return true;
     }
     invert(doc) {
         // Cursor is on the newly created line; the split point is its own start.
@@ -126,18 +142,27 @@ export class SplitLineOp {
  */
 export class JoinLineOp {
     _joinAt = 0;
+    _joined = false;
     apply(doc) {
+        this._joined = false;
         const { line } = doc.cursor;
         if (line >= doc.lineCount - 1) {
-            return;
+            return false;
         }
         const cur = doc.getLine(line);
         const next = doc.getLine(line + 1);
         this._joinAt = cur.length;
+        this._joined = true;
         doc.setLine(line, cur + next);
         doc.removeLineAt(line + 1);
+        return true;
     }
     invert(doc) {
+        // apply() no-ops on the last line; inverting that split would corrupt
+        // the document, so mirror the no-op.
+        if (!this._joined) {
+            return;
+        }
         const { line } = doc.cursor;
         const cur = doc.getLine(line);
         doc.setLine(line, cur.slice(0, this._joinAt));
@@ -152,6 +177,7 @@ export class IndentOp {
         const spaces = " ".repeat(doc.indentWidth);
         doc.setLine(line, spaces + cur);
         doc.setCursor(line, logical + doc.indentWidth);
+        return true;
     }
     invert(doc) {
         const { line, logical } = doc.cursor;
@@ -172,7 +198,9 @@ export class OutdentOp {
         if (remove > 0) {
             doc.setLine(line, cur.slice(remove));
             doc.setCursor(line, Math.max(0, logical - remove));
+            return true;
         }
+        return false;
     }
     invert(doc) {
         if (this._removed === 0) {

package/dist/core/editor-controller.d.ts

@@ -1,24 +1,36 @@
 import { Document } from "./document/document.js";
+import { History } from "./document/history.js";
+import { type EditOperation } from "./document/operations.js";
 export type EditorOptions = {
     indentWidth?: number;
 };
 export type EditorCommandArgs = Record<string, unknown> | undefined;
-export type EditorCommandHandler = (doc: Document, args: EditorCommandArgs) => void;
+/**
+ * A command handler. Returning an {@link EditOperation} makes the command
+ * undoable — `execute` routes the operation through the {@link History},
+ * which applies it and records the cursor positions around it. Returning
+ * nothing marks a command that mutates the document directly or only moves
+ * the cursor; neither is recorded.
+ */
+export type EditorCommandHandler = (doc: Document, args: EditorCommandArgs) => EditOperation | void;
 type ChangeListener = () => void;
 /**
  * Coordinator between the pure core and the keymap/render layers.
  *
  * Owns the document, a command registry (so P2 vim mode only swaps key
- * bindings, never touching the core), and the change-notification channel
- * the view subscribes to. Editing commands run operations that carry their
- * own `invert`; the history stack (P1) will collect them.
+ * bindings, never touching the core), the change-notification channel the
+ * view subscribes to, and the undo/redo {@link History}. Editing commands
+ * return an atomic operation carrying its own `invert`, which `execute`
+ * routes through the history; movement commands return nothing.
  */
 export declare class EditorController {
     private readonly _document;
     private readonly _commands;
     private readonly _listeners;
+    private readonly _history;
     constructor(text: string, options?: EditorOptions);
     get document(): Document;
+    get history(): History;
     onChange(listener: ChangeListener): () => void;
     defineCommand(id: string, handler: EditorCommandHandler): this;
     execute(id: string, args?: EditorCommandArgs): void;

package/dist/core/editor-controller.js

@@ -1,17 +1,20 @@
 import { Document } from "./document/document.js";
+import { History } from "./document/history.js";
 import { DeleteAfterOp, DeleteBeforeOp, IndentOp, InsertTextOp, JoinLineOp, OutdentOp, SplitLineOp, } from "./document/operations.js";
 /**
  * Coordinator between the pure core and the keymap/render layers.
  *
  * Owns the document, a command registry (so P2 vim mode only swaps key
- * bindings, never touching the core), and the change-notification channel
- * the view subscribes to. Editing commands run operations that carry their
- * own `invert`; the history stack (P1) will collect them.
+ * bindings, never touching the core), the change-notification channel the
+ * view subscribes to, and the undo/redo {@link History}. Editing commands
+ * return an atomic operation carrying its own `invert`, which `execute`
+ * routes through the history; movement commands return nothing.
  */
 export class EditorController {
     _document;
     _commands = new Map();
     _listeners = new Set();
+    _history = new History();
     constructor(text, options = {}) {
         this._document = new Document(text, { indentWidth: options.indentWidth });
         this._registerBuiltins();
@@ -19,6 +22,9 @@ export class EditorController {
     get document() {
         return this._document;
     }
+    get history() {
+        return this._history;
+    }
     onChange(listener) {
         this._listeners.add(listener);
         return () => {
@@ -34,38 +40,44 @@ export class EditorController {
         if (!handler) {
             throw new Error(`[ink-cartridge] Unknown editor command: ${id}`);
         }
-        handler(this._document, args);
+        const op = handler(this._document, args);
+        if (op) {
+            this._history.run(op, this._document);
+        }
         this._listeners.forEach((fn) => fn());
     }
     _registerBuiltins() {
-        this.defineCommand("editor.insertText", (doc, args) => {
+        // Editing commands return their operation instead of applying it:
+        // `execute` hands it to the history, which applies it and records the
+        // cursor positions around it (see History.run).
+        this.defineCommand("editor.insertText", (_doc, args) => {
             const text = typeof args?.text === "string" ? args.text : "";
-            if (text) {
-                new InsertTextOp(text).apply(doc);
-            }
-        });
-        this.defineCommand("editor.deleteBefore", (doc) => {
-            new DeleteBeforeOp().apply(doc);
-        });
-        this.defineCommand("editor.deleteAfter", (doc) => {
-            new DeleteAfterOp().apply(doc);
+            return text ? new InsertTextOp(text) : undefined;
         });
-        this.defineCommand("editor.splitLine", (doc) => {
-            new SplitLineOp().apply(doc);
+        this.defineCommand("editor.deleteBefore", () => new DeleteBeforeOp());
+        this.defineCommand("editor.deleteAfter", () => new DeleteAfterOp());
+        this.defineCommand("editor.splitLine", () => new SplitLineOp());
+        this.defineCommand("editor.joinLine", () => new JoinLineOp());
+        this.defineCommand("editor.indent", () => new IndentOp());
+        this.defineCommand("editor.outdent", () => new OutdentOp());
+        // Undo/redo drive the history directly; they are not edits themselves,
+        // so they return nothing and are never recorded.
+        this.defineCommand("history.undo", () => {
+            this._history.undo(this._document);
         });
-        this.defineCommand("editor.joinLine", (doc) => {
-            new JoinLineOp().apply(doc);
-        });
-        this.defineCommand("editor.indent", (doc) => {
-            new IndentOp().apply(doc);
-        });
-        this.defineCommand("editor.outdent", (doc) => {
-            new OutdentOp().apply(doc);
+        this.defineCommand("history.redo", () => {
+            this._history.redo(this._document);
         });
         this.defineCommand("cursor.moveLeft", (doc) => doc.moveLeft());
         this.defineCommand("cursor.moveRight", (doc) => doc.moveRight());
-        this.defineCommand("cursor.moveUp", (doc) => doc.moveUp());
-        this.defineCommand("cursor.moveDown", (doc) => doc.moveDown());
+        this.defineCommand("cursor.moveUp", (doc, args) => {
+            const count = typeof args?.count === "number" ? args.count : 1;
+            doc.moveUp(count);
+        });
+        this.defineCommand("cursor.moveDown", (doc, args) => {
+            const count = typeof args?.count === "number" ? args.count : 1;
+            doc.moveDown(count);
+        });
         this.defineCommand("cursor.lineStart", (doc) => doc.moveToLineStart());
         this.defineCommand("cursor.lineEnd", (doc) => doc.moveToLineEnd());
         this.defineCommand("cursor.wordForward", (doc) => doc.moveWordForward());