@tiptap/core 3.0.0-next.4 → 3.0.0-next.6

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Transaction, EditorState, Plugin, Selection, NodeSelection, TextSelection, PluginKey } from '@tiptap/pm/state';
-import { Node as Node$1, NodeType as NodeType$1, NodeSpec, DOMOutputSpec, MarkType as MarkType$1, MarkSpec, Mark as Mark$1, Slice, ParseOptions, Fragment, Schema, ContentMatch, ResolvedPos, ParseRule } from '@tiptap/pm/model';
-import { NodeView as NodeView$1, EditorProps, EditorView, Decoration, DecorationAttrs, ViewMutationRecord, NodeViewConstructor } from '@tiptap/pm/view';
+import { Node as Node$1, MarkType as MarkType$1, MarkSpec, Mark as Mark$1, DOMOutputSpec, NodeType as NodeType$1, NodeSpec, Slice, ParseOptions, Fragment as Fragment$1, Schema, ContentMatch, ResolvedPos, ParseRule } from '@tiptap/pm/model';
+import { EditorProps, EditorView, Decoration, DecorationAttrs, ViewMutationRecord, NodeViewConstructor, NodeView as NodeView$1, MarkViewConstructor, MarkView as MarkView$1 } from '@tiptap/pm/view';
 import { Transform, Mappable } from '@tiptap/pm/transform';
 
 type StringKeyOf<T> = Extract<keyof T, string>;
@@ -73,6 +73,404 @@ declare function inputRulesPlugin(props: {
     rules: InputRule[];
 }): Plugin;
 
