@tiptap/core 2.0.0-beta.18 → 2.0.0-beta.180

package/dist/tiptap-core.esm.js

@@ -1,276 +1,66 @@
 import { Plugin, PluginKey, TextSelection, Selection, NodeSelection, EditorState } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
-import { DOMParser, DOMSerializer, Schema, Fragment, Slice, Node as Node$1 } from 'prosemirror-model';
 import { keymap } from 'prosemirror-keymap';
-import { inputRules, undoInputRule as undoInputRule$2, InputRule } from 'prosemirror-inputrules';
-import { liftTarget, ReplaceStep, ReplaceAroundStep, canSplit } from 'prosemirror-transform';
-import { createParagraphNear as createParagraphNear$2, deleteSelection as deleteSelection$2, exitCode as exitCode$2, joinBackward as joinBackward$2, joinForward as joinForward$2, lift as lift$2, liftEmptyBlock as liftEmptyBlock$2, newlineInCode as newlineInCode$2, selectAll as selectAll$2, selectNodeBackward as selectNodeBackward$2, selectNodeForward as selectNodeForward$2, selectParentNode as selectParentNode$2, setBlockType, wrapIn as wrapIn$2 } from 'prosemirror-commands';
-import { liftListItem as liftListItem$2, sinkListItem as sinkListItem$2, wrapInList as wrapInList$2 } from 'prosemirror-schema-list';
-
-function getNodeType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        return schema.nodes[nameOrType];
-    }
-    return nameOrType;
-}
-
-function getNodeAttributes(state, typeOrName) {
-    const type = getNodeType(typeOrName, state.schema);
-    const { from, to } = state.selection;
-    let nodes = [];
-    state.doc.nodesBetween(from, to, node => {
-        nodes = [...nodes, node];
-    });
-    const node = nodes
-        .reverse()
-        .find(nodeItem => nodeItem.type.name === type.name);
-    if (node) {
-        return { ...node.attrs };
-    }
-    return {};
-}
-
-function getMarkType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        return schema.marks[nameOrType];
-    }
-    return nameOrType;
-}
-
-function getMarkAttributes(state, typeOrName) {
-    const type = getMarkType(typeOrName, state.schema);
-    const { from, to, empty } = state.selection;
-    let marks = [];
-    if (empty) {
-        marks = state.selection.$head.marks();
-    }
-    else {
-        state.doc.nodesBetween(from, to, node => {
-            marks = [...marks, ...node.marks];
-        });
-    }
-    const mark = marks.find(markItem => markItem.type.name === type.name);
-    if (mark) {
-        return { ...mark.attrs };
-    }
-    return {};
-}
-
-/**
- * Check if object1 includes object2
- * @param object1 Object
- * @param object2 Object
- */
-function objectIncludes(object1, object2) {
-    const keys = Object.keys(object2);
-    if (!keys.length) {
-        return true;
-    }
-    return !!keys
-        .filter(key => object2[key] === object1[key])
-        .length;
-}
-
-function isNodeActive(state, typeOrName, attributes = {}) {
-    const { from, to, empty } = state.selection;
-    const type = typeOrName
-        ? getNodeType(typeOrName, state.schema)
-        : null;
-    let nodeRanges = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        if (!node.isText) {
-            const relativeFrom = Math.max(from, pos);
-            const relativeTo = Math.min(to, pos + node.nodeSize);
-            nodeRanges = [...nodeRanges, {
-                    node,
-                    from: relativeFrom,
-                    to: relativeTo,
-                }];
-        }
-    });
-    if (empty) {
-        return !!nodeRanges
-            .filter(nodeRange => {
-            if (!type) {
-                return true;
-            }
-            return type.name === nodeRange.node.type.name;
-        })
-            .find(nodeRange => objectIncludes(nodeRange.node.attrs, attributes));
-    }
-    const selectionRange = to - from;
-    const range = nodeRanges
-        .filter(nodeRange => {
-        if (!type) {
-            return true;
-        }
-        return type.name === nodeRange.node.type.name;
-    })
-        .filter(nodeRange => objectIncludes(nodeRange.node.attrs, attributes))
-        .reduce((sum, nodeRange) => {
-        const size = nodeRange.to - nodeRange.from;
-        return sum + size;
-    }, 0);
-    return range >= selectionRange;
-}
-
-function isMarkActive(state, typeOrName, attributes = {}) {
-    const { from, to, empty } = state.selection;
-    const type = typeOrName
-        ? getMarkType(typeOrName, state.schema)
-        : null;
-    if (empty) {
-        return !!(state.storedMarks || state.selection.$from.marks())
-            .filter(mark => {
-            if (!type) {
-                return true;
-            }
-            return type.name === mark.type.name;
-        })
-            .find(mark => objectIncludes(mark.attrs, attributes));
-    }
-    let selectionRange = 0;
-    let markRanges = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.isText) {
-            const relativeFrom = Math.max(from, pos);
-            const relativeTo = Math.min(to, pos + node.nodeSize);
-            const range = relativeTo - relativeFrom;
-            selectionRange += range;
-            markRanges = [...markRanges, ...node.marks.map(mark => ({
-                    mark,
-                    from: relativeFrom,
-                    to: relativeTo,
-                }))];
-        }
-    });
-    if (selectionRange === 0) {
-        return false;
-    }
-    const range = markRanges
-        .filter(markRange => {
-        if (!type) {
-            return true;
-        }
-        return type.name === markRange.mark.type.name;
-    })
-        .filter(markRange => objectIncludes(markRange.mark.attrs, attributes))
-        .reduce((sum, markRange) => {
-        const size = markRange.to - markRange.from;
-        return sum + size;
-    }, 0);
-    return range >= selectionRange;
-}
-
-function getSchemaTypeNameByName(name, schema) {
-    if (schema.nodes[name]) {
-        return 'node';
-    }
-    if (schema.marks[name]) {
-        return 'mark';
-    }
-    return null;
-}
-
-function isActive(state, name, attributes = {}) {
-    if (!name) {
-        return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes);
-    }
-    const schemaType = getSchemaTypeNameByName(name, state.schema);
-    if (schemaType === 'node') {
-        return isNodeActive(state, name, attributes);
-    }
-    if (schemaType === 'mark') {
-        return isMarkActive(state, name, attributes);
-    }
-    return false;
-}
-
-function removeElement(element) {
-    if (element && element.parentNode) {
-        element.parentNode.removeChild(element);
-    }
-}
-
-function elementFromString(value) {
-    const htmlString = `<div>${value}</div>`;
-    const parser = new window.DOMParser();
-    const element = parser.parseFromString(htmlString, 'text/html').body;
-    return element;
-}
-
-function createNodeFromContent(content, schema, options) {
-    options = {
-        slice: true,
-        parseOptions: {},
-        ...options,
+import { Schema, Fragment, DOMParser, Slice, DOMSerializer, Node as Node$1 } from 'prosemirror-model';
+import { liftTarget, ReplaceStep, ReplaceAroundStep, canSplit, canJoin, Transform, findWrapping } from 'prosemirror-transform';
+import { createParagraphNear as createParagraphNear$1, deleteSelection as deleteSelection$1, exitCode as exitCode$1, joinBackward as joinBackward$1, joinForward as joinForward$1, lift as lift$1, liftEmptyBlock as liftEmptyBlock$1, newlineInCode as newlineInCode$1, selectNodeBackward as selectNodeBackward$1, selectNodeForward as selectNodeForward$1, selectParentNode as selectParentNode$1, selectTextblockEnd as selectTextblockEnd$1, selectTextblockStart as selectTextblockStart$1, setBlockType, wrapIn as wrapIn$1 } from 'prosemirror-commands';
+import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, wrapInList as wrapInList$1 } from 'prosemirror-schema-list';
+
+function createChainableState(config) {
+    const { state, transaction } = config;
+    let { selection } = transaction;
+    let { doc } = transaction;
+    let { storedMarks } = transaction;
+    return {
+        ...state,
+        apply: state.apply.bind(state),
+        applyTransaction: state.applyTransaction.bind(state),
+        filterTransaction: state.filterTransaction,
+        plugins: state.plugins,
+        schema: state.schema,
+        reconfigure: state.reconfigure.bind(state),
+        toJSON: state.toJSON.bind(state),
+        get storedMarks() {
+            return storedMarks;
+        },
+        get selection() {
+            return selection;
+        },
+        get doc() {
+            return doc;
+        },
+        get tr() {
+            selection = transaction.selection;
+            doc = transaction.doc;
+            storedMarks = transaction.storedMarks;
+            return transaction;
+        },
     };
-    if (content && typeof content === 'object') {
-        try {
-            return schema.nodeFromJSON(content);
-        }
-        catch (error) {
-            console.warn('[tiptap warn]: Invalid content.', 'Passed value:', content, 'Error:', error);
-            return createNodeFromContent('', schema, options);
-        }
-    }
-    if (typeof content === 'string') {
-        const isHTML = content.trim().startsWith('<') && content.trim().endsWith('>');
-        if (isHTML || !options.slice) {
-            const parser = DOMParser.fromSchema(schema);
-            return options.slice
-                ? parser.parseSlice(elementFromString(content), options.parseOptions).content
-                : parser.parse(elementFromString(content), options.parseOptions);
-        }
-        return content;
-    }
-    return createNodeFromContent('', schema, options);
-}
-
-function createDocument(content, schema, parseOptions = {}) {
-    return createNodeFromContent(content, schema, { slice: false, parseOptions });
-}
-
-function getHTMLFromFragment(doc, schema) {
-    const fragment = DOMSerializer
-        .fromSchema(schema)
-        .serializeFragment(doc.content);
-    const temporaryDocument = document.implementation.createHTMLDocument();
-    const container = temporaryDocument.createElement('div');
-    container.appendChild(fragment);
-    return container.innerHTML;
-}
-
-function isNodeEmpty(node) {
-    var _a;
-    const defaultContent = (_a = node.type.createAndFill()) === null || _a === void 0 ? void 0 : _a.toJSON();
-    const content = node.toJSON();
-    return JSON.stringify(defaultContent) === JSON.stringify(content);
-}
-
-function createStyleTag(style) {
-    const styleNode = document.createElement('style');
-    styleNode.innerHTML = style;
-    document.getElementsByTagName('head')[0].appendChild(styleNode);
-    return styleNode;
 }
 
 class CommandManager {
-    constructor(editor, commands) {
-        this.editor = editor;
-        this.commands = commands;
+    constructor(props) {
+        this.editor = props.editor;
+        this.rawCommands = this.editor.extensionManager.commands;
+        this.customState = props.state;
+    }
+    get hasCustomState() {
+        return !!this.customState;
     }
-    createCommands() {
-        const { commands, editor } = this;
-        const { state, view } = editor;
+    get state() {
+        return this.customState || this.editor.state;
+    }
+    get commands() {
+        const { rawCommands, editor, state } = this;
+        const { view } = editor;
         const { tr } = state;
         const props = this.buildProps(tr);
         return Object.fromEntries(Object
-            .entries(commands)
+            .entries(rawCommands)
             .map(([name, command]) => {
             const method = (...args) => {
                 const callback = command(...args)(props);
-                if (!tr.getMeta('preventDispatch')) {
+                if (!tr.getMeta('preventDispatch') && !this.hasCustomState) {
                     view.dispatch(tr);
                 }
                 return callback;
@@ -278,20 +68,29 @@ class CommandManager {
             return [name, method];
         }));
     }
+    get chain() {
+        return () => this.createChain();
+    }
+    get can() {
+        return () => this.createCan();
+    }
     createChain(startTr, shouldDispatch = true) {
-        const { commands, editor } = this;
-        const { state, view } = editor;
+        const { rawCommands, editor, state } = this;
+        const { view } = editor;
         const callbacks = [];
         const hasStartTransaction = !!startTr;
         const tr = startTr || state.tr;
         const run = () => {
-            if (!hasStartTransaction && shouldDispatch && !tr.getMeta('preventDispatch')) {
+            if (!hasStartTransaction
+                && shouldDispatch
+                && !tr.getMeta('preventDispatch')
+                && !this.hasCustomState) {
                 view.dispatch(tr);
             }
-            return () => callbacks.every(callback => callback === true);
+            return callbacks.every(callback => callback === true);
         };
         const chain = {
-            ...Object.fromEntries(Object.entries(commands).map(([name, command]) => {
+            ...Object.fromEntries(Object.entries(rawCommands).map(([name, command]) => {
                 const chainedCommand = (...args) => {
                     const props = this.buildProps(tr, shouldDispatch);
                     const callback = command(...args)(props);
@@ -305,13 +104,12 @@ class CommandManager {
         return chain;
     }
     createCan(startTr) {
-        const { commands, editor } = this;
-        const { state } = editor;
+        const { rawCommands, state } = this;
         const dispatch = undefined;
         const tr = startTr || state.tr;
         const props = this.buildProps(tr, dispatch);
         const formattedCommands = Object.fromEntries(Object
-            .entries(commands)
+            .entries(rawCommands)
             .map(([name, command]) => {
             return [name, (...args) => command(...args)({ ...props, dispatch })];
         }));
@@ -321,8 +119,8 @@ class CommandManager {
         };
     }
     buildProps(tr, shouldDispatch = true) {
-        const { editor, commands } = this;
-        const { state, view } = editor;
+        const { rawCommands, editor, state } = this;
+        const { view } = editor;
         if (state.storedMarks) {
             tr.setStoredMarks(state.storedMarks);
         }
@@ -330,7 +128,10 @@ class CommandManager {
             tr,
             editor,
             view,
-            state: this.chainableState(tr, state),
+            state: createChainableState({
+                state,
+                transaction: tr,
+            }),
             dispatch: shouldDispatch
                 ? () => undefined
                 : undefined,
@@ -338,7 +139,7 @@ class CommandManager {
             can: () => this.createCan(tr),
             get commands() {
                 return Object.fromEntries(Object
-                    .entries(commands)
+                    .entries(rawCommands)
                     .map(([name, command]) => {
                     return [name, (...args) => command(...args)(props)];
                 }));
@@ -346,35 +147,57 @@ class CommandManager {
         };
         return props;
     }
-    chainableState(tr, state) {
-        let { selection } = tr;
-        let { doc } = tr;
-        let { storedMarks } = tr;
-        return {
-            ...state,
-            schema: state.schema,
-            plugins: state.plugins,
-            apply: state.apply.bind(state),
-            applyTransaction: state.applyTransaction.bind(state),
-            reconfigure: state.reconfigure.bind(state),
-            toJSON: state.toJSON.bind(state),
-            get storedMarks() {
-                return storedMarks;
-            },
-            get selection() {
-                return selection;
-            },
-            get doc() {
-                return doc;
-            },
-            get tr() {
-                selection = tr.selection;
-                doc = tr.doc;
-                storedMarks = tr.storedMarks;
-                return tr;
-            },
-        };
+}
+
+class EventEmitter {
+    constructor() {
+        this.callbacks = {};
+    }
+    on(event, fn) {
+        if (!this.callbacks[event]) {
+            this.callbacks[event] = [];
+        }
+        this.callbacks[event].push(fn);
+        return this;
+    }
+    emit(event, ...args) {
+        const callbacks = this.callbacks[event];
+        if (callbacks) {
+            callbacks.forEach(callback => callback.apply(this, args));
+        }
+        return this;
     }
+    off(event, fn) {
+        const callbacks = this.callbacks[event];
+        if (callbacks) {
+            if (fn) {
+                this.callbacks[event] = callbacks.filter(callback => callback !== fn);
+            }
+            else {
+                delete this.callbacks[event];
+            }
+        }
+        return this;
+    }
+    removeAllListeners() {
+        this.callbacks = {};
+    }
+}
+
+function getExtensionField(extension, field, context) {
+    if (extension.config[field] === undefined && extension.parent) {
+        return getExtensionField(extension.parent, field, context);
+    }
+    if (typeof extension.config[field] === 'function') {
+        const value = extension.config[field].bind({
+            ...context,
+            parent: extension.parent
+                ? getExtensionField(extension.parent, field, context)
+                : null,
+        });
+        return value;
+    }
+    return extension.config[field];
 }
 
 function splitExtensions(extensions) {
@@ -402,15 +225,20 @@ function getAttributesFromExtensions(extensions) {
         renderHTML: null,
         parseHTML: null,
         keepOnSplit: true,
+        isRequired: false,
     };
     extensions.forEach(extension => {
         const context = {
+            name: extension.name,
             options: extension.options,
+            storage: extension.storage,
         };
-        if (!extension.config.addGlobalAttributes) {
+        const addGlobalAttributes = getExtensionField(extension, 'addGlobalAttributes', context);
+        if (!addGlobalAttributes) {
             return;
         }
-        const globalAttributes = extension.config.addGlobalAttributes.bind(context)();
+        // TODO: remove `as GlobalAttributes`
+        const globalAttributes = addGlobalAttributes();
         globalAttributes.forEach(globalAttribute => {
             globalAttribute.types.forEach(type => {
                 Object
@@ -430,28 +258,46 @@ function getAttributesFromExtensions(extensions) {
     });
     nodeAndMarkExtensions.forEach(extension => {
         const context = {
+            name: extension.name,
             options: extension.options,
+            storage: extension.storage,
         };
-        if (!extension.config.addAttributes) {
+        const addAttributes = getExtensionField(extension, 'addAttributes', context);
+        if (!addAttributes) {
             return;
         }
-        const attributes = extension.config.addAttributes.bind(context)();
+        // TODO: remove `as Attributes`
+        const attributes = addAttributes();
         Object
             .entries(attributes)
             .forEach(([name, attribute]) => {
+            const mergedAttr = {
+                ...defaultAttribute,
+                ...attribute,
+            };
+            if (attribute.isRequired && attribute.default === undefined) {
+                delete mergedAttr.default;
+            }
             extensionAttributes.push({
-                type: extension.config.name,
+                type: extension.name,
                 name,
-                attribute: {
-                    ...defaultAttribute,
-                    ...attribute,
-                },
+                attribute: mergedAttr,
             });
         });
     });
     return extensionAttributes;
 }
 
+function getNodeType(nameOrType, schema) {
+    if (typeof nameOrType === 'string') {
+        if (!schema.nodes[nameOrType]) {
+            throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
+        }
+        return schema.nodes[nameOrType];
+    }
+    return nameOrType;
+}
+
 function mergeAttributes(...objects) {
     return objects
         .filter(item => !!item)
@@ -488,20 +334,39 @@ function getRenderedAttributes(nodeOrMark, extensionAttributes) {
         }
         return item.attribute.renderHTML(nodeOrMark.attrs) || {};
     })
-        .reduce((attributes, attribute) => {
-        return mergeAttributes(attributes, attribute);
-    }, {});
+        .reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {});
+}
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+/**
+ * Optionally calls `value` as a function.
+ * Otherwise it is returned directly.
+ * @param value Function or any value.
+ * @param context Optional context to bind to function.
+ * @param props Optional props to pass to function.
+ */
+function callOrReturn(value, context = undefined, ...props) {
+    if (isFunction(value)) {
+        if (context) {
+            return value.bind(context)(...props);
+        }
+        return value(...props);
+    }
+    return value;
 }
 
-function isEmptyObject(object = {}) {
-    return Object.keys(object).length === 0 && object.constructor === Object;
+function isEmptyObject(value = {}) {
+    return Object.keys(value).length === 0 && value.constructor === Object;
 }
 
 function fromString(value) {
     if (typeof value !== 'string') {
         return value;
     }
-    if (value.match(/^\d*(\.\d+)?$/)) {
+    if (value.match(/^[+-]?(?:\d*\.)?\d+$/)) {
         return Number(value);
     }
     if (value === 'true') {
@@ -532,19 +397,16 @@ function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
             if (oldAttributes === false) {
                 return false;
             }
-            const newAttributes = extensionAttributes
-                .filter(item => item.attribute.rendered)
-                .reduce((items, item) => {
-                const attributes = item.attribute.parseHTML
-                    ? item.attribute.parseHTML(node) || {}
-                    : {
-                        [item.name]: fromString(node.getAttribute(item.name)),
-                    };
-                const filteredAttributes = Object.fromEntries(Object.entries(attributes)
-                    .filter(([, value]) => value !== undefined && value !== null));
+            const newAttributes = extensionAttributes.reduce((items, item) => {
+                const value = item.attribute.parseHTML
+                    ? item.attribute.parseHTML(node)
+                    : fromString(node.getAttribute(item.name));
+                if (value === null || value === undefined) {
+                    return items;
+                }
                 return {
                     ...items,
-                    ...filteredAttributes,
+                    [item.name]: value,
                 };
             }, {});
             return { ...oldAttributes, ...newAttributes };
@@ -552,23 +414,6 @@ function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
     };
 }
 
-/**
- * Optionally calls `value` as a function.
- * Otherwise it is returned directly.
- * @param value Function or any value.
- * @param context Optional context to bind to function.
- * @param props Optional props to pass to function.
- */
-function callOrReturn(value, context = undefined, ...props) {
-    if (typeof value === 'function') {
-        if (context) {
-            return value.bind(context)(...props);
-        }
-        return value(...props);
-    }
-    return value;
-}
-
 function cleanUpSchemaItem(data) {
     return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
         if (key === 'attrs' && isEmptyObject(value)) {
@@ -577,100 +422,99 @@ function cleanUpSchemaItem(data) {
         return value !== null && value !== undefined;
     }));
 }
-function getSchema(extensions) {
+function getSchemaByResolvedExtensions(extensions) {
     var _a;
     const allAttributes = getAttributesFromExtensions(extensions);
     const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-    const topNode = (_a = nodeExtensions.find(extension => extension.config.topNode)) === null || _a === void 0 ? void 0 : _a.config.name;
-    const nodeSchemaExtenders = [];
-    const markSchemaExtenders = [];
-    extensions.forEach(extension => {
-        if (typeof extension.config.extendNodeSchema === 'function') {
-            nodeSchemaExtenders.push(extension.config.extendNodeSchema);
-        }
-        if (typeof extension.config.extendMarkSchema === 'function') {
-            markSchemaExtenders.push(extension.config.extendMarkSchema);
-        }
-    });
+    const topNode = (_a = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))) === null || _a === void 0 ? void 0 : _a.name;
     const nodes = Object.fromEntries(nodeExtensions.map(extension => {
-        var _a;
-        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name);
-        const context = { options: extension.options };
-        const extraNodeFields = nodeSchemaExtenders.reduce((fields, nodeSchemaExtender) => {
-            const extraFields = callOrReturn(nodeSchemaExtender, context, extension);
+        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name);
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        const extraNodeFields = extensions.reduce((fields, e) => {
+            const extendNodeSchema = getExtensionField(e, 'extendNodeSchema', context);
             return {
                 ...fields,
-                ...extraFields,
+                ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
             };
         }, {});
         const schema = cleanUpSchemaItem({
             ...extraNodeFields,
-            content: callOrReturn(extension.config.content, context),
-            marks: callOrReturn(extension.config.marks, context),
-            group: callOrReturn(extension.config.group, context),
-            inline: callOrReturn(extension.config.inline, context),
-            atom: callOrReturn(extension.config.atom, context),
-            selectable: callOrReturn(extension.config.selectable, context),
-            draggable: callOrReturn(extension.config.draggable, context),
-            code: callOrReturn(extension.config.code, context),
-            defining: callOrReturn(extension.config.defining, context),
-            isolating: callOrReturn(extension.config.isolating, context),
+            content: callOrReturn(getExtensionField(extension, 'content', context)),
+            marks: callOrReturn(getExtensionField(extension, 'marks', context)),
+            group: callOrReturn(getExtensionField(extension, 'group', context)),
+            inline: callOrReturn(getExtensionField(extension, 'inline', context)),
+            atom: callOrReturn(getExtensionField(extension, 'atom', context)),
+            selectable: callOrReturn(getExtensionField(extension, 'selectable', context)),
+            draggable: callOrReturn(getExtensionField(extension, 'draggable', context)),
+            code: callOrReturn(getExtensionField(extension, 'code', context)),
+            defining: callOrReturn(getExtensionField(extension, 'defining', context)),
+            isolating: callOrReturn(getExtensionField(extension, 'isolating', context)),
             attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
                 var _a;
                 return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
             })),
         });
-        if (extension.config.parseHTML) {
-            schema.parseDOM = (_a = extension.config.parseHTML
-                .bind(context)()) === null || _a === void 0 ? void 0 : _a.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+        const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
+        if (parseHTML) {
+            schema.parseDOM = parseHTML
+                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
         }
-        if (extension.config.renderHTML) {
-            schema.toDOM = node => {
-                var _a;
-                return (_a = extension.config.renderHTML) === null || _a === void 0 ? void 0 : _a.bind(context)({
-                    node,
-                    HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-                });
-            };
+        const renderHTML = getExtensionField(extension, 'renderHTML', context);
+        if (renderHTML) {
+            schema.toDOM = node => renderHTML({
+                node,
+                HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+            });
+        }
+        const renderText = getExtensionField(extension, 'renderText', context);
+        if (renderText) {
+            schema.toText = renderText;
         }
-        return [extension.config.name, schema];
+        return [extension.name, schema];
     }));
     const marks = Object.fromEntries(markExtensions.map(extension => {
-        var _a;
-        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name);
-        const context = { options: extension.options };
-        const extraMarkFields = markSchemaExtenders.reduce((fields, markSchemaExtender) => {
-            const extraFields = callOrReturn(markSchemaExtender, context, extension);
+        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name);
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        const extraMarkFields = extensions.reduce((fields, e) => {
+            const extendMarkSchema = getExtensionField(e, 'extendMarkSchema', context);
             return {
                 ...fields,
-                ...extraFields,
+                ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
             };
         }, {});
         const schema = cleanUpSchemaItem({
             ...extraMarkFields,
-            inclusive: callOrReturn(extension.config.inclusive, context),
-            excludes: callOrReturn(extension.config.excludes, context),
-            group: callOrReturn(extension.config.group, context),
-            spanning: callOrReturn(extension.config.spanning, context),
+            inclusive: callOrReturn(getExtensionField(extension, 'inclusive', context)),
+            excludes: callOrReturn(getExtensionField(extension, 'excludes', context)),
+            group: callOrReturn(getExtensionField(extension, 'group', context)),
+            spanning: callOrReturn(getExtensionField(extension, 'spanning', context)),
+            code: callOrReturn(getExtensionField(extension, 'code', context)),
             attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
                 var _a;
                 return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
             })),
         });
-        if (extension.config.parseHTML) {
-            schema.parseDOM = (_a = extension.config.parseHTML
-                .bind(context)()) === null || _a === void 0 ? void 0 : _a.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+        const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
+        if (parseHTML) {
+            schema.parseDOM = parseHTML
+                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
         }
-        if (extension.config.renderHTML) {
-            schema.toDOM = mark => {
-                var _a;
-                return (_a = extension.config.renderHTML) === null || _a === void 0 ? void 0 : _a.bind(context)({
-                    mark,
-                    HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-                });
-            };
+        const renderHTML = getExtensionField(extension, 'renderHTML', context);
+        if (renderHTML) {
+            schema.toDOM = mark => renderHTML({
+                mark,
+                HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+            });
         }
-        return [extension.config.name, schema];
+        return [extension.name, schema];
     }));
     return new Schema({
         topNode,
@@ -680,67 +524,453 @@ function getSchema(extensions) {
 }
 
 function getSchemaTypeByName(name, schema) {
-    if (schema.nodes[name]) {
-        return schema.nodes[name];
+    return schema.nodes[name] || schema.marks[name] || null;
+}
+
+function isExtensionRulesEnabled(extension, enabled) {
+    if (Array.isArray(enabled)) {
+        return enabled.some(enabledExtension => {
+            const name = typeof enabledExtension === 'string'
+                ? enabledExtension
+                : enabledExtension.name;
+            return name === extension.name;
+        });
     }
-    if (schema.marks[name]) {
-        return schema.marks[name];
+    return enabled;
+}
+
+const getTextContentFromNodes = ($from, maxMatch = 500) => {
+    let textBefore = '';
+    $from.parent.nodesBetween(Math.max(0, $from.parentOffset - maxMatch), $from.parentOffset, (node, pos, parent, index) => {
+        var _a, _b;
+        textBefore += ((_b = (_a = node.type.spec).toText) === null || _b === void 0 ? void 0 : _b.call(_a, {
+            node, pos, parent, index,
+        })) || node.textContent || '%leaf%';
+    });
+    return textBefore;
+};
+
+function isRegExp(value) {
+    return Object.prototype.toString.call(value) === '[object RegExp]';
+}
+
+class InputRule {
+    constructor(config) {
+        this.find = config.find;
+        this.handler = config.handler;
     }
-    return null;
+}
+const inputRuleMatcherHandler = (text, find) => {
+    if (isRegExp(find)) {
+        return find.exec(text);
+    }
+    const inputRuleMatch = find(text);
+    if (!inputRuleMatch) {
+        return null;
+    }
+    const result = [];
+    result.push(inputRuleMatch.text);
+    result.index = inputRuleMatch.index;
+    result.input = text;
+    result.data = inputRuleMatch.data;
+    if (inputRuleMatch.replaceWith) {
+        if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
+            console.warn('[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".');
+        }
+        result.push(inputRuleMatch.replaceWith);
+    }
+    return result;
+};
+function run$1(config) {
+    var _a;
+    const { editor, from, to, text, rules, plugin, } = config;
+    const { view } = editor;
+    if (view.composing) {
+        return false;
+    }
+    const $from = view.state.doc.resolve(from);
+    if (
+    // check for code node
+    $from.parent.type.spec.code
+        // check for code mark
+        || !!((_a = ($from.nodeBefore || $from.nodeAfter)) === null || _a === void 0 ? void 0 : _a.marks.find(mark => mark.type.spec.code))) {
+        return false;
+    }
+    let matched = false;
+    const textBefore = getTextContentFromNodes($from) + text;
+    rules.forEach(rule => {
+        if (matched) {
+            return;
+        }
+        const match = inputRuleMatcherHandler(textBefore, rule.find);
+        if (!match) {
+            return;
+        }
+        const tr = view.state.tr;
+        const state = createChainableState({
+            state: view.state,
+            transaction: tr,
+        });
+        const range = {
+            from: from - (match[0].length - text.length),
+            to,
+        };
+        const { commands, chain, can } = new CommandManager({
+            editor,
+            state,
+        });
+        const handler = rule.handler({
+            state,
+            range,
+            match,
+            commands,
+            chain,
+            can,
+        });
+        // stop if there are no changes
+        if (handler === null || !tr.steps.length) {
+            return;
+        }
+        // store transform as meta data
+        // so we can undo input rules within the `undoInputRules` command
+        tr.setMeta(plugin, {
+            transform: tr,
+            from,
+            to,
+            text,
+        });
+        view.dispatch(tr);
+        matched = true;
+    });
+    return matched;
+}
+/**
+ * Create an input rules plugin. When enabled, it will cause text
+ * input that matches any of the given rules to trigger the rule’s
+ * action.
+ */
+function inputRulesPlugin(props) {
+    const { editor, rules } = props;
+    const plugin = new Plugin({
+        state: {
+            init() {
+                return null;
+            },
+            apply(tr, prev) {
+                const stored = tr.getMeta(plugin);
+                if (stored) {
+                    return stored;
+                }
+                return tr.selectionSet || tr.docChanged
+                    ? null
+                    : prev;
+            },
+        },
+        props: {
+            handleTextInput(view, from, to, text) {
+                return run$1({
+                    editor,
+                    from,
+                    to,
+                    text,
+                    rules,
+                    plugin,
+                });
+            },
+            handleDOMEvents: {
+                compositionend: view => {
+                    setTimeout(() => {
+                        const { $cursor } = view.state.selection;
+                        if ($cursor) {
+                            run$1({
+                                editor,
+                                from: $cursor.pos,
+                                to: $cursor.pos,
+                                text: '',
+                                rules,
+                                plugin,
+                            });
+                        }
+                    });
+                    return false;
+                },
+            },
+            // add support for input rules to trigger on enter
+            // this is useful for example for code blocks
+            handleKeyDown(view, event) {
+                if (event.key !== 'Enter') {
+                    return false;
+                }
+                const { $cursor } = view.state.selection;
+                if ($cursor) {
+                    return run$1({
+                        editor,
+                        from: $cursor.pos,
+                        to: $cursor.pos,
+                        text: '\n',
+                        rules,
+                        plugin,
+                    });
+                }
+                return false;
+            },
+        },
+        // @ts-ignore
+        isInputRules: true,
+    });
+    return plugin;
+}
+
+function isNumber(value) {
+    return typeof value === 'number';
+}
+
+class PasteRule {
+    constructor(config) {
+        this.find = config.find;
+        this.handler = config.handler;
+    }
+}
+const pasteRuleMatcherHandler = (text, find) => {
+    if (isRegExp(find)) {
+        return [...text.matchAll(find)];
+    }
+    const matches = find(text);
+    if (!matches) {
+        return [];
+    }
+    return matches.map(pasteRuleMatch => {
+        const result = [];
+        result.push(pasteRuleMatch.text);
+        result.index = pasteRuleMatch.index;
+        result.input = text;
+        result.data = pasteRuleMatch.data;
+        if (pasteRuleMatch.replaceWith) {
+            if (!pasteRuleMatch.text.includes(pasteRuleMatch.replaceWith)) {
+                console.warn('[tiptap warn]: "pasteRuleMatch.replaceWith" must be part of "pasteRuleMatch.text".');
+            }
+            result.push(pasteRuleMatch.replaceWith);
+        }
+        return result;
+    });
+};
+function run(config) {
+    const { editor, state, from, to, rule, } = config;
+    const { commands, chain, can } = new CommandManager({
+        editor,
+        state,
+    });
+    const handlers = [];
+    state.doc.nodesBetween(from, to, (node, pos) => {
+        if (!node.isTextblock || node.type.spec.code) {
+            return;
+        }
+        const resolvedFrom = Math.max(from, pos);
+        const resolvedTo = Math.min(to, pos + node.content.size);
+        const textToMatch = node.textBetween(resolvedFrom - pos, resolvedTo - pos, undefined, '\ufffc');
+        const matches = pasteRuleMatcherHandler(textToMatch, rule.find);
+        matches.forEach(match => {
+            if (match.index === undefined) {
+                return;
+            }
+            const start = resolvedFrom + match.index + 1;
+            const end = start + match[0].length;
+            const range = {
+                from: state.tr.mapping.map(start),
+                to: state.tr.mapping.map(end),
+            };
+            const handler = rule.handler({
+                state,
+                range,
+                match,
+                commands,
+                chain,
+                can,
+            });
+            handlers.push(handler);
+        });
+    });
+    const success = handlers.every(handler => handler !== null);
+    return success;
+}
+/**
+ * Create an paste rules plugin. When enabled, it will cause pasted
+ * text that matches any of the given rules to trigger the rule’s
+ * action.
+ */
+function pasteRulesPlugin(props) {
+    const { editor, rules } = props;
+    let dragSourceElement = null;
+    let isPastedFromProseMirror = false;
+    let isDroppedFromProseMirror = false;
+    const plugins = rules.map(rule => {
+        return new Plugin({
+            // we register a global drag handler to track the current drag source element
+            view(view) {
+                const handleDragstart = (event) => {
+                    var _a;
+                    dragSourceElement = ((_a = view.dom.parentElement) === null || _a === void 0 ? void 0 : _a.contains(event.target))
+                        ? view.dom.parentElement
+                        : null;
+                };
+                window.addEventListener('dragstart', handleDragstart);
+                return {
+                    destroy() {
+                        window.removeEventListener('dragstart', handleDragstart);
+                    },
+                };
+            },
+            props: {
+                handleDOMEvents: {
+                    drop: view => {
+                        isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
+                        return false;
+                    },
+                    paste: (view, event) => {
+                        var _a;
+                        const html = (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text/html');
+                        isPastedFromProseMirror = !!(html === null || html === void 0 ? void 0 : html.includes('data-pm-slice'));
+                        return false;
+                    },
+                },
+            },
+            appendTransaction: (transactions, oldState, state) => {
+                const transaction = transactions[0];
+                const isPaste = transaction.getMeta('uiEvent') === 'paste' && !isPastedFromProseMirror;
+                const isDrop = transaction.getMeta('uiEvent') === 'drop' && !isDroppedFromProseMirror;
+                if (!isPaste && !isDrop) {
+                    return;
+                }
+                // stop if there is no changed range
+                const from = oldState.doc.content.findDiffStart(state.doc.content);
+                const to = oldState.doc.content.findDiffEnd(state.doc.content);
+                if (!isNumber(from) || !to || from === to.b) {
+                    return;
+                }
+                // build a chainable state
+                // so we can use a single transaction for all paste rules
+                const tr = state.tr;
+                const chainableState = createChainableState({
+                    state,
+                    transaction: tr,
+                });
+                const handler = run({
+                    editor,
+                    state: chainableState,
+                    from: Math.max(from - 1, 0),
+                    to: to.b,
+                    rule,
+                });
+                // stop if there are no changes
+                if (!handler || !tr.steps.length) {
+                    return;
+                }
+                return tr;
+            },
+        });
+    });
+    return plugins;
+}
+
+function findDuplicates(items) {
+    const filtered = items.filter((el, index) => items.indexOf(el) !== index);
+    return [...new Set(filtered)];
 }
 
 class ExtensionManager {
     constructor(extensions, editor) {
         this.splittableMarks = [];
         this.editor = editor;
-        this.extensions = this.sort(extensions);
-        this.schema = getSchema(this.extensions);
+        this.extensions = ExtensionManager.resolve(extensions);
+        this.schema = getSchemaByResolvedExtensions(this.extensions);
         this.extensions.forEach(extension => {
             var _a;
+            // store extension storage in editor
+            this.editor.extensionStorage[extension.name] = extension.storage;
             const context = {
+                name: extension.name,
                 options: extension.options,
+                storage: extension.storage,
                 editor: this.editor,
-                type: getSchemaTypeByName(extension.config.name, this.schema),
+                type: getSchemaTypeByName(extension.name, this.schema),
             };
             if (extension.type === 'mark') {
-                const keepOnSplit = (_a = callOrReturn(extension.config.keepOnSplit, context)) !== null && _a !== void 0 ? _a : true;
+                const keepOnSplit = (_a = callOrReturn(getExtensionField(extension, 'keepOnSplit', context))) !== null && _a !== void 0 ? _a : true;
                 if (keepOnSplit) {
-                    this.splittableMarks.push(extension.config.name);
+                    this.splittableMarks.push(extension.name);
                 }
             }
-            if (typeof extension.config.onCreate === 'function') {
-                this.editor.on('create', extension.config.onCreate.bind(context));
+            const onBeforeCreate = getExtensionField(extension, 'onBeforeCreate', context);
+            if (onBeforeCreate) {
+                this.editor.on('beforeCreate', onBeforeCreate);
             }
-            if (typeof extension.config.onUpdate === 'function') {
-                this.editor.on('update', extension.config.onUpdate.bind(context));
+            const onCreate = getExtensionField(extension, 'onCreate', context);
+            if (onCreate) {
+                this.editor.on('create', onCreate);
             }
-            if (typeof extension.config.onSelectionUpdate === 'function') {
-                this.editor.on('selectionUpdate', extension.config.onSelectionUpdate.bind(context));
+            const onUpdate = getExtensionField(extension, 'onUpdate', context);
+            if (onUpdate) {
+                this.editor.on('update', onUpdate);
             }
-            if (typeof extension.config.onViewUpdate === 'function') {
-                this.editor.on('viewUpdate', extension.config.onViewUpdate.bind(context));
+            const onSelectionUpdate = getExtensionField(extension, 'onSelectionUpdate', context);
+            if (onSelectionUpdate) {
+                this.editor.on('selectionUpdate', onSelectionUpdate);
             }
-            if (typeof extension.config.onTransaction === 'function') {
-                this.editor.on('transaction', extension.config.onTransaction.bind(context));
+            const onTransaction = getExtensionField(extension, 'onTransaction', context);
+            if (onTransaction) {
+                this.editor.on('transaction', onTransaction);
             }
-            if (typeof extension.config.onFocus === 'function') {
-                this.editor.on('focus', extension.config.onFocus.bind(context));
+            const onFocus = getExtensionField(extension, 'onFocus', context);
+            if (onFocus) {
+                this.editor.on('focus', onFocus);
             }
-            if (typeof extension.config.onBlur === 'function') {
-                this.editor.on('blur', extension.config.onBlur.bind(context));
+            const onBlur = getExtensionField(extension, 'onBlur', context);
+            if (onBlur) {
+                this.editor.on('blur', onBlur);
             }
-            if (typeof extension.config.onDestroy === 'function') {
-                this.editor.on('destroy', extension.config.onDestroy.bind(context));
+            const onDestroy = getExtensionField(extension, 'onDestroy', context);
+            if (onDestroy) {
+                this.editor.on('destroy', onDestroy);
             }
         });
     }
-    sort(extensions) {
+    static resolve(extensions) {
+        const resolvedExtensions = ExtensionManager.sort(ExtensionManager.flatten(extensions));
+        const duplicatedNames = findDuplicates(resolvedExtensions.map(extension => extension.name));
+        if (duplicatedNames.length) {
+            console.warn(`[tiptap warn]: Duplicate extension names found: [${duplicatedNames.map(item => `'${item}'`).join(', ')}]. This can lead to issues.`);
+        }
+        return resolvedExtensions;
+    }
+    static flatten(extensions) {
+        return extensions
+            .map(extension => {
+            const context = {
+                name: extension.name,
+                options: extension.options,
+                storage: extension.storage,
+            };
+            const addExtensions = getExtensionField(extension, 'addExtensions', context);
+            if (addExtensions) {
+                return [
+                    extension,
+                    ...this.flatten(addExtensions()),
+                ];
+            }
+            return extension;
+        })
+            // `Infinity` will break TypeScript so we set a number that is probably high enough
+            .flat(10);
+    }
+    static sort(extensions) {
         const defaultPriority = 100;
         return extensions.sort((a, b) => {
-            if ((a.config.priority || defaultPriority) > (b.config.priority || defaultPriority)) {
+            const priorityA = getExtensionField(a, 'priority') || defaultPriority;
+            const priorityB = getExtensionField(b, 'priority') || defaultPriority;
+            if (priorityA > priorityB) {
                 return -1;
             }
-            if ((a.config.priority || defaultPriority) < (b.config.priority || defaultPriority)) {
+            if (priorityA < priorityB) {
                 return 1;
             }
             return 0;
@@ -749,51 +979,79 @@ class ExtensionManager {
     get commands() {
         return this.extensions.reduce((commands, extension) => {
             const context = {
+                name: extension.name,
                 options: extension.options,
+                storage: extension.storage,
                 editor: this.editor,
-                type: getSchemaTypeByName(extension.config.name, this.schema),
+                type: getSchemaTypeByName(extension.name, this.schema),
             };
-            if (!extension.config.addCommands) {
+            const addCommands = getExtensionField(extension, 'addCommands', context);
+            if (!addCommands) {
                 return commands;
             }
             return {
                 ...commands,
-                ...extension.config.addCommands.bind(context)(),
+                ...addCommands(),
             };
         }, {});
     }
     get plugins() {
-        return [...this.extensions]
-            .reverse()
+        const { editor } = this;
+        // With ProseMirror, first plugins within an array are executed first.
+        // In tiptap, we provide the ability to override plugins,
+        // so it feels more natural to run plugins at the end of an array first.
+        // That’s why we have to reverse the `extensions` array and sort again
+        // based on the `priority` option.
+        const extensions = ExtensionManager.sort([...this.extensions].reverse());
+        const inputRules = [];
+        const pasteRules = [];
+        const allPlugins = extensions
             .map(extension => {
             const context = {
+                name: extension.name,
                 options: extension.options,
-                editor: this.editor,
-                type: getSchemaTypeByName(extension.config.name, this.schema),
+                storage: extension.storage,
+                editor,
+                type: getSchemaTypeByName(extension.name, this.schema),
             };
             const plugins = [];
-            if (extension.config.addKeyboardShortcuts) {
-                const keyMapPlugin = keymap(extension.config.addKeyboardShortcuts.bind(context)());
+            const addKeyboardShortcuts = getExtensionField(extension, 'addKeyboardShortcuts', context);
+            if (addKeyboardShortcuts) {
+                const bindings = Object.fromEntries(Object
+                    .entries(addKeyboardShortcuts())
+                    .map(([shortcut, method]) => {
+                    return [shortcut, () => method({ editor })];
+                }));
+                const keyMapPlugin = keymap(bindings);
                 plugins.push(keyMapPlugin);
             }
-            if (this.editor.options.enableInputRules && extension.config.addInputRules) {
-                const inputRules$1 = extension.config.addInputRules.bind(context)();
-                const inputRulePlugins = inputRules$1.length
-                    ? [inputRules({ rules: inputRules$1 })]
-                    : [];
-                plugins.push(...inputRulePlugins);
+            const addInputRules = getExtensionField(extension, 'addInputRules', context);
+            if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
+                inputRules.push(...addInputRules());
             }
-            if (this.editor.options.enablePasteRules && extension.config.addPasteRules) {
-                const pasteRulePlugins = extension.config.addPasteRules.bind(context)();
-                plugins.push(...pasteRulePlugins);
+            const addPasteRules = getExtensionField(extension, 'addPasteRules', context);
+            if (isExtensionRulesEnabled(extension, editor.options.enablePasteRules) && addPasteRules) {
+                pasteRules.push(...addPasteRules());
             }
-            if (extension.config.addProseMirrorPlugins) {
-                const proseMirrorPlugins = extension.config.addProseMirrorPlugins.bind(context)();
+            const addProseMirrorPlugins = getExtensionField(extension, 'addProseMirrorPlugins', context);
+            if (addProseMirrorPlugins) {
+                const proseMirrorPlugins = addProseMirrorPlugins();
                 plugins.push(...proseMirrorPlugins);
             }
             return plugins;
         })
             .flat();
+        return [
+            inputRulesPlugin({
+                editor,
+                rules: inputRules,
+            }),
+            ...pasteRulesPlugin({
+                editor,
+                rules: pasteRules,
+            }),
+            ...allPlugins,
+        ];
     }
     get attributes() {
         return getAttributesFromExtensions(this.extensions);
@@ -802,19 +1060,23 @@ class ExtensionManager {
         const { editor } = this;
         const { nodeExtensions } = splitExtensions(this.extensions);
         return Object.fromEntries(nodeExtensions
-            .filter(extension => !!extension.config.addNodeView)
+            .filter(extension => !!getExtensionField(extension, 'addNodeView'))
             .map(extension => {
-            var _a;
-            const extensionAttributes = this.attributes.filter(attribute => attribute.type === extension.config.name);
+            const extensionAttributes = this.attributes.filter(attribute => attribute.type === extension.name);
             const context = {
+                name: extension.name,
                 options: extension.options,
+                storage: extension.storage,
                 editor,
-                type: getNodeType(extension.config.name, this.schema),
+                type: getNodeType(extension.name, this.schema),
             };
-            const renderer = (_a = extension.config.addNodeView) === null || _a === void 0 ? void 0 : _a.call(context);
+            const addNodeView = getExtensionField(extension, 'addNodeView', context);
+            if (!addNodeView) {
+                return [];
+            }
             const nodeview = (node, view, getPos, decorations) => {
                 const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
-                return renderer({
+                return addNodeView()({
                     editor,
                     node,
                     getPos,
@@ -823,90 +1085,20 @@ class ExtensionManager {
                     extension,
                 });
             };
-            return [extension.config.name, nodeview];
-        }));
-    }
-    get textSerializers() {
-        const { editor } = this;
-        const { nodeExtensions } = splitExtensions(this.extensions);
-        return Object.fromEntries(nodeExtensions
-            .filter(extension => !!extension.config.renderText)
-            .map(extension => {
-            const context = {
-                options: extension.options,
-                editor,
-                type: getNodeType(extension.config.name, this.schema),
-            };
-            const textSerializer = (props) => { var _a; return (_a = extension.config.renderText) === null || _a === void 0 ? void 0 : _a.call(context, props); };
-            return [extension.config.name, textSerializer];
+            return [extension.name, nodeview];
         }));
     }
 }
 
-class EventEmitter {
-    constructor() {
-        this.callbacks = {};
-    }
-    on(event, fn) {
-        if (!this.callbacks[event]) {
-            this.callbacks[event] = [];
-        }
-        this.callbacks[event].push(fn);
-        return this;
-    }
-    emit(event, ...args) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            callbacks.forEach(callback => callback.apply(this, args));
-        }
-        return this;
-    }
-    off(event, fn) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            if (fn) {
-                this.callbacks[event] = callbacks.filter(callback => callback !== fn);
-            }
-            else {
-                delete this.callbacks[event];
-            }
-        }
-        return this;
-    }
-    removeAllListeners() {
-        this.callbacks = {};
-    }
-}
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
 // see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
-function getType(payload) {
-    return Object.prototype.toString.call(payload).slice(8, -1);
+function getType(value) {
+    return Object.prototype.toString.call(value).slice(8, -1);
 }
-function isPlainObject(payload) {
-    if (getType(payload) !== 'Object')
+function isPlainObject(value) {
+    if (getType(value) !== 'Object') {
         return false;
-    return payload.constructor === Object && Object.getPrototypeOf(payload) === Object.prototype;
+    }
+    return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
 }
 
 function mergeDeep(target, source) {
@@ -929,69 +1121,115 @@ function mergeDeep(target, source) {
     return output;
 }
 
-var _configure$2;
 class Extension {
-    constructor(config) {
+    constructor(config = {}) {
         this.type = 'extension';
+        this.name = 'extension';
+        this.parent = null;
+        this.child = null;
         this.config = {
-            name: 'extension',
-            priority: 100,
+            name: this.name,
             defaultOptions: {},
         };
-        _configure$2.set(this, (options) => {
-            this.options = mergeDeep(this.config.defaultOptions, options);
-            return this;
-        });
         this.config = {
             ...this.config,
             ...config,
         };
+        this.name = this.config.name;
+        if (config.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
+        }
+        // TODO: remove `addOptions` fallback
         this.options = this.config.defaultOptions;
+        if (this.config.addOptions) {
+            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
+                name: this.name,
+            }));
+        }
+        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
+            name: this.name,
+            options: this.options,
+        })) || {};
     }
-    static create(config) {
+    static create(config = {}) {
         return new Extension(config);
     }
     configure(options = {}) {
-        var _a;
-        return __classPrivateFieldGet((_a = Extension
-            .create(this.config)), _configure$2).call(_a, options);
-    }
-    extend(extendedConfig) {
-        return new Extension({
-            ...this.config,
-            ...extendedConfig,
-        });
+        // return a new instance so we can use the same extension
+        // with different calls of `configure`
+        const extension = this.extend();
+        extension.options = mergeDeep(this.options, options);
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
+    }
+    extend(extendedConfig = {}) {
+        const extension = new Extension(extendedConfig);
+        extension.parent = this;
+        this.child = extension;
+        extension.name = extendedConfig.name
+            ? extendedConfig.name
+            : extension.parent.name;
+        if (extendedConfig.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
+        }
+        extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
+            name: extension.name,
+        }));
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
     }
-}
-_configure$2 = new WeakMap();
+}
 
-const textBetween = (editor, from, to, blockSeparator, leafText) => {
+function getTextBetween(startNode, range, options) {
+    const { from, to } = range;
+    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
     let text = '';
     let separated = true;
-    editor.state.doc.nodesBetween(from, to, (node, pos) => {
+    startNode.nodesBetween(from, to, (node, pos, parent, index) => {
         var _a;
-        const textSerializer = editor.extensionManager.textSerializers[node.type.name];
+        const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
         if (textSerializer) {
-            text += textSerializer({ node });
-            separated = !blockSeparator;
+            if (node.isBlock && !separated) {
+                text += blockSeparator;
+                separated = true;
+            }
+            if (parent) {
+                text += textSerializer({
+                    node,
+                    pos,
+                    parent,
+                    index,
+                    range,
+                });
+            }
         }
         else if (node.isText) {
-            text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
-            separated = !blockSeparator;
+            text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos); // eslint-disable-line
+            separated = false;
         }
-        else if (node.isLeaf && leafText) {
-            text += leafText;
-            separated = !blockSeparator;
-        }
-        else if (!separated && node.isBlock) {
+        else if (node.isBlock && !separated) {
             text += blockSeparator;
             separated = true;
         }
-    }, 0);
+    });
     return text;
-};
+}
+
+function getTextSerializersFromSchema(schema) {
+    return Object.fromEntries(Object
+        .entries(schema.nodes)
+        .filter(([, node]) => node.spec.toText)
+        .map(([name, node]) => [name, node.spec.toText]));
+}
+
 const ClipboardTextSerializer = Extension.create({
-    name: 'editable',
+    name: 'clipboardTextSerializer',
     addProseMirrorPlugins() {
         return [
             new Plugin({
@@ -999,8 +1237,16 @@ const ClipboardTextSerializer = Extension.create({
                 props: {
                     clipboardTextSerializer: () => {
                         const { editor } = this;
-                        const { from, to } = editor.state.selection;
-                        return textBetween(editor, from, to, '\n');
+                        const { state, schema } = editor;
+                        const { doc, selection } = state;
+                        const { ranges } = selection;
+                        const from = Math.min(...ranges.map(range => range.$from.pos));
+                        const to = Math.max(...ranges.map(range => range.$to.pos));
+                        const textSerializers = getTextSerializersFromSchema(schema);
+                        const range = { from, to };
+                        return getTextBetween(doc, range, {
+                            textSerializers,
+                        });
                     },
                 },
             }),
@@ -1008,72 +1254,78 @@ const ClipboardTextSerializer = Extension.create({
     },
 });
 
-const blur = () => ({ view }) => {
-    const element = view.dom;
-    element.blur();
+const blur = () => ({ editor, view }) => {
+    requestAnimationFrame(() => {
+        var _a;
+        if (!editor.isDestroyed) {
+            view.dom.blur();
+            // Browsers should remove the caret on blur but safari does not.
+            // See: https://github.com/ueberdosis/tiptap/issues/2405
+            (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
+        }
+    });
     return true;
 };
 
-var blur$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  blur: blur
-});
-
 const clearContent = (emitUpdate = false) => ({ commands }) => {
     return commands.setContent('', emitUpdate);
 };
 
-var clearContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  clearContent: clearContent
-});
-
 const clearNodes = () => ({ state, tr, dispatch }) => {
     const { selection } = tr;
     const { ranges } = selection;
-    ranges.forEach(range => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-            if (!node.type.isText) {
-                const fromPos = tr.doc.resolve(tr.mapping.map(pos + 1));
-                const toPos = tr.doc.resolve(tr.mapping.map(pos + node.nodeSize - 1));
-                const nodeRange = fromPos.blockRange(toPos);
-                if (nodeRange) {
-                    const targetLiftDepth = liftTarget(nodeRange);
-                    if (node.type.isTextblock && dispatch) {
-                        tr.setNodeMarkup(nodeRange.start, state.doc.type.contentMatch.defaultType);
-                    }
-                    if ((targetLiftDepth || targetLiftDepth === 0) && dispatch) {
-                        tr.lift(nodeRange, targetLiftDepth);
-                    }
-                }
+    if (!dispatch) {
+        return true;
+    }
+    ranges.forEach(({ $from, $to }) => {
+        state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+            if (node.type.isText) {
+                return;
+            }
+            const { doc, mapping } = tr;
+            const $mappedFrom = doc.resolve(mapping.map(pos));
+            const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize));
+            const nodeRange = $mappedFrom.blockRange($mappedTo);
+            if (!nodeRange) {
+                return;
+            }
+            const targetLiftDepth = liftTarget(nodeRange);
+            if (node.type.isTextblock) {
+                const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
+                tr.setNodeMarkup(nodeRange.start, defaultType);
+            }
+            if (targetLiftDepth || targetLiftDepth === 0) {
+                tr.lift(nodeRange, targetLiftDepth);
             }
         });
     });
     return true;
 };
 
-var clearNodes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  clearNodes: clearNodes
-});
-
 const command = fn => props => {
     return fn(props);
 };
 
-var command$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  command: command
-});
-
 const createParagraphNear = () => ({ state, dispatch }) => {
-    return createParagraphNear$2(state, dispatch);
+    return createParagraphNear$1(state, dispatch);
 };
 
-var createParagraphNear$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createParagraphNear: createParagraphNear
-});
+const deleteNode = typeOrName => ({ tr, state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema);
+    const $pos = tr.selection.$anchor;
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+        const node = $pos.node(depth);
+        if (node.type === type) {
+            if (dispatch) {
+                const from = $pos.before(depth);
+                const to = $pos.after(depth);
+                tr.delete(from, to).scrollIntoView();
+            }
+            return true;
+        }
+    }
+    return false;
+};
 
 const deleteRange = range => ({ tr, dispatch }) => {
     const { from, to } = range;
@@ -1083,59 +1335,73 @@ const deleteRange = range => ({ tr, dispatch }) => {
     return true;
 };
 
-var deleteRange$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  deleteRange: deleteRange
-});
-
 const deleteSelection = () => ({ state, dispatch }) => {
-    return deleteSelection$2(state, dispatch);
+    return deleteSelection$1(state, dispatch);
 };
 
-var deleteSelection$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  deleteSelection: deleteSelection
-});
-
 const enter = () => ({ commands }) => {
     return commands.keyboardShortcut('Enter');
 };
 
-var enter$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  enter: enter
-});
-
 const exitCode = () => ({ state, dispatch }) => {
-    return exitCode$2(state, dispatch);
+    return exitCode$1(state, dispatch);
 };
 
-var exitCode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  exitCode: exitCode
-});
+/**
+ * Check if object1 includes object2
+ * @param object1 Object
+ * @param object2 Object
+ */
+function objectIncludes(object1, object2, options = { strict: true }) {
+    const keys = Object.keys(object2);
+    if (!keys.length) {
+        return true;
+    }
+    return keys.every(key => {
+        if (options.strict) {
+            return object2[key] === object1[key];
+        }
+        if (isRegExp(object2[key])) {
+            return object2[key].test(object1[key]);
+        }
+        return object2[key] === object1[key];
+    });
+}
 
-function getMarkRange($pos, type) {
+function findMarkInSet(marks, type, attributes = {}) {
+    return marks.find(item => {
+        return item.type === type && objectIncludes(item.attrs, attributes);
+    });
+}
+function isMarkInSet(marks, type, attributes = {}) {
+    return !!findMarkInSet(marks, type, attributes);
+}
+function getMarkRange($pos, type, attributes = {}) {
     if (!$pos || !type) {
         return;
     }
-    const start = $pos.parent.childAfter($pos.parentOffset);
+    let start = $pos.parent.childAfter($pos.parentOffset);
+    if ($pos.parentOffset === start.offset && start.offset !== 0) {
+        start = $pos.parent.childBefore($pos.parentOffset);
+    }
     if (!start.node) {
         return;
     }
-    const link = start.node.marks.find(mark => mark.type === type);
-    if (!link) {
+    const mark = findMarkInSet([...start.node.marks], type, attributes);
+    if (!mark) {
         return;
     }
-    let startIndex = $pos.index();
+    let startIndex = start.index;
     let startPos = $pos.start() + start.offset;
     let endIndex = startIndex + 1;
     let endPos = startPos + start.node.nodeSize;
-    while (startIndex > 0 && link.isInSet($pos.parent.child(startIndex - 1).marks)) {
+    findMarkInSet([...start.node.marks], type, attributes);
+    while (startIndex > 0 && mark.isInSet($pos.parent.child(startIndex - 1).marks)) {
         startIndex -= 1;
         startPos -= $pos.parent.child(startIndex).nodeSize;
     }
-    while (endIndex < $pos.parent.childCount && link.isInSet($pos.parent.child(endIndex).marks)) {
+    while (endIndex < $pos.parent.childCount
+        && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
         endPos += $pos.parent.child(endIndex).nodeSize;
         endIndex += 1;
     }
@@ -1145,13 +1411,23 @@ function getMarkRange($pos, type) {
     };
 }
 
-const extendMarkRange = typeOrName => ({ tr, state, dispatch }) => {
+function getMarkType(nameOrType, schema) {
+    if (typeof nameOrType === 'string') {
+        if (!schema.marks[nameOrType]) {
+            throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
+        }
+        return schema.marks[nameOrType];
+    }
+    return nameOrType;
+}
+
+const extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
     const type = getMarkType(typeOrName, state.schema);
     const { doc, selection } = tr;
-    const { $from, empty } = selection;
-    if (empty && dispatch) {
-        const range = getMarkRange($from, type);
-        if (range) {
+    const { $from, from, to } = selection;
+    if (dispatch) {
+        const range = getMarkRange($from, type, attributes);
+        if (range && range.from <= from && range.to >= to) {
             const newSelection = TextSelection.create(doc, range.from, range.to);
             tr.setSelection(newSelection);
         }
@@ -1159,11 +1435,6 @@ const extendMarkRange = typeOrName => ({ tr, state, dispatch }) => {
     return true;
 };
 
-var extendMarkRange$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  extendMarkRange: extendMarkRange
-});
-
 const first = commands => props => {
     const items = typeof commands === 'function'
         ? commands(props)
@@ -1176,87 +1447,148 @@ const first = commands => props => {
     return false;
 };
 
-var first$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  first: first
-});
-
-function minMax(value = 0, min = 0, max = 0) {
-    return Math.min(Math.max(value, min), max);
-}
-
-function isClass(item) {
+function isClass(value) {
     var _a;
-    if (((_a = item.constructor) === null || _a === void 0 ? void 0 : _a.toString().substring(0, 5)) !== 'class') {
+    if (((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.toString().substring(0, 5)) !== 'class') {
         return false;
     }
     return true;
 }
 
-function isObject(item) {
-    return (item
-        && typeof item === 'object'
-        && !Array.isArray(item)
-        && !isClass(item));
+function isObject(value) {
+    return (value
+        && typeof value === 'object'
+        && !Array.isArray(value)
+        && !isClass(value));
 }
 
 function isTextSelection(value) {
     return isObject(value) && value instanceof TextSelection;
 }
 
-function resolveSelection(state, position = null) {
+function minMax(value = 0, min = 0, max = 0) {
+    return Math.min(Math.max(value, min), max);
+}
+
+function resolveFocusPosition(doc, position = null) {
     if (!position) {
         return null;
     }
+    const selectionAtStart = Selection.atStart(doc);
+    const selectionAtEnd = Selection.atEnd(doc);
     if (position === 'start' || position === true) {
-        return {
-            from: 0,
-            to: 0,
-        };
+        return selectionAtStart;
     }
     if (position === 'end') {
-        const { size } = state.doc.content;
-        return {
-            from: size,
-            to: size,
-        };
+        return selectionAtEnd;
     }
-    return {
-        from: position,
-        to: position,
+    const minPos = selectionAtStart.from;
+    const maxPos = selectionAtEnd.to;
+    if (position === 'all') {
+        return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
+    }
+    return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
+}
+
+function isiOS() {
+    return [
+        'iPad Simulator',
+        'iPhone Simulator',
+        'iPod Simulator',
+        'iPad',
+        'iPhone',
+        'iPod',
+    ].includes(navigator.platform)
+        // iPad on iOS 13 detection
+        || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);
+}
+
+const focus = (position = null, options = {}) => ({ editor, view, tr, dispatch, }) => {
+    options = {
+        scrollIntoView: true,
+        ...options,
+    };
+    const delayedFocus = () => {
+        // focus within `requestAnimationFrame` breaks focus on iOS
+        // so we have to call this
+        if (isiOS()) {
+            view.dom.focus();
+        }
+        // For React we have to focus asynchronously. Otherwise wild things happen.
+        // see: https://github.com/ueberdosis/tiptap/issues/1520
+        requestAnimationFrame(() => {
+            if (!editor.isDestroyed) {
+                view.focus();
+                if (options === null || options === void 0 ? void 0 : options.scrollIntoView) {
+                    editor.commands.scrollIntoView();
+                }
+            }
+        });
     };
-}
-const focus = (position = null) => ({ editor, view, tr, dispatch, }) => {
     if ((view.hasFocus() && position === null) || position === false) {
         return true;
     }
     // we don’t try to resolve a NodeSelection or CellSelection
     if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-        view.focus();
+        delayedFocus();
         return true;
     }
-    const { from, to } = resolveSelection(editor.state, position) || editor.state.selection;
-    const { doc, storedMarks } = tr;
-    const resolvedFrom = minMax(from, 0, doc.content.size);
-    const resolvedEnd = minMax(to, 0, doc.content.size);
-    const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
+    const selection = resolveFocusPosition(editor.state.doc, position) || editor.state.selection;
     const isSameSelection = editor.state.selection.eq(selection);
     if (dispatch) {
-        tr.setSelection(selection);
+        if (!isSameSelection) {
+            tr.setSelection(selection);
+        }
         // `tr.setSelection` resets the stored marks
         // so we’ll restore them if the selection is the same as before
-        if (isSameSelection && storedMarks) {
-            tr.setStoredMarks(storedMarks);
+        if (isSameSelection && tr.storedMarks) {
+            tr.setStoredMarks(tr.storedMarks);
         }
-        view.focus();
+        delayedFocus();
     }
     return true;
 };
 
-var focus$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  focus: focus
-});
+const forEach = (items, fn) => props => {
+    return items.every((item, index) => fn(item, { ...props, index }));
+};
+
+const insertContent = (value, options) => ({ tr, commands }) => {
+    return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
+};
+
+function elementFromString(value) {
+    // add a wrapper to preserve leading and trailing whitespace
+    const wrappedValue = `<body>${value}</body>`;
+    return new window.DOMParser().parseFromString(wrappedValue, 'text/html').body;
+}
+
+function createNodeFromContent(content, schema, options) {
+    options = {
+        slice: true,
+        parseOptions: {},
+        ...options,
+    };
+    if (typeof content === 'object' && content !== null) {
+        try {
+            if (Array.isArray(content)) {
+                return Fragment.fromArray(content.map(item => schema.nodeFromJSON(item)));
+            }
+            return schema.nodeFromJSON(content);
+        }
+        catch (error) {
+            console.warn('[tiptap warn]: Invalid content.', 'Passed value:', content, 'Error:', error);
+            return createNodeFromContent('', schema, options);
+        }
+    }
+    if (typeof content === 'string') {
+        const parser = DOMParser.fromSchema(schema);
+        return options.slice
+            ? parser.parseSlice(elementFromString(content), options.parseOptions).content
+            : parser.parse(elementFromString(content), options.parseOptions);
+    }
+    return createNodeFromContent('', schema, options);
+}
 
 // source: https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.js#L466
 function selectionToInsertionEnd(tr, startLen, bias) {
@@ -1278,95 +1610,89 @@ function selectionToInsertionEnd(tr, startLen, bias) {
     tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
 }
 
-const insertContent = value => ({ tr, dispatch, editor }) => {
+const isFragment = (nodeOrFragment) => {
+    return nodeOrFragment.toString().startsWith('<');
+};
+const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
     if (dispatch) {
-        const content = createNodeFromContent(value, editor.schema);
-        if (typeof content === 'string') {
-            tr.insertText(content);
+        options = {
+            parseOptions: {},
+            updateSelection: true,
+            ...options,
+        };
+        const content = createNodeFromContent(value, editor.schema, {
+            parseOptions: {
+                preserveWhitespace: 'full',
+                ...options.parseOptions,
+            },
+        });
+        // don’t dispatch an empty fragment because this can lead to strange errors
+        if (content.toString() === '<>') {
             return true;
         }
-        if (!tr.selection.empty) {
-            tr.deleteSelection();
+        let { from, to } = typeof position === 'number'
+            ? { from: position, to: position }
+            : position;
+        let isOnlyTextContent = true;
+        let isOnlyBlockContent = true;
+        const nodes = isFragment(content)
+            ? content
+            : [content];
+        nodes.forEach(node => {
+            // check if added node is valid
+            node.check();
+            isOnlyTextContent = isOnlyTextContent
+                ? node.isText && node.marks.length === 0
+                : false;
+            isOnlyBlockContent = isOnlyBlockContent
+                ? node.isBlock
+                : false;
+        });
+        // check if we can replace the wrapping node by
+        // the newly inserted content
+        // example:
+        // replace an empty paragraph by an inserted image
+        // instead of inserting the image below the paragraph
+        if (from === to && isOnlyBlockContent) {
+            const { parent } = tr.doc.resolve(from);
+            const isEmptyTextBlock = parent.isTextblock
+                && !parent.type.spec.code
+                && !parent.childCount;
+            if (isEmptyTextBlock) {
+                from -= 1;
+                to += 1;
+            }
+        }
+        // if there is only plain text we have to use `insertText`
+        // because this will keep the current marks
+        if (isOnlyTextContent) {
+            tr.insertText(value, from, to);
+        }
+        else {
+            tr.replaceWith(from, to, content);
+        }
+        // set cursor at end of inserted content
+        if (options.updateSelection) {
+            selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
         }
-        tr.insert(tr.selection.anchor, content);
-        selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-    }
-    return true;
-};
-
-var insertContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertContent: insertContent
-});
-
-const insertHTML = value => ({ tr, state, dispatch }) => {
-    console.warn('[tiptap warn]: insertHTML() is deprecated. please use insertContent() instead.');
-    const { selection } = tr;
-    const element = elementFromString(value);
-    const slice = DOMParser.fromSchema(state.schema).parseSlice(element);
-    if (dispatch) {
-        tr.insert(selection.anchor, slice.content);
-        selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-    }
-    return true;
-};
-
-var insertHTML$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertHTML: insertHTML
-});
-
-const insertNode = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    console.warn('[tiptap warn]: insertNode() is deprecated. please use insertContent() instead.');
-    const { selection } = tr;
-    const type = getNodeType(typeOrName, state.schema);
-    if (!type) {
-        return false;
-    }
-    const node = type.create(attributes);
-    if (dispatch) {
-        tr.insert(selection.anchor, node);
-    }
-    return true;
-};
-
-var insertNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertNode: insertNode
-});
-
-const insertText = value => ({ tr, dispatch }) => {
-    console.warn('[tiptap warn]: insertText() is deprecated. please use insertContent() instead.');
-    if (dispatch) {
-        tr.insertText(value);
     }
     return true;
 };
 
-var insertText$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertText: insertText
-});
-
 const joinBackward = () => ({ state, dispatch }) => {
-    return joinBackward$2(state, dispatch);
+    return joinBackward$1(state, dispatch);
 };
 
-var joinBackward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  joinBackward: joinBackward
-});
-
 const joinForward = () => ({ state, dispatch }) => {
-    return joinForward$2(state, dispatch);
+    return joinForward$1(state, dispatch);
 };
 
-var joinForward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  joinForward: joinForward
-});
+function isMacOS() {
+    return typeof navigator !== 'undefined'
+        ? /Mac/.test(navigator.platform)
+        : false;
+}
 
-const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
 function normalizeKeyName(name) {
     const parts = name.split(/-(?!$)/);
     let result = parts[parts.length - 1];
@@ -1392,7 +1718,7 @@ function normalizeKeyName(name) {
             shift = true;
         }
         else if (/^mod$/i.test(mod)) {
-            if (mac) {
+            if (isiOS() || isMacOS()) {
                 meta = true;
             }
             else {
@@ -1443,10 +1769,40 @@ const keyboardShortcut = name => ({ editor, view, tr, dispatch, }) => {
     return true;
 };
 
-var keyboardShortcut$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  keyboardShortcut: keyboardShortcut
-});
+function isNodeActive(state, typeOrName, attributes = {}) {
+    const { from, to, empty } = state.selection;
+    const type = typeOrName
+        ? getNodeType(typeOrName, state.schema)
+        : null;
+    const nodeRanges = [];
+    state.doc.nodesBetween(from, to, (node, pos) => {
+        if (node.isText) {
+            return;
+        }
+        const relativeFrom = Math.max(from, pos);
+        const relativeTo = Math.min(to, pos + node.nodeSize);
+        nodeRanges.push({
+            node,
+            from: relativeFrom,
+            to: relativeTo,
+        });
+    });
+    const selectionRange = to - from;
+    const matchedNodeRanges = nodeRanges
+        .filter(nodeRange => {
+        if (!type) {
+            return true;
+        }
+        return type.name === nodeRange.node.type.name;
+    })
+        .filter(nodeRange => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
+    if (empty) {
+        return !!matchedNodeRanges.length;
+    }
+    const range = matchedNodeRanges
+        .reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
+    return range >= selectionRange;
+}
 
 const lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
@@ -1454,71 +1810,31 @@ const lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
     if (!isActive) {
         return false;
     }
-    return lift$2(state, dispatch);
+    return lift$1(state, dispatch);
 };
 
-var lift$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  lift: lift
-});
-
 const liftEmptyBlock = () => ({ state, dispatch }) => {
-    return liftEmptyBlock$2(state, dispatch);
+    return liftEmptyBlock$1(state, dispatch);
 };
 
-var liftEmptyBlock$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  liftEmptyBlock: liftEmptyBlock
-});
-
 const liftListItem = typeOrName => ({ state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
-    return liftListItem$2(type)(state, dispatch);
+    return liftListItem$1(type)(state, dispatch);
 };
 
-var liftListItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  liftListItem: liftListItem
-});
-
 const newlineInCode = () => ({ state, dispatch }) => {
-    return newlineInCode$2(state, dispatch);
+    return newlineInCode$1(state, dispatch);
 };
 
-var newlineInCode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  newlineInCode: newlineInCode
-});
-
-const replace = (typeOrName, attributes = {}) => ({ state, commands }) => {
-    const { from, to } = state.selection;
-    const range = { from, to };
-    return commands.replaceRange(range, typeOrName, attributes);
-};
-
-var replace$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  replace: replace
-});
-
-const replaceRange = (range, typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const { from, to } = range;
-    const $from = tr.doc.resolve(from);
-    const index = $from.index();
-    if (!$from.parent.canReplaceWith(index, index, type)) {
-        return false;
+function getSchemaTypeNameByName(name, schema) {
+    if (schema.nodes[name]) {
+        return 'node';
     }
-    if (dispatch) {
-        tr.replaceWith(from, to, type.create(attributes));
+    if (schema.marks[name]) {
+        return 'mark';
     }
-    return true;
-};
-
-var replaceRange$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  replaceRange: replaceRange
-});
+    return null;
+}
 
 /**
  * Remove a property or an array of properties from an object
@@ -1539,25 +1855,40 @@ function deleteProps(obj, propOrProps) {
     }, {});
 }
 
-const resetNodeAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const { selection } = tr;
-    const { ranges } = selection;
-    ranges.forEach(range => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-            if (node.type === type && dispatch) {
-                tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes));
-            }
+const resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
+    let nodeType = null;
+    let markType = null;
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
+        ? typeOrName
+        : typeOrName.name, state.schema);
+    if (!schemaType) {
+        return false;
+    }
+    if (schemaType === 'node') {
+        nodeType = getNodeType(typeOrName, state.schema);
+    }
+    if (schemaType === 'mark') {
+        markType = getMarkType(typeOrName, state.schema);
+    }
+    if (dispatch) {
+        tr.selection.ranges.forEach(range => {
+            state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+                if (nodeType && nodeType === node.type) {
+                    tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes));
+                }
+                if (markType && node.marks.length) {
+                    node.marks.forEach(mark => {
+                        if (markType === mark.type) {
+                            tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
+                        }
+                    });
+                }
+            });
         });
-    });
+    }
     return true;
 };
 
-var resetNodeAttributes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  resetNodeAttributes: resetNodeAttributes
-});
-
 const scrollIntoView = () => ({ tr, dispatch }) => {
     if (dispatch) {
         tr.scrollIntoView();
@@ -1565,46 +1896,38 @@ const scrollIntoView = () => ({ tr, dispatch }) => {
     return true;
 };
 
-var scrollIntoView$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scrollIntoView: scrollIntoView
-});
-
-const selectAll = () => ({ state, dispatch }) => {
-    return selectAll$2(state, dispatch);
+const selectAll = () => ({ tr, commands }) => {
+    return commands.setTextSelection({
+        from: 0,
+        to: tr.doc.content.size,
+    });
 };
 
-var selectAll$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectAll: selectAll
-});
-
 const selectNodeBackward = () => ({ state, dispatch }) => {
-    return selectNodeBackward$2(state, dispatch);
+    return selectNodeBackward$1(state, dispatch);
 };
 
-var selectNodeBackward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectNodeBackward: selectNodeBackward
-});
-
 const selectNodeForward = () => ({ state, dispatch }) => {
-    return selectNodeForward$2(state, dispatch);
+    return selectNodeForward$1(state, dispatch);
 };
 
-var selectNodeForward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectNodeForward: selectNodeForward
-});
-
 const selectParentNode = () => ({ state, dispatch }) => {
-    return selectParentNode$2(state, dispatch);
+    return selectParentNode$1(state, dispatch);
 };
 
-var selectParentNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectParentNode: selectParentNode
-});
+// @ts-ignore
+const selectTextblockEnd = () => ({ state, dispatch }) => {
+    return selectTextblockEnd$1(state, dispatch);
+};
+
+// @ts-ignore
+const selectTextblockStart = () => ({ state, dispatch }) => {
+    return selectTextblockStart$1(state, dispatch);
+};
+
+function createDocument(content, schema, parseOptions = {}) {
+    return createNodeFromContent(content, schema, { slice: false, parseOptions });
+}
 
 const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
     const { doc } = tr;
@@ -1618,58 +1941,131 @@ const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, ed
     return true;
 };
 
-var setContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setContent: setContent
-});
+function getMarkAttributes(state, typeOrName) {
+    const type = getMarkType(typeOrName, state.schema);
+    const { from, to, empty } = state.selection;
+    const marks = [];
+    if (empty) {
+        if (state.storedMarks) {
+            marks.push(...state.storedMarks);
+        }
+        marks.push(...state.selection.$head.marks());
+    }
+    else {
+        state.doc.nodesBetween(from, to, node => {
+            marks.push(...node.marks);
+        });
+    }
+    const mark = marks.find(markItem => markItem.type.name === type.name);
+    if (!mark) {
+        return {};
+    }
+    return { ...mark.attrs };
+}
 
 const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
     const { selection } = tr;
     const { empty, ranges } = selection;
     const type = getMarkType(typeOrName, state.schema);
-    const oldAttributes = getMarkAttributes(state, type);
-    const newAttributes = {
-        ...oldAttributes,
-        ...attributes,
-    };
     if (dispatch) {
         if (empty) {
-            tr.addStoredMark(type.create(newAttributes));
+            const oldAttributes = getMarkAttributes(state, type);
+            tr.addStoredMark(type.create({
+                ...oldAttributes,
+                ...attributes,
+            }));
         }
         else {
             ranges.forEach(range => {
-                tr.addMark(range.$from.pos, range.$to.pos, type.create(newAttributes));
+                const from = range.$from.pos;
+                const to = range.$to.pos;
+                state.doc.nodesBetween(from, to, (node, pos) => {
+                    const trimmedFrom = Math.max(pos, from);
+                    const trimmedTo = Math.min(pos + node.nodeSize, to);
+                    const someHasMark = node.marks.find(mark => mark.type === type);
+                    // if there is already a mark of this type
+                    // we know that we have to merge its attributes
+                    // otherwise we add a fresh new mark
+                    if (someHasMark) {
+                        node.marks.forEach(mark => {
+                            if (type === mark.type) {
+                                tr.addMark(trimmedFrom, trimmedTo, type.create({
+                                    ...mark.attrs,
+                                    ...attributes,
+                                }));
+                            }
+                        });
+                    }
+                    else {
+                        tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
+                    }
+                });
             });
         }
     }
     return true;
 };
 
-var setMark$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setMark: setMark
-});
+const setMeta = (key, value) => ({ tr }) => {
+    tr.setMeta(key, value);
+    return true;
+};
 
-const setNode = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+const setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
     const type = getNodeType(typeOrName, state.schema);
-    return setBlockType(type, attributes)(state, dispatch);
+    // TODO: use a fallback like insertContent?
+    if (!type.isTextblock) {
+        console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
+        return false;
+    }
+    return chain()
+        // try to convert node to default node if needed
+        .command(({ commands }) => {
+        const canSetBlock = setBlockType(type, attributes)(state);
+        if (canSetBlock) {
+            return true;
+        }
+        return commands.clearNodes();
+    })
+        .command(({ state: updatedState }) => {
+        return setBlockType(type, attributes)(updatedState, dispatch);
+    })
+        .run();
 };
 
-var setNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setNode: setNode
-});
+const setNodeSelection = position => ({ tr, dispatch }) => {
+    if (dispatch) {
+        const { doc } = tr;
+        const minPos = Selection.atStart(doc).from;
+        const maxPos = Selection.atEnd(doc).to;
+        const resolvedPos = minMax(position, minPos, maxPos);
+        const selection = NodeSelection.create(doc, resolvedPos);
+        tr.setSelection(selection);
+    }
+    return true;
+};
+
+const setTextSelection = position => ({ tr, dispatch }) => {
+    if (dispatch) {
+        const { doc } = tr;
+        const { from, to } = typeof position === 'number'
+            ? { from: position, to: position }
+            : position;
+        const minPos = TextSelection.atStart(doc).from;
+        const maxPos = TextSelection.atEnd(doc).to;
+        const resolvedFrom = minMax(from, minPos, maxPos);
+        const resolvedEnd = minMax(to, minPos, maxPos);
+        const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
+        tr.setSelection(selection);
+    }
+    return true;
+};
 
 const sinkListItem = typeOrName => ({ state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
-    return sinkListItem$2(type)(state, dispatch);
+    return sinkListItem$1(type)(state, dispatch);
 };
 
-var sinkListItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  sinkListItem: sinkListItem
-});
-
 function getSplittedAttributes(extensionAttributes, typeName, attributes) {
     return Object.fromEntries(Object
         .entries(attributes)
@@ -1684,8 +2080,8 @@ function getSplittedAttributes(extensionAttributes, typeName, attributes) {
     }));
 }
 
-function defaultBlockAt(match) {
-    for (let i = 0; i < match.edgeCount; i + 1) {
+function defaultBlockAt$1(match) {
+    for (let i = 0; i < match.edgeCount; i += 1) {
         const { type } = match.edge(i);
         if (type.isTextblock && !type.hasRequiredAttrs()) {
             return type;
@@ -1728,7 +2124,7 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
         }
         const deflt = $from.depth === 0
             ? undefined
-            : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
+            : defaultBlockAt$1($from.node(-1).contentMatchAt($from.indexAfter(-1)));
         let types = atEnd && deflt
             ? [{
                     type: deflt,
@@ -1749,11 +2145,15 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
         }
         if (can) {
             tr.split(tr.mapping.map($from.pos), 1, types);
-            if (!atEnd
+            if (deflt
+                && !atEnd
                 && !$from.parentOffset
-                && $from.parent.type !== deflt
-                && $from.node(-1).canReplace($from.index(-1), $from.indexAfter(-1), Fragment.from(deflt === null || deflt === void 0 ? void 0 : deflt.create()))) {
-                tr.setNodeMarkup(tr.mapping.map($from.before()), deflt || undefined);
+                && $from.parent.type !== deflt) {
+                const first = tr.mapping.map($from.before());
+                const $first = tr.doc.resolve(first);
+                if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
+                    tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
+                }
             }
         }
         if (keepMarks) {
@@ -1764,11 +2164,6 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
     return true;
 };
 
-var splitBlock$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  splitBlock: splitBlock
-});
-
 const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
     var _a;
     const type = getNodeType(typeOrName, state.schema);
@@ -1795,20 +2190,42 @@ const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
         }
         if (dispatch) {
             let wrap = Fragment.empty;
-            const keepItem = $from.index(-1) > 0;
+            // eslint-disable-next-line
+            const depthBefore = $from.index(-1)
+                ? 1
+                : $from.index(-2)
+                    ? 2
+                    : 3;
             // Build a fragment containing empty versions of the structure
             // from the outer list item to the parent node of the cursor
-            for (let d = $from.depth - (keepItem ? 1 : 2); d >= $from.depth - 3; d -= 1) {
+            for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
                 wrap = Fragment.from($from.node(d).copy(wrap));
             }
+            // eslint-disable-next-line
+            const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount
+                ? 1
+                : $from.indexAfter(-2) < $from.node(-3).childCount
+                    ? 2
+                    : 3;
             // Add a second list item with an empty default start node
             const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
             const nextType = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes)) || undefined;
             wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined));
-            tr
-                .replace($from.before(keepItem ? undefined : -1), $from.after(-3), new Slice(wrap, keepItem ? 3 : 2, 2))
-                .setSelection(TextSelection.near(tr.doc.resolve($from.pos + (keepItem ? 3 : 2))))
-                .scrollIntoView();
+            const start = $from.before($from.depth - (depthBefore - 1));
+            tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+            let sel = -1;
+            tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
+                if (sel > -1) {
+                    return false;
+                }
+                if (n.isTextblock && n.content.size === 0) {
+                    sel = pos + 1;
+                }
+            });
+            if (sel > -1) {
+                tr.setSelection(TextSelection.near(tr.doc.resolve(sel)));
+            }
+            tr.scrollIntoView();
         }
         return true;
     }
@@ -1830,11 +2247,6 @@ const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
     return true;
 };
 
-var splitListItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  splitListItem: splitListItem
-});
-
 function findParentNodeClosestToPos($pos, predicate) {
     for (let i = $pos.depth; i > 0; i -= 1) {
         const node = $pos.node(i);
@@ -1855,19 +2267,60 @@ function findParentNode(predicate) {
 
 function isList(name, extensions) {
     const { nodeExtensions } = splitExtensions(extensions);
-    const extension = nodeExtensions.find(item => item.config.name === name);
+    const extension = nodeExtensions.find(item => item.name === name);
     if (!extension) {
         return false;
     }
-    const groups = callOrReturn(extension.config.group, { options: extension.options });
-    if (typeof groups !== 'string') {
+    const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+    };
+    const group = callOrReturn(getExtensionField(extension, 'group', context));
+    if (typeof group !== 'string') {
         return false;
     }
-    return groups.split(' ').includes('list');
+    return group.split(' ').includes('list');
 }
 
+const joinListBackwards = (tr, listType) => {
+    const list = findParentNode(node => node.type === listType)(tr.selection);
+    if (!list) {
+        return true;
+    }
+    const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
+    if (before === undefined) {
+        return true;
+    }
+    const nodeBefore = tr.doc.nodeAt(before);
+    const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type)
+        && canJoin(tr.doc, list.pos);
+    if (!canJoinBackwards) {
+        return true;
+    }
+    tr.join(list.pos);
+    return true;
+};
+const joinListForwards = (tr, listType) => {
+    const list = findParentNode(node => node.type === listType)(tr.selection);
+    if (!list) {
+        return true;
+    }
+    const after = tr.doc.resolve(list.start).after(list.depth);
+    if (after === undefined) {
+        return true;
+    }
+    const nodeAfter = tr.doc.nodeAt(after);
+    const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type)
+        && canJoin(tr.doc, after);
+    if (!canJoinForwards) {
+        return true;
+    }
+    tr.join(after);
+    return true;
+};
 const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dispatch, chain, commands, can, }) => {
-    const { extensions } = editor.options;
+    const { extensions } = editor.extensionManager;
     const listType = getNodeType(listTypeOrName, state.schema);
     const itemType = getNodeType(itemTypeOrName, state.schema);
     const { selection } = state;
@@ -1886,40 +2339,108 @@ const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dis
         if (isList(parentList.node.type.name, extensions)
             && listType.validContent(parentList.node.content)
             && dispatch) {
-            tr.setNodeMarkup(parentList.pos, listType);
-            return true;
+            return chain()
+                .command(() => {
+                tr.setNodeMarkup(parentList.pos, listType);
+                return true;
+            })
+                .command(() => joinListBackwards(tr, listType))
+                .command(() => joinListForwards(tr, listType))
+                .run();
         }
     }
-    const canWrapInList = can().wrapInList(listType);
-    // try to convert node to paragraph if needed
-    if (!canWrapInList) {
-        return chain()
-            .clearNodes()
-            .wrapInList(listType)
-            .run();
-    }
-    return commands.wrapInList(listType);
+    return chain()
+        // try to convert node to default node if needed
+        .command(() => {
+        const canWrapInList = can().wrapInList(listType);
+        if (canWrapInList) {
+            return true;
+        }
+        return commands.clearNodes();
+    })
+        .wrapInList(listType)
+        .command(() => joinListBackwards(tr, listType))
+        .command(() => joinListForwards(tr, listType))
+        .run();
 };
 
-var toggleList$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleList: toggleList
-});
+function isMarkActive(state, typeOrName, attributes = {}) {
+    const { empty, ranges } = state.selection;
+    const type = typeOrName
+        ? getMarkType(typeOrName, state.schema)
+        : null;
+    if (empty) {
+        return !!(state.storedMarks || state.selection.$from.marks())
+            .filter(mark => {
+            if (!type) {
+                return true;
+            }
+            return type.name === mark.type.name;
+        })
+            .find(mark => objectIncludes(mark.attrs, attributes, { strict: false }));
+    }
+    let selectionRange = 0;
+    const markRanges = [];
+    ranges.forEach(({ $from, $to }) => {
+        const from = $from.pos;
+        const to = $to.pos;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+            if (!node.isText && !node.marks.length) {
+                return;
+            }
+            const relativeFrom = Math.max(from, pos);
+            const relativeTo = Math.min(to, pos + node.nodeSize);
+            const range = relativeTo - relativeFrom;
+            selectionRange += range;
+            markRanges.push(...node.marks.map(mark => ({
+                mark,
+                from: relativeFrom,
+                to: relativeTo,
+            })));
+        });
+    });
+    if (selectionRange === 0) {
+        return false;
+    }
+    // calculate range of matched mark
+    const matchedRange = markRanges
+        .filter(markRange => {
+        if (!type) {
+            return true;
+        }
+        return type.name === markRange.mark.type.name;
+    })
+        .filter(markRange => objectIncludes(markRange.mark.attrs, attributes, { strict: false }))
+        .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
+    // calculate range of marks that excludes the searched mark
+    // for example `code` doesn’t allow any other marks
+    const excludedRange = markRanges
+        .filter(markRange => {
+        if (!type) {
+            return true;
+        }
+        return markRange.mark.type !== type
+            && markRange.mark.type.excludes(type);
+    })
+        .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
+    // we only include the result of `excludedRange`
+    // if there is a match at all
+    const range = matchedRange > 0
+        ? matchedRange + excludedRange
+        : matchedRange;
+    return range >= selectionRange;
+}
 
-const toggleMark = (typeOrName, attributes = {}) => ({ state, commands }) => {
+const toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands }) => {
+    const { extendEmptyMarkRange = false } = options;
     const type = getMarkType(typeOrName, state.schema);
     const isActive = isMarkActive(state, type, attributes);
     if (isActive) {
-        return commands.unsetMark(type);
+        return commands.unsetMark(type, { extendEmptyMarkRange });
     }
     return commands.setMark(type, attributes);
 };
 
-var toggleMark$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleMark: toggleMark
-});
-
 const toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands }) => {
     const type = getNodeType(typeOrName, state.schema);
     const toggleType = getNodeType(toggleTypeOrName, state.schema);
@@ -1930,129 +2451,190 @@ const toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state,
     return commands.setNode(type, attributes);
 };
 
-var toggleNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleNode: toggleNode
-});
-
-const toggleWrap = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+const toggleWrap = (typeOrName, attributes = {}) => ({ state, commands }) => {
     const type = getNodeType(typeOrName, state.schema);
     const isActive = isNodeActive(state, type, attributes);
     if (isActive) {
-        return lift$2(state, dispatch);
+        return commands.lift(type);
     }
-    return wrapIn$2(type, attributes)(state, dispatch);
+    return commands.wrapIn(type, attributes);
 };
 
-var toggleWrap$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleWrap: toggleWrap
-});
-
 const undoInputRule = () => ({ state, dispatch }) => {
-    return undoInputRule$2(state, dispatch);
+    const plugins = state.plugins;
+    for (let i = 0; i < plugins.length; i += 1) {
+        const plugin = plugins[i];
+        let undoable;
+        // @ts-ignore
+        // eslint-disable-next-line
+        if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+            if (dispatch) {
+                const tr = state.tr;
+                const toUndo = undoable.transform;
+                for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
+                    tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+                }
+                if (undoable.text) {
+                    const marks = tr.doc.resolve(undoable.from).marks();
+                    tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+                }
+                else {
+                    tr.delete(undoable.from, undoable.to);
+                }
+            }
+            return true;
+        }
+    }
+    return false;
 };
 
-var undoInputRule$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  undoInputRule: undoInputRule
-});
-
-const unsetAllMarks = () => ({ tr, state, dispatch }) => {
+const unsetAllMarks = () => ({ tr, dispatch }) => {
     const { selection } = tr;
     const { empty, ranges } = selection;
     if (empty) {
         return true;
     }
     if (dispatch) {
-        Object
-            .entries(state.schema.marks)
-            .forEach(([, mark]) => {
-            ranges.forEach(range => {
-                tr.removeMark(range.$from.pos, range.$to.pos, mark);
-            });
+        ranges.forEach(range => {
+            tr.removeMark(range.$from.pos, range.$to.pos);
         });
     }
     return true;
 };
 
-var unsetAllMarks$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  unsetAllMarks: unsetAllMarks
-});
-
-const unsetMark = typeOrName => ({ tr, state, dispatch }) => {
+const unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
+    var _a;
+    const { extendEmptyMarkRange = false } = options;
     const { selection } = tr;
     const type = getMarkType(typeOrName, state.schema);
     const { $from, empty, ranges } = selection;
-    if (dispatch) {
-        if (empty) {
-            let { from, to } = selection;
-            const range = getMarkRange($from, type);
-            if (range) {
-                from = range.from;
-                to = range.to;
-            }
-            tr.removeMark(from, to, type);
-        }
-        else {
-            ranges.forEach(range => {
-                tr.removeMark(range.$from.pos, range.$to.pos, type);
-            });
+    if (!dispatch) {
+        return true;
+    }
+    if (empty && extendEmptyMarkRange) {
+        let { from, to } = selection;
+        const attrs = (_a = $from.marks().find(mark => mark.type === type)) === null || _a === void 0 ? void 0 : _a.attrs;
+        const range = getMarkRange($from, type, attrs);
+        if (range) {
+            from = range.from;
+            to = range.to;
         }
-        tr.removeStoredMark(type);
+        tr.removeMark(from, to, type);
+    }
+    else {
+        ranges.forEach(range => {
+            tr.removeMark(range.$from.pos, range.$to.pos, type);
+        });
     }
+    tr.removeStoredMark(type);
     return true;
 };
 
-var unsetMark$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  unsetMark: unsetMark
-});
-
-const updateNodeAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const { selection } = tr;
-    const { ranges } = selection;
-    ranges.forEach(range => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-            if (node.type === type && dispatch) {
-                tr.setNodeMarkup(pos, undefined, {
-                    ...node.attrs,
-                    ...attributes,
-                });
-            }
+const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+    let nodeType = null;
+    let markType = null;
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
+        ? typeOrName
+        : typeOrName.name, state.schema);
+    if (!schemaType) {
+        return false;
+    }
+    if (schemaType === 'node') {
+        nodeType = getNodeType(typeOrName, state.schema);
+    }
+    if (schemaType === 'mark') {
+        markType = getMarkType(typeOrName, state.schema);
+    }
+    if (dispatch) {
+        tr.selection.ranges.forEach(range => {
+            const from = range.$from.pos;
+            const to = range.$to.pos;
+            state.doc.nodesBetween(from, to, (node, pos) => {
+                if (nodeType && nodeType === node.type) {
+                    tr.setNodeMarkup(pos, undefined, {
+                        ...node.attrs,
+                        ...attributes,
+                    });
+                }
+                if (markType && node.marks.length) {
+                    node.marks.forEach(mark => {
+                        if (markType === mark.type) {
+                            const trimmedFrom = Math.max(pos, from);
+                            const trimmedTo = Math.min(pos + node.nodeSize, to);
+                            tr.addMark(trimmedFrom, trimmedTo, markType.create({
+                                ...mark.attrs,
+                                ...attributes,
+                            }));
+                        }
+                    });
+                }
+            });
         });
-    });
+    }
     return true;
 };
 
-var updateNodeAttributes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  updateNodeAttributes: updateNodeAttributes
-});
-
 const wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
-    const isActive = isNodeActive(state, type, attributes);
-    if (isActive) {
-        return false;
-    }
-    return wrapIn$2(type, attributes)(state, dispatch);
+    return wrapIn$1(type, attributes)(state, dispatch);
 };
 
-var wrapIn$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  wrapIn: wrapIn
-});
-
 const wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
-    return wrapInList$2(type, attributes)(state, dispatch);
+    return wrapInList$1(type, attributes)(state, dispatch);
 };
 
-var wrapInList$1 = /*#__PURE__*/Object.freeze({
+var commands = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  blur: blur,
+  clearContent: clearContent,
+  clearNodes: clearNodes,
+  command: command,
+  createParagraphNear: createParagraphNear,
+  deleteNode: deleteNode,
+  deleteRange: deleteRange,
+  deleteSelection: deleteSelection,
+  enter: enter,
+  exitCode: exitCode,
+  extendMarkRange: extendMarkRange,
+  first: first,
+  focus: focus,
+  forEach: forEach,
+  insertContent: insertContent,
+  insertContentAt: insertContentAt,
+  joinBackward: joinBackward,
+  joinForward: joinForward,
+  keyboardShortcut: keyboardShortcut,
+  lift: lift,
+  liftEmptyBlock: liftEmptyBlock,
+  liftListItem: liftListItem,
+  newlineInCode: newlineInCode,
+  resetAttributes: resetAttributes,
+  scrollIntoView: scrollIntoView,
+  selectAll: selectAll,
+  selectNodeBackward: selectNodeBackward,
+  selectNodeForward: selectNodeForward,
+  selectParentNode: selectParentNode,
+  selectTextblockEnd: selectTextblockEnd,
+  selectTextblockStart: selectTextblockStart,
+  setContent: setContent,
+  setMark: setMark,
+  setMeta: setMeta,
+  setNode: setNode,
+  setNodeSelection: setNodeSelection,
+  setTextSelection: setTextSelection,
+  sinkListItem: sinkListItem,
+  splitBlock: splitBlock,
+  splitListItem: splitListItem,
+  toggleList: toggleList,
+  toggleMark: toggleMark,
+  toggleNode: toggleNode,
+  toggleWrap: toggleWrap,
+  undoInputRule: undoInputRule,
+  unsetAllMarks: unsetAllMarks,
+  unsetMark: unsetMark,
+  updateAttributes: updateAttributes,
+  wrapIn: wrapIn,
   wrapInList: wrapInList
 });
 
@@ -2060,53 +2642,7 @@ const Commands = Extension.create({
     name: 'commands',
     addCommands() {
         return {
-            ...blur$1,
-            ...clearContent$1,
-            ...clearNodes$1,
-            ...command$1,
-            ...createParagraphNear$1,
-            ...deleteRange$1,
-            ...deleteSelection$1,
-            ...enter$1,
-            ...exitCode$1,
-            ...extendMarkRange$1,
-            ...first$1,
-            ...focus$1,
-            ...insertContent$1,
-            ...insertHTML$1,
-            ...insertNode$1,
-            ...insertText$1,
-            ...joinBackward$1,
-            ...joinForward$1,
-            ...keyboardShortcut$1,
-            ...lift$1,
-            ...liftEmptyBlock$1,
-            ...liftListItem$1,
-            ...newlineInCode$1,
-            ...replace$1,
-            ...replaceRange$1,
-            ...resetNodeAttributes$1,
-            ...scrollIntoView$1,
-            ...selectAll$1,
-            ...selectNodeBackward$1,
-            ...selectNodeForward$1,
-            ...selectParentNode$1,
-            ...setContent$1,
-            ...setMark$1,
-            ...setNode$1,
-            ...sinkListItem$1,
-            ...splitBlock$1,
-            ...splitListItem$1,
-            ...toggleList$1,
-            ...toggleMark$1,
-            ...toggleNode$1,
-            ...toggleWrap$1,
-            ...undoInputRule$1,
-            ...unsetAllMarks$1,
-            ...unsetMark$1,
-            ...updateNodeAttributes$1,
-            ...wrapIn$1,
-            ...wrapInList$1,
+            ...commands,
         };
     },
 });
@@ -2133,9 +2669,6 @@ const FocusEvents = Extension.create({
             new Plugin({
                 key: new PluginKey('focusEvents'),
                 props: {
-                    attributes: {
-                        tabindex: '0',
-                    },
                     handleDOMEvents: {
                         focus: (view, event) => {
                             editor.isFocused = true;
@@ -2165,6 +2698,20 @@ const Keymap = Extension.create({
     addKeyboardShortcuts() {
         const handleBackspace = () => this.editor.commands.first(({ commands }) => [
             () => commands.undoInputRule(),
+            // maybe convert first text block node to default node
+            () => commands.command(({ tr }) => {
+                const { selection, doc } = tr;
+                const { empty, $anchor } = selection;
+                const { pos, parent } = $anchor;
+                const isAtStart = Selection.atStart(doc).from === pos;
+                if (!empty
+                    || !isAtStart
+                    || !parent.type.isTextblock
+                    || parent.textContent.length) {
+                    return false;
+                }
+                return commands.clearNodes();
+            }),
             () => commands.deleteSelection(),
             () => commands.joinBackward(),
             () => commands.selectNodeBackward(),
@@ -2174,33 +2721,176 @@ const Keymap = Extension.create({
             () => commands.joinForward(),
             () => commands.selectNodeForward(),
         ]);
-        return {
-            Enter: () => this.editor.commands.first(({ commands }) => [
-                () => commands.newlineInCode(),
-                () => commands.createParagraphNear(),
-                () => commands.liftEmptyBlock(),
-                () => commands.splitBlock(),
-            ]),
+        const handleEnter = () => this.editor.commands.first(({ commands }) => [
+            () => commands.newlineInCode(),
+            () => commands.createParagraphNear(),
+            () => commands.liftEmptyBlock(),
+            () => commands.splitBlock(),
+        ]);
+        const baseKeymap = {
+            Enter: handleEnter,
             'Mod-Enter': () => this.editor.commands.exitCode(),
-            Backspace: () => handleBackspace(),
-            'Mod-Backspace': () => handleBackspace(),
-            Delete: () => handleDelete(),
-            'Mod-Delete': () => handleDelete(),
-            // we don’t need a custom `selectAll` for now
-            // 'Mod-a': () => this.editor.commands.selectAll(),
+            Backspace: handleBackspace,
+            'Mod-Backspace': handleBackspace,
+            'Shift-Backspace': handleBackspace,
+            Delete: handleDelete,
+            'Mod-Delete': handleDelete,
+            'Mod-a': () => this.editor.commands.selectAll(),
         };
+        const pcKeymap = {
+            ...baseKeymap,
+        };
+        const macKeymap = {
+            ...baseKeymap,
+            'Ctrl-h': handleBackspace,
+            'Alt-Backspace': handleBackspace,
+            'Ctrl-d': handleDelete,
+            'Ctrl-Alt-Backspace': handleDelete,
+            'Alt-Delete': handleDelete,
+            'Alt-d': handleDelete,
+            'Ctrl-a': () => this.editor.commands.selectTextblockStart(),
+            'Ctrl-e': () => this.editor.commands.selectTextblockEnd(),
+        };
+        if (isiOS() || isMacOS()) {
+            return macKeymap;
+        }
+        return pcKeymap;
     },
-});
-
-var extensions = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ClipboardTextSerializer: ClipboardTextSerializer,
+    addProseMirrorPlugins() {
+        return [
+            // With this plugin we check if the whole document was selected and deleted.
+            // In this case we will additionally call `clearNodes()` to convert e.g. a heading
+            // to a paragraph if necessary.
+            // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
+            // with many other commands.
+            new Plugin({
+                key: new PluginKey('clearDocument'),
+                appendTransaction: (transactions, oldState, newState) => {
+                    const docChanges = transactions.some(transaction => transaction.docChanged)
+                        && !oldState.doc.eq(newState.doc);
+                    if (!docChanges) {
+                        return;
+                    }
+                    const { empty, from, to } = oldState.selection;
+                    const allFrom = Selection.atStart(oldState.doc).from;
+                    const allEnd = Selection.atEnd(oldState.doc).to;
+                    const allWasSelected = from === allFrom && to === allEnd;
+                    const isEmpty = newState.doc.textBetween(0, newState.doc.content.size, ' ', ' ').length === 0;
+                    if (empty || !allWasSelected || !isEmpty) {
+                        return;
+                    }
+                    const tr = newState.tr;
+                    const state = createChainableState({
+                        state: newState,
+                        transaction: tr,
+                    });
+                    const { commands } = new CommandManager({
+                        editor: this.editor,
+                        state,
+                    });
+                    commands.clearNodes();
+                    if (!tr.steps.length) {
+                        return;
+                    }
+                    return tr;
+                },
+            }),
+        ];
+    },
+});
+
+const Tabindex = Extension.create({
+    name: 'tabindex',
+    addProseMirrorPlugins() {
+        return [
+            new Plugin({
+                key: new PluginKey('tabindex'),
+                props: {
+                    attributes: this.editor.isEditable ? { tabindex: '0' } : {},
+                },
+            }),
+        ];
+    },
+});
+
+var extensions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ClipboardTextSerializer: ClipboardTextSerializer,
   Commands: Commands,
   Editable: Editable,
   FocusEvents: FocusEvents,
-  Keymap: Keymap
+  Keymap: Keymap,
+  Tabindex: Tabindex
 });
 
+function getNodeAttributes(state, typeOrName) {
+    const type = getNodeType(typeOrName, state.schema);
+    const { from, to } = state.selection;
+    const nodes = [];
+    state.doc.nodesBetween(from, to, node => {
+        nodes.push(node);
+    });
+    const node = nodes
+        .reverse()
+        .find(nodeItem => nodeItem.type.name === type.name);
+    if (!node) {
+        return {};
+    }
+    return { ...node.attrs };
+}
+
+function getAttributes(state, typeOrName) {
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
+        ? typeOrName
+        : typeOrName.name, state.schema);
+    if (schemaType === 'node') {
+        return getNodeAttributes(state, typeOrName);
+    }
+    if (schemaType === 'mark') {
+        return getMarkAttributes(state, typeOrName);
+    }
+    return {};
+}
+
+function getHTMLFromFragment(fragment, schema) {
+    const documentFragment = DOMSerializer
+        .fromSchema(schema)
+        .serializeFragment(fragment);
+    const temporaryDocument = document.implementation.createHTMLDocument();
+    const container = temporaryDocument.createElement('div');
+    container.appendChild(documentFragment);
+    return container.innerHTML;
+}
+
+function getText(node, options) {
+    const range = {
+        from: 0,
+        to: node.content.size,
+    };
+    return getTextBetween(node, range, options);
+}
+
+function isActive(state, name, attributes = {}) {
+    if (!name) {
+        return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes);
+    }
+    const schemaType = getSchemaTypeNameByName(name, state.schema);
+    if (schemaType === 'node') {
+        return isNodeActive(state, name, attributes);
+    }
+    if (schemaType === 'mark') {
+        return isMarkActive(state, name, attributes);
+    }
+    return false;
+}
+
+function isNodeEmpty(node) {
+    var _a;
+    const defaultContent = (_a = node.type.createAndFill()) === null || _a === void 0 ? void 0 : _a.toJSON();
+    const content = node.toJSON();
+    return JSON.stringify(defaultContent) === JSON.stringify(content);
+}
+
 const style = `.ProseMirror {
   position: relative;
 }
@@ -2208,8 +2898,10 @@ const style = `.ProseMirror {
 .ProseMirror {
   word-wrap: break-word;
   white-space: pre-wrap;
+  white-space: break-spaces;
   -webkit-font-variant-ligatures: none;
   font-variant-ligatures: none;
+  font-feature-settings: "liga" 0; /* the above doesn't seem to work in Edge */
 }
 
 .ProseMirror [contenteditable="false"] {
@@ -2224,10 +2916,19 @@ const style = `.ProseMirror {
   white-space: pre-wrap;
 }
 
+img.ProseMirror-separator {
+  display: inline !important;
+  border: none !important;
+  margin: 0 !important;
+  width: 1px !important;
+  height: 1px !important;
+}
+
 .ProseMirror-gapcursor {
   display: none;
   pointer-events: none;
   position: absolute;
+  margin: 0;
 }
 
 .ProseMirror-gapcursor:after {
@@ -2260,16 +2961,37 @@ const style = `.ProseMirror {
 
 .ProseMirror-focused .ProseMirror-gapcursor {
   display: block;
+}
+
+.tippy-box[data-animation=fade][data-state=hidden] {
+  opacity: 0
 }`;
 
+function createStyleTag(style, nonce) {
+    const tipTapStyleTag = document.querySelector('style[data-tiptap-style]');
+    if (tipTapStyleTag !== null) {
+        return tipTapStyleTag;
+    }
+    const styleNode = document.createElement('style');
+    if (nonce) {
+        styleNode.setAttribute('nonce', nonce);
+    }
+    styleNode.setAttribute('data-tiptap-style', '');
+    styleNode.innerHTML = style;
+    document.getElementsByTagName('head')[0].appendChild(styleNode);
+    return styleNode;
+}
+
 class Editor extends EventEmitter {
     constructor(options = {}) {
         super();
         this.isFocused = false;
+        this.extensionStorage = {};
         this.options = {
             element: document.createElement('div'),
             content: '',
             injectCSS: true,
+            injectNonce: undefined,
             extensions: [],
             autofocus: false,
             editable: true,
@@ -2277,14 +2999,14 @@ class Editor extends EventEmitter {
             parseOptions: {},
             enableInputRules: true,
             enablePasteRules: true,
+            enableCoreExtensions: true,
+            onBeforeCreate: () => null,
             onCreate: () => null,
             onUpdate: () => null,
             onSelectionUpdate: () => null,
-            onViewUpdate: () => null,
             onTransaction: () => null,
             onFocus: () => null,
             onBlur: () => null,
-            onResize: () => null,
             onDestroy: () => null,
         };
         this.isCapturingTransaction = false;
@@ -2293,51 +3015,55 @@ class Editor extends EventEmitter {
         this.createExtensionManager();
         this.createCommandManager();
         this.createSchema();
+        this.on('beforeCreate', this.options.onBeforeCreate);
+        this.emit('beforeCreate', { editor: this });
         this.createView();
         this.injectCSS();
         this.on('create', this.options.onCreate);
         this.on('update', this.options.onUpdate);
         this.on('selectionUpdate', this.options.onSelectionUpdate);
-        this.on('viewUpdate', this.options.onViewUpdate);
         this.on('transaction', this.options.onTransaction);
         this.on('focus', this.options.onFocus);
         this.on('blur', this.options.onBlur);
         this.on('destroy', this.options.onDestroy);
         window.setTimeout(() => {
+            if (this.isDestroyed) {
+                return;
+            }
             this.commands.focus(this.options.autofocus);
             this.emit('create', { editor: this });
-            if (window.ResizeObserver) {
-                this.resizeObserver = new ResizeObserver(() => {
-                    this.emit('resize', { editor: this });
-                });
-                this.resizeObserver.observe(this.view.dom);
-            }
         }, 0);
     }
+    /**
+     * Returns the editor storage.
+     */
+    get storage() {
+        return this.extensionStorage;
+    }
     /**
      * An object of all registered commands.
      */
     get commands() {
-        return this.commandManager.createCommands();
+        return this.commandManager.commands;
     }
     /**
      * Create a command chain to call multiple commands at once.
      */
     chain() {
-        return this.commandManager.createChain();
+        return this.commandManager.chain();
     }
     /**
      * Check if a command or a command chain can be executed. Without executing it.
      */
     can() {
-        return this.commandManager.createCan();
+        return this.commandManager.can();
     }
     /**
      * Inject CSS styles.
      */
     injectCSS() {
         if (this.options.injectCSS && document) {
-            this.css = createStyleTag(style);
+            this.css = createStyleTag(style, this.options.injectNonce);
         }
     }
     /**
@@ -2346,22 +3072,34 @@ class Editor extends EventEmitter {
      * @param options A list of options
      */
     setOptions(options = {}) {
-        this.options = { ...this.options, ...options };
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+        if (!this.view || !this.state || this.isDestroyed) {
+            return;
+        }
+        if (this.options.editorProps) {
+            this.view.setProps(this.options.editorProps);
+        }
+        this.view.updateState(this.state);
     }
     /**
      * Update editable state of the editor.
      */
     setEditable(editable) {
         this.setOptions({ editable });
-        if (this.view && this.state && !this.isDestroyed) {
-            this.view.updateState(this.state);
-        }
     }
     /**
      * Returns whether the editor is editable.
      */
     get isEditable() {
-        return this.view && this.view.editable;
+        // since plugins are applied after creating the view
+        // `editable` is always `true` for one tick.
+        // that’s why we also have to check for `options.editable`
+        return this.options.editable
+            && this.view
+            && this.view.editable;
     }
     /**
      * Returns the editor state.
@@ -2376,8 +3114,8 @@ class Editor extends EventEmitter {
      * @param handlePlugins Control how to merge the plugin into the existing plugins.
      */
     registerPlugin(plugin, handlePlugins) {
-        const plugins = typeof handlePlugins === 'function'
-            ? handlePlugins(plugin, this.state.plugins)
+        const plugins = isFunction(handlePlugins)
+            ? handlePlugins(plugin, [...this.state.plugins])
             : [...this.state.plugins, plugin];
         const state = this.state.reconfigure({ plugins });
         this.view.updateState(state);
@@ -2385,7 +3123,7 @@ class Editor extends EventEmitter {
     /**
      * Unregister a ProseMirror plugin.
      *
-     * @param name The plugins name
+     * @param nameOrPluginKey The plugins name
      */
     unregisterPlugin(nameOrPluginKey) {
         if (this.isDestroyed) {
@@ -2405,7 +3143,9 @@ class Editor extends EventEmitter {
      * Creates an extension manager.
      */
     createExtensionManager() {
-        const coreExtensions = Object.entries(extensions).map(([, extension]) => extension);
+        const coreExtensions = this.options.enableCoreExtensions
+            ? Object.values(extensions)
+            : [];
         const allExtensions = [...coreExtensions, ...this.options.extensions].filter(extension => {
             return ['extension', 'node', 'mark'].includes(extension === null || extension === void 0 ? void 0 : extension.type);
         });
@@ -2415,7 +3155,9 @@ class Editor extends EventEmitter {
      * Creates an command manager.
      */
     createCommandManager() {
-        this.commandManager = new CommandManager(this, this.extensionManager.commands);
+        this.commandManager = new CommandManager({
+            editor: this,
+        });
     }
     /**
      * Creates a ProseMirror schema.
@@ -2427,26 +3169,20 @@ class Editor extends EventEmitter {
      * Creates a ProseMirror view.
      */
     createView() {
+        const doc = createDocument(this.options.content, this.schema, this.options.parseOptions);
+        const selection = resolveFocusPosition(doc, this.options.autofocus);
         this.view = new EditorView(this.options.element, {
             ...this.options.editorProps,
             dispatchTransaction: this.dispatchTransaction.bind(this),
             state: EditorState.create({
-                doc: createDocument(this.options.content, this.schema, this.options.parseOptions),
+                doc,
+                selection: selection || undefined,
             }),
         });
         // `editor.view` is not yet available at this time.
         // Therefore we will add all plugins and node views directly afterwards.
         const newState = this.state.reconfigure({
-            plugins: [
-                new Plugin({
-                    view: () => ({
-                        update: () => this.emit('viewUpdate', {
-                            editor: this,
-                        }),
-                    }),
-                }),
-                ...this.extensionManager.plugins,
-            ],
+            plugins: this.extensionManager.plugins,
         });
         this.view.updateState(newState);
         this.createNodeViews();
@@ -2477,9 +3213,6 @@ class Editor extends EventEmitter {
      * @param transaction An editor state transaction
      */
     dispatchTransaction(transaction) {
-        if (transaction.docChanged && !this.isEditable) {
-            return;
-        }
         if (this.isCapturingTransaction) {
             if (!this.capturedTransaction) {
                 this.capturedTransaction = transaction;
@@ -2498,6 +3231,7 @@ class Editor extends EventEmitter {
         if (selectionHasChanged) {
             this.emit('selectionUpdate', {
                 editor: this,
+                transaction,
             });
         }
         const focus = transaction.getMeta('focus');
@@ -2506,12 +3240,14 @@ class Editor extends EventEmitter {
             this.emit('focus', {
                 editor: this,
                 event: focus.event,
+                transaction,
             });
         }
         if (blur) {
             this.emit('blur', {
                 editor: this,
                 event: blur.event,
+                transaction,
             });
         }
         if (!transaction.docChanged || transaction.getMeta('preventUpdate')) {
@@ -2523,20 +3259,10 @@ class Editor extends EventEmitter {
         });
     }
     /**
-     * Get attributes of the currently selected node.
-     *
-     * @param name Name of the node
-     */
-    getNodeAttributes(name) {
-        return getNodeAttributes(this.state, name);
-    }
-    /**
-     * Get attributes of the currently selected mark.
-     *
-     * @param name Name of the mark
+     * Get attributes of the currently selected node or mark.
      */
-    getMarkAttributes(name) {
-        return getMarkAttributes(this.state, name);
+    getAttributes(nameOrType) {
+        return getAttributes(this.state, nameOrType);
     }
     isActive(nameOrAttributes, attributesOrUndefined) {
         const name = typeof nameOrAttributes === 'string'
@@ -2557,7 +3283,20 @@ class Editor extends EventEmitter {
      * Get the document as HTML.
      */
     getHTML() {
-        return getHTMLFromFragment(this.state.doc, this.schema);
+        return getHTMLFromFragment(this.state.doc.content, this.schema);
+    }
+    /**
+     * Get the document as text.
+     */
+    getText(options) {
+        const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
+        return getText(this.state.doc, {
+            blockSeparator,
+            textSerializers: {
+                ...textSerializers,
+                ...getTextSerializersFromSchema(this.schema),
+            },
+        });
     }
     /**
      * Check if there is no content.
@@ -2567,22 +3306,22 @@ class Editor extends EventEmitter {
     }
     /**
      * Get the number of characters for the current document.
+     *
+     * @deprecated
      */
     getCharacterCount() {
+        console.warn('[tiptap warn]: "editor.getCharacterCount()" is deprecated. Please use "editor.storage.characterCount.characters()" instead.');
         return this.state.doc.content.size - 2;
     }
     /**
      * Destroy the editor.
      */
     destroy() {
-        var _a;
-        (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.unobserve(this.view.dom);
         this.emit('destroy');
         if (this.view) {
             this.view.destroy();
         }
         this.removeAllListeners();
-        removeElement(this.css);
     }
     /**
      * Check if the editor is already destroyed.
@@ -2594,88 +3333,584 @@ class Editor extends EventEmitter {
     }
 }
 
-var _configure$1;
-class Node {
-    constructor(config) {
-        this.type = 'node';
-        this.config = {
-            name: 'node',
-            priority: 100,
-            defaultOptions: {},
-        };
-        _configure$1.set(this, (options) => {
-            this.options = mergeDeep(this.config.defaultOptions, options);
-            return this;
+/**
+ * Returns a new `Transform` based on all steps of the passed transactions.
+ */
+function combineTransactionSteps(oldDoc, transactions) {
+    const transform = new Transform(oldDoc);
+    transactions.forEach(transaction => {
+        transaction.steps.forEach(step => {
+            transform.step(step);
         });
-        this.config = {
-            ...this.config,
-            ...config,
+    });
+    return transform;
+}
+
+function defaultBlockAt(match) {
+    for (let i = 0; i < match.edgeCount; i += 1) {
+        const { type } = match.edge(i);
+        if (type.isTextblock && !type.hasRequiredAttrs()) {
+            return type;
+        }
+    }
+    return null;
+}
+
+function findChildren(node, predicate) {
+    const nodesWithPos = [];
+    node.descendants((child, pos) => {
+        if (predicate(child)) {
+            nodesWithPos.push({
+                node: child,
+                pos,
+            });
+        }
+    });
+    return nodesWithPos;
+}
+
+/**
+ * Same as `findChildren` but searches only within a `range`.
+ */
+function findChildrenInRange(node, range, predicate) {
+    const nodesWithPos = [];
+    // if (range.from === range.to) {
+    //   const nodeAt = node.nodeAt(range.from)
+    //   if (nodeAt) {
+    //     nodesWithPos.push({
+    //       node: nodeAt,
+    //       pos: range.from,
+    //     })
+    //   }
+    // }
+    node.nodesBetween(range.from, range.to, (child, pos) => {
+        if (predicate(child)) {
+            nodesWithPos.push({
+                node: child,
+                pos,
+            });
+        }
+    });
+    return nodesWithPos;
+}
+
+function getSchema(extensions) {
+    const resolvedExtensions = ExtensionManager.resolve(extensions);
+    return getSchemaByResolvedExtensions(resolvedExtensions);
+}
+
+function generateHTML(doc, extensions) {
+    const schema = getSchema(extensions);
+    const contentNode = Node$1.fromJSON(schema, doc);
+    return getHTMLFromFragment(contentNode.content, schema);
+}
+
+function generateJSON(html, extensions) {
+    const schema = getSchema(extensions);
+    const dom = elementFromString(html);
+    return DOMParser.fromSchema(schema)
+        .parse(dom)
+        .toJSON();
+}
+
+function generateText(doc, extensions, options) {
+    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
+    const schema = getSchema(extensions);
+    const contentNode = Node$1.fromJSON(schema, doc);
+    return getText(contentNode, {
+        blockSeparator,
+        textSerializers: {
+            ...textSerializers,
+            ...getTextSerializersFromSchema(schema),
+        },
+    });
+}
+
+/**
+ * Removes duplicated values within an array.
+ * Supports numbers, strings and objects.
+ */
+function removeDuplicates(array, by = JSON.stringify) {
+    const seen = {};
+    return array.filter(item => {
+        const key = by(item);
+        return Object.prototype.hasOwnProperty.call(seen, key)
+            ? false
+            : (seen[key] = true);
+    });
+}
+
+/**
+ * Removes duplicated ranges and ranges that are
+ * fully captured by other ranges.
+ */
+function simplifyChangedRanges(changes) {
+    const uniqueChanges = removeDuplicates(changes);
+    return uniqueChanges.length === 1
+        ? uniqueChanges
+        : uniqueChanges.filter((change, index) => {
+            const rest = uniqueChanges.filter((_, i) => i !== index);
+            return !rest.some(otherChange => {
+                return change.oldRange.from >= otherChange.oldRange.from
+                    && change.oldRange.to <= otherChange.oldRange.to
+                    && change.newRange.from >= otherChange.newRange.from
+                    && change.newRange.to <= otherChange.newRange.to;
+            });
+        });
+}
+/**
+ * Returns a list of changed ranges
+ * based on the first and last state of all steps.
+ */
+function getChangedRanges(transform) {
+    const { mapping, steps } = transform;
+    const changes = [];
+    mapping.maps.forEach((stepMap, index) => {
+        const ranges = [];
+        // This accounts for step changes where no range was actually altered
+        // e.g. when setting a mark, node attribute, etc.
+        // @ts-ignore
+        if (!stepMap.ranges.length) {
+            const { from, to } = steps[index];
+            if (from === undefined || to === undefined) {
+                return;
+            }
+            ranges.push({ from, to });
+        }
+        else {
+            stepMap.forEach((from, to) => {
+                ranges.push({ from, to });
+            });
+        }
+        ranges.forEach(({ from, to }) => {
+            const newStart = mapping.slice(index).map(from, -1);
+            const newEnd = mapping.slice(index).map(to);
+            const oldStart = mapping.invert().map(newStart, -1);
+            const oldEnd = mapping.invert().map(newEnd);
+            changes.push({
+                oldRange: {
+                    from: oldStart,
+                    to: oldEnd,
+                },
+                newRange: {
+                    from: newStart,
+                    to: newEnd,
+                },
+            });
+        });
+    });
+    return simplifyChangedRanges(changes);
+}
+
+function getDebugJSON(node, startOffset = 0) {
+    const isTopNode = node.type === node.type.schema.topNodeType;
+    const increment = isTopNode ? 0 : 1;
+    const from = startOffset;
+    const to = from + node.nodeSize;
+    const marks = node.marks.map(mark => {
+        const output = {
+            type: mark.type.name,
         };
-        this.options = this.config.defaultOptions;
+        if (Object.keys(mark.attrs).length) {
+            output.attrs = { ...mark.attrs };
+        }
+        return output;
+    });
+    const attrs = { ...node.attrs };
+    const output = {
+        type: node.type.name,
+        from,
+        to,
+    };
+    if (Object.keys(attrs).length) {
+        output.attrs = attrs;
     }
-    static create(config) {
-        return new Node(config);
+    if (marks.length) {
+        output.marks = marks;
     }
-    configure(options = {}) {
-        var _a;
-        return __classPrivateFieldGet((_a = Node
-            .create(this.config)), _configure$1).call(_a, options);
+    if (node.content.childCount) {
+        output.content = [];
+        node.forEach((child, offset) => {
+            var _a;
+            (_a = output.content) === null || _a === void 0 ? void 0 : _a.push(getDebugJSON(child, startOffset + offset + increment));
+        });
     }
-    extend(extendedConfig) {
-        return new Node({
-            ...this.config,
-            ...extendedConfig,
+    if (node.text) {
+        output.text = node.text;
+    }
+    return output;
+}
+
+function getMarksBetween(from, to, doc) {
+    const marks = [];
+    // get all inclusive marks on empty selection
+    if (from === to) {
+        doc
+            .resolve(from)
+            .marks()
+            .forEach(mark => {
+            const $pos = doc.resolve(from - 1);
+            const range = getMarkRange($pos, mark.type);
+            if (!range) {
+                return;
+            }
+            marks.push({
+                mark,
+                ...range,
+            });
         });
     }
-}
-_configure$1 = new WeakMap();
+    else {
+        doc.nodesBetween(from, to, (node, pos) => {
+            marks.push(...node.marks.map(mark => ({
+                from: pos,
+                to: pos + node.nodeSize,
+                mark,
+            })));
+        });
+    }
+    return marks;
+}
+
+function isNodeSelection(value) {
+    return isObject(value) && value instanceof NodeSelection;
+}
+
+function posToDOMRect(view, from, to) {
+    const minPos = 0;
+    const maxPos = view.state.doc.content.size;
+    const resolvedFrom = minMax(from, minPos, maxPos);
+    const resolvedEnd = minMax(to, minPos, maxPos);
+    const start = view.coordsAtPos(resolvedFrom);
+    const end = view.coordsAtPos(resolvedEnd, -1);
+    const top = Math.min(start.top, end.top);
+    const bottom = Math.max(start.bottom, end.bottom);
+    const left = Math.min(start.left, end.left);
+    const right = Math.max(start.right, end.right);
+    const width = right - left;
+    const height = bottom - top;
+    const x = left;
+    const y = top;
+    const data = {
+        top,
+        bottom,
+        left,
+        right,
+        width,
+        height,
+        x,
+        y,
+    };
+    return {
+        ...data,
+        toJSON: () => data,
+    };
+}
+
+/**
+ * Build an input rule that adds a mark when the
+ * matched text is typed into it.
+ */
+function markInputRule(config) {
+    return new InputRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            const attributes = callOrReturn(config.getAttributes, undefined, match);
+            if (attributes === false || attributes === null) {
+                return null;
+            }
+            const { tr } = state;
+            const captureGroup = match[match.length - 1];
+            const fullMatch = match[0];
+            let markEnd = range.to;
+            if (captureGroup) {
+                const startSpaces = fullMatch.search(/\S/);
+                const textStart = range.from + fullMatch.indexOf(captureGroup);
+                const textEnd = textStart + captureGroup.length;
+                const excludedMarks = getMarksBetween(range.from, range.to, state.doc)
+                    .filter(item => {
+                    // @ts-ignore
+                    const excluded = item.mark.type.excluded;
+                    return excluded.find(type => type === config.type && type !== item.mark.type);
+                })
+                    .filter(item => item.to > textStart);
+                if (excludedMarks.length) {
+                    return null;
+                }
+                if (textEnd < range.to) {
+                    tr.delete(textEnd, range.to);
+                }
+                if (textStart > range.from) {
+                    tr.delete(range.from + startSpaces, textStart);
+                }
+                markEnd = range.from + startSpaces + captureGroup.length;
+                tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
+                tr.removeStoredMark(config.type);
+            }
+        },
+    });
+}
+
+/**
+ * Build an input rule that adds a node when the
+ * matched text is typed into it.
+ */
+function nodeInputRule(config) {
+    return new InputRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            const attributes = callOrReturn(config.getAttributes, undefined, match) || {};
+            const { tr } = state;
+            const start = range.from;
+            let end = range.to;
+            if (match[1]) {
+                const offset = match[0].lastIndexOf(match[1]);
+                let matchStart = start + offset;
+                if (matchStart > end) {
+                    matchStart = end;
+                }
+                else {
+                    end = matchStart + match[1].length;
+                }
+                // insert last typed character
+                const lastChar = match[0][match[0].length - 1];
+                tr.insertText(lastChar, start + match[0].length - 1);
+                // insert node from input rule
+                tr.replaceWith(matchStart, end, config.type.create(attributes));
+            }
+            else if (match[0]) {
+                tr.replaceWith(start, end, config.type.create(attributes));
+            }
+        },
+    });
+}
+
+/**
+ * Build an input rule that changes the type of a textblock when the
+ * matched text is typed into it. When using a regular expresion you’ll
+ * probably want the regexp to start with `^`, so that the pattern can
+ * only occur at the start of a textblock.
+ */
+function textblockTypeInputRule(config) {
+    return new InputRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            const $start = state.doc.resolve(range.from);
+            const attributes = callOrReturn(config.getAttributes, undefined, match) || {};
+            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), config.type)) {
+                return null;
+            }
+            state.tr
+                .delete(range.from, range.to)
+                .setBlockType(range.from, range.from, config.type, attributes);
+        },
+    });
+}
+
+/**
+ * Build an input rule that replaces text when the
+ * matched text is typed into it.
+ */
+function textInputRule(config) {
+    return new InputRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            let insert = config.replace;
+            let start = range.from;
+            const end = range.to;
+            if (match[1]) {
+                const offset = match[0].lastIndexOf(match[1]);
+                insert += match[0].slice(offset + match[1].length);
+                start += offset;
+                const cutOff = start - end;
+                if (cutOff > 0) {
+                    insert = match[0].slice(offset - cutOff, offset) + insert;
+                    start = end;
+                }
+            }
+            state.tr.insertText(insert, start, end);
+        },
+    });
+}
+
+/**
+ * Build an input rule for automatically wrapping a textblock when a
+ * given string is typed. When using a regular expresion you’ll
+ * probably want the regexp to start with `^`, so that the pattern can
+ * only occur at the start of a textblock.
+ *
+ * `type` is the type of node to wrap in.
+ *
+ * By default, if there’s a node with the same type above the newly
+ * wrapped node, the rule will try to join those
+ * two nodes. You can pass a join predicate, which takes a regular
+ * expression match and the node before the wrapped node, and can
+ * return a boolean to indicate whether a join should happen.
+ */
+function wrappingInputRule(config) {
+    return new InputRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            const attributes = callOrReturn(config.getAttributes, undefined, match) || {};
+            const tr = state.tr.delete(range.from, range.to);
+            const $start = tr.doc.resolve(range.from);
+            const blockRange = $start.blockRange();
+            const wrapping = blockRange && findWrapping(blockRange, config.type, attributes);
+            if (!wrapping) {
+                return null;
+            }
+            tr.wrap(blockRange, wrapping);
+            const before = tr.doc.resolve(range.from - 1).nodeBefore;
+            if (before
+                && before.type === config.type
+                && canJoin(tr.doc, range.from - 1)
+                && (!config.joinPredicate || config.joinPredicate(match, before))) {
+                tr.join(range.from - 1);
+            }
+        },
+    });
+}
 
-var _configure;
 class Mark {
-    constructor(config) {
+    constructor(config = {}) {
         this.type = 'mark';
+        this.name = 'mark';
+        this.parent = null;
+        this.child = null;
         this.config = {
-            name: 'mark',
-            priority: 100,
+            name: this.name,
             defaultOptions: {},
         };
-        _configure.set(this, (options) => {
-            this.options = mergeDeep(this.config.defaultOptions, options);
-            return this;
-        });
         this.config = {
             ...this.config,
             ...config,
         };
+        this.name = this.config.name;
+        if (config.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
+        }
+        // TODO: remove `addOptions` fallback
         this.options = this.config.defaultOptions;
+        if (this.config.addOptions) {
+            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
+                name: this.name,
+            }));
+        }
+        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
+            name: this.name,
+            options: this.options,
+        })) || {};
     }
-    static create(config) {
+    static create(config = {}) {
         return new Mark(config);
     }
     configure(options = {}) {
-        var _a;
-        return __classPrivateFieldGet((_a = Mark
-            .create(this.config)), _configure).call(_a, options);
+        // return a new instance so we can use the same extension
+        // with different calls of `configure`
+        const extension = this.extend();
+        extension.options = mergeDeep(this.options, options);
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
+    }
+    extend(extendedConfig = {}) {
+        const extension = new Mark(extendedConfig);
+        extension.parent = this;
+        this.child = extension;
+        extension.name = extendedConfig.name
+            ? extendedConfig.name
+            : extension.parent.name;
+        if (extendedConfig.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
+        }
+        extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
+            name: extension.name,
+        }));
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
     }
-    extend(extendedConfig) {
-        return new Mark({
+}
+
+class Node {
+    constructor(config = {}) {
+        this.type = 'node';
+        this.name = 'node';
+        this.parent = null;
+        this.child = null;
+        this.config = {
+            name: this.name,
+            defaultOptions: {},
+        };
+        this.config = {
             ...this.config,
-            ...extendedConfig,
-        });
+            ...config,
+        };
+        this.name = this.config.name;
+        if (config.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
+        }
+        // TODO: remove `addOptions` fallback
+        this.options = this.config.defaultOptions;
+        if (this.config.addOptions) {
+            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
+                name: this.name,
+            }));
+        }
+        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
+            name: this.name,
+            options: this.options,
+        })) || {};
     }
-}
-_configure = new WeakMap();
+    static create(config = {}) {
+        return new Node(config);
+    }
+    configure(options = {}) {
+        // return a new instance so we can use the same extension
+        // with different calls of `configure`
+        const extension = this.extend();
+        extension.options = mergeDeep(this.options, options);
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
+    }
+    extend(extendedConfig = {}) {
+        const extension = new Node(extendedConfig);
+        extension.parent = this;
+        this.child = extension;
+        extension.name = extendedConfig.name
+            ? extendedConfig.name
+            : extension.parent.name;
+        if (extendedConfig.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
+        }
+        extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
+            name: extension.name,
+        }));
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
+    }
+}
 
 class NodeView {
     constructor(component, props, options) {
         this.isDragging = false;
+        this.component = component;
+        this.editor = props.editor;
         this.options = {
             stopEvent: null,
-            update: null,
+            ignoreMutation: null,
+            ...options,
         };
-        this.component = component;
-        this.options = { ...this.options, ...options };
-        this.editor = props.editor;
         this.extension = props.extension;
         this.node = props.node;
         this.decorations = props.decorations;
@@ -2687,23 +3922,40 @@ class NodeView {
         return;
     }
     get dom() {
-        return null;
+        return this.editor.view.dom;
     }
     get contentDOM() {
         return null;
     }
     onDragStart(event) {
-        var _a, _b;
-        if (!this.dom) {
-            return;
-        }
+        var _a, _b, _c, _d, _e, _f, _g;
         const { view } = this.editor;
         const target = event.target;
-        if ((_a = this.contentDOM) === null || _a === void 0 ? void 0 : _a.contains(target)) {
+        // get the drag handle element
+        // `closest` is not available for text nodes so we may have to use its parent
+        const dragHandle = target.nodeType === 3
+            ? (_a = target.parentElement) === null || _a === void 0 ? void 0 : _a.closest('[data-drag-handle]')
+            : target.closest('[data-drag-handle]');
+        if (!this.dom
+            || ((_b = this.contentDOM) === null || _b === void 0 ? void 0 : _b.contains(target))
+            || !dragHandle) {
             return;
         }
-        // sometimes `event.target` is not the `dom` element
-        (_b = event.dataTransfer) === null || _b === void 0 ? void 0 : _b.setDragImage(this.dom, 0, 0);
+        let x = 0;
+        let y = 0;
+        // calculate offset for drag element if we use a different drag handle element
+        if (this.dom !== dragHandle) {
+            const domBox = this.dom.getBoundingClientRect();
+            const handleBox = dragHandle.getBoundingClientRect();
+            // In React, we have to go through nativeEvent to reach offsetX/offsetY.
+            const offsetX = (_c = event.offsetX) !== null && _c !== void 0 ? _c : (_d = event.nativeEvent) === null || _d === void 0 ? void 0 : _d.offsetX;
+            const offsetY = (_e = event.offsetY) !== null && _e !== void 0 ? _e : (_f = event.nativeEvent) === null || _f === void 0 ? void 0 : _f.offsetY;
+            x = handleBox.x - domBox.x + offsetX;
+            y = handleBox.y - domBox.y + offsetY;
+        }
+        (_g = event.dataTransfer) === null || _g === void 0 ? void 0 : _g.setDragImage(this.dom, x, y);
+        // we need to tell ProseMirror that we want to move the whole node
+        // so we create a NodeSelection
         const selection = NodeSelection.create(view.state.doc, this.getPos());
         const transaction = view.state.tr.setSelection(selection);
         view.dispatch(transaction);
@@ -2714,7 +3966,7 @@ class NodeView {
             return false;
         }
         if (typeof this.options.stopEvent === 'function') {
-            return this.options.stopEvent(event);
+            return this.options.stopEvent({ event });
         }
         const target = event.target;
         const isInElement = this.dom.contains(target) && !((_a = this.contentDOM) === null || _a === void 0 ? void 0 : _a.contains(target));
@@ -2722,10 +3974,11 @@ class NodeView {
         if (!isInElement) {
             return false;
         }
+        const isDropEvent = event.type === 'drop';
         const isInput = ['INPUT', 'BUTTON', 'SELECT', 'TEXTAREA'].includes(target.tagName)
             || target.isContentEditable;
         // any input event within node views should be ignored by ProseMirror
-        if (isInput) {
+        if (isInput && !isDropEvent) {
             return true;
         }
         const { isEditable } = this.editor;
@@ -2736,7 +3989,7 @@ class NodeView {
         const isPasteEvent = event.type === 'paste';
         const isCutEvent = event.type === 'cut';
         const isClickEvent = event.type === 'mousedown';
-        const isDragEvent = event.type.startsWith('drag') || event.type === 'drop';
+        const isDragEvent = event.type.startsWith('drag');
         // ProseMirror tries to drag selectable nodes
         // even if `draggable` is set to `false`
         // this fix prevents that
@@ -2764,6 +4017,7 @@ class NodeView {
         }
         // these events are handled by prosemirror
         if (isDragging
+            || isDropEvent
             || isCopyEvent
             || isPasteEvent
             || isCutEvent
@@ -2773,156 +4027,166 @@ class NodeView {
         return true;
     }
     ignoreMutation(mutation) {
+        if (!this.dom || !this.contentDOM) {
+            return true;
+        }
+        if (typeof this.options.ignoreMutation === 'function') {
+            return this.options.ignoreMutation({ mutation });
+        }
+        // a leaf/atom node is like a black box for ProseMirror
+        // and should be fully handled by the node view
+        if (this.node.isLeaf || this.node.isAtom) {
+            return true;
+        }
+        // ProseMirror should handle any selections
         if (mutation.type === 'selection') {
-            if (this.node.isLeaf) {
-                return true;
-            }
             return false;
         }
-        if (!this.contentDOM) {
+        // try to prevent a bug on iOS that will break node views on enter
+        // this is because ProseMirror can’t preventDispatch on enter
+        // this will lead to a re-render of the node view on enter
+        // see: https://github.com/ueberdosis/tiptap/issues/1214
+        if (this.dom.contains(mutation.target)
+            && mutation.type === 'childList'
+            && isiOS()
+            && this.editor.isFocused) {
+            const changedNodes = [
+                ...Array.from(mutation.addedNodes),
+                ...Array.from(mutation.removedNodes),
+            ];
+            // we’ll check if every changed node is contentEditable
+            // to make sure it’s probably mutated by ProseMirror
+            if (changedNodes.every(node => node.isContentEditable)) {
+                return false;
+            }
+        }
+        // we will allow mutation contentDOM with attributes
+        // so we can for example adding classes within our node view
+        if (this.contentDOM === mutation.target && mutation.type === 'attributes') {
             return true;
         }
-        const contentDOMHasChanged = !this.contentDOM.contains(mutation.target)
-            || this.contentDOM === mutation.target;
-        return contentDOMHasChanged;
+        // ProseMirror should handle any changes within contentDOM
+        if (this.contentDOM.contains(mutation.target)) {
+            return false;
+        }
+        return true;
     }
     updateAttributes(attributes) {
-        if (!this.editor.view.editable) {
-            return;
-        }
-        const { state } = this.editor.view;
-        const pos = this.getPos();
-        const transaction = state.tr.setNodeMarkup(pos, undefined, {
-            ...this.node.attrs,
-            ...attributes,
+        this.editor.commands.command(({ tr }) => {
+            const pos = this.getPos();
+            tr.setNodeMarkup(pos, undefined, {
+                ...this.node.attrs,
+                ...attributes,
+            });
+            return true;
         });
-        this.editor.view.dispatch(transaction);
+    }
+    deleteNode() {
+        const from = this.getPos();
+        const to = from + this.node.nodeSize;
+        this.editor.commands.deleteRange({ from, to });
     }
 }
 
-function nodeInputRule (regexp, type, getAttributes) {
-    return new InputRule(regexp, (state, match, start, end) => {
-        const attributes = getAttributes instanceof Function
-            ? getAttributes(match)
-            : getAttributes;
-        const { tr } = state;
-        if (match[0]) {
-            tr.replaceWith(start - 1, end, type.create(attributes));
-        }
-        return tr;
-    });
-}
-
-function getMarksBetween(from, to, state) {
-    let marks = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        marks = [...marks, ...node.marks.map(mark => ({
-                from: pos,
-                to: pos + node.nodeSize,
-                mark,
-            }))];
-    });
-    return marks;
-}
-
-function markInputRule (regexp, markType, getAttributes) {
-    return new InputRule(regexp, (state, match, start, end) => {
-        const attributes = getAttributes instanceof Function
-            ? getAttributes(match)
-            : getAttributes;
-        const { tr } = state;
-        const captureGroup = match[match.length - 1];
-        const fullMatch = match[0];
-        let markEnd = end;
-        if (captureGroup) {
-            const startSpaces = fullMatch.search(/\S/);
-            const textStart = start + fullMatch.indexOf(captureGroup);
-            const textEnd = textStart + captureGroup.length;
-            const excludedMarks = getMarksBetween(start, end, state)
-                .filter(item => {
-                // TODO: PR to add excluded to MarkType
-                // @ts-ignore
-                const { excluded } = item.mark.type;
-                return excluded.find((type) => type.name === markType.name);
-            })
-                .filter(item => item.to > textStart);
-            if (excludedMarks.length) {
+/**
+ * Build an paste rule that adds a mark when the
+ * matched text is pasted into it.
+ */
+function markPasteRule(config) {
+    return new PasteRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            const attributes = callOrReturn(config.getAttributes, undefined, match);
+            if (attributes === false || attributes === null) {
                 return null;
             }
-            if (textEnd < end) {
-                tr.delete(textEnd, end);
-            }
-            if (textStart > start) {
-                tr.delete(start + startSpaces, textStart);
+            const { tr } = state;
+            const captureGroup = match[match.length - 1];
+            const fullMatch = match[0];
+            let markEnd = range.to;
+            if (captureGroup) {
+                const startSpaces = fullMatch.search(/\S/);
+                const textStart = range.from + fullMatch.indexOf(captureGroup);
+                const textEnd = textStart + captureGroup.length;
+                const excludedMarks = getMarksBetween(range.from, range.to, state.doc)
+                    .filter(item => {
+                    // @ts-ignore
+                    const excluded = item.mark.type.excluded;
+                    return excluded.find(type => type === config.type && type !== item.mark.type);
+                })
+                    .filter(item => item.to > textStart);
+                if (excludedMarks.length) {
+                    return null;
+                }
+                if (textEnd < range.to) {
+                    tr.delete(textEnd, range.to);
+                }
+                if (textStart > range.from) {
+                    tr.delete(range.from + startSpaces, textStart);
+                }
+                markEnd = range.from + startSpaces + captureGroup.length;
+                tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
+                tr.removeStoredMark(config.type);
             }
-            markEnd = start + startSpaces + captureGroup.length;
-            tr.addMark(start + startSpaces, markEnd, markType.create(attributes));
-            tr.removeStoredMark(markType);
-        }
-        return tr;
+        },
     });
 }
 
-function markPasteRule (regexp, type, getAttrs) {
-    const handler = (fragment, parent) => {
-        const nodes = [];
-        fragment.forEach(child => {
-            if (child.isText && child.text) {
-                const { text } = child;
-                let pos = 0;
-                let match;
-                // eslint-disable-next-line
-                while ((match = regexp.exec(text)) !== null) {
-                    const outerMatch = Math.max(match.length - 2, 0);
-                    const innerMatch = Math.max(match.length - 1, 0);
-                    if (parent === null || parent === void 0 ? void 0 : parent.type.allowsMarkType(type)) {
-                        const start = match.index;
-                        const matchStart = start + match[0].indexOf(match[outerMatch]);
-                        const matchEnd = matchStart + match[outerMatch].length;
-                        const textStart = matchStart + match[outerMatch].lastIndexOf(match[innerMatch]);
-                        const textEnd = textStart + match[innerMatch].length;
-                        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
-                        // adding text before markdown to nodes
-                        if (matchStart > 0) {
-                            nodes.push(child.cut(pos, matchStart));
-                        }
-                        // adding the markdown part to nodes
-                        nodes.push(child
-                            .cut(textStart, textEnd)
-                            .mark(type.create(attrs).addToSet(child.marks)));
-                        pos = matchEnd;
-                    }
-                }
-                // adding rest of text to nodes
-                if (pos < text.length) {
-                    nodes.push(child.cut(pos));
+/**
+ * Build an paste rule that replaces text when the
+ * matched text is pasted into it.
+ */
+function textPasteRule(config) {
+    return new PasteRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            let insert = config.replace;
+            let start = range.from;
+            const end = range.to;
+            if (match[1]) {
+                const offset = match[0].lastIndexOf(match[1]);
+                insert += match[0].slice(offset + match[1].length);
+                start += offset;
+                const cutOff = start - end;
+                if (cutOff > 0) {
+                    insert = match[0].slice(offset - cutOff, offset) + insert;
+                    start = end;
                 }
             }
-            else {
-                nodes.push(child.copy(handler(child.content, child)));
-            }
-        });
-        return Fragment.fromArray(nodes);
-    };
-    return new Plugin({
-        key: new PluginKey('markPasteRule'),
-        props: {
-            transformPasted: slice => {
-                return new Slice(handler(slice.content), slice.openStart, slice.openEnd);
-            },
+            state.tr.insertText(insert, start, end);
         },
     });
 }
 
-function generateHTML(doc, extensions) {
-    const schema = getSchema(extensions);
-    const contentNode = Node$1.fromJSON(schema, doc);
-    return getHTMLFromFragment(contentNode, schema);
+class Tracker {
+    constructor(transaction) {
+        this.transaction = transaction;
+        this.currentStep = this.transaction.steps.length;
+    }
+    map(position) {
+        let deleted = false;
+        const mappedPosition = this.transaction.steps
+            .slice(this.currentStep)
+            .reduce((newPosition, step) => {
+            const mapResult = step
+                .getMap()
+                .mapResult(newPosition);
+            if (mapResult.deleted) {
+                deleted = true;
+            }
+            return mapResult.pos;
+        }, position);
+        return {
+            position: mappedPosition,
+            deleted,
+        };
+    }
 }
 
-function isNodeSelection(value) {
-    return isObject(value) && value instanceof NodeSelection;
+// source: https://stackoverflow.com/a/6969486
+function escapeForRegEx(string) {
+    return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
 }
 
-export { Editor, Extension, Mark, Node, NodeView, callOrReturn, extensions, findParentNodeClosestToPos, generateHTML, getHTMLFromFragment, getMarkAttributes, getSchema, isActive, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isTextSelection, markInputRule, markPasteRule, mergeAttributes, nodeInputRule };
+export { CommandManager, Editor, Extension, InputRule, Mark, Node, NodeView, PasteRule, Tracker, callOrReturn, combineTransactionSteps, defaultBlockAt, escapeForRegEx, extensions, findChildren, findChildrenInRange, findParentNode, findParentNodeClosestToPos, generateHTML, generateJSON, generateText, getAttributes, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAttributes, getNodeType, getSchema, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, inputRulesPlugin, isActive, isList, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isTextSelection, markInputRule, markPasteRule, mergeAttributes, nodeInputRule, pasteRulesPlugin, posToDOMRect, textInputRule, textPasteRule, textblockTypeInputRule, wrappingInputRule };
 //# sourceMappingURL=tiptap-core.esm.js.map