@tiptap/core 2.0.0-beta.98 → 2.0.0-rc.1

package/dist/{tiptap-core.esm.js → index.js}

@@ -1,318 +1,64 @@
-import { Plugin, PluginKey, TextSelection, Selection, NodeSelection, EditorState } from 'prosemirror-state';
-import { EditorView } from 'prosemirror-view';
-import { Fragment, DOMParser, DOMSerializer, Schema, 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 getSchemaTypeNameByName(name, schema) {
-    if (schema.nodes[name]) {
-        return 'node';
-    }
-    if (schema.marks[name]) {
-        return 'mark';
-    }
-    return null;
-}
-
-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 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') {
-        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;
-}
-
-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 {};
-}
-
-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 {};
-}
-
-/**
- * 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;
-    }
-    // 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))
-        .reduce((sum, markRange) => {
-        const size = markRange.to - markRange.from;
-        return sum + size;
-    }, 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) => {
-        const size = markRange.to - markRange.from;
-        return sum + size;
-    }, 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;
-}
-
-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) {
-    // 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,
+import { Plugin, PluginKey, TextSelection, Selection, NodeSelection, EditorState } from '@tiptap/pm/state';
+import { EditorView } from '@tiptap/pm/view';
+import { keymap } from '@tiptap/pm/keymap';
+import { Schema, Fragment, DOMParser, DOMSerializer, Node as Node$1, Slice } from '@tiptap/pm/model';
+import { liftTarget, ReplaceStep, ReplaceAroundStep, Transform, canSplit, canJoin, findWrapping } from '@tiptap/pm/transform';
+import { createParagraphNear as createParagraphNear$1, deleteSelection as deleteSelection$1, exitCode as exitCode$1, joinUp as joinUp$1, joinDown as joinDown$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 '@tiptap/pm/commands';
+import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, wrapInList as wrapInList$1 } from '@tiptap/pm/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 (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);
-}
-
-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 tipTapStyleTag = document.querySelector('style[data-tiptap-style]');
-    if (tipTapStyleTag !== null) {
-        return tipTapStyleTag;
-    }
-    const styleNode = document.createElement('style');
-    styleNode.setAttribute('data-tiptap-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;
     }
-    createCommands() {
-        const { commands, editor } = this;
-        const { state, view } = editor;
+    get hasCustomState() {
+        return !!this.customState;
+    }
+    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)
-            .map(([name, command]) => {
+        return Object.fromEntries(Object.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;
@@ -320,20 +66,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);
         };
         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);
@@ -347,15 +102,12 @@ class CommandManager {
         return chain;
     }
     createCan(startTr) {
-        const { commands, editor } = this;
-        const { state } = editor;
-        const dispatch = undefined;
+        const { rawCommands, state } = this;
+        const dispatch = false;
         const tr = startTr || state.tr;
         const props = this.buildProps(tr, dispatch);
-        const formattedCommands = Object.fromEntries(Object
-            .entries(commands)
-            .map(([name, command]) => {
-            return [name, (...args) => command(...args)({ ...props, dispatch })];
+        const formattedCommands = Object.fromEntries(Object.entries(rawCommands).map(([name, command]) => {
+            return [name, (...args) => command(...args)({ ...props, dispatch: undefined })];
         }));
         return {
             ...formattedCommands,
@@ -363,8 +115,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);
         }
@@ -372,68 +124,73 @@ class CommandManager {
             tr,
             editor,
             view,
-            state: this.chainableState(tr, state),
-            dispatch: shouldDispatch
-                ? () => undefined
-                : undefined,
+            state: createChainableState({
+                state,
+                transaction: tr,
+            }),
+            dispatch: shouldDispatch ? () => undefined : undefined,
             chain: () => this.createChain(tr),
             can: () => this.createCan(tr),
             get commands() {
-                return Object.fromEntries(Object
-                    .entries(commands)
-                    .map(([name, command]) => {
+                return Object.fromEntries(Object.entries(rawCommands).map(([name, command]) => {
                     return [name, (...args) => command(...args)(props)];
                 }));
             },
         };
         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;
-            },
-        };
-    }
 }
 
-function getExtensionField(extension, field, context = {}) {
-    if (extension.config[field] === undefined && extension.parent) {
-        return getExtensionField(extension.parent, field, context);
+class EventEmitter {
+    constructor() {
+        this.callbacks = {};
     }
-    if (typeof extension.config[field] === 'function') {
-        const value = extension.config[field].bind({
-            ...context,
-            parent: extension.parent
-                ? getExtensionField(extension.parent, field, context)
-                : null,
-        });
-        return value;
+    on(event, fn) {
+        if (!this.callbacks[event]) {
+            this.callbacks[event] = [];
+        }
+        this.callbacks[event].push(fn);
+        return this;
     }
-    return extension.config[field];
-}
+    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) {
     const baseExtensions = extensions.filter(extension => extension.type === 'extension');
@@ -460,11 +217,13 @@ 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,
         };
         const addGlobalAttributes = getExtensionField(extension, 'addGlobalAttributes', context);
         if (!addGlobalAttributes) {
@@ -493,6 +252,7 @@ function getAttributesFromExtensions(extensions) {
         const context = {
             name: extension.name,
             options: extension.options,
+            storage: extension.storage,
         };
         const addAttributes = getExtensionField(extension, 'addAttributes', context);
         if (!addAttributes) {
@@ -503,19 +263,36 @@ function getAttributesFromExtensions(extensions) {
         Object
             .entries(attributes)
             .forEach(([name, attribute]) => {
+            const mergedAttr = {
+                ...defaultAttribute,
+                ...attribute,
+            };
+            if (typeof (mergedAttr === null || mergedAttr === void 0 ? void 0 : mergedAttr.default) === 'function') {
+                mergedAttr.default = mergedAttr.default();
+            }
+            if ((mergedAttr === null || mergedAttr === void 0 ? void 0 : mergedAttr.isRequired) && (mergedAttr === null || mergedAttr === void 0 ? void 0 : mergedAttr.default) === undefined) {
+                delete mergedAttr.default;
+            }
             extensionAttributes.push({
                 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)
@@ -552,20 +329,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') {
@@ -590,25 +386,20 @@ function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
     return {
         ...parseRule,
         getAttrs: node => {
-            const oldAttributes = parseRule.getAttrs
-                ? parseRule.getAttrs(node)
-                : parseRule.attrs;
+            const oldAttributes = parseRule.getAttrs ? parseRule.getAttrs(node) : parseRule.attrs;
             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 };
@@ -616,23 +407,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)) {
@@ -651,6 +425,7 @@ function getSchemaByResolvedExtensions(extensions) {
         const context = {
             name: extension.name,
             options: extension.options,
+            storage: extension.storage,
         };
         const extraNodeFields = extensions.reduce((fields, e) => {
             const extendNodeSchema = getExtensionField(e, 'extendNodeSchema', context);
@@ -678,8 +453,7 @@ function getSchemaByResolvedExtensions(extensions) {
         });
         const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
         if (parseHTML) {
-            schema.parseDOM = parseHTML
-                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+            schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
         }
         const renderHTML = getExtensionField(extension, 'renderHTML', context);
         if (renderHTML) {
@@ -688,6 +462,10 @@ function getSchemaByResolvedExtensions(extensions) {
                 HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
             });
         }
+        const renderText = getExtensionField(extension, 'renderText', context);
+        if (renderText) {
+            schema.toText = renderText;
+        }
         return [extension.name, schema];
     }));
     const marks = Object.fromEntries(markExtensions.map(extension => {
@@ -695,6 +473,7 @@ function getSchemaByResolvedExtensions(extensions) {
         const context = {
             name: extension.name,
             options: extension.options,
+            storage: extension.storage,
         };
         const extraMarkFields = extensions.reduce((fields, e) => {
             const extendMarkSchema = getExtensionField(e, 'extendMarkSchema', context);
@@ -709,6 +488,7 @@ function getSchemaByResolvedExtensions(extensions) {
             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 }];
@@ -716,8 +496,7 @@ function getSchemaByResolvedExtensions(extensions) {
         });
         const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
         if (parseHTML) {
-            schema.parseDOM = parseHTML
-                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+            schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
         }
         const renderHTML = getExtensionField(extension, 'renderHTML', context);
         if (renderHTML) {
@@ -736,13 +515,360 @@ function getSchemaByResolvedExtensions(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 = '';
+    const sliceEndPos = $from.parentOffset;
+    $from.parent.nodesBetween(Math.max(0, sliceEndPos - maxMatch), sliceEndPos, (node, pos, parent, index) => {
+        var _a, _b;
+        const chunk = ((_b = (_a = node.type.spec).toText) === null || _b === void 0 ? void 0 : _b.call(_a, {
+            node,
+            pos,
+            parent,
+            index,
+        }))
+            || node.textContent
+            || '%leaf%';
+        textBefore += chunk.slice(0, Math.max(0, sliceEndPos - pos));
+    });
+    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 = [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 = [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 - 1,
+                    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 {
@@ -753,9 +879,12 @@ class ExtensionManager {
         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.name, this.schema),
             };
@@ -800,26 +929,31 @@ class ExtensionManager {
         });
     }
     static resolve(extensions) {
-        return ExtensionManager.sort(ExtensionManager.flatten(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
+        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, ...this.flatten(addExtensions())];
             }
             return extension;
         })
             // `Infinity` will break TypeScript so we set a number that is probably high enough
-            .flat(10);
+            .flat(10));
     }
     static sort(extensions) {
         const defaultPriority = 100;
@@ -840,6 +974,7 @@ class ExtensionManager {
             const context = {
                 name: extension.name,
                 options: extension.options,
+                storage: extension.storage,
                 editor: this.editor,
                 type: getSchemaTypeByName(extension.name, this.schema),
             };
@@ -854,38 +989,46 @@ class ExtensionManager {
         }, {});
     }
     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,
+                storage: extension.storage,
+                editor,
                 type: getSchemaTypeByName(extension.name, this.schema),
             };
             const plugins = [];
             const addKeyboardShortcuts = getExtensionField(extension, 'addKeyboardShortcuts', context);
+            let defaultBindings = {};
+            // bind exit handling
+            if (extension.type === 'mark' && extension.config.exitable) {
+                defaultBindings.ArrowRight = () => Mark.handleExit({ editor, mark: extension });
+            }
             if (addKeyboardShortcuts) {
-                const bindings = Object.fromEntries(Object
-                    .entries(addKeyboardShortcuts())
-                    .map(([shortcut, method]) => {
-                    return [shortcut, () => method({ editor: this.editor })];
+                const bindings = Object.fromEntries(Object.entries(addKeyboardShortcuts()).map(([shortcut, method]) => {
+                    return [shortcut, () => method({ editor })];
                 }));
-                const keyMapPlugin = keymap(bindings);
-                plugins.push(keyMapPlugin);
+                defaultBindings = { ...defaultBindings, ...bindings };
             }
+            const keyMapPlugin = keymap(defaultBindings);
+            plugins.push(keyMapPlugin);
             const addInputRules = getExtensionField(extension, 'addInputRules', context);
-            if (this.editor.options.enableInputRules && addInputRules) {
-                const inputRules$1 = addInputRules();
-                const inputRulePlugins = inputRules$1.length
-                    ? [inputRules({ rules: inputRules$1 })]
-                    : [];
-                plugins.push(...inputRulePlugins);
+            if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
+                inputRules.push(...addInputRules());
             }
             const addPasteRules = getExtensionField(extension, 'addPasteRules', context);
-            if (this.editor.options.enablePasteRules && addPasteRules) {
-                const pasteRulePlugins = addPasteRules();
-                plugins.push(...pasteRulePlugins);
+            if (isExtensionRulesEnabled(extension, editor.options.enablePasteRules) && addPasteRules) {
+                pasteRules.push(...addPasteRules());
             }
             const addProseMirrorPlugins = getExtensionField(extension, 'addProseMirrorPlugins', context);
             if (addProseMirrorPlugins) {
@@ -895,6 +1038,17 @@ class ExtensionManager {
             return plugins;
         })
             .flat();
+        return [
+            inputRulesPlugin({
+                editor,
+                rules: inputRules,
+            }),
+            ...pasteRulesPlugin({
+                editor,
+                rules: pasteRules,
+            }),
+            ...allPlugins,
+        ];
     }
     get attributes() {
         return getAttributesFromExtensions(this.extensions);
@@ -909,6 +1063,7 @@ class ExtensionManager {
             const context = {
                 name: extension.name,
                 options: extension.options,
+                storage: extension.storage,
                 editor,
                 type: getNodeType(extension.name, this.schema),
             };
@@ -930,89 +1085,35 @@ class ExtensionManager {
             return [extension.name, nodeview];
         }));
     }
-    get textSerializers() {
-        const { editor } = this;
-        const { nodeExtensions } = splitExtensions(this.extensions);
-        return Object.fromEntries(nodeExtensions
-            .filter(extension => !!getExtensionField(extension, 'renderText'))
-            .map(extension => {
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                editor,
-                type: getNodeType(extension.name, this.schema),
-            };
-            const renderText = getExtensionField(extension, 'renderText', context);
-            if (!renderText) {
-                return [];
-            }
-            const textSerializer = (props) => renderText(props);
-            return [extension.name, textSerializer];
-        }));
+}
+
+// see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
+function getType(value) {
+    return Object.prototype.toString.call(value).slice(8, -1);
+}
+function isPlainObject(value) {
+    if (getType(value) !== 'Object') {
+        return false;
     }
+    return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
 }
 
-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 = {};
-    }
-}
-
-// 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 isPlainObject(payload) {
-    if (getType(payload) !== 'Object')
-        return false;
-    return payload.constructor === Object && Object.getPrototypeOf(payload) === Object.prototype;
-}
-
-function mergeDeep(target, source) {
-    const output = { ...target };
-    if (isPlainObject(target) && isPlainObject(source)) {
-        Object.keys(source).forEach(key => {
-            if (isPlainObject(source[key])) {
-                if (!(key in target)) {
-                    Object.assign(output, { [key]: source[key] });
-                }
-                else {
-                    output[key] = mergeDeep(target[key], source[key]);
-                }
-            }
-            else {
-                Object.assign(output, { [key]: source[key] });
-            }
-        });
+function mergeDeep(target, source) {
+    const output = { ...target };
+    if (isPlainObject(target) && isPlainObject(source)) {
+        Object.keys(source).forEach(key => {
+            if (isPlainObject(source[key])) {
+                if (!(key in target)) {
+                    Object.assign(output, { [key]: source[key] });
+                }
+                else {
+                    output[key] = mergeDeep(target[key], source[key]);
+                }
+            }
+            else {
+                Object.assign(output, { [key]: source[key] });
+            }
+        });
     }
     return output;
 }
@@ -1032,7 +1133,20 @@ class Extension {
             ...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 = {}) {
         return new Extension(config);
@@ -1042,49 +1156,74 @@ class 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;
-        extension.options = extendedConfig.defaultOptions
-            ? extendedConfig.defaultOptions
-            : extension.parent.options;
+        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;
     }
 }
 
-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({
@@ -1092,8 +1231,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,
+                        });
                     },
                 },
             }),
@@ -1103,47 +1250,45 @@ const ClipboardTextSerializer = Extension.create({
 
 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 (!dispatch) {
+        return true;
+    }
+    ranges.forEach(({ $from, $to }) => {
+        state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
             if (node.type.isText) {
                 return;
             }
-            const $fromPos = tr.doc.resolve(tr.mapping.map(pos));
-            const $toPos = tr.doc.resolve(tr.mapping.map(pos + node.nodeSize));
-            const nodeRange = $fromPos.blockRange($toPos);
+            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 && dispatch) {
-                const { defaultType } = $fromPos.parent.contentMatchAt($fromPos.index());
+            if (node.type.isTextblock) {
+                const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
                 tr.setNodeMarkup(nodeRange.start, defaultType);
             }
-            if ((targetLiftDepth || targetLiftDepth === 0) && dispatch) {
+            if (targetLiftDepth || targetLiftDepth === 0) {
                 tr.lift(nodeRange, targetLiftDepth);
             }
         });
@@ -1151,28 +1296,35 @@ const clearNodes = () => ({ state, tr, dispatch }) => {
     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 deleteCurrentNode = () => ({ tr, dispatch }) => {
+    const { selection } = tr;
+    const currentNode = selection.$anchor.node();
+    // if there is content inside the current node, break out of this command
+    if (currentNode.content.size > 0) {
+        return false;
+    }
+    const $pos = tr.selection.$anchor;
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+        const node = $pos.node(depth);
+        if (node.type === currentNode.type) {
+            if (dispatch) {
+                const from = $pos.before(depth);
+                const to = $pos.after(depth);
+                tr.delete(from, to).scrollIntoView();
+            }
+            return true;
+        }
+    }
+    return false;
+};
 
 const deleteNode = typeOrName => ({ tr, state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
@@ -1191,11 +1343,6 @@ const deleteNode = typeOrName => ({ tr, state, dispatch }) => {
     return false;
 };
 
-var deleteNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  deleteNode: deleteNode
-});
-
 const deleteRange = range => ({ tr, dispatch }) => {
     const { from, to } = range;
     if (dispatch) {
@@ -1204,37 +1351,38 @@ 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 findMarkInSet(marks, type, attributes = {}) {
     return marks.find(item => {
@@ -1248,25 +1396,28 @@ 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 mark = findMarkInSet(start.node.marks, type, attributes);
+    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;
-    findMarkInSet(start.node.marks, type, attributes);
+    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
-        && isMarkInSet($pos.parent.child(endIndex).marks, type, attributes)) {
+        && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
         endPos += $pos.parent.child(endIndex).nodeSize;
         endIndex += 1;
     }
@@ -1276,6 +1427,16 @@ function getMarkRange($pos, type, attributes = {}) {
     };
 }
 
+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;
@@ -1290,11 +1451,6 @@ const extendMarkRange = (typeOrName, attributes = {}) => ({ 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)
@@ -1307,63 +1463,66 @@ const first = commands => props => {
     return false;
 };
 
-var first$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  first: first
-});
+function isTextSelection(value) {
+    return value instanceof TextSelection;
+}
 
 function minMax(value = 0, min = 0, max = 0) {
     return Math.min(Math.max(value, min), max);
 }
 
-function isClass(item) {
-    var _a;
-    if (((_a = item.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 isTextSelection(value) {
-    return isObject(value) && value instanceof TextSelection;
-}
-
-function resolveSelection(state, position = null) {
+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 focus = (position = null) => ({ editor, view, tr, dispatch, }) => {
     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();
+                }
             }
         });
     };
@@ -1375,13 +1534,9 @@ const focus = (position = null) => ({ editor, view, tr, dispatch, }) => {
         delayedFocus();
         return true;
     }
-    const { from, to } = resolveSelection(editor.state, position) || editor.state.selection;
-    const { doc, storedMarks } = tr;
-    const minPos = Selection.atStart(doc).from;
-    const maxPos = Selection.atEnd(doc).to;
-    const resolvedFrom = minMax(from, minPos, maxPos);
-    const resolvedEnd = minMax(to, minPos, maxPos);
-    const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
+    // pass through tr.doc instead of editor.state.doc
+    // since transactions could change the editors state before this command has been run
+    const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
     const isSameSelection = editor.state.selection.eq(selection);
     if (dispatch) {
         if (!isSameSelection) {
@@ -1389,36 +1544,54 @@ const focus = (position = null) => ({ editor, view, tr, dispatch, }) => {
         }
         // `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);
         }
         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 }));
 };
 
-var forEach$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  forEach: forEach
-});
-
 const insertContent = (value, options) => ({ tr, commands }) => {
     return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
 };
 
-var insertContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertContent: insertContent
-});
+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) && content.length > 0) {
+                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) {
@@ -1440,52 +1613,94 @@ function selectionToInsertionEnd(tr, startLen, bias) {
     tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
 }
 
+const isFragment = (nodeOrFragment) => {
+    return nodeOrFragment.toString().startsWith('<');
+};
 const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
     if (dispatch) {
+        options = {
+            parseOptions: {},
+            updateSelection: true,
+            ...options,
+        };
         const content = createNodeFromContent(value, editor.schema, {
             parseOptions: {
                 preserveWhitespace: 'full',
+                ...options.parseOptions,
             },
-            ...(options || {}),
         });
         // don’t dispatch an empty fragment because this can lead to strange errors
         if (content.toString() === '<>') {
             return true;
         }
-        const { from, to } = typeof position === 'number'
-            ? { from: position, to: position }
-            : position;
-        tr.replaceWith(from, to, content);
+        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) {
+            // if value is string, we can use it directly
+            // otherwise if it is an array, we have to join it
+            if (Array.isArray(value)) {
+                tr.insertText(value.map(v => v.text || '').join(''), from, to);
+            }
+            else if (typeof value === 'object' && !!value && !!value.text) {
+                tr.insertText(value.text, from, to);
+            }
+            else {
+                tr.insertText(value, from, to);
+            }
+        }
+        else {
+            tr.replaceWith(from, to, content);
+        }
         // set cursor at end of inserted content
-        selectionToInsertionEnd(tr, tr.steps.length - 1, 1);
+        if (options.updateSelection) {
+            selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
+        }
     }
     return true;
 };
 
-var insertContentAt$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertContentAt: insertContentAt
-});
-
+const joinUp = () => ({ state, dispatch }) => {
+    return joinUp$1(state, dispatch);
+};
+const joinDown = () => ({ state, dispatch }) => {
+    return joinDown$1(state, dispatch);
+};
 const joinBackward = () => ({ state, dispatch }) => {
-    return joinBackward$2(state, dispatch);
+    return joinBackward$1(state, dispatch);
+};
+const joinForward = () => ({ state, dispatch }) => {
+    return joinForward$1(state, dispatch);
 };
 
-var joinBackward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  joinBackward: joinBackward
-});
+function isMacOS() {
+    return typeof navigator !== 'undefined'
+        ? /Mac/.test(navigator.platform)
+        : false;
+}
 
-const joinForward = () => ({ state, dispatch }) => {
-    return joinForward$2(state, dispatch);
-};
-
-var joinForward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  joinForward: joinForward
-});
-
-const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
 function normalizeKeyName(name) {
     const parts = name.split(/-(?!$)/);
     let result = parts[parts.length - 1];
@@ -1511,7 +1726,7 @@ function normalizeKeyName(name) {
             shift = true;
         }
         else if (/^mod$/i.test(mod)) {
-            if (mac) {
+            if (isiOS() || isMacOS()) {
                 meta = true;
             }
             else {
@@ -1562,10 +1777,37 @@ 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);
@@ -1573,165 +1815,634 @@ 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
-});
+function getSchemaTypeNameByName(name, schema) {
+    if (schema.nodes[name]) {
+        return 'node';
+    }
+    if (schema.marks[name]) {
+        return 'mark';
+    }
+    return null;
+}
+
+/**
+ * Remove a property or an array of properties from an object
+ * @param obj Object
+ * @param key Key to remove
+ */
+function deleteProps(obj, propOrProps) {
+    const props = typeof propOrProps === 'string'
+        ? [propOrProps]
+        : propOrProps;
+    return Object
+        .keys(obj)
+        .reduce((newObj, prop) => {
+        if (!props.includes(prop)) {
+            newObj[prop] = obj[prop];
+        }
+        return newObj;
+    }, {});
+}
+
+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;
+};
+
+const scrollIntoView = () => ({ tr, dispatch }) => {
+    if (dispatch) {
+        tr.scrollIntoView();
+    }
+    return true;
+};
+
+const selectAll = () => ({ tr, commands }) => {
+    return commands.setTextSelection({
+        from: 0,
+        to: tr.doc.content.size,
+    });
+};
+
+const selectNodeBackward = () => ({ state, dispatch }) => {
+    return selectNodeBackward$1(state, dispatch);
+};
+
+const selectNodeForward = () => ({ state, dispatch }) => {
+    return selectNodeForward$1(state, dispatch);
+};
+
+const selectParentNode = () => ({ state, dispatch }) => {
+    return selectParentNode$1(state, dispatch);
+};
+
+// @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;
+    const document = createDocument(content, editor.schema, parseOptions);
+    if (dispatch) {
+        tr.replaceWith(0, doc.content.size, document).setMeta('preventUpdate', !emitUpdate);
+    }
+    return true;
+};
+
+/**
+ * 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);
+        });
+    });
+    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 findParentNodeClosestToPos($pos, predicate) {
+    for (let i = $pos.depth; i > 0; i -= 1) {
+        const node = $pos.node(i);
+        if (predicate(node)) {
+            return {
+                pos: i > 0 ? $pos.before(i) : 0,
+                start: $pos.start(i),
+                depth: i,
+                node,
+            };
+        }
+    }
+}
+
+function findParentNode(predicate) {
+    return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
+}
+
+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 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 getText(node, options) {
+    const range = {
+        from: 0,
+        to: node.content.size,
+    };
+    return getTextBetween(node, range, options);
+}
+
+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: {
+            ...getTextSerializersFromSchema(schema),
+            ...textSerializers,
+        },
+    });
+}
+
+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 };
+}
+
+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 {};
+}
+
+/**
+ * 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);
+    });
+}
 
 /**
- * Remove a property or an array of properties from an object
- * @param obj Object
- * @param key Key to remove
+ * Removes duplicated ranges and ranges that are
+ * fully captured by other ranges.
  */