+interface MarkConfig<Options = any, Storage = any> extends ExtendableConfig<Options, Storage, MarkConfig<Options, Storage>, MarkType$1> {
+    /**
+     * Mark View
+     */
+    addMarkView?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: MarkType$1;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['addMarkView'];
+    }) => MarkViewRenderer) | null;
+    /**
+     * Keep mark after split node
+     */
+    keepOnSplit?: boolean | (() => boolean);
+    /**
+     * Inclusive
+     */
+    inclusive?: MarkSpec['inclusive'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['inclusive'];
+        editor?: Editor;
+    }) => MarkSpec['inclusive']);
+    /**
+     * Excludes
+     */
+    excludes?: MarkSpec['excludes'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['excludes'];
+        editor?: Editor;
+    }) => MarkSpec['excludes']);
+    /**
+     * Marks this Mark as exitable
+     */
+    exitable?: boolean | (() => boolean);
+    /**
+     * Group
+     */
+    group?: MarkSpec['group'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['group'];
+        editor?: Editor;
+    }) => MarkSpec['group']);
+    /**
+     * Spanning
+     */
+    spanning?: MarkSpec['spanning'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['spanning'];
+        editor?: Editor;
+    }) => MarkSpec['spanning']);
+    /**
+     * Code
+     */
+    code?: boolean | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['code'];
+        editor?: Editor;
+    }) => boolean);
+    /**
+     * Parse HTML
+     */
+    parseHTML?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['parseHTML'];
+        editor?: Editor;
+    }) => MarkSpec['parseDOM'];
+    /**
+     * Render HTML
+     */
+    renderHTML?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['renderHTML'];
+        editor?: Editor;
+    }, props: {
+        mark: Mark$1;
+        HTMLAttributes: Record<string, any>;
+    }) => DOMOutputSpec) | null;
+    /**
+     * Attributes
+     */
+    addAttributes?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<MarkConfig<Options, Storage>>['addAttributes'];
+        editor?: Editor;
+    }) => Attributes$1 | {};
+}
+/**
+ * The Mark class is used to create custom mark extensions.
+ * @see https://tiptap.dev/api/extensions#create-a-new-extension
+ */
+declare class Mark<Options = any, Storage = any> extends Extendable<Options, Storage> {
+    type: string;
+    static create<O = any, S = any>(config?: Partial<MarkConfig<O, S>>): Mark<O, S>;
+    static handleExit({ editor, mark }: {
+        editor: Editor;
+        mark: Mark;
+    }): boolean;
+}
+
+interface NodeConfig<Options = any, Storage = any> extends ExtendableConfig<Options, Storage, NodeConfig<Options, Storage>, NodeType$1> {
+    /**
+     * Node View
+     */
+    addNodeView?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: NodeType$1;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['addNodeView'];
+    }) => NodeViewRenderer) | null;
+    /**
+     * Defines if this node should be a top level node (doc)
+     * @default false
+     * @example true
+     */
+    topNode?: boolean;
+    /**
+     * The content expression for this node, as described in the [schema
+     * guide](/docs/guide/#schema.content_expressions). When not given,
+     * the node does not allow any content.
+     *
+     * You can read more about it on the Prosemirror documentation here
+     * @see https://prosemirror.net/docs/guide/#schema.content_expressions
+     * @default undefined
+     * @example content: 'block+'
+     * @example content: 'headline paragraph block*'
+     */
+    content?: NodeSpec['content'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['content'];
+        editor?: Editor;
+    }) => NodeSpec['content']);
+    /**
+     * The marks that are allowed inside of this node. May be a
+     * space-separated string referring to mark names or groups, `"_"`
+     * to explicitly allow all marks, or `""` to disallow marks. When
+     * not given, nodes with inline content default to allowing all
+     * marks, other nodes default to not allowing marks.
+     *
+     * @example marks: 'strong em'
+     */
+    marks?: NodeSpec['marks'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['marks'];
+        editor?: Editor;
+    }) => NodeSpec['marks']);
+    /**
+     * The group or space-separated groups to which this node belongs,
+     * which can be referred to in the content expressions for the
+     * schema.
+     *
+     * By default Tiptap uses the groups 'block' and 'inline' for nodes. You
+     * can also use custom groups if you want to group specific nodes together
+     * and handle them in your schema.
+     * @example group: 'block'
+     * @example group: 'inline'
+     * @example group: 'customBlock' // this uses a custom group
+     */
+    group?: NodeSpec['group'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['group'];
+        editor?: Editor;
+    }) => NodeSpec['group']);
+    /**
+     * Should be set to true for inline nodes. (Implied for text nodes.)
+     */
+    inline?: NodeSpec['inline'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['inline'];
+        editor?: Editor;
+    }) => NodeSpec['inline']);
+    /**
+     * Can be set to true to indicate that, though this isn't a [leaf
+     * node](https://prosemirror.net/docs/ref/#model.NodeType.isLeaf), it doesn't have directly editable
+     * content and should be treated as a single unit in the view.
+     *
+     * @example atom: true
+     */
+    atom?: NodeSpec['atom'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['atom'];
+        editor?: Editor;
+    }) => NodeSpec['atom']);
+    /**
+     * Controls whether nodes of this type can be selected as a [node
+     * selection](https://prosemirror.net/docs/ref/#state.NodeSelection). Defaults to true for non-text
+     * nodes.
+     *
+     * @default true
+     * @example selectable: false
+     */
+    selectable?: NodeSpec['selectable'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['selectable'];
+        editor?: Editor;
+    }) => NodeSpec['selectable']);
+    /**
+     * Determines whether nodes of this type can be dragged without
+     * being selected. Defaults to false.
+     *
+     * @default: false
+     * @example: draggable: true
+     */
+    draggable?: NodeSpec['draggable'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['draggable'];
+        editor?: Editor;
+    }) => NodeSpec['draggable']);
+    /**
+     * Can be used to indicate that this node contains code, which
+     * causes some commands to behave differently.
+     */
+    code?: NodeSpec['code'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['code'];
+        editor?: Editor;
+    }) => NodeSpec['code']);
+    /**
+     * Controls way whitespace in this a node is parsed. The default is
+     * `"normal"`, which causes the [DOM parser](https://prosemirror.net/docs/ref/#model.DOMParser) to
+     * collapse whitespace in normal mode, and normalize it (replacing
+     * newlines and such with spaces) otherwise. `"pre"` causes the
+     * parser to preserve spaces inside the node. When this option isn't
+     * given, but [`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) is true, `whitespace`
+     * will default to `"pre"`. Note that this option doesn't influence
+     * the way the node is rendered—that should be handled by `toDOM`
+     * and/or styling.
+     */
+    whitespace?: NodeSpec['whitespace'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['whitespace'];
+        editor?: Editor;
+    }) => NodeSpec['whitespace']);
+    /**
+     * Allows a **single** node to be set as linebreak equivalent (e.g. hardBreak).
+     * When converting between block types that have whitespace set to "pre"
+     * and don't support the linebreak node (e.g. codeBlock) and other block types
+     * that do support the linebreak node (e.g. paragraphs) - this node will be used
+     * as the linebreak instead of stripping the newline.
+     *
+     * See [linebreakReplacement](https://prosemirror.net/docs/ref/#model.NodeSpec.linebreakReplacement).
+     */
+    linebreakReplacement?: NodeSpec['linebreakReplacement'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['linebreakReplacement'];
+        editor?: Editor;
+    }) => NodeSpec['linebreakReplacement']);
+    /**
+     * When enabled, enables both
+     * [`definingAsContext`](https://prosemirror.net/docs/ref/#model.NodeSpec.definingAsContext) and
+     * [`definingForContent`](https://prosemirror.net/docs/ref/#model.NodeSpec.definingForContent).
+     *
+     * @default false
+     * @example isolating: true
+     */
+    defining?: NodeSpec['defining'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['defining'];
+        editor?: Editor;
+    }) => NodeSpec['defining']);
+    /**
+     * When enabled (default is false), the sides of nodes of this type
+     * count as boundaries that regular editing operations, like
+     * backspacing or lifting, won't cross. An example of a node that
+     * should probably have this enabled is a table cell.
+     */
+    isolating?: NodeSpec['isolating'] | ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['isolating'];
+        editor?: Editor;
+    }) => NodeSpec['isolating']);
+    /**
+     * Associates DOM parser information with this node, which can be
+     * used by [`DOMParser.fromSchema`](https://prosemirror.net/docs/ref/#model.DOMParser^fromSchema) to
+     * automatically derive a parser. The `node` field in the rules is
+     * implied (the name of this node will be filled in automatically).
+     * If you supply your own parser, you do not need to also specify
+     * parsing rules in your schema.
+     *
+     * @example parseHTML: [{ tag: 'div', attrs: { 'data-id': 'my-block' } }]
+     */
+    parseHTML?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['parseHTML'];
+        editor?: Editor;
+    }) => NodeSpec['parseDOM'];
+    /**
+     * A description of a DOM structure. Can be either a string, which is
+     * interpreted as a text node, a DOM node, which is interpreted as
+     * itself, a `{dom, contentDOM}` object, or an array.
+     *
+     * An array describes a DOM element. The first value in the array
+     * should be a string—the name of the DOM element, optionally prefixed
+     * by a namespace URL and a space. If the second element is plain
+     * object, it is interpreted as a set of attributes for the element.
+     * Any elements after that (including the 2nd if it's not an attribute
+     * object) are interpreted as children of the DOM elements, and must
+     * either be valid `DOMOutputSpec` values, or the number zero.
+     *
+     * The number zero (pronounced “hole”) is used to indicate the place
+     * where a node's child nodes should be inserted. If it occurs in an
+     * output spec, it should be the only child element in its parent
+     * node.
+     *
+     * @example toDOM: ['div[data-id="my-block"]', { class: 'my-block' }, 0]
+     */
+    renderHTML?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['renderHTML'];
+        editor?: Editor;
+    }, props: {
+        node: Node$1;
+        HTMLAttributes: Record<string, any>;
+    }) => DOMOutputSpec) | null;
+    /**
+     * renders the node as text
+     * @example renderText: () => 'foo
+     */
+    renderText?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['renderText'];
+        editor?: Editor;
+    }, props: {
+        node: Node$1;
+        pos: number;
+        parent: Node$1;
+        index: number;
+    }) => string) | null;
+    /**
+     * Add attributes to the node
+     * @example addAttributes: () => ({ class: 'foo' })
+     */
+    addAttributes?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<NodeConfig<Options, Storage>>['addAttributes'];
+        editor?: Editor;
+    }) => Attributes$1 | {};
+}
+/**
+ * The Node class is used to create custom node extensions.
+ * @see https://tiptap.dev/api/extensions#create-a-new-extension
+ */
+declare class Node<Options = any, Storage = any> extends Extendable<Options, Storage> {
+    type: string;
+    static create<O = any, S = any>(config?: Partial<NodeConfig<O, S>>): Node<O, S>;
+}
+
 type PasteRuleMatch = {
     index: number;
     text: string;
@@ -121,1407 +519,341 @@ declare function pasteRulesPlugin(props: {
     rules: PasteRule[];
 }): Plugin[];
 
-declare module '@tiptap/core' {
-    interface NodeConfig<Options = any, Storage = any> {
-        [key: string]: any;
-        /**
-         * The extension name - this must be unique.
-         * It will be used to identify the extension.
-         *
-         * @example 'myExtension'
-         */
-        name: string;
-        /**
-         * The priority of your extension. The higher, the earlier it will be called
-         * and will take precedence over other extensions with a lower priority.
-         * @default 100
-         * @example 101
-         */
-        priority?: number;
-        /**
-         * The default options for this extension.
-         * @example
-         * defaultOptions: {
-         *   myOption: 'foo',
-         *   myOtherOption: 10,
-         * }
-         */
-        defaultOptions?: Options;
-        /**
-         * This method will add options to this extension
-         * @see https://tiptap.dev/guide/custom-extensions#settings
-         * @example
-         * addOptions() {
-         *  return {
-         *    myOption: 'foo',
-         *    myOtherOption: 10,
-         * }
-         */
-        addOptions?: (this: {
-            name: string;
-            parent: Exclude<ParentConfig<NodeConfig<Options, Storage>>['addOptions'], undefined>;
-        }) => Options;
-        /**
-         * The default storage this extension can save data to.
-         * @see https://tiptap.dev/guide/custom-extensions#storage
-         * @example
-         * defaultStorage: {
-         *   prefetchedUsers: [],
-         *   loading: false,
-         * }
-         */
-        addStorage?: (this: {
-            name: string;
-            options: Options;
-            parent: Exclude<ParentConfig<NodeConfig<Options, Storage>>['addStorage'], undefined>;
-        }) => Storage;
-        /**
-         * This function adds globalAttributes to specific nodes.
-         * @see https://tiptap.dev/guide/custom-extensions#global-attributes
-         * @example
-         * addGlobalAttributes() {
-         *   return [
-         *     {
-                 // Extend the following extensions
-         *       types: [
-         *         'heading',
-         *         'paragraph',
-         *       ],
-         *       // … with those attributes
-         *       attributes: {
-         *         textAlign: {
-         *           default: 'left',
-         *           renderHTML: attributes => ({
-         *             style: `text-align: ${attributes.textAlign}`,
-         *           }),
-         *           parseHTML: element => element.style.textAlign || 'left',
-         *         },
-         *       },
-         *     },
-         *   ]
-         * }
-         */
-        addGlobalAttributes?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            extensions: (Node | Mark)[];
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addGlobalAttributes'];
-        }) => GlobalAttributes;
-        /**
-         * This function adds commands to the editor
-         * @see https://tiptap.dev/guide/custom-extensions#keyboard-shortcuts
-         * @example
-         * addCommands() {
-         *   return {
-         *     myCommand: () => ({ chain }) => chain().setMark('type', 'foo').run(),
-         *   }
-         * }
-         */
-        addCommands?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addCommands'];
-        }) => Partial<RawCommands>;
-        /**
-         * This function registers keyboard shortcuts.
-         * @see https://tiptap.dev/guide/custom-extensions#keyboard-shortcuts
-         * @example
-         * addKeyboardShortcuts() {
-         *   return {
-         *     'Mod-l': () => this.editor.commands.toggleBulletList(),
-         *   }
-         * },
-         */
-        addKeyboardShortcuts?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addKeyboardShortcuts'];
-        }) => {
-            [key: string]: KeyboardShortcutCommand;
-        };
-        /**
-         * This function adds input rules to the editor.
-         * @see https://tiptap.dev/guide/custom-extensions#input-rules
-         * @example
-         * addInputRules() {
-         *   return [
-         *     markInputRule({
-         *       find: inputRegex,
-         *       type: this.type,
-         *     }),
-         *   ]
-         * },
-         */
-        addInputRules?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addInputRules'];
-        }) => InputRule[];
-        /**
-         * This function adds paste rules to the editor.
-         * @see https://tiptap.dev/guide/custom-extensions#paste-rules
-         * @example
-         * addPasteRules() {
-         *   return [
-         *     markPasteRule({
-         *       find: pasteRegex,
-         *       type: this.type,
-         *     }),
-         *   ]
-         * },
-         */
-        addPasteRules?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addPasteRules'];
-        }) => PasteRule[];
-        /**
-         * This function adds Prosemirror plugins to the editor
-         * @see https://tiptap.dev/guide/custom-extensions#prosemirror-plugins
-         * @example
-         * addProseMirrorPlugins() {
-         *   return [
-         *     customPlugin(),
-         *   ]
-         * }
-         */
-        addProseMirrorPlugins?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addProseMirrorPlugins'];
-        }) => Plugin[];
-        /**
-         * This function adds additional extensions to the editor. This is useful for
-         * building extension kits.
-         * @example
-         * addExtensions() {
-         *   return [
-         *     BulletList,
-         *     OrderedList,
-         *     ListItem
-         *   ]
-         * }
-         */
-        addExtensions?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addExtensions'];
-        }) => Extensions;
-        /**
-         * This function extends the schema of the node.
-         * @example
-         * extendNodeSchema() {
-         *   return {
-         *     group: 'inline',
-         *     selectable: false,
-         *   }
-         * }
-         */
-        extendNodeSchema?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['extendNodeSchema'];
-        }, extension: Node) => Record<string, any>) | null;
-        /**
-         * This function extends the schema of the mark.
-         * @example
-         * extendMarkSchema() {
-         *   return {
-         *     group: 'inline',
-         *     selectable: false,
-         *   }
-         * }
-         */
-        extendMarkSchema?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['extendMarkSchema'];
-            editor?: Editor;
-        }, extension: Node) => Record<string, any>) | null;
-        /**
-         * The editor is not ready yet.
-         */
-        onBeforeCreate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onBeforeCreate'];
-        }) => void) | null;
-        /**
-         * The editor is ready.
-         */
-        onCreate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onCreate'];
-        }) => void) | null;
-        /**
-         * The content has changed.
-         */
-        onUpdate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onUpdate'];
-        }) => void) | null;
-        /**
-         * The selection has changed.
-         */
-        onSelectionUpdate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onSelectionUpdate'];
-        }) => void) | null;
-        /**
-         * The editor state has changed.
-         */
-        onTransaction?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onTransaction'];
-        }, props: {
-            editor: Editor;
-            transaction: Transaction;
-        }) => void) | null;
-        /**
-         * The editor is focused.
-         */
-        onFocus?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onFocus'];
-        }, props: {
-            event: FocusEvent;
-        }) => void) | null;
-        /**
-         * The editor isn’t focused anymore.
-         */
-        onBlur?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onBlur'];
-        }, props: {
-            event: FocusEvent;
-        }) => void) | null;
-        /**
-         * The editor is destroyed.
-         */
-        onDestroy?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['onDestroy'];
-        }) => void) | null;
-        /**
-         * Node View
-         */
-        addNodeView?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: NodeType$1;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addNodeView'];
-        }) => NodeViewRenderer) | null;
-        /**
-         * Defines if this node should be a top level node (doc)
-         * @default false
-         * @example true
-         */
-        topNode?: boolean;
-        /**
-         * The content expression for this node, as described in the [schema
-         * guide](/docs/guide/#schema.content_expressions). When not given,
-         * the node does not allow any content.
-         *
-         * You can read more about it on the Prosemirror documentation here
-         * @see https://prosemirror.net/docs/guide/#schema.content_expressions
-         * @default undefined
-         * @example content: 'block+'
-         * @example content: 'headline paragraph block*'
-         */
-        content?: NodeSpec['content'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['content'];
-            editor?: Editor;
-        }) => NodeSpec['content']);
-        /**
-         * The marks that are allowed inside of this node. May be a
-         * space-separated string referring to mark names or groups, `"_"`
-         * to explicitly allow all marks, or `""` to disallow marks. When
-         * not given, nodes with inline content default to allowing all
-         * marks, other nodes default to not allowing marks.
-         *
-         * @example marks: 'strong em'
-         */
-        marks?: NodeSpec['marks'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['marks'];
-            editor?: Editor;
-        }) => NodeSpec['marks']);
-        /**
-         * The group or space-separated groups to which this node belongs,
-         * which can be referred to in the content expressions for the
-         * schema.
-         *
-         * By default Tiptap uses the groups 'block' and 'inline' for nodes. You
-         * can also use custom groups if you want to group specific nodes together
-         * and handle them in your schema.
-         * @example group: 'block'
-         * @example group: 'inline'
-         * @example group: 'customBlock' // this uses a custom group
-         */
-        group?: NodeSpec['group'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['group'];
-            editor?: Editor;
-        }) => NodeSpec['group']);
-        /**
-         * Should be set to true for inline nodes. (Implied for text nodes.)
-         */
-        inline?: NodeSpec['inline'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['inline'];
-            editor?: Editor;
-        }) => NodeSpec['inline']);
-        /**
-         * Can be set to true to indicate that, though this isn't a [leaf
-         * node](https://prosemirror.net/docs/ref/#model.NodeType.isLeaf), it doesn't have directly editable
-         * content and should be treated as a single unit in the view.
-         *
-         * @example atom: true
-         */
-        atom?: NodeSpec['atom'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['atom'];
-            editor?: Editor;
-        }) => NodeSpec['atom']);
-        /**
-         * Controls whether nodes of this type can be selected as a [node
-         * selection](https://prosemirror.net/docs/ref/#state.NodeSelection). Defaults to true for non-text
-         * nodes.
-         *
-         * @default true
-         * @example selectable: false
-         */
-        selectable?: NodeSpec['selectable'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['selectable'];
-            editor?: Editor;
-        }) => NodeSpec['selectable']);
-        /**
-         * Determines whether nodes of this type can be dragged without
-         * being selected. Defaults to false.
-         *
-         * @default: false
-         * @example: draggable: true
-         */
-        draggable?: NodeSpec['draggable'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['draggable'];
-            editor?: Editor;
-        }) => NodeSpec['draggable']);
-        /**
-         * Can be used to indicate that this node contains code, which
-         * causes some commands to behave differently.
-         */
-        code?: NodeSpec['code'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['code'];
-            editor?: Editor;
-        }) => NodeSpec['code']);
-        /**
-         * Controls way whitespace in this a node is parsed. The default is
-         * `"normal"`, which causes the [DOM parser](https://prosemirror.net/docs/ref/#model.DOMParser) to
-         * collapse whitespace in normal mode, and normalize it (replacing
-         * newlines and such with spaces) otherwise. `"pre"` causes the
-         * parser to preserve spaces inside the node. When this option isn't
-         * given, but [`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) is true, `whitespace`
-         * will default to `"pre"`. Note that this option doesn't influence
-         * the way the node is rendered—that should be handled by `toDOM`
-         * and/or styling.
-         */
-        whitespace?: NodeSpec['whitespace'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['whitespace'];
-            editor?: Editor;
-        }) => NodeSpec['whitespace']);
-        /**
-         * Allows a **single** node to be set as linebreak equivalent (e.g. hardBreak).
-         * When converting between block types that have whitespace set to "pre"
-         * and don't support the linebreak node (e.g. codeBlock) and other block types
-         * that do support the linebreak node (e.g. paragraphs) - this node will be used
-         * as the linebreak instead of stripping the newline.
-         *
-         * See [linebreakReplacement](https://prosemirror.net/docs/ref/#model.NodeSpec.linebreakReplacement).
-         */
-        linebreakReplacement?: NodeSpec['linebreakReplacement'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['linebreakReplacement'];
-            editor?: Editor;
-        }) => NodeSpec['linebreakReplacement']);
-        /**
-         * When enabled, enables both
-         * [`definingAsContext`](https://prosemirror.net/docs/ref/#model.NodeSpec.definingAsContext) and
-         * [`definingForContent`](https://prosemirror.net/docs/ref/#model.NodeSpec.definingForContent).
-         *
-         * @default false
-         * @example isolating: true
-         */
-        defining?: NodeSpec['defining'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['defining'];
-            editor?: Editor;
-        }) => NodeSpec['defining']);
-        /**
-         * When enabled (default is false), the sides of nodes of this type
-         * count as boundaries that regular editing operations, like
-         * backspacing or lifting, won't cross. An example of a node that
-         * should probably have this enabled is a table cell.
-         */
-        isolating?: NodeSpec['isolating'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['isolating'];
-            editor?: Editor;
-        }) => NodeSpec['isolating']);
-        /**
-         * Associates DOM parser information with this node, which can be
-         * used by [`DOMParser.fromSchema`](https://prosemirror.net/docs/ref/#model.DOMParser^fromSchema) to
-         * automatically derive a parser. The `node` field in the rules is
-         * implied (the name of this node will be filled in automatically).
-         * If you supply your own parser, you do not need to also specify
-         * parsing rules in your schema.
-         *
-         * @example parseHTML: [{ tag: 'div', attrs: { 'data-id': 'my-block' } }]
-         */
-        parseHTML?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['parseHTML'];
-            editor?: Editor;
-        }) => NodeSpec['parseDOM'];
-        /**
-         * A description of a DOM structure. Can be either a string, which is
-         * interpreted as a text node, a DOM node, which is interpreted as
-         * itself, a `{dom, contentDOM}` object, or an array.
-         *
-         * An array describes a DOM element. The first value in the array
-         * should be a string—the name of the DOM element, optionally prefixed
-         * by a namespace URL and a space. If the second element is plain
-         * object, it is interpreted as a set of attributes for the element.
-         * Any elements after that (including the 2nd if it's not an attribute
-         * object) are interpreted as children of the DOM elements, and must
-         * either be valid `DOMOutputSpec` values, or the number zero.
-         *
-         * The number zero (pronounced “hole”) is used to indicate the place
-         * where a node's child nodes should be inserted. If it occurs in an
-         * output spec, it should be the only child element in its parent
-         * node.
-         *
-         * @example toDOM: ['div[data-id="my-block"]', { class: 'my-block' }, 0]
-         */
-        renderHTML?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['renderHTML'];
-            editor?: Editor;
-        }, props: {
-            node: Node$1;
-            HTMLAttributes: Record<string, any>;
-        }) => DOMOutputSpec) | null;
-        /**
-         * renders the node as text
-         * @example renderText: () => 'foo
-         */
-        renderText?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['renderText'];
-            editor?: Editor;
-        }, props: {
-            node: Node$1;
-            pos: number;
-            parent: Node$1;
-            index: number;
-        }) => string) | null;
-        /**
-         * Add attributes to the node
-         * @example addAttributes: () => ({ class: 'foo' })
-         */
-        addAttributes?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<NodeConfig<Options, Storage>>['addAttributes'];
-            editor?: Editor;
-        }) => Attributes | {};
-    }
-}
-/**
- * The Node class is used to create custom node extensions.
- * @see https://tiptap.dev/api/extensions#create-a-new-extension
- */
-declare class Node<Options = any, Storage = any> {
-    type: string;
+interface ExtendableConfig<Options = any, Storage = any, Config extends ExtensionConfig<Options, Storage> | NodeConfig<Options, Storage> | MarkConfig<Options, Storage> | ExtendableConfig<Options, Storage> = ExtendableConfig<Options, Storage, any, any>, PMType = any> {
+    /**
+     * The extension name - this must be unique.
+     * It will be used to identify the extension.
+     *
+     * @example 'myExtension'
+     */
     name: string;
-    parent: Node | null;
-    child: Node | null;
-    options: Options;
-    storage: Storage;
-    config: NodeConfig;
-    constructor(config?: Partial<NodeConfig<Options, Storage>>);
-    static create<O = any, S = any>(config?: Partial<NodeConfig<O, S>>): Node<O, S>;
-    configure(options?: Partial<Options>): Node<Options, Storage>;
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig?: Partial<NodeConfig<ExtendedOptions, ExtendedStorage>>): Node<ExtendedOptions, ExtendedStorage>;
-}
-
-declare module '@tiptap/core' {
-    interface MarkConfig<Options = any, Storage = any> {
-        [key: string]: any;
-        /**
-         * The extension name - this must be unique.
-         * It will be used to identify the extension.
-         *
-         * @example 'myExtension'
-         */
+    /**
+     * The priority of your extension. The higher, the earlier it will be called
+     * and will take precedence over other extensions with a lower priority.
+     * @default 100
+     * @example 101
+     */
+    priority?: number;
+    /**
+     * This method will add options to this extension
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#settings
+     * @example
+     * addOptions() {
+     *  return {
+     *    myOption: 'foo',
+     *    myOtherOption: 10,
+     * }
+     */
+    addOptions?: (this: {
         name: string;
-        /**
-         * The priority of your extension. The higher, the earlier it will be called
-         * and will take precedence over other extensions with a lower priority.
-         * @default 100
-         * @example 101
-         */
-        priority?: number;
-        /**
-         * The default options for this extension.
-         * @example
-         * defaultOptions: {
-         *   myOption: 'foo',
-         *   myOtherOption: 10,
-         * }
-         */
-        defaultOptions?: Options;
-        /**
-         * This method will add options to this extension
-         * @see https://tiptap.dev/guide/custom-extensions#settings
-         * @example
-         * addOptions() {
-         *  return {
-         *    myOption: 'foo',
-         *    myOtherOption: 10,
-         * }
-         */
-        addOptions?: (this: {
-            name: string;
-            parent: Exclude<ParentConfig<MarkConfig<Options, Storage>>['addOptions'], undefined>;
-        }) => Options;
-        /**
-         * The default storage this extension can save data to.
-         * @see https://tiptap.dev/guide/custom-extensions#storage
-         * @example
-         * defaultStorage: {
-         *   prefetchedUsers: [],
-         *   loading: false,
-         * }
-         */
-        addStorage?: (this: {
-            name: string;
-            options: Options;
-            parent: Exclude<ParentConfig<MarkConfig<Options, Storage>>['addStorage'], undefined>;
-        }) => Storage;
-        /**
-         * This function adds globalAttributes to specific nodes.
-         * @see https://tiptap.dev/guide/custom-extensions#global-attributes
-         * @example
-         * addGlobalAttributes() {
-         *   return [
-         *     {
-                 // Extend the following extensions
-         *       types: [
-         *         'heading',
-         *         'paragraph',
-         *       ],
-         *       // … with those attributes
-         *       attributes: {
-         *         textAlign: {
-         *           default: 'left',
-         *           renderHTML: attributes => ({
-         *             style: `text-align: ${attributes.textAlign}`,
-         *           }),
-         *           parseHTML: element => element.style.textAlign || 'left',
-         *         },
-         *       },
-         *     },
-         *   ]
-         * }
-         */
-        addGlobalAttributes?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            extensions: (Node | Mark)[];
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addGlobalAttributes'];
-        }) => GlobalAttributes;
-        /**
-         * This function adds commands to the editor
-         * @see https://tiptap.dev/guide/custom-extensions#keyboard-shortcuts
-         * @example
-         * addCommands() {
-         *   return {
-         *     myCommand: () => ({ chain }) => chain().setMark('type', 'foo').run(),
-         *   }
-         * }
-         */
-        addCommands?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addCommands'];
-        }) => Partial<RawCommands>;
-        /**
-         * This function registers keyboard shortcuts.
-         * @see https://tiptap.dev/guide/custom-extensions#keyboard-shortcuts
-         * @example
-         * addKeyboardShortcuts() {
-         *   return {
-         *     'Mod-l': () => this.editor.commands.toggleBulletList(),
-         *   }
-         * },
-         */
-        addKeyboardShortcuts?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addKeyboardShortcuts'];
-        }) => {
-            [key: string]: KeyboardShortcutCommand;
-        };
-        /**
-         * This function adds input rules to the editor.
-         * @see https://tiptap.dev/guide/custom-extensions#input-rules
-         * @example
-         * addInputRules() {
-         *   return [
-         *     markInputRule({
-         *       find: inputRegex,
-         *       type: this.type,
-         *     }),
-         *   ]
-         * },
-         */
-        addInputRules?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addInputRules'];
-        }) => InputRule[];
-        /**
-         * This function adds paste rules to the editor.
-         * @see https://tiptap.dev/guide/custom-extensions#paste-rules
-         * @example
-         * addPasteRules() {
-         *   return [
-         *     markPasteRule({
-         *       find: pasteRegex,
-         *       type: this.type,
-         *     }),
-         *   ]
-         * },
-         */
-        addPasteRules?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addPasteRules'];
-        }) => PasteRule[];
-        /**
-         * This function adds Prosemirror plugins to the editor
-         * @see https://tiptap.dev/guide/custom-extensions#prosemirror-plugins
-         * @example
-         * addProseMirrorPlugins() {
-         *   return [
-         *     customPlugin(),
-         *   ]
-         * }
-         */
-        addProseMirrorPlugins?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addProseMirrorPlugins'];
-        }) => Plugin[];
-        /**
-         * This function adds additional extensions to the editor. This is useful for
-         * building extension kits.
-         * @example
-         * addExtensions() {
-         *   return [
-         *     BulletList,
-         *     OrderedList,
-         *     ListItem
-         *   ]
-         * }
-         */
-        addExtensions?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addExtensions'];
-        }) => Extensions;
-        /**
-         * This function extends the schema of the node.
-         * @example
-         * extendNodeSchema() {
-         *   return {
-         *     group: 'inline',
-         *     selectable: false,
-         *   }
-         * }
-         */
-        extendNodeSchema?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['extendNodeSchema'];
-        }, extension: Node) => Record<string, any>) | null;
-        /**
-         * This function extends the schema of the mark.
-         * @example
-         * extendMarkSchema() {
-         *   return {
-         *     group: 'inline',
-         *     selectable: false,
-         *   }
-         * }
-         */
-        extendMarkSchema?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['extendMarkSchema'];
-        }, extension: Mark) => Record<string, any>) | null;
-        /**
-         * The editor is not ready yet.
-         */
-        onBeforeCreate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onBeforeCreate'];
-        }) => void) | null;
-        /**
-         * The editor is ready.
-         */
-        onCreate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onCreate'];
-        }) => void) | null;
-        /**
-         * The content has changed.
-         */
-        onUpdate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onUpdate'];
-        }) => void) | null;
-        /**
-         * The selection has changed.
-         */
-        onSelectionUpdate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onSelectionUpdate'];
-        }) => void) | null;
-        /**
-         * The editor state has changed.
-         */
-        onTransaction?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onTransaction'];
-        }, props: {
-            editor: Editor;
-            transaction: Transaction;
-        }) => void) | null;
-        /**
-         * The editor is focused.
-         */
-        onFocus?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onFocus'];
-        }, props: {
-            event: FocusEvent;
-        }) => void) | null;
-        /**
-         * The editor isn’t focused anymore.
-         */
-        onBlur?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onBlur'];
-        }, props: {
-            event: FocusEvent;
-        }) => void) | null;
-        /**
-         * The editor is destroyed.
-         */
-        onDestroy?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            type: MarkType$1;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['onDestroy'];
-        }) => void) | null;
-        /**
-         * Keep mark after split node
-         */
-        keepOnSplit?: boolean | (() => boolean);
-        /**
-         * Inclusive
-         */
-        inclusive?: MarkSpec['inclusive'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['inclusive'];
-            editor?: Editor;
-        }) => MarkSpec['inclusive']);
-        /**
-         * Excludes
-         */
-        excludes?: MarkSpec['excludes'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['excludes'];
-            editor?: Editor;
-        }) => MarkSpec['excludes']);
-        /**
-         * Marks this Mark as exitable
-         */
-        exitable?: boolean | (() => boolean);
-        /**
-         * Group
-         */
-        group?: MarkSpec['group'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['group'];
-            editor?: Editor;
-        }) => MarkSpec['group']);
-        /**
-         * Spanning
-         */
-        spanning?: MarkSpec['spanning'] | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['spanning'];
-            editor?: Editor;
-        }) => MarkSpec['spanning']);
-        /**
-         * Code
-         */
-        code?: boolean | ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['code'];
-            editor?: Editor;
-        }) => boolean);
-        /**
-         * Parse HTML
-         */
-        parseHTML?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['parseHTML'];
-            editor?: Editor;
-        }) => MarkSpec['parseDOM'];
-        /**
-         * Render HTML
-         */
-        renderHTML?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['renderHTML'];
-            editor?: Editor;
-        }, props: {
-            mark: Mark$1;
-            HTMLAttributes: Record<string, any>;
-        }) => DOMOutputSpec) | null;
-        /**
-         * Attributes
-         */
-        addAttributes?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<MarkConfig<Options, Storage>>['addAttributes'];
-            editor?: Editor;
-        }) => Attributes | {};
-    }
-}
-/**
- * The Mark class is used to create custom mark extensions.
- * @see https://tiptap.dev/api/extensions#create-a-new-extension
- */
-declare class Mark<Options = any, Storage = any> {
-    type: string;
-    name: string;
-    parent: Mark | null;
-    child: Mark | null;
-    options: Options;
-    storage: Storage;
-    config: MarkConfig;
-    constructor(config?: Partial<MarkConfig<Options, Storage>>);
-    static create<O = any, S = any>(config?: Partial<MarkConfig<O, S>>): Mark<O, S>;
-    configure(options?: Partial<Options>): Mark<Options, Storage>;
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig?: Partial<MarkConfig<ExtendedOptions, ExtendedStorage>>): Mark<ExtendedOptions, ExtendedStorage>;
-    static handleExit({ editor, mark }: {
+        parent: ParentConfig<Config>['addOptions'];
+    }) => Options;
+    /**
+     * The default storage this extension can save data to.
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#storage
+     * @example
+     * defaultStorage: {
+     *   prefetchedUsers: [],
+     *   loading: false,
+     * }
+     */
+    addStorage?: (this: {
+        name: string;
+        options: Options;
+        parent: ParentConfig<Config>['addStorage'];
+    }) => Storage;
+    /**
+     * This function adds globalAttributes to specific nodes.
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#global-attributes
+     * @example
+     * addGlobalAttributes() {
+     *   return [
+     *     {
+             // Extend the following extensions
+     *       types: [
+     *         'heading',
+     *         'paragraph',
+     *       ],
+     *       // … with those attributes
+     *       attributes: {
+     *         textAlign: {
+     *           default: 'left',
+     *           renderHTML: attributes => ({
+     *             style: `text-align: ${attributes.textAlign}`,
+     *           }),
+     *           parseHTML: element => element.style.textAlign || 'left',
+     *         },
+     *       },
+     *     },
+     *   ]
+     * }
+     */
+    addGlobalAttributes?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        extensions: (Node | Mark)[];
+        parent: ParentConfig<Config>['addGlobalAttributes'];
+    }) => GlobalAttributes;
+    /**
+     * This function adds commands to the editor
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#commands
+     * @example
+     * addCommands() {
+     *   return {
+     *     myCommand: () => ({ chain }) => chain().setMark('type', 'foo').run(),
+     *   }
+     * }
+     */
+    addCommands?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
         editor: Editor;
