@inkami/blx 0.17.3

package/README.md

@@ -0,0 +1,98 @@
+# @inkami/blx
+
+**A block-based editor for the web.** Notion-style editing — rich text, media, tables, nesting — in a single TypeScript library with zero framework dependencies.
+
+## Install
+
+```bash
+npm install @inkami/blx
+```
+
+## Quick Start
+
+```ts
+import { Editor, AttributedString } from "@inkami/blx";
+import "@inkami/blx/style.css";
+
+const editor = new Editor(document.getElementById("editor")!, {
+  initialBlocks: [
+    {
+      id: "1",
+      type: "paragraph",
+      content: AttributedString.fromPlain("Hello, world!"),
+      metadata: {},
+    },
+  ],
+});
+```
+
+## Features
+
+| | |
+|---|---|
+| **Rich text** | Bold, italic, underline, strikethrough, inline code, highlights (6 colors) |
+| **Block types** | Paragraphs, headings (1-6), ordered/unordered lists, task lists, code (syntax highlighted), images, YouTube embeds, tables, horizontal rules |
+| **Links** | Inline links with `[markdown](syntax)`, Cmd+K popover, `[[` internal block references with autocomplete |
+| **Editing** | Slash menu, inline toolbar, block action menu, drag handles, multi-block selection |
+| **Search** | Cmd+F with regex, case-sensitive toggle, find & replace |
+| **Undo/Redo** | Transaction-based history with smart grouping |
+| **Nesting** | Tab/Shift+Tab for lists and task lists, 4 indent levels |
+| **Theming** | Light & dark mode via CSS custom properties |
+| **Extensible** | Custom block types, toolbar buttons, block actions, slash menu items, autocomplete providers |
+
+## Custom Block Types
+
+```ts
+import type { BlockTypePlugin } from "@inkami/blx";
+
+const calloutPlugin: BlockTypePlugin = {
+  type: "callout",
+  label: "Callout",
+  hasTextContent: true,
+  defaultContent: () => AttributedString.empty(),
+  defaultMetadata: () => ({ emoji: "💡" }),
+  render(container, content, metadata) {
+    // Build your DOM from the model
+  },
+};
+
+editor.registerBlockType(calloutPlugin);
+```
+
+## API
+
+### Editor
+
+| Method | Description |
+|---|---|
+| `new Editor(root, options?)` | Create editor |
+| `addBlock(typeOrBlock, index?)` | Add a block |
+| `removeBlock(id)` | Remove a block |
+| `moveBlock(id, toIndex)` | Reorder a block |
+| `changeBlockType(id, newType)` | Convert block type |
+| `focusBlock(id, offset?)` | Focus a block |
+| `registerBlockType(plugin)` | Register a custom block type |
+| `addToolbarButton(config)` | Add inline toolbar button |
+| `addBlockActionItem(config)` | Add block action menu item |
+| `addSlashMenuItem(config)` | Add slash menu entry |
+| `addAutoCompleteProvider(provider)` | Add `[[` autocomplete provider |
+| `toJSON()` / `Editor.fromJSON()` | Serialize / restore |
+| `destroy()` | Clean up |
+
+### AttributedString
+
+| Method | Description |
+|---|---|
+| `AttributedString.empty()` | Create empty string |
+| `AttributedString.fromPlain(text, attrs?)` | Create from plain text |
+| `.insertAt(offset, text, attrs?)` | Insert text |
+| `.deleteRange(start, end)` | Delete range |
+| `.applyAttributes(start, end, attrs)` | Apply formatting |
+| `.removeAttributes(start, end, keys)` | Remove formatting |
+| `.slice(start, end)` | Extract substring |
+| `.concat(other)` | Concatenate |
+| `.toJSON()` / `AttributedString.fromJSON()` | Serialize / restore |
+
+## License
+
+MIT

package/dist/attributed-string/attributed-string.d.ts

