@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/editor-find.js

@@ -0,0 +1,148 @@
+/**
+ * Editor find/replace logic extracted from CustomEditor.svelte
+ *
+ * Factory function that creates all find/replace state and operations,
+ * accepting callbacks for things it cannot own (editor state access, DOM operations).
+ */
+import { findAllMatches, findMatchIndexAtOrAfter, getNextMatchIndex, getPrevMatchIndex, replaceMatch, replaceAllMatches } from './core';
+export function createEditorFind(deps) {
+    let query = '';
+    let replace = '';
+    let caseSensitive = false;
+    let useRegex = false;
+    let matches = [];
+    let currentIndex = -1;
+    function updateMatches() {
+        const lines = deps.getLines();
+        if (!lines || !query) {
+            matches = [];
+            currentIndex = -1;
+            return;
+        }
+        matches = findAllMatches(lines, query, {
+            caseSensitive,
+            useRegex
+        });
+        if (matches.length > 0) {
+            currentIndex = findMatchIndexAtOrAfter(matches, deps.getSelection().head);
+        }
+        else {
+            currentIndex = -1;
+        }
+    }
+    function setQuery(q) {
+        query = q;
+        updateMatches();
+    }
+    function setReplaceText(text) {
+        replace = text;
+    }
+    function setCaseSensitive(value) {
+        caseSensitive = value;
+        updateMatches();
+    }
+    function setUseRegex(value) {
+        useRegex = value;
+        updateMatches();
+    }
+    function goToMatch(index) {
+        if (index < 0 || index >= matches.length)
+            return;
+        const match = matches[index];
+        deps.setSelection(match.start, match.end);
+        deps.scrollCursorIntoView();
+        deps.focusEditor();
+    }
+    function findNext() {
+        if (matches.length === 0)
+            return;
+        currentIndex = getNextMatchIndex(matches, currentIndex, true);
+        goToMatch(currentIndex);
+    }
+    function findPrev() {
+        if (matches.length === 0)
+            return;
+        currentIndex = getPrevMatchIndex(matches, currentIndex, true);
+        goToMatch(currentIndex);
+    }
+    function doReplace() {
+        if (deps.isReadonly() || matches.length === 0 || currentIndex < 0)
+            return;
+        const match = matches[currentIndex];
+        const lines = deps.getLines();
+        const result = replaceMatch(lines, match, replace);
+        deps.setContent(result.newLines.join('\n'));
+        deps.setCursor(result.cursorPosition);
+        updateMatches();
+        if (matches.length > 0) {
+            currentIndex = Math.min(currentIndex, matches.length - 1);
+            goToMatch(currentIndex);
+        }
+    }
+    function doReplaceAll() {
+        if (deps.isReadonly() || matches.length === 0)
+            return;
+        const lines = deps.getLines();
+        const newLines = replaceAllMatches(lines, matches, replace);
+        deps.setContent(newLines.join('\n'));
+        updateMatches();
+    }
+    function computeMatchRects(viewport, measurements) {
+        if (matches.length === 0)
+            return [];
+        const { scrollTop, viewportHeight } = viewport;
+        const { lineHeight, charWidth, gutterWidth, contentPadding } = measurements;
+        const firstVisibleLine = Math.max(0, Math.floor(scrollTop / lineHeight) - 1);
+        const lineCount = deps.getLineCount();
+        const lastVisibleLine = Math.min(lineCount - 1, Math.ceil((scrollTop + viewportHeight) / lineHeight) + 1);
+        const rects = [];
+        for (let i = 0; i < matches.length; i++) {
+            const match = matches[i];
+            if (match.line < firstVisibleLine || match.line > lastVisibleLine)
+                continue;
+            const width = (match.endColumn - match.startColumn) * charWidth;
+            if (width <= 0)
+                continue;
+            rects.push({
+                top: match.line * lineHeight,
+                left: gutterWidth + contentPadding + match.startColumn * charWidth,
+                width,
+                height: lineHeight,
+                isCurrent: i === currentIndex
+            });
+        }
+        return rects;
+    }
+    return {
+        // Getters for reactive reads
+        get query() {
+            return query;
+        },
+        get replaceText() {
+            return replace;
+        },
+        get caseSensitive() {
+            return caseSensitive;
+        },
+        get useRegex() {
+            return useRegex;
+        },
+        get matches() {
+            return matches;
+        },
+        get currentIndex() {
+            return currentIndex;
+        },
+        // Setters / actions
+        setQuery,
+        setReplaceText,
+        setCaseSensitive,
+        setUseRegex,
+        updateMatches,
+        findNext,
+        findPrev,
+        replace: doReplace,
+        replaceAll: doReplaceAll,
+        computeMatchRects
+    };
+}