-        mark: Mark;
-    }): boolean;
-}
-
-declare module '@tiptap/core' {
-    interface ExtensionConfig<Options = any, Storage = any> {
-        [key: string]: any;
-        /**
-         * The extension name - this must be unique.
-         * It will be used to identify the extension.
-         *
-         * @example 'myExtension'
-         */
+        type: PMType;
+        parent: ParentConfig<Config>['addCommands'];
+    }) => Partial<RawCommands>;
+    /**
+     * This function registers keyboard shortcuts.
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#keyboard-shortcuts
+     * @example
+     * addKeyboardShortcuts() {
+     *   return {
+     *     'Mod-l': () => this.editor.commands.toggleBulletList(),
+     *   }
+     * },
+     */
+    addKeyboardShortcuts?: (this: {
         name: string;
-        /**
-         * The priority of your extension. The higher, the earlier it will be called
-         * and will take precedence over other extensions with a lower priority.
-         * @default 100
-         * @example 101
-         */
-        priority?: number;
-        /**
-         * The default options for this extension.
-         * @example
-         * defaultOptions: {
-         *   myOption: 'foo',
-         *   myOtherOption: 10,
-         * }
-         */
-        defaultOptions?: Options;
-        /**
-         * This method will add options to this extension
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#settings
-         * @example
-         * addOptions() {
-         *  return {
-         *    myOption: 'foo',
-         *    myOtherOption: 10,
-         * }
-         */
-        addOptions?: (this: {
-            name: string;
-            parent: Exclude<ParentConfig<ExtensionConfig<Options, Storage>>['addOptions'], undefined>;
-        }) => Options;
-        /**
-         * The default storage this extension can save data to.
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#storage
-         * @example
-         * defaultStorage: {
-         *   prefetchedUsers: [],
-         *   loading: false,
-         * }
-         */
-        addStorage?: (this: {
-            name: string;
-            options: Options;
-            parent: Exclude<ParentConfig<ExtensionConfig<Options, Storage>>['addStorage'], undefined>;
-        }) => Storage;
-        /**
-         * This function adds globalAttributes to specific nodes.
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#global-attributes
-         * @example
-         * addGlobalAttributes() {
-         *   return [
-         *     {
-                 // Extend the following extensions
-         *       types: [
-         *         'heading',
-         *         'paragraph',
-         *       ],
-         *       // … with those attributes
-         *       attributes: {
-         *         textAlign: {
-         *           default: 'left',
-         *           renderHTML: attributes => ({
-         *             style: `text-align: ${attributes.textAlign}`,
-         *           }),
-         *           parseHTML: element => element.style.textAlign || 'left',
-         *         },
-         *       },
-         *     },
-         *   ]
-         * }
-         */
-        addGlobalAttributes?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            extensions: (Node | Mark)[];
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addGlobalAttributes'];
-        }) => GlobalAttributes;
-        /**
-         * This function adds commands to the editor
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#commands
-         * @example
-         * addCommands() {
-         *   return {
-         *     myCommand: () => ({ chain }) => chain().setMark('type', 'foo').run(),
-         *   }
-         * }
-         */
-        addCommands?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addCommands'];
-        }) => Partial<RawCommands>;
-        /**
-         * This function registers keyboard shortcuts.
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#keyboard-shortcuts
-         * @example
-         * addKeyboardShortcuts() {
-         *   return {
-         *     'Mod-l': () => this.editor.commands.toggleBulletList(),
-         *   }
-         * },
-         */
-        addKeyboardShortcuts?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addKeyboardShortcuts'];
-        }) => {
-            [key: string]: KeyboardShortcutCommand;
-        };
-        /**
-         * This function adds input rules to the editor.
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#input-rules
-         * @example
-         * addInputRules() {
-         *   return [
-         *     markInputRule({
-         *       find: inputRegex,
-         *       type: this.type,
-         *     }),
-         *   ]
-         * },
-         */
-        addInputRules?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addInputRules'];
-        }) => InputRule[];
-        /**
-         * This function adds paste rules to the editor.
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#paste-rules
-         * @example
-         * addPasteRules() {
-         *   return [
-         *     markPasteRule({
-         *       find: pasteRegex,
-         *       type: this.type,
-         *     }),
-         *   ]
-         * },
-         */
-        addPasteRules?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addPasteRules'];
-        }) => PasteRule[];
-        /**
-         * This function adds Prosemirror plugins to the editor
-         * @see https://tiptap.dev/docs/editor/guide/custom-extensions#prosemirror-plugins
-         * @example
-         * addProseMirrorPlugins() {
-         *   return [
-         *     customPlugin(),
-         *   ]
-         * }
-         */
-        addProseMirrorPlugins?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addProseMirrorPlugins'];
-        }) => Plugin[];
-        /**
-         * This function adds additional extensions to the editor. This is useful for
-         * building extension kits.
-         * @example
-         * addExtensions() {
-         *   return [
-         *     BulletList,
-         *     OrderedList,
-         *     ListItem
-         *   ]
-         * }
-         */
-        addExtensions?: (this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addExtensions'];
-        }) => Extensions;
-        /**
-         * This function extends the schema of the node.
-         * @example
-         * extendNodeSchema() {
-         *   return {
-         *     group: 'inline',
-         *     selectable: false,
-         *   }
-         * }
-         */
-        extendNodeSchema?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['extendNodeSchema'];
-        }, extension: Node) => Record<string, any>) | null;
-        /**
-         * This function extends the schema of the mark.
-         * @example
-         * extendMarkSchema() {
-         *   return {
-         *     group: 'inline',
-         *     selectable: false,
-         *   }
-         * }
-         */
-        extendMarkSchema?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['extendMarkSchema'];
-        }, extension: Mark) => Record<string, any>) | null;
-        /**
-         * The editor is not ready yet.
-         */
-        onBeforeCreate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onBeforeCreate'];
-        }) => void) | null;
-        /**
-         * The editor is ready.
-         */
-        onCreate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onCreate'];
-        }) => void) | null;
-        /**
-         * The content has changed.
-         */
-        onUpdate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onUpdate'];
-        }) => void) | null;
-        /**
-         * The selection has changed.
-         */
-        onSelectionUpdate?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onSelectionUpdate'];
-        }) => void) | null;
-        /**
-         * The editor state has changed.
-         */
-        onTransaction?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onTransaction'];
-        }, props: {
-            editor: Editor;
-            transaction: Transaction;
-        }) => void) | null;
-        /**
-         * The editor is focused.
-         */
-        onFocus?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onFocus'];
-        }, props: {
-            event: FocusEvent;
-        }) => void) | null;
-        /**
-         * The editor isn’t focused anymore.
-         */
-        onBlur?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onBlur'];
-        }, props: {
-            event: FocusEvent;
-        }) => void) | null;
-        /**
-         * The editor is destroyed.
-         */
-        onDestroy?: ((this: {
-            name: string;
-            options: Options;
-            storage: Storage;
-            editor: Editor;
-            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onDestroy'];
-        }) => void) | null;
-    }
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['addKeyboardShortcuts'];
+    }) => {
+        [key: string]: KeyboardShortcutCommand;
+    };
+    /**
+     * This function adds input rules to the editor.
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#input-rules
+     * @example
+     * addInputRules() {
+     *   return [
+     *     markInputRule({
+     *       find: inputRegex,
+     *       type: this.type,
+     *     }),
+     *   ]
+     * },
+     */
+    addInputRules?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['addInputRules'];
+    }) => InputRule[];
+    /**
+     * This function adds paste rules to the editor.
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#paste-rules
+     * @example
+     * addPasteRules() {
+     *   return [
+     *     markPasteRule({
+     *       find: pasteRegex,
+     *       type: this.type,
+     *     }),
+     *   ]
+     * },
+     */
+    addPasteRules?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['addPasteRules'];
+    }) => PasteRule[];
+    /**
+     * This function adds Prosemirror plugins to the editor
+     * @see https://tiptap.dev/docs/editor/guide/custom-extensions#prosemirror-plugins
+     * @example
+     * addProseMirrorPlugins() {
+     *   return [
+     *     customPlugin(),
+     *   ]
+     * }
+     */
+    addProseMirrorPlugins?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['addProseMirrorPlugins'];
+    }) => Plugin[];
+    /**
+     * This function adds additional extensions to the editor. This is useful for
+     * building extension kits.
+     * @example
+     * addExtensions() {
+     *   return [
+     *     BulletList,
+     *     OrderedList,
+     *     ListItem
+     *   ]
+     * }
+     */
+    addExtensions?: (this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<Config>['addExtensions'];
+    }) => Extensions;
+    /**
+     * This function extends the schema of the node.
+     * @example
+     * extendNodeSchema() {
+     *   return {
+     *     group: 'inline',
+     *     selectable: false,
+     *   }
+     * }
+     */
+    extendNodeSchema?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<Config>['extendNodeSchema'];
+    }, extension: Node) => Record<string, any>) | null;
+    /**
+     * This function extends the schema of the mark.
+     * @example
+     * extendMarkSchema() {
+     *   return {
+     *     group: 'inline',
+     *     selectable: false,
+     *   }
+     * }
+     */
+    extendMarkSchema?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        parent: ParentConfig<Config>['extendMarkSchema'];
+    }, extension: Mark) => Record<string, any>) | null;
+    /**
+     * The editor is not ready yet.
+     */
+    onBeforeCreate?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onBeforeCreate'];
+    }, event: EditorEvents['beforeCreate']) => void) | null;
+    /**
+     * The editor is ready.
+     */
+    onCreate?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onCreate'];
+    }, event: EditorEvents['create']) => void) | null;
+    /**
+     * The content has changed.
+     */
+    onUpdate?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onUpdate'];
+    }, event: EditorEvents['update']) => void) | null;
+    /**
+     * The selection has changed.
+     */
+    onSelectionUpdate?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onSelectionUpdate'];
+    }, event: EditorEvents['selectionUpdate']) => void) | null;
+    /**
+     * The editor state has changed.
+     */
+    onTransaction?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onTransaction'];
+    }, event: EditorEvents['transaction']) => void) | null;
+    /**
+     * The editor is focused.
+     */
+    onFocus?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onFocus'];
+    }, event: EditorEvents['focus']) => void) | null;
+    /**
+     * The editor isn’t focused anymore.
+     */
+    onBlur?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onBlur'];
+    }, event: EditorEvents['blur']) => void) | null;
+    /**
+     * The editor is destroyed.
+     */
+    onDestroy?: ((this: {
+        name: string;
+        options: Options;
+        storage: Storage;
+        editor: Editor;
+        type: PMType;
+        parent: ParentConfig<Config>['onDestroy'];
+    }, event: EditorEvents['destroy']) => void) | null;
+}
+declare class Extendable<Options = any, Storage = any, Config = ExtensionConfig<Options, Storage> | NodeConfig<Options, Storage> | MarkConfig<Options, Storage>> {
+    type: string;
+    parent: Extendable | null;
+    child: Extendable | null;
+    name: string;
+    config: Config;
+    constructor(config?: Partial<Config>);
+    get options(): Options;
+    get storage(): Readonly<Storage>;
+    configure(options?: Partial<Options>): Extendable<Options, Storage, ExtensionConfig<Options, Storage> | NodeConfig<Options, Storage> | MarkConfig<Options, Storage>>;
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig?: Partial<ExtensionConfig<ExtendedOptions, ExtendedStorage> | NodeConfig<ExtendedOptions, ExtendedStorage> | MarkConfig<ExtendedOptions, ExtendedStorage>>): Extendable<ExtendedOptions, ExtendedStorage>;
+}
+
+interface ExtensionConfig<Options = any, Storage = any> extends ExtendableConfig<Options, Storage, ExtensionConfig<Options, Storage>, null> {
 }
 /**
  * The Extension class is the base class for all extensions.
  * @see https://tiptap.dev/api/extensions#create-a-new-extension
  */