@@ -0,0 +1,37 @@
+import type { Attributes, AttributedStringJSON, Span } from "./types";
+/**
+ * Immutable attributed string — every mutation returns a new instance.
+ * Internally stores an array of non-overlapping, ordered Spans that cover
+ * the full string. Adjacent spans with identical attributes are always merged.
+ */
+export declare class AttributedString {
+    readonly spans: ReadonlyArray<Span>;
+    private constructor();
+    static empty(): AttributedString;
+    static fromPlain(text: string, attrs?: Attributes): AttributedString;
+    static fromSpans(spans: ReadonlyArray<Span>): AttributedString;
+    static fromJSON(json: AttributedStringJSON): AttributedString;
+    get length(): number;
+    get text(): string;
+    isEmpty(): boolean;
+    /**
+     * Get attributes at a character offset.
+     *
+     * @param side - Which side's attributes to prefer at a boundary:
+     *   - `'right'` (default): return the attributes of the span that starts at
+     *     or contains the offset — this is the classic behavior.
+     *   - `'left'`: return the attributes of the span to the *left* of the
+     *     cursor.  At position 0 this means "nothing to the left" → `{}`.
+     *     Use `'left'` for text insertion so that typing before a formatted
+     *     span does not inherit its formatting.
+     */
+    attributesAt(offset: number, side?: "left" | "right"): Attributes;
+    insertAt(offset: number, text: string, attrs?: Attributes): AttributedString;
+    deleteRange(start: number, end: number): AttributedString;
+    applyAttributes(start: number, end: number, attrs: Attributes): AttributedString;
+    removeAttributes(start: number, end: number, keys: string[]): AttributedString;
+    slice(start: number, end: number): AttributedString;
+    concat(other: AttributedString): AttributedString;
+    toJSON(): AttributedStringJSON;
+    equals(other: AttributedString): boolean;
+}

package/dist/attributed-string/index.d.ts

@@ -0,0 +1,2 @@
+export { AttributedString } from "./attributed-string";
+export type { Attributes, AttributeValue, Span, AttributedStringJSON } from "./types";

package/dist/attributed-string/types.d.ts

@@ -0,0 +1,13 @@
+/** Attribute values can be strings, numbers, or booleans */
+export type AttributeValue = string | number | boolean;
+/** A dictionary of formatting attributes */
+export type Attributes = Record<string, AttributeValue>;
+/** A span of text with uniform attributes */
+export interface Span {
+    text: string;
+    attributes: Attributes;
+}
+/** JSON-serializable representation of an AttributedString */
+export interface AttributedStringJSON {
+    spans: ReadonlyArray<Span>;
+}

package/dist/autocomplete/autocomplete-menu.d.ts

@@ -0,0 +1,24 @@
+import type { AutoCompleteEntry } from "./types";
+/**
+ * Floating menu showing autocomplete results.
+ * Triggered by `[[` in the editor; wraps ContextMenu.
+ */
+export declare class AutoCompleteMenu {
+    private menu;
+    private items;
+    private onSelectCb;
+    constructor(onSelect: (entry: AutoCompleteEntry) => void, onClose: () => void);
+    get element(): HTMLElement;
+    get visible(): boolean;
+    get hasItems(): boolean;
+    show(anchorRect: DOMRect): void;
+    /** Reposition the menu relative to a new anchor rect (e.g. caret moved). */
+    reposition(anchorRect: DOMRect): void;
+    hide(): void;
+    /** Update displayed results. Resets selection to first item. */
+    updateResults(entries: AutoCompleteEntry[]): void;
+    /** Handle keyboard events. Returns true if the event was consumed. */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    destroy(): void;
+    private toMenuItems;
+}

package/dist/autocomplete/index.d.ts

@@ -0,0 +1,2 @@
+export { AutoCompleteMenu } from "./autocomplete-menu";
+export type { AutoCompleteEntry, AutoCompleteProvider } from "./types";

package/dist/autocomplete/types.d.ts

@@ -0,0 +1,29 @@
+import type { Attributes } from "../attributed-string/types";
+/** A single entry in the autocomplete results. */
+export interface AutoCompleteEntry {
+    /** Unique identifier (e.g. block ID, external doc ID). */
+    id: string;
+    /** Display text shown in the menu. */
+    label: string;
+    /** Optional secondary description. */
+    description?: string;
+    /** Optional icon (emoji or HTML string). */
+    icon?: string;
+    /** Text to insert into the document when selected. Defaults to `label`. */
+    insertText?: string;
+    /** Attributes to apply on the inserted text (e.g. `{ blockRef: id }`). */
+    attributes?: Attributes;
+}
+/**
+ * Provider that supplies autocomplete entries.
+ * Multiple providers can be registered; results are merged in registration order.
+ */
+export interface AutoCompleteProvider {
+    /** Unique identifier for this provider. */
+    id: string;
+    /**
+     * Search for entries matching the query.
+     * Called on every keystroke while the `[[` menu is open.
+     */
+    search(query: string): AutoCompleteEntry[] | Promise<AutoCompleteEntry[]>;
+}

