@inkami/blx 0.17.3

package/dist/emoji-picker/emoji-data.d.ts

@@ -0,0 +1,22 @@
+export interface EmojiEntry {
+    emoji: string;
+    name: string;
+    keywords: string[];
+}
+export declare const EMOJI_LIST: EmojiEntry[];
+/** Emoji category — defines a slice of EMOJI_LIST for browsing. */
+export interface EmojiCategory {
+    key: string;
+    icon: string;
+    start: number;
+    end: number;
+}
+/** Category definitions matching the order of EMOJI_LIST. */
+export declare const EMOJI_CATEGORIES: EmojiCategory[];
+/** Get emoji entries for a category. */
+export declare function getEmojiByCategory(category: EmojiCategory): EmojiEntry[];
+/**
+ * Search emoji by name/keyword prefix match.
+ * Returns top N results (default 8).
+ */
+export declare function searchEmoji(query: string, limit?: number): EmojiEntry[];

package/dist/emoji-picker/emoji-picker.d.ts

@@ -0,0 +1,43 @@
+import type { EmojiEntry } from "./emoji-data";
+export declare class EmojiPicker {
+    private el;
+    private items;
+    private selectedIndex;
+    private onSelect;
+    private onClose;
+    /** Whether the picker is showing browse mode (all categories) vs search results. */
+    private browseMode;
+    private activeCategoryIndex;
+    private tabBar;
+    private grid;
+    private tooltip;
+    constructor(onSelect: (emoji: string) => void, onClose: () => void);
+    get element(): HTMLElement;
+    show(anchorRect: DOMRect): void;
+    /** Reposition the picker to follow a new anchor rect (e.g. on scroll) */
+    reposition(anchorRect: DOMRect): void;
+    hide(): void;
+    get visible(): boolean;
+    updateResults(entries: EmojiEntry[]): void;
+    /**
+     * Switch to browse mode — show all emoji in the active category.
+     * Called when the query is empty (user just typed `:` with nothing after).
+     */
+    enterBrowseMode(): void;
+    /**
+     * Switch to search mode — show filtered results.
+     * Called when the query has text.
+     */
+    enterSearchMode(entries: EmojiEntry[]): void;
+    /** Handle keyboard events. Returns true if the event was consumed. */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    /** Get the currently selected entry, or null */
+    getSelectedEntry(): EmojiEntry | null;
+    destroy(): void;
+    private buildTabBar;
+    private switchCategory;
+    private updateTabSelection;
+    private renderGrid;
+    private updateSelection;
+    private showTooltip;
+}

package/dist/emoji-picker/index.d.ts

@@ -0,0 +1,3 @@
+export { EmojiPicker } from "./emoji-picker";
+export { searchEmoji, EMOJI_LIST, EMOJI_CATEGORIES, getEmojiByCategory } from "./emoji-data";
+export type { EmojiEntry, EmojiCategory } from "./emoji-data";

package/dist/event-bus/event-bus.d.ts

@@ -0,0 +1,14 @@
+import type { EventHandler, Unsubscribe } from "./types";
+/**
+ * Typed event bus — generic over an event map.
+ * Handlers that throw do not break other handlers.
+ */
+export declare class EventBus<TEventMap = Record<string, unknown>> {
+    private handlers;
+    on<K extends keyof TEventMap>(event: K, handler: EventHandler<TEventMap[K]>): Unsubscribe;
+    once<K extends keyof TEventMap>(event: K, handler: EventHandler<TEventMap[K]>): Unsubscribe;
+    off<K extends keyof TEventMap>(event: K, handler: EventHandler<TEventMap[K]>): void;
+    emit<K extends keyof TEventMap>(event: K, payload: TEventMap[K]): void;
+    emitAsync<K extends keyof TEventMap>(event: K, payload: TEventMap[K]): Promise<void>;
+    clear(): void;
+}

package/dist/event-bus/index.d.ts

@@ -0,0 +1,2 @@
+export { EventBus } from "./event-bus";
+export type { EditorEventMap, EventHandler, Unsubscribe, ThemeMode } from "./types";

package/dist/event-bus/types.d.ts