-declare class Extension<Options = any, Storage = any> {
+declare class Extension<Options = any, Storage = any> extends Extendable<Options, Storage> {
     type: string;
-    name: string;
-    parent: Extension | null;
-    child: Extension | null;
-    options: Options;
-    storage: Storage;
-    config: ExtensionConfig;
-    constructor(config?: Partial<ExtensionConfig<Options, Storage>>);
     static create<O = any, S = any>(config?: Partial<ExtensionConfig<O, S>>): Extension<O, S>;
-    configure(options?: Partial<Options>): Extension<Options, Storage>;
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig?: Partial<ExtensionConfig<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
 }
 
 type AnyConfig = ExtensionConfig | NodeConfig | MarkConfig;
@@ -1536,13 +868,25 @@ type MaybeReturnType<T> = T extends (...args: any) => any ? ReturnType<T> : T;
 type MaybeThisParameterType<T> = Exclude<T, Primitive> extends (...args: any) => any ? ThisParameterType<Exclude<T, Primitive>> : any;
 interface EditorEvents {
     beforeCreate: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
     };
     create: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
     };
     contentError: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The error that occurred while parsing the content
+         */
         error: Error;
         /**
          * If called, will re-initialize the editor with the collaboration extension removed.
@@ -1551,64 +895,247 @@ interface EditorEvents {
         disableCollaboration: () => void;
     };
     update: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The transaction that caused the update
+         */
         transaction: Transaction;