package/dist/blob-store/index.d.ts

@@ -0,0 +1,32 @@
+export type { BlobStore } from "./types";
+import type { BlobStore } from "./types";
+/** Register a blob store for the editor to use for image storage. */
+export declare function setBlobStore(store: BlobStore | null): void;
+/** Get the currently registered blob store (if any). */
+export declare function getBlobStore(): BlobStore | null;
+/** Check whether a `src` value is a blob-store reference. */
+export declare function isBlobRef(src: unknown): boolean;
+/** Build a blob reference string from a SHA-256 hex digest. */
+export declare function makeBlobRef(sha256Hex: string): string;
+/** Extract the hash portion from a blob reference string. */
+export declare function blobRefHash(ref: string): string;
+/**
+ * Resolve a `src` string to a displayable URL.
+ *
+ * - Regular URLs / data URIs are returned as-is.
+ * - Blob references (`blxblob:…`) are resolved through the registered
+ *   blob store. Returns `null` if the store is missing or the key is
+ *   not found.
+ */
+export declare function resolveBlobSrc(src: unknown): Promise<string | null>;
+/**
+ * Store a file's contents in the blob store (if one is registered) and
+ * return the blob reference key. Falls back to a base64 data URI when
+ * no blob store is available.
+ */
+export declare function storeFileAsBlob(file: File): Promise<string>;
+/**
+ * Compute the SHA-256 hex digest of an ArrayBuffer.
+ * Uses the Web Crypto API (available in browsers and Node 18+).
+ */
+export declare function sha256Hex(data: ArrayBuffer): Promise<string>;

package/dist/blob-store/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Interface for content-addressed binary blob storage.
+ *
+ * Implementations store image data (and other large binaries) outside of the
+ * CRDT document, keeping only a small hash reference in block metadata.
+ */
+export interface BlobStore {
+    /**
+     * Store binary data and return a content-addressed key.
+     * Calling `put` with identical data must return the same key
+     * (content-addressed / idempotent).
+     */
+    put(data: ArrayBuffer): Promise<string>;
+    /**
+     * Retrieve a displayable URL for the given blob key.
+     * Returns `null` if the key is not found in the store.
+     *
+     * Implementations may return an object URL (`URL.createObjectURL`),
+     * a data URI, or a remote URL — the caller treats it as opaque.
+     */
+    getUrl(key: string): Promise<string | null>;
+    /** Check whether a blob exists in the store. */
+    has(key: string): Promise<boolean>;
+}

package/dist/block/block-controller.d.ts