-function deleteProps(obj, propOrProps) {
-    const props = typeof propOrProps === 'string'
-        ? [propOrProps]
-        : propOrProps;
-    return Object
-        .keys(obj)
-        .reduce((newObj, prop) => {
-        if (!props.includes(prop)) {
-            newObj[prop] = obj[prop];
+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 });
         }
-        return newObj;
-    }, {});
+        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);
 }
 
-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;
+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,
+        };
+        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;
     }
-    if (schemaType === 'node') {
-        nodeType = getNodeType(typeOrName, state.schema);
+    if (marks.length) {
+        output.marks = marks;
     }
-    if (schemaType === 'mark') {
-        markType = getMarkType(typeOrName, state.schema);
+    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));
+        });
     }
-    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)));
-                        }
-                    });
-                }
+    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,
             });
         });
     }
-    return true;
-};
-
-var resetAttributes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  resetAttributes: resetAttributes
-});
-
-const scrollIntoView = () => ({ tr, dispatch }) => {
-    if (dispatch) {
-        tr.scrollIntoView();
+    else {
+        doc.nodesBetween(from, to, (node, pos) => {
+            marks.push(...node.marks.map(mark => ({
+                from: pos,
+                to: pos + node.nodeSize,
+                mark,
+            })));
+        });
     }
-    return true;
-};
-
-var scrollIntoView$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scrollIntoView: scrollIntoView
-});
-
-const selectAll = () => ({ state, dispatch }) => {
-    return selectAll$2(state, dispatch);
-};
+    return marks;
+}
 
