@vemjs/core 0.1.0

package/dist/editor.js

@@ -0,0 +1,818 @@
+import { VimBuffer, UndoManager } from './buffer';
+import { getWordForward, getWordBackward, getWordEndForward, getTextObjectRange } from './motions';
+import { parseKeys } from './parser';
+export class VemEditorState {
+    mode = 'NORMAL';
+    cursor = { line: 0, character: 0 };
+    desiredCol = 0;
+    buffer;
+    undoManager;
+    register = null;
+    pendingKeys = [];
+    visualSelection = null;
+    isInsertMutated = false;
+    changeCallbacks = [];
+    commandText = '';
+    saveCallbacks = [];
+    quitCallbacks = [];
+    splitCallbacks = [];
+    customKeybindings = new Map();
+    didOpenBufferCallbacks = [];
+    changeBufferCallbacks = [];
+    changeModeCallbacks = [];
+    pluginCommandCallbacks = [];
+    diagnostics = [];
+    publishDiagnosticsCallbacks = [];
+    constructor(initialText) {
+        this.buffer = new VimBuffer(initialText);
+        this.undoManager = new UndoManager();
+        this.buffer.onChange(() => {
+            this.triggerChangeBuffer();
+        });
+        setTimeout(() => {
+            this.triggerDidOpenBuffer();
+        }, 0);
+    }
+    // --- Callbacks & Events ---
+    onChange(callback) {
+        this.changeCallbacks.push(callback);
+    }
+    triggerChange() {
+        for (const cb of this.changeCallbacks) {
+            cb();
+        }
+    }
+    onSave(callback) {
+        this.saveCallbacks.push(callback);
+    }
+    onQuit(callback) {
+        this.quitCallbacks.push(callback);
+    }
+    onSplit(callback) {
+        this.splitCallbacks.push(callback);
+    }
+    triggerSave() {
+        for (const cb of this.saveCallbacks) {
+            cb();
+        }
+    }
+    triggerQuit() {
+        for (const cb of this.quitCallbacks) {
+            cb();
+        }
+    }
+    triggerSplit(direction) {
+        for (const cb of this.splitCallbacks) {
+            cb(direction);
+        }
+    }
+    registerKeybinding(mode, keys, commandName) {
+        if (!this.customKeybindings.has(mode)) {
+            this.customKeybindings.set(mode, new Map());
+        }
+        this.customKeybindings.get(mode).set(keys, commandName);
+    }
+    onDidOpenBuffer(callback) {
+        this.didOpenBufferCallbacks.push(callback);
+    }
+    onDidChangeBuffer(callback) {
+        this.changeBufferCallbacks.push(callback);
+    }
+    onDidChangeMode(callback) {
+        this.changeModeCallbacks.push(callback);
+    }
+    onExecutePluginCommand(callback) {
+        this.pluginCommandCallbacks.push(callback);
+    }
+    onPublishDiagnostics(callback) {
+        this.publishDiagnosticsCallbacks.push(callback);
+    }
+    setDiagnostics(diagnostics) {
+        this.diagnostics = diagnostics;
+        for (const cb of this.publishDiagnosticsCallbacks) {
+            cb(this.diagnostics);
+        }
+        // Trigger a render-change so renderers can repaint highlight overlays
+        for (const cb of this.changeCallbacks) {
+            cb();
+        }
+    }
+    getDiagnostics() {
+        return this.diagnostics;
+    }
+    triggerDidOpenBuffer() {
+        for (const cb of this.didOpenBufferCallbacks) {
+            cb();
+        }
+    }
+    triggerChangeBuffer() {
+        for (const cb of this.changeBufferCallbacks) {
+            cb();
+        }
+    }
+    triggerChangeMode(mode) {
+        for (const cb of this.changeModeCallbacks) {
+            cb(mode);
+        }
+    }
+    executePluginCommand(commandName) {
+        for (const cb of this.pluginCommandCallbacks) {
+            cb(commandName);
+        }
+    }
+    // --- Getters & Setters ---
+    getMode() {
+        return this.mode;
+    }
+    getText() {
+        return this.buffer.getText();
+    }
+    setMode(mode) {
+        if (this.mode === mode)
+            return;
+        // Handle exiting insert mode
+        if (this.mode === 'INSERT') {
+            this.isInsertMutated = false;
+        }
+        this.mode = mode;
+        // Initialize visual selection if entering visual mode
+        if (mode === 'VISUAL') {
+            this.visualSelection = {
+                type: 'char',
+                anchor: { ...this.cursor },
+                active: { ...this.cursor },
+            };
+        }
+        else {
+            this.visualSelection = null;
+        }
+        this.triggerChangeMode(mode);
+        this.triggerChange();
+    }
+    getCursor() {
+        return { ...this.cursor };
+    }
+    getBuffer() {
+        return this.buffer;
+    }
+    getPendingKeys() {
+        return [...this.pendingKeys];
+    }
+    getVisualSelection() {
+        return this.visualSelection;
+    }
+    getRegister() {
+        return this.register;
+    }
+    getCommandText() {
+        return this.commandText;
+    }
+    // --- Key Input Entry Point ---
+    handleKey(key) {
+        if (this.mode === 'COMMAND') {
+            if (key === 'Escape') {
+                this.setMode('NORMAL');
+                this.commandText = '';
+                this.triggerChange();
+                return;
+            }
+            if (key === 'Enter') {
+                this.executeCommandLineText(this.commandText);
+                this.setMode('NORMAL');
+                this.commandText = '';
+                this.triggerChange();
+                return;
+            }
+            if (key === 'Backspace') {
+                this.commandText = this.commandText.substring(0, this.commandText.length - 1);
+                this.triggerChange();
+                return;
+            }
+            if (key.length === 1) {
+                this.commandText += key;
+                this.triggerChange();
+                return;
+            }
+            return;
+        }
+        // Check custom keybindings
+        const modeBindings = this.customKeybindings.get(this.mode);
+        if (modeBindings) {
+            const currentSequence = [...this.pendingKeys, key].join('');
+            let hasExactMatch = false;
+            let hasPartialMatch = false;
+            let matchedCommand = '';
+            for (const [keys, cmd] of modeBindings.entries()) {
+                if (keys === currentSequence) {
+                    hasExactMatch = true;
+                    matchedCommand = cmd;
+                }
+                else if (keys.startsWith(currentSequence)) {
+                    hasPartialMatch = true;
+                }
+            }
+            if (hasExactMatch && !hasPartialMatch) {
+                this.pendingKeys = [];
+                this.executePluginCommand(matchedCommand);
+                this.triggerChange();
+                return;
+            }
+            if (hasPartialMatch) {
+                this.pendingKeys.push(key);
+                this.triggerChange();
+                return;
+            }
+            if (this.pendingKeys.length > 0) {
+                const keysToReplay = [...this.pendingKeys, key];
+                this.pendingKeys = [];
+                for (const k of keysToReplay) {
+                    this.handleKeyStandard(k);
+                }
+                return;
+            }
+        }
+        this.handleKeyStandard(key);
+    }
+    handleKeyStandard(key) {
+        if (this.mode === 'INSERT') {
+            if (key === 'Escape') {
+                this.setMode('NORMAL');
+                // Move cursor back one character in Normal mode
+                this.cursor.character = Math.max(0, this.cursor.character - 1);
+                this.desiredCol = this.cursor.character;
+                this.triggerChange();
+                return;
+            }
+            if (key === 'Backspace') {
+                this.handleBackspaceInInsert();
+                this.triggerChange();
+                return;
+            }
+            if (key === 'Enter') {
+                this.handleEnterInInsert();
+                this.triggerChange();
+                return;
+            }
+            if (key.length === 1) {
+                this.handleCharInputInInsert(key);
+                this.triggerChange();
+                return;
+            }
+            return;
+        }
+        // Normal or Visual Mode
+        if (key === 'Escape') {
+            this.pendingKeys = [];
+            if (this.mode === 'VISUAL') {
+                this.setMode('NORMAL');
+            }
+            this.triggerChange();
+            return;
+        }
+        this.pendingKeys.push(key);
+        const parsed = parseKeys(this.pendingKeys, this.mode);
+        if (!parsed.isValid) {
+            this.pendingKeys = [];
+            return;
+        }
+        if (parsed.isComplete) {
+            this.pendingKeys = [];
+            this.executeCommand(parsed);
+            this.triggerChange();
+        }
+    }
+    // --- Insertion Helpers ---
+    handleCharInputInInsert(char) {
+        if (!this.isInsertMutated) {
+            this.saveStateForUndo();
+            this.isInsertMutated = true;
+        }
+        const line = this.buffer.getLine(this.cursor.line);
+        const before = line.substring(0, this.cursor.character);
+        const after = line.substring(this.cursor.character);
+        this.buffer.setLine(this.cursor.line, before + char + after);
+        this.cursor.character++;
+        this.desiredCol = this.cursor.character;
+    }
+    handleBackspaceInInsert() {
+        if (!this.isInsertMutated) {
+            this.saveStateForUndo();
+            this.isInsertMutated = true;
+        }
+        if (this.cursor.character > 0) {
+            const line = this.buffer.getLine(this.cursor.line);
+            const before = line.substring(0, this.cursor.character - 1);
+            const after = line.substring(this.cursor.character);
+            this.buffer.setLine(this.cursor.line, before + after);
+            this.cursor.character--;
+            this.desiredCol = this.cursor.character;
+        }
+        else if (this.cursor.line > 0) {
+            const prevLine = this.buffer.getLine(this.cursor.line - 1);
+            const currLine = this.buffer.getLine(this.cursor.line);
+            this.buffer.setLine(this.cursor.line - 1, prevLine + currLine);
+            this.buffer.deleteLines(this.cursor.line, this.cursor.line);
+            this.cursor.line--;
+            this.cursor.character = prevLine.length;
+            this.desiredCol = this.cursor.character;
+        }
+    }
+    handleEnterInInsert() {
+        if (!this.isInsertMutated) {
+            this.saveStateForUndo();
+            this.isInsertMutated = true;
+        }
+        const line = this.buffer.getLine(this.cursor.line);
+        const before = line.substring(0, this.cursor.character);
+        const after = line.substring(this.cursor.character);
+        this.buffer.setLine(this.cursor.line, before);
+        this.buffer.insertLine(this.cursor.line + 1, after);
+        this.cursor.line++;
+        this.cursor.character = 0;
+        this.desiredCol = 0;
+    }
+    // --- Command Execution ---
+    executeCommand(cmd) {
+        if (this.mode === 'VISUAL') {
+            this.executeVisualCommand(cmd);
+            return;
+        }
+        // NORMAL mode commands
+        if (cmd.operator) {
+            this.executeOperatorCommand(cmd);
+            return;
+        }
+        if (cmd.motion) {
+            this.moveCursorByMotion(cmd.motion, cmd.count);
+            return;
+        }
+        if (cmd.command) {
+            switch (cmd.command) {
+                case 'i':
+                    this.setMode('INSERT');
+                    break;
+                case 'I':
+                    this.moveToFirstNonWhitespace();
+                    this.setMode('INSERT');
+                    break;
+                case 'a':
+                    this.moveCursorRightForInsert();
+                    this.setMode('INSERT');
+                    break;
+                case 'A':
+                    this.moveToEndOfLine();
+                    this.setMode('INSERT');
+                    break;
+                case 'o':
+                    this.saveStateForUndo();
+                    this.buffer.insertLine(this.cursor.line + 1, '');
+                    this.cursor.line++;
+                    this.cursor.character = 0;
+                    this.desiredCol = 0;
+                    this.setMode('INSERT');
+                    break;
+                case 'O':
+                    this.saveStateForUndo();
+                    this.buffer.insertLine(this.cursor.line, '');
+                    this.cursor.character = 0;
+                    this.desiredCol = 0;
+                    this.setMode('INSERT');
+                    break;
+                case 'x':
+                    this.saveStateForUndo();
+                    this.deleteCharUnderCursor(cmd.count);
+                    break;
+                case 'u':
+                    this.undo();
+                    break;
+                case '<C-r>':
+                    this.redo();
+                    break;
+                case 'v':
+                    this.setMode('VISUAL');
+                    if (this.visualSelection)
+                        this.visualSelection.type = 'char';
+                    break;
+                case 'V':
+                    this.setMode('VISUAL');
+                    if (this.visualSelection)
+                        this.visualSelection.type = 'line';
+                    break;
+                case '<C-v>':
+                    this.setMode('VISUAL');
+                    if (this.visualSelection)
+                        this.visualSelection.type = 'block';
+                    break;
+                case 'p':
+                    this.saveStateForUndo();
+                    this.paste(false);
+                    break;
+                case 'P':
+                    this.saveStateForUndo();
+                    this.paste(true);
+                    break;
+                case ':':
+                    this.setMode('COMMAND');
+                    this.commandText = '';
+                    break;
+            }
+        }
+    }
+    executeCommandLineText(cmd) {
+        if (cmd === 'w') {
+            this.triggerSave();
+        }
+        else if (cmd === 'q') {
+            this.triggerQuit();
+        }
+        else if (cmd === 'vsp') {
+            this.triggerSplit('vertical');
+        }
+        else if (cmd === 'sp') {
+            this.triggerSplit('horizontal');
+        }
+    }
+    executeVisualCommand(cmd) {
+        if (cmd.motion) {
+            this.moveCursorByMotion(cmd.motion, cmd.count);
+            if (this.visualSelection) {
+                this.visualSelection.active = { ...this.cursor };
+            }
+            return;
+        }
+        const op = cmd.command || cmd.operator;
+        if (op === 'd' || op === 'x' || op === 'c' || op === 'y') {
+            this.saveStateForUndo();
+            this.operateOnVisualSelection(op);
+            if (op === 'c') {
+                this.setMode('INSERT');
+            }
+            else {
+                this.setMode('NORMAL');
+            }
+        }
+    }
+    // --- Motions Execution ---
+    moveCursorByMotion(motion, count) {
+        for (let i = 0; i < count; i++) {
+            switch (motion) {
+                case 'h':
+                    this.cursor.character = Math.max(0, this.cursor.character - 1);
+                    this.desiredCol = this.cursor.character;
+                    break;
+                case 'l': {
+                    const lineLen = this.buffer.getLine(this.cursor.line).length;
+                    const maxChar = this.mode === 'INSERT' ? lineLen : Math.max(0, lineLen - 1);
+                    this.cursor.character = Math.min(maxChar, this.cursor.character + 1);
+                    this.desiredCol = this.cursor.character;
+                    break;
+                }
+                case 'j':
+                    if (this.cursor.line < this.buffer.getLineCount() - 1) {
+                        this.cursor.line++;
+                        const lineLen = this.buffer.getLine(this.cursor.line).length;
+                        const maxChar = this.mode === 'INSERT' ? lineLen : Math.max(0, lineLen - 1);
+                        this.cursor.character = Math.min(maxChar, this.desiredCol);
+                    }
+                    break;
+                case 'k':
+                    if (this.cursor.line > 0) {
+                        this.cursor.line--;
+                        const lineLen = this.buffer.getLine(this.cursor.line).length;
+                        const maxChar = this.mode === 'INSERT' ? lineLen : Math.max(0, lineLen - 1);
+                        this.cursor.character = Math.min(maxChar, this.desiredCol);
+                    }
+                    break;
+                case 'w':
+                    this.cursor = getWordForward(this.buffer, this.cursor);
+                    this.desiredCol = this.cursor.character;
+                    break;
+                case 'b':
+                    this.cursor = getWordBackward(this.buffer, this.cursor);
+                    this.desiredCol = this.cursor.character;
+                    break;
+                case 'e':
+                    this.cursor = getWordEndForward(this.buffer, this.cursor);
+                    this.desiredCol = this.cursor.character;
+                    break;
+                case '0':
+                    this.cursor.character = 0;
+                    this.desiredCol = 0;
+                    break;
+                case '$': {
+                    const lineLen = this.buffer.getLine(this.cursor.line).length;
+                    this.cursor.character = Math.max(0, lineLen - 1);
+                    this.desiredCol = Infinity;
+                    break;
+                }
+                case 'gg':
+                    this.cursor.line = 0;
+                    this.cursor.character = 0;
+                    this.desiredCol = 0;
+                    break;
+                case 'G':
+                    this.cursor.line = this.buffer.getLineCount() - 1;
+                    this.cursor.character = 0;
+                    this.desiredCol = 0;
+                    break;
+            }
+        }
+    }
+    // --- Operator Command Execution ---
+    executeOperatorCommand(cmd) {
+        const op = cmd.operator;
+        const count = cmd.count;
+        // Double operator e.g. dd, cc, yy
+        if (cmd.command === op + op) {
+            this.saveStateForUndo();
+            const startLine = this.cursor.line;
+            const endLine = Math.min(this.buffer.getLineCount() - 1, this.cursor.line + count - 1);
+            // Extract text for yank
+            const yankedLines = [];
+            for (let l = startLine; l <= endLine; l++) {
+                yankedLines.push(this.buffer.getLine(l));
+            }
+            this.register = {
+                text: yankedLines.join('\n') + '\n',
+                type: 'line',
+            };
+            if (op === 'd' || op === 'c') {
+                this.buffer.deleteLines(startLine, endLine);
+                this.cursor.line = Math.min(this.cursor.line, this.buffer.getLineCount() - 1);
+                this.cursor.character = 0;
+                this.desiredCol = 0;
+                if (op === 'c') {
+                    this.buffer.insertLine(this.cursor.line, '');
+                    this.setMode('INSERT');
+                }
+            }
+            return;
+        }
+        // Motions or Text Objects
+        let range = null;
+        let isLineWise = false;
+        if (cmd.textObject) {
+            range = getTextObjectRange(this.buffer, this.cursor, cmd.textObject);
+        }
+        else if (cmd.motion) {
+            const startPos = { ...this.cursor };
+            this.moveCursorByMotion(cmd.motion, count);
+            const endPos = { ...this.cursor };
+            this.cursor = { ...startPos }; // Restore cursor before operation
+            range = { start: startPos, end: endPos };
+            // Line-wise motion check
+            if (cmd.motion === 'j' || cmd.motion === 'k' || cmd.motion === 'gg' || cmd.motion === 'G') {
+                isLineWise = true;
+            }
+        }
+        if (!range)
+            return;
+        this.saveStateForUndo();
+        // Ensure start is before end
+        let s = { ...range.start };
+        let e = { ...range.end };
+        if (s.line > e.line || (s.line === e.line && s.character > e.character)) {
+            const temp = s;
+            s = e;
+            e = temp;
+        }
+        if (isLineWise) {
+            const yankedLines = [];
+            for (let l = s.line; l <= e.line; l++) {
+                yankedLines.push(this.buffer.getLine(l));
+            }
+            this.register = {
+                text: yankedLines.join('\n') + '\n',
+                type: 'line',
+            };
+            if (op === 'd' || op === 'c') {
+                this.buffer.deleteLines(s.line, e.line);
+                this.cursor.line = Math.min(s.line, this.buffer.getLineCount() - 1);
+                this.cursor.character = 0;
+                this.desiredCol = 0;
+                if (op === 'c') {
+                    this.buffer.insertLine(this.cursor.line, '');
+                    this.setMode('INSERT');
+                }
+            }
+        }
+        else {
+            // Character-wise operation
+            // Inclusive vs Exclusive: motions like $ or text objects are inclusive. Others are exclusive.
+            // E.g. 'dw' deletes from start to start of next word (exclusive).
+            // 'd$' deletes to end of line (inclusive).
+            let isInclusive = cmd.textObject !== undefined || cmd.motion === '$';
+            const startLineText = this.buffer.getLine(s.line);
+            const endLineText = this.buffer.getLine(e.line);
+            let yankText = '';
+            if (s.line === e.line) {
+                yankText = startLineText.substring(s.character, e.character + (isInclusive ? 1 : 0));
+            }
+            else {
+                yankText = startLineText.substring(s.character) + '\n';
+                for (let l = s.line + 1; l < e.line; l++) {
+                    yankText += this.buffer.getLine(l) + '\n';
+                }
+                yankText += endLineText.substring(0, e.character + (isInclusive ? 1 : 0));
+            }
+            this.register = {
+                text: yankText,
+                type: 'char',
+            };
+            if (op === 'd' || op === 'c') {
+                const deleteEnd = { ...e };
+                if (isInclusive) {
+                    deleteEnd.character++;
+                }
+                this.buffer.deleteRange(s, deleteEnd);
+                this.cursor = { ...s };
+                this.desiredCol = this.cursor.character;
+                if (op === 'c') {
+                    this.setMode('INSERT');
+                }
+            }
+        }
+    }
+    // --- Visual Mode Operations ---
+    operateOnVisualSelection(op) {
+        if (!this.visualSelection)
+            return;
+        const { type, anchor, active } = this.visualSelection;
+        let s = { ...anchor };
+        let e = { ...active };
+        // Standard ordering
+        if (s.line > e.line || (s.line === e.line && s.character > e.character)) {
+            const temp = s;
+            s = e;
+            e = temp;
+        }
+        if (type === 'line') {
+            const startLine = Math.min(s.line, e.line);
+            const endLine = Math.max(s.line, e.line);
+            const yankedLines = [];
+            for (let l = startLine; l <= endLine; l++) {
+                yankedLines.push(this.buffer.getLine(l));
+            }
+            this.register = {
+                text: yankedLines.join('\n') + '\n',
+                type: 'line',
+            };
+            if (op === 'd' || op === 'c') {
+                this.buffer.deleteLines(startLine, endLine);
+                this.cursor.line = Math.min(startLine, this.buffer.getLineCount() - 1);
+                this.cursor.character = 0;
+                this.desiredCol = 0;
+                if (op === 'c') {
+                    this.buffer.insertLine(this.cursor.line, '');
+                }
+            }
+        }
+        else if (type === 'char') {
+            const startLineText = this.buffer.getLine(s.line);
+            const endLineText = this.buffer.getLine(e.line);
+            let yankText = '';
+            if (s.line === e.line) {
+                yankText = startLineText.substring(s.character, e.character + 1);
+            }
+            else {
+                yankText = startLineText.substring(s.character) + '\n';
+                for (let l = s.line + 1; l < e.line; l++) {
+                    yankText += this.buffer.getLine(l) + '\n';
+                }
+                yankText += endLineText.substring(0, e.character + 1);
+            }
+            this.register = {
+                text: yankText,
+                type: 'char',
+            };
+            if (op === 'd' || op === 'c') {
+                const deleteEnd = { ...e };
+                deleteEnd.character++; // Inclusive delete
+                this.buffer.deleteRange(s, deleteEnd);
+                this.cursor = { ...s };
+                this.desiredCol = this.cursor.character;
+            }
+        }
+        else if (type === 'block') {
+            // Block-wise selection yanks/deletes character rectangles
+            const minCol = Math.min(anchor.character, active.character);
+            const maxCol = Math.max(anchor.character, active.character);
+            const minLine = Math.min(anchor.line, active.line);
+            const maxLine = Math.max(anchor.line, active.line);
+            const yankedBlocks = [];
+            for (let l = minLine; l <= maxLine; l++) {
+                const lineText = this.buffer.getLine(l);
+                const chunk = lineText.substring(minCol, maxCol + 1);
+                yankedBlocks.push(chunk);
+            }
+            this.register = {
+                text: yankedBlocks.join('\n'),
+                type: 'block',
+            };
+            if (op === 'd' || op === 'c') {
+                for (let l = minLine; l <= maxLine; l++) {
+                    const lineText = this.buffer.getLine(l);
+                    const before = lineText.substring(0, minCol);
+                    const after = lineText.substring(maxCol + 1);
+                    this.buffer.setLine(l, before + after);
+                }
+                this.cursor = { line: minLine, character: minCol };
+                this.desiredCol = minCol;
+            }
+        }
+    }
+    // --- Editing Actions ---
+    moveToFirstNonWhitespace() {
+        const line = this.buffer.getLine(this.cursor.line);
+        const match = /^[ \t]*/.exec(line);
+        const index = match ? match[0].length : 0;
+        this.cursor.character = Math.min(index, Math.max(0, line.length - 1));
+        this.desiredCol = this.cursor.character;
+    }
+    moveCursorRightForInsert() {
+        const lineLen = this.buffer.getLine(this.cursor.line).length;
+        this.cursor.character = Math.min(lineLen, this.cursor.character + 1);
+        this.desiredCol = this.cursor.character;
+    }
+    moveToEndOfLine() {
+        const lineLen = this.buffer.getLine(this.cursor.line).length;
+        this.cursor.character = lineLen;
+        this.desiredCol = Infinity;
+    }
+    deleteCharUnderCursor(count) {
+        const line = this.buffer.getLine(this.cursor.line);
+        if (line.length === 0)
+            return;
+        const deleteCount = Math.min(count, line.length - this.cursor.character);
+        const deletedText = line.substring(this.cursor.character, this.cursor.character + deleteCount);
+        this.register = {
+            text: deletedText,
+            type: 'char',
+        };
+        const before = line.substring(0, this.cursor.character);
+        const after = line.substring(this.cursor.character + deleteCount);
+        this.buffer.setLine(this.cursor.line, before + after);
+        // Adjust cursor if it's past the end of the line in Normal mode
+        const newLineLen = this.buffer.getLine(this.cursor.line).length;
+        this.cursor.character = Math.min(this.cursor.character, Math.max(0, newLineLen - 1));
+        this.desiredCol = this.cursor.character;
+    }
+    paste(before) {
+        if (!this.register)
+            return;
+        const { text, type } = this.register;
+        if (type === 'line') {
+            const targetLine = before ? this.cursor.line : this.cursor.line + 1;
+            const pasteLines = text.split('\n');
+            // If trailing newline, split leaves empty string at end, remove it
+            if (pasteLines[pasteLines.length - 1] === '') {
+                pasteLines.pop();
+            }
+            for (let i = 0; i < pasteLines.length; i++) {
+                this.buffer.insertLine(targetLine + i, pasteLines[i]);
+            }
+            this.cursor.line = targetLine;
+            this.cursor.character = 0;
+            this.desiredCol = 0;
+        }
+        else {
+            // Character-wise or block-wise paste (block-wise simple fallback to char paste)
+            const line = this.buffer.getLine(this.cursor.line);
+            const insertIdx = before
+                ? this.cursor.character
+                : Math.min(line.length, this.cursor.character + 1);
+            const endPos = this.buffer.insertText({ line: this.cursor.line, character: insertIdx }, text);
+            this.cursor = endPos;
+            // In Normal mode, leave cursor on last pasted character
+            this.cursor.character = Math.max(0, this.cursor.character - 1);
+            this.desiredCol = this.cursor.character;
+        }
+    }
+    // --- Undo & Redo ---
+    saveStateForUndo() {
+        this.undoManager.push(this.buffer.getLines());
+    }
+    undo() {
+        const prevState = this.undoManager.undo(this.buffer.getLines());
+        if (prevState) {
+            this.buffer.setLines(prevState);
+            // Clamp cursor
+            this.cursor.line = Math.min(this.cursor.line, this.buffer.getLineCount() - 1);
+            const lineLen = this.buffer.getLine(this.cursor.line).length;
+            this.cursor.character = Math.min(this.cursor.character, Math.max(0, lineLen - 1));
+            this.desiredCol = this.cursor.character;
+        }
+    }
+    redo() {
+        const nextState = this.undoManager.redo(this.buffer.getLines());
+        if (nextState) {
+            this.buffer.setLines(nextState);
+            // Clamp cursor
+            this.cursor.line = Math.min(this.cursor.line, this.buffer.getLineCount() - 1);
+            const lineLen = this.buffer.getLine(this.cursor.line).length;
+            this.cursor.character = Math.min(this.cursor.character, Math.max(0, lineLen - 1));
+            this.desiredCol = this.cursor.character;
+        }
+    }
+}
+//# sourceMappingURL=editor.js.map