@inkami/blx 0.17.3

package/dist/editor.d.ts

@@ -0,0 +1,864 @@
+import type { Block, BlockJSON } from "./types";
+import { AttributedString } from "./attributed-string";
+import type { Attributes } from "./attributed-string";
+import { EventBus } from "./event-bus";
+import type { EditorEventMap, ThemeMode } from "./event-bus";
+import { SchemaRegistry } from "./schema";
+import type { BlockTypePlugin } from "./schema";
+import type { TransactionResult } from "./transaction";
+import type { SlashMenuItem } from "./slash-menu";
+import type { AutoCompleteProvider } from "./autocomplete";
+import type { DateSuggestion } from "./date-picker";
+import type { ToolbarButton } from "./inline-toolbar";
+import type { BlockActionMenuEntry } from "./block-action-menu";
+import type { KeybindingMap } from "./keybindings";
+import type { BlockViewportOptions } from "./viewport";
+import { CrdtLog } from "./crdt/crdt-log";
+import { AutomergeSync } from "./crdt/automerge-sync";
+import type { AutomergeSyncOptions } from "./crdt/automerge-sync";
+import type { CrdtPeer, RemoteCursor, CrdtOperation } from "./crdt/types";
+import type { FoldState } from "./fold";
+import { CommandRegistry, type ExternalCommandEntry } from "./commands/command-registry";
+import type { BlockContextMenuEntry } from "./block-context-menu";
+/**
+ * Provider that supplies date suggestions for the @ agenda trigger.
+ * Register via `editor.setDateSuggestionProvider()`.
+ */
+export interface DateSuggestionProvider {
+    /** Parse a natural language query and return date suggestions. */
+    suggest(query: string): DateSuggestion[];
+}
+export interface ExternalKeybinding {
+    /** Key sequence descriptor, e.g. `" ,a"` for leader+a. */
+    keys: string;
+    /** Unique command ID for the action. */
+    commandId: string;
+    /** Handler invoked when the key sequence is matched. */
+    handler: () => void;
+}
+export interface EditorOptions {
+    schema?: SchemaRegistry;
+    eventBus?: EventBus<EditorEventMap>;
+    defaultPlugins?: boolean;
+    initialBlocks?: Block[];
+    /**
+     * Custom URL resolver for link hrefs. Receives the raw URL from the
+     * content model and should return a fully-qualified URL.
+     *
+     * Default: prepends `https://` to URLs that lack a protocol and don't
+     * look like internal references (`#`, `/`, `mailto:`, `tel:`).
+     */
+    resolveUrl?: (url: string) => string;
+    /**
+     * Auto-focus the last block when typing occurs while no block is focused.
+     * The `editor:unfocusedInput` event is emitted regardless of this setting.
+     */
+    autoFocusOnInput?: boolean;
+    /**
+     * Custom keybinding map. Partial overrides are merged with the defaults.
+     */
+    keybindings?: Partial<KeybindingMap>;
+    /**
+     * Color theme. `"system"` (default) follows `prefers-color-scheme`,
+     * `"light"` / `"dark"` forces a specific theme.
+     */
+    theme?: ThemeMode;
+    /**
+     * Handler for inline link clicks. Called when a user activates a link
+     * (Cmd/Ctrl+Click on desktop, double-tap on mobile). If not provided,
+     * links open in a new tab via `window.open()`.
+     *
+     * Return `true` to indicate the click was handled; the default
+     * `window.open` will be suppressed.
+     */
+    onLinkClick?: (href: string, resolvedHref: string, event: MouseEvent) => boolean | void;
+    /**
+     * Called after a blockRef span is rendered. Use to add CSS classes or
+     * data attributes for app-specific styling (e.g. broken-link indicators).
+     */
+    onBlockRefRender?: (element: HTMLElement, refId: string) => void;
+    /**
+     * Transform pasted plain text before BLX processes it.
+     * Return an object to replace the paste with marked text, or null/undefined
+     * for default handling.
+     */
+    transformPastedText?: (text: string) => {
+        text: string;
+        attributes: Attributes;
+    } | null;
+    /**
+     * Options for the virtual rendering viewport. When enabled, only blocks
+     * visible in the viewport (plus a buffer zone) have their content rendered
+     * in the DOM. Off-screen blocks keep lightweight placeholder containers
+     * for scroll stability.
+     *
+     * Set to `false` to disable virtual rendering entirely (all blocks are
+     * always rendered). Enabled by default.
+     */
+    viewport?: BlockViewportOptions | false;
+    /** Callback when fold state changes. Host should persist this. */
+    onFoldChanged?: (state: FoldState) => void;
+    /** Initial fold state to restore. */
+    initialFoldState?: FoldState;
+    /**
+     * An outer container element (e.g. the scroll host) that should also
+     * respond to clicks by focusing the nearest block. Clicks inside the
+     * editor root are ignored (handled by the editor's own mousedown).
+     */
+    clickContainer?: HTMLElement;
+}
+export interface EditorJSON {
+    blocks: BlockJSON[];
+}
+export declare class Editor {
+    readonly root: HTMLElement;
+    readonly content: HTMLElement;
+    readonly gutter: HTMLElement;
+    readonly blocksContainer: HTMLElement;
+    readonly schema: SchemaRegistry;
+    readonly bus: EventBus<EditorEventMap>;
+    readonly commands: CommandRegistry;
+    private controllers;
+    private controllerMap;
+    /** Sticky X position for consecutive ArrowUp/ArrowDown navigation */
+    private goalX;
+    /** Block selection state */
+    private blockSelectAnchor;
+    private blockSelectFocus;
+    private editorMode;
+    /** Whether visual block mode persists without Shift (true = vim V, false = shift-arrow transient) */
+    private visualBlockSticky;
+    /** Last action that mutated blocks — replayed by the dot (.) command */
+    private lastRepeatableAction;
+    /** Actions that count as repeatable mutations (navigation, mode changes, etc. are excluded) */
+    private static readonly REPEATABLE_ACTIONS;
+    /** Slash command menu */
+    private slashMenu;
+    private slashMenuBlockId;
+    private slashCommandOffset;
+    private slashMenuKeyHandler;
+    private customSlashHandlers;
+    private customSlashItems;
+    /** Emoji picker */
+    private emojiPicker;
+    private emojiBlockId;
+    private emojiColonOffset;
+    private emojiKeyHandler;
+    /** Agenda date picker (@) */
+    private agendaPicker;
+    private agendaBlockId;
+    private agendaAtOffset;
+    private agendaKeyHandler;
+    private dateSuggestionProvider;
+    /** Autocomplete menu ([[) */
+    private autoCompleteMenu;
+    private autoCompleteBlockId;
+    private autoCompleteBracketOffset;
+    private autoCompleteKeyHandler;
+    private autoCompleteProviders;
+    /** Drag handle */
+    private dragHandle;
+    /** Inline formatting toolbar */
+    private inlineToolbar;
+    private selectionChangeHandler;
+    private _toolbarDebounceTimer;
+    private _mouseDown;
+    private _onMouseDown;
+    private _onMouseUp;
+    private formatKeyHandler;
+    private floatingScroll;
+    /** Controller with active pending marks (for clearing when focus moves) */
+    private _pendingMarksCtrl;
+    /** Block ID force-mounted because it has an active text selection */
+    private selectionForceMountedId;
+    /** Mouse drag → block selection */
+    private mouseDragAnchorBlockId;
+    private mouseDragActive;
+    /** Saved text cursor offset within the anchor block when entering block selection */
+    private mouseDragAnchorOffset;
+    /** Auto-scroll during drag */
+    private dragScrollRAF;
+    private _lastDragMouseX;
+    private _lastDragMouseY;
+    /** Block action menu */
+    private blockActionMenu;
+    private customCaret;
+    private customActionItems;
+    /** Right-click context menu */
+    private blockContextMenu;
+    private customContextItems;
+    /** Link popover */
+    private linkPopover;
+    /** Highlight picker */
+    private highlightPicker;
+    /** URL hash navigation handler (bound for cleanup) */
+    private hashChangeHandler;
+    /** Mobile double-tap tracking for link activation */
+    private lastTapTarget;
+    private lastTapTime;
+    /** Search panel */
+    private searchEngine;
+    private searchUI;
+    private searchKeyHandler;
+    /** All current search matches (for dim highlighting) */
+    private searchMatches;
+    /** Index of the currently focused search match (for bright highlighting) */
+    private searchCurrentMatch;
+    /** Drop zone indicator for external image drag-drop */
+    private imageDropZone;
+    /** Full-editor overlay shown when dragging unsupported files */
+    private dropRejectOverlay;
+    /** Focused non-text block (image, youtube, etc.) */
+    private focusedNonTextBlockId;
+    private nonTextKeyHandler;
+    /** Editor options (stored for runtime checks) */
+    private options;
+    /** Outer click container for focus-on-click outside the editor root */
+    private clickContainer;
+    /** Current theme mode */
+    private themeMode;
+    /** Keybinding map and sequencer for block selection mode */
+    private keybindings;
+    private keySequencer;
+    /** Handlers registered by the host app via registerKeybindings(). */
+    private externalActions;
+    /** Undo/redo history */
+    private undoManager;
+    /** When true, mutations are not recorded in undo history (used during undo/redo) */
+    private _suppressHistory;
+    /** Navigation jumplist (Ctrl-O / Ctrl-I) */
+    private jumpList;
+    /** Last block that had focus (for jumplist tracking) */
+    private _lastFocusedBlockId;
+    /** Last edit position for g,. navigation */
+    private _lastEditPosition;
+    /** Cursor position saved before an overlay (search, link popover, etc.) steals focus */
+    private _preOverlayCursor;
+    /** Keyboard handler for undo/redo and jump shortcuts */
+    private undoKeyHandler;
+    /** CRDT operation log (null until enabled) */
+    private crdtLog;
+    /** Replay state */
+    private _replayActive;
+    private _replayPosition;
+    private _replaySavedState;
+    private _replayUI;
+    private _replayTimer;
+    private _replaySpeed;
+    /** Multiplayer peer tracking */
+    private _localPeer;
+    private _peers;
+    private _remoteCursors;
+    private _remoteCursorRenderScheduled;
+    private _cursorScrollCleanup;
+    private _cursorIdleTimers;
+    /** Automerge CRDT sync adapter (null until enabled) */
+    private _automergeSync;
+    /** Heading fold manager */
+    private foldManager;
+    /** Table of contents navigation widget */
+    private toc;
+    /** Virtual rendering viewport manager */
+    private viewport;
+    constructor(root: HTMLElement, options?: EditorOptions);
+    /**
+     * Fast path for loading the initial set of blocks. Bypasses the per-block
+     * overhead of addBlock() — no events emitted, no undo history, no
+     * individual DOM insertions. All containers are appended via a single
+     * DocumentFragment and viewport registration is batched.
+     */
+    private loadInitialBlocks;
+    /**
+     * Replace all blocks in a single batch operation. Destroys existing
+     * controllers and bulk-loads the new set via DocumentFragment.
+     * Used by AutomergeSync.applyDocToEditor() to avoid per-block overhead
+     * on full document reload.
+     * @internal
+     */
+    replaceAllBlocks(blocks: Block[]): void;
+    addBlock(blockOrType?: Block | string, index?: number): Block;
+    removeBlock(id: string): boolean;
+    moveBlock(id: string, toIndex: number): boolean;
+    /**
+     * Import an array of blocks into the editor, appending after existing content.
+     * The entire import is treated as a single compound undo entry so the user
+     * can undo the import in one step.
+     *
+     * @param blocks - Serialized blocks to import
+     * @returns The created Block instances
+     */
+    importBlocks(blocks: ReadonlyArray<BlockJSON>): Block[];
+    /**
+     * Paste blocks at the current cursor position.
+     * Splits the focused block at the cursor and inserts the given blocks
+     * between the two halves. The entire operation is a single undo entry.
+     *
+     * If the first pasted block is a paragraph, its content merges into the
+     * end of the "before" half (avoids an awkward empty line). Similarly,
+     * if the last pasted block is a paragraph, its content merges into the
+     * start of the "after" half.
+     *
+     * Falls back to importBlocks() when no block is focused.
+     */
+    pasteBlocks(blocks: ReadonlyArray<BlockJSON>): Block[];
+    /**
+     * Move multiple blocks as a group to a new position, preserving their
+     * internal order. `toIndex` is the target position in the array after
+     * all the blocks have been removed.
+     */
+    moveBlocks(blockIds: string[], toIndex: number): boolean;
+    /** Get currently selected block IDs, or null if no selection */
+    private getSelectedBlockIds;
+    /** Move a completed task to the bottom of consecutive checklist blocks */
+    private moveCompletedChecklistToBottom;
+    /** Move an unchecked task (and its nested children) above the first checked sibling */
+    private moveUncheckedTaskToTop;
+    /** Set checked state on all nested checklist children of a toggled task */
+    private cascadeChecklistToggle;
+    private toggleChecklist;
+    private cycleTaskStatus;
+    private setTaskStatusExplicit;
+    private removeTaskStatus;
+    /** Block types that support agenda dates (have badge rendering). */
+    static readonly AGENDA_BLOCK_TYPES: Set<string>;
+    private openAgendaPickerForBlock;
+    getBlock(id: string): Block | undefined;
+    getBlocks(): ReadonlyArray<Block>;
+    getBlockAt(index: number): Block | undefined;
+    getBlockIndex(id: string): number;
+    getBlockCount(): number;
+    changeBlockType(id: string, newType: string, metadata?: Record<string, unknown>): boolean;
+    /**
+     * Focus the block nearest to the given viewport coordinates.
+     * If the point is below the last block, focuses or creates an empty
+     * paragraph at the end.
+     */
+    focusAtPoint(clientX: number, clientY: number): void;
+    private focusOrCreateAtEnd;
+    focusBlock(id: string, offset?: number): void;
+    /** Focus a block and select the text range [start, end). */
+    private selectBlockRange;
+    /**
+     * Scroll a block into view and optionally focus it.
+     * Returns `true` if the block was found.
+     */
+    scrollToBlock(id: string, focus?: boolean): boolean;
+    /**
+     * Focus the block whose container is closest to the given click point.
+     * Used when a click lands in the editor but outside any block element.
+     */
+    private focusNearestBlock;
+    /**
+     * Handle a click that landed outside any block element.
+     * If the click is below the last block, create a new empty paragraph
+     * (or focus the existing empty last block). Otherwise focus the nearest block.
+     */
+    private handleEmptyAreaClick;
+    registerBlockType(plugin: BlockTypePlugin): void;
+    /** Register a custom slash menu item with a handler. */
+    addSlashMenuItem(item: SlashMenuItem, handler: (blockId: string) => void): void;
+    /**
+     * Add a custom button to the inline formatting toolbar.
+     *
+     * Buttons with an `attribute` field act as simple toggles (the editor
+     * applies/removes the attribute via transactions automatically).
+     *
+     * Buttons with an `onAction` callback receive a `ToolbarActionContext`
+     * and can implement arbitrary behavior (open a popover, apply complex
+     * formatting, etc.).
+     *
+     * Plugin buttons appear after a separator, to the right of the
+     * built-in formatting buttons.
+     *
+     * @example
+     * // Simple attribute toggle
+     * editor.addToolbarButton({
+     *   key: "highlight",
+     *   label: "Highlight",
+     *   icon: "H",
+     *   attribute: "highlight",
+     * });
+     *
+     * @example
+     * // Custom action with render function
+     * editor.addToolbarButton({
+     *   key: "link",
+     *   label: "Link",
+     *   icon: (container) => { container.textContent = "🔗"; },
+     *   onAction: (ctx) => showLinkDialog(ctx),
+     *   isActive: (ctx) => !!ctx.activeAttributes.href,
+     * });
+     */
+    addToolbarButton(button: ToolbarButton): void;
+    /**
+     * Remove a previously-added custom toolbar button by key.
+     * Returns `true` if the button was found and removed.
+     */
+    removeToolbarButton(key: string): boolean;
+    /** Add a custom item to the block action context menu. */
+    addBlockActionItem(entry: BlockActionMenuEntry): void;
+    /** Remove a custom block action item by key. Returns true if found. */
+    removeBlockActionItem(key: string): boolean;
+    /** Return all registered commands with execute handlers for external integration. */
+    getCommands(): ExternalCommandEntry[];
+    toJSON(): EditorJSON;
+    static fromJSON(root: HTMLElement, json: EditorJSON, options?: EditorOptions): Editor;
+    /**
+     * Set the color theme. `"system"` follows `prefers-color-scheme`,
+     * `"light"` / `"dark"` forces a specific theme.
+     */
+    setTheme(mode: ThemeMode): void;
+    /** Return the current theme mode. */
+    getTheme(): ThemeMode;
+    /** Undo the last action. Returns true if an entry was undone. */
+    undo(): boolean;
+    /** Redo the last undone action. Returns true if an entry was redone. */
+    redo(): boolean;
+    /** Whether there are entries to undo */
+    canUndo(): boolean;
+    /** Whether there are entries to redo */
+    canRedo(): boolean;
+    /** Execute a function with history recording suppressed. */
+    withSuppressedHistory(fn: () => void): void;
+    /** Clear all undo/redo history */
+    clearHistory(): void;
+    /** Toggle fold on a heading block */
+    toggleFold(headingBlockId: string): void;
+    /** Fold a heading section */
+    foldBlock(headingBlockId: string): void;
+    /** Unfold a heading section */
+    unfoldBlock(headingBlockId: string): void;
+    /** Fold all headings */
+    foldAll(): void;
+    /** Unfold all headings */
+    unfoldAll(): void;
+    /** Check if a heading is folded */
+    isFolded(headingBlockId: string): boolean;
+    /** Check if a block is hidden by a fold */
+    isBlockHidden(blockId: string): boolean;
+    /** Load fold state (e.g. from localStorage on document open) */
+    loadFoldState(state: FoldState): void;
+    /** Get current fold state for persistence */
+    getFoldState(): FoldState;
+    private applyFoldVisibility;
+    /**
+     * Navigate backwards in the jumplist (Ctrl-O).
+     * Returns true if a jump was performed.
+     */
+    jumpBack(): boolean;
+    /**
+     * Navigate forwards in the jumplist (Ctrl-I).
+     * Returns true if a jump was performed.
+     */
+    jumpForward(): boolean;
+    /**
+     * Jump to the last edit position.
+     * Records current position in jumplist, then focuses the last edit.
+     * Returns true if a jump was performed.
+     */
+    jumpToLastEdit(): boolean;
+    /** Record the current cursor position in the jumplist before a jump */
+    recordJump(): void;
+    /** Whether there are entries to jump back to */
+    canJumpBack(): boolean;
+    /** Whether there are entries to jump forward to */
+    canJumpForward(): boolean;
+    /**
+     * Enable CRDT operation logging. Captures the current editor state as
+     * the initial snapshot and begins recording every subsequent edit.
+     * Returns the log instance.
+     */
+    enableCrdtLog(): CrdtLog;
+    /** Get the CRDT log, or null if not enabled */
+    getCrdtLog(): CrdtLog | null;
+    /** Whether replay mode is currently active */
+    get isReplayActive(): boolean;
+    /**
+     * Show the replay bar UI at the bottom of the editor.
+     * Automatically enables the CRDT log if not already enabled.
+     */
+    showReplayUI(): void;
+    /** Hide the replay bar UI */
+    hideReplayUI(): void;
+    /** Enter replay mode: save state, disable editing */
+    private enterReplayMode;
+    /** Exit replay mode: restore saved state, re-enable editing */
+    private exitReplayMode;
+    /** Seek to a specific position in the CRDT log */
+    private replaySeekTo;
+    /** Render peer cursors based on the current replay position */
+    private renderReplayCursors;
+    /** Step one operation forward in replay */
+    private replayStepForward;
+    /** Step one operation backward in replay */
+    private replayStepBackward;
+    /** Start auto-playing operations */
+    private replayPlay;
+    /** Pause auto-play */
+    private replayPause;
+    /** Apply a single CRDT operation in the given direction */
+    private applyCrdtOperation;
+    /**
+     * Replace all blocks in the editor with the given block state.
+     * Used by replay to restore state on exit.
+     */
+    private loadBlockState;
+    /**
+     * Set the local peer identity. All subsequent CRDT operations will be
+     * tagged with this peer ID. Call this before users start editing.
+     */
+    setLocalPeer(peer: CrdtPeer): void;
+    /** Get the local peer, or null if not set */
+    getLocalPeer(): CrdtPeer | null;
+    /**
+     * Register a remote peer. Their cursor will be rendered when
+     * `setRemoteCursor()` is called.
+     */
+    addPeer(peer: CrdtPeer): void;
+    /** Remove a remote peer and their cursor */
+    removePeer(peerId: string): void;
+    /** Get all registered peers (including local) */
+    getPeers(): CrdtPeer[];
+    /**
+     * Update a remote peer's cursor position. Pass null blockId to hide the cursor.
+     * When endOffset is provided and differs from offset, a selection highlight is rendered.
+     */
+    setRemoteCursor(peerId: string, blockId: string | null, offset?: number, endOffset?: number, endBlockId?: string): void;
+    /** Get all current remote cursor positions */
+    getRemoteCursors(): RemoteCursor[];
+    /**
+     * Apply a remote peer's operation to the editor.
+     * This applies the operation, records it in the CRDT log, and updates
+     * the remote peer's cursor to the operation's afterCursor.
+     */
+    applyRemoteOperation(op: CrdtOperation): void;
+    /** Schedule a microtask to render remote cursors (batches rapid updates) */
+    private scheduleRemoteCursorRender;
+    /** Render remote cursors into all blocks that have them */
+    private renderAllRemoteCursors;
+    /**
+     * Compute all peer cursor positions at a given replay position by
+     * replaying the operation log. Returns the last known cursor for
+     * each peer up to that point.
+     */
+    private computeReplayCursors;
+    /**
+     * Enable Automerge CRDT sync. Returns the AutomergeSync instance
+     * which provides the sync protocol API (generateSyncMessage,
+     * receiveSyncMessage, merge, save/load, etc.).
+     *
+     * Calling this multiple times returns the same instance.
+     */
+    enableAutomerge(options?: AutomergeSyncOptions): AutomergeSync;
+    /** Get the AutomergeSync instance, or null if not enabled */
+    getAutomergeSync(): AutomergeSync | null;
+    /**
+     * Update a block's content, metadata, and optionally type.
+     * Suppresses undo history and re-renders with cursor preservation.
+     * Used by AutomergeSync for remote changes and by consumers for
+     * streaming / progressive content updates.
+     */
+    updateBlockContent(blockId: string, content: AttributedString, metadata?: Record<string, unknown>, blockType?: string): void;
+    /**
+     * Apply a single undo action in the given direction.
+     * Called with _suppressHistory = true.
+     */
+    private applyUndoAction;
+    /** Record a single undo action (delegates to compound group if active) */
+    private recordUndoAction;
+    /** Create a snapshot of a block for undo storage */
+    private snapshotBlock;
+    /** Get the current cursor state, or null if nothing is focused */
+    private getCursorState;
+    /** Save the current cursor so it can be restored after an overlay is dismissed. */
+    saveOverlayCursor(): void;
+    /** Restore focus to the position saved before an overlay opened, then clear it. */
+    restoreOverlayCursor(): void;
+    /** Emit historyChanged event with current canUndo/canRedo state */
+    private emitHistoryChanged;
+    /** Listen to block:contentChanged to record transaction-based content changes */
+    private setupUndoContentListener;
+    /** Set up keyboard shortcuts for undo/redo and navigation history */
+    private setupUndoShortcuts;
+    /** Track block focus changes for the jumplist */
+    private setupJumpListTracking;
+    /** Re-render remote cursors after any DOM change (content, add, remove) and on scroll */
+    private setupRemoteCursorRefresh;
+    /** @internal Apply a pre-computed transaction result to a block */
+    applyTransactionToBlock(blockId: string, result: TransactionResult): void;
+    private registerBuiltInCommands;
+    destroy(): void;
+    private setupHashNavigation;
+    private navigateToHash;
+    /** Unsub callbacks for ToC event subscriptions */
+    private tocUnsubs;
+    private setupTableOfContents;
+    private setupEventHandlers;
+    private handleClickContainerMouseDown;
+    private handleMouseDown;
+    private handleMouseDrag;
+    /**
+     * Detect the block under the given viewport coordinates and update
+     * selection. Called from both mousemove (with event) and the auto-scroll
+     * RAF tick (without event).
+     */
+    private updateDragBlockUnderMouse;
+    /** Find the nearest scrollable ancestor of the editor root. */
+    private findScrollParent;
+    /** Start a RAF loop that auto-scrolls when the mouse is near viewport edges. */
+    private startDragAutoScroll;
+    /** Stop the drag auto-scroll RAF loop. */
+    private stopDragAutoScroll;
+    /**
+     * Re-focus the anchor block and create a text selection from the saved
+     * anchor offset to the position under the mouse cursor.
+     */
+    private restoreDragSelection;
+    /**
+     * Walk text nodes within a container and find the DOM node + offset
+     * for a given character offset.
+     */
+    private findTextPosition;
+    private handleMouseDragEnd;
+    private handleSplit;
+    private handleMerge;
+    private handleFocusNavigation;
+    private static MAX_INDENT_LEVEL;
+    private handleIndent;
+    private handleOutdent;
+    /** Enter normal mode on a single block (Escape from editing) */
+    private enterNormalMode;
+    /** Enter visual block mode from normal mode (v key or shift+arrow) */
+    private enterVisualBlockMode;
+    /** Enter visual block mode from insert mode (Shift+Arrow, mouse drag) */
+    private enterVisualBlockFromInsert;
+    /** Calculate the approximate number of blocks that fit in a page (viewport) */
+    private calculatePageJump;
+    /** Handle PageUp/PageDown — jump focus by approximately one viewport of blocks */
+    private handlePageJump;
+    /** Select all blocks (enter visual block mode spanning first to last) */
+    private selectAllBlocks;
+    /** Move a block up or down by one position */
+    private handleBlockMove;
+    private handleBlockSelectTo;
+    /** Action dispatch map for normal mode keybindings (single-block) */
+    private get normalModeActions();
+    /** Action dispatch map for visual block mode keybindings (multi-block) */
+    private get visualBlockModeActions();
+    private handleEditorKeyDown;
+    /**
+     * Handle keyboard input when no block is focused.
+     * Emits `editor:unfocusedInput` and optionally auto-focuses the last block.
+     */
+    private handleUnfocusedInput;
+    private deleteBlockSelection;
+    private buildMultiBlockSelection;
+    private applyBlockSelectionCSS;
+    private clearBlockSelectionCSS;
+    /** Exit to insert mode and focus a block */
+    private exitToInsertMode;
+    /** Exit to insert mode without focusing any block */
+    private exitToInsertModeSilent;
+    /** Exit visual block mode back to normal mode (Escape or v from visual) */
+    private exitVisualBlockToNormal;
+    /** Set editor mode and update CSS classes on root */
+    private setMode;
+    /** @internal Whether the editor is in block selection mode (normal or visual block) */
+    get isBlockSelecting(): boolean;
+    /** @internal Get the current editor mode */
+    get mode(): "insert" | "normal" | "visualBlock";
+    private openOrUpdateSlashMenu;
+    private closeSlashMenu;
+    private handleSlashMenuSelect;
+    private openOrUpdateEmojiPicker;
+    private closeEmojiPicker;
+    private commitEmoji;
+    /**
+     * Register a provider that supplies date suggestions when the user types
+     * after `@`. If no provider is set, the @ trigger shows only the calendar.
+     */
+    setDateSuggestionProvider(provider: DateSuggestionProvider): void;
+    /** Remove the date suggestion provider. */
+    removeDateSuggestionProvider(): void;
+    /**
+     * Register additional keybindings from the host application.
+     * Each binding adds a key sequence to the normal-mode binding map
+     * and registers its handler so the editor can dispatch it.
+     */
+    registerKeybindings(bindings: ExternalKeybinding[]): void;
+    /** Pass the current query to the date suggestion provider and update the picker. */
+    private updateAgendaSearch;
+    setBlockAgenda(blockId: string, role: "due" | "scheduled" | "event", date: string | null, recurrence?: {
+        interval: number;
+        unit: string;
+        anchor?: string;
+        fromCompletion?: boolean;
+    } | null): void;
+    /** @deprecated Use `setBlockAgenda` instead. */
+    setBlockRecurrence(blockId: string, recurrence: {
+        interval: number;
+        unit: string;
+        anchor?: string;
+        fromCompletion?: boolean;
+    } | null): void;
+    /** @deprecated Use `setBlockAgenda(blockId, "due", date)` instead. */
+    setBlockAgendaDate(blockId: string, agendaDate: string | null): void;
+    /** @deprecated Use `setBlockAgenda(blockId, role, null)` instead. */
+    removeBlockAgendaDate(blockId: string): void;
+    /** Open the date picker for a new agenda item (triggered by `@` in text) */
+    private openAgendaPicker;
+    /** Open the date picker for editing an existing agenda item (triggered by badge/label click) */
+    private openAgendaPickerForEdit;
+    private ensureAgendaPicker;
+    private registerAgendaScrollAndKeys;
+    private closeAgendaPicker;
+    private commitAgendaDate;
+    /**
+     * Register an autocomplete provider that supplies entries when `[[` is typed.
+     * Multiple providers can be registered; results are merged in order.
+     */
+    addAutoCompleteProvider(provider: AutoCompleteProvider): void;
+    /** Remove a previously-registered autocomplete provider by id. */
+    removeAutoCompleteProvider(id: string): boolean;
+    private openOrUpdateAutoComplete;
+    /** Search headings in the current document. */
+    private searchDocumentHeadings;
+    private commitAutoComplete;
+    private closeAutoComplete;
+    private linkClickHandler;
+    private touchEndHandler;
+    private blockRefHoverHandler;
+    private blockRefHoverEndHandler;
+    private setupLinkClickHandler;
+    private teardownLinkClickHandler;
+    /**
+     * Open a link, delegating to the consumer's `onLinkClick` callback if set.
+     * Falls back to `window.open()` in a new tab.
+     */
+    private activateLink;
+    /**
+     * Handle a click on a blockRef pill.
+     * Scrolls to the referenced block by default.
+     * Emits `blockRef:click` so external consumers can also react.
+     */
+    private activateBlockRef;
+    /** Returns true when two taps on the same element occur within 400ms. */
+    private isDoubleTap;
+    private setupInlineToolbar;
+    private setupLinkButton;
+    private showLinkPopover;
+    private _linkContext;
+    private applyLinkToSelection;
+    private removeLinkFromSelection;
+    private _highlightContext;
+    private setupHighlightButton;
+    private showHighlightPicker;
+    private applyHighlightToSelection;
+    private removeHighlightFromSelection;
+    private teardownInlineToolbar;
+    private handleSelectionChange;
+    /**
+     * Force-mount the block that owns the active text selection so the
+     * viewport never unloads it. Release the previous force-mount when
+     * the selection moves or collapses.
+     */
+    private updateSelectionForceMount;
+    private handleFormatKeyDown;
+    /** Apply inline formatting to the current selection */
+    private applyInlineFormat;
+    /** Apply inline formatting to a table cell via metadata */
+    private applyFormatToTableCell;
+    /** Clear pending marks from the tracked controller */
+    private clearPendingMarks;
+    private applyFormatToController;
+    /**
+     * Get the attributes that are common across the entire selection range.
+     * An attribute is "active" only if every character in the range has it.
+     * Checks all attribute keys used by registered toolbar buttons.
+     */
+    private getSelectionAttributes;
+    /** Get the selection range (start, end) within a block controller's content */
+    private getControllerSelectionRange;
+    /** Restore a text selection after re-rendering */
+    private restoreSelection;
+    /**
+     * Get attributes common across a selection range within an array of spans.
+     * Used for table cells where content is in metadata, not block content.
+     */
+    private getAttributesFromSpans;
+    /** Restore selection in a table cell after re-render */
+    private restoreTableCellSelection;
+    /** Get the block ID of the currently focused block, or null */
+    private getFocusedBlockId;
+    /** Find the BlockController that contains the given DOM node */
+    private findControllerForNode;
+    private getActionTargetBlockIds;
+    /** Map a conversion target (type + metadata) to a lucide icon HTML string */
+    private static convertTargetIcon;
+    /** Returns true if a key descriptor is a non-vim binding (modifier combos or named keys). */
+    private static isNonVimKey;
+    /** Format a key descriptor as a human-readable OS-aware hint string. */
+    private static formatKeyHint;
+    /** Return the display hint for the first non-vim keybinding for a command, or undefined. */
+    private getKeybindingHint;
+    private buildActionMenuItems;
+    /**
+     * Resolve block IDs for right-click context menu.
+     * If blocks are selected and the click is on a selected block, use the selection.
+     * Otherwise, use the single block under the click.
+     */
+    private resolveContextMenuBlockIds;
+    /** Build context menu items for given block IDs */
+    private buildContextMenuItems;
+    /** Add a custom item to the right-click context menu */
+    addContextMenuItem(entry: BlockContextMenuEntry): void;
+    /** Remove a custom item from the right-click context menu */
+    removeContextMenuItem(key: string): void;
+    private clipboardKeyHandler;
+    private setupClipboardShortcuts;
+    /**
+     * Read blocks from clipboard and paste AFTER the focused block as discrete
+     * new blocks (no content merging). Used by `p` in normal/visual modes.
+     */
+    private pasteBlocksFromClipboard;
+    /**
+     * Read blocks from clipboard and paste BEFORE the focused block as discrete
+     * new blocks. Used by `P` in normal/visual modes.
+     */
+    private pasteBlocksBeforeFromClipboard;
+    /**
+     * Walk all blocks and set `<ol start="N">` on consecutive ordered list
+     * blocks at the same indent level.  Non-list blocks or a change in
+     * indent level reset the counter.
+     */
+    private recomputeListIndices;
+    /**
+     * Focus a table block's cell directly, bypassing block-level focus.
+     * @param direction "down" focuses first row, "up" focuses last row.
+     */
+    private focusTableCell;
+    private focusNonTextBlock;
+    private blurNonTextBlock;
+    /** Find the nearest text block index in the given direction (-1 or 1). */
+    private findTextBlockIndex;
+    private removeImageDropZone;
+    private showDropRejectOverlay;
+    private removeDropRejectOverlay;
+    private setupMediaBlockHandlers;
+    private setupSearchShortcut;
+    /** Open (or re-focus) the search panel. */
+    openSearch(): void;
+    /** Close the search panel. */
+    closeSearch(): void;
+    /** Highlight ALL search matches dimly across all blocks. */
+    private highlightAllSearchMatches;
+    /** Add bright highlight to the current/focused search match. */
+    private highlightSearchMatch;
+    /** Remove bright highlight from the current match (keep dim highlights). */
+    private clearCurrentSearchHighlight;
+    /** Clear ALL search highlights (dim + bright) from all blocks. */
+    private clearSearchHighlights;
+    private replaceSearchMatch;
+    private replaceAllSearchMatches;
+    private getPlugin;
+}