@lyfie/luthor 1.1.0 → 2.0.1

package/dist/index.d.ts

@@ -1,2311 +1,56 @@
-import * as lexical from 'lexical';
-import { TextFormatType, LexicalEditor, EditorThemeClasses, ParagraphNode, DecoratorNode, DOMConversionMap, NodeKey, EditorConfig as EditorConfig$1, DOMExportOutput, Spread, SerializedLexicalNode, LexicalNode, ElementNode, RangeSelection } from 'lexical';
-import React$1, { ReactNode, ComponentType, CSSProperties } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { Transformer } from '@lexical/markdown';
-import { CodeNode } from '@lexical/code';
-import { HeadingTagType, HeadingNode, QuoteNode } from '@lexical/rich-text';
-import * as _lexical_table from '@lexical/table';
-import * as _lexical_react_LexicalHorizontalRuleNode from '@lexical/react/LexicalHorizontalRuleNode';
+import * as _lyfie_luthor_headless from '@lyfie/luthor-headless';
+import { LinkExtension, TableExtension, ImageExtension, MarkdownExtension, HTMLEmbedExtension, FloatingToolbarExtension, ContextMenuExtension, CommandPaletteExtension, DraggableBlockExtension, Extension, EditorConfig, LuthorTheme } from '@lyfie/luthor-headless';
+import React from 'react';
 
-/** 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]: any;
-}
-/** Toolbar item configuration */
-interface ToolbarItem {
-    label: string;
-    onClick: () => void;
-    isActive?: () => boolean;
-    component?: React.ComponentType<any>;
-}
-/**
- * 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, any> = {}, StateQueries extends Record<string, () => Promise<boolean>> = {}, 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]: any;
-    }>) => Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /** Override node rendering logic */
-    overrideNodeRender?: (overrides: {
-        createDOM?: (config: any) => HTMLElement;
-        updateDOM?: (prev: any, next: any, dom: HTMLElement) => boolean;
-    }) => Extension<Name, Config, Commands, StateQueries, Plugins>;
-    /** Return custom Lexical nodes */
-    getNodes?: () => any[];
-    /** 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<any>>;
-    /** Event listener registration */
-    listeners: {
-        registerUpdate: (listener: (state: any) => void) => (() => void) | undefined;
-        registerPaste: (listener: (event: ClipboardEvent) => boolean) => (() => void) | undefined;
-    };
-    /** Export helpers for formats */
-    export: {
-        toHTML: () => Promise<string>;
-        toMarkdown: () => Promise<string>;
-        toJSON: () => any;
-    };
-    /** Import helpers for formats */
-    import: {
-        fromHTML: (html: string) => Promise<void>;
-        fromMarkdown: (md: string) => Promise<void>;
-        fromJSON: (json: any) => 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]: any;
-}
+declare const blogPreset: EditorPreset;
 
-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, {}, {}, React$1.ReactNode[]>[]>) => react_jsx_runtime.JSX.Element;
-declare const useBaseEditor: () => EditorContextType<any>;
+declare const chatPreset: EditorPreset;
 