@@ -0,0 +1,205 @@
+import type { Block } from "../types";
+import type { BlockView } from "./types";
+import type { EventBus } from "../event-bus";
+import type { EditorEventMap } from "../event-bus";
+import type { BlockTypePlugin } from "../schema";
+import { Transaction } from "../transaction";
+/**
+ * Per-block controller that bridges model and DOM.
+ *
+ * Strategy:
+ * - `beforeinput` → preventDefault → create Transaction → apply → re-render
+ * - MutationObserver as fallback for IME / spell-check
+ * - Model is always source of truth
+ */
+export declare class BlockController implements BlockView {
+    readonly blockId: string;
+    readonly container: HTMLElement;
+    private _contentEditable;
+    private _mounted;
+    private _contentRendered;
+    private _listenersAttached;
+    private block;
+    private plugin;
+    private bus;
+    private observer;
+    private suppressObserver;
+    /** One-shot attribute override for the next insertText, set after inline shortcuts */
+    private nextInsertAttrs;
+    /**
+     * Persistent attribute overrides set by format shortcuts (Ctrl-B/I/U) on a
+     * collapsed cursor. Unlike nextInsertAttrs, these persist across multiple
+     * character inserts until the cursor moves or a non-insert action occurs.
+     * Keys are attribute names, values indicate desired state (true = add, false = remove).
+     */
+    private _pendingMarks;
+    /** Flag to suppress clearing pendingMarks on the next selectionchange event */
+    private _suppressPendingMarksClear;
+    /** Offset of the opening ':' for emoji picker, or null when inactive */
+    private emojiColonOffset;
+    /** Offset of the opening '/' for slash command menu, or null when inactive */
+    private slashCommandOffset;
+    /** Offset of a pending first '[' for autocomplete trigger */
+    private pendingBracketOffset;
+    /** Offset of the opening '[[' for autocomplete menu, or null when inactive */
+    private autoCompleteOffset;
+    /** Offset of the '@' that triggered the agenda picker, or null when inactive */
+    private agendaAtOffset;
+    /** Detected role prefix from inline syntax like @due( or @scheduled( */
+    private agendaRole;
+    /** Length of the prefix portion (e.g., "due(" = 4) that has been typed, used to strip from query */
+    private agendaPrefixLen;
+    constructor(block: Block, plugin: BlockTypePlugin, bus: EventBus<EditorEventMap>);
+    get contentEditable(): HTMLElement | null;
+    get mounted(): boolean;
+    /** Whether block content is currently rendered into the container */
+    get contentRendered(): boolean;
+    /** Mount this block — render into container and attach event listeners */
+    mount(parent: HTMLElement, before?: HTMLElement | null): void;
+    /**
+     * Insert the container element into the DOM without rendering content.
+     * Used by the viewport system to place all block containers for scroll
+     * position stability while deferring expensive content rendering.
+     */
+    mountContainer(parent: HTMLElement | DocumentFragment, before?: HTMLElement | null): void;
+    /**
+     * Render content into an already-mounted container and attach event
+     * listeners. If the block was previously ejected (content hidden but
+     * still in the DOM), restores it without re-rendering.
+     */
+    mountContent(): void;
+    /**
+     * Eject block content: detach listeners and hide rendering via CSS.
+     * The DOM stays intact so the container height is perfectly preserved —
+     * no layout shift, no scroll compensation needed.
+     */
+    ejectContent(preReadHeight?: number): void;
+    /**
+     * Restore a previously ejected block: re-attach listeners and show content.
+     * Since the DOM was never cleared, this is a zero-cost operation with no
+     * layout shift.
+     */
+    restoreContent(): void;
+    /**
+     * Remove rendered content and event listeners but keep the container
+     * in the DOM. Saves the current height as minHeight for scroll stability.
+     * The block data model is preserved — only the DOM representation is removed.
+     *
+     * Used for full cleanup (block deletion, deep eviction). For normal
+     * viewport cycling, prefer ejectContent/restoreContent which preserve
+     * the DOM and avoid layout shifts.
+     *
+     * @param preReadHeight — If provided, skip the offsetHeight read and use
+     *   this value instead. This avoids forced layout when the caller has
+     *   already batched height reads (e.g. BlockViewport.handleIntersection).
+     */
+    unmountContent(preReadHeight?: number): void;
+    /** Apply a transaction — updates the model and re-renders */
+    applyTransaction(tx: Transaction): void;
+    /** Get current block data (read-only snapshot) */
+    getBlock(): Block;
+    /** Update the block data directly (used by editor for split/merge/type-change) */
+    updateBlock(updates: Partial<Pick<Block, "content" | "metadata" | "type">>): void;
+    /** Re-render with a new plugin (after type change) */
+    setPlugin(plugin: BlockTypePlugin): void;
+    /**
+     * Re-render block content with cursor preservation.
+     * Used by remote sync (AutomergeSync) to update content without losing
+     * the user's cursor position or triggering spurious MutationObserver events.
+     */
+    rerender(): void;
+    /** Ensure the contenteditable is visible (e.g. mermaid blocks hide their editor). */
+    private ensureEditable;
+    focus(offset?: number): void;
+    /** Returns the bounding rect of the current caret, or null if layout unavailable (jsdom). */
+    getCaretRect(): DOMRect | null;
+    /** Is the caret on the first visual line of this block? Returns true when layout is unavailable. */
+    isCaretOnFirstLine(): boolean;
+    /** Is the caret on the last visual line of this block? Returns true when layout is unavailable. */
+    isCaretOnLastLine(): boolean;
+    /** Focus this block and position cursor at horizontal X on the first or last line. */
+    focusAtX(x: number, line: "first" | "last"): void;
+    /**
+     * Focus this block and position cursor at the character nearest to (x, y).
+     * Uses caretRangeFromPoint with the raw click coordinates; if the point
+     * falls outside the text lines it clamps to the nearest (first/last) line.
+     * If the click is outside the contenteditable's horizontal bounds, x is
+     * clamped inside so caretRangeFromPoint returns the nearest line edge rather
+     * than falling through to an offset-0 fallback.
+     */
+    focusAtPoint(x: number, y: number): void;
+    /** Get the vertical center of the first or last text line in this block, or null. */
+    private getLineY;
+    /**
+     * Wrap characters [start, end) in a <mark> element with the given CSS class.
+     * Handles ranges that span across multiple inline elements (bold, italic, etc.)
+     * by wrapping each text node portion separately.
+     * Must suppress MutationObserver to avoid treating marks as user edits.
+     */
+    highlightRange(start: number, end: number, className: string): void;
+    /**
+     * Remove all <mark> elements with the given CSS class, restoring the original
+     * text nodes. Normalizes the parent to merge adjacent text nodes.
+     */
+    clearHighlights(className: string): void;
+    destroy(): void;
+    /** Scroll the current caret position into view if needed */
+    private scrollCaretIntoView;
+    private renderContent;
+    private attachListeners;
+    private detachListeners;
+    /** Connect the MutationObserver to the contentEditable element */
+    private connectObserver;
+    /** Disconnect the MutationObserver */
+    private disconnectObserver;
+    private handleBeforeInput;
+    private handlePaste;
+    private handleKeyDown;
+    private handleFocus;
+    private handleBlur;
+    private handleCodeLanguageChange;
+    private handleChecklistToggle;
+    /** Handle click on an agenda badge/label — open date picker for editing */
+    private handleAgendaEdit;
+    private handleHeadingTaskToggle;
+    private handleMutation;
+    /** Apply visual indentation based on metadata.indentLevel */
+    private applyIndentation;
+    /** Clear emoji picker state (called when picker is closed externally) */
+    clearEmojiState(): void;
+    /** Clear slash menu state (called when menu is closed externally) */
+    clearSlashState(): void;
+    /** Clear autocomplete state (called when menu is closed/committed externally) */
+    clearAutoCompleteState(): void;
+    /** Clear agenda picker state (called when picker is closed externally) */
+    clearAgendaState(): void;
+    /** Get the offset of the '@' that triggered the agenda picker */
+    getAgendaAtOffset(): number | null;
+    /**
+     * Set a one-shot attribute override for the next inserted character.
+     * Pass `{}` to force no attributes (preventing inheritance from adjacent spans).
+     */
+    setNextInsertAttrs(attrs: Record<string, unknown>): void;
+    /**
+     * Toggle a pending mark for format shortcuts on collapsed cursor.
+     * Computes the effective state (pending override or inherited) and flips it.
+     * If the new desired state matches what would be inherited, the pending
+     * override is removed (since inheritance already produces the right result).
+     */
+    togglePendingMark(attr: string, cursorOffset: number): void;
+    /** Get the current pending marks (for UI feedback), or null if none. */
+    getPendingMarks(): Record<string, boolean> | null;
+    /** Clear all pending marks. */
+    clearPendingMarks(): void;
+    /**
+     * Called by selectionchange handler. Clears pending marks unless the
+     * clear was suppressed (e.g. because we just inserted text).
+     */
+    selectionDidChange(): void;
+    /** Get current cursor offset within the block's text content */
+    getCursorOffset(): number | null;
+    /** Set cursor to a specific offset */
+    private setCursorOffset;
+    private getSelectionRange;
+    private findTextPosition;
+}

