@tiptap/core 2.0.0-beta.195 → 2.0.0-beta.197

package/dist/tiptap-core.esm.js

@@ -1,8 +1,8 @@
 import { Plugin, PluginKey, TextSelection, Selection, NodeSelection, EditorState } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
 import { keymap } from 'prosemirror-keymap';
-import { Schema, Fragment, DOMParser, Slice, DOMSerializer, Node as Node$1 } from 'prosemirror-model';
-import { liftTarget, ReplaceStep, ReplaceAroundStep, canSplit, canJoin, Transform, findWrapping } from 'prosemirror-transform';
+import { Schema, Fragment, DOMParser, DOMSerializer, Node as Node$1, Slice } from 'prosemirror-model';
+import { liftTarget, ReplaceStep, ReplaceAroundStep, Transform, canSplit, canJoin, findWrapping } from 'prosemirror-transform';
 import { createParagraphNear as createParagraphNear$1, deleteSelection as deleteSelection$1, exitCode as exitCode$1, joinBackward as joinBackward$1, joinForward as joinForward$1, lift as lift$1, liftEmptyBlock as liftEmptyBlock$1, newlineInCode as newlineInCode$1, selectNodeBackward as selectNodeBackward$1, selectNodeForward as selectNodeForward$1, selectParentNode as selectParentNode$1, selectTextblockEnd as selectTextblockEnd$1, selectTextblockStart as selectTextblockStart$1, setBlockType, wrapIn as wrapIn$1 } from 'prosemirror-commands';
 import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, wrapInList as wrapInList$1 } from 'prosemirror-schema-list';
 
@@ -1932,6 +1932,135 @@ const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, ed
     return true;
 };
 
+/**
+ * Returns a new `Transform` based on all steps of the passed transactions.
+ */
+function combineTransactionSteps(oldDoc, transactions) {
+    const transform = new Transform(oldDoc);
+    transactions.forEach(transaction => {
+        transaction.steps.forEach(step => {
+            transform.step(step);
+        });
+    });
+    return transform;
+}
+
+function defaultBlockAt(match) {
+    for (let i = 0; i < match.edgeCount; i += 1) {
+        const { type } = match.edge(i);
+        if (type.isTextblock && !type.hasRequiredAttrs()) {
+            return type;
+        }
+    }
+    return null;
+}
+
+function findChildren(node, predicate) {
+    const nodesWithPos = [];
+    node.descendants((child, pos) => {
+        if (predicate(child)) {
+            nodesWithPos.push({
+                node: child,
+                pos,
+            });
+        }
+    });
+    return nodesWithPos;
+}
+
+/**
+ * Same as `findChildren` but searches only within a `range`.
+ */
+function findChildrenInRange(node, range, predicate) {
+    const nodesWithPos = [];
+    // if (range.from === range.to) {
+    //   const nodeAt = node.nodeAt(range.from)
+    //   if (nodeAt) {
+    //     nodesWithPos.push({
+    //       node: nodeAt,
+    //       pos: range.from,
+    //     })
+    //   }
+    // }
+    node.nodesBetween(range.from, range.to, (child, pos) => {
+        if (predicate(child)) {
+            nodesWithPos.push({
+                node: child,
+                pos,
+            });
+        }
+    });
+    return nodesWithPos;
+}
+
+function findParentNodeClosestToPos($pos, predicate) {
+    for (let i = $pos.depth; i > 0; i -= 1) {
+        const node = $pos.node(i);
+        if (predicate(node)) {
+            return {
+                pos: i > 0 ? $pos.before(i) : 0,
+                start: $pos.start(i),
+                depth: i,
+                node,
+            };
+        }
+    }
+}
+
+function findParentNode(predicate) {
+    return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
+}
+
+function getHTMLFromFragment(fragment, schema) {
+    const documentFragment = DOMSerializer
+        .fromSchema(schema)
+        .serializeFragment(fragment);
+    const temporaryDocument = document.implementation.createHTMLDocument();
+    const container = temporaryDocument.createElement('div');
+    container.appendChild(documentFragment);
+    return container.innerHTML;
+}
+
+function getSchema(extensions) {
+    const resolvedExtensions = ExtensionManager.resolve(extensions);
+    return getSchemaByResolvedExtensions(resolvedExtensions);
+}
+
+function generateHTML(doc, extensions) {
+    const schema = getSchema(extensions);
+    const contentNode = Node$1.fromJSON(schema, doc);
+    return getHTMLFromFragment(contentNode.content, schema);
+}
+
+function generateJSON(html, extensions) {
+    const schema = getSchema(extensions);
+    const dom = elementFromString(html);
+    return DOMParser.fromSchema(schema)
+        .parse(dom)
+        .toJSON();
+}
+
+function getText(node, options) {
+    const range = {
+        from: 0,
+        to: node.content.size,
+    };
+    return getTextBetween(node, range, options);
+}
+
+function generateText(doc, extensions, options) {
+    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
+    const schema = getSchema(extensions);
+    const contentNode = Node$1.fromJSON(schema, doc);
+    return getText(contentNode, {
+        blockSeparator,
+        textSerializers: {
+            ...textSerializers,
+            ...getTextSerializersFromSchema(schema),
+        },
+    });
+}
+
 function getMarkAttributes(state, typeOrName) {
     const type = getMarkType(typeOrName, state.schema);
     const { from, to, empty } = state.selection;
@@ -1954,118 +2083,454 @@ function getMarkAttributes(state, typeOrName) {
     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 }) => {
+function getNodeAttributes(state, typeOrName) {
     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 = setBlockType(type, attributes)(state);
-        if (canSetBlock) {
-            return true;
-        }
-        return commands.clearNodes();
-    })
-        .command(({ state: updatedState }) => {
-        return setBlockType(type, attributes)(updatedState, dispatch);
-    })
-        .run();
-};
-
-const setNodeSelection = position => ({ tr, dispatch }) => {
-    if (dispatch) {
-        const { doc } = tr;
-        const from = minMax(position, 0, doc.content.size);
-        const selection = NodeSelection.create(doc, from);
-        tr.setSelection(selection);
+    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 true;
-};
+    return { ...node.attrs };
+}
 
