@tiptap/core 2.0.0-beta.14 → 2.0.0-beta.140

package/dist/tiptap-core.cjs.js

@@ -3,1117 +3,443 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var prosemirrorState = require('prosemirror-state');
-var prosemirrorView = require('prosemirror-view');
-var prosemirrorModel = require('prosemirror-model');
-var prosemirrorKeymap = require('prosemirror-keymap');
-var prosemirrorInputrules = require('prosemirror-inputrules');
 var prosemirrorTransform = require('prosemirror-transform');
 var prosemirrorCommands = require('prosemirror-commands');
+var prosemirrorModel = require('prosemirror-model');
 var prosemirrorSchemaList = require('prosemirror-schema-list');
+var prosemirrorView = require('prosemirror-view');
+var prosemirrorKeymap = require('prosemirror-keymap');
 
-function elementFromString(value) {
-    const htmlString = `<div>${value}</div>`;
-    const parser = new window.DOMParser();
-    const element = parser.parseFromString(htmlString, 'text/html').body;
-    return element;
+// 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;
 }
 
-function getNodeType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        return schema.nodes[nameOrType];
+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 nameOrType;
+    return output;
 }
 
-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 isObject$1(value) {
+    return typeof value === 'function';
 }
 
-function getMarkType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        return schema.marks[nameOrType];
+/**
+ * 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 (isObject$1(value)) {
+        if (context) {
+            return value.bind(context)(...props);
+        }
+        return value(...props);
     }
-    return nameOrType;
+    return value;
 }
 
-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();
+function getExtensionField(extension, field, context) {
+    if (extension.config[field] === undefined && extension.parent) {
+        return getExtensionField(extension.parent, field, context);
     }
-    else {
-        state.doc.nodesBetween(from, to, node => {
-            marks = [...marks, ...node.marks];
+    if (typeof extension.config[field] === 'function') {
+        const value = extension.config[field].bind({
+            ...context,
+            parent: extension.parent
+                ? getExtensionField(extension.parent, field, context)
+                : null,
         });
+        return value;
     }
-    const mark = marks.find(markItem => markItem.type.name === type.name);
-    if (mark) {
-        return { ...mark.attrs };
-    }
-    return {};
-}
-
-/**
- * Check if object1 includes object2
- * @param object1 Object
- * @param object2 Object
- */
-function objectIncludes(object1, object2) {
-    const keys = Object.keys(object2);
-    if (!keys.length) {
-        return true;
-    }
-    return !!keys
-        .filter(key => object2[key] === object1[key])
-        .length;
+    return extension.config[field];
 }
 
-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,
-                }];
+class Extension {
+    constructor(config = {}) {
+        this.type = 'extension';
+        this.name = 'extension';
+        this.parent = null;
+        this.child = null;
+        this.config = {
+            name: this.name,
+            defaultOptions: {},
+        };
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+        this.name = this.config.name;
+        if (config.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
         }
-    });
-    if (empty) {
-        return !!nodeRanges
-            .filter(nodeRange => {
-            if (!type) {
-                return true;
-            }
-            return type.name === nodeRange.node.type.name;
-        })
-            .find(nodeRange => objectIncludes(nodeRange.node.attrs, attributes));
+        // 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,
+        })) || {};
     }
-    const selectionRange = to - from;
-    const range = nodeRanges
-        .filter(nodeRange => {
-        if (!type) {
-            return true;
+    static create(config = {}) {
+        return new Extension(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 Extension(extendedConfig);
+        extension.parent = this;
+        this.child = extension;
+        extension.name = extendedConfig.name
+            ? extendedConfig.name
+            : extension.parent.name;
+        if (extendedConfig.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
         }
-        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;
+        // TODO: remove `addOptions` fallback
+        extension.options = extendedConfig.defaultOptions
+            ? extendedConfig.defaultOptions
+            : extension.parent.options;
+        if (extendedConfig.addOptions) {
+            extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
+                name: extension.name,
+            }));
+        }
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
+    }
 }
 
-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;
+function getTextBetween(startNode, range, options) {
+    const { from, to } = range;
+    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
+    let text = '';
+    let separated = true;
+    startNode.nodesBetween(from, to, (node, pos, parent, index) => {
+        var _a;
+        const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
+        if (textSerializer) {
+            if (node.isBlock && !separated) {
+                text += blockSeparator;
+                separated = 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,
-                }))];
+            text += textSerializer({
+                node,
+                pos,
+                parent,
+                index,
+            });
         }
-    });
-    if (selectionRange === 0) {
-        return false;
-    }
-    const range = markRanges
-        .filter(markRange => {
-        if (!type) {
-            return true;
+        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 = false;
         }
-        return type.name === markRange.mark.type.name;
-    })
-        .filter(markRange => objectIncludes(markRange.mark.attrs, attributes))
-        .reduce((sum, markRange) => {
-        const size = markRange.to - markRange.from;
-        return sum + size;
-    }, 0);
-    return range >= selectionRange;
+        else if (node.isBlock && !separated) {
+            text += blockSeparator;
+            separated = true;
+        }
+    });
+    return text;
 }
 
-function getSchemaTypeNameByName(name, schema) {
-    if (schema.nodes[name]) {
-        return 'node';
-    }
-    if (schema.marks[name]) {
-        return 'mark';
-    }
-    return null;
+function getTextSeralizersFromSchema(schema) {
+    return Object.fromEntries(Object
+        .entries(schema.nodes)
+        .filter(([, node]) => node.spec.toText)
+        .map(([name, node]) => [name, node.spec.toText]));
 }
 
-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 ClipboardTextSerializer = Extension.create({
+    name: 'clipboardTextSerializer',
+    addProseMirrorPlugins() {
+        return [
+            new prosemirrorState.Plugin({
+                key: new prosemirrorState.PluginKey('clipboardTextSerializer'),
+                props: {
+                    clipboardTextSerializer: () => {
+                        const { editor } = this;
+                        const { state, schema } = editor;
+                        const { doc, selection } = state;
+                        const { from, to } = selection;
+                        const textSerializers = getTextSeralizersFromSchema(schema);
+                        const range = { from, to };
+                        return getTextBetween(doc, range, {
+                            textSerializers,
+                        });
+                    },
+                },
+            }),
+        ];
+    },
+});
 
-function removeElement(element) {
-    if (element && element.parentNode) {
-        element.parentNode.removeChild(element);
-    }
-}
+const blur = () => ({ editor, view }) => {
+    requestAnimationFrame(() => {
+        if (!editor.isDestroyed) {
+            view.dom.blur();
+        }
+    });
+    return true;
+};
 
-function getHTMLFromFragment(doc, schema) {
-    const fragment = prosemirrorModel.DOMSerializer
-        .fromSchema(schema)
-        .serializeFragment(doc.content);
-    const temporaryDocument = document.implementation.createHTMLDocument();
-    const container = temporaryDocument.createElement('div');
-    container.appendChild(fragment);
-    return container.innerHTML;
-}
+var blur$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  blur: blur
+});
 
-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 clearContent = (emitUpdate = false) => ({ commands }) => {
+    return commands.setContent('', emitUpdate);
+};
 
-function createStyleTag(style) {
-    const styleNode = document.createElement('style');
-    styleNode.innerHTML = style;
-    document.getElementsByTagName('head')[0].appendChild(styleNode);
-    return styleNode;
-}
+var clearContent$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  clearContent: clearContent
+});
 
-class CommandManager {
-    constructor(editor, commands) {
-        this.editor = editor;
-        this.commands = commands;
-    }
-    createCommands() {
-        const { commands, editor } = this;
-        const { state, view } = editor;
-        const { tr } = state;
-        const props = this.buildProps(tr);
-        return Object.fromEntries(Object
-            .entries(commands)
-            .map(([name, command]) => {
-            const method = (...args) => {
-                const callback = command(...args)(props);
-                if (!tr.getMeta('preventDispatch')) {
-                    view.dispatch(tr);
-                }
-                return callback;
-            };
-            return [name, method];
-        }));
-    }
-    createChain(startTr, shouldDispatch = true) {
-        const { commands, editor } = this;
-        const { state, view } = editor;
-        const callbacks = [];
-        const hasStartTransaction = !!startTr;
-        const tr = startTr || state.tr;
-        const run = () => {
-            if (!hasStartTransaction && shouldDispatch && !tr.getMeta('preventDispatch')) {
-                view.dispatch(tr);
-            }
-            return () => callbacks.every(callback => callback === true);
-        };
-        const chain = {
-            ...Object.fromEntries(Object.entries(commands).map(([name, command]) => {
-                const chainedCommand = (...args) => {
-                    const props = this.buildProps(tr, shouldDispatch);
-                    const callback = command(...args)(props);
-                    callbacks.push(callback);
-                    return chain;
-                };
-                return [name, chainedCommand];
-            })),
-            run,
-        };
-        return chain;
-    }
-    createCan(startTr) {
-        const { commands, editor } = this;
-        const { state } = editor;
-        const dispatch = undefined;
-        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 })];
-        }));
-        return {
-            ...formattedCommands,
-            chain: () => this.createChain(tr, dispatch),
-        };
-    }
-    buildProps(tr, shouldDispatch = true) {
-        const { editor, commands } = this;
-        const { state, view } = editor;
-        if (state.storedMarks) {
-            tr.setStoredMarks(state.storedMarks);
-        }
-        const props = {
-            tr,
-            editor,
-            view,
-            state: this.chainableState(tr, state),
-            dispatch: shouldDispatch
-                ? () => undefined
-                : undefined,
-            chain: () => this.createChain(tr),
-            can: () => this.createCan(tr),
-            get commands() {
-                return Object.fromEntries(Object
-                    .entries(commands)
-                    .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 splitExtensions(extensions) {
-    const baseExtensions = extensions.filter(extension => extension.type === 'extension');
-    const nodeExtensions = extensions.filter(extension => extension.type === 'node');
-    const markExtensions = extensions.filter(extension => extension.type === 'mark');
-    return {
-        baseExtensions,
-        nodeExtensions,
-        markExtensions,
-    };
-}
-
-/**
- * Get a list of all extension attributes defined in `addAttribute` and `addGlobalAttribute`.
- * @param extensions List of extensions
- */
-function getAttributesFromExtensions(extensions) {
-    const extensionAttributes = [];
-    const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-    const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions];
-    const defaultAttribute = {
-        default: null,
-        rendered: true,
-        renderHTML: null,
-        parseHTML: null,
-        keepOnSplit: true,
-    };
-    extensions.forEach(extension => {
-        const context = {
-            options: extension.options,
-        };
-        if (!extension.config.addGlobalAttributes) {
-            return;
-        }
-        const globalAttributes = extension.config.addGlobalAttributes.bind(context)();
-        globalAttributes.forEach(globalAttribute => {
-            globalAttribute.types.forEach(type => {
-                Object
-                    .entries(globalAttribute.attributes)
-                    .forEach(([name, attribute]) => {
-                    extensionAttributes.push({
-                        type,
-                        name,
-                        attribute: {
-                            ...defaultAttribute,
-                            ...attribute,
-                        },
-                    });
-                });
-            });
-        });
-    });
-    nodeAndMarkExtensions.forEach(extension => {
-        const context = {
-            options: extension.options,
-        };
-        if (!extension.config.addAttributes) {
-            return;
-        }
-        const attributes = extension.config.addAttributes.bind(context)();
-        Object
-            .entries(attributes)
-            .forEach(([name, attribute]) => {
-            extensionAttributes.push({
-                type: extension.config.name,
-                name,
-                attribute: {
-                    ...defaultAttribute,
-                    ...attribute,
-                },
-            });
-        });
-    });
-    return extensionAttributes;
-}
-
-function mergeAttributes(...objects) {
-    return objects
-        .filter(item => !!item)
-        .reduce((items, item) => {
-        const mergedAttributes = { ...items };
-        Object.entries(item).forEach(([key, value]) => {
-            const exists = mergedAttributes[key];
-            if (!exists) {
-                mergedAttributes[key] = value;
+const clearNodes = () => ({ state, tr, dispatch }) => {
+    const { selection } = tr;
+    const { ranges } = selection;
+    ranges.forEach(range => {
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+            if (node.type.isText) {
                 return;
             }
-            if (key === 'class') {
-                mergedAttributes[key] = [mergedAttributes[key], value].join(' ');
+            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);
+            if (!nodeRange) {
+                return;
             }
-            else if (key === 'style') {
-                mergedAttributes[key] = [mergedAttributes[key], value].join('; ');
+            const targetLiftDepth = prosemirrorTransform.liftTarget(nodeRange);
+            if (node.type.isTextblock && dispatch) {
+                const { defaultType } = $fromPos.parent.contentMatchAt($fromPos.index());
+                tr.setNodeMarkup(nodeRange.start, defaultType);
             }
-            else {
-                mergedAttributes[key] = value;
+            if ((targetLiftDepth || targetLiftDepth === 0) && dispatch) {
+                tr.lift(nodeRange, targetLiftDepth);
             }
         });
-        return mergedAttributes;
-    }, {});
-}
+    });
+    return true;
+};
 
-function getRenderedAttributes(nodeOrMark, extensionAttributes) {
-    return extensionAttributes
-        .filter(item => item.attribute.rendered)
-        .map(item => {
-        if (!item.attribute.renderHTML) {
-            return {
-                [item.name]: nodeOrMark.attrs[item.name],
-            };
-        }
-        return item.attribute.renderHTML(nodeOrMark.attrs) || {};
-    })
-        .reduce((attributes, attribute) => {
-        return mergeAttributes(attributes, attribute);
-    }, {});
-}
+var clearNodes$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  clearNodes: clearNodes
+});
 
-function isEmptyObject(object = {}) {
-    return Object.keys(object).length === 0 && object.constructor === Object;
-}
+const command = fn => props => {
+    return fn(props);
+};
 
-function fromString(value) {
-    if (typeof value !== 'string') {
-        return value;
-    }
-    if (value.match(/^\d*(\.\d+)?$/)) {
-        return Number(value);
-    }
-    if (value === 'true') {
-        return true;
-    }
-    if (value === 'false') {
-        return false;
-    }
-    return value;
-}
+var command$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  command: command
+});
 
-/**
- * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
- * Cancels when `getAttrs` returned `false`.
- * @param parseRule ProseMirror ParseRule
- * @param extensionAttributes List of attributes to inject
- */
-function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
-    if (parseRule.style) {
-        return parseRule;
+const createParagraphNear = () => ({ state, dispatch }) => {
+    return prosemirrorCommands.createParagraphNear(state, dispatch);
+};
+
+var createParagraphNear$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createParagraphNear: createParagraphNear
+});
+
+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 {
-        ...parseRule,
-        getAttrs: node => {
-            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));
-                return {
-                    ...items,
-                    ...filteredAttributes,
-                };
-            }, {});
-            return { ...oldAttributes, ...newAttributes };
-        },
-    };
+    return nameOrType;
 }
 
-/**
- * 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);
+const deleteNode = typeOrName => ({ tr, state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema);
+    const $pos = tr.selection.$anchor;
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+        const node = $pos.node(depth);
+        if (node.type === type) {
+            if (dispatch) {
+                const from = $pos.before(depth);
+                const to = $pos.after(depth);
+                tr.delete(from, to).scrollIntoView();
+            }
+            return true;
         }
-        return value(...props);
     }
-    return value;
-}
+    return false;
+};
 
-function cleanUpSchemaItem(data) {
-    return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-        if (key === 'attrs' && isEmptyObject(value)) {
-            return false;
-        }
-        return value !== null && value !== undefined;
-    }));
-}
-function getSchema(extensions) {
-    var _a;
-    const allAttributes = getAttributesFromExtensions(extensions);
-    const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-    const topNode = (_a = nodeExtensions.find(extension => extension.config.topNode)) === null || _a === void 0 ? void 0 : _a.config.name;
-    const nodeSchemaExtenders = [];
-    const markSchemaExtenders = [];
-    extensions.forEach(extension => {
-        if (typeof extension.config.extendNodeSchema === 'function') {
-            nodeSchemaExtenders.push(extension.config.extendNodeSchema);
-        }
-        if (typeof extension.config.extendMarkSchema === 'function') {
-            markSchemaExtenders.push(extension.config.extendMarkSchema);
-        }
-    });
-    const nodes = Object.fromEntries(nodeExtensions.map(extension => {
-        var _a;
-        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name);
-        const context = { options: extension.options };
-        const extraNodeFields = nodeSchemaExtenders.reduce((fields, nodeSchemaExtender) => {
-            const extraFields = callOrReturn(nodeSchemaExtender, context, extension);
-            return {
-                ...fields,
-                ...extraFields,
-            };
-        }, {});
-        const schema = cleanUpSchemaItem({
-            ...extraNodeFields,
-            content: callOrReturn(extension.config.content, context),
-            marks: callOrReturn(extension.config.marks, context),
-            group: callOrReturn(extension.config.group, context),
-            inline: callOrReturn(extension.config.inline, context),
-            atom: callOrReturn(extension.config.atom, context),
-            selectable: callOrReturn(extension.config.selectable, context),
-            draggable: callOrReturn(extension.config.draggable, context),
-            code: callOrReturn(extension.config.code, context),
-            defining: callOrReturn(extension.config.defining, context),
-            isolating: callOrReturn(extension.config.isolating, context),
-            attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-                var _a;
-                return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
-            })),
-        });
-        if (extension.config.parseHTML) {
-            schema.parseDOM = (_a = extension.config.parseHTML
-                .bind(context)()) === null || _a === void 0 ? void 0 : _a.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-        }
-        if (extension.config.renderHTML) {
-            schema.toDOM = node => {
-                var _a;
-                return (_a = extension.config.renderHTML) === null || _a === void 0 ? void 0 : _a.bind(context)({
-                    node,
-                    HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-                });
-            };
-        }
-        return [extension.config.name, schema];
-    }));
-    const marks = Object.fromEntries(markExtensions.map(extension => {
-        var _a;
-        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name);
-        const context = { options: extension.options };
-        const extraMarkFields = markSchemaExtenders.reduce((fields, markSchemaExtender) => {
-            const extraFields = callOrReturn(markSchemaExtender, context, extension);
-            return {
-                ...fields,
-                ...extraFields,
-            };
-        }, {});
-        const schema = cleanUpSchemaItem({
-            ...extraMarkFields,
-            inclusive: callOrReturn(extension.config.inclusive, context),
-            excludes: callOrReturn(extension.config.excludes, context),
-            group: callOrReturn(extension.config.group, context),
-            spanning: callOrReturn(extension.config.spanning, context),
-            attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-                var _a;
-                return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
-            })),
-        });
-        if (extension.config.parseHTML) {
-            schema.parseDOM = (_a = extension.config.parseHTML
-                .bind(context)()) === null || _a === void 0 ? void 0 : _a.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-        }
-        if (extension.config.renderHTML) {
-            schema.toDOM = mark => {
-                var _a;
-                return (_a = extension.config.renderHTML) === null || _a === void 0 ? void 0 : _a.bind(context)({
-                    mark,
-                    HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-                });
-            };
-        }
-        return [extension.config.name, schema];
-    }));
-    return new prosemirrorModel.Schema({
-        topNode,
-        nodes,
-        marks,
-    });
-}
+var deleteNode$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  deleteNode: deleteNode
+});
 
-function getSchemaTypeByName(name, schema) {
-    if (schema.nodes[name]) {
-        return schema.nodes[name];
+const deleteRange = range => ({ tr, dispatch }) => {
+    const { from, to } = range;
+    if (dispatch) {
+        tr.delete(from, to);
     }
-    if (schema.marks[name]) {
-        return schema.marks[name];
+    return true;
+};
+
+var deleteRange$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  deleteRange: deleteRange
+});
+
+const deleteSelection = () => ({ state, dispatch }) => {
+    return prosemirrorCommands.deleteSelection(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 prosemirrorCommands.exitCode(state, dispatch);
+};
+
+var exitCode$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  exitCode: exitCode
+});
+
+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 null;
+    return nameOrType;
 }
 
-class ExtensionManager {
-    constructor(extensions, editor) {
-        this.splittableMarks = [];
-        this.editor = editor;
-        this.extensions = extensions;
-        this.schema = getSchema(this.extensions);
-        this.extensions.forEach(extension => {
-            var _a;
-            const context = {
-                options: extension.options,
-                editor: this.editor,
-                type: getSchemaTypeByName(extension.config.name, this.schema),
-            };
-            if (extension.type === 'mark') {
-                const keepOnSplit = (_a = callOrReturn(extension.config.keepOnSplit, context)) !== null && _a !== void 0 ? _a : true;
-                if (keepOnSplit) {
-                    this.splittableMarks.push(extension.config.name);
-                }
-            }
-            if (typeof extension.config.onCreate === 'function') {
-                this.editor.on('create', extension.config.onCreate.bind(context));
-            }
-            if (typeof extension.config.onUpdate === 'function') {
-                this.editor.on('update', extension.config.onUpdate.bind(context));
-            }
-            if (typeof extension.config.onSelectionUpdate === 'function') {
-                this.editor.on('selectionUpdate', extension.config.onSelectionUpdate.bind(context));
-            }
-            if (typeof extension.config.onViewUpdate === 'function') {
-                this.editor.on('viewUpdate', extension.config.onViewUpdate.bind(context));
-            }
-            if (typeof extension.config.onTransaction === 'function') {
-                this.editor.on('transaction', extension.config.onTransaction.bind(context));
-            }
-            if (typeof extension.config.onFocus === 'function') {
-                this.editor.on('focus', extension.config.onFocus.bind(context));
-            }
-            if (typeof extension.config.onBlur === 'function') {
-                this.editor.on('blur', extension.config.onBlur.bind(context));
-            }
-            if (typeof extension.config.onDestroy === 'function') {
-                this.editor.on('destroy', extension.config.onDestroy.bind(context));
-            }
-        });
+function isRegExp(value) {
+    return Object.prototype.toString.call(value) === '[object RegExp]';
+}
+
+/**
+ * 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;
     }
-    get commands() {
-        return this.extensions.reduce((commands, extension) => {
-            const context = {
-                options: extension.options,
-                editor: this.editor,
-                type: getSchemaTypeByName(extension.config.name, this.schema),
-            };
-            if (!extension.config.addCommands) {
-                return commands;
-            }
-            return {
-                ...commands,
-                ...extension.config.addCommands.bind(context)(),
-            };
-        }, {});
+    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 => {
+        return item.type === type && objectIncludes(item.attrs, attributes);
+    });
+}
+function isMarkInSet(marks, type, attributes = {}) {
+    return !!findMarkInSet(marks, type, attributes);
+}
+function getMarkRange($pos, type, attributes = {}) {
+    if (!$pos || !type) {
+        return;
     }
-    get plugins() {
-        return [...this.extensions]
-            .reverse()
-            .map(extension => {
-            const context = {
-                options: extension.options,
-                editor: this.editor,
-                type: getSchemaTypeByName(extension.config.name, this.schema),
-            };
-            const plugins = [];
-            if (extension.config.addKeyboardShortcuts) {
-                const keyMapPlugin = prosemirrorKeymap.keymap(extension.config.addKeyboardShortcuts.bind(context)());
-                plugins.push(keyMapPlugin);
-            }
-            if (this.editor.options.enableInputRules && extension.config.addInputRules) {
-                const inputRules = extension.config.addInputRules.bind(context)();
-                const inputRulePlugins = inputRules.length
-                    ? [prosemirrorInputrules.inputRules({ rules: inputRules })]
-                    : [];
-                plugins.push(...inputRulePlugins);
-            }
-            if (this.editor.options.enablePasteRules && extension.config.addPasteRules) {
-                const pasteRulePlugins = extension.config.addPasteRules.bind(context)();
-                plugins.push(...pasteRulePlugins);
-            }
-            if (extension.config.addProseMirrorPlugins) {
-                const proseMirrorPlugins = extension.config.addProseMirrorPlugins.bind(context)();
-                plugins.push(...proseMirrorPlugins);
-            }
-            return plugins;
-        })
-            .flat();
+    const start = $pos.parent.childAfter($pos.parentOffset);
+    if (!start.node) {
+        return;
     }
-    get attributes() {
-        return getAttributesFromExtensions(this.extensions);
+    const mark = findMarkInSet(start.node.marks, type, attributes);
+    if (!mark) {
+        return;
     }
-    get nodeViews() {
-        const { editor } = this;
-        const { nodeExtensions } = splitExtensions(this.extensions);
-        return Object.fromEntries(nodeExtensions
-            .filter(extension => !!extension.config.addNodeView)
-            .map(extension => {
-            var _a;
-            const extensionAttributes = this.attributes.filter(attribute => attribute.type === extension.config.name);
-            const context = {
-                options: extension.options,
-                editor,
-                type: getNodeType(extension.config.name, this.schema),
-            };
-            const renderer = (_a = extension.config.addNodeView) === null || _a === void 0 ? void 0 : _a.call(context);
-            const nodeview = (node, view, getPos, decorations) => {
-                const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
-                return renderer({
-                    editor,
-                    node,
-                    getPos,
-                    decorations,
-                    HTMLAttributes,
-                    extension,
-                });
-            };
-            return [extension.config.name, nodeview];
-        }));
+    let startIndex = $pos.index();
+    let startPos = $pos.start() + start.offset;
+    let endIndex = startIndex + 1;
+    let endPos = startPos + start.node.nodeSize;
+    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;
     }
-    get textSerializers() {
-        const { editor } = this;
-        const { nodeExtensions } = splitExtensions(this.extensions);
-        return Object.fromEntries(nodeExtensions
-            .filter(extension => !!extension.config.renderText)
-            .map(extension => {
-            const context = {
-                options: extension.options,
-                editor,
-                type: getNodeType(extension.config.name, this.schema),
-            };
-            const textSerializer = (props) => { var _a; return (_a = extension.config.renderText) === null || _a === void 0 ? void 0 : _a.call(context, props); };
-            return [extension.config.name, textSerializer];
-        }));
+    while (endIndex < $pos.parent.childCount
+        && isMarkInSet($pos.parent.child(endIndex).marks, type, attributes)) {
+        endPos += $pos.parent.child(endIndex).nodeSize;
+        endIndex += 1;
     }
+    return {
+        from: startPos,
+        to: endPos,
+    };
 }
 
-class EventEmitter {
-    constructor() {
-        this.callbacks = {};
-    }
-    on(event, fn) {
-        if (!this.callbacks[event]) {
-            this.callbacks[event] = [];
-        }
-        this.callbacks[event].push(fn);
-        return this;
-    }
-    emit(event, ...args) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            callbacks.forEach(callback => callback.apply(this, args));
-        }
-        return this;
-    }
-    off(event, fn) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            if (fn) {
-                this.callbacks[event] = callbacks.filter(callback => callback !== fn);
-            }
-            else {
-                delete this.callbacks[event];
-            }
-        }
-        return this;
-    }
-    removeAllListeners() {
-        this.callbacks = {};
-    }
-}
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __classPrivateFieldGet(receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-
-// see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
-function getType(payload) {
-    return Object.prototype.toString.call(payload).slice(8, -1);
-}
-function 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] });
-            }
-        });
-    }
-    return output;
-}
-
-var _configure$2;
-class Extension {
-    constructor(config) {
-        this.type = 'extension';
-        this.config = {
-            name: 'extension',
-            defaultOptions: {},
-        };
-        _configure$2.set(this, (options) => {
-            this.options = mergeDeep(this.config.defaultOptions, options);
-            return this;
-        });
-        this.config = {
-            ...this.config,
-            ...config,
-        };
-        this.options = this.config.defaultOptions;
-    }
-    static create(config) {
-        return new Extension(config);
-    }
-    configure(options = {}) {
-        var _a;
-        return __classPrivateFieldGet((_a = Extension
-            .create(this.config)), _configure$2).call(_a, options);
-    }
-    extend(extendedConfig) {
-        return new Extension({
-            ...this.config,
-            ...extendedConfig,
-        });
-    }
-}
-_configure$2 = new WeakMap();
-
-const textBetween = (editor, from, to, blockSeparator, leafText) => {
-    let text = '';
-    let separated = true;
-    editor.state.doc.nodesBetween(from, to, (node, pos) => {
-        var _a;
-        const textSerializer = editor.extensionManager.textSerializers[node.type.name];
-        if (textSerializer) {
-            text += textSerializer({ node });
-            separated = !blockSeparator;
-        }
-        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;
-        }
-        else if (node.isLeaf && leafText) {
-            text += leafText;
-            separated = !blockSeparator;
-        }
-        else if (!separated && node.isBlock) {
-            text += blockSeparator;
-            separated = true;
-        }
-    }, 0);
-    return text;
-};
-const ClipboardTextSerializer = Extension.create({
-    name: 'editable',
-    addProseMirrorPlugins() {
-        return [
-            new prosemirrorState.Plugin({
-                key: new prosemirrorState.PluginKey('clipboardTextSerializer'),
-                props: {
-                    clipboardTextSerializer: () => {
-                        const { editor } = this;
-                        const { from, to } = editor.state.selection;
-                        return textBetween(editor, from, to, '\n');
-                    },
-                },
-            }),
-        ];
-    },
-});
-
-const blur = () => ({ view }) => {
-    const element = view.dom;
-    element.blur();
-    return true;
-};
-
-var blur$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  blur: blur
-});
-
-const clearContent = (emitUpdate = false) => ({ commands }) => {
-    return commands.setContent('', emitUpdate);
-};
-
-var clearContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  clearContent: clearContent
-});
-
-const clearNodes = () => ({ state, tr, dispatch }) => {
-    const { selection } = tr;
-    const { ranges } = selection;
-    ranges.forEach(range => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-            if (!node.type.isText) {
-                const fromPos = tr.doc.resolve(tr.mapping.map(pos + 1));
-                const toPos = tr.doc.resolve(tr.mapping.map(pos + node.nodeSize - 1));
-                const nodeRange = fromPos.blockRange(toPos);
-                if (nodeRange) {
-                    const targetLiftDepth = prosemirrorTransform.liftTarget(nodeRange);
-                    if (node.type.isTextblock && dispatch) {
-                        tr.setNodeMarkup(nodeRange.start, state.doc.type.contentMatch.defaultType);
-                    }
-                    if ((targetLiftDepth || targetLiftDepth === 0) && dispatch) {
-                        tr.lift(nodeRange, targetLiftDepth);
-                    }
-                }
-            }
-        });
-    });
-    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 prosemirrorCommands.createParagraphNear(state, dispatch);
-};
-
-var createParagraphNear$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createParagraphNear: createParagraphNear
-});
-
-const deleteRange = range => ({ tr, dispatch }) => {
-    const { from, to } = range;
-    if (dispatch) {
-        tr.delete(from, to);
-    }
-    return true;
-};
-
-var deleteRange$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  deleteRange: deleteRange
-});
-
-const deleteSelection = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.deleteSelection(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 prosemirrorCommands.exitCode(state, dispatch);
-};
-
-var exitCode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  exitCode: exitCode
-});
-
-function getMarkRange($pos, type) {
-    if (!$pos || !type) {
-        return;
-    }
-    const start = $pos.parent.childAfter($pos.parentOffset);
-    if (!start.node) {
-        return;
-    }
-    const link = start.node.marks.find(mark => mark.type === type);
-    if (!link) {
-        return;
-    }
-    let startIndex = $pos.index();
-    let startPos = $pos.start() + start.offset;
-    let endIndex = startIndex + 1;
-    let endPos = startPos + start.node.nodeSize;
-    while (startIndex > 0 && link.isInSet($pos.parent.child(startIndex - 1).marks)) {
-        startIndex -= 1;
-        startPos -= $pos.parent.child(startIndex).nodeSize;
-    }
-    while (endIndex < $pos.parent.childCount && link.isInSet($pos.parent.child(endIndex).marks)) {
-        endPos += $pos.parent.child(endIndex).nodeSize;
-        endIndex += 1;
-    }
-    return {
-        from: startPos,
-        to: endPos,
-    };
-}
-
-const extendMarkRange = typeOrName => ({ tr, state, dispatch }) => {
-    const type = getMarkType(typeOrName, state.schema);
-    const { doc, selection } = tr;
-    const { $from, empty } = selection;
-    if (empty && dispatch) {
-        const range = getMarkRange($from, type);
-        if (range) {
-            const newSelection = prosemirrorState.TextSelection.create(doc, range.from, range.to);
-            tr.setSelection(newSelection);
+const extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+    const type = getMarkType(typeOrName, state.schema);
+    const { doc, selection } = tr;
+    const { $from, from, to } = selection;
+    if (dispatch) {
+        const range = getMarkRange($from, type, attributes);
+        if (range && range.from <= from && range.to >= to) {
+            const newSelection = prosemirrorState.TextSelection.create(doc, range.from, range.to);
+            tr.setSelection(newSelection);
         }
     }
     return true;
@@ -1145,25 +471,38 @@ function minMax(value = 0, min = 0, max = 0) {
     return Math.min(Math.max(value, min), max);
 }
 
-function isClass(item) {
+function isClass(value) {
     var _a;
-    if (((_a = item.constructor) === null || _a === void 0 ? void 0 : _a.toString().substring(0, 5)) !== 'class') {
+    if (((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.toString().substring(0, 5)) !== 'class') {
         return false;
     }
     return true;
 }
 
-function isObject(item) {
-    return (item
-        && typeof item === 'object'
-        && !Array.isArray(item)
-        && !isClass(item));
+function isObject(value) {
+    return (value
+        && typeof value === 'object'
+        && !Array.isArray(value)
+        && !isClass(value));
 }
 
 function isTextSelection(value) {
     return isObject(value) && value instanceof prosemirrorState.TextSelection;
 }
 
+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);
+}
+
 function resolveSelection(state, position = null) {
     if (!position) {
         return null;
@@ -1187,28 +526,47 @@ function resolveSelection(state, position = null) {
     };
 }
 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();
+                editor.commands.scrollIntoView();
+            }
+        });
+    };
     if ((view.hasFocus() && position === null) || position === false) {
         return true;
     }
     // we don’t try to resolve a NodeSelection or CellSelection
     if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-        view.focus();
+        delayedFocus();
         return true;
     }
     const { from, to } = resolveSelection(editor.state, position) || editor.state.selection;
     const { doc, storedMarks } = tr;
-    const resolvedFrom = minMax(from, 0, doc.content.size);
-    const resolvedEnd = minMax(to, 0, doc.content.size);
+    const minPos = prosemirrorState.Selection.atStart(doc).from;
+    const maxPos = prosemirrorState.Selection.atEnd(doc).to;
+    const resolvedFrom = minMax(from, minPos, maxPos);
+    const resolvedEnd = minMax(to, minPos, maxPos);
     const selection = prosemirrorState.TextSelection.create(doc, resolvedFrom, resolvedEnd);
     const isSameSelection = editor.state.selection.eq(selection);
     if (dispatch) {
-        tr.setSelection(selection);
+        if (!isSameSelection) {
+            tr.setSelection(selection);
+        }
         // `tr.setSelection` resets the stored marks
         // so we’ll restore them if the selection is the same as before
         if (isSameSelection && storedMarks) {
             tr.setStoredMarks(storedMarks);
         }
-        view.focus();
+        delayedFocus();
     }
     return true;
 };
@@ -1218,6 +576,57 @@ var focus$1 = /*#__PURE__*/Object.freeze({
   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)) {
+                return prosemirrorModel.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 = prosemirrorModel.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) {
     const last = tr.steps.length - 1;
@@ -1238,50 +647,65 @@ function selectionToInsertionEnd(tr, startLen, bias) {
     tr.setSelection(prosemirrorState.Selection.near(tr.doc.resolve(end), bias));
 }
 
-const insertHTML = value => ({ tr, state, dispatch }) => {
-    const { selection } = tr;
-    const element = elementFromString(value);
-    const slice = prosemirrorModel.DOMParser.fromSchema(state.schema).parseSlice(element);
+const isFragment = (nodeOrFragment) => {
+    return nodeOrFragment.toString().startsWith('<');
+};
+const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
     if (dispatch) {
-        tr.insert(selection.anchor, slice.content);
-        selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-    }
-    return true;
-};
-
-var insertHTML$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertHTML: insertHTML
-});
-
-const insertNode = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const { selection } = tr;
-    const type = getNodeType(typeOrName, state.schema);
-    if (!type) {
-        return false;
-    }
-    const node = type.create(attributes);
-    if (dispatch) {
-        tr.insert(selection.anchor, node);
-    }
-    return true;
-};
-
-var insertNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertNode: insertNode
-});
-
-const insertText = value => ({ tr, dispatch }) => {
-    if (dispatch) {
-        tr.insertText(value);
+        options = {
+            parseOptions: {},
+            updateSelection: true,
+            ...options,
+        };
+        const content = createNodeFromContent(value, editor.schema, {
+            parseOptions: {
+                preserveWhitespace: 'full',
+                ...options.parseOptions,
+            },
+        });
+        // don’t dispatch an empty fragment because this can lead to strange errors
+        if (content.toString() === '<>') {
+            return true;
+        }
+        let { from, to } = typeof position === 'number'
+            ? { from: position, to: position }
+            : position;
+        let isOnlyBlockContent = true;
+        const nodes = isFragment(content)
+            ? content
+            : [content];
+        nodes.forEach(node => {
+            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;
+            }
+        }
+        tr.replaceWith(from, to, content);
+        // set cursor at end of inserted content
+        if (options.updateSelection) {
+            selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
+        }
     }
     return true;
 };
 
-var insertText$1 = /*#__PURE__*/Object.freeze({
+var insertContentAt$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  insertText: insertText
+  insertContentAt: insertContentAt
 });
 
 const joinBackward = () => ({ state, dispatch }) => {
@@ -1384,6 +808,41 @@ var keyboardShortcut$1 = /*#__PURE__*/Object.freeze({
   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);
     const isActive = isNodeActive(state, type, attributes);
@@ -1426,35 +885,15 @@ var newlineInCode$1 = /*#__PURE__*/Object.freeze({
   newlineInCode: newlineInCode
 });
 
-const replace = (typeOrName, attributes = {}) => ({ state, commands }) => {
-    const { from, to } = state.selection;
-    const range = { from, to };
-    return commands.replaceRange(range, typeOrName, attributes);
-};
-
-var replace$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  replace: replace
-});
-
-const replaceRange = (range, typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const { from, to } = range;
-    const $from = tr.doc.resolve(from);
-    const index = $from.index();
-    if (!$from.parent.canReplaceWith(index, index, type)) {
-        return false;
+function getSchemaTypeNameByName(name, schema) {
+    if (schema.nodes[name]) {
+        return 'node';
     }
-    if (dispatch) {
-        tr.replaceWith(from, to, type.create(attributes));
+    if (schema.marks[name]) {
+        return 'mark';
     }
-    return true;
-};
-
-var replaceRange$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  replaceRange: replaceRange
-});
+    return null;
+}
 
 /**
  * Remove a property or an array of properties from an object
@@ -1475,23 +914,43 @@ function deleteProps(obj, propOrProps) {
     }, {});
 }
 
-const resetNodeAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const { selection } = tr;
-    const { ranges } = selection;
-    ranges.forEach(range => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-            if (node.type === type && dispatch) {
-                tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes));
-            }
+const resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
+    let nodeType = null;
+    let markType = null;
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
+        ? typeOrName
+        : typeOrName.name, state.schema);
+    if (!schemaType) {
+        return false;
+    }
+    if (schemaType === 'node') {
+        nodeType = getNodeType(typeOrName, state.schema);
+    }
+    if (schemaType === 'mark') {
+        markType = getMarkType(typeOrName, state.schema);
+    }
+    if (dispatch) {
+        tr.selection.ranges.forEach(range => {
+            state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+                if (nodeType && nodeType === node.type) {
+                    tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes));
+                }
+                if (markType && node.marks.length) {
+                    node.marks.forEach(mark => {
+                        if (markType === mark.type) {
+                            tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
+                        }
+                    });
+                }
+            });
         });
-    });
+    }
     return true;
 };
 
-var resetNodeAttributes$1 = /*#__PURE__*/Object.freeze({
+var resetAttributes$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  resetNodeAttributes: resetNodeAttributes
+  resetAttributes: resetAttributes
 });
 
 const scrollIntoView = () => ({ tr, dispatch }) => {
@@ -1506,8 +965,11 @@ var scrollIntoView$1 = /*#__PURE__*/Object.freeze({
   scrollIntoView: scrollIntoView
 });
 
-const selectAll = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectAll(state, dispatch);
+const selectAll = () => ({ tr, commands }) => {
+    return commands.setTextSelection({
+        from: 0,
+        to: tr.doc.content.size,
+    });
 };
 
 var selectAll$1 = /*#__PURE__*/Object.freeze({
@@ -1542,10 +1004,13 @@ var selectParentNode$1 = /*#__PURE__*/Object.freeze({
   selectParentNode: selectParentNode
 });
 
+function createDocument(content, schema, parseOptions = {}) {
+    return createNodeFromContent(content, schema, { slice: false, parseOptions });
+}
+
 const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
-    const { createDocument } = editor;
     const { doc } = tr;
-    const document = createDocument(content, parseOptions);
+    const document = createDocument(content, editor.schema, parseOptions);
     const selection = prosemirrorState.TextSelection.create(doc, 0, doc.content.size);
     if (dispatch) {
         tr.setSelection(selection)
@@ -1560,22 +1025,65 @@ var setContent$1 = /*#__PURE__*/Object.freeze({
   setContent: setContent
 });
 
+function getMarkAttributes(state, typeOrName) {
+    const type = getMarkType(typeOrName, state.schema);
+    const { from, to, empty } = state.selection;
+    const marks = [];
+    if (empty) {
+        if (state.storedMarks) {
+            marks.push(...state.storedMarks);
+        }
+        marks.push(...state.selection.$head.marks());
+    }
+    else {
+        state.doc.nodesBetween(from, to, node => {
+            marks.push(...node.marks);
+        });
+    }
+    const mark = marks.find(markItem => markItem.type.name === type.name);
+    if (!mark) {
+        return {};
+    }
+    return { ...mark.attrs };
+}
+
 const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
     const { selection } = tr;
     const { empty, ranges } = selection;
     const type = getMarkType(typeOrName, state.schema);
-    const oldAttributes = getMarkAttributes(state, type);
-    const newAttributes = {
-        ...oldAttributes,
-        ...attributes,
-    };
     if (dispatch) {
         if (empty) {
-            tr.addStoredMark(type.create(newAttributes));
+            const oldAttributes = getMarkAttributes(state, type);
+            tr.addStoredMark(type.create({
+                ...oldAttributes,
+                ...attributes,
+            }));
         }
         else {
             ranges.forEach(range => {
-                tr.addMark(range.$from.pos, range.$to.pos, type.create(newAttributes));
+                const from = range.$from.pos;
+                const to = range.$to.pos;
+                state.doc.nodesBetween(from, to, (node, pos) => {
+                    const trimmedFrom = Math.max(pos, from);
+                    const trimmedTo = Math.min(pos + node.nodeSize, to);
+                    const someHasMark = node.marks.find(mark => mark.type === type);
+                    // if there is already a mark of this type
+                    // we know that we have to merge its attributes
+                    // otherwise we add a fresh new mark
+                    if (someHasMark) {
+                        node.marks.forEach(mark => {
+                            if (type === mark.type) {
+                                tr.addMark(trimmedFrom, trimmedTo, type.create({
+                                    ...mark.attrs,
+                                    ...attributes,
+                                }));
+                            }
+                        });
+                    }
+                    else {
+                        tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
+                    }
+                });
             });
         }
     }
@@ -1587,6 +1095,16 @@ var setMark$1 = /*#__PURE__*/Object.freeze({
   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 type = getNodeType(typeOrName, state.schema);
     return prosemirrorCommands.setBlockType(type, attributes)(state, dispatch);
@@ -1597,6 +1115,44 @@ var setNode$1 = /*#__PURE__*/Object.freeze({
   setNode: setNode
 });
 
+const setNodeSelection = position => ({ tr, dispatch }) => {
+    if (dispatch) {
+        const { doc } = tr;
+        const minPos = prosemirrorState.Selection.atStart(doc).from;
+        const maxPos = prosemirrorState.Selection.atEnd(doc).to;
+        const resolvedPos = minMax(position, minPos, maxPos);
+        const selection = prosemirrorState.NodeSelection.create(doc, resolvedPos);
+        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 = prosemirrorState.Selection.atStart(doc).from;
+        const maxPos = prosemirrorState.Selection.atEnd(doc).to;
+        const resolvedFrom = minMax(from, minPos, maxPos);
+        const resolvedEnd = minMax(to, minPos, maxPos);
+        const selection = prosemirrorState.TextSelection.create(doc, resolvedFrom, resolvedEnd);
+        tr.setSelection(selection);
+    }
+    return true;
+};
+
+var setTextSelection$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  setTextSelection: setTextSelection
+});
+
 const sinkListItem = typeOrName => ({ state, dispatch }) => {
     const type = getNodeType(typeOrName, state.schema);
     return prosemirrorSchemaList.sinkListItem(type)(state, dispatch);
@@ -1622,7 +1178,7 @@ function getSplittedAttributes(extensionAttributes, typeName, attributes) {
 }
 
 function defaultBlockAt(match) {
-    for (let i = 0; i < match.edgeCount; i + 1) {
+    for (let i = 0; i < match.edgeCount; i += 1) {
         const { type } = match.edge(i);
         if (type.isTextblock && !type.hasRequiredAttrs()) {
             return type;
@@ -1686,11 +1242,15 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
         }
         if (can) {
             tr.split(tr.mapping.map($from.pos), 1, types);
-            if (!atEnd
+            if (deflt
+                && !atEnd
                 && !$from.parentOffset
-                && $from.parent.type !== deflt
-                && $from.node(-1).canReplace($from.index(-1), $from.indexAfter(-1), prosemirrorModel.Fragment.from(deflt === null || deflt === void 0 ? void 0 : deflt.create()))) {
-                tr.setNodeMarkup(tr.mapping.map($from.before()), deflt || undefined);
+                && $from.parent.type !== deflt) {
+                const first = tr.mapping.map($from.before());
+                const $first = tr.doc.resolve(first);
+                if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
+                    tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
+                }
             }
         }
         if (keepMarks) {
@@ -1732,20 +1292,42 @@ const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
         }
         if (dispatch) {
             let wrap = prosemirrorModel.Fragment.empty;
-            const keepItem = $from.index(-1) > 0;
+            // eslint-disable-next-line
+            const depthBefore = $from.index(-1)
+                ? 1
+                : $from.index(-2)
+                    ? 2
+                    : 3;
             // Build a fragment containing empty versions of the structure
             // from the outer list item to the parent node of the cursor
-            for (let d = $from.depth - (keepItem ? 1 : 2); d >= $from.depth - 3; d -= 1) {
+            for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
                 wrap = prosemirrorModel.Fragment.from($from.node(d).copy(wrap));
             }
+            // eslint-disable-next-line
+            const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount
+                ? 1
+                : $from.indexAfter(-2) < $from.node(-3).childCount
+                    ? 2
+                    : 3;
             // Add a second list item with an empty default start node
             const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
             const nextType = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes)) || undefined;
             wrap = wrap.append(prosemirrorModel.Fragment.from(type.createAndFill(null, nextType) || undefined));
-            tr
-                .replace($from.before(keepItem ? undefined : -1), $from.after(-3), new prosemirrorModel.Slice(wrap, keepItem ? 3 : 2, 2))
-                .setSelection(prosemirrorState.TextSelection.near(tr.doc.resolve($from.pos + (keepItem ? 3 : 2))))
-                .scrollIntoView();
+            const start = $from.before($from.depth - (depthBefore - 1));
+            tr.replace(start, $from.after(-depthAfter), new prosemirrorModel.Slice(wrap, 4 - depthBefore, 0));
+            let sel = -1;
+            tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
+                if (sel > -1) {
+                    return false;
+                }
+                if (n.isTextblock && n.content.size === 0) {
+                    sel = pos + 1;
+                }
+            });
+            if (sel > -1) {
+                tr.setSelection(prosemirrorState.TextSelection.near(tr.doc.resolve(sel)));
+            }
+            tr.scrollIntoView();
         }
         return true;
     }
@@ -1790,21 +1372,37 @@ function findParentNode(predicate) {
     return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
 }
 
+function splitExtensions(extensions) {
+    const baseExtensions = extensions.filter(extension => extension.type === 'extension');
+    const nodeExtensions = extensions.filter(extension => extension.type === 'node');
+    const markExtensions = extensions.filter(extension => extension.type === 'mark');
+    return {
+        baseExtensions,
+        nodeExtensions,
+        markExtensions,
+    };
+}
+
 function isList(name, extensions) {
     const { nodeExtensions } = splitExtensions(extensions);
-    const extension = nodeExtensions.find(item => item.config.name === name);
+    const extension = nodeExtensions.find(item => item.name === name);
     if (!extension) {
         return false;
     }
-    const groups = callOrReturn(extension.config.group, { options: extension.options });
-    if (typeof groups !== 'string') {
+    const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+    };
+    const group = callOrReturn(getExtensionField(extension, 'group', context));
+    if (typeof group !== 'string') {
         return false;
     }
-    return groups.split(' ').includes('list');
+    return group.split(' ').includes('list');
 }
 
 const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dispatch, chain, commands, can, }) => {
-    const { extensions } = editor.options;
+    const { extensions } = editor.extensionManager;
     const listType = getNodeType(listTypeOrName, state.schema);
     const itemType = getNodeType(itemTypeOrName, state.schema);
     const { selection } = state;
@@ -1843,11 +1441,79 @@ var toggleList$1 = /*#__PURE__*/Object.freeze({
   toggleList: toggleList
 });
 
-const toggleMark = (typeOrName, attributes = {}) => ({ state, commands }) => {
+function isMarkActive(state, typeOrName, attributes = {}) {
+    const { empty, ranges } = state.selection;
+    const type = typeOrName
+        ? getMarkType(typeOrName, state.schema)
+        : null;
+    if (empty) {
+        return !!(state.storedMarks || state.selection.$from.marks())
+            .filter(mark => {
+            if (!type) {
+                return true;
+            }
+            return type.name === mark.type.name;
+        })
+            .find(mark => objectIncludes(mark.attrs, attributes, { strict: false }));
+    }
+    let selectionRange = 0;
+    const markRanges = [];
+    ranges.forEach(({ $from, $to }) => {
+        const from = $from.pos;
+        const to = $to.pos;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+            if (!node.isText && !node.marks.length) {
+                return;
+            }
+            const relativeFrom = Math.max(from, pos);
+            const relativeTo = Math.min(to, pos + node.nodeSize);
+            const range = relativeTo - relativeFrom;
+            selectionRange += range;
+            markRanges.push(...node.marks.map(mark => ({
+                mark,
+                from: relativeFrom,
+                to: relativeTo,
+            })));
+        });
+    });
+    if (selectionRange === 0) {
+        return false;
+    }
+    // calculate range of matched mark
+    const matchedRange = markRanges
+        .filter(markRange => {
+        if (!type) {
+            return true;
+        }
+        return type.name === markRange.mark.type.name;
+    })
+        .filter(markRange => objectIncludes(markRange.mark.attrs, attributes, { strict: false }))
+        .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
+    // calculate range of marks that excludes the searched mark
+    // for example `code` doesn’t allow any other marks
+    const excludedRange = markRanges
+        .filter(markRange => {
+        if (!type) {
+            return true;
+        }
+        return markRange.mark.type !== type
+            && markRange.mark.type.excludes(type);
+    })
+        .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
+    // we only include the result of `excludedRange`
+    // if there is a match at all
+    const range = matchedRange > 0
+        ? matchedRange + excludedRange
+        : matchedRange;
+    return range >= selectionRange;
+}
+
+const toggleMark = (typeOrName, attributes = {}, 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);
 };
@@ -1887,7 +1553,31 @@ var toggleWrap$1 = /*#__PURE__*/Object.freeze({
 });
 
 const undoInputRule = () => ({ state, dispatch }) => {
-    return prosemirrorInputrules.undoInputRule(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({
@@ -1918,27 +1608,31 @@ var unsetAllMarks$1 = /*#__PURE__*/Object.freeze({
   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;
 };
 
@@ -1947,26 +1641,53 @@ var unsetMark$1 = /*#__PURE__*/Object.freeze({
   unsetMark: unsetMark
 });
 
-const updateNodeAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const { selection } = tr;
-    const { ranges } = selection;
-    ranges.forEach(range => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-            if (node.type === type && dispatch) {
-                tr.setNodeMarkup(pos, undefined, {
-                    ...node.attrs,
-                    ...attributes,
-                });
-            }
+const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+    let nodeType = null;
+    let markType = null;
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
+        ? typeOrName
+        : typeOrName.name, state.schema);
+    if (!schemaType) {
+        return false;
+    }
+    if (schemaType === 'node') {
+        nodeType = getNodeType(typeOrName, state.schema);
+    }
+    if (schemaType === 'mark') {
+        markType = getMarkType(typeOrName, state.schema);
+    }
+    if (dispatch) {
+        tr.selection.ranges.forEach(range => {
+            const from = range.$from.pos;
+            const to = range.$to.pos;
+            state.doc.nodesBetween(from, to, (node, pos) => {
+                if (nodeType && nodeType === node.type) {
+                    tr.setNodeMarkup(pos, undefined, {
+                        ...node.attrs,
+                        ...attributes,
+                    });
+                }
+                if (markType && node.marks.length) {
+                    node.marks.forEach(mark => {
+                        if (markType === mark.type) {
+                            const trimmedFrom = Math.max(pos, from);
+                            const trimmedTo = Math.min(pos + node.nodeSize, to);
+                            tr.addMark(trimmedFrom, trimmedTo, markType.create({
+                                ...mark.attrs,
+                                ...attributes,
+                            }));
+                        }
+                    });
+                }
+            });
         });
-    });
+    }
     return true;
 };
 
-var updateNodeAttributes$1 = /*#__PURE__*/Object.freeze({
+var updateAttributes$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  updateNodeAttributes: updateNodeAttributes
+  updateAttributes: updateAttributes
 });
 
 const wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
@@ -2002,6 +1723,7 @@ const Commands = Extension.create({
             ...clearNodes$1,
             ...command$1,
             ...createParagraphNear$1,
+            ...deleteNode$1,
             ...deleteRange$1,
             ...deleteSelection$1,
             ...enter$1,
@@ -2009,9 +1731,9 @@ const Commands = Extension.create({
             ...extendMarkRange$1,
             ...first$1,
             ...focus$1,
-            ...insertHTML$1,
-            ...insertNode$1,
-            ...insertText$1,
+            ...forEach$1,
+            ...insertContent$1,
+            ...insertContentAt$1,
             ...joinBackward$1,
             ...joinForward$1,
             ...keyboardShortcut$1,
@@ -2019,9 +1741,7 @@ const Commands = Extension.create({
             ...liftEmptyBlock$1,
             ...liftListItem$1,
             ...newlineInCode$1,
-            ...replace$1,
-            ...replaceRange$1,
-            ...resetNodeAttributes$1,
+            ...resetAttributes$1,
             ...scrollIntoView$1,
             ...selectAll$1,
             ...selectNodeBackward$1,
@@ -2029,7 +1749,10 @@ const Commands = Extension.create({
             ...selectParentNode$1,
             ...setContent$1,
             ...setMark$1,
+            ...setMeta$1,
             ...setNode$1,
+            ...setNodeSelection$1,
+            ...setTextSelection$1,
             ...sinkListItem$1,
             ...splitBlock$1,
             ...splitListItem$1,
@@ -2040,7 +1763,7 @@ const Commands = Extension.create({
             ...undoInputRule$1,
             ...unsetAllMarks$1,
             ...unsetMark$1,
-            ...updateNodeAttributes$1,
+            ...updateAttributes$1,
             ...wrapIn$1,
             ...wrapInList$1,
         };
@@ -2069,9 +1792,6 @@ const FocusEvents = Extension.create({
             new prosemirrorState.Plugin({
                 key: new prosemirrorState.PluginKey('focusEvents'),
                 props: {
-                    attributes: {
-                        tabindex: '0',
-                    },
                     handleDOMEvents: {
                         focus: (view, event) => {
                             editor.isFocused = true;
@@ -2118,24 +1838,1108 @@ const Keymap = Extension.create({
                 () => commands.splitBlock(),
             ]),
             '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(),
         };
     },
 });
 
-var extensions = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ClipboardTextSerializer: ClipboardTextSerializer,
-  Commands: Commands,
-  Editable: Editable,
-  FocusEvents: FocusEvents,
-  Keymap: Keymap
-});
+const Tabindex = Extension.create({
+    name: 'tabindex',
+    addProseMirrorPlugins() {
+        return [
+            new prosemirrorState.Plugin({
+                key: new prosemirrorState.PluginKey('tabindex'),
+                props: {
+                    attributes: {
+                        tabindex: '0',
+                    },
+                },
+            }),
+        ];
+    },
+});
+
+var extensions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ClipboardTextSerializer: ClipboardTextSerializer,
+  Commands: Commands,
+  Editable: Editable,
+  FocusEvents: FocusEvents,
+  Keymap: Keymap,
+  Tabindex: Tabindex
+});
+
+function getNodeAttributes(state, typeOrName) {
+    const type = getNodeType(typeOrName, state.schema);
+    const { from, to } = state.selection;
+    const nodes = [];
+    state.doc.nodesBetween(from, to, node => {
+        nodes.push(node);
+    });
+    const node = nodes
+        .reverse()
+        .find(nodeItem => nodeItem.type.name === type.name);
+    if (!node) {
+        return {};
+    }
+    return { ...node.attrs };
+}
+
+function getAttributes(state, typeOrName) {
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
+        ? typeOrName
+        : typeOrName.name, state.schema);
+    if (schemaType === 'node') {
+        return getNodeAttributes(state, typeOrName);
+    }
+    if (schemaType === 'mark') {
+        return getMarkAttributes(state, typeOrName);
+    }
+    return {};
+}
+
+function 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 getHTMLFromFragment(fragment, schema) {
+    const documentFragment = prosemirrorModel.DOMSerializer
+        .fromSchema(schema)
+        .serializeFragment(fragment);
+    const temporaryDocument = document.implementation.createHTMLDocument();
+    const container = temporaryDocument.createElement('div');
+    container.appendChild(documentFragment);
+    return container.innerHTML;
+}
+
+function getText(node, options) {
+    const range = {
+        from: 0,
+        to: node.content.size,
+    };
+    return getTextBetween(node, range, options);
+}
+
+function 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;
+}
+
+function createChainableState(config) {
+    const { state, transaction } = config;
+    let { selection } = transaction;
+    let { doc } = transaction;
+    let { storedMarks } = transaction;
+    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 = transaction.selection;
+            doc = transaction.doc;
+            storedMarks = transaction.storedMarks;
+            return transaction;
+        },
+    };
+}
+
+class CommandManager {
+    constructor(props) {
+        this.editor = props.editor;
+        this.rawCommands = this.editor.extensionManager.commands;
+        this.customState = props.state;
+    }
+    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(rawCommands)
+            .map(([name, command]) => {
+            const method = (...args) => {
+                const callback = command(...args)(props);
+                if (!tr.getMeta('preventDispatch') && !this.hasCustomState) {
+                    view.dispatch(tr);
+                }
+                return callback;
+            };
+            return [name, method];
+        }));
+    }
+    get chain() {
+        return () => this.createChain();
+    }
+    get can() {
+        return () => this.createCan();
+    }
+    createChain(startTr, shouldDispatch = true) {
+        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')
+                && !this.hasCustomState) {
+                view.dispatch(tr);
+            }
+            return callbacks.every(callback => callback === true);
+        };
+        const chain = {
+            ...Object.fromEntries(Object.entries(rawCommands).map(([name, command]) => {
+                const chainedCommand = (...args) => {
+                    const props = this.buildProps(tr, shouldDispatch);
+                    const callback = command(...args)(props);
+                    callbacks.push(callback);
+                    return chain;
+                };
+                return [name, chainedCommand];
+            })),
+            run,
+        };
+        return chain;
+    }
+    createCan(startTr) {
+        const { rawCommands, state } = this;
+        const dispatch = undefined;
+        const tr = startTr || state.tr;
+        const props = this.buildProps(tr, dispatch);
+        const formattedCommands = Object.fromEntries(Object
+            .entries(rawCommands)
+            .map(([name, command]) => {
+            return [name, (...args) => command(...args)({ ...props, dispatch })];
+        }));
+        return {
+            ...formattedCommands,
+            chain: () => this.createChain(tr, dispatch),
+        };
+    }
+    buildProps(tr, shouldDispatch = true) {
+        const { rawCommands, editor, state } = this;
+        const { view } = editor;
+        if (state.storedMarks) {
+            tr.setStoredMarks(state.storedMarks);
+        }
+        const props = {
+            tr,
+            editor,
+            view,
+            state: createChainableState({
+                state,
+                transaction: tr,
+            }),
+            dispatch: shouldDispatch
+                ? () => undefined
+                : undefined,
+            chain: () => this.createChain(tr),
+            can: () => this.createCan(tr),
+            get commands() {
+                return Object.fromEntries(Object
+                    .entries(rawCommands)
+                    .map(([name, command]) => {
+                    return [name, (...args) => command(...args)(props)];
+                }));
+            },
+        };
+        return props;
+    }
+}
+
+class InputRule {
+    constructor(config) {
+        this.find = config.find;
+        this.handler = config.handler;
+    }
+}
+const inputRuleMatcherHandler = (text, find) => {
+    if (isRegExp(find)) {
+        return find.exec(text);
+    }
+    const inputRuleMatch = find(text);
+    if (!inputRuleMatch) {
+        return null;
+    }
+    const result = [];
+    result.push(inputRuleMatch.text);
+    result.index = inputRuleMatch.index;
+    result.input = text;
+    result.data = inputRuleMatch.data;
+    if (inputRuleMatch.replaceWith) {
+        if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
+            console.warn('[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".');
+        }
+        result.push(inputRuleMatch.replaceWith);
+    }
+    return result;
+};
+function run$1(config) {
+    var _a;
+    const { editor, from, to, text, rules, plugin, } = config;
+    const { view } = editor;
+    if (view.composing) {
+        return false;
+    }
+    const $from = view.state.doc.resolve(from);
+    if (
+    // check for code node
+    $from.parent.type.spec.code
+        // check for code mark
+        || !!((_a = ($from.nodeBefore || $from.nodeAfter)) === null || _a === void 0 ? void 0 : _a.marks.find(mark => mark.type.spec.code))) {
+        return false;
+    }
+    let matched = false;
+    const maxMatch = 500;
+    const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - maxMatch), $from.parentOffset, undefined, '\ufffc') + 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,
+        });
+        rule.handler({
+            state,
+            range,
+            match,
+            commands,
+            chain,
+            can,
+        });
+        // stop if there are no changes
+        if (!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 prosemirrorState.Plugin({
+        state: {
+            init() {
+                return null;
+            },
+            apply(tr, prev) {
+                const stored = tr.getMeta(this);
+                if (stored) {
+                    return stored;
+                }
+                return tr.selectionSet || tr.docChanged
+                    ? null
+                    : prev;
+            },
+        },
+        props: {
+            handleTextInput(view, from, to, text) {
+                return run$1({
+                    editor,
+                    from,
+                    to,
+                    text,
+                    rules,
+                    plugin,
+                });
+            },
+            handleDOMEvents: {
+                compositionend: view => {
+                    setTimeout(() => {
+                        const { $cursor } = view.state.selection;
+                        if ($cursor) {
+                            run$1({
+                                editor,
+                                from: $cursor.pos,
+                                to: $cursor.pos,
+                                text: '',
+                                rules,
+                                plugin,
+                            });
+                        }
+                    });
+                    return false;
+                },
+            },
+            // add support for input rules to trigger on enter
+            // this is useful for example for code blocks
+            handleKeyDown(view, event) {
+                if (event.key !== 'Enter') {
+                    return false;
+                }
+                const { $cursor } = view.state.selection;
+                if ($cursor) {
+                    return run$1({
+                        editor,
+                        from: $cursor.pos,
+                        to: $cursor.pos,
+                        text: '\n',
+                        rules,
+                        plugin,
+                    });
+                }
+                return false;
+            },
+        },
+        // @ts-ignore
+        isInputRules: true,
+    });
+    return plugin;
+}
+
+function isNumber(value) {
+    return typeof value === 'number';
+}
+
+class PasteRule {
+    constructor(config) {
+        this.find = config.find;
+        this.handler = config.handler;
+    }
+}
+const pasteRuleMatcherHandler = (text, find) => {
+    if (isRegExp(find)) {
+        return [...text.matchAll(find)];
+    }
+    const matches = find(text);
+    if (!matches) {
+        return [];
+    }
+    return matches.map(pasteRuleMatch => {
+        const result = [];
+        result.push(pasteRuleMatch.text);
+        result.index = pasteRuleMatch.index;
+        result.input = text;
+        result.data = pasteRuleMatch.data;
+        if (pasteRuleMatch.replaceWith) {
+            if (!pasteRuleMatch.text.includes(pasteRuleMatch.replaceWith)) {
+                console.warn('[tiptap warn]: "pasteRuleMatch.replaceWith" must be part of "pasteRuleMatch.text".');
+            }
+            result.push(pasteRuleMatch.replaceWith);
+        }
+        return result;
+    });
+};
+function run(config) {
+    const { editor, state, from, to, rules, } = config;
+    const { commands, chain, can } = new CommandManager({
+        editor,
+        state,
+    });
+    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');
+        rules.forEach(rule => {
+            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),
+                };
+                rule.handler({
+                    state,
+                    range,
+                    match,
+                    commands,
+                    chain,
+                    can,
+                });
+            });
+        });
+    });
+}
+/**
+ * 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 isProseMirrorHTML = false;
+    const plugin = new prosemirrorState.Plugin({
+        props: {
+            handlePaste: (view, event) => {
+                var _a;
+                const html = (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text/html');
+                isProseMirrorHTML = !!(html === null || html === void 0 ? void 0 : html.includes('data-pm-slice'));
+                return false;
+            },
+        },
+        appendTransaction: (transactions, oldState, state) => {
+            const transaction = transactions[0];
+            // stop if there is not a paste event
+            if (!transaction.getMeta('paste') || isProseMirrorHTML) {
+                return;
+            }
+            // stop if there is no changed range
+            const { doc, before } = transaction;
+            const from = before.content.findDiffStart(doc.content);
+            const to = before.content.findDiffEnd(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,
+            });
+            run({
+                editor,
+                state: chainableState,
+                from: Math.max(from - 1, 0),
+                to: to.b,
+                rules,
+                plugin,
+            });
+            // stop if there are no changes
+            if (!tr.steps.length) {
+                return;
+            }
+            return tr;
+        },
+        // @ts-ignore
+        isPasteRules: true,
+    });
+    return plugin;
+}
+
+/**
+ * Get a list of all extension attributes defined in `addAttribute` and `addGlobalAttribute`.
+ * @param extensions List of extensions
+ */
+function getAttributesFromExtensions(extensions) {
+    const extensionAttributes = [];
+    const { nodeExtensions, markExtensions } = splitExtensions(extensions);
+    const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions];
+    const defaultAttribute = {
+        default: null,
+        rendered: true,
+        renderHTML: null,
+        parseHTML: null,
+        keepOnSplit: true,
+    };
+    extensions.forEach(extension => {
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        const addGlobalAttributes = getExtensionField(extension, 'addGlobalAttributes', context);
+        if (!addGlobalAttributes) {
+            return;
+        }
+        // TODO: remove `as GlobalAttributes`
+        const globalAttributes = addGlobalAttributes();
+        globalAttributes.forEach(globalAttribute => {
+            globalAttribute.types.forEach(type => {
+                Object
+                    .entries(globalAttribute.attributes)
+                    .forEach(([name, attribute]) => {
+                    extensionAttributes.push({
+                        type,
+                        name,
+                        attribute: {
+                            ...defaultAttribute,
+                            ...attribute,
+                        },
+                    });
+                });
+            });
+        });
+    });
+    nodeAndMarkExtensions.forEach(extension => {
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        const addAttributes = getExtensionField(extension, 'addAttributes', context);
+        if (!addAttributes) {
+            return;
+        }
+        // TODO: remove `as Attributes`
+        const attributes = addAttributes();
+        Object
+            .entries(attributes)
+            .forEach(([name, attribute]) => {
+            extensionAttributes.push({
+                type: extension.name,
+                name,
+                attribute: {
+                    ...defaultAttribute,
+                    ...attribute,
+                },
+            });
+        });
+    });
+    return extensionAttributes;
+}
+
+function mergeAttributes(...objects) {
+    return objects
+        .filter(item => !!item)
+        .reduce((items, item) => {
+        const mergedAttributes = { ...items };
+        Object.entries(item).forEach(([key, value]) => {
+            const exists = mergedAttributes[key];
+            if (!exists) {
+                mergedAttributes[key] = value;
+                return;
+            }
+            if (key === 'class') {
+                mergedAttributes[key] = [mergedAttributes[key], value].join(' ');
+            }
+            else if (key === 'style') {
+                mergedAttributes[key] = [mergedAttributes[key], value].join('; ');
+            }
+            else {
+                mergedAttributes[key] = value;
+            }
+        });
+        return mergedAttributes;
+    }, {});
+}
+
+function getRenderedAttributes(nodeOrMark, extensionAttributes) {
+    return extensionAttributes
+        .filter(item => item.attribute.rendered)
+        .map(item => {
+        if (!item.attribute.renderHTML) {
+            return {
+                [item.name]: nodeOrMark.attrs[item.name],
+            };
+        }
+        return item.attribute.renderHTML(nodeOrMark.attrs) || {};
+    })
+        .reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {});
+}
+
+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+$/)) {
+        return Number(value);
+    }
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    return value;
+}
+
+/**
+ * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
+ * Cancels when `getAttrs` returned `false`.
+ * @param parseRule ProseMirror ParseRule
+ * @param extensionAttributes List of attributes to inject
+ */
+function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
+    if (parseRule.style) {
+        return parseRule;
+    }
+    return {
+        ...parseRule,
+        getAttrs: node => {
+            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 value = item.attribute.parseHTML
+                    ? item.attribute.parseHTML(node)
+                    : fromString(node.getAttribute(item.name));
+                if (isObject(value)) {
+                    console.warn(`[tiptap warn]: BREAKING CHANGE: "parseHTML" for your attribute "${item.name}" returns an object but should return the value itself. If this is expected you can ignore this message. This warning will be removed in one of the next releases. Further information: https://github.com/ueberdosis/tiptap/issues/1863`);
+                }
+                if (value === null || value === undefined) {
+                    return items;
+                }
+                return {
+                    ...items,
+                    [item.name]: value,
+                };
+            }, {});
+            return { ...oldAttributes, ...newAttributes };
+        },
+    };
+}
+
+function cleanUpSchemaItem(data) {
+    return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
+        if (key === 'attrs' && isEmptyObject(value)) {
+            return false;
+        }
+        return value !== null && value !== undefined;
+    }));
+}
+function getSchemaByResolvedExtensions(extensions) {
+    var _a;
+    const allAttributes = getAttributesFromExtensions(extensions);
+    const { nodeExtensions, markExtensions } = splitExtensions(extensions);
+    const topNode = (_a = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))) === null || _a === void 0 ? void 0 : _a.name;
+    const nodes = Object.fromEntries(nodeExtensions.map(extension => {
+        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name);
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        const extraNodeFields = extensions.reduce((fields, e) => {
+            const extendNodeSchema = getExtensionField(e, 'extendNodeSchema', context);
+            return {
+                ...fields,
+                ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
+            };
+        }, {});
+        const schema = cleanUpSchemaItem({
+            ...extraNodeFields,
+            content: callOrReturn(getExtensionField(extension, 'content', context)),
+            marks: callOrReturn(getExtensionField(extension, 'marks', context)),
+            group: callOrReturn(getExtensionField(extension, 'group', context)),
+            inline: callOrReturn(getExtensionField(extension, 'inline', context)),
+            atom: callOrReturn(getExtensionField(extension, 'atom', context)),
+            selectable: callOrReturn(getExtensionField(extension, 'selectable', context)),
+            draggable: callOrReturn(getExtensionField(extension, 'draggable', context)),
+            code: callOrReturn(getExtensionField(extension, 'code', context)),
+            defining: callOrReturn(getExtensionField(extension, 'defining', context)),
+            isolating: callOrReturn(getExtensionField(extension, 'isolating', context)),
+            attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
+                var _a;
+                return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
+            })),
+        });
+        const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
+        if (parseHTML) {
+            schema.parseDOM = parseHTML
+                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+        }
+        const renderHTML = getExtensionField(extension, 'renderHTML', context);
+        if (renderHTML) {
+            schema.toDOM = node => renderHTML({
+                node,
+                HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+            });
+        }
+        const renderText = getExtensionField(extension, 'renderText', context);
+        if (renderText) {
+            schema.toText = renderText;
+        }
+        return [extension.name, schema];
+    }));
+    const marks = Object.fromEntries(markExtensions.map(extension => {
+        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name);
+        const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+        };
+        const extraMarkFields = extensions.reduce((fields, e) => {
+            const extendMarkSchema = getExtensionField(e, 'extendMarkSchema', context);
+            return {
+                ...fields,
+                ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
+            };
+        }, {});
+        const schema = cleanUpSchemaItem({
+            ...extraMarkFields,
+            inclusive: callOrReturn(getExtensionField(extension, 'inclusive', context)),
+            excludes: callOrReturn(getExtensionField(extension, 'excludes', context)),
+            group: callOrReturn(getExtensionField(extension, 'group', context)),
+            spanning: callOrReturn(getExtensionField(extension, 'spanning', context)),
+            code: callOrReturn(getExtensionField(extension, 'code', context)),
+            attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
+                var _a;
+                return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
+            })),
+        });
+        const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
+        if (parseHTML) {
+            schema.parseDOM = parseHTML
+                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+        }
+        const renderHTML = getExtensionField(extension, 'renderHTML', context);
+        if (renderHTML) {
+            schema.toDOM = mark => renderHTML({
+                mark,
+                HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+            });
+        }
+        return [extension.name, schema];
+    }));
+    return new prosemirrorModel.Schema({
+        topNode,
+        nodes,
+        marks,
+    });
+}
+
+function getSchemaTypeByName(name, schema) {
+    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;
+        });
+    }
+    return enabled;
+}
+
+function findDuplicates(items) {
+    const filtered = items.filter((el, index) => items.indexOf(el) !== index);
+    return [...new Set(filtered)];
+}
+
+class ExtensionManager {
+    constructor(extensions, editor) {
+        this.splittableMarks = [];
+        this.editor = editor;
+        this.extensions = ExtensionManager.resolve(extensions);
+        this.schema = getSchemaByResolvedExtensions(this.extensions);
+        this.extensions.forEach(extension => {
+            var _a;
+            // store extension storage in editor
+            this.editor.extensionStorage[extension.name] = extension.storage;
+            const context = {
+                name: extension.name,
+                options: extension.options,
+                storage: extension.storage,
+                editor: this.editor,
+                type: getSchemaTypeByName(extension.name, this.schema),
+            };
+            if (extension.type === 'mark') {
+                const keepOnSplit = (_a = callOrReturn(getExtensionField(extension, 'keepOnSplit', context))) !== null && _a !== void 0 ? _a : true;
+                if (keepOnSplit) {
+                    this.splittableMarks.push(extension.name);
+                }
+            }
+            const onBeforeCreate = getExtensionField(extension, 'onBeforeCreate', context);
+            if (onBeforeCreate) {
+                this.editor.on('beforeCreate', onBeforeCreate);
+            }
+            const onCreate = getExtensionField(extension, 'onCreate', context);
+            if (onCreate) {
+                this.editor.on('create', onCreate);
+            }
+            const onUpdate = getExtensionField(extension, 'onUpdate', context);
+            if (onUpdate) {
+                this.editor.on('update', onUpdate);
+            }
+            const onSelectionUpdate = getExtensionField(extension, 'onSelectionUpdate', context);
+            if (onSelectionUpdate) {
+                this.editor.on('selectionUpdate', onSelectionUpdate);
+            }
+            const onTransaction = getExtensionField(extension, 'onTransaction', context);
+            if (onTransaction) {
+                this.editor.on('transaction', onTransaction);
+            }
+            const onFocus = getExtensionField(extension, 'onFocus', context);
+            if (onFocus) {
+                this.editor.on('focus', onFocus);
+            }
+            const onBlur = getExtensionField(extension, 'onBlur', context);
+            if (onBlur) {
+                this.editor.on('blur', onBlur);
+            }
+            const onDestroy = getExtensionField(extension, 'onDestroy', context);
+            if (onDestroy) {
+                this.editor.on('destroy', onDestroy);
+            }
+        });
+    }
+    static resolve(extensions) {
+        const resolvedExtensions = ExtensionManager.sort(ExtensionManager.flatten(extensions));
+        const duplicatedNames = findDuplicates(resolvedExtensions.map(extension => extension.name));
+        if (duplicatedNames.length) {
+            console.warn(`[tiptap warn]: Duplicate extension names found: [${duplicatedNames.map(item => `'${item}'`).join(', ')}]. This can lead to issues.`);
+        }
+        return resolvedExtensions;
+    }
+    static flatten(extensions) {
+        return extensions
+            .map(extension => {
+            const context = {
+                name: extension.name,
+                options: extension.options,
+                storage: extension.storage,
+            };
+            const addExtensions = getExtensionField(extension, 'addExtensions', context);
+            if (addExtensions) {
+                return [
+                    extension,
+                    ...this.flatten(addExtensions()),
+                ];
+            }
+            return extension;
+        })
+            // `Infinity` will break TypeScript so we set a number that is probably high enough
+            .flat(10);
+    }
+    static sort(extensions) {
+        const defaultPriority = 100;
+        return extensions.sort((a, b) => {
+            const priorityA = getExtensionField(a, 'priority') || defaultPriority;
+            const priorityB = getExtensionField(b, 'priority') || defaultPriority;
+            if (priorityA > priorityB) {
+                return -1;
+            }
+            if (priorityA < priorityB) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    get commands() {
+        return this.extensions.reduce((commands, extension) => {
+            const context = {
+                name: extension.name,
+                options: extension.options,
+                storage: extension.storage,
+                editor: this.editor,
+                type: getSchemaTypeByName(extension.name, this.schema),
+            };
+            const addCommands = getExtensionField(extension, 'addCommands', context);
+            if (!addCommands) {
+                return commands;
+            }
+            return {
+                ...commands,
+                ...addCommands(),
+            };
+        }, {});
+    }
+    get plugins() {
+        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,
+                storage: extension.storage,
+                editor,
+                type: getSchemaTypeByName(extension.name, this.schema),
+            };
+            const plugins = [];
+            const addKeyboardShortcuts = getExtensionField(extension, 'addKeyboardShortcuts', context);
+            if (addKeyboardShortcuts) {
+                const bindings = Object.fromEntries(Object
+                    .entries(addKeyboardShortcuts())
+                    .map(([shortcut, method]) => {
+                    return [shortcut, () => method({ editor })];
+                }));
+                const keyMapPlugin = prosemirrorKeymap.keymap(bindings);
+                plugins.push(keyMapPlugin);
+            }
+            const addInputRules = getExtensionField(extension, 'addInputRules', context);
+            if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
+                inputRules.push(...addInputRules());
+            }
+            const addPasteRules = getExtensionField(extension, 'addPasteRules', context);
+            if (isExtensionRulesEnabled(extension, editor.options.enablePasteRules) && addPasteRules) {
+                pasteRules.push(...addPasteRules());
+            }
+            const addProseMirrorPlugins = getExtensionField(extension, 'addProseMirrorPlugins', context);
+            if (addProseMirrorPlugins) {
+                const proseMirrorPlugins = addProseMirrorPlugins();
+                plugins.push(...proseMirrorPlugins);
+            }
+            return plugins;
+        })
+            .flat();
+        return [
+            inputRulesPlugin({
+                editor,
+                rules: inputRules,
+            }),
+            pasteRulesPlugin({
+                editor,
+                rules: pasteRules,
+            }),
+            ...allPlugins,
+        ];
+    }
+    get attributes() {
+        return getAttributesFromExtensions(this.extensions);
+    }
+    get nodeViews() {
+        const { editor } = this;
+        const { nodeExtensions } = splitExtensions(this.extensions);
+        return Object.fromEntries(nodeExtensions
+            .filter(extension => !!getExtensionField(extension, 'addNodeView'))
+            .map(extension => {
+            const extensionAttributes = this.attributes.filter(attribute => attribute.type === extension.name);
+            const context = {
+                name: extension.name,
+                options: extension.options,
+                storage: extension.storage,
+                editor,
+                type: getNodeType(extension.name, this.schema),
+            };
+            const addNodeView = getExtensionField(extension, 'addNodeView', context);
+            if (!addNodeView) {
+                return [];
+            }
+            const nodeview = (node, view, getPos, decorations) => {
+                const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
+                return addNodeView()({
+                    editor,
+                    node,
+                    getPos,
+                    decorations,
+                    HTMLAttributes,
+                    extension,
+                });
+            };
+            return [extension.name, nodeview];
+        }));
+    }
+}
+
+class EventEmitter {
+    constructor() {
+        this.callbacks = {};
+    }
+    on(event, fn) {
+        if (!this.callbacks[event]) {
+            this.callbacks[event] = [];
+        }
+        this.callbacks[event].push(fn);
+        return this;
+    }
+    emit(event, ...args) {
+        const callbacks = this.callbacks[event];
+        if (callbacks) {
+            callbacks.forEach(callback => callback.apply(this, args));
+        }
+        return this;
+    }
+    off(event, fn) {
+        const callbacks = this.callbacks[event];
+        if (callbacks) {
+            if (fn) {
+                this.callbacks[event] = callbacks.filter(callback => callback !== fn);
+            }
+            else {
+                delete this.callbacks[event];
+            }
+        }
+        return this;
+    }
+    removeAllListeners() {
+        this.callbacks = {};
+    }
+}
 
 const style = `.ProseMirror {
   position: relative;
@@ -2144,8 +2948,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"] {
@@ -2160,6 +2966,14 @@ 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;
@@ -2196,12 +3010,17 @@ const style = `.ProseMirror {
 
 .ProseMirror-focused .ProseMirror-gapcursor {
   display: block;
+}
+
+.tippy-box[data-animation=fade][data-state=hidden] {
+  opacity: 0
 }`;
 
 class Editor extends EventEmitter {
     constructor(options = {}) {
         super();
         this.isFocused = false;
+        this.extensionStorage = {};
         this.options = {
             element: document.createElement('div'),
             content: '',
@@ -2213,80 +3032,64 @@ class Editor extends EventEmitter {
             parseOptions: {},
             enableInputRules: true,
             enablePasteRules: true,
+            enableCoreExtensions: true,
+            onBeforeCreate: () => null,
             onCreate: () => null,
             onUpdate: () => null,
             onSelectionUpdate: () => null,
-            onViewUpdate: () => null,
             onTransaction: () => null,
             onFocus: () => null,
             onBlur: () => null,
-            onResize: () => null,
             onDestroy: () => null,
         };
-        /**
-         * Creates a ProseMirror document.
-         */
-        this.createDocument = (content, parseOptions = this.options.parseOptions) => {
-            if (content && typeof content === 'object') {
-                try {
-                    return this.schema.nodeFromJSON(content);
-                }
-                catch (error) {
-                    console.warn('[tiptap warn]: Invalid content.', 'Passed value:', content, 'Error:', error);
-                    return this.createDocument('');
-                }
-            }
-            if (typeof content === 'string') {
-                return prosemirrorModel.DOMParser
-                    .fromSchema(this.schema)
-                    .parse(elementFromString(content), parseOptions);
-            }
-            return this.createDocument('');
-        };
         this.isCapturingTransaction = false;
         this.capturedTransaction = null;
         this.setOptions(options);
         this.createExtensionManager();
         this.createCommandManager();
         this.createSchema();
+        this.on('beforeCreate', this.options.onBeforeCreate);
+        this.emit('beforeCreate', { editor: this });
         this.createView();
         this.injectCSS();
         this.on('create', this.options.onCreate);
         this.on('update', this.options.onUpdate);
         this.on('selectionUpdate', this.options.onSelectionUpdate);
-        this.on('viewUpdate', this.options.onViewUpdate);
         this.on('transaction', this.options.onTransaction);
         this.on('focus', this.options.onFocus);
         this.on('blur', this.options.onBlur);
         this.on('destroy', this.options.onDestroy);
         window.setTimeout(() => {
+            if (this.isDestroyed) {
+                return;
+            }
             this.commands.focus(this.options.autofocus);
             this.emit('create', { editor: this });
-            if (window.ResizeObserver) {
-                this.resizeObserver = new ResizeObserver(() => {
-                    this.emit('resize', { editor: this });
-                });
-                this.resizeObserver.observe(this.view.dom);
-            }
         }, 0);
     }
+    /**
+     * Returns the editor storage.
+     */
+    get storage() {
+        return this.extensionStorage;
+    }
     /**
      * An object of all registered commands.
      */
     get commands() {
-        return this.commandManager.createCommands();
+        return this.commandManager.commands;
     }
     /**
      * Create a command chain to call multiple commands at once.
      */
     chain() {
-        return this.commandManager.createChain();
+        return this.commandManager.chain();
     }
     /**
      * Check if a command or a command chain can be executed. Without executing it.
      */
     can() {
-        return this.commandManager.createCan();
+        return this.commandManager.can();
     }
     /**
      * Inject CSS styles.
@@ -2302,22 +3105,34 @@ class Editor extends EventEmitter {
      * @param options A list of options
      */
     setOptions(options = {}) {
-        this.options = { ...this.options, ...options };
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+        if (!this.view || !this.state || this.isDestroyed) {
+            return;
+        }
+        if (this.options.editorProps) {
+            this.view.setProps(this.options.editorProps);
+        }
+        this.view.updateState(this.state);
     }
     /**
      * Update editable state of the editor.
      */
     setEditable(editable) {
         this.setOptions({ editable });
-        if (this.view && this.state && !this.isDestroyed) {
-            this.view.updateState(this.state);
-        }
     }
     /**
      * Returns whether the editor is editable.
      */
     get isEditable() {
-        return this.view && this.view.editable;
+        // since plugins are applied after creating the view
+        // `editable` is always `true` for one tick.
+        // that’s why we also have to check for `options.editable`
+        return this.options.editable
+            && this.view
+            && this.view.editable;
     }
     /**
      * Returns the editor state.
@@ -2332,7 +3147,7 @@ class Editor extends EventEmitter {
      * @param handlePlugins Control how to merge the plugin into the existing plugins.
      */
     registerPlugin(plugin, handlePlugins) {
-        const plugins = typeof handlePlugins === 'function'
+        const plugins = isObject$1(handlePlugins)
             ? handlePlugins(plugin, this.state.plugins)
             : [...this.state.plugins, plugin];
         const state = this.state.reconfigure({ plugins });
@@ -2341,7 +3156,7 @@ class Editor extends EventEmitter {
     /**
      * Unregister a ProseMirror plugin.
      *
-     * @param name The plugins name
+     * @param nameOrPluginKey The plugins name
      */
     unregisterPlugin(nameOrPluginKey) {
         if (this.isDestroyed) {
@@ -2361,7 +3176,9 @@ class Editor extends EventEmitter {
      * Creates an extension manager.
      */
     createExtensionManager() {
-        const coreExtensions = Object.entries(extensions).map(([, extension]) => extension);
+        const coreExtensions = this.options.enableCoreExtensions
+            ? Object.values(extensions)
+            : [];
         const allExtensions = [...coreExtensions, ...this.options.extensions].filter(extension => {
             return ['extension', 'node', 'mark'].includes(extension === null || extension === void 0 ? void 0 : extension.type);
         });
@@ -2371,7 +3188,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.
@@ -2387,22 +3206,13 @@ class Editor extends EventEmitter {
             ...this.options.editorProps,
             dispatchTransaction: this.dispatchTransaction.bind(this),
             state: prosemirrorState.EditorState.create({
-                doc: this.createDocument(this.options.content),
+                doc: createDocument(this.options.content, this.schema, this.options.parseOptions),
             }),
         });
         // `editor.view` is not yet available at this time.
         // Therefore we will add all plugins and node views directly afterwards.
         const newState = this.state.reconfigure({
-            plugins: [
-                new prosemirrorState.Plugin({
-                    view: () => ({
-                        update: () => this.emit('viewUpdate', {
-                            editor: this,
-                        }),
-                    }),
-                }),
-                ...this.extensionManager.plugins,
-            ],
+            plugins: this.extensionManager.plugins,
         });
         this.view.updateState(newState);
         this.createNodeViews();
@@ -2433,9 +3243,6 @@ class Editor extends EventEmitter {
      * @param transaction An editor state transaction
      */
     dispatchTransaction(transaction) {
-        if (transaction.docChanged && !this.isEditable) {
-            return;
-        }
         if (this.isCapturingTransaction) {
             if (!this.capturedTransaction) {
                 this.capturedTransaction = transaction;
@@ -2454,6 +3261,7 @@ class Editor extends EventEmitter {
         if (selectionHasChanged) {
             this.emit('selectionUpdate', {
                 editor: this,
+                transaction,
             });
         }
         const focus = transaction.getMeta('focus');
@@ -2462,12 +3270,14 @@ class Editor extends EventEmitter {
             this.emit('focus', {
                 editor: this,
                 event: focus.event,
+                transaction,
             });
         }
         if (blur) {
             this.emit('blur', {
                 editor: this,
                 event: blur.event,
+                transaction,
             });
         }
         if (!transaction.docChanged || transaction.getMeta('preventUpdate')) {
@@ -2479,20 +3289,10 @@ class Editor extends EventEmitter {
         });
     }
     /**
-     * Get attributes of the currently selected node.
-     *
-     * @param name Name of the node
-     */
-    getNodeAttributes(name) {
-        return getNodeAttributes(this.state, name);
-    }
-    /**
-     * Get attributes of the currently selected mark.
-     *
-     * @param name Name of the mark
+     * Get attributes of the currently selected node or mark.
      */
-    getMarkAttributes(name) {
-        return getMarkAttributes(this.state, name);
+    getAttributes(nameOrType) {
+        return getAttributes(this.state, nameOrType);
     }
     isActive(nameOrAttributes, attributesOrUndefined) {
         const name = typeof nameOrAttributes === 'string'
@@ -2513,7 +3313,20 @@ class Editor extends EventEmitter {
      * Get the document as HTML.
      */
     getHTML() {
-        return getHTMLFromFragment(this.state.doc, this.schema);
+        return getHTMLFromFragment(this.state.doc.content, this.schema);
+    }
+    /**
+     * Get the document as text.
+     */
+    getText(options) {
+        const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
+        return getText(this.state.doc, {
+            blockSeparator,
+            textSerializers: {
+                ...textSerializers,
+                ...getTextSeralizersFromSchema(this.schema),
+            },
+        });
     }
     /**
      * Check if there is no content.
@@ -2531,14 +3344,11 @@ class Editor extends EventEmitter {
      * Destroy the editor.
      */
     destroy() {
-        var _a;
-        (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.unobserve(this.view.dom);
         this.emit('destroy');
         if (this.view) {
             this.view.destroy();
         }
         this.removeAllListeners();
-        removeElement(this.css);
     }
     /**
      * Check if the editor is already destroyed.
@@ -2550,86 +3360,158 @@ class Editor extends EventEmitter {
     }
 }
 
-var _configure$1;
 class Node {
-    constructor(config) {
+    constructor(config = {}) {
         this.type = 'node';
+        this.name = 'node';
+        this.parent = null;
+        this.child = null;
         this.config = {
-            name: 'node',
+            name: this.name,
             defaultOptions: {},
         };
-        _configure$1.set(this, (options) => {
-            this.options = mergeDeep(this.config.defaultOptions, options);
-            return this;
-        });
         this.config = {
             ...this.config,
             ...config,
         };
+        this.name = this.config.name;
+        if (config.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
+        }
+        // TODO: remove `addOptions` fallback
         this.options = this.config.defaultOptions;
+        if (this.config.addOptions) {
+            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
+                name: this.name,
+            }));
+        }
+        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
+            name: this.name,
+            options: this.options,
+        })) || {};
     }
-    static create(config) {
+    static create(config = {}) {
         return new Node(config);
     }
     configure(options = {}) {
-        var _a;
-        return __classPrivateFieldGet((_a = Node
-            .create(this.config)), _configure$1).call(_a, options);
-    }
-    extend(extendedConfig) {
-        return new Node({
-            ...this.config,
-            ...extendedConfig,
-        });
+        // return a new instance so we can use the same extension
+        // with different calls of `configure`
+        const extension = this.extend();
+        extension.options = mergeDeep(this.options, options);
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
+    }
+    extend(extendedConfig = {}) {
+        const extension = new Node(extendedConfig);
+        extension.parent = this;
+        this.child = extension;
+        extension.name = extendedConfig.name
+            ? extendedConfig.name
+            : extension.parent.name;
+        if (extendedConfig.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
+        }
+        // TODO: remove `addOptions` fallback
+        extension.options = extendedConfig.defaultOptions
+            ? extendedConfig.defaultOptions
+            : extension.parent.options;
+        if (extendedConfig.addOptions) {
+            extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
+                name: extension.name,
+            }));
+        }
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
     }
-}
-_configure$1 = new WeakMap();
+}
 
-var _configure;
 class Mark {
-    constructor(config) {
+    constructor(config = {}) {
         this.type = 'mark';
+        this.name = 'mark';
+        this.parent = null;
+        this.child = null;
         this.config = {
-            name: 'mark',
+            name: this.name,
             defaultOptions: {},
         };
-        _configure.set(this, (options) => {
-            this.options = mergeDeep(this.config.defaultOptions, options);
-            return this;
-        });
         this.config = {
             ...this.config,
             ...config,
         };
+        this.name = this.config.name;
+        if (config.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
+        }
+        // TODO: remove `addOptions` fallback
         this.options = this.config.defaultOptions;
+        if (this.config.addOptions) {
+            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
+                name: this.name,
+            }));
+        }
+        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
+            name: this.name,
+            options: this.options,
+        })) || {};
     }
-    static create(config) {
+    static create(config = {}) {
         return new Mark(config);
     }
     configure(options = {}) {
-        var _a;
-        return __classPrivateFieldGet((_a = Mark
-            .create(this.config)), _configure).call(_a, options);
-    }
-    extend(extendedConfig) {
-        return new Mark({
-            ...this.config,
-            ...extendedConfig,
-        });
+        // return a new instance so we can use the same extension
+        // with different calls of `configure`
+        const extension = this.extend();
+        extension.options = mergeDeep(this.options, options);
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
+    }
+    extend(extendedConfig = {}) {
+        const extension = new Mark(extendedConfig);
+        extension.parent = this;
+        this.child = extension;
+        extension.name = extendedConfig.name
+            ? extendedConfig.name
+            : extension.parent.name;
+        if (extendedConfig.defaultOptions) {
+            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
+        }
+        // TODO: remove `addOptions` fallback
+        extension.options = extendedConfig.defaultOptions
+            ? extendedConfig.defaultOptions
+            : extension.parent.options;
+        if (extendedConfig.addOptions) {
+            extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
+                name: extension.name,
+            }));
+        }
+        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
+            name: extension.name,
+            options: extension.options,
+        }));
+        return extension;
     }
-}
-_configure = new WeakMap();
+}
 
 class NodeView {
     constructor(component, props, options) {
         this.isDragging = false;
+        this.component = component;
+        this.editor = props.editor;
         this.options = {
             stopEvent: null,
-            update: null,
+            ignoreMutation: null,
+            ...options,
         };
-        this.component = component;
-        this.options = { ...this.options, ...options };
-        this.editor = props.editor;
         this.extension = props.extension;
         this.node = props.node;
         this.decorations = props.decorations;
@@ -2647,17 +3529,31 @@ class NodeView {
         return null;
     }
     onDragStart(event) {
-        var _a, _b;
-        if (!this.dom) {
-            return;
-        }
+        var _a, _b, _c;
         const { view } = this.editor;
         const target = event.target;
-        if ((_a = this.contentDOM) === null || _a === void 0 ? void 0 : _a.contains(target)) {
+        // get the drag handle element
+        // `closest` is not available for text nodes so we may have to use its parent
+        const dragHandle = target.nodeType === 3
+            ? (_a = target.parentElement) === null || _a === void 0 ? void 0 : _a.closest('[data-drag-handle]')
+            : target.closest('[data-drag-handle]');
+        if (!this.dom
+            || ((_b = this.contentDOM) === null || _b === void 0 ? void 0 : _b.contains(target))
+            || !dragHandle) {
             return;
         }
-        // sometimes `event.target` is not the `dom` element
-        (_b = event.dataTransfer) === null || _b === void 0 ? void 0 : _b.setDragImage(this.dom, 0, 0);
+        let x = 0;
+        let y = 0;
+        // calculate offset for drag element if we use a different drag handle element
+        if (this.dom !== dragHandle) {
+            const domBox = this.dom.getBoundingClientRect();
+            const handleBox = dragHandle.getBoundingClientRect();
+            x = handleBox.x - domBox.x + event.offsetX;
+            y = handleBox.y - domBox.y + event.offsetY;
+        }
+        (_c = event.dataTransfer) === null || _c === void 0 ? void 0 : _c.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 = prosemirrorState.NodeSelection.create(view.state.doc, this.getPos());
         const transaction = view.state.tr.setSelection(selection);
         view.dispatch(transaction);
@@ -2668,7 +3564,7 @@ class NodeView {
             return false;
         }
         if (typeof this.options.stopEvent === 'function') {
-            return this.options.stopEvent(event);
+            return this.options.stopEvent({ event });
         }
         const target = event.target;
         const isInElement = this.dom.contains(target) && !((_a = this.contentDOM) === null || _a === void 0 ? void 0 : _a.contains(target));
@@ -2676,10 +3572,11 @@ class NodeView {
         if (!isInElement) {
             return false;
         }
+        const isDropEvent = event.type === 'drop';
         const isInput = ['INPUT', 'BUTTON', 'SELECT', 'TEXTAREA'].includes(target.tagName)
             || target.isContentEditable;
         // any input event within node views should be ignored by ProseMirror
-        if (isInput) {
+        if (isInput && !isDropEvent) {
             return true;
         }
         const { isEditable } = this.editor;
@@ -2690,7 +3587,7 @@ class NodeView {
         const isPasteEvent = event.type === 'paste';
         const isCutEvent = event.type === 'cut';
         const isClickEvent = event.type === 'mousedown';
-        const isDragEvent = event.type.startsWith('drag') || event.type === 'drop';
+        const isDragEvent = event.type.startsWith('drag');
         // ProseMirror tries to drag selectable nodes
         // even if `draggable` is set to `false`
         // this fix prevents that
@@ -2718,6 +3615,7 @@ class NodeView {
         }
         // these events are handled by prosemirror
         if (isDragging
+            || isDropEvent
             || isCopyEvent
             || isPasteEvent
             || isCutEvent
@@ -2727,170 +3625,510 @@ class NodeView {
         return true;
     }
     ignoreMutation(mutation) {
+        if (!this.dom || !this.contentDOM) {
+            return true;
+        }
+        if (typeof this.options.ignoreMutation === 'function') {
+            return this.options.ignoreMutation({ mutation });
+        }
+        // a leaf/atom node is like a black box for ProseMirror
+        // and should be fully handled by the node view
+        if (this.node.isLeaf || this.node.isAtom) {
+            return true;
+        }
+        // ProseMirror should handle any selections
         if (mutation.type === 'selection') {
-            if (this.node.isLeaf) {
-                return true;
-            }
             return false;
         }
-        if (!this.contentDOM) {
+        // try to prevent a bug on iOS that will break node views on enter
+        // this is because ProseMirror can’t preventDispatch on enter
+        // this will lead to a re-render of the node view on enter
+        // see: https://github.com/ueberdosis/tiptap/issues/1214
+        if (this.dom.contains(mutation.target)
+            && mutation.type === 'childList'
+            && isiOS()
+            && this.editor.isFocused) {
+            const changedNodes = [
+                ...Array.from(mutation.addedNodes),
+                ...Array.from(mutation.removedNodes),
+            ];
+            // we’ll check if every changed node is contentEditable
+            // to make sure it’s probably mutated by ProseMirror
+            if (changedNodes.every(node => node.isContentEditable)) {
+                return false;
+            }
+        }
+        // we will allow mutation contentDOM with attributes
+        // so we can for example adding classes within our node view
+        if (this.contentDOM === mutation.target && mutation.type === 'attributes') {
             return true;
         }
-        const contentDOMHasChanged = !this.contentDOM.contains(mutation.target)
-            || this.contentDOM === mutation.target;
-        return contentDOMHasChanged;
+        // ProseMirror should handle any changes within contentDOM
+        if (this.contentDOM.contains(mutation.target)) {
+            return false;
+        }
+        return true;
     }
     updateAttributes(attributes) {
-        if (!this.editor.view.editable) {
-            return;
-        }
-        const { state } = this.editor.view;
-        const pos = this.getPos();
-        const transaction = state.tr.setNodeMarkup(pos, undefined, {
-            ...this.node.attrs,
-            ...attributes,
+        this.editor.commands.command(({ tr }) => {
+            const pos = this.getPos();
+            tr.setNodeMarkup(pos, undefined, {
+                ...this.node.attrs,
+                ...attributes,
+            });
+            return true;
         });
-        this.editor.view.dispatch(transaction);
+    }
+    deleteNode() {
+        const from = this.getPos();
+        const to = from + this.node.nodeSize;
+        this.editor.commands.deleteRange({ from, to });
     }
 }
 
-function nodeInputRule (regexp, type, getAttributes) {
-    return new prosemirrorInputrules.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;
+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,
+        };
+    }
+}
+
+/**
+ * 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));
+            }
+        },
     });
 }
 
 function getMarksBetween(from, to, state) {
-    let marks = [];
+    const marks = [];
     state.doc.nodesBetween(from, to, (node, pos) => {
-        marks = [...marks, ...node.marks.map(mark => ({
-                from: pos,
-                to: pos + node.nodeSize,
-                mark,
-            }))];
+        marks.push(...node.marks.map(mark => ({
+            from: pos,
+            to: pos + node.nodeSize,
+            mark,
+        })));
     });
     return marks;
 }
 
-function markInputRule (regexp, markType, getAttributes) {
-    return new prosemirrorInputrules.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 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;
+            }
+            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)
+                    .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 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;
             }
-            if (textEnd < end) {
-                tr.delete(textEnd, end);
+            state.tr
+                .delete(range.from, range.to)
+                .setBlockType(range.from, range.from, config.type, attributes);
+        },
+    });
+}
+
+/**
+ * Build an input rule that replaces text when the
+ * matched text is typed into it.
+ */
+function textInputRule(config) {
+    return new InputRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            let insert = config.replace;
+            let start = range.from;
+            const end = range.to;
+            if (match[1]) {
+                const offset = match[0].lastIndexOf(match[1]);
+                insert += match[0].slice(offset + match[1].length);
+                start += offset;
+                const cutOff = start - end;
+                if (cutOff > 0) {
+                    insert = match[0].slice(offset - cutOff, offset) + insert;
+                    start = end;
+                }
+            }
+            state.tr.insertText(insert, start, end);
+        },
+    });
+}
+
+/**
+ * Build an input rule for automatically wrapping a textblock when a
+ * given string is typed. When using a regular expresion you’ll
+ * probably want the regexp to start with `^`, so that the pattern can
+ * only occur at the start of a textblock.
+ *
+ * `type` is the type of node to wrap in.
+ *
+ * By default, if there’s a node with the same type above the newly
+ * wrapped node, the rule will try to join those
+ * two nodes. You can pass a join predicate, which takes a regular
+ * expression match and the node before the wrapped node, and can
+ * return a boolean to indicate whether a join should happen.
+ */
+function wrappingInputRule(config) {
+    return new InputRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            const attributes = callOrReturn(config.getAttributes, undefined, match) || {};
+            const tr = state.tr.delete(range.from, range.to);
+            const $start = tr.doc.resolve(range.from);
+            const blockRange = $start.blockRange();
+            const wrapping = blockRange && prosemirrorTransform.findWrapping(blockRange, config.type, attributes);
+            if (!wrapping) {
+                return null;
             }
-            if (textStart > start) {
-                tr.delete(start + startSpaces, textStart);
+            tr.wrap(blockRange, wrapping);
+            const before = tr.doc.resolve(range.from - 1).nodeBefore;
+            if (before
+                && before.type === config.type
+                && prosemirrorTransform.canJoin(tr.doc, range.from - 1)
+                && (!config.joinPredicate || config.joinPredicate(match, before))) {
+                tr.join(range.from - 1);
             }
-            markEnd = start + startSpaces + captureGroup.length;
-            tr.addMark(start + startSpaces, markEnd, markType.create(attributes));
-            tr.removeStoredMark(markType);
-        }
-        return tr;
+        },
     });
 }
 
-function markPasteRule (regexp, type, getAttrs) {
-    const handler = (fragment, parent) => {
-        const nodes = [];
-        fragment.forEach(child => {
-            if (child.isText && child.text) {
-                const { text } = child;
-                let pos = 0;
-                let match;
-                // eslint-disable-next-line
-                while ((match = regexp.exec(text)) !== null) {
-                    const outerMatch = Math.max(match.length - 2, 0);
-                    const innerMatch = Math.max(match.length - 1, 0);
-                    if (parent === null || parent === void 0 ? void 0 : parent.type.allowsMarkType(type)) {
-                        const start = match.index;
-                        const matchStart = start + match[0].indexOf(match[outerMatch]);
-                        const matchEnd = matchStart + match[outerMatch].length;
-                        const textStart = matchStart + match[outerMatch].lastIndexOf(match[innerMatch]);
-                        const textEnd = textStart + match[innerMatch].length;
-                        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
-                        // adding text before markdown to nodes
-                        if (matchStart > 0) {
-                            nodes.push(child.cut(pos, matchStart));
-                        }
-                        // adding the markdown part to nodes
-                        nodes.push(child
-                            .cut(textStart, textEnd)
-                            .mark(type.create(attrs).addToSet(child.marks)));
-                        pos = matchEnd;
-                    }
+/**
+ * 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;
+            }
+            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)
+                    .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);
                 }
-                // adding rest of text to nodes
-                if (pos < text.length) {
-                    nodes.push(child.cut(pos));
+                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)));
+        },
+    });
+}
+
+/**
+ * Build an paste rule that replaces text when the
+ * matched text is pasted into it.
+ */
+function textPasteRule(config) {
+    return new PasteRule({
+        find: config.find,
+        handler: ({ state, range, match }) => {
+            let insert = config.replace;
+            let start = range.from;
+            const end = range.to;
+            if (match[1]) {
+                const offset = match[0].lastIndexOf(match[1]);
+                insert += match[0].slice(offset + match[1].length);
+                start += offset;
+                const cutOff = start - end;
+                if (cutOff > 0) {
+                    insert = match[0].slice(offset - cutOff, offset) + insert;
+                    start = end;
+                }
             }
-        });
-        return prosemirrorModel.Fragment.fromArray(nodes);
-    };
-    return new prosemirrorState.Plugin({
-        key: new prosemirrorState.PluginKey('markPasteRule'),
-        props: {
-            transformPasted: slice => {
-                return new prosemirrorModel.Slice(handler(slice.content), slice.openStart, slice.openEnd);
-            },
+            state.tr.insertText(insert, start, end);
         },
     });
 }
 
+function findChildren(node, predicate) {
+    const nodesWithPos = [];
+    node.descendants((child, pos) => {
+        if (predicate(child)) {
+            nodesWithPos.push({
+                node: child,
+                pos,
+            });
+        }
+    });
+    return nodesWithPos;
+}
+
+/**
+ * Same as `findChildren` but searches only within a `range`.
+ */
+function findChildrenInRange(node, range, predicate) {
+    const nodesWithPos = [];
+    // if (range.from === range.to) {
+    //   const nodeAt = node.nodeAt(range.from)
+    //   if (nodeAt) {
+    //     nodesWithPos.push({
+    //       node: nodeAt,
+    //       pos: range.from,
+    //     })
+    //   }
+    // }
+    node.nodesBetween(range.from, range.to, (child, pos) => {
+        if (predicate(child)) {
+            nodesWithPos.push({
+                node: child,
+                pos,
+            });
+        }
+    });
+    return nodesWithPos;
+}
+
+function getSchema(extensions) {
+    const resolvedExtensions = ExtensionManager.resolve(extensions);
+    return getSchemaByResolvedExtensions(resolvedExtensions);
+}
+
 function generateHTML(doc, extensions) {
     const schema = getSchema(extensions);
     const contentNode = prosemirrorModel.Node.fromJSON(schema, doc);
-    return getHTMLFromFragment(contentNode, schema);
+    return getHTMLFromFragment(contentNode.content, schema);
+}
+
+function generateJSON(html, extensions) {
+    const schema = getSchema(extensions);
+    const dom = elementFromString(html);
+    return prosemirrorModel.DOMParser.fromSchema(schema)
+        .parse(dom)
+        .toJSON();
+}
+
+function generateText(doc, extensions, options) {
+    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
+    const schema = getSchema(extensions);
+    const contentNode = prosemirrorModel.Node.fromJSON(schema, doc);
+    return getText(contentNode, {
+        blockSeparator,
+        textSerializers: {
+            ...textSerializers,
+            ...getTextSeralizersFromSchema(schema),
+        },
+    });
+}
+
+function getDebugJSON(node, startOffset = 0) {
+    const isTopNode = node.type === node.type.schema.topNodeType;
+    const increment = isTopNode ? 0 : 1;
+    const from = startOffset; // + offset
+    const to = from + node.nodeSize;
+    const marks = node.marks.map(mark => ({
+        type: mark.type.name,
+        attrs: { ...mark.attrs },
+    }));
+    const attrs = { ...node.attrs };
+    const output = {
+        type: node.type.name,
+        from,
+        to,
+    };
+    if (Object.keys(attrs).length) {
+        output.attrs = attrs;
+    }
+    if (marks.length) {
+        output.marks = marks;
+    }
+    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 (node.text) {
+        output.text = node.text;
+    }
+    return output;
 }
 
 function isNodeSelection(value) {
     return isObject(value) && value instanceof prosemirrorState.NodeSelection;
 }
 
+function posToDOMRect(view, from, to) {
+    const minPos = 0;
+    const maxPos = view.state.doc.content.size;
+    const resolvedFrom = minMax(from, minPos, maxPos);
+    const resolvedEnd = minMax(to, minPos, maxPos);
+    const start = view.coordsAtPos(resolvedFrom);
+    const end = view.coordsAtPos(resolvedEnd, -1);
+    const top = Math.min(start.top, end.top);
+    const bottom = Math.max(start.bottom, end.bottom);
+    const left = Math.min(start.left, end.left);
+    const right = Math.max(start.right, end.right);
+    const width = right - left;
+    const height = bottom - top;
+    const x = left;
+    const y = top;
+    const data = {
+        top,
+        bottom,
+        left,
+        right,
+        width,
+        height,
+        x,
+        y,
+    };
+    return {
+        ...data,
+        toJSON: () => data,
+    };
+}
+
 exports.Editor = Editor;
 exports.Extension = Extension;
+exports.InputRule = InputRule;
 exports.Mark = Mark;
 exports.Node = Node;
 exports.NodeView = NodeView;
+exports.PasteRule = PasteRule;
+exports.Tracker = Tracker;
 exports.callOrReturn = callOrReturn;
 exports.extensions = extensions;
+exports.findChildren = findChildren;
+exports.findChildrenInRange = findChildrenInRange;
+exports.findParentNode = findParentNode;
 exports.findParentNodeClosestToPos = findParentNodeClosestToPos;
 exports.generateHTML = generateHTML;
+exports.generateJSON = generateJSON;
+exports.generateText = generateText;
+exports.getAttributes = getAttributes;
+exports.getDebugJSON = getDebugJSON;
+exports.getExtensionField = getExtensionField;
 exports.getHTMLFromFragment = getHTMLFromFragment;
 exports.getMarkAttributes = getMarkAttributes;
+exports.getMarkRange = getMarkRange;
+exports.getMarkType = getMarkType;
+exports.getMarksBetween = getMarksBetween;
+exports.getNodeAttributes = getNodeAttributes;
+exports.getNodeType = getNodeType;
 exports.getSchema = getSchema;
+exports.getText = getText;
+exports.getTextBetween = getTextBetween;
+exports.inputRulesPlugin = inputRulesPlugin;
 exports.isActive = isActive;
+exports.isList = isList;
 exports.isMarkActive = isMarkActive;
 exports.isNodeActive = isNodeActive;
 exports.isNodeEmpty = isNodeEmpty;
@@ -2900,4 +4138,10 @@ exports.markInputRule = markInputRule;
 exports.markPasteRule = markPasteRule;
 exports.mergeAttributes = mergeAttributes;
 exports.nodeInputRule = nodeInputRule;
+exports.pasteRulesPlugin = pasteRulesPlugin;
+exports.posToDOMRect = posToDOMRect;
+exports.textInputRule = textInputRule;
+exports.textPasteRule = textPasteRule;
+exports.textblockTypeInputRule = textblockTypeInputRule;
+exports.wrappingInputRule = wrappingInputRule;
 //# sourceMappingURL=tiptap-core.cjs.js.map