+        /**
+         * Appended transactions that were added to the initial transaction by plugins
+         */
         appendedTransactions: Transaction[];
     };
     selectionUpdate: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The transaction that caused the selection update
+         */
         transaction: Transaction;
     };
     beforeTransaction: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The transaction that will be applied
+         */
         transaction: Transaction;
+        /**
+         * The next state of the editor after the transaction is applied
+         */
         nextState: EditorState;
     };
     transaction: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The initial transaction
+         */
         transaction: Transaction;
+        /**
+         * Appended transactions that were added to the initial transaction by plugins
+         */
         appendedTransactions: Transaction[];
     };
     focus: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The focus event
+         */
         event: FocusEvent;
+        /**
+         * The transaction that caused the focus
+         */
         transaction: Transaction;
     };
     blur: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The focus event
+         */
         event: FocusEvent;
+        /**
+         * The transaction that caused the blur
+         */
         transaction: Transaction;
     };
     destroy: void;
     paste: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The clipboard event
+         */
         event: ClipboardEvent;
+        /**
+         * The slice that was pasted
+         */
         slice: Slice;
     };
     drop: {
+        /**
+         * The editor instance
+         */
         editor: Editor;
+        /**
+         * The drag event
+         */
         event: DragEvent;
+        /**
+         * The slice that was dropped
+         */
         slice: Slice;
+        /**
+         * Whether the content was moved (true) or copied (false)
+         */
         moved: boolean;
     };