-/**
- * 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, any> = {}, StateQueries extends Record<string, () => Promise<boolean>> = {}, 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: any) => HTMLElement;
-        updateDOM?: (prev: any, next: any, 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(): any[];
-    /**
-     * 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]: any;
-    }>): 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: any) => HTMLElement;
-        updateDOM?: (prev: any, next: any, 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: any): ToolbarItem[];
-}
+declare const classicPreset: EditorPreset;
 
-/**
- * Configuration options for creating a custom extension
- */
-interface CreateExtensionConfig<Name extends string, Config extends BaseExtensionConfig = BaseExtensionConfig, Commands extends Record<string, any> = {}, StateQueries extends Record<string, () => Promise<boolean>> = {}, 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?: any[];
-    /** Text formats supported by this extension */
-    supportedFormats?: readonly any[];
-}
-/**
- * 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, any> = {}, StateQueries extends Record<string, () => Promise<boolean>> = {}, Plugins extends ReactNode[] = ReactNode[]>(config: CreateExtensionConfig<Name, Config, Commands, StateQueries, Plugins>): BaseExtension<Name, Config, Commands, StateQueries, Plugins>;
+declare const cmsPreset: EditorPreset;
 
-/**
- * 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$1.CSSProperties;
-            handleActive?: React$1.CSSProperties;
-            handleHover?: React$1.CSSProperties;
-            handleDragging?: React$1.CSSProperties;
-            blockDragging?: React$1.CSSProperties;
-            dropIndicator?: React$1.CSSProperties;
-            upButton?: React$1.CSSProperties;
-            downButton?: React$1.CSSProperties;
-            blockIsDragging?: React$1.CSSProperties;
-            buttonStack?: React$1.CSSProperties;
-        };
-    };
-    floatingToolbar?: {
-        container?: string;
-        button?: string;
-        buttonActive?: string;
-        styles?: {
-            container?: React$1.CSSProperties;
-            button?: React$1.CSSProperties;
-            buttonActive?: React$1.CSSProperties;
-        };
-    };
-    htmlEmbed?: {
-        container?: string;
-        preview?: string;
-        editor?: string;
-        textarea?: string;
-        toggle?: string;
-        content?: string;
-        styles?: {
-            container?: React$1.CSSProperties;
-            preview?: React$1.CSSProperties;
-            editor?: React$1.CSSProperties;
-            textarea?: React$1.CSSProperties;
-            toggle?: React$1.CSSProperties;
-            content?: React$1.CSSProperties;
-        };
-    };
-    styles?: {
-        toolbar?: {
-            button?: React$1.CSSProperties;
-            buttonActive?: React$1.CSSProperties;
-            buttonDisabled?: React$1.CSSProperties;
-            group?: React$1.CSSProperties;
-        };
-        container?: React$1.CSSProperties;
-        wrapper?: React$1.CSSProperties;
-        draggable?: {
-            handle?: React$1.CSSProperties;
-            handleHover?: React$1.CSSProperties;
-            handleDragging?: React$1.CSSProperties;
-            blockDragging?: React$1.CSSProperties;
-            dropIndicator?: React$1.CSSProperties;
-            upButton?: React$1.CSSProperties;
-            downButton?: React$1.CSSProperties;
-            blockIsDragging?: React$1.CSSProperties;
-            buttonStack?: React$1.CSSProperties;
-        };
-        floatingToolbar?: {
-            container?: React$1.CSSProperties;
-            button?: React$1.CSSProperties;
-            buttonActive?: React$1.CSSProperties;
-        };
-        htmlEmbed?: {
-            container?: React$1.CSSProperties;
-            preview?: React$1.CSSProperties;
-            editor?: React$1.CSSProperties;
-            textarea?: React$1.CSSProperties;
-            toggle?: React$1.CSSProperties;
-            content?: React$1.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 const codePreset: EditorPreset;
 
-/**
- * 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>>;
-}
+declare const defaultPreset: EditorPreset;
 
-/**
- * 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;
+declare const docsPreset: EditorPreset;
 
-/**
- * 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;
+declare const emailPreset: EditorPreset;
 
-/**
- * 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/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(): any[];
-}
-declare const underlineExtension: UnderlineExtension;
+declare const extensivePreset: EditorPreset;
 
-/**
- * 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/extensions/formatting/StrikethroughExtension';
- *
- * const extensions = [strikethroughExtension];
- * const editor = createEditorSystem(extensions);
- * ```
- */
-declare class StrikethroughExtension extends TextFormatExtension<"strikethrough"> {
-    constructor();
-}
-declare const strikethroughExtension: StrikethroughExtension;
+declare const extensiveExtensions: readonly [_lyfie_luthor_headless.BoldExtension, _lyfie_luthor_headless.ItalicExtension, _lyfie_luthor_headless.UnderlineExtension, _lyfie_luthor_headless.StrikethroughExtension, LinkExtension, _lyfie_luthor_headless.HorizontalRuleExtension, TableExtension, _lyfie_luthor_headless.ListExtension, _lyfie_luthor_headless.HistoryExtension, ImageExtension, _lyfie_luthor_headless.BlockFormatExtension, _lyfie_luthor_headless.HTMLExtension, MarkdownExtension, _lyfie_luthor_headless.CodeExtension, _lyfie_luthor_headless.CodeFormatExtension, HTMLEmbedExtension, FloatingToolbarExtension<any, any>, ContextMenuExtension, CommandPaletteExtension, DraggableBlockExtension];
 
