@lyfie/luthor-headless 2.2.0 → 2.3.1

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-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 { 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';
-import * as _lexical_table from '@lexical/table';
-import * as _lexical_react_LexicalHorizontalRuleNode from '@lexical/react/LexicalHorizontalRuleNode';
 
+type LexicalNodeRegistration = KlassConstructor<typeof LexicalNode> | LexicalNodeReplacement;
 /** Extension category buckets */
 declare enum ExtensionCategory {
     Toolbar = "toolbar",
@@ -22,14 +22,14 @@ interface BaseExtensionConfig {
     position?: "before" | "after";
     /** Initialization priority; higher registers first (default: 0) */
     initPriority?: number;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /** Toolbar item configuration */
 interface ToolbarItem {
     label: string;
     onClick: () => void;
     isActive?: () => boolean;
-    component?: React.ComponentType<any>;
+    component?: React.ComponentType<Record<string, unknown>>;
 }
 /**
  * Core extension contract implemented by all extensions.
@@ -41,7 +41,7 @@ interface ToolbarItem {
  * @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[]> {
+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 */
@@ -59,15 +59,15 @@ interface Extension<Name extends string = string, Config extends BaseExtensionCo
         selected?: boolean;
         className?: string;
         style?: CSSProperties;
-        [key: string]: any;
+        [key: string]: unknown;
     }>) => Extension<Name, Config, Commands, StateQueries, Plugins>;
     /** Override node rendering logic */
     overrideNodeRender?: (overrides: {
-        createDOM?: (config: any) => HTMLElement;
-        updateDOM?: (prev: any, next: any, dom: HTMLElement) => boolean;
+        createDOM?: (config: unknown) => HTMLElement;
+        updateDOM?: (prev: unknown, next: unknown, dom: HTMLElement) => boolean;
     }) => Extension<Name, Config, Commands, StateQueries, Plugins>;
     /** Return custom Lexical nodes */
-    getNodes?: () => any[];
+    getNodes?: () => LexicalNodeRegistration[];
     /** Return React plugins */
     getPlugins: () => Plugins;
     /** Provide commands exposed by the extension */
@@ -109,23 +109,19 @@ interface EditorContextType<Exts extends readonly Extension[]> {
     /** Current state for all extensions */
     activeStates: ExtractStateQueries<Exts>;
     /** State query functions from extensions */
-    stateQueries: Record<string, () => Promise<any>>;
+    stateQueries: Record<string, () => Promise<unknown>>;
     /** Event listener registration */
     listeners: {
-        registerUpdate: (listener: (state: any) => void) => (() => void) | undefined;
+        registerUpdate: (listener: (state: unknown) => void) => (() => void) | undefined;
         registerPaste: (listener: (event: ClipboardEvent) => boolean) => (() => void) | undefined;
     };
     /** Export helpers for formats */
     export: {
-        toHTML: () => Promise<string>;
-        toMarkdown: () => Promise<string>;
-        toJSON: () => any;
+        toJSON: () => unknown;
     };
     /** Import helpers for formats */
     import: {
-        fromHTML: (html: string) => Promise<void>;
-        fromMarkdown: (md: string) => Promise<void>;
-        fromJSON: (json: any) => void;
+        fromJSON: (json: unknown) => void;
     };
     /** Alias of the raw Lexical editor */
     lexical: LexicalEditor | null;
@@ -142,7 +138,7 @@ interface EditorContextType<Exts extends readonly Extension[]> {
 }
 interface EditorConfig {
     theme?: EditorThemeClasses;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 
 interface ProviderProps<Exts extends readonly Extension[]> {
@@ -168,8 +164,8 @@ 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 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.
@@ -181,7 +177,7 @@ declare const useBaseEditor: () => EditorContextType<any>;
  * @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> {
+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.) */
@@ -192,8 +188,8 @@ declare abstract class BaseExtension<Name extends string = string, Config extend
     supportedFormats: readonly TextFormatType[];
     /** Node rendering overrides */
     nodeOverrides: {
-        createDOM?: (config: any) => HTMLElement;
-        updateDOM?: (prev: any, next: any, dom: HTMLElement) => boolean;
+        createDOM?: (config: unknown) => HTMLElement;
+        updateDOM?: (prev: unknown, next: unknown, dom: HTMLElement) => boolean;
     };
     /**
      * Creates a new extension instance.
@@ -223,7 +219,7 @@ declare abstract class BaseExtension<Name extends string = string, Config extend
      *
      * @returns Array of Lexical node classes
      */
-    getNodes(): any[];
+    getNodes(): LexicalNodeRegistration[];
     /**
      * Allows overriding the UI component used for this extension.
      *
@@ -234,7 +230,7 @@ declare abstract class BaseExtension<Name extends string = string, Config extend
         selected?: boolean;
         className?: string;
         style?: CSSProperties;
-        [key: string]: any;
+        [key: string]: unknown;
     }>): Extension<Name, Config, Commands, StateQueries, Plugins>;
     /**
      * Overrides node rendering behavior.
@@ -243,8 +239,8 @@ declare abstract class BaseExtension<Name extends string = string, Config extend
      * @returns Extension instance for chaining
      */
     overrideNodeRender(overrides: {
-        createDOM?: (config: any) => HTMLElement;
-        updateDOM?: (prev: any, next: any, dom: HTMLElement) => boolean;
+        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.
@@ -272,13 +268,13 @@ declare abstract class BaseExtension<Name extends string = string, Config extend
      * @param commands - Available commands from all extensions
      * @returns Array of toolbar item configurations
      */
-    getToolbarItems(commands: any): ToolbarItem[];
+    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, any> = {}, StateQueries extends Record<string, () => Promise<boolean>> = {}, Plugins extends ReactNode[] = ReactNode[]> {
+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 */
@@ -294,9 +290,9 @@ interface CreateExtensionConfig<Name extends string, Config extends BaseExtensio
     /** Initialization function called when extension is registered */
     initialize?: (editor: LexicalEditor) => (() => void) | void;
     /** Custom Lexical nodes */
-    nodes?: any[];
+    nodes?: LexicalNodeRegistration[];
     /** Text formats supported by this extension */
-    supportedFormats?: readonly any[];
+    supportedFormats?: readonly TextFormatType[];
 }
 /**
  * Factory function to create a type-safe extension that extends BaseExtension.
@@ -330,8 +326,12 @@ interface CreateExtensionConfig<Name extends string, Config extends BaseExtensio
  * });
  * ```
  */
-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 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
@@ -362,16 +362,16 @@ interface LuthorTheme extends EditorThemeClasses {
         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;
+            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?: {
@@ -379,59 +379,35 @@ interface LuthorTheme extends EditorThemeClasses {
         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;
+            container?: React__default.CSSProperties;
+            button?: React__default.CSSProperties;
+            buttonActive?: React__default.CSSProperties;
         };
     };
     styles?: {
         toolbar?: {
-            button?: React$1.CSSProperties;
-            buttonActive?: React$1.CSSProperties;
-            buttonDisabled?: React$1.CSSProperties;
-            group?: React$1.CSSProperties;
+            button?: React__default.CSSProperties;
+            buttonActive?: React__default.CSSProperties;
+            buttonDisabled?: React__default.CSSProperties;
+            group?: React__default.CSSProperties;
         };
-        container?: React$1.CSSProperties;
-        wrapper?: React$1.CSSProperties;
+        container?: React__default.CSSProperties;
+        wrapper?: React__default.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;
+            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$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;
+            container?: React__default.CSSProperties;
+            button?: React__default.CSSProperties;
+            buttonActive?: React__default.CSSProperties;
         };
     };
 }
@@ -448,6 +424,40 @@ declare function mergeThemes(baseTheme: LuthorTheme, overrideTheme: Partial<Luth
  */
 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).
@@ -543,6 +553,15 @@ declare class ItalicExtension extends TextFormatExtension<"italic"> {
  */
 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
  *
@@ -567,7 +586,7 @@ declare class UnderlineExtension extends TextFormatExtension<"underline"> {
      *
     * @returns An array containing the underline transformer
      */
-    getMarkdownTransformers(): any[];
+    getMarkdownTransformers(): readonly typeof UNDERLINE_TRANSFORMER[];
 }
 declare const underlineExtension: UnderlineExtension;
 
@@ -613,13 +632,30 @@ interface LinkConfig extends BaseExtensionConfig {
     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.
@@ -665,7 +701,8 @@ type LinkStateQueries = {
  * }
  * ```
  */
-declare class LinkExtension extends BaseExtension<"link", LinkConfig, LinkCommands, LinkStateQueries, React$1.ReactElement[]> {
+declare class LinkExtension extends BaseExtension<"link", LinkConfig, LinkCommands, LinkStateQueries, React__default.ReactElement[]> {
+    private lastSelectedLinkNodeKey;
     /**
      * Creates a new link extension instance.
      */
@@ -682,11 +719,16 @@ declare class LinkExtension extends BaseExtension<"link", LinkConfig, LinkComman
     /**
      * Returns React plugins exposed by this extension.
      */
-    getPlugins(): React$1.ReactElement[];
+    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.
      */
@@ -729,7 +771,7 @@ type HorizontalRuleStateQueries = {
  * }
  * ```
  */
-declare class HorizontalRuleExtension extends BaseExtension<"horizontalRule", any, HorizontalRuleCommands, HorizontalRuleStateQueries, React$1.ReactElement[]> {
+declare class HorizontalRuleExtension extends BaseExtension<"horizontalRule", any, HorizontalRuleCommands, HorizontalRuleStateQueries, React__default.ReactElement[]> {
     /**
      * Creates a new horizontal rule extension.
      */
@@ -753,7 +795,7 @@ declare class HorizontalRuleExtension extends BaseExtension<"horizontalRule", an
      *
      * @returns Array containing the HorizontalRulePlugin
      */
-    getPlugins(): React$1.ReactElement[];
+    getPlugins(): React__default.ReactElement[];
     /**
      * Returns commands exposed by this extension.
      *
@@ -775,37 +817,189 @@ declare class HorizontalRuleExtension extends BaseExtension<"horizontalRule", an
  */
 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;
+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();
-    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;
+    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;
 }
-declare const markdownExtension: MarkdownExtension;
+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
@@ -813,7 +1007,7 @@ declare const markdownExtension: MarkdownExtension;
 type ContextMenuItem = {
     label: string;
     action: () => void;
-    icon?: React$1.ComponentType<{
+    icon?: React__default.ComponentType<{
         size?: number;
         className?: string;
     }>;
@@ -851,12 +1045,12 @@ type ContextMenuRenderer = (props: {
     };
     onClose: () => void;
     className: string;
-    style?: React$1.CSSProperties;
+    style?: React__default.CSSProperties;
     itemClassName: string;
-    itemStyle?: React$1.CSSProperties;
+    itemStyle?: React__default.CSSProperties;
     disabledItemClassName: string;
-    disabledItemStyle?: React$1.CSSProperties;
-}) => React$1.ReactElement;
+    disabledItemStyle?: React__default.CSSProperties;
+}) => React__default.ReactElement;
 /**
  * Context menu configuration
  */
@@ -869,9 +1063,9 @@ interface ContextMenuConfig extends BaseExtensionConfig {
         itemDisabled?: string;
     };
     styles?: {
-        container?: React$1.CSSProperties;
-        item?: React$1.CSSProperties;
-        itemDisabled?: React$1.CSSProperties;
+        container?: React__default.CSSProperties;
+        item?: React__default.CSSProperties;
+        itemDisabled?: React__default.CSSProperties;
     };
 }
 /**
@@ -932,7 +1126,7 @@ declare class ContextMenuManager {
 /**
  * Context menu extension - provides a clean, registry-based context menu system
  */
-declare class ContextMenuExtension extends BaseExtension<"contextMenu", ContextMenuConfig, ContextMenuCommands, ContextMenuStateQueries, React$1.ReactElement[]> {
+declare class ContextMenuExtension extends BaseExtension<"contextMenu", ContextMenuConfig, ContextMenuCommands, ContextMenuStateQueries, React__default.ReactElement[]> {
     manager: ContextMenuManager | null;
     private pendingListeners;
     constructor(config?: ContextMenuConfig);
@@ -940,7 +1134,7 @@ declare class ContextMenuExtension extends BaseExtension<"contextMenu", ContextM
     register(editor: LexicalEditor): () => void;
     getCommands(editor: LexicalEditor): ContextMenuCommands;
     getStateQueries(editor: LexicalEditor): ContextMenuStateQueries;
-    getPlugins(): React$1.ReactElement[];
+    getPlugins(): React__default.ReactElement[];
     subscribe(listener: (menu: any) => void): () => void;
 }
 declare const contextMenuExtension: ContextMenuExtension;
@@ -960,8 +1154,21 @@ type TableConfig = BaseExtensionConfig & {
     contextMenuRenderer?: ContextMenuRenderer;
     /** Context menu extension used to register providers */
     contextMenuExtension?: typeof contextMenuExtension;
-    /** Markdown extension used to register transformers */
-    markdownExtension?: typeof markdownExtension;
+    /** 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.
@@ -976,6 +1183,10 @@ type TableCommands = {
     insertRowBelow: () => void;
     insertColumnLeft: () => void;
     insertColumnRight: () => void;
+    toggleRowHeader: () => void;
+    toggleColumnHeader: () => void;
+    mergeSelectedCells: () => void;
+    unmergeSelectedCell: () => void;
     deleteRow: () => void;
     deleteColumn: () => void;
     deleteTable: () => void;
@@ -1020,6 +1231,8 @@ type ListCommands = {
     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) */
@@ -1066,6 +1279,7 @@ type ListCommands = {
 declare class ListExtension extends BaseExtension<"list", any, ListCommands, {
     unorderedList: () => Promise<boolean>;
     orderedList: () => Promise<boolean>;
+    checkList: () => Promise<boolean>;
 }, ReactNode[]> {
     /**
      * Creates a new list extension instance.
@@ -1084,13 +1298,13 @@ declare class ListExtension extends BaseExtension<"list", any, ListCommands, {
      *
      * @returns Array containing ListNode and ListItemNode
      */
-    getNodes(): any[];
+    getNodes(): (typeof ListNode | typeof ListItemNode)[];
     /**
      * Returns React plugins needed for list functionality.
      *
      * @returns Array containing the ListPlugin component
      */
-    getPlugins(): React$1.ReactNode[];
+    getPlugins(): ReactNode[];
     /**
      * Returns command handlers exposed by this extension.
      *
@@ -1107,6 +1321,7 @@ declare class ListExtension extends BaseExtension<"list", any, ListCommands, {
     getStateQueries(editor: LexicalEditor): {
         unorderedList: () => Promise<boolean>;
         orderedList: () => Promise<boolean>;
+        checkList: () => Promise<boolean>;
     };
 }
 /**
@@ -1115,6 +1330,23 @@ declare class ListExtension extends BaseExtension<"list", any, ListCommands, {
  */
 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
  */
@@ -1129,6 +1361,10 @@ 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
  *
@@ -1151,7 +1387,8 @@ type CodeStateQueries = {
  * commands.toggleCodeBlock(); // Toggle code block on or off
  * ```
  */
-declare class CodeExtension extends BaseExtension<"code", {}, CodeCommands, CodeStateQueries, ReactNode[]> {
+declare class CodeExtension extends BaseExtension<"code", CodeExtensionConfig, CodeCommands, CodeStateQueries, ReactNode[]> {
+    private codeHighlightProviderPromise;
     constructor();
     /**
      * Register the extension with Lexical
@@ -1163,7 +1400,7 @@ declare class CodeExtension extends BaseExtension<"code", {}, CodeCommands, Code
      * Get Lexical nodes required by this extension
      * @returns Array of node classes
      */
-    getNodes(): (typeof CodeNode)[];
+    getNodes(): (typeof CodeNode | typeof CodeHighlightNode)[];
     /**
      * Get commands exposed by this extension
      * @param editor - Lexical editor instance
@@ -1175,6 +1412,8 @@ declare class CodeExtension extends BaseExtension<"code", {}, CodeCommands, Code
      * @param editor - Lexical editor instance
      */
     private toggleCodeBlock;
+    private resolveConfiguredTokenizer;
+    private loadCodeHighlightProvider;
     /**
      * Get state queries exposed by this extension
      * @param editor - Lexical editor instance
@@ -1208,6 +1447,48 @@ declare class CodeExtension extends BaseExtension<"code", {}, CodeCommands, Code
 }
 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
  *
@@ -1244,6 +1525,8 @@ type BlockFormatCommands = {
     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;
 };
@@ -1267,6 +1550,14 @@ type BlockFormatStateQueries = {
     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
@@ -1292,8 +1583,7 @@ type BlockFormatStateQueries = {
  * commands.toggleQuote(); // Convert selection to a quote block
  * ```
  */
-declare class BlockFormatExtension extends BaseExtension<"blockFormat", {}, // No extra config needed
-BlockFormatCommands, BlockFormatStateQueries> {
+declare class BlockFormatExtension extends BaseExtension<"blockFormat", Record<string, never>, BlockFormatCommands, BlockFormatStateQueries> {
     constructor();
     /**
      * Register the extension with Lexical
@@ -1312,6 +1602,12 @@ BlockFormatCommands, BlockFormatStateQueries> {
      * @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
@@ -1324,6 +1620,14 @@ BlockFormatCommands, BlockFormatStateQueries> {
     * @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
@@ -1453,12 +1757,8 @@ declare const historyExtension: HistoryExtension;
 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;
+    /** 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) */
@@ -1473,25 +1773,23 @@ interface DraggableConfig extends BaseExtensionConfig {
         handleActive?: string;
         blockDragging?: string;
         dropIndicator?: string;
-        upButton?: string;
-        downButton?: string;
+        addButton?: 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;
+        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$1.DragEvent) => void;
+        onDragStart: (e: React__default.DragEvent) => void;
         className: string;
     }) => ReactNode;
     /** Custom up/down button renderer */
@@ -1545,89 +1843,6 @@ declare class DraggableBlockExtension extends BaseExtension<"draggableBlock", Dr
  */
 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
  */
@@ -1663,6 +1878,8 @@ interface ImageComponentProps extends ImagePayload {
     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;
 }
@@ -1707,6 +1924,8 @@ interface ImageExtensionConfig extends BaseExtensionConfig {
     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 */
@@ -1729,6 +1948,8 @@ type ImageCommands = {
     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 */
@@ -1750,51 +1971,11 @@ type ImageStateQueries = {
     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;
+    /** 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;
@@ -1804,183 +1985,72 @@ declare class ImageExtension extends BaseExtension<"image", ImageExtensionConfig
 }
 declare const imageExtension: ImageExtension;
 
-/**
- * Payload for HTML embed content
- */
-type HTMLEmbedPayload = {
-    /** HTML content to embed */
-    html: string;
-    /** Whether to show preview or edit mode */
-    preview: boolean;
+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>;
 };
-/**
- * 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;
+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;
 }
-/**
- * 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;
+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>;
 };
-/**
- * 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>;
+type YouTubeEmbedQueries = {
+    isYouTubeEmbedSelected: () => Promise<boolean>;
+    isYouTubeEmbedAlignedLeft: () => Promise<boolean>;
+    isYouTubeEmbedAlignedCenter: () => Promise<boolean>;
+    isYouTubeEmbedAlignedRight: () => 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>);
+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): HTMLEmbedCommands;
-    getStateQueries(editor: LexicalEditor): HTMLEmbedQueries;
+    getCommands(editor: LexicalEditor): YouTubeEmbedCommands;
+    getStateQueries(editor: LexicalEditor): YouTubeEmbedQueries;
 }
-declare const htmlEmbedExtension: HTMLEmbedExtension;
+declare const youTubeEmbedExtension: YouTubeEmbedExtension;
 
 type CustomPayload = Record<string, any>;
 interface CustomNodeConfig<CustomCommands, CustomStateQueries> {
@@ -2042,15 +2112,15 @@ interface CustomNodeConfig<CustomCommands, CustomStateQueries> {
  * });
  * ```
  */
-declare function createCustomNodeExtension<Name extends string, Commands extends Record<string, any> = {}, StateQueries extends Record<string, () => Promise<boolean>> = {}>(userConfig: CustomNodeConfig<Commands, StateQueries>): {
+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$1.ReactElement;
-    placeholder?: React$1.ReactElement | string;
+    contentEditable?: React__default.ReactElement;
+    placeholder?: React__default.ReactElement | string;
     className?: string;
     classNames?: {
         container?: string;
@@ -2058,36 +2128,153 @@ interface BaseRichTextProps {
         placeholder?: string;
     };
     styles?: {
-        container?: React$1.CSSProperties;
-        contentEditable?: React$1.CSSProperties;
-        placeholder?: React$1.CSSProperties;
+        container?: React__default.CSSProperties;
+        contentEditable?: React__default.CSSProperties;
+        placeholder?: React__default.CSSProperties;
     };
-    errorBoundary?: React$1.ComponentType<{
-        children: React$1.JSX.Element;
+    errorBoundary?: React__default.ComponentType<{
+        children: React__default.JSX.Element;
         onError: (error: Error) => void;
     }>;
 }
-interface SharedRichTextProps extends BaseRichTextProps {
-}
-interface RichTextConfig extends BaseExtensionConfig, BaseRichTextProps {
-}
 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, {}, // No commands
-{}, // No state queries
-ReactNode[]> {
+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;
-interface RichTextComponentProps extends SharedRichTextProps {
+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 RichText: React$1.FC<RichTextComponentProps>;
+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.
@@ -2182,7 +2369,7 @@ interface FloatingConfig<TCommands = any, TStates = any> extends BaseExtensionCo
 /**
  * Commands exposed by the floating toolbar extension (none by default).
  */
-type FloatingCommands = {};
+type FloatingCommands = Record<string, never>;
 /**
  * State queries exposed by the floating toolbar extension.
  */
@@ -2221,7 +2408,7 @@ type CommandPaletteItem = {
     action: () => void;
     keywords?: string[];
     category?: string;
-    icon?: React$1.ReactNode;
+    icon?: React__default.ReactNode;
     shortcut?: string;
 };
 /**
@@ -2243,7 +2430,7 @@ type CommandPaletteStateQueries = {
  * 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[]> {
+declare class CommandPaletteExtension extends BaseExtension<"commandPalette", any, CommandPaletteCommands, CommandPaletteStateQueries, React__default.ReactElement[]> {
     private isOpen;
     private commands;
     private listeners;
@@ -2266,46 +2453,79 @@ declare class CommandPaletteExtension extends BaseExtension<"commandPalette", an
 }
 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;
+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;
     };
-    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";
-})[];
+    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 { 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 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 };