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

package/dist/tiptap-core.umd.js

@@ -1930,6 +1930,135 @@
       return true;
   };
 
+  /**
+   * 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 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 = prosemirrorModel.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 = 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 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 = prosemirrorModel.Node.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;
@@ -1952,118 +2081,454 @@
       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 = 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 from = minMax(position, 0, doc.content.size);
-          const selection = prosemirrorState.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 = 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);
+  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 prosemirrorSchemaList.sinkListItem(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 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,
+      };
+  }
+
+  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 = 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 from = minMax(position, 0, doc.content.size);
+          const selection = prosemirrorState.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 = 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]) => {
@@ -2235,42 +2700,6 @@
       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) {
@@ -2352,73 +2781,6 @@
           .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);
@@ -2806,78 +3168,10 @@
     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);
-  }
+    FocusEvents: FocusEvents,
+    Keymap: Keymap,
+    Tabindex: Tabindex
+  });
 
   const style = `.ProseMirror {
   position: relative;
@@ -3183,407 +3477,143 @@ img.ProseMirror-separator {
       /**
        * 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 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;
-              });
+      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 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,
-      };
+      /**
+       * 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);
+      }
   }
 
   /**