-var selectAll$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectAll: selectAll
-});
+function getSplittedAttributes(extensionAttributes, typeName, attributes) {
+    return Object.fromEntries(Object
+        .entries(attributes)
+        .filter(([name]) => {
+        const extensionAttribute = extensionAttributes.find(item => {
+            return item.type === typeName && item.name === name;
+        });
+        if (!extensionAttribute) {
+            return false;
+        }
+        return extensionAttribute.attribute.keepOnSplit;
+    }));
+}
 
-const selectNodeBackward = () => ({ state, dispatch }) => {
-    return selectNodeBackward$2(state, dispatch);
-};
+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;
+}
 
-var selectNodeBackward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectNodeBackward: selectNodeBackward
-});
+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;
+}
 
-const selectNodeForward = () => ({ state, dispatch }) => {
-    return selectNodeForward$2(state, dispatch);
-};
+function isList(name, extensions) {
+    const { nodeExtensions } = splitExtensions(extensions);
+    const extension = nodeExtensions.find(item => item.name === name);
+    if (!extension) {
+        return false;
+    }
+    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 group.split(' ').includes('list');
+}
 
-var selectNodeForward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectNodeForward: selectNodeForward
-});
+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 selectParentNode = () => ({ state, dispatch }) => {
-    return selectParentNode$2(state, dispatch);
-};
+function isNodeSelection(value) {
+    return value instanceof NodeSelection;
+}
 
-var selectParentNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectParentNode: selectParentNode
-});
+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,
+    };
+}
 
-const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
-    const { doc } = tr;
-    const document = createDocument(content, editor.schema, parseOptions);
-    const selection = TextSelection.create(doc, 0, doc.content.size);
-    if (dispatch) {
-        tr.setSelection(selection)
-            .replaceSelectionWith(document, false)
-            .setMeta('preventUpdate', !emitUpdate);
+function canSetMark(state, tr, newMarkType) {
+    var _a;
+    const { selection } = tr;
+    let cursor = null;
+    if (isTextSelection(selection)) {
+        cursor = selection.$cursor;
     }
-    return true;
-};
-
-var setContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setContent: setContent
-});
-
+    if (cursor) {
+        const currentMarks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : cursor.marks();
+        // There can be no current marks that exclude the new mark
+        return (!!newMarkType.isInSet(currentMarks)
+            || !currentMarks.some(mark => mark.type.excludes(newMarkType)));
+    }
+    const { ranges } = selection;
+    return ranges.some(({ $from, $to }) => {
+        let someNodeSupportsMark = $from.depth === 0
+            ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType)
+            : false;
+        state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
+            // If we already found a mark that we can enable, return false to bypass the remaining search
+            if (someNodeSupportsMark) {
+                return false;
+            }
+            if (node.isInline) {
+                const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
+                const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks)
+                    || !node.marks.some(otherMark => otherMark.type.excludes(newMarkType));
+                someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
+            }
+            return !someNodeSupportsMark;
+        });
+        return someNodeSupportsMark;
+    });
+}
 const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
     const { selection } = tr;
     const { empty, ranges } = selection;
@@ -1772,59 +2483,52 @@ const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
             });
         }
     }
-    return true;
+    return canSetMark(state, tr, type);
 };
 
-var setMark$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setMark: setMark
-});
-
 const setMeta = (key, value) => ({ tr }) => {
     tr.setMeta(key, value);
     return true;
 };
 
-var setMeta$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setMeta: setMeta
-});
-
-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);
+        const from = minMax(position, 0, doc.content.size);
+        const selection = NodeSelection.create(doc, from);
         tr.setSelection(selection);
     }
     return true;
 };
 
-var setNodeSelection$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setNodeSelection: setNodeSelection
-});
-
 const setTextSelection = position => ({ tr, dispatch }) => {
     if (dispatch) {
         const { doc } = tr;
-        const { from, to } = typeof position === 'number'
-            ? { from: position, to: position }
-            : position;
-        const minPos = Selection.atStart(doc).from;
-        const maxPos = Selection.atEnd(doc).to;
+        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);
@@ -1833,47 +2537,13 @@ const setTextSelection = position => ({ tr, dispatch }) => {
     return true;
 };
 
-var setTextSelection$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setTextSelection: setTextSelection
-});
-
 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)
-        .filter(([name]) => {
-        const extensionAttribute = extensionAttributes.find(item => {
-            return item.type === typeName && item.name === name;
-        });
-        if (!extensionAttribute) {
-            return false;
-        }
-        return extensionAttribute.attribute.keepOnSplit;
-    }));
-}
-
-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 ensureMarks(state, splittableMarks) {
-    const marks = state.storedMarks
-        || (state.selection.$to.parentOffset && state.selection.$from.marks());
+    const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
     if (marks) {
         const filteredMarks = marks.filter(mark => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
         state.tr.ensureMarks(filteredMarks);
@@ -1908,10 +2578,12 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
             ? undefined
             : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
         let types = atEnd && deflt
-            ? [{
+            ? [
+                {
                     type: deflt,
                     attrs: newAttributes,
-                }]
+                },
+            ]
             : undefined;
         let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
         if (!types
@@ -1919,18 +2591,17 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
             && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
             can = true;
             types = deflt
-                ? [{
+                ? [
+                    {
                         type: deflt,
                         attrs: newAttributes,
-                    }]
+                    },
+                ]
                 : undefined;
         }
         if (can) {
             tr.split(tr.mapping.map($from.pos), 1, types);
-            if (deflt
-                && !atEnd
-                && !$from.parentOffset
-                && $from.parent.type !== deflt) {
+            if (deflt && !atEnd && !$from.parentOffset && $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)) {
@@ -1946,11 +2617,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);
@@ -1978,22 +2644,14 @@ const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
         if (dispatch) {
             let wrap = Fragment.empty;
             // eslint-disable-next-line
-            const depthBefore = $from.index(-1)
-                ? 1
-                : $from.index(-2)
-                    ? 2
-                    : 3;
+            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 - 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;
+            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;
@@ -2016,71 +2674,75 @@ const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
         }
         return true;
     }
-    const nextType = $to.pos === $from.end()
-        ? grandParent.contentMatchAt(0).defaultType
-        : null;
+    const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
     const newTypeAttributes = getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs);
     const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
     tr.delete($from.pos, $to.pos);
     const types = nextType
-        ? [{ type, attrs: newTypeAttributes }, { type: nextType, attrs: newNextTypeAttributes }]
+        ? [
+            { type, attrs: newTypeAttributes },
+            { type: nextType, attrs: newNextTypeAttributes },
+        ]
         : [{ type, attrs: newTypeAttributes }];
     if (!canSplit(tr.doc, $from.pos, 2)) {
         return false;
     }
     if (dispatch) {
+        const { selection, storedMarks } = state;
+        const { splittableMarks } = editor.extensionManager;
+        const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks());
         tr.split($from.pos, 2, types).scrollIntoView();
+        if (!marks || !dispatch) {
+            return true;
+        }
+        const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name));
+        tr.ensureMarks(filteredMarks);
     }
     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);
