@lyfie/luthor-headless 2.3.1 → 2.3.2

package/dist/index.d.cts

@@ -1,2531 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { TextFormatType, LexicalEditor, KlassConstructor, LexicalNode, LexicalNodeReplacement, EditorThemeClasses, ParagraphNode, SerializedLexicalNode, EditorConfig as EditorConfig$1, DOMConversionMap, DOMExportOutput, ElementNode, DecoratorNode, RangeSelection } from 'lexical';
-export { LexicalEditor } from 'lexical';
-import * as React$1 from 'react';
-import React__default, { ReactNode, ComponentType, CSSProperties } from 'react';
-import { ListNode, ListItemNode } from '@lexical/list';
-import { CodeNode, CodeHighlightNode } from '@lexical/code';
-import { HeadingTagType, HeadingNode, QuoteNode } from '@lexical/rich-text';
-
-type LexicalNodeRegistration = KlassConstructor<typeof LexicalNode> | LexicalNodeReplacement;
-/** Extension category buckets */
-declare enum ExtensionCategory {
-    Toolbar = "toolbar",
-    Sidebar = "sidebar",
-    ContextMenu = "contextmenu",
-    Floating = "floating"
-}
-/** Shared base config for extensions */
-interface BaseExtensionConfig {
-    showInToolbar?: boolean;
-    category?: ExtensionCategory[];
-    position?: "before" | "after";
-    /** Initialization priority; higher registers first (default: 0) */
-    initPriority?: number;
-    [key: string]: unknown;
-}
-/** Toolbar item configuration */
-interface ToolbarItem {
-    label: string;
-    onClick: () => void;
-    isActive?: () => boolean;
-    component?: React.ComponentType<Record<string, unknown>>;
-}
-/**
- * Core extension contract implemented by all extensions.
- * Defines the required API surface for Luthor extensions.
- *
- * @template Name - Exact literal type of the extension name
- * @template Config - Extension configuration type
- * @template Commands - Command map exposed by the extension
- * @template StateQueries - State query function map
- * @template Plugins - React plugins exposed by the extension
- */
-interface Extension<Name extends string = string, Config extends BaseExtensionConfig = BaseExtensionConfig, Commands extends Record<string, unknown> = Record<string, never>, StateQueries extends Record<string, () => Promise<boolean>> = Record<string, never>, Plugins extends ReactNode[] = ReactNode[]> {
-    /** Unique identifier for this extension */
-    name: Name;
-    /** Category groups for this extension */
-    category: ExtensionCategory[];
-    /** Extension configuration */
-    config: Config;
-    /** Supported text formats */
-    supportedFormats?: readonly TextFormatType[];
-    /** Update extension settings */
-    configure?: (config: Partial<Config>) => Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /** Register the extension with Lexical */
-    register: (editor: LexicalEditor) => () => void;
-    /** Override the extension UI component */
-    overrideUI?: (CustomUI: ComponentType<{
-        selected?: boolean;
-        className?: string;
-        style?: CSSProperties;
-        [key: string]: unknown;
-    }>) => Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /** Override node rendering logic */
-    overrideNodeRender?: (overrides: {
-        createDOM?: (config: unknown) => HTMLElement;
-        updateDOM?: (prev: unknown, next: unknown, dom: HTMLElement) => boolean;
-    }) => Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /** Return custom Lexical nodes */
-    getNodes?: () => LexicalNodeRegistration[];
-    /** Return React plugins */
-    getPlugins: () => Plugins;
-    /** Provide commands exposed by the extension */
-    getCommands: (editor: LexicalEditor) => Commands;
-    /** Return state query functions */
-    getStateQueries?: (editor: LexicalEditor) => StateQueries;
-}
-type MergeCommands<T> = {
-    [K in UnionKeys<T>]: T extends {
-        [P in K]: infer V;
-    } ? V : never;
-};
-type MergeStateQueries<T> = {
-    [K in UnionKeys<T>]: boolean;
-};
-type ExtractNames<Exts extends readonly Extension[]> = Exts[number]["name"];
-type ExtractCommands<Exts extends readonly Extension[]> = MergeCommands<ReturnType<Exts[number]["getCommands"]>>;
-type ExtractPlugins<Exts extends readonly Extension[]> = ReturnType<Exts[number]["getPlugins"]>[number];
-type UnionKeys<T> = T extends unknown ? keyof T : never;
-type ExtractStateQueries<Exts extends readonly Extension[]> = MergeStateQueries<ReturnType<NonNullable<Exts[number]["getStateQueries"]>>>;
-interface BaseCommands {
-    formatText: (format: TextFormatType, value?: boolean | string) => void;
-}
-/**
- * Editor system context type, parameterized by the extensions array.
- * Exposes typed commands, state, and utilities.
- *
- * @template Exts - Extensions array that defines available functionality
- */
-interface EditorContextType<Exts extends readonly Extension[]> {
-    /** Underlying Lexical editor instance */
-    editor: LexicalEditor | null;
-    /** Editor settings */
-    config?: EditorConfig;
-    /** Loaded extensions list */
-    extensions: Exts;
-    /** Commands available from all extensions */
-    commands: BaseCommands & ExtractCommands<Exts>;
-    /** Current state for all extensions */
-    activeStates: ExtractStateQueries<Exts>;
-    /** State query functions from extensions */
-    stateQueries: Record<string, () => Promise<unknown>>;
-    /** Event listener registration */
-    listeners: {
-        registerUpdate: (listener: (state: unknown) => void) => (() => void) | undefined;
-        registerPaste: (listener: (event: ClipboardEvent) => boolean) => (() => void) | undefined;
-    };
-    /** Export helpers for formats */
-    export: {
-        toJSON: () => unknown;
-    };
-    /** Import helpers for formats */
-    import: {
-        fromJSON: (json: unknown) => void;
-    };
-    /** Alias of the raw Lexical editor */
-    lexical: LexicalEditor | null;
-    /** Dynamic extensions API */
-    extensionsAPI: {
-        add: (ext: Extension) => void;
-        remove: (name: string) => void;
-        reorder: (names: string[]) => void;
-    };
-    /** React plugins collected from extensions */
-    plugins: ExtractPlugins<Exts>[];
-    /** Check whether a specific extension is loaded */
-    hasExtension: (name: ExtractNames<Exts>) => boolean;
-}
-interface EditorConfig {
-    theme?: EditorThemeClasses;
-    [key: string]: unknown;
-}
-
-interface ProviderProps<Exts extends readonly Extension[]> {
-    children: ReactNode;
-    config?: EditorConfig;
-    extensions: Exts;
-}
-/**
- * Creates a typed editor system based on the provided extensions array.
- * This factory function generates a Provider component and useEditor hook
- * that are strongly typed based on the extensions passed to it.
- *
- * @template Exts - Array of extensions that define the editor's capabilities
- * @returns Object containing Provider component and useEditor hook
- *
- * @example
- * ```tsx
- * const extensions = [boldExtension, italicExtension] as const;
- * const { Provider, useEditor } = createEditorSystem<typeof extensions>();
- * ```
- */
-declare function createEditorSystem<Exts extends readonly Extension[]>(): {
-    Provider: (props: ProviderProps<Exts>) => react_jsx_runtime.JSX.Element;
-    useEditor: () => EditorContextType<Exts>;
-};
-declare const BaseProvider: (props: ProviderProps<readonly Extension<string, BaseExtensionConfig, Record<string, never>, Record<string, never>, React__default.ReactNode[]>[]>) => react_jsx_runtime.JSX.Element;
-declare const useBaseEditor: () => EditorContextType<readonly Extension<string, BaseExtensionConfig, Record<string, never>, Record<string, never>, React__default.ReactNode[]>[]>;
-
-/**
- * Abstract base class for all Luthor extensions.
- * Provides default implementations and shared extension behavior.
- *
- * @template Name - Literal extension name
- * @template Config - Configuration object type
- * @template Commands - Commands exposed by this extension
- * @template StateQueries - State query functions exposed by this extension
- * @template Plugins - React plugins/components exposed by this extension
- */
-declare abstract class BaseExtension<Name extends string = string, Config extends BaseExtensionConfig = BaseExtensionConfig, Commands extends Record<string, unknown> = Record<string, never>, StateQueries extends Record<string, () => Promise<boolean>> = Record<string, never>, Plugins extends ReactNode[] = ReactNode[]> implements Extension<Name, Config, Commands, StateQueries, Plugins> {
-    /** Unique name identifier for this extension */
-    name: Name;
-    /** Categories this extension belongs to (toolbar, sidebar, etc.) */
-    category: ExtensionCategory[];
-    /** Configuration for this extension */
-    config: Config;
-    /** Text formats supported by this extension */
-    supportedFormats: readonly TextFormatType[];
-    /** Node rendering overrides */
-    nodeOverrides: {
-        createDOM?: (config: unknown) => HTMLElement;
-        updateDOM?: (prev: unknown, next: unknown, dom: HTMLElement) => boolean;
-    };
-    /**
-     * Creates a new extension instance.
-     *
-     * @param name - Unique name for this extension
-     * @param category - Categories this extension belongs to
-     */
-    constructor(name: Name, category?: ExtensionCategory[]);
-    /**
-     * Configures the extension with new settings.
-     * Returns the instance with updated configuration.
-     *
-     * @param config - Partial configuration to merge into existing config
-     * @returns Extension instance with updated config
-     */
-    configure(config: Partial<Config>): Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /**
-     * Registers the extension with the Lexical editor.
-     * Override to set up event listeners, commands, etc.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function to unregister the extension
-     */
-    abstract register(editor: LexicalEditor): () => void;
-    /**
-     * Returns custom Lexical nodes exposed by this extension.
-     *
-     * @returns Array of Lexical node classes
-     */
-    getNodes(): LexicalNodeRegistration[];
-    /**
-     * Allows overriding the UI component used for this extension.
-     *
-     * @param CustomUI - Custom React component to render
-     * @returns Extension instance for chaining
-     */
-    overrideUI(CustomUI: ComponentType<{
-        selected?: boolean;
-        className?: string;
-        style?: CSSProperties;
-        [key: string]: unknown;
-    }>): Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /**
-     * Overrides node rendering behavior.
-     *
-     * @param overrides - DOM creation and update handlers
-     * @returns Extension instance for chaining
-     */
-    overrideNodeRender(overrides: {
-        createDOM?: (config: unknown) => HTMLElement;
-        updateDOM?: (prev: unknown, next: unknown, dom: HTMLElement) => boolean;
-    }): Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /**
-     * Returns React plugins/components exposed by this extension.
-     *
-     * @returns Array of React nodes to render
-     */
-    getPlugins(): Plugins;
-    /**
-     * Returns commands exposed by this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing command functions
-     */
-    getCommands(editor: LexicalEditor): Commands;
-    /**
-     * Returns state query functions exposed by this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing state query functions
-     */
-    getStateQueries(editor: LexicalEditor): StateQueries;
-    /**
-     * Returns toolbar items contributed by this extension.
-     *
-     * @param commands - Available commands from all extensions
-     * @returns Array of toolbar item configurations
-     */
-    getToolbarItems(commands: Record<string, unknown>): ToolbarItem[];
-}
-
-/**
- * Configuration options for creating a custom extension
- */
-interface CreateExtensionConfig<Name extends string, Config extends BaseExtensionConfig = BaseExtensionConfig, Commands extends Record<string, unknown> = Record<string, never>, StateQueries extends Record<string, () => Promise<boolean>> = Record<string, never>, Plugins extends ReactNode[] = ReactNode[]> {
-    /** Unique name for the extension */
-    name: Name;
-    /** Categories this extension belongs to */
-    category?: ExtensionCategory[];
-    /** Default configuration */
-    config?: Partial<Config>;
-    /** Commands provided by this extension */
-    commands?: (editor: LexicalEditor) => Commands;
-    /** State query functions */
-    stateQueries?: (editor: LexicalEditor) => StateQueries;
-    /** React plugins/components */
-    plugins?: Plugins;
-    /** Initialization function called when extension is registered */
-    initialize?: (editor: LexicalEditor) => (() => void) | void;
-    /** Custom Lexical nodes */
-    nodes?: LexicalNodeRegistration[];
-    /** Text formats supported by this extension */
-    supportedFormats?: readonly TextFormatType[];
-}
-/**
- * Factory function to create a type-safe extension that extends BaseExtension.
- * Provides a simpler API for creating extensions while maintaining full type safety.
- *
- * @template Name - Literal type for the extension name
- * @template Config - Configuration object type
- * @template Commands - Commands provided by the extension
- * @template StateQueries - State query functions
- * @template Plugins - React plugins provided by the extension
- *
- * @param config - Configuration object for the extension
- * @returns A fully typed extension instance
- *
- * @example
- * ```tsx
- * const myExtension = createExtension({
- *   name: 'my-extension',
- *   commands: (editor) => ({
- *     myCommand: () => console.log('Hello!')
- *   }),
- *   stateQueries: (editor) => ({
- *     isActive: async () => true
- *   }),
- *   initialize: (editor) => {
- *     // Custom initialization
- *     return () => {
- *       // Cleanup function
- *     };
- *   }
- * });
- * ```
- */
-declare function createExtension<Name extends string, Config extends BaseExtensionConfig = BaseExtensionConfig, Commands extends Record<string, unknown> = Record<string, never>, StateQueries extends Record<string, () => Promise<boolean>> = Record<string, never>, Plugins extends ReactNode[] = ReactNode[]>(config: CreateExtensionConfig<Name, Config, Commands, StateQueries, Plugins>): BaseExtension<Name, Config, Commands, StateQueries, Plugins>;
-
-declare const LUTHOR_EDITOR_THEME_TOKENS: readonly ["--luthor-bg", "--luthor-fg", "--luthor-border", "--luthor-border-hover", "--luthor-border-active", "--luthor-accent", "--luthor-accent-hover", "--luthor-shadow", "--luthor-muted", "--luthor-muted-fg", "--luthor-theme-transition", "--luthor-drag-gutter-width", "--luthor-line-height-ratio", "--luthor-toolbar-bg", "--luthor-toolbar-section-border", "--luthor-toolbar-button-fg", "--luthor-toolbar-button-hover-bg", "--luthor-toolbar-button-hover-border", "--luthor-toolbar-button-hover-shadow", "--luthor-toolbar-button-press-shadow", "--luthor-toolbar-button-active-bg", "--luthor-toolbar-button-active-border", "--luthor-toolbar-button-active-fg", "--luthor-toolbar-button-active-shadow", "--luthor-toolbar-button-overlay", "--luthor-toolbar-button-active-overlay", "--luthor-toolbar-color-indicator-border", "--luthor-toolbar-highlight-bg", "--luthor-quote-bg", "--luthor-quote-fg", "--luthor-quote-border", "--luthor-text-bold-color", "--luthor-link-color", "--luthor-list-marker-color", "--luthor-list-checkbox-color", "--luthor-table-border-color", "--luthor-table-header-bg", "--luthor-hr-color", "--luthor-placeholder-color", "--luthor-codeblock-bg", "--luthor-syntax-comment", "--luthor-syntax-keyword", "--luthor-syntax-string", "--luthor-syntax-number", "--luthor-syntax-function", "--luthor-syntax-variable", "--luthor-floating-bg", "--luthor-floating-fg", "--luthor-floating-border", "--luthor-floating-shadow", "--luthor-floating-muted", "--luthor-floating-border-hover", "--luthor-floating-border-active", "--luthor-floating-accent", "--luthor-floating-accent-fg", "--luthor-preset-bg", "--luthor-preset-fg", "--luthor-preset-border", "--luthor-preset-muted", "--luthor-preset-muted-fg", "--luthor-preset-accent", "--luthor-preset-radius", "--luthor-preset-shadow", "--luthor-preset-content-padding", "--luthor-preset-content-min-height"];
-type LuthorEditorThemeToken = (typeof LUTHOR_EDITOR_THEME_TOKENS)[number];
-type LuthorEditorThemeOverrides = Partial<Record<LuthorEditorThemeToken, string>>;
-declare function createEditorThemeStyleVars(overrides?: LuthorEditorThemeOverrides): React__default.CSSProperties | undefined;
-/**
- * Enhanced theme type that extends Lexical's EditorThemeClasses
- * with better TypeScript support and additional properties
- */
-interface LuthorTheme extends EditorThemeClasses {
-    toolbar?: {
-        button?: string;
-        buttonActive?: string;
-        buttonDisabled?: string;
-        group?: string;
-    };
-    container?: string;
-    wrapper?: string;
-    contextMenu?: {
-        container?: string;
-        item?: string;
-        itemDisabled?: string;
-    };
-    draggable?: {
-        handle?: string;
-        handleActive?: string;
-        handleHover?: string;
-        handleDragging?: string;
-        blockDragging?: string;
-        dropIndicator?: string;
-        upButton?: string;
-        downButton?: string;
-        blockIsDragging?: string;
-        buttonStack?: string;
-        styles?: {
-            handle?: React__default.CSSProperties;
-            handleActive?: React__default.CSSProperties;
-            handleHover?: React__default.CSSProperties;
-            handleDragging?: React__default.CSSProperties;
-            blockDragging?: React__default.CSSProperties;
-            dropIndicator?: React__default.CSSProperties;
-            upButton?: React__default.CSSProperties;
-            downButton?: React__default.CSSProperties;
-            blockIsDragging?: React__default.CSSProperties;
-            buttonStack?: React__default.CSSProperties;
-        };
-    };
-    floatingToolbar?: {
-        container?: string;
-        button?: string;
-        buttonActive?: string;
-        styles?: {
-            container?: React__default.CSSProperties;
-            button?: React__default.CSSProperties;
-            buttonActive?: React__default.CSSProperties;
-        };
-    };
-    styles?: {
-        toolbar?: {
-            button?: React__default.CSSProperties;
-            buttonActive?: React__default.CSSProperties;
-            buttonDisabled?: React__default.CSSProperties;
-            group?: React__default.CSSProperties;
-        };
-        container?: React__default.CSSProperties;
-        wrapper?: React__default.CSSProperties;
-        draggable?: {
-            handle?: React__default.CSSProperties;
-            handleHover?: React__default.CSSProperties;
-            handleDragging?: React__default.CSSProperties;
-            blockDragging?: React__default.CSSProperties;
-            dropIndicator?: React__default.CSSProperties;
-            upButton?: React__default.CSSProperties;
-            downButton?: React__default.CSSProperties;
-            blockIsDragging?: React__default.CSSProperties;
-            buttonStack?: React__default.CSSProperties;
-        };
-        floatingToolbar?: {
-            container?: React__default.CSSProperties;
-            button?: React__default.CSSProperties;
-            buttonActive?: React__default.CSSProperties;
-        };
-    };
-}
-/**
- * Default Luthor theme with sensible defaults
- */
-declare const defaultLuthorTheme: LuthorTheme;
-/**
- * Helper function to merge themes
- */
-declare function mergeThemes(baseTheme: LuthorTheme, overrideTheme: Partial<LuthorTheme>): LuthorTheme;
-/**
- * Type guard to check if a theme is a LuthorTheme
- */
-declare function isLuthorTheme(theme: any): theme is LuthorTheme;
-
-declare function clearLexicalSelection(editor: LexicalEditor): void;
-declare function resolveLinkNodeKeyFromAnchor(editor: LexicalEditor, anchorEl: HTMLAnchorElement): string | null;
-
-type JsonTextNode = {
-    type: "text";
-    version: 1;
-    text: string;
-    detail: 0;
-    format: 0;
-    mode: "normal";
-    style: "";
-};
-type JsonParagraphNode = {
-    type: "paragraph";
-    version: 1;
-    format: "";
-    indent: 0;
-    direction: null;
-    children: JsonTextNode[];
-};
-type JsonRootNode = {
-    type: "root";
-    version: 1;
-    format: "";
-    indent: 0;
-    direction: null;
-    children: JsonParagraphNode[];
-};
-type JsonbDocument = {
-    root: JsonRootNode;
-};
-declare function markdownToJSONB(markdown: string): JsonbDocument;
-declare function jsonbToMarkdown(input: unknown): string;
-
-/**
- * Commands exposed by text format extensions.
- * Generates toggle commands for text formatting (e.g., toggleBold, toggleItalic).
- */
-type TextFormatCommands<Name extends TextFormatType> = {
-    [Key in `toggle${Capitalize<Name>}`]: () => void;
-};
-/**
- * Base extension for text formatting (bold, italic, underline, etc.).
- * Provides shared functionality for text format extensions.
- *
- * @template Name - Text format name (e.g., 'bold', 'italic')
- */
-declare abstract class TextFormatExtension<Name extends TextFormatType> extends BaseExtension<Name, any, TextFormatCommands<Name>, Record<Name, () => Promise<boolean>>, ReactNode[]> {
-    /**
-     * Creates a new text format extension instance.
-     *
-     * @param name - Text format name
-     */
-    constructor(name: Name);
-    /**
-     * Registers the extension with the editor.
-     * Text format extensions register listeners for INSERT_PARAGRAPH_COMMAND and INSERT_LINE_BREAK_COMMAND
-     * to handle formatting behavior when Enter/Shift+Enter is pressed.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Returns the toggle command for this text format.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object with toggle command function
-     */
-    getCommands(editor: LexicalEditor): TextFormatCommands<Name>;
-    /**
-     * Returns a state query to check if the selection has this format applied.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object with format state query function
-     */
-    getStateQueries(editor: LexicalEditor): Record<Name, () => Promise<boolean>>;
-}
-
-/**
- * Bold text formatting extension.
- * Provides bold text formatting functionality with toggle command and state tracking.
- *
- * @example
- * ```tsx
- * const extensions = [boldExtension] as const;
- * const { Provider, useEditor } = createEditorSystem<typeof extensions>();
- *
- * function MyEditor() {
- *   const { commands, activeStates } = useEditor();
- *   return (
- *     <button
- *       onClick={() => commands.toggleBold()}
- *       className={activeStates.bold ? 'active' : ''}
- *     >
- *       Bold
- *     </button>
- *   );
- * }
- * ```
- */
-declare class BoldExtension extends TextFormatExtension<"bold"> {
-    /**
-     * Creates a new bold extension instance.
-     */
-    constructor();
-}
-/**
- * Pre-configured bold extension instance.
- * Ready to use in extension arrays.
- */
-declare const boldExtension: BoldExtension;
-
-/**
- * Italic text formatting extension.
- * Provides italic formatting with toggle command and state tracking.
- */
-declare class ItalicExtension extends TextFormatExtension<"italic"> {
-    /**
-     * Creates a new italic extension.
-     */
-    constructor();
-}
-/**
- * Preconfigured italic extension instance.
- * Ready for use in extension arrays.
- */
-declare const italicExtension: ItalicExtension;
-
-/**
- * Custom underline transformer for Markdown
- * Uses ++underline++ syntax (common in extended Markdown)
- */
-declare const UNDERLINE_TRANSFORMER: {
-    format: readonly ["underline"];
-    tag: string;
-    type: "text-format";
-};
-/**
- * UnderlineExtension - Adds underline text formatting
- *
- * Extends TextFormatExtension to add underline formatting for selected text in
- * the Lexical editor. Integrates with the toolbar system and exposes commands
- * and state queries for underline actions.
- *
- * Supports Markdown syntax: ++underline++
- *
- * @example
- * ```tsx
- * import { underlineExtension } from '@lyfie/luthor-headless/extensions/formatting/UnderlineExtension';
- *
- * const extensions = [underlineExtension];
- * const editor = createEditorSystem(extensions);
- * ```
- */
-declare class UnderlineExtension extends TextFormatExtension<"underline"> {
-    constructor();
-    /**
-     * Returns Markdown transformers for underline formatting.
-     *
-    * @returns An array containing the underline transformer
-     */
-    getMarkdownTransformers(): readonly typeof UNDERLINE_TRANSFORMER[];
-}
-declare const underlineExtension: UnderlineExtension;
-
-/**
- * StrikethroughExtension - Adds strikethrough text formatting
- *
- * Extends TextFormatExtension to add strikethrough formatting for selected
- * text in the Lexical editor. Integrates with the toolbar system and exposes
- * commands and state queries for strikethrough actions.
- *
- * @example
- * ```tsx
- * import { strikethroughExtension } from '@lyfie/luthor-headless/extensions/formatting/StrikethroughExtension';
- *
- * const extensions = [strikethroughExtension];
- * const editor = createEditorSystem(extensions);
- * ```
- */
-declare class StrikethroughExtension extends TextFormatExtension<"strikethrough"> {
-    constructor();
-}
-declare const strikethroughExtension: StrikethroughExtension;
-
-/**
- * Link extension configuration.
- */
-interface LinkConfig extends BaseExtensionConfig {
-    /**
-     * Automatically link URLs as you type in the editor.
-     * Uses real-time pattern matching. Default: false
-     */
-    autoLinkText?: boolean;
-    /**
-     * Automatically link URLs when pasted into the editor.
-     * When false, pasted URLs remain plain text. Default: true
-     */
-    autoLinkUrls?: boolean;
-    /**
-     * Link selected text when pasting URLs over it.
-     * When true: selected text becomes a link with the pasted URL.
-     * When false: selected text is replaced with the pasted URL and then linked. Default: true
-     */
-    linkSelectedTextOnPaste?: boolean;
-    /** URL validation function (default: basic URL regex) */
-    validateUrl?: (url: string) => boolean;
-    /** Enable click navigation on links rendered inside the editor. Default: true */
-    clickableLinks?: boolean;
-    /** Open clicked links in a new tab when click navigation is enabled. Default: true */
-    openLinksInNewTab?: boolean;
-}
-/**
- * Commands exposed by the link extension.
- */
-type LinkCommands = {
-    insertLink: (url?: string, text?: string) => void;
-    updateLink: (url: string, rel?: string, target?: string) => boolean;
-    removeLink: () => void;
-    getCurrentLink: () => Promise<{
-        url: string;
-        rel: string | null;
-        target: string | null;
-    } | null>;
-    getLinkByKey: (linkNodeKey: string) => Promise<{
-        url: string;
-        rel: string | null;
-        target: string | null;
-    } | null>;
-    updateLinkByKey: (linkNodeKey: string, url: string, rel?: string, target?: string) => boolean;
-    removeLinkByKey: (linkNodeKey: string) => boolean;
-};
-/**
- * State queries exposed by the link extension.
- */
-type LinkStateQueries = {
-    isLink: () => Promise<boolean>;
-    isTextSelected: () => Promise<boolean>;
-};
-/**
- * Link extension for creating and managing hyperlinks.
- *
- * Features:
- * - Manual link creation via commands
- * - Built-in paste handling (creates links when pasting URLs)
- * - Optional auto-linking while typing
- * - Click to follow links, click again to edit
- *
- * Uses Lexical's built-in LinkPlugin which handles:
- * - Pasting URLs over selected text (converts selection to a link)
- * - Pasting URLs at the cursor (creates a new link)
- * - Link editing and validation
- *
- * @example
- * ```tsx
- * const extensions = [
- *   linkExtension.configure({
- *     autoLinkText: true, // Optional: auto-link while typing
- *     autoLinkUrls: true, // Optional: auto-link pasted URLs
- *     linkSelectedTextOnPaste: false // Optional: replace selected text rather than linking it
- *   })
- * ] as const;
- *
- * function MyEditor() {
- *   const { commands, activeStates } = useEditor();
- *   return (
- *     <button
- *       onClick={() => commands.insertLink()}
- *       className={activeStates.isLink ? 'active' : ''}
- *     >
- *       Link
- *     </button>
- *   );
- * }
- * ```
- */
-declare class LinkExtension extends BaseExtension<"link", LinkConfig, LinkCommands, LinkStateQueries, React__default.ReactElement[]> {
-    private lastSelectedLinkNodeKey;
-    /**
-     * Creates a new link extension instance.
-     */
-    constructor();
-    /**
-     * Registers the extension with the editor.
-     * Configures URL paste handling.
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Returns Lexical nodes exposed by this extension.
-     */
-    getNodes(): any[];
-    /**
-     * Returns React plugins exposed by this extension.
-     */
-    getPlugins(): React__default.ReactElement[];
-    /**
-     * Returns command handlers exposed by this extension.
-     */
-    getCommands(editor: LexicalEditor): LinkCommands;
-    private serializeLinkNode;
-    private removeLinkNode;
-    private getLinkNodeByKey;
-    private getSelectedLinkNode;
-    private getCachedLinkNode;
-    /**
-     * Returns state query functions exposed by this extension.
-     */
-    getStateQueries(editor: LexicalEditor): LinkStateQueries;
-}
-/**
- * Preconfigured link extension instance.
- * Ready for use in extension arrays.
- */
-declare const linkExtension: LinkExtension;
-
-/**
- * Commands exposed by the horizontal rule extension.
- */
-type HorizontalRuleCommands = {
-    insertHorizontalRule: () => void;
-};
-/**
- * State queries exposed by the horizontal rule extension.
- */
-type HorizontalRuleStateQueries = {
-    isHorizontalRuleSelected: () => Promise<boolean>;
-};
-/**
- * Horizontal rule extension for inserting dividers.
- * Provides commands to insert and manage horizontal rules in the editor.
- *
- * @example
- * ```tsx
- * const extensions = [horizontalRuleExtension] as const;
- * const { Provider, useEditor } = createEditorSystem<typeof extensions>();
- *
- * function MyEditor() {
- *   const { commands } = useEditor();
- *   return (
- *     <button onClick={() => commands.insertHorizontalRule()}>
- *       Insert HR
- *     </button>
- *   );
- * }
- * ```
- */
-declare class HorizontalRuleExtension extends BaseExtension<"horizontalRule", any, HorizontalRuleCommands, HorizontalRuleStateQueries, React__default.ReactElement[]> {
-    /**
-     * Creates a new horizontal rule extension.
-     */
-    constructor();
-    /**
-     * Registers the extension with the editor.
-     * No special registration needed because Lexical handles HR commands.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Returns Lexical nodes provided by this extension.
-     *
-     * @returns Array containing the HorizontalRuleNode
-     */
-    getNodes(): any[];
-    /**
-     * Returns React plugins provided by this extension.
-     *
-     * @returns Array containing the HorizontalRulePlugin
-     */
-    getPlugins(): React__default.ReactElement[];
-    /**
-     * Returns commands exposed by this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object with horizontal rule command functions
-     */
-    getCommands(editor: LexicalEditor): HorizontalRuleCommands;
-    /**
-     * Returns state query functions exposed by this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object with horizontal rule state query functions
-     */
-    getStateQueries(editor: LexicalEditor): HorizontalRuleStateQueries;
-}
-/**
- * Preconfigured horizontal rule extension instance.
- * Ready for use in extension arrays.
- */
-declare const horizontalRuleExtension: HorizontalRuleExtension;
-
-type FontFamilyOption = {
-    value: string;
-    label: string;
-    fontFamily: string;
-    cssImportUrl?: string;
-};
-type FontCssLoadStrategy = "none" | "preload-all" | "on-demand";
-interface FontFamilyConfig extends BaseExtensionConfig {
-    options: readonly FontFamilyOption[];
-    cssLoadStrategy: FontCssLoadStrategy;
-}
-type FontFamilyCommands = {
-    setFontFamily: (fontValue: string) => void;
-    clearFontFamily: () => void;
-    getCurrentFontFamily: () => Promise<string | null>;
-    getFontFamilyOptions: () => readonly FontFamilyOption[];
-};
-type FontFamilyStateQueries = {
-    hasCustomFontFamily: () => Promise<boolean>;
-};
-/**
- * FontFamilyExtension provides controlled font-family styling for text selections.
- *
- * Fonts are only applied from a configured whitelist (`config.options`).
- * Optional CSS font loading can be configured via `cssLoadStrategy`:
- * - "none": do not load external CSS
- * - "preload-all": load all option `cssImportUrl` values on register
- * - "on-demand": load a font's `cssImportUrl` when it is first selected
- */
-declare class FontFamilyExtension extends BaseExtension<"fontFamily", FontFamilyConfig, FontFamilyCommands, FontFamilyStateQueries> {
-    private readonly loadedFontUrls;
-    constructor();
-    register(): () => void;
-    configure(config: Partial<FontFamilyConfig>): Extension<"fontFamily", FontFamilyConfig, FontFamilyCommands, FontFamilyStateQueries, React$1.ReactNode[]>;
-    getCommands(editor: LexicalEditor): FontFamilyCommands;
-    getStateQueries(editor: LexicalEditor): FontFamilyStateQueries;
-    private applyFontFamily;
-    private hasCustomFontFamily;
-    private getCurrentFontFamilyValue;
-    private findOption;
-    private normalizeFontValue;
-    private ensureFontCssLoaded;
-}
-declare const fontFamilyExtension: FontFamilyExtension;
-
-type FontSizeOption = {
-    value: string;
-    label: string;
-    fontSize: string;
-};
-interface FontSizeConfig extends BaseExtensionConfig {
-    options: readonly FontSizeOption[];
-}
-type FontSizeCommands = {
-    setFontSize: (fontSizeValue: string) => void;
-    clearFontSize: () => void;
-    getCurrentFontSize: () => Promise<string | null>;
-    getFontSizeOptions: () => readonly FontSizeOption[];
-};
-type FontSizeStateQueries = {
-    hasCustomFontSize: () => Promise<boolean>;
-};
-declare class FontSizeExtension extends BaseExtension<"fontSize", FontSizeConfig, FontSizeCommands, FontSizeStateQueries> {
-    constructor();
-    register(): () => void;
-    configure(config: Partial<FontSizeConfig>): Extension<"fontSize", FontSizeConfig, FontSizeCommands, FontSizeStateQueries, React$1.ReactNode[]>;
-    getCommands(editor: LexicalEditor): FontSizeCommands;
-    getStateQueries(editor: LexicalEditor): FontSizeStateQueries;
-    private applyFontSize;
-    private hasCustomFontSize;
-    private getCurrentFontSizeValue;
-    private findOption;
-    private normalizeValue;
-}
-declare const fontSizeExtension: FontSizeExtension;
-
-type LineHeightOption = {
-    value: string;
-    label: string;
-    lineHeight: string;
-};
-interface LineHeightConfig extends BaseExtensionConfig {
-    options: readonly LineHeightOption[];
-    defaultLineHeight: string;
-}
-type LineHeightCommands = {
-    setLineHeight: (lineHeightValue: string) => void;
-    clearLineHeight: () => void;
-    getCurrentLineHeight: () => Promise<string | null>;
-    getLineHeightOptions: () => readonly LineHeightOption[];
-};
-type LineHeightStateQueries = {
-    hasCustomLineHeight: () => Promise<boolean>;
-};
-declare class LineHeightExtension extends BaseExtension<"lineHeight", LineHeightConfig, LineHeightCommands, LineHeightStateQueries> {
-    constructor();
-    register(): () => void;
-    configure(config: Partial<LineHeightConfig>): Extension<"lineHeight", LineHeightConfig, LineHeightCommands, LineHeightStateQueries, React$1.ReactNode[]>;
-    getCommands(editor: LexicalEditor): LineHeightCommands;
-    getStateQueries(editor: LexicalEditor): LineHeightStateQueries;
-    private applyLineHeight;
-    private getSelectedTopLevelBlocks;
-    private withStyleProperty;
-    private hasCustomLineHeight;
-    private getCurrentLineHeightValue;
-    private getSelectedBlocksLineHeight;
-    private findOption;
-    private normalizeValue;
-    private readStyleProperty;
-}
-declare const lineHeightExtension: LineHeightExtension;
-
-type TextColorOption = {
-    value: string;
-    label: string;
-    color: string;
-};
-interface TextColorConfig extends BaseExtensionConfig {
-    options: readonly TextColorOption[];
-}
-type TextColorCommands = {
-    setTextColor: (colorValue: string) => void;
-    clearTextColor: () => void;
-    getCurrentTextColor: () => Promise<string | null>;
-    getTextColorOptions: () => readonly TextColorOption[];
-};
-type TextColorStateQueries = {
-    hasCustomTextColor: () => Promise<boolean>;
-};
-declare class TextColorExtension extends BaseExtension<"textColor", TextColorConfig, TextColorCommands, TextColorStateQueries> {
-    constructor();
-    register(): () => void;
-    getCommands(editor: LexicalEditor): TextColorCommands;
-    getStateQueries(editor: LexicalEditor): TextColorStateQueries;
-    private applyColor;
-    private hasCustomTextColor;
-    private getCurrentTextColorValue;
-    private findOption;
-    private normalizeValue;
-    private isValidCssColor;
-}
-declare const textColorExtension: TextColorExtension;
-
-type TextHighlightOption = {
-    value: string;
-    label: string;
-    backgroundColor: string;
-};
-interface TextHighlightConfig extends BaseExtensionConfig {
-    options: readonly TextHighlightOption[];
-}
-type TextHighlightCommands = {
-    setTextHighlight: (highlightValue: string) => void;
-    clearTextHighlight: () => void;
-    getCurrentTextHighlight: () => Promise<string | null>;
-    getTextHighlightOptions: () => readonly TextHighlightOption[];
-};
-type TextHighlightStateQueries = {
-    hasTextHighlight: () => Promise<boolean>;
-};
-declare class TextHighlightExtension extends BaseExtension<"textHighlight", TextHighlightConfig, TextHighlightCommands, TextHighlightStateQueries> {
-    constructor();
-    register(): () => void;
-    getCommands(editor: LexicalEditor): TextHighlightCommands;
-    getStateQueries(editor: LexicalEditor): TextHighlightStateQueries;
-    private applyHighlight;
-    private hasTextHighlight;
-    private getCurrentTextHighlightValue;
-    private findOption;
-    private normalizeValue;
-    private isValidCssColor;
-}
-declare const textHighlightExtension: TextHighlightExtension;
-
-declare class SubscriptExtension extends TextFormatExtension<"subscript"> {
-    constructor();
-}
-declare const subscriptExtension: SubscriptExtension;
-
-declare class SuperscriptExtension extends TextFormatExtension<"superscript"> {
-    constructor();
-}
-declare const superscriptExtension: SuperscriptExtension;
-
-/**
- * Context menu item definition
- */
-type ContextMenuItem = {
-    label: string;
-    action: () => void;
-    icon?: React__default.ComponentType<{
-        size?: number;
-        className?: string;
-    }>;
-    disabled?: boolean;
-    separator?: boolean;
-};
-/**
- * Context menu provider registered by extensions
- */
-type ContextMenuProvider = {
-    id: string;
-    priority?: number;
-    canHandle: (context: {
-        editor: LexicalEditor;
-        target: HTMLElement;
-        selection: any;
-        event: MouseEvent;
-    }) => boolean;
-    getItems: (context: {
-        editor: LexicalEditor;
-        target: HTMLElement;
-        selection: any;
-        event: MouseEvent;
-    }) => ContextMenuItem[];
-    renderer?: ContextMenuRenderer;
-};
-/**
- * Context menu renderer function type
- */
-type ContextMenuRenderer = (props: {
-    items: ContextMenuItem[];
-    position: {
-        x: number;
-        y: number;
-    };
-    onClose: () => void;
-    className: string;
-    style?: React__default.CSSProperties;
-    itemClassName: string;
-    itemStyle?: React__default.CSSProperties;
-    disabledItemClassName: string;
-    disabledItemStyle?: React__default.CSSProperties;
-}) => React__default.ReactElement;
-/**
- * Context menu configuration
- */
-interface ContextMenuConfig extends BaseExtensionConfig {
-    defaultRenderer?: ContextMenuRenderer;
-    preventDefault?: boolean;
-    theme?: {
-        container?: string;
-        item?: string;
-        itemDisabled?: string;
-    };
-    styles?: {
-        container?: React__default.CSSProperties;
-        item?: React__default.CSSProperties;
-        itemDisabled?: React__default.CSSProperties;
-    };
-}
-/**
- * Commands exposed by the context menu extension
- */
-type ContextMenuCommands = {
-    registerProvider: (provider: ContextMenuProvider) => void;
-    unregisterProvider: (id: string) => void;
-    showContextMenu: (config: {
-        items: ContextMenuItem[];
-        position: {
-            x: number;
-            y: number;
-        };
-        renderer?: ContextMenuRenderer;
-    }) => void;
-    hideContextMenu: () => void;
-};
-/**
- * State queries for context menus
- */
-type ContextMenuStateQueries = {
-    isContextMenuOpen: () => Promise<boolean>;
-};
-/**
- * Context menu manager - handles provider registry and menu display
- */
-declare class ContextMenuManager {
-    private providers;
-    private currentMenu;
-    private listeners;
-    private editor;
-    private config;
-    constructor(editor: LexicalEditor, config?: ContextMenuConfig);
-    registerProvider(provider: ContextMenuProvider): void;
-    unregisterProvider(id: string): void;
-    handleContextMenu(event: MouseEvent): void;
-    showMenu(config: {
-        items: ContextMenuItem[];
-        position: {
-            x: number;
-            y: number;
-        };
-        renderer?: ContextMenuRenderer;
-    }): void;
-    hideMenu(): void;
-    getCurrentMenu(): {
-        items: ContextMenuItem[];
-        position: {
-            x: number;
-            y: number;
-        };
-        renderer?: ContextMenuRenderer;
-    } | null;
-    subscribe(listener: (menu: typeof this.currentMenu) => void): () => void;
-    private notifyListeners;
-}
-/**
- * Context menu extension - provides a clean, registry-based context menu system
- */
-declare class ContextMenuExtension extends BaseExtension<"contextMenu", ContextMenuConfig, ContextMenuCommands, ContextMenuStateQueries, React__default.ReactElement[]> {
-    manager: ContextMenuManager | null;
-    private pendingListeners;
-    constructor(config?: ContextMenuConfig);
-    configure(config: Partial<ContextMenuConfig>): this;
-    register(editor: LexicalEditor): () => void;
-    getCommands(editor: LexicalEditor): ContextMenuCommands;
-    getStateQueries(editor: LexicalEditor): ContextMenuStateQueries;
-    getPlugins(): React__default.ReactElement[];
-    subscribe(listener: (menu: any) => void): () => void;
-}
-declare const contextMenuExtension: ContextMenuExtension;
-
-/**
- * Table extension configuration options.
- */
-type TableConfig = BaseExtensionConfig & {
-    rows?: number;
-    columns?: number;
-    includeHeaders?: boolean;
-    /** Enable right-click context menu */
-    enableContextMenu?: boolean;
-    /** Custom context menu items - static list or a function that receives commands */
-    contextMenuItems?: ContextMenuItem[] | ((commands: TableCommands) => ContextMenuItem[]);
-    /** Custom context menu renderer for full headless control */
-    contextMenuRenderer?: ContextMenuRenderer;
-    /** Context menu extension used to register providers */
-    contextMenuExtension?: typeof contextMenuExtension;
-    /** Custom table bubble menu renderer */
-    tableBubbleRenderer?: (props: TableBubbleRenderProps) => ReactNode;
-};
-type TableBubbleRenderProps = {
-    headersEnabled: boolean;
-    setHeadersEnabled: (enabled: boolean) => void;
-    actions: {
-        insertRowAbove: () => void;
-        insertRowBelow: () => void;
-        insertColumnLeft: () => void;
-        insertColumnRight: () => void;
-        deleteSelectedColumn: () => void;
-        deleteSelectedRow: () => void;
-        deleteTable: () => void;
-    };
-};
-/**
- * Commands exposed by the Table extension.
- */
-type TableCommands = {
-    insertTable: (config: {
-        rows?: number;
-        columns?: number;
-        includeHeaders?: boolean;
-    }) => void;
-    insertRowAbove: () => void;
-    insertRowBelow: () => void;
-    insertColumnLeft: () => void;
-    insertColumnRight: () => void;
-    toggleRowHeader: () => void;
-    toggleColumnHeader: () => void;
-    mergeSelectedCells: () => void;
-    unmergeSelectedCell: () => void;
-    deleteRow: () => void;
-    deleteColumn: () => void;
-    deleteTable: () => void;
-    showTableContextMenu: (position: {
-        x: number;
-        y: number;
-    }) => void;
-};
-/**
- * State queries exposed by the Table extension.
- */
-type TableStateQueries = {
-    isTableSelected: () => Promise<boolean>;
-    isInTableCell: () => Promise<boolean>;
-};
-/**
- * Table extension for table operations in the editor.
- * Provides commands for inserting and manipulating tables.
- */
-declare class TableExtension extends BaseExtension<"table", TableConfig, TableCommands, TableStateQueries, ReactNode[]> {
-    getContextMenuItems(commands: TableCommands): ContextMenuItem[];
-    private defaultContextMenuItems;
-    constructor(config?: Partial<TableConfig>);
-    configure(config: Partial<TableConfig>): this;
-    register(editor: LexicalEditor): () => void;
-    getNodes(): any[];
-    getCommands(editor: LexicalEditor): TableCommands;
-    getStateQueries(editor: LexicalEditor): TableStateQueries;
-    getPlugins(): ReactNode[];
-}
-/**
- * Preconfigured Table extension instance.
- * Ready for use in extension arrays.
- */
-declare const tableExtension: TableExtension;
-
-/**
- * Commands exposed by the list extension.
- */
-type ListCommands = {
-    /** Toggle a bullet list for the current selection */
-    toggleUnorderedList: () => void;
-    /** Toggle a numbered list for the current selection */
-    toggleOrderedList: () => void;
-    /** Toggle a checklist for the current selection */
-    toggleCheckList: () => void;
-    /** Indent the current list item (nest deeper) */
-    indentList: () => void;
-    /** Outdent the current list item (unnest) */
-    outdentList: () => void;
-    /** Create a nested bullet list at the current selection */
-    insertNestedUnorderedList: () => void;
-    /** Create a nested numbered list at the current selection */
-    insertNestedOrderedList: () => void;
-};
-/**
- * List extension for managing ordered and unordered lists.
- * Provides functionality to convert paragraphs to lists and vice versa.
- *
- * @example
- * ```tsx
- * const extensions = [listExtension] as const;
- * const { Provider, useEditor } = createEditorSystem<typeof extensions>();
- *
- * function MyEditor() {
- *   const { commands, activeStates } = useEditor();
- *   return (
- *     <div>
- *       <button
- *         onClick={() => commands.toggleUnorderedList()}
- *         className={activeStates.unorderedList ? 'active' : ''}
- *       >
- *         Bullet List
- *       </button>
- *       <button
- *         onClick={() => commands.toggleOrderedList()}
- *         className={activeStates.orderedList ? 'active' : ''}
- *       >
- *         Numbered List
- *       </button>
- *       <button onClick={() => commands.indentList()}>Indent</button>
- *       <button onClick={() => commands.outdentList()}>Outdent</button>
- *       <button onClick={() => commands.insertNestedUnorderedList()}>Nested Bullet</button>
- *       <button onClick={() => commands.insertNestedOrderedList()}>Nested Numbered</button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare class ListExtension extends BaseExtension<"list", any, ListCommands, {
-    unorderedList: () => Promise<boolean>;
-    orderedList: () => Promise<boolean>;
-    checkList: () => Promise<boolean>;
-}, ReactNode[]> {
-    /**
-     * Creates a new list extension instance.
-     */
-    constructor();
-    /**
-     * Registers the extension with Lexical.
-     * No special registration needed because Lexical handles list commands.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function (no-op for lists)
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Returns Lexical nodes needed for list functionality.
-     *
-     * @returns Array containing ListNode and ListItemNode
-     */
-    getNodes(): (typeof ListNode | typeof ListItemNode)[];
-    /**
-     * Returns React plugins needed for list functionality.
-     *
-     * @returns Array containing the ListPlugin component
-     */
-    getPlugins(): ReactNode[];
-    /**
-     * Returns command handlers exposed by this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing list toggle commands
-     */
-    getCommands(editor: LexicalEditor): ListCommands;
-    /**
-     * Returns state query functions for list state.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing state query functions for list types
-     */
-    getStateQueries(editor: LexicalEditor): {
-        unorderedList: () => Promise<boolean>;
-        orderedList: () => Promise<boolean>;
-        checkList: () => Promise<boolean>;
-    };
-}
-/**
- * Preconfigured list extension instance.
- * Ready for use in extension arrays.
- */
-declare const listExtension: ListExtension;
-
-type CodeTokenizer = {
-    defaultLanguage: string;
-    tokenize: (code: string, language?: string) => unknown[];
-};
-type CodeHighlightResult = {
-    language?: string | null;
-};
-type CodeHighlightProvider = {
-    highlightAuto?: (code: string, languageSubset?: string[]) => CodeHighlightResult | Promise<CodeHighlightResult>;
-    tokenizer?: CodeTokenizer | null;
-    getTokenizer?: () => CodeTokenizer | null | Promise<CodeTokenizer | null>;
-};
-type CodeHighlightProviderConfig = {
-    provider?: CodeHighlightProvider | null;
-    loadProvider?: () => Promise<CodeHighlightProvider | null>;
-};
-
-/**
- * Commands exposed by the CodeExtension for toggling code blocks
- */
-type CodeCommands = {
-    /** Toggle code block vs paragraph for the current selection */
-    toggleCodeBlock: () => void;
-};
-/**
- * State queries exposed by the CodeExtension for checking code block status
- */
-type CodeStateQueries = {
-    /** Check whether the current selection is within a code block */
-    isInCodeBlock: () => Promise<boolean>;
-};
-type CodeExtensionConfig = BaseExtensionConfig & CodeHighlightProviderConfig & {
-    syntaxHighlighting?: "auto" | "disabled";
-    tokenizer?: CodeTokenizer | null;
-};
-/**
- * CodeExtension - Adds code block support for the Lexical editor
- *
- * Enables users to create and manage code blocks in the editor.
- * Provides commands to toggle between code blocks and paragraphs,
- * plus state queries to check whether the selection is in a code block.
- *
- * Integrates with Lexical's CodeNode and provides a clean API
- * for toolbar integration and programmatic control.
- *
- * @example
- * ```tsx
- * import { codeExtension } from '@lyfie/luthor-headless/extensions/formatting/CodeExtension';
- *
- * const extensions = [codeExtension];
- * const editor = createEditorSystem(extensions);
- *
- * // Use in a component
- * const { commands } = useEditor();
- * commands.toggleCodeBlock(); // Toggle code block on or off
- * ```
- */
-declare class CodeExtension extends BaseExtension<"code", CodeExtensionConfig, CodeCommands, CodeStateQueries, ReactNode[]> {
-    private codeHighlightProviderPromise;
-    constructor();
-    /**
-     * Register the extension with Lexical
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Get Lexical nodes required by this extension
-     * @returns Array of node classes
-     */
-    getNodes(): (typeof CodeNode | typeof CodeHighlightNode)[];
-    /**
-     * Get commands exposed by this extension
-     * @param editor - Lexical editor instance
-     * @returns Object containing available commands
-     */
-    getCommands(editor: LexicalEditor): CodeCommands;
-    /**
-    * Toggle between code block and paragraph for the selection
-     * @param editor - Lexical editor instance
-     */
-    private toggleCodeBlock;
-    private resolveConfiguredTokenizer;
-    private loadCodeHighlightProvider;
-    /**
-     * Get state queries exposed by this extension
-     * @param editor - Lexical editor instance
-     * @returns Object containing available state queries
-     */
-    getStateQueries(editor: LexicalEditor): CodeStateQueries;
-    /**
-     * Check whether the current selection matches the specified format
-     * @param format - Format to check for (currently only 'code')
-     * @param editor - Lexical editor instance
-     * @returns True if all selected nodes match the format
-     */
-    private isFormat;
-    /**
-     * Get the nearest block node from the given node
-     * @param node - Starting node
-     * @returns Nearest CodeNode or null
-     */
-    private getBlockNode;
-    /**
-     * Get the format type of a given node
-     * @param node - Node to check
-     * @returns Format type or null
-     */
-    private getNodeFormat;
-    /**
-     * Get the current format synchronously (for use inside editor.update())
-     * @returns Current format or null
-     */
-    private getCurrentFormatSync;
-}
-declare const codeExtension: CodeExtension;
-
-type CodeIntelligenceCommands = {
-    setCodeLanguage: (language: string) => void;
-    autoDetectCodeLanguage: () => Promise<string | null>;
-    getCurrentCodeLanguage: () => Promise<string | null>;
-    getCodeLanguageOptions: () => string[];
-    copySelectedCodeBlock: () => Promise<boolean>;
-};
-type CodeLanguageOptionsMode = "append" | "replace";
-type CodeLanguageOptionsConfig = {
-    mode?: CodeLanguageOptionsMode;
-    values: readonly string[];
-};
-type CodeIntelligenceConfig = CodeHighlightProviderConfig & {
-    maxAutoDetectLength?: number;
-    isCopyAllowed?: boolean;
-    languageOptions?: readonly string[] | CodeLanguageOptionsConfig;
-};
-declare class CodeIntelligenceExtension extends BaseExtension<"codeIntelligence", CodeIntelligenceConfig, CodeIntelligenceCommands, Record<string, never>, ReactNode[]> {
-    private languageOptions;
-    constructor();
-    register(editor: LexicalEditor): () => void;
-    getPlugins(): ReactNode[];
-    getCommands(editor: LexicalEditor): CodeIntelligenceCommands;
-    isCopyAllowed(): boolean;
-    getLanguageOptionsSnapshot(): string[];
-    getCodeBlocksSnapshot(editor: LexicalEditor): CodeBlockSnapshot[];
-    setCodeBlockLanguage(editor: LexicalEditor, nodeKey: string, selectedLanguage: string): void;
-    getCodeBlockText(editor: LexicalEditor, nodeKey: string): string;
-    private getThemeForLanguage;
-    private ensureCodeBlockThemes;
-    private getSelectionCodeNodes;
-    private getNearestCodeNode;
-    private getLanguageOptions;
-    private getPrimaryCodeBlockText;
-}
-type CodeBlockSnapshot = {
-    key: string;
-    language: string;
-    text: string;
-};
-declare const codeIntelligenceExtension: CodeIntelligenceExtension;
-
-/**
- * CodeFormatExtension - Provides inline code text formatting functionality
- *
- * This extension extends TextFormatExtension to provide inline code formatting
- * for selected text in the Lexical editor. It integrates with the toolbar system
- * and provides commands and state queries for inline code operations.
- *
- * @example
- * ```tsx
- * import { codeFormatExtension } from '@lyfie/luthor-headless/extensions/formatting/CodeFormatExtension';
- *
- * const extensions = [codeFormatExtension];
- * const editor = createEditorSystem(extensions);
- * ```
- */
-declare class CodeFormatExtension extends TextFormatExtension<"code"> {
-    constructor();
-}
-declare const codeFormatExtension: CodeFormatExtension;
-
-/**
- * Supported block formats for BlockFormatExtension
- */
-type BlockFormat = "p" | HeadingTagType | "quote";
-/**
- * Commands exposed by BlockFormatExtension for block-level formatting
- */
-type BlockFormatCommands = {
-    /** Switch to a specific block format */
-    toggleBlockFormat: (format: BlockFormat) => void;
-    /** Switch to paragraph format */
-    toggleParagraph: () => void;
-    /** Switch to a heading format */
-    toggleHeading: (tag: HeadingTagType) => void;
-    /** Switch to quote format */
-    toggleQuote: () => void;
-    /** Set text alignment for selected blocks */
-    setTextAlignment: (alignment: "left" | "center" | "right" | "justify") => void;
-    /** Return the current block type as a string ('p', 'h1', 'h2', etc.) */
-    getCurrentBlockType: () => BlockFormat;
-};
-/**
- * State queries exposed by BlockFormatExtension for checking block formats
- */
-type BlockFormatStateQueries = {
-    /** Check whether the selection is in a paragraph */
-    isParagraph: () => Promise<boolean>;
-    /** Check whether the selection is in an H1 heading */
-    isH1: () => Promise<boolean>;
-    /** Check whether the selection is in an H2 heading */
-    isH2: () => Promise<boolean>;
-    /** Check whether the selection is in an H3 heading */
-    isH3: () => Promise<boolean>;
-    /** Check whether the selection is in an H4 heading */
-    isH4: () => Promise<boolean>;
-    /** Check whether the selection is in an H5 heading */
-    isH5: () => Promise<boolean>;
-    /** Check whether the selection is in an H6 heading */
-    isH6: () => Promise<boolean>;
-    /** Check whether the selection is in a quote block */
-    isQuote: () => Promise<boolean>;
-    /** Check whether selected blocks are left-aligned */
-    isTextAlignedLeft: () => Promise<boolean>;
-    /** Check whether selected blocks are center-aligned */
-    isTextAlignedCenter: () => Promise<boolean>;
-    /** Check whether selected blocks are right-aligned */
-    isTextAlignedRight: () => Promise<boolean>;
-    /** Check whether selected blocks are justified */
-    isTextAlignedJustify: () => Promise<boolean>;
-};
-/**
- * BlockFormatExtension - Provides block-level formatting
- *
- * Enables users to change block-level elements like paragraphs,
- * headings (H1-H6), and quotes. Provides a comprehensive set of commands
- * for switching between formats and state queries for checking
- * the current block format.
- *
- * The extension supports true toggling - applying the same format
- * again reverts to a paragraph.
- *
- * @example
- * ```tsx
- * import { blockFormatExtension } from '@lyfie/luthor-headless/extensions/formatting/BlockTypeExtension';
- *
- * const extensions = [blockFormatExtension];
- * const editor = createEditorSystem(extensions);
- *
- * // Use in a component
- * const { commands } = useEditor();
- * commands.toggleHeading('h1'); // Switch selection to H1
- * commands.toggleQuote(); // Convert selection to a quote block
- * ```
- */
-declare class BlockFormatExtension extends BaseExtension<"blockFormat", Record<string, never>, BlockFormatCommands, BlockFormatStateQueries> {
-    constructor();
-    /**
-     * Register the extension with Lexical
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Get Lexical nodes required by this extension
-     * @returns Array of node classes
-     */
-    getNodes(): (typeof ParagraphNode | typeof HeadingNode | typeof QuoteNode)[];
-    /**
-     * Get commands exposed by this extension
-     * @param editor - Lexical editor instance
-     * @returns Object containing available commands
-     */
-    getCommands(editor: LexicalEditor): BlockFormatCommands;
-    /**
-     * Set element alignment for selected blocks
-     * @param editor - Lexical editor instance
-     * @param alignment - Target text alignment
-     */
-    private setTextAlignment;
-    /**
-     * Toggle the block format for the current selection
-     * @param editor - Lexical editor instance
-     * @param format - Target block format
-     */
-    private toggleBlockFormat;
-    /**
-     * Get the state queries provided by this extension
-    * @param editor - Lexical editor instance
-    * @returns Object containing available state queries
-     */
-    getStateQueries(editor: LexicalEditor): BlockFormatStateQueries;
-    /**
-     * Check whether all selected blocks match the specified alignment
-     * @param alignment - Alignment to check
-     * @param editor - Lexical editor instance
-     * @returns True if all selected blocks match the alignment
-     */
-    private isAlignment;
-    private normalizeAlignment;
-    /**
-     * Get the nearest block node starting from the given node
-     * @param node - Starting node
-     * @returns Nearest block node or null
-     */
-    private getBlockNode;
-    /**
-     * Check whether all blocks in the current selection match the specified format
-     * @param format - Format to check for
-     * @param editor - Lexical editor instance
-     * @returns True if all selected blocks match the format
-     */
-    private isFormat;
-    /**
-     * Get the format type for a block node
-     * @param node - Block node to check
-     * @returns Format type or null
-     */
-    private getNodeFormat;
-    /**
-     * Get the current block format for the selection
-     * @param editor - Lexical editor instance
-     * @returns Current format or null
-     */
-    private getCurrentFormat;
-    /**
-     * Get the current block format synchronously (for use inside editor.update())
-     * @returns Current format or null
-     */
-    private getCurrentFormatSync;
-}
-declare const blockFormatExtension: BlockFormatExtension;
-
-/**
- * Commands exposed by the history extension.
- */
-type HistoryCommands = {
-    /** Undo the most recent action */
-    undo: () => void;
-    /** Redo the most recently undone action */
-    redo: () => void;
-    /** Clear the full history stack */
-    clearHistory: () => void;
-};
-/**
- * History extension that provides undo/redo functionality.
- * Integrates with Lexical's built-in history system to offer
- * undo and redo capabilities with state tracking.
- *
- * @example
- * ```tsx
- * const extensions = [historyExtension] as const;
- * const { Provider, useEditor } = createEditorSystem<typeof extensions>();
- *
- * function MyEditor() {
- *   const { commands, activeStates } = useEditor();
- *   return (
- *     <div>
- *       <button
- *         onClick={() => commands.undo()}
- *         disabled={!activeStates.canUndo}
- *       >
- *         Undo
- *       </button>
- *       <button
- *         onClick={() => commands.redo()}
- *         disabled={!activeStates.canRedo}
- *       >
- *         Redo
- *       </button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare class HistoryExtension extends BaseExtension<"history", any, HistoryCommands, {
-    canUndo: () => Promise<boolean>;
-    canRedo: () => Promise<boolean>;
-}, ReactNode[]> {
-    private canUndoState;
-    private canRedoState;
-    /**
-     * Creates a new history extension.
-     */
-    constructor();
-    /**
-     * Registers the extension with the Lexical editor.
-     * Sets up listeners for undo/redo state changes.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Returns React plugins required for history support.
-     *
-     * @returns Array containing the HistoryPlugin component
-     */
-    getPlugins(): ReactNode[];
-    /**
-     * Returns commands exposed by this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing history commands
-     */
-    getCommands(editor: LexicalEditor): HistoryCommands;
-    /**
-     * Returns state query functions for undo/redo availability.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing state query functions
-     */
-    getStateQueries(editor: LexicalEditor): {
-        canUndo: () => Promise<boolean>;
-        canRedo: () => Promise<boolean>;
-    };
-}
-/**
- * Preconfigured history extension instance.
- * Ready for use in extension arrays.
- */
-declare const historyExtension: HistoryExtension;
-
-/**
- * DraggableBlockExtension configuration
- */
-interface DraggableConfig extends BaseExtensionConfig {
-    /** Portal anchor element (default: document.body) */
-    anchorElem?: HTMLElement;
-    /** Show the add button near the drag handle */
-    showAddButton?: boolean;
-    /** Button stack position relative to blocks */
-    buttonStackPosition?: "left" | "right";
-    /** Allow drag via text selection (default: true) */
-    enableTextSelectionDrag?: boolean;
-    /** Left offset */
-    offsetLeft?: number;
-    /** Right offset */
-    offsetRight?: number;
-    /** Theme class names */
-    theme?: {
-        handle?: string;
-        handleActive?: string;
-        blockDragging?: string;
-        dropIndicator?: string;
-        addButton?: string;
-        buttonStack?: string;
-    };
-    /** Custom styles for UI elements */
-    styles?: {
-        handle?: React__default.CSSProperties;
-        handleActive?: React__default.CSSProperties;
-        blockDragging?: React__default.CSSProperties;
-        dropIndicator?: React__default.CSSProperties;
-        addButton?: React__default.CSSProperties;
-        buttonStack?: React__default.CSSProperties;
-    };
-    /** Custom handle renderer for full headless control */
-    handleRenderer?: (props: {
-        rect: DOMRect;
-        isDragging: boolean;
-        onDragStart: (e: React__default.DragEvent) => void;
-        className: string;
-    }) => ReactNode;
-    /** Custom up/down button renderer */
-    buttonsRenderer?: (props: {
-        rect: DOMRect;
-        onMoveUp: () => void;
-        onMoveDown: () => void;
-        showUp: boolean;
-        showDown: boolean;
-        upClassName: string;
-        downClassName: string;
-    }) => ReactNode;
-    /** Custom drop indicator renderer */
-    dropIndicatorRenderer?: (props: {
-        top: number;
-        left: number;
-        width: number;
-        className: string;
-    }) => ReactNode;
-}
-/**
- * Commands exposed by the draggable block extension
- */
-type DraggableCommands = {
-    moveBlock: (sourceKey: string, targetKey: string, insertAfter: boolean) => void;
-    moveCurrentBlockUp: () => void;
-    moveCurrentBlockDown: () => void;
-};
-/**
- * State queries exposed by the draggable block extension
- */
-type DraggableStateQueries = {
-    isDragging: () => Promise<boolean>;
-};
-/**
- * DraggableBlockExtension - Clean, headless drag-and-drop for blocks
- */
-declare class DraggableBlockExtension extends BaseExtension<"draggableBlock", DraggableConfig, DraggableCommands, DraggableStateQueries, ReactNode[]> {
-    private isDraggingState;
-    private stateChangeCallbacks;
-    constructor(config?: Partial<DraggableConfig>);
-    register(editor: LexicalEditor): () => void;
-    getPlugins(): ReactNode[];
-    getCommands(editor: LexicalEditor): DraggableCommands;
-    getStateQueries(editor: LexicalEditor): DraggableStateQueries;
-    setIsDragging(isDragging: boolean): void;
-    onStateChange(callback: () => void): () => void;
-}
-/**
- * Preconfigured instance
- */
-declare const draggableBlockExtension: DraggableBlockExtension;
-
-/**
- * Supported alignment options for media items
- */
-type Alignment = "left" | "right" | "center" | "none";
-/**
- * Payload interface for image insertion and updates
- */
-interface ImagePayload {
-    /** Source URL for the image */
-    src?: string;
-    /** Accessible alt text */
-    alt: string;
-    /** Optional caption */
-    caption?: string;
-    /** Alignment */
-    alignment?: Alignment;
-    /** CSS class name for styling */
-    className?: string;
-    /** Inline style overrides */
-    style?: CSSProperties;
-    /** File object for uploads */
-    file?: File;
-    /** Width in pixels */
-    width?: number;
-    /** Height in pixels */
-    height?: number;
-}
-/**
- * Props for the Image component
- */
-interface ImageComponentProps extends ImagePayload {
-    /** Lexical node key */
-    nodeKey?: string;
-    /** Whether the image is resizable */
-    resizable?: boolean;
-    /** Whether resize keeps aspect ratio by default */
-    scaleByRatio?: boolean;
-    /** Whether the image is uploading */
-    uploading?: boolean;
-}
-/**
- * Serialized ImageNode representation for persistence
- */
-interface SerializedImageNode {
-    /** Node type ID */
-    type: "image";
-    /** Version for migrations */
-    version: number;
-    /** Source URL for the image */
-    src: string;
-    /** Accessible alt text */
-    alt: string;
-    /** Optional caption */
-    caption?: string;
-    /** Alignment */
-    alignment: Alignment;
-    /** CSS class name */
-    className?: string;
-    /** Inline styles as a string record */
-    style?: Record<string, string>;
-    /** Width in pixels */
-    width?: number;
-    /** Height in pixels */
-    height?: number;
-}
-/**
- * ImageExtension configuration options
- */
-interface ImageExtensionConfig extends BaseExtensionConfig {
-    /** Upload handler that returns the image URL */
-    uploadHandler?: (file: File) => Promise<string>;
-    /** Default alignment for new images */
-    defaultAlignment?: Alignment;
-    /** Class names for alignments and elements */
-    classNames?: Partial<Record<Alignment | "wrapper" | "caption", string>>;
-    /** Styles for alignments and elements */
-    styles?: Partial<Record<Alignment | "wrapper" | "caption", CSSProperties>>;
-    /** Custom renderer component for images */
-    customRenderer?: ComponentType<ImageComponentProps>;
-    /** Enable image resizing (default: true) */
-    resizable?: boolean;
-    /** Keep aspect ratio while resizing by default (Shift toggles) */
-    scaleByRatio?: boolean;
-    /** Paste behavior configuration */
-    pasteListener?: {
-        /** Insert a new image on paste when none is selected */
-        insert: boolean;
-        /** Replace selected image src on paste */
-        replace: boolean;
-    };
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Force upload even for remote URLs (default: false) */
-    forceUpload?: boolean;
-}
-/**
- * Commands exposed by the ImageExtension
- */
-type ImageCommands = {
-    /** Insert an image into the editor */
-    insertImage: (payload: ImagePayload) => void;
-    /** Set alignment for the selected image */
-    setImageAlignment: (alignment: Alignment) => void;
-    /** Set caption for the selected image */
-    setImageCaption: (caption: string) => void;
-    /** Read caption for the selected image */
-    getImageCaption: () => Promise<string>;
-    /** Set the CSS class name on the selected image */
-    setImageClassName: (className: string) => void;
-    /** Set inline styles on the selected image */
-    setImageStyle: (style: CSSProperties) => void;
-};
-/**
- * State queries exposed by the ImageExtension
- */
-type ImageStateQueries = {
-    /** Check whether an image is selected */
-    imageSelected: () => Promise<boolean>;
-    /** Check whether the selected image is left-aligned */
-    isImageAlignedLeft: () => Promise<boolean>;
-    /** Check whether the selected image is center-aligned */
-    isImageAlignedCenter: () => Promise<boolean>;
-    /** Check whether the selected image is right-aligned */
-    isImageAlignedRight: () => Promise<boolean>;
-    /** Check whether the selected image has no special alignment */
-    isImageAlignedNone: () => Promise<boolean>;
-};
-
-declare class ImageExtension extends BaseExtension<"image", ImageExtensionConfig, ImageCommands, ImageStateQueries, ReactNode[]> {
-    /** Track recent image sources to avoid duplicate inserts */
-    private recentImages;
-    /** Last selected image key for toolbar edits while focus moves to external inputs */
-    private lastSelectedImageNodeKey;
-    constructor();
-    configure(config: Partial<ImageExtensionConfig>): this;
-    register(editor: LexicalEditor): () => void;
-    getNodes(): any[];
-    getCommands(editor: LexicalEditor): ImageCommands;
-    getStateQueries(editor: LexicalEditor): ImageStateQueries;
-}
-declare const imageExtension: ImageExtension;
-
-type EmbedAlignment = "left" | "center" | "right";
-interface IframeEmbedConfig extends BaseExtensionConfig {
-    defaultWidth?: number;
-    defaultHeight?: number;
-    defaultAlignment?: EmbedAlignment;
-}
-type IframeEmbedCommands = {
-    insertIframeEmbed: (inputUrl: string, width?: number, height?: number, title?: string) => void;
-    setIframeEmbedAlignment: (alignment: EmbedAlignment) => void;
-    resizeIframeEmbed: (width: number, height: number) => void;
-    setIframeEmbedCaption: (caption: string) => void;
-    getIframeEmbedCaption: () => Promise<string>;
-    updateIframeEmbedUrl: (inputUrl: string) => boolean;
-    getIframeEmbedUrl: () => Promise<string>;
-};
-type IframeEmbedQueries = {
-    isIframeEmbedSelected: () => Promise<boolean>;
-    isIframeEmbedAlignedLeft: () => Promise<boolean>;
-    isIframeEmbedAlignedCenter: () => Promise<boolean>;
-    isIframeEmbedAlignedRight: () => Promise<boolean>;
-};
-declare class IframeEmbedExtension extends BaseExtension<"iframeEmbed", IframeEmbedConfig, IframeEmbedCommands, IframeEmbedQueries, ReactNode[]> {
-    constructor(config?: Partial<IframeEmbedConfig>);
-    register(editor: LexicalEditor): () => void;
-    getNodes(): any[];
-    getPlugins(): ReactNode[];
-    getCommands(editor: LexicalEditor): IframeEmbedCommands;
-    getStateQueries(editor: LexicalEditor): IframeEmbedQueries;
-}
-declare const iframeEmbedExtension: IframeEmbedExtension;
-
-interface YouTubeEmbedConfig extends BaseExtensionConfig {
-    defaultWidth?: number;
-    defaultHeight?: number;
-    defaultAlignment?: EmbedAlignment;
-    allowFullscreen?: boolean;
-    autoplay?: boolean;
-    controls?: boolean;
-    nocookie?: boolean;
-    rel?: number;
-}
-type YouTubeEmbedCommands = {
-    insertYouTubeEmbed: (inputUrl: string, width?: number, height?: number, start?: number) => void;
-    setYouTubeEmbedAlignment: (alignment: EmbedAlignment) => void;
-    resizeYouTubeEmbed: (width: number, height: number) => void;
-    setYouTubeEmbedCaption: (caption: string) => void;
-    getYouTubeEmbedCaption: () => Promise<string>;
-    updateYouTubeEmbedUrl: (inputUrl: string) => boolean;
-    getYouTubeEmbedUrl: () => Promise<string>;
-};
-type YouTubeEmbedQueries = {
-    isYouTubeEmbedSelected: () => Promise<boolean>;
-    isYouTubeEmbedAlignedLeft: () => Promise<boolean>;
-    isYouTubeEmbedAlignedCenter: () => Promise<boolean>;
-    isYouTubeEmbedAlignedRight: () => Promise<boolean>;
-};
-declare class YouTubeEmbedExtension extends BaseExtension<"youtubeEmbed", YouTubeEmbedConfig, YouTubeEmbedCommands, YouTubeEmbedQueries, ReactNode[]> {
-    private lastSelectedYouTubeNodeKey;
-    constructor(config?: Partial<YouTubeEmbedConfig>);
-    register(editor: LexicalEditor): () => void;
-    getNodes(): any[];
-    getPlugins(): ReactNode[];
-    getCommands(editor: LexicalEditor): YouTubeEmbedCommands;
-    getStateQueries(editor: LexicalEditor): YouTubeEmbedQueries;
-}
-declare const youTubeEmbedExtension: YouTubeEmbedExtension;
-
-type CustomPayload = Record<string, any>;
-interface CustomNodeConfig<CustomCommands, CustomStateQueries> {
-    nodeType: string;
-    isContainer?: boolean;
-    defaultPayload?: CustomPayload;
-    initialChildren?: () => SerializedLexicalNode[];
-    render?: (props: {
-        node: LexicalNode;
-        payload: CustomPayload;
-        children?: ReactNode;
-        nodeKey: string;
-        isSelected: boolean;
-        updatePayload: (newPayload: Partial<CustomPayload>) => void;
-    }) => ReactNode;
-    jsx?: (props: {
-        node: LexicalNode;
-        payload: CustomPayload;
-        nodeKey: string;
-        isSelected: boolean;
-        updatePayload: (newPayload: Partial<CustomPayload>) => void;
-    }) => React.ReactElement;
-    createDOM?: (config: EditorConfig$1, node: LexicalNode) => HTMLElement;
-    updateDOM?: (prevNode: LexicalNode, dom: HTMLElement, config: EditorConfig$1) => boolean;
-    importDOM?: () => DOMConversionMap;
-    exportDOM?: (editor: LexicalEditor, options: {
-        element: HTMLElement;
-        node: LexicalNode;
-    }) => DOMExportOutput;
-    commands?: (editor: LexicalEditor) => CustomCommands;
-    stateQueries?: (editor: LexicalEditor) => CustomStateQueries;
-}
-/**
- * Creates a custom node extension for the Luthor editor system.
- * This factory lets you define custom Lexical nodes with React rendering,
- * commands, and state queries.
- *
- * @template Name - Literal name type for the extension
- * @template Commands - Commands exposed by this custom extension
- * @template StateQueries - State query functions exposed by this extension
- * @param userConfig - Configuration object defining the custom node behavior
- * @returns Object containing the extension and helper functions
- *
- * @example
- * ```tsx
- * const { extension, $createCustomNode } = createCustomNodeExtension({
- *   nodeType: 'myBlock',
- *   render: ({ payload, isSelected }) => (
- *     <div className={isSelected ? 'selected' : ''}>
- *       {payload.text}
- *     </div>
- *   ),
- *   commands: (editor) => ({
- *     insertMyBlock: (data) => {
- *       const node = $createCustomNode(data);
- *       editor.dispatchCommand(INSERT_CUSTOM_NODE, node);
- *     }
- *   })
- * });
- * ```
- */
-declare function createCustomNodeExtension<Name extends string, Commands extends Record<string, any> = Record<string, never>, StateQueries extends Record<string, () => Promise<boolean>> = Record<string, never>>(userConfig: CustomNodeConfig<Commands, StateQueries>): {
-    extension: BaseExtension<Name, BaseExtensionConfig, Commands, StateQueries>;
-    $createCustomNode: (payload?: CustomPayload) => ElementNode | DecoratorNode<ReactNode>;
-    jsxToDOM: (jsxElement: React.ReactElement) => HTMLElement;
-};
-
-interface BaseRichTextProps {
-    contentEditable?: React__default.ReactElement;
-    placeholder?: React__default.ReactElement | string;
-    className?: string;
-    classNames?: {
-        container?: string;
-        contentEditable?: string;
-        placeholder?: string;
-    };
-    styles?: {
-        container?: React__default.CSSProperties;
-        contentEditable?: React__default.CSSProperties;
-        placeholder?: React__default.CSSProperties;
-    };
-    errorBoundary?: React__default.ComponentType<{
-        children: React__default.JSX.Element;
-        onError: (error: Error) => void;
-    }>;
-}
-interface RichTextConfig extends BaseExtensionConfig, BaseRichTextProps {
-}
-type SharedRichTextProps = BaseRichTextProps;
-/**
- * RichTextExtension - Provides core rich text editing functionality
- * Extends BaseExtension to stay consistent with other extensions
- */
-declare class RichTextExtension extends BaseExtension<"richText", RichTextConfig, Record<string, never>, Record<string, never>, ReactNode[]> {
-    constructor(config?: RichTextConfig);
-    register(editor: LexicalEditor): () => void;
-    getPlugins(): ReactNode[];
-}
-declare const richTextExtension: RichTextExtension;
-type RichTextComponentProps = SharedRichTextProps;
-declare const RichText: React__default.FC<RichTextComponentProps>;
-
-/**
- * TabIndentExtension - Adds universal Tab/Shift+Tab indentation support
- *
- * Enables Tab key to indent and Shift+Tab to outdent content throughout
- * the editor, not just in code blocks. This provides a consistent
- * indentation experience across all content types.
- *
- * @example
- * ```tsx
- * import { tabIndentExtension } from '@lyfie/luthor-headless';
- *
- * const extensions = [tabIndentExtension];
- * ```
- */
-declare class TabIndentExtension extends BaseExtension<"tabIndent", Record<string, never>, Record<string, never>, Record<string, never>, ReactNode[]> {
-    constructor();
-    /**
-     * Register the extension with Lexical
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Check if a node is within a code block
-     * @param node - Node to check
-     * @returns True if node is in a code block
-     */
-    private isInCodeBlock;
-    /**
-     * Check if a node is within a checklist list item.
-     */
-    private isInCheckList;
-}
-declare const tabIndentExtension: TabIndentExtension;
-
-type EmojiCatalogItem = {
-    emoji: string;
-    label: string;
-    shortcodes: string[];
-    keywords?: string[];
-};
-type EmojiCatalogAdapter = {
-    search: (query: string, options?: {
-        limit?: number;
-    }) => EmojiCatalogItem[];
-    resolveShortcode: (shortcode: string) => EmojiCatalogItem | null;
-    getAll: () => EmojiCatalogItem[];
-};
-type EmojiSuggestionState = {
-    isOpen: boolean;
-    query: string;
-    position: {
-        x: number;
-        y: number;
-    } | null;
-    suggestions: EmojiCatalogItem[];
-};
-interface EmojiConfig extends BaseExtensionConfig {
-    trigger?: string;
-    maxSuggestions?: number;
-    maxQueryLength?: number;
-    autoReplaceSymbols?: boolean;
-    symbolReplacements?: Record<string, string>;
-    catalog?: EmojiCatalogItem[];
-    catalogAdapter?: EmojiCatalogAdapter;
-    autoDetectExternalCatalog?: boolean;
-    offset?: {
-        x: number;
-        y: number;
-    };
-}
-type EmojiCommands = {
-    insertEmoji: (emoji: string) => void;
-    executeEmojiSuggestion: (emoji: string) => boolean;
-    closeEmojiSuggestions: () => void;
-    getEmojiSuggestions: (query?: string) => EmojiCatalogItem[];
-    getEmojiCatalog: () => EmojiCatalogItem[];
-    resolveEmojiShortcode: (shortcode: string) => EmojiCatalogItem | null;
-    setEmojiCatalog: (catalog: EmojiCatalogItem[]) => void;
-    setEmojiCatalogAdapter: (adapter: EmojiCatalogAdapter) => void;
-    getEmojiCatalogAdapter: () => EmojiCatalogAdapter;
-};
-type EmojiStateQueries = {
-    isEmojiSuggestionOpen: () => Promise<boolean>;
-};
-declare const LIGHTWEIGHT_EMOJI_CATALOG: EmojiCatalogItem[];
-declare class EmojiExtension extends BaseExtension<"emoji", EmojiConfig, EmojiCommands, EmojiStateQueries, React__default.ReactElement[]> {
-    private listeners;
-    private isOpen;
-    private query;
-    private position;
-    private suggestions;
-    private activeMatch;
-    private applyingAutoReplace;
-    private catalogAdapter;
-    private hasExplicitCatalogConfig;
-    private hasExplicitAdapterConfig;
-    private externalCatalogDetectionStarted;
-    constructor(config?: EmojiConfig);
-    configure(config: Partial<EmojiConfig>): this;
-    register(editor: LexicalEditor): () => void;
-    getCommands(editor: LexicalEditor): EmojiCommands;
-    getStateQueries(editor: LexicalEditor): EmojiStateQueries;
-    subscribe(listener: (state: EmojiSuggestionState) => void): () => void;
-    private getCatalog;
-    private getSuggestions;
-    private resolveShortcode;
-    private resolveCatalogAdapter;
-    private tryEnableExternalCatalog;
-    private refreshSuggestionsIfOpen;
-    private updateFromSelection;
-    private isSelectionInsideCodeBlock;
-    private detectSymbolReplacement;
-    private replaceSymbolsInText;
-    private executeEmojiSuggestion;
-    private closeEmojiSuggestions;
-    private closeIfNeeded;
-    private getCaretPosition;
-    private getState;
-    private notifyListeners;
-}
-declare const emojiExtension: EmojiExtension;
-
-/**
- * Selection rectangle with position data.
- */
-interface SelectionRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    top: number;
-    left: number;
-    bottom: number;
-    right: number;
-    positionFromRight?: boolean;
-}
-/**
- * Floating toolbar render props (typed, headless).
- */
-interface FloatingToolbarRenderProps<TCommands = any, TStates = any> {
-    /** Whether the toolbar is visible. */
-    isVisible: boolean;
-    /** Selection rectangle used for positioning. */
-    selectionRect: SelectionRect | null;
-    /** Current selection reference. */
-    selection: RangeSelection | null;
-    /** Lexical editor reference. */
-    editor: LexicalEditor;
-    /** Typed commands from the editor system. */
-    commands: TCommands;
-    /** Active state map from the editor system. */
-    activeStates: TStates;
-    /** Callback to dismiss the toolbar. */
-    hide: () => void;
-    /** Theme class names for styling. */
-    theme: {
-        container?: string;
-        button?: string;
-        buttonActive?: string;
-    };
-}
-/**
- * FloatingToolbarExtension configuration.
- */
-interface FloatingConfig<TCommands = any, TStates = any> extends BaseExtensionConfig {
-    /**
-     * Headless render function for full UI control.
-     */
-    render: (props: FloatingToolbarRenderProps<TCommands, TStates>) => ReactNode | null;
-    /**
-     * Function to retrieve typed commands from the editor system.
-     */
-    getCommands?: () => TCommands;
-    /**
-     * Function to retrieve active states from the editor system.
-     */
-    getActiveStates?: () => TStates;
-    /**
-     * Portal anchor element (defaults to document.body).
-     */
-    anchorElem?: HTMLElement;
-    /**
-     * Debounce delay for selection changes (default: 100ms).
-     */
-    debounceMs?: number;
-    /**
-     * Offset from the selection (default: { x: 0, y: 8 }).
-     */
-    offset?: {
-        x: number;
-        y: number;
-    };
-    /**
-     * Position strategy (default: 'below').
-     */
-    positionStrategy?: "above" | "below" | "auto";
-    /**
-     * Theme class names for styling.
-     */
-    theme?: {
-        container?: string;
-        button?: string;
-        buttonActive?: string;
-    };
-    /**
-     * Toolbar dimensions for positioning calculations (default: { width: 300, height: 40 }).
-     */
-    toolbarDimensions?: {
-        width: number;
-        height: number;
-    };
-}
-/**
- * Commands exposed by the floating toolbar extension (none by default).
- */
-type FloatingCommands = Record<string, never>;
-/**
- * State queries exposed by the floating toolbar extension.
- */
-type FloatingStateQueries = {
-    isFloatingVisible: () => Promise<boolean>;
-};
-/**
- * FloatingToolbarExtension - Headless toolbar that appears on selection.
- */
-declare class FloatingToolbarExtension<TCommands = any, TStates = any> extends BaseExtension<"floatingToolbar", FloatingConfig<TCommands, TStates>, FloatingCommands, FloatingStateQueries, ReactNode[]> {
-    private isVisible;
-    private selectionRect;
-    constructor();
-    register(editor: LexicalEditor): () => void;
-    getPlugins(): ReactNode[];
-    getCommands(editor: LexicalEditor): FloatingCommands;
-    getStateQueries(editor: LexicalEditor): FloatingStateQueries;
-    updateContext(commands: TCommands, activeStates: TStates): void;
-    getSelectionRect(): SelectionRect | null;
-    getIsVisible(): boolean;
-    setVisible(visible: boolean): void;
-    setSelectionRect(rect: SelectionRect | null): void;
-}
-/**
- * Preconfigured instance.
- */
-declare const floatingToolbarExtension: FloatingToolbarExtension<any, any>;
-
-/**
- * Command palette item definition
- */
-type CommandPaletteItem = {
-    id: string;
-    label: string;
-    description?: string;
-    action: () => void;
-    keywords?: string[];
-    category?: string;
-    icon?: React__default.ReactNode;
-    shortcut?: string;
-};
-/**
- * Commands exposed by the command palette extension
- */
-type CommandPaletteCommands = {
-    showCommandPalette: () => void;
-    hideCommandPalette: () => void;
-    registerCommand: (item: CommandPaletteItem) => void;
-    unregisterCommand: (id: string) => void;
-};
-/**
- * State queries exposed by the command palette extension
- */
-type CommandPaletteStateQueries = {
-    isCommandPaletteOpen: () => Promise<boolean>;
-};
-/**
- * Command palette extension for quick access to editor commands.
- * Provides a searchable command palette similar to VS Code.
- */
-declare class CommandPaletteExtension extends BaseExtension<"commandPalette", any, CommandPaletteCommands, CommandPaletteStateQueries, React__default.ReactElement[]> {
-    private isOpen;
-    private commands;
-    private listeners;
-    constructor();
-    register(editor: LexicalEditor): () => void;
-    getCommands(editor: LexicalEditor): CommandPaletteCommands;
-    getStateQueries(editor: LexicalEditor): CommandPaletteStateQueries;
-    private showCommandPalette;
-    private hideCommandPalette;
-    private toggleCommandPalette;
-    private registerCommand;
-    private unregisterCommand;
-    private registerTableCommands;
-    private notifyListeners;
-    /**
-     * Subscribe to command palette updates
-     */
-    subscribe(listener: (isOpen: boolean, commands: CommandPaletteItem[]) => void): () => void;
-    getAllCommands(): CommandPaletteItem[];
-}
-declare const commandPaletteExtension: CommandPaletteExtension;
-
-type SlashCommandItem = {
-    id: string;
-    label: string;
-    description?: string;
-    action: () => void;
-    keywords?: string[];
-    category?: string;
-    icon?: React__default.ReactNode;
-    shortcut?: string;
-};
-type SlashCommandMenuState = {
-    isOpen: boolean;
-    query: string;
-    position: {
-        x: number;
-        y: number;
-    } | null;
-    commands: SlashCommandItem[];
-};
-interface SlashCommandConfig extends BaseExtensionConfig {
-    trigger?: string;
-    offset?: {
-        x: number;
-        y: number;
-    };
-    items?: readonly SlashCommandItem[];
-}
-type SlashCommandCommands = {
-    registerSlashCommand: (item: SlashCommandItem) => void;
-    unregisterSlashCommand: (id: string) => void;
-    setSlashCommands: (items: readonly SlashCommandItem[]) => void;
-    closeSlashMenu: () => void;
-    executeSlashCommand: (id: string) => boolean;
-};
-type SlashCommandStateQueries = {
-    isSlashMenuOpen: () => Promise<boolean>;
-};
-declare class SlashCommandExtension extends BaseExtension<"slashCommand", SlashCommandConfig, SlashCommandCommands, SlashCommandStateQueries, React__default.ReactElement[]> {
-    private commands;
-    private listeners;
-    private isOpen;
-    private query;
-    private position;
-    private activeMatch;
-    constructor(config?: SlashCommandConfig);
-    register(editor: LexicalEditor): () => void;
-    getCommands(editor: LexicalEditor): SlashCommandCommands;
-    getStateQueries(_editor: LexicalEditor): SlashCommandStateQueries;
-    subscribe(listener: (state: SlashCommandMenuState) => void): () => void;
-    getAllCommands(): SlashCommandItem[];
-    private registerSlashCommand;
-    private unregisterSlashCommand;
-    private setSlashCommands;
-    private closeSlashMenu;
-    private executeSlashCommand;
-    private updateMatchFromSelection;
-    private closeIfNeeded;
-    private getCaretPosition;
-    private getState;
-    private notifyListeners;
-}
-declare const slashCommandExtension: SlashCommandExtension;
-
-type EnterKeyBehaviorCommands = Record<string, never>;
-type EnterKeyBehaviorStateQueries = Record<string, never>;
-declare class EnterKeyBehaviorExtension extends BaseExtension<"enterKeyBehavior", BaseExtensionConfig, EnterKeyBehaviorCommands, EnterKeyBehaviorStateQueries> {
-    constructor();
-    register(editor: LexicalEditor): () => void;
-    private findQuoteNode;
-    private findCodeNode;
-    private findDirectQuoteChild;
-    private isEmptyQuoteLine;
-}
-declare const enterKeyBehaviorExtension: EnterKeyBehaviorExtension;
-
-export { type Alignment, type BaseCommands, BaseExtension, type BaseExtensionConfig, BaseProvider, BlockFormatExtension, BoldExtension, CodeExtension, type CodeExtensionConfig, CodeFormatExtension, type CodeHighlightProvider, type CodeHighlightProviderConfig, type CodeIntelligenceCommands, type CodeIntelligenceConfig, CodeIntelligenceExtension, type CodeLanguageOptionsConfig, type CodeLanguageOptionsMode, type CommandPaletteCommands, CommandPaletteExtension, type CommandPaletteItem, type CommandPaletteStateQueries, type ContextMenuCommands, type ContextMenuConfig, ContextMenuExtension, type ContextMenuItem, type ContextMenuStateQueries, DraggableBlockExtension, type DraggableCommands, type DraggableConfig, type DraggableStateQueries, type EditorConfig, type EditorContextType, type EmojiCatalogAdapter, type EmojiCatalogItem, type EmojiCommands, type EmojiConfig, EmojiExtension, type EmojiStateQueries, type EmojiSuggestionState, EnterKeyBehaviorExtension, type Extension, ExtensionCategory, type ExtractCommands, type ExtractNames, type ExtractPlugins, type ExtractStateQueries, type FloatingCommands, type FloatingConfig, type FloatingStateQueries, FloatingToolbarExtension, type FontCssLoadStrategy, type FontFamilyConfig, FontFamilyExtension, type FontFamilyOption, type FontSizeConfig, FontSizeExtension, type FontSizeOption, HistoryExtension, HorizontalRuleExtension, IframeEmbedExtension, type ImageCommands, type ImageComponentProps, ImageExtension, type ImageExtensionConfig, type ImagePayload, type ImageStateQueries, ItalicExtension, type JsonbDocument, LIGHTWEIGHT_EMOJI_CATALOG, LUTHOR_EDITOR_THEME_TOKENS, type LexicalNodeRegistration, type LineHeightConfig, LineHeightExtension, type LineHeightOption, LinkExtension, ListExtension, type LuthorEditorThemeOverrides, type LuthorEditorThemeToken, type LuthorTheme, RichText, type RichTextComponentProps, type RichTextConfig, type SerializedImageNode, type SlashCommandCommands, type SlashCommandConfig, SlashCommandExtension, type SlashCommandItem, type SlashCommandMenuState, type SlashCommandStateQueries, StrikethroughExtension, SubscriptExtension, SuperscriptExtension, TabIndentExtension, type TableConfig, TableExtension, type TextColorConfig, TextColorExtension, type TextColorOption, TextFormatExtension, type TextHighlightConfig, TextHighlightExtension, type TextHighlightOption, type ToolbarItem, UnderlineExtension, YouTubeEmbedExtension, blockFormatExtension, boldExtension, clearLexicalSelection, codeExtension, codeFormatExtension, codeIntelligenceExtension, commandPaletteExtension, contextMenuExtension, createCustomNodeExtension, createEditorSystem, createEditorThemeStyleVars, createExtension, defaultLuthorTheme, draggableBlockExtension, emojiExtension, enterKeyBehaviorExtension, floatingToolbarExtension, fontFamilyExtension, fontSizeExtension, historyExtension, horizontalRuleExtension, iframeEmbedExtension, imageExtension, isLuthorTheme, italicExtension, jsonbToMarkdown, lineHeightExtension, linkExtension, listExtension, markdownToJSONB, mergeThemes, resolveLinkNodeKeyFromAnchor, richTextExtension, slashCommandExtension, strikethroughExtension, subscriptExtension, superscriptExtension, tabIndentExtension, tableExtension, textColorExtension, textHighlightExtension, underlineExtension, useBaseEditor, youTubeEmbedExtension };