@scrider/formatter 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1658 @@
+import { AttributeMap, Op, Delta } from '@scrider/delta';
+export * from '@scrider/delta';
+
+/**
+ * DOM Adapter Interface
+ *
+ * Provides a unified interface for DOM operations across different environments:
+ * - Browser: uses native DOM APIs
+ * - Node.js: uses jsdom
+ *
+ * This abstraction allows the same conversion code to work in both environments.
+ */
+/**
+ * Minimal Document interface required for HTML parsing/rendering
+ */
+interface DOMDocument {
+    createElement(tagName: string): DOMElement;
+    createTextNode(text: string): DOMNode;
+    createDocumentFragment(): DOMDocumentFragment;
+    readonly body: DOMElement;
+}
+/**
+ * Minimal DocumentFragment interface
+ */
+interface DOMDocumentFragment {
+    appendChild(node: DOMNode): DOMNode;
+    readonly childNodes: DOMNodeList;
+    readonly firstChild: DOMNode | null;
+    readonly nodeType: number;
+    readonly textContent: string | null;
+}
+/**
+ * Minimal Node interface
+ */
+interface DOMNode {
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly parentNode: DOMNode | null;
+    readonly childNodes: DOMNodeList;
+    readonly firstChild: DOMNode | null;
+    readonly nextSibling: DOMNode | null;
+    textContent: string | null;
+    appendChild(node: DOMNode): DOMNode;
+    cloneNode(deep?: boolean): DOMNode;
+}
+/**
+ * Minimal Element interface
+ */
+interface DOMElement extends DOMNode {
+    readonly tagName: string;
+    innerHTML: string;
+    outerHTML: string;
+    getAttribute(name: string): string | null;
+    setAttribute(name: string, value: string): void;
+    hasAttribute(name: string): boolean;
+    removeAttribute(name: string): void;
+    readonly style: DOMCSSStyleDeclaration;
+    readonly classList: DOMTokenList;
+    querySelector(selector: string): DOMElement | null;
+    querySelectorAll(selector: string): DOMNodeList;
+}
+/**
+ * Minimal CSSStyleDeclaration interface
+ */
+interface DOMCSSStyleDeclaration {
+    getPropertyValue(property: string): string;
+    setProperty(property: string, value: string): void;
+    color?: string;
+    backgroundColor?: string;
+    fontWeight?: string;
+    fontStyle?: string;
+    textDecoration?: string;
+    textAlign?: string;
+}
+/**
+ * Minimal DOMTokenList interface (for classList)
+ */
+interface DOMTokenList {
+    add(...tokens: string[]): void;
+    remove(...tokens: string[]): void;
+    contains(token: string): boolean;
+    readonly length: number;
+}
+/**
+ * Minimal NodeList interface
+ */
+interface DOMNodeList {
+    readonly length: number;
+    item(index: number): DOMNode | null;
+    [index: number]: DOMNode;
+    forEach(callback: (node: DOMNode, index: number) => void): void;
+}
+/**
+ * Node type constants
+ */
+declare const NODE_TYPE: {
+    readonly ELEMENT_NODE: 1;
+    readonly TEXT_NODE: 3;
+    readonly DOCUMENT_NODE: 9;
+    readonly DOCUMENT_FRAGMENT_NODE: 11;
+};
+/**
+ * DOM Adapter interface
+ *
+ * Provides methods for creating and manipulating DOM structures
+ * in a platform-agnostic way.
+ */
+interface DOMAdapter {
+    /**
+     * Parse HTML string into a document fragment
+     */
+    parseHTML(html: string): DOMDocumentFragment;
+    /**
+     * Serialize a node to HTML string
+     */
+    serializeHTML(node: DOMNode | DOMDocumentFragment): string;
+    /**
+     * Create a new document for building DOM structures
+     */
+    createDocument(): DOMDocument;
+    /**
+     * Check if this adapter is available in the current environment
+     */
+    isAvailable(): boolean;
+}
+/**
+ * Type guard: check if node is an Element
+ */
+declare function isElement(node: DOMNode): node is DOMElement;
+/**
+ * Type guard: check if node is a Text node
+ */
+declare function isTextNode(node: DOMNode): boolean;
+
+/**
+ * Scope of a format
+ *
+ * - inline: applies to text runs (bold, italic, link, color...)
+ * - block: applies to lines (header, list, blockquote...)
+ * - embed: non-text content (image, video, formula...)
+ */
+type FormatScope = 'inline' | 'block' | 'embed';
+/**
+ * Result returned by Format.match() when an HTML element is recognized.
+ */
+interface FormatMatchResult<T = unknown> {
+    /** The embed value for Delta (e.g. URL string, boolean, etc.) */
+    value: T;
+    /** Optional attributes to attach to the op (e.g. alt, width, height) */
+    attributes?: AttributeMap;
+}
+/**
+ * Format interface with optional conversion methods.
+ *
+ * Three-level extensibility:
+ * - Level 1 (validate/normalize): format works in Delta, no conversion
+ * - Level 2 (render/match): HTML roundtrip — Delta ↔ HTML
+ * - Level 3 (toMarkdown/fromMarkdown): Markdown roundtrip — Delta ↔ Markdown
+ *
+ * @template T - The type of the attribute value
+ */
+interface Format<T = unknown> {
+    /**
+     * Name of the attribute in Delta
+     * Must be unique within a Registry
+     */
+    readonly name: string;
+    /**
+     * Scope of the format
+     */
+    readonly scope: FormatScope;
+    /**
+     * Normalize value to canonical form
+     *
+     * Examples:
+     * - 'red' → '#ff0000'
+     * - 'RGB(255,0,0)' → '#ff0000'
+     * - 7 (header) → 6 (clamped)
+     *
+     * @param value - The value to normalize
+     * @returns Normalized value
+     */
+    normalize?(value: T): T;
+    /**
+     * Validate that a value is acceptable
+     *
+     * @param value - The value to validate
+     * @returns true if value is valid
+     */
+    validate?(value: T): boolean;
+    /**
+     * Render Delta value to HTML string.
+     *
+     * Used by deltaToHtml for embed formats. If not provided,
+     * the converter falls back to built-in EMBED_RENDERERS config.
+     *
+     * @param value - The embed value (e.g. URL string)
+     * @param attributes - Op-level attributes (alt, width, height, etc.)
+     * @returns HTML string
+     */
+    render?(value: T, attributes?: AttributeMap): string;
+    /**
+     * Match an HTML element and extract Delta embed value.
+     *
+     * Used by htmlToDelta to recognize custom elements.
+     * Return null if this element is not a match for this format.
+     *
+     * @param element - The DOM element to inspect
+     * @returns Match result with value and optional attributes, or null
+     */
+    match?(element: DOMElement): FormatMatchResult<T> | null;
+    /**
+     * Render Delta value to Markdown string.
+     *
+     * Return null to fall back to HTML-in-Markdown (current behavior
+     * for embeds without native Markdown representation).
+     *
+     * @param value - The embed value
+     * @param attributes - Op-level attributes
+     * @returns Markdown string, or null for HTML fallback
+     */
+    toMarkdown?(value: T, attributes?: AttributeMap): string | null;
+    /**
+     * Parse a Markdown AST node into a Delta embed value.
+     *
+     * Used by markdownToDelta to recognize custom Markdown patterns
+     * (e.g. image-like URLs, fenced code blocks with custom language).
+     *
+     * @param node - Markdown AST node (MDAST)
+     * @returns Match result with value and optional attributes, or null
+     */
+    fromMarkdown?(node: unknown): FormatMatchResult<T> | null;
+}
+/**
+ * Helper type for creating format objects
+ */
+type FormatDefinition<T = unknown> = Format<T>;
+
+/**
+ * Registry of formats
+ *
+ * Manages a collection of Format definitions for validation,
+ * normalization, and sanitization of Delta attributes.
+ *
+ * @example
+ * ```typescript
+ * const registry = new Registry()
+ *   .register(boldFormat)
+ *   .register(italicFormat)
+ *   .register(colorFormat);
+ *
+ * // Normalize attributes
+ * registry.normalize({ color: 'red' });
+ * // { color: '#ff0000' }
+ *
+ * // Validate attributes
+ * registry.validate({ header: 3 }); // true
+ * registry.validate({ header: 10 }); // false
+ * ```
+ */
+declare class Registry {
+    private formats;
+    /**
+     * Register a format or array of formats
+     *
+     * @param format - Format or array of formats to register
+     * @returns this for chaining
+     */
+    register(format: Format): this;
+    register(formats: Format[]): this;
+    /**
+     * Get a format by name
+     *
+     * @param name - Format name
+     * @returns Format or undefined if not found
+     */
+    get(name: string): Format | undefined;
+    /**
+     * Check if a format is registered
+     *
+     * @param name - Format name
+     * @returns true if format exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get all formats with a specific scope
+     *
+     * @param scope - Format scope to filter by
+     * @returns Array of formats with the given scope
+     */
+    getByScope(scope: FormatScope): Format[];
+    /**
+     * Get all registered format names
+     *
+     * @returns Array of format names
+     */
+    getNames(): string[];
+    /**
+     * Normalize all attributes using registered formats
+     *
+     * Applies normalize() for each attribute that has a registered format.
+     * Unknown attributes are passed through unchanged.
+     *
+     * @param attributes - Attributes to normalize
+     * @returns New object with normalized attributes
+     */
+    normalize(attributes: AttributeMap | undefined): AttributeMap | undefined;
+    /**
+     * Validate all attributes
+     *
+     * @param attributes - Attributes to validate
+     * @returns true if all known attributes are valid
+     */
+    validate(attributes: AttributeMap | undefined): boolean;
+    /**
+     * Sanitize attributes by removing invalid values
+     *
+     * Removes attributes that:
+     * - Are not registered (unknown formats)
+     * - Fail validation
+     *
+     * @param attributes - Attributes to sanitize
+     * @param removeUnknown - If true, remove unregistered attributes (default: true)
+     * @returns New object with only valid attributes
+     */
+    sanitize(attributes: AttributeMap | undefined, removeUnknown?: boolean): AttributeMap | undefined;
+    /**
+     * Get the number of registered formats
+     */
+    get size(): number;
+}
+
+/**
+ * Options for block rendering
+ */
+interface BlockRenderOptions {
+    /** Pretty-print HTML output */
+    pretty?: boolean;
+    /** Indentation level for pretty-print */
+    indent?: number;
+    /** How to interpret colWidths: percent (default) or pixel */
+    tableWidthMode?: 'percent' | 'pixel';
+}
+/**
+ * Context injected by converters into BlockHandler methods.
+ *
+ * Solves cyclic dependencies: handlers live in schema layer,
+ * converters live in conversion layer. Converters pass themselves
+ * as callbacks via context — no direct imports between layers.
+ */
+interface BlockContext {
+    /** Format registry for attribute validation/normalization */
+    registry: Registry;
+    /** Render options */
+    options?: BlockRenderOptions;
+    /** Render nested Delta ops → HTML (injected by deltaToHtml) */
+    renderDelta?: (ops: Op[]) => string;
+    /** Parse HTML element → Delta ops (injected by htmlToDelta) */
+    parseElement?: (element: DOMElement) => Op[];
+    /**
+     * Op-level attributes from the Delta operation containing this block embed.
+     * Used by handlers that store visual properties (float, width, height, overflow)
+     * in op attributes rather than in block data (e.g. Inline-Box).
+     */
+    opAttributes?: Record<string, unknown>;
+}
+/**
+ * Generic handler for complex block embeds with nested Delta content.
+ *
+ * Block embeds use a single `block` key in Delta:
+ * `{ insert: { block: { type: "table", ... } } }`
+ *
+ * The `type` field dispatches to the appropriate BlockHandler
+ * via BlockHandlerRegistry.
+ *
+ * T includes `type` — data is stored as `{ block: T }` where T
+ * is the full object including `type`. No destructuring needed.
+ *
+ * @template T - Block data type (e.g. TableBlockData)
+ */
+interface BlockHandler<T = unknown> {
+    /** Unique block type — value of `type` field in block embed */
+    readonly type: string;
+    /** Semantic validation of block data (cells, colWidths, etc.) */
+    validate(data: T): boolean;
+    /** Delta → HTML (context.renderDelta for nested Delta) */
+    toHtml(data: T, context: BlockContext): string;
+    /** HTML element → block data (context.parseElement for cells) */
+    fromHtml(element: DOMElement, context: BlockContext): T | null;
+    /** Delta → Markdown (null = fallback to toHtml) */
+    toMarkdown?(data: T, context: BlockContext): string | null;
+    /** Markdown AST node → block data */
+    fromMarkdown?(node: unknown, context: BlockContext): T | null;
+    /** Normalize block data + recursive normalization of nested Deltas */
+    normalize?(data: T, registry: Registry): T;
+    /** Extract all nested Deltas from block */
+    getNestedDeltas?(data: T): Op[][];
+    /** Replace nested Deltas (immutable, returns new T) */
+    setNestedDeltas?(data: T, deltas: Op[][]): T;
+    compose?(base: T, change: T): T;
+    transform?(a: T, b: T, priority: boolean): T;
+}
+
+/**
+ * Registry for BlockHandler implementations.
+ *
+ * Separate from Registry (FormatRegistry) — different responsibilities:
+ * - Registry: attribute validation/normalization (key-value pairs, primitives)
+ * - BlockHandlerRegistry: block rendering/parsing (complex structures with nested Delta)
+ *
+ * Connected to converters via options:
+ * ```typescript
+ * deltaToHtml(delta, { registry, blockHandlers });
+ * htmlToDelta(html, { registry, blockHandlers });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const blockHandlers = new BlockHandlerRegistry()
+ *   .register(tableBlockHandler);
+ *
+ * deltaToHtml(delta, { registry, blockHandlers });
+ * ```
+ */
+declare class BlockHandlerRegistry {
+    private handlers;
+    /**
+     * Register a block handler
+     *
+     * @param handler - BlockHandler to register
+     * @returns this for chaining
+     * @throws Error if handler with same type is already registered
+     */
+    register(handler: BlockHandler): this;
+    /**
+     * Get a handler by block type
+     *
+     * @param type - Block type (e.g. "table")
+     * @returns BlockHandler or undefined if not found
+     */
+    get(type: string): BlockHandler | undefined;
+    /**
+     * Check if a handler is registered for a block type
+     *
+     * @param type - Block type
+     * @returns true if handler exists
+     */
+    has(type: string): boolean;
+    /**
+     * Get the number of registered handlers
+     */
+    get size(): number;
+    /**
+     * Get all registered block type names
+     */
+    getTypes(): string[];
+}
+
+/**
+ * Cell alignment options
+ */
+type CellAlign = 'left' | 'center' | 'right';
+/**
+ * Data for a single cell in an Extended Table.
+ *
+ * Every non-merged cell must have `ops` — a nested Delta (Op[]).
+ * Empty cells use `{ ops: [{ insert: "\n" }] }`.
+ */
+interface CellData {
+    /** Nested Delta content (full rich-text) */
+    ops: Op[];
+    /** Number of columns this cell spans (default: 1) */
+    colspan?: number;
+    /** Number of rows this cell spans (default: 1) */
+    rowspan?: number;
+}
+/**
+ * Extended Table block data.
+ *
+ * Stored in Delta as: `{ insert: { block: <TableBlockData> } }`
+ *
+ * All coordinates "r:c" within the grid MUST be present in `cells`.
+ * - `CellData` — cell with content
+ * - `null` — cell absorbed by neighbor's colspan/rowspan
+ * - Missing key — INVALID (validate() rejects)
+ */
+interface TableBlockData {
+    /** Block type discriminator */
+    type: 'table';
+    /** Number of header rows (default: 0) */
+    headerRows?: number;
+    /** Column widths (percentages by default) */
+    colWidths?: number[];
+    /** Column alignments */
+    colAligns?: (CellAlign | null)[];
+    /** Cells indexed by "row:col" */
+    cells: Record<string, CellData | null>;
+}
+/**
+ * BlockHandler implementation for Extended Table.
+ *
+ * Handles validation, HTML conversion, and nested Delta access.
+ * toHtml/fromHtml are implemented in E.3/E.4 stages.
+ */
+declare const tableBlockHandler: BlockHandler<TableBlockData>;
+
+/**
+ * Footnotes block data — a collection of footnote definitions.
+ *
+ * Stored in Delta as: `{ insert: { block: <FootnotesBlockData> } }`
+ *
+ * Each note is keyed by its string identifier (e.g. "1", "note", "my-ref").
+ * Values contain nested Delta content (rich-text).
+ *
+ * Placed at the end of the document, after all content.
+ */
+interface FootnotesBlockData {
+    /** Block type discriminator */
+    type: 'footnotes';
+    /** Map of footnote id → content (nested Delta ops) */
+    notes: Record<string, {
+        ops: Op[];
+    }>;
+}
+/**
+ * BlockHandler implementation for Footnotes.
+ *
+ * Handles a single block embed containing all footnote definitions.
+ * Each footnote has an id and nested Delta content.
+ *
+ * HTML: <section class="footnotes"><ol><li id="fn-{id}">...</li></ol></section>
+ * Markdown: [^id]: content
+ */
+declare const footnotesBlockHandler: BlockHandler<FootnotesBlockData>;
+
+/** The 5 standard GitHub alert types */
+declare const ALERT_TYPES: readonly ["note", "tip", "important", "warning", "caution"];
+/** Union of valid alert types */
+type AlertType = (typeof ALERT_TYPES)[number];
+/**
+ * Alert / Admonition block data.
+ *
+ * Stored in Delta as: `{ insert: { block: <AlertBlockData> } }`
+ *
+ * GitHub-style alerts:
+ * ```markdown
+ * > [!NOTE]
+ * > Useful information.
+ * ```
+ *
+ * HTML:
+ * ```html
+ * <div class="markdown-alert markdown-alert-note">
+ *   <p class="markdown-alert-title">Note</p>
+ *   <p>Useful information.</p>
+ * </div>
+ * ```
+ */
+interface AlertBlockData {
+    /** Block type discriminator */
+    type: 'alert';
+    /** Alert variant (note, tip, important, warning, caution) */
+    alertType: AlertType;
+    /** Nested Delta content (rich text) */
+    content: {
+        ops: Op[];
+    };
+}
+/**
+ * BlockHandler implementation for Alerts / Admonitions.
+ *
+ * Handles GitHub-style alerts (5 types: note, tip, important, warning, caution).
+ * Each alert contains nested Delta content (rich text).
+ *
+ * HTML: `<div class="markdown-alert markdown-alert-{type}"><p class="markdown-alert-title">{Type}</p>...</div>`
+ * Markdown: `> [!TYPE]\n> content`
+ */
+declare const alertBlockHandler: BlockHandler<AlertBlockData>;
+
+/**
+ * Columns Layout block data.
+ *
+ * Stored in Delta as: `{ insert: { block: <ColumnsBlockData> } }`
+ *
+ * Each column contains a full nested Delta (rich text, embeds, nested blocks).
+ *
+ * HTML:
+ * ```html
+ * <div class="columns columns-2">
+ *   <div class="column"><p>Column 1</p></div>
+ *   <div class="column"><p>Column 2</p></div>
+ * </div>
+ * ```
+ *
+ * With custom widths:
+ * ```html
+ * <div class="columns columns-2" style="grid-template-columns: 30% 70%">
+ *   <div class="column"><p>Sidebar</p></div>
+ *   <div class="column"><p>Main content</p></div>
+ * </div>
+ * ```
+ *
+ * Markdown: no native equivalent → toMarkdown returns null → HTML fallback.
+ *
+ * Resize-ready: `widths` for per-column resize (future scrider-editor),
+ * `width`/`height` in op attributes for overall dimensions.
+ */
+interface ColumnsBlockData {
+    /** Block type discriminator */
+    type: 'columns';
+    /** Column contents — array of nested Deltas */
+    columns: {
+        ops: Op[];
+    }[];
+    /** Optional: column widths in percent (sum ≈ 100). Default: equal (CSS 1fr each) */
+    widths?: number[];
+}
+/**
+ * BlockHandler implementation for Columns Layout.
+ *
+ * Multi-column layout with nested Delta content in each column.
+ * Analogous to Alert (nested Delta) but with an array of columns.
+ *
+ * HTML: `<div class="columns columns-N" [style="grid-template-columns: W1% W2%"]>
+ *          <div class="column">...</div>...
+ *        </div>`
+ * Markdown: no equivalent → toMarkdown returns null → HTML fallback
+ */
+declare const columnsBlockHandler: BlockHandler<ColumnsBlockData>;
+
+/** Valid float positions for Inline-Box */
+declare const BOX_FLOAT_VALUES: readonly ["left", "right", "center"];
+/** Valid overflow modes for Inline-Box */
+declare const BOX_OVERFLOW_VALUES: readonly ["auto", "hidden", "visible"];
+/** Union of valid float positions */
+type BoxFloat = (typeof BOX_FLOAT_VALUES)[number];
+/** Union of valid overflow modes */
+type BoxOverflow = (typeof BOX_OVERFLOW_VALUES)[number];
+/**
+ * Inline-Box block data.
+ *
+ * Stored in Delta as: `{ insert: { block: <BoxBlockData> }, attributes: { float, width, height, overflow } }`
+ *
+ * A float container with nested Delta content and text wrapping.
+ * Visual properties (float, width, height, overflow) are stored in op attributes,
+ * not in block data — clean separation of semantics vs presentation.
+ *
+ * HTML (float left/right):
+ * ```html
+ * <div class="inline-box" data-float="left" data-overflow="auto"
+ *      style="width: 200px; height: 300px;">
+ *   <p>Rich content</p>
+ * </div>
+ * ```
+ *
+ * HTML (center — no wrapping):
+ * ```html
+ * <div class="inline-box" data-float="center" data-overflow="auto"
+ *      style="width: 200px; height: 300px;">
+ *   <p>Content</p>
+ * </div>
+ * ```
+ *
+ * Markdown: no native equivalent → toMarkdown returns null → HTML fallback.
+ */
+interface BoxBlockData {
+    /** Block type discriminator */
+    type: 'box';
+    /** Nested Delta content (rich text) */
+    content: {
+        ops: Op[];
+    };
+}
+/**
+ * Op-level attributes for box block embed.
+ * Stored in `op.attributes`, not in block data.
+ */
+interface BoxOpAttributes {
+    /** Float position: left/right = text wrapping, center = no wrapping */
+    float?: BoxFloat;
+    /** Container width (e.g. "200px", "30%") */
+    width?: string;
+    /** Container height (e.g. "300px", "auto") */
+    height?: string;
+    /** Overflow behavior when content exceeds dimensions */
+    overflow?: BoxOverflow;
+}
+/**
+ * BlockHandler implementation for Inline-Box (Float Container).
+ *
+ * A container with nested Delta content that supports float positioning
+ * and text wrapping. Like Alert (single nested Delta), but visual
+ * properties are stored in op attributes, not in block data.
+ *
+ * HTML: `<div class="inline-box" data-float="F" data-overflow="O" style="width: W; height: H">...</div>`
+ * Markdown: no equivalent → toMarkdown returns null → HTML fallback
+ */
+declare const boxBlockHandler: BlockHandler<BoxBlockData>;
+/**
+ * Extract op attributes for box from an HTML element.
+ *
+ * Used by html-to-delta intercept to reconstruct op attributes
+ * (float, width, height, overflow) from the HTML representation.
+ */
+declare function extractBoxOpAttributes(element: DOMElement): BoxOpAttributes;
+
+/**
+ * All default inline formats
+ */
+declare const defaultInlineFormats: Format[];
+/**
+ * All default block formats
+ */
+declare const defaultBlockFormats: Format[];
+/**
+ * All default embed formats
+ */
+declare const defaultEmbedFormats: Format[];
+/**
+ * All default formats combined
+ */
+declare const defaultFormats: Format[];
+/**
+ * Create a Registry with all default formats registered
+ *
+ * @returns Registry with standard formats
+ *
+ * @example
+ * ```typescript
+ * const registry = createDefaultRegistry();
+ * registry.normalize({ color: 'red' }); // { color: '#ff0000' }
+ * ```
+ */
+declare function createDefaultRegistry(): Registry;
+/**
+ * Create a BlockHandlerRegistry with default block handlers
+ *
+ * Includes:
+ * - tableBlockHandler (Extended Table)
+ * - footnotesBlockHandler (Footnotes)
+ * - alertBlockHandler (Alerts/Admonitions)
+ * - columnsBlockHandler (Columns Layout)
+ * - boxBlockHandler (Inline-Box / Float Container)
+ *
+ * @returns BlockHandlerRegistry with default handlers
+ *
+ * @example
+ * ```typescript
+ * const blockHandlers = createDefaultBlockHandlers();
+ * blockHandlers.has('table'); // true
+ * blockHandlers.has('footnotes'); // true
+ * blockHandlers.has('alert'); // true
+ * blockHandlers.has('columns'); // true
+ * blockHandlers.has('box'); // true
+ * ```
+ */
+declare function createDefaultBlockHandlers(): BlockHandlerRegistry;
+
+/**
+ * Background color format
+ *
+ * Delta: { insert: "text", attributes: { background: "#ff0000" } }
+ *
+ * Normalizes all color formats (rgb, named, etc.) to lowercase hex (#rrggbb)
+ */
+declare const backgroundFormat: Format<string>;
+
+/**
+ * Bold format
+ *
+ * Delta: { insert: "text", attributes: { bold: true } }
+ */
+declare const boldFormat: Format<boolean>;
+
+/**
+ * Inline code format
+ *
+ * Delta: { insert: "text", attributes: { code: true } }
+ */
+declare const codeFormat: Format<boolean>;
+
+/**
+ * Text color format
+ *
+ * Delta: { insert: "text", attributes: { color: "#ff0000" } }
+ *
+ * Normalizes all color formats (rgb, named, etc.) to lowercase hex (#rrggbb)
+ */
+declare const colorFormat: Format<string>;
+
+/**
+ * Italic format
+ *
+ * Delta: { insert: "text", attributes: { italic: true } }
+ */
+declare const italicFormat: Format<boolean>;
+
+/**
+ * Keyboard input format
+ *
+ * Delta: { insert: "text", attributes: { kbd: true } }
+ * HTML: <kbd>text</kbd>
+ * Markdown: <kbd>text</kbd> (inline HTML)
+ */
+declare const kbdFormat: Format<boolean>;
+
+/**
+ * Link format
+ *
+ * Delta: { insert: "text", attributes: { link: "https://example.com" } }
+ *
+ * Supports:
+ * - Absolute URLs (http://, https://)
+ * - Relative URLs (/path, ./path, ../path)
+ * - Protocol-relative URLs (//example.com)
+ * - mailto: and tel: links
+ */
+declare const linkFormat: Format<string>;
+
+/**
+ * Mark (highlight) format
+ *
+ * Delta: { insert: "text", attributes: { mark: true } }
+ * HTML: <mark>text</mark>
+ */
+declare const markFormat: Format<boolean>;
+
+/**
+ * Strikethrough format
+ *
+ * Delta: { insert: "text", attributes: { strike: true } }
+ */
+declare const strikeFormat: Format<boolean>;
+
+/**
+ * Subscript format
+ *
+ * Delta: { insert: "text", attributes: { subscript: true } }
+ * HTML: <sub>text</sub>
+ */
+declare const subscriptFormat: Format<boolean>;
+
+/**
+ * Superscript format
+ *
+ * Delta: { insert: "text", attributes: { superscript: true } }
+ * HTML: <sup>text</sup>
+ */
+declare const superscriptFormat: Format<boolean>;
+
+/**
+ * Underline format
+ *
+ * Delta: { insert: "text", attributes: { underline: true } }
+ */
+declare const underlineFormat: Format<boolean>;
+
+/**
+ * Valid alignment values
+ */
+type AlignType = 'left' | 'center' | 'right' | 'justify';
+/**
+ * Text alignment format
+ *
+ * Delta: { insert: "\n", attributes: { align: "center" } }
+ */
+declare const alignFormat: Format<AlignType>;
+
+/**
+ * Blockquote format
+ *
+ * Delta: { insert: "\n", attributes: { blockquote: true } }
+ */
+declare const blockquoteFormat: Format<boolean>;
+
+/**
+ * Code block format
+ *
+ * Delta: { insert: "\n", attributes: { "code-block": true } }
+ * Delta: { insert: "\n", attributes: { "code-block": "javascript" } }
+ *
+ * Value can be:
+ * - true: generic code block
+ * - string: language identifier for syntax highlighting
+ */
+declare const codeBlockFormat: Format<boolean | string>;
+
+/**
+ * Header format (h1-h6)
+ *
+ * Delta: { insert: "\n", attributes: { header: 1 } }
+ *
+ * Values: 1-6 (corresponding to h1-h6)
+ */
+declare const headerFormat: Format<number>;
+
+/**
+ * Header ID format — optional custom anchor id for headings
+ *
+ * Delta: { insert: "\n", attributes: { header: 2, "header-id": "getting-started" } }
+ *
+ * When present, the heading gets this exact id in HTML output.
+ * When absent, id is computed via slugify(text) at render time (if anchorLinks is enabled).
+ *
+ * Markdown: ## Title {#custom-id}
+ */
+declare const headerIdFormat: Format<string>;
+
+/**
+ * Indent format
+ *
+ * Delta: { insert: "\n", attributes: { indent: 1 } }
+ *
+ * Values: 0-8 (0 = no indent)
+ */
+declare const indentFormat: Format<number>;
+
+/**
+ * Valid list types
+ */
+type ListType = 'ordered' | 'bullet' | 'checked' | 'unchecked';
+/**
+ * List format
+ *
+ * Delta: { insert: "\n", attributes: { list: "ordered" } }
+ * Delta: { insert: "\n", attributes: { list: "bullet" } }
+ * Delta: { insert: "\n", attributes: { list: "checked" } }
+ * Delta: { insert: "\n", attributes: { list: "unchecked" } }
+ */
+declare const listFormat: Format<ListType>;
+
+/**
+ * Table row index format
+ *
+ * Delta: { insert: "\n", attributes: { "table-row": 0 } }
+ */
+declare const tableRowFormat: Format<number>;
+
+/**
+ * Table column index format
+ *
+ * Delta: { insert: "\n", attributes: { "table-col": 0 } }
+ */
+declare const tableColFormat: Format<number>;
+
+/**
+ * Table header cell format
+ *
+ * Delta: { insert: "\n", attributes: { "table-header": true } }
+ *
+ * When true, the cell is rendered as <th> inside <thead>.
+ */
+declare const tableHeaderFormat: Format<boolean>;
+
+/**
+ * Valid table column alignment values
+ */
+type TableColAlignType = 'left' | 'center' | 'right';
+/**
+ * Table column alignment format
+ *
+ * Delta: { insert: "\n", attributes: { "table-col-align": "center" } }
+ *
+ * Controls text-align of the column (rendered via style on <th>/<td>).
+ * Compatible with GFM alignment syntax (:---|:---:|---:).
+ */
+declare const tableColAlignFormat: Format<TableColAlignType>;
+
+/**
+ * Block embed format — structural validation for complex block embeds.
+ *
+ * Delta: `{ insert: { block: { type: "table", ... } } }`
+ *
+ * This is the first level of two-level validation:
+ * 1. blockFormat.validate() — structural: is it an object with `type`?
+ * 2. BlockHandlerRegistry.get(type).validate() — semantic: is it a valid table?
+ *
+ * The `block` key is a **category**, not "just another embed".
+ * It signals to converters and OT layer: "nested structure, needs special handling".
+ */
+declare const blockFormat: Format<Record<string, unknown>>;
+
+/**
+ * Divider (Horizontal Rule) embed format
+ *
+ * Delta: { insert: { divider: true } }
+ * HTML:  <hr>
+ * Markdown: ---
+ *
+ * Value is always `true` (no additional data needed)
+ */
+declare const dividerFormat: Format<boolean>;
+
+/**
+ * Footnote reference embed format
+ *
+ * Delta: { insert: { "footnote-ref": "1" } }
+ *
+ * Value is the footnote identifier string (e.g. "1", "note", "my-ref").
+ * Rendered as superscript link in HTML: <sup class="footnote-ref"><a href="#fn-1">1</a></sup>
+ * Markdown: [^1]
+ */
+declare const footnoteRefFormat: Format<string>;
+
+/**
+ * Formula (LaTeX) embed format
+ *
+ * Delta: { insert: { formula: "E = mc^2" } }
+ *
+ * Value is LaTeX string
+ */
+declare const formulaFormat: Format<string>;
+
+/**
+ * Image embed format
+ *
+ * Delta: { insert: { image: "https://example.com/image.png" } }
+ *
+ * Value is the image URL (http, https, data URI, or relative path)
+ */
+declare const imageFormat: Format<string>;
+
+/**
+ * Video embed format
+ *
+ * Delta: { insert: { video: "https://youtube.com/watch?v=..." } }
+ *
+ * Value is the video URL
+ */
+declare const videoFormat: Format<string>;
+
+/**
+ * Convert any color format to lowercase hex (#rrggbb)
+ *
+ * Supports:
+ * - Hex: #rgb, #rrggbb, #rrggbbaa
+ * - RGB: rgb(r, g, b), rgb(r g b)
+ * - RGBA: rgba(r, g, b, a), rgba(r g b / a)
+ * - Named colors: red, blue, etc.
+ *
+ * @param value - Color value to convert
+ * @returns Lowercase hex color (#rrggbb) or original value if not recognized
+ */
+declare function toHexColor(value: string): string;
+/**
+ * Check if a value is a valid hex color
+ *
+ * @param value - Value to check
+ * @returns true if valid hex color (#rrggbb or #rgb)
+ */
+declare function isValidHexColor(value: string): boolean;
+/**
+ * Check if a value is a valid color (hex, rgb, rgba, or named)
+ *
+ * @param value - Value to check
+ * @returns true if valid color
+ */
+declare function isValidColor(value: string): boolean;
+/**
+ * Get list of all named colors
+ */
+declare function getNamedColors(): string[];
+
+/**
+ * Browser DOM Adapter
+ *
+ * Uses native browser DOM APIs for HTML parsing and serialization.
+ * Only available in browser environments.
+ */
+
+/**
+ * Browser DOM Adapter implementation
+ *
+ * Uses native browser APIs:
+ * - DOMParser for parsing HTML
+ * - Element.outerHTML for serialization
+ */
+declare class BrowserDOMAdapter implements DOMAdapter {
+    /**
+     * Parse HTML string into a document fragment
+     *
+     * Uses a template element to parse arbitrary HTML safely.
+     */
+    parseHTML(html: string): DOMDocumentFragment;
+    /**
+     * Serialize a node to HTML string
+     */
+    serializeHTML(node: DOMNode | DOMDocumentFragment): string;
+    /**
+     * Create a new document for building DOM structures
+     */
+    createDocument(): DOMDocument;
+    /**
+     * Check if browser DOM APIs are available
+     */
+    isAvailable(): boolean;
+}
+/**
+ * Singleton instance of browser adapter
+ */
+declare const browserAdapter: BrowserDOMAdapter;
+
+/**
+ * Node.js DOM Adapter
+ *
+ * Uses jsdom for HTML parsing and serialization in Node.js environment.
+ */
+
+/**
+ * Node.js DOM Adapter implementation
+ *
+ * Uses jsdom for DOM operations in Node.js environment.
+ * jsdom is loaded lazily to avoid issues in browser bundles.
+ */
+declare class NodeDOMAdapter implements DOMAdapter {
+    private jsdom;
+    /**
+     * Parse HTML string into a document fragment
+     */
+    parseHTML(html: string): DOMDocumentFragment;
+    /**
+     * Serialize a node to HTML string
+     */
+    serializeHTML(node: DOMNode | DOMDocumentFragment): string;
+    /**
+     * Create a new document for building DOM structures
+     */
+    createDocument(): DOMDocument;
+    /**
+     * Check if jsdom is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Initialize the adapter with jsdom (async)
+     *
+     * Call this before using the adapter if you want to handle
+     * loading errors gracefully.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get or create jsdom instance (sync, throws if not available)
+     */
+    private getOrCreateJsdom;
+}
+/**
+ * Singleton instance of Node adapter
+ */
+declare const nodeAdapter: NodeDOMAdapter;
+
+/**
+ * DOM Adapters
+ *
+ * Platform-agnostic DOM manipulation for HTML ↔ Delta conversion.
+ */
+
+/**
+ * Get the appropriate DOM adapter for the current environment
+ *
+ * - In browser: returns BrowserDOMAdapter (native DOM)
+ * - In Node.js: returns NodeDOMAdapter (jsdom)
+ *
+ * @returns The appropriate DOM adapter
+ * @throws Error if no adapter is available
+ */
+declare function getAdapter(): DOMAdapter;
+/**
+ * Check if any DOM adapter is available
+ */
+declare function isAdapterAvailable(): boolean;
+
+/**
+ * Delta Sanitization
+ *
+ * Cleans Delta by removing unknown attributes, validating values,
+ * and normalizing through Registry.
+ */
+
+/**
+ * Options for sanitizeDelta
+ */
+interface SanitizeOptions {
+    /**
+     * Remove attributes not registered in the registry
+     * @default true
+     */
+    removeUnknown?: boolean;
+    /**
+     * Normalize attribute values (e.g., color: 'red' → '#ff0000')
+     * @default true
+     */
+    normalize?: boolean;
+    /**
+     * Remove operations with invalid embed values
+     * @default false
+     */
+    removeInvalidEmbeds?: boolean;
+    /**
+     * List of embed types that are allowed (if not set, all registered are allowed)
+     */
+    allowedEmbeds?: string[];
+}
+/**
+ * Sanitize a Delta using a Registry
+ *
+ * Performs the following operations:
+ * 1. Removes attributes not registered in the registry (if removeUnknown=true)
+ * 2. Removes attributes with invalid values
+ * 3. Normalizes attribute values (if normalize=true)
+ * 4. Optionally removes invalid embed operations
+ *
+ * @param delta - The Delta to sanitize
+ * @param registry - The Registry to use for validation/normalization
+ * @param options - Sanitization options
+ * @returns A new sanitized Delta
+ *
+ * @example
+ * ```typescript
+ * const registry = createDefaultRegistry();
+ * const dirty = new Delta()
+ *   .insert('Hello', { bold: true, unknown: 'value', color: 'red' })
+ *   .insert('\n');
+ *
+ * const clean = sanitizeDelta(dirty, registry);
+ * // { bold: true, color: '#ff0000' } - unknown removed, color normalized
+ * ```
+ */
+declare function sanitizeDelta(delta: Delta, registry: Registry, options?: SanitizeOptions): Delta;
+/**
+ * Normalize a Delta's attributes without removing anything
+ *
+ * This is a lighter operation that only normalizes values,
+ * without removing unknown or invalid attributes.
+ *
+ * @param delta - The Delta to normalize
+ * @param registry - The Registry to use for normalization
+ * @returns A new Delta with normalized attributes
+ */
+declare function normalizeDelta(delta: Delta, registry: Registry): Delta;
+/**
+ * Validate a Delta against a Registry
+ *
+ * @param delta - The Delta to validate
+ * @param registry - The Registry to use for validation
+ * @returns true if all attributes in the Delta are valid
+ */
+declare function validateDelta(delta: Delta, registry: Registry): boolean;
+/**
+ * Deep clone a Delta
+ *
+ * @param delta - The Delta to clone
+ * @returns A new Delta with cloned ops
+ */
+declare function cloneDelta(delta: Delta): Delta;
+
+/**
+ * Delta → HTML Conversion
+ *
+ * Converts a Delta document to an HTML string.
+ */
+
+/**
+ * Options for Delta → HTML conversion
+ */
+interface DeltaToHtmlOptions {
+    /**
+     * Pretty print output with indentation
+     * @default false
+     */
+    pretty?: boolean;
+    /**
+     * Custom embed renderers (merged with defaults)
+     */
+    embedRenderers?: Record<string, (value: unknown, attrs?: Record<string, unknown>) => string>;
+    /**
+     * Wrap output in a container element
+     * @default undefined (no wrapper)
+     */
+    wrapper?: string;
+    /**
+     * Use semantic HTML5 elements
+     * @default true
+     */
+    semantic?: boolean;
+    /**
+     * Use hierarchical numbering for ordered lists (e.g., 1, 1.1, 1.1.1)
+     * When enabled, list items get data-number attribute with calculated number
+     * @default false
+     */
+    hierarchicalNumbers?: boolean;
+    /**
+     * Block handler registry for complex block embeds (Extended Table, etc.)
+     * When provided, `{ insert: { block: { type, ... } } }` ops are dispatched
+     * to the matching BlockHandler.toHtml() for rendering.
+     */
+    blockHandlers?: BlockHandlerRegistry;
+    /**
+     * Generate anchor link `id` attributes on heading elements (`<h1>`-`<h6>`).
+     *
+     * When enabled, headings get an `id` computed via slugify(text).
+     * If a heading has an explicit `header-id` attribute in Delta, that id is used instead.
+     * Duplicate slugs are deduplicated with `-1`, `-2` suffixes.
+     *
+     * @default false
+     */
+    anchorLinks?: boolean;
+    /**
+     * Format registry for custom embed rendering.
+     *
+     * When provided, embed formats with a `render()` method are used
+     * before falling back to built-in EMBED_RENDERERS.
+     * This enables extensibility without modifying converter internals.
+     */
+    registry?: Registry;
+}
+/**
+ * Convert a Delta to an HTML string
+ *
+ * @param delta - The Delta to convert
+ * @param options - Conversion options
+ * @returns HTML string
+ *
+ * @example
+ * ```typescript
+ * const delta = new Delta()
+ *   .insert('Hello ', { bold: true })
+ *   .insert('World')
+ *   .insert('\n', { header: 1 });
+ *
+ * const html = deltaToHtml(delta);
+ * // '<h1><strong>Hello </strong>World</h1>'
+ * ```
+ */
+declare function deltaToHtml(delta: Delta, options?: DeltaToHtmlOptions): string;
+
+/**
+ * HTML → Delta Conversion
+ *
+ * Converts HTML string to a Delta document.
+ */
+
+/**
+ * Options for HTML → Delta conversion
+ */
+interface HtmlToDeltaOptions {
+    /**
+     * DOM adapter to use (defaults to auto-detected)
+     */
+    adapter?: DOMAdapter;
+    /**
+     * Normalize whitespace (collapse multiple spaces, trim)
+     * @default true
+     */
+    normalizeWhitespace?: boolean;
+    /**
+     * Custom tag handlers for special elements
+     */
+    tagHandlers?: Record<string, TagHandler>;
+    /**
+     * Block handler registry for Extended Table and other block embeds.
+     * When provided and a handler for 'table' is registered,
+     * `<table>` elements will be parsed as block embeds instead of Simple Table.
+     */
+    blockHandlers?: BlockHandlerRegistry;
+    /**
+     * Format registry for custom embed matching.
+     *
+     * When provided, embed formats with a `match()` method are tried
+     * before falling back to built-in tag handlers (img, video, iframe, etc.).
+     * This enables extensibility without modifying converter internals.
+     */
+    registry?: Registry;
+}
+/**
+ * Custom tag handler function
+ */
+type TagHandler = (element: DOMElement, context: ParserContext$1) => void;
+/**
+ * Parser context passed to tag handlers
+ */
+interface ParserContext$1 {
+    delta: Delta;
+    attributes: AttributeMap;
+    blockAttributes: AttributeMap;
+    pushText(text: string): void;
+    pushEmbed(embed: Record<string, unknown>, attrs?: AttributeMap): void;
+    pushNewline(): void;
+}
+/**
+ * Convert HTML string to Delta
+ *
+ * @param html - The HTML string to convert
+ * @param options - Conversion options
+ * @returns Delta document
+ *
+ * @example
+ * ```typescript
+ * const html = '<p><strong>Hello</strong> World</p>';
+ * const delta = htmlToDelta(html);
+ * // { ops: [
+ * //   { insert: 'Hello', attributes: { bold: true } },
+ * //   { insert: ' World\n' }
+ * // ]}
+ * ```
+ */
+declare function htmlToDelta(html: string, options?: HtmlToDeltaOptions): Delta;
+
+/**
+ * Escape HTML special characters
+ */
+declare function escapeHtml(text: string): string;
+/**
+ * Unescape HTML entities
+ */
+declare function unescapeHtml(text: string): string;
+
+/**
+ * GitHub-compatible slugify for heading anchor links.
+ *
+ * Algorithm matches GitHub's heading-to-id conversion:
+ * 1. Trim leading/trailing whitespace
+ * 2. Convert to lowercase
+ * 3. Remove everything except word characters (letters, digits, underscore),
+ *    spaces, hyphens (preserves Unicode letters via \p{L})
+ * 4. Replace spaces with hyphens
+ * 5. Collapse consecutive hyphens
+ * 6. Trim leading/trailing hyphens
+ *
+ * @param text - heading plain text content
+ * @returns slugified string suitable for HTML id attribute
+ *
+ * @example
+ * ```typescript
+ * slugify('Getting Started');     // 'getting-started'
+ * slugify('API Reference (v2)');  // 'api-reference-v2'
+ * slugify('Что нового?');         // 'что-нового'
+ * slugify('  Hello  World  ');    // 'hello--world' → 'hello-world'
+ * ```
+ */
+declare function slugify(text: string): string;
+/**
+ * Slugify with deduplication: appends `-1`, `-2`, etc. on collision.
+ *
+ * Tracks used slugs via a Map. Call this for each heading in order during
+ * a single document render pass.
+ *
+ * @param text - heading plain text content
+ * @param usedSlugs - mutable map tracking slug usage counts
+ * @returns unique slugified string
+ *
+ * @example
+ * ```typescript
+ * const used = new Map<string, number>();
+ * slugifyWithDedup('FAQ', used);  // 'faq'
+ * slugifyWithDedup('FAQ', used);  // 'faq-1'
+ * slugifyWithDedup('FAQ', used);  // 'faq-2'
+ * ```
+ */
+declare function slugifyWithDedup(text: string, usedSlugs: Map<string, number>): string;
+
+/**
+ * Delta → Markdown Conversion
+ *
+ * Converts a Delta document to Markdown string.
+ */
+
+/**
+ * Options for Delta → Markdown conversion
+ */
+interface DeltaToMarkdownOptions {
+    /**
+     * Use strict Markdown (no GFM extensions)
+     * @default false
+     */
+    strict?: boolean;
+    /**
+     * Preserve empty lines using <br> tags
+     * When false, multiple empty lines collapse to one paragraph break
+     * @default false
+     */
+    preserveEmptyLines?: boolean;
+    /**
+     * Math syntax for formula output
+     * - 'dollar': $...$ for inline, $$...$$ for block (default, GFM-compatible)
+     * - 'latex': \(...\) for inline, \[...\] for block (used by LLMs: DeepSeek, ChatGPT, Claude)
+     * @default 'dollar'
+     */
+    mathSyntax?: 'dollar' | 'latex';
+    /**
+     * Display math rendering mode
+     * - true (default): code-block "math" → ```math ``` (GFM code block)
+     * - false: code-block "math" → $...$ on its own line (inline syntax)
+     *
+     * Does NOT affect inline formulas ({ formula }) — they always render as $...$
+     * @default true
+     */
+    mathBlock?: boolean;
+    /**
+     * Mermaid diagram rendering mode
+     * - true (default): code-block "mermaid" → ```mermaid ``` (fenced block)
+     * - false: code-block "mermaid" → ```mermaid ``` (same output, but { diagram } embeds also → ```mermaid)
+     *
+     * Does NOT affect the Markdown output for code-block "mermaid" (always fenced).
+     * Controls how { diagram } embeds are rendered.
+     * @default true
+     */
+    mermaidBlock?: boolean;
+    /**
+     * PlantUML diagram rendering mode
+     * - true (default): code-block "plantuml" → ```plantuml ``` (fenced block)
+     * - false: code-block "plantuml" → ```plantuml ``` (same output, but { diagram } embeds with @startuml → ```plantuml)
+     *
+     * Does NOT affect the Markdown output for code-block "plantuml" (always fenced).
+     * Controls how { diagram } embeds containing PlantUML are rendered.
+     * @default true
+     */
+    plantumlBlock?: boolean;
+    /**
+     * Custom embed renderers
+     */
+    embedRenderers?: Record<string, (value: unknown, attrs?: AttributeMap) => string>;
+    /**
+     * Block handler registry for Extended Table and other block embeds.
+     * When provided, block embeds will be rendered via handler.toMarkdown() → fallback to handler.toHtml().
+     */
+    blockHandlers?: BlockHandlerRegistry;
+    /**
+     * Pretty-print HTML output for block embeds (Extended Table, Columns, etc.)
+     * When true, HTML fallback in Markdown is indented and line-broken for readability.
+     * When false (default), HTML is compact single-line — safer for CommonMark.
+     * @default false
+     */
+    prettyHtml?: boolean;
+    /**
+     * Format registry for custom embed Markdown rendering.
+     *
+     * When provided, embed formats with a `toMarkdown()` method are used
+     * before falling back to built-in handlers. If `toMarkdown()` returns null,
+     * `render()` is used as HTML fallback in Markdown.
+     */
+    registry?: Registry;
+}
+/**
+ * Convert Delta to Markdown
+ *
+ * @param delta - The Delta document to convert
+ * @param options - Conversion options
+ * @returns Markdown string
+ *
+ * @example
+ * ```typescript
+ * const delta = new Delta()
+ *   .insert('Hello', { bold: true })
+ *   .insert(' World\n');
+ *
+ * const md = deltaToMarkdown(delta);
+ * // '**Hello** World\n'
+ * ```
+ */
+declare function deltaToMarkdown(delta: Delta, options?: DeltaToMarkdownOptions): string;
+
+/**
+ * Markdown → Delta Conversion
+ *
+ * Converts Markdown string to a Delta document using remark (unified).
+ */
+
+/**
+ * Options for Markdown → Delta conversion
+ */
+interface MarkdownToDeltaOptions {
+    /**
+     * Enable GFM (GitHub Flavored Markdown) extensions
+     * Includes: tables, strikethrough, task lists, autolinks
+     * @default true
+     */
+    gfm?: boolean;
+    /**
+     * Display math rendering mode
+     * - true (default): $$...$$ / ```math → code-block "math" in Delta
+     * - false: $$...$$ / ```math → inline { formula } embed in Delta
+     *
+     * Does NOT affect inline math ($...$) — always becomes { formula } embed
+     * @default true
+     */
+    mathBlock?: boolean;
+    /**
+     * Mermaid diagram rendering mode
+     * - true (default): ```mermaid → code-block "mermaid" in Delta
+     * - false: ```mermaid → inline { diagram } embed in Delta
+     * @default true
+     */
+    mermaidBlock?: boolean;
+    /**
+     * PlantUML diagram rendering mode
+     * - true (default): ```plantuml → code-block "plantuml" in Delta
+     * - false: ```plantuml → inline { diagram } embed in Delta
+     * @default true
+     */
+    plantumlBlock?: boolean;
+    /**
+     * Custom node handlers for special elements
+     */
+    nodeHandlers?: Record<string, NodeHandler>;
+    /**
+     * Block handler registry for Extended Table and other block embeds.
+     * Reserved for future use — GFM tables don't support Extended Table features.
+     * HTML tables in Markdown are parsed via htmlToDelta when blockHandlers is provided.
+     */
+    blockHandlers?: BlockHandlerRegistry;
+}
+/**
+ * MDAST node type (simplified)
+ */
+interface MdastNode {
+    type: string;
+    children?: MdastNode[];
+    value?: string;
+    url?: string;
+    alt?: string;
+    title?: string;
+    lang?: string;
+    meta?: string;
+    depth?: number;
+    ordered?: boolean;
+    checked?: boolean | null;
+    spread?: boolean;
+    /** Footnote identifier (for footnoteReference / footnoteDefinition) */
+    identifier?: string;
+    /** Footnote label (for footnoteReference / footnoteDefinition) */
+    label?: string;
+}
+/**
+ * Custom node handler function
+ */
+type NodeHandler = (node: MdastNode, context: ParserContext) => void;
+/**
+ * Parser context for building Delta
+ */
+interface ParserContext {
+    delta: Delta;
+    pushText(text: string, attrs?: AttributeMap): void;
+    pushEmbed(embed: Record<string, unknown>, attrs?: AttributeMap): void;
+    pushNewline(attrs?: AttributeMap): void;
+}
+/**
+ * Check if remark is available
+ */
+declare function isRemarkAvailable(): boolean;
+/**
+ * Convert Markdown to Delta (async)
+ */
+declare function markdownToDelta(markdown: string, options?: MarkdownToDeltaOptions): Promise<Delta>;
+/**
+ * Synchronous version (requires remark to be pre-loaded or uses require)
+ */
+declare function markdownToDeltaSync(markdown: string, options?: MarkdownToDeltaOptions): Delta;
+
+export { ALERT_TYPES, type AlertBlockData, type AlertType, type AlignType, BOX_FLOAT_VALUES, BOX_OVERFLOW_VALUES, type BlockContext, type BlockHandler, BlockHandlerRegistry, type BlockRenderOptions, type BoxBlockData, type BoxFloat, type BoxOpAttributes, type BoxOverflow, BrowserDOMAdapter, type CellAlign, type CellData, type ColumnsBlockData, type DOMAdapter, type DOMDocument, type DOMDocumentFragment, type DOMElement, type DOMNode, type DOMNodeList, type DeltaToHtmlOptions, type DeltaToMarkdownOptions, type FootnotesBlockData, type Format, type FormatDefinition, type FormatMatchResult, type FormatScope, type HtmlToDeltaOptions, type ListType, type MarkdownToDeltaOptions, NODE_TYPE, NodeDOMAdapter, Registry, type SanitizeOptions, type TableBlockData, type TableColAlignType, alertBlockHandler, alignFormat, backgroundFormat, blockFormat, blockquoteFormat, boldFormat, boxBlockHandler, browserAdapter, cloneDelta, codeBlockFormat, codeFormat, colorFormat, columnsBlockHandler, createDefaultBlockHandlers, createDefaultRegistry, defaultBlockFormats, defaultEmbedFormats, defaultFormats, defaultInlineFormats, deltaToHtml, deltaToMarkdown, dividerFormat, escapeHtml, extractBoxOpAttributes, footnoteRefFormat, footnotesBlockHandler, formulaFormat, getAdapter, getNamedColors, headerFormat, headerIdFormat, htmlToDelta, imageFormat, indentFormat, isAdapterAvailable, isElement, isRemarkAvailable, isTextNode, isValidColor, isValidHexColor, italicFormat, kbdFormat, linkFormat, listFormat, markFormat, markdownToDelta, markdownToDeltaSync, nodeAdapter, normalizeDelta, sanitizeDelta, slugify, slugifyWithDedup, strikeFormat, subscriptFormat, superscriptFormat, tableBlockHandler, tableColAlignFormat, tableColFormat, tableHeaderFormat, tableRowFormat, toHexColor, underlineFormat, unescapeHtml, validateDelta, videoFormat };