-/**
- * 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;
+interface ExtensiveEditorRef {
+    injectMarkdown: (content: string) => void;
+    injectHTML: (content: string) => void;
+    getMarkdown: () => string;
+    getHTML: () => string;
 }
-/**
- * Commands exposed by the link extension.
- */
-type LinkCommands = {
-    insertLink: (url?: string, text?: string) => void;
-    removeLink: () => void;
-};
-/**
- * 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$1.ReactElement[]> {
-    /**
-     * 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$1.ReactElement[];
-    /**
-     * Returns command handlers exposed by this extension.
-     */
-    getCommands(editor: LexicalEditor): LinkCommands;
-    /**
-     * 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$1.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$1.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 MarkdownConfig = BaseExtensionConfig & {
-    /** Optional debounce (ms) for programmatic markdown imports */
-    importDebounce?: number;
-    /** Pre-registered transformers */
-    transformers?: Transformer[];
-    /** Transformer alias for backward compatibility */
-    customTransformers?: Transformer[];
-};
-type MarkdownCommands = {
-    exportToMarkdown: () => string;
-    importFromMarkdown: (markdown: string, opts?: {
-        immediate?: boolean;
-        preventFocus?: boolean;
-    }) => Promise<void>;
-    registerMarkdownTransformer: (transformer: Transformer) => void;
-};
-type MarkdownStateQueries = {};
-declare class MarkdownExtension extends BaseExtension<'markdown', MarkdownConfig, MarkdownCommands, MarkdownStateQueries, [
-]> {
-    private manager;
-    private pendingTransformers;
-    private importTimer;
-    constructor();
-    configure(config: Partial<MarkdownConfig>): this;
-    /** Allow other extensions to register transformers before or after editor registration */
-    registerTransformer: (transformer: Transformer) => void;
-    register(editor: LexicalEditor): () => void;
-    getCommands(editor: LexicalEditor): MarkdownCommands;
-    getStateQueries(editor: LexicalEditor): MarkdownStateQueries;
-}
-declare const markdownExtension: MarkdownExtension;
-
-/**
- * Context menu item definition
- */
-type ContextMenuItem = {
-    label: string;
-    action: () => void;
-    icon?: React$1.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$1.CSSProperties;
-    itemClassName: string;
-    itemStyle?: React$1.CSSProperties;
-    disabledItemClassName: string;
-    disabledItemStyle?: React$1.CSSProperties;
-}) => React$1.ReactElement;
-/**
- * Context menu configuration
- */
-interface ContextMenuConfig extends BaseExtensionConfig {
-    defaultRenderer?: ContextMenuRenderer;
-    preventDefault?: boolean;
-    theme?: {
-        container?: string;
-        item?: string;
-        itemDisabled?: string;
-    };
-    styles?: {
-        container?: React$1.CSSProperties;
-        item?: React$1.CSSProperties;
-        itemDisabled?: React$1.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$1.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$1.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;
-    /** Markdown extension used to register transformers */
-    markdownExtension?: typeof markdownExtension;
-};
-/**
- * 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;
-    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;
-    /** 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>;
-}, 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(): any[];
-    /**
-     * Returns React plugins needed for list functionality.
-     *
-     * @returns Array containing the ListPlugin component
-     */
-    getPlugins(): React$1.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>;
-    };
-}
-/**
- * Preconfigured list extension instance.
- * Ready for use in extension arrays.
- */
-declare const listExtension: ListExtension;
-
-/**
- * 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>;
-};
-/**
- * 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/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", {}, CodeCommands, CodeStateQueries, ReactNode[]> {
-    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)[];
-    /**
-     * 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;
-    /**
-     * 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;
-
-/**
- * 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/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;
-    /** 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>;
-};
-/**
- * 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/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", {}, // No extra config needed
-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;
-    /**
-     * 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;
-    /**
-     * 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 move buttons */
-    showMoveButtons?: boolean;
-    /** Show the up button */
-    showUpButton?: boolean;
-    /** Show the down button */
-    showDownButton?: 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;
-        upButton?: string;
-        downButton?: string;
-        buttonStack?: string;
-    };
-    /** Custom styles for UI elements */
-    styles?: {
-        handle?: React$1.CSSProperties;
-        handleActive?: React$1.CSSProperties;
-        blockDragging?: React$1.CSSProperties;
-        dropIndicator?: React$1.CSSProperties;
-        upButton?: React$1.CSSProperties;
-        downButton?: React$1.CSSProperties;
-        buttonStack?: React$1.CSSProperties;
-    };
-    /** Custom handle renderer for full headless control */
-    handleRenderer?: (props: {
-        rect: DOMRect;
-        isDragging: boolean;
-        onDragStart: (e: React$1.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;
-
-/**
- * Commands exposed by the HTML extension.
- */
-type HTMLCommands = {
-    /** Export current editor content as an HTML string */
-    exportToHTML: () => string;
-    /** Import HTML into the editor, replacing current content */
-    importFromHTML: (html: string, opts?: {
-        preventFocus?: boolean;
-    }) => Promise<void>;
-};
-/**
- * State queries exposed by the HTML extension.
- */
-type HTMLStateQueries = {
-    /** Check whether HTML export is available (always true) */
-    canExportHTML: () => Promise<boolean>;
-};
-/**
- * HTML extension for import/export of HTML content.
- * Converts between Lexical editor state and HTML strings.
- *
- * @example
- * ```tsx
- * const extensions = [htmlExtension] as const;
- * const { Provider, useEditor } = createEditorSystem<typeof extensions>();
- *
- * function MyEditor() {
- *   const { commands } = useEditor();
- *
- *   const handleExport = () => {
- *     const html = commands.exportToHTML();
- *     console.log('Exported HTML:', html);
- *   };
- *
- *   const handleImport = () => {
- *     const html = '<p>Hello <strong>world</strong>!</p>';
- *     commands.importFromHTML(html);
- *   };
- *
- *   return (
- *     <div>
- *       <button onClick={handleExport}>Export HTML</button>
- *       <button onClick={handleImport}>Import HTML</button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare class HTMLExtension extends BaseExtension<"html", {}, HTMLCommands, HTMLStateQueries, ReactNode[]> {
-    /**
-     * Creates a new HTML extension.
-     */
-    constructor();
-    /**
-     * Registers the extension with the Lexical editor.
-     * No special registration needed for HTML functionality.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Cleanup function
-     */
-    register(editor: LexicalEditor): () => void;
-    /**
-     * Returns commands exposed by this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing HTML import/export commands
-     */
-    getCommands(editor: LexicalEditor): HTMLCommands;
-    /**
-     * Returns state query functions for this extension.
-     *
-     * @param editor - Lexical editor instance
-     * @returns Object containing state query functions
-     */
-    getStateQueries(editor: LexicalEditor): HTMLStateQueries;
-}
-/**
- * Preconfigured HTML extension instance.
- * Ready for use in extension arrays.
- */
-declare const htmlExtension: HTMLExtension;
-
-/**
- * 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 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 */
+interface ExtensiveEditorProps {
     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;
-    /** 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;
-    /** 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 ImageNode extends DecoratorNode<ReactNode> {
-    /** 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 style overrides */
-    __style?: CSSProperties;
-    /** Width in pixels */
-    __width?: number;
-    /** Height in pixels */
-    __height?: number;
-    /** Whether the image is uploading */
-    __uploading?: boolean;
-    static getType(): string;
-    static clone(node: ImageNode): ImageNode;
-    static importDOM(): DOMConversionMap | null;
-    static importJSON(serializedNode: SerializedImageNode): ImageNode;
-    constructor(src?: string, alt?: string, caption?: string, alignment?: Alignment, className?: string, style?: CSSProperties, width?: number, height?: number, uploading?: boolean, key?: NodeKey);
-    createDOM(config: EditorConfig$1): HTMLElement;
-    updateDOM(prevNode: ImageNode, dom: HTMLElement, config: EditorConfig$1): boolean;
-    exportDOM(): DOMExportOutput;
-    exportJSON(): SerializedImageNode;
-    setSrc(src: string): void;
-    setAlt(alt: string): void;
-    setCaption(caption?: string): void;
-    setAlignment(alignment: Alignment): void;
-    setClassName(className?: string): void;
-    setStyle(style?: CSSProperties): void;
-    getWidth(): number | undefined;
-    getHeight(): number | undefined;
-    setWidthAndHeight(width: number, height: number): void;
-    isInline(): boolean;
-    isBlockElement(): boolean;
-    canBeEmpty(): boolean;
-    decorate(): ReactNode;
-}
-declare class ImageExtension extends BaseExtension<"image", ImageExtensionConfig, ImageCommands, ImageStateQueries, ReactNode[]> {
-    /** Track recent image sources to avoid duplicate inserts */
-    private recentImages;
-    constructor();
-    configure(config: Partial<ImageExtensionConfig>): this;
-    register(editor: LexicalEditor): () => void;
-    getNodes(): any[];
-    getCommands(editor: LexicalEditor): ImageCommands;
-    getStateQueries(editor: LexicalEditor): ImageStateQueries;
+    onReady?: (methods: ExtensiveEditorRef) => void;
+    initialTheme?: "light" | "dark";
 }
-declare const imageExtension: ImageExtension;
+declare const ExtensiveEditor: React.ForwardRefExoticComponent<ExtensiveEditorProps & React.RefAttributes<ExtensiveEditorRef>>;
 
-/**
- * Payload for HTML embed content
- */
-type HTMLEmbedPayload = {
-    /** HTML content to embed */
-    html: string;
-    /** Whether to show preview or edit mode */
-    preview: boolean;
-};
-/**
- * HTMLEmbedExtension configuration
- */
-interface HTMLEmbedConfig extends BaseExtensionConfig {
-    /** Default HTML for new embeds */
-    defaultHtml?: string;
-    /** Default to preview mode */
-    defaultPreview?: boolean;
-    /** Theme class names */
-    theme?: {
-        container?: string;
-        preview?: string;
-        editor?: string;
-        textarea?: string;
-        toggle?: string;
-        content?: string;
-    };
-    /** Custom styles for UI elements */
-    styles?: {
-        container?: React$1.CSSProperties;
-        preview?: React$1.CSSProperties;
-        editor?: React$1.CSSProperties;
-        textarea?: React$1.CSSProperties;
-        toggle?: React$1.CSSProperties;
-        content?: React$1.CSSProperties;
-    };
-    /** Custom container renderer for full headless control */
-    containerRenderer?: (props: {
-        children: ReactNode;
-        className: string;
-        style?: React$1.CSSProperties;
-    }) => ReactNode;
-    /** Custom preview renderer component */
-    previewRenderer?: (props: {
-        html: string;
-        onToggleEdit: () => void;
-        className: string;
-        style?: React$1.CSSProperties;
-        toggleClassName: string;
-        toggleStyle?: React$1.CSSProperties;
-    }) => ReactNode;
-    /** Custom editor renderer component */
-    editorRenderer?: (props: {
-        html: string;
-        onTogglePreview: () => void;
-        onSave: () => void;
-        className: string;
-        style?: React$1.CSSProperties;
-        textareaClassName: string;
-        textareaStyle?: React$1.CSSProperties;
-        toggleClassName: string;
-        toggleStyle?: React$1.CSSProperties;
-    }) => ReactNode;
-    /** Custom toggle button renderer component */
-    toggleRenderer?: (props: {
-        isPreview: boolean;
-        onClick: () => void;
-        className: string;
-        style?: React$1.CSSProperties;
-    }) => ReactNode;
-    /** Markdown extension instance used to register transformers */
-    markdownExtension?: typeof markdownExtension;
-}
-/**
- * Commands exposed by the HTMLEmbedExtension
- */
-type HTMLEmbedCommands = {
-    /** Insert an HTML embed with optional initial HTML */
-    insertHTMLEmbed: (html?: string) => void;
-    /** Toggle between preview and edit modes */
-    toggleHTMLPreview: () => void;
-};
-/**
- * State queries exposed by the HTMLEmbedExtension
- */
-type HTMLEmbedQueries = {
-    /** Check whether an HTML embed is selected */
-    isHTMLEmbedSelected: () => Promise<boolean>;
-    /** Check whether HTML preview mode is active */
-    isHTMLPreviewMode: () => Promise<boolean>;
-};
-/**
- * Serialized representation of an HTMLEmbedNode
- */
-type SerializedHTMLEmbedNode = Spread<{
-    /** HTML content */
-    html: string;
-    /** Preview mode state */
-    preview: boolean;
-    /** Node type ID */
-    type: "html-embed";
-    /** Version for migrations */
-    version: 1;
-}, SerializedLexicalNode>;
-/**
- * HTMLEmbedNode - A Lexical DecoratorNode for custom HTML embeds
- *
- * Allows users to embed custom HTML content in the editor.
- * Supports preview mode (rendered HTML) and edit mode
- * (editable HTML source).
- *
- * @example
- * ```typescript
- * const node = new HTMLEmbedNode({
- *   html: '<div>Hello World</div>',
- *   preview: true
- * });
- * ```
- */
-declare class HTMLEmbedNode extends DecoratorNode<ReactNode> {
-    __payload: HTMLEmbedPayload;
-    /**
-     * Get the node type identifier
-     * @returns Node type string
-     */
-    static getType(): string;
-    /**
-     * Clone the node
-     * @param node - Node to clone
-     * @returns New cloned node instance
-     */
-    static clone(node: HTMLEmbedNode): HTMLEmbedNode;
-    /**
-     * Constructor for HTMLEmbedNode
-     * @param payload - HTML embed payload
-     * @param key - Optional node key
-     */
-    constructor(payload: HTMLEmbedPayload, key?: NodeKey);
-    /**
-     * Create the DOM element for this node
-     * @returns DOM element
-     */
-    createDOM(): HTMLElement;
-    /**
-     * Update the DOM element (unused with React rendering)
-     * @returns Always false to let React handle updates
-     */
-    updateDOM(): boolean;
-    /**
-     * Import node from JSON serialization
-     * @param serialized - Serialized node data
-     * @returns New HTMLEmbedNode instance
-     */
-    static importJSON(serialized: SerializedHTMLEmbedNode): HTMLEmbedNode;
-    /**
-     * Export node to JSON serialization
-     * @returns Serialized node data
-     */
-    exportJSON(): SerializedHTMLEmbedNode;
-    static importDOM(): DOMConversionMap | null;
-    exportDOM(): {
-        element: HTMLElement;
-    };
-    getPayload(): HTMLEmbedPayload;
-    setPayload(payload: Partial<HTMLEmbedPayload>): void;
-    decorate(editor: LexicalEditor): ReactNode;
-    isInline(): false;
-    isKeyboardSelectable(): boolean;
-}
-declare class HTMLEmbedExtension extends BaseExtension<"htmlEmbed", HTMLEmbedConfig, HTMLEmbedCommands, HTMLEmbedQueries, ReactNode[]> {
-    constructor(config?: Partial<HTMLEmbedConfig>);
-    register(editor: LexicalEditor): () => void;
-    getNodes(): any[];
-    getPlugins(): ReactNode[];
-    getCommands(editor: LexicalEditor): HTMLEmbedCommands;
-    getStateQueries(editor: LexicalEditor): HTMLEmbedQueries;
-}
-declare const htmlEmbedExtension: HTMLEmbedExtension;
-
-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> = {}, StateQueries extends Record<string, () => Promise<boolean>> = {}>(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$1.ReactElement;
-    placeholder?: React$1.ReactElement | string;
-    className?: string;
-    classNames?: {
-        container?: string;
-        contentEditable?: string;
-        placeholder?: string;
-    };
-    styles?: {
-        container?: React$1.CSSProperties;
-        contentEditable?: React$1.CSSProperties;
-        placeholder?: React$1.CSSProperties;
-    };
-    errorBoundary?: React$1.ComponentType<{
-        children: React$1.JSX.Element;
-        onError: (error: Error) => void;
-    }>;
-}
-interface SharedRichTextProps extends BaseRichTextProps {
-}
-interface RichTextConfig extends BaseExtensionConfig, BaseRichTextProps {
-}
-interface RichTextConfig extends BaseExtensionConfig, BaseRichTextProps {
-}
-/**
- * RichTextExtension - Provides core rich text editing functionality
- * Extends BaseExtension to stay consistent with other extensions
- */
-declare class RichTextExtension extends BaseExtension<"richText", RichTextConfig, {}, // No commands
-{}, // No state queries
-ReactNode[]> {
-    constructor(config?: RichTextConfig);
-    register(editor: LexicalEditor): () => void;
-    getPlugins(): ReactNode[];
-}
-declare const richTextExtension: RichTextExtension;
-interface RichTextComponentProps extends SharedRichTextProps {
-}
-declare const RichText: React$1.FC<RichTextComponentProps>;
+declare const markdownPreset: EditorPreset;
 
-/**
- * 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 = {};
-/**
- * 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>;
+declare const minimalPreset: EditorPreset;
 
-/**
- * Command palette item definition
- */
-type CommandPaletteItem = {
+interface EditorPreset {
     id: string;
     label: string;
     description?: string;
-    action: () => void;
-    keywords?: string[];
-    category?: string;
-    icon?: React$1.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$1.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[];
+    extensions?: Extension[];
+    config?: EditorConfig;
+    theme?: LuthorTheme;
+    toolbar?: string[];
+    components?: Record<string, unknown>;
+    css?: string;
 }
-declare const commandPaletteExtension: CommandPaletteExtension;
 
-/**
- * All Markdown transformers collected in one place
- * Import this array to get all available transformers
- */
-declare const ALL_MARKDOWN_TRANSFORMERS: ({
-    format: readonly ["underline"];
-    tag: string;
-    type: "text-format";
-} | {
-    dependencies: typeof _lexical_react_LexicalHorizontalRuleNode.HorizontalRuleNode[];
-    export: (node: lexical.LexicalNode) => "---" | null;
-    regExp: RegExp;
-    replace: (parentNode: lexical.ElementNode, children: lexical.LexicalNode[], match: string[]) => void;
-    type: "element";
-} | {
-    dependencies: (typeof _lexical_table.TableNode | typeof _lexical_table.TableRowNode | typeof _lexical_table.TableCellNode)[];
-    export: (node: any) => string | null;
-    regExpStart: RegExp;
-    regExpEnd: {
-        optional: true;
-        regExp: RegExp;
-    };
-    replace: (rootNode: any, children: any, startMatch: any, endMatch: any, linesInBetween: any, isImport: boolean) => void;
-    type: "multiline-element";
-} | {
-    dependencies: typeof HTMLEmbedNode[];
-    export: (node: any) => string | null;
-    regExpStart: RegExp;
-    regExpEnd: {
-        optional: true;
-        regExp: RegExp;
-    };
-    replace: (rootNode: any, children: any, startMatch: any, endMatch: any, linesInBetween: any, isImport: boolean) => void;
-    type: "multiline-element";
-} | {
-    dependencies: typeof ImageNode[];
-    export: (node: lexical.LexicalNode) => string | null;
-    regExp: RegExp;
-    replace: (parentNode: lexical.ElementNode, _children: lexical.LexicalNode[], match: string[], isImport: boolean) => void;
-    type: "element";
-})[];
+declare const presetRegistry: Record<string, EditorPreset>;
 
-export { ALL_MARKDOWN_TRANSFORMERS, type Alignment, type BaseCommands, BaseExtension, type BaseExtensionConfig, BaseProvider, BlockFormatExtension, BoldExtension, CodeExtension, CodeFormatExtension, 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 Extension, ExtensionCategory, type ExtractCommands, type ExtractNames, type ExtractPlugins, type ExtractStateQueries, type FloatingCommands, type FloatingConfig, type FloatingStateQueries, FloatingToolbarExtension, HTMLEmbedExtension, HTMLExtension, HistoryExtension, HorizontalRuleExtension, type ImageCommands, type ImageComponentProps, ImageExtension, type ImageExtensionConfig, type ImagePayload, type ImageStateQueries, ItalicExtension, LinkExtension, ListExtension, type LuthorTheme, MarkdownExtension, RichText, type RichTextComponentProps, type RichTextConfig, type SerializedImageNode, StrikethroughExtension, type TableConfig, TableExtension, TextFormatExtension, type ToolbarItem, UnderlineExtension, blockFormatExtension, boldExtension, codeExtension, codeFormatExtension, commandPaletteExtension, contextMenuExtension, createCustomNodeExtension, createEditorSystem, createExtension, defaultLuthorTheme, draggableBlockExtension, floatingToolbarExtension, historyExtension, horizontalRuleExtension, htmlEmbedExtension, htmlExtension, imageExtension, isLuthorTheme, italicExtension, linkExtension, listExtension, markdownExtension, mergeThemes, richTextExtension, strikethroughExtension, tableExtension, underlineExtension, useBaseEditor };
+export { type EditorPreset, ExtensiveEditor, blogPreset, chatPreset, classicPreset, cmsPreset, codePreset, defaultPreset, docsPreset, emailPreset, extensiveExtensions, extensivePreset, markdownPreset, minimalPreset, presetRegistry };