@zuilib/text-editor 0.11.1 → 0.12.0

package/dist/index.d.ts

@@ -1,1396 +1,38 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode, ReactElement } from 'react';
-import { LexicalEditor, TextFormatType, ElementNode, NodeKey, EditorConfig, SerializedElementNode, LexicalNode, DecoratorNode, Spread, SerializedLexicalNode, DOMExportOutput, DOMConversionMap } from 'lexical';
-import { TableNode, TableCellNode, TableRowNode } from '@lexical/table';
-import { MultilineElementTransformer, ElementTransformer } from '@lexical/markdown';
-import { registerCodeHighlighting } from '@lexical/code';
-
-/**
- * Horizontal sizing of a block that would otherwise span the editor:
- *
- * - `full` — the container width (the content pane, minus its gutters).
- *   The default; omitted when serialised.
- * - `text` — the text column: the block's edges align with the paragraphs
- *   around it. Only differs from `full` when a measure is set
- *   (`--zui-text-editor-measure` / the `measure` prop); otherwise the two
- *   are visually identical.
- * - `content` — shrinks to fit what is inside (table columns, drawing
- *   shapes), left-aligned with the text and never wider than the column.
- */
-type BlockWidth = 'full' | 'text' | 'content';
-declare const BLOCK_WIDTHS: readonly BlockWidth[];
-declare function isBlockWidth(value: unknown): value is BlockWidth;
-/**
- * Width written into the markdown when a new table / drawing is inserted
- * (`MarkdownEditor.Root`'s `defaultBlockWidth`). Only affects insertion:
- * existing markdown without a width marker always means `full`.
- */
-type BlockWidthDefaults = Readonly<{
-    table?: BlockWidth;
-    drawing?: BlockWidth;
-}>;
-
-/** Card-like shapes: fillable, bindable, carrying the three text slots */
-type BoxType = 'rect' | 'ellipse' | 'diamond' | 'note' | 'cylinder' | 'cloud' | 'queue' | 'actor';
-type ConnectorType = 'arrow' | 'line';
-type DrawingShapeType = BoxType | ConnectorType | 'text';
-declare const BOX_TYPES: readonly BoxType[];
-declare const CONNECTOR_TYPES: readonly ConnectorType[];
-declare const SHAPE_TYPES: readonly DrawingShapeType[];
-type Point = Readonly<{
-    x: number;
-    y: number;
-}>;
-type BindingSide = 'top' | 'right' | 'bottom' | 'left';
-/**
- * Where a connector endpoint attaches to a box.
- *
- * `fixedPoint` is a ratio inside the box's bounding box (`[0,0]` top-left,
- * `[1,1]` bottom-right). Omitted = the box center, which makes the endpoint
- * auto-aim at the other end. `mode: 'inside'` pins the endpoint exactly on
- * the fixed point; the default (`'orbit'`) projects it onto the outline with
- * a small gap.
- */
-type Binding = Readonly<{
-    id: string;
-    fixedPoint?: readonly [number, number];
-    mode?: 'orbit' | 'inside';
-}>;
-type DrawingShape = Readonly<{
-    id: string;
-    type: DrawingShapeType;
-    /** Top-left corner (boxes/text) or start point (connectors) */
-    x: number;
-    y: number;
-    /** Size (boxes/text) or delta to the end point (connectors) */
-    w: number;
-    h: number;
-    stroke: string;
-    fill: string;
-    strokeWidth: number;
-    /** Standalone text, main (center) content of a box, or connector label */
-    text?: string;
-    /** Small heading rendered at the top of a box */
-    label?: string;
-    /** Small line rendered at the bottom of a box */
-    footer?: string;
-    /** Connector: box the start point is attached to */
-    startBinding?: Binding;
-    /** Connector: box the end point is attached to */
-    endBinding?: Binding;
-    /** Arrow: arrowheads on both ends */
-    bidirectional?: boolean;
-    /** Connector routing: right-angled auto-routed path instead of a straight line */
-    routing?: 'elbow';
-    /**
-     * Elbow override: position of the middle segment as a fraction of the
-     * span, applied only when the routed path is a simple three-segment Z.
-     */
-    elbow?: number;
-    /**
-     * Connector: intermediate path points between start and end (absolute
-     * canvas coordinates). Takes precedence over `routing`.
-     */
-    waypoints?: readonly Point[];
-}>;
-type DrawingData = Readonly<{
-    version: 2;
-    /**
-     * Logical canvas width. When set the drawing is scaled to fit narrower
-     * layouts (SVG viewBox); when omitted the canvas is fluid and shapes are
-     * in CSS pixels.
-     */
-    canvasWidth?: number;
-    canvasHeight: number;
-    /**
-     * Block width: `full` (default) spans the editor; `text` aligns with the
-     * text column; `content` fits the shapes' horizontal extent. The editor
-     * omits `full` unless it was written explicitly (an insertion default or
-     * the source payload); unknown values are dropped.
-     */
-    width?: BlockWidth;
-    shapes: readonly DrawingShape[];
-}>;
-declare const EMPTY_DRAWING: DrawingData;
-declare const STROKE_COLORS: readonly ["#1e1e1e", "#e03131", "#2f9e44", "#1971c2", "#f08c00", "#7048e8"];
-declare const FILL_COLORS: readonly ["transparent", "#ffc9c9", "#b2f2bb", "#a5d8ff", "#ffec99", "#d0bfff"];
-/** Edge midpoints, used by the ```diagram skeleton's `side` option */
-declare const SIDE_FIXED_POINTS: Record<BindingSide, readonly [number, number]>;
-declare function serializeDrawingData(data: DrawingData): string;
-/**
- * Parse a ```drawing payload. Exactly one format is accepted: version 2 as
- * written by the editor (the ```diagram skeleton is a separate block type,
- * see skeleton.ts). Shapes that fail validation are dropped and a malformed
- * document yields an empty canvas. Never throws.
- */
-declare function parseDrawingData(json: string): DrawingData;
-declare function normalizeDrawingData(parsed: unknown): DrawingData;
-
-/**
- * "Ink" rendering: one confident pen stroke instead of a plotted outline.
- * Every shape's centerline is resampled densely, displaced along its normal
- * by a smooth low-frequency field (two sines, integer frequencies on closed
- * paths so the seam is continuous) and widened by a slowly varying pressure
- * factor. The result is a filled ring path, not an SVG stroke, so the width
- * can breathe along the path. Everything is seeded from the shape id: the
- * same shape draws the same way on every render, undo, export and machine.
- *
- * This is a renderer concern only — the drawing format never sees it.
- */
-type DrawingStyle = 'clean' | 'ink';
-type InkOptions = Readonly<{
-    closed: boolean;
-    seed: number;
-    /** Nominal stroke width; the pressure factor varies it by ±30 % */
-    width: number;
-    /** Peak displacement from the geometric path, in px */
-    amplitude: number;
-}>;
-type InkStroke = Readonly<{
-    /** Filled outline of the stroke (use `fillRule="evenodd"`) */
-    ring: string;
-    /** Displaced centerline, for fills */
-    center: string;
-}>;
-/** FNV-1a: a stable 32-bit seed from a shape id */
-declare function seedFrom(text: string): number;
-/** Wobble amplitude for a shape of the given smallest dimension (px) */
-declare function inkAmplitude(size: number): number;
-/** Fill misregistration for a shape: a seeded 2–3 px offset */
-declare function inkFillOffset(seed: number): Point;
-/** Ink stroke along a polyline (open) or polygon (closed) */
-declare function inkStroke(points: readonly Point[], options: InkOptions): InkStroke;
-/** Rectangle outline with circular corners, as a polygon */
-declare function roundedRectPolygon(r: Readonly<{
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}>, radius: number, segments?: number): Point[];
-/** Polyline with its interior corners rounded (quadratic), as points */
-declare function roundedPolyline(points: readonly Point[], cornerRadius?: number, segments?: number): Point[];
-
-type EditorMode = 'edit-raw' | 'edit-md' | 'view';
-
-type EditorRootProps = Readonly<{
-    value?: string;
-    onChange?: (value: string) => void;
-    readOnly?: boolean;
-    className?: string;
-    mode?: EditorMode;
-    autoFocus?: boolean;
-    /**
-     * Text measure: the maximum width of the text column, as a CSS length
-     * (`'48rem'` recommended). Text blocks are capped at this width and
-     * centred; tables and drawings choose per block whether to align with
-     * the column (`text`), span the pane (`full`) or hug their content.
-     * Sugar for setting `--zui-text-editor-measure` on the root; the
-     * variable can equally be set from a stylesheet. Unset: no measure, every
-     * block spans the pane.
-     */
-    measure?: string;
-    /**
-     * Width written into the markdown when the toolbar or
-     * `useMarkdownEditor()` inserts a new table / drawing. Only affects
-     * insertion — markdown without a width marker always means `full`.
-     */
-    defaultBlockWidth?: BlockWidthDefaults;
-    /**
-     * `clean` (default) draws crisp geometry; `ink` draws every shape as a
-     * single pen stroke with pressure and slightly misregistered fills, and
-     * sets the casual face (Recursive, if the host loads it).
-     */
-    drawingStyle?: DrawingStyle;
-    children: ReactNode;
-}>;
-/**
- * Owns the Lexical composer and every non-visual plugin. Anything rendered
- * beneath it (`Content`, `Toolbar`, `Outline`, or your own components using
- * `useMarkdownEditor`) shares the same editor instance.
- */
-declare function EditorRoot({ value, onChange, readOnly, className, mode, autoFocus, measure, defaultBlockWidth, drawingStyle, children, }: EditorRootProps): ReactElement;
-
-type EditorContentProps = Readonly<{
-    placeholder?: string;
-    /** Allow collapsing sections under their headings (default true) */
-    foldable?: boolean;
-    /** Sidebars docked next to the content, e.g. `<MarkdownEditor.Outline />` */
-    children?: ReactNode;
-}>;
-/**
- * The editable surface. Renders a plain textarea in `edit-raw` mode and the
- * Lexical rich-text surface otherwise.
- */
-declare function EditorContent({ placeholder, foldable, children, }: EditorContentProps): ReactElement;
-
-/**
- * Docked, collapsible table-of-contents sidebar. Lists the document's
- * headings (live), scrolls to a heading on click, and highlights the section
- * the viewport is currently in. Pure UI — nothing is added to the document.
- */
-declare function OutlinePlugin(): ReactElement;
-
-/** Cell padding / font size preset */
-type TableDensity = 'compact' | 'comfortable' | 'spacious';
-type TableSettings = Readonly<{
-    width: BlockWidth;
-    density: TableDensity;
-}>;
-declare const DEFAULT_TABLE_SETTINGS: TableSettings;
-type TableSettingsOptions = Readonly<{
-    /** Persist the width even when it is `full` */
-    explicitWidth?: boolean;
-}>;
-declare function $getTableSettings(table: TableNode): TableSettings;
-declare function $setTableSettings(table: TableNode, settings: Partial<TableSettings>, options?: TableSettingsOptions): void;
-/** Whether the table's width should be persisted even when it is `full` */
-declare function $isTableWidthExplicit(table: TableNode): boolean;
-declare function $getTableWidth(table: TableNode): BlockWidth;
-declare function $setTableWidth(table: TableNode, width: BlockWidth): void;
-declare function $getTableDensity(table: TableNode): TableDensity;
-declare function $setTableDensity(table: TableNode, density: TableDensity): void;
-/** The table containing the current selection (caret or cell range), if any */
-declare function $getSelectedTable(): TableNode | null;
-/** @deprecated Use `formatTableSettingsMarker({ ...DEFAULT_TABLE_SETTINGS, width: 'content' })` */
-declare const TABLE_WIDTH_MARKER = "<!-- width: content -->";
-/**
- * Settings encoded in a marker line, or null if the text is not a marker.
- * A marker naming a known setting with an unknown value yields that setting
- * omitted (possibly an empty object): the line is still a settings marker.
- */
-declare function parseTableSettingsMarker(text: string): Partial<TableSettings> | null;
-/**
- * Marker line for the given settings, or null when everything is default.
- * With `explicitWidth` the width is listed even when it is `full`.
- */
-declare function formatTableSettingsMarker(settings: TableSettings, options?: TableSettingsOptions): string | null;
-
-/**
- * Row and column operations for GFM tables. Markdown tables have no merged
- * cells, every row has the same number of cells and there is exactly one
- * header row (the first), so these helpers work on plain indices and keep
- * that shape: a row can't be inserted above the header, deleting the
- * header promotes the row below it, and new cells in the header row are
- * header cells.
- */
-/** Where the selection sits in its table */
-type TableCellPosition = Readonly<{
-    /** Row index of the caret (or of the anchor cell of a cell range) */
-    row: number;
-    /** Column index of that cell */
-    column: number;
-    /** Number of rows in the table */
-    rows: number;
-    /** Number of columns in the table */
-    columns: number;
-    /** Whether the first row is a header row */
-    hasHeader: boolean;
-}>;
-/** The cell containing the selection (caret or the anchor of a cell range) */
-declare function $getSelectedTableCell(): TableCellNode | null;
-/** Where the selection sits in its table, or null outside tables */
-declare function $getTableCellPosition(): TableCellPosition | null;
-/**
- * The row boundaries a new row may be inserted at: `0..rows`, minus `0`
- * when the first row is a header (a table's header is always its first row).
- */
-declare function insertableRowIndices(position: Pick<TableCellPosition, 'rows' | 'hasHeader'>): number[];
-/** A row can be removed as long as one row stays */
-declare function canDeleteRow(position: Pick<TableCellPosition, 'rows'>): boolean;
-/**
- * Insert an empty row so that it becomes row `index` (`0` = first, `rows`
- * = last). Column header state is copied from the row above; the header
- * row itself is never displaced, so `index` is clamped to `1` when the
- * table has a header. The caret moves into the new row, at `column`.
- */
-declare function $insertTableRowAt(table: TableNode, index: number, column?: number): TableRowNode;
-/**
- * Remove row `index`. No-op on a single-row table (see `canDeleteRow`).
- * Removing the header row makes the next row the header so the markdown
- * keeps its divider. The caret moves to the row that takes the removed
- * row's place (or the last row), at `column`.
- */
-declare function $deleteTableRowAt(table: TableNode, index: number, column?: number): boolean;
-/** Insert a row next to the selection's row. Returns the new row, or null outside tables. */
-declare function $insertTableRowNear(table: TableNode, position: 'above' | 'below'): TableRowNode | null;
-/** Remove the selection's row. Returns false when nothing was removed. */
-declare function $deleteSelectedTableRow(table: TableNode): boolean;
-/** The column boundaries a new column may be inserted at: `0..columns` */
-declare function insertableColumnIndices(position: Pick<TableCellPosition, 'columns'>): number[];
-/** A column can be removed as long as one column stays */
-declare function canDeleteColumn(position: Pick<TableCellPosition, 'columns'>): boolean;
-/**
- * Insert an empty column so that it becomes column `index` (`0` = first,
- * `columns` = last). Cells in the header row are header cells. The caret
- * moves into the new column, at `row`.
- */
-declare function $insertTableColumnAt(table: TableNode, index: number, row?: number): void;
-/**
- * Remove column `index`. No-op on a single-column table (see
- * `canDeleteColumn`). The caret moves to the column that takes the removed
- * column's place (or the last column), at `row`.
- */
-declare function $deleteTableColumnAt(table: TableNode, index: number, row?: number): boolean;
-/** Insert a column next to the selection's column; no-op outside tables. */
-declare function $insertTableColumnNear(table: TableNode, position: 'before' | 'after'): boolean;
-/** Remove the selection's column. Returns false when nothing was removed. */
-declare function $deleteSelectedTableColumn(table: TableNode): boolean;
-
-type MarkdownEditorApi = Readonly<{
-    /** The underlying Lexical editor, for dispatching your own commands */
-    editor: LexicalEditor;
-    /** Text formats active at the current selection */
-    activeFormats: ReadonlySet<TextFormatType>;
-    toggleFormat: (format: TextFormatType) => void;
-    /**
-     * Insert a table at the selection. `width` defaults to
-     * `defaultBlockWidth.table` (Root prop); when given it is written to the
-     * markdown explicitly, even when `full`.
-     */
-    insertTable: (options?: {
-        rows?: number;
-        columns?: number;
-        width?: BlockWidth;
-    }) => void;
-    /**
-     * Insert an empty drawing at the selection. `width` defaults to
-     * `defaultBlockWidth.drawing` (Root prop); when given it is written to
-     * the markdown explicitly, even when `full`.
-     */
-    insertDrawing: (options?: {
-        width?: BlockWidth;
-    }) => void;
-    /**
-     * Width of the block containing the selection — the focused drawing, or
-     * else the table the caret is in; `null` outside both.
-     */
-    blockWidth: BlockWidth | null;
-    /** Resize that block; no-op when `blockWidth` is `null` */
-    setBlockWidth: (width: BlockWidth) => void;
-    /**
-     * Width of the table containing the selection; `null` outside tables.
-     * @deprecated Use `blockWidth`, which also covers drawings.
-     */
-    tableWidth: BlockWidth | null;
-    /**
-     * Resize the table containing the selection; no-op outside tables.
-     * @deprecated Use `setBlockWidth`, which also covers drawings.
-     */
-    setTableWidth: (width: BlockWidth) => void;
-    /** Density of the table containing the selection; `null` outside tables */
-    tableDensity: TableDensity | null;
-    /** Change the density of the table containing the selection; no-op outside tables */
-    setTableDensity: (density: TableDensity) => void;
-    /** The selection's cell in its table (row, column, counts, header); `null` outside tables */
-    tableCell: TableCellPosition | null;
-    /**
-     * Insert an empty row next to the selection's row (default `below`) and
-     * move the caret into it; no-op outside tables. A row is never inserted
-     * above the header row: `above` there inserts right below it.
-     */
-    insertTableRow: (position?: 'above' | 'below') => void;
-    /**
-     * Remove the selection's row; no-op outside tables and on the last
-     * remaining row. Deleting the header row makes the next row the header.
-     */
-    deleteTableRow: () => void;
-    /**
-     * Insert an empty column next to the selection's column (default
-     * `after`) and move the caret into it; no-op outside tables.
-     */
-    insertTableColumn: (position?: 'before' | 'after') => void;
-    /** Remove the selection's column; no-op outside tables and on the last remaining column. */
-    deleteTableColumn: () => void;
-    canUndo: boolean;
-    canRedo: boolean;
-    undo: () => void;
-    redo: () => void;
-}>;
-/**
- * Headless access to the editor. Must be rendered under `MarkdownEditor.Root`
- * (or `MarkdownEditor`). Use it to wire editor actions into your own buttons.
- */
-declare function useMarkdownEditor(): MarkdownEditorApi;
-
-/** Default toolbar groups, handed to a `toolbar` render function */
-type ToolbarItems = Readonly<{
-    format: ReactElement;
-    insert: ReactElement;
-    history: ReactElement;
-}>;
-type Props = Omit<EditorRootProps, 'children'> & Readonly<{
-    placeholder?: string;
-    /**
-     * Toolbar in edit-md mode (default true). Pass a function to customise
-     * it: it receives the default groups and returns the toolbar to render.
-     */
-    toolbar?: boolean | ((items: ToolbarItems) => ReactNode);
-    /** Show a table-of-contents sidebar listing the document's headings */
-    outline?: boolean;
-    /** Allow collapsing sections under their headings (default true) */
-    foldable?: boolean;
-}>;
-/**
- * Toolbar that only shows while the document is editable in `edit-md` mode.
- * Used by `MarkdownEditor` and available as `MarkdownEditor.Toolbar` for
- * compound layouts.
- */
-declare function EditorToolbar({ children, className, }: Readonly<{
-    children?: ReactNode;
-    className?: string;
-}>): ReactElement | null;
-declare function MarkdownEditor({ placeholder, toolbar, outline, foldable, ...rootProps }: Props): react_jsx_runtime.JSX.Element;
-declare namespace MarkdownEditor {
-    var Root: typeof EditorRoot;
-    var Content: typeof EditorContent;
-    var Toolbar: typeof EditorToolbar;
-    var ToolbarButton: typeof ToolbarButton;
-    var ToolbarDivider: typeof ToolbarDivider;
-    var FormatButtons: typeof FormatButtons;
-    var InsertButtons: typeof InsertButtons;
-    var HistoryButtons: typeof HistoryButtons;
-    var Outline: typeof OutlinePlugin;
-    var useEditor: typeof useMarkdownEditor;
-}
-
-type ToolbarProps = Readonly<{
-    children?: ReactNode;
-    className?: string;
-}>;
-/** Toolbar container. Renders the default items when given no children. */
-declare function Toolbar({ children, className }: ToolbarProps): ReactElement;
-declare function ToolbarDivider(): ReactElement;
-type ToolbarButtonProps = Readonly<{
-    label: string;
-    onClick: () => void;
-    /** Icon content — an SVG, emoji, or text. 16px SVGs match the built-ins. */
-    children: ReactNode;
-    active?: boolean;
-    disabled?: boolean;
-    className?: string;
-}>;
-/**
- * Button styled like the built-in toolbar buttons. Prevents focus from
- * leaving the editor on click so the selection is preserved.
- */
-declare function ToolbarButton({ label, onClick, children, active, disabled, className, }: ToolbarButtonProps): ReactElement;
-/** Bold / italic / strikethrough / inline-code buttons */
-declare function FormatButtons(): ReactElement;
-/** Insert-table / insert-drawing buttons */
-declare function InsertButtons(): ReactElement;
-/** Undo / redo buttons */
-declare function HistoryButtons(): ReactElement;
-
-type SerializedFrontmatterNode = SerializedElementNode;
-/**
- * A block node holding a document's YAML frontmatter — the metadata section
- * delimited by `---` lines at the very top of a markdown file (as used by
- * Claude skills, static-site generators, etc.).
- *
- * Content is stored as plain TextNode children separated by LineBreakNodes, so
- * `getTextContent()` yields the raw YAML with `\n` line separators — exactly
- * what the FRONTMATTER transformer re-serializes on export.
- */
-declare class FrontmatterNode extends ElementNode {
-    static getType(): string;
-    static clone(node: FrontmatterNode): FrontmatterNode;
-    constructor(key?: NodeKey);
-    createDOM(config: EditorConfig): HTMLElement;
-    updateDOM(): boolean;
-    static importJSON(_serializedNode: SerializedFrontmatterNode): FrontmatterNode;
-    exportJSON(): SerializedFrontmatterNode;
-    isInline(): false;
-    canBeEmpty(): boolean;
-    canIndent(): false;
-}
-declare function $createFrontmatterNode(): FrontmatterNode;
-declare function $isFrontmatterNode(node: LexicalNode | null | undefined): node is FrontmatterNode;
-/**
- * Markdown transformer for a leading YAML frontmatter block:
- *
- * ```
- * ---
- * name: my-skill
- * description: ...
- * ---
- * ```
- *
- * Import only claims the block when it's the very first thing in the document
- * (frontmatter is defined as leading metadata); a `---` fence appearing later
- * falls through to normal handling. Must be ordered before other multiline
- * transformers so its `export` runs first for a FrontmatterNode.
- */
-declare const FRONTMATTER: MultilineElementTransformer;
-
-type SerializedDrawingNode = Spread<{
-    data: string;
-}, SerializedLexicalNode>;
-/**
- * A block-level decorator node embedding a vector diagram (cards, connectors,
- * text) edited on a canvas.
- *
- * The drawing is stored as a JSON string and round-trips through markdown as
- * a ```drawing fenced code block, so documents remain plain markdown.
- */
-declare class DrawingNode extends DecoratorNode<ReactElement> {
-    __data: string;
-    static getType(): string;
-    static clone(node: DrawingNode): DrawingNode;
-    constructor(data: string, key?: NodeKey);
-    static importJSON(serializedNode: SerializedDrawingNode): DrawingNode;
-    exportJSON(): SerializedDrawingNode;
-    createDOM(config: EditorConfig): HTMLElement;
-    updateDOM(): false;
-    exportDOM(): DOMExportOutput;
-    static importDOM(): DOMConversionMap | null;
-    getData(): DrawingData;
-    setData(data: DrawingData): void;
-    isInline(): false;
-    decorate(_editor: LexicalEditor, _config: EditorConfig): ReactElement;
-}
-declare function $createDrawingNode(data?: string): DrawingNode;
-declare function $isDrawingNode(node: LexicalNode | null | undefined): node is DrawingNode;
-/**
- * Markdown transformer persisting drawings as fenced ```drawing blocks with a
- * JSON payload. Must be ordered before the built-in CODE transformer so it
- * claims the fence first on import.
- */
-declare const DRAWING: MultilineElementTransformer;
-/**
- * Import-only transformer for ```diagram blocks: a compact skeleton
- * (boxes, connectors by id, auto layout) that expands into a full drawing.
- * Once in the editor the node is a regular drawing and exports as
- * ```drawing, so the expansion is one-way.
- */
-declare const DIAGRAM: MultilineElementTransformer;
-
-/**
- * Markdown transformer for GFM tables. Adapted from the Lexical playground.
- * Rows are matched line-by-line on import and stitched into a single
- * TableNode; the divider row promotes the row above it to a header row.
- * A `<!-- width: text; density: compact -->` settings line directly
- * above the table (see tableSettings.ts) is consumed on import and
- * re-emitted on export.
- */
-declare const TABLE: ElementTransformer;
-
-/**
- * JSON Schema (draft-07) for the payload of a ```drawing fenced block
- * (format version 2).
- *
- * Use it to validate LLM- or tool-generated drawings before embedding them,
- * or pass it as a structured-output / tool schema so a model is forced to
- * emit valid payloads. Kept in sync with `parseDrawingData` /
- * `normalizeShape` in types.ts; update both together.
- *
- * For generation prefer the ```diagram skeleton
- * (`DRAWING_SKELETON_JSON_SCHEMA`): it needs no coordinates and expands into
- * this format on import.
- */
-declare const DRAWING_DATA_JSON_SCHEMA: {
-    readonly $schema: "http://json-schema.org/draft-07/schema#";
-    readonly title: "DrawingData";
-    readonly description: "Vector drawing embedded in markdown as a ```drawing fenced code block (format version 2)";
-    readonly type: "object";
-    readonly required: readonly ["version", "canvasHeight", "shapes"];
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly version: {
-            readonly const: 2;
-            readonly description: "Format version; always 2";
-        };
-        readonly canvasHeight: {
-            readonly type: "number";
-            readonly minimum: 80;
-            readonly description: "Canvas height in pixels. Make it large enough to contain every shape plus ~20px margin.";
-        };
-        readonly canvasWidth: {
-            readonly type: "number";
-            readonly minimum: 120;
-            readonly description: "Optional logical canvas width in pixels. When set, the drawing is scaled down to fit narrower layouts (SVG viewBox) so coordinates can assume this width. When omitted the canvas is fluid and coordinates are CSS pixels.";
-        };
-        readonly width: {
-            readonly enum: readonly ["full", "text", "content"];
-            readonly description: "Block width: \"full\" (default, omit it) spans the editor; \"text\" aligns the block with the text column (same as \"full\" unless the app sets a text measure); \"content\" fits the shapes' horizontal extent and left-aligns with the text";
-        };
-        readonly shapes: {
-            readonly type: "array";
-            readonly items: {
-                readonly $ref: "#/definitions/shape";
-            };
-            readonly description: "Render order: later shapes draw on top";
-        };
-    };
-    readonly definitions: {
-        readonly point: {
-            readonly type: "object";
-            readonly required: readonly ["x", "y"];
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly x: {
-                    readonly type: "number";
-                    readonly description: "Absolute canvas x";
-                };
-                readonly y: {
-                    readonly type: "number";
-                    readonly description: "Absolute canvas y";
-                };
-            };
-        };
-        readonly binding: {
-            readonly type: "object";
-            readonly description: "Where a connector endpoint attaches to a box. Omit fixedPoint to let the endpoint auto-aim from the box center at the other end.";
-            readonly required: readonly ["id"];
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly id: {
-                    readonly type: "string";
-                    readonly description: "Id of the box this endpoint is attached to";
-                };
-                readonly fixedPoint: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "number";
-                        readonly minimum: 0;
-                        readonly maximum: 1;
-                    };
-                    readonly minItems: 2;
-                    readonly maxItems: 2;
-                    readonly description: "Attach point as a ratio of the box's bounding box: [0,0] top-left, [1,1] bottom-right, [0.5,0] top edge midpoint, [1,0.5] right edge midpoint. Omitted: the endpoint auto-aims from the box center at the other end.";
-                };
-                readonly mode: {
-                    readonly enum: readonly ["orbit", "inside"];
-                    readonly description: "\"orbit\" (default): the endpoint is projected onto the box outline with a 6px gap. \"inside\": the endpoint sits exactly on the fixed point.";
-                };
-            };
-        };
-        readonly shape: {
-            readonly type: "object";
-            readonly required: readonly ["id", "type", "x", "y", "w", "h", "stroke", "fill", "strokeWidth"];
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly id: {
-                    readonly type: "string";
-                    readonly description: "Unique within the drawing; connector bindings reference it";
-                };
-                readonly type: {
-                    readonly enum: readonly ["rect", "ellipse", "diamond", "note", "cylinder", "cloud", "queue", "actor", "arrow", "line", "text"];
-                    readonly description: "Boxes (cards with label/text/footer slots): rect, ellipse, diamond, note (sticky note with a folded corner), cylinder (database), cloud, queue (horizontal cylinder), actor (stick figure; only the text slot, rendered as a name under the figure). Connectors: arrow (head at the end), line. Free-floating annotation: text.";
-                };
-                readonly x: {
-                    readonly type: "number";
-                    readonly description: "Boxes/text: left edge of the bounding box. Connectors: start point x.";
-                };
-                readonly y: {
-                    readonly type: "number";
-                    readonly description: "Boxes/text: top edge of the bounding box. Connectors: start point y.";
-                };
-                readonly w: {
-                    readonly type: "number";
-                    readonly description: "Boxes/text: width (non-negative). Connectors: delta x to the end point (may be negative).";
-                };
-                readonly h: {
-                    readonly type: "number";
-                    readonly description: "Boxes/text: height (non-negative). Connectors: delta y to the end point (may be negative).";
-                };
-                readonly stroke: {
-                    readonly type: "string";
-                    readonly description: "CSS color of the outline (and of any text). Palette: #1e1e1e (default), #e03131 red, #2f9e44 green, #1971c2 blue, #f08c00 orange, #7048e8 purple.";
-                };
-                readonly fill: {
-                    readonly type: "string";
-                    readonly description: "CSS color of the interior; \"transparent\" for none. Palette: #ffc9c9 red, #b2f2bb green, #a5d8ff blue, #ffec99 yellow, #d0bfff purple.";
-                };
-                readonly strokeWidth: {
-                    readonly type: "number";
-                    readonly description: "Outline width; use 2";
-                };
-                readonly text: {
-                    readonly type: "string";
-                    readonly description: "Standalone text content; center content of a box (the name under an actor); midpoint label of a connector";
-                };
-                readonly label: {
-                    readonly type: "string";
-                    readonly description: "Boxes only (not actor): small bold heading at the top";
-                };
-                readonly footer: {
-                    readonly type: "string";
-                    readonly description: "Boxes only (not actor): small dim line at the bottom";
-                };
-                readonly startBinding: {
-                    readonly $ref: "#/definitions/binding";
-                    readonly description: "Connectors only: box the start point attaches to. The editor re-anchors the endpoint onto that box and keeps it attached as the box moves.";
-                };
-                readonly endBinding: {
-                    readonly $ref: "#/definitions/binding";
-                    readonly description: "Connectors only: box the end point attaches to";
-                };
-                readonly bidirectional: {
-                    readonly type: "boolean";
-                    readonly description: "Arrows only: arrowheads on both ends";
-                };
-                readonly routing: {
-                    readonly const: "elbow";
-                    readonly description: "Connectors only: right-angled auto-routed path. It leaves the box perpendicular to the attach side, avoids every box on the canvas and minimises bends. Ignored when waypoints are present.";
-                };
-                readonly elbow: {
-                    readonly type: "number";
-                    readonly minimum: 0;
-                    readonly maximum: 1;
-                    readonly description: "Elbow override: position of the middle segment as a fraction of the span. Applied only when the routed path is a simple three-segment Z.";
-                };
-                readonly waypoints: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly $ref: "#/definitions/point";
-                    };
-                    readonly description: "Connectors only: intermediate path points in canvas coordinates, ordered start to end. Takes precedence over routing.";
-                };
-            };
-        };
-    };
+import { M as MarkdownEditorProps, E as EditorRootProps, a as EditorContent, T as ToolbarButton, b as ToolbarDivider, F as FormatButtons, B as BlockButtons, I as InsertButtons, H as HistoryButtons, O as OutlinePlugin, C as CharacterCount } from './table-grid-D70tNhp2.js';
+export { D as DEFAULT_LABELS, c as DEFAULT_TABLE_SETTINGS, d as DeepPartial, e as EditorContentProps, f as EditorFieldProps, g as EditorLabels, h as EditorLabelsInput, i as EditorMode, j as TABLE_WIDTH_MARKER, k as TableCellPosition, l as TableDensity, m as TableSettings, n as TableSettingsOptions, o as Toolbar, p as ToolbarItems, q as canDeleteColumn, r as canDeleteRow, s as formatTableSettingsMarker, t as insertableColumnIndices, u as insertableRowIndices, v as parseTableSettingsMarker, w as resolveLabels, x as useEditorContext, y as useLabels } from './table-grid-D70tNhp2.js';
+export { B as BUILTIN_CODE_LANGUAGES, a as BlockType, C as CODE_TOKEN_TYPES, b as CodeGrammar, c as CodeRule, d as CodeToken, e as CodeTokenType, f as CollapsibleHeadingsLabels, E as EDIT_LINK_COMMAND, M as MarkdownEditorApi, P as PLAIN_LANGUAGE, S as SAFE_LINK_PROTOCOLS, T as TOOLBAR_ITEM_ATTRIBUTE, g as TableColumnShortcutsLabels, h as TableRowShortcutsLabels, i as getCodeLanguages, j as hasCodeLanguage, k as isSafeUrl, r as registerCodeLanguage, l as resolveCodeLanguage, t as tokenizeCode, u as useMarkdownEditor, m as useToolbarKeyboard } from './index-A4S7bRwQ.js';
+export { B as BLOCK_WIDTHS, a as BlockWidth, D as DrawingStyle, N as NewBlockWidths, i as isBlockWidth } from './presets-BtNPH0pa.js';
+import * as react from 'react';
+export { C as COLOR_PRESETS, a as ColorName, D as DRAWING_DATA_JSON_SCHEMA, b as DRAWING_FOCUS_COMMAND, c as DRAWING_SKELETON_JSON_SCHEMA, d as DrawingPlugin, e as DrawingSkeleton, I as INSERT_DRAWING_COMMAND, M as MermaidDirection, f as MermaidOptions, N as NODE_SHAPE_DEFINITIONS, g as NodeShapeDefinition, S as SkeletonBox, h as SkeletonConnector, i as SkeletonEnd, j as SkeletonText, T as TextField, k as createBinding, l as drawingToMermaid, m as expandDrawingSkeleton, n as findNodeShapeAt, o as isDrawingSkeleton, p as parseDrawingSkeleton } from './mermaid-BwGHjwpk.js';
+export { B as Binding, a as BindingSide, C as CONNECTOR_TYPES, b as ConnectorType, D as DrawingData, c as DrawingShape, d as DrawingShapeType, E as EMPTY_DRAWING, F as FILL_COLORS, N as NODE_SHAPE_TYPES, e as NodeShapeType, P as Point, S as SHAPE_TYPES, f as SIDE_FIXED_POINTS, g as STROKE_COLORS, h as deserializeDrawingData, i as isNodeShapeType, n as normalizeDrawingData, s as serializeDrawingData } from './drawing-data-EWzEQ1_i.js';
+export { D as DEFAULT_MENTIONS_LABELS, I as INSERT_MENTION_COMMAND, a as InsertMentionPayload, M as MentionItem, b as MentionMatch, c as MentionRenderState, d as MentionTrigger, e as MentionsLabels, f as MentionsPlugin, g as MentionsPluginProps, h as findMentionMatch } from './mentions-plugin-gio3_XKd.js';
+export { ADD_COMMENT_COMMAND, COMMENTS_THEME, Comment, CommentActions, CommentRange, CommentsLabels, CommentsPlugin, CommentsPluginProps, DEFAULT_COMMENTS_LABELS } from './comments.js';
+export { f as formatCommentMarker, p as parseCommentIds } from './comment-markers-BrrrAdSL.js';
+export { INSERT_IMAGE_COMMAND, ImageButton, ImageError, ImagesPlugin, ImagesPluginProps, InsertImagePayload, UPLOAD_IMAGES_COMMAND, UploadedImage } from './images.js';
+export { D as DEFAULT_IMAGES_LABELS, I as ImagesLabels } from './image-node-kR1Zf5kz.js';
+export { PasteNormalizeOptions, PastePlugin, PastePluginProps, isRichSourceHtml, normalizePastedHtml } from './paste.js';
+import 'lexical';
+import '@lexical/table';
+import '@lexical/rich-text';
+import '@lexical/markdown';
+import '@lexical/mark';
+
+declare const MarkdownEditor: {
+    ({ placeholder, toolbar, outline, collapsible, showCharacterCount, children, ...rootProps }: MarkdownEditorProps): react.ReactElement;
+    Root: (props: Omit<EditorRootProps, "preset">) => react.ReactElement;
+    Content: typeof EditorContent;
+    Toolbar: ({ children, className, }: Readonly<{
+        children?: react.ReactNode;
+        className?: string;
+    }>) => react.ReactElement | null;
+    ToolbarButton: typeof ToolbarButton;
+    ToolbarDivider: typeof ToolbarDivider;
+    FormatButtons: typeof FormatButtons;
+    BlockButtons: typeof BlockButtons;
+    InsertButtons: typeof InsertButtons;
+    HistoryButtons: typeof HistoryButtons;
+    Outline: typeof OutlinePlugin;
+    CharacterCount: typeof CharacterCount;
 };
 
