@domternal/core 0.2.1 → 0.4.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Node as Node$1, DOMOutputSpec, NodeType, NodeSpec, Mark as Mark$1, MarkType, MarkSpec, Schema, Attrs, DOMParser, ResolvedPos, ContentMatch } from '@domternal/pm/model';
+import { Schema, Node as Node$1, DOMOutputSpec, NodeType, Mark as Mark$1, MarkType, Attrs, DOMParser, ResolvedPos, ContentMatch, NodeSpec, MarkSpec } from '@domternal/pm/model';
 import { Transaction, EditorState, Plugin, PluginKey, Selection as Selection$1 } from '@domternal/pm/state';
 export { PluginKey } from '@domternal/pm/state';
 import { InputRule } from '@domternal/pm/inputrules';
@@ -175,6 +175,136 @@ interface EditorEvents {
  */
 type EditorEventName = keyof EditorEvents;
 
+/**
+ * Type-erased base for Extension, Node, and Mark.
+ *
+ * The Extension class has generic Options/Storage parameters, and methods
+ * like `configure(options: Partial<Options>)` that make Options contravariant.
+ * This means `Extension<MyOptions>` is not assignable to `Extension<unknown>`.
+ *
+ * AnyExtension uses an interface with only the properties that ExtensionManager
+ * and the editor need at runtime, avoiding the generic variance issue. Every
+ * Extension<O, S>, Node<O, S>, and Mark<O, S> structurally satisfies this
+ * interface regardless of their generic parameters.
+ */
+interface AnyExtension {
+    readonly type: 'extension' | 'node' | 'mark';
+    readonly name: string;
+    readonly options: unknown;
+    storage: unknown;
+    readonly config: unknown;
+    editor: unknown;
+    parent?: ((...args: unknown[]) => unknown) | undefined;
+}
+/**
+ * Autofocus options for the editor
+ * - true: Focus at the end
+ * - false: Don't autofocus
+ * - null: Explicitly no autofocus
+ * - 'start': Focus at the beginning
+ * - 'end': Focus at the end
+ * - 'all': Select all content
+ * - number: Focus at specific position
+ */
+type FocusPosition = boolean | 'start' | 'end' | 'all' | number | null;
+/**
+ * Configuration options for creating an Editor instance
+ */
+interface EditorOptions {
+    /**
+     * ProseMirror Schema for the editor
+     *
+     * Step 1.3: Required (no extensions system yet)
+     * Step 2+: Optional if extensions are provided (schema built from extensions)
+     *
+     * The schema must contain at least 'doc' and 'text' nodes.
+     */
+    schema?: Schema;
+    /**
+     * HTML element to mount the editor
+     * If not provided, creates a detached div (useful for testing/headless mode)
+     */
+    element?: HTMLElement | null;
+    /**
+     * Initial content (JSON or HTML string)
+     * @default null (empty document)
+     */
+    content?: Content;
+    /**
+     * Extensions to load
+     * @default []
+     */
+    extensions?: AnyExtension[];
+    /**
+     * Whether the editor is editable
+     * @default true
+     */
+    editable?: boolean;
+    /**
+     * Autofocus behavior on mount
+     * @default false
+     */
+    autofocus?: FocusPosition;
+    /**
+     * Transform function applied to clipboard HTML on copy/cut.
+     * Use with `inlineStyles` from core to auto-apply inline CSS on copy:
+     *
+     * @example
+     * ```ts
+     * import { inlineStyles } from '@domternal/core';
+     * new Editor({ clipboardHTMLTransform: inlineStyles });
+     * ```
+     */
+    clipboardHTMLTransform?: (html: string) => string;
+    /**
+     * Called before the editor is created
+     * Can be used to modify options
+     */
+    onBeforeCreate?: (props: CreateEventProps) => void;
+    /**
+     * Called when the editor is created and ready
+     */
+    onCreate?: (props: CreateEventProps) => void;
+    /**
+     * Called when editor view is mounted to DOM
+     */
+    onMount?: (props: MountEventProps) => void;
+    /**
+     * Called when the document content changes
+     */
+    onUpdate?: (props: TransactionEventProps) => void;
+    /**
+     * Called when selection changes (without content change)
+     */
+    onSelectionUpdate?: (props: TransactionEventProps) => void;
+    /**
+     * Called on every transaction
+     */
+    onTransaction?: (props: TransactionEventProps) => void;
+    /**
+     * Called when editor receives focus
+     */
+    onFocus?: (props: FocusEventProps) => void;
+    /**
+     * Called when editor loses focus
+     */
+    onBlur?: (props: FocusEventProps) => void;
+    /**
+     * Called before editor is destroyed
+     */
+    onDestroy?: () => void;
+    /**
+     * Called when content doesn't match schema (AD-8)
+     * Use this to handle content validation errors gracefully
+     */
+    onContentError?: (props: ContentErrorProps) => void;
+    /**
+     * Called when an extension throws an error (2.7: Extension Error Isolation)
+     * Allows graceful error handling without crashing the editor
+     */
+    onError?: (props: ErrorEventProps$1) => void;
+}
+
 /**
  * Editor instance type (forward declaration)
  */
@@ -739,226 +869,74 @@ interface ExtensionConfigBase<Options = unknown, Storage = unknown> {
 type ExtensionConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & ThisType<ExtensionContext<Options, Storage>>;
 
 /**
- * Extension - Base class for all extensions
- *
- * Extensions provide functionality without contributing to the schema.
- * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
+ * Attribute specification for Node and Mark extensions
  *
- * Three-tier model:
- * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
- * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
- * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ * Used by addAttributes() to define node/mark attributes
+ * with parsing, rendering, and validation rules.
  *
  * @example
- * const History = Extension.create({
- *   name: 'history',
- *   addOptions() {
- *     return { depth: 100 };
- *   },
- *   addKeyboardShortcuts() {
- *     return {
- *       'Mod-z': () => this.editor.commands.undo(),
- *       'Mod-Shift-z': () => this.editor.commands.redo(),
- *     };
- *   },
- * });
- */
-
-/**
- * Editor interface for Extension
- * Forward declaration to avoid circular dependency
+ * addAttributes() {
+ *   return {
+ *     level: {
+ *       default: 1,
+ *       parseHTML: (element) => parseInt(element.tagName.charAt(1), 10),
+ *       renderHTML: (attributes) => ({ 'data-level': attributes.level }),
+ *     },
+ *   };
+ * }
  */
-interface ExtensionEditorInterface {
-    readonly state: EditorState;
-    readonly view: EditorView;
-    readonly schema: unknown;
-    readonly commands: SingleCommands;
-}
 /**
- * Base class for all extensions
- *
- * @typeParam Options - Extension options type
- * @typeParam Storage - Extension storage type
+ * Specification for a single attribute
  */
-declare class Extension<Options = unknown, Storage = unknown> {
-    /**
-     * Extension type identifier
-     * Used to distinguish between Extension, Node, and Mark
-     * Subclasses override this to 'node' or 'mark'
-     */
-    readonly type: 'extension' | 'node' | 'mark';
-    /**
-     * Unique extension name
-     */
-    readonly name: string;
-    /**
-     * Extension options (immutable after creation)
-     */
-    readonly options: Options;
-    /**
-     * Extension storage (mutable state)
-     * Accessible via editor.storage[extensionName]
-     */
-    storage: Storage;
+interface AttributeSpec {
     /**
-     * The original configuration object
+     * Default value for the attribute
+     * Used when the attribute is not explicitly set
      */
-    readonly config: ExtensionConfig<Options, Storage>;
+    default?: unknown;
     /**
-     * Editor instance (set by ExtensionManager after creation)
-     * null until ExtensionManager binds it
+     * Whether this attribute is rendered to the DOM
+     * @default true
      */
-    editor: ExtensionEditorInterface | null;
+    rendered?: boolean;
     /**
-     * Reference to the parent config method when using extend().
-     * Set temporarily during config method execution so overridden
-     * methods can call `this.parent?.()` to invoke the original.
+     * Keep this attribute when splitting the node
+     * For example, heading level should be kept when pressing Enter
+     * @default true
      */
-    parent?: ((...args: unknown[]) => unknown) | undefined;
+    keepOnSplit?: boolean;
     /**
-     * Protected constructor - use Extension.create() instead
+     * Validate attribute value (ProseMirror 1.22.0+).
+     * When a string, a `|`-separated list of primitive types
+     * (`"number"`, `"string"`, `"boolean"`, `"null"`, `"undefined"`).
+     * When a function, it should throw if the value is invalid.
+     *
+     * @example
+     * validate: 'number'
+     * validate: 'string|null'
+     * validate: (value) => { if (typeof value !== 'number') throw new Error('expected number'); }
      */
-    protected constructor(config: ExtensionConfig<Options, Storage>);
+    validate?: string | ((value: unknown) => void);
     /**
-     * Creates a new extension instance
+     * Parse attribute value from HTML element
+     * Called during HTML parsing to extract attribute value
      *
-     * @param config - Extension configuration
-     * @returns New extension instance
+     * @param element - The HTML element being parsed
+     * @returns The attribute value
      *
      * @example
-     * const MyExtension = Extension.create({
-     *   name: 'myExtension',
-     *   addOptions() {
-     *     return { enabled: true };
-     *   },
-     * });
+     * parseHTML: (element) => element.getAttribute('data-level')
      */
-    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
+    parseHTML?: (element: HTMLElement) => unknown;
     /**
-     * Creates a new extension with merged options
-     * Original extension is not modified
-     *
-     * **Note:** Options are merged shallowly using object spread (`...`).
-     * Nested objects are replaced entirely, not deeply merged.
-     *
-     * @param options - Options to merge with existing options
-     * @returns New extension instance with merged options
+     * Render attribute to HTML attributes object
+     * Called during HTML serialization
      *
-     * @example
-     * const configured = MyExtension.configure({ enabled: false });
+     * @param attributes - All attributes of the node/mark
+     * @returns HTML attributes object or null to skip
      *
      * @example
-     * // Shallow merge behavior with nested objects:
-     * // Given: options = { nested: { a: 1, b: 2 } }
-     * // configure({ nested: { b: 3 } })
-     * // Result: { nested: { b: 3 } } — 'a' is lost!
-     * // To preserve nested values, spread manually:
-     * // configure({ nested: { ...original.options.nested, b: 3 } })
-     */
-    configure(options: Partial<Options>): Extension<Options, Storage>;
-    /**
-     * Creates a new extension with extended configuration
-     * Original extension is not modified
-     *
-     * **Note:** Config is merged shallowly using object spread (`...`).
-     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
-     * replaced entirely, not combined with the base extension's config.
-     *
-     * @param extendedConfig - Configuration to extend/override
-     * @returns New extension instance with extended config
-     *
-     * @example
-     * const Extended = MyExtension.extend({
-     *   name: 'extendedExtension',
-     *   addCommands() {
-     *     return { customCommand: () => ({ tr }) => true };
-     *   },
-     * });
-     *
-     * @example
-     * // To preserve base extension's commands while adding new ones:
-     * const Extended = BaseExtension.extend({
-     *   addCommands() {
-     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
-     *     return {
-     *       ...baseCommands,
-     *       newCommand: () => ({ tr }) => true,
-     *     };
-     *   },
-     * });
-     */
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
-}
-
-/**
- * Attribute specification for Node and Mark extensions
- *
- * Used by addAttributes() to define node/mark attributes
- * with parsing, rendering, and validation rules.
- *
- * @example
- * addAttributes() {
- *   return {
- *     level: {
- *       default: 1,
- *       parseHTML: (element) => parseInt(element.tagName.charAt(1), 10),
- *       renderHTML: (attributes) => ({ 'data-level': attributes.level }),
- *     },
- *   };
- * }
- */
-/**
- * Specification for a single attribute
- */
-interface AttributeSpec {
-    /**
-     * Default value for the attribute
-     * Used when the attribute is not explicitly set
-     */
-    default?: unknown;
-    /**
-     * Whether this attribute is rendered to the DOM
-     * @default true
-     */
-    rendered?: boolean;
-    /**
-     * Keep this attribute when splitting the node
-     * For example, heading level should be kept when pressing Enter
-     * @default true
-     */
-    keepOnSplit?: boolean;
-    /**
-     * Validate attribute value (ProseMirror 1.22.0+).
-     * When a string, a `|`-separated list of primitive types
-     * (`"number"`, `"string"`, `"boolean"`, `"null"`, `"undefined"`).
-     * When a function, it should throw if the value is invalid.
-     *
-     * @example
-     * validate: 'number'
-     * validate: 'string|null'
-     * validate: (value) => { if (typeof value !== 'number') throw new Error('expected number'); }
-     */
-    validate?: string | ((value: unknown) => void);
-    /**
-     * Parse attribute value from HTML element
-     * Called during HTML parsing to extract attribute value
-     *
-     * @param element - The HTML element being parsed
-     * @returns The attribute value
-     *
-     * @example
-     * parseHTML: (element) => element.getAttribute('data-level')
-     */
-    parseHTML?: (element: HTMLElement) => unknown;
-    /**
-     * Render attribute to HTML attributes object
-     * Called during HTML serialization
-     *
-     * @param attributes - All attributes of the node/mark
-     * @returns HTML attributes object or null to skip
-     *
-     * @example
-     * renderHTML: (attributes) => ({ 'data-level': attributes.level })
+     * renderHTML: (attributes) => ({ 'data-level': attributes.level })
      */
     renderHTML?: (attributes: Record<string, unknown>) => Record<string, string | number | boolean | null | undefined> | null;
 }
@@ -1226,157 +1204,6 @@ interface NodeSchemaProperties {
  */
 type NodeConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & NodeSchemaProperties & ThisType<NodeContext<Options, Storage>>;
 
-/**
- * Node - Base class for node extensions
- *
- * Nodes define document structure elements that contribute to the schema.
- * Examples: Paragraph, Heading, List, Image, etc.
- *
- * Three-tier model:
- * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
- * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
- * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
- *
- * @example
- * const Paragraph = Node.create({
- *   name: 'paragraph',
- *   group: 'block',
- *   content: 'inline*',
- *   parseHTML() {
- *     return [{ tag: 'p' }];
- *   },
- *   renderHTML({ HTMLAttributes }) {
- *     return ['p', HTMLAttributes, 0];
- *   },
- * });
- */
-
-/**
- * Extended editor interface for Node
- * Includes schema access for NodeType getter
- */
-interface NodeEditorInterface extends ExtensionEditorInterface {
-    readonly schema: {
-        nodes: Record<string, NodeType>;
-    };
-}
-/**
- * Base class for node extensions
- *
- * @typeParam Options - Node options type
- * @typeParam Storage - Node storage type
- */
-declare class Node<Options = unknown, Storage = unknown> extends Extension<Options, Storage> {
-    /**
-     * Node type identifier
-     * Distinguishes nodes from extensions and marks
-     */
-    readonly type: "node";
-    /**
-     * The original configuration object
-     * Typed as NodeConfig for node-specific properties
-     */
-    readonly config: NodeConfig<Options, Storage>;
-    /**
-     * Editor instance with schema access
-     * null until set by ExtensionManager
-     */
-    editor: NodeEditorInterface | null;
-    /**
-     * Protected constructor - use Node.create() instead
-     */
-    protected constructor(config: NodeConfig<Options, Storage>);
-    /**
-     * Get the ProseMirror NodeType from schema
-     *
-     * This is a lazy getter because schema doesn't exist at node creation time.
-     * Schema is built FROM nodes by ExtensionManager.
-     *
-     * Returns null if editor is not yet initialized.
-     * Always check editor is set before using nodeType.
-     */
-    get nodeType(): NodeType | null;
-    /**
-     * Get NodeType or throw if not initialized.
-     * Use in contexts where editor is guaranteed to be set (like addCommands).
-     */
-    get nodeTypeOrThrow(): NodeType;
-    /**
-     * Creates a new node instance
-     *
-     * @param config - Node configuration
-     * @returns New node instance
-     *
-     * @example
-     * const Paragraph = Node.create({
-     *   name: 'paragraph',
-     *   group: 'block',
-     *   content: 'inline*',
-     * });
-     */
-    static create<O = unknown, S = unknown>(config: NodeConfig<O, S>): Node<O, S>;
-    /**
-     * Creates a new node with merged options
-     * Original node is not modified
-     *
-     * **Note:** Options are merged shallowly using object spread (`...`).
-     * Nested objects are replaced entirely, not deeply merged.
-     *
-     * @param options - Options to merge with existing options
-     * @returns New node instance with merged options
-     *
-     * @example
-     * const CustomParagraph = Paragraph.configure({ HTMLAttributes: { class: 'custom' } });
-     *
-     * @example
-     * // Shallow merge behavior with nested objects:
-     * // Given: options = { HTMLAttributes: { class: 'a', id: 'b' } }
-     * // configure({ HTMLAttributes: { class: 'c' } })
-     * // Result: { HTMLAttributes: { class: 'c' } } — 'id' is lost!
-     * // To preserve nested values, spread manually:
-     * // configure({ HTMLAttributes: { ...original.options.HTMLAttributes, class: 'c' } })
-     */
-    configure(options: Partial<Options>): Node<Options, Storage>;
-    /**
-     * Creates a new node with extended configuration
-     * Original node is not modified
-     *
-     * **Note:** Config is merged shallowly using object spread (`...`).
-     * Config properties (like `addAttributes`, `parseHTML`) are
-     * replaced entirely, not combined with the base node's config.
-     *
-     * @param extendedConfig - Configuration to extend/override
-     * @returns New node instance with extended config
-     *
-     * @example
-     * const CustomParagraph = Paragraph.extend({
-     *   name: 'customParagraph',
-     *   addAttributes() {
-     *     return { ...this.parent?.(), align: { default: 'left' } };
-     *   },
-     * });
-     *
-     * @example
-     * // To preserve base node's parse rules while adding new ones:
-     * const Extended = BaseNode.extend({
-     *   parseHTML() {
-     *     const baseRules = BaseNode.config.parseHTML?.call(this) ?? [];
-     *     return [...baseRules, { tag: 'custom-tag' }];
-     *   },
-     * });
-     */
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<NodeConfig<ExtendedOptions, ExtendedStorage>> & ThisType<NodeContext<ExtendedOptions, ExtendedStorage>>): Node<ExtendedOptions, ExtendedStorage>;
-    /**
-     * Creates a ProseMirror NodeSpec from this node's configuration
-     *
-     * Called by ExtensionManager when building the schema.
-     * Converts our config format to ProseMirror's NodeSpec format.
-     *
-     * @returns ProseMirror NodeSpec
-     */
-    createNodeSpec(): NodeSpec;
-}
-
 /**
  * Mark configuration types
  *
@@ -1579,397 +1406,130 @@ interface MarkSchemaProperties {
 type MarkConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & MarkSchemaProperties & ThisType<MarkContext<Options, Storage>>;
 
 /**
- * Mark - Base class for mark extensions
- *
- * Marks define inline formatting that can be applied to text.
- * Examples: Bold, Italic, Link, Code, etc.
- *
- * Three-tier model:
- * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
- * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
- * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
- *
- * @example
- * const Bold = Mark.create({
- *   name: 'bold',
- *   parseHTML() {
- *     return [
- *       { tag: 'strong' },
- *       { tag: 'b' },
- *       { style: 'font-weight=bold' },
- *     ];
- *   },
- *   renderHTML({ HTMLAttributes }) {
- *     return ['strong', HTMLAttributes, 0];
- *   },
- * });
- */
-
-/**
- * Extended editor interface for Mark
- * Includes schema access for MarkType getter
+ * Callback type for event handlers
+ * - Events with payload: (data: T) => void
+ * - Events without payload (undefined): () => void
  */
-interface MarkEditorInterface extends ExtensionEditorInterface {
-    readonly schema: {
-        marks: Record<string, MarkType>;
-    };
-}
+type EventCallback<T> = T extends undefined ? () => void : (data: T) => void;
 /**
- * Base class for mark extensions
+ * Generic, type-safe event emitter
  *
- * @typeParam Options - Mark options type
- * @typeParam Storage - Mark storage type
+ * @example
+ * ```typescript
+ * interface MyEvents {
+ *   update: { value: number };
+ *   destroy: undefined;
+ * }
+ *
+ * const emitter = new EventEmitter<MyEvents>();
+ * emitter.on('update', ({ value }) => console.log(value));
+ * emitter.on('destroy', () => console.log('destroyed'));
+ * ```
  */
-declare class Mark<Options = unknown, Storage = unknown> extends Extension<Options, Storage> {
-    /**
-     * Mark type identifier
-     * Distinguishes marks from extensions and nodes
-     */
-    readonly type: "mark";
-    /**
-     * The original configuration object
-     * Typed as MarkConfig for mark-specific properties
-     */
-    readonly config: MarkConfig<Options, Storage>;
-    /**
-     * Editor instance with schema access
-     * null until set by ExtensionManager
-     */
-    editor: MarkEditorInterface | null;
-    /**
-     * Protected constructor - use Mark.create() instead
-     */
-    protected constructor(config: MarkConfig<Options, Storage>);
+declare class EventEmitter<Events extends {
+    [K in keyof Events]: unknown;
+} = Record<string, never>> {
+    protected callbacks: Map<keyof Events, Set<(data: unknown) => void>>;
     /**
-     * Whether this mark represents visual formatting.
-     * Returns false for semantic marks (links, comments) that should
-     * survive `unsetAllMarks`. Defaults to true.
+     * Register an event listener
      */
-    get isFormatting(): boolean;
+    on<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
     /**
-     * Get the ProseMirror MarkType from schema
-     *
-     * This is a lazy getter because schema doesn't exist at mark creation time.
-     * Schema is built FROM marks by ExtensionManager.
-     *
-     * Returns null if editor is not yet initialized.
-     * Always check editor is set before using markType.
+     * Remove an event listener, or all listeners for an event if no callback specified
      */
-    get markType(): MarkType | null;
+    off<E extends keyof Events>(event: E, callback?: EventCallback<Events[E]>): this;
     /**
-     * Get MarkType or throw if not initialized.
-     * Use in contexts where editor is guaranteed to be set (like addCommands).
+     * Emit an event to all registered listeners
+     * Uses .call(this) to preserve context for callbacks
      */
-    get markTypeOrThrow(): MarkType;
+    emit<E extends keyof Events>(event: E, ...args: Events[E] extends undefined ? [] : [Events[E]]): this;
     /**
-     * Creates a new mark instance
-     *
-     * @param config - Mark configuration
-     * @returns New mark instance
-     *
-     * @example
-     * const Bold = Mark.create({
-     *   name: 'bold',
-     *   parseHTML() {
-     *     return [{ tag: 'strong' }, { tag: 'b' }];
-     *   },
-     * });
+     * Register an event listener that fires only once
      */
-    static create<O = unknown, S = unknown>(config: MarkConfig<O, S>): Mark<O, S>;
+    once<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
     /**
-     * Creates a new mark with merged options
-     * Original mark is not modified
-     *
-     * **Note:** Options are merged shallowly using object spread (`...`).
-     * Nested objects are replaced entirely, not deeply merged.
-     *
-     * @param options - Options to merge with existing options
-     * @returns New mark instance with merged options
-     *
-     * @example
-     * const CustomBold = Bold.configure({ HTMLAttributes: { class: 'custom-bold' } });
-     *
-     * @example
-     * // Shallow merge behavior with nested objects:
-     * // Given: options = { HTMLAttributes: { class: 'a', id: 'b' } }
-     * // configure({ HTMLAttributes: { class: 'c' } })
-     * // Result: { HTMLAttributes: { class: 'c' } } — 'id' is lost!
-     * // To preserve nested values, spread manually:
-     * // configure({ HTMLAttributes: { ...original.options.HTMLAttributes, class: 'c' } })
+     * Remove all listeners for a specific event, or all events if no event specified
      */
-    configure(options: Partial<Options> & {
-        isFormatting?: boolean;
-    }): Mark<Options, Storage>;
+    removeAllListeners(event?: keyof Events): this;
     /**
-     * Creates a new mark with extended configuration
-     * Original mark is not modified
-     *
-     * **Note:** Config is merged shallowly using object spread (`...`).
-     * Config properties (like `addAttributes`, `parseHTML`) are
-     * replaced entirely, not combined with the base mark's config.
-     *
-     * @param extendedConfig - Configuration to extend/override
-     * @returns New mark instance with extended config
-     *
-     * @example
-     * const CustomBold = Bold.extend({
-     *   name: 'customBold',
-     *   addAttributes() {
-     *     return { ...this.parent?.(), weight: { default: 'bold' } };
-     *   },
-     * });
-     *
-     * @example
-     * // To preserve base mark's parse rules while adding new ones:
-     * const Extended = BaseMark.extend({
-     *   parseHTML() {
-     *     const baseRules = BaseMark.config.parseHTML?.call(this) ?? [];
-     *     return [...baseRules, { tag: 'custom-tag' }];
-     *   },
-     * });
+     * Get the number of listeners for a specific event
      */
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<MarkConfig<ExtendedOptions, ExtendedStorage>> & ThisType<MarkContext<ExtendedOptions, ExtendedStorage>>): Mark<ExtendedOptions, ExtendedStorage>;
+    listenerCount(event: keyof Events): number;
     /**
-     * Creates a ProseMirror MarkSpec from this mark's configuration
-     *
-     * Called by ExtensionManager when building the schema.
-     * Converts our config format to ProseMirror's MarkSpec format.
-     *
-     * @returns ProseMirror MarkSpec
+     * Get all event names that have listeners
      */
-    createMarkSpec(): MarkSpec;
+    eventNames(): (keyof Events)[];
 }
 
 /**
- * Union type for all extension types
- * - Extension: Pure functionality (History, Placeholder)
- * - Node: Schema nodes (Paragraph, Heading)
- * - Mark: Schema marks (Bold, Italic)
+ * ExtensionManager - Manages extensions and schema
+ *
+ * Handles:
+ * - Extension lifecycle (flatten, resolve, bind)
+ * - Schema building from Node/Mark extensions
+ * - Plugin collection from all extensions
+ * - Extension storage management
+ * - Conflict detection (AD-7)
  */
-type AnyExtension = Extension | Node | Mark;
+
 /**
- * Autofocus options for the editor
- * - true: Focus at the end
- * - false: Don't autofocus
- * - null: Explicitly no autofocus
- * - 'start': Focus at the beginning
- * - 'end': Focus at the end
- * - 'all': Select all content
- * - number: Focus at specific position
+ * Error event props for safeCall
  */
-type FocusPosition = boolean | 'start' | 'end' | 'all' | number | null;
+interface ErrorEventProps {
+    error: Error;
+    context: string;
+}
 /**
- * Configuration options for creating an Editor instance
+ * Editor interface for ExtensionManager
+ * Forward declaration to avoid circular dependency
  */
-interface EditorOptions {
+interface ExtensionManagerEditor {
+    readonly schema: Schema;
+    emit?(event: 'error', props: ErrorEventProps): void;
+}
+/**
+ * Context attached to node view constructors for framework wrappers.
+ * Accessible via `(constructor as any).__domternalContext`.
+ */
+interface NodeViewContext {
+    editor: ExtensionManagerEditor;
+    extension: {
+        name: string;
+        options: Record<string, unknown>;
+    };
+}
+/**
+ * Options for ExtensionManager constructor
+ */
+interface ExtensionManagerOptions {
     /**
-     * ProseMirror Schema for the editor
-     *
-     * Step 1.3: Required (no extensions system yet)
-     * Step 2+: Optional if extensions are provided (schema built from extensions)
-     *
-     * The schema must contain at least 'doc' and 'text' nodes.
+     * Extensions to process
+     * If provided, schema is built from extensions
      */
-    schema?: Schema;
+    extensions?: AnyExtension[] | undefined;
     /**
-     * HTML element to mount the editor
-     * If not provided, creates a detached div (useful for testing/headless mode)
+     * Direct schema (backward compatibility with Step 1.3)
+     * If provided, extensions are ignored for schema building
      */
-    element?: HTMLElement | null;
+    schema?: Schema | undefined;
+}
+declare class ExtensionManager {
     /**
-     * Initial content (JSON or HTML string)
-     * @default null (empty document)
+     * Processed extensions (flattened, sorted by priority)
      */
-    content?: Content;
+    private readonly _extensions;
     /**
-     * Extensions to load
-     * @default []
+     * ProseMirror schema (built from extensions or passed directly)
      */
-    extensions?: AnyExtension[];
+    private readonly _schema;
     /**
-     * Whether the editor is editable
-     * @default true
+     * Reference to the editor instance
      */
-    editable?: boolean;
+    readonly editor: ExtensionManagerEditor;
     /**
-     * Autofocus behavior on mount
-     * @default false
+     * Extension storage (keyed by extension name)
      */
-    autofocus?: FocusPosition;
-    /**
-     * Transform function applied to clipboard HTML on copy/cut.
-     * Use with `inlineStyles` from core to auto-apply inline CSS on copy:
-     *
-     * @example
-     * ```ts
-     * import { inlineStyles } from '@domternal/core';
-     * new Editor({ clipboardHTMLTransform: inlineStyles });
-     * ```
-     */
-    clipboardHTMLTransform?: (html: string) => string;
-    /**
-     * Called before the editor is created
-     * Can be used to modify options
-     */
-    onBeforeCreate?: (props: CreateEventProps) => void;
-    /**
-     * Called when the editor is created and ready
-     */
-    onCreate?: (props: CreateEventProps) => void;
-    /**
-     * Called when editor view is mounted to DOM
-     */
-    onMount?: (props: MountEventProps) => void;
-    /**
-     * Called when the document content changes
-     */
-    onUpdate?: (props: TransactionEventProps) => void;
-    /**
-     * Called when selection changes (without content change)
-     */
-    onSelectionUpdate?: (props: TransactionEventProps) => void;
-    /**
-     * Called on every transaction
-     */
-    onTransaction?: (props: TransactionEventProps) => void;
-    /**
-     * Called when editor receives focus
-     */
-    onFocus?: (props: FocusEventProps) => void;
-    /**
-     * Called when editor loses focus
-     */
-    onBlur?: (props: FocusEventProps) => void;
-    /**
-     * Called before editor is destroyed
-     */
-    onDestroy?: () => void;
-    /**
-     * Called when content doesn't match schema (AD-8)
-     * Use this to handle content validation errors gracefully
-     */
-    onContentError?: (props: ContentErrorProps) => void;
-    /**
-     * Called when an extension throws an error (2.7: Extension Error Isolation)
-     * Allows graceful error handling without crashing the editor
-     */
-    onError?: (props: ErrorEventProps$1) => void;
-}
-
-/**
- * Callback type for event handlers
- * - Events with payload: (data: T) => void
- * - Events without payload (undefined): () => void
- */
-type EventCallback<T> = T extends undefined ? () => void : (data: T) => void;
-/**
- * Generic, type-safe event emitter
- *
- * @example
- * ```typescript
- * interface MyEvents {
- *   update: { value: number };
- *   destroy: undefined;
- * }
- *
- * const emitter = new EventEmitter<MyEvents>();
- * emitter.on('update', ({ value }) => console.log(value));
- * emitter.on('destroy', () => console.log('destroyed'));
- * ```
- */
-declare class EventEmitter<Events extends {
-    [K in keyof Events]: unknown;
-} = Record<string, never>> {
-    protected callbacks: Map<keyof Events, Set<(data: unknown) => void>>;
-    /**
-     * Register an event listener
-     */
-    on<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
-    /**
-     * Remove an event listener, or all listeners for an event if no callback specified
-     */
-    off<E extends keyof Events>(event: E, callback?: EventCallback<Events[E]>): this;
-    /**
-     * Emit an event to all registered listeners
-     * Uses .call(this) to preserve context for callbacks
-     */
-    emit<E extends keyof Events>(event: E, ...args: Events[E] extends undefined ? [] : [Events[E]]): this;
-    /**
-     * Register an event listener that fires only once
-     */
-    once<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
-    /**
-     * Remove all listeners for a specific event, or all events if no event specified
-     */
-    removeAllListeners(event?: keyof Events): this;
-    /**
-     * Get the number of listeners for a specific event
-     */
-    listenerCount(event: keyof Events): number;
-    /**
-     * Get all event names that have listeners
-     */
-    eventNames(): (keyof Events)[];
-}
-
-/**
- * ExtensionManager - Manages extensions and schema
- *
- * Handles:
- * - Extension lifecycle (flatten, resolve, bind)
- * - Schema building from Node/Mark extensions
- * - Plugin collection from all extensions
- * - Extension storage management
- * - Conflict detection (AD-7)
- */
-
-/**
- * Error event props for safeCall
- */
-interface ErrorEventProps {
-    error: Error;
-    context: string;
-}
-/**
- * Editor interface for ExtensionManager
- * Forward declaration to avoid circular dependency
- */
-interface ExtensionManagerEditor {
-    readonly schema: Schema;
-    emit?(event: 'error', props: ErrorEventProps): void;
-}
-/**
- * Options for ExtensionManager constructor
- */
-interface ExtensionManagerOptions {
-    /**
-     * Extensions to process
-     * If provided, schema is built from extensions
-     */
-    extensions?: AnyExtension[] | undefined;
-    /**
-     * Direct schema (backward compatibility with Step 1.3)
-     * If provided, extensions are ignored for schema building
-     */
-    schema?: Schema | undefined;
-}
-declare class ExtensionManager {
-    /**
-     * Processed extensions (flattened, sorted by priority)
-     */
-    private readonly _extensions;
-    /**
-     * ProseMirror schema (built from extensions or passed directly)
-     */
-    private readonly _schema;
-    /**
-     * Reference to the editor instance
-     */
-    readonly editor: ExtensionManagerEditor;
-    /**
-     * Extension storage (keyed by extension name)
-     */
-    private readonly _storage;
+    private readonly _storage;
     /**
      * Whether the manager has been destroyed
      */
@@ -2110,8 +1670,12 @@ declare class ExtensionManager {
      */
     private collectToolbarItems;
     /**
-     * Collects node views from all Node extensions
-     * Returns a map of node name → NodeViewConstructor for EditorView
+     * Collects node views from all Node extensions.
+     * Returns a map of node name to NodeViewConstructor for EditorView.
+     *
+     * Each constructor is annotated with `__domternalContext` containing
+     * the editor and extension metadata so framework wrappers (React, Vue)
+     * can access them without changing the ProseMirror calling convention.
      */
     private collectNodeViews;
     /**
@@ -3068,6 +2632,11 @@ interface MarkInputRuleOptions {
      * The mark type to apply
      */
     type: MarkType;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
     /**
      * Optional: get attributes from the match
      *
@@ -3127,67 +2696,238 @@ declare const markInputRulePatterns: {
 };
 
 /**
- * URL Validation Helper
+ * Wrapping Input Rule Helper
  *
- * Provides a utility for validating URLs.
+ * Drop-in replacement for ProseMirror's wrappingInputRule that exposes
+ * the `undoable` option so extension authors can opt out of Backspace undo.
  */
-/**
- * Options for URL validation
- */
-interface IsValidUrlOptions {
+
+interface WrappingInputRuleOptions {
     /**
-     * List of allowed URL protocols
-     * @default ['http:', 'https:']
+     * The regex pattern to match. Should start with `^` so it only
+     * fires at the start of a textblock.
      */
-    protocols?: string[];
+    find: RegExp;
+    /**
+     * The node type to wrap in.
+     */
+    type: NodeType;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+    /**
+     * Node attributes, or a function that computes them from the match.
+     */
+    getAttributes?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    /**
+     * Predicate that decides whether to join with an adjacent node of
+     * the same type above the newly wrapped node.
+     */
+    joinPredicate?: (match: RegExpMatchArray, node: Node$1) => boolean;
+    /**
+     * Optional guard predicate. When provided, the rule only fires if
+     * this returns true. Use this to prevent wrapping in certain contexts
+     * (e.g. don't create a nested list inside an existing list item).
+     */
+    guard?: (state: EditorState) => boolean;
 }
 /**
- * Checks if a string is a valid URL
+ * Creates an input rule that wraps a textblock in a given node type.
  *
- * @param url - The string to validate
- * @param options - Validation options
- * @returns True if the string is a valid URL with an allowed protocol
+ * @example
+ * // `> ` at start of line wraps in blockquote
+ * wrappingInputRule({
+ *   find: /^\s*>\s$/,
+ *   type: schema.nodes.blockquote,
+ * });
  *
  * @example
- * ```ts
- * isValidUrl('https://example.com'); // true
- * isValidUrl('javascript:alert(1)'); // false (protocol not allowed)
- * isValidUrl('not a url'); // false
- * ```
+ * // Non-undoable wrapping rule
+ * wrappingInputRule({
+ *   find: /^\s*>\s$/,
+ *   type: schema.nodes.blockquote,
+ *   undoable: false,
+ * });
  */
-declare function isValidUrl(url: string, options?: IsValidUrlOptions): boolean;
+declare function wrappingInputRule(options: WrappingInputRuleOptions): InputRule;
 
-interface GenerateHTMLOptions {
+/**
+ * Textblock Type Input Rule Helper
+ *
+ * Drop-in replacement for ProseMirror's textblockTypeInputRule that exposes
+ * the `undoable` option so extension authors can opt out of Backspace undo.
+ */
+
+interface TextblockTypeInputRuleOptions {
     /**
-     * Custom document implementation. If not provided, uses native document
-     * in browser or linkedom in Node.js.
+     * The regex pattern to match. Should start with `^` so it only
+     * fires at the start of a textblock.
      */
-    document?: Document;
+    find: RegExp;
+    /**
+     * The node type to change the textblock to.
+     */
+    type: NodeType;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+    /**
+     * Node attributes, or a function that computes them from the match.
+     */
+    getAttributes?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
 }
 /**
- * Generate HTML string from JSON content.
- *
- * @param content - The JSON content to convert
- * @param extensions - Extensions that define the schema
- * @param options - Optional configuration
- * @returns HTML string
+ * Creates an input rule that changes the type of a textblock.
  *
  * @example
- * ```ts
- * const html = generateHTML(
- *   { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Hello' }] }] },
- *   [Document, Paragraph, Text]
- * );
- * // Returns: '<p>Hello</p>'
- * ```
+ * // `## ` at start of line converts to heading level 2
+ * textblockTypeInputRule({
+ *   find: /^(#{1,4})\s$/,
+ *   type: schema.nodes.heading,
+ *   getAttributes: (match) => ({ level: match[1].length }),
+ * });
  */
-declare function generateHTML(content: JSONContent, extensions: AnyExtension[], options?: GenerateHTMLOptions): string;
-interface GenerateJSONOptions {
+declare function textblockTypeInputRule(options: TextblockTypeInputRuleOptions): InputRule;
+
+/**
+ * Text Input Rule Helper
+ *
+ * Creates input rules for simple text replacements (e.g. `--` to em dash).
+ */
+
+interface TextInputRuleOptions {
     /**
-     * Custom document implementation. If not provided, uses native document
-     * in browser or linkedom in Node.js.
+     * The regex pattern to match.
      */
-    document?: Document;
+    find: RegExp;
+    /**
+     * The replacement text.
+     */
+    replace: string;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+}
+/**
+ * Creates an input rule that replaces matched text with a string.
+ *
+ * @example
+ * // `--` converts to em dash
+ * textInputRule({ find: /--$/, replace: '\u2014' });
+ *
+ * @example
+ * // Non-undoable replacement
+ * textInputRule({ find: /->$/, replace: '\u2192', undoable: false });
+ */
+declare function textInputRule(options: TextInputRuleOptions): InputRule;
+
+/**
+ * Node Input Rule Helper
+ *
+ * Creates input rules that replace matched text with a node.
+ * Used for nodes like HorizontalRule, Image, Emoji, etc.
+ */
+
+interface NodeInputRuleOptions {
+    /**
+     * The regex pattern to match.
+     */
+    find: RegExp;
+    /**
+     * The node type to insert.
+     */
+    type: NodeType;
+    /**
+     * Whether Backspace can undo this input rule immediately after it fires.
+     * @default true
+     */
+    undoable?: boolean;
+    /**
+     * Node attributes, or a function that computes them from the match.
+     */
+    getAttributes?: Attrs | null | ((match: RegExpMatchArray, state: EditorState) => Attrs | null);
+}
+/**
+ * Creates an input rule that replaces matched text with a node.
+ *
+ * @example
+ * // `:smile:` inserts an emoji node
+ * nodeInputRule({
+ *   find: /:([a-zA-Z0-9_+-]+):$/,
+ *   type: schema.nodes.emoji,
+ *   getAttributes: (match) => ({ name: match[1] }),
+ * });
+ */
+declare function nodeInputRule(options: NodeInputRuleOptions): InputRule;
+
+/**
+ * URL Validation Helper
+ *
+ * Provides a utility for validating URLs.
+ */
+/**
+ * Options for URL validation
+ */
+interface IsValidUrlOptions {
+    /**
+     * List of allowed URL protocols
+     * @default ['http:', 'https:']
+     */
+    protocols?: string[];
+}
+/**
+ * Checks if a string is a valid URL
+ *
+ * @param url - The string to validate
+ * @param options - Validation options
+ * @returns True if the string is a valid URL with an allowed protocol
+ *
+ * @example
+ * ```ts
+ * isValidUrl('https://example.com'); // true
+ * isValidUrl('javascript:alert(1)'); // false (protocol not allowed)
+ * isValidUrl('not a url'); // false
+ * ```
+ */
+declare function isValidUrl(url: string, options?: IsValidUrlOptions): boolean;
+
+interface GenerateHTMLOptions {
+    /**
+     * Custom document implementation. If not provided, uses native document
+     * in browser or linkedom in Node.js.
+     */
+    document?: Document;
+}
+/**
+ * Generate HTML string from JSON content.
+ *
+ * @param content - The JSON content to convert
+ * @param extensions - Extensions that define the schema
+ * @param options - Optional configuration
+ * @returns HTML string
+ *
+ * @example
+ * ```ts
+ * const html = generateHTML(
+ *   { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Hello' }] }] },
+ *   [Document, Paragraph, Text]
+ * );
+ * // Returns: '<p>Hello</p>'
+ * ```
+ */
+declare function generateHTML(content: JSONContent, extensions: AnyExtension[], options?: GenerateHTMLOptions): string;
+interface GenerateJSONOptions {
+    /**
+     * Custom document implementation. If not provided, uses native document
+     * in browser or linkedom in Node.js.
+     */
+    document?: Document;
 }
 /**
  * Generate JSON content from HTML string.
@@ -3212,94 +2952,397 @@ interface GenerateTextOptions {
      * Separator between block elements.
      * @default '\n\n'
      */
-    blockSeparator?: string;
-}
-/**
- * Generate plain text from JSON content.
- *
- * @param content - The JSON content to extract text from
- * @param extensions - Extensions that define the schema
- * @param options - Optional configuration
- * @returns Plain text string
- *
- * @example
- * ```ts
- * const text = generateText(
- *   { type: 'doc', content: [
- *     { type: 'paragraph', content: [{ type: 'text', text: 'Hello' }] },
- *     { type: 'paragraph', content: [{ type: 'text', text: 'World' }] }
- *   ]},
- *   [Document, Paragraph, Text]
- * );
- * // Returns: 'Hello\n\nWorld'
- * ```
- */
-declare function generateText(content: JSONContent, extensions: AnyExtension[], options?: GenerateTextOptions): string;
-
-/**
- * Get the range of a mark at a resolved position.
- *
- * Walks backward and forward from the position to find contiguous
- * text nodes that share the same mark type, returning the full range.
- */
-
-interface MarkRange {
-    from: number;
-    to: number;
-}
-/**
- * Returns the contiguous range of a mark around the given resolved position.
- * Returns undefined if the mark is not present at the position.
- */
-declare function getMarkRange($pos: ResolvedPos, type: MarkType): MarkRange | undefined;
-
-/**
- * Find the closest parent node matching a predicate
- *
- * Returns a curried function: findParentNode(predicate)(selection)
- *
- * @example
- * const details = findParentNode(node => node.type.name === 'details')(selection);
- * if (details) {
- *   console.log(details.pos, details.node);
- * }
- */
-
-interface FindParentNodeResult {
-    pos: number;
-    start: number;
-    depth: number;
-    node: Node$1;
-}
-declare const findParentNode: (predicate: (node: Node$1) => boolean) => (selection: Selection$1) => FindParentNodeResult | undefined;
-
-/**
- * Find all children of a node matching a predicate
- *
- * @example
- * const summaries = findChildren(detailsNode, node => node.type.name === 'detailsSummary');
- */
-
-interface FindChildResult {
-    node: Node$1;
-    pos: number;
+    blockSeparator?: string;
+}
+/**
+ * Generate plain text from JSON content.
+ *
+ * @param content - The JSON content to extract text from
+ * @param extensions - Extensions that define the schema
+ * @param options - Optional configuration
+ * @returns Plain text string
+ *
+ * @example
+ * ```ts
+ * const text = generateText(
+ *   { type: 'doc', content: [
+ *     { type: 'paragraph', content: [{ type: 'text', text: 'Hello' }] },
+ *     { type: 'paragraph', content: [{ type: 'text', text: 'World' }] }
+ *   ]},
+ *   [Document, Paragraph, Text]
+ * );
+ * // Returns: 'Hello\n\nWorld'
+ * ```
+ */
+declare function generateText(content: JSONContent, extensions: AnyExtension[], options?: GenerateTextOptions): string;
+
+/**
+ * Get the range of a mark at a resolved position.
+ *
+ * Walks backward and forward from the position to find contiguous
+ * text nodes that share the same mark type, returning the full range.
+ */
+
+interface MarkRange {
+    from: number;
+    to: number;
+}
+/**
+ * Returns the contiguous range of a mark around the given resolved position.
+ * Returns undefined if the mark is not present at the position.
+ */
+declare function getMarkRange($pos: ResolvedPos, type: MarkType): MarkRange | undefined;
+
+/**
+ * Find the closest parent node matching a predicate
+ *
+ * Returns a curried function: findParentNode(predicate)(selection)
+ *
+ * @example
+ * const details = findParentNode(node => node.type.name === 'details')(selection);
+ * if (details) {
+ *   console.log(details.pos, details.node);
+ * }
+ */
+
+interface FindParentNodeResult {
+    pos: number;
+    start: number;
+    depth: number;
+    node: Node$1;
+}
+declare const findParentNode: (predicate: (node: Node$1) => boolean) => (selection: Selection$1) => FindParentNodeResult | undefined;
+
+/**
+ * Find all children of a node matching a predicate
+ *
+ * @example
+ * const summaries = findChildren(detailsNode, node => node.type.name === 'detailsSummary');
+ */
+
+interface FindChildResult {
+    node: Node$1;
+    pos: number;
+}
+declare const findChildren: (node: Node$1, predicate: (node: Node$1) => boolean) => FindChildResult[];
+
+/**
+ * Get the default block type at a given content match position
+ *
+ * Finds the first textblock type that can be created without required attributes.
+ * Useful for creating new empty blocks (e.g., paragraph after details).
+ *
+ * @example
+ * const type = defaultBlockAt(parent.contentMatchAt(index));
+ * if (type) {
+ *   const node = type.createAndFill();
+ * }
+ */
+
+declare const defaultBlockAt: (match: ContentMatch) => NodeType | null;
+
+/**
+ * Extension - Base class for all extensions
+ *
+ * Extensions provide functionality without contributing to the schema.
+ * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const History = Extension.create({
+ *   name: 'history',
+ *   addOptions() {
+ *     return { depth: 100 };
+ *   },
+ *   addKeyboardShortcuts() {
+ *     return {
+ *       'Mod-z': () => this.editor.commands.undo(),
+ *       'Mod-Shift-z': () => this.editor.commands.redo(),
+ *     };
+ *   },
+ * });
+ */
+
+/**
+ * Editor interface for Extension
+ * Forward declaration to avoid circular dependency
+ */
+interface ExtensionEditorInterface {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: unknown;
+    readonly commands: SingleCommands;
+}
+/**
+ * Base class for all extensions
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+declare class Extension<Options = unknown, Storage = unknown> {
+    /**
+     * Extension type identifier
+     * Used to distinguish between Extension, Node, and Mark
+     * Subclasses override this to 'node' or 'mark'
+     */
+    readonly type: 'extension' | 'node' | 'mark';
+    /**
+     * Unique extension name
+     */
+    readonly name: string;
+    /**
+     * Extension options (immutable after creation)
+     */
+    readonly options: Options;
+    /**
+     * Extension storage (mutable state)
+     * Accessible via editor.storage[extensionName]
+     */
+    storage: Storage;
+    /**
+     * The original configuration object
+     */
+    readonly config: ExtensionConfig<Options, Storage>;
+    /**
+     * Editor instance (set by ExtensionManager after creation)
+     * null until ExtensionManager binds it
+     */
+    editor: ExtensionEditorInterface | null;
+    /**
+     * Reference to the parent config method when using extend().
+     * Set temporarily during config method execution so overridden
+     * methods can call `this.parent?.()` to invoke the original.
+     */
+    parent?: ((...args: unknown[]) => unknown) | undefined;
+    /**
+     * Protected constructor - use Extension.create() instead
+     */
+    protected constructor(config: ExtensionConfig<Options, Storage>);
+    /**
+     * Creates a new extension instance
+     *
+     * @param config - Extension configuration
+     * @returns New extension instance
+     *
+     * @example
+     * const MyExtension = Extension.create({
+     *   name: 'myExtension',
+     *   addOptions() {
+     *     return { enabled: true };
+     *   },
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
+    /**
+     * Creates a new extension with merged options
+     * Original extension is not modified
+     *
+     * **Note:** Options are merged shallowly using object spread (`...`).
+     * Nested objects are replaced entirely, not deeply merged.
+     *
+     * @param options - Options to merge with existing options
+     * @returns New extension instance with merged options
+     *
+     * @example
+     * const configured = MyExtension.configure({ enabled: false });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { nested: { a: 1, b: 2 } }
+     * // configure({ nested: { b: 3 } })
+     * // Result: { nested: { b: 3 } } — 'a' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ nested: { ...original.options.nested, b: 3 } })
+     */
+    configure(options: Partial<Options>): Extension<Options, Storage>;
+    /**
+     * Creates a new extension with extended configuration
+     * Original extension is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
+     * replaced entirely, not combined with the base extension's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New extension instance with extended config
+     *
+     * @example
+     * const Extended = MyExtension.extend({
+     *   name: 'extendedExtension',
+     *   addCommands() {
+     *     return { customCommand: () => ({ tr }) => true };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base extension's commands while adding new ones:
+     * const Extended = BaseExtension.extend({
+     *   addCommands() {
+     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
+     *     return {
+     *       ...baseCommands,
+     *       newCommand: () => ({ tr }) => true,
+     *     };
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
+}
+
+/**
+ * Node - Base class for node extensions
+ *
+ * Nodes define document structure elements that contribute to the schema.
+ * Examples: Paragraph, Heading, List, Image, etc.
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const Paragraph = Node.create({
+ *   name: 'paragraph',
+ *   group: 'block',
+ *   content: 'inline*',
+ *   parseHTML() {
+ *     return [{ tag: 'p' }];
+ *   },
+ *   renderHTML({ HTMLAttributes }) {
+ *     return ['p', HTMLAttributes, 0];
+ *   },
+ * });
+ */
+
+/**
+ * Extended editor interface for Node
+ * Includes schema access for NodeType getter
+ */
+interface NodeEditorInterface extends ExtensionEditorInterface {
+    readonly schema: {
+        nodes: Record<string, NodeType>;
+    };
+}
+/**
+ * Base class for node extensions
+ *
+ * @typeParam Options - Node options type
+ * @typeParam Storage - Node storage type
+ */
+declare class Node<Options = unknown, Storage = unknown> extends Extension<Options, Storage> {
+    /**
+     * Node type identifier
+     * Distinguishes nodes from extensions and marks
+     */
+    readonly type: "node";
+    /**
+     * The original configuration object
+     * Typed as NodeConfig for node-specific properties
+     */
+    readonly config: NodeConfig<Options, Storage>;
+    /**
+     * Editor instance with schema access
+     * null until set by ExtensionManager
+     */
+    editor: NodeEditorInterface | null;
+    /**
+     * Protected constructor - use Node.create() instead
+     */
+    protected constructor(config: NodeConfig<Options, Storage>);
+    /**
+     * Get the ProseMirror NodeType from schema
+     *
+     * This is a lazy getter because schema doesn't exist at node creation time.
+     * Schema is built FROM nodes by ExtensionManager.
+     *
+     * Returns null if editor is not yet initialized.
+     * Always check editor is set before using nodeType.
+     */
+    get nodeType(): NodeType | null;
+    /**
+     * Get NodeType or throw if not initialized.
+     * Use in contexts where editor is guaranteed to be set (like addCommands).
+     */
+    get nodeTypeOrThrow(): NodeType;
+    /**
+     * Creates a new node instance
+     *
+     * @param config - Node configuration
+     * @returns New node instance
+     *
+     * @example
+     * const Paragraph = Node.create({
+     *   name: 'paragraph',
+     *   group: 'block',
+     *   content: 'inline*',
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: NodeConfig<O, S>): Node<O, S>;
+    /**
+     * Creates a new node with merged options
+     * Original node is not modified
+     *
+     * **Note:** Options are merged shallowly using object spread (`...`).
+     * Nested objects are replaced entirely, not deeply merged.
+     *
+     * @param options - Options to merge with existing options
+     * @returns New node instance with merged options
+     *
+     * @example
+     * const CustomParagraph = Paragraph.configure({ HTMLAttributes: { class: 'custom' } });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { HTMLAttributes: { class: 'a', id: 'b' } }
+     * // configure({ HTMLAttributes: { class: 'c' } })
+     * // Result: { HTMLAttributes: { class: 'c' } } — 'id' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ HTMLAttributes: { ...original.options.HTMLAttributes, class: 'c' } })
+     */
+    configure(options: Partial<Options>): Node<Options, Storage>;
+    /**
+     * Creates a new node with extended configuration
+     * Original node is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addAttributes`, `parseHTML`) are
+     * replaced entirely, not combined with the base node's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New node instance with extended config
+     *
+     * @example
+     * const CustomParagraph = Paragraph.extend({
+     *   name: 'customParagraph',
+     *   addAttributes() {
+     *     return { ...this.parent?.(), align: { default: 'left' } };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base node's parse rules while adding new ones:
+     * const Extended = BaseNode.extend({
+     *   parseHTML() {
+     *     const baseRules = BaseNode.config.parseHTML?.call(this) ?? [];
+     *     return [...baseRules, { tag: 'custom-tag' }];
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<NodeConfig<ExtendedOptions, ExtendedStorage>> & ThisType<NodeContext<ExtendedOptions, ExtendedStorage>>): Node<ExtendedOptions, ExtendedStorage>;
+    /**
+     * Creates a ProseMirror NodeSpec from this node's configuration
+     *
+     * Called by ExtensionManager when building the schema.
+     * Converts our config format to ProseMirror's NodeSpec format.
+     *
+     * @returns ProseMirror NodeSpec
+     */
+    createNodeSpec(): NodeSpec;
 }
-declare const findChildren: (node: Node$1, predicate: (node: Node$1) => boolean) => FindChildResult[];
-
-/**
- * Get the default block type at a given content match position
- *
- * Finds the first textblock type that can be created without required attributes.
- * Useful for creating new empty blocks (e.g., paragraph after details).
- *
- * @example
- * const type = defaultBlockAt(parent.contentMatchAt(index));
- * if (type) {
- *   const node = type.createAndFill();
- * }
- */
-
-declare const defaultBlockAt: (match: ContentMatch) => NodeType | null;
 
 /**
  * ToolbarController — Headless, framework-agnostic toolbar state machine
@@ -3471,6 +3514,168 @@ declare class ToolbarController {
 
 declare const defaultIcons: IconSet;
 
+/**
+ * Mark - Base class for mark extensions
+ *
+ * Marks define inline formatting that can be applied to text.
+ * Examples: Bold, Italic, Link, Code, etc.
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const Bold = Mark.create({
+ *   name: 'bold',
+ *   parseHTML() {
+ *     return [
+ *       { tag: 'strong' },
+ *       { tag: 'b' },
+ *       { style: 'font-weight=bold' },
+ *     ];
+ *   },
+ *   renderHTML({ HTMLAttributes }) {
+ *     return ['strong', HTMLAttributes, 0];
+ *   },
+ * });
+ */
+
+/**
+ * Extended editor interface for Mark
+ * Includes schema access for MarkType getter
+ */
+interface MarkEditorInterface extends ExtensionEditorInterface {
+    readonly schema: {
+        marks: Record<string, MarkType>;
+    };
+}
+/**
+ * Base class for mark extensions
+ *
+ * @typeParam Options - Mark options type
+ * @typeParam Storage - Mark storage type
+ */
+declare class Mark<Options = unknown, Storage = unknown> extends Extension<Options, Storage> {
+    /**
+     * Mark type identifier
+     * Distinguishes marks from extensions and nodes
+     */
+    readonly type: "mark";
+    /**
+     * The original configuration object
+     * Typed as MarkConfig for mark-specific properties
+     */
+    readonly config: MarkConfig<Options, Storage>;
+    /**
+     * Editor instance with schema access
+     * null until set by ExtensionManager
+     */
+    editor: MarkEditorInterface | null;
+    /**
+     * Protected constructor - use Mark.create() instead
+     */
+    protected constructor(config: MarkConfig<Options, Storage>);
+    /**
+     * Whether this mark represents visual formatting.
+     * Returns false for semantic marks (links, comments) that should
+     * survive `unsetAllMarks`. Defaults to true.
+     */
+    get isFormatting(): boolean;
+    /**
+     * Get the ProseMirror MarkType from schema
+     *
+     * This is a lazy getter because schema doesn't exist at mark creation time.
+     * Schema is built FROM marks by ExtensionManager.
+     *
+     * Returns null if editor is not yet initialized.
+     * Always check editor is set before using markType.
+     */
+    get markType(): MarkType | null;
+    /**
+     * Get MarkType or throw if not initialized.
+     * Use in contexts where editor is guaranteed to be set (like addCommands).
+     */
+    get markTypeOrThrow(): MarkType;
+    /**
+     * Creates a new mark instance
+     *
+     * @param config - Mark configuration
+     * @returns New mark instance
+     *
+     * @example
+     * const Bold = Mark.create({
+     *   name: 'bold',
+     *   parseHTML() {
+     *     return [{ tag: 'strong' }, { tag: 'b' }];
+     *   },
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: MarkConfig<O, S>): Mark<O, S>;
+    /**
+     * Creates a new mark with merged options
+     * Original mark is not modified
+     *
+     * **Note:** Options are merged shallowly using object spread (`...`).
+     * Nested objects are replaced entirely, not deeply merged.
+     *
+     * @param options - Options to merge with existing options
+     * @returns New mark instance with merged options
+     *
+     * @example
+     * const CustomBold = Bold.configure({ HTMLAttributes: { class: 'custom-bold' } });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { HTMLAttributes: { class: 'a', id: 'b' } }
+     * // configure({ HTMLAttributes: { class: 'c' } })
+     * // Result: { HTMLAttributes: { class: 'c' } } — 'id' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ HTMLAttributes: { ...original.options.HTMLAttributes, class: 'c' } })
+     */
+    configure(options: Partial<Options> & {
+        isFormatting?: boolean;
+    }): Mark<Options, Storage>;
+    /**
+     * Creates a new mark with extended configuration
+     * Original mark is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addAttributes`, `parseHTML`) are
+     * replaced entirely, not combined with the base mark's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New mark instance with extended config
+     *
+     * @example
+     * const CustomBold = Bold.extend({
+     *   name: 'customBold',
+     *   addAttributes() {
+     *     return { ...this.parent?.(), weight: { default: 'bold' } };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base mark's parse rules while adding new ones:
+     * const Extended = BaseMark.extend({
+     *   parseHTML() {
+     *     const baseRules = BaseMark.config.parseHTML?.call(this) ?? [];
+     *     return [...baseRules, { tag: 'custom-tag' }];
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<MarkConfig<ExtendedOptions, ExtendedStorage>> & ThisType<MarkContext<ExtendedOptions, ExtendedStorage>>): Mark<ExtendedOptions, ExtendedStorage>;
+    /**
+     * Creates a ProseMirror MarkSpec from this mark's configuration
+     *
+     * Called by ExtensionManager when building the schema.
+     * Converts our config format to ProseMirror's MarkSpec format.
+     *
+     * @returns ProseMirror MarkSpec
+     */
+    createMarkSpec(): MarkSpec;
+}
+
 /**
  * ChainBuilder - Chainable command builder
  *
@@ -5022,7 +5227,7 @@ declare const Selection: Extension<SelectionOptions, SelectionStorage>;
  *
  * Collapses the editor's range selection to a cursor when the editor loses
  * focus.  This prevents a "ghost selection" from lingering after the user
- * clicks outside the editor (approach A — same as Google Docs / Notion).
+ * clicks outside the editor (approach A - same as Google Docs / Notion).
  *
  * Toolbar and bubble-menu buttons call `event.preventDefault()` on
  * `mousedown`, so they never trigger blur — the selection stays intact
@@ -5133,7 +5338,7 @@ declare const InvisibleChars: Extension<InvisibleCharsOptions, InvisibleCharsSto
  *   extensions: [
  *     // ... other extensions
  *     TextStyle,
- *     TextColor, // uses the default 80-color palette
+ *     TextColor, // uses the default 25-color palette
  *   ],
  * });
  *
@@ -5628,4 +5833,4 @@ declare const StarterKit: Extension<StarterKitOptions, unknown>;
  */
 declare const VERSION = "0.1.0";
 
-export { type AnyExtension, type AnyExtensionConfig, type AttributeSpec, type AttributeSpecs, type AutolinkPluginOptions, BaseKeymap, type BaseKeymapOptions, Blockquote, type BlockquoteOptions, Bold, type BoldOptions, BubbleMenu, type BubbleMenuOptions, type BuildCommandPropsOptions, BulletList, type BulletListOptions, type CanChainedCommands, CanChecker, type CanCheckerEditor, type CanCheckerOptions, type CanCommands, ChainBuilder, type ChainBuilderEditor, type ChainBuilderOptions, type ChainFailure, type ChainedCommands, CharacterCount, type CharacterCountOptions, type CharacterCountStorage, type ClearContentOptions, ClearFormatting, Code, CodeBlock, type CodeBlockOptions, type CodeOptions, type Command, type CommandEditor, CommandManager, type CommandManagerEditor, type CommandMap, type CommandProps, type CommandPropsEditor, type CommandSpec$1 as CommandSpec, type Content, type ContentErrorProps, type CreateBubbleMenuPluginOptions, type CreateDocumentOptions, type CreateEventProps, type CreateFloatingMenuPluginOptions, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_TEXT_COLORS, type DeleteEventProps, Document$1 as Document, type DropEventProps, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, EventEmitter, Extension, type ExtensionConfig, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, type FindChildResult, type FindParentNodeResult, FloatingMenu, type FloatingMenuOptions, Focus, type FocusEventProps, type FocusOptions, type FocusPosition, FontFamily, type FontFamilyOptions, FontSize, type FontSizeOptions, Gapcursor, type GenerateHTMLOptions, type GenerateJSONOptions, type GenerateTextOptions, type GlobalAttributeSpec, type GlobalAttributes, HardBreak, type HardBreakOptions, Heading, type HeadingOptions, Highlight, type HighlightOptions, History, type HistoryOptions, HorizontalRule, type HorizontalRuleOptions, type IconSet, type InlineStyleOverrides, InvisibleChars, type InvisibleCharsOptions, type InvisibleCharsStorage, type IsNodeEmptyOptions, type IsValidUrlOptions, Italic, type ItalicOptions, type JSONAttribute, type JSONContent, type JSONMark, type KeyboardShortcutCommand, LineHeight, type LineHeightOptions, Link, type LinkAttributes, type LinkClickPluginOptions, type LinkExitPluginOptions, type LinkOptions, type LinkPastePluginOptions, LinkPopover, type LinkPopoverOptions, ListItem, type ListItemOptions, ListKeymap, type ListKeymapOptions, Mark, type MarkConfig, type MarkInputRuleOptions, type MarkParseRule, type MarkRange, type MarkRenderHTMLProps, type MountEventProps, Node, type NodeConfig, type NodeParseRule, type NodeRenderHTMLProps, OrderedList, type OrderedListOptions, Paragraph, type ParagraphOptions, type PasteEventProps, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, type Range, type RawCommands, Selection, SelectionDecoration, type SelectionDecorationOptions, type SelectionOptions, type SelectionStorage, type SetContentOptions, type SingleCommands, StarterKit, type StarterKitOptions, Strike, type StrikeOptions, Subscript, type SubscriptOptions, Superscript, type SuperscriptOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, Text, TextAlign, type TextAlignOptions, TextColor, type TextColorOptions, TextStyle, type TextStyleOptions, type ToolbarButton, ToolbarController, type ToolbarControllerEditor, type ToolbarDropdown, type ToolbarGroup, type ToolbarItem, type ToolbarLayoutDropdown, type ToolbarLayoutEntry, type ToolbarSeparator, TrailingNode, type TrailingNodeOptions, type TransactionEventProps, Typography, type TypographyOptions, Underline, type UnderlineOptions, UniqueID, type UniqueIDOptions, VERSION, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, createAccumulatingDispatch, createBubbleMenuPlugin, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultIcons, deleteSelection, findChildren, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getMarkRange, inlineStyles, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isNodeEmpty, isValidUrl, lift, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, placeholderPluginKey, positionFloating, positionFloatingOnce, resetAttributes, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, wrapIn };
+export { type AnyExtension, type AnyExtensionConfig, type AttributeSpec, type AttributeSpecs, type AutolinkPluginOptions, BaseKeymap, type BaseKeymapOptions, Blockquote, type BlockquoteOptions, Bold, type BoldOptions, BubbleMenu, type BubbleMenuOptions, type BuildCommandPropsOptions, BulletList, type BulletListOptions, type CanChainedCommands, CanChecker, type CanCheckerEditor, type CanCheckerOptions, type CanCommands, ChainBuilder, type ChainBuilderEditor, type ChainBuilderOptions, type ChainFailure, type ChainedCommands, CharacterCount, type CharacterCountOptions, type CharacterCountStorage, type ClearContentOptions, ClearFormatting, Code, CodeBlock, type CodeBlockOptions, type CodeOptions, type Command, type CommandEditor, CommandManager, type CommandManagerEditor, type CommandMap, type CommandProps, type CommandPropsEditor, type CommandSpec$1 as CommandSpec, type Content, type ContentErrorProps, type CreateBubbleMenuPluginOptions, type CreateDocumentOptions, type CreateEventProps, type CreateFloatingMenuPluginOptions, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_TEXT_COLORS, type DeleteEventProps, Document$1 as Document, type DropEventProps, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, EventEmitter, Extension, type ExtensionConfig, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, type FindChildResult, type FindParentNodeResult, FloatingMenu, type FloatingMenuOptions, Focus, type FocusEventProps, type FocusOptions, type FocusPosition, FontFamily, type FontFamilyOptions, FontSize, type FontSizeOptions, Gapcursor, type GenerateHTMLOptions, type GenerateJSONOptions, type GenerateTextOptions, type GlobalAttributeSpec, type GlobalAttributes, HardBreak, type HardBreakOptions, Heading, type HeadingOptions, Highlight, type HighlightOptions, History, type HistoryOptions, HorizontalRule, type HorizontalRuleOptions, type IconSet, type InlineStyleOverrides, InvisibleChars, type InvisibleCharsOptions, type InvisibleCharsStorage, type IsNodeEmptyOptions, type IsValidUrlOptions, Italic, type ItalicOptions, type JSONAttribute, type JSONContent, type JSONMark, type KeyboardShortcutCommand, LineHeight, type LineHeightOptions, Link, type LinkAttributes, type LinkClickPluginOptions, type LinkExitPluginOptions, type LinkOptions, type LinkPastePluginOptions, LinkPopover, type LinkPopoverOptions, ListItem, type ListItemOptions, ListKeymap, type ListKeymapOptions, Mark, type MarkConfig, type MarkInputRuleOptions, type MarkParseRule, type MarkRange, type MarkRenderHTMLProps, type MountEventProps, Node, type NodeConfig, type NodeInputRuleOptions, type NodeParseRule, type NodeRenderHTMLProps, type NodeViewContext, OrderedList, type OrderedListOptions, Paragraph, type ParagraphOptions, type PasteEventProps, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, type Range, type RawCommands, Selection, SelectionDecoration, type SelectionDecorationOptions, type SelectionOptions, type SelectionStorage, type SetContentOptions, type SingleCommands, StarterKit, type StarterKitOptions, Strike, type StrikeOptions, Subscript, type SubscriptOptions, Superscript, type SuperscriptOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, Text, TextAlign, type TextAlignOptions, TextColor, type TextColorOptions, type TextInputRuleOptions, TextStyle, type TextStyleOptions, type TextblockTypeInputRuleOptions, type ToolbarButton, ToolbarController, type ToolbarControllerEditor, type ToolbarDropdown, type ToolbarGroup, type ToolbarItem, type ToolbarLayoutDropdown, type ToolbarLayoutEntry, type ToolbarSeparator, TrailingNode, type TrailingNodeOptions, type TransactionEventProps, Typography, type TypographyOptions, Underline, type UnderlineOptions, UniqueID, type UniqueIDOptions, VERSION, type WrappingInputRuleOptions, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, createAccumulatingDispatch, createBubbleMenuPlugin, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultIcons, deleteSelection, findChildren, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getMarkRange, inlineStyles, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isNodeEmpty, isValidUrl, lift, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, placeholderPluginKey, positionFloating, positionFloatingOnce, resetAttributes, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrappingInputRule };