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

package/dist/tiptap-core.cjs.js

@@ -1,3408 +0,0 @@
-'use strict';
-
-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 prosemirrorSchemaList = require('prosemirror-schema-list');
-
-function getSchemaTypeNameByName(name, schema) {
-    if (schema.nodes[name]) {
-        return 'node';
-    }
-    if (schema.marks[name]) {
-        return 'mark';
-    }
-    return null;
-}
-
-function getNodeType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        if (!schema.nodes[nameOrType]) {
-            throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-        }
-        return schema.nodes[nameOrType];
-    }
-    return nameOrType;
-}
-
-function getNodeAttributes(state, typeOrName) {
-    const type = getNodeType(typeOrName, state.schema);
-    const { from, to } = state.selection;
-    let nodes = [];
-    state.doc.nodesBetween(from, to, node => {
-        nodes = [...nodes, node];
-    });
-    const node = nodes
-        .reverse()
-        .find(nodeItem => nodeItem.type.name === type.name);
-    if (node) {
-        return { ...node.attrs };
-    }
-    return {};
-}
-
-function getMarkType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        if (!schema.marks[nameOrType]) {
-            throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-        }
-        return schema.marks[nameOrType];
-    }
-    return nameOrType;
-}
-
-function getMarkAttributes(state, typeOrName) {
-    const type = getMarkType(typeOrName, state.schema);
-    const { from, to, empty } = state.selection;
-    let marks = [];
-    if (empty) {
-        marks = state.selection.$head.marks();
-    }
-    else {
-        state.doc.nodesBetween(from, to, node => {
-            marks = [...marks, ...node.marks];
-        });
-    }
-    const mark = marks.find(markItem => markItem.type.name === type.name);
-    if (mark) {
-        return { ...mark.attrs };
-    }
-    return {};
-}
-
-function getAttributes(state, typeOrName) {
-    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
-        ? typeOrName
-        : typeOrName.name, state.schema);
-    if (schemaType === 'node') {
-        return getNodeAttributes(state, typeOrName);
-    }
-    if (schemaType === 'mark') {
-        return getMarkAttributes(state, typeOrName);
-    }
-    return {};
-}
-
-/**
- * Check if object1 includes object2
- * @param object1 Object
- * @param object2 Object
- */
-function objectIncludes(object1, object2) {
-    const keys = Object.keys(object2);
-    if (!keys.length) {
-        return true;
-    }
-    return !!keys
-        .filter(key => object2[key] === object1[key])
-        .length;
-}
-
-function isNodeActive(state, typeOrName, attributes = {}) {
-    const { from, to, empty } = state.selection;
-    const type = typeOrName
-        ? getNodeType(typeOrName, state.schema)
-        : null;
-    let nodeRanges = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        if (!node.isText) {
-            const relativeFrom = Math.max(from, pos);
-            const relativeTo = Math.min(to, pos + node.nodeSize);
-            nodeRanges = [...nodeRanges, {
-                    node,
-                    from: relativeFrom,
-                    to: relativeTo,
-                }];
-        }
-    });
-    if (empty) {
-        return !!nodeRanges
-            .filter(nodeRange => {
-            if (!type) {
-                return true;
-            }
-            return type.name === nodeRange.node.type.name;
-        })
-            .find(nodeRange => objectIncludes(nodeRange.node.attrs, attributes));
-    }
-    const selectionRange = to - from;
-    const range = nodeRanges
-        .filter(nodeRange => {
-        if (!type) {
-            return true;
-        }
-        return type.name === nodeRange.node.type.name;
-    })
-        .filter(nodeRange => objectIncludes(nodeRange.node.attrs, attributes))
-        .reduce((sum, nodeRange) => {
-        const size = nodeRange.to - nodeRange.from;
-        return sum + size;
-    }, 0);
-    return range >= selectionRange;
-}
-
-function isMarkActive(state, typeOrName, attributes = {}) {
-    const { from, to, empty } = state.selection;
-    const type = typeOrName
-        ? getMarkType(typeOrName, state.schema)
-        : null;
-    if (empty) {
-        return !!(state.storedMarks || state.selection.$from.marks())
-            .filter(mark => {
-            if (!type) {
-                return true;
-            }
-            return type.name === mark.type.name;
-        })
-            .find(mark => objectIncludes(mark.attrs, attributes));
-    }
-    let selectionRange = 0;
-    let markRanges = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.isText) {
-            const relativeFrom = Math.max(from, pos);
-            const relativeTo = Math.min(to, pos + node.nodeSize);
-            const range = relativeTo - relativeFrom;
-            selectionRange += range;
-            markRanges = [...markRanges, ...node.marks.map(mark => ({
-                    mark,
-                    from: relativeFrom,
-                    to: relativeTo,
-                }))];
-        }
-    });
-    if (selectionRange === 0) {
-        return false;
-    }
-    // calculate range of matched mark
-    const matchedRange = markRanges
-        .filter(markRange => {
-        if (!type) {
-            return true;
-        }
-        return type.name === markRange.mark.type.name;
-    })
-        .filter(markRange => objectIncludes(markRange.mark.attrs, attributes))
-        .reduce((sum, markRange) => {
-        const size = markRange.to - markRange.from;
-        return sum + size;
-    }, 0);
-    // calculate range of marks that excludes the searched mark
-    // for example `code` doesn’t allow any other marks
-    const excludedRange = markRanges
-        .filter(markRange => {
-        if (!type) {
-            return true;
-        }
-        return markRange.mark.type !== type
-            && markRange.mark.type.excludes(type);
-    })
-        .reduce((sum, markRange) => {
-        const size = markRange.to - markRange.from;
-        return sum + size;
-    }, 0);
-    // we only include the result of `excludedRange`
-    // if there is a match at all
-    const range = matchedRange > 0
-        ? matchedRange + excludedRange
-        : matchedRange;
-    return range >= selectionRange;
-}
-
-function isActive(state, name, attributes = {}) {
-    if (!name) {
-        return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes);
-    }
-    const schemaType = getSchemaTypeNameByName(name, state.schema);
-    if (schemaType === 'node') {
-        return isNodeActive(state, name, attributes);
-    }
-    if (schemaType === 'mark') {
-        return isMarkActive(state, name, attributes);
-    }
-    return false;
-}
-
-function removeElement(element) {
-    if (element && element.parentNode) {
-        element.parentNode.removeChild(element);
-    }
-}
-
-function elementFromString(value) {
-    // add a wrapper to preserve leading and trailing whitespace
-    const wrappedValue = `<body>${value}</body>`;
-    return new window.DOMParser().parseFromString(wrappedValue, 'text/html').body;
-}
-
-function createNodeFromContent(content, schema, options) {
-    options = {
-        slice: true,
-        parseOptions: {},
-        ...options,
-    };
-    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);
-}
-
-function createDocument(content, schema, parseOptions = {}) {
-    return createNodeFromContent(content, schema, { slice: false, parseOptions });
-}
-
-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;
-}
-
-function isNodeEmpty(node) {
-    var _a;
-    const defaultContent = (_a = node.type.createAndFill()) === null || _a === void 0 ? void 0 : _a.toJSON();
-    const content = node.toJSON();
-    return JSON.stringify(defaultContent) === JSON.stringify(content);
-}
-
-function createStyleTag(style) {
-    const tipTapStyleTag = document.querySelector('style[data-tiptap-style]');
-    if (tipTapStyleTag !== null) {
-        return tipTapStyleTag;
-    }
-    const styleNode = document.createElement('style');
-    styleNode.setAttribute('data-tiptap-style', '');
-    styleNode.innerHTML = style;
-    document.getElementsByTagName('head')[0].appendChild(styleNode);
-    return styleNode;
-}
-
-class CommandManager {
-    constructor(editor, commands) {
-        this.editor = editor;
-        this.commands = commands;
-    }
-    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 getExtensionField(extension, field, context = {}) {
-    if (extension.config[field] === undefined && extension.parent) {
-        return getExtensionField(extension.parent, field, context);
-    }
-    if (typeof extension.config[field] === 'function') {
-        const value = extension.config[field].bind({
-            ...context,
-            parent: extension.parent
-                ? getExtensionField(extension.parent, field, context)
-                : null,
-        });
-        return value;
-    }
-    return extension.config[field];
-}
-
-function splitExtensions(extensions) {
-    const baseExtensions = extensions.filter(extension => extension.type === 'extension');
-    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 = {
-            name: extension.name,
-            options: extension.options,
-        };
-        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,
-        };
-        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) => {
-        return mergeAttributes(attributes, attribute);
-    }, {});
-}
-
-function isEmptyObject(object = {}) {
-    return Object.keys(object).length === 0 && object.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 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 };
-        },
-    };
-}
-
-/**
- * Optionally calls `value` as a function.
- * Otherwise it is returned directly.
- * @param value Function or any value.
- * @param context Optional context to bind to function.
- * @param props Optional props to pass to function.
- */
-function callOrReturn(value, context = undefined, ...props) {
-    if (typeof value === 'function') {
-        if (context) {
-            return value.bind(context)(...props);
-        }
-        return value(...props);
-    }
-    return value;
-}
-
-function cleanUpSchemaItem(data) {
-    return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-        if (key === 'attrs' && isEmptyObject(value)) {
-            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,
-        };
-        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),
-            });
-        }
-        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,
-        };
-        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)),
-            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) {
-    if (schema.nodes[name]) {
-        return schema.nodes[name];
-    }
-    if (schema.marks[name]) {
-        return schema.marks[name];
-    }
-    return null;
-}
-
-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;
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                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) {
-        return ExtensionManager.sort(ExtensionManager.flatten(extensions));
-    }
-    static flatten(extensions) {
-        return extensions
-            .map(extension => {
-            const context = {
-                name: extension.name,
-                options: extension.options,
-            };
-            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,
-                editor: this.editor,
-                type: getSchemaTypeByName(extension.name, this.schema),
-            };
-            const addCommands = getExtensionField(extension, 'addCommands', context);
-            if (!addCommands) {
-                return commands;
-            }
-            return {
-                ...commands,
-                ...addCommands(),
-            };
-        }, {});
-    }
-    get plugins() {
-        return [...this.extensions]
-            .reverse()
-            .map(extension => {
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                editor: this.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: this.editor })];
-                }));
-                const keyMapPlugin = prosemirrorKeymap.keymap(bindings);
-                plugins.push(keyMapPlugin);
-            }
-            const addInputRules = getExtensionField(extension, 'addInputRules', context);
-            if (this.editor.options.enableInputRules && addInputRules) {
-                const inputRules = addInputRules();
-                const inputRulePlugins = inputRules.length
-                    ? [prosemirrorInputrules.inputRules({ rules: inputRules })]
-                    : [];
-                plugins.push(...inputRulePlugins);
-            }
-            const addPasteRules = getExtensionField(extension, 'addPasteRules', context);
-            if (this.editor.options.enablePasteRules && addPasteRules) {
-                const pasteRulePlugins = addPasteRules();
-                plugins.push(...pasteRulePlugins);
-            }
-            const addProseMirrorPlugins = getExtensionField(extension, 'addProseMirrorPlugins', context);
-            if (addProseMirrorPlugins) {
-                const proseMirrorPlugins = addProseMirrorPlugins();
-                plugins.push(...proseMirrorPlugins);
-            }
-            return plugins;
-        })
-            .flat();
-    }
-    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,
-                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];
-        }));
-    }
-    get textSerializers() {
-        const { editor } = this;
-        const { nodeExtensions } = splitExtensions(this.extensions);
-        return Object.fromEntries(nodeExtensions
-            .filter(extension => !!getExtensionField(extension, 'renderText'))
-            .map(extension => {
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                editor,
-                type: getNodeType(extension.name, this.schema),
-            };
-            const renderText = getExtensionField(extension, 'renderText', context);
-            if (!renderText) {
-                return [];
-            }
-            const textSerializer = (props) => renderText(props);
-            return [extension.name, textSerializer];
-        }));
-    }
-}
-
-class EventEmitter {
-    constructor() {
-        this.callbacks = {};
-    }
-    on(event, fn) {
-        if (!this.callbacks[event]) {
-            this.callbacks[event] = [];
-        }
-        this.callbacks[event].push(fn);
-        return this;
-    }
-    emit(event, ...args) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            callbacks.forEach(callback => callback.apply(this, args));
-        }
-        return this;
-    }
-    off(event, fn) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            if (fn) {
-                this.callbacks[event] = callbacks.filter(callback => callback !== fn);
-            }
-            else {
-                delete this.callbacks[event];
-            }
-        }
-        return this;
-    }
-    removeAllListeners() {
-        this.callbacks = {};
-    }
-}
-
-// see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
-function getType(payload) {
-    return Object.prototype.toString.call(payload).slice(8, -1);
-}
-function isPlainObject(payload) {
-    if (getType(payload) !== 'Object')
-        return false;
-    return payload.constructor === Object && Object.getPrototypeOf(payload) === Object.prototype;
-}
-
-function mergeDeep(target, source) {
-    const output = { ...target };
-    if (isPlainObject(target) && isPlainObject(source)) {
-        Object.keys(source).forEach(key => {
-            if (isPlainObject(source[key])) {
-                if (!(key in target)) {
-                    Object.assign(output, { [key]: source[key] });
-                }
-                else {
-                    output[key] = mergeDeep(target[key], source[key]);
-                }
-            }
-            else {
-                Object.assign(output, { [key]: source[key] });
-            }
-        });
-    }
-    return output;
-}
-
-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;
-        this.options = this.config.defaultOptions;
-    }
-    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);
-        return extension;
-    }
-    extend(extendedConfig = {}) {
-        const extension = new Extension(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        extension.options = extendedConfig.defaultOptions
-            ? extendedConfig.defaultOptions
-            : extension.parent.options;
-        return extension;
-    }
-}
-
-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 = () => ({ editor, view }) => {
-    requestAnimationFrame(() => {
-        if (!editor.isDestroyed) {
-            view.dom.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) {
-                return;
-            }
-            const $fromPos = tr.doc.resolve(tr.mapping.map(pos));
-            const $toPos = tr.doc.resolve(tr.mapping.map(pos + node.nodeSize));
-            const nodeRange = $fromPos.blockRange($toPos);
-            if (!nodeRange) {
-                return;
-            }
-            const targetLiftDepth = prosemirrorTransform.liftTarget(nodeRange);
-            if (node.type.isTextblock && dispatch) {
-                const { defaultType } = $fromPos.parent.contentMatchAt($fromPos.index());
-                tr.setNodeMarkup(nodeRange.start, 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 deleteNode = typeOrName => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const $pos = tr.selection.$anchor;
-    for (let depth = $pos.depth; depth > 0; depth -= 1) {
-        const node = $pos.node(depth);
-        if (node.type === type) {
-            if (dispatch) {
-                const from = $pos.before(depth);
-                const to = $pos.after(depth);
-                tr.delete(from, to).scrollIntoView();
-            }
-            return true;
-        }
-    }
-    return false;
-};
-
-var deleteNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  deleteNode: deleteNode
-});
-
-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 findMarkInSet(marks, type, attributes = {}) {
-    return marks.find(item => {
-        return item.type === type && objectIncludes(item.attrs, attributes);
-    });
-}
-function isMarkInSet(marks, type, attributes = {}) {
-    return !!findMarkInSet(marks, type, attributes);
-}
-function getMarkRange($pos, type, attributes = {}) {
-    if (!$pos || !type) {
-        return;
-    }
-    const start = $pos.parent.childAfter($pos.parentOffset);
-    if (!start.node) {
-        return;
-    }
-    const mark = findMarkInSet(start.node.marks, type, attributes);
-    if (!mark) {
-        return;
-    }
-    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;
-    }
-    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,
-    };
-}
-
-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;
-};
-
-var extendMarkRange$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  extendMarkRange: extendMarkRange
-});
-
-const first = commands => props => {
-    const items = typeof commands === 'function'
-        ? commands(props)
-        : commands;
-    for (let i = 0; i < items.length; i += 1) {
-        if (items[i](props)) {
-            return true;
-        }
-    }
-    return false;
-};
-
-var first$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  first: first
-});
-
-function minMax(value = 0, min = 0, max = 0) {
-    return Math.min(Math.max(value, min), max);
-}
-
-function isClass(item) {
-    var _a;
-    if (((_a = item.constructor) === null || _a === void 0 ? void 0 : _a.toString().substring(0, 5)) !== 'class') {
-        return false;
-    }
-    return true;
-}
-
-function isObject(item) {
-    return (item
-        && typeof item === 'object'
-        && !Array.isArray(item)
-        && !isClass(item));
-}
-
-function isTextSelection(value) {
-    return isObject(value) && value instanceof prosemirrorState.TextSelection;
-}
-
-function resolveSelection(state, position = null) {
-    if (!position) {
-        return null;
-    }
-    if (position === 'start' || position === true) {
-        return {
-            from: 0,
-            to: 0,
-        };
-    }
-    if (position === 'end') {
-        const { size } = state.doc.content;
-        return {
-            from: size,
-            to: size,
-        };
-    }
-    return {
-        from: position,
-        to: position,
-    };
-}
-const focus = (position = null) => ({ editor, view, tr, dispatch, }) => {
-    const delayedFocus = () => {
-        // For React we have to focus asynchronously. Otherwise wild things happen.
-        // see: https://github.com/ueberdosis/tiptap/issues/1520
-        requestAnimationFrame(() => {
-            if (!editor.isDestroyed) {
-                view.focus();
-            }
-        });
-    };
-    if ((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)) {
-        delayedFocus();
-        return true;
-    }
-    const { from, to } = resolveSelection(editor.state, position) || editor.state.selection;
-    const { doc, storedMarks } = tr;
-    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) {
-        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);
-        }
-        delayedFocus();
-    }
-    return true;
-};
-
-var focus$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  focus: focus
-});
-
-const forEach = (items, fn) => props => {
-    return items.every((item, index) => fn(item, { ...props, index }));
-};
-
-var forEach$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  forEach: forEach
-});
-
-const insertContent = (value, options) => ({ tr, commands }) => {
-    return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-};
-
-var insertContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertContent: insertContent
-});
-
-// source: https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.js#L466
-function selectionToInsertionEnd(tr, startLen, bias) {
-    const last = tr.steps.length - 1;
-    if (last < startLen) {
-        return;
-    }
-    const step = tr.steps[last];
-    if (!(step instanceof prosemirrorTransform.ReplaceStep || step instanceof prosemirrorTransform.ReplaceAroundStep)) {
-        return;
-    }
-    const map = tr.mapping.maps[last];
-    let end = 0;
-    map.forEach((_from, _to, _newFrom, newTo) => {
-        if (end === 0) {
-            end = newTo;
-        }
-    });
-    tr.setSelection(prosemirrorState.Selection.near(tr.doc.resolve(end), bias));
-}
-
-const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
-    if (dispatch) {
-        const content = createNodeFromContent(value, editor.schema, {
-            parseOptions: {
-                preserveWhitespace: 'full',
-            },
-            ...(options || {}),
-        });
-        // don’t dispatch an empty fragment because this can lead to strange errors
-        if (content.toString() === '<>') {
-            return true;
-        }
-        const { from, to } = typeof position === 'number'
-            ? { from: position, to: position }
-            : position;
-        tr.replaceWith(from, to, content);
-        // set cursor at end of inserted content
-        selectionToInsertionEnd(tr, tr.steps.length - 1, 1);
-    }
-    return true;
-};
-
-var insertContentAt$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertContentAt: insertContentAt
-});
-
-const joinBackward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.joinBackward(state, dispatch);
-};
-
-var joinBackward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  joinBackward: joinBackward
-});
-
-const joinForward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.joinForward(state, dispatch);
-};
-
-var joinForward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  joinForward: joinForward
-});
-
-const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
-function normalizeKeyName(name) {
-    const parts = name.split(/-(?!$)/);
-    let result = parts[parts.length - 1];
-    if (result === 'Space') {
-        result = ' ';
-    }
-    let alt;
-    let ctrl;
-    let shift;
-    let meta;
-    for (let i = 0; i < parts.length - 1; i += 1) {
-        const mod = parts[i];
-        if (/^(cmd|meta|m)$/i.test(mod)) {
-            meta = true;
-        }
-        else if (/^a(lt)?$/i.test(mod)) {
-            alt = true;
-        }
-        else if (/^(c|ctrl|control)$/i.test(mod)) {
-            ctrl = true;
-        }
-        else if (/^s(hift)?$/i.test(mod)) {
-            shift = true;
-        }
-        else if (/^mod$/i.test(mod)) {
-            if (mac) {
-                meta = true;
-            }
-            else {
-                ctrl = true;
-            }
-        }
-        else {
-            throw new Error(`Unrecognized modifier name: ${mod}`);
-        }
-    }
-    if (alt) {
-        result = `Alt-${result}`;
-    }
-    if (ctrl) {
-        result = `Ctrl-${result}`;
-    }
-    if (meta) {
-        result = `Meta-${result}`;
-    }
-    if (shift) {
-        result = `Shift-${result}`;
-    }
-    return result;
-}
-const keyboardShortcut = name => ({ editor, view, tr, dispatch, }) => {
-    const keys = normalizeKeyName(name).split(/-(?!$)/);
-    const key = keys.find(item => !['Alt', 'Ctrl', 'Meta', 'Shift'].includes(item));
-    const event = new KeyboardEvent('keydown', {
-        key: key === 'Space'
-            ? ' '
-            : key,
-        altKey: keys.includes('Alt'),
-        ctrlKey: keys.includes('Ctrl'),
-        metaKey: keys.includes('Meta'),
-        shiftKey: keys.includes('Shift'),
-        bubbles: true,
-        cancelable: true,
-    });
-    const capturedTransaction = editor.captureTransaction(() => {
-        view.someProp('handleKeyDown', f => f(view, event));
-    });
-    capturedTransaction === null || capturedTransaction === void 0 ? void 0 : capturedTransaction.steps.forEach(step => {
-        const newStep = step.map(tr.mapping);
-        if (newStep && dispatch) {
-            tr.maybeStep(newStep);
-        }
-    });
-    return true;
-};
-
-var keyboardShortcut$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  keyboardShortcut: keyboardShortcut
-});
-
-const lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const isActive = isNodeActive(state, type, attributes);
-    if (!isActive) {
-        return false;
-    }
-    return prosemirrorCommands.lift(state, dispatch);
-};
-
-var lift$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  lift: lift
-});
-
-const liftEmptyBlock = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.liftEmptyBlock(state, dispatch);
-};
-
-var liftEmptyBlock$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  liftEmptyBlock: liftEmptyBlock
-});
-
-const liftListItem = typeOrName => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    return prosemirrorSchemaList.liftListItem(type)(state, dispatch);
-};
-
-var liftListItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  liftListItem: liftListItem
-});
-
-const newlineInCode = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.newlineInCode(state, dispatch);
-};
-
-var newlineInCode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  newlineInCode: newlineInCode
-});
-
-/**
- * Remove a property or an array of properties from an object
- * @param obj Object
- * @param key Key to remove
- */
-function deleteProps(obj, propOrProps) {
-    const props = typeof propOrProps === 'string'
-        ? [propOrProps]
-        : propOrProps;
-    return Object
-        .keys(obj)
-        .reduce((newObj, prop) => {
-        if (!props.includes(prop)) {
-            newObj[prop] = obj[prop];
-        }
-        return newObj;
-    }, {});
-}
-
-const resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-    let nodeType = null;
-    let markType = null;
-    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
-        ? typeOrName
-        : typeOrName.name, state.schema);
-    if (!schemaType) {
-        return false;
-    }
-    if (schemaType === 'node') {
-        nodeType = getNodeType(typeOrName, state.schema);
-    }
-    if (schemaType === 'mark') {
-        markType = getMarkType(typeOrName, state.schema);
-    }
-    if (dispatch) {
-        tr.selection.ranges.forEach(range => {
-            state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-                if (nodeType && nodeType === node.type) {
-                    tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes));
-                }
-                if (markType && node.marks.length) {
-                    node.marks.forEach(mark => {
-                        if (markType === mark.type) {
-                            tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
-                        }
-                    });
-                }
-            });
-        });
-    }
-    return true;
-};
-
-var resetAttributes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  resetAttributes: resetAttributes
-});
-
-const scrollIntoView = () => ({ tr, dispatch }) => {
-    if (dispatch) {
-        tr.scrollIntoView();
-    }
-    return true;
-};
-
-var scrollIntoView$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  scrollIntoView: scrollIntoView
-});
-
-const selectAll = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectAll(state, dispatch);
-};
-
-var selectAll$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectAll: selectAll
-});
-
-const selectNodeBackward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectNodeBackward(state, dispatch);
-};
-
-var selectNodeBackward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectNodeBackward: selectNodeBackward
-});
-
-const selectNodeForward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectNodeForward(state, dispatch);
-};
-
-var selectNodeForward$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectNodeForward: selectNodeForward
-});
-
-const selectParentNode = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectParentNode(state, dispatch);
-};
-
-var selectParentNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  selectParentNode: selectParentNode
-});
-
-const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
-    const { doc } = tr;
-    const document = createDocument(content, editor.schema, parseOptions);
-    const selection = prosemirrorState.TextSelection.create(doc, 0, doc.content.size);
-    if (dispatch) {
-        tr.setSelection(selection)
-            .replaceSelectionWith(document, false)
-            .setMeta('preventUpdate', !emitUpdate);
-    }
-    return true;
-};
-
-var setContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setContent: setContent
-});
-
-const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const { selection } = tr;
-    const { empty, ranges } = selection;
-    const type = getMarkType(typeOrName, state.schema);
-    if (dispatch) {
-        if (empty) {
-            const oldAttributes = getMarkAttributes(state, type);
-            tr.addStoredMark(type.create({
-                ...oldAttributes,
-                ...attributes,
-            }));
-        }
-        else {
-            ranges.forEach(range => {
-                const from = range.$from.pos;
-                const to = range.$to.pos;
-                state.doc.nodesBetween(from, to, (node, pos) => {
-                    const trimmedFrom = Math.max(pos, from);
-                    const trimmedTo = Math.min(pos + node.nodeSize, to);
-                    const someHasMark = node.marks.find(mark => mark.type === type);
-                    // if there is already a mark of this type
-                    // we know that we have to merge its attributes
-                    // otherwise we add a fresh new mark
-                    if (someHasMark) {
-                        node.marks.forEach(mark => {
-                            if (type === mark.type) {
-                                tr.addMark(trimmedFrom, trimmedTo, type.create({
-                                    ...mark.attrs,
-                                    ...attributes,
-                                }));
-                            }
-                        });
-                    }
-                    else {
-                        tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
-                    }
-                });
-            });
-        }
-    }
-    return true;
-};
-
-var setMark$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setMark: setMark
-});
-
-const setMeta = (key, value) => ({ tr }) => {
-    tr.setMeta(key, value);
-    return true;
-};
-
-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);
-};
-
-var setNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  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);
-};
-
-var sinkListItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  sinkListItem: sinkListItem
-});
-
-function getSplittedAttributes(extensionAttributes, typeName, attributes) {
-    return Object.fromEntries(Object
-        .entries(attributes)
-        .filter(([name]) => {
-        const extensionAttribute = extensionAttributes.find(item => {
-            return item.type === typeName && item.name === name;
-        });
-        if (!extensionAttribute) {
-            return false;
-        }
-        return extensionAttribute.attribute.keepOnSplit;
-    }));
-}
-
-function defaultBlockAt(match) {
-    for (let i = 0; i < match.edgeCount; i += 1) {
-        const { type } = match.edge(i);
-        if (type.isTextblock && !type.hasRequiredAttrs()) {
-            return type;
-        }
-    }
-    return null;
-}
-function ensureMarks(state, splittableMarks) {
-    const marks = state.storedMarks
-        || (state.selection.$to.parentOffset && state.selection.$from.marks());
-    if (marks) {
-        const filteredMarks = marks.filter(mark => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
-        state.tr.ensureMarks(filteredMarks);
-    }
-}
-const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor, }) => {
-    const { selection, doc } = tr;
-    const { $from, $to } = selection;
-    const extensionAttributes = editor.extensionManager.attributes;
-    const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-    if (selection instanceof prosemirrorState.NodeSelection && selection.node.isBlock) {
-        if (!$from.parentOffset || !prosemirrorTransform.canSplit(doc, $from.pos)) {
-            return false;
-        }
-        if (dispatch) {
-            if (keepMarks) {
-                ensureMarks(state, editor.extensionManager.splittableMarks);
-            }
-            tr.split($from.pos).scrollIntoView();
-        }
-        return true;
-    }
-    if (!$from.parent.isBlock) {
-        return false;
-    }
-    if (dispatch) {
-        const atEnd = $to.parentOffset === $to.parent.content.size;
-        if (selection instanceof prosemirrorState.TextSelection) {
-            tr.deleteSelection();
-        }
-        const deflt = $from.depth === 0
-            ? undefined
-            : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-        let types = atEnd && deflt
-            ? [{
-                    type: deflt,
-                    attrs: newAttributes,
-                }]
-            : undefined;
-        let can = prosemirrorTransform.canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
-        if (!types
-            && !can
-            && prosemirrorTransform.canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
-            can = true;
-            types = deflt
-                ? [{
-                        type: deflt,
-                        attrs: newAttributes,
-                    }]
-                : undefined;
-        }
-        if (can) {
-            tr.split(tr.mapping.map($from.pos), 1, types);
-            if (deflt
-                && !atEnd
-                && !$from.parentOffset
-                && $from.parent.type !== deflt) {
-                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) {
-            ensureMarks(state, editor.extensionManager.splittableMarks);
-        }
-        tr.scrollIntoView();
-    }
-    return true;
-};
-
-var splitBlock$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  splitBlock: splitBlock
-});
-
-const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
-    var _a;
-    const type = getNodeType(typeOrName, state.schema);
-    const { $from, $to } = state.selection;
-    // @ts-ignore
-    // eslint-disable-next-line
-    const node = state.selection.node;
-    if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) {
-        return false;
-    }
-    const grandParent = $from.node(-1);
-    if (grandParent.type !== type) {
-        return false;
-    }
-    const extensionAttributes = editor.extensionManager.attributes;
-    if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-        // In an empty block. If this is a nested list, the wrapping
-        // list item should be split. Otherwise, bail out and let next
-        // command handle lifting.
-        if ($from.depth === 2
-            || $from.node(-3).type !== type
-            || $from.index(-2) !== $from.node(-2).childCount - 1) {
-            return false;
-        }
-        if (dispatch) {
-            let wrap = prosemirrorModel.Fragment.empty;
-            // 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 - 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));
-            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;
-    }
-    const nextType = $to.pos === $from.end()
-        ? grandParent.contentMatchAt(0).defaultType
-        : null;
-    const newTypeAttributes = getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs);
-    const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-    tr.delete($from.pos, $to.pos);
-    const types = nextType
-        ? [{ type, attrs: newTypeAttributes }, { type: nextType, attrs: newNextTypeAttributes }]
-        : [{ type, attrs: newTypeAttributes }];
-    if (!prosemirrorTransform.canSplit(tr.doc, $from.pos, 2)) {
-        return false;
-    }
-    if (dispatch) {
-        tr.split($from.pos, 2, types).scrollIntoView();
-    }
-    return true;
-};
-
-var splitListItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  splitListItem: splitListItem
-});
-
-function findParentNodeClosestToPos($pos, predicate) {
-    for (let i = $pos.depth; i > 0; i -= 1) {
-        const node = $pos.node(i);
-        if (predicate(node)) {
-            return {
-                pos: i > 0 ? $pos.before(i) : 0,
-                start: $pos.start(i),
-                depth: i,
-                node,
-            };
-        }
-    }
-}
-
-function findParentNode(predicate) {
-    return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-}
-
-function isList(name, extensions) {
-    const { nodeExtensions } = splitExtensions(extensions);
-    const extension = nodeExtensions.find(item => item.name === name);
-    if (!extension) {
-        return false;
-    }
-    const context = {
-        name: extension.name,
-        options: extension.options,
-    };
-    const group = callOrReturn(getExtensionField(extension, 'group', context));
-    if (typeof group !== 'string') {
-        return false;
-    }
-    return group.split(' ').includes('list');
-}
-
-const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dispatch, chain, commands, can, }) => {
-    const { extensions } = editor.extensionManager;
-    const listType = getNodeType(listTypeOrName, state.schema);
-    const itemType = getNodeType(itemTypeOrName, state.schema);
-    const { selection } = state;
-    const { $from, $to } = selection;
-    const range = $from.blockRange($to);
-    if (!range) {
-        return false;
-    }
-    const parentList = findParentNode(node => isList(node.type.name, extensions))(selection);
-    if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-        // remove list
-        if (parentList.node.type === listType) {
-            return commands.liftListItem(itemType);
-        }
-        // change list type
-        if (isList(parentList.node.type.name, extensions)
-            && listType.validContent(parentList.node.content)
-            && dispatch) {
-            tr.setNodeMarkup(parentList.pos, listType);
-            return true;
-        }
-    }
-    const canWrapInList = can().wrapInList(listType);
-    // try to convert node to paragraph if needed
-    if (!canWrapInList) {
-        return chain()
-            .clearNodes()
-            .wrapInList(listType)
-            .run();
-    }
-    return commands.wrapInList(listType);
-};
-
-var toggleList$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleList: toggleList
-});
-
-const toggleMark = (typeOrName, attributes = {}) => ({ state, commands }) => {
-    const type = getMarkType(typeOrName, state.schema);
-    const isActive = isMarkActive(state, type, attributes);
-    if (isActive) {
-        return commands.unsetMark(type);
-    }
-    return commands.setMark(type, attributes);
-};
-
-var toggleMark$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleMark: toggleMark
-});
-
-const toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const toggleType = getNodeType(toggleTypeOrName, state.schema);
-    const isActive = isNodeActive(state, type, attributes);
-    if (isActive) {
-        return commands.setNode(toggleType);
-    }
-    return commands.setNode(type, attributes);
-};
-
-var toggleNode$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleNode: toggleNode
-});
-
-const toggleWrap = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const isActive = isNodeActive(state, type, attributes);
-    if (isActive) {
-        return prosemirrorCommands.lift(state, dispatch);
-    }
-    return prosemirrorCommands.wrapIn(type, attributes)(state, dispatch);
-};
-
-var toggleWrap$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toggleWrap: toggleWrap
-});
-
-const undoInputRule = () => ({ state, dispatch }) => {
-    return prosemirrorInputrules.undoInputRule(state, dispatch);
-};
-
-var undoInputRule$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  undoInputRule: undoInputRule
-});
-
-const unsetAllMarks = () => ({ tr, state, dispatch }) => {
-    const { selection } = tr;
-    const { empty, ranges } = selection;
-    if (empty) {
-        return true;
-    }
-    if (dispatch) {
-        Object
-            .entries(state.schema.marks)
-            .forEach(([, mark]) => {
-            ranges.forEach(range => {
-                tr.removeMark(range.$from.pos, range.$to.pos, mark);
-            });
-        });
-    }
-    return true;
-};
-
-var unsetAllMarks$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  unsetAllMarks: unsetAllMarks
-});
-
-const unsetMark = typeOrName => ({ tr, state, dispatch }) => {
-    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);
-            });
-        }
-        tr.removeStoredMark(type);
-    }
-    return true;
-};
-
-var unsetMark$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  unsetMark: unsetMark
-});
-
-const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    let nodeType = null;
-    let markType = null;
-    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
-        ? typeOrName
-        : typeOrName.name, state.schema);
-    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 updateAttributes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  updateAttributes: updateAttributes
-});
-
-const wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const isActive = isNodeActive(state, type, attributes);
-    if (isActive) {
-        return false;
-    }
-    return prosemirrorCommands.wrapIn(type, attributes)(state, dispatch);
-};
-
-var wrapIn$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  wrapIn: wrapIn
-});
-
-const wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    return prosemirrorSchemaList.wrapInList(type, attributes)(state, dispatch);
-};
-
-var wrapInList$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  wrapInList: wrapInList
-});
-
-const Commands = Extension.create({
-    name: 'commands',
-    addCommands() {
-        return {
-            ...blur$1,
-            ...clearContent$1,
-            ...clearNodes$1,
-            ...command$1,
-            ...createParagraphNear$1,
-            ...deleteNode$1,
-            ...deleteRange$1,
-            ...deleteSelection$1,
-            ...enter$1,
-            ...exitCode$1,
-            ...extendMarkRange$1,
-            ...first$1,
-            ...focus$1,
-            ...forEach$1,
-            ...insertContent$1,
-            ...insertContentAt$1,
-            ...joinBackward$1,
-            ...joinForward$1,
-            ...keyboardShortcut$1,
-            ...lift$1,
-            ...liftEmptyBlock$1,
-            ...liftListItem$1,
-            ...newlineInCode$1,
-            ...resetAttributes$1,
-            ...scrollIntoView$1,
-            ...selectAll$1,
-            ...selectNodeBackward$1,
-            ...selectNodeForward$1,
-            ...selectParentNode$1,
-            ...setContent$1,
-            ...setMark$1,
-            ...setMeta$1,
-            ...setNode$1,
-            ...setNodeSelection$1,
-            ...setTextSelection$1,
-            ...sinkListItem$1,
-            ...splitBlock$1,
-            ...splitListItem$1,
-            ...toggleList$1,
-            ...toggleMark$1,
-            ...toggleNode$1,
-            ...toggleWrap$1,
-            ...undoInputRule$1,
-            ...unsetAllMarks$1,
-            ...unsetMark$1,
-            ...updateAttributes$1,
-            ...wrapIn$1,
-            ...wrapInList$1,
-        };
-    },
-});
-
-const Editable = Extension.create({
-    name: 'editable',
-    addProseMirrorPlugins() {
-        return [
-            new prosemirrorState.Plugin({
-                key: new prosemirrorState.PluginKey('editable'),
-                props: {
-                    editable: () => this.editor.options.editable,
-                },
-            }),
-        ];
-    },
-});
-
-const FocusEvents = Extension.create({
-    name: 'focusEvents',
-    addProseMirrorPlugins() {
-        const { editor } = this;
-        return [
-            new prosemirrorState.Plugin({
-                key: new prosemirrorState.PluginKey('focusEvents'),
-                props: {
-                    attributes: {
-                        tabindex: '0',
-                    },
-                    handleDOMEvents: {
-                        focus: (view, event) => {
-                            editor.isFocused = true;
-                            const transaction = editor.state.tr
-                                .setMeta('focus', { event })
-                                .setMeta('addToHistory', false);
-                            view.dispatch(transaction);
-                            return false;
-                        },
-                        blur: (view, event) => {
-                            editor.isFocused = false;
-                            const transaction = editor.state.tr
-                                .setMeta('blur', { event })
-                                .setMeta('addToHistory', false);
-                            view.dispatch(transaction);
-                            return false;
-                        },
-                    },
-                },
-            }),
-        ];
-    },
-});
-
-const Keymap = Extension.create({
-    name: 'keymap',
-    addKeyboardShortcuts() {
-        const handleBackspace = () => this.editor.commands.first(({ commands }) => [
-            () => commands.undoInputRule(),
-            () => commands.deleteSelection(),
-            () => commands.joinBackward(),
-            () => commands.selectNodeBackward(),
-        ]);
-        const handleDelete = () => this.editor.commands.first(({ commands }) => [
-            () => commands.deleteSelection(),
-            () => commands.joinForward(),
-            () => commands.selectNodeForward(),
-        ]);
-        return {
-            Enter: () => this.editor.commands.first(({ commands }) => [
-                () => commands.newlineInCode(),
-                () => commands.createParagraphNear(),
-                () => commands.liftEmptyBlock(),
-                () => 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(),
-        };
-    },
-});
-
-var extensions = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ClipboardTextSerializer: ClipboardTextSerializer,
-  Commands: Commands,
-  Editable: Editable,
-  FocusEvents: FocusEvents,
-  Keymap: Keymap
-});
-
-const style = `.ProseMirror {
-  position: relative;
-}
-
-.ProseMirror {
-  word-wrap: break-word;
-  white-space: pre-wrap;
-  -webkit-font-variant-ligatures: none;
-  font-variant-ligatures: none;
-}
-
-.ProseMirror [contenteditable="false"] {
-  white-space: normal;
-}
-
-.ProseMirror [contenteditable="false"] [contenteditable="true"] {
-  white-space: pre-wrap;
-}
-
-.ProseMirror pre {
-  white-space: pre-wrap;
-}
-
-.ProseMirror-gapcursor {
-  display: none;
-  pointer-events: none;
-  position: absolute;
-}
-
-.ProseMirror-gapcursor:after {
-  content: "";
-  display: block;
-  position: absolute;
-  top: -2px;
-  width: 20px;
-  border-top: 1px solid black;
-  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
-}
-
-@keyframes ProseMirror-cursor-blink {
-  to {
-    visibility: hidden;
-  }
-}
-
-.ProseMirror-hideselection *::selection {
-  background: transparent;
-}
-
-.ProseMirror-hideselection *::-moz-selection {
-  background: transparent;
-}
-
-.ProseMirror-hideselection * {
-  caret-color: transparent;
-}
-
-.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.options = {
-            element: document.createElement('div'),
-            content: '',
-            injectCSS: true,
-            extensions: [],
-            autofocus: false,
-            editable: true,
-            editorProps: {},
-            parseOptions: {},
-            enableInputRules: true,
-            enablePasteRules: true,
-            onBeforeCreate: () => null,
-            onCreate: () => null,
-            onUpdate: () => null,
-            onSelectionUpdate: () => null,
-            onTransaction: () => null,
-            onFocus: () => null,
-            onBlur: () => null,
-            onDestroy: () => null,
-        };
-        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('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 });
-        }, 0);
-    }
-    /**
-     * An object of all registered commands.
-     */
-    get commands() {
-        return this.commandManager.createCommands();
-    }
-    /**
-     * Create a command chain to call multiple commands at once.
-     */
-    chain() {
-        return this.commandManager.createChain();
-    }
-    /**
-     * Check if a command or a command chain can be executed. Without executing it.
-     */
-    can() {
-        return this.commandManager.createCan();
-    }
-    /**
-     * Inject CSS styles.
-     */
-    injectCSS() {
-        if (this.options.injectCSS && document) {
-            this.css = createStyleTag(style);
-        }
-    }
-    /**
-     * Update editor options.
-     *
-     * @param options A list of options
-     */
-    setOptions(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 });
-    }
-    /**
-     * Returns whether the editor is editable.
-     */
-    get isEditable() {
-        // 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.
-     */
-    get state() {
-        return this.view.state;
-    }
-    /**
-     * Register a ProseMirror plugin.
-     *
-     * @param plugin A ProseMirror plugin
-     * @param handlePlugins Control how to merge the plugin into the existing plugins.
-     */
-    registerPlugin(plugin, handlePlugins) {
-        const plugins = typeof handlePlugins === 'function'
-            ? handlePlugins(plugin, this.state.plugins)
-            : [...this.state.plugins, plugin];
-        const state = this.state.reconfigure({ plugins });
-        this.view.updateState(state);
-    }
-    /**
-     * Unregister a ProseMirror plugin.
-     *
-     * @param name The plugins name
-     */
-    unregisterPlugin(nameOrPluginKey) {
-        if (this.isDestroyed) {
-            return;
-        }
-        const name = typeof nameOrPluginKey === 'string'
-            ? `${nameOrPluginKey}$`
-            // @ts-ignore
-            : nameOrPluginKey.key;
-        const state = this.state.reconfigure({
-            // @ts-ignore
-            plugins: this.state.plugins.filter(plugin => !plugin.key.startsWith(name)),
-        });
-        this.view.updateState(state);
-    }
-    /**
-     * Creates an extension manager.
-     */
-    createExtensionManager() {
-        const coreExtensions = Object.entries(extensions).map(([, extension]) => extension);
-        const allExtensions = [...coreExtensions, ...this.options.extensions].filter(extension => {
-            return ['extension', 'node', 'mark'].includes(extension === null || extension === void 0 ? void 0 : extension.type);
-        });
-        this.extensionManager = new ExtensionManager(allExtensions, this);
-    }
-    /**
-     * Creates an command manager.
-     */
-    createCommandManager() {
-        this.commandManager = new CommandManager(this, this.extensionManager.commands);
-    }
-    /**
-     * Creates a ProseMirror schema.
-     */
-    createSchema() {
-        this.schema = this.extensionManager.schema;
-    }
-    /**
-     * Creates a ProseMirror view.
-     */
-    createView() {
-        this.view = new prosemirrorView.EditorView(this.options.element, {
-            ...this.options.editorProps,
-            dispatchTransaction: this.dispatchTransaction.bind(this),
-            state: prosemirrorState.EditorState.create({
-                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: this.extensionManager.plugins,
-        });
-        this.view.updateState(newState);
-        this.createNodeViews();
-        // Let’s store the editor instance in the DOM element.
-        // So we’ll have access to it for tests.
-        const dom = this.view.dom;
-        dom.editor = this;
-    }
-    /**
-     * Creates all node views.
-     */
-    createNodeViews() {
-        this.view.setProps({
-            nodeViews: this.extensionManager.nodeViews,
-        });
-    }
-    captureTransaction(fn) {
-        this.isCapturingTransaction = true;
-        fn();
-        this.isCapturingTransaction = false;
-        const tr = this.capturedTransaction;
-        this.capturedTransaction = null;
-        return tr;
-    }
-    /**
-     * The callback over which to send transactions (state updates) produced by the view.
-     *
-     * @param transaction An editor state transaction
-     */
-    dispatchTransaction(transaction) {
-        if (this.isCapturingTransaction) {
-            if (!this.capturedTransaction) {
-                this.capturedTransaction = transaction;
-                return;
-            }
-            transaction.steps.forEach(step => { var _a; return (_a = this.capturedTransaction) === null || _a === void 0 ? void 0 : _a.step(step); });
-            return;
-        }
-        const state = this.state.apply(transaction);
-        const selectionHasChanged = !this.state.selection.eq(state.selection);
-        this.view.updateState(state);
-        this.emit('transaction', {
-            editor: this,
-            transaction,
-        });
-        if (selectionHasChanged) {
-            this.emit('selectionUpdate', {
-                editor: this,
-                transaction,
-            });
-        }
-        const focus = transaction.getMeta('focus');
-        const blur = transaction.getMeta('blur');
-        if (focus) {
-            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')) {
-            return;
-        }
-        this.emit('update', {
-            editor: this,
-            transaction,
-        });
-    }
-    /**
-     * Get attributes of the currently selected node or mark.
-     */
-    getAttributes(nameOrType) {
-        return getAttributes(this.state, nameOrType);
-    }
-    isActive(nameOrAttributes, attributesOrUndefined) {
-        const name = typeof nameOrAttributes === 'string'
-            ? nameOrAttributes
-            : null;
-        const attributes = typeof nameOrAttributes === 'string'
-            ? attributesOrUndefined
-            : nameOrAttributes;
-        return isActive(this.state, name, attributes);
-    }
-    /**
-     * Get the document as JSON.
-     */
-    getJSON() {
-        return this.state.doc.toJSON();
-    }
-    /**
-     * Get the document as HTML.
-     */
-    getHTML() {
-        return getHTMLFromFragment(this.state.doc, this.schema);
-    }
-    /**
-     * Check if there is no content.
-     */
-    get isEmpty() {
-        return isNodeEmpty(this.state.doc);
-    }
-    /**
-     * Get the number of characters for the current document.
-     */
-    getCharacterCount() {
-        return this.state.doc.content.size - 2;
-    }
-    /**
-     * Destroy the editor.
-     */
-    destroy() {
-        this.emit('destroy');
-        if (this.view) {
-            this.view.destroy();
-        }
-        this.removeAllListeners();
-        removeElement(this.css);
-    }
-    /**
-     * Check if the editor is already destroyed.
-     */
-    get isDestroyed() {
-        var _a;
-        // @ts-ignore
-        return !((_a = this.view) === null || _a === void 0 ? void 0 : _a.docView);
-    }
-}
-
-class Node {
-    constructor(config = {}) {
-        this.type = 'node';
-        this.name = 'node';
-        this.parent = null;
-        this.child = null;
-        this.config = {
-            name: this.name,
-            defaultOptions: {},
-        };
-        this.config = {
-            ...this.config,
-            ...config,
-        };
-        this.name = this.config.name;
-        this.options = this.config.defaultOptions;
-    }
-    static create(config = {}) {
-        return new Node(config);
-    }
-    configure(options = {}) {
-        // return a new instance so we can use the same extension
-        // with different calls of `configure`
-        const extension = this.extend();
-        extension.options = mergeDeep(this.options, options);
-        return extension;
-    }
-    extend(extendedConfig = {}) {
-        const extension = new Node(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        extension.options = extendedConfig.defaultOptions
-            ? extendedConfig.defaultOptions
-            : extension.parent.options;
-        return extension;
-    }
-}
-
-class Mark {
-    constructor(config = {}) {
-        this.type = 'mark';
-        this.name = 'mark';
-        this.parent = null;
-        this.child = null;
-        this.config = {
-            name: this.name,
-            defaultOptions: {},
-        };
-        this.config = {
-            ...this.config,
-            ...config,
-        };
-        this.name = this.config.name;
-        this.options = this.config.defaultOptions;
-    }
-    static create(config = {}) {
-        return new Mark(config);
-    }
-    configure(options = {}) {
-        // return a new instance so we can use the same extension
-        // with different calls of `configure`
-        const extension = this.extend();
-        extension.options = mergeDeep(this.options, options);
-        return extension;
-    }
-    extend(extendedConfig = {}) {
-        const extension = new Mark(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        extension.options = extendedConfig.defaultOptions
-            ? extendedConfig.defaultOptions
-            : extension.parent.options;
-        return extension;
-    }
-}
-
-function isiOS() {
-    return [
-        'iPad Simulator',
-        'iPhone Simulator',
-        'iPod Simulator',
-        'iPad',
-        'iPhone',
-        'iPod',
-    ].includes(navigator.platform)
-        // iPad on iOS 13 detection
-        || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);
-}
-
-class NodeView {
-    constructor(component, props, options) {
-        this.isDragging = false;
-        this.component = component;
-        this.editor = props.editor;
-        this.options = {
-            stopEvent: null,
-            ignoreMutation: null,
-            ...options,
-        };
-        this.extension = props.extension;
-        this.node = props.node;
-        this.decorations = props.decorations;
-        this.getPos = props.getPos;
-        this.mount();
-    }
-    mount() {
-        // eslint-disable-next-line
-        return;
-    }
-    get dom() {
-        return null;
-    }
-    get contentDOM() {
-        return null;
-    }
-    onDragStart(event) {
-        var _a, _b, _c;
-        const { view } = this.editor;
-        const target = event.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;
-        }
-        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);
-    }
-    stopEvent(event) {
-        var _a;
-        if (!this.dom) {
-            return false;
-        }
-        if (typeof this.options.stopEvent === 'function') {
-            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));
-        // any event from child nodes should be handled by ProseMirror
-        if (!isInElement) {
-            return false;
-        }
-        const isInput = ['INPUT', 'BUTTON', 'SELECT', 'TEXTAREA'].includes(target.tagName)
-            || target.isContentEditable;
-        // any input event within node views should be ignored by ProseMirror
-        if (isInput) {
-            return true;
-        }
-        const { isEditable } = this.editor;
-        const { isDragging } = this;
-        const isDraggable = !!this.node.type.spec.draggable;
-        const isSelectable = prosemirrorState.NodeSelection.isSelectable(this.node);
-        const isCopyEvent = event.type === 'copy';
-        const isPasteEvent = event.type === 'paste';
-        const isCutEvent = event.type === 'cut';
-        const isClickEvent = event.type === 'mousedown';
-        const isDragEvent = event.type.startsWith('drag') || event.type === 'drop';
-        // ProseMirror tries to drag selectable nodes
-        // even if `draggable` is set to `false`
-        // this fix prevents that
-        if (!isDraggable && isSelectable && isDragEvent) {
-            event.preventDefault();
-        }
-        if (isDraggable && isDragEvent && !isDragging) {
-            event.preventDefault();
-            return false;
-        }
-        // we have to store that dragging started
-        if (isDraggable && isEditable && !isDragging && isClickEvent) {
-            const dragHandle = target.closest('[data-drag-handle]');
-            const isValidDragHandle = dragHandle
-                && (this.dom === dragHandle || (this.dom.contains(dragHandle)));
-            if (isValidDragHandle) {
-                this.isDragging = true;
-                document.addEventListener('dragend', () => {
-                    this.isDragging = false;
-                }, { once: true });
-                document.addEventListener('mouseup', () => {
-                    this.isDragging = false;
-                }, { once: true });
-            }
-        }
-        // these events are handled by prosemirror
-        if (isDragging
-            || isCopyEvent
-            || isPasteEvent
-            || isCutEvent
-            || (isClickEvent && isSelectable)) {
-            return false;
-        }
-        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') {
-            return false;
-        }
-        // 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()) {
-            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;
-        }
-        // ProseMirror should handle any changes within contentDOM
-        if (this.contentDOM.contains(mutation.target)) {
-            return false;
-        }
-        return true;
-    }
-    updateAttributes(attributes) {
-        this.editor.commands.command(({ tr }) => {
-            const pos = this.getPos();
-            tr.setNodeMarkup(pos, undefined, {
-                ...this.node.attrs,
-                ...attributes,
-            });
-            return true;
-        });
-    }
-    deleteNode() {
-        const from = this.getPos();
-        const to = from + this.node.nodeSize;
-        this.editor.commands.deleteRange({ from, to });
-    }
-}
-
-class Tracker {
-    constructor(transaction) {
-        this.transaction = transaction;
-        this.currentStep = this.transaction.steps.length;
-    }
-    map(position) {
-        let deleted = false;
-        const mappedPosition = this.transaction.steps
-            .slice(this.currentStep)
-            .reduce((newPosition, step) => {
-            const mapResult = step
-                .getMap()
-                .mapResult(newPosition);
-            if (mapResult.deleted) {
-                deleted = true;
-            }
-            return mapResult.pos;
-        }, position);
-        return {
-            position: mappedPosition,
-            deleted,
-        };
-    }
-}
-
-function nodeInputRule (regexp, type, getAttributes) {
-    return new 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;
-    });
-}
-
-function getMarksBetween(from, to, state) {
-    let marks = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        marks = [...marks, ...node.marks.map(mark => ({
-                from: pos,
-                to: pos + node.nodeSize,
-                mark,
-            }))];
-    });
-    return marks;
-}
-
-function markInputRule (regexp, markType, getAttributes) {
-    return new 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) {
-                return null;
-            }
-            if (textEnd < end) {
-                tr.delete(textEnd, end);
-            }
-            if (textStart > start) {
-                tr.delete(start + startSpaces, textStart);
-            }
-            markEnd = start + startSpaces + captureGroup.length;
-            tr.addMark(start + startSpaces, markEnd, markType.create(attributes));
-            tr.removeStoredMark(markType);
-        }
-        return tr;
-    });
-}
-
-function markPasteRule (regexp, type, getAttributes) {
-    const handler = (fragment, parent) => {
-        const nodes = [];
-        fragment.forEach(child => {
-            if (child.isText && child.text) {
-                const { text } = child;
-                let pos = 0;
-                let match;
-                // eslint-disable-next-line
-                while ((match = regexp.exec(text)) !== null) {
-                    const outerMatch = Math.max(match.length - 2, 0);
-                    const innerMatch = Math.max(match.length - 1, 0);
-                    if (parent === null || parent === void 0 ? void 0 : parent.type.allowsMarkType(type)) {
-                        const start = match.index;
-                        const matchStart = start + match[0].indexOf(match[outerMatch]);
-                        const matchEnd = matchStart + match[outerMatch].length;
-                        const textStart = matchStart + match[outerMatch].lastIndexOf(match[innerMatch]);
-                        const textEnd = textStart + match[innerMatch].length;
-                        const attrs = getAttributes instanceof Function
-                            ? getAttributes(match)
-                            : getAttributes;
-                        if (!attrs && attrs !== undefined) {
-                            continue;
-                        }
-                        // adding text before markdown to nodes
-                        if (matchStart > 0) {
-                            nodes.push(child.cut(pos, matchStart));
-                        }
-                        // adding the markdown part to nodes
-                        nodes.push(child
-                            .cut(textStart, textEnd)
-                            .mark(type.create(attrs).addToSet(child.marks)));
-                        pos = matchEnd;
-                    }
-                }
-                // adding rest of text to nodes
-                if (pos < text.length) {
-                    nodes.push(child.cut(pos));
-                }
-            }
-            else {
-                nodes.push(child.copy(handler(child.content, child)));
-            }
-        });
-        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);
-            },
-        },
-    });
-}
-
-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);
-}
-
-function generateJSON(html, extensions) {
-    const schema = getSchema(extensions);
-    const dom = elementFromString(html);
-    return prosemirrorModel.DOMParser.fromSchema(schema)
-        .parse(dom)
-        .toJSON();
-}
-
-/**
- * Returns a node tree with node positions.
- */
-function getDebugJSON(node, startOffset = 0) {
-    const nodes = [];
-    node.forEach((n, offset) => {
-        const from = startOffset + offset;
-        const to = from + n.nodeSize;
-        const marks = n.marks.map(mark => ({
-            type: mark.type.name,
-            attrs: { ...mark.attrs },
-        }));
-        const attrs = { ...n.attrs };
-        const content = getDebugJSON(n, from + 1);
-        const output = {
-            type: n.type.name,
-            from,
-            to,
-        };
-        if (Object.keys(attrs).length) {
-            output.attrs = attrs;
-        }
-        if (marks.length) {
-            output.marks = marks;
-        }
-        if (content.length) {
-            output.content = content;
-        }
-        if (n.text) {
-            output.text = n.text;
-        }
-        nodes.push(output);
-    });
-    return nodes;
-}
-
-function isNodeSelection(value) {
-    return isObject(value) && value instanceof prosemirrorState.NodeSelection;
-}
-
-function posToDOMRect(view, from, to) {
-    const start = view.coordsAtPos(from);
-    const end = view.coordsAtPos(to, -1);
-    const top = Math.min(start.top, end.top);
-    const bottom = Math.max(start.bottom, end.bottom);
-    const left = Math.min(start.left, end.left);
-    const right = Math.max(start.right, end.right);
-    const width = right - left;
-    const height = bottom - top;
-    const x = left;
-    const y = top;
-    const data = {
-        top,
-        bottom,
-        left,
-        right,
-        width,
-        height,
-        x,
-        y,
-    };
-    return {
-        ...data,
-        toJSON: () => data,
-    };
-}
-
-exports.Editor = Editor;
-exports.Extension = Extension;
-exports.Mark = Mark;
-exports.Node = Node;
-exports.NodeView = NodeView;
-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.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.isActive = isActive;
-exports.isList = isList;
-exports.isMarkActive = isMarkActive;
-exports.isNodeActive = isNodeActive;
-exports.isNodeEmpty = isNodeEmpty;
-exports.isNodeSelection = isNodeSelection;
-exports.isTextSelection = isTextSelection;
-exports.markInputRule = markInputRule;
-exports.markPasteRule = markPasteRule;
-exports.mergeAttributes = mergeAttributes;
-exports.nodeInputRule = nodeInputRule;
-exports.posToDOMRect = posToDOMRect;
-//# sourceMappingURL=tiptap-core.cjs.js.map