-        if (predicate(node)) {
-            return {
-                pos: i > 0 ? $pos.before(i) : 0,
-                start: $pos.start(i),
-                depth: i,
-                node,
-            };
-        }
+const joinListBackwards = (tr, listType) => {
+    const list = findParentNode(node => node.type === listType)(tr.selection);
+    if (!list) {
+        return true;
     }
-}
-
-function findParentNode(predicate) {
-    return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-}
-
-function isList(name, extensions) {
-    const { nodeExtensions } = splitExtensions(extensions);
-    const extension = nodeExtensions.find(item => item.name === name);
-    if (!extension) {
-        return false;
+    const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
+    if (before === undefined) {
+        return true;
     }
-    const context = {
-        name: extension.name,
-        options: extension.options,
-    };
-    const group = callOrReturn(getExtensionField(extension, 'group', context));
-    if (typeof group !== 'string') {
-        return false;
+    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;
     }
-    return group.split(' ').includes('list');
-}
-
-const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dispatch, chain, commands, can, }) => {
-    const { extensions } = editor.extensionManager;
+    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, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands, can, }) => {
+    const { extensions, splittableMarks } = editor.extensionManager;
     const listType = getNodeType(listTypeOrName, state.schema);
     const itemType = getNodeType(itemTypeOrName, state.schema);
-    const { selection } = state;
+    const { selection, storedMarks } = state;
     const { $from, $to } = selection;
     const range = $from.blockRange($to);
+    const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks());
     if (!range) {
         return false;
     }
@@ -2094,40 +2756,58 @@ 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) {
+    if (!keepMarks || !marks || !dispatch) {
         return chain()
-            .clearNodes()
-            .wrapInList(listType)
+            // try to convert node to default node if needed
+            .command(() => {
+            const canWrapInList = can().wrapInList(listType, attributes);
+            if (canWrapInList) {
+                return true;
+            }
+            return commands.clearNodes();
+        })
+            .wrapInList(listType, attributes)
+            .command(() => joinListBackwards(tr, listType))
+            .command(() => joinListForwards(tr, listType))
             .run();
     }
-    return commands.wrapInList(listType);
+    return (chain()
+        // try to convert node to default node if needed
+        .command(() => {
+        const canWrapInList = can().wrapInList(listType, attributes);
+        const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name));
+        tr.ensureMarks(filteredMarks);
+        if (canWrapInList) {
+            return true;
+        }
+        return commands.clearNodes();
+    })
+        .wrapInList(listType, attributes)
+        .command(() => joinListBackwards(tr, listType))
+        .command(() => joinListForwards(tr, listType))
+        .run());
 };
 
-var toggleList$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleList: toggleList
-});
-
-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);
@@ -2138,92 +2818,89 @@ 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 updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
     let nodeType = null;
     let markType = null;
-    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
-        ? typeOrName
-        : typeOrName.name, state.schema);
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string' ? typeOrName : typeOrName.name, state.schema);
     if (!schemaType) {
         return false;
     }
@@ -2262,32 +2939,70 @@ const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch
     return true;
 };
 
-var updateAttributes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  updateAttributes: updateAttributes
-});
-
 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,
+  deleteCurrentNode: deleteCurrentNode,
+  deleteNode: deleteNode,
+  deleteRange: deleteRange,
+  deleteSelection: deleteSelection,
+  enter: enter,
+  exitCode: exitCode,
+  extendMarkRange: extendMarkRange,
+  first: first,
+  focus: focus,
+  forEach: forEach,
+  insertContent: insertContent,
+  insertContentAt: insertContentAt,
+  joinUp: joinUp,
+  joinDown: joinDown,
+  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
 });
 
@@ -2295,54 +3010,7 @@ const Commands = Extension.create({
     name: 'commands',
     addCommands() {
         return {
-            ...blur$1,
-            ...clearContent$1,
-            ...clearNodes$1,
-            ...command$1,
-            ...createParagraphNear$1,
-            ...deleteNode$1,
-            ...deleteRange$1,
-            ...deleteSelection$1,
-            ...enter$1,
-            ...exitCode$1,
-            ...extendMarkRange$1,
-            ...first$1,
-            ...focus$1,
-            ...forEach$1,
-            ...insertContent$1,
-            ...insertContentAt$1,
-            ...joinBackward$1,
-            ...joinForward$1,
-            ...keyboardShortcut$1,
-            ...lift$1,
-            ...liftEmptyBlock$1,
-            ...liftListItem$1,
-            ...newlineInCode$1,
-            ...resetAttributes$1,
-            ...scrollIntoView$1,
-            ...selectAll$1,
-            ...selectNodeBackward$1,
-            ...selectNodeForward$1,
-            ...selectParentNode$1,
-            ...setContent$1,
-            ...setMark$1,
-            ...setMeta$1,
-            ...setNode$1,
-            ...setNodeSelection$1,
-            ...setTextSelection$1,
-            ...sinkListItem$1,
-            ...splitBlock$1,
-            ...splitListItem$1,
-            ...toggleList$1,
-            ...toggleMark$1,
-            ...toggleNode$1,
-            ...toggleWrap$1,
-            ...undoInputRule$1,
-            ...unsetAllMarks$1,
-            ...unsetMark$1,
-            ...updateAttributes$1,
-            ...wrapIn$1,
-            ...wrapInList$1,
+            ...commands,
         };
     },
 });
@@ -2369,9 +3037,6 @@ const FocusEvents = Extension.create({
             new Plugin({
                 key: new PluginKey('focusEvents'),
                 props: {
-                    attributes: {
-                        tabindex: '0',
-                    },
                     handleDOMEvents: {
                         focus: (view, event) => {
                             editor.isFocused = true;
@@ -2401,30 +3066,119 @@ 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(),
         ]);
         const handleDelete = () => this.editor.commands.first(({ commands }) => [
             () => commands.deleteSelection(),
+            () => commands.deleteCurrentNode(),
             () => 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;
+    },
+    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;
+                    if (empty || !allWasSelected) {
+                        return;
+                    }
+                    const isEmpty = newState.doc.textBetween(0, newState.doc.content.size, ' ', ' ').length === 0;
+                    if (!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' } : {},
+                },
+            }),
+        ];
     },
 });
 
@@ -2434,7 +3188,8 @@ var extensions = /*#__PURE__*/Object.freeze({
   Commands: Commands,
   Editable: Editable,
   FocusEvents: FocusEvents,
-  Keymap: Keymap
+  Keymap: Keymap,
+  Tabindex: Tabindex
 });
 
 const style = `.ProseMirror {
@@ -2444,8 +3199,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"] {
@@ -2460,10 +3217,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 {
@@ -2502,14 +3268,31 @@ const style = `.ProseMirror {
   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,
@@ -2517,6 +3300,7 @@ class Editor extends EventEmitter {
             parseOptions: {},
             enableInputRules: true,
             enablePasteRules: true,
+            enableCoreExtensions: true,
             onBeforeCreate: () => null,
             onCreate: () => null,
             onUpdate: () => null,
@@ -2551,30 +3335,36 @@ class Editor extends EventEmitter {
             this.emit('create', { editor: this });
         }, 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);
         }
     }
     /**
@@ -2598,8 +3388,11 @@ class Editor extends EventEmitter {
     /**
      * Update editable state of the editor.
      */
