vim-sim 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,1380 @@
+declare enum Mode {
+    NORMAL = 0,
+    INSERT = 1,
+    VISUAL = 2,
+    VISUAL_LINE = 3,
+    VISUAL_BLOCK = 4,
+    REPLACE = 5,
+    COMMAND = 6
+}
+
+declare class Buffer {
+    content: string;
+    constructor(content: string);
+    getLineCount(): number;
+}
+
+declare class Cursor {
+    line: number;
+    column: number;
+    constructor(line: number, column: number);
+}
+
+interface Range {
+    start: Cursor;
+    end: Cursor;
+}
+
+declare class VimViewport {
+    topLine: number;
+    height: number;
+    constructor(topLine?: number, height?: number);
+    scrollToLine(line: number): void;
+}
+
+/**
+ * Fold type definitions
+ */
+interface Fold {
+    /** Starting line of the fold (inclusive, 0-indexed) */
+    startLine: number;
+    /** Ending line of the fold (inclusive, 0-indexed) */
+    endLine: number;
+    /** Whether the fold is currently closed */
+    isClosed: boolean;
+    /** Nesting level (0 = top level) */
+    level: number;
+}
+/**
+ * Manager for tracking and manipulating folds in a buffer
+ */
+declare class FoldManager {
+    /** Array of folds, sorted by startLine */
+    private folds;
+    constructor(folds?: Fold[]);
+    /**
+     * Get all folds
+     */
+    getFolds(): Fold[];
+    /**
+     * Create a new fold
+     */
+    createFold(startLine: number, endLine: number): FoldManager;
+    /**
+     * Find fold at a specific line
+     */
+    findFoldAtLine(line: number): Fold | null;
+    /**
+     * Open fold at line
+     */
+    openFold(line: number): FoldManager;
+    /**
+     * Open fold and all nested folds recursively
+     */
+    openFoldRecursive(line: number): FoldManager;
+    /**
+     * Close fold at line
+     */
+    closeFold(line: number): FoldManager;
+    /**
+     * Close fold and all nested folds recursively
+     */
+    closeFoldRecursive(line: number): FoldManager;
+    /**
+     * Toggle fold at line
+     */
+    toggleFold(line: number): FoldManager;
+    /**
+     * Toggle fold and nested folds recursively
+     */
+    toggleFoldRecursive(line: number): FoldManager;
+    /**
+     * Delete fold at line
+     */
+    deleteFold(line: number): FoldManager;
+    /**
+     * Delete fold and all nested folds recursively
+     */
+    deleteFoldRecursive(line: number): FoldManager;
+    /**
+     * Open all folds
+     */
+    openAllFolds(): FoldManager;
+    /**
+     * Close all folds
+     */
+    closeAllFolds(): FoldManager;
+    /**
+     * Open folds up to a certain level
+     */
+    openFoldsToLevel(maxLevel: number): FoldManager;
+    /**
+     * Close folds from a certain level
+     */
+    closeFoldsFromLevel(minLevel: number): FoldManager;
+    /**
+     * Open folds to view a specific line
+     */
+    openToViewLine(line: number): FoldManager;
+    /**
+     * Find next fold starting after a given line
+     */
+    findNextFold(line: number): Fold | null;
+    /**
+     * Find previous fold starting before a given line
+     */
+    findPrevFold(line: number): Fold | null;
+    /**
+     * Check if a line is hidden (inside a closed fold)
+     */
+    isLineHidden(line: number): boolean;
+    /**
+     * Get visible lines (accounting for closed folds)
+     * Returns array of line numbers that should be visible
+     */
+    getVisibleLines(totalLines: number): number[];
+}
+
+/**
+ * Mark type definitions
+ */
+interface Mark {
+    /** The cursor position of the mark */
+    position: Cursor;
+    /** Optional buffer identifier (for global marks) */
+    bufferId?: string;
+}
+/**
+ * Manager for tracking and manipulating marks in a buffer
+ */
+declare class MarkManager {
+    /** Map of mark names to their positions */
+    private marks;
+    constructor(marks?: Map<string, Mark>);
+    /**
+     * Set a mark at a position
+     * @param name - Mark name (a-z for local, A-Z for global)
+     * @param position - Cursor position
+     * @param bufferId - Optional buffer ID for global marks
+     */
+    setMark(name: string, position: Cursor, bufferId?: string): MarkManager;
+    /**
+     * Get a mark by name
+     */
+    getMark(name: string): Mark | undefined;
+    /**
+     * Check if a mark exists
+     */
+    hasMark(name: string): boolean;
+    /**
+     * Delete a mark
+     */
+    deleteMark(name: string): MarkManager;
+    /**
+     * Delete all marks
+     */
+    deleteAllMarks(): MarkManager;
+    /**
+     * Delete all marks in a range
+     */
+    deleteMarksInRange(startLine: number, endLine: number): MarkManager;
+    /**
+     * Get all marks
+     */
+    getAllMarks(): Map<string, Mark>;
+    /**
+     * Get local marks (a-z)
+     */
+    getLocalMarks(): Map<string, Mark>;
+    /**
+     * Get global marks (A-Z)
+     */
+    getGlobalMarks(): Map<string, Mark>;
+    /**
+     * Check if a mark name is valid
+     */
+    private isValidMarkName;
+    /**
+     * Check if a mark is a local mark (a-z)
+     */
+    private isLocalMark;
+    /**
+     * Check if a mark is a global mark (A-Z)
+     */
+    private isGlobalMark;
+    /**
+     * Update mark positions when lines are inserted
+     * Shifts marks after the insertion point
+     */
+    adjustMarksAfterInsert(insertLine: number, numLines: number): MarkManager;
+    /**
+     * Update mark positions when lines are deleted
+     * Removes marks in deleted range and shifts marks after deletion
+     */
+    adjustMarksAfterDelete(startLine: number, endLine: number): MarkManager;
+    /**
+     * Set automatic marks
+     * These are special marks that vim sets automatically
+     */
+    setAutomaticMark(name: string, position: Cursor): MarkManager;
+}
+
+/**
+ * Jump list type definitions
+ */
+interface Jump {
+    /** The cursor position of the jump */
+    position: Cursor;
+    /** Optional buffer identifier */
+    bufferId?: string;
+    /** Timestamp when jump was created */
+    timestamp: number;
+}
+/**
+ * Manager for tracking and navigating the jump list
+ *
+ * The jump list is automatically maintained by Vim to track "jumps" -
+ * movements that cross multiple lines (like G, gg, %, searches, marks)
+ */
+declare class JumpListManager {
+    /** Array of jumps in chronological order */
+    private jumps;
+    /** Current position in the jump list (null if at most recent position) */
+    private currentIndex;
+    /** Maximum number of jumps to keep */
+    private readonly maxJumps;
+    constructor(jumps?: Jump[], currentIndex?: number | null);
+    /**
+     * Add a jump to the list
+     * This removes any "future" jumps if we're in the middle of the list
+     */
+    addJump(position: Cursor, bufferId?: string): JumpListManager;
+    /**
+     * Jump backward in the list (Ctrl-o)
+     * Returns the jump position to go to, or null if can't go back
+     */
+    jumpBackward(): {
+        manager: JumpListManager;
+        position: Cursor | null;
+    };
+    /**
+     * Jump forward in the list (Ctrl-i)
+     * Returns the jump position to go to, or null if can't go forward
+     */
+    jumpForward(): {
+        manager: JumpListManager;
+        position: Cursor | null;
+    };
+    /**
+     * Get the current jump position (if in the middle of the list)
+     */
+    getCurrentJump(): Jump | null;
+    /**
+     * Get all jumps
+     */
+    getAllJumps(): Jump[];
+    /**
+     * Get current index in jump list
+     */
+    getCurrentIndex(): number | null;
+    /**
+     * Check if we can jump backward
+     */
+    canJumpBackward(): boolean;
+    /**
+     * Check if we can jump forward
+     */
+    canJumpForward(): boolean;
+    /**
+     * Update jump positions when lines are inserted
+     */
+    adjustJumpsAfterInsert(insertLine: number, numLines: number): JumpListManager;
+    /**
+     * Update jump positions when lines are deleted
+     */
+    adjustJumpsAfterDelete(startLine: number, endLine: number): JumpListManager;
+    /**
+     * Clear the jump list
+     */
+    clear(): JumpListManager;
+    /**
+     * Check if a cursor movement should be considered a "jump"
+     * (movements that cross multiple lines)
+     */
+    static isJumpMotion(fromLine: number, toLine: number, minLineDiff?: number): boolean;
+}
+
+/**
+ * Represents a file in the simulated file system
+ */
+interface VimFile {
+    path: string;
+    buffer: Buffer;
+    modified: boolean;
+    readonly: boolean;
+}
+/**
+ * Manages the simulated file system with multiple buffers
+ * Immutable operations return new FileSystemManager instances
+ */
+declare class FileSystemManager {
+    private files;
+    private currentFilePath;
+    constructor(files?: Map<string, VimFile>, currentFilePath?: string | null);
+    /**
+     * Create or open a file with the given path
+     */
+    openFile(path: string, content?: string, readonly?: boolean): FileSystemManager;
+    /**
+     * Update the buffer content for the current file
+     */
+    updateCurrentBuffer(buffer: Buffer, modified?: boolean): FileSystemManager;
+    /**
+     * Save the current file (mark as not modified)
+     */
+    saveCurrentFile(): FileSystemManager;
+    /**
+     * Close the current file
+     */
+    closeCurrentFile(): {
+        manager: FileSystemManager;
+        success: boolean;
+        message?: string;
+    };
+    /**
+     * Force close the current file (ignore modifications)
+     */
+    forceCloseCurrentFile(): {
+        manager: FileSystemManager;
+        success: boolean;
+    };
+    /**
+     * Switch to a specific file by path
+     */
+    switchToFile(path: string): FileSystemManager;
+    /**
+     * Get the current file
+     */
+    getCurrentFile(): VimFile | null;
+    /**
+     * Get current file path
+     */
+    getCurrentPath(): string | null;
+    /**
+     * Get all file paths
+     */
+    getAllPaths(): string[];
+    /**
+     * Get number of open files
+     */
+    getFileCount(): number;
+    /**
+     * Check if current file is modified
+     */
+    isCurrentModified(): boolean;
+    /**
+     * Check if current file is readonly
+     */
+    isCurrentReadonly(): boolean;
+    /**
+     * Get next file in the list (for buffer cycling)
+     */
+    getNextFilePath(): string | null;
+    /**
+     * Get previous file in the list (for buffer cycling)
+     */
+    getPreviousFilePath(): string | null;
+}
+
+/**
+ * Represents the type of window split
+ */
+declare enum SplitType {
+    HORIZONTAL = 0,
+    VERTICAL = 1
+}
+/**
+ * Represents a window in the editor
+ */
+interface Window {
+    id: number;
+    bufferId: string | null;
+    cursorLine: number;
+    cursorColumn: number;
+    scrollOffset: number;
+    width: number;
+    height: number;
+}
+/**
+ * Layout node for window tree structure
+ */
+interface WindowLayout {
+    type: 'leaf' | 'split';
+    splitType?: SplitType;
+    window?: Window;
+    children?: [WindowLayout, WindowLayout];
+}
+/**
+ * Manages window splits and navigation
+ * Immutable operations return new WindowManager instances
+ */
+declare class WindowManager {
+    private windows;
+    private layout;
+    private activeWindowId;
+    private nextWindowId;
+    constructor(windows?: Map<number, Window>, layout?: WindowLayout | null, activeWindowId?: number, nextWindowId?: number);
+    /**
+     * Split the active window horizontally (above/below)
+     */
+    splitHorizontal(): WindowManager;
+    /**
+     * Split the active window vertically (left/right)
+     */
+    splitVertical(): WindowManager;
+    /**
+     * Close the active window
+     */
+    closeActiveWindow(): {
+        manager: WindowManager;
+        success: boolean;
+        message?: string;
+    };
+    /**
+     * Close all windows except the active one
+     */
+    closeOtherWindows(): WindowManager;
+    /**
+     * Navigate to the next window
+     */
+    cycleWindow(): WindowManager;
+    /**
+     * Navigate to window in a direction (h/j/k/l)
+     */
+    navigateWindow(direction: 'h' | 'j' | 'k' | 'l'): WindowManager;
+    /**
+     * Update the active window
+     */
+    updateActiveWindow(updates: Partial<Window>): WindowManager;
+    /**
+     * Get the active window
+     */
+    getActiveWindow(): Window | null;
+    /**
+     * Get all windows
+     */
+    getAllWindows(): Window[];
+    /**
+     * Get window count
+     */
+    getWindowCount(): number;
+    /**
+     * Get layout tree
+     */
+    getLayout(): WindowLayout;
+    private replaceWindowInLayout;
+    private removeWindowFromLayout;
+    private updateWindowInLayout;
+}
+
+interface SpellCheckResult {
+    word: string;
+    line: number;
+    column: number;
+    suggestions: string[];
+}
+/**
+ * Manages spell checking functionality using nspell
+ */
+declare class SpellChecker {
+    private spell;
+    private enabled;
+    private goodWords;
+    private badWords;
+    private sessionGoodWords;
+    private sessionBadWords;
+    constructor();
+    private initializeSpellChecker;
+    /**
+     * Enable spell checking
+     */
+    enable(): void;
+    /**
+     * Disable spell checking
+     */
+    disable(): void;
+    /**
+     * Check if spell checking is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Check if a word is spelled correctly
+     */
+    isCorrect(word: string): boolean;
+    /**
+     * Get spelling suggestions for a word
+     */
+    suggest(word: string, maxSuggestions?: number): string[];
+    /**
+     * Add word to personal dictionary (persistent)
+     */
+    addGoodWord(word: string): void;
+    /**
+     * Add word to session word list (temporary)
+     */
+    addSessionGoodWord(word: string): void;
+    /**
+     * Mark word as bad in personal dictionary (persistent)
+     */
+    addBadWord(word: string): void;
+    /**
+     * Mark word as bad in session list (temporary)
+     */
+    addSessionBadWord(word: string): void;
+    /**
+     * Remove word from good word list
+     */
+    removeGoodWord(word: string): void;
+    /**
+     * Remove word from session good word list
+     */
+    removeSessionGoodWord(word: string): void;
+    /**
+     * Remove word from bad word list
+     */
+    removeBadWord(word: string): void;
+    /**
+     * Remove word from session bad word list
+     */
+    removeSessionBadWord(word: string): void;
+    /**
+     * Check all words in buffer content
+     */
+    checkBuffer(content: string): SpellCheckResult[];
+    /**
+     * Extract words from a line with their positions
+     */
+    private extractWords;
+    /**
+     * Find next misspelled word from cursor position
+     */
+    findNextMisspelled(content: string, currentLine: number, currentColumn: number): SpellCheckResult | null;
+    /**
+     * Find previous misspelled word from cursor position
+     */
+    findPrevMisspelled(content: string, currentLine: number, currentColumn: number): SpellCheckResult | null;
+    /**
+     * Get word at specific position
+     */
+    getWordAt(content: string, line: number, column: number): string | null;
+    /**
+     * Create a copy of this spell checker
+     */
+    clone(): SpellChecker;
+}
+
+interface CompletionMatch {
+    text: string;
+    type: CompletionType;
+    info?: string;
+}
+declare enum CompletionType {
+    KEYWORD = "keyword",
+    LINE = "line",
+    FILENAME = "filename",
+    TAG = "tag",
+    OMNI = "omni",
+    USER = "user",
+    SPELLING = "spelling"
+}
+interface CompletionState {
+    matches: CompletionMatch[];
+    currentIndex: number;
+    prefix: string;
+    type: CompletionType;
+    isActive: boolean;
+}
+/**
+ * Manages completion functionality for insert mode
+ */
+declare class CompletionManager {
+    private state;
+    constructor();
+    /**
+     * Check if completion is active
+     */
+    isActive(): boolean;
+    /**
+     * Get current completion state
+     */
+    getState(): CompletionState | null;
+    /**
+     * Get currently selected completion match
+     */
+    getCurrentMatch(): CompletionMatch | null;
+    /**
+     * Cancel completion
+     */
+    cancel(): void;
+    /**
+     * Select next completion match
+     */
+    next(): void;
+    /**
+     * Select previous completion match
+     */
+    prev(): void;
+    /**
+     * Start keyword completion - complete from buffer words
+     */
+    keywordCompletion(buffer: string, cursorLine: number, cursorCol: number): CompletionMatch[];
+    /**
+     * Start line completion - complete entire lines
+     */
+    lineCompletion(buffer: string, cursorLine: number, cursorCol: number): CompletionMatch[];
+    /**
+     * Start filename completion
+     */
+    fileNameCompletion(buffer: string, cursorLine: number, cursorCol: number, currentDir?: string): Promise<CompletionMatch[]>;
+    /**
+     * Start omni completion - context-aware completion
+     * This is a simplified version that combines keyword and line completion
+     */
+    omniCompletion(buffer: string, cursorLine: number, cursorCol: number): CompletionMatch[];
+    /**
+     * Extract word prefix before cursor
+     */
+    private getWordPrefix;
+    /**
+     * Extract file path prefix before cursor
+     */
+    private getFilePathPrefix;
+    /**
+     * Extract all keywords from buffer
+     */
+    private extractKeywords;
+    /**
+     * Get file type information
+     */
+    private getFileTypeInfo;
+    /**
+     * Get completion text to insert (without prefix)
+     */
+    getCompletionText(): string;
+    /**
+     * Get full completion text including prefix
+     */
+    getFullCompletionText(): string;
+    /**
+     * Clone this completion manager
+     */
+    clone(): CompletionManager;
+}
+
+/**
+ * Undo/Redo system with tree structure (like Vim's undo branches)
+ */
+
+interface UndoNode {
+    id: number;
+    state: State;
+    parent: UndoNode | null;
+    children: UndoNode[];
+    timestamp: number;
+    description?: string;
+}
+/**
+ * Manages undo/redo with a tree structure
+ * Unlike linear undo, this preserves all branches of history
+ */
+declare class UndoTree {
+    private root;
+    private current;
+    private nextId;
+    private maxHistorySize;
+    constructor(initialState: State);
+    /**
+     * Add a new state to the undo tree
+     */
+    addState(state: State, description?: string): void;
+    /**
+     * Undo to previous state
+     */
+    undo(): State | null;
+    /**
+     * Redo to next state (follows most recent branch)
+     */
+    redo(): State | null;
+    /**
+     * Get current state
+     */
+    getCurrentState(): State;
+    /**
+     * Check if undo is available
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is available
+     */
+    canRedo(): boolean;
+    /**
+     * Go to specific undo branch by ID
+     */
+    gotoNode(nodeId: number): State | null;
+    /**
+     * Go to older text state by time
+     */
+    gotoOlder(seconds?: number): State | null;
+    /**
+     * Go to newer text state by time
+     */
+    gotoNewer(seconds?: number): State | null;
+    /**
+     * Get undo history for display
+     */
+    getHistory(): Array<{
+        id: number;
+        description?: string;
+        timestamp: number;
+        isCurrent: boolean;
+    }>;
+    /**
+     * Get all available branches from current position
+     */
+    getBranches(): UndoNode[];
+    /**
+     * Clear all undo history
+     */
+    clear(): void;
+    /**
+     * Find node by ID (DFS)
+     */
+    private findNode;
+    /**
+     * Find newer path in tree
+     */
+    private findNewerPath;
+    /**
+     * Prune old history to keep memory usage reasonable
+     */
+    private pruneHistory;
+    /**
+     * Get nodes in current branch from root to current
+     */
+    private getCurrentBranch;
+    /**
+     * Remove a node from the tree
+     */
+    private removeNode;
+    /**
+     * Clone this undo tree
+     */
+    clone(): UndoTree;
+    /**
+     * Deep clone a node and its children
+     */
+    private cloneNode;
+    /**
+     * Get statistics about the undo tree
+     */
+    getStats(): {
+        totalNodes: number;
+        currentDepth: number;
+        maxDepth: number;
+        branchCount: number;
+    };
+}
+
+interface LastVisualSelection {
+    range: Range;
+    mode: Mode.VISUAL | Mode.VISUAL_LINE | Mode.VISUAL_BLOCK;
+}
+interface SearchState {
+    pattern: string;
+    isForward: boolean;
+}
+interface LastCommand {
+    key: string;
+    count?: number;
+    register?: string;
+}
+declare class State {
+    buffer: Buffer;
+    cursor: Cursor;
+    selection: Range | null;
+    mode: Mode;
+    commandLine: string;
+    desiredColumn: number | null;
+    viewport: VimViewport;
+    visualAnchor: Cursor | null;
+    lastVisualSelection: LastVisualSelection | null;
+    recordingRegister: string | null;
+    lastMacroRegister: string | null;
+    foldManager: FoldManager;
+    markManager: MarkManager;
+    jumpListManager: JumpListManager;
+    fileSystem: FileSystemManager;
+    windowManager: WindowManager;
+    lastSearch: SearchState | null;
+    spellChecker: SpellChecker;
+    completionManager: CompletionManager;
+    undoTree: UndoTree | null;
+    lastCommand: LastCommand | null;
+    constructor(buffer: Buffer, cursor: Cursor, selection: Range | null, mode: Mode, commandLine?: string, desiredColumn?: number | null, viewport?: VimViewport, visualAnchor?: Cursor | null, lastVisualSelection?: LastVisualSelection | null, recordingRegister?: string | null, lastMacroRegister?: string | null, foldManager?: FoldManager, markManager?: MarkManager, jumpListManager?: JumpListManager, fileSystem?: FileSystemManager, windowManager?: WindowManager, lastSearch?: SearchState | null, spellChecker?: SpellChecker, completionManager?: CompletionManager, undoTree?: UndoTree | null, lastCommand?: LastCommand | null);
+}
+
+declare abstract class TextObject {
+    abstract key: string;
+    abstract getRange(state: State, variant: 'inner' | 'outer'): Range | null;
+}
+
+declare class Register {
+    content: string;
+    linewise: boolean;
+    constructor(content?: string, linewise?: boolean);
+}
+
+declare class RegisterManager {
+    private registers;
+    get(name: string): Register | undefined;
+    set(name: string, content: string, linewise: boolean): void;
+    /**
+     * Store deleted text: writes to unnamed register `"` and shifts numbered registers 1-9.
+     */
+    storeDelete(content: string, linewise: boolean): void;
+    /**
+     * Store yanked text: writes to register `0` and unnamed register `"`.
+     */
+    storeYank(content: string, linewise: boolean): void;
+    /**
+     * Returns a snapshot of all non-empty registers for display.
+     */
+    getAll(): Map<string, Register>;
+    getDefaultRegister(): Register | undefined;
+}
+
+interface IndentConfig {
+    useSpaces: boolean;
+    indentSize: number;
+}
+/**
+ * Manages indentation detection, calculation, and adjustment
+ */
+declare class IndentationManager {
+    private config;
+    constructor(config?: Partial<IndentConfig>);
+    /**
+     * Detect indentation style from buffer content
+     * Analyzes the buffer to determine if tabs or spaces are used,
+     * and what the indent size is.
+     */
+    detectIndentation(buffer: Buffer): IndentConfig;
+    /**
+     * Update the indent configuration
+     */
+    setConfig(config: Partial<IndentConfig>): void;
+    /**
+     * Get the current indent configuration
+     */
+    getConfig(): IndentConfig;
+    /**
+     * Get the indent string for a given level
+     */
+    getIndentString(level: number): string;
+    /**
+     * Get the indent of a line (leading whitespace)
+     */
+    getLineIndent(line: string): string;
+    /**
+     * Get the indent level of a line (number of indent units)
+     */
+    getIndentLevel(line: string): number;
+    /**
+     * Calculate indent for a new line after a given line
+     * Uses smart indentation based on the content of the previous line
+     */
+    calculateIndentForNewLine(buffer: Buffer, afterLineIndex: number): string;
+    /**
+     * Adjust indent of content to match target indent
+     * Takes content (possibly multi-line) and adjusts its indentation
+     * to match the target indent while preserving relative indentation
+     */
+    adjustIndent(content: string, targetIndent: string): string;
+    /**
+     * Re-indent a line to a specific level
+     */
+    reindentLine(line: string, level: number): string;
+}
+
+interface CommandContext {
+    count?: number;
+    motion?: Motion;
+    textObject?: TextObject;
+    variant?: 'inner' | 'outer';
+    register?: string;
+    char?: string;
+    registerManager?: RegisterManager;
+    indentationManager?: IndentationManager;
+    args?: string;
+    range?: Range;
+}
+declare abstract class Command {
+    abstract key: string;
+    acceptsMotion: boolean;
+    acceptsTextObject: boolean;
+    acceptsPrecedingCount: boolean;
+    acceptsRegister: boolean;
+    needsFollowingChar: boolean;
+    isPrefix: boolean;
+    inclusive: boolean;
+    abstract execute(state: State, context: CommandContext): State;
+}
+
+declare abstract class Motion extends Command {
+    abstract key: string;
+    acceptsMotion: boolean;
+    acceptsTextObject: boolean;
+    acceptsPrecedingCount: boolean;
+    inclusive: boolean;
+    linewise: boolean;
+}
+
+declare class Change {
+    stateBefore: State;
+    stateAfter: State;
+    keySequence: string;
+    timestamp: number;
+    constructor(stateBefore: State, stateAfter: State, keySequence: string, timestamp: number);
+}
+
+declare class UndoStack {
+    private entries;
+    private currentIndex;
+    push(change: Change): void;
+    undo(): State | null;
+    redo(): State | null;
+    getEntries(): Change[];
+    getCurrentIndex(): number;
+}
+
+/**
+ * Vim configuration options
+ */
+interface VimConfig {
+    number: boolean;
+    relativenumber: boolean;
+    wrap: boolean;
+    cursorline: boolean;
+    tabstop: number;
+    shiftwidth: number;
+    expandtab: boolean;
+    autoindent: boolean;
+    smartindent: boolean;
+    ignorecase: boolean;
+    smartcase: boolean;
+    hlsearch: boolean;
+    incsearch: boolean;
+    undolevels: number;
+    clipboard: 'unnamed' | 'unnamedplus' | '';
+}
+type VimConfigKey = keyof VimConfig;
+/**
+ * Manages Vim configuration options
+ */
+declare class ConfigManager {
+    private config;
+    private listeners;
+    constructor(initialConfig?: Partial<VimConfig>);
+    /**
+     * Get a config value
+     */
+    get<K extends VimConfigKey>(key: K): VimConfig[K];
+    /**
+     * Set a config value
+     */
+    set<K extends VimConfigKey>(key: K, value: VimConfig[K]): void;
+    /**
+     * Set multiple config values at once
+     */
+    setMultiple(updates: Partial<VimConfig>): void;
+    /**
+     * Get all config values
+     */
+    getAll(): Readonly<VimConfig>;
+    /**
+     * Reset to default configuration
+     */
+    reset(): void;
+    /**
+     * Toggle a boolean config option
+     */
+    toggle(key: VimConfigKey): void;
+    /**
+     * Subscribe to config changes
+     * @param key - Config key to watch, or '*' for all changes
+     * @param callback - Function to call when config changes
+     * @returns Unsubscribe function
+     */
+    onChange(key: VimConfigKey | '*', callback: (key: VimConfigKey, value: unknown) => void): () => void;
+    /**
+     * Notify all listeners of a config change
+     */
+    private notifyListeners;
+    /**
+     * Parse a Vim set command string (e.g., "number", "nonumber", "tabstop=4")
+     */
+    parseSetCommand(command: string): boolean;
+    /**
+     * Get a formatted string representation of a config value
+     */
+    formatValue(key: VimConfigKey): string;
+}
+
+interface CommandHistoryEntry {
+    keys: string;
+    timestamp: number;
+}
+declare class Session {
+    private commands;
+    private motions;
+    private textObjects;
+    private keyBuffer;
+    private isPlayingMacro;
+    state: State;
+    registerManager: RegisterManager;
+    undoStack: UndoStack;
+    commandHistory: CommandHistoryEntry[];
+    indentationManager: IndentationManager;
+    configManager: ConfigManager;
+    constructor();
+    private syncIndentConfig;
+    setState(state: State): void;
+    getState(): State;
+    getPendingKeys(): string;
+    getCommandLine(): string;
+    getRegisters(): Map<string, {
+        content: string;
+        linewise: boolean;
+    }>;
+    getUndoStack(): UndoStack;
+    getCommandHistory(): CommandHistoryEntry[];
+    /**
+     * Convenience method to set cursor position directly.
+     * Automatically clamps to valid buffer bounds.
+     */
+    setCursor(line: number, column: number): void;
+    /**
+     * Convenience method to enter VISUAL mode with a selection.
+     * Automatically clamps coordinates to valid buffer bounds.
+     */
+    setSelection(startLine: number, startCol: number, endLine: number, endCol: number): void;
+    /**
+     * Convenience method to clear selection and return to NORMAL mode.
+     */
+    clearSelection(): void;
+    /**
+     * Convenience method to set the mode.
+     * Note: Use clearSelection() to exit VISUAL mode, or setCursor() to maintain cursor position.
+     */
+    setMode(mode: Mode): void;
+    /**
+     * Normalize a key string to Vim format.
+     * This is useful for testing or when you have key strings that need normalization.
+     *
+     * Examples:
+     * - normalizeKey("Ctrl+f") -> "<C-f>"
+     * - normalizeKey("Alt+x") -> "<A-x>"
+     * - normalizeKey("Escape") -> "<Esc>"
+     */
+    static normalizeKey(key: string): string;
+    /**
+     * Handle a raw keyboard event from the browser.
+     * Converts browser KeyboardEvent to Vim-style key notation.
+     *
+     * Key format conventions:
+     * - Single keys: 'a', 'B', '1', '$', etc.
+     * - Ctrl combinations: '<C-f>', '<C-w>', etc.
+     * - Alt combinations: '<A-x>', '<A-k>', etc.
+     * - Command/Meta: '<D-s>', '<D-c>', etc.
+     * - Special keys: '<Esc>', 'Space', 'Enter', 'Backspace', etc.
+     * - Arrow keys: 'ArrowUp', 'ArrowDown', etc.
+     */
+    handleRawKeyEvent(event: KeyboardEvent): void;
+    handleKey(key: string): void;
+    private handleInsertMode;
+    private handleCommandMode;
+    private executeCommand;
+    private match;
+    private tryMatch;
+    private playMacro;
+    addMotion(motion: Motion): void;
+    addTextObject(textObject: TextObject): void;
+    addCommand(mode: Mode, command: Command): void;
+    loadStandardVimCommands(): void;
+}
+
+declare abstract class Operator extends Command {
+    acceptsPrecedingCount: boolean;
+    acceptsMotion: boolean;
+    acceptsTextObject: boolean;
+    acceptsRegister: boolean;
+}
+
+declare class PatternRegistry {
+    private patterns;
+    register(name: string, regexProvider: () => string): void;
+    expand(pattern: string): RegExp;
+    private escapeRegex;
+}
+
+declare abstract class ModeTransition extends Command {
+    abstract targetMode: Mode;
+    protected beforeTransition(state: State, context: CommandContext): State;
+    execute(state: State, context: CommandContext): State;
+}
+
+/**
+ * Character classification utilities
+ */
+type CharClassifier = (char: string) => boolean;
+declare function isWordChar(char: string): boolean;
+declare function isWhitespace(char: string): boolean;
+declare function isPunctuation(char: string): boolean;
+declare function isNewline(char: string): boolean;
+/**
+ * Character access utilities
+ */
+declare function getCharAt(buffer: Buffer, cursor: Cursor): string;
+
+/**
+ * Cursor state checks
+ */
+declare function isOnChar(buffer: Buffer, cursor: Cursor, classifier: CharClassifier): boolean;
+declare function isOnWord(buffer: Buffer, cursor: Cursor): boolean;
+declare function isOnWhitespace(buffer: Buffer, cursor: Cursor): boolean;
+declare function isOnPunctuation(buffer: Buffer, cursor: Cursor): boolean;
+declare function isAtLineStart(cursor: Cursor): boolean;
+declare function isAtLineEnd(buffer: Buffer, cursor: Cursor): boolean;
+declare function isAtBufferStart(cursor: Cursor): boolean;
+declare function isAtBufferEnd(buffer: Buffer, cursor: Cursor): boolean;
+
+/**
+ * Move cursor by a given character offset.
+ * Handles moving across line boundaries.
+ */
+declare function moveCursorBy(buffer: Buffer, cursor: Cursor, offset: number): Cursor;
+declare function moveRight(buffer: Buffer, cursor: Cursor): Cursor;
+declare function moveLeft(buffer: Buffer, cursor: Cursor): Cursor;
+declare function moveDown(buffer: Buffer, cursor: Cursor): Cursor;
+declare function moveUp(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Character access by offset
+ */
+declare function getCharAtOffset(buffer: Buffer, cursor: Cursor, offset: number): string;
+
+/**
+ * Generic search functions
+ */
+declare function findNext(buffer: Buffer, cursor: Cursor, classifier: CharClassifier, inclusive?: boolean): Cursor;
+declare function findPrev(buffer: Buffer, cursor: Cursor, classifier: CharClassifier, inclusive?: boolean): Cursor;
+/**
+ * Skip while character matches classifier
+ */
+declare function skipWhile(buffer: Buffer, cursor: Cursor, classifier: CharClassifier, forward?: boolean): Cursor;
+/**
+ * Skip until character matches classifier
+ */
+declare function skipUntil(buffer: Buffer, cursor: Cursor, classifier: CharClassifier, forward?: boolean): Cursor;
+
+/**
+ * Word boundary navigation (built on atomic functions)
+ */
+/**
+ * Find the start of the next word (w motion)
+ */
+declare function findNextWordStart(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Find the start of the previous word (b motion)
+ */
+declare function findPrevWordStart(buffer: Buffer, cursor: Cursor): Cursor;
+declare function findNextWordEnd(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * WORD (big word) navigation - whitespace separated
+ */
+/**
+ * Find the start of the next WORD (W motion)
+ * WORDs are whitespace-separated (hello-world is one WORD)
+ */
+declare function findNextWORDStart(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Find the end of the next WORD (E motion)
+ * WORDs are whitespace-separated
+ */
+declare function findNextWORDEnd(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Find the start of the previous WORD (B motion)
+ * WORDs are whitespace-separated
+ */
+declare function findPrevWORDStart(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Find the end of the previous word (ge motion)
+ * This is the mirror of 'e' but going backward
+ */
+declare function findPrevWordEnd(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Find the end of the previous WORD (gE motion)
+ * WORDs are whitespace-separated (hello-world is one WORD)
+ */
+declare function findPrevWORDEnd(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Whitespace navigation
+ */
+declare function skipWhitespace(buffer: Buffer, cursor: Cursor): Cursor;
+
+/**
+ * Line navigation
+ */
+/**
+ * First non-blank character on cursor's line
+ */
+declare function findFirstNonBlank(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Move to start of current line
+ */
+declare function findLineStart(cursor: Cursor): Cursor;
+/**
+ * Move to end of current line
+ */
+declare function findLineEnd(buffer: Buffer, cursor: Cursor): Cursor;
+
+/**
+ * Normalize a range so that start always comes before end.
+ * Handles backward motions where end < start.
+ */
+declare function normalizeRange(range: Range): Range;
+/**
+ * Extract text content from a range
+ */
+declare function getTextInRange(buffer: Buffer, range: Range): string;
+/**
+ * Delete text in a range and return new buffer content
+ */
+declare function deleteRange(buffer: Buffer, range: Range): string;
+/**
+ * Replace text in a range
+ */
+declare function replaceRange(buffer: Buffer, range: Range, text: string): string;
+/**
+ * Expand range to include surrounding whitespace
+ * Prefers trailing whitespace, falls back to leading if at end of line
+ */
+declare function expandRangeOuter(buffer: Buffer, range: Range): Range;
+/**
+ * Check if cursor is within range
+ */
+declare function isInRange(cursor: Cursor, range: Range): boolean;
+
+/**
+ * Get lines array from buffer
+ */
+declare function getLines(buffer: Buffer): string[];
+/**
+ * Get specific line
+ */
+declare function getLine(buffer: Buffer, lineNum: number): string;
+/**
+ * Delete line and return new buffer content
+ */
+declare function deleteLine(buffer: Buffer, lineNum: number): string;
+/**
+ * Delete multiple lines
+ */
+declare function deleteLines(buffer: Buffer, startLine: number, count: number): string;
+/**
+ * Create new state with updated buffer content
+ */
+declare function withBufferContent(state: State, content: string): State;
+/**
+ * Create new state with updated cursor
+ * By default, preserves desiredColumn (for vertical motions)
+ */
+declare function withCursor(state: State, cursor: Cursor, preserveDesiredColumn?: boolean): State;
+/**
+ * Create new state with updated cursor, maintaining desiredColumn for vertical motion
+ * Sets desiredColumn to the target column if not already set
+ */
+declare function withCursorVertical(state: State, cursor: Cursor, targetColumn: number): State;
+/**
+ * Create new state with updated cursor and reset desiredColumn (for horizontal motions)
+ */
+declare function withCursorHorizontal(state: State, cursor: Cursor): State;
+/**
+ * Create new state with updated viewport
+ */
+declare function withViewport(state: State, topLine: number): State;
+/**
+ * Create new state with updated cursor and viewport
+ */
+declare function withCursorAndViewport(state: State, cursor: Cursor, topLine: number, desiredCol?: number | null): State;
+/**
+ * Clamp cursor to valid buffer position
+ */
+declare function clampCursor(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Clamp cursor for normal mode vertical motion
+ * In normal mode, cursor must be ON a character, not past the end
+ */
+declare function clampCursorNormalMode(buffer: Buffer, cursor: Cursor): Cursor;
+/**
+ * Clamp cursor for vertical motion (j/k) with Vim's whitespace handling.
+ * If the desired column would land in leading whitespace (before any non-whitespace),
+ * move to the beginning of the line instead.
+ */
+declare function clampCursorVerticalMotion(buffer: Buffer, cursor: Cursor, desiredColumn: number): Cursor;
+/**
+ * Update visual selection based on current cursor and anchor
+ * Used when cursor moves in visual mode
+ */
+declare function updateVisualSelection(state: State, newCursor: Cursor): State;
+
+/**
+ * Get the effective count from a command context (defaults to 1).
+ */
+declare function getCount(context: CommandContext): number;
+/**
+ * Get the text of the line at the cursor position.
+ */
+declare function currentLine(state: State): string;
+/**
+ * Get the total number of lines in the buffer.
+ */
+declare function lineCount(state: State): number;
+/**
+ * Get the maximum valid line index (0-based).
+ */
+declare function lastLine(state: State): number;
+/**
+ * Apply a cursor motion function `count` times, clamping the result.
+ * Replaces the repeated loop+clamp pattern in word motions.
+ * Resets desiredColumn since word motions are horizontal.
+ */
+declare function repeatCursorMotion(state: State, context: CommandContext, fn: (buffer: Buffer, cursor: Cursor) => Cursor): State;
+/**
+ * Resolve the operator range from either a text object or a motion in the context.
+ * Returns null if neither is present.
+ * Normalizes the range so start always comes before end (handles backward motions).
+ * Handles inclusive motions by extending the range by 1 character.
+ */
+declare function resolveOperatorRange(state: State, context: CommandContext): Range | null;
+/**
+ * Create a new state with both updated buffer content and cursor position.
+ */
+declare function withContentAndCursor(state: State, content: string, cursor: Cursor): State;
+/**
+ * Delete a range and store the deleted text in the register manager.
+ * Returns a new state with the content deleted and cursor repositioned.
+ * Normalizes the range to ensure start comes before end.
+ */
+declare function deleteRangeWithRegister(state: State, range: Range, context: CommandContext, isLinewise?: boolean): State;
+
+export { Buffer, Change, type CharClassifier, Command, type CommandContext, type CommandHistoryEntry, ConfigManager, Cursor, type IndentConfig, IndentationManager, Mode, ModeTransition, Motion, Operator, PatternRegistry, type Range, Register, RegisterManager, Session, State, TextObject, UndoStack, type VimConfig, type VimConfigKey, VimViewport, clampCursor, clampCursorNormalMode, clampCursorVerticalMotion, currentLine, deleteLine, deleteLines, deleteRange, deleteRangeWithRegister, expandRangeOuter, findFirstNonBlank, findLineEnd, findLineStart, findNext, findNextWORDEnd, findNextWORDStart, findNextWordEnd, findNextWordStart, findPrev, findPrevWORDEnd, findPrevWORDStart, findPrevWordEnd, findPrevWordStart, getCharAt, getCharAtOffset, getCount, getLine, getLines, getTextInRange, isAtBufferEnd, isAtBufferStart, isAtLineEnd, isAtLineStart, isInRange, isNewline, isOnChar, isOnPunctuation, isOnWhitespace, isOnWord, isPunctuation, isWhitespace, isWordChar, lastLine, lineCount, moveCursorBy, moveDown, moveLeft, moveRight, moveUp, normalizeRange, repeatCursorMotion, replaceRange, resolveOperatorRange, skipUntil, skipWhile, skipWhitespace, updateVisualSelection, withBufferContent, withContentAndCursor, withCursor, withCursorAndViewport, withCursorHorizontal, withCursorVertical, withViewport };