-type Rect = Readonly<{
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}>;
-
-declare function boxOutline(box: DrawingShape): Point[];
-/** Topmost box under a point, if any; smaller boxes win over enclosing ones */
-declare function findBoxAt(shapes: readonly DrawingShape[], point: Point, excludeId?: string, tolerance?: number): DrawingShape | null;
-/** The point a binding refers to: its fixed point, or the box center */
-declare function anchorPoint(box: DrawingShape, binding?: Binding): Point;
-/**
- * Fixed point for a drop at `point`: undefined (auto-aim) for drops near
- * the center, otherwise a ratio snapped onto the nearest bounding-box edge.
- */
-declare function fixedPointFor(box: DrawingShape, point: Point): [number, number] | undefined;
-/**
- * Recompute the endpoints of every bound connector from the current
- * positions of the boxes they're attached to, and drop bindings whose box
- * no longer exists. Idempotent, so it can run after every shape update.
- */
-declare function resolveBindings(shapes: readonly DrawingShape[]): readonly DrawingShape[];
-/** Attach a freshly drawn connector to the boxes under its endpoints */
-declare function bindEndpoints(shape: DrawingShape, shapes: readonly DrawingShape[]): DrawingShape;
-declare function makeBinding(box: DrawingShape, point: Point): Binding;
-
-/** Vertices of a connector's path, start to end */
-declare function connectorPoints(shape: DrawingShape, shapes?: readonly DrawingShape[]): Point[];
-
-/**
- * Orthogonal route for an elbow connector: leaves each bound box
- * perpendicular to its attach side, avoids every box on the canvas, and
- * takes the path with the fewest bends (then the shortest). Falls back to
- * a plain L when the grid search fails.
- */
-declare function routeElbow(shape: DrawingShape, shapes: readonly DrawingShape[]): Point[];
-
-type TextField = 'text' | 'label' | 'footer';
-/**
- * Geometry of a box type, kept free of React so the router, bindings,
- * skeleton expansion and exporters can use it without a DOM.
- */
-type BoxDefinition = Readonly<{
-    type: BoxType;
-    label: string;
-    /** Size used when a shape is created without explicit dimensions */
-    defaultSize: Readonly<{
-        w: number;
-        h: number;
-    }>;
-    /** Text slots the shape renders (and offers for editing) */
-    textSlots: readonly TextField[];
-    /** Fill applied when the tool is picked with the default (transparent) fill */
-    defaultFill?: string;
-    /** Closed outline used for hit-testing and binding endpoints */
-    outline: (shape: DrawingShape) => Point[];
-    /** Area the text slots lay out in */
-    textArea: (shape: DrawingShape) => Rect;
-}>;
-declare const BOX_DEFINITIONS: Record<BoxType, BoxDefinition>;
-
-/**
- * Skeleton (intent) layer: a compact, LLM-friendly description of a diagram
- * — boxes, connectors between them and loose texts — that expands into a
- * full `DrawingData` document. Sizes, positions and connector geometry are
- * derived, so a generator only needs to say *what* is on the canvas.
- */
-
-type ColorName = 'plain' | 'black' | 'gray' | 'red' | 'green' | 'blue' | 'orange' | 'purple';
-declare const COLOR_PRESETS: Record<ColorName, {
-    stroke: string;
-    fill: string;
-}>;
-type SkeletonBox = Readonly<{
-    id: string;
-    /** Default `'rect'` */
-    type?: BoxType;
-    label?: string;
-    text?: string;
-    footer?: string;
-    /** Omitted → auto layout */
-    x?: number;
-    y?: number;
-    /** Omitted → measured from the text, never smaller than the type's default size */
-    w?: number;
-    h?: number;
-    /** Preset → stroke + fill (fill only when `fill` isn't given) */
-    color?: ColorName;
-    stroke?: string;
-    fill?: string;
-}>;
-type SkeletonEnd = string | Readonly<{
-    id: string;
-    side?: BindingSide;
-}>;
-type SkeletonConnector = Readonly<{
-    id?: string;
-    /** Default `'arrow'` */
-    type?: ConnectorType;
-    from: SkeletonEnd;
-    to: SkeletonEnd;
-    text?: string;
-    bidirectional?: boolean;
-    /** Default `'straight'` */
-    routing?: 'elbow' | 'straight';
-    color?: ColorName;
-    stroke?: string;
-}>;
-type SkeletonText = Readonly<{
-    id?: string;
-    x: number;
-    y: number;
-    text: string;
-    color?: ColorName;
-    stroke?: string;
-}>;
-type DrawingSkeleton = Readonly<{
-    /** Auto-layout flow direction, default `'right'` */
-    direction?: 'right' | 'down';
-    canvasWidth?: number;
-    canvasHeight?: number;
-    /** Block width of the expanded drawing; omit for `full` */
-    width?: BlockWidth;
-    boxes: readonly SkeletonBox[];
-    connectors?: readonly SkeletonConnector[];
-    texts?: readonly SkeletonText[];
-}>;
-/** Structural check: an object with a `boxes` array */
-declare function isDrawingSkeleton(value: unknown): value is DrawingSkeleton;
-/**
- * Parse a skeleton JSON payload into drawing data. Lenient: invalid boxes,
- * connectors and texts are dropped individually, and a malformed document
- * yields an empty canvas. Never throws.
- */
-declare function parseDrawingSkeleton(json: string): DrawingData;
-declare function expandSkeleton(skeleton: DrawingSkeleton): DrawingData;
-declare const DRAWING_SKELETON_JSON_SCHEMA: {
-    readonly $schema: "http://json-schema.org/draft-07/schema#";
-    readonly title: "DrawingSkeleton";
-    readonly description: "Compact intent description of a diagram. Boxes are sized from their text and laid out automatically along the connector flow; connectors are drawn between box outlines. Only say what is on the canvas — geometry is derived";
-    readonly type: "object";
-    readonly required: readonly ["boxes"];
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly direction: {
-            readonly enum: readonly ["right", "down"];
-            readonly description: "Auto-layout flow direction. Boxes connected a→b are placed in successive ranks along this axis (\"right\" = columns left to right, \"down\" = rows top to bottom). Default \"right\"";
-        };
-        readonly canvasWidth: {
-            readonly type: "number";
-            readonly minimum: 120;
-            readonly description: "Logical canvas width in px. Omit for a fluid canvas in CSS pixels";
-        };
-        readonly canvasHeight: {
-            readonly type: "number";
-            readonly minimum: 80;
-            readonly description: "Canvas height in px. Omit to fit the content";
-        };
-        readonly width: {
-            readonly enum: readonly ["full", "text", "content"];
-            readonly description: "Block width: \"text\" aligns the drawing with the text column (same as \"full\" unless the app sets a text measure); \"content\" fits the drawing to its shapes and left-aligns it with the text; omit to span the editor";
-        };
-        readonly boxes: {
-            readonly type: "array";
-            readonly items: {
-                readonly $ref: "#/definitions/box";
-            };
-            readonly description: "Card-like shapes carrying up to three text slots. Order is the render order and the stacking order within a layout rank";
-        };
-        readonly connectors: {
-            readonly type: "array";
-            readonly items: {
-                readonly $ref: "#/definitions/connector";
-            };
-            readonly description: "Arrows and lines between boxes. Connectors whose from/to id does not match a box are dropped";
-        };
-        readonly texts: {
-            readonly type: "array";
-            readonly items: {
-                readonly $ref: "#/definitions/text";
-            };
-            readonly description: "Free-floating annotations not attached to any box. Prefer box slots (label/text/footer) when the text belongs to a box";
-        };
-    };
-    readonly definitions: {
-        readonly box: {
-            readonly type: "object";
-            readonly required: readonly ["id"];
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly id: {
-                    readonly type: "string";
-                    readonly description: "Unique within the drawing; connectors reference it";
-                };
-                readonly type: {
-                    readonly enum: readonly BoxType[];
-                    readonly description: "Shape: rect (default), ellipse, diamond (decision), note (sticky note, yellow by default), cylinder (database), cloud (external system), queue (message queue), actor (stick figure; only the \"text\" slot renders, below the figure)";
-                };
-                readonly label: {
-                    readonly type: "string";
-                    readonly description: "Small bold heading at the top of the box";
-                };
-                readonly text: {
-                    readonly type: "string";
-                    readonly description: "Main content, centered. Wraps automatically; \"\\n\" forces a line break";
-                };
-                readonly footer: {
-                    readonly type: "string";
-                    readonly description: "Small dim line at the bottom of the box";
-                };
-                readonly x: {
-                    readonly type: "number";
-                    readonly description: "Top-left x in px. Omit (with y) to let the layout place the box";
-                };
-                readonly y: {
-                    readonly type: "number";
-                    readonly description: "Top-left y in px. Omit (with x) to let the layout place the box";
-                };
-                readonly w: {
-                    readonly type: "number";
-                    readonly exclusiveMinimum: 0;
-                    readonly description: "Width in px. Omit to size from the text (never smaller than the type default)";
-                };
-                readonly h: {
-                    readonly type: "number";
-                    readonly exclusiveMinimum: 0;
-                    readonly description: "Height in px. Omit to size from the text (never smaller than the type default)";
-                };
-                readonly color: {
-                    readonly enum: readonly ColorName[];
-                    readonly description: "Named color preset: outline plus, for boxes, a matching fill. `plain` has no outline and a light fill, `black` is a dark card with light text, `gray` is a dark outline on transparent (the default); the rest pair a colored outline with its pastel fill.";
-                };
-                readonly stroke: {
-                    readonly type: "string";
-                    readonly description: "CSS color of the outline and text; overrides the preset";
-                };
-                readonly fill: {
-                    readonly type: "string";
-                    readonly description: "CSS color of the interior (\"transparent\" for none); overrides the preset";
-                };
-            };
-        };
-        readonly connector: {
-            readonly type: "object";
-            readonly required: readonly ["from", "to"];
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly id: {
-                    readonly type: "string";
-                    readonly description: "Optional; generated when omitted";
-                };
-                readonly type: {
-                    readonly enum: readonly ConnectorType[];
-                    readonly description: "arrow (default; arrowhead at \"to\") or line (no arrowheads)";
-                };
-                readonly from: {
-                    readonly oneOf: readonly [{
-                        readonly type: "string";
-                        readonly description: "Id of a box. The connector attaches to its outline, aimed at the other end";
-                    }, {
-                        readonly type: "object";
-                        readonly required: readonly ["id"];
-                        readonly additionalProperties: false;
-                        readonly properties: {
-                            readonly id: {
-                                readonly type: "string";
-                                readonly description: "Id of a box";
-                            };
-                            readonly side: {
-                                readonly enum: readonly ["top", "right", "bottom", "left"];
-                                readonly description: "Pin the endpoint to the middle of this side of the box instead of auto-aiming";
-                            };
-                        };
-                    }];
-                    readonly description: "Box a connector end attaches to: a bare box id, or {id, side} to pick the attach edge";
-                };
-                readonly to: {
-                    readonly oneOf: readonly [{
-                        readonly type: "string";
-                        readonly description: "Id of a box. The connector attaches to its outline, aimed at the other end";
-                    }, {
-                        readonly type: "object";
-                        readonly required: readonly ["id"];
-                        readonly additionalProperties: false;
-                        readonly properties: {
-                            readonly id: {
-                                readonly type: "string";
-                                readonly description: "Id of a box";
-                            };
-                            readonly side: {
-                                readonly enum: readonly ["top", "right", "bottom", "left"];
-                                readonly description: "Pin the endpoint to the middle of this side of the box instead of auto-aiming";
-                            };
-                        };
-                    }];
-                    readonly description: "Box a connector end attaches to: a bare box id, or {id, side} to pick the attach edge";
-                };
-                readonly text: {
-                    readonly type: "string";
-                    readonly description: "Label rendered at the middle of the connector";
-                };
-                readonly bidirectional: {
-                    readonly type: "boolean";
-                    readonly description: "Arrow only: arrowheads on both ends";
-                };
-                readonly routing: {
-                    readonly enum: readonly ["straight", "elbow"];
-                    readonly description: "straight (default) draws a direct line; elbow draws a right-angled path routed around the boxes";
-                };
-                readonly color: {
-                    readonly enum: readonly ColorName[];
-                    readonly description: "Named color preset: outline plus, for boxes, a matching fill. `plain` has no outline and a light fill, `black` is a dark card with light text, `gray` is a dark outline on transparent (the default); the rest pair a colored outline with its pastel fill.";
-                };
-                readonly stroke: {
-                    readonly type: "string";
-                    readonly description: "CSS color of the line and label; overrides the preset";
-                };
-            };
-        };
-        readonly text: {
-            readonly type: "object";
-            readonly required: readonly ["x", "y", "text"];
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly id: {
-                    readonly type: "string";
-                    readonly description: "Optional; generated when omitted";
-                };
-                readonly x: {
-                    readonly type: "number";
-                    readonly description: "Top-left x of the first line, in px";
-                };
-                readonly y: {
-                    readonly type: "number";
-                    readonly description: "Top-left y of the first line, in px";
-                };
-                readonly text: {
-                    readonly type: "string";
-                    readonly description: "Content; \"\\n\" forces a line break";
-                };
-                readonly color: {
-                    readonly enum: readonly ColorName[];
-                    readonly description: "Named color preset: outline plus, for boxes, a matching fill. `plain` has no outline and a light fill, `black` is a dark card with light text, `gray` is a dark outline on transparent (the default); the rest pair a colored outline with its pastel fill.";
-                };
-                readonly stroke: {
-                    readonly type: "string";
-                    readonly description: "CSS color of the text; overrides the preset";
-                };
-            };
-        };
-    };
-};
-
-type MermaidDirection = 'LR' | 'TD';
-type MermaidOptions = Readonly<{
-    direction?: MermaidDirection;
-}>;
-/**
- * Export a drawing as a Mermaid `flowchart`. Boxes become nodes (in shape
- * order), connectors bound at both ends become edges; unbound connectors
- * are dropped and free text shapes are kept as `%% note:` comments so
- * nothing is silently lost.
- */
-declare function drawingToMermaid(data: DrawingData, options?: MermaidOptions): string;
-
-/**
- * `@lexical/markdown`'s CODE transformer, except that a block whose language
- * is the highlighter's default (`plain`, assigned to every untagged block)
- * exports as a bare ``` fence — markdown in, markdown out.
- */
-declare const CODE_BLOCK: MultilineElementTransformer;
-
-/** The built-in grammars. Importing this module registers them. */
-declare const BUILTIN_CODE_LANGUAGES: readonly [Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>, Readonly<{
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    identifier?: string;
-    caseInsensitive?: boolean;
-    callIsFunction?: boolean;
-    capitalizedIsType?: boolean;
-}>];
-
-/**
- * Semantic token vocabulary for code highlighting. Closed on purpose: every
- * grammar maps its syntax onto these names, and the theme maps each name onto
- * one class (`zui-token-<type>`) and one color custom property
- * (`--zui-code-<type>`). Adding a language never adds a color.
- */
-declare const CODE_TOKEN_TYPES: readonly ["comment", "string", "number", "keyword", "builtin", "type", "function", "property", "variable", "constant", "operator", "punctuation", "tag", "attr", "regex", "meta", "inserted", "deleted"];
-type CodeTokenType = (typeof CODE_TOKEN_TYPES)[number];
-/** A run of source text. `text` is uncolored (identifiers, whitespace, …). */
-type CodeToken = Readonly<{
-    type: CodeTokenType | 'text';
-    text: string;
-}>;
-/**
- * One lexer rule: a regular-expression *source* (no flags, no capturing
- * groups — use `(?:…)`, no backreferences) tried at the current position.
- * Rules are tried in order; the first one that matches wins.
- */
-type CodeRule = Readonly<{
-    type: CodeTokenType;
-    match: string;
-}>;
-/**
- * A language definition. Pure data: the lexer compiles it once (cached per
- * object identity) and walks the source with it.
- *
- * Identifiers not consumed by a rule are classified by the word lists, then
- * by the two heuristics, and otherwise left as plain text.
- */
-type CodeGrammar = Readonly<{
-    /** Canonical name, as written after ``` in markdown */
-    name: string;
-    aliases?: readonly string[];
-    rules: readonly CodeRule[];
-    keywords?: readonly string[];
-    builtins?: readonly string[];
-    types?: readonly string[];
-    constants?: readonly string[];
-    /** Regex source for identifiers (default: `[A-Za-z_$][\w$]*`) */
-    identifier?: string;
-    /** Word lists and rules match case-insensitively (SQL) */
-    caseInsensitive?: boolean;
-    /** An identifier directly followed by `(` is a `function` */
-    callIsFunction?: boolean;
-    /**
-     * A Capitalized identifier is a `type`; a SCREAMING_CASE one is a
-     * `constant`
-     */
-    capitalizedIsType?: boolean;
-}>;
-
-/**
- * Splits `code` into a flat list of tokens covering the whole input, in
- * order; adjacent tokens of the same type are merged. Never throws on user
- * input and always makes progress (an empty match counts as no match).
- */
-declare function tokenizeCode(code: string, grammar: CodeGrammar): CodeToken[];
-
-/**
- * Language registry: canonical names and aliases, lower-cased, mapped to a
- * grammar. Unknown names resolve to `plain` (line structure, no colors) so
- * every fenced block gets the same editing behavior.
- */
-declare const PLAIN_LANGUAGE = "plain";
-/** Adds (or replaces) a language. Call before the editor mounts. */
-declare function registerCodeLanguage(grammar: CodeGrammar): void;
-declare function hasCodeLanguage(name: string): boolean;
-/** Resolves a fence name (canonical, alias, or `diff-<lang>`) to a grammar. */
-declare function resolveCodeLanguage(name: string | null | undefined): CodeGrammar;
-/** Canonical names of every registered language, sorted */
-declare function getCodeLanguages(): string[];
-
-type LexicalTokenizer = NonNullable<Parameters<typeof registerCodeHighlighting>[1]>;
-/**
- * The tokenizer handed to `@lexical/code`. It never touches Prism: the
- * registry's grammars produce the tokens, and `$tokenize` turns them into the
- * flat CodeHighlightNode / LineBreakNode / TabNode structure CodeNode expects.
- */
-declare const codeTokenizer: LexicalTokenizer;
-/**
- * Registers syntax highlighting for every CodeNode in the editor, driven by
- * the language registry. Unknown languages render as plain text with the
- * same line structure, so editing behaves identically.
- */
-declare function registerCodeBlockHighlighting(editor: LexicalEditor): () => void;
-
-export { $createDrawingNode, $createFrontmatterNode, $deleteSelectedTableColumn, $deleteSelectedTableRow, $deleteTableColumnAt, $deleteTableRowAt, $getSelectedTable, $getSelectedTableCell, $getTableCellPosition, $getTableDensity, $getTableSettings, $getTableWidth, $insertTableColumnAt, $insertTableColumnNear, $insertTableRowAt, $insertTableRowNear, $isDrawingNode, $isFrontmatterNode, $isTableWidthExplicit, $setTableDensity, $setTableSettings, $setTableWidth, BLOCK_WIDTHS, BOX_DEFINITIONS, BOX_TYPES, BUILTIN_CODE_LANGUAGES, type Binding, type BindingSide, type BlockWidth, type BlockWidthDefaults, type BoxDefinition, type BoxType, CODE_BLOCK, CODE_TOKEN_TYPES, COLOR_PRESETS, CONNECTOR_TYPES, type CodeGrammar, type CodeRule, type CodeToken, type CodeTokenType, type ColorName, type ConnectorType, DEFAULT_TABLE_SETTINGS, DIAGRAM, DRAWING, DRAWING_DATA_JSON_SCHEMA, DRAWING_SKELETON_JSON_SCHEMA, type DrawingData, DrawingNode, type DrawingShape, type DrawingShapeType, type DrawingSkeleton, type DrawingStyle, EMPTY_DRAWING, type EditorContentProps, type EditorMode, type EditorRootProps, FILL_COLORS, FRONTMATTER, FormatButtons, FrontmatterNode, HistoryButtons, type InkOptions, type InkStroke, InsertButtons, MarkdownEditor, type MarkdownEditorApi, type Props as MarkdownEditorProps, type MermaidDirection, type MermaidOptions, PLAIN_LANGUAGE, type Point, SHAPE_TYPES, SIDE_FIXED_POINTS, STROKE_COLORS, type SerializedDrawingNode, type SerializedFrontmatterNode, type SkeletonBox, type SkeletonConnector, type SkeletonEnd, type SkeletonText, TABLE, TABLE_WIDTH_MARKER, type TableCellPosition, type TableDensity, type TableSettings, type TableSettingsOptions, type TextField, Toolbar, ToolbarButton, ToolbarDivider, type ToolbarItems, anchorPoint, bindEndpoints, boxOutline, canDeleteColumn, canDeleteRow, codeTokenizer, connectorPoints, drawingToMermaid, expandSkeleton, findBoxAt, fixedPointFor, formatTableSettingsMarker, getCodeLanguages, hasCodeLanguage, inkAmplitude, inkFillOffset, inkStroke, insertableColumnIndices, insertableRowIndices, isBlockWidth, isDrawingSkeleton, makeBinding, normalizeDrawingData, parseDrawingData, parseDrawingSkeleton, parseTableSettingsMarker, registerCodeBlockHighlighting, registerCodeLanguage, resolveBindings, resolveCodeLanguage, roundedPolyline, roundedRectPolygon, routeElbow, seedFrom, serializeDrawingData, tokenizeCode, useMarkdownEditor };
+export { BlockButtons, CharacterCount, EditorRootProps, FormatButtons, HistoryButtons, InsertButtons, MarkdownEditor, MarkdownEditorProps, ToolbarButton, ToolbarDivider };