@@ -0,0 +1,320 @@
+import type { AttributedString } from "../attributed-string";
+import type { BlockMetadata } from "../schema/types";
+import type { MultiBlockSelection } from "../selection/types";
+import type { CommandRegistry } from "../commands/command-registry";
+/** Payload types for all editor events */
+export interface EditorEventMap {
+    "block:added": {
+        blockId: string;
+        index: number;
+    };
+    "block:removed": {
+        blockId: string;
+    };
+    "block:moved": {
+        blockId: string;
+        fromIndex: number;
+        toIndex: number;
+    };
+    "block:typeChanged": {
+        blockId: string;
+        oldType: string;
+        newType: string;
+    };
+    "block:contentChanged": {
+        blockId: string;
+        content: AttributedString;
+        metadata?: BlockMetadata;
+        previousContent?: AttributedString;
+        previousMetadata?: BlockMetadata;
+        previousCursorOffset?: number;
+    };
+    "block:focus": {
+        blockId: string;
+        offset?: number;
+        caretX?: number;
+    };
+    "block:blur": {
+        blockId: string;
+    };
+    "block:split": {
+        blockId: string;
+        offset: number;
+    };
+    "block:merge": {
+        blockId: string;
+        direction: "backward" | "forward";
+    };
+    "block:slashMenu": {
+        blockId: string;
+        query: string;
+        slashOffset: number;
+    };
+    "block:slashClose": {
+        blockId: string;
+    };
+    "block:emojiSearch": {
+        blockId: string;
+        query: string;
+        colonOffset: number;
+    };
+    "block:emojiClose": {
+        blockId: string;
+    };
+    "block:emojiCommit": {
+        blockId: string;
+        colonOffset: number;
+        cursorOffset: number;
+        emoji: string;
+    };
+    "block:autoCompleteMenu": {
+        blockId: string;
+        query: string;
+        bracketOffset: number;
+    };
+    "block:autoCompleteClose": {
+        blockId: string;
+    };
+    "block:convertType": {
+        blockId: string;
+        newType: string;
+        metadata: Record<string, unknown>;
+    };
+    "block:checklistToggled": {
+        blockId: string;
+        checked: boolean;
+    };
+    "block:agendaOpen": {
+        blockId: string;
+        atOffset: number;
+        role?: "due" | "scheduled" | "event";
+    };
+    "block:agendaSearch": {
+        blockId: string;
+        query: string;
+        atOffset: number;
+        role?: "due" | "scheduled" | "event";
+    };
+    "block:agendaClose": {
+        blockId: string;
+    };
+    "block:agendaAutoConfirm": {
+        blockId: string;
+        query: string;
+        role?: "due" | "scheduled" | "event";
+    };
+    "block:agendaEdit": {
+        blockId: string;
+        role: "due" | "scheduled" | "event";
+        date: string;
+    };
+    "block:agendaChanged": {
+        blockId: string;
+        role: "due" | "scheduled" | "event";
+        date: string | null;
+        previous: string | null;
+        recurrence?: {
+            interval: number;
+            unit: string;
+            anchor?: string;
+            fromCompletion?: boolean;
+        } | null;
+    };
+    "editor:ready": Record<string, never>;
+    "editor:destroyed": Record<string, never>;
+    "block:indent": {
+        blockId: string;
+    };
+    "block:outdent": {
+        blockId: string;
+    };
+    "block:selectTo": {
+        blockId: string;
+        direction: "up" | "down";
+    };
+    "selection:blockSelect": {
+        state: MultiBlockSelection | null;
+    };
+    "block:jumpToDocStart": {
+        blockId: string;
+    };
+    "block:jumpToDocEnd": {
+        blockId: string;
+    };
+    "block:selectToDocStart": {
+        blockId: string;
+    };
+    "block:selectToDocEnd": {
+        blockId: string;
+    };
+    "block:pageUp": {
+        blockId: string;
+    };
+    "block:pageDown": {
+        blockId: string;
+    };
+    "selection:changed": {
+        blockId: string | null;
+        start: number;
+        end: number;
+        /** Set when the selection spans into a different block (multi-block) */
+        endBlockId?: string;
+    };
+    "editor:unfocusedInput": {
+        key: string;
+        isComposing: boolean;
+    };
+    "block:enterBlockSelect": {
+        blockId: string;
+    };
+    "editor:modeChanged": {
+        mode: "insert" | "normal" | "visualBlock";
+    };
+    "block:moveUp": {
+        blockId: string;
+    };
+    "block:moveDown": {
+        blockId: string;
+    };
+    "link:click": {
+        href: string;
+        resolvedHref: string;
+        originalEvent: MouseEvent;
+    };
+    "blockRef:click": {
+        blockId: string;
+        originalEvent: MouseEvent;
+    };
+    "blockRef:hover": {
+        blockId: string;
+        element: HTMLElement;
+        originalEvent: MouseEvent;
+    };
+    "blockRef:hoverEnd": {
+        blockId: string;
+    };
+    "block:refineWithAI": {
+        blockIds: string[];
+    };
+    "editor:themeChanged": {
+        theme: ThemeMode;
+    };
+    "editor:undo": Record<string, never>;
+    "editor:redo": Record<string, never>;
+    "editor:historyChanged": {
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+    "editor:jumpBack": {
+        blockId: string;
+        offset: number;
+    };
+    "editor:jumpForward": {
+        blockId: string;
+        offset: number;
+    };
+    "table:cellEdit": {
+        blockId: string;
+        row: number;
+        col: number;
+        value: string;
+    };
+    "table:createRowBelow": {
+        blockId: string;
+        row: number;
+    };
+    "table:deleteRow": {
+        blockId: string;
+        row: number;
+    };
+    "table:navigateOut": {
+        blockId: string;
+        direction: "up" | "down";
+    };
+    "table:exit": {
+        blockId: string;
+    };
+    "table:escape": {
+        blockId: string;
+    };
+    "table:addColumn": {
+        blockId: string;
+        col: number;
+    };
+    "table:deleteColumn": {
+        blockId: string;
+        col: number;
+    };
+    "table:moveRow": {
+        blockId: string;
+        from: number;
+        to: number;
+    };
+    "table:moveColumn": {
+        blockId: string;
+        from: number;
+        to: number;
+    };
+    "table:bulkClear": {
+        blockId: string;
+        keys: string[];
+    };
+    "table:selectionChanged": {
+        blockId: string;
+        startRow: number;
+        endRow: number;
+        startCol: number;
+        endCol: number;
+    };
+    "table:insertRowAbove": {
+        blockId: string;
+        row: number;
+    };
+    "table:duplicateRow": {
+        blockId: string;
+        startRow: number;
+        endRow: number;
+    };
+    "table:clearRow": {
+        blockId: string;
+        startRow: number;
+        endRow: number;
+    };
+    "table:duplicateColumn": {
+        blockId: string;
+        startCol: number;
+        endCol: number;
+    };
+    "table:clearColumn": {
+        blockId: string;
+        startCol: number;
+        endCol: number;
+    };
+    "table:bulkFormat": {
+        blockId: string;
+        startRow: number;
+        endRow: number;
+        startCol: number;
+        endCol: number;
+        attribute: string;
+        applied: boolean;
+    };
+    "editor:openSlashMenu": {
+        blockId: string;
+    };
+    "editor:openCommandMode": {
+        commands: CommandRegistry;
+    };
+    "editor:save": Record<string, never>;
+    "editor:close": Record<string, never>;
+    "editor:openDocumentSwitcher": Record<string, never>;
+    "editor:foldChanged": {
+        blockId: string | null;
+        folded: boolean;
+    };
+}
+export type ThemeMode = "light" | "dark" | "system";
+/** Handler function for a given event key */
+export type EventHandler<T> = (payload: T) => void | Promise<void>;
+/** Unsubscribe function returned by on() */
+export type Unsubscribe = () => void;

package/dist/fold/fold-manager.d.ts

@@ -0,0 +1,27 @@
+import type { Block } from "../types";
+export interface FoldState {
+    foldedIds: string[];
+}
+export interface FoldCallbacks {
+    onFoldChanged?: (state: FoldState) => void;
+}
+export declare class FoldManager {
+    private foldedHeadingIds;
+    private hiddenBlockIds;
+    private callbacks;
+    setCallbacks(cb: FoldCallbacks): void;
+    loadState(state: FoldState | null): void;
+    getState(): FoldState;
+    toggle(headingBlockId: string, allBlocks: ReadonlyArray<Block>): Set<string>;
+    fold(headingBlockId: string, allBlocks: ReadonlyArray<Block>): Set<string>;
+    unfold(headingBlockId: string, allBlocks: ReadonlyArray<Block>): Set<string>;
+    foldAll(allBlocks: ReadonlyArray<Block>): Set<string>;
+    unfoldAll(allBlocks: ReadonlyArray<Block>): Set<string>;
+    isFolded(headingBlockId: string): boolean;
+    isHidden(blockId: string): boolean;
+    recompute(allBlocks: ReadonlyArray<Block>): Set<string>;
+    getHiddenBlockIds(): ReadonlySet<string>;
+    findOwningHeading(blockId: string, allBlocks: ReadonlyArray<Block>): string | null;
+}
+export declare function getHeadingScope(headingBlock: Block, allBlocks: ReadonlyArray<Block>): string[];
+export declare function computeHiddenBlocks(foldedHeadingIds: Set<string>, allBlocks: ReadonlyArray<Block>): Set<string>;

package/dist/fold/index.d.ts

@@ -0,0 +1,2 @@
+export { FoldManager, getHeadingScope, computeHiddenBlocks } from "./fold-manager";
+export type { FoldState, FoldCallbacks } from "./fold-manager";

package/dist/grapheme.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Grapheme-cluster boundary utilities.
+ *
+ * JavaScript string `.length` counts UTF-16 code units, so multi-codepoint
+ * characters like ❤️ (U+2764 + U+FE0F, length 2) or 👨‍👩‍👧 (length 8)
+ * span more than 1 unit.  When deleting "one character" on backspace or
+ * forward-delete we must remove the entire grapheme cluster, not just a
+ * single code unit.
+ *
+ * Uses `Intl.Segmenter` (supported in all modern browsers and Node 16+).
+ */
+/**
+ * Return the UTF-16 offset of the start of the grapheme cluster that
+ * ends at (or contains) `offset`.  If `offset` is 0, returns 0.
+ *
+ * Example: for text "a❤️b" (UTF-16 units: a ❤ \uFE0F b),
+ * prevGraphemeBoundary(text, 3) → 1  (skips both code units of ❤️)
+ */
+export declare function prevGraphemeBoundary(text: string, offset: number): number;
+/**
+ * Return the UTF-16 offset just past the grapheme cluster that starts
+ * at (or contains) `offset`.  If `offset` is at/past the end, returns
+ * `text.length`.
+ *
+ * Example: for text "a❤️b" (UTF-16 units: a ❤ \uFE0F b),
+ * nextGraphemeBoundary(text, 1) → 3  (skips both code units of ❤️)
+ */
+export declare function nextGraphemeBoundary(text: string, offset: number): number;

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+export { Editor } from "./editor";
+export type { EditorOptions, EditorJSON, DateSuggestionProvider, ExternalKeybinding } from "./editor";
+export type { Block, BlockJSON } from "./types";
+export { blockToJSON, blockFromJSON } from "./types";
+export { AttributedString } from "./attributed-string";
+export type { Attributes, AttributeValue, Span, AttributedStringJSON } from "./attributed-string";
+export { EventBus } from "./event-bus";
+export type { EditorEventMap, EventHandler, Unsubscribe, ThemeMode } from "./event-bus";
+export { SchemaRegistry } from "./schema";
+export type { BlockTypePlugin, BlockMetadata, ConversionTarget } from "./schema";
+export { Transaction } from "./transaction";
+export type { Operation, TransactionResult } from "./transaction";
+export { BlockController } from "./block";
+export type { BlockView } from "./block";
+export { paragraphPlugin, headingPlugin, listPlugin, codeBlockPlugin, horizontalRulePlugin, youtubePlugin, imagePlugin, tablePlugin, blockquotePlugin, mermaidPlugin, renderMermaidSvg, excalidrawPlugin, openExcalidrawModal, renderExcalidrawSvg, parseYouTubeUrl, CODE_LANGUAGES, registerDefaultPlugins, renderAttributedString, setUrlResolver, setBlockRefRenderCallback, resolveUrl, } from "./plugins";
+export type { ParagraphMetadata, HeadingMetadata, ListMetadata, CodeBlockMetadata, HorizontalRuleMetadata, YouTubeMetadata, ImageMetadata, TableMetadata, BlockquoteMetadata, MermaidMetadata, ExcalidrawMetadata } from "./plugins";
+export type { TableSelection } from "./plugins/table";
+export { SelectionManager } from "./selection";
+export type { InlineSelection, MultiBlockSelection, SelectionState } from "./selection";
+export { isMultiBlockSelection, isInlineSelection } from "./selection";
+export { detectInlineShortcut, detectBlockShortcut, blocksToMarkdown } from "./markdown";
+export type { InlineShortcutMatch, BlockShortcutMatch } from "./markdown";
+export { DatePicker, classifyAgendaDate, parseAgendaDate, formatAgendaDateISO, agendaStateClass, parseDateQuery } from "./date-picker";
+export type { AgendaState, AgendaDisplay, DateSuggestion, DateRole, Recurrence } from "./date-picker";
+export { EmojiPicker, searchEmoji, EMOJI_LIST } from "./emoji-picker";
+export type { EmojiEntry } from "./emoji-picker";
+export { InlineToolbar, TOOLBAR_BUTTONS } from "./inline-toolbar";
+export type { ToolbarButton, ToolbarActionContext } from "./inline-toolbar";
+export { HighlightPicker, HIGHLIGHT_COLORS } from "./inline-toolbar";
+export type { HighlightColorName } from "./inline-toolbar";
+export { BlockActionMenu } from "./block-action-menu";
+export type { BlockActionMenuEntry } from "./block-action-menu";
+export { BlockContextMenu } from "./block-context-menu";
+export type { BlockContextMenuEntry } from "./block-context-menu";
+export { copyBlocksToClipboard, readBlocksFromClipboard, extractBlocksFromHtml, htmlToBlocks, markdownToBlocks, plainTextToBlocks } from "./clipboard";
+export { AutoCompleteMenu } from "./autocomplete";
+export type { AutoCompleteEntry, AutoCompleteProvider } from "./autocomplete";
+export { DEFAULT_KEYBINDINGS, VIM_KEYBINDINGS } from "./keybindings";
+export type { KeyDescriptor, KeybindingMap } from "./keybindings";
+export { CommandRegistry } from "./commands/command-registry";
+export type { CommandEntry, ExternalCommandEntry } from "./commands/command-registry";
+export { SearchEngine, SearchUI } from "./search";
+export type { SearchMatch, SearchOptions, SearchUICallbacks } from "./search";
+export { UndoManager } from "./undo";
+export type { UndoManagerOptions } from "./undo";
+export { JumpList } from "./undo";
+export type { JumpEntry, JumpListOptions, UndoAction, UndoEntry, CursorState, BlockSnapshot } from "./undo";
+export { CrdtLog } from "./crdt";
+export { PEER_COLORS, renderRemoteCursors, clearRemoteCursors } from "./crdt";
+export { AutomergeSync, diffText } from "./crdt";
+export type { AutomergeDocSchema, AutomergeBlockData, AutomergeSyncOptions } from "./crdt";
+export type { CrdtOperation, CrdtLogSnapshot, CrdtPeer, RemoteCursor } from "./crdt";
+export { setBlobStore, getBlobStore, isBlobRef, resolveBlobSrc, storeFileAsBlob, sha256Hex, makeBlobRef, blobRefHash } from "./blob-store";
+export type { BlobStore } from "./blob-store";
+export { BlockViewport } from "./viewport";
+export type { BlockViewportOptions } from "./viewport";
+export { FoldManager, getHeadingScope, computeHiddenBlocks } from "./fold";
+export type { FoldState, FoldCallbacks } from "./fold";
+export { TableOfContents } from "./table-of-contents";
+export { ContextMenu, Popover, positionFixed, dismissOnClickOutside } from "./ui";
+export type { MenuItem, ContextMenuOptions, PopoverOptions, PositionFixedOptions, DismissHandle } from "./ui";
+export { generateId, isUUID } from "./util/id";

package/dist/inline-toolbar/highlight-picker.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Small floating popover showing color swatches for text highlighting.
+ * Displayed below the inline toolbar or selection rect.
+ */
+/** Predefined highlight colors available in the picker. */
+export declare const HIGHLIGHT_COLORS: readonly [{
+    readonly name: "yellow";
+    readonly label: "Yellow";
+}, {
+    readonly name: "green";
+    readonly label: "Green";
+}, {
+    readonly name: "blue";
+    readonly label: "Blue";
+}, {
+    readonly name: "pink";
+    readonly label: "Pink";
+}, {
+    readonly name: "orange";
+    readonly label: "Orange";
+}, {
+    readonly name: "purple";
+    readonly label: "Purple";
+}];
+export type HighlightColorName = (typeof HIGHLIGHT_COLORS)[number]["name"];
+export declare class HighlightPicker {
+    private popover;
+    private onApply;
+    private onRemove;
+    private onClose;
+    constructor(onApply: (color: string) => void, onRemove: () => void, onClose: () => void);
+    get element(): HTMLElement;
+    get visible(): boolean;
+    /**
+     * Show the picker positioned relative to the given anchor rect.
+     * Highlights the currently active color (if any).
+     */
+    show(anchorRect: DOMRect, activeColor?: string): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/inline-toolbar/index.d.ts

@@ -0,0 +1,5 @@
+export { InlineToolbar, TOOLBAR_BUTTONS } from "./inline-toolbar";
+export type { ToolbarButton, ToolbarActionContext } from "./inline-toolbar";
+export { LinkPopover } from "./link-popover";
+export { HighlightPicker, HIGHLIGHT_COLORS } from "./highlight-picker";
+export type { HighlightColorName } from "./highlight-picker";

package/dist/inline-toolbar/inline-toolbar.d.ts

@@ -0,0 +1,97 @@
+import type { Attributes } from "../attributed-string/types";
+/** Context passed to custom toolbar button handlers */
+export interface ToolbarActionContext {
+    /** ID of the block containing the selection */
+    blockId: string;
+    /** Start offset of the selection within the block */
+    start: number;
+    /** End offset of the selection within the block */
+    end: number;
+    /** Attributes that are active across the entire selection */
+    activeAttributes: Attributes;
+    /** Convenience: apply or remove a single attribute on the selection */
+    applyAttribute: (attribute: string, active: boolean) => void;
+}
+/** Toolbar button configuration */
+export interface ToolbarButton {
+    /** Unique key identifying this button */
+    key: string;
+    /** Accessible label / tooltip text */
+    label: string;
+    /**
+     * Button icon — either a text string or a render function.
+     * When a string, displayed as text with a CSS class `blx-inline-toolbar-icon-{key}`.
+     * When a function, called with the container element to render custom HTML.
+     */
+    icon: string | ((container: HTMLElement) => void);
+    /**
+     * Attribute to toggle (e.g. "bold", "italic").
+     * When set, clicking the button toggles this attribute via the standard
+     * applyAttributes/removeAttributes transaction flow.
+     * Mutually exclusive with `onAction`.
+     */
+    attribute?: string;
+    /**
+     * Custom action handler. Called when the button is clicked.
+     * Use this for buttons that need non-standard behavior (e.g. link input,
+     * color picker). Mutually exclusive with `attribute`.
+     */
+    onAction?: (context: ToolbarActionContext) => void;
+    /**
+     * Custom active-state check. When provided, this function determines
+     * whether the button appears pressed/active. When omitted, buttons
+     * with `attribute` use the standard attribute intersection check.
+     */
+    isActive?: (context: ToolbarActionContext) => boolean;
+}
+/** Standard inline formatting buttons */
+export declare const TOOLBAR_BUTTONS: ToolbarButton[];
+/**
+ * Floating inline toolbar that appears on text selection.
+ *
+ * Provides buttons for formatting and is extensible via `addButton()`.
+ * Positioned above (or below) the selection bounding rect. Dismissed on
+ * selection collapse, click outside, or Escape key.
+ */
+export declare class InlineToolbar {
+    private popover;
+    private onFormat;
+    private onCustomAction;
+    private activeAttributes;
+    /** Built-in buttons (left group) */
+    private builtinButtons;
+    /** Plugin-added buttons (right group, after separator) */
+    private pluginButtons;
+    /** Current action context (set on show/update, used by click handlers) */
+    private actionContext;
+    constructor(onFormat: (attribute: string, active: boolean) => void, builtinButtons?: ToolbarButton[]);
+    get element(): HTMLElement;
+    get visible(): boolean;
+    /** Set the handler for custom (non-attribute) button actions */
+    setCustomActionHandler(handler: (key: string, context: ToolbarActionContext) => void): void;
+    /**
+     * Add a button to the toolbar. Plugin buttons appear after a separator.
+     * If a button with the same key already exists, it is replaced.
+     */
+    addButton(button: ToolbarButton): void;
+    /** Remove a plugin-added button by key. Returns true if found. */
+    removeButton(key: string): boolean;
+    /** Get all currently registered buttons (built-in + plugin) */
+    getButtons(): ReadonlyArray<ToolbarButton>;
+    /**
+     * Show the toolbar positioned relative to the given selection rect.
+     * Positions above the selection by default; flips below if near viewport top.
+     */
+    show(selectionRect: DOMRect, activeAttrs: Attributes, context?: ToolbarActionContext): void;
+    /** Reposition the toolbar to follow a new anchor rect (e.g. on scroll) */
+    reposition(selectionRect: DOMRect): void;
+    /** Update the active state of buttons without repositioning */
+    updateActiveAttributes(activeAttrs: Attributes, context?: ToolbarActionContext): void;
+    hide(): void;
+    destroy(): void;
+    /** Sync the active set from standard attributes + custom isActive checks */
+    private syncActiveState;
+    private renderButtons;
+    private handleButtonClick;
+    private updateButtonStates;
+}