package/dist/block/index.d.ts

@@ -0,0 +1,2 @@
+export { BlockController } from "./block-controller";
+export type { BlockView } from "./types";

package/dist/block/types.d.ts

@@ -0,0 +1,15 @@
+/** Interface for interacting with a mounted block */
+export interface BlockView {
+    /** The block's unique ID */
+    readonly blockId: string;
+    /** The outer container element */
+    readonly container: HTMLElement;
+    /** The contenteditable element (null for non-text blocks) */
+    readonly contentEditable: HTMLElement | null;
+    /** Whether the block is currently mounted in the DOM */
+    readonly mounted: boolean;
+    /** Focus this block, optionally at a specific offset */
+    focus(offset?: number): void;
+    /** Unmount and clean up */
+    destroy(): void;
+}

package/dist/block-action-menu/block-action-menu.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Block action menu: a ⊞ trigger button that appears on hover and opens
+ * a context menu of block-level actions (convert, delete, copy link, etc.).
+ */
+export interface BlockActionMenuEntry {
+    key: string;
+    label: string;
+    icon?: string | ((container: HTMLElement) => void);
+    danger?: boolean;
+    section?: "convert" | "action" | "task" | "danger";
+    disabled?: boolean;
+    /** Dynamic disabled check — called when menu opens with the target block IDs. */
+    isDisabled?: (blockIds: string[]) => boolean;
+    hint?: string;
+    commandName?: string;
+    onAction: (blockIds: string[]) => void;
+}
+export declare class BlockActionMenu {
+    private editorRoot;
+    private gutterEl;
+    private btn;
+    private menu;
+    private getTargetBlockIds;
+    private getMenuItems;
+    private hoveredBlockEl;
+    private menuOpen;
+    private _dragActive;
+    /** Called when the action menu opens/closes — used by editor to hide drag handle */
+    onOpen: (() => void) | null;
+    onClose: (() => void) | null;
+    private keyHandler;
+    private dismissHandle;
+    private scrollHandler;
+    private shouldShowForBlock;
+    constructor(editorRoot: HTMLElement, gutterEl: HTMLElement, getTargetBlockIds: () => string[], getMenuItems: () => BlockActionMenuEntry[], options?: {
+        shouldShowForBlock?: (blockId: string) => boolean;
+    });
+    /** The block ID the trigger button is currently associated with */
+    get hoveredBlockId(): string | null;
+    /** Hide the button and close menu if open (e.g. when user starts typing or dragging) */
+    hide(): void;
+    /** Called by the editor when a block drag starts — suppresses the action button */
+    notifyDragStart(): void;
+    /** Called by the editor when a block drag ends */
+    notifyDragEnd(): void;
+    destroy(): void;
+    private attachListeners;
+    private handleTouchStart;
+    private handleMouseMove;
+    private showBtn;
+    private hideBtn;
+    private findBlockAtY;
+    private handleMouseLeave;
+    private handleBtnLeave;
+    private positionBtn;
+    private handleBtnClick;
+    /** Touch equivalent of click for the action button */
+    private handleBtnTouchEnd;
+    private openMenu;
+    closeMenu(): void;
+    private toMenuItems;
+}

