@tiptap/core 2.0.0-beta.182 → 2.0.0-beta.193

package/dist/tiptap-core.cjs.js

@@ -1,4275 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var prosemirrorState = require('prosemirror-state');
-var prosemirrorView = require('prosemirror-view');
-var prosemirrorKeymap = require('prosemirror-keymap');
-var prosemirrorModel = require('prosemirror-model');
-var prosemirrorTransform = require('prosemirror-transform');
-var prosemirrorCommands = require('prosemirror-commands');
-var prosemirrorSchemaList = require('prosemirror-schema-list');
-
-function createChainableState(config) {
-    const { state, transaction } = config;
-    let { selection } = transaction;
-    let { doc } = transaction;
-    let { storedMarks } = transaction;
-    return {
-        ...state,
-        apply: state.apply.bind(state),
-        applyTransaction: state.applyTransaction.bind(state),
-        filterTransaction: state.filterTransaction,
-        plugins: state.plugins,
-        schema: state.schema,
-        reconfigure: state.reconfigure.bind(state),
-        toJSON: state.toJSON.bind(state),
-        get storedMarks() {
-            return storedMarks;
-        },
-        get selection() {
-            return selection;
-        },
-        get doc() {
-            return doc;
-        },
-        get tr() {
-            selection = transaction.selection;
-            doc = transaction.doc;
-            storedMarks = transaction.storedMarks;
-            return transaction;
-        },
-    };
-}
-
-class CommandManager {
-    constructor(props) {
-        this.editor = props.editor;
-        this.rawCommands = this.editor.extensionManager.commands;
-        this.customState = props.state;
-    }
-    get hasCustomState() {
-        return !!this.customState;
-    }
-    get state() {
-        return this.customState || this.editor.state;
-    }
-    get commands() {
-        const { rawCommands, editor, state } = this;
-        const { view } = editor;
-        const { tr } = state;
-        const props = this.buildProps(tr);
-        return Object.fromEntries(Object
-            .entries(rawCommands)
-            .map(([name, command]) => {
-            const method = (...args) => {
-                const callback = command(...args)(props);
-                if (!tr.getMeta('preventDispatch') && !this.hasCustomState) {
-                    view.dispatch(tr);
-                }
-                return callback;
-            };
-            return [name, method];
-        }));
-    }
-    get chain() {
-        return () => this.createChain();
-    }
-    get can() {
-        return () => this.createCan();
-    }
-    createChain(startTr, shouldDispatch = true) {
-        const { rawCommands, editor, state } = this;
-        const { view } = editor;
-        const callbacks = [];
-        const hasStartTransaction = !!startTr;
-        const tr = startTr || state.tr;
-        const run = () => {
-            if (!hasStartTransaction
-                && shouldDispatch
-                && !tr.getMeta('preventDispatch')
-                && !this.hasCustomState) {
-                view.dispatch(tr);
-            }
-            return callbacks.every(callback => callback === true);
-        };
-        const chain = {
-            ...Object.fromEntries(Object.entries(rawCommands).map(([name, command]) => {
-                const chainedCommand = (...args) => {
-                    const props = this.buildProps(tr, shouldDispatch);
-                    const callback = command(...args)(props);
-                    callbacks.push(callback);
-                    return chain;
-                };
-                return [name, chainedCommand];
-            })),
-            run,
-        };
-        return chain;
-    }
-    createCan(startTr) {
-        const { rawCommands, state } = this;
-        const dispatch = undefined;
-        const tr = startTr || state.tr;
-        const props = this.buildProps(tr, dispatch);
-        const formattedCommands = Object.fromEntries(Object
-            .entries(rawCommands)
-            .map(([name, command]) => {
-            return [name, (...args) => command(...args)({ ...props, dispatch })];
-        }));
-        return {
-            ...formattedCommands,
-            chain: () => this.createChain(tr, dispatch),
-        };
-    }
-    buildProps(tr, shouldDispatch = true) {
-        const { rawCommands, editor, state } = this;
-        const { view } = editor;
-        if (state.storedMarks) {
-            tr.setStoredMarks(state.storedMarks);
-        }
-        const props = {
-            tr,
-            editor,
-            view,
-            state: createChainableState({
-                state,
-                transaction: tr,
-            }),
-            dispatch: shouldDispatch
-                ? () => undefined
-                : undefined,
-            chain: () => this.createChain(tr),
-            can: () => this.createCan(tr),
-            get commands() {
-                return Object.fromEntries(Object
-                    .entries(rawCommands)
-                    .map(([name, command]) => {
-                    return [name, (...args) => command(...args)(props)];
-                }));
-            },
-        };
-        return props;
-    }
-}
-
-class EventEmitter {
-    constructor() {
-        this.callbacks = {};
-    }
-    on(event, fn) {
-        if (!this.callbacks[event]) {
-            this.callbacks[event] = [];
-        }
-        this.callbacks[event].push(fn);
-        return this;
-    }
-    emit(event, ...args) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            callbacks.forEach(callback => callback.apply(this, args));
-        }
-        return this;
-    }
-    off(event, fn) {
-        const callbacks = this.callbacks[event];
-        if (callbacks) {
-            if (fn) {
-                this.callbacks[event] = callbacks.filter(callback => callback !== fn);
-            }
-            else {
-                delete this.callbacks[event];
-            }
-        }
-        return this;
-    }
-    removeAllListeners() {
-        this.callbacks = {};
-    }
-}
-
-function getExtensionField(extension, field, context) {
-    if (extension.config[field] === undefined && extension.parent) {
-        return getExtensionField(extension.parent, field, context);
-    }
-    if (typeof extension.config[field] === 'function') {
-        const value = extension.config[field].bind({
-            ...context,
-            parent: extension.parent
-                ? getExtensionField(extension.parent, field, context)
-                : null,
-        });
-        return value;
-    }
-    return extension.config[field];
-}
-
-function splitExtensions(extensions) {
-    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,
-        isRequired: false,
-    };
-    extensions.forEach(extension => {
-        const context = {
-            name: extension.name,
-            options: extension.options,
-            storage: extension.storage,
-        };
-        const addGlobalAttributes = getExtensionField(extension, 'addGlobalAttributes', context);
-        if (!addGlobalAttributes) {
-            return;
-        }
-        // TODO: remove `as GlobalAttributes`
-        const globalAttributes = addGlobalAttributes();
-        globalAttributes.forEach(globalAttribute => {
-            globalAttribute.types.forEach(type => {
-                Object
-                    .entries(globalAttribute.attributes)
-                    .forEach(([name, attribute]) => {
-                    extensionAttributes.push({
-                        type,
-                        name,
-                        attribute: {
-                            ...defaultAttribute,
-                            ...attribute,
-                        },
-                    });
-                });
-            });
-        });
-    });
-    nodeAndMarkExtensions.forEach(extension => {
-        const context = {
-            name: extension.name,
-            options: extension.options,
-            storage: extension.storage,
-        };
-        const addAttributes = getExtensionField(extension, 'addAttributes', context);
-        if (!addAttributes) {
-            return;
-        }
-        // TODO: remove `as Attributes`
-        const attributes = addAttributes();
-        Object
-            .entries(attributes)
-            .forEach(([name, attribute]) => {
-            const mergedAttr = {
-                ...defaultAttribute,
-                ...attribute,
-            };
-            if (attribute.isRequired && attribute.default === undefined) {
-                delete mergedAttr.default;
-            }
-            extensionAttributes.push({
-                type: extension.name,
-                name,
-                attribute: mergedAttr,
-            });
-        });
-    });
-    return extensionAttributes;
-}
-
-function getNodeType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        if (!schema.nodes[nameOrType]) {
-            throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-        }
-        return schema.nodes[nameOrType];
-    }
-    return nameOrType;
-}
-
-function mergeAttributes(...objects) {
-    return objects
-        .filter(item => !!item)
-        .reduce((items, item) => {
-        const mergedAttributes = { ...items };
-        Object.entries(item).forEach(([key, value]) => {
-            const exists = mergedAttributes[key];
-            if (!exists) {
-                mergedAttributes[key] = value;
-                return;
-            }
-            if (key === 'class') {
-                mergedAttributes[key] = [mergedAttributes[key], value].join(' ');
-            }
-            else if (key === 'style') {
-                mergedAttributes[key] = [mergedAttributes[key], value].join('; ');
-            }
-            else {
-                mergedAttributes[key] = value;
-            }
-        });
-        return mergedAttributes;
-    }, {});
-}
-
-function getRenderedAttributes(nodeOrMark, extensionAttributes) {
-    return extensionAttributes
-        .filter(item => item.attribute.rendered)
-        .map(item => {
-        if (!item.attribute.renderHTML) {
-            return {
-                [item.name]: nodeOrMark.attrs[item.name],
-            };
-        }
-        return item.attribute.renderHTML(nodeOrMark.attrs) || {};
-    })
-        .reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {});
-}
-
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-/**
- * Optionally calls `value` as a function.
- * Otherwise it is returned directly.
- * @param value Function or any value.
- * @param context Optional context to bind to function.
- * @param props Optional props to pass to function.
- */
-function callOrReturn(value, context = undefined, ...props) {
-    if (isFunction(value)) {
-        if (context) {
-            return value.bind(context)(...props);
-        }
-        return value(...props);
-    }
-    return value;
-}
-
-function isEmptyObject(value = {}) {
-    return Object.keys(value).length === 0 && value.constructor === Object;
-}
-
-function fromString(value) {
-    if (typeof value !== 'string') {
-        return value;
-    }
-    if (value.match(/^[+-]?(?:\d*\.)?\d+$/)) {
-        return Number(value);
-    }
-    if (value === 'true') {
-        return true;
-    }
-    if (value === 'false') {
-        return false;
-    }
-    return value;
-}
-
-/**
- * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
- * Cancels when `getAttrs` returned `false`.
- * @param parseRule ProseMirror ParseRule
- * @param extensionAttributes List of attributes to inject
- */
-function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
-    if (parseRule.style) {
-        return parseRule;
-    }
-    return {
-        ...parseRule,
-        getAttrs: node => {
-            const oldAttributes = parseRule.getAttrs
-                ? parseRule.getAttrs(node)
-                : parseRule.attrs;
-            if (oldAttributes === false) {
-                return false;
-            }
-            const newAttributes = extensionAttributes.reduce((items, item) => {
-                const value = item.attribute.parseHTML
-                    ? item.attribute.parseHTML(node)
-                    : fromString(node.getAttribute(item.name));
-                if (value === null || value === undefined) {
-                    return items;
-                }
-                return {
-                    ...items,
-                    [item.name]: value,
-                };
-            }, {});
-            return { ...oldAttributes, ...newAttributes };
-        },
-    };
-}
-
-function cleanUpSchemaItem(data) {
-    return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-        if (key === 'attrs' && isEmptyObject(value)) {
-            return false;
-        }
-        return value !== null && value !== undefined;
-    }));
-}
-function getSchemaByResolvedExtensions(extensions) {
-    var _a;
-    const allAttributes = getAttributesFromExtensions(extensions);
-    const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-    const topNode = (_a = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))) === null || _a === void 0 ? void 0 : _a.name;
-    const nodes = Object.fromEntries(nodeExtensions.map(extension => {
-        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name);
-        const context = {
-            name: extension.name,
-            options: extension.options,
-            storage: extension.storage,
-        };
-        const extraNodeFields = extensions.reduce((fields, e) => {
-            const extendNodeSchema = getExtensionField(e, 'extendNodeSchema', context);
-            return {
-                ...fields,
-                ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
-            };
-        }, {});
-        const schema = cleanUpSchemaItem({
-            ...extraNodeFields,
-            content: callOrReturn(getExtensionField(extension, 'content', context)),
-            marks: callOrReturn(getExtensionField(extension, 'marks', context)),
-            group: callOrReturn(getExtensionField(extension, 'group', context)),
-            inline: callOrReturn(getExtensionField(extension, 'inline', context)),
-            atom: callOrReturn(getExtensionField(extension, 'atom', context)),
-            selectable: callOrReturn(getExtensionField(extension, 'selectable', context)),
-            draggable: callOrReturn(getExtensionField(extension, 'draggable', context)),
-            code: callOrReturn(getExtensionField(extension, 'code', context)),
-            defining: callOrReturn(getExtensionField(extension, 'defining', context)),
-            isolating: callOrReturn(getExtensionField(extension, 'isolating', context)),
-            attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-                var _a;
-                return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
-            })),
-        });
-        const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
-        if (parseHTML) {
-            schema.parseDOM = parseHTML
-                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-        }
-        const renderHTML = getExtensionField(extension, 'renderHTML', context);
-        if (renderHTML) {
-            schema.toDOM = node => renderHTML({
-                node,
-                HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-            });
-        }
-        const renderText = getExtensionField(extension, 'renderText', context);
-        if (renderText) {
-            schema.toText = renderText;
-        }
-        return [extension.name, schema];
-    }));
-    const marks = Object.fromEntries(markExtensions.map(extension => {
-        const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name);
-        const context = {
-            name: extension.name,
-            options: extension.options,
-            storage: extension.storage,
-        };
-        const extraMarkFields = extensions.reduce((fields, e) => {
-            const extendMarkSchema = getExtensionField(e, 'extendMarkSchema', context);
-            return {
-                ...fields,
-                ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
-            };
-        }, {});
-        const schema = cleanUpSchemaItem({
-            ...extraMarkFields,
-            inclusive: callOrReturn(getExtensionField(extension, 'inclusive', context)),
-            excludes: callOrReturn(getExtensionField(extension, 'excludes', context)),
-            group: callOrReturn(getExtensionField(extension, 'group', context)),
-            spanning: callOrReturn(getExtensionField(extension, 'spanning', context)),
-            code: callOrReturn(getExtensionField(extension, 'code', context)),
-            attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-                var _a;
-                return [extensionAttribute.name, { default: (_a = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a === void 0 ? void 0 : _a.default }];
-            })),
-        });
-        const parseHTML = callOrReturn(getExtensionField(extension, 'parseHTML', context));
-        if (parseHTML) {
-            schema.parseDOM = parseHTML
-                .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-        }
-        const renderHTML = getExtensionField(extension, 'renderHTML', context);
-        if (renderHTML) {
-            schema.toDOM = mark => renderHTML({
-                mark,
-                HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-            });
-        }
-        return [extension.name, schema];
-    }));
-    return new prosemirrorModel.Schema({
-        topNode,
-        nodes,
-        marks,
-    });
-}
-
-function getSchemaTypeByName(name, schema) {
-    return schema.nodes[name] || schema.marks[name] || null;
-}
-
-function isExtensionRulesEnabled(extension, enabled) {
-    if (Array.isArray(enabled)) {
-        return enabled.some(enabledExtension => {
-            const name = typeof enabledExtension === 'string'
-                ? enabledExtension
-                : enabledExtension.name;
-            return name === extension.name;
-        });
-    }
-    return enabled;
-}
-
-const getTextContentFromNodes = ($from, maxMatch = 500) => {
-    let textBefore = '';
-    $from.parent.nodesBetween(Math.max(0, $from.parentOffset - maxMatch), $from.parentOffset, (node, pos, parent, index) => {
-        var _a, _b, _c;
-        textBefore += ((_b = (_a = node.type.spec).toText) === null || _b === void 0 ? void 0 : _b.call(_a, {
-            node, pos, parent, index,
-        })) || ((_c = $from.nodeBefore) === null || _c === void 0 ? void 0 : _c.text) || '%leaf%';
-    });
-    return textBefore;
-};
-
-function isRegExp(value) {
-    return Object.prototype.toString.call(value) === '[object RegExp]';
-}
-
-class InputRule {
-    constructor(config) {
-        this.find = config.find;
-        this.handler = config.handler;
-    }
-}
-const inputRuleMatcherHandler = (text, find) => {
-    if (isRegExp(find)) {
-        return find.exec(text);
-    }
-    const inputRuleMatch = find(text);
-    if (!inputRuleMatch) {
-        return null;
-    }
-    const result = [];
-    result.push(inputRuleMatch.text);
-    result.index = inputRuleMatch.index;
-    result.input = text;
-    result.data = inputRuleMatch.data;
-    if (inputRuleMatch.replaceWith) {
-        if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
-            console.warn('[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".');
-        }
-        result.push(inputRuleMatch.replaceWith);
-    }
-    return result;
-};
-function run$1(config) {
-    var _a;
-    const { editor, from, to, text, rules, plugin, } = config;
-    const { view } = editor;
-    if (view.composing) {
-        return false;
-    }
-    const $from = view.state.doc.resolve(from);
-    if (
-    // check for code node
-    $from.parent.type.spec.code
-        // check for code mark
-        || !!((_a = ($from.nodeBefore || $from.nodeAfter)) === null || _a === void 0 ? void 0 : _a.marks.find(mark => mark.type.spec.code))) {
-        return false;
-    }
-    let matched = false;
-    const textBefore = getTextContentFromNodes($from) + text;
-    rules.forEach(rule => {
-        if (matched) {
-            return;
-        }
-        const match = inputRuleMatcherHandler(textBefore, rule.find);
-        if (!match) {
-            return;
-        }
-        const tr = view.state.tr;
-        const state = createChainableState({
-            state: view.state,
-            transaction: tr,
-        });
-        const range = {
-            from: from - (match[0].length - text.length),
-            to,
-        };
-        const { commands, chain, can } = new CommandManager({
-            editor,
-            state,
-        });
-        const handler = rule.handler({
-            state,
-            range,
-            match,
-            commands,
-            chain,
-            can,
-        });
-        // stop if there are no changes
-        if (handler === null || !tr.steps.length) {
-            return;
-        }
-        // store transform as meta data
-        // so we can undo input rules within the `undoInputRules` command
-        tr.setMeta(plugin, {
-            transform: tr,
-            from,
-            to,
-            text,
-        });
-        view.dispatch(tr);
-        matched = true;
-    });
-    return matched;
-}
-/**
- * Create an input rules plugin. When enabled, it will cause text
- * input that matches any of the given rules to trigger the rule’s
- * action.
- */
-function inputRulesPlugin(props) {
-    const { editor, rules } = props;
-    const plugin = new prosemirrorState.Plugin({
-        state: {
-            init() {
-                return null;
-            },
-            apply(tr, prev) {
-                const stored = tr.getMeta(plugin);
-                if (stored) {
-                    return stored;
-                }
-                return tr.selectionSet || tr.docChanged
-                    ? null
-                    : prev;
-            },
-        },
-        props: {
-            handleTextInput(view, from, to, text) {
-                return run$1({
-                    editor,
-                    from,
-                    to,
-                    text,
-                    rules,
-                    plugin,
-                });
-            },
-            handleDOMEvents: {
-                compositionend: view => {
-                    setTimeout(() => {
-                        const { $cursor } = view.state.selection;
-                        if ($cursor) {
-                            run$1({
-                                editor,
-                                from: $cursor.pos,
-                                to: $cursor.pos,
-                                text: '',
-                                rules,
-                                plugin,
-                            });
-                        }
-                    });
-                    return false;
-                },
-            },
-            // add support for input rules to trigger on enter
-            // this is useful for example for code blocks
-            handleKeyDown(view, event) {
-                if (event.key !== 'Enter') {
-                    return false;
-                }
-                const { $cursor } = view.state.selection;
-                if ($cursor) {
-                    return run$1({
-                        editor,
-                        from: $cursor.pos,
-                        to: $cursor.pos,
-                        text: '\n',
-                        rules,
-                        plugin,
-                    });
-                }
-                return false;
-            },
-        },
-        // @ts-ignore
-        isInputRules: true,
-    });
-    return plugin;
-}
-
-function isNumber(value) {
-    return typeof value === 'number';
-}
-
-class PasteRule {
-    constructor(config) {
-        this.find = config.find;
-        this.handler = config.handler;
-    }
-}
-const pasteRuleMatcherHandler = (text, find) => {
-    if (isRegExp(find)) {
-        return [...text.matchAll(find)];
-    }
-    const matches = find(text);
-    if (!matches) {
-        return [];
-    }
-    return matches.map(pasteRuleMatch => {
-        const result = [];
-        result.push(pasteRuleMatch.text);
-        result.index = pasteRuleMatch.index;
-        result.input = text;
-        result.data = pasteRuleMatch.data;
-        if (pasteRuleMatch.replaceWith) {
-            if (!pasteRuleMatch.text.includes(pasteRuleMatch.replaceWith)) {
-                console.warn('[tiptap warn]: "pasteRuleMatch.replaceWith" must be part of "pasteRuleMatch.text".');
-            }
-            result.push(pasteRuleMatch.replaceWith);
-        }
-        return result;
-    });
-};
-function run(config) {
-    const { editor, state, from, to, rule, } = config;
-    const { commands, chain, can } = new CommandManager({
-        editor,
-        state,
-    });
-    const handlers = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        if (!node.isTextblock || node.type.spec.code) {
-            return;
-        }
-        const resolvedFrom = Math.max(from, pos);
-        const resolvedTo = Math.min(to, pos + node.content.size);
-        const textToMatch = node.textBetween(resolvedFrom - pos, resolvedTo - pos, undefined, '\ufffc');
-        const matches = pasteRuleMatcherHandler(textToMatch, rule.find);
-        matches.forEach(match => {
-            if (match.index === undefined) {
-                return;
-            }
-            const start = resolvedFrom + match.index + 1;
-            const end = start + match[0].length;
-            const range = {
-                from: state.tr.mapping.map(start),
-                to: state.tr.mapping.map(end),
-            };
-            const handler = rule.handler({
-                state,
-                range,
-                match,
-                commands,
-                chain,
-                can,
-            });
-            handlers.push(handler);
-        });
-    });
-    const success = handlers.every(handler => handler !== null);
-    return success;
-}
-/**
- * Create an paste rules plugin. When enabled, it will cause pasted
- * text that matches any of the given rules to trigger the rule’s
- * action.
- */
-function pasteRulesPlugin(props) {
-    const { editor, rules } = props;
-    let dragSourceElement = null;
-    let isPastedFromProseMirror = false;
-    let isDroppedFromProseMirror = false;
-    const plugins = rules.map(rule => {
-        return new prosemirrorState.Plugin({
-            // we register a global drag handler to track the current drag source element
-            view(view) {
-                const handleDragstart = (event) => {
-                    var _a;
-                    dragSourceElement = ((_a = view.dom.parentElement) === null || _a === void 0 ? void 0 : _a.contains(event.target))
-                        ? view.dom.parentElement
-                        : null;
-                };
-                window.addEventListener('dragstart', handleDragstart);
-                return {
-                    destroy() {
-                        window.removeEventListener('dragstart', handleDragstart);
-                    },
-                };
-            },
-            props: {
-                handleDOMEvents: {
-                    drop: view => {
-                        isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
-                        return false;
-                    },
-                    paste: (view, event) => {
-                        var _a;
-                        const html = (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text/html');
-                        isPastedFromProseMirror = !!(html === null || html === void 0 ? void 0 : html.includes('data-pm-slice'));
-                        return false;
-                    },
-                },
-            },
-            appendTransaction: (transactions, oldState, state) => {
-                const transaction = transactions[0];
-                const isPaste = transaction.getMeta('uiEvent') === 'paste' && !isPastedFromProseMirror;
-                const isDrop = transaction.getMeta('uiEvent') === 'drop' && !isDroppedFromProseMirror;
-                if (!isPaste && !isDrop) {
-                    return;
-                }
-                // stop if there is no changed range
-                const from = oldState.doc.content.findDiffStart(state.doc.content);
-                const to = oldState.doc.content.findDiffEnd(state.doc.content);
-                if (!isNumber(from) || !to || from === to.b) {
-                    return;
-                }
-                // build a chainable state
-                // so we can use a single transaction for all paste rules
-                const tr = state.tr;
-                const chainableState = createChainableState({
-                    state,
-                    transaction: tr,
-                });
-                const handler = run({
-                    editor,
-                    state: chainableState,
-                    from: Math.max(from - 1, 0),
-                    to: to.b,
-                    rule,
-                });
-                // stop if there are no changes
-                if (!handler || !tr.steps.length) {
-                    return;
-                }
-                return tr;
-            },
-        });
-    });
-    return plugins;
-}
-
-function findDuplicates(items) {
-    const filtered = items.filter((el, index) => items.indexOf(el) !== index);
-    return [...new Set(filtered)];
-}
-
-class ExtensionManager {
-    constructor(extensions, editor) {
-        this.splittableMarks = [];
-        this.editor = editor;
-        this.extensions = ExtensionManager.resolve(extensions);
-        this.schema = getSchemaByResolvedExtensions(this.extensions);
-        this.extensions.forEach(extension => {
-            var _a;
-            // store extension storage in editor
-            this.editor.extensionStorage[extension.name] = extension.storage;
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                storage: extension.storage,
-                editor: this.editor,
-                type: getSchemaTypeByName(extension.name, this.schema),
-            };
-            if (extension.type === 'mark') {
-                const keepOnSplit = (_a = callOrReturn(getExtensionField(extension, 'keepOnSplit', context))) !== null && _a !== void 0 ? _a : true;
-                if (keepOnSplit) {
-                    this.splittableMarks.push(extension.name);
-                }
-            }
-            const onBeforeCreate = getExtensionField(extension, 'onBeforeCreate', context);
-            if (onBeforeCreate) {
-                this.editor.on('beforeCreate', onBeforeCreate);
-            }
-            const onCreate = getExtensionField(extension, 'onCreate', context);
-            if (onCreate) {
-                this.editor.on('create', onCreate);
-            }
-            const onUpdate = getExtensionField(extension, 'onUpdate', context);
-            if (onUpdate) {
-                this.editor.on('update', onUpdate);
-            }
-            const onSelectionUpdate = getExtensionField(extension, 'onSelectionUpdate', context);
-            if (onSelectionUpdate) {
-                this.editor.on('selectionUpdate', onSelectionUpdate);
-            }
-            const onTransaction = getExtensionField(extension, 'onTransaction', context);
-            if (onTransaction) {
-                this.editor.on('transaction', onTransaction);
-            }
-            const onFocus = getExtensionField(extension, 'onFocus', context);
-            if (onFocus) {
-                this.editor.on('focus', onFocus);
-            }
-            const onBlur = getExtensionField(extension, 'onBlur', context);
-            if (onBlur) {
-                this.editor.on('blur', onBlur);
-            }
-            const onDestroy = getExtensionField(extension, 'onDestroy', context);
-            if (onDestroy) {
-                this.editor.on('destroy', onDestroy);
-            }
-        });
-    }
-    static resolve(extensions) {
-        const resolvedExtensions = ExtensionManager.sort(ExtensionManager.flatten(extensions));
-        const duplicatedNames = findDuplicates(resolvedExtensions.map(extension => extension.name));
-        if (duplicatedNames.length) {
-            console.warn(`[tiptap warn]: Duplicate extension names found: [${duplicatedNames.map(item => `'${item}'`).join(', ')}]. This can lead to issues.`);
-        }
-        return resolvedExtensions;
-    }
-    static flatten(extensions) {
-        return extensions
-            .map(extension => {
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                storage: extension.storage,
-            };
-            const addExtensions = getExtensionField(extension, 'addExtensions', context);
-            if (addExtensions) {
-                return [
-                    extension,
-                    ...this.flatten(addExtensions()),
-                ];
-            }
-            return extension;
-        })
-            // `Infinity` will break TypeScript so we set a number that is probably high enough
-            .flat(10);
-    }
-    static sort(extensions) {
-        const defaultPriority = 100;
-        return extensions.sort((a, b) => {
-            const priorityA = getExtensionField(a, 'priority') || defaultPriority;
-            const priorityB = getExtensionField(b, 'priority') || defaultPriority;
-            if (priorityA > priorityB) {
-                return -1;
-            }
-            if (priorityA < priorityB) {
-                return 1;
-            }
-            return 0;
-        });
-    }
-    get commands() {
-        return this.extensions.reduce((commands, extension) => {
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                storage: extension.storage,
-                editor: this.editor,
-                type: getSchemaTypeByName(extension.name, this.schema),
-            };
-            const addCommands = getExtensionField(extension, 'addCommands', context);
-            if (!addCommands) {
-                return commands;
-            }
-            return {
-                ...commands,
-                ...addCommands(),
-            };
-        }, {});
-    }
-    get plugins() {
-        const { editor } = this;
-        // With ProseMirror, first plugins within an array are executed first.
-        // In tiptap, we provide the ability to override plugins,
-        // so it feels more natural to run plugins at the end of an array first.
-        // That’s why we have to reverse the `extensions` array and sort again
-        // based on the `priority` option.
-        const extensions = ExtensionManager.sort([...this.extensions].reverse());
-        const inputRules = [];
-        const pasteRules = [];
-        const allPlugins = extensions
-            .map(extension => {
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                storage: extension.storage,
-                editor,
-                type: getSchemaTypeByName(extension.name, this.schema),
-            };
-            const plugins = [];
-            const addKeyboardShortcuts = getExtensionField(extension, 'addKeyboardShortcuts', context);
-            if (addKeyboardShortcuts) {
-                const bindings = Object.fromEntries(Object
-                    .entries(addKeyboardShortcuts())
-                    .map(([shortcut, method]) => {
-                    return [shortcut, () => method({ editor })];
-                }));
-                const keyMapPlugin = prosemirrorKeymap.keymap(bindings);
-                plugins.push(keyMapPlugin);
-            }
-            const addInputRules = getExtensionField(extension, 'addInputRules', context);
-            if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
-                inputRules.push(...addInputRules());
-            }
-            const addPasteRules = getExtensionField(extension, 'addPasteRules', context);
-            if (isExtensionRulesEnabled(extension, editor.options.enablePasteRules) && addPasteRules) {
-                pasteRules.push(...addPasteRules());
-            }
-            const addProseMirrorPlugins = getExtensionField(extension, 'addProseMirrorPlugins', context);
-            if (addProseMirrorPlugins) {
-                const proseMirrorPlugins = addProseMirrorPlugins();
-                plugins.push(...proseMirrorPlugins);
-            }
-            return plugins;
-        })
-            .flat();
-        return [
-            inputRulesPlugin({
-                editor,
-                rules: inputRules,
-            }),
-            ...pasteRulesPlugin({
-                editor,
-                rules: pasteRules,
-            }),
-            ...allPlugins,
-        ];
-    }
-    get attributes() {
-        return getAttributesFromExtensions(this.extensions);
-    }
-    get nodeViews() {
-        const { editor } = this;
-        const { nodeExtensions } = splitExtensions(this.extensions);
-        return Object.fromEntries(nodeExtensions
-            .filter(extension => !!getExtensionField(extension, 'addNodeView'))
-            .map(extension => {
-            const extensionAttributes = this.attributes.filter(attribute => attribute.type === extension.name);
-            const context = {
-                name: extension.name,
-                options: extension.options,
-                storage: extension.storage,
-                editor,
-                type: getNodeType(extension.name, this.schema),
-            };
-            const addNodeView = getExtensionField(extension, 'addNodeView', context);
-            if (!addNodeView) {
-                return [];
-            }
-            const nodeview = (node, view, getPos, decorations) => {
-                const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
-                return addNodeView()({
-                    editor,
-                    node,
-                    getPos,
-                    decorations,
-                    HTMLAttributes,
-                    extension,
-                });
-            };
-            return [extension.name, nodeview];
-        }));
-    }
-}
-
-// see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
-function getType(value) {
-    return Object.prototype.toString.call(value).slice(8, -1);
-}
-function isPlainObject(value) {
-    if (getType(value) !== 'Object') {
-        return false;
-    }
-    return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
-}
-
-function 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;
-        if (config.defaultOptions) {
-            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-        }
-        // TODO: remove `addOptions` fallback
-        this.options = this.config.defaultOptions;
-        if (this.config.addOptions) {
-            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
-                name: this.name,
-            }));
-        }
-        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
-            name: this.name,
-            options: this.options,
-        })) || {};
-    }
-    static create(config = {}) {
-        return new Extension(config);
-    }
-    configure(options = {}) {
-        // return a new instance so we can use the same extension
-        // with different calls of `configure`
-        const extension = this.extend();
-        extension.options = mergeDeep(this.options, options);
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
-        return extension;
-    }
-    extend(extendedConfig = {}) {
-        const extension = new Extension(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        if (extendedConfig.defaultOptions) {
-            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-        }
-        extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
-            name: extension.name,
-        }));
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
-        return extension;
-    }
-}
-
-function getTextBetween(startNode, range, options) {
-    const { from, to } = range;
-    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
-    let text = '';
-    let separated = true;
-    startNode.nodesBetween(from, to, (node, pos, parent, index) => {
-        var _a;
-        const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
-        if (textSerializer) {
-            if (node.isBlock && !separated) {
-                text += blockSeparator;
-                separated = true;
-            }
-            if (parent) {
-                text += textSerializer({
-                    node,
-                    pos,
-                    parent,
-                    index,
-                    range,
-                });
-            }
-        }
-        else if (node.isText) {
-            text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos); // eslint-disable-line
-            separated = false;
-        }
-        else if (node.isBlock && !separated) {
-            text += blockSeparator;
-            separated = true;
-        }
-    });
-    return text;
-}
-
-function getTextSerializersFromSchema(schema) {
-    return Object.fromEntries(Object
-        .entries(schema.nodes)
-        .filter(([, node]) => node.spec.toText)
-        .map(([name, node]) => [name, node.spec.toText]));
-}
-
-const ClipboardTextSerializer = Extension.create({
-    name: 'clipboardTextSerializer',
-    addProseMirrorPlugins() {
-        return [
-            new prosemirrorState.Plugin({
-                key: new prosemirrorState.PluginKey('clipboardTextSerializer'),
-                props: {
-                    clipboardTextSerializer: () => {
-                        const { editor } = this;
-                        const { state, schema } = editor;
-                        const { doc, selection } = state;
-                        const { ranges } = selection;
-                        const from = Math.min(...ranges.map(range => range.$from.pos));
-                        const to = Math.max(...ranges.map(range => range.$to.pos));
-                        const textSerializers = getTextSerializersFromSchema(schema);
-                        const range = { from, to };
-                        return getTextBetween(doc, range, {
-                            textSerializers,
-                        });
-                    },
-                },
-            }),
-        ];
-    },
-});
-
-const blur = () => ({ editor, view }) => {
-    requestAnimationFrame(() => {
-        var _a;
-        if (!editor.isDestroyed) {
-            view.dom.blur();
-            // Browsers should remove the caret on blur but safari does not.
-            // See: https://github.com/ueberdosis/tiptap/issues/2405
-            (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
-        }
-    });
-    return true;
-};
-
-const clearContent = (emitUpdate = false) => ({ commands }) => {
-    return commands.setContent('', emitUpdate);
-};
-
-const clearNodes = () => ({ state, tr, dispatch }) => {
-    const { selection } = tr;
-    const { ranges } = selection;
-    if (!dispatch) {
-        return true;
-    }
-    ranges.forEach(({ $from, $to }) => {
-        state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
-            if (node.type.isText) {
-                return;
-            }
-            const { doc, mapping } = tr;
-            const $mappedFrom = doc.resolve(mapping.map(pos));
-            const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize));
-            const nodeRange = $mappedFrom.blockRange($mappedTo);
-            if (!nodeRange) {
-                return;
-            }
-            const targetLiftDepth = prosemirrorTransform.liftTarget(nodeRange);
-            if (node.type.isTextblock) {
-                const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
-                tr.setNodeMarkup(nodeRange.start, defaultType);
-            }
-            if (targetLiftDepth || targetLiftDepth === 0) {
-                tr.lift(nodeRange, targetLiftDepth);
-            }
-        });
-    });
-    return true;
-};
-
-const command = fn => props => {
-    return fn(props);
-};
-
-const createParagraphNear = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.createParagraphNear(state, dispatch);
-};
-
-const deleteNode = typeOrName => ({ tr, state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const $pos = tr.selection.$anchor;
-    for (let depth = $pos.depth; depth > 0; depth -= 1) {
-        const node = $pos.node(depth);
-        if (node.type === type) {
-            if (dispatch) {
-                const from = $pos.before(depth);
-                const to = $pos.after(depth);
-                tr.delete(from, to).scrollIntoView();
-            }
-            return true;
-        }
-    }
-    return false;
-};
-
-const deleteRange = range => ({ tr, dispatch }) => {
-    const { from, to } = range;
-    if (dispatch) {
-        tr.delete(from, to);
-    }
-    return true;
-};
-
-const deleteSelection = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.deleteSelection(state, dispatch);
-};
-
-const enter = () => ({ commands }) => {
-    return commands.keyboardShortcut('Enter');
-};
-
-const exitCode = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.exitCode(state, dispatch);
-};
-
-/**
- * Check if object1 includes object2
- * @param object1 Object
- * @param object2 Object
- */
-function objectIncludes(object1, object2, options = { strict: true }) {
-    const keys = Object.keys(object2);
-    if (!keys.length) {
-        return true;
-    }
-    return keys.every(key => {
-        if (options.strict) {
-            return object2[key] === object1[key];
-        }
-        if (isRegExp(object2[key])) {
-            return object2[key].test(object1[key]);
-        }
-        return object2[key] === object1[key];
-    });
-}
-
-function findMarkInSet(marks, type, attributes = {}) {
-    return marks.find(item => {
-        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;
-    }
-    let start = $pos.parent.childAfter($pos.parentOffset);
-    if ($pos.parentOffset === start.offset && start.offset !== 0) {
-        start = $pos.parent.childBefore($pos.parentOffset);
-    }
-    if (!start.node) {
-        return;
-    }
-    const mark = findMarkInSet([...start.node.marks], type, attributes);
-    if (!mark) {
-        return;
-    }
-    let startIndex = start.index;
-    let startPos = $pos.start() + start.offset;
-    let endIndex = startIndex + 1;
-    let endPos = startPos + start.node.nodeSize;
-    findMarkInSet([...start.node.marks], type, attributes);
-    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,
-    };
-}
-
-function getMarkType(nameOrType, schema) {
-    if (typeof nameOrType === 'string') {
-        if (!schema.marks[nameOrType]) {
-            throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-        }
-        return schema.marks[nameOrType];
-    }
-    return nameOrType;
-}
-
-const extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const type = getMarkType(typeOrName, state.schema);
-    const { doc, selection } = tr;
-    const { $from, 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;
-};
-
-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;
-};
-
-function isClass(value) {
-    var _a;
-    if (((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.toString().substring(0, 5)) !== 'class') {
-        return false;
-    }
-    return true;
-}
-
-function isObject(value) {
-    return (value
-        && typeof value === 'object'
-        && !Array.isArray(value)
-        && !isClass(value));
-}
-
-function isTextSelection(value) {
-    return isObject(value) && value instanceof prosemirrorState.TextSelection;
-}
-
-function minMax(value = 0, min = 0, max = 0) {
-    return Math.min(Math.max(value, min), max);
-}
-
-function resolveFocusPosition(doc, position = null) {
-    if (!position) {
-        return null;
-    }
-    const selectionAtStart = prosemirrorState.Selection.atStart(doc);
-    const selectionAtEnd = prosemirrorState.Selection.atEnd(doc);
-    if (position === 'start' || position === true) {
-        return selectionAtStart;
-    }
-    if (position === 'end') {
-        return selectionAtEnd;
-    }
-    const minPos = selectionAtStart.from;
-    const maxPos = selectionAtEnd.to;
-    if (position === 'all') {
-        return prosemirrorState.TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-    }
-    return prosemirrorState.TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-
-function isiOS() {
-    return [
-        'iPad Simulator',
-        'iPhone Simulator',
-        'iPod Simulator',
-        'iPad',
-        'iPhone',
-        'iPod',
-    ].includes(navigator.platform)
-        // iPad on iOS 13 detection
-        || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);
-}
-
-const focus = (position = null, options = {}) => ({ editor, view, tr, dispatch, }) => {
-    options = {
-        scrollIntoView: true,
-        ...options,
-    };
-    const delayedFocus = () => {
-        // focus within `requestAnimationFrame` breaks focus on iOS
-        // so we have to call this
-        if (isiOS()) {
-            view.dom.focus();
-        }
-        // For React we have to focus asynchronously. Otherwise wild things happen.
-        // see: https://github.com/ueberdosis/tiptap/issues/1520
-        requestAnimationFrame(() => {
-            if (!editor.isDestroyed) {
-                view.focus();
-                if (options === null || options === void 0 ? void 0 : options.scrollIntoView) {
-                    editor.commands.scrollIntoView();
-                }
-            }
-        });
-    };
-    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;
-    }
-    // pass through tr.doc instead of editor.state.doc
-    // since transactions could change the editors state before this command has been run
-    const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
-    const isSameSelection = editor.state.selection.eq(selection);
-    if (dispatch) {
-        if (!isSameSelection) {
-            tr.setSelection(selection);
-        }
-        // `tr.setSelection` resets the stored marks
-        // so we’ll restore them if the selection is the same as before
-        if (isSameSelection && tr.storedMarks) {
-            tr.setStoredMarks(tr.storedMarks);
-        }
-        delayedFocus();
-    }
-    return true;
-};
-
-const forEach = (items, fn) => props => {
-    return items.every((item, index) => fn(item, { ...props, index }));
-};
-
-const insertContent = (value, options) => ({ tr, commands }) => {
-    return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-};
-
-function elementFromString(value) {
-    // add a wrapper to preserve leading and trailing whitespace
-    const wrappedValue = `<body>${value}</body>`;
-    return new window.DOMParser().parseFromString(wrappedValue, 'text/html').body;
-}
-
-function createNodeFromContent(content, schema, options) {
-    options = {
-        slice: true,
-        parseOptions: {},
-        ...options,
-    };
-    if (typeof content === 'object' && content !== null) {
-        try {
-            if (Array.isArray(content)) {
-                return prosemirrorModel.Fragment.fromArray(content.map(item => schema.nodeFromJSON(item)));
-            }
-            return schema.nodeFromJSON(content);
-        }
-        catch (error) {
-            console.warn('[tiptap warn]: Invalid content.', 'Passed value:', content, 'Error:', error);
-            return createNodeFromContent('', schema, options);
-        }
-    }
-    if (typeof content === 'string') {
-        const parser = prosemirrorModel.DOMParser.fromSchema(schema);
-        return options.slice
-            ? parser.parseSlice(elementFromString(content), options.parseOptions).content
-            : parser.parse(elementFromString(content), options.parseOptions);
-    }
-    return createNodeFromContent('', schema, options);
-}
-
-// source: https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.js#L466
-function selectionToInsertionEnd(tr, startLen, bias) {
-    const last = tr.steps.length - 1;
-    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 isFragment = (nodeOrFragment) => {
-    return nodeOrFragment.toString().startsWith('<');
-};
-const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
-    if (dispatch) {
-        options = {
-            parseOptions: {},
-            updateSelection: true,
-            ...options,
-        };
-        const content = createNodeFromContent(value, editor.schema, {
-            parseOptions: {
-                preserveWhitespace: 'full',
-                ...options.parseOptions,
-            },
-        });
-        // don’t dispatch an empty fragment because this can lead to strange errors
-        if (content.toString() === '<>') {
-            return true;
-        }
-        let { from, to } = typeof position === 'number'
-            ? { from: position, to: position }
-            : position;
-        let isOnlyTextContent = true;
-        let isOnlyBlockContent = true;
-        const nodes = isFragment(content)
-            ? content
-            : [content];
-        nodes.forEach(node => {
-            // check if added node is valid
-            node.check();
-            isOnlyTextContent = isOnlyTextContent
-                ? node.isText && node.marks.length === 0
-                : false;
-            isOnlyBlockContent = isOnlyBlockContent
-                ? node.isBlock
-                : false;
-        });
-        // check if we can replace the wrapping node by
-        // the newly inserted content
-        // example:
-        // replace an empty paragraph by an inserted image
-        // instead of inserting the image below the paragraph
-        if (from === to && isOnlyBlockContent) {
-            const { parent } = tr.doc.resolve(from);
-            const isEmptyTextBlock = parent.isTextblock
-                && !parent.type.spec.code
-                && !parent.childCount;
-            if (isEmptyTextBlock) {
-                from -= 1;
-                to += 1;
-            }
-        }
-        // if there is only plain text we have to use `insertText`
-        // because this will keep the current marks
-        if (isOnlyTextContent) {
-            tr.insertText(value, from, to);
-        }
-        else {
-            tr.replaceWith(from, to, content);
-        }
-        // set cursor at end of inserted content
-        if (options.updateSelection) {
-            selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-        }
-    }
-    return true;
-};
-
-const joinBackward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.joinBackward(state, dispatch);
-};
-
-const joinForward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.joinForward(state, dispatch);
-};
-
-function isMacOS() {
-    return 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 (isiOS() || isMacOS()) {
-                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;
-};
-
-function isNodeActive(state, typeOrName, attributes = {}) {
-    const { from, to, empty } = state.selection;
-    const type = typeOrName
-        ? getNodeType(typeOrName, state.schema)
-        : null;
-    const nodeRanges = [];
-    state.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.isText) {
-            return;
-        }
-        const relativeFrom = Math.max(from, pos);
-        const relativeTo = Math.min(to, pos + node.nodeSize);
-        nodeRanges.push({
-            node,
-            from: relativeFrom,
-            to: relativeTo,
-        });
-    });
-    const selectionRange = to - from;
-    const matchedNodeRanges = nodeRanges
-        .filter(nodeRange => {
-        if (!type) {
-            return true;
-        }
-        return type.name === nodeRange.node.type.name;
-    })
-        .filter(nodeRange => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
-    if (empty) {
-        return !!matchedNodeRanges.length;
-    }
-    const range = matchedNodeRanges
-        .reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
-    return range >= selectionRange;
-}
-
-const lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const isActive = isNodeActive(state, type, attributes);
-    if (!isActive) {
-        return false;
-    }
-    return prosemirrorCommands.lift(state, dispatch);
-};
-
-const liftEmptyBlock = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.liftEmptyBlock(state, dispatch);
-};
-
-const liftListItem = typeOrName => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    return prosemirrorSchemaList.liftListItem(type)(state, dispatch);
-};
-
-const newlineInCode = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.newlineInCode(state, dispatch);
-};
-
-function getSchemaTypeNameByName(name, schema) {
-    if (schema.nodes[name]) {
-        return 'node';
-    }
-    if (schema.marks[name]) {
-        return 'mark';
-    }
-    return null;
-}
-
-/**
- * Remove a property or an array of properties from an object
- * @param obj Object
- * @param key Key to remove
- */
-function deleteProps(obj, propOrProps) {
-    const props = typeof propOrProps === 'string'
-        ? [propOrProps]
-        : propOrProps;
-    return Object
-        .keys(obj)
-        .reduce((newObj, prop) => {
-        if (!props.includes(prop)) {
-            newObj[prop] = obj[prop];
-        }
-        return newObj;
-    }, {});
-}
-
-const resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-    let nodeType = null;
-    let markType = null;
-    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
-        ? typeOrName
-        : typeOrName.name, state.schema);
-    if (!schemaType) {
-        return false;
-    }
-    if (schemaType === 'node') {
-        nodeType = getNodeType(typeOrName, state.schema);
-    }
-    if (schemaType === 'mark') {
-        markType = getMarkType(typeOrName, state.schema);
-    }
-    if (dispatch) {
-        tr.selection.ranges.forEach(range => {
-            state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-                if (nodeType && nodeType === node.type) {
-                    tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes));
-                }
-                if (markType && node.marks.length) {
-                    node.marks.forEach(mark => {
-                        if (markType === mark.type) {
-                            tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
-                        }
-                    });
-                }
-            });
-        });
-    }
-    return true;
-};
-
-const scrollIntoView = () => ({ tr, dispatch }) => {
-    if (dispatch) {
-        tr.scrollIntoView();
-    }
-    return true;
-};
-
-const selectAll = () => ({ tr, commands }) => {
-    return commands.setTextSelection({
-        from: 0,
-        to: tr.doc.content.size,
-    });
-};
-
-const selectNodeBackward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectNodeBackward(state, dispatch);
-};
-
-const selectNodeForward = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectNodeForward(state, dispatch);
-};
-
-const selectParentNode = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectParentNode(state, dispatch);
-};
-
-// @ts-ignore
-const selectTextblockEnd = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectTextblockEnd(state, dispatch);
-};
-
-// @ts-ignore
-const selectTextblockStart = () => ({ state, dispatch }) => {
-    return prosemirrorCommands.selectTextblockStart(state, dispatch);
-};
-
-function createDocument(content, schema, parseOptions = {}) {
-    return createNodeFromContent(content, schema, { slice: false, parseOptions });
-}
-
-const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
-    const { doc } = tr;
-    const document = createDocument(content, editor.schema, parseOptions);
-    if (dispatch) {
-        tr.replaceWith(0, doc.content.size, document)
-            .setMeta('preventUpdate', !emitUpdate);
-    }
-    return true;
-};
-
-function getMarkAttributes(state, typeOrName) {
-    const type = getMarkType(typeOrName, state.schema);
-    const { from, to, empty } = state.selection;
-    const marks = [];
-    if (empty) {
-        if (state.storedMarks) {
-            marks.push(...state.storedMarks);
-        }
-        marks.push(...state.selection.$head.marks());
-    }
-    else {
-        state.doc.nodesBetween(from, to, node => {
-            marks.push(...node.marks);
-        });
-    }
-    const mark = marks.find(markItem => markItem.type.name === type.name);
-    if (!mark) {
-        return {};
-    }
-    return { ...mark.attrs };
-}
-
-const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-    const { selection } = tr;
-    const { empty, ranges } = selection;
-    const type = getMarkType(typeOrName, state.schema);
-    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;
-};
-
-const setMeta = (key, value) => ({ tr }) => {
-    tr.setMeta(key, value);
-    return true;
-};
-
-const setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    // TODO: use a fallback like insertContent?
-    if (!type.isTextblock) {
-        console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
-        return false;
-    }
-    return chain()
-        // try to convert node to default node if needed
-        .command(({ commands }) => {
-        const canSetBlock = prosemirrorCommands.setBlockType(type, attributes)(state);
-        if (canSetBlock) {
-            return true;
-        }
-        return commands.clearNodes();
-    })
-        .command(({ state: updatedState }) => {
-        return prosemirrorCommands.setBlockType(type, attributes)(updatedState, dispatch);
-    })
-        .run();
-};
-
-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;
-};
-
-const setTextSelection = position => ({ tr, dispatch }) => {
-    if (dispatch) {
-        const { doc } = tr;
-        const { from, to } = typeof position === 'number'
-            ? { from: position, to: position }
-            : position;
-        const minPos = prosemirrorState.TextSelection.atStart(doc).from;
-        const maxPos = prosemirrorState.TextSelection.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;
-};
-
-const sinkListItem = typeOrName => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    return prosemirrorSchemaList.sinkListItem(type)(state, dispatch);
-};
-
-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$1(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$1($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;
-};
-
-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;
-};
-
-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,
-        storage: extension.storage,
-    };
-    const group = callOrReturn(getExtensionField(extension, 'group', context));
-    if (typeof group !== 'string') {
-        return false;
-    }
-    return group.split(' ').includes('list');
-}
-
-const joinListBackwards = (tr, listType) => {
-    const list = findParentNode(node => node.type === listType)(tr.selection);
-    if (!list) {
-        return true;
-    }
-    const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
-    if (before === undefined) {
-        return true;
-    }
-    const nodeBefore = tr.doc.nodeAt(before);
-    const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type)
-        && prosemirrorTransform.canJoin(tr.doc, list.pos);
-    if (!canJoinBackwards) {
-        return true;
-    }
-    tr.join(list.pos);
-    return true;
-};
-const joinListForwards = (tr, listType) => {
-    const list = findParentNode(node => node.type === listType)(tr.selection);
-    if (!list) {
-        return true;
-    }
-    const after = tr.doc.resolve(list.start).after(list.depth);
-    if (after === undefined) {
-        return true;
-    }
-    const nodeAfter = tr.doc.nodeAt(after);
-    const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type)
-        && prosemirrorTransform.canJoin(tr.doc, after);
-    if (!canJoinForwards) {
-        return true;
-    }
-    tr.join(after);
-    return true;
-};
-const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dispatch, chain, commands, can, }) => {
-    const { extensions } = editor.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) {
-            return chain()
-                .command(() => {
-                tr.setNodeMarkup(parentList.pos, listType);
-                return true;
-            })
-                .command(() => joinListBackwards(tr, listType))
-                .command(() => joinListForwards(tr, listType))
-                .run();
-        }
-    }
-    return chain()
-        // try to convert node to default node if needed
-        .command(() => {
-        const canWrapInList = can().wrapInList(listType);
-        if (canWrapInList) {
-            return true;
-        }
-        return commands.clearNodes();
-    })
-        .wrapInList(listType)
-        .command(() => joinListBackwards(tr, listType))
-        .command(() => joinListForwards(tr, listType))
-        .run();
-};
-
-function isMarkActive(state, typeOrName, attributes = {}) {
-    const { empty, ranges } = state.selection;
-    const type = typeOrName
-        ? getMarkType(typeOrName, state.schema)
-        : null;
-    if (empty) {
-        return !!(state.storedMarks || state.selection.$from.marks())
-            .filter(mark => {
-            if (!type) {
-                return true;
-            }
-            return type.name === mark.type.name;
-        })
-            .find(mark => objectIncludes(mark.attrs, attributes, { strict: false }));
-    }
-    let selectionRange = 0;
-    const markRanges = [];
-    ranges.forEach(({ $from, $to }) => {
-        const from = $from.pos;
-        const to = $to.pos;
-        state.doc.nodesBetween(from, to, (node, pos) => {
-            if (!node.isText && !node.marks.length) {
-                return;
-            }
-            const relativeFrom = Math.max(from, pos);
-            const relativeTo = Math.min(to, pos + node.nodeSize);
-            const range = relativeTo - relativeFrom;
-            selectionRange += range;
-            markRanges.push(...node.marks.map(mark => ({
-                mark,
-                from: relativeFrom,
-                to: relativeTo,
-            })));
-        });
-    });
-    if (selectionRange === 0) {
-        return false;
-    }
-    // calculate range of matched mark
-    const matchedRange = markRanges
-        .filter(markRange => {
-        if (!type) {
-            return true;
-        }
-        return type.name === markRange.mark.type.name;
-    })
-        .filter(markRange => objectIncludes(markRange.mark.attrs, attributes, { strict: false }))
-        .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-    // calculate range of marks that excludes the searched mark
-    // for example `code` doesn’t allow any other marks
-    const excludedRange = markRanges
-        .filter(markRange => {
-        if (!type) {
-            return true;
-        }
-        return markRange.mark.type !== type
-            && markRange.mark.type.excludes(type);
-    })
-        .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-    // we only include the result of `excludedRange`
-    // if there is a match at all
-    const range = matchedRange > 0
-        ? matchedRange + excludedRange
-        : matchedRange;
-    return range >= selectionRange;
-}
-
-const toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands }) => {
-    const { extendEmptyMarkRange = false } = options;
-    const type = getMarkType(typeOrName, state.schema);
-    const isActive = isMarkActive(state, type, attributes);
-    if (isActive) {
-        return commands.unsetMark(type, { extendEmptyMarkRange });
-    }
-    return commands.setMark(type, attributes);
-};
-
-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);
-};
-
-const toggleWrap = (typeOrName, attributes = {}) => ({ state, commands }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    const isActive = isNodeActive(state, type, attributes);
-    if (isActive) {
-        return commands.lift(type);
-    }
-    return commands.wrapIn(type, attributes);
-};
-
-const undoInputRule = () => ({ state, dispatch }) => {
-    const plugins = state.plugins;
-    for (let i = 0; i < plugins.length; i += 1) {
-        const plugin = plugins[i];
-        let undoable;
-        // @ts-ignore
-        // eslint-disable-next-line
-        if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
-            if (dispatch) {
-                const tr = state.tr;
-                const toUndo = undoable.transform;
-                for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
-                    tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
-                }
-                if (undoable.text) {
-                    const marks = tr.doc.resolve(undoable.from).marks();
-                    tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
-                }
-                else {
-                    tr.delete(undoable.from, undoable.to);
-                }
-            }
-            return true;
-        }
-    }
-    return false;
-};
-
-const unsetAllMarks = () => ({ tr, dispatch }) => {
-    const { selection } = tr;
-    const { empty, ranges } = selection;
-    if (empty) {
-        return true;
-    }
-    if (dispatch) {
-        ranges.forEach(range => {
-            tr.removeMark(range.$from.pos, range.$to.pos);
-        });
-    }
-    return true;
-};
-
-const unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
-    var _a;
-    const { extendEmptyMarkRange = false } = options;
-    const { selection } = tr;
-    const type = getMarkType(typeOrName, state.schema);
-    const { $from, empty, ranges } = selection;
-    if (!dispatch) {
-        return true;
-    }
-    if (empty && extendEmptyMarkRange) {
-        let { from, to } = selection;
-        const attrs = (_a = $from.marks().find(mark => mark.type === type)) === null || _a === void 0 ? void 0 : _a.attrs;
-        const range = getMarkRange($from, type, attrs);
-        if (range) {
-            from = range.from;
-            to = range.to;
-        }
-        tr.removeMark(from, to, type);
-    }
-    else {
-        ranges.forEach(range => {
-            tr.removeMark(range.$from.pos, range.$to.pos, type);
-        });
-    }
-    tr.removeStoredMark(type);
-    return true;
-};
-
-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;
-};
-
-const wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    return prosemirrorCommands.wrapIn(type, attributes)(state, dispatch);
-};
-
-const wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    return prosemirrorSchemaList.wrapInList(type, attributes)(state, dispatch);
-};
-
-var commands = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  blur: blur,
-  clearContent: clearContent,
-  clearNodes: clearNodes,
-  command: command,
-  createParagraphNear: createParagraphNear,
-  deleteNode: deleteNode,
-  deleteRange: deleteRange,
-  deleteSelection: deleteSelection,
-  enter: enter,
-  exitCode: exitCode,
-  extendMarkRange: extendMarkRange,
-  first: first,
-  focus: focus,
-  forEach: forEach,
-  insertContent: insertContent,
-  insertContentAt: insertContentAt,
-  joinBackward: joinBackward,
-  joinForward: joinForward,
-  keyboardShortcut: keyboardShortcut,
-  lift: lift,
-  liftEmptyBlock: liftEmptyBlock,
-  liftListItem: liftListItem,
-  newlineInCode: newlineInCode,
-  resetAttributes: resetAttributes,
-  scrollIntoView: scrollIntoView,
-  selectAll: selectAll,
-  selectNodeBackward: selectNodeBackward,
-  selectNodeForward: selectNodeForward,
-  selectParentNode: selectParentNode,
-  selectTextblockEnd: selectTextblockEnd,
-  selectTextblockStart: selectTextblockStart,
-  setContent: setContent,
-  setMark: setMark,
-  setMeta: setMeta,
-  setNode: setNode,
-  setNodeSelection: setNodeSelection,
-  setTextSelection: setTextSelection,
-  sinkListItem: sinkListItem,
-  splitBlock: splitBlock,
-  splitListItem: splitListItem,
-  toggleList: toggleList,
-  toggleMark: toggleMark,
-  toggleNode: toggleNode,
-  toggleWrap: toggleWrap,
-  undoInputRule: undoInputRule,
-  unsetAllMarks: unsetAllMarks,
-  unsetMark: unsetMark,
-  updateAttributes: updateAttributes,
-  wrapIn: wrapIn,
-  wrapInList: wrapInList
-});
-
-const Commands = Extension.create({
-    name: 'commands',
-    addCommands() {
-        return {
-            ...commands,
-        };
-    },
-});
-
-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: {
-                    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(),
-            // maybe convert first text block node to default node
-            () => commands.command(({ tr }) => {
-                const { selection, doc } = tr;
-                const { empty, $anchor } = selection;
-                const { pos, parent } = $anchor;
-                const isAtStart = prosemirrorState.Selection.atStart(doc).from === pos;
-                if (!empty
-                    || !isAtStart
-                    || !parent.type.isTextblock
-                    || parent.textContent.length) {
-                    return false;
-                }
-                return commands.clearNodes();
-            }),
-            () => commands.deleteSelection(),
-            () => commands.joinBackward(),
-            () => commands.selectNodeBackward(),
-        ]);
-        const handleDelete = () => this.editor.commands.first(({ commands }) => [
-            () => commands.deleteSelection(),
-            () => commands.joinForward(),
-            () => commands.selectNodeForward(),
-        ]);
-        const handleEnter = () => this.editor.commands.first(({ commands }) => [
-            () => commands.newlineInCode(),
-            () => commands.createParagraphNear(),
-            () => commands.liftEmptyBlock(),
-            () => commands.splitBlock(),
-        ]);
-        const baseKeymap = {
-            Enter: handleEnter,
-            'Mod-Enter': () => this.editor.commands.exitCode(),
-            Backspace: handleBackspace,
-            'Mod-Backspace': handleBackspace,
-            'Shift-Backspace': handleBackspace,
-            Delete: handleDelete,
-            'Mod-Delete': handleDelete,
-            'Mod-a': () => this.editor.commands.selectAll(),
-        };
-        const pcKeymap = {
-            ...baseKeymap,
-        };
-        const macKeymap = {
-            ...baseKeymap,
-            'Ctrl-h': handleBackspace,
-            'Alt-Backspace': handleBackspace,
-            'Ctrl-d': handleDelete,
-            'Ctrl-Alt-Backspace': handleDelete,
-            'Alt-Delete': handleDelete,
-            'Alt-d': handleDelete,
-            'Ctrl-a': () => this.editor.commands.selectTextblockStart(),
-            'Ctrl-e': () => this.editor.commands.selectTextblockEnd(),
-        };
-        if (isiOS() || isMacOS()) {
-            return macKeymap;
-        }
-        return pcKeymap;
-    },
-    addProseMirrorPlugins() {
-        return [
-            // With this plugin we check if the whole document was selected and deleted.
-            // In this case we will additionally call `clearNodes()` to convert e.g. a heading
-            // to a paragraph if necessary.
-            // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
-            // with many other commands.
-            new prosemirrorState.Plugin({
-                key: new prosemirrorState.PluginKey('clearDocument'),
-                appendTransaction: (transactions, oldState, newState) => {
-                    const docChanges = transactions.some(transaction => transaction.docChanged)
-                        && !oldState.doc.eq(newState.doc);
-                    if (!docChanges) {
-                        return;
-                    }
-                    const { empty, from, to } = oldState.selection;
-                    const allFrom = prosemirrorState.Selection.atStart(oldState.doc).from;
-                    const allEnd = prosemirrorState.Selection.atEnd(oldState.doc).to;
-                    const allWasSelected = from === allFrom && to === allEnd;
-                    const isEmpty = newState.doc.textBetween(0, newState.doc.content.size, ' ', ' ').length === 0;
-                    if (empty || !allWasSelected || !isEmpty) {
-                        return;
-                    }
-                    const tr = newState.tr;
-                    const state = createChainableState({
-                        state: newState,
-                        transaction: tr,
-                    });
-                    const { commands } = new CommandManager({
-                        editor: this.editor,
-                        state,
-                    });
-                    commands.clearNodes();
-                    if (!tr.steps.length) {
-                        return;
-                    }
-                    return tr;
-                },
-            }),
-        ];
-    },
-});
-
-const Tabindex = Extension.create({
-    name: 'tabindex',
-    addProseMirrorPlugins() {
-        return [
-            new prosemirrorState.Plugin({
-                key: new prosemirrorState.PluginKey('tabindex'),
-                props: {
-                    attributes: this.editor.isEditable ? { tabindex: '0' } : {},
-                },
-            }),
-        ];
-    },
-});
-
-var extensions = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ClipboardTextSerializer: ClipboardTextSerializer,
-  Commands: Commands,
-  Editable: Editable,
-  FocusEvents: FocusEvents,
-  Keymap: Keymap,
-  Tabindex: Tabindex
-});
-
-function getNodeAttributes(state, typeOrName) {
-    const type = getNodeType(typeOrName, state.schema);
-    const { from, to } = state.selection;
-    const nodes = [];
-    state.doc.nodesBetween(from, to, node => {
-        nodes.push(node);
-    });
-    const node = nodes
-        .reverse()
-        .find(nodeItem => nodeItem.type.name === type.name);
-    if (!node) {
-        return {};
-    }
-    return { ...node.attrs };
-}
-
-function getAttributes(state, typeOrName) {
-    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
-        ? typeOrName
-        : typeOrName.name, state.schema);
-    if (schemaType === 'node') {
-        return getNodeAttributes(state, typeOrName);
-    }
-    if (schemaType === 'mark') {
-        return getMarkAttributes(state, typeOrName);
-    }
-    return {};
-}
-
-function getHTMLFromFragment(fragment, schema) {
-    const documentFragment = prosemirrorModel.DOMSerializer
-        .fromSchema(schema)
-        .serializeFragment(fragment);
-    const temporaryDocument = document.implementation.createHTMLDocument();
-    const container = temporaryDocument.createElement('div');
-    container.appendChild(documentFragment);
-    return container.innerHTML;
-}
-
-function getText(node, options) {
-    const range = {
-        from: 0,
-        to: node.content.size,
-    };
-    return getTextBetween(node, range, options);
-}
-
-function isActive(state, name, attributes = {}) {
-    if (!name) {
-        return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes);
-    }
-    const schemaType = getSchemaTypeNameByName(name, state.schema);
-    if (schemaType === 'node') {
-        return isNodeActive(state, name, attributes);
-    }
-    if (schemaType === 'mark') {
-        return isMarkActive(state, name, attributes);
-    }
-    return false;
-}
-
-function isNodeEmpty(node) {
-    var _a;
-    const defaultContent = (_a = node.type.createAndFill()) === null || _a === void 0 ? void 0 : _a.toJSON();
-    const content = node.toJSON();
-    return JSON.stringify(defaultContent) === JSON.stringify(content);
-}
-
-const style = `.ProseMirror {
-  position: relative;
-}
-
-.ProseMirror {
-  word-wrap: break-word;
-  white-space: pre-wrap;
-  white-space: break-spaces;
-  -webkit-font-variant-ligatures: none;
-  font-variant-ligatures: none;
-  font-feature-settings: "liga" 0; /* the above doesn't seem to work in Edge */
-}
-
-.ProseMirror [contenteditable="false"] {
-  white-space: normal;
-}
-
-.ProseMirror [contenteditable="false"] [contenteditable="true"] {
-  white-space: pre-wrap;
-}
-
-.ProseMirror pre {
-  white-space: pre-wrap;
-}
-
-img.ProseMirror-separator {
-  display: inline !important;
-  border: none !important;
-  margin: 0 !important;
-  width: 1px !important;
-  height: 1px !important;
-}
-
-.ProseMirror-gapcursor {
-  display: none;
-  pointer-events: none;
-  position: absolute;
-  margin: 0;
-}
-
-.ProseMirror-gapcursor:after {
-  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
-}`;
-
-function createStyleTag(style, nonce) {
-    const tipTapStyleTag = document.querySelector('style[data-tiptap-style]');
-    if (tipTapStyleTag !== null) {
-        return tipTapStyleTag;
-    }
-    const styleNode = document.createElement('style');
-    if (nonce) {
-        styleNode.setAttribute('nonce', nonce);
-    }
-    styleNode.setAttribute('data-tiptap-style', '');
-    styleNode.innerHTML = style;
-    document.getElementsByTagName('head')[0].appendChild(styleNode);
-    return styleNode;
-}
-
-class Editor extends EventEmitter {
-    constructor(options = {}) {
-        super();
-        this.isFocused = false;
-        this.extensionStorage = {};
-        this.options = {
-            element: document.createElement('div'),
-            content: '',
-            injectCSS: true,
-            injectNonce: undefined,
-            extensions: [],
-            autofocus: false,
-            editable: true,
-            editorProps: {},
-            parseOptions: {},
-            enableInputRules: true,
-            enablePasteRules: true,
-            enableCoreExtensions: 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);
-    }
-    /**
-     * Returns the editor storage.
-     */
-    get storage() {
-        return this.extensionStorage;
-    }
-    /**
-     * An object of all registered commands.
-     */
-    get commands() {
-        return this.commandManager.commands;
-    }
-    /**
-     * Create a command chain to call multiple commands at once.
-     */
-    chain() {
-        return this.commandManager.chain();
-    }
-    /**
-     * Check if a command or a command chain can be executed. Without executing it.
-     */
-    can() {
-        return this.commandManager.can();
-    }
-    /**
-     * Inject CSS styles.
-     */
-    injectCSS() {
-        if (this.options.injectCSS && document) {
-            this.css = createStyleTag(style, this.options.injectNonce);
-        }
-    }
-    /**
-     * 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 = isFunction(handlePlugins)
-            ? handlePlugins(plugin, [...this.state.plugins])
-            : [...this.state.plugins, plugin];
-        const state = this.state.reconfigure({ plugins });
-        this.view.updateState(state);
-    }
-    /**
-     * Unregister a ProseMirror plugin.
-     *
-     * @param nameOrPluginKey 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 = this.options.enableCoreExtensions
-            ? Object.values(extensions)
-            : [];
-        const allExtensions = [...coreExtensions, ...this.options.extensions].filter(extension => {
-            return ['extension', 'node', 'mark'].includes(extension === null || extension === void 0 ? void 0 : extension.type);
-        });
-        this.extensionManager = new ExtensionManager(allExtensions, this);
-    }
-    /**
-     * Creates an command manager.
-     */
-    createCommandManager() {
-        this.commandManager = new CommandManager({
-            editor: this,
-        });
-    }
-    /**
-     * Creates a ProseMirror schema.
-     */
-    createSchema() {
-        this.schema = this.extensionManager.schema;
-    }
-    /**
-     * Creates a ProseMirror view.
-     */
-    createView() {
-        const doc = createDocument(this.options.content, this.schema, this.options.parseOptions);
-        const selection = resolveFocusPosition(doc, this.options.autofocus);
-        this.view = new prosemirrorView.EditorView(this.options.element, {
-            ...this.options.editorProps,
-            dispatchTransaction: this.dispatchTransaction.bind(this),
-            state: prosemirrorState.EditorState.create({
-                doc,
-                selection: selection || undefined,
-            }),
-        });
-        // `editor.view` is not yet available at this time.
-        // Therefore we will add all plugins and node views directly afterwards.
-        const newState = this.state.reconfigure({
-            plugins: 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.content, this.schema);
-    }
-    /**
-     * Get the document as text.
-     */
-    getText(options) {
-        const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
-        return getText(this.state.doc, {
-            blockSeparator,
-            textSerializers: {
-                ...textSerializers,
-                ...getTextSerializersFromSchema(this.schema),
-            },
-        });
-    }
-    /**
-     * Check if there is no content.
-     */
-    get isEmpty() {
-        return isNodeEmpty(this.state.doc);
-    }
-    /**
-     * Get the number of characters for the current document.
-     *
-     * @deprecated
-     */
-    getCharacterCount() {
-        console.warn('[tiptap warn]: "editor.getCharacterCount()" is deprecated. Please use "editor.storage.characterCount.characters()" instead.');
-        return this.state.doc.content.size - 2;
-    }
-    /**
-     * Destroy the editor.
-     */
-    destroy() {
-        this.emit('destroy');
-        if (this.view) {
-            this.view.destroy();
-        }
-        this.removeAllListeners();
-    }
-    /**
-     * 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);
-    }
-}
-
-/**
- * Returns a new `Transform` based on all steps of the passed transactions.
- */
-function combineTransactionSteps(oldDoc, transactions) {
-    const transform = new prosemirrorTransform.Transform(oldDoc);
-    transactions.forEach(transaction => {
-        transaction.steps.forEach(step => {
-            transform.step(step);
-        });
-    });
-    return transform;
-}
-
-function defaultBlockAt(match) {
-    for (let i = 0; i < match.edgeCount; i += 1) {
-        const { type } = match.edge(i);
-        if (type.isTextblock && !type.hasRequiredAttrs()) {
-            return type;
-        }
-    }
-    return null;
-}
-
-function findChildren(node, predicate) {
-    const nodesWithPos = [];
-    node.descendants((child, pos) => {
-        if (predicate(child)) {
-            nodesWithPos.push({
-                node: child,
-                pos,
-            });
-        }
-    });
-    return nodesWithPos;
-}
-
-/**
- * Same as `findChildren` but searches only within a `range`.
- */
-function findChildrenInRange(node, range, predicate) {
-    const nodesWithPos = [];
-    // if (range.from === range.to) {
-    //   const nodeAt = node.nodeAt(range.from)
-    //   if (nodeAt) {
-    //     nodesWithPos.push({
-    //       node: nodeAt,
-    //       pos: range.from,
-    //     })
-    //   }
-    // }
-    node.nodesBetween(range.from, range.to, (child, pos) => {
-        if (predicate(child)) {
-            nodesWithPos.push({
-                node: child,
-                pos,
-            });
-        }
-    });
-    return nodesWithPos;
-}
-
-function 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.content, schema);
-}
-
-function generateJSON(html, extensions) {
-    const schema = getSchema(extensions);
-    const dom = elementFromString(html);
-    return prosemirrorModel.DOMParser.fromSchema(schema)
-        .parse(dom)
-        .toJSON();
-}
-
-function generateText(doc, extensions, options) {
-    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
-    const schema = getSchema(extensions);
-    const contentNode = prosemirrorModel.Node.fromJSON(schema, doc);
-    return getText(contentNode, {
-        blockSeparator,
-        textSerializers: {
-            ...textSerializers,
-            ...getTextSerializersFromSchema(schema),
-        },
-    });
-}
-
-/**
- * Removes duplicated values within an array.
- * Supports numbers, strings and objects.
- */
-function removeDuplicates(array, by = JSON.stringify) {
-    const seen = {};
-    return array.filter(item => {
-        const key = by(item);
-        return Object.prototype.hasOwnProperty.call(seen, key)
-            ? false
-            : (seen[key] = true);
-    });
-}
-
-/**
- * Removes duplicated ranges and ranges that are
- * fully captured by other ranges.
- */
-function simplifyChangedRanges(changes) {
-    const uniqueChanges = removeDuplicates(changes);
-    return uniqueChanges.length === 1
-        ? uniqueChanges
-        : uniqueChanges.filter((change, index) => {
-            const rest = uniqueChanges.filter((_, i) => i !== index);
-            return !rest.some(otherChange => {
-                return change.oldRange.from >= otherChange.oldRange.from
-                    && change.oldRange.to <= otherChange.oldRange.to
-                    && change.newRange.from >= otherChange.newRange.from
-                    && change.newRange.to <= otherChange.newRange.to;
-            });
-        });
-}
-/**
- * Returns a list of changed ranges
- * based on the first and last state of all steps.
- */
-function getChangedRanges(transform) {
-    const { mapping, steps } = transform;
-    const changes = [];
-    mapping.maps.forEach((stepMap, index) => {
-        const ranges = [];
-        // This accounts for step changes where no range was actually altered
-        // e.g. when setting a mark, node attribute, etc.
-        // @ts-ignore
-        if (!stepMap.ranges.length) {
-            const { from, to } = steps[index];
-            if (from === undefined || to === undefined) {
-                return;
-            }
-            ranges.push({ from, to });
-        }
-        else {
-            stepMap.forEach((from, to) => {
-                ranges.push({ from, to });
-            });
-        }
-        ranges.forEach(({ from, to }) => {
-            const newStart = mapping.slice(index).map(from, -1);
-            const newEnd = mapping.slice(index).map(to);
-            const oldStart = mapping.invert().map(newStart, -1);
-            const oldEnd = mapping.invert().map(newEnd);
-            changes.push({
-                oldRange: {
-                    from: oldStart,
-                    to: oldEnd,
-                },
-                newRange: {
-                    from: newStart,
-                    to: newEnd,
-                },
-            });
-        });
-    });
-    return simplifyChangedRanges(changes);
-}
-
-function getDebugJSON(node, startOffset = 0) {
-    const isTopNode = node.type === node.type.schema.topNodeType;
-    const increment = isTopNode ? 0 : 1;
-    const from = startOffset;
-    const to = from + node.nodeSize;
-    const marks = node.marks.map(mark => {
-        const output = {
-            type: mark.type.name,
-        };
-        if (Object.keys(mark.attrs).length) {
-            output.attrs = { ...mark.attrs };
-        }
-        return output;
-    });
-    const attrs = { ...node.attrs };
-    const output = {
-        type: node.type.name,
-        from,
-        to,
-    };
-    if (Object.keys(attrs).length) {
-        output.attrs = attrs;
-    }
-    if (marks.length) {
-        output.marks = marks;
-    }
-    if (node.content.childCount) {
-        output.content = [];
-        node.forEach((child, offset) => {
-            var _a;
-            (_a = output.content) === null || _a === void 0 ? void 0 : _a.push(getDebugJSON(child, startOffset + offset + increment));
-        });
-    }
-    if (node.text) {
-        output.text = node.text;
-    }
-    return output;
-}
-
-function getMarksBetween(from, to, doc) {
-    const marks = [];
-    // get all inclusive marks on empty selection
-    if (from === to) {
-        doc
-            .resolve(from)
-            .marks()
-            .forEach(mark => {
-            const $pos = doc.resolve(from - 1);
-            const range = getMarkRange($pos, mark.type);
-            if (!range) {
-                return;
-            }
-            marks.push({
-                mark,
-                ...range,
-            });
-        });
-    }
-    else {
-        doc.nodesBetween(from, to, (node, pos) => {
-            marks.push(...node.marks.map(mark => ({
-                from: pos,
-                to: pos + node.nodeSize,
-                mark,
-            })));
-        });
-    }
-    return marks;
-}
-
-function isNodeSelection(value) {
-    return isObject(value) && value instanceof prosemirrorState.NodeSelection;
-}
-
-function posToDOMRect(view, from, to) {
-    const minPos = 0;
-    const maxPos = view.state.doc.content.size;
-    const resolvedFrom = minMax(from, minPos, maxPos);
-    const resolvedEnd = minMax(to, minPos, maxPos);
-    const start = view.coordsAtPos(resolvedFrom);
-    const end = view.coordsAtPos(resolvedEnd, -1);
-    const top = Math.min(start.top, end.top);
-    const bottom = Math.max(start.bottom, end.bottom);
-    const left = Math.min(start.left, end.left);
-    const right = Math.max(start.right, end.right);
-    const width = right - left;
-    const height = bottom - top;
-    const x = left;
-    const y = top;
-    const data = {
-        top,
-        bottom,
-        left,
-        right,
-        width,
-        height,
-        x,
-        y,
-    };
-    return {
-        ...data,
-        toJSON: () => data,
-    };
-}
-
-/**
- * Build an input rule that adds a mark when the
- * matched text is typed into it.
- */
-function markInputRule(config) {
-    return new InputRule({
-        find: config.find,
-        handler: ({ state, range, match }) => {
-            const attributes = callOrReturn(config.getAttributes, undefined, match);
-            if (attributes === false || attributes === null) {
-                return null;
-            }
-            const { tr } = state;
-            const captureGroup = match[match.length - 1];
-            const fullMatch = match[0];
-            let markEnd = range.to;
-            if (captureGroup) {
-                const startSpaces = fullMatch.search(/\S/);
-                const textStart = range.from + fullMatch.indexOf(captureGroup);
-                const textEnd = textStart + captureGroup.length;
-                const excludedMarks = getMarksBetween(range.from, range.to, state.doc)
-                    .filter(item => {
-                    // @ts-ignore
-                    const excluded = item.mark.type.excluded;
-                    return excluded.find(type => type === config.type && type !== item.mark.type);
-                })
-                    .filter(item => item.to > textStart);
-                if (excludedMarks.length) {
-                    return null;
-                }
-                if (textEnd < range.to) {
-                    tr.delete(textEnd, range.to);
-                }
-                if (textStart > range.from) {
-                    tr.delete(range.from + startSpaces, textStart);
-                }
-                markEnd = range.from + startSpaces + captureGroup.length;
-                tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
-                tr.removeStoredMark(config.type);
-            }
-        },
-    });
-}
-
-/**
- * Build an input rule that adds a node when the
- * matched text is typed into it.
- */
-function nodeInputRule(config) {
-    return new InputRule({
-        find: config.find,
-        handler: ({ state, range, match }) => {
-            const attributes = callOrReturn(config.getAttributes, undefined, match) || {};
-            const { tr } = state;
-            const start = range.from;
-            let end = range.to;
-            if (match[1]) {
-                const offset = match[0].lastIndexOf(match[1]);
-                let matchStart = start + offset;
-                if (matchStart > end) {
-                    matchStart = end;
-                }
-                else {
-                    end = matchStart + match[1].length;
-                }
-                // insert last typed character
-                const lastChar = match[0][match[0].length - 1];
-                tr.insertText(lastChar, start + match[0].length - 1);
-                // insert node from input rule
-                tr.replaceWith(matchStart, end, config.type.create(attributes));
-            }
-            else if (match[0]) {
-                tr.replaceWith(start, end, config.type.create(attributes));
-            }
-        },
-    });
-}
-
-/**
- * Build an input rule that changes the type of a textblock when the
- * matched text is typed into it. When using a regular expresion you’ll
- * probably want the regexp to start with `^`, so that the pattern can
- * only occur at the start of a textblock.
- */
-function textblockTypeInputRule(config) {
-    return new InputRule({
-        find: config.find,
-        handler: ({ state, range, match }) => {
-            const $start = state.doc.resolve(range.from);
-            const attributes = callOrReturn(config.getAttributes, undefined, match) || {};
-            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), config.type)) {
-                return null;
-            }
-            state.tr
-                .delete(range.from, range.to)
-                .setBlockType(range.from, range.from, config.type, attributes);
-        },
-    });
-}
-
-/**
- * Build an input rule that replaces text when the
- * matched text is typed into it.
- */
-function textInputRule(config) {
-    return new InputRule({
-        find: config.find,
-        handler: ({ state, range, match }) => {
-            let insert = config.replace;
-            let start = range.from;
-            const end = range.to;
-            if (match[1]) {
-                const offset = match[0].lastIndexOf(match[1]);
-                insert += match[0].slice(offset + match[1].length);
-                start += offset;
-                const cutOff = start - end;
-                if (cutOff > 0) {
-                    insert = match[0].slice(offset - cutOff, offset) + insert;
-                    start = end;
-                }
-            }
-            state.tr.insertText(insert, start, end);
-        },
-    });
-}
-
-/**
- * Build an input rule for automatically wrapping a textblock when a
- * given string is typed. When using a regular expresion you’ll
- * probably want the regexp to start with `^`, so that the pattern can
- * only occur at the start of a textblock.
- *
- * `type` is the type of node to wrap in.
- *
- * By default, if there’s a node with the same type above the newly
- * wrapped node, the rule will try to join those
- * two nodes. You can pass a join predicate, which takes a regular
- * expression match and the node before the wrapped node, and can
- * return a boolean to indicate whether a join should happen.
- */
-function wrappingInputRule(config) {
-    return new InputRule({
-        find: config.find,
-        handler: ({ state, range, match }) => {
-            const attributes = callOrReturn(config.getAttributes, undefined, match) || {};
-            const tr = state.tr.delete(range.from, range.to);
-            const $start = tr.doc.resolve(range.from);
-            const blockRange = $start.blockRange();
-            const wrapping = blockRange && prosemirrorTransform.findWrapping(blockRange, config.type, attributes);
-            if (!wrapping) {
-                return null;
-            }
-            tr.wrap(blockRange, wrapping);
-            const before = tr.doc.resolve(range.from - 1).nodeBefore;
-            if (before
-                && before.type === config.type
-                && prosemirrorTransform.canJoin(tr.doc, range.from - 1)
-                && (!config.joinPredicate || config.joinPredicate(match, before))) {
-                tr.join(range.from - 1);
-            }
-        },
-    });
-}
-
-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;
-        if (config.defaultOptions) {
-            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-        }
-        // TODO: remove `addOptions` fallback
-        this.options = this.config.defaultOptions;
-        if (this.config.addOptions) {
-            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
-                name: this.name,
-            }));
-        }
-        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
-            name: this.name,
-            options: this.options,
-        })) || {};
-    }
-    static create(config = {}) {
-        return new Mark(config);
-    }
-    configure(options = {}) {
-        // return a new instance so we can use the same extension
-        // with different calls of `configure`
-        const extension = this.extend();
-        extension.options = mergeDeep(this.options, options);
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
-        return extension;
-    }
-    extend(extendedConfig = {}) {
-        const extension = new Mark(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        if (extendedConfig.defaultOptions) {
-            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-        }
-        extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
-            name: extension.name,
-        }));
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
-        return extension;
-    }
-}
-
-class 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;
-        if (config.defaultOptions) {
-            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-        }
-        // TODO: remove `addOptions` fallback
-        this.options = this.config.defaultOptions;
-        if (this.config.addOptions) {
-            this.options = callOrReturn(getExtensionField(this, 'addOptions', {
-                name: this.name,
-            }));
-        }
-        this.storage = callOrReturn(getExtensionField(this, 'addStorage', {
-            name: this.name,
-            options: this.options,
-        })) || {};
-    }
-    static create(config = {}) {
-        return new Node(config);
-    }
-    configure(options = {}) {
-        // return a new instance so we can use the same extension
-        // with different calls of `configure`
-        const extension = this.extend();
-        extension.options = mergeDeep(this.options, options);
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
-        return extension;
-    }
-    extend(extendedConfig = {}) {
-        const extension = new Node(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name
-            ? extendedConfig.name
-            : extension.parent.name;
-        if (extendedConfig.defaultOptions) {
-            console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-        }
-        extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
-            name: extension.name,
-        }));
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
-        return extension;
-    }
-}
-
-class NodeView {
-    constructor(component, props, options) {
-        this.isDragging = false;
-        this.component = component;
-        this.editor = props.editor;
-        this.options = {
-            stopEvent: null,
-            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 this.editor.view.dom;
-    }
-    get contentDOM() {
-        return null;
-    }
-    onDragStart(event) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        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();
-            // In React, we have to go through nativeEvent to reach offsetX/offsetY.
-            const offsetX = (_c = event.offsetX) !== null && _c !== void 0 ? _c : (_d = event.nativeEvent) === null || _d === void 0 ? void 0 : _d.offsetX;
-            const offsetY = (_e = event.offsetY) !== null && _e !== void 0 ? _e : (_f = event.nativeEvent) === null || _f === void 0 ? void 0 : _f.offsetY;
-            x = handleBox.x - domBox.x + offsetX;
-            y = handleBox.y - domBox.y + offsetY;
-        }
-        (_g = event.dataTransfer) === null || _g === void 0 ? void 0 : _g.setDragImage(this.dom, x, y);
-        // we need to tell ProseMirror that we want to move the whole node
-        // so we create a NodeSelection
-        const selection = 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 isDropEvent = event.type === 'drop';
-        const isInput = ['INPUT', 'BUTTON', 'SELECT', 'TEXTAREA'].includes(target.tagName)
-            || target.isContentEditable;
-        // any input event within node views should be ignored by ProseMirror
-        if (isInput && !isDropEvent) {
-            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');
-        // 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
-            || isDropEvent
-            || 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()
-            && this.editor.isFocused) {
-            const changedNodes = [
-                ...Array.from(mutation.addedNodes),
-                ...Array.from(mutation.removedNodes),
-            ];
-            // we’ll check if every changed node is contentEditable
-            // to make sure it’s probably mutated by ProseMirror
-            if (changedNodes.every(node => node.isContentEditable)) {
-                return false;
-            }
-        }
-        // we will allow mutation contentDOM with attributes
-        // so we can for example adding classes within our node view
-        if (this.contentDOM === mutation.target && mutation.type === 'attributes') {
-            return true;
-        }
-        // 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 });
-    }
-}
-
-/**
- * Build an paste rule that adds a mark when the
- * matched text is pasted into it.
- */
-function markPasteRule(config) {
-    return new PasteRule({
-        find: config.find,
-        handler: ({ state, range, match }) => {
-            const attributes = callOrReturn(config.getAttributes, undefined, match);
-            if (attributes === false || attributes === null) {
-                return null;
-            }
-            const { tr } = state;
-            const captureGroup = match[match.length - 1];
-            const fullMatch = match[0];
-            let markEnd = range.to;
-            if (captureGroup) {
-                const startSpaces = fullMatch.search(/\S/);
-                const textStart = range.from + fullMatch.indexOf(captureGroup);
-                const textEnd = textStart + captureGroup.length;
-                const excludedMarks = getMarksBetween(range.from, range.to, state.doc)
-                    .filter(item => {
-                    // @ts-ignore
-                    const excluded = item.mark.type.excluded;
-                    return excluded.find(type => type === config.type && type !== item.mark.type);
-                })
-                    .filter(item => item.to > textStart);
-                if (excludedMarks.length) {
-                    return null;
-                }
-                if (textEnd < range.to) {
-                    tr.delete(textEnd, range.to);
-                }
-                if (textStart > range.from) {
-                    tr.delete(range.from + startSpaces, textStart);
-                }
-                markEnd = range.from + startSpaces + captureGroup.length;
-                tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
-                tr.removeStoredMark(config.type);
-            }
-        },
-    });
-}
-
-// source: https://stackoverflow.com/a/6969486
-function escapeForRegEx(string) {
-    return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-
-/**
- * Build an paste rule that adds a node when the
- * matched text is pasted into it.
- */
-function nodePasteRule(config) {
-    return new PasteRule({
-        find: config.find,
-        handler({ match, chain, range }) {
-            const attributes = callOrReturn(config.getAttributes, undefined, match);
-            if (attributes === false || attributes === null) {
-                return null;
-            }
-            if (match.input) {
-                chain()
-                    .deleteRange(range)
-                    .insertContent({
-                    type: config.type.name,
-                    attrs: attributes,
-                });
-            }
-        },
-    });
-}
-
-/**
- * Build an paste rule that replaces text when the
- * matched text is pasted into it.
- */
-function textPasteRule(config) {
-    return new PasteRule({
-        find: config.find,
-        handler: ({ state, range, match }) => {
-            let insert = config.replace;
-            let start = range.from;
-            const end = range.to;
-            if (match[1]) {
-                const offset = match[0].lastIndexOf(match[1]);
-                insert += match[0].slice(offset + match[1].length);
-                start += offset;
-                const cutOff = start - end;
-                if (cutOff > 0) {
-                    insert = match[0].slice(offset - cutOff, offset) + insert;
-                    start = end;
-                }
-            }
-            state.tr.insertText(insert, start, end);
-        },
-    });
-}
-
-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,
-        };
-    }
-}
-
-exports.CommandManager = CommandManager;
-exports.Editor = Editor;
-exports.Extension = Extension;
-exports.InputRule = InputRule;
-exports.Mark = Mark;
-exports.Node = Node;
-exports.NodeView = NodeView;
-exports.PasteRule = PasteRule;
-exports.Tracker = Tracker;
-exports.callOrReturn = callOrReturn;
-exports.combineTransactionSteps = combineTransactionSteps;
-exports.defaultBlockAt = defaultBlockAt;
-exports.escapeForRegEx = escapeForRegEx;
-exports.extensions = extensions;
-exports.findChildren = findChildren;
-exports.findChildrenInRange = findChildrenInRange;
-exports.findParentNode = findParentNode;
-exports.findParentNodeClosestToPos = findParentNodeClosestToPos;
-exports.generateHTML = generateHTML;
-exports.generateJSON = generateJSON;
-exports.generateText = generateText;
-exports.getAttributes = getAttributes;
-exports.getChangedRanges = getChangedRanges;
-exports.getDebugJSON = getDebugJSON;
-exports.getExtensionField = getExtensionField;
-exports.getHTMLFromFragment = getHTMLFromFragment;
-exports.getMarkAttributes = getMarkAttributes;
-exports.getMarkRange = getMarkRange;
-exports.getMarkType = getMarkType;
-exports.getMarksBetween = getMarksBetween;
-exports.getNodeAttributes = getNodeAttributes;
-exports.getNodeType = getNodeType;
-exports.getSchema = getSchema;
-exports.getText = getText;
-exports.getTextBetween = getTextBetween;
-exports.getTextContentFromNodes = getTextContentFromNodes;
-exports.getTextSerializersFromSchema = getTextSerializersFromSchema;
-exports.inputRulesPlugin = inputRulesPlugin;
-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.nodePasteRule = nodePasteRule;
-exports.pasteRulesPlugin = pasteRulesPlugin;
-exports.posToDOMRect = posToDOMRect;
-exports.textInputRule = textInputRule;
-exports.textPasteRule = textPasteRule;
-exports.textblockTypeInputRule = textblockTypeInputRule;
-exports.wrappingInputRule = wrappingInputRule;
-//# sourceMappingURL=tiptap-core.cjs.js.map