+    delete: {
+        /**
+         * The editor instance
+         */
+        editor: Editor;
+        /**
+         * The range of the deleted content (before the deletion)
+         */
+        deletedRange: Range;
+        /**
+         * The new range of positions of where the deleted content was in the new document (after the deletion)
+         */
+        newRange: Range;
+        /**
+         * The transaction that caused the deletion
+         */
+        transaction: Transaction;
+        /**
+         * The combined transform (including all appended transactions) that caused the deletion
+         */
+        combinedTransform: Transform;
+        /**
+         * Whether the deletion was partial (only a part of this content was deleted)
+         */
+        partial: boolean;
+        /**
+         * This is the start position of the mark in the document (before the deletion)
+         */
+        from: number;
+        /**
+         * This is the end position of the mark in the document (before the deletion)
+         */
+        to: number;
+    } & ({
+        /**
+         * The content that was deleted
+         */
+        type: 'node';
+        /**
+         * The node which the deletion occurred in
+         * @note This can be a parent node of the deleted content
+         */
+        node: Node$1;
+        /**
+         * The new start position of the node in the document (after the deletion)
+         */
+        newFrom: number;
+        /**
+         * The new end position of the node in the document (after the deletion)
+         */
+        newTo: number;
+    } | {
+        /**
+         * The content that was deleted
+         */
+        type: 'mark';
+        /**
+         * The mark that was deleted
+         */
+        mark: Mark$1;
+    });
 }
 type EnableRules = (AnyExtension | string)[] | boolean;
 interface EditorOptions {
-    element: Element;
+    /**
+     * The element or selector to bind the editor to
+     * If `null` is passed, the editor will not be mounted automatically
+     * If a function is passed, it will be called with the editor's root element
+     */
+    element: Element | null;
+    /**
+     * The content of the editor (HTML, JSON, or a JSON array)
+     */
     content: Content;
+    /**
+     * The extensions to use
+     */
     extensions: Extensions;
+    /**
+     * Whether to inject base CSS styles
+     */
     injectCSS: boolean;
+    /**
+     * A nonce to use for CSP while injecting styles
+     */
     injectNonce: string | undefined;
+    /**
+     * The editor's initial focus position
+     */
     autofocus: FocusPosition;
+    /**
+     * Whether the editor is editable
+     */
     editable: boolean;
+    /**
+     * The editor's props
+     */
     editorProps: EditorProps;
+    /**
+     * The editor's content parser options
+     */
     parseOptions: ParseOptions;
+    /**
+     * The editor's core extension options
+     */
     coreExtensionOptions?: {
         clipboardTextSerializer?: {
             blockSeparator?: string;
         };
+        delete?: {
+            /**
+             * Whether the `delete` extension should be called asynchronously to avoid blocking the editor while processing deletions
+             * @default true deletion events are called asynchronously
+             */
+            async?: boolean;
+            /**
+             * Allows filtering the transactions that are processed by the `delete` extension.
+             * If the function returns `true`, the transaction will be ignored.
+             */
+            filterTransaction?: (transaction: Transaction) => boolean;
+        };
     };
+    /**
+     * Whether to enable input rules behavior
+     */
     enableInputRules: EnableRules;
+    /**
+     * Whether to enable paste rules behavior
+     */
     enablePasteRules: EnableRules;
     /**
      * Determines whether core extensions are enabled.
@@ -1627,7 +1154,7 @@ interface EditorOptions {
      *
      * @default true
      */
-    enableCoreExtensions?: boolean | Partial<Record<'editable' | 'clipboardTextSerializer' | 'commands' | 'focusEvents' | 'keymap' | 'tabindex' | 'drop' | 'paste', false>>;
+    enableCoreExtensions?: boolean | Partial<Record<'editable' | 'clipboardTextSerializer' | 'commands' | 'focusEvents' | 'keymap' | 'tabindex' | 'drop' | 'paste' | 'delete', false>>;
     /**
      * If `true`, the editor will check the content for errors on initialization.
      * Emitting the `contentError` event if the content is invalid.
@@ -1635,23 +1162,63 @@ interface EditorOptions {
      * @default false
      */
     enableContentCheck: boolean;
+    /**
+     * Called before the editor is constructed.
+     */
     onBeforeCreate: (props: EditorEvents['beforeCreate']) => void;
+    /**
+     * Called after the editor is constructed.
+     */
     onCreate: (props: EditorEvents['create']) => void;
     /**
      * Called when the editor encounters an error while parsing the content.
      * Only enabled if `enableContentCheck` is `true`.
      */
     onContentError: (props: EditorEvents['contentError']) => void;
+    /**
+     * Called when the editor's content is updated.
+     */
     onUpdate: (props: EditorEvents['update']) => void;
+    /**
+     * Called when the editor's selection is updated.
+     */
     onSelectionUpdate: (props: EditorEvents['selectionUpdate']) => void;
+    /**
+     * Called after a transaction is applied to the editor.
+     */
     onTransaction: (props: EditorEvents['transaction']) => void;
+    /**
+     * Called on focus events.
+     */
     onFocus: (props: EditorEvents['focus']) => void;
+    /**
+     * Called on blur events.
+     */
     onBlur: (props: EditorEvents['blur']) => void;
+    /**
+     * Called when the editor is destroyed.
+     */
     onDestroy: (props: EditorEvents['destroy']) => void;
+    /**
+     * Called when content is pasted into the editor.
+     */
     onPaste: (e: ClipboardEvent, slice: Slice) => void;
+    /**
+     * Called when content is dropped into the editor.
+     */
     onDrop: (e: DragEvent, slice: Slice, moved: boolean) => void;
+    /**
+     * Called when content is deleted from the editor.
+     */
+    onDelete: (props: EditorEvents['delete']) => void;
 }
