@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/state.js

@@ -0,0 +1,900 @@
+/**
+ * Core editor state management
+ *
+ * This module provides the fundamental state management for the custom editor,
+ * handling document content, cursor positions, selections, and history.
+ * Supports multi-cursor editing with automatic cursor merging.
+ */
+import { getTokenizer, tokenize } from '../tokenizer';
+import { HISTORY_GROUP_TIMEOUT_MS, MAX_HISTORY_SIZE } from '../constants';
+import { CursorManager, createCursorManager, getSelectionStart, getSelectionEnd, isSelectionEmpty, comparePositions } from './multi-cursor';
+/**
+ * Core editor state class
+ */
+export class EditorState {
+    /** Document lines */
+    _lines = [];
+    /** Multi-cursor manager */
+    _cursorManager;
+    /** Language for syntax highlighting */
+    _language;
+    /** Tokenizer state for incremental tokenization */
+    _tokenizerStates = [];
+    /** Undo history */
+    _undoStack = [];
+    /** Redo history */
+    _redoStack = [];
+    /** Maximum history size */
+    maxHistorySize;
+    /** Tab settings */
+    tabSize;
+    insertSpaces;
+    /** Maximum listeners per type to prevent memory leaks */
+    static MAX_LISTENERS = 100;
+    /** Change listeners */
+    changeListeners = new Set();
+    /** Selection change listeners */
+    selectionListeners = new Set();
+    /** Cursor change listeners (for multi-cursor) */
+    cursorListeners = new Set();
+    /** Undo grouping: timestamp of last history save */
+    lastHistoryTimestamp = 0;
+    /** Undo grouping: type of last change */
+    lastHistoryType = null;
+    /** Undo grouping: time window in ms for grouping consecutive edits */
+    historyGroupTimeout = HISTORY_GROUP_TIMEOUT_MS;
+    /** Cached content string (invalidated on changes) */
+    _contentCache = null;
+    /** Flag to suppress notifications during atomic operations (e.g., CRDT sync) */
+    _suppressNotifications = false;
+    constructor(config = {}) {
+        this._language = config.language ?? 'plaintext';
+        this.maxHistorySize = config.maxHistorySize ?? MAX_HISTORY_SIZE;
+        this.tabSize = config.tabSize ?? 2;
+        this.insertSpaces = config.insertSpaces ?? false;
+        // Initialize cursor manager
+        this._cursorManager = createCursorManager({
+            maxCursors: config.maxCursors
+        });
+        // Set initial content
+        this.setContent(config.content ?? '');
+    }
+    // ============================================
+    // Content Access
+    // ============================================
+    /**
+     * Get all lines
+     */
+    get lines() {
+        return this._lines;
+    }
+    /**
+     * Get line count
+     */
+    get lineCount() {
+        return this._lines.length;
+    }
+    /**
+     * Get a specific line
+     */
+    getLine(lineNumber) {
+        return this._lines[lineNumber];
+    }
+    /**
+     * Get document content as string (cached for performance)
+     */
+    getContent() {
+        if (this._contentCache === null) {
+            this._contentCache = this._lines.map((l) => l.text).join('\n');
+        }
+        return this._contentCache;
+    }
+    /**
+     * Invalidate content cache (call when lines change)
+     */
+    invalidateContentCache() {
+        this._contentCache = null;
+    }
+    /**
+     * Set document content (replaces everything)
+     */
+    setContent(content) {
+        const oldContent = this.getContent();
+        // Normalize line endings: CRLF and CR to LF
+        const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const textLines = normalized.split('\n');
+        this._lines = textLines.map((text, i) => ({
+            number: i,
+            text
+        }));
+        // Reset tokenizer states
+        this._tokenizerStates = new Array(this._lines.length).fill(undefined);
+        // Tokenize all lines
+        this.retokenize(0, this._lines.length);
+        // Emit change event
+        if (oldContent !== content) {
+            this.emitChange({
+                type: 'replace',
+                from: { line: 0, column: 0 },
+                to: this.endPosition(),
+                text: content,
+                removed: oldContent
+            });
+        }
+    }
+    /**
+     * Get current language
+     */
+    get language() {
+        return this._language;
+    }
+    /**
+     * Set language (triggers re-tokenization)
+     */
+    setLanguage(language) {
+        if (this._language !== language) {
+            this._language = language;
+            this._tokenizerStates = new Array(this._lines.length).fill(undefined);
+            this.retokenize(0, this._lines.length);
+        }
+    }
+    // ============================================
+    // Selection (backward compatible - uses primary cursor)
+    // ============================================
+    /**
+     * Get current selection (primary cursor)
+     */
+    get selection() {
+        return this._cursorManager.getPrimary().selection;
+    }
+    /**
+     * Get cursor position (primary cursor head)
+     */
+    get cursor() {
+        return this._cursorManager.getPrimary().selection.head;
+    }
+    /**
+     * Check if primary cursor has a selection
+     */
+    get hasSelection() {
+        return !isSelectionEmpty(this._cursorManager.getPrimary().selection);
+    }
+    /**
+     * Get normalized selection (start before end) for primary cursor
+     */
+    get normalizedSelection() {
+        const selection = this._cursorManager.getPrimary().selection;
+        return {
+            start: getSelectionStart(selection),
+            end: getSelectionEnd(selection)
+        };
+    }
+    /**
+     * Set cursor position (clears selection, affects primary cursor only)
+     */
+    setCursor(position) {
+        const clamped = this.clampPosition(position);
+        this._cursorManager.setSingleCursor(clamped);
+        this.emitSelectionChange();
+        this.emitCursorChange();
+    }
+    /**
+     * Set selection range (affects primary cursor only, clears secondary cursors)
+     */
+    setSelection(anchor, head) {
+        this._cursorManager.setSingleSelection(this.clampPosition(anchor), this.clampPosition(head));
+        this.emitSelectionChange();
+        this.emitCursorChange();
+    }
+    /**
+     * Extend selection to position (keeps anchor, primary cursor only)
+     */
+    extendSelection(head) {
+        const primary = this._cursorManager.getPrimary();
+        this._cursorManager.extendSelection(primary.id, this.clampPosition(head));
+        this.emitSelectionChange();
+        this.emitCursorChange();
+    }
+    /**
+     * Select all
+     */
+    selectAll() {
+        this.setSelection({ line: 0, column: 0 }, this.endPosition());
+    }
+    /**
+     * Get selected text (primary cursor)
+     */
+    getSelectedText() {
+        return this.getTextInSelection(this._cursorManager.getPrimary().selection);
+    }
+    /**
+     * Get selected text from all cursors
+     * Joins multiple selections with newlines (VS Code behavior)
+     */
+    getSelectedTextFromAllCursors() {
+        const selections = [];
+        for (const cursor of this._cursorManager.getSortedCursors()) {
+            if (!isSelectionEmpty(cursor.selection)) {
+                selections.push(this.getTextInSelection(cursor.selection));
+            }
+        }
+        return selections.join('\n');
+    }
+    /**
+     * Check if any cursor has a selection
+     */
+    get hasAnySelection() {
+        for (const cursor of this._cursorManager.getCursors()) {
+            if (!isSelectionEmpty(cursor.selection)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get text within a selection range
+     */
+    getTextInSelection(selection) {
+        if (isSelectionEmpty(selection)) {
+            return '';
+        }
+        const start = getSelectionStart(selection);
+        const end = getSelectionEnd(selection);
+        if (start.line === end.line) {
+            return this._lines[start.line].text.slice(start.column, end.column);
+        }
+        const lines = [];
+        lines.push(this._lines[start.line].text.slice(start.column));
+        for (let i = start.line + 1; i < end.line; i++) {
+            lines.push(this._lines[i].text);
+        }
+        lines.push(this._lines[end.line].text.slice(0, end.column));
+        return lines.join('\n');
+    }
+    // ============================================
+    // Multi-Cursor API
+    // ============================================
+    /**
+     * Get cursor manager for advanced multi-cursor operations
+     */
+    get cursorManager() {
+        return this._cursorManager;
+    }
+    /**
+     * Get all cursors
+     */
+    get allCursors() {
+        return this._cursorManager.getCursors();
+    }
+    /**
+     * Get primary cursor
+     */
+    get primaryCursor() {
+        return this._cursorManager.getPrimary();
+    }
+    /**
+     * Check if there are multiple cursors
+     */
+    get hasMultipleCursors() {
+        return this._cursorManager.hasMultiple;
+    }
+    /**
+     * Add a new cursor at position
+     */
+    addCursor(position, makePrimary = false) {
+        const clamped = this.clampPosition(position);
+        const cursor = this._cursorManager.addCursor(clamped, makePrimary);
+        this.emitCursorChange();
+        return cursor;
+    }
+    /**
+     * Add a cursor with selection
+     */
+    addCursorWithSelection(anchor, head, makePrimary = false) {
+        const cursor = this._cursorManager.addCursorWithSelection(this.clampPosition(anchor), this.clampPosition(head), makePrimary);
+        this.emitCursorChange();
+        return cursor;
+    }
+    /**
+     * Add cursor above primary cursor
+     */
+    addCursorAbove() {
+        const primary = this._cursorManager.getPrimary();
+        const pos = primary.selection.head;
+        if (pos.line <= 0)
+            return false;
+        const newLine = pos.line - 1;
+        const lineText = this._lines[newLine]?.text ?? '';
+        const newColumn = Math.min(pos.column, lineText.length);
+        this._cursorManager.addCursor({ line: newLine, column: newColumn });
+        this.emitCursorChange();
+        return true;
+    }
+    /**
+     * Add cursor below primary cursor
+     */
+    addCursorBelow() {
+        const primary = this._cursorManager.getPrimary();
+        const pos = primary.selection.head;
+        if (pos.line >= this._lines.length - 1)
+            return false;
+        const newLine = pos.line + 1;
+        const lineText = this._lines[newLine]?.text ?? '';
+        const newColumn = Math.min(pos.column, lineText.length);
+        this._cursorManager.addCursor({ line: newLine, column: newColumn });
+        this.emitCursorChange();
+        return true;
+    }
+    /**
+     * Remove last added secondary cursor
+     */
+    removeLastCursor() {
+        const result = this._cursorManager.removeLastSecondary();
+        if (result) {
+            this.emitCursorChange();
+        }
+        return result;
+    }
+    /**
+     * Clear all secondary cursors
+     */
+    clearSecondaryCursors() {
+        this._cursorManager.clearSecondary();
+        this.emitCursorChange();
+    }
+    // ============================================
+    // Editing Operations (Multi-Cursor Aware)
+    // ============================================
+    /**
+     * Insert text at all cursor positions
+     */
+    insert(text) {
+        this.saveHistory('insert');
+        // Get cursors in reverse order (bottom to top) to maintain position validity
+        const cursors = this._cursorManager.getSortedCursorsReverse();
+        // Store cursor updates to apply after all insertions
+        const updates = [];
+        for (const cursor of cursors) {
+            let currentPos = cursor.selection.head;
+            // Delete selection first if exists
+            if (!isSelectionEmpty(cursor.selection)) {
+                const start = getSelectionStart(cursor.selection);
+                const end = getSelectionEnd(cursor.selection);
+                this.deleteRangeInternal(start, end);
+                currentPos = start;
+            }
+            // Insert text
+            const newPos = this.insertAtInternal(currentPos, text);
+            updates.push({ id: cursor.id, position: newPos });
+        }
+        // Apply all cursor updates using batch update to avoid multiple merge/emit calls
+        this._cursorManager.batchUpdateCursors(updates);
+        this.emitChange({ type: 'insert', from: this.cursor, text });
+        this.emitSelectionChange();
+        this.emitCursorChange();
+    }
+    /**
+     * Insert text at a specific position (internal, doesn't update cursor)
+     * @returns New position after insert
+     */
+    insertAtInternal(position, text) {
+        const pos = this.clampPosition(position);
+        const line = this._lines[pos.line];
+        const textLines = text.split('\n');
+        if (textLines.length === 1) {
+            // Single line insert
+            line.text = line.text.slice(0, pos.column) + text + line.text.slice(pos.column);
+            // Re-tokenize from the edited line to the end of the document: the
+            // tokenizer carries multi-line state (block comments, template
+            // literals), so typing `/*` must propagate downward. retokenize()
+            // early-exits once the carried state re-converges, so this is cheap
+            // in the common single-line case.
+            this.retokenize(pos.line, this._lines.length);
+            return { line: pos.line, column: pos.column + text.length };
+        }
+        else {
+            // Multi-line insert
+            const before = line.text.slice(0, pos.column);
+            const after = line.text.slice(pos.column);
+            // Modify first line
+            line.text = before + textLines[0];
+            // Insert middle lines
+            const newLines = textLines.slice(1, -1).map((t, i) => ({
+                number: pos.line + i + 1,
+                text: t
+            }));
+            // Add last line
+            newLines.push({
+                number: pos.line + textLines.length - 1,
+                text: textLines[textLines.length - 1] + after
+            });
+            // Splice in new lines
+            this._lines.splice(pos.line + 1, 0, ...newLines);
+            this._tokenizerStates.splice(pos.line + 1, 0, ...new Array(newLines.length).fill(undefined));
+            // Renumber lines
+            this.renumberLines(pos.line + 1);
+            // Retokenize affected lines
+            this.retokenize(pos.line, pos.line + textLines.length);
+            // Return new position
+            const lastLineIdx = textLines.length - 1;
+            return {
+                line: pos.line + lastLineIdx,
+                column: textLines[lastLineIdx].length
+            };
+        }
+    }
+    /**
+     * Insert text at a specific position (public API - single cursor)
+     */
+    insertAt(position, text) {
+        this.saveHistory('insert');
+        const newPos = this.insertAtInternal(position, text);
+        this.setCursor(newPos);
+        this.emitChange({ type: 'insert', from: position, text });
+    }
+    /**
+     * Delete the current selection (all cursors)
+     */
+    deleteSelection() {
+        const cursors = this._cursorManager.getSortedCursorsReverse();
+        let hasAnySelection = false;
+        for (const cursor of cursors) {
+            if (!isSelectionEmpty(cursor.selection)) {
+                hasAnySelection = true;
+            }
+        }
+        if (!hasAnySelection) {
+            return;
+        }
+        this.saveHistory('delete');
+        const updates = [];
+        for (const cursor of cursors) {
+            if (!isSelectionEmpty(cursor.selection)) {
+                const start = getSelectionStart(cursor.selection);
+                const end = getSelectionEnd(cursor.selection);
+                this.deleteRangeInternal(start, end);
+                updates.push({ id: cursor.id, position: start });
+            }
+        }
+        // Apply all cursor updates using batch update
+        this._cursorManager.batchUpdateCursors(updates);
+        this.emitChange({ type: 'delete', from: this.cursor, to: this.cursor });
+        this.emitSelectionChange();
+        this.emitCursorChange();
+    }
+    /**
+     * Delete a range of text (internal, doesn't update cursor)
+     */
+    deleteRangeInternal(from, to) {
+        if (from.line === to.line) {
+            // Single line deletion
+            const line = this._lines[from.line];
+            line.text = line.text.slice(0, from.column) + line.text.slice(to.column);
+            // Re-tokenize to end of document so removing a multi-line construct
+            // delimiter (e.g. a closing `*/`) re-propagates state to lines below.
+            this.retokenize(from.line, this._lines.length);
+        }
+        else {
+            // Multi-line deletion
+            const firstLine = this._lines[from.line];
+            const lastLine = this._lines[to.line];
+            // Merge first and last lines
+            firstLine.text = firstLine.text.slice(0, from.column) + lastLine.text.slice(to.column);
+            // Remove intermediate lines
+            const removedCount = to.line - from.line;
+            this._lines.splice(from.line + 1, removedCount);
+            this._tokenizerStates.splice(from.line + 1, removedCount);
+            // Renumber lines
+            this.renumberLines(from.line + 1);
+            // Retokenize from affected line to end
+            this.retokenize(from.line, this._lines.length);
+        }
+    }
+    /**
+     * Delete a range of text (public API - single cursor)
+     */
+    deleteRange(from, to) {
+        this.deleteRangeInternal(from, to);
+        this.setCursor(from);
+    }
+    /**
+     * Delete character before all cursors (backspace)
+     */
+    deleteBackward() {
+        // Check if any cursor has a selection
+        const cursors = this._cursorManager.getSortedCursorsReverse();
+        let hasAnySelection = false;
+        for (const cursor of cursors) {
+            if (!isSelectionEmpty(cursor.selection)) {
+                hasAnySelection = true;
+                break;
+            }
+        }
+        if (hasAnySelection) {
+            this.deleteSelection();
+            return;
+        }
+        this.saveHistory('delete');
+        const updates = [];
+        for (const cursor of cursors) {
+            const { line, column } = cursor.selection.head;
+            if (column > 0) {
+                // Delete within line
+                const currentLine = this._lines[line];
+                currentLine.text = currentLine.text.slice(0, column - 1) + currentLine.text.slice(column);
+                // Re-tokenize to end of document so deleting a multi-line construct
+                // delimiter re-propagates state to lines below.
+                this.retokenize(line, this._lines.length);
+                updates.push({ id: cursor.id, position: { line, column: column - 1 } });
+            }
+            else if (line > 0) {
+                // Join with previous line
+                const prevLine = this._lines[line - 1];
+                const currentLine = this._lines[line];
+                const newColumn = prevLine.text.length;
+                prevLine.text += currentLine.text;
+                this._lines.splice(line, 1);
+                this._tokenizerStates.splice(line, 1);
+                this.renumberLines(line);
+                this.retokenize(line - 1, this._lines.length);
+                updates.push({ id: cursor.id, position: { line: line - 1, column: newColumn } });
+            }
+        }
+        // Apply all cursor updates using batch update
+        this._cursorManager.batchUpdateCursors(updates);
+        this.emitChange({ type: 'delete', from: this.cursor, to: this.cursor });
+        this.emitSelectionChange();
+        this.emitCursorChange();
+    }
+    /**
+     * Delete character after all cursors (delete key)
+     */
+    deleteForward() {
+        // Check if any cursor has a selection
+        const cursors = this._cursorManager.getSortedCursorsReverse();
+        let hasAnySelection = false;
+        for (const cursor of cursors) {
+            if (!isSelectionEmpty(cursor.selection)) {
+                hasAnySelection = true;
+                break;
+            }
+        }
+        if (hasAnySelection) {
+            this.deleteSelection();
+            return;
+        }
+        this.saveHistory('delete');
+        for (const cursor of cursors) {
+            const { line, column } = cursor.selection.head;
+            const currentLine = this._lines[line];
+            if (column < currentLine.text.length) {
+                // Delete within line
+                currentLine.text = currentLine.text.slice(0, column) + currentLine.text.slice(column + 1);
+                // Re-tokenize to end of document so deleting a multi-line construct
+                // delimiter re-propagates state to lines below.
+                this.retokenize(line, this._lines.length);
+            }
+            else if (line < this._lines.length - 1) {
+                // Join with next line
+                const nextLine = this._lines[line + 1];
+                currentLine.text += nextLine.text;
+                this._lines.splice(line + 1, 1);
+                this._tokenizerStates.splice(line + 1, 1);
+                this.renumberLines(line + 1);
+                this.retokenize(line, this._lines.length);
+            }
+        }
+        this.emitChange({ type: 'delete', from: this.cursor, to: this.cursor });
+        this.emitSelectionChange();
+    }
+    /**
+     * Insert a new line (enter key)
+     */
+    insertNewline() {
+        this.insert('\n');
+    }
+    /**
+     * Insert tab
+     */
+    insertTab() {
+        const tabStr = this.insertSpaces ? ' '.repeat(this.tabSize) : '\t';
+        this.insert(tabStr);
+    }
+    // ============================================
+    // History (Undo/Redo)
+    // ============================================
+    /**
+     * Save current state to history with optional grouping
+     * @param changeType - Type of change for grouping consecutive edits
+     */
+    saveHistory(changeType) {
+        const now = Date.now();
+        // Check if we should merge with the last history entry
+        const shouldMerge = (changeType &&
+            changeType === this.lastHistoryType &&
+            this._undoStack.length > 0 &&
+            now - this.lastHistoryTimestamp < this.historyGroupTimeout);
+        // Save cursor state
+        const cursorState = this._cursorManager.clone();
+        const entry = {
+            content: this.getContent(),
+            selection: this.deepCopySelection(this.selection),
+            cursors: cursorState.cursors,
+            primaryCursorId: cursorState.primaryId,
+            timestamp: now
+        };
+        if (shouldMerge) {
+            // Update the last entry instead of creating a new one
+            this._undoStack[this._undoStack.length - 1] = entry;
+        }
+        else {
+            this._undoStack.push(entry);
+            // Limit history size
+            if (this._undoStack.length > this.maxHistorySize) {
+                this._undoStack.shift();
+            }
+        }
+        // Update grouping state
+        this.lastHistoryTimestamp = now;
+        this.lastHistoryType = changeType ?? null;
+        // Clear redo stack on new edit
+        this._redoStack = [];
+    }
+    /**
+     * Undo last change
+     */
+    undo() {
+        const entry = this._undoStack.pop();
+        if (!entry) {
+            return false;
+        }
+        // Save current state to redo stack
+        const currentCursorState = this._cursorManager.clone();
+        this._redoStack.push({
+            content: this.getContent(),
+            selection: this.deepCopySelection(this.selection),
+            cursors: currentCursorState.cursors,
+            primaryCursorId: currentCursorState.primaryId,
+            timestamp: Date.now()
+        });
+        // Restore state
+        this.setContent(entry.content);
+        // Restore cursor state
+        if (entry.cursors && entry.primaryCursorId) {
+            this._cursorManager.restore(entry.cursors, entry.primaryCursorId);
+        }
+        else {
+            // Fallback for old history entries
+            this._cursorManager.setSingleSelection(entry.selection.anchor, entry.selection.head);
+        }
+        this.emitSelectionChange();
+        this.emitCursorChange();
+        return true;
+    }
+    /**
+     * Redo last undone change
+     */
+    redo() {
+        const entry = this._redoStack.pop();
+        if (!entry) {
+            return false;
+        }
+        // Save current state to undo stack (with size limit)
+        const currentCursorState = this._cursorManager.clone();
+        this._undoStack.push({
+            content: this.getContent(),
+            selection: this.deepCopySelection(this.selection),
+            cursors: currentCursorState.cursors,
+            primaryCursorId: currentCursorState.primaryId,
+            timestamp: Date.now()
+        });
+        // Enforce history size limit
+        while (this._undoStack.length > this.maxHistorySize) {
+            this._undoStack.shift();
+        }
+        // Restore state
+        this.setContent(entry.content);
+        // Restore cursor state
+        if (entry.cursors && entry.primaryCursorId) {
+            this._cursorManager.restore(entry.cursors, entry.primaryCursorId);
+        }
+        else {
+            // Fallback for old history entries
+            this._cursorManager.setSingleSelection(entry.selection.anchor, entry.selection.head);
+        }
+        this.emitSelectionChange();
+        this.emitCursorChange();
+        return true;
+    }
+    /**
+     * Deep copy a selection to prevent reference issues in history
+     */
+    deepCopySelection(sel) {
+        return {
+            anchor: { line: sel.anchor.line, column: sel.anchor.column },
+            head: { line: sel.head.line, column: sel.head.column }
+        };
+    }
+    /**
+     * Check if undo is available
+     */
+    get canUndo() {
+        return this._undoStack.length > 0;
+    }
+    /**
+     * Check if redo is available
+     */
+    get canRedo() {
+        return this._redoStack.length > 0;
+    }
+    // ============================================
+    // Tokenization
+    // ============================================
+    /**
+     * Compare two tokenizer states for equality
+     */
+    tokenizerStatesEqual(a, b) {
+        if (a === b)
+            return true;
+        if (!a || !b)
+            return a === b;
+        return (a.inBlockComment === b.inBlockComment &&
+            a.inTemplateLiteral === b.inTemplateLiteral &&
+            a.inMultilineString === b.inMultilineString &&
+            a.stringDelimiter === b.stringDelimiter &&
+            a.templateDepth === b.templateDepth);
+    }
+    /**
+     * Re-tokenize a range of lines with early-exit optimization
+     */
+    retokenize(startLine, endLine) {
+        const tokenizer = getTokenizer(this._language);
+        let state = startLine > 0 ? this._tokenizerStates[startLine - 1] : tokenizer.getInitialState();
+        for (let i = startLine; i < endLine && i < this._lines.length; i++) {
+            const line = this._lines[i];
+            const oldState = this._tokenizerStates[i];
+            const tokenized = tokenizer.tokenizeLine(line.text, i + 1, state);
+            line.tokens = tokenized;
+            state = tokenized.state;
+            // Early exit: if state unchanged from what was stored, subsequent lines are unchanged
+            if (i > startLine && this.tokenizerStatesEqual(oldState, state)) {
+                break;
+            }
+            this._tokenizerStates[i] = state;
+        }
+    }
+    // ============================================
+    // Helpers
+    // ============================================
+    /**
+     * Clamp a position to valid document bounds
+     */
+    clampPosition(pos) {
+        const line = Math.max(0, Math.min(pos.line, this._lines.length - 1));
+        const lineText = this._lines[line]?.text ?? '';
+        const column = Math.max(0, Math.min(pos.column, lineText.length));
+        return { line, column };
+    }
+    /**
+     * Get end position of document
+     */
+    endPosition() {
+        if (this._lines.length === 0) {
+            return { line: 0, column: 0 };
+        }
+        const lastLine = this._lines.length - 1;
+        return { line: lastLine, column: this._lines[lastLine].text.length };
+    }
+    /**
+     * Renumber lines from a starting point
+     */
+    renumberLines(startFrom) {
+        for (let i = startFrom; i < this._lines.length; i++) {
+            this._lines[i].number = i;
+        }
+    }
+    // ============================================
+    // Event Listeners
+    // ============================================
+    /**
+     * Helper to add a listener with overflow protection
+     * In development mode, throws an error to catch memory leaks early.
+     * In production, warns and evicts the oldest listener.
+     */
+    addListener(listeners, callback, name) {
+        if (listeners.size >= EditorState.MAX_LISTENERS) {
+            const msg = `[EditorState] Maximum ${name} listener count (${EditorState.MAX_LISTENERS}) exceeded. Possible memory leak - ensure listeners are unsubscribed.`;
+            // Fail fast in development to catch bugs early
+            if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') {
+                throw new Error(msg);
+            }
+            // In production, warn and auto-cleanup oldest listener
+            console.warn(msg);
+            const firstListener = listeners.values().next().value;
+            if (firstListener) {
+                listeners.delete(firstListener);
+            }
+        }
+        listeners.add(callback);
+        return () => listeners.delete(callback);
+    }
+    /**
+     * Add change listener
+     */
+    onContentChange(callback) {
+        return this.addListener(this.changeListeners, callback, 'change');
+    }
+    /**
+     * Add selection change listener
+     */
+    onSelectionChange(callback) {
+        return this.addListener(this.selectionListeners, callback, 'selection');
+    }
+    /**
+     * Add cursor change listener (for multi-cursor updates)
+     */
+    onCursorChange(callback) {
+        return this.addListener(this.cursorListeners, callback, 'cursor');
+    }
+    emitChange(event) {
+        // Invalidate cache when content changes
+        this.invalidateContentCache();
+        if (this._suppressNotifications)
+            return;
+        for (const listener of this.changeListeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                console.error('[EditorState] Change listener failed:', error);
+            }
+        }
+    }
+    emitSelectionChange() {
+        if (this._suppressNotifications)
+            return;
+        const selection = this.selection;
+        for (const listener of this.selectionListeners) {
+            try {
+                listener(selection);
+            }
+            catch (error) {
+                console.error('[EditorState] Selection listener failed:', error);
+            }
+        }
+    }
+    emitCursorChange() {
+        if (this._suppressNotifications)
+            return;
+        const cursors = this._cursorManager.getCursors();
+        for (const listener of this.cursorListeners) {
+            try {
+                listener(cursors);
+            }
+            catch (error) {
+                console.error('[EditorState] Cursor listener failed:', error);
+            }
+        }
+    }
+    /**
+     * Run a function with notifications suppressed.
+     * Useful for atomic operations like CRDT sync where we want to
+     * update content and selection without triggering intermediate events.
+     */
+    runWithoutNotifications(fn) {
+        const wasSupressed = this._suppressNotifications;
+        this._suppressNotifications = true;
+        try {
+            return fn();
+        }
+        finally {
+            this._suppressNotifications = wasSupressed;
+        }
+    }
+}
+/**
+ * Create editor state
+ */
+export function createEditorState(config) {
+    return new EditorState(config);
+}