package/dist/block-action-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { BlockActionMenu } from "./block-action-menu";
+export type { BlockActionMenuEntry } from "./block-action-menu";

package/dist/block-context-menu/block-context-menu.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Right-click context menu for blocks.
+ *
+ * Shows clipboard actions (Copy, Cut, Paste) and extensible action items
+ * when the user right-clicks on a block. Reuses the shared ContextMenu
+ * component for rendering and keyboard navigation.
+ */
+export interface BlockContextMenuEntry {
+    key: string;
+    label: string;
+    icon?: string | ((container: HTMLElement) => void);
+    danger?: boolean;
+    section?: string;
+    disabled?: boolean;
+    onAction: (blockIds: string[]) => void;
+}
+export declare class BlockContextMenu {
+    private editorRoot;
+    private menu;
+    private getMenuItems;
+    private resolveTargetBlockIds;
+    private menuOpen;
+    private keyHandler;
+    private dismissHandle;
+    private scrollHandler;
+    private currentBlockIds;
+    constructor(editorRoot: HTMLElement, resolveTargetBlockIds: (e: MouseEvent) => string[], getMenuItems: (blockIds: string[]) => BlockContextMenuEntry[]);
+    get isOpen(): boolean;
+    close(): void;
+    destroy(): void;
+    private handleContextMenu;
+    private toMenuItems;
+}

package/dist/block-context-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { BlockContextMenu } from "./block-context-menu";
+export type { BlockContextMenuEntry } from "./block-context-menu";