+/**
+ * The editor's content as HTML
+ */
 type HTMLContent = string;
+/**
+ * Loosely describes a JSON representation of a Prosemirror document or node
+ */
 type JSONContent = {
     type?: string;
     attrs?: Record<string, any>;
@@ -1669,19 +1236,19 @@ type JSONContent = {
  */
 type MarkType<Type extends string | {
     name: string;
-} = any, Attributes extends undefined | Record<string, any> = any> = {
+} = any, TAttributes extends undefined | Record<string, any> = any> = {
     type: Type;
-    attrs: Attributes;
+    attrs: TAttributes;
 };
 /**
  * A node type is either a JSON representation of a node or a Prosemirror node instance
  */
 type NodeType<Type extends string | {
     name: string;
-} = any, Attributes extends undefined | Record<string, any> = any, NodeMarkType extends MarkType = any, Content extends (NodeType | TextType)[] = any> = {
+} = any, TAttributes extends undefined | Record<string, any> = any, NodeMarkType extends MarkType = any, TContent extends (NodeType | TextType)[] = any> = {
     type: Type;
-    attrs: Attributes;
-    content?: Content;
+    attrs: TAttributes;
+    content?: TContent;
     marks?: NodeMarkType[];
 };
 /**
@@ -1702,7 +1269,7 @@ type TextType<TMarkType extends MarkType = MarkType> = {
  * Describes the output of a `renderHTML` function in prosemirror
  * @see https://prosemirror.net/docs/ref/#model.DOMOutputSpec
  */
-type DOMOutputSpecArray = [string] | [string, Record<string, any>] | [string, 0] | [string, Record<string, any>, 0] | [string, Record<string, any>, DOMOutputSpecArray | 0] | [string, DOMOutputSpecArray];
+type DOMOutputSpecArray$1 = [string] | [string, Record<string, any>] | [string, 0] | [string, Record<string, any>, 0] | [string, Record<string, any>, DOMOutputSpecArray$1 | 0] | [string, DOMOutputSpecArray$1];
 type Content = HTMLContent | JSONContent | JSONContent[] | null;
 type CommandProps = {
     editor: Editor;
@@ -1728,7 +1295,7 @@ type Attribute = {
     keepOnSplit?: boolean;
     isRequired?: boolean;
 };
-type Attributes = {
+type Attributes$1 = {
     [key: string]: Attribute;
 };
 type ExtensionAttribute = {
@@ -1832,6 +1399,40 @@ interface NodeViewRendererProps {
     HTMLAttributes: Record<string, any>;
 }
 type NodeViewRenderer = (props: NodeViewRendererProps) => NodeView$1;
+interface MarkViewProps extends MarkViewRendererProps {
+}
+interface MarkViewRendererProps {
+    /**
+     * The node that is being rendered.
+     */
+    mark: Parameters<MarkViewConstructor>[0];
+    /**
+     * The editor's view.
+     */
+    view: Parameters<MarkViewConstructor>[1];
+    /**
+     * indicates whether the mark's content is inline
+     */
+    inline: Parameters<MarkViewConstructor>[2];
+    /**
+     * The editor instance.
+     */
+    editor: Editor;
+    /**
+     * The extension that is responsible for the mark.
+     */
+    extension: Mark;
+    /**
+     * The HTML attributes that should be added to the mark's DOM element.
+     */
+    HTMLAttributes: Record<string, any>;
+}
+type MarkViewRenderer = (props: MarkViewRendererProps) => MarkView$1;
+interface MarkViewRendererOptions {
+    ignoreMutation: ((props: {
+        mutation: ViewMutationRecord;
+    }) => boolean) | null;
+}
 type AnyCommands = Record<string, (...args: any[]) => Command>;
 type UnionCommands<T = Command> = UnionToIntersection<ValuesOf<Pick<Commands<T>, KeysWithTypeOf<Commands<T>, object>>>>;
 type RawCommands = {
@@ -1887,7 +1488,7 @@ type Dispatch = ((args?: any) => any) | undefined;
  * @param parseOptions Options for the parser
  * @returns The created Prosemirror document node
  */
-declare function createDocument(content: Content | Node$1 | Fragment, schema: Schema, parseOptions?: ParseOptions, options?: {
+declare function createDocument(content: Content | Node$1 | Fragment$1, schema: Schema, parseOptions?: ParseOptions, options?: {
     errorOnInvalidContent?: boolean;
 }): Node$1;
 
@@ -1903,7 +1504,7 @@ type CreateNodeFromContentOptions = {
  * @param options Options for the parser
  * @returns The created Prosemirror node or fragment
  */
-declare function createNodeFromContent(content: Content | Node$1 | Fragment, schema: Schema, options?: CreateNodeFromContentOptions): Node$1 | Fragment;
+declare function createNodeFromContent(content: Content | Node$1 | Fragment$1, schema: Schema, options?: CreateNodeFromContentOptions): Node$1 | Fragment$1;
 
 /**
  * Gets the default block type at a given match
@@ -2027,9 +1628,9 @@ declare function getDebugJSON(node: Node$1, startOffset?: number): DebugJSONCont
  * @param context The context object that should be passed as `this` into the function
  * @returns The field value
  */
-declare function getExtensionField<T = any>(extension: AnyExtension, field: string, context?: Omit<MaybeThisParameterType<T>, 'parent'>): RemoveThis<T>;
+declare function getExtensionField<T = any, E extends AnyExtension = any>(extension: E, field: keyof ExtensionConfig | keyof MarkConfig | keyof NodeConfig, context?: Omit<MaybeThisParameterType<T>, 'parent'>): RemoveThis<T>;
 
-declare function getHTMLFromFragment(fragment: Fragment, schema: Schema): string;
+declare function getHTMLFromFragment(fragment: Fragment$1, schema: Schema): string;
 
 declare function getMarkAttributes(state: EditorState, typeOrName: string | MarkType$1): Record<string, any>;
 
@@ -2287,6 +1888,7 @@ declare class ExtensionManager {
      * @returns An object with all node views where the key is the node name and the value is the node view function
      */
     get nodeViews(): Record<string, NodeViewConstructor>;
+    get markViews(): Record<string, MarkViewConstructor>;
     /**
      * Go through all extensions, create extension storages & setup marks
      * & bind editor event listener.
@@ -2306,7 +1908,7 @@ declare class NodePos {
     actualDepth: number | null;
     get depth(): number;
     get pos(): number;
-    get content(): Fragment;
+    get content(): Fragment$1;
     set content(content: Content);
     get attributes(): {
         [key: string]: any;
@@ -2358,10 +1960,14 @@ declare module '@tiptap/core' {
         clearContent: {
             /**
              * Clear the whole document.
-             * @param emitUpdate Whether to emit an update event.
              * @example editor.commands.clearContent()
              */
-            clearContent: (emitUpdate?: boolean) => ReturnType;
+            clearContent: (
+            /**
+             * Whether to emit an update event.
+             * @default true
+             */
+            emitUpdate?: boolean) => ReturnType;
         };
     }
 }
@@ -2587,7 +2193,7 @@ declare module '@tiptap/core' {
             /**
              * The ProseMirror content to insert.
              */
-            value: Content | Node$1 | Fragment, 
+            value: Content | Node$1 | Fragment$1, 
             /**
              * Optional options
              */
@@ -2622,7 +2228,7 @@ declare module '@tiptap/core' {
             /**
              * The ProseMirror content to insert.
              */
-            value: Content | Node$1 | Fragment, 
+            value: Content | Node$1 | Fragment$1, 
             /**
              * Optional options
              */
@@ -2912,25 +2518,25 @@ declare module '@tiptap/core' {
             /**
              * The new content.
              */
-            content: Content | Fragment | Node$1, 
-            /**
-             * Whether to emit an update event.
-             * @default false
-             */
-            emitUpdate?: boolean, 
-            /**
-             * Options for parsing the content.
-             * @default {}
-             */
-            parseOptions?: ParseOptions, 
+            content: Content | Fragment$1 | Node$1, 
             /**
              * Options for `setContent`.
              */
             options?: {
+                /**
+                 * Options for parsing the content.
+                 * @default {}
+                 */
+                parseOptions?: ParseOptions;
                 /**
                  * Whether to throw an error if the content is invalid.
                  */
                 errorOnInvalidContent?: boolean;
+                /**
+                 * Whether to emit an update event.
+                 * @default true
+                 */
+                emitUpdate?: boolean;
             }) => ReturnType;
         };
     }
@@ -3218,6 +2824,11 @@ declare module '@tiptap/core' {
 
 declare const Commands$1: Extension<any, any>;
 
+/**
+ * This extension allows you to be notified when the user deletes content you are interested in.
+ */
+declare const Delete: Extension<any, any>;
+
 declare const Drop: Extension<any, any>;
 
 declare const Editable: Extension<any, any>;
@@ -3231,6 +2842,7 @@ declare const Paste: Extension<any, any>;
 declare const Tabindex: Extension<any, any>;
 
 declare const index_ClipboardTextSerializer: typeof ClipboardTextSerializer;
+declare const index_Delete: typeof Delete;
 declare const index_Drop: typeof Drop;
 declare const index_Editable: typeof Editable;
 declare const index_FocusEvents: typeof FocusEvents;
@@ -3238,7 +2850,7 @@ declare const index_Keymap: typeof Keymap;
 declare const index_Paste: typeof Paste;
 declare const index_Tabindex: typeof Tabindex;
 declare namespace index {
-  export { index_ClipboardTextSerializer as ClipboardTextSerializer, Commands$1 as Commands, index_Drop as Drop, index_Editable as Editable, index_FocusEvents as FocusEvents, index_Keymap as Keymap, index_Paste as Paste, index_Tabindex as Tabindex };
+  export { index_ClipboardTextSerializer as ClipboardTextSerializer, Commands$1 as Commands, index_Delete as Delete, index_Drop as Drop, index_Editable as Editable, index_FocusEvents as FocusEvents, index_Keymap as Keymap, index_Paste as Paste, index_Tabindex as Tabindex };
 }
 
 interface TiptapEditorHTMLElement extends HTMLElement {
@@ -3249,23 +2861,25 @@ declare class Editor extends EventEmitter<EditorEvents> {
     extensionManager: ExtensionManager;
     private css;
     schema: Schema;
-    view: EditorView;
+    private editorView;
     isFocused: boolean;
+    private editorState;
     /**
      * The editor is considered initialized after the `create` event has been emitted.
      */
     isInitialized: boolean;
-    extensionStorage: Record<string, any>;
+    extensionStorage: Storage;
     /**
      * A unique ID for this editor instance.
      */
     instanceId: string;
     options: EditorOptions;
     constructor(options?: Partial<EditorOptions>);
+    mount(el: NonNullable<EditorOptions['element']> & {}): void;
     /**
      * Returns the editor storage.
      */
-    get storage(): Record<string, any>;
+    get storage(): Storage;
     /**
      * An object of all registered commands.
      */
@@ -3296,6 +2910,10 @@ declare class Editor extends EventEmitter<EditorEvents> {
      * Returns whether the editor is editable.
      */
     get isEditable(): boolean;
+    /**
+     * Returns the editor state.
+     */
+    get view(): EditorView;
     /**
      * Returns the editor state.
      */
@@ -3327,6 +2945,10 @@ declare class Editor extends EventEmitter<EditorEvents> {
      * Creates a ProseMirror schema.
      */
     private createSchema;
+    /**
+     * Creates the initial document.
+     */
+    private createDoc;
     /**
      * Creates a ProseMirror view.
      */
@@ -3495,6 +3117,39 @@ declare function wrappingInputRule(config: {
     joinPredicate?: (match: ExtendedRegExpMatchArray, node: Node$1) => boolean;
 }): InputRule;
 
+type Attributes = Record<string, any>;
+type DOMOutputSpecElement = 0 | Attributes | DOMOutputSpecArray;
+/**
+ * Better describes the output of a `renderHTML` function in prosemirror
+ * @see https://prosemirror.net/docs/ref/#model.DOMOutputSpec
+ */
+type DOMOutputSpecArray = [string] | [string, Attributes] | [string, 0] | [string, Attributes, 0] | [string, Attributes, DOMOutputSpecArray | 0] | [string, DOMOutputSpecArray];
+declare global {
+    namespace JSX {
+        type Element = [string, ...any[]];
+        interface IntrinsicElements {
+            [key: string]: any;
+        }
+    }
+}
+type JSXRenderer = (tag: 'slot' | string | ((props?: Attributes) => DOMOutputSpecArray | DOMOutputSpecElement), props?: Attributes, ...children: JSXRenderer[]) => DOMOutputSpecArray | DOMOutputSpecElement;
+declare function Fragment(props: {
+    children: JSXRenderer[];
+}): JSXRenderer[];
+declare const h: JSXRenderer;
+
+declare class MarkView<Component, Options extends MarkViewRendererOptions = MarkViewRendererOptions> {
+    component: Component;
+    editor: Editor;
+    options: Options;
+    mark: MarkViewProps['mark'];
+    HTMLAttributes: MarkViewProps['HTMLAttributes'];
+    constructor(component: Component, props: MarkViewProps, options?: Partial<Options>);
+    get dom(): HTMLElement;
+    get contentDOM(): HTMLElement | null;
+    ignoreMutation(mutation: ViewMutationRecord): boolean;
+}
+
 /**
  * Node views are used to customize the rendered DOM structure of a node.
  * @see https://tiptap.dev/guide/node-views
@@ -3606,6 +3261,8 @@ declare function findDuplicates<T>(items: T[]): T[];
 
 declare function fromString(value: any): any;
 
+declare function isAndroid(): boolean;
+
 declare function isEmptyObject(value?: {}): boolean;
 
 declare function isFunction(value: any): value is Function;
@@ -3648,11 +3305,7 @@ declare function removeDuplicates<T>(array: T[], by?: {
 
 interface Commands<ReturnType = any> {
 }
-interface ExtensionConfig<Options = any, Storage = any> {
-}
-interface NodeConfig<Options = any, Storage = any> {
-}
-interface MarkConfig<Options = any, Storage = any> {
+interface Storage {
 }
 
-export { type AnyCommands, type AnyConfig, type AnyExtension, type Attribute, type Attributes, type CanCommands, type ChainedCommands, type ChangedRange, type Command, CommandManager, type CommandProps, type CommandSpec, type Commands, type Content, type CreateNodeFromContentOptions, type DOMNode, type DOMOutputSpecArray, type DecorationType, type DecorationWithType, type Diff, type Dispatch, type DocumentType, Editor, type EditorEvents, type EditorOptions, type EnableRules, type ExtendedRegExpMatchArray, Extension, type ExtensionAttribute, type ExtensionConfig, type Extensions, type FocusPosition, type GlobalAttributes, type HTMLContent, InputRule, type InputRuleFinder, type InputRuleMatch, type JSONContent, type KeyboardShortcutCommand, type KeysWithTypeOf, Mark, type MarkConfig, type MarkRange, type MarkType, type MaybeReturnType, type MaybeThisParameterType, Node, type NodeConfig, NodePos, type NodeRange, type NodeType, NodeView, type NodeViewProps, type NodeViewRenderer, type NodeViewRendererOptions, type NodeViewRendererProps, type NodeWithPos, type Overwrite, type ParentConfig, PasteRule, type PasteRuleFinder, type PasteRuleMatch, type PickValue, type Predicate, type Primitive, type Range, type RawCommands, type RemoveThis, type SingleCommands, type TextSerializer, type TextType, type TiptapEditorHTMLElement, Tracker, type TrackerResult, type UnionCommands, type UnionToIntersection, type ValuesOf, callOrReturn, combineTransactionSteps, createChainableState, createDocument, createNodeFromContent, createStyleTag, defaultBlockAt, deleteProps, elementFromString, escapeForRegEx, index as extensions, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, flattenExtensions, fromString, generateHTML, generateJSON, generateText, getAttributes, getAttributesFromExtensions, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAtPosition, getNodeAttributes, getNodeType, getRenderedAttributes, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, injectExtensionAttributesToParseRule, inputRulesPlugin, isActive, isAtEndOfNode, isAtStartOfNode, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isRegExp, isString, isTextSelection, isiOS, markInputRule, markPasteRule, mergeAttributes, mergeDeep, minMax, nodeInputRule, nodePasteRule, objectIncludes, pasteRulesPlugin, posToDOMRect, removeDuplicates, resolveExtensions, resolveFocusPosition, rewriteUnknownContent, selectionToInsertionEnd, sortExtensions, splitExtensions, textInputRule, textPasteRule, textblockTypeInputRule, wrappingInputRule };
+export { type AnyCommands, type AnyConfig, type AnyExtension, type Attribute, type Attributes$1 as Attributes, type CanCommands, type ChainedCommands, type ChangedRange, type Command, CommandManager, type CommandProps, type CommandSpec, type Commands, type Content, type CreateNodeFromContentOptions, type DOMNode, type DOMOutputSpecArray$1 as DOMOutputSpecArray, type DecorationType, type DecorationWithType, type Diff, type Dispatch, type DocumentType, Editor, type EditorEvents, type EditorOptions, type EnableRules, type ExtendedRegExpMatchArray, Extension, type ExtensionAttribute, type ExtensionConfig, type Extensions, type FocusPosition, Fragment, type GlobalAttributes, type HTMLContent, InputRule, type InputRuleFinder, type InputRuleMatch, type JSONContent, type KeyboardShortcutCommand, type KeysWithTypeOf, Mark, type MarkConfig, type MarkRange, type MarkType, MarkView, type MarkViewProps, type MarkViewRenderer, type MarkViewRendererOptions, type MarkViewRendererProps, type MaybeReturnType, type MaybeThisParameterType, Node, type NodeConfig, NodePos, type NodeRange, type NodeType, NodeView, type NodeViewProps, type NodeViewRenderer, type NodeViewRendererOptions, type NodeViewRendererProps, type NodeWithPos, type Overwrite, type ParentConfig, PasteRule, type PasteRuleFinder, type PasteRuleMatch, type PickValue, type Predicate, type Primitive, type Range, type RawCommands, type RemoveThis, type SingleCommands, type Storage, type TextSerializer, type TextType, type TiptapEditorHTMLElement, Tracker, type TrackerResult, type UnionCommands, type UnionToIntersection, type ValuesOf, callOrReturn, combineTransactionSteps, createChainableState, createDocument, h as createElement, createNodeFromContent, createStyleTag, defaultBlockAt, deleteProps, elementFromString, escapeForRegEx, index as extensions, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, flattenExtensions, fromString, generateHTML, generateJSON, generateText, getAttributes, getAttributesFromExtensions, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAtPosition, getNodeAttributes, getNodeType, getRenderedAttributes, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, h, injectExtensionAttributesToParseRule, inputRulesPlugin, isActive, isAndroid, isAtEndOfNode, isAtStartOfNode, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isRegExp, isString, isTextSelection, isiOS, markInputRule, markPasteRule, mergeAttributes, mergeDeep, minMax, nodeInputRule, nodePasteRule, objectIncludes, pasteRulesPlugin, posToDOMRect, removeDuplicates, resolveExtensions, resolveFocusPosition, rewriteUnknownContent, selectionToInsertionEnd, sortExtensions, splitExtensions, textInputRule, textPasteRule, textblockTypeInputRule, wrappingInputRule };