-    setEditable(editable) {
+    setEditable(editable, emitUpdate = true) {
         this.setOptions({ editable });
+        if (emitUpdate) {
+            this.emit('update', { editor: this, transaction: this.state.tr });
+        }
     }
     /**
      * Returns whether the editor is editable.
@@ -2608,9 +3401,7 @@ class Editor extends EventEmitter {
         // 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;
+        return this.options.editable && this.view && this.view.editable;
     }
     /**
      * Returns the editor state.
@@ -2625,8 +3416,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);
@@ -2634,16 +3425,14 @@ class Editor extends EventEmitter {
     /**
      * Unregister a ProseMirror plugin.
      *
-     * @param name The plugins name
+     * @param nameOrPluginKey The plugins name
      */
     unregisterPlugin(nameOrPluginKey) {
         if (this.isDestroyed) {
             return;
         }
-        const name = typeof nameOrPluginKey === 'string'
-            ? `${nameOrPluginKey}$`
-            // @ts-ignore
-            : nameOrPluginKey.key;
+        // @ts-ignore
+        const name = typeof nameOrPluginKey === 'string' ? `${nameOrPluginKey}$` : nameOrPluginKey.key;
         const state = this.state.reconfigure({
             // @ts-ignore
             plugins: this.state.plugins.filter(plugin => !plugin.key.startsWith(name)),
@@ -2654,7 +3443,7 @@ 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);
         });
@@ -2664,7 +3453,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.
@@ -2676,11 +3467,14 @@ 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.
@@ -2717,6 +3511,11 @@ class Editor extends EventEmitter {
      * @param transaction An editor state transaction
      */
     dispatchTransaction(transaction) {
+        // if the editor / the view of the editor was destroyed
+        // the transaction should not be dispatched as there is no view anymore.
+        if (this.view.isDestroyed) {
+            return;
+        }
         if (this.isCapturingTransaction) {
             if (!this.capturedTransaction) {
                 this.capturedTransaction = transaction;
@@ -2769,12 +3568,8 @@ class Editor extends EventEmitter {
         return getAttributes(this.state, nameOrType);
     }
     isActive(nameOrAttributes, attributesOrUndefined) {
-        const name = typeof nameOrAttributes === 'string'
-            ? nameOrAttributes
-            : null;
-        const attributes = typeof nameOrAttributes === 'string'
-            ? attributesOrUndefined
-            : nameOrAttributes;
+        const name = typeof nameOrAttributes === 'string' ? nameOrAttributes : null;
+        const attributes = typeof nameOrAttributes === 'string' ? attributesOrUndefined : nameOrAttributes;
         return isActive(this.state, name, attributes);
     }
     /**
@@ -2787,7 +3582,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: {
+                ...getTextSerializersFromSchema(this.schema),
+                ...textSerializers,
+            },
+        });
     }
     /**
      * Check if there is no content.
@@ -2797,8 +3605,11 @@ 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;
     }
     /**
@@ -2810,7 +3621,6 @@ class Editor extends EventEmitter {
             this.view.destroy();
         }
         this.removeAllListeners();
-        removeElement(this.css);
     }
     /**
      * Check if the editor is already destroyed.
@@ -2822,10 +3632,188 @@ class Editor extends EventEmitter {
     }
 }
 
-class Node {
+/**
+ * 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, chain, }) => {
+            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);
+            if (config.keepMarks && config.editor) {
+                const { selection, storedMarks } = state;
+                const { splittableMarks } = config.editor.extensionManager;
+                const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks());
+                if (marks) {
+                    const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name));
+                    tr.ensureMarks(filteredMarks);
+                }
+            }
+            if (config.keepAttributes) {
+                /** If the nodeType is `bulletList` or `orderedList` set the `nodeType` as `listItem` */
+                const nodeType = config.type.name === 'bulletList' || config.type.name === 'orderedList' ? 'listItem' : 'taskList';
+                chain().updateAttributes(nodeType, attributes).run();
+            }
+            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);
+            }
+        },
+    });
+}
+
+class Mark {
     constructor(config = {}) {
-        this.type = 'node';
-        this.name = 'node';
+        this.type = 'mark';
+        this.name = 'mark';
         this.parent = null;
         this.child = null;
         this.config = {
@@ -2837,36 +3825,78 @@ class Node {
             ...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 = {}) {
-        return new Node(config);
+        return new Mark(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);
+        const extension = new Mark(extendedConfig);
         extension.parent = this;
         this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        extension.options = extendedConfig.defaultOptions
-            ? extendedConfig.defaultOptions
-            : extension.parent.options;
+        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;
     }
+    static handleExit({ editor, mark }) {
+        const { tr } = editor.state;
+        const currentPos = editor.state.selection.$from;
+        const isAtEnd = currentPos.pos === currentPos.end();
+        if (isAtEnd) {
+            const currentMarks = currentPos.marks();
+            const isInMark = !!currentMarks.find(m => (m === null || m === void 0 ? void 0 : m.type.name) === mark.name);
+            if (!isInMark) {
+                return false;
+            }
+            const removeMark = currentMarks.find(m => (m === null || m === void 0 ? void 0 : m.type.name) === mark.name);
+            if (removeMark) {
+                tr.removeStoredMark(removeMark);
+            }
+            tr.insertText(' ', currentPos.pos);
+            editor.view.dispatch(tr);
+            return true;
+        }
+        return false;
+    }
 }
 
-class Mark {
+class Node {
     constructor(config = {}) {
-        this.type = 'mark';
-        this.name = 'mark';
+        this.type = 'node';
+        this.name = 'node';
         this.parent = null;
         this.child = null;
         this.config = {
@@ -2878,45 +3908,54 @@ class Mark {
             ...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 = {}) {
-        return new Mark(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 Mark(extendedConfig);
+        const extension = new Node(extendedConfig);
         extension.parent = this;
         this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        extension.options = extendedConfig.defaultOptions
-            ? extendedConfig.defaultOptions
-            : extension.parent.options;
+        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;
     }
 }
 
-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);
-}
-
 class NodeView {
     constructor(component, props, options) {
         this.isDragging = false;
@@ -2938,13 +3977,13 @@ class NodeView {
         return;
     }
     get dom() {
-        return null;
+        return this.editor.view.dom;
     }
     get contentDOM() {
         return null;
     }
     onDragStart(event) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         const { view } = this.editor;
         const target = event.target;
         // get the drag handle element
@@ -2952,9 +3991,7 @@ class NodeView {
         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) {
+        if (!this.dom || ((_b = this.contentDOM) === null || _b === void 0 ? void 0 : _b.contains(target)) || !dragHandle) {
             return;
         }
         let x = 0;
@@ -2963,10 +4000,13 @@ class NodeView {
         if (this.dom !== dragHandle) {
             const domBox = this.dom.getBoundingClientRect();
             const handleBox = dragHandle.getBoundingClientRect();
-            x = handleBox.x - domBox.x + event.offsetX;
-            y = handleBox.y - domBox.y + event.offsetY;
+            // 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;
         }
-        (_c = event.dataTransfer) === null || _c === void 0 ? void 0 : _c.setDragImage(this.dom, x, y);
+        (_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());
@@ -2987,10 +4027,11 @@ class NodeView {
         if (!isInElement) {
             return false;
         }
-        const isInput = ['INPUT', 'BUTTON', 'SELECT', 'TEXTAREA'].includes(target.tagName)
-            || target.isContentEditable;
+        const isDragEvent = event.type.startsWith('drag');
+        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 && !isDragEvent) {
             return true;
         }
         const { isEditable } = this.editor;
@@ -3001,7 +4042,6 @@ 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';
         // ProseMirror tries to drag selectable nodes
         // even if `draggable` is set to `false`
         // this fix prevents that
@@ -3015,13 +4055,15 @@ class NodeView {
         // we have to store that dragging started
         if (isDraggable && isEditable && !isDragging && isClickEvent) {
             const dragHandle = target.closest('[data-drag-handle]');
-            const isValidDragHandle = dragHandle
-                && (this.dom === dragHandle || (this.dom.contains(dragHandle)));
+            const isValidDragHandle = dragHandle && (this.dom === dragHandle || this.dom.contains(dragHandle));
             if (isValidDragHandle) {
                 this.isDragging = true;
                 document.addEventListener('dragend', () => {
                     this.isDragging = false;
                 }, { once: true });
+                document.addEventListener('drop', () => {
+                    this.isDragging = false;
+                }, { once: true });
                 document.addEventListener('mouseup', () => {
                     this.isDragging = false;
                 }, { once: true });
@@ -3029,6 +4071,7 @@ class NodeView {
         }
         // these events are handled by prosemirror
         if (isDragging
+            || isDropEvent
             || isCopyEvent
             || isPasteEvent
             || isCutEvent
@@ -3057,7 +4100,10 @@ class NodeView {
         // 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()) {
+        if (this.dom.contains(mutation.target)
+            && mutation.type === 'childList'
+            && isiOS()
+            && this.editor.isFocused) {
             const changedNodes = [
                 ...Array.from(mutation.addedNodes),
                 ...Array.from(mutation.removedNodes),
@@ -3096,273 +4142,129 @@ class NodeView {
     }
 }
 
-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 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);
-            }
-            markEnd = start + startSpaces + captureGroup.length;
-            tr.addMark(start + startSpaces, markEnd, markType.create(attributes));
-            tr.removeStoredMark(markType);
-        }
-        return tr;
-    });
-}
-
-function markPasteRule (regexp, type, getAttributes) {
-    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 = getAttributes instanceof Function
-                            ? getAttributes(match)
-                            : getAttributes;
-                        if (!attrs && attrs !== undefined) {
-                            continue;
-                        }
-                        // 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;
-                    }
+            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;
                 }
-                // adding rest of text to nodes
-                if (pos < text.length) {
-                    nodes.push(child.cut(pos));
+                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);
             }
-            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);
-            },
         },
     });
 }
 
-function findChildren(node, predicate) {
-    const nodesWithPos = [];
-    node.descendants((child, pos) => {
-        if (predicate(child)) {
-            nodesWithPos.push({
-                node: child,
-                pos,
-            });
-        }
-    });
-    return nodesWithPos;
+// source: https://stackoverflow.com/a/6969486
+function escapeForRegEx(string) {
+    return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
+function isString(value) {
+    return typeof value === 'string';
 }
 
 /**
- * Same as `findChildren` but searches only within a `range`.
+ * Build an paste rule that adds a node when the
+ * matched text is pasted into it.
  */
-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,
-            });
-        }
+function nodePasteRule(config) {
+    return new PasteRule({
+        find: config.find,
+        handler({ match, chain, range }) {
+            const attributes = callOrReturn(config.getAttributes, undefined, match);
+            if (attributes === false || attributes === null) {
+                return null;
+            }
+            if (match.input) {
+                chain().deleteRange(range).insertContentAt(range.from, {
+                    type: config.type.name,
+                    attrs: attributes,
+                });
+            }
+        },
     });
-    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, schema);
-}
-
-function generateJSON(html, extensions) {
-    const schema = getSchema(extensions);
-    const dom = elementFromString(html);
-    return DOMParser.fromSchema(schema)
-        .parse(dom)
-        .toJSON();
 }
 
 /**
- * Returns a node tree with node positions.
+ * Build an paste rule that replaces text when the
+ * matched text is pasted into it.
  */
-function getDebugJSON(node, startOffset = 0) {
-    const nodes = [];
-    node.forEach((n, offset) => {
-        const from = startOffset + offset;
-        const to = from + n.nodeSize;
-        const marks = n.marks.map(mark => ({
-            type: mark.type.name,
-            attrs: { ...mark.attrs },
-        }));
-        const attrs = { ...n.attrs };
-        const content = getDebugJSON(n, from + 1);
-        const output = {
-            type: n.type.name,
-            from,
-            to,
-        };
-        if (Object.keys(attrs).length) {
-            output.attrs = attrs;
-        }
-        if (marks.length) {
-            output.marks = marks;
-        }
-        if (content.length) {
-            output.content = content;
-        }
-        if (n.text) {
-            output.text = n.text;
-        }
-        nodes.push(output);
+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;
+                }
+            }
+            state.tr.insertText(insert, start, end);
+        },
     });
-    return nodes;
-}
-
-function isNodeSelection(value) {
-    return isObject(value) && value instanceof NodeSelection;
 }
 
-function posToDOMRect(view, from, to) {
-    const start = view.coordsAtPos(from);
-    const end = view.coordsAtPos(to, -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,
-    };
+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,
+        };
+    }
 }
 
-export { Editor, Extension, Mark, Node, NodeView, Tracker, callOrReturn, extensions, findChildren, findChildrenInRange, findParentNode, findParentNodeClosestToPos, generateHTML, generateJSON, getAttributes, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAttributes, getNodeType, getSchema, isActive, isList, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isTextSelection, markInputRule, markPasteRule, mergeAttributes, nodeInputRule, posToDOMRect };
-//# sourceMappingURL=tiptap-core.esm.js.map
+export { CommandManager, Editor, Extension, InputRule, Mark, Node, NodeView, PasteRule, Tracker, callOrReturn, combineTransactionSteps, createChainableState, createDocument, createNodeFromContent, createStyleTag, defaultBlockAt, deleteProps, elementFromString, escapeForRegEx, extensions, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, fromString, generateHTML, generateJSON, generateText, getAttributes, getAttributesFromExtensions, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAttributes, getNodeType, getRenderedAttributes, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, injectExtensionAttributesToParseRule, inputRulesPlugin, isActive, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isRegExp, isString, isTextSelection, isiOS, markInputRule, markPasteRule, mergeAttributes, mergeDeep, minMax, nodeInputRule, nodePasteRule, objectIncludes, pasteRulesPlugin, posToDOMRect, removeDuplicates, resolveFocusPosition, selectionToInsertionEnd, splitExtensions, textInputRule, textPasteRule, textblockTypeInputRule, wrappingInputRule };
+//# sourceMappingURL=index.js.map