package/dist/components/editor/editor-input.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Editor input handling — keyboard, mouse, clipboard, IME, focus, and measurement.
+ *
+ * Extracted from CustomEditor.svelte to keep the component focused on rendering.
+ * All handlers are created via a factory that receives dependency callbacks so the
+ * module remains framework-agnostic and testable.
+ */
+import type { EditorState, Selection, Cursor } from './core';
+import type { createNavigation, createKeyboardHandler, FoldManager } from './core';
+export interface EditorInputDeps {
+    getEditorState: () => EditorState;
+    getNavigation: () => ReturnType<typeof createNavigation>;
+    getKeyboardHandler: () => ReturnType<typeof createKeyboardHandler>;
+    getFoldManager: () => FoldManager;
+    getEditorContent: () => HTMLDivElement | null;
+    getHiddenInput: () => HTMLTextAreaElement | null;
+    getMeasureSpan: () => HTMLSpanElement | null;
+    isReadonly: () => boolean;
+    isMultiCursor: () => boolean;
+    isFolding: () => boolean;
+    hasMultipleCursors: () => boolean;
+    getSelection: () => Selection;
+    getCursors: () => readonly Cursor[];
+    getScrollPosition: () => {
+        scrollTop: number;
+        scrollLeft: number;
+    };
+    getMeasurements: () => {
+        charWidth: number;
+        lineHeight: number;
+        gutterWidth: number;
+    };
+    /**
+     * Editor tab size (columns per tab stop). Optional for backwards
+     * compatibility; when omitted, DEFAULT_TAB_SIZE is used. Needed so that
+     * mouse hit-testing expands tabs to the correct visual width.
+     */
+    getTabSize?: () => number;
+    onOpenFind: (withReplace: boolean) => void;
+    onCloseFind: () => void;
+    onFindNext: () => void;
+    onFindPrev: () => void;
+    onFoldCurrent: () => void;
+    onUnfoldCurrent: () => void;
+    onFoldAll: () => void;
+    onUnfoldAll: () => void;
+    onSelectNextOccurrence: () => void;
+    onSelectAllOccurrences: () => void;
+    onShowCommandPalette: () => void;
+    onSave: (() => void) | undefined;
+    announce: (message: string) => void;
+    resetCursorBlink: () => void;
+    stopCursorBlink: () => void;
+    setCharWidth: (w: number) => void;
+    setLineHeight: (h: number) => void;
+    setScrollTop: (v: number) => void;
+    setScrollLeft: (v: number) => void;
+    setCursorVisible: (v: boolean) => void;
+    isShowFindReplace: () => boolean;
+    getSearchQuery: () => string;
+    getSearchMatchCount: () => number;
+}
+export declare function createEditorInput(deps: EditorInputDeps): {
+    handleMouseDown: (e: MouseEvent) => void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    handleInput: (e: Event) => void;
+    handlePaste: (e: ClipboardEvent) => void;
+    handleCopy: (e: ClipboardEvent) => void;
+    handleCut: (e: ClipboardEvent) => void;
+    handleScroll: (e: Event) => void;
+    handleFocus: () => void;
+    handleBlur: () => void;
+    handleCompositionStart: () => void;
+    handleCompositionEnd: (e: CompositionEvent) => void;
+    measureCharacter: () => void;
+    cleanupGlobalListeners: () => void;
+};

package/dist/components/editor/editor-input.js

@@ -0,0 +1,445 @@
+/**
+ * Editor input handling — keyboard, mouse, clipboard, IME, focus, and measurement.
+ *
+ * Extracted from CustomEditor.svelte to keep the component focused on rendering.
+ * All handlers are created via a factory that receives dependency callbacks so the
+ * module remains framework-agnostic and testable.
+ */
+import { selectNextOccurrence, selectAllOccurrences } from './editor-multicursor';
+import { CONTENT_PADDING, DEFAULT_FONT_SIZE, LINE_HEIGHT_MULTIPLIER } from './constants';
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/** Fallback tab size used when deps.getTabSize is not provided. */
+const DEFAULT_TAB_SIZE = 4;
+export function createEditorInput(deps) {
+    // ---- internal mutable state ----
+    let isMouseDown = false;
+    let isDragging = false;
+    let isComposing = false;
+    let boundMouseMove = null;
+    let boundMouseUp = null;
+    /**
+     * Map a horizontal pixel offset (relative to the start of the text content,
+     * scroll already applied) to a character column on a line, expanding tabs to
+     * the next tab stop. A tab occupies `tabSize - (visualCol % tabSize)` columns
+     * worth of width. We pick the column whose character boundary is nearest the
+     * target x by tracking the visual width consumed character-by-character.
+     *
+     * Perfect proportional measurement (emoji, CJK wide glyphs) is not attempted;
+     * tabs are the dominant source of mis-clicks and are handled exactly.
+     */
+    function columnFromX(lineText, x, charWidth, tabSize) {
+        if (charWidth <= 0)
+            return 0;
+        if (x <= 0)
+            return 0;
+        let visualCol = 0; // visual column in "cells" (each cell == charWidth px)
+        for (let i = 0; i < lineText.length; i++) {
+            const cellsForChar = lineText[i] === '\t'
+                ? tabSize - (visualCol % tabSize)
+                : 1;
+            const startPx = visualCol * charWidth;
+            const widthPx = cellsForChar * charWidth;
+            // If x falls within the first half of this character's width, the
+            // click belongs to column i; otherwise it moves past it.
+            if (x < startPx + widthPx / 2) {
+                return i;
+            }
+            visualCol += cellsForChar;
+        }
+        return lineText.length;
+    }
+    // ------------------------------------------------------------------
+    // Measurement
+    // ------------------------------------------------------------------
+    function measureCharacter() {
+        const measureSpan = deps.getMeasureSpan();
+        if (!measureSpan)
+            return;
+        measureSpan.textContent = 'M';
+        const rect = measureSpan.getBoundingClientRect();
+        deps.setCharWidth(rect.width || 8);
+        // Use computed line-height from CSS, not character bounding box height
+        const computedStyle = window.getComputedStyle(measureSpan);
+        const computedLineHeight = parseFloat(computedStyle.lineHeight);
+        if (isNaN(computedLineHeight)) {
+            const fontSize = parseFloat(computedStyle.fontSize) || DEFAULT_FONT_SIZE;
+            deps.setLineHeight(Math.ceil(fontSize * LINE_HEIGHT_MULTIPLIER));
+        }
+        else {
+            deps.setLineHeight(Math.ceil(computedLineHeight));
+        }
+    }
+    // ------------------------------------------------------------------
+    // Mouse helpers
+    // ------------------------------------------------------------------
+    function getPositionFromMouse(e) {
+        const editorContent = deps.getEditorContent();
+        if (!editorContent)
+            return { line: 0, column: 0 };
+        const { charWidth, lineHeight, gutterWidth } = deps.getMeasurements();
+        const { scrollTop, scrollLeft } = deps.getScrollPosition();
+        const rect = editorContent.getBoundingClientRect();
+        const x = e.clientX - rect.left - gutterWidth - CONTENT_PADDING;
+        const y = e.clientY - rect.top;
+        const editorState = deps.getEditorState();
+        const line = Math.max(0, Math.min(Math.floor((y + scrollTop) / lineHeight), editorState.lineCount - 1));
+        const lineContent = editorState.getLine(line);
+        const lineText = lineContent?.text ?? '';
+        const tabSize = deps.getTabSize?.() ?? DEFAULT_TAB_SIZE;
+        // Map the pixel offset to a column, expanding tabs to tab stops so that
+        // clicks on lines containing tabs land on the intended character.
+        const column = columnFromX(lineText, x + scrollLeft, charWidth, tabSize);
+        return { line, column };
+    }
+    // ------------------------------------------------------------------
+    // Mouse handlers
+    // ------------------------------------------------------------------
+    function handleMouseDown(e) {
+        if (e.button !== 0)
+            return;
+        e.preventDefault();
+        deps.getHiddenInput()?.focus();
+        isMouseDown = true;
+        isDragging = false;
+        // Attach global listeners only when drag starts (per-instance scoping)
+        if (!boundMouseMove) {
+            boundMouseMove = (ev) => handleMouseMove(ev);
+            boundMouseUp = () => handleMouseUp();
+            window.addEventListener('mousemove', boundMouseMove);
+            window.addEventListener('mouseup', boundMouseUp);
+        }
+        const pos = getPositionFromMouse(e);
+        const editorState = deps.getEditorState();
+        const navigation = deps.getNavigation();
+        if (e.shiftKey) {
+            editorState.extendSelection(pos);
+        }
+        else if (e.altKey && deps.isMultiCursor() && !e.shiftKey) {
+            // Alt+Click - add a new cursor
+            editorState.addCursor(pos);
+        }
+        else if (e.detail === 2) {
+            // Double click - select word
+            editorState.setCursor(pos);
+            navigation.selectWord();
+        }
+        else if (e.detail === 3) {
+            // Triple click - select line
+            editorState.setCursor(pos);
+            navigation.selectLine();
+        }
+        else {
+            editorState.setCursor(pos);
+        }
+    }
+    function handleMouseMove(e) {
+        if (!isMouseDown)
+            return;
+        isDragging = true;
+        const pos = getPositionFromMouse(e);
+        deps.getEditorState().extendSelection(pos);
+    }
+    function handleMouseUp() {
+        isMouseDown = false;
+        isDragging = false;
+        // Remove global listeners when drag ends
+        if (boundMouseMove) {
+            window.removeEventListener('mousemove', boundMouseMove);
+            boundMouseMove = null;
+        }
+        if (boundMouseUp) {
+            window.removeEventListener('mouseup', boundMouseUp);
+            boundMouseUp = null;
+        }
+    }
+    function cleanupGlobalListeners() {
+        if (boundMouseMove) {
+            window.removeEventListener('mousemove', boundMouseMove);
+            boundMouseMove = null;
+        }
+        if (boundMouseUp) {
+            window.removeEventListener('mouseup', boundMouseUp);
+            boundMouseUp = null;
+        }
+    }
+    // ------------------------------------------------------------------
+    // Keyboard
+    // ------------------------------------------------------------------
+    function handleKeyDown(e) {
+        // Don't process keyboard shortcuts during IME composition
+        if (isComposing)
+            return;
+        const isMod = e.ctrlKey || e.metaKey;
+        const editorState = deps.getEditorState();
+        // Find/Replace shortcuts
+        if (isMod && e.key === 'f') {
+            e.preventDefault();
+            deps.onOpenFind(false);
+            return;
+        }
+        if (isMod && e.key === 'h') {
+            e.preventDefault();
+            deps.onOpenFind(true);
+            return;
+        }
+        // Command Palette (Ctrl+Shift+P or Cmd+Shift+P)
+        if (isMod && e.shiftKey && e.key.toLowerCase() === 'p') {
+            e.preventDefault();
+            deps.onShowCommandPalette();
+            return;
+        }
+        if (e.key === 'F3' || (isMod && e.key === 'g')) {
+            e.preventDefault();
+            if (deps.isShowFindReplace() && deps.getSearchMatchCount() > 0) {
+                if (e.shiftKey) {
+                    deps.onFindPrev();
+                }
+                else {
+                    deps.onFindNext();
+                }
+            }
+            else if (deps.getSearchQuery()) {
+                // Re-open find with last query
+                deps.onOpenFind(false);
+            }
+            return;
+        }
+        if (e.key === 'Escape' && deps.isShowFindReplace()) {
+            e.preventDefault();
+            deps.onCloseFind();
+            return;
+        }
+        // Folding shortcuts (Ctrl+Shift+[ and Ctrl+Shift+])
+        if (deps.isFolding() && isMod && e.shiftKey) {
+            if (e.key === '[' || e.code === 'BracketLeft') {
+                e.preventDefault();
+                deps.onFoldCurrent();
+                return;
+            }
+            if (e.key === ']' || e.code === 'BracketRight') {
+                e.preventDefault();
+                deps.onUnfoldCurrent();
+                return;
+            }
+        }
+        // Ctrl+Alt+[ for fold all, Ctrl+Alt+] for unfold all
+        if (deps.isFolding() && isMod && e.altKey && !e.shiftKey) {
+            if (e.key === '[' || e.code === 'BracketLeft') {
+                e.preventDefault();
+                deps.onFoldAll();
+                deps.announce('Collapsed all foldable regions');
+                return;
+            }
+            if (e.key === ']' || e.code === 'BracketRight') {
+                e.preventDefault();
+                deps.onUnfoldAll();
+                deps.announce('Expanded all foldable regions');
+                return;
+            }
+        }
+        // Multi-cursor shortcuts
+        if (deps.isMultiCursor()) {
+            // Escape to clear secondary cursors
+            if (e.key === 'Escape' && deps.hasMultipleCursors()) {
+                e.preventDefault();
+                editorState.clearSecondaryCursors();
+                return;
+            }
+            // Ctrl+Alt+Up/Down to add cursors above/below
+            if (isMod && e.altKey && !e.shiftKey) {
+                if (e.key === 'ArrowUp') {
+                    e.preventDefault();
+                    editorState.addCursorAbove();
+                    return;
+                }
+                if (e.key === 'ArrowDown') {
+                    e.preventDefault();
+                    editorState.addCursorBelow();
+                    return;
+                }
+            }
+            // Ctrl+U to remove last cursor
+            if (isMod && e.key === 'u' && !e.shiftKey && !e.altKey) {
+                e.preventDefault();
+                editorState.removeLastCursor();
+                return;
+            }
+            // Ctrl+D to select next occurrence
+            if (isMod && e.key === 'd' && !e.shiftKey && !e.altKey) {
+                e.preventDefault();
+                selectNextOccurrence(editorState);
+                return;
+            }
+            // Ctrl+Shift+L to select all occurrences
+            if (isMod && e.shiftKey && e.key === 'l') {
+                e.preventDefault();
+                selectAllOccurrences(editorState);
+                return;
+            }
+            // Ctrl+S to save
+            if (isMod && e.key === 's') {
+                e.preventDefault();
+                if (deps.onSave) {
+                    deps.onSave();
+                }
+                return;
+            }
+        }
+        // Let keyboard handler process it
+        const handled = deps.getKeyboardHandler().handleKeyDown(e, deps.isReadonly());
+        if (!handled && !deps.isReadonly() && e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+            // Regular character input - handled by input event
+        }
+    }
+    // ------------------------------------------------------------------
+    // Text input / IME
+    // ------------------------------------------------------------------
+    function handleInput(e) {
+        if (deps.isReadonly())
+            return;
+        // Don't process input during IME composition - wait for compositionend
+        if (isComposing)
+            return;
+        const target = e.target;
+        const inputText = target.value;
+        if (inputText) {
+            deps.getEditorState().insert(inputText);
+            target.value = '';
+        }
+    }
+    function handleCompositionStart() {
+        isComposing = true;
+    }
+    function handleCompositionEnd(e) {
+        isComposing = false;
+        if (deps.isReadonly())
+            return;
+        // Insert the composed text
+        const composedText = e.data;
+        if (composedText) {
+            deps.getEditorState().insert(composedText);
+        }
+        // Clear the hidden input
+        const hiddenInput = deps.getHiddenInput();
+        if (hiddenInput) {
+            hiddenInput.value = '';
+        }
+    }
+    // ------------------------------------------------------------------
+    // Clipboard
+    // ------------------------------------------------------------------
+    function handlePaste(e) {
+        if (deps.isReadonly())
+            return;
+        e.preventDefault();
+        const text = e.clipboardData?.getData('text/plain');
+        if (text) {
+            deps.getEditorState().insert(text);
+        }
+    }
+    function handleCopy(e) {
+        e.preventDefault();
+        const editorState = deps.getEditorState();
+        const selection = deps.getSelection();
+        const cursors = deps.getCursors();
+        // Multi-cursor: if any cursor has a selection, copy from all cursors
+        if (editorState.hasAnySelection) {
+            const text = editorState.getSelectedTextFromAllCursors();
+            e.clipboardData?.setData('text/plain', text);
+        }
+        else if (deps.hasMultipleCursors()) {
+            // Multiple cursors with no selection: copy line at each cursor
+            const lines = cursors.map(c => editorState.getLine(c.selection.head.line)?.text ?? '');
+            e.clipboardData?.setData('text/plain', lines.join('\n') + '\n');
+        }
+        else {
+            // Single cursor with no selection: copy the entire current line
+            const line = editorState.getLine(selection.head.line);
+            const lineText = (line?.text ?? '') + '\n';
+            e.clipboardData?.setData('text/plain', lineText);
+        }
+    }
+    function handleCut(e) {
+        if (deps.isReadonly())
+            return;
+        e.preventDefault();
+        const editorState = deps.getEditorState();
+        const selection = deps.getSelection();
+        const cursors = deps.getCursors();
+        // Multi-cursor: if any cursor has a selection, cut from all cursors
+        if (editorState.hasAnySelection) {
+            const text = editorState.getSelectedTextFromAllCursors();
+            e.clipboardData?.setData('text/plain', text);
+            editorState.deleteSelection();
+        }
+        else if (deps.hasMultipleCursors()) {
+            // Multiple cursors with no selection: cut line at each cursor
+            const lines = cursors.map(c => editorState.getLine(c.selection.head.line)?.text ?? '');
+            e.clipboardData?.setData('text/plain', lines.join('\n') + '\n');
+            // Select and delete each line (in reverse order to maintain positions)
+            const sortedCursors = [...cursors].sort((a, b) => b.selection.head.line - a.selection.head.line);
+            for (const cursor of sortedCursors) {
+                const lineNum = cursor.selection.head.line;
+                const line = editorState.getLine(lineNum);
+                const lineStart = { line: lineNum, column: 0 };
+                const lineEnd = lineNum < editorState.lineCount - 1
+                    ? { line: lineNum + 1, column: 0 }
+                    : { line: lineNum, column: line?.text.length ?? 0 };
+                editorState.cursorManager.setSelection(cursor.id, lineStart, lineEnd);
+            }
+            editorState.deleteSelection();
+        }
+        else {
+            // Single cursor with no selection: cut the entire current line
+            const lineNum = selection.head.line;
+            const line = editorState.getLine(lineNum);
+            const lineText = (line?.text ?? '') + '\n';
+            e.clipboardData?.setData('text/plain', lineText);
+            // Delete the entire line
+            const lineStart = { line: lineNum, column: 0 };
+            const lineEnd = lineNum < editorState.lineCount - 1
+                ? { line: lineNum + 1, column: 0 }
+                : { line: lineNum, column: line?.text.length ?? 0 };
+            editorState.setSelection(lineStart, lineEnd);
+            editorState.deleteSelection();
+        }
+    }
+    // ------------------------------------------------------------------
+    // Scroll
+    // ------------------------------------------------------------------
+    function handleScroll(e) {
+        const target = e.target;
+        deps.setScrollTop(target.scrollTop);
+        deps.setScrollLeft(target.scrollLeft);
+    }
+    // ------------------------------------------------------------------
+    // Focus
+    // ------------------------------------------------------------------
+    function handleFocus() {
+        deps.resetCursorBlink();
+    }
+    function handleBlur() {
+        deps.stopCursorBlink();
+        deps.setCursorVisible(false);
+    }
+    // ------------------------------------------------------------------
+    // Public API
+    // ------------------------------------------------------------------
+    return {
+        handleMouseDown,
+        handleKeyDown,
+        handleInput,
+        handlePaste,
+        handleCopy,
+        handleCut,
+        handleScroll,
+        handleFocus,
+        handleBlur,
+        handleCompositionStart,
+        handleCompositionEnd,
+        measureCharacter,
+        cleanupGlobalListeners
+    };
+}

package/dist/components/editor/editor-multicursor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Multi-cursor selection helpers extracted from CustomEditor.
+ * Pure functions that operate on EditorState.
+ */
+import type { EditorState, Position } from './core';
+/**
+ * Get word at cursor position
+ */
+export declare function getWordAtPosition(state: EditorState, pos: Position): {
+    text: string;
+    start: Position;
+    end: Position;
+} | null;
+/**
+ * Select next occurrence of current word/selection (Ctrl+D)
+ */
+export declare function selectNextOccurrence(state: EditorState): void;
+/**
+ * Select all occurrences of current word/selection (Ctrl+Shift+L)
+ */
+export declare function selectAllOccurrences(state: EditorState): void;