-const setTextSelection = position => ({ tr, dispatch }) => {
-    if (dispatch) {
-        const { doc } = tr;
-        const { from, to } = typeof position === 'number'
-            ? { from: position, to: position }
-            : position;
-        const minPos = TextSelection.atStart(doc).from;
-        const maxPos = TextSelection.atEnd(doc).to;
-        const resolvedFrom = minMax(from, minPos, maxPos);
-        const resolvedEnd = minMax(to, minPos, maxPos);
-        const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
-        tr.setSelection(selection);
+function getAttributes(state, typeOrName) {
+    const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string'
+        ? typeOrName
+        : typeOrName.name, state.schema);
+    if (schemaType === 'node') {
+        return getNodeAttributes(state, typeOrName);
     }
-    return true;
-};
-
-const sinkListItem = typeOrName => ({ state, dispatch }) => {
-    const type = getNodeType(typeOrName, state.schema);
-    return sinkListItem$1(type)(state, dispatch);
-};
-
-function defaultBlockAt(match) {
-    for (let i = 0; i < match.edgeCount; i += 1) {
-        const { type } = match.edge(i);
-        if (type.isTextblock && !type.hasRequiredAttrs()) {
-            return type;
-        }
+    if (schemaType === 'mark') {
+        return getMarkAttributes(state, typeOrName);
     }
-    return null;
+    return {};
 }
 
-function getSplittedAttributes(extensionAttributes, typeName, attributes) {
+/**
+ * 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 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;
+}
+
+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 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');
+}
+
+function isNodeEmpty(node) {
+    var _a;
+    const defaultContent = (_a = node.type.createAndFill()) === null || _a === void 0 ? void 0 : _a.toJSON();
+    const content = node.toJSON();
+    return JSON.stringify(defaultContent) === JSON.stringify(content);
+}
+
+function isNodeSelection(value) {
+    return value instanceof NodeSelection;
+}
+
+function posToDOMRect(view, from, to) {
+    const minPos = 0;
+    const maxPos = view.state.doc.content.size;
+    const resolvedFrom = minMax(from, minPos, maxPos);
+    const resolvedEnd = minMax(to, minPos, maxPos);
+    const start = view.coordsAtPos(resolvedFrom);
+    const end = view.coordsAtPos(resolvedEnd, -1);
+    const top = Math.min(start.top, end.top);
+    const bottom = Math.max(start.bottom, end.bottom);
+    const left = Math.min(start.left, end.left);
+    const right = Math.max(start.right, end.right);
+    const width = right - left;
+    const height = bottom - top;
+    const x = left;
+    const y = top;
+    const data = {
+        top,
+        bottom,
+        left,
+        right,
+        width,
+        height,
+        x,
+        y,
+    };
+    return {
+        ...data,
+        toJSON: () => data,
+    };
+}
+
+function canSetMark(state, tr, newMarkType) {
+    var _a;
+    const { selection } = tr;
+    let cursor = null;
+    if (isTextSelection(selection)) {
+        cursor = selection.$cursor;
+    }
+    if (cursor) {
+        const currentMarks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : cursor.marks();
+        // There can be no current marks that exclude the new mark
+        return !!newMarkType.isInSet(currentMarks) || !currentMarks.some(mark => mark.type.excludes(newMarkType));
+    }
+    const { ranges } = selection;
+    return ranges.some(({ $from, $to }) => {
+        let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
+        state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
+            // If we already found a mark that we can enable, return false to bypass the remaining search
+            if (someNodeSupportsMark) {
+                return false;
+            }
+            if (node.isInline) {
+                const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
+                const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks) || !node.marks.some(otherMark => otherMark.type.excludes(newMarkType));
+                someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
+            }
+            return !someNodeSupportsMark;
+        });
+        return someNodeSupportsMark;
+    });
+}
+const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+    const { selection } = tr;
+    const { empty, ranges } = selection;
+    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 canSetMark(state, tr, type);
+};
+
+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 = setBlockType(type, attributes)(state);
+        if (canSetBlock) {
+            return true;
+        }
+        return commands.clearNodes();
+    })
+        .command(({ state: updatedState }) => {
+        return setBlockType(type, attributes)(updatedState, dispatch);
+    })
+        .run();
+};
+
+const setNodeSelection = position => ({ tr, dispatch }) => {
+    if (dispatch) {
+        const { doc } = tr;
+        const from = minMax(position, 0, doc.content.size);
+        const selection = NodeSelection.create(doc, from);
+        tr.setSelection(selection);
+    }
+    return true;
+};
+
+const setTextSelection = position => ({ tr, dispatch }) => {
+    if (dispatch) {
+        const { doc } = tr;
+        const { from, to } = typeof position === 'number'
+            ? { from: position, to: position }
+            : position;
+        const minPos = TextSelection.atStart(doc).from;
+        const maxPos = TextSelection.atEnd(doc).to;
+        const resolvedFrom = minMax(from, minPos, maxPos);
+        const resolvedEnd = minMax(to, minPos, maxPos);
+        const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
+        tr.setSelection(selection);
+    }
+    return true;
+};
+
+const sinkListItem = typeOrName => ({ state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema);
+    return sinkListItem$1(type)(state, dispatch);
+};
+
+function getSplittedAttributes(extensionAttributes, typeName, attributes) {
     return Object.fromEntries(Object
         .entries(attributes)
         .filter(([name]) => {
@@ -2237,42 +2702,6 @@ const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
     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) {
@@ -2354,73 +2783,6 @@ const toggleList = (listTypeOrName, itemTypeOrName) => ({ editor, tr, state, dis
         .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);
@@ -2808,78 +3170,10 @@ var extensions = /*#__PURE__*/Object.freeze({
   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 = 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);
-}
+  FocusEvents: FocusEvents,
+  Keymap: Keymap,
+  Tabindex: Tabindex
+});
 
 const style = `.ProseMirror {
   position: relative;
@@ -3185,407 +3479,143 @@ class Editor extends EventEmitter {
     /**
      * 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 Transform(oldDoc);
-    transactions.forEach(transaction => {
-        transaction.steps.forEach(step => {
-            transform.step(step);
-        });
-    });
-    return transform;
-}
-
-function findChildren(node, predicate) {
-    const nodesWithPos = [];
-    node.descendants((child, pos) => {
-        if (predicate(child)) {
-            nodesWithPos.push({
-                node: child,
-                pos,
-            });
-        }
-    });
-    return nodesWithPos;
-}
-
-/**
- * Same as `findChildren` but searches only within a `range`.
- */
-function findChildrenInRange(node, range, predicate) {
-    const nodesWithPos = [];
-    // if (range.from === range.to) {
-    //   const nodeAt = node.nodeAt(range.from)
-    //   if (nodeAt) {
-    //     nodesWithPos.push({
-    //       node: nodeAt,
-    //       pos: range.from,
-    //     })
-    //   }
-    // }
-    node.nodesBetween(range.from, range.to, (child, pos) => {
-        if (predicate(child)) {
-            nodesWithPos.push({
-                node: child,
-                pos,
-            });
-        }
-    });
-    return nodesWithPos;
-}
-
-function getSchema(extensions) {
-    const resolvedExtensions = ExtensionManager.resolve(extensions);
-    return getSchemaByResolvedExtensions(resolvedExtensions);
-}
-
-function generateHTML(doc, extensions) {
-    const schema = getSchema(extensions);
-    const contentNode = Node$1.fromJSON(schema, doc);
-    return getHTMLFromFragment(contentNode.content, schema);
-}
-
-function generateJSON(html, extensions) {
-    const schema = getSchema(extensions);
-    const dom = elementFromString(html);
-    return DOMParser.fromSchema(schema)
-        .parse(dom)
-        .toJSON();
-}
-
-function generateText(doc, extensions, options) {
-    const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
-    const schema = getSchema(extensions);
-    const contentNode = Node$1.fromJSON(schema, doc);
-    return getText(contentNode, {
-        blockSeparator,
-        textSerializers: {
-            ...textSerializers,
-            ...getTextSerializersFromSchema(schema),
-        },
-    });
-}
-
-/**
- * Removes duplicated values within an array.
- * Supports numbers, strings and objects.
- */
-function removeDuplicates(array, by = JSON.stringify) {
-    const seen = {};
-    return array.filter(item => {
-        const key = by(item);
-        return Object.prototype.hasOwnProperty.call(seen, key)
-            ? false
-            : (seen[key] = true);
-    });
-}
-
-/**
- * Removes duplicated ranges and ranges that are
- * fully captured by other ranges.
- */
-function simplifyChangedRanges(changes) {
-    const uniqueChanges = removeDuplicates(changes);
-    return uniqueChanges.length === 1
-        ? uniqueChanges
-        : uniqueChanges.filter((change, index) => {
-            const rest = uniqueChanges.filter((_, i) => i !== index);
-            return !rest.some(otherChange => {
-                return change.oldRange.from >= otherChange.oldRange.from
-                    && change.oldRange.to <= otherChange.oldRange.to
-                    && change.newRange.from >= otherChange.newRange.from
-                    && change.newRange.to <= otherChange.newRange.to;
-            });
+    createNodeViews() {
+        this.view.setProps({
+            nodeViews: this.extensionManager.nodeViews,
         });
-}
-/**
- * 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) {
+    }
+    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;
             }
-            ranges.push({ from, to });
+            transaction.steps.forEach(step => { var _a; return (_a = this.capturedTransaction) === null || _a === void 0 ? void 0 : _a.step(step); });
+            return;
         }
-        else {
-            stepMap.forEach((from, to) => {
-                ranges.push({ from, to });
+        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,
             });
         }
-        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,
-                },
+        const focus = transaction.getMeta('focus');
+        const blur = transaction.getMeta('blur');
+        if (focus) {
+            this.emit('focus', {
+                editor: this,
+                event: focus.event,
+                transaction,
             });
-        });
-    });
-    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 (blur) {
+            this.emit('blur', {
+                editor: this,
+                event: blur.event,
+                transaction,
+            });
+        }
+        if (!transaction.docChanged || transaction.getMeta('preventUpdate')) {
+            return;
+        }
+        this.emit('update', {
+            editor: this,
+            transaction,
+        });
     }
-    if (marks.length) {
-        output.marks = marks;
+    /**
+     * Get attributes of the currently selected node or mark.
+     */
+    getAttributes(nameOrType) {
+        return getAttributes(this.state, nameOrType);
     }
-    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));
-        });
+    isActive(nameOrAttributes, attributesOrUndefined) {
+        const name = typeof nameOrAttributes === 'string'
+            ? nameOrAttributes
+            : null;
+        const attributes = typeof nameOrAttributes === 'string'
+            ? attributesOrUndefined
+            : nameOrAttributes;
+        return isActive(this.state, name, attributes);
     }
-    if (node.text) {
-        output.text = node.text;
+    /**
+     * Get the document as JSON.
+     */
+    getJSON() {
+        return this.state.doc.toJSON();
     }
-    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,
-            });
-        });
+    /**
+     * Get the document as HTML.
+     */
+    getHTML() {
+        return getHTMLFromFragment(this.state.doc.content, this.schema);
     }
-    else {
-        doc.nodesBetween(from, to, (node, pos) => {
-            marks.push(...node.marks.map(mark => ({
-                from: pos,
-                to: pos + node.nodeSize,
-                mark,
-            })));
+    /**
+     * Get the document as text.
+     */
+    getText(options) {
+        const { blockSeparator = '\n\n', textSerializers = {}, } = options || {};
+        return getText(this.state.doc, {
+            blockSeparator,
+            textSerializers: {
+                ...textSerializers,
+                ...getTextSerializersFromSchema(this.schema),
+            },
         });
     }
-    return marks;
-}
-
-function isNodeSelection(value) {
-    return value instanceof NodeSelection;
-}
-
-function posToDOMRect(view, from, to) {
-    const minPos = 0;
-    const maxPos = view.state.doc.content.size;
-    const resolvedFrom = minMax(from, minPos, maxPos);
-    const resolvedEnd = minMax(to, minPos, maxPos);
-    const start = view.coordsAtPos(resolvedFrom);
-    const end = view.coordsAtPos(resolvedEnd, -1);
-    const top = Math.min(start.top, end.top);
-    const bottom = Math.max(start.bottom, end.bottom);
-    const left = Math.min(start.left, end.left);
-    const right = Math.max(start.right, end.right);
-    const width = right - left;
-    const height = bottom - top;
-    const x = left;
-    const y = top;
-    const data = {
-        top,
-        bottom,
-        left,
-        right,
-        width,
-        height,
-        x,
-        y,
-    };
-    return {
-        ...data,
-        toJSON: () => data,
-    };
+    /**
+     * 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);
+    }
 }
 
 /**