bsky-richtext-react 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -13,6 +13,8 @@ var api = require('@atproto/api');
 var extensionMention = require('@tiptap/extension-mention');
 var tippy = require('tippy.js');
 var core = require('@tiptap/core');
+var state = require('@tiptap/pm/state');
+var view = require('@tiptap/pm/view');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -479,9 +481,9 @@ function createDefaultSuggestionRenderer(options = {}) {
           editor: props.editor
         });
         if (!props.clientRect) return;
-        const clientRect2 = props.clientRect;
+        const clientRect = props.clientRect;
         popup = tippy__default.default("body", {
-          getReferenceClientRect: () => clientRect2?.() ?? new DOMRect(),
+          getReferenceClientRect: () => clientRect?.() ?? new DOMRect(),
           appendTo: () => document.body,
           content: renderer.element,
           showOnCreate: true,
@@ -493,9 +495,9 @@ function createDefaultSuggestionRenderer(options = {}) {
       onUpdate(props) {
         renderer?.updateProps(buildProps(props));
         if (!props.clientRect) return;
-        const clientRect2 = props.clientRect;
+        const clientRect = props.clientRect;
         popup?.[0]?.setProps({
-          getReferenceClientRect: () => clientRect2?.() ?? new DOMRect()
+          getReferenceClientRect: () => clientRect?.() ?? new DOMRect()
         });
       },
       onKeyDown(props) {
@@ -559,4831 +561,10 @@ function createBskyMentionExtension({
     }
   });
 }
-
-// node_modules/prosemirror-model/dist/index.js
-function findDiffStart(a, b, pos) {
-  for (let i = 0; ; i++) {
-    if (i == a.childCount || i == b.childCount)
-      return a.childCount == b.childCount ? null : pos;
-    let childA = a.child(i), childB = b.child(i);
-    if (childA == childB) {
-      pos += childA.nodeSize;
-      continue;
-    }
-    if (!childA.sameMarkup(childB))
-      return pos;
-    if (childA.isText && childA.text != childB.text) {
-      for (let j = 0; childA.text[j] == childB.text[j]; j++)
-        pos++;
-      return pos;
-    }
-    if (childA.content.size || childB.content.size) {
-      let inner = findDiffStart(childA.content, childB.content, pos + 1);
-      if (inner != null)
-        return inner;
-    }
-    pos += childA.nodeSize;
-  }
-}
-function findDiffEnd(a, b, posA, posB) {
-  for (let iA = a.childCount, iB = b.childCount; ; ) {
-    if (iA == 0 || iB == 0)
-      return iA == iB ? null : { a: posA, b: posB };
-    let childA = a.child(--iA), childB = b.child(--iB), size = childA.nodeSize;
-    if (childA == childB) {
-      posA -= size;
-      posB -= size;
-      continue;
-    }
-    if (!childA.sameMarkup(childB))
-      return { a: posA, b: posB };
-    if (childA.isText && childA.text != childB.text) {
-      let same = 0, minSize = Math.min(childA.text.length, childB.text.length);
-      while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
-        same++;
-        posA--;
-        posB--;
-      }
-      return { a: posA, b: posB };
-    }
-    if (childA.content.size || childB.content.size) {
-      let inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
-      if (inner)
-        return inner;
-    }
-    posA -= size;
-    posB -= size;
-  }
-}
-var Fragment = class _Fragment {
-  /**
-  @internal
-  */
-  constructor(content, size) {
-    this.content = content;
-    this.size = size || 0;
-    if (size == null)
-      for (let i = 0; i < content.length; i++)
-        this.size += content[i].nodeSize;
-  }
-  /**
-  Invoke a callback for all descendant nodes between the given two
-  positions (relative to start of this fragment). Doesn't descend
-  into a node when the callback returns `false`.
-  */
-  nodesBetween(from, to, f, nodeStart = 0, parent) {
-    for (let i = 0, pos = 0; pos < to; i++) {
-      let child = this.content[i], end = pos + child.nodeSize;
-      if (end > from && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
-        let start = pos + 1;
-        child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
-      }
-      pos = end;
-    }
-  }
-  /**
-  Call the given callback for every descendant node. `pos` will be
-  relative to the start of the fragment. The callback may return
-  `false` to prevent traversal of a given node's children.
-  */
-  descendants(f) {
-    this.nodesBetween(0, this.size, f);
-  }
-  /**
-  Extract the text between `from` and `to`. See the same method on
-  [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
-  */
-  textBetween(from, to, blockSeparator, leafText) {
-    let text = "", first = true;
-    this.nodesBetween(from, to, (node, pos) => {
-      let nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
-      if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) {
-        if (first)
-          first = false;
-        else
-          text += blockSeparator;
-      }
-      text += nodeText;
-    }, 0);
-    return text;
-  }
-  /**
-  Create a new fragment containing the combined content of this
-  fragment and the other.
-  */
-  append(other) {
-    if (!other.size)
-      return this;
-    if (!this.size)
-      return other;
-    let last = this.lastChild, first = other.firstChild, content = this.content.slice(), i = 0;
-    if (last.isText && last.sameMarkup(first)) {
-      content[content.length - 1] = last.withText(last.text + first.text);
-      i = 1;
-    }
-    for (; i < other.content.length; i++)
-      content.push(other.content[i]);
-    return new _Fragment(content, this.size + other.size);
-  }
-  /**
-  Cut out the sub-fragment between the two given positions.
-  */
-  cut(from, to = this.size) {
-    if (from == 0 && to == this.size)
-      return this;
-    let result = [], size = 0;
-    if (to > from)
-      for (let i = 0, pos = 0; pos < to; i++) {
-        let child = this.content[i], end = pos + child.nodeSize;
-        if (end > from) {
-          if (pos < from || end > to) {
-            if (child.isText)
-              child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
-            else
-              child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
-          }
-          result.push(child);
-          size += child.nodeSize;
-        }
-        pos = end;
-      }
-    return new _Fragment(result, size);
-  }
-  /**
-  @internal
-  */
-  cutByIndex(from, to) {
-    if (from == to)
-      return _Fragment.empty;
-    if (from == 0 && to == this.content.length)
-      return this;
-    return new _Fragment(this.content.slice(from, to));
-  }
-  /**
-  Create a new fragment in which the node at the given index is
-  replaced by the given node.
-  */
-  replaceChild(index, node) {
-    let current = this.content[index];
-    if (current == node)
-      return this;
-    let copy2 = this.content.slice();
-    let size = this.size + node.nodeSize - current.nodeSize;
-    copy2[index] = node;
-    return new _Fragment(copy2, size);
-  }
-  /**
-  Create a new fragment by prepending the given node to this
-  fragment.
-  */
-  addToStart(node) {
-    return new _Fragment([node].concat(this.content), this.size + node.nodeSize);
-  }
-  /**
-  Create a new fragment by appending the given node to this
-  fragment.
-  */
-  addToEnd(node) {
-    return new _Fragment(this.content.concat(node), this.size + node.nodeSize);
-  }
-  /**
-  Compare this fragment to another one.
-  */
-  eq(other) {
-    if (this.content.length != other.content.length)
-      return false;
-    for (let i = 0; i < this.content.length; i++)
-      if (!this.content[i].eq(other.content[i]))
-        return false;
-    return true;
-  }
-  /**
-  The first child of the fragment, or `null` if it is empty.
-  */
-  get firstChild() {
-    return this.content.length ? this.content[0] : null;
-  }
-  /**
-  The last child of the fragment, or `null` if it is empty.
-  */
-  get lastChild() {
-    return this.content.length ? this.content[this.content.length - 1] : null;
-  }
-  /**
-  The number of child nodes in this fragment.
-  */
-  get childCount() {
-    return this.content.length;
-  }
-  /**
-  Get the child node at the given index. Raise an error when the
-  index is out of range.
-  */
-  child(index) {
-    let found2 = this.content[index];
-    if (!found2)
-      throw new RangeError("Index " + index + " out of range for " + this);
-    return found2;
-  }
-  /**
-  Get the child node at the given index, if it exists.
-  */
-  maybeChild(index) {
-    return this.content[index] || null;
-  }
-  /**
-  Call `f` for every child node, passing the node, its offset
-  into this parent node, and its index.
-  */
-  forEach(f) {
-    for (let i = 0, p = 0; i < this.content.length; i++) {
-      let child = this.content[i];
-      f(child, p, i);
-      p += child.nodeSize;
-    }
-  }
-  /**
-  Find the first position at which this fragment and another
-  fragment differ, or `null` if they are the same.
-  */
-  findDiffStart(other, pos = 0) {
-    return findDiffStart(this, other, pos);
-  }
-  /**
-  Find the first position, searching from the end, at which this
-  fragment and the given fragment differ, or `null` if they are
-  the same. Since this position will not be the same in both
-  nodes, an object with two separate positions is returned.
-  */
-  findDiffEnd(other, pos = this.size, otherPos = other.size) {
-    return findDiffEnd(this, other, pos, otherPos);
-  }
-  /**
-  Find the index and inner offset corresponding to a given relative
-  position in this fragment. The result object will be reused
-  (overwritten) the next time the function is called. @internal
-  */
-  findIndex(pos) {
-    if (pos == 0)
-      return retIndex(0, pos);
-    if (pos == this.size)
-      return retIndex(this.content.length, pos);
-    if (pos > this.size || pos < 0)
-      throw new RangeError(`Position ${pos} outside of fragment (${this})`);
-    for (let i = 0, curPos = 0; ; i++) {
-      let cur = this.child(i), end = curPos + cur.nodeSize;
-      if (end >= pos) {
-        if (end == pos)
-          return retIndex(i + 1, end);
-        return retIndex(i, curPos);
-      }
-      curPos = end;
-    }
-  }
-  /**
-  Return a debugging string that describes this fragment.
-  */
-  toString() {
-    return "<" + this.toStringInner() + ">";
-  }
-  /**
-  @internal
-  */
-  toStringInner() {
-    return this.content.join(", ");
-  }
-  /**
-  Create a JSON-serializeable representation of this fragment.
-  */
-  toJSON() {
-    return this.content.length ? this.content.map((n) => n.toJSON()) : null;
-  }
-  /**
-  Deserialize a fragment from its JSON representation.
-  */
-  static fromJSON(schema, value) {
-    if (!value)
-      return _Fragment.empty;
-    if (!Array.isArray(value))
-      throw new RangeError("Invalid input for Fragment.fromJSON");
-    return new _Fragment(value.map(schema.nodeFromJSON));
-  }
-  /**
-  Build a fragment from an array of nodes. Ensures that adjacent
-  text nodes with the same marks are joined together.
-  */
-  static fromArray(array) {
-    if (!array.length)
-      return _Fragment.empty;
-    let joined, size = 0;
-    for (let i = 0; i < array.length; i++) {
-      let node = array[i];
-      size += node.nodeSize;
-      if (i && node.isText && array[i - 1].sameMarkup(node)) {
-        if (!joined)
-          joined = array.slice(0, i);
-        joined[joined.length - 1] = node.withText(joined[joined.length - 1].text + node.text);
-      } else if (joined) {
-        joined.push(node);
-      }
-    }
-    return new _Fragment(joined || array, size);
-  }
-  /**
-  Create a fragment from something that can be interpreted as a
-  set of nodes. For `null`, it returns the empty fragment. For a
-  fragment, the fragment itself. For a node or array of nodes, a
-  fragment containing those nodes.
-  */
-  static from(nodes) {
-    if (!nodes)
-      return _Fragment.empty;
-    if (nodes instanceof _Fragment)
-      return nodes;
-    if (Array.isArray(nodes))
-      return this.fromArray(nodes);
-    if (nodes.attrs)
-      return new _Fragment([nodes], nodes.nodeSize);
-    throw new RangeError("Can not convert " + nodes + " to a Fragment" + (nodes.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
-  }
-};
-Fragment.empty = new Fragment([], 0);
-var found = { index: 0, offset: 0 };
-function retIndex(index, offset) {
-  found.index = index;
-  found.offset = offset;
-  return found;
-}
-function compareDeep(a, b) {
-  if (a === b)
-    return true;
-  if (!(a && typeof a == "object") || !(b && typeof b == "object"))
-    return false;
-  let array = Array.isArray(a);
-  if (Array.isArray(b) != array)
-    return false;
-  if (array) {
-    if (a.length != b.length)
-      return false;
-    for (let i = 0; i < a.length; i++)
-      if (!compareDeep(a[i], b[i]))
-        return false;
-  } else {
-    for (let p in a)
-      if (!(p in b) || !compareDeep(a[p], b[p]))
-        return false;
-    for (let p in b)
-      if (!(p in a))
-        return false;
-  }
-  return true;
-}
-var Mark = class _Mark {
-  /**
-  @internal
-  */
-  constructor(type, attrs) {
-    this.type = type;
-    this.attrs = attrs;
-  }
-  /**
-  Given a set of marks, create a new set which contains this one as
-  well, in the right position. If this mark is already in the set,
-  the set itself is returned. If any marks that are set to be
-  [exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
-  those are replaced by this one.
-  */
-  addToSet(set) {
-    let copy2, placed = false;
-    for (let i = 0; i < set.length; i++) {
-      let other = set[i];
-      if (this.eq(other))
-        return set;
-      if (this.type.excludes(other.type)) {
-        if (!copy2)
-          copy2 = set.slice(0, i);
-      } else if (other.type.excludes(this.type)) {
-        return set;
-      } else {
-        if (!placed && other.type.rank > this.type.rank) {
-          if (!copy2)
-            copy2 = set.slice(0, i);
-          copy2.push(this);
-          placed = true;
-        }
-        if (copy2)
-          copy2.push(other);
-      }
-    }
-    if (!copy2)
-      copy2 = set.slice();
-    if (!placed)
-      copy2.push(this);
-    return copy2;
-  }
-  /**
-  Remove this mark from the given set, returning a new set. If this
-  mark is not in the set, the set itself is returned.
-  */
-  removeFromSet(set) {
-    for (let i = 0; i < set.length; i++)
-      if (this.eq(set[i]))
-        return set.slice(0, i).concat(set.slice(i + 1));
-    return set;
-  }
-  /**
-  Test whether this mark is in the given set of marks.
-  */
-  isInSet(set) {
-    for (let i = 0; i < set.length; i++)
-      if (this.eq(set[i]))
-        return true;
-    return false;
-  }
-  /**
-  Test whether this mark has the same type and attributes as
-  another mark.
-  */
-  eq(other) {
-    return this == other || this.type == other.type && compareDeep(this.attrs, other.attrs);
-  }
-  /**
-  Convert this mark to a JSON-serializeable representation.
-  */
-  toJSON() {
-    let obj = { type: this.type.name };
-    for (let _ in this.attrs) {
-      obj.attrs = this.attrs;
-      break;
-    }
-    return obj;
-  }
-  /**
-  Deserialize a mark from JSON.
-  */
-  static fromJSON(schema, json) {
-    if (!json)
-      throw new RangeError("Invalid input for Mark.fromJSON");
-    let type = schema.marks[json.type];
-    if (!type)
-      throw new RangeError(`There is no mark type ${json.type} in this schema`);
-    let mark = type.create(json.attrs);
-    type.checkAttrs(mark.attrs);
-    return mark;
-  }
-  /**
-  Test whether two sets of marks are identical.
-  */
-  static sameSet(a, b) {
-    if (a == b)
-      return true;
-    if (a.length != b.length)
-      return false;
-    for (let i = 0; i < a.length; i++)
-      if (!a[i].eq(b[i]))
-        return false;
-    return true;
-  }
-  /**
-  Create a properly sorted mark set from null, a single mark, or an
-  unsorted array of marks.
-  */
-  static setFrom(marks) {
-    if (!marks || Array.isArray(marks) && marks.length == 0)
-      return _Mark.none;
-    if (marks instanceof _Mark)
-      return [marks];
-    let copy2 = marks.slice();
-    copy2.sort((a, b) => a.type.rank - b.type.rank);
-    return copy2;
-  }
-};
-Mark.none = [];
-var ReplaceError = class extends Error {
-};
-var Slice = class _Slice {
-  /**
-  Create a slice. When specifying a non-zero open depth, you must
-  make sure that there are nodes of at least that depth at the
-  appropriate side of the fragment—i.e. if the fragment is an
-  empty paragraph node, `openStart` and `openEnd` can't be greater
-  than 1.
-  
-  It is not necessary for the content of open nodes to conform to
-  the schema's content constraints, though it should be a valid
-  start/end/middle for such a node, depending on which sides are
-  open.
-  */
-  constructor(content, openStart, openEnd) {
-    this.content = content;
-    this.openStart = openStart;
-    this.openEnd = openEnd;
-  }
-  /**
-  The size this slice would add when inserted into a document.
-  */
-  get size() {
-    return this.content.size - this.openStart - this.openEnd;
-  }
-  /**
-  @internal
-  */
-  insertAt(pos, fragment) {
-    let content = insertInto(this.content, pos + this.openStart, fragment);
-    return content && new _Slice(content, this.openStart, this.openEnd);
-  }
-  /**
-  @internal
-  */
-  removeBetween(from, to) {
-    return new _Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
-  }
-  /**
-  Tests whether this slice is equal to another slice.
-  */
-  eq(other) {
-    return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
-  }
-  /**
-  @internal
-  */
-  toString() {
-    return this.content + "(" + this.openStart + "," + this.openEnd + ")";
-  }
-  /**
-  Convert a slice to a JSON-serializable representation.
-  */
-  toJSON() {
-    if (!this.content.size)
-      return null;
-    let json = { content: this.content.toJSON() };
-    if (this.openStart > 0)
-      json.openStart = this.openStart;
-    if (this.openEnd > 0)
-      json.openEnd = this.openEnd;
-    return json;
-  }
-  /**
-  Deserialize a slice from its JSON representation.
-  */
-  static fromJSON(schema, json) {
-    if (!json)
-      return _Slice.empty;
-    let openStart = json.openStart || 0, openEnd = json.openEnd || 0;
-    if (typeof openStart != "number" || typeof openEnd != "number")
-      throw new RangeError("Invalid input for Slice.fromJSON");
-    return new _Slice(Fragment.fromJSON(schema, json.content), openStart, openEnd);
-  }
-  /**
-  Create a slice from a fragment by taking the maximum possible
-  open value on both side of the fragment.
-  */
-  static maxOpen(fragment, openIsolating = true) {
-    let openStart = 0, openEnd = 0;
-    for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild)
-      openStart++;
-    for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild)
-      openEnd++;
-    return new _Slice(fragment, openStart, openEnd);
-  }
-};
-Slice.empty = new Slice(Fragment.empty, 0, 0);
-function removeRange(content, from, to) {
-  let { index, offset } = content.findIndex(from), child = content.maybeChild(index);
-  let { index: indexTo, offset: offsetTo } = content.findIndex(to);
-  if (offset == from || child.isText) {
-    if (offsetTo != to && !content.child(indexTo).isText)
-      throw new RangeError("Removing non-flat range");
-    return content.cut(0, from).append(content.cut(to));
-  }
-  if (index != indexTo)
-    throw new RangeError("Removing non-flat range");
-  return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
-}
-function insertInto(content, dist, insert, parent) {
-  let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
-  if (offset == dist || child.isText) {
-    if (parent && !parent.canReplace(index, index, insert))
-      return null;
-    return content.cut(0, dist).append(insert).append(content.cut(dist));
-  }
-  let inner = insertInto(child.content, dist - offset - 1, insert, child);
-  return inner && content.replaceChild(index, child.copy(inner));
-}
-function isTagRule(rule) {
-  return rule.tag != null;
-}
-function isStyleRule(rule) {
-  return rule.style != null;
-}
-var DOMParser = class _DOMParser {
-  /**
-  Create a parser that targets the given schema, using the given
-  parsing rules.
-  */
-  constructor(schema, rules) {
-    this.schema = schema;
-    this.rules = rules;
-    this.tags = [];
-    this.styles = [];
-    let matchedStyles = this.matchedStyles = [];
-    rules.forEach((rule) => {
-      if (isTagRule(rule)) {
-        this.tags.push(rule);
-      } else if (isStyleRule(rule)) {
-        let prop = /[^=]*/.exec(rule.style)[0];
-        if (matchedStyles.indexOf(prop) < 0)
-          matchedStyles.push(prop);
-        this.styles.push(rule);
-      }
-    });
-    this.normalizeLists = !this.tags.some((r) => {
-      if (!/^(ul|ol)\b/.test(r.tag) || !r.node)
-        return false;
-      let node = schema.nodes[r.node];
-      return node.contentMatch.matchType(node);
-    });
-  }
-  /**
-  Parse a document from the content of a DOM node.
-  */
-  parse(dom, options = {}) {
-    let context = new ParseContext(this, options, false);
-    context.addAll(dom, Mark.none, options.from, options.to);
-    return context.finish();
-  }
-  /**
-  Parses the content of the given DOM node, like
-  [`parse`](https://prosemirror.net/docs/ref/#model.DOMParser.parse), and takes the same set of
-  options. But unlike that method, which produces a whole node,
-  this one returns a slice that is open at the sides, meaning that
-  the schema constraints aren't applied to the start of nodes to
-  the left of the input and the end of nodes at the end.
-  */
-  parseSlice(dom, options = {}) {
-    let context = new ParseContext(this, options, true);
-    context.addAll(dom, Mark.none, options.from, options.to);
-    return Slice.maxOpen(context.finish());
-  }
-  /**
-  @internal
-  */
-  matchTag(dom, context, after) {
-    for (let i = after ? this.tags.indexOf(after) + 1 : 0; i < this.tags.length; i++) {
-      let rule = this.tags[i];
-      if (matches(dom, rule.tag) && (rule.namespace === void 0 || dom.namespaceURI == rule.namespace) && (!rule.context || context.matchesContext(rule.context))) {
-        if (rule.getAttrs) {
-          let result = rule.getAttrs(dom);
-          if (result === false)
-            continue;
-          rule.attrs = result || void 0;
-        }
-        return rule;
-      }
-    }
-  }
-  /**
-  @internal
-  */
-  matchStyle(prop, value, context, after) {
-    for (let i = after ? this.styles.indexOf(after) + 1 : 0; i < this.styles.length; i++) {
-      let rule = this.styles[i], style = rule.style;
-      if (style.indexOf(prop) != 0 || rule.context && !context.matchesContext(rule.context) || // Test that the style string either precisely matches the prop,
-      // or has an '=' sign after the prop, followed by the given
-      // value.
-      style.length > prop.length && (style.charCodeAt(prop.length) != 61 || style.slice(prop.length + 1) != value))
-        continue;
-      if (rule.getAttrs) {
-        let result = rule.getAttrs(value);
-        if (result === false)
-          continue;
-        rule.attrs = result || void 0;
-      }
-      return rule;
-    }
-  }
-  /**
-  @internal
-  */
-  static schemaRules(schema) {
-    let result = [];
-    function insert(rule) {
-      let priority = rule.priority == null ? 50 : rule.priority, i = 0;
-      for (; i < result.length; i++) {
-        let next = result[i], nextPriority = next.priority == null ? 50 : next.priority;
-        if (nextPriority < priority)
-          break;
-      }
-      result.splice(i, 0, rule);
-    }
-    for (let name in schema.marks) {
-      let rules = schema.marks[name].spec.parseDOM;
-      if (rules)
-        rules.forEach((rule) => {
-          insert(rule = copy(rule));
-          if (!(rule.mark || rule.ignore || rule.clearMark))
-            rule.mark = name;
-        });
-    }
-    for (let name in schema.nodes) {
-      let rules = schema.nodes[name].spec.parseDOM;
-      if (rules)
-        rules.forEach((rule) => {
-          insert(rule = copy(rule));
-          if (!(rule.node || rule.ignore || rule.mark))
-            rule.node = name;
-        });
-    }
-    return result;
-  }
-  /**
-  Construct a DOM parser using the parsing rules listed in a
-  schema's [node specs](https://prosemirror.net/docs/ref/#model.NodeSpec.parseDOM), reordered by
-  [priority](https://prosemirror.net/docs/ref/#model.GenericParseRule.priority).
-  */
-  static fromSchema(schema) {
-    return schema.cached.domParser || (schema.cached.domParser = new _DOMParser(schema, _DOMParser.schemaRules(schema)));
-  }
-};
-var blockTags = {
-  address: true,
-  article: true,
-  aside: true,
-  blockquote: true,
-  canvas: true,
-  dd: true,
-  div: true,
-  dl: true,
-  fieldset: true,
-  figcaption: true,
-  figure: true,
-  footer: true,
-  form: true,
-  h1: true,
-  h2: true,
-  h3: true,
-  h4: true,
-  h5: true,
-  h6: true,
-  header: true,
-  hgroup: true,
-  hr: true,
-  li: true,
-  noscript: true,
-  ol: true,
-  output: true,
-  p: true,
-  pre: true,
-  section: true,
-  table: true,
-  tfoot: true,
-  ul: true
-};
-var ignoreTags = {
-  head: true,
-  noscript: true,
-  object: true,
-  script: true,
-  style: true,
-  title: true
-};
-var listTags = { ol: true, ul: true };
-var OPT_PRESERVE_WS = 1;
-var OPT_PRESERVE_WS_FULL = 2;
-var OPT_OPEN_LEFT = 4;
-function wsOptionsFor(type, preserveWhitespace, base) {
-  if (preserveWhitespace != null)
-    return (preserveWhitespace ? OPT_PRESERVE_WS : 0) | (preserveWhitespace === "full" ? OPT_PRESERVE_WS_FULL : 0);
-  return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base & ~OPT_OPEN_LEFT;
-}
-var NodeContext = class {
-  constructor(type, attrs, marks, solid, match, options) {
-    this.type = type;
-    this.attrs = attrs;
-    this.marks = marks;
-    this.solid = solid;
-    this.options = options;
-    this.content = [];
-    this.activeMarks = Mark.none;
-    this.match = match || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
-  }
-  findWrapping(node) {
-    if (!this.match) {
-      if (!this.type)
-        return [];
-      let fill = this.type.contentMatch.fillBefore(Fragment.from(node));
-      if (fill) {
-        this.match = this.type.contentMatch.matchFragment(fill);
-      } else {
-        let start = this.type.contentMatch, wrap;
-        if (wrap = start.findWrapping(node.type)) {
-          this.match = start;
-          return wrap;
-        } else {
-          return null;
-        }
-      }
-    }
-    return this.match.findWrapping(node.type);
-  }
-  finish(openEnd) {
-    if (!(this.options & OPT_PRESERVE_WS)) {
-      let last = this.content[this.content.length - 1], m;
-      if (last && last.isText && (m = /[ \t\r\n\u000c]+$/.exec(last.text))) {
-        let text = last;
-        if (last.text.length == m[0].length)
-          this.content.pop();
-        else
-          this.content[this.content.length - 1] = text.withText(text.text.slice(0, text.text.length - m[0].length));
-      }
-    }
-    let content = Fragment.from(this.content);
-    if (!openEnd && this.match)
-      content = content.append(this.match.fillBefore(Fragment.empty, true));
-    return this.type ? this.type.create(this.attrs, content, this.marks) : content;
-  }
-  inlineContext(node) {
-    if (this.type)
-      return this.type.inlineContent;
-    if (this.content.length)
-      return this.content[0].isInline;
-    return node.parentNode && !blockTags.hasOwnProperty(node.parentNode.nodeName.toLowerCase());
-  }
-};
-var ParseContext = class {
-  constructor(parser, options, isOpen) {
-    this.parser = parser;
-    this.options = options;
-    this.isOpen = isOpen;
-    this.open = 0;
-    this.localPreserveWS = false;
-    let topNode = options.topNode, topContext;
-    let topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
-    if (topNode)
-      topContext = new NodeContext(topNode.type, topNode.attrs, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
-    else if (isOpen)
-      topContext = new NodeContext(null, null, Mark.none, true, null, topOptions);
-    else
-      topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, true, null, topOptions);
-    this.nodes = [topContext];
-    this.find = options.findPositions;
-    this.needsBlock = false;
-  }
-  get top() {
-    return this.nodes[this.open];
-  }
-  // Add a DOM node to the content. Text is inserted as text node,
-  // otherwise, the node is passed to `addElement` or, if it has a
-  // `style` attribute, `addElementWithStyles`.
-  addDOM(dom, marks) {
-    if (dom.nodeType == 3)
-      this.addTextNode(dom, marks);
-    else if (dom.nodeType == 1)
-      this.addElement(dom, marks);
-  }
-  addTextNode(dom, marks) {
-    let value = dom.nodeValue;
-    let top = this.top, preserveWS = top.options & OPT_PRESERVE_WS_FULL ? "full" : this.localPreserveWS || (top.options & OPT_PRESERVE_WS) > 0;
-    let { schema } = this.parser;
-    if (preserveWS === "full" || top.inlineContext(dom) || /[^ \t\r\n\u000c]/.test(value)) {
-      if (!preserveWS) {
-        value = value.replace(/[ \t\r\n\u000c]+/g, " ");
-        if (/^[ \t\r\n\u000c]/.test(value) && this.open == this.nodes.length - 1) {
-          let nodeBefore = top.content[top.content.length - 1];
-          let domNodeBefore = dom.previousSibling;
-          if (!nodeBefore || domNodeBefore && domNodeBefore.nodeName == "BR" || nodeBefore.isText && /[ \t\r\n\u000c]$/.test(nodeBefore.text))
-            value = value.slice(1);
-        }
-      } else if (preserveWS === "full") {
-        value = value.replace(/\r\n?/g, "\n");
-      } else if (schema.linebreakReplacement && /[\r\n]/.test(value) && this.top.findWrapping(schema.linebreakReplacement.create())) {
-        let lines = value.split(/\r?\n|\r/);
-        for (let i = 0; i < lines.length; i++) {
-          if (i)
-            this.insertNode(schema.linebreakReplacement.create(), marks, true);
-          if (lines[i])
-            this.insertNode(schema.text(lines[i]), marks, !/\S/.test(lines[i]));
-        }
-        value = "";
-      } else {
-        value = value.replace(/\r?\n|\r/g, " ");
-      }
-      if (value)
-        this.insertNode(schema.text(value), marks, !/\S/.test(value));
-      this.findInText(dom);
-    } else {
-      this.findInside(dom);
-    }
-  }
-  // Try to find a handler for the given tag and use that to parse. If
-  // none is found, the element's content nodes are added directly.
-  addElement(dom, marks, matchAfter) {
-    let outerWS = this.localPreserveWS, top = this.top;
-    if (dom.tagName == "PRE" || /pre/.test(dom.style && dom.style.whiteSpace))
-      this.localPreserveWS = true;
-    let name = dom.nodeName.toLowerCase(), ruleID;
-    if (listTags.hasOwnProperty(name) && this.parser.normalizeLists)
-      normalizeList(dom);
-    let rule = this.options.ruleFromNode && this.options.ruleFromNode(dom) || (ruleID = this.parser.matchTag(dom, this, matchAfter));
-    out: if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
-      this.findInside(dom);
-      this.ignoreFallback(dom, marks);
-    } else if (!rule || rule.skip || rule.closeParent) {
-      if (rule && rule.closeParent)
-        this.open = Math.max(0, this.open - 1);
-      else if (rule && rule.skip.nodeType)
-        dom = rule.skip;
-      let sync, oldNeedsBlock = this.needsBlock;
-      if (blockTags.hasOwnProperty(name)) {
-        if (top.content.length && top.content[0].isInline && this.open) {
-          this.open--;
-          top = this.top;
-        }
-        sync = true;
-        if (!top.type)
-          this.needsBlock = true;
-      } else if (!dom.firstChild) {
-        this.leafFallback(dom, marks);
-        break out;
-      }
-      let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
-      if (innerMarks)
-        this.addAll(dom, innerMarks);
-      if (sync)
-        this.sync(top);
-      this.needsBlock = oldNeedsBlock;
-    } else {
-      let innerMarks = this.readStyles(dom, marks);
-      if (innerMarks)
-        this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : void 0);
-    }
-    this.localPreserveWS = outerWS;
-  }
-  // Called for leaf DOM nodes that would otherwise be ignored
-  leafFallback(dom, marks) {
-    if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent)
-      this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
-  }
-  // Called for ignored nodes
-  ignoreFallback(dom, marks) {
-    if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent))
-      this.findPlace(this.parser.schema.text("-"), marks, true);
-  }
-  // Run any style parser associated with the node's styles. Either
-  // return an updated array of marks, or null to indicate some of the
-  // styles had a rule with `ignore` set.
-  readStyles(dom, marks) {
-    let styles = dom.style;
-    if (styles && styles.length)
-      for (let i = 0; i < this.parser.matchedStyles.length; i++) {
-        let name = this.parser.matchedStyles[i], value = styles.getPropertyValue(name);
-        if (value)
-          for (let after = void 0; ; ) {
-            let rule = this.parser.matchStyle(name, value, this, after);
-            if (!rule)
-              break;
-            if (rule.ignore)
-              return null;
-            if (rule.clearMark)
-              marks = marks.filter((m) => !rule.clearMark(m));
-            else
-              marks = marks.concat(this.parser.schema.marks[rule.mark].create(rule.attrs));
-            if (rule.consuming === false)
-              after = rule;
-            else
-              break;
-          }
-      }
-    return marks;
-  }
-  // Look up a handler for the given node. If none are found, return
-  // false. Otherwise, apply it, use its return value to drive the way
-  // the node's content is wrapped, and return true.
-  addElementByRule(dom, rule, marks, continueAfter) {
-    let sync, nodeType;
-    if (rule.node) {
-      nodeType = this.parser.schema.nodes[rule.node];
-      if (!nodeType.isLeaf) {
-        let inner = this.enter(nodeType, rule.attrs || null, marks, rule.preserveWhitespace);
-        if (inner) {
-          sync = true;
-          marks = inner;
-        }
-      } else if (!this.insertNode(nodeType.create(rule.attrs), marks, dom.nodeName == "BR")) {
-        this.leafFallback(dom, marks);
-      }
-    } else {
-      let markType = this.parser.schema.marks[rule.mark];
-      marks = marks.concat(markType.create(rule.attrs));
-    }
-    let startIn = this.top;
-    if (nodeType && nodeType.isLeaf) {
-      this.findInside(dom);
-    } else if (continueAfter) {
-      this.addElement(dom, marks, continueAfter);
-    } else if (rule.getContent) {
-      this.findInside(dom);
-      rule.getContent(dom, this.parser.schema).forEach((node) => this.insertNode(node, marks, false));
-    } else {
-      let contentDOM = dom;
-      if (typeof rule.contentElement == "string")
-        contentDOM = dom.querySelector(rule.contentElement);
-      else if (typeof rule.contentElement == "function")
-        contentDOM = rule.contentElement(dom);
-      else if (rule.contentElement)
-        contentDOM = rule.contentElement;
-      this.findAround(dom, contentDOM, true);
-      this.addAll(contentDOM, marks);
-      this.findAround(dom, contentDOM, false);
-    }
-    if (sync && this.sync(startIn))
-      this.open--;
-  }
-  // Add all child nodes between `startIndex` and `endIndex` (or the
-  // whole node, if not given). If `sync` is passed, use it to
-  // synchronize after every block element.
-  addAll(parent, marks, startIndex, endIndex) {
-    let index = startIndex || 0;
-    for (let dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end = endIndex == null ? null : parent.childNodes[endIndex]; dom != end; dom = dom.nextSibling, ++index) {
-      this.findAtPoint(parent, index);
-      this.addDOM(dom, marks);
-    }
-    this.findAtPoint(parent, index);
-  }
-  // Try to find a way to fit the given node type into the current
-  // context. May add intermediate wrappers and/or leave non-solid
-  // nodes that we're in.
-  findPlace(node, marks, cautious) {
-    let route, sync;
-    for (let depth = this.open, penalty = 0; depth >= 0; depth--) {
-      let cx = this.nodes[depth];
-      let found2 = cx.findWrapping(node);
-      if (found2 && (!route || route.length > found2.length + penalty)) {
-        route = found2;
-        sync = cx;
-        if (!found2.length)
-          break;
-      }
-      if (cx.solid) {
-        if (cautious)
-          break;
-        penalty += 2;
-      }
-    }
-    if (!route)
-      return null;
-    this.sync(sync);
-    for (let i = 0; i < route.length; i++)
-      marks = this.enterInner(route[i], null, marks, false);
-    return marks;
-  }
-  // Try to insert the given node, adjusting the context when needed.
-  insertNode(node, marks, cautious) {
-    if (node.isInline && this.needsBlock && !this.top.type) {
-      let block = this.textblockFromContext();
-      if (block)
-        marks = this.enterInner(block, null, marks);
-    }
-    let innerMarks = this.findPlace(node, marks, cautious);
-    if (innerMarks) {
-      this.closeExtra();
-      let top = this.top;
-      if (top.match)
-        top.match = top.match.matchType(node.type);
-      let nodeMarks = Mark.none;
-      for (let m of innerMarks.concat(node.marks))
-        if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, node.type))
-          nodeMarks = m.addToSet(nodeMarks);
-      top.content.push(node.mark(nodeMarks));
-      return true;
-    }
-    return false;
-  }
-  // Try to start a node of the given type, adjusting the context when
-  // necessary.
-  enter(type, attrs, marks, preserveWS) {
-    let innerMarks = this.findPlace(type.create(attrs), marks, false);
-    if (innerMarks)
-      innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
-    return innerMarks;
-  }
-  // Open a node of the given type
-  enterInner(type, attrs, marks, solid = false, preserveWS) {
-    this.closeExtra();
-    let top = this.top;
-    top.match = top.match && top.match.matchType(type);
-    let options = wsOptionsFor(type, preserveWS, top.options);
-    if (top.options & OPT_OPEN_LEFT && top.content.length == 0)
-      options |= OPT_OPEN_LEFT;
-    let applyMarks = Mark.none;
-    marks = marks.filter((m) => {
-      if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, type)) {
-        applyMarks = m.addToSet(applyMarks);
-        return false;
-      }
-      return true;
-    });
-    this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
-    this.open++;
-    return marks;
-  }
-  // Make sure all nodes above this.open are finished and added to
-  // their parents
-  closeExtra(openEnd = false) {
-    let i = this.nodes.length - 1;
-    if (i > this.open) {
-      for (; i > this.open; i--)
-        this.nodes[i - 1].content.push(this.nodes[i].finish(openEnd));
-      this.nodes.length = this.open + 1;
-    }
-  }
-  finish() {
-    this.open = 0;
-    this.closeExtra(this.isOpen);
-    return this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
-  }
-  sync(to) {
-    for (let i = this.open; i >= 0; i--) {
-      if (this.nodes[i] == to) {
-        this.open = i;
-        return true;
-      } else if (this.localPreserveWS) {
-        this.nodes[i].options |= OPT_PRESERVE_WS;
-      }
-    }
-    return false;
-  }
-  get currentPos() {
-    this.closeExtra();
-    let pos = 0;
-    for (let i = this.open; i >= 0; i--) {
-      let content = this.nodes[i].content;
-      for (let j = content.length - 1; j >= 0; j--)
-        pos += content[j].nodeSize;
-      if (i)
-        pos++;
-    }
-    return pos;
-  }
-  findAtPoint(parent, offset) {
-    if (this.find)
-      for (let i = 0; i < this.find.length; i++) {
-        if (this.find[i].node == parent && this.find[i].offset == offset)
-          this.find[i].pos = this.currentPos;
-      }
-  }
-  findInside(parent) {
-    if (this.find)
-      for (let i = 0; i < this.find.length; i++) {
-        if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node))
-          this.find[i].pos = this.currentPos;
-      }
-  }
-  findAround(parent, content, before) {
-    if (parent != content && this.find)
-      for (let i = 0; i < this.find.length; i++) {
-        if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node)) {
-          let pos = content.compareDocumentPosition(this.find[i].node);
-          if (pos & (before ? 2 : 4))
-            this.find[i].pos = this.currentPos;
-        }
-      }
-  }
-  findInText(textNode) {
-    if (this.find)
-      for (let i = 0; i < this.find.length; i++) {
-        if (this.find[i].node == textNode)
-          this.find[i].pos = this.currentPos - (textNode.nodeValue.length - this.find[i].offset);
-      }
-  }
-  // Determines whether the given context string matches this context.
-  matchesContext(context) {
-    if (context.indexOf("|") > -1)
-      return context.split(/\s*\|\s*/).some(this.matchesContext, this);
-    let parts = context.split("/");
-    let option = this.options.context;
-    let useRoot = !this.isOpen && (!option || option.parent.type == this.nodes[0].type);
-    let minDepth = -(option ? option.depth + 1 : 0) + (useRoot ? 0 : 1);
-    let match = (i, depth) => {
-      for (; i >= 0; i--) {
-        let part = parts[i];
-        if (part == "") {
-          if (i == parts.length - 1 || i == 0)
-            continue;
-          for (; depth >= minDepth; depth--)
-            if (match(i - 1, depth))
-              return true;
-          return false;
-        } else {
-          let next = depth > 0 || depth == 0 && useRoot ? this.nodes[depth].type : option && depth >= minDepth ? option.node(depth - minDepth).type : null;
-          if (!next || next.name != part && !next.isInGroup(part))
-            return false;
-          depth--;
-        }
-      }
-      return true;
-    };
-    return match(parts.length - 1, this.open);
-  }
-  textblockFromContext() {
-    let $context = this.options.context;
-    if ($context)
-      for (let d = $context.depth; d >= 0; d--) {
-        let deflt = $context.node(d).contentMatchAt($context.indexAfter(d)).defaultType;
-        if (deflt && deflt.isTextblock && deflt.defaultAttrs)
-          return deflt;
-      }
-    for (let name in this.parser.schema.nodes) {
-      let type = this.parser.schema.nodes[name];
-      if (type.isTextblock && type.defaultAttrs)
-        return type;
-    }
-  }
-};
-function normalizeList(dom) {
-  for (let child = dom.firstChild, prevItem = null; child; child = child.nextSibling) {
-    let name = child.nodeType == 1 ? child.nodeName.toLowerCase() : null;
-    if (name && listTags.hasOwnProperty(name) && prevItem) {
-      prevItem.appendChild(child);
-      child = prevItem;
-    } else if (name == "li") {
-      prevItem = child;
-    } else if (name) {
-      prevItem = null;
-    }
-  }
-}
-function matches(dom, selector) {
-  return (dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector).call(dom, selector);
-}
-function copy(obj) {
-  let copy2 = {};
-  for (let prop in obj)
-    copy2[prop] = obj[prop];
-  return copy2;
-}
-function markMayApply(markType, nodeType) {
-  let nodes = nodeType.schema.nodes;
-  for (let name in nodes) {
-    let parent = nodes[name];
-    if (!parent.allowsMarkType(markType))
-      continue;
-    let seen = [], scan = (match) => {
-      seen.push(match);
-      for (let i = 0; i < match.edgeCount; i++) {
-        let { type, next } = match.edge(i);
-        if (type == nodeType)
-          return true;
-        if (seen.indexOf(next) < 0 && scan(next))
-          return true;
-      }
-    };
-    if (scan(parent.contentMatch))
-      return true;
-  }
-}
-var DOMSerializer = class _DOMSerializer {
-  /**
-  Create a serializer. `nodes` should map node names to functions
-  that take a node and return a description of the corresponding
-  DOM. `marks` does the same for mark names, but also gets an
-  argument that tells it whether the mark's content is block or
-  inline content (for typical use, it'll always be inline). A mark
-  serializer may be `null` to indicate that marks of that type
-  should not be serialized.
-  */
-  constructor(nodes, marks) {
-    this.nodes = nodes;
-    this.marks = marks;
-  }
-  /**
-  Serialize the content of this fragment to a DOM fragment. When
-  not in the browser, the `document` option, containing a DOM
-  document, should be passed so that the serializer can create
-  nodes.
-  */
-  serializeFragment(fragment, options = {}, target) {
-    if (!target)
-      target = doc(options).createDocumentFragment();
-    let top = target, active = [];
-    fragment.forEach((node) => {
-      if (active.length || node.marks.length) {
-        let keep = 0, rendered = 0;
-        while (keep < active.length && rendered < node.marks.length) {
-          let next = node.marks[rendered];
-          if (!this.marks[next.type.name]) {
-            rendered++;
-            continue;
-          }
-          if (!next.eq(active[keep][0]) || next.type.spec.spanning === false)
-            break;
-          keep++;
-          rendered++;
-        }
-        while (keep < active.length)
-          top = active.pop()[1];
-        while (rendered < node.marks.length) {
-          let add = node.marks[rendered++];
-          let markDOM = this.serializeMark(add, node.isInline, options);
-          if (markDOM) {
-            active.push([add, top]);
-            top.appendChild(markDOM.dom);
-            top = markDOM.contentDOM || markDOM.dom;
-          }
-        }
-      }
-      top.appendChild(this.serializeNodeInner(node, options));
-    });
-    return target;
-  }
-  /**
-  @internal
-  */
-  serializeNodeInner(node, options) {
-    let { dom, contentDOM } = renderSpec(doc(options), this.nodes[node.type.name](node), null, node.attrs);
-    if (contentDOM) {
-      if (node.isLeaf)
-        throw new RangeError("Content hole not allowed in a leaf node spec");
-      this.serializeFragment(node.content, options, contentDOM);
-    }
-    return dom;
-  }
-  /**
-  Serialize this node to a DOM node. This can be useful when you
-  need to serialize a part of a document, as opposed to the whole
-  document. To serialize a whole document, use
-  [`serializeFragment`](https://prosemirror.net/docs/ref/#model.DOMSerializer.serializeFragment) on
-  its [content](https://prosemirror.net/docs/ref/#model.Node.content).
-  */
-  serializeNode(node, options = {}) {
-    let dom = this.serializeNodeInner(node, options);
-    for (let i = node.marks.length - 1; i >= 0; i--) {
-      let wrap = this.serializeMark(node.marks[i], node.isInline, options);
-      if (wrap) {
-        (wrap.contentDOM || wrap.dom).appendChild(dom);
-        dom = wrap.dom;
-      }
-    }
-    return dom;
-  }
-  /**
-  @internal
-  */
-  serializeMark(mark, inline, options = {}) {
-    let toDOM = this.marks[mark.type.name];
-    return toDOM && renderSpec(doc(options), toDOM(mark, inline), null, mark.attrs);
-  }
-  static renderSpec(doc3, structure, xmlNS = null, blockArraysIn) {
-    return renderSpec(doc3, structure, xmlNS, blockArraysIn);
-  }
-  /**
-  Build a serializer using the [`toDOM`](https://prosemirror.net/docs/ref/#model.NodeSpec.toDOM)
-  properties in a schema's node and mark specs.
-  */
-  static fromSchema(schema) {
-    return schema.cached.domSerializer || (schema.cached.domSerializer = new _DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
-  }
-  /**
-  Gather the serializers in a schema's node specs into an object.
-  This can be useful as a base to build a custom serializer from.
-  */
-  static nodesFromSchema(schema) {
-    let result = gatherToDOM(schema.nodes);
-    if (!result.text)
-      result.text = (node) => node.text;
-    return result;
-  }
-  /**
-  Gather the serializers in a schema's mark specs into an object.
-  */
-  static marksFromSchema(schema) {
-    return gatherToDOM(schema.marks);
-  }
-};
-function gatherToDOM(obj) {
-  let result = {};
-  for (let name in obj) {
-    let toDOM = obj[name].spec.toDOM;
-    if (toDOM)
-      result[name] = toDOM;
-  }
-  return result;
-}
-function doc(options) {
-  return options.document || window.document;
-}
-var suspiciousAttributeCache = /* @__PURE__ */ new WeakMap();
-function suspiciousAttributes(attrs) {
-  let value = suspiciousAttributeCache.get(attrs);
-  if (value === void 0)
-    suspiciousAttributeCache.set(attrs, value = suspiciousAttributesInner(attrs));
-  return value;
-}
-function suspiciousAttributesInner(attrs) {
-  let result = null;
-  function scan(value) {
-    if (value && typeof value == "object") {
-      if (Array.isArray(value)) {
-        if (typeof value[0] == "string") {
-          if (!result)
-            result = [];
-          result.push(value);
-        } else {
-          for (let i = 0; i < value.length; i++)
-            scan(value[i]);
-        }
-      } else {
-        for (let prop in value)
-          scan(value[prop]);
-      }
-    }
-  }
-  scan(attrs);
-  return result;
-}
-function renderSpec(doc3, structure, xmlNS, blockArraysIn) {
-  if (typeof structure == "string")
-    return { dom: doc3.createTextNode(structure) };
-  if (structure.nodeType != null)
-    return { dom: structure };
-  if (structure.dom && structure.dom.nodeType != null)
-    return structure;
-  let tagName = structure[0], suspicious;
-  if (typeof tagName != "string")
-    throw new RangeError("Invalid array passed to renderSpec");
-  if (blockArraysIn && (suspicious = suspiciousAttributes(blockArraysIn)) && suspicious.indexOf(structure) > -1)
-    throw new RangeError("Using an array from an attribute object as a DOM spec. This may be an attempted cross site scripting attack.");
-  let space = tagName.indexOf(" ");
-  if (space > 0) {
-    xmlNS = tagName.slice(0, space);
-    tagName = tagName.slice(space + 1);
-  }
-  let contentDOM;
-  let dom = xmlNS ? doc3.createElementNS(xmlNS, tagName) : doc3.createElement(tagName);
-  let attrs = structure[1], start = 1;
-  if (attrs && typeof attrs == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
-    start = 2;
-    for (let name in attrs)
-      if (attrs[name] != null) {
-        let space2 = name.indexOf(" ");
-        if (space2 > 0)
-          dom.setAttributeNS(name.slice(0, space2), name.slice(space2 + 1), attrs[name]);
-        else if (name == "style" && dom.style)
-          dom.style.cssText = attrs[name];
-        else
-          dom.setAttribute(name, attrs[name]);
-      }
-  }
-  for (let i = start; i < structure.length; i++) {
-    let child = structure[i];
-    if (child === 0) {
-      if (i < structure.length - 1 || i > start)
-        throw new RangeError("Content hole must be the only child of its parent node");
-      return { dom, contentDOM: dom };
-    } else {
-      let { dom: inner, contentDOM: innerContent } = renderSpec(doc3, child, xmlNS, blockArraysIn);
-      dom.appendChild(inner);
-      if (innerContent) {
-        if (contentDOM)
-          throw new RangeError("Multiple content holes");
-        contentDOM = innerContent;
-      }
-    }
-  }
-  return { dom, contentDOM };
-}
-
-// node_modules/prosemirror-transform/dist/index.js
-var lower16 = 65535;
-var factor16 = Math.pow(2, 16);
-function makeRecover(index, offset) {
-  return index + offset * factor16;
-}
-function recoverIndex(value) {
-  return value & lower16;
-}
-function recoverOffset(value) {
-  return (value - (value & lower16)) / factor16;
-}
-var DEL_BEFORE = 1;
-var DEL_AFTER = 2;
-var DEL_ACROSS = 4;
-var DEL_SIDE = 8;
-var MapResult = class {
-  /**
-  @internal
-  */
-  constructor(pos, delInfo, recover) {
-    this.pos = pos;
-    this.delInfo = delInfo;
-    this.recover = recover;
-  }
-  /**
-  Tells you whether the position was deleted, that is, whether the
-  step removed the token on the side queried (via the `assoc`)
-  argument from the document.
-  */
-  get deleted() {
-    return (this.delInfo & DEL_SIDE) > 0;
-  }
-  /**
-  Tells you whether the token before the mapped position was deleted.
-  */
-  get deletedBefore() {
-    return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0;
-  }
-  /**
-  True when the token after the mapped position was deleted.
-  */
-  get deletedAfter() {
-    return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0;
-  }
-  /**
-  Tells whether any of the steps mapped through deletes across the
-  position (including both the token before and after the
-  position).
-  */
-  get deletedAcross() {
-    return (this.delInfo & DEL_ACROSS) > 0;
-  }
-};
-var StepMap = class _StepMap {
-  /**
-  Create a position map. The modifications to the document are
-  represented as an array of numbers, in which each group of three
-  represents a modified chunk as `[start, oldSize, newSize]`.
-  */
-  constructor(ranges, inverted = false) {
-    this.ranges = ranges;
-    this.inverted = inverted;
-    if (!ranges.length && _StepMap.empty)
-      return _StepMap.empty;
-  }
-  /**
-  @internal
-  */
-  recover(value) {
-    let diff = 0, index = recoverIndex(value);
-    if (!this.inverted)
-      for (let i = 0; i < index; i++)
-        diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
-    return this.ranges[index * 3] + diff + recoverOffset(value);
-  }
-  mapResult(pos, assoc = 1) {
-    return this._map(pos, assoc, false);
-  }
-  map(pos, assoc = 1) {
-    return this._map(pos, assoc, true);
-  }
-  /**
-  @internal
-  */
-  _map(pos, assoc, simple) {
-    let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-    for (let i = 0; i < this.ranges.length; i += 3) {
-      let start = this.ranges[i] - (this.inverted ? diff : 0);
-      if (start > pos)
-        break;
-      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
-      if (pos <= end) {
-        let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc;
-        let result = start + diff + (side < 0 ? 0 : newSize);
-        if (simple)
-          return result;
-        let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
-        let del = pos == start ? DEL_AFTER : pos == end ? DEL_BEFORE : DEL_ACROSS;
-        if (assoc < 0 ? pos != start : pos != end)
-          del |= DEL_SIDE;
-        return new MapResult(result, del, recover);
-      }
-      diff += newSize - oldSize;
-    }
-    return simple ? pos + diff : new MapResult(pos + diff, 0, null);
-  }
-  /**
-  @internal
-  */
-  touches(pos, recover) {
-    let diff = 0, index = recoverIndex(recover);
-    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-    for (let i = 0; i < this.ranges.length; i += 3) {
-      let start = this.ranges[i] - (this.inverted ? diff : 0);
-      if (start > pos)
-        break;
-      let oldSize = this.ranges[i + oldIndex], end = start + oldSize;
-      if (pos <= end && i == index * 3)
-        return true;
-      diff += this.ranges[i + newIndex] - oldSize;
-    }
-    return false;
-  }
-  /**
-  Calls the given function on each of the changed ranges included in
-  this map.
-  */
-  forEach(f) {
-    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-    for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
-      let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
-      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex];
-      f(oldStart, oldStart + oldSize, newStart, newStart + newSize);
-      diff += newSize - oldSize;
-    }
-  }
-  /**
-  Create an inverted version of this map. The result can be used to
-  map positions in the post-step document to the pre-step document.
-  */
-  invert() {
-    return new _StepMap(this.ranges, !this.inverted);
-  }
-  /**
-  @internal
-  */
-  toString() {
-    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
-  }
-  /**
-  Create a map that moves all positions by offset `n` (which may be
-  negative). This can be useful when applying steps meant for a
-  sub-document to a larger document, or vice-versa.
-  */
-  static offset(n) {
-    return n == 0 ? _StepMap.empty : new _StepMap(n < 0 ? [0, -n, 0] : [0, 0, n]);
-  }
-};
-StepMap.empty = new StepMap([]);
-var stepsByID = /* @__PURE__ */ Object.create(null);
-var Step = class {
-  /**
-  Get the step map that represents the changes made by this step,
-  and which can be used to transform between positions in the old
-  and the new document.
-  */
-  getMap() {
-    return StepMap.empty;
-  }
-  /**
-  Try to merge this step with another one, to be applied directly
-  after it. Returns the merged step when possible, null if the
-  steps can't be merged.
-  */
-  merge(other) {
-    return null;
-  }
-  /**
-  Deserialize a step from its JSON representation. Will call
-  through to the step class' own implementation of this method.
-  */
-  static fromJSON(schema, json) {
-    if (!json || !json.stepType)
-      throw new RangeError("Invalid input for Step.fromJSON");
-    let type = stepsByID[json.stepType];
-    if (!type)
-      throw new RangeError(`No step type ${json.stepType} defined`);
-    return type.fromJSON(schema, json);
-  }
-  /**
-  To be able to serialize steps to JSON, each step needs a string
-  ID to attach to its JSON representation. Use this method to
-  register an ID for your step classes. Try to pick something
-  that's unlikely to clash with steps from other modules.
-  */
-  static jsonID(id, stepClass) {
-    if (id in stepsByID)
-      throw new RangeError("Duplicate use of step JSON ID " + id);
-    stepsByID[id] = stepClass;
-    stepClass.prototype.jsonID = id;
-    return stepClass;
-  }
-};
-var StepResult = class _StepResult {
-  /**
-  @internal
-  */
-  constructor(doc3, failed) {
-    this.doc = doc3;
-    this.failed = failed;
-  }
-  /**
-  Create a successful step result.
-  */
-  static ok(doc3) {
-    return new _StepResult(doc3, null);
-  }
-  /**
-  Create a failed step result.
-  */
-  static fail(message) {
-    return new _StepResult(null, message);
-  }
-  /**
-  Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
-  arguments. Create a successful result if it succeeds, and a
-  failed one if it throws a `ReplaceError`.
-  */
-  static fromReplace(doc3, from, to, slice) {
-    try {
-      return _StepResult.ok(doc3.replace(from, to, slice));
-    } catch (e) {
-      if (e instanceof ReplaceError)
-        return _StepResult.fail(e.message);
-      throw e;
-    }
-  }
-};
-function mapFragment(fragment, f, parent) {
-  let mapped = [];
-  for (let i = 0; i < fragment.childCount; i++) {
-    let child = fragment.child(i);
-    if (child.content.size)
-      child = child.copy(mapFragment(child.content, f, child));
-    if (child.isInline)
-      child = f(child, parent, i);
-    mapped.push(child);
-  }
-  return Fragment.fromArray(mapped);
-}
-var AddMarkStep = class _AddMarkStep extends Step {
-  /**
-  Create a mark step.
-  */
-  constructor(from, to, mark) {
-    super();
-    this.from = from;
-    this.to = to;
-    this.mark = mark;
-  }
-  apply(doc3) {
-    let oldSlice = doc3.slice(this.from, this.to), $from = doc3.resolve(this.from);
-    let parent = $from.node($from.sharedDepth(this.to));
-    let slice = new Slice(mapFragment(oldSlice.content, (node, parent2) => {
-      if (!node.isAtom || !parent2.type.allowsMarkType(this.mark.type))
-        return node;
-      return node.mark(this.mark.addToSet(node.marks));
-    }, parent), oldSlice.openStart, oldSlice.openEnd);
-    return StepResult.fromReplace(doc3, this.from, this.to, slice);
-  }
-  invert() {
-    return new RemoveMarkStep(this.from, this.to, this.mark);
-  }
-  map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos)
-      return null;
-    return new _AddMarkStep(from.pos, to.pos, this.mark);
-  }
-  merge(other) {
-    if (other instanceof _AddMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
-      return new _AddMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
-    return null;
-  }
-  toJSON() {
-    return {
-      stepType: "addMark",
-      mark: this.mark.toJSON(),
-      from: this.from,
-      to: this.to
-    };
-  }
-  /**
-  @internal
-  */
-  static fromJSON(schema, json) {
-    if (typeof json.from != "number" || typeof json.to != "number")
-      throw new RangeError("Invalid input for AddMarkStep.fromJSON");
-    return new _AddMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
-  }
-};
-Step.jsonID("addMark", AddMarkStep);
-var RemoveMarkStep = class _RemoveMarkStep extends Step {
-  /**
-  Create a mark-removing step.
-  */
-  constructor(from, to, mark) {
-    super();
-    this.from = from;
-    this.to = to;
-    this.mark = mark;
-  }
-  apply(doc3) {
-    let oldSlice = doc3.slice(this.from, this.to);
-    let slice = new Slice(mapFragment(oldSlice.content, (node) => {
-      return node.mark(this.mark.removeFromSet(node.marks));
-    }, doc3), oldSlice.openStart, oldSlice.openEnd);
-    return StepResult.fromReplace(doc3, this.from, this.to, slice);
-  }
-  invert() {
-    return new AddMarkStep(this.from, this.to, this.mark);
-  }
-  map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos)
-      return null;
-    return new _RemoveMarkStep(from.pos, to.pos, this.mark);
-  }
-  merge(other) {
-    if (other instanceof _RemoveMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
-      return new _RemoveMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
-    return null;
-  }
-  toJSON() {
-    return {
-      stepType: "removeMark",
-      mark: this.mark.toJSON(),
-      from: this.from,
-      to: this.to
-    };
-  }
-  /**
-  @internal
-  */
-  static fromJSON(schema, json) {
-    if (typeof json.from != "number" || typeof json.to != "number")
-      throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
-    return new _RemoveMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
-  }
-};
-Step.jsonID("removeMark", RemoveMarkStep);
-var AddNodeMarkStep = class _AddNodeMarkStep extends Step {
-  /**
-  Create a node mark step.
-  */
-  constructor(pos, mark) {
-    super();
-    this.pos = pos;
-    this.mark = mark;
-  }
-  apply(doc3) {
-    let node = doc3.nodeAt(this.pos);
-    if (!node)
-      return StepResult.fail("No node at mark step's position");
-    let updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
-    return StepResult.fromReplace(doc3, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-  }
-  invert(doc3) {
-    let node = doc3.nodeAt(this.pos);
-    if (node) {
-      let newSet = this.mark.addToSet(node.marks);
-      if (newSet.length == node.marks.length) {
-        for (let i = 0; i < node.marks.length; i++)
-          if (!node.marks[i].isInSet(newSet))
-            return new _AddNodeMarkStep(this.pos, node.marks[i]);
-        return new _AddNodeMarkStep(this.pos, this.mark);
-      }
-    }
-    return new RemoveNodeMarkStep(this.pos, this.mark);
-  }
-  map(mapping) {
-    let pos = mapping.mapResult(this.pos, 1);
-    return pos.deletedAfter ? null : new _AddNodeMarkStep(pos.pos, this.mark);
-  }
-  toJSON() {
-    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-  }
-  /**
-  @internal
-  */
-  static fromJSON(schema, json) {
-    if (typeof json.pos != "number")
-      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
-    return new _AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
-  }
-};
-Step.jsonID("addNodeMark", AddNodeMarkStep);
-var RemoveNodeMarkStep = class _RemoveNodeMarkStep extends Step {
-  /**
-  Create a mark-removing step.
-  */
-  constructor(pos, mark) {
-    super();
-    this.pos = pos;
-    this.mark = mark;
-  }
-  apply(doc3) {
-    let node = doc3.nodeAt(this.pos);
-    if (!node)
-      return StepResult.fail("No node at mark step's position");
-    let updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
-    return StepResult.fromReplace(doc3, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-  }
-  invert(doc3) {
-    let node = doc3.nodeAt(this.pos);
-    if (!node || !this.mark.isInSet(node.marks))
-      return this;
-    return new AddNodeMarkStep(this.pos, this.mark);
-  }
-  map(mapping) {
-    let pos = mapping.mapResult(this.pos, 1);
-    return pos.deletedAfter ? null : new _RemoveNodeMarkStep(pos.pos, this.mark);
-  }
-  toJSON() {
-    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-  }
-  /**
-  @internal
-  */
-  static fromJSON(schema, json) {
-    if (typeof json.pos != "number")
-      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
-    return new _RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
-  }
-};
-Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
-var ReplaceStep = class _ReplaceStep extends Step {
-  /**
-  The given `slice` should fit the 'gap' between `from` and
-  `to`—the depths must line up, and the surrounding nodes must be
-  able to be joined with the open sides of the slice. When
-  `structure` is true, the step will fail if the content between
-  from and to is not just a sequence of closing and then opening
-  tokens (this is to guard against rebased replace steps
-  overwriting something they weren't supposed to).
-  */
-  constructor(from, to, slice, structure = false) {
-    super();
-    this.from = from;
-    this.to = to;
-    this.slice = slice;
-    this.structure = structure;
-  }
-  apply(doc3) {
-    if (this.structure && contentBetween(doc3, this.from, this.to))
-      return StepResult.fail("Structure replace would overwrite content");
-    return StepResult.fromReplace(doc3, this.from, this.to, this.slice);
-  }
-  getMap() {
-    return new StepMap([this.from, this.to - this.from, this.slice.size]);
-  }
-  invert(doc3) {
-    return new _ReplaceStep(this.from, this.from + this.slice.size, doc3.slice(this.from, this.to));
-  }
-  map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deletedAcross && to.deletedAcross)
-      return null;
-    return new _ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure);
-  }
-  merge(other) {
-    if (!(other instanceof _ReplaceStep) || other.structure || this.structure)
-      return null;
-    if (this.from + this.slice.size == other.from && !this.slice.openEnd && !other.slice.openStart) {
-      let slice = this.slice.size + other.slice.size == 0 ? Slice.empty : new Slice(this.slice.content.append(other.slice.content), this.slice.openStart, other.slice.openEnd);
-      return new _ReplaceStep(this.from, this.to + (other.to - other.from), slice, this.structure);
-    } else if (other.to == this.from && !this.slice.openStart && !other.slice.openEnd) {
-      let slice = this.slice.size + other.slice.size == 0 ? Slice.empty : new Slice(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
-      return new _ReplaceStep(other.from, this.to, slice, this.structure);
-    } else {
-      return null;
-    }
-  }
-  toJSON() {
-    let json = { stepType: "replace", from: this.from, to: this.to };
-    if (this.slice.size)
-      json.slice = this.slice.toJSON();
-    if (this.structure)
-      json.structure = true;
-    return json;
-  }
-  /**
-  @internal
-  */
-  static fromJSON(schema, json) {
-    if (typeof json.from != "number" || typeof json.to != "number")
-      throw new RangeError("Invalid input for ReplaceStep.fromJSON");
-    return new _ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure);
-  }
-};
-Step.jsonID("replace", ReplaceStep);
-var ReplaceAroundStep = class _ReplaceAroundStep extends Step {
-  /**
-  Create a replace-around step with the given range and gap.
-  `insert` should be the point in the slice into which the content
-  of the gap should be moved. `structure` has the same meaning as
-  it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
-  */
-  constructor(from, to, gapFrom, gapTo, slice, insert, structure = false) {
-    super();
-    this.from = from;
-    this.to = to;
-    this.gapFrom = gapFrom;
-    this.gapTo = gapTo;
-    this.slice = slice;
-    this.insert = insert;
-    this.structure = structure;
-  }
-  apply(doc3) {
-    if (this.structure && (contentBetween(doc3, this.from, this.gapFrom) || contentBetween(doc3, this.gapTo, this.to)))
-      return StepResult.fail("Structure gap-replace would overwrite content");
-    let gap = doc3.slice(this.gapFrom, this.gapTo);
-    if (gap.openStart || gap.openEnd)
-      return StepResult.fail("Gap is not a flat range");
-    let inserted = this.slice.insertAt(this.insert, gap.content);
-    if (!inserted)
-      return StepResult.fail("Content does not fit in gap");
-    return StepResult.fromReplace(doc3, this.from, this.to, inserted);
-  }
-  getMap() {
-    return new StepMap([
-      this.from,
-      this.gapFrom - this.from,
-      this.insert,
-      this.gapTo,
-      this.to - this.gapTo,
-      this.slice.size - this.insert
-    ]);
-  }
-  invert(doc3) {
-    let gap = this.gapTo - this.gapFrom;
-    return new _ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc3.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
-  }
-  map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
-    let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
-    if (from.deletedAcross && to.deletedAcross || gapFrom < from.pos || gapTo > to.pos)
-      return null;
-    return new _ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
-  }
-  toJSON() {
-    let json = {
-      stepType: "replaceAround",
-      from: this.from,
-      to: this.to,
-      gapFrom: this.gapFrom,
-      gapTo: this.gapTo,
-      insert: this.insert
-    };
-    if (this.slice.size)
-      json.slice = this.slice.toJSON();
-    if (this.structure)
-      json.structure = true;
-    return json;
-  }
-  /**
-  @internal
-  */
-  static fromJSON(schema, json) {
-    if (typeof json.from != "number" || typeof json.to != "number" || typeof json.gapFrom != "number" || typeof json.gapTo != "number" || typeof json.insert != "number")
-      throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
-    return new _ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
-  }
-};
-Step.jsonID("replaceAround", ReplaceAroundStep);
-function contentBetween(doc3, from, to) {
-  let $from = doc3.resolve(from), dist = to - from, depth = $from.depth;
-  while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
-    depth--;
-    dist--;
-  }
-  if (dist > 0) {
-    let next = $from.node(depth).maybeChild($from.indexAfter(depth));
-    while (dist > 0) {
-      if (!next || next.isLeaf)
-        return true;
-      next = next.firstChild;
-      dist--;
-    }
-  }
-  return false;
-}
-function dropPoint(doc3, pos, slice) {
-  let $pos = doc3.resolve(pos);
-  if (!slice.content.size)
-    return pos;
-  let content = slice.content;
-  for (let i = 0; i < slice.openStart; i++)
-    content = content.firstChild.content;
-  for (let pass = 1; pass <= (slice.openStart == 0 && slice.size ? 2 : 1); pass++) {
-    for (let d = $pos.depth; d >= 0; d--) {
-      let bias = d == $pos.depth ? 0 : $pos.pos <= ($pos.start(d + 1) + $pos.end(d + 1)) / 2 ? -1 : 1;
-      let insertPos = $pos.index(d) + (bias > 0 ? 1 : 0);
-      let parent = $pos.node(d), fits = false;
-      if (pass == 1) {
-        fits = parent.canReplace(insertPos, insertPos, content);
-      } else {
-        let wrapping = parent.contentMatchAt(insertPos).findWrapping(content.firstChild.type);
-        fits = wrapping && parent.canReplaceWith(insertPos, insertPos, wrapping[0]);
-      }
-      if (fits)
-        return bias == 0 ? $pos.pos : bias < 0 ? $pos.before(d + 1) : $pos.after(d + 1);
-    }
-  }
-  return null;
-}
-var AttrStep = class _AttrStep extends Step {
-  /**
-  Construct an attribute step.
-  */
-  constructor(pos, attr, value) {
-    super();
-    this.pos = pos;
-    this.attr = attr;
-    this.value = value;
-  }
-  apply(doc3) {
-    let node = doc3.nodeAt(this.pos);
-    if (!node)
-      return StepResult.fail("No node at attribute step's position");
-    let attrs = /* @__PURE__ */ Object.create(null);
-    for (let name in node.attrs)
-      attrs[name] = node.attrs[name];
-    attrs[this.attr] = this.value;
-    let updated = node.type.create(attrs, null, node.marks);
-    return StepResult.fromReplace(doc3, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-  }
-  getMap() {
-    return StepMap.empty;
-  }
-  invert(doc3) {
-    return new _AttrStep(this.pos, this.attr, doc3.nodeAt(this.pos).attrs[this.attr]);
-  }
-  map(mapping) {
-    let pos = mapping.mapResult(this.pos, 1);
-    return pos.deletedAfter ? null : new _AttrStep(pos.pos, this.attr, this.value);
-  }
-  toJSON() {
-    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
-  }
-  static fromJSON(schema, json) {
-    if (typeof json.pos != "number" || typeof json.attr != "string")
-      throw new RangeError("Invalid input for AttrStep.fromJSON");
-    return new _AttrStep(json.pos, json.attr, json.value);
-  }
-};
-Step.jsonID("attr", AttrStep);
-var DocAttrStep = class _DocAttrStep extends Step {
-  /**
-  Construct an attribute step.
-  */
-  constructor(attr, value) {
-    super();
-    this.attr = attr;
-    this.value = value;
-  }
-  apply(doc3) {
-    let attrs = /* @__PURE__ */ Object.create(null);
-    for (let name in doc3.attrs)
-      attrs[name] = doc3.attrs[name];
-    attrs[this.attr] = this.value;
-    let updated = doc3.type.create(attrs, doc3.content, doc3.marks);
-    return StepResult.ok(updated);
-  }
-  getMap() {
-    return StepMap.empty;
-  }
-  invert(doc3) {
-    return new _DocAttrStep(this.attr, doc3.attrs[this.attr]);
-  }
-  map(mapping) {
-    return this;
-  }
-  toJSON() {
-    return { stepType: "docAttr", attr: this.attr, value: this.value };
-  }
-  static fromJSON(schema, json) {
-    if (typeof json.attr != "string")
-      throw new RangeError("Invalid input for DocAttrStep.fromJSON");
-    return new _DocAttrStep(json.attr, json.value);
-  }
-};
-Step.jsonID("docAttr", DocAttrStep);
-var TransformError = class extends Error {
-};
-TransformError = function TransformError2(message) {
-  let err = Error.call(this, message);
-  err.__proto__ = TransformError2.prototype;
-  return err;
-};
-TransformError.prototype = Object.create(Error.prototype);
-TransformError.prototype.constructor = TransformError;
-TransformError.prototype.name = "TransformError";
-
-// node_modules/prosemirror-state/dist/index.js
-var classesById = /* @__PURE__ */ Object.create(null);
-var Selection = class {
-  /**
-  Initialize a selection with the head and anchor and ranges. If no
-  ranges are given, constructs a single range across `$anchor` and
-  `$head`.
-  */
-  constructor($anchor, $head, ranges) {
-    this.$anchor = $anchor;
-    this.$head = $head;
-    this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))];
-  }
-  /**
-  The selection's anchor, as an unresolved position.
-  */
-  get anchor() {
-    return this.$anchor.pos;
-  }
-  /**
-  The selection's head.
-  */
-  get head() {
-    return this.$head.pos;
-  }
-  /**
-  The lower bound of the selection's main range.
-  */
-  get from() {
-    return this.$from.pos;
-  }
-  /**
-  The upper bound of the selection's main range.
-  */
-  get to() {
-    return this.$to.pos;
-  }
-  /**
-  The resolved lower  bound of the selection's main range.
-  */
-  get $from() {
-    return this.ranges[0].$from;
-  }
-  /**
-  The resolved upper bound of the selection's main range.
-  */
-  get $to() {
-    return this.ranges[0].$to;
-  }
-  /**
-  Indicates whether the selection contains any content.
-  */
-  get empty() {
-    let ranges = this.ranges;
-    for (let i = 0; i < ranges.length; i++)
-      if (ranges[i].$from.pos != ranges[i].$to.pos)
-        return false;
-    return true;
-  }
-  /**
-  Get the content of this selection as a slice.
-  */
-  content() {
-    return this.$from.doc.slice(this.from, this.to, true);
-  }
-  /**
-  Replace the selection with a slice or, if no slice is given,
-  delete the selection. Will append to the given transaction.
-  */
-  replace(tr, content = Slice.empty) {
-    let lastNode = content.content.lastChild, lastParent = null;
-    for (let i = 0; i < content.openEnd; i++) {
-      lastParent = lastNode;
-      lastNode = lastNode.lastChild;
-    }
-    let mapFrom = tr.steps.length, ranges = this.ranges;
-    for (let i = 0; i < ranges.length; i++) {
-      let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-      tr.replaceRange(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
-      if (i == 0)
-        selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1);
-    }
-  }
-  /**
-  Replace the selection with the given node, appending the changes
-  to the given transaction.
-  */
-  replaceWith(tr, node) {
-    let mapFrom = tr.steps.length, ranges = this.ranges;
-    for (let i = 0; i < ranges.length; i++) {
-      let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-      let from = mapping.map($from.pos), to = mapping.map($to.pos);
-      if (i) {
-        tr.deleteRange(from, to);
-      } else {
-        tr.replaceRangeWith(from, to, node);
-        selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1);
-      }
-    }
-  }
-  /**
-  Find a valid cursor or leaf node selection starting at the given
-  position and searching back if `dir` is negative, and forward if
-  positive. When `textOnly` is true, only consider cursor
-  selections. Will return null when no valid selection position is
-  found.
-  */
-  static findFrom($pos, dir, textOnly = false) {
-    let inner = $pos.parent.inlineContent ? new TextSelection($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
-    if (inner)
-      return inner;
-    for (let depth = $pos.depth - 1; depth >= 0; depth--) {
-      let found2 = dir < 0 ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.before(depth + 1), $pos.index(depth), dir, textOnly) : findSelectionIn($pos.node(0), $pos.node(depth), $pos.after(depth + 1), $pos.index(depth) + 1, dir, textOnly);
-      if (found2)
-        return found2;
-    }
-    return null;
-  }
-  /**
-  Find a valid cursor or leaf node selection near the given
-  position. Searches forward first by default, but if `bias` is
-  negative, it will search backwards first.
-  */
-  static near($pos, bias = 1) {
-    return this.findFrom($pos, bias) || this.findFrom($pos, -bias) || new AllSelection($pos.node(0));
-  }
-  /**
-  Find the cursor or leaf node selection closest to the start of
-  the given document. Will return an
-  [`AllSelection`](https://prosemirror.net/docs/ref/#state.AllSelection) if no valid position
-  exists.
-  */
-  static atStart(doc3) {
-    return findSelectionIn(doc3, doc3, 0, 0, 1) || new AllSelection(doc3);
-  }
-  /**
-  Find the cursor or leaf node selection closest to the end of the
-  given document.
-  */
-  static atEnd(doc3) {
-    return findSelectionIn(doc3, doc3, doc3.content.size, doc3.childCount, -1) || new AllSelection(doc3);
-  }
-  /**
-  Deserialize the JSON representation of a selection. Must be
-  implemented for custom classes (as a static class method).
-  */
-  static fromJSON(doc3, json) {
-    if (!json || !json.type)
-      throw new RangeError("Invalid input for Selection.fromJSON");
-    let cls = classesById[json.type];
-    if (!cls)
-      throw new RangeError(`No selection type ${json.type} defined`);
-    return cls.fromJSON(doc3, json);
-  }
-  /**
-  To be able to deserialize selections from JSON, custom selection
-  classes must register themselves with an ID string, so that they
-  can be disambiguated. Try to pick something that's unlikely to
-  clash with classes from other modules.
-  */
-  static jsonID(id, selectionClass) {
-    if (id in classesById)
-      throw new RangeError("Duplicate use of selection JSON ID " + id);
-    classesById[id] = selectionClass;
-    selectionClass.prototype.jsonID = id;
-    return selectionClass;
-  }
-  /**
-  Get a [bookmark](https://prosemirror.net/docs/ref/#state.SelectionBookmark) for this selection,
-  which is a value that can be mapped without having access to a
-  current document, and later resolved to a real selection for a
-  given document again. (This is used mostly by the history to
-  track and restore old selections.) The default implementation of
-  this method just converts the selection to a text selection and
-  returns the bookmark for that.
-  */
-  getBookmark() {
-    return TextSelection.between(this.$anchor, this.$head).getBookmark();
-  }
-};
-Selection.prototype.visible = true;
-var SelectionRange = class {
-  /**
-  Create a range.
-  */
-  constructor($from, $to) {
-    this.$from = $from;
-    this.$to = $to;
-  }
-};
-var warnedAboutTextSelection = false;
-function checkTextSelection($pos) {
-  if (!warnedAboutTextSelection && !$pos.parent.inlineContent) {
-    warnedAboutTextSelection = true;
-    console["warn"]("TextSelection endpoint not pointing into a node with inline content (" + $pos.parent.type.name + ")");
-  }
-}
-var TextSelection = class _TextSelection extends Selection {
-  /**
-  Construct a text selection between the given points.
-  */
-  constructor($anchor, $head = $anchor) {
-    checkTextSelection($anchor);
-    checkTextSelection($head);
-    super($anchor, $head);
-  }
-  /**
-  Returns a resolved position if this is a cursor selection (an
-  empty text selection), and null otherwise.
-  */
-  get $cursor() {
-    return this.$anchor.pos == this.$head.pos ? this.$head : null;
-  }
-  map(doc3, mapping) {
-    let $head = doc3.resolve(mapping.map(this.head));
-    if (!$head.parent.inlineContent)
-      return Selection.near($head);
-    let $anchor = doc3.resolve(mapping.map(this.anchor));
-    return new _TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head);
-  }
-  replace(tr, content = Slice.empty) {
-    super.replace(tr, content);
-    if (content == Slice.empty) {
-      let marks = this.$from.marksAcross(this.$to);
-      if (marks)
-        tr.ensureMarks(marks);
-    }
-  }
-  eq(other) {
-    return other instanceof _TextSelection && other.anchor == this.anchor && other.head == this.head;
-  }
-  getBookmark() {
-    return new TextBookmark(this.anchor, this.head);
-  }
-  toJSON() {
-    return { type: "text", anchor: this.anchor, head: this.head };
-  }
-  /**
-  @internal
-  */
-  static fromJSON(doc3, json) {
-    if (typeof json.anchor != "number" || typeof json.head != "number")
-      throw new RangeError("Invalid input for TextSelection.fromJSON");
-    return new _TextSelection(doc3.resolve(json.anchor), doc3.resolve(json.head));
-  }
-  /**
-  Create a text selection from non-resolved positions.
-  */
-  static create(doc3, anchor, head = anchor) {
-    let $anchor = doc3.resolve(anchor);
-    return new this($anchor, head == anchor ? $anchor : doc3.resolve(head));
-  }
-  /**
-  Return a text selection that spans the given positions or, if
-  they aren't text positions, find a text selection near them.
-  `bias` determines whether the method searches forward (default)
-  or backwards (negative number) first. Will fall back to calling
-  [`Selection.near`](https://prosemirror.net/docs/ref/#state.Selection^near) when the document
-  doesn't contain a valid text position.
-  */
-  static between($anchor, $head, bias) {
-    let dPos = $anchor.pos - $head.pos;
-    if (!bias || dPos)
-      bias = dPos >= 0 ? 1 : -1;
-    if (!$head.parent.inlineContent) {
-      let found2 = Selection.findFrom($head, bias, true) || Selection.findFrom($head, -bias, true);
-      if (found2)
-        $head = found2.$head;
-      else
-        return Selection.near($head, bias);
-    }
-    if (!$anchor.parent.inlineContent) {
-      if (dPos == 0) {
-        $anchor = $head;
-      } else {
-        $anchor = (Selection.findFrom($anchor, -bias, true) || Selection.findFrom($anchor, bias, true)).$anchor;
-        if ($anchor.pos < $head.pos != dPos < 0)
-          $anchor = $head;
-      }
-    }
-    return new _TextSelection($anchor, $head);
-  }
-};
-Selection.jsonID("text", TextSelection);
-var TextBookmark = class _TextBookmark {
-  constructor(anchor, head) {
-    this.anchor = anchor;
-    this.head = head;
-  }
-  map(mapping) {
-    return new _TextBookmark(mapping.map(this.anchor), mapping.map(this.head));
-  }
-  resolve(doc3) {
-    return TextSelection.between(doc3.resolve(this.anchor), doc3.resolve(this.head));
-  }
-};
-var NodeSelection = class _NodeSelection extends Selection {
-  /**
-  Create a node selection. Does not verify the validity of its
-  argument.
-  */
-  constructor($pos) {
-    let node = $pos.nodeAfter;
-    let $end = $pos.node(0).resolve($pos.pos + node.nodeSize);
-    super($pos, $end);
-    this.node = node;
-  }
-  map(doc3, mapping) {
-    let { deleted, pos } = mapping.mapResult(this.anchor);
-    let $pos = doc3.resolve(pos);
-    if (deleted)
-      return Selection.near($pos);
-    return new _NodeSelection($pos);
-  }
-  content() {
-    return new Slice(Fragment.from(this.node), 0, 0);
-  }
-  eq(other) {
-    return other instanceof _NodeSelection && other.anchor == this.anchor;
-  }
-  toJSON() {
-    return { type: "node", anchor: this.anchor };
-  }
-  getBookmark() {
-    return new NodeBookmark(this.anchor);
-  }
-  /**
-  @internal
-  */
-  static fromJSON(doc3, json) {
-    if (typeof json.anchor != "number")
-      throw new RangeError("Invalid input for NodeSelection.fromJSON");
-    return new _NodeSelection(doc3.resolve(json.anchor));
-  }
-  /**
-  Create a node selection from non-resolved positions.
-  */
-  static create(doc3, from) {
-    return new _NodeSelection(doc3.resolve(from));
-  }
-  /**
-  Determines whether the given node may be selected as a node
-  selection.
-  */
-  static isSelectable(node) {
-    return !node.isText && node.type.spec.selectable !== false;
-  }
-};
-NodeSelection.prototype.visible = false;
-Selection.jsonID("node", NodeSelection);
-var NodeBookmark = class _NodeBookmark {
-  constructor(anchor) {
-    this.anchor = anchor;
-  }
-  map(mapping) {
-    let { deleted, pos } = mapping.mapResult(this.anchor);
-    return deleted ? new TextBookmark(pos, pos) : new _NodeBookmark(pos);
-  }
-  resolve(doc3) {
-    let $pos = doc3.resolve(this.anchor), node = $pos.nodeAfter;
-    if (node && NodeSelection.isSelectable(node))
-      return new NodeSelection($pos);
-    return Selection.near($pos);
-  }
-};
-var AllSelection = class _AllSelection extends Selection {
-  /**
-  Create an all-selection over the given document.
-  */
-  constructor(doc3) {
-    super(doc3.resolve(0), doc3.resolve(doc3.content.size));
-  }
-  replace(tr, content = Slice.empty) {
-    if (content == Slice.empty) {
-      tr.delete(0, tr.doc.content.size);
-      let sel = Selection.atStart(tr.doc);
-      if (!sel.eq(tr.selection))
-        tr.setSelection(sel);
-    } else {
-      super.replace(tr, content);
-    }
-  }
-  toJSON() {
-    return { type: "all" };
-  }
-  /**
-  @internal
-  */
-  static fromJSON(doc3) {
-    return new _AllSelection(doc3);
-  }
-  map(doc3) {
-    return new _AllSelection(doc3);
-  }
-  eq(other) {
-    return other instanceof _AllSelection;
-  }
-  getBookmark() {
-    return AllBookmark;
-  }
-};
-Selection.jsonID("all", AllSelection);
-var AllBookmark = {
-  map() {
-    return this;
-  },
-  resolve(doc3) {
-    return new AllSelection(doc3);
-  }
-};
-function findSelectionIn(doc3, node, pos, index, dir, text = false) {
-  if (node.inlineContent)
-    return TextSelection.create(doc3, pos);
-  for (let i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
-    let child = node.child(i);
-    if (!child.isAtom) {
-      let inner = findSelectionIn(doc3, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text);
-      if (inner)
-        return inner;
-    } else if (!text && NodeSelection.isSelectable(child)) {
-      return NodeSelection.create(doc3, pos - (dir < 0 ? child.nodeSize : 0));
-    }
-    pos += child.nodeSize * dir;
-  }
-  return null;
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-  let last = tr.steps.length - 1;
-  if (last < startLen)
-    return;
-  let step = tr.steps[last];
-  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep))
-    return;
-  let map = tr.mapping.maps[last], end;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end == null)
-      end = newTo;
-  });
-  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
-}
-function bind(f, self) {
-  return !self || !f ? f : f.bind(self);
-}
-var FieldDesc = class {
-  constructor(name, desc, self) {
-    this.name = name;
-    this.init = bind(desc.init, self);
-    this.apply = bind(desc.apply, self);
-  }
-};
-[
-  new FieldDesc("doc", {
-    init(config) {
-      return config.doc || config.schema.topNodeType.createAndFill();
-    },
-    apply(tr) {
-      return tr.doc;
-    }
-  }),
-  new FieldDesc("selection", {
-    init(config, instance) {
-      return config.selection || Selection.atStart(instance.doc);
-    },
-    apply(tr) {
-      return tr.selection;
-    }
-  }),
-  new FieldDesc("storedMarks", {
-    init(config) {
-      return config.storedMarks || null;
-    },
-    apply(tr, _marks, _old, state) {
-      return state.selection.$cursor ? tr.storedMarks : null;
-    }
-  }),
-  new FieldDesc("scrollToSelection", {
-    init() {
-      return 0;
-    },
-    apply(tr, prev) {
-      return tr.scrolledIntoView ? prev + 1 : prev;
-    }
-  })
-];
-function bindProps(obj, self, target) {
-  for (let prop in obj) {
-    let val = obj[prop];
-    if (val instanceof Function)
-      val = val.bind(self);
-    else if (prop == "handleDOMEvents")
-      val = bindProps(val, self, {});
-    target[prop] = val;
-  }
-  return target;
-}
-var Plugin = class {
-  /**
-  Create a plugin.
-  */
-  constructor(spec) {
-    this.spec = spec;
-    this.props = {};
-    if (spec.props)
-      bindProps(spec.props, this, this.props);
-    this.key = spec.key ? spec.key.key : createKey("plugin");
-  }
-  /**
-  Extract the plugin's state field from an editor state.
-  */
-  getState(state) {
-    return state[this.key];
-  }
-};
-var keys = /* @__PURE__ */ Object.create(null);
-function createKey(name) {
-  if (name in keys)
-    return name + "$" + ++keys[name];
-  keys[name] = 0;
-  return name + "$";
-}
-var PluginKey = class {
-  /**
-  Create a plugin key.
-  */
-  constructor(name = "key") {
-    this.key = createKey(name);
-  }
-  /**
-  Get the active plugin with this key, if any, from an editor
-  state.
-  */
-  get(state) {
-    return state.config.pluginsByKey[this.key];
-  }
-  /**
-  Get the plugin's state from an editor state.
-  */
-  getState(state) {
-    return state[this.key];
-  }
-};
-
-// node_modules/prosemirror-view/dist/index.js
-var domIndex = function(node) {
-  for (var index = 0; ; index++) {
-    node = node.previousSibling;
-    if (!node)
-      return index;
-  }
-};
-var isEquivalentPosition = function(node, off, targetNode, targetOff) {
-  return targetNode && (scanFor(node, off, targetNode, targetOff, -1) || scanFor(node, off, targetNode, targetOff, 1));
-};
-var atomElements = /^(img|br|input|textarea|hr)$/i;
-function scanFor(node, off, targetNode, targetOff, dir) {
-  var _a;
-  for (; ; ) {
-    if (node == targetNode && off == targetOff)
-      return true;
-    if (off == (dir < 0 ? 0 : nodeSize(node))) {
-      let parent = node.parentNode;
-      if (!parent || parent.nodeType != 1 || hasBlockDesc(node) || atomElements.test(node.nodeName) || node.contentEditable == "false")
-        return false;
-      off = domIndex(node) + (dir < 0 ? 0 : 1);
-      node = parent;
-    } else if (node.nodeType == 1) {
-      let child = node.childNodes[off + (dir < 0 ? -1 : 0)];
-      if (child.nodeType == 1 && child.contentEditable == "false") {
-        if ((_a = child.pmViewDesc) === null || _a === void 0 ? void 0 : _a.ignoreForSelection)
-          off += dir;
-        else
-          return false;
-      } else {
-        node = child;
-        off = dir < 0 ? nodeSize(node) : 0;
-      }
-    } else {
-      return false;
-    }
-  }
-}
-function nodeSize(node) {
-  return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
-}
-function isOnEdge(node, offset, parent) {
-  for (let atStart = offset == 0, atEnd = offset == nodeSize(node); atStart || atEnd; ) {
-    if (node == parent)
-      return true;
-    let index = domIndex(node);
-    node = node.parentNode;
-    if (!node)
-      return false;
-    atStart = atStart && index == 0;
-    atEnd = atEnd && index == nodeSize(node);
-  }
-}
-function hasBlockDesc(dom) {
-  let desc;
-  for (let cur = dom; cur; cur = cur.parentNode)
-    if (desc = cur.pmViewDesc)
-      break;
-  return desc && desc.node && desc.node.isBlock && (desc.dom == dom || desc.contentDOM == dom);
-}
-var selectionCollapsed = function(domSel) {
-  return domSel.focusNode && isEquivalentPosition(domSel.focusNode, domSel.focusOffset, domSel.anchorNode, domSel.anchorOffset);
-};
-function keyEvent(keyCode, key) {
-  let event = document.createEvent("Event");
-  event.initEvent("keydown", true, true);
-  event.keyCode = keyCode;
-  event.key = event.code = key;
-  return event;
-}
-var nav = typeof navigator != "undefined" ? navigator : null;
-var doc2 = typeof document != "undefined" ? document : null;
-var agent = nav && nav.userAgent || "";
-var ie_edge = /Edge\/(\d+)/.exec(agent);
-var ie_upto10 = /MSIE \d/.exec(agent);
-var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(agent);
-var ie = !!(ie_upto10 || ie_11up || ie_edge);
-var ie_version = ie_upto10 ? document.documentMode : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : 0;
-var gecko = !ie && /gecko\/(\d+)/i.test(agent);
-gecko && +(/Firefox\/(\d+)/.exec(agent) || [0, 0])[1];
-var _chrome = !ie && /Chrome\/(\d+)/.exec(agent);
-var chrome = !!_chrome;
-var chrome_version = _chrome ? +_chrome[1] : 0;
-var safari = !ie && !!nav && /Apple Computer/.test(nav.vendor);
-var ios = safari && (/Mobile\/\w+/.test(agent) || !!nav && nav.maxTouchPoints > 2);
-var mac = ios || (nav ? /Mac/.test(nav.platform) : false);
-var windows = nav ? /Win/.test(nav.platform) : false;
-var android = /Android \d/.test(agent);
-var webkit = !!doc2 && "webkitFontSmoothing" in doc2.documentElement.style;
-var webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [0, 0])[1] : 0;
-function selectionFromDOM(view, origin = null) {
-  let domSel = view.domSelectionRange(), doc3 = view.state.doc;
-  if (!domSel.focusNode)
-    return null;
-  let nearestDesc = view.docView.nearestDesc(domSel.focusNode), inWidget = nearestDesc && nearestDesc.size == 0;
-  let head = view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset, 1);
-  if (head < 0)
-    return null;
-  let $head = doc3.resolve(head), anchor, selection;
-  if (selectionCollapsed(domSel)) {
-    anchor = head;
-    while (nearestDesc && !nearestDesc.node)
-      nearestDesc = nearestDesc.parent;
-    let nearestDescNode = nearestDesc.node;
-    if (nearestDesc && nearestDescNode.isAtom && NodeSelection.isSelectable(nearestDescNode) && nearestDesc.parent && !(nearestDescNode.isInline && isOnEdge(domSel.focusNode, domSel.focusOffset, nearestDesc.dom))) {
-      let pos = nearestDesc.posBefore;
-      selection = new NodeSelection(head == pos ? $head : doc3.resolve(pos));
-    }
-  } else {
-    if (domSel instanceof view.dom.ownerDocument.defaultView.Selection && domSel.rangeCount > 1) {
-      let min = head, max = head;
-      for (let i = 0; i < domSel.rangeCount; i++) {
-        let range = domSel.getRangeAt(i);
-        min = Math.min(min, view.docView.posFromDOM(range.startContainer, range.startOffset, 1));
-        max = Math.max(max, view.docView.posFromDOM(range.endContainer, range.endOffset, -1));
-      }
-      if (min < 0)
-        return null;
-      [anchor, head] = max == view.state.selection.anchor ? [max, min] : [min, max];
-      $head = doc3.resolve(head);
-    } else {
-      anchor = view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset, 1);
-    }
-    if (anchor < 0)
-      return null;
-  }
-  let $anchor = doc3.resolve(anchor);
-  if (!selection) {
-    let bias = origin == "pointer" || view.state.selection.head < $head.pos && !inWidget ? 1 : -1;
-    selection = selectionBetween(view, $anchor, $head, bias);
-  }
-  return selection;
-}
-function editorOwnsSelection(view) {
-  return view.editable ? view.hasFocus() : hasSelection(view) && document.activeElement && document.activeElement.contains(view.dom);
-}
-function selectionToDOM(view, force = false) {
-  let sel = view.state.selection;
-  syncNodeSelection(view, sel);
-  if (!editorOwnsSelection(view))
-    return;
-  if (!force && view.input.mouseDown && view.input.mouseDown.allowDefault && chrome) {
-    let domSel = view.domSelectionRange(), curSel = view.domObserver.currentSelection;
-    if (domSel.anchorNode && curSel.anchorNode && isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset, curSel.anchorNode, curSel.anchorOffset)) {
-      view.input.mouseDown.delayedSelectionSync = true;
-      view.domObserver.setCurSelection();
-      return;
-    }
-  }
-  view.domObserver.disconnectSelection();
-  if (view.cursorWrapper) {
-    selectCursorWrapper(view);
-  } else {
-    let { anchor, head } = sel, resetEditableFrom, resetEditableTo;
-    if (brokenSelectBetweenUneditable && !(sel instanceof TextSelection)) {
-      if (!sel.$from.parent.inlineContent)
-        resetEditableFrom = temporarilyEditableNear(view, sel.from);
-      if (!sel.empty && !sel.$from.parent.inlineContent)
-        resetEditableTo = temporarilyEditableNear(view, sel.to);
-    }
-    view.docView.setSelection(anchor, head, view, force);
-    if (brokenSelectBetweenUneditable) {
-      if (resetEditableFrom)
-        resetEditable(resetEditableFrom);
-      if (resetEditableTo)
-        resetEditable(resetEditableTo);
-    }
-    if (sel.visible) {
-      view.dom.classList.remove("ProseMirror-hideselection");
-    } else {
-      view.dom.classList.add("ProseMirror-hideselection");
-      if ("onselectionchange" in document)
-        removeClassOnSelectionChange(view);
-    }
-  }
-  view.domObserver.setCurSelection();
-  view.domObserver.connectSelection();
-}
-var brokenSelectBetweenUneditable = safari || chrome && chrome_version < 63;
-function temporarilyEditableNear(view, pos) {
-  let { node, offset } = view.docView.domFromPos(pos, 0);
-  let after = offset < node.childNodes.length ? node.childNodes[offset] : null;
-  let before = offset ? node.childNodes[offset - 1] : null;
-  if (safari && after && after.contentEditable == "false")
-    return setEditable(after);
-  if ((!after || after.contentEditable == "false") && (!before || before.contentEditable == "false")) {
-    if (after)
-      return setEditable(after);
-    else if (before)
-      return setEditable(before);
-  }
-}
-function setEditable(element) {
-  element.contentEditable = "true";
-  if (safari && element.draggable) {
-    element.draggable = false;
-    element.wasDraggable = true;
-  }
-  return element;
-}
-function resetEditable(element) {
-  element.contentEditable = "false";
-  if (element.wasDraggable) {
-    element.draggable = true;
-    element.wasDraggable = null;
-  }
-}
-function removeClassOnSelectionChange(view) {
-  let doc3 = view.dom.ownerDocument;
-  doc3.removeEventListener("selectionchange", view.input.hideSelectionGuard);
-  let domSel = view.domSelectionRange();
-  let node = domSel.anchorNode, offset = domSel.anchorOffset;
-  doc3.addEventListener("selectionchange", view.input.hideSelectionGuard = () => {
-    if (domSel.anchorNode != node || domSel.anchorOffset != offset) {
-      doc3.removeEventListener("selectionchange", view.input.hideSelectionGuard);
-      setTimeout(() => {
-        if (!editorOwnsSelection(view) || view.state.selection.visible)
-          view.dom.classList.remove("ProseMirror-hideselection");
-      }, 20);
-    }
-  });
-}
-function selectCursorWrapper(view) {
-  let domSel = view.domSelection();
-  if (!domSel)
-    return;
-  let node = view.cursorWrapper.dom, img = node.nodeName == "IMG";
-  if (img)
-    domSel.collapse(node.parentNode, domIndex(node) + 1);
-  else
-    domSel.collapse(node, 0);
-  if (!img && !view.state.selection.visible && ie && ie_version <= 11) {
-    node.disabled = true;
-    node.disabled = false;
-  }
-}
-function syncNodeSelection(view, sel) {
-  if (sel instanceof NodeSelection) {
-    let desc = view.docView.descAt(sel.from);
-    if (desc != view.lastSelectedViewDesc) {
-      clearNodeSelection(view);
-      if (desc)
-        desc.selectNode();
-      view.lastSelectedViewDesc = desc;
-    }
-  } else {
-    clearNodeSelection(view);
-  }
-}
-function clearNodeSelection(view) {
-  if (view.lastSelectedViewDesc) {
-    if (view.lastSelectedViewDesc.parent)
-      view.lastSelectedViewDesc.deselectNode();
-    view.lastSelectedViewDesc = void 0;
-  }
-}
-function selectionBetween(view, $anchor, $head, bias) {
-  return view.someProp("createSelectionBetween", (f) => f(view, $anchor, $head)) || TextSelection.between($anchor, $head, bias);
-}
-function hasSelection(view) {
-  let sel = view.domSelectionRange();
-  if (!sel.anchorNode)
-    return false;
-  try {
-    return view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode) && (view.editable || view.dom.contains(sel.focusNode.nodeType == 3 ? sel.focusNode.parentNode : sel.focusNode));
-  } catch (_) {
-    return false;
-  }
-}
-function moveSelectionBlock(state, dir) {
-  let { $anchor, $head } = state.selection;
-  let $side = dir > 0 ? $anchor.max($head) : $anchor.min($head);
-  let $start = !$side.parent.inlineContent ? $side : $side.depth ? state.doc.resolve(dir > 0 ? $side.after() : $side.before()) : null;
-  return $start && Selection.findFrom($start, dir);
-}
-function apply(view, sel) {
-  view.dispatch(view.state.tr.setSelection(sel).scrollIntoView());
-  return true;
-}
-function selectHorizontally(view, dir, mods) {
-  let sel = view.state.selection;
-  if (sel instanceof TextSelection) {
-    if (mods.indexOf("s") > -1) {
-      let { $head } = sel, node = $head.textOffset ? null : dir < 0 ? $head.nodeBefore : $head.nodeAfter;
-      if (!node || node.isText || !node.isLeaf)
-        return false;
-      let $newHead = view.state.doc.resolve($head.pos + node.nodeSize * (dir < 0 ? -1 : 1));
-      return apply(view, new TextSelection(sel.$anchor, $newHead));
-    } else if (!sel.empty) {
-      return false;
-    } else if (view.endOfTextblock(dir > 0 ? "forward" : "backward")) {
-      let next = moveSelectionBlock(view.state, dir);
-      if (next && next instanceof NodeSelection)
-        return apply(view, next);
-      return false;
-    } else if (!(mac && mods.indexOf("m") > -1)) {
-      let $head = sel.$head, node = $head.textOffset ? null : dir < 0 ? $head.nodeBefore : $head.nodeAfter, desc;
-      if (!node || node.isText)
-        return false;
-      let nodePos = dir < 0 ? $head.pos - node.nodeSize : $head.pos;
-      if (!(node.isAtom || (desc = view.docView.descAt(nodePos)) && !desc.contentDOM))
-        return false;
-      if (NodeSelection.isSelectable(node)) {
-        return apply(view, new NodeSelection(dir < 0 ? view.state.doc.resolve($head.pos - node.nodeSize) : $head));
-      } else if (webkit) {
-        return apply(view, new TextSelection(view.state.doc.resolve(dir < 0 ? nodePos : nodePos + node.nodeSize)));
-      } else {
-        return false;
-      }
-    }
-  } else if (sel instanceof NodeSelection && sel.node.isInline) {
-    return apply(view, new TextSelection(dir > 0 ? sel.$to : sel.$from));
-  } else {
-    let next = moveSelectionBlock(view.state, dir);
-    if (next)
-      return apply(view, next);
-    return false;
-  }
-}
-function nodeLen(node) {
-  return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
-}
-function isIgnorable(dom, dir) {
-  let desc = dom.pmViewDesc;
-  return desc && desc.size == 0 && (dir < 0 || dom.nextSibling || dom.nodeName != "BR");
-}
-function skipIgnoredNodes(view, dir) {
-  return dir < 0 ? skipIgnoredNodesBefore(view) : skipIgnoredNodesAfter(view);
-}
-function skipIgnoredNodesBefore(view) {
-  let sel = view.domSelectionRange();
-  let node = sel.focusNode, offset = sel.focusOffset;
-  if (!node)
-    return;
-  let moveNode, moveOffset, force = false;
-  if (gecko && node.nodeType == 1 && offset < nodeLen(node) && isIgnorable(node.childNodes[offset], -1))
-    force = true;
-  for (; ; ) {
-    if (offset > 0) {
-      if (node.nodeType != 1) {
-        break;
-      } else {
-        let before = node.childNodes[offset - 1];
-        if (isIgnorable(before, -1)) {
-          moveNode = node;
-          moveOffset = --offset;
-        } else if (before.nodeType == 3) {
-          node = before;
-          offset = node.nodeValue.length;
-        } else
-          break;
-      }
-    } else if (isBlockNode(node)) {
-      break;
-    } else {
-      let prev = node.previousSibling;
-      while (prev && isIgnorable(prev, -1)) {
-        moveNode = node.parentNode;
-        moveOffset = domIndex(prev);
-        prev = prev.previousSibling;
-      }
-      if (!prev) {
-        node = node.parentNode;
-        if (node == view.dom)
-          break;
-        offset = 0;
-      } else {
-        node = prev;
-        offset = nodeLen(node);
-      }
-    }
-  }
-  if (force)
-    setSelFocus(view, node, offset);
-  else if (moveNode)
-    setSelFocus(view, moveNode, moveOffset);
-}
-function skipIgnoredNodesAfter(view) {
-  let sel = view.domSelectionRange();
-  let node = sel.focusNode, offset = sel.focusOffset;
-  if (!node)
-    return;
-  let len = nodeLen(node);
-  let moveNode, moveOffset;
-  for (; ; ) {
-    if (offset < len) {
-      if (node.nodeType != 1)
-        break;
-      let after = node.childNodes[offset];
-      if (isIgnorable(after, 1)) {
-        moveNode = node;
-        moveOffset = ++offset;
-      } else
-        break;
-    } else if (isBlockNode(node)) {
-      break;
-    } else {
-      let next = node.nextSibling;
-      while (next && isIgnorable(next, 1)) {
-        moveNode = next.parentNode;
-        moveOffset = domIndex(next) + 1;
-        next = next.nextSibling;
-      }
-      if (!next) {
-        node = node.parentNode;
-        if (node == view.dom)
-          break;
-        offset = len = 0;
-      } else {
-        node = next;
-        offset = 0;
-        len = nodeLen(node);
-      }
-    }
-  }
-  if (moveNode)
-    setSelFocus(view, moveNode, moveOffset);
-}
-function isBlockNode(dom) {
-  let desc = dom.pmViewDesc;
-  return desc && desc.node && desc.node.isBlock;
-}
-function textNodeAfter(node, offset) {
-  while (node && offset == node.childNodes.length && !hasBlockDesc(node)) {
-    offset = domIndex(node) + 1;
-    node = node.parentNode;
-  }
-  while (node && offset < node.childNodes.length) {
-    let next = node.childNodes[offset];
-    if (next.nodeType == 3)
-      return next;
-    if (next.nodeType == 1 && next.contentEditable == "false")
-      break;
-    node = next;
-    offset = 0;
-  }
-}
-function textNodeBefore(node, offset) {
-  while (node && !offset && !hasBlockDesc(node)) {
-    offset = domIndex(node);
-    node = node.parentNode;
-  }
-  while (node && offset) {
-    let next = node.childNodes[offset - 1];
-    if (next.nodeType == 3)
-      return next;
-    if (next.nodeType == 1 && next.contentEditable == "false")
-      break;
-    node = next;
-    offset = node.childNodes.length;
-  }
-}
-function setSelFocus(view, node, offset) {
-  if (node.nodeType != 3) {
-    let before, after;
-    if (after = textNodeAfter(node, offset)) {
-      node = after;
-      offset = 0;
-    } else if (before = textNodeBefore(node, offset)) {
-      node = before;
-      offset = before.nodeValue.length;
-    }
-  }
-  let sel = view.domSelection();
-  if (!sel)
-    return;
-  if (selectionCollapsed(sel)) {
-    let range = document.createRange();
-    range.setEnd(node, offset);
-    range.setStart(node, offset);
-    sel.removeAllRanges();
-    sel.addRange(range);
-  } else if (sel.extend) {
-    sel.extend(node, offset);
-  }
-  view.domObserver.setCurSelection();
-  let { state } = view;
-  setTimeout(() => {
-    if (view.state == state)
-      selectionToDOM(view);
-  }, 50);
-}
-function findDirection(view, pos) {
-  let $pos = view.state.doc.resolve(pos);
-  if (!(chrome || windows) && $pos.parent.inlineContent) {
-    let coords = view.coordsAtPos(pos);
-    if (pos > $pos.start()) {
-      let before = view.coordsAtPos(pos - 1);
-      let mid = (before.top + before.bottom) / 2;
-      if (mid > coords.top && mid < coords.bottom && Math.abs(before.left - coords.left) > 1)
-        return before.left < coords.left ? "ltr" : "rtl";
-    }
-    if (pos < $pos.end()) {
-      let after = view.coordsAtPos(pos + 1);
-      let mid = (after.top + after.bottom) / 2;
-      if (mid > coords.top && mid < coords.bottom && Math.abs(after.left - coords.left) > 1)
-        return after.left > coords.left ? "ltr" : "rtl";
-    }
-  }
-  let computed = getComputedStyle(view.dom).direction;
-  return computed == "rtl" ? "rtl" : "ltr";
-}
-function selectVertically(view, dir, mods) {
-  let sel = view.state.selection;
-  if (sel instanceof TextSelection && !sel.empty || mods.indexOf("s") > -1)
-    return false;
-  if (mac && mods.indexOf("m") > -1)
-    return false;
-  let { $from, $to } = sel;
-  if (!$from.parent.inlineContent || view.endOfTextblock(dir < 0 ? "up" : "down")) {
-    let next = moveSelectionBlock(view.state, dir);
-    if (next && next instanceof NodeSelection)
-      return apply(view, next);
-  }
-  if (!$from.parent.inlineContent) {
-    let side = dir < 0 ? $from : $to;
-    let beyond = sel instanceof AllSelection ? Selection.near(side, dir) : Selection.findFrom(side, dir);
-    return beyond ? apply(view, beyond) : false;
-  }
-  return false;
-}
-function stopNativeHorizontalDelete(view, dir) {
-  if (!(view.state.selection instanceof TextSelection))
-    return true;
-  let { $head, $anchor, empty: empty2 } = view.state.selection;
-  if (!$head.sameParent($anchor))
-    return true;
-  if (!empty2)
-    return false;
-  if (view.endOfTextblock(dir > 0 ? "forward" : "backward"))
-    return true;
-  let nextNode = !$head.textOffset && (dir < 0 ? $head.nodeBefore : $head.nodeAfter);
-  if (nextNode && !nextNode.isText) {
-    let tr = view.state.tr;
-    if (dir < 0)
-      tr.delete($head.pos - nextNode.nodeSize, $head.pos);
-    else
-      tr.delete($head.pos, $head.pos + nextNode.nodeSize);
-    view.dispatch(tr);
-    return true;
-  }
-  return false;
-}
-function switchEditable(view, node, state) {
-  view.domObserver.stop();
-  node.contentEditable = state;
-  view.domObserver.start();
-}
-function safariDownArrowBug(view) {
-  if (!safari || view.state.selection.$head.parentOffset > 0)
-    return false;
-  let { focusNode, focusOffset } = view.domSelectionRange();
-  if (focusNode && focusNode.nodeType == 1 && focusOffset == 0 && focusNode.firstChild && focusNode.firstChild.contentEditable == "false") {
-    let child = focusNode.firstChild;
-    switchEditable(view, child, "true");
-    setTimeout(() => switchEditable(view, child, "false"), 20);
-  }
-  return false;
-}
-function getMods(event) {
-  let result = "";
-  if (event.ctrlKey)
-    result += "c";
-  if (event.metaKey)
-    result += "m";
-  if (event.altKey)
-    result += "a";
-  if (event.shiftKey)
-    result += "s";
-  return result;
-}
-function captureKeyDown(view, event) {
-  let code = event.keyCode, mods = getMods(event);
-  if (code == 8 || mac && code == 72 && mods == "c") {
-    return stopNativeHorizontalDelete(view, -1) || skipIgnoredNodes(view, -1);
-  } else if (code == 46 && !event.shiftKey || mac && code == 68 && mods == "c") {
-    return stopNativeHorizontalDelete(view, 1) || skipIgnoredNodes(view, 1);
-  } else if (code == 13 || code == 27) {
-    return true;
-  } else if (code == 37 || mac && code == 66 && mods == "c") {
-    let dir = code == 37 ? findDirection(view, view.state.selection.from) == "ltr" ? -1 : 1 : -1;
-    return selectHorizontally(view, dir, mods) || skipIgnoredNodes(view, dir);
-  } else if (code == 39 || mac && code == 70 && mods == "c") {
-    let dir = code == 39 ? findDirection(view, view.state.selection.from) == "ltr" ? 1 : -1 : 1;
-    return selectHorizontally(view, dir, mods) || skipIgnoredNodes(view, dir);
-  } else if (code == 38 || mac && code == 80 && mods == "c") {
-    return selectVertically(view, -1, mods) || skipIgnoredNodes(view, -1);
-  } else if (code == 40 || mac && code == 78 && mods == "c") {
-    return safariDownArrowBug(view) || selectVertically(view, 1, mods) || skipIgnoredNodes(view, 1);
-  } else if (mods == (mac ? "m" : "c") && (code == 66 || code == 73 || code == 89 || code == 90)) {
-    return true;
-  }
-  return false;
-}
-function serializeForClipboard(view, slice) {
-  view.someProp("transformCopied", (f) => {
-    slice = f(slice, view);
-  });
-  let context = [], { content, openStart, openEnd } = slice;
-  while (openStart > 1 && openEnd > 1 && content.childCount == 1 && content.firstChild.childCount == 1) {
-    openStart--;
-    openEnd--;
-    let node = content.firstChild;
-    context.push(node.type.name, node.attrs != node.type.defaultAttrs ? node.attrs : null);
-    content = node.content;
-  }
-  let serializer = view.someProp("clipboardSerializer") || DOMSerializer.fromSchema(view.state.schema);
-  let doc3 = detachedDoc(), wrap = doc3.createElement("div");
-  wrap.appendChild(serializer.serializeFragment(content, { document: doc3 }));
-  let firstChild = wrap.firstChild, needsWrap, wrappers = 0;
-  while (firstChild && firstChild.nodeType == 1 && (needsWrap = wrapMap[firstChild.nodeName.toLowerCase()])) {
-    for (let i = needsWrap.length - 1; i >= 0; i--) {
-      let wrapper = doc3.createElement(needsWrap[i]);
-      while (wrap.firstChild)
-        wrapper.appendChild(wrap.firstChild);
-      wrap.appendChild(wrapper);
-      wrappers++;
-    }
-    firstChild = wrap.firstChild;
-  }
-  if (firstChild && firstChild.nodeType == 1)
-    firstChild.setAttribute("data-pm-slice", `${openStart} ${openEnd}${wrappers ? ` -${wrappers}` : ""} ${JSON.stringify(context)}`);
-  let text = view.someProp("clipboardTextSerializer", (f) => f(slice, view)) || slice.content.textBetween(0, slice.content.size, "\n\n");
-  return { dom: wrap, text, slice };
-}
-function parseFromClipboard(view, text, html, plainText, $context) {
-  let inCode = $context.parent.type.spec.code;
-  let dom, slice;
-  if (!html && !text)
-    return null;
-  let asText = !!text && (plainText || inCode || !html);
-  if (asText) {
-    view.someProp("transformPastedText", (f) => {
-      text = f(text, inCode || plainText, view);
-    });
-    if (inCode) {
-      slice = new Slice(Fragment.from(view.state.schema.text(text.replace(/\r\n?/g, "\n"))), 0, 0);
-      view.someProp("transformPasted", (f) => {
-        slice = f(slice, view, true);
-      });
-      return slice;
-    }
-    let parsed = view.someProp("clipboardTextParser", (f) => f(text, $context, plainText, view));
-    if (parsed) {
-      slice = parsed;
-    } else {
-      let marks = $context.marks();
-      let { schema } = view.state, serializer = DOMSerializer.fromSchema(schema);
-      dom = document.createElement("div");
-      text.split(/(?:\r\n?|\n)+/).forEach((block) => {
-        let p = dom.appendChild(document.createElement("p"));
-        if (block)
-          p.appendChild(serializer.serializeNode(schema.text(block, marks)));
-      });
-    }
-  } else {
-    view.someProp("transformPastedHTML", (f) => {
-      html = f(html, view);
-    });
-    dom = readHTML(html);
-    if (webkit)
-      restoreReplacedSpaces(dom);
-  }
-  let contextNode = dom && dom.querySelector("[data-pm-slice]");
-  let sliceData = contextNode && /^(\d+) (\d+)(?: -(\d+))? (.*)/.exec(contextNode.getAttribute("data-pm-slice") || "");
-  if (sliceData && sliceData[3])
-    for (let i = +sliceData[3]; i > 0; i--) {
-      let child = dom.firstChild;
-      while (child && child.nodeType != 1)
-        child = child.nextSibling;
-      if (!child)
-        break;
-      dom = child;
-    }
-  if (!slice) {
-    let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
-    slice = parser.parseSlice(dom, {
-      preserveWhitespace: !!(asText || sliceData),
-      context: $context,
-      ruleFromNode(dom2) {
-        if (dom2.nodeName == "BR" && !dom2.nextSibling && dom2.parentNode && !inlineParents.test(dom2.parentNode.nodeName))
-          return { ignore: true };
-        return null;
-      }
-    });
-  }
-  if (sliceData) {
-    slice = addContext(closeSlice(slice, +sliceData[1], +sliceData[2]), sliceData[4]);
-  } else {
-    slice = Slice.maxOpen(normalizeSiblings(slice.content, $context), true);
-    if (slice.openStart || slice.openEnd) {
-      let openStart = 0, openEnd = 0;
-      for (let node = slice.content.firstChild; openStart < slice.openStart && !node.type.spec.isolating; openStart++, node = node.firstChild) {
-      }
-      for (let node = slice.content.lastChild; openEnd < slice.openEnd && !node.type.spec.isolating; openEnd++, node = node.lastChild) {
-      }
-      slice = closeSlice(slice, openStart, openEnd);
-    }
-  }
-  view.someProp("transformPasted", (f) => {
-    slice = f(slice, view, asText);
-  });
-  return slice;
-}
-var inlineParents = /^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var)$/i;
-function normalizeSiblings(fragment, $context) {
-  if (fragment.childCount < 2)
-    return fragment;
-  for (let d = $context.depth; d >= 0; d--) {
-    let parent = $context.node(d);
-    let match = parent.contentMatchAt($context.index(d));
-    let lastWrap, result = [];
-    fragment.forEach((node) => {
-      if (!result)
-        return;
-      let wrap = match.findWrapping(node.type), inLast;
-      if (!wrap)
-        return result = null;
-      if (inLast = result.length && lastWrap.length && addToSibling(wrap, lastWrap, node, result[result.length - 1], 0)) {
-        result[result.length - 1] = inLast;
-      } else {
-        if (result.length)
-          result[result.length - 1] = closeRight(result[result.length - 1], lastWrap.length);
-        let wrapped = withWrappers(node, wrap);
-        result.push(wrapped);
-        match = match.matchType(wrapped.type);
-        lastWrap = wrap;
-      }
-    });
-    if (result)
-      return Fragment.from(result);
-  }
-  return fragment;
-}
-function withWrappers(node, wrap, from = 0) {
-  for (let i = wrap.length - 1; i >= from; i--)
-    node = wrap[i].create(null, Fragment.from(node));
-  return node;
-}
-function addToSibling(wrap, lastWrap, node, sibling, depth) {
-  if (depth < wrap.length && depth < lastWrap.length && wrap[depth] == lastWrap[depth]) {
-    let inner = addToSibling(wrap, lastWrap, node, sibling.lastChild, depth + 1);
-    if (inner)
-      return sibling.copy(sibling.content.replaceChild(sibling.childCount - 1, inner));
-    let match = sibling.contentMatchAt(sibling.childCount);
-    if (match.matchType(depth == wrap.length - 1 ? node.type : wrap[depth + 1]))
-      return sibling.copy(sibling.content.append(Fragment.from(withWrappers(node, wrap, depth + 1))));
-  }
-}
-function closeRight(node, depth) {
-  if (depth == 0)
-    return node;
-  let fragment = node.content.replaceChild(node.childCount - 1, closeRight(node.lastChild, depth - 1));
-  let fill = node.contentMatchAt(node.childCount).fillBefore(Fragment.empty, true);
-  return node.copy(fragment.append(fill));
-}
-function closeRange(fragment, side, from, to, depth, openEnd) {
-  let node = side < 0 ? fragment.firstChild : fragment.lastChild, inner = node.content;
-  if (fragment.childCount > 1)
-    openEnd = 0;
-  if (depth < to - 1)
-    inner = closeRange(inner, side, from, to, depth + 1, openEnd);
-  if (depth >= from)
-    inner = side < 0 ? node.contentMatchAt(0).fillBefore(inner, openEnd <= depth).append(inner) : inner.append(node.contentMatchAt(node.childCount).fillBefore(Fragment.empty, true));
-  return fragment.replaceChild(side < 0 ? 0 : fragment.childCount - 1, node.copy(inner));
-}
-function closeSlice(slice, openStart, openEnd) {
-  if (openStart < slice.openStart)
-    slice = new Slice(closeRange(slice.content, -1, openStart, slice.openStart, 0, slice.openEnd), openStart, slice.openEnd);
-  if (openEnd < slice.openEnd)
-    slice = new Slice(closeRange(slice.content, 1, openEnd, slice.openEnd, 0, 0), slice.openStart, openEnd);
-  return slice;
-}
-var wrapMap = {
-  thead: ["table"],
-  tbody: ["table"],
-  tfoot: ["table"],
-  caption: ["table"],
-  colgroup: ["table"],
-  col: ["table", "colgroup"],
-  tr: ["table", "tbody"],
-  td: ["table", "tbody", "tr"],
-  th: ["table", "tbody", "tr"]
-};
-var _detachedDoc = null;
-function detachedDoc() {
-  return _detachedDoc || (_detachedDoc = document.implementation.createHTMLDocument("title"));
-}
-var _policy = null;
-function maybeWrapTrusted(html) {
-  let trustedTypes = window.trustedTypes;
-  if (!trustedTypes)
-    return html;
-  if (!_policy)
-    _policy = trustedTypes.defaultPolicy || trustedTypes.createPolicy("ProseMirrorClipboard", { createHTML: (s) => s });
-  return _policy.createHTML(html);
-}
-function readHTML(html) {
-  let metas = /^(\s*<meta [^>]*>)*/.exec(html);
-  if (metas)
-    html = html.slice(metas[0].length);
-  let elt = detachedDoc().createElement("div");
-  let firstTag = /<([a-z][^>\s]+)/i.exec(html), wrap;
-  if (wrap = firstTag && wrapMap[firstTag[1].toLowerCase()])
-    html = wrap.map((n) => "<" + n + ">").join("") + html + wrap.map((n) => "</" + n + ">").reverse().join("");
-  elt.innerHTML = maybeWrapTrusted(html);
-  if (wrap)
-    for (let i = 0; i < wrap.length; i++)
-      elt = elt.querySelector(wrap[i]) || elt;
-  return elt;
-}
-function restoreReplacedSpaces(dom) {
-  let nodes = dom.querySelectorAll(chrome ? "span:not([class]):not([style])" : "span.Apple-converted-space");
-  for (let i = 0; i < nodes.length; i++) {
-    let node = nodes[i];
-    if (node.childNodes.length == 1 && node.textContent == "\xA0" && node.parentNode)
-      node.parentNode.replaceChild(dom.ownerDocument.createTextNode(" "), node);
-  }
-}
-function addContext(slice, context) {
-  if (!slice.size)
-    return slice;
-  let schema = slice.content.firstChild.type.schema, array;
-  try {
-    array = JSON.parse(context);
-  } catch (e) {
-    return slice;
-  }
-  let { content, openStart, openEnd } = slice;
-  for (let i = array.length - 2; i >= 0; i -= 2) {
-    let type = schema.nodes[array[i]];
-    if (!type || type.hasRequiredAttrs())
-      break;
-    content = Fragment.from(type.create(array[i + 1], content));
-    openStart++;
-    openEnd++;
-  }
-  return new Slice(content, openStart, openEnd);
-}
-var handlers = {};
-var editHandlers = {};
-function setSelectionOrigin(view, origin) {
-  view.input.lastSelectionOrigin = origin;
-  view.input.lastSelectionTime = Date.now();
-}
-editHandlers.keydown = (view, _event) => {
-  let event = _event;
-  view.input.shiftKey = event.keyCode == 16 || event.shiftKey;
-  if (inOrNearComposition(view, event))
-    return;
-  view.input.lastKeyCode = event.keyCode;
-  view.input.lastKeyCodeTime = Date.now();
-  if (android && chrome && event.keyCode == 13)
-    return;
-  if (event.keyCode != 229)
-    view.domObserver.forceFlush();
-  if (ios && event.keyCode == 13 && !event.ctrlKey && !event.altKey && !event.metaKey) {
-    let now = Date.now();
-    view.input.lastIOSEnter = now;
-    view.input.lastIOSEnterFallbackTimeout = setTimeout(() => {
-      if (view.input.lastIOSEnter == now) {
-        view.someProp("handleKeyDown", (f) => f(view, keyEvent(13, "Enter")));
-        view.input.lastIOSEnter = 0;
-      }
-    }, 200);
-  } else if (view.someProp("handleKeyDown", (f) => f(view, event)) || captureKeyDown(view, event)) {
-    event.preventDefault();
-  } else {
-    setSelectionOrigin(view, "key");
-  }
-};
-editHandlers.keyup = (view, event) => {
-  if (event.keyCode == 16)
-    view.input.shiftKey = false;
-};
-editHandlers.keypress = (view, _event) => {
-  let event = _event;
-  if (inOrNearComposition(view, event) || !event.charCode || event.ctrlKey && !event.altKey || mac && event.metaKey)
-    return;
-  if (view.someProp("handleKeyPress", (f) => f(view, event))) {
-    event.preventDefault();
-    return;
-  }
-  let sel = view.state.selection;
-  if (!(sel instanceof TextSelection) || !sel.$from.sameParent(sel.$to)) {
-    let text = String.fromCharCode(event.charCode);
-    let deflt = () => view.state.tr.insertText(text).scrollIntoView();
-    if (!/[\r\n]/.test(text) && !view.someProp("handleTextInput", (f) => f(view, sel.$from.pos, sel.$to.pos, text, deflt)))
-      view.dispatch(deflt());
-    event.preventDefault();
-  }
-};
-function eventCoords(event) {
-  return { left: event.clientX, top: event.clientY };
-}
-function isNear(event, click) {
-  let dx = click.x - event.clientX, dy = click.y - event.clientY;
-  return dx * dx + dy * dy < 100;
-}
-function runHandlerOnContext(view, propName, pos, inside, event) {
-  if (inside == -1)
-    return false;
-  let $pos = view.state.doc.resolve(inside);
-  for (let i = $pos.depth + 1; i > 0; i--) {
-    if (view.someProp(propName, (f) => i > $pos.depth ? f(view, pos, $pos.nodeAfter, $pos.before(i), event, true) : f(view, pos, $pos.node(i), $pos.before(i), event, false)))
-      return true;
-  }
-  return false;
-}
-function updateSelection(view, selection, origin) {
-  if (!view.focused)
-    view.focus();
-  if (view.state.selection.eq(selection))
-    return;
-  let tr = view.state.tr.setSelection(selection);
-  tr.setMeta("pointer", true);
-  view.dispatch(tr);
-}
-function selectClickedLeaf(view, inside) {
-  if (inside == -1)
-    return false;
-  let $pos = view.state.doc.resolve(inside), node = $pos.nodeAfter;
-  if (node && node.isAtom && NodeSelection.isSelectable(node)) {
-    updateSelection(view, new NodeSelection($pos));
-    return true;
-  }
-  return false;
-}
-function selectClickedNode(view, inside) {
-  if (inside == -1)
-    return false;
-  let sel = view.state.selection, selectedNode, selectAt;
-  if (sel instanceof NodeSelection)
-    selectedNode = sel.node;
-  let $pos = view.state.doc.resolve(inside);
-  for (let i = $pos.depth + 1; i > 0; i--) {
-    let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i);
-    if (NodeSelection.isSelectable(node)) {
-      if (selectedNode && sel.$from.depth > 0 && i >= sel.$from.depth && $pos.before(sel.$from.depth + 1) == sel.$from.pos)
-        selectAt = $pos.before(sel.$from.depth);
-      else
-        selectAt = $pos.before(i);
-      break;
-    }
-  }
-  if (selectAt != null) {
-    updateSelection(view, NodeSelection.create(view.state.doc, selectAt));
-    return true;
-  } else {
-    return false;
-  }
-}
-function handleSingleClick(view, pos, inside, event, selectNode) {
-  return runHandlerOnContext(view, "handleClickOn", pos, inside, event) || view.someProp("handleClick", (f) => f(view, pos, event)) || (selectNode ? selectClickedNode(view, inside) : selectClickedLeaf(view, inside));
-}
-function handleDoubleClick(view, pos, inside, event) {
-  return runHandlerOnContext(view, "handleDoubleClickOn", pos, inside, event) || view.someProp("handleDoubleClick", (f) => f(view, pos, event));
-}
-function handleTripleClick(view, pos, inside, event) {
-  return runHandlerOnContext(view, "handleTripleClickOn", pos, inside, event) || view.someProp("handleTripleClick", (f) => f(view, pos, event)) || defaultTripleClick(view, inside, event);
-}
-function defaultTripleClick(view, inside, event) {
-  if (event.button != 0)
-    return false;
-  let doc3 = view.state.doc;
-  if (inside == -1) {
-    if (doc3.inlineContent) {
-      updateSelection(view, TextSelection.create(doc3, 0, doc3.content.size));
-      return true;
-    }
-    return false;
-  }
-  let $pos = doc3.resolve(inside);
-  for (let i = $pos.depth + 1; i > 0; i--) {
-    let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i);
-    let nodePos = $pos.before(i);
-    if (node.inlineContent)
-      updateSelection(view, TextSelection.create(doc3, nodePos + 1, nodePos + 1 + node.content.size));
-    else if (NodeSelection.isSelectable(node))
-      updateSelection(view, NodeSelection.create(doc3, nodePos));
-    else
-      continue;
-    return true;
-  }
-}
-function forceDOMFlush(view) {
-  return endComposition(view);
-}
-var selectNodeModifier = mac ? "metaKey" : "ctrlKey";
-handlers.mousedown = (view, _event) => {
-  let event = _event;
-  view.input.shiftKey = event.shiftKey;
-  let flushed = forceDOMFlush(view);
-  let now = Date.now(), type = "singleClick";
-  if (now - view.input.lastClick.time < 500 && isNear(event, view.input.lastClick) && !event[selectNodeModifier] && view.input.lastClick.button == event.button) {
-    if (view.input.lastClick.type == "singleClick")
-      type = "doubleClick";
-    else if (view.input.lastClick.type == "doubleClick")
-      type = "tripleClick";
-  }
-  view.input.lastClick = { time: now, x: event.clientX, y: event.clientY, type, button: event.button };
-  let pos = view.posAtCoords(eventCoords(event));
-  if (!pos)
-    return;
-  if (type == "singleClick") {
-    if (view.input.mouseDown)
-      view.input.mouseDown.done();
-    view.input.mouseDown = new MouseDown(view, pos, event, !!flushed);
-  } else if ((type == "doubleClick" ? handleDoubleClick : handleTripleClick)(view, pos.pos, pos.inside, event)) {
-    event.preventDefault();
-  } else {
-    setSelectionOrigin(view, "pointer");
-  }
-};
-var MouseDown = class {
-  constructor(view, pos, event, flushed) {
-    this.view = view;
-    this.pos = pos;
-    this.event = event;
-    this.flushed = flushed;
-    this.delayedSelectionSync = false;
-    this.mightDrag = null;
-    this.startDoc = view.state.doc;
-    this.selectNode = !!event[selectNodeModifier];
-    this.allowDefault = event.shiftKey;
-    let targetNode, targetPos;
-    if (pos.inside > -1) {
-      targetNode = view.state.doc.nodeAt(pos.inside);
-      targetPos = pos.inside;
-    } else {
-      let $pos = view.state.doc.resolve(pos.pos);
-      targetNode = $pos.parent;
-      targetPos = $pos.depth ? $pos.before() : 0;
-    }
-    const target = flushed ? null : event.target;
-    const targetDesc = target ? view.docView.nearestDesc(target, true) : null;
-    this.target = targetDesc && targetDesc.nodeDOM.nodeType == 1 ? targetDesc.nodeDOM : null;
-    let { selection } = view.state;
-    if (event.button == 0 && targetNode.type.spec.draggable && targetNode.type.spec.selectable !== false || selection instanceof NodeSelection && selection.from <= targetPos && selection.to > targetPos)
-      this.mightDrag = {
-        node: targetNode,
-        pos: targetPos,
-        addAttr: !!(this.target && !this.target.draggable),
-        setUneditable: !!(this.target && gecko && !this.target.hasAttribute("contentEditable"))
-      };
-    if (this.target && this.mightDrag && (this.mightDrag.addAttr || this.mightDrag.setUneditable)) {
-      this.view.domObserver.stop();
-      if (this.mightDrag.addAttr)
-        this.target.draggable = true;
-      if (this.mightDrag.setUneditable)
-        setTimeout(() => {
-          if (this.view.input.mouseDown == this)
-            this.target.setAttribute("contentEditable", "false");
-        }, 20);
-      this.view.domObserver.start();
-    }
-    view.root.addEventListener("mouseup", this.up = this.up.bind(this));
-    view.root.addEventListener("mousemove", this.move = this.move.bind(this));
-    setSelectionOrigin(view, "pointer");
-  }
-  done() {
-    this.view.root.removeEventListener("mouseup", this.up);
-    this.view.root.removeEventListener("mousemove", this.move);
-    if (this.mightDrag && this.target) {
-      this.view.domObserver.stop();
-      if (this.mightDrag.addAttr)
-        this.target.removeAttribute("draggable");
-      if (this.mightDrag.setUneditable)
-        this.target.removeAttribute("contentEditable");
-      this.view.domObserver.start();
-    }
-    if (this.delayedSelectionSync)
-      setTimeout(() => selectionToDOM(this.view));
-    this.view.input.mouseDown = null;
-  }
-  up(event) {
-    this.done();
-    if (!this.view.dom.contains(event.target))
-      return;
-    let pos = this.pos;
-    if (this.view.state.doc != this.startDoc)
-      pos = this.view.posAtCoords(eventCoords(event));
-    this.updateAllowDefault(event);
-    if (this.allowDefault || !pos) {
-      setSelectionOrigin(this.view, "pointer");
-    } else if (handleSingleClick(this.view, pos.pos, pos.inside, event, this.selectNode)) {
-      event.preventDefault();
-    } else if (event.button == 0 && (this.flushed || // Safari ignores clicks on draggable elements
-    safari && this.mightDrag && !this.mightDrag.node.isAtom || // Chrome will sometimes treat a node selection as a
-    // cursor, but still report that the node is selected
-    // when asked through getSelection. You'll then get a
-    // situation where clicking at the point where that
-    // (hidden) cursor is doesn't change the selection, and
-    // thus doesn't get a reaction from ProseMirror. This
-    // works around that.
-    chrome && !this.view.state.selection.visible && Math.min(Math.abs(pos.pos - this.view.state.selection.from), Math.abs(pos.pos - this.view.state.selection.to)) <= 2)) {
-      updateSelection(this.view, Selection.near(this.view.state.doc.resolve(pos.pos)));
-      event.preventDefault();
-    } else {
-      setSelectionOrigin(this.view, "pointer");
-    }
-  }
-  move(event) {
-    this.updateAllowDefault(event);
-    setSelectionOrigin(this.view, "pointer");
-    if (event.buttons == 0)
-      this.done();
-  }
-  updateAllowDefault(event) {
-    if (!this.allowDefault && (Math.abs(this.event.x - event.clientX) > 4 || Math.abs(this.event.y - event.clientY) > 4))
-      this.allowDefault = true;
-  }
-};
-handlers.touchstart = (view) => {
-  view.input.lastTouch = Date.now();
-  forceDOMFlush(view);
-  setSelectionOrigin(view, "pointer");
-};
-handlers.touchmove = (view) => {
-  view.input.lastTouch = Date.now();
-  setSelectionOrigin(view, "pointer");
-};
-handlers.contextmenu = (view) => forceDOMFlush(view);
-function inOrNearComposition(view, event) {
-  if (view.composing)
-    return true;
-  if (safari && Math.abs(event.timeStamp - view.input.compositionEndedAt) < 500) {
-    view.input.compositionEndedAt = -2e8;
-    return true;
-  }
-  return false;
-}
-var timeoutComposition = android ? 5e3 : -1;
-editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
-  if (!view.composing) {
-    view.domObserver.flush();
-    let { state } = view, $pos = state.selection.$to;
-    if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false) || chrome && windows && selectionBeforeUneditable(view))) {
-      view.markCursor = view.state.storedMarks || $pos.marks();
-      endComposition(view, true);
-      view.markCursor = null;
-    } else {
-      endComposition(view, !state.selection.empty);
-      if (gecko && state.selection.empty && $pos.parentOffset && !$pos.textOffset && $pos.nodeBefore.marks.length) {
-        let sel = view.domSelectionRange();
-        for (let node = sel.focusNode, offset = sel.focusOffset; node && node.nodeType == 1 && offset != 0; ) {
-          let before = offset < 0 ? node.lastChild : node.childNodes[offset - 1];
-          if (!before)
-            break;
-          if (before.nodeType == 3) {
-            let sel2 = view.domSelection();
-            if (sel2)
-              sel2.collapse(before, before.nodeValue.length);
-            break;
-          } else {
-            node = before;
-            offset = -1;
-          }
-        }
-      }
-    }
-    view.input.composing = true;
-  }
-  scheduleComposeEnd(view, timeoutComposition);
-};
-function selectionBeforeUneditable(view) {
-  let { focusNode, focusOffset } = view.domSelectionRange();
-  if (!focusNode || focusNode.nodeType != 1 || focusOffset >= focusNode.childNodes.length)
-    return false;
-  let next = focusNode.childNodes[focusOffset];
-  return next.nodeType == 1 && next.contentEditable == "false";
-}
-editHandlers.compositionend = (view, event) => {
-  if (view.composing) {
-    view.input.composing = false;
-    view.input.compositionEndedAt = event.timeStamp;
-    view.input.compositionPendingChanges = view.domObserver.pendingRecords().length ? view.input.compositionID : 0;
-    view.input.compositionNode = null;
-    if (view.input.badSafariComposition)
-      view.domObserver.forceFlush();
-    else if (view.input.compositionPendingChanges)
-      Promise.resolve().then(() => view.domObserver.flush());
-    view.input.compositionID++;
-    scheduleComposeEnd(view, 20);
-  }
-};
-function scheduleComposeEnd(view, delay) {
-  clearTimeout(view.input.composingTimeout);
-  if (delay > -1)
-    view.input.composingTimeout = setTimeout(() => endComposition(view), delay);
-}
-function clearComposition(view) {
-  if (view.composing) {
-    view.input.composing = false;
-    view.input.compositionEndedAt = timestampFromCustomEvent();
-  }
-  while (view.input.compositionNodes.length > 0)
-    view.input.compositionNodes.pop().markParentsDirty();
-}
-function timestampFromCustomEvent() {
-  let event = document.createEvent("Event");
-  event.initEvent("event", true, true);
-  return event.timeStamp;
-}
-function endComposition(view, restarting = false) {
-  if (android && view.domObserver.flushingSoon >= 0)
-    return;
-  view.domObserver.forceFlush();
-  clearComposition(view);
-  if (restarting || view.docView && view.docView.dirty) {
-    let sel = selectionFromDOM(view), cur = view.state.selection;
-    if (sel && !sel.eq(cur))
-      view.dispatch(view.state.tr.setSelection(sel));
-    else if ((view.markCursor || restarting) && !cur.$from.node(cur.$from.sharedDepth(cur.to)).inlineContent)
-      view.dispatch(view.state.tr.deleteSelection());
-    else
-      view.updateState(view.state);
-    return true;
-  }
-  return false;
-}
-function captureCopy(view, dom) {
-  if (!view.dom.parentNode)
-    return;
-  let wrap = view.dom.parentNode.appendChild(document.createElement("div"));
-  wrap.appendChild(dom);
-  wrap.style.cssText = "position: fixed; left: -10000px; top: 10px";
-  let sel = getSelection(), range = document.createRange();
-  range.selectNodeContents(dom);
-  view.dom.blur();
-  sel.removeAllRanges();
-  sel.addRange(range);
-  setTimeout(() => {
-    if (wrap.parentNode)
-      wrap.parentNode.removeChild(wrap);
-    view.focus();
-  }, 50);
-}
-var brokenClipboardAPI = ie && ie_version < 15 || ios && webkit_version < 604;
-handlers.copy = editHandlers.cut = (view, _event) => {
-  let event = _event;
-  let sel = view.state.selection, cut = event.type == "cut";
-  if (sel.empty)
-    return;
-  let data = brokenClipboardAPI ? null : event.clipboardData;
-  let slice = sel.content(), { dom, text } = serializeForClipboard(view, slice);
-  if (data) {
-    event.preventDefault();
-    data.clearData();
-    data.setData("text/html", dom.innerHTML);
-    data.setData("text/plain", text);
-  } else {
-    captureCopy(view, dom);
-  }
-  if (cut)
-    view.dispatch(view.state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent", "cut"));
-};
-function sliceSingleNode(slice) {
-  return slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1 ? slice.content.firstChild : null;
-}
-function capturePaste(view, event) {
-  if (!view.dom.parentNode)
-    return;
-  let plainText = view.input.shiftKey || view.state.selection.$from.parent.type.spec.code;
-  let target = view.dom.parentNode.appendChild(document.createElement(plainText ? "textarea" : "div"));
-  if (!plainText)
-    target.contentEditable = "true";
-  target.style.cssText = "position: fixed; left: -10000px; top: 10px";
-  target.focus();
-  let plain = view.input.shiftKey && view.input.lastKeyCode != 45;
-  setTimeout(() => {
-    view.focus();
-    if (target.parentNode)
-      target.parentNode.removeChild(target);
-    if (plainText)
-      doPaste(view, target.value, null, plain, event);
-    else
-      doPaste(view, target.textContent, target.innerHTML, plain, event);
-  }, 50);
-}
-function doPaste(view, text, html, preferPlain, event) {
-  let slice = parseFromClipboard(view, text, html, preferPlain, view.state.selection.$from);
-  if (view.someProp("handlePaste", (f) => f(view, event, slice || Slice.empty)))
-    return true;
-  if (!slice)
-    return false;
-  let singleNode = sliceSingleNode(slice);
-  let tr = singleNode ? view.state.tr.replaceSelectionWith(singleNode, preferPlain) : view.state.tr.replaceSelection(slice);
-  view.dispatch(tr.scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste"));
-  return true;
-}
-function getText(clipboardData) {
-  let text = clipboardData.getData("text/plain") || clipboardData.getData("Text");
-  if (text)
-    return text;
-  let uris = clipboardData.getData("text/uri-list");
-  return uris ? uris.replace(/\r?\n/g, " ") : "";
-}
-editHandlers.paste = (view, _event) => {
-  let event = _event;
-  if (view.composing && !android)
-    return;
-  let data = brokenClipboardAPI ? null : event.clipboardData;
-  let plain = view.input.shiftKey && view.input.lastKeyCode != 45;
-  if (data && doPaste(view, getText(data), data.getData("text/html"), plain, event))
-    event.preventDefault();
-  else
-    capturePaste(view, event);
-};
-var Dragging = class {
-  constructor(slice, move, node) {
-    this.slice = slice;
-    this.move = move;
-    this.node = node;
-  }
-};
-var dragCopyModifier = mac ? "altKey" : "ctrlKey";
-function dragMoves(view, event) {
-  let moves = view.someProp("dragCopies", (test) => !test(event));
-  return moves != null ? moves : !event[dragCopyModifier];
-}
-handlers.dragstart = (view, _event) => {
-  let event = _event;
-  let mouseDown = view.input.mouseDown;
-  if (mouseDown)
-    mouseDown.done();
-  if (!event.dataTransfer)
-    return;
-  let sel = view.state.selection;
-  let pos = sel.empty ? null : view.posAtCoords(eventCoords(event));
-  let node;
-  if (pos && pos.pos >= sel.from && pos.pos <= (sel instanceof NodeSelection ? sel.to - 1 : sel.to)) ;
-  else if (mouseDown && mouseDown.mightDrag) {
-    node = NodeSelection.create(view.state.doc, mouseDown.mightDrag.pos);
-  } else if (event.target && event.target.nodeType == 1) {
-    let desc = view.docView.nearestDesc(event.target, true);
-    if (desc && desc.node.type.spec.draggable && desc != view.docView)
-      node = NodeSelection.create(view.state.doc, desc.posBefore);
-  }
-  let draggedSlice = (node || view.state.selection).content();
-  let { dom, text, slice } = serializeForClipboard(view, draggedSlice);
-  if (!event.dataTransfer.files.length || !chrome || chrome_version > 120)
-    event.dataTransfer.clearData();
-  event.dataTransfer.setData(brokenClipboardAPI ? "Text" : "text/html", dom.innerHTML);
-  event.dataTransfer.effectAllowed = "copyMove";
-  if (!brokenClipboardAPI)
-    event.dataTransfer.setData("text/plain", text);
-  view.dragging = new Dragging(slice, dragMoves(view, event), node);
-};
-handlers.dragend = (view) => {
-  let dragging = view.dragging;
-  window.setTimeout(() => {
-    if (view.dragging == dragging)
-      view.dragging = null;
-  }, 50);
-};
-editHandlers.dragover = editHandlers.dragenter = (_, e) => e.preventDefault();
-editHandlers.drop = (view, event) => {
-  try {
-    handleDrop(view, event, view.dragging);
-  } finally {
-    view.dragging = null;
-  }
-};
-function handleDrop(view, event, dragging) {
-  if (!event.dataTransfer)
-    return;
-  let eventPos = view.posAtCoords(eventCoords(event));
-  if (!eventPos)
-    return;
-  let $mouse = view.state.doc.resolve(eventPos.pos);
-  let slice = dragging && dragging.slice;
-  if (slice) {
-    view.someProp("transformPasted", (f) => {
-      slice = f(slice, view, false);
-    });
-  } else {
-    slice = parseFromClipboard(view, getText(event.dataTransfer), brokenClipboardAPI ? null : event.dataTransfer.getData("text/html"), false, $mouse);
-  }
-  let move = !!(dragging && dragMoves(view, event));
-  if (view.someProp("handleDrop", (f) => f(view, event, slice || Slice.empty, move))) {
-    event.preventDefault();
-    return;
-  }
-  if (!slice)
-    return;
-  event.preventDefault();
-  let insertPos = slice ? dropPoint(view.state.doc, $mouse.pos, slice) : $mouse.pos;
-  if (insertPos == null)
-    insertPos = $mouse.pos;
-  let tr = view.state.tr;
-  if (move) {
-    let { node } = dragging;
-    if (node)
-      node.replace(tr);
-    else
-      tr.deleteSelection();
-  }
-  let pos = tr.mapping.map(insertPos);
-  let isNode = slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1;
-  let beforeInsert = tr.doc;
-  if (isNode)
-    tr.replaceRangeWith(pos, pos, slice.content.firstChild);
-  else
-    tr.replaceRange(pos, pos, slice);
-  if (tr.doc.eq(beforeInsert))
-    return;
-  let $pos = tr.doc.resolve(pos);
-  if (isNode && NodeSelection.isSelectable(slice.content.firstChild) && $pos.nodeAfter && $pos.nodeAfter.sameMarkup(slice.content.firstChild)) {
-    tr.setSelection(new NodeSelection($pos));
-  } else {
-    let end = tr.mapping.map(insertPos);
-    tr.mapping.maps[tr.mapping.maps.length - 1].forEach((_from, _to, _newFrom, newTo) => end = newTo);
-    tr.setSelection(selectionBetween(view, $pos, tr.doc.resolve(end)));
-  }
-  view.focus();
-  view.dispatch(tr.setMeta("uiEvent", "drop"));
-}
-handlers.focus = (view) => {
-  view.input.lastFocus = Date.now();
-  if (!view.focused) {
-    view.domObserver.stop();
-    view.dom.classList.add("ProseMirror-focused");
-    view.domObserver.start();
-    view.focused = true;
-    setTimeout(() => {
-      if (view.docView && view.hasFocus() && !view.domObserver.currentSelection.eq(view.domSelectionRange()))
-        selectionToDOM(view);
-    }, 20);
-  }
-};
-handlers.blur = (view, _event) => {
-  let event = _event;
-  if (view.focused) {
-    view.domObserver.stop();
-    view.dom.classList.remove("ProseMirror-focused");
-    view.domObserver.start();
-    if (event.relatedTarget && view.dom.contains(event.relatedTarget))
-      view.domObserver.currentSelection.clear();
-    view.focused = false;
-  }
-};
-handlers.beforeinput = (view, _event) => {
-  let event = _event;
-  if (chrome && android && event.inputType == "deleteContentBackward") {
-    view.domObserver.flushSoon();
-    let { domChangeCount } = view.input;
-    setTimeout(() => {
-      if (view.input.domChangeCount != domChangeCount)
-        return;
-      view.dom.blur();
-      view.focus();
-      if (view.someProp("handleKeyDown", (f) => f(view, keyEvent(8, "Backspace"))))
-        return;
-      let { $cursor } = view.state.selection;
-      if ($cursor && $cursor.pos > 0)
-        view.dispatch(view.state.tr.delete($cursor.pos - 1, $cursor.pos).scrollIntoView());
-    }, 50);
-  }
-};
-for (let prop in editHandlers)
-  handlers[prop] = editHandlers[prop];
-function compareObjs(a, b) {
-  if (a == b)
-    return true;
-  for (let p in a)
-    if (a[p] !== b[p])
-      return false;
-  for (let p in b)
-    if (!(p in a))
-      return false;
-  return true;
-}
-var WidgetType = class _WidgetType {
-  constructor(toDOM, spec) {
-    this.toDOM = toDOM;
-    this.spec = spec || noSpec;
-    this.side = this.spec.side || 0;
-  }
-  map(mapping, span, offset, oldOffset) {
-    let { pos, deleted } = mapping.mapResult(span.from + oldOffset, this.side < 0 ? -1 : 1);
-    return deleted ? null : new Decoration(pos - offset, pos - offset, this);
-  }
-  valid() {
-    return true;
-  }
-  eq(other) {
-    return this == other || other instanceof _WidgetType && (this.spec.key && this.spec.key == other.spec.key || this.toDOM == other.toDOM && compareObjs(this.spec, other.spec));
-  }
-  destroy(node) {
-    if (this.spec.destroy)
-      this.spec.destroy(node);
-  }
-};
-var InlineType = class _InlineType {
-  constructor(attrs, spec) {
-    this.attrs = attrs;
-    this.spec = spec || noSpec;
-  }
-  map(mapping, span, offset, oldOffset) {
-    let from = mapping.map(span.from + oldOffset, this.spec.inclusiveStart ? -1 : 1) - offset;
-    let to = mapping.map(span.to + oldOffset, this.spec.inclusiveEnd ? 1 : -1) - offset;
-    return from >= to ? null : new Decoration(from, to, this);
-  }
-  valid(_, span) {
-    return span.from < span.to;
-  }
-  eq(other) {
-    return this == other || other instanceof _InlineType && compareObjs(this.attrs, other.attrs) && compareObjs(this.spec, other.spec);
-  }
-  static is(span) {
-    return span.type instanceof _InlineType;
-  }
-  destroy() {
-  }
-};
-var NodeType = class _NodeType {
-  constructor(attrs, spec) {
-    this.attrs = attrs;
-    this.spec = spec || noSpec;
-  }
-  map(mapping, span, offset, oldOffset) {
-    let from = mapping.mapResult(span.from + oldOffset, 1);
-    if (from.deleted)
-      return null;
-    let to = mapping.mapResult(span.to + oldOffset, -1);
-    if (to.deleted || to.pos <= from.pos)
-      return null;
-    return new Decoration(from.pos - offset, to.pos - offset, this);
-  }
-  valid(node, span) {
-    let { index, offset } = node.content.findIndex(span.from), child;
-    return offset == span.from && !(child = node.child(index)).isText && offset + child.nodeSize == span.to;
-  }
-  eq(other) {
-    return this == other || other instanceof _NodeType && compareObjs(this.attrs, other.attrs) && compareObjs(this.spec, other.spec);
-  }
-  destroy() {
-  }
-};
-var Decoration = class _Decoration {
-  /**
-  @internal
-  */
-  constructor(from, to, type) {
-    this.from = from;
-    this.to = to;
-    this.type = type;
-  }
-  /**
-  @internal
-  */
-  copy(from, to) {
-    return new _Decoration(from, to, this.type);
-  }
-  /**
-  @internal
-  */
-  eq(other, offset = 0) {
-    return this.type.eq(other.type) && this.from + offset == other.from && this.to + offset == other.to;
-  }
-  /**
-  @internal
-  */
-  map(mapping, offset, oldOffset) {
-    return this.type.map(mapping, this, offset, oldOffset);
-  }
-  /**
-  Creates a widget decoration, which is a DOM node that's shown in
-  the document at the given position. It is recommended that you
-  delay rendering the widget by passing a function that will be
-  called when the widget is actually drawn in a view, but you can
-  also directly pass a DOM node. `getPos` can be used to find the
-  widget's current document position.
-  */
-  static widget(pos, toDOM, spec) {
-    return new _Decoration(pos, pos, new WidgetType(toDOM, spec));
-  }
-  /**
-  Creates an inline decoration, which adds the given attributes to
-  each inline node between `from` and `to`.
-  */
-  static inline(from, to, attrs, spec) {
-    return new _Decoration(from, to, new InlineType(attrs, spec));
-  }
-  /**
-  Creates a node decoration. `from` and `to` should point precisely
-  before and after a node in the document. That node, and only that
-  node, will receive the given attributes.
-  */
-  static node(from, to, attrs, spec) {
-    return new _Decoration(from, to, new NodeType(attrs, spec));
-  }
-  /**
-  The spec provided when creating this decoration. Can be useful
-  if you've stored extra information in that object.
-  */
-  get spec() {
-    return this.type.spec;
-  }
-  /**
-  @internal
-  */
-  get inline() {
-    return this.type instanceof InlineType;
-  }
-  /**
-  @internal
-  */
-  get widget() {
-    return this.type instanceof WidgetType;
-  }
-};
-var none = [];
-var noSpec = {};
-var DecorationSet = class _DecorationSet {
-  /**
-  @internal
-  */
-  constructor(local, children) {
-    this.local = local.length ? local : none;
-    this.children = children.length ? children : none;
-  }
-  /**
-  Create a set of decorations, using the structure of the given
-  document. This will consume (modify) the `decorations` array, so
-  you must make a copy if you want need to preserve that.
-  */
-  static create(doc3, decorations) {
-    return decorations.length ? buildTree(decorations, doc3, 0, noSpec) : empty;
-  }
-  /**
-  Find all decorations in this set which touch the given range
-  (including decorations that start or end directly at the
-  boundaries) and match the given predicate on their spec. When
-  `start` and `end` are omitted, all decorations in the set are
-  considered. When `predicate` isn't given, all decorations are
-  assumed to match.
-  */
-  find(start, end, predicate) {
-    let result = [];
-    this.findInner(start == null ? 0 : start, end == null ? 1e9 : end, result, 0, predicate);
-    return result;
-  }
-  findInner(start, end, result, offset, predicate) {
-    for (let i = 0; i < this.local.length; i++) {
-      let span = this.local[i];
-      if (span.from <= end && span.to >= start && (!predicate || predicate(span.spec)))
-        result.push(span.copy(span.from + offset, span.to + offset));
-    }
-    for (let i = 0; i < this.children.length; i += 3) {
-      if (this.children[i] < end && this.children[i + 1] > start) {
-        let childOff = this.children[i] + 1;
-        this.children[i + 2].findInner(start - childOff, end - childOff, result, offset + childOff, predicate);
-      }
-    }
-  }
-  /**
-  Map the set of decorations in response to a change in the
-  document.
-  */
-  map(mapping, doc3, options) {
-    if (this == empty || mapping.maps.length == 0)
-      return this;
-    return this.mapInner(mapping, doc3, 0, 0, options || noSpec);
-  }
-  /**
-  @internal
-  */
-  mapInner(mapping, node, offset, oldOffset, options) {
-    let newLocal;
-    for (let i = 0; i < this.local.length; i++) {
-      let mapped = this.local[i].map(mapping, offset, oldOffset);
-      if (mapped && mapped.type.valid(node, mapped))
-        (newLocal || (newLocal = [])).push(mapped);
-      else if (options.onRemove)
-        options.onRemove(this.local[i].spec);
-    }
-    if (this.children.length)
-      return mapChildren(this.children, newLocal || [], mapping, node, offset, oldOffset, options);
-    else
-      return newLocal ? new _DecorationSet(newLocal.sort(byPos), none) : empty;
-  }
-  /**
-  Add the given array of decorations to the ones in the set,
-  producing a new set. Consumes the `decorations` array. Needs
-  access to the current document to create the appropriate tree
-  structure.
-  */
-  add(doc3, decorations) {
-    if (!decorations.length)
-      return this;
-    if (this == empty)
-      return _DecorationSet.create(doc3, decorations);
-    return this.addInner(doc3, decorations, 0);
-  }
-  addInner(doc3, decorations, offset) {
-    let children, childIndex = 0;
-    doc3.forEach((childNode, childOffset) => {
-      let baseOffset = childOffset + offset, found2;
-      if (!(found2 = takeSpansForNode(decorations, childNode, baseOffset)))
-        return;
-      if (!children)
-        children = this.children.slice();
-      while (childIndex < children.length && children[childIndex] < childOffset)
-        childIndex += 3;
-      if (children[childIndex] == childOffset)
-        children[childIndex + 2] = children[childIndex + 2].addInner(childNode, found2, baseOffset + 1);
-      else
-        children.splice(childIndex, 0, childOffset, childOffset + childNode.nodeSize, buildTree(found2, childNode, baseOffset + 1, noSpec));
-      childIndex += 3;
-    });
-    let local = moveSpans(childIndex ? withoutNulls(decorations) : decorations, -offset);
-    for (let i = 0; i < local.length; i++)
-      if (!local[i].type.valid(doc3, local[i]))
-        local.splice(i--, 1);
-    return new _DecorationSet(local.length ? this.local.concat(local).sort(byPos) : this.local, children || this.children);
-  }
-  /**
-  Create a new set that contains the decorations in this set, minus
-  the ones in the given array.
-  */
-  remove(decorations) {
-    if (decorations.length == 0 || this == empty)
-      return this;
-    return this.removeInner(decorations, 0);
-  }
-  removeInner(decorations, offset) {
-    let children = this.children, local = this.local;
-    for (let i = 0; i < children.length; i += 3) {
-      let found2;
-      let from = children[i] + offset, to = children[i + 1] + offset;
-      for (let j = 0, span; j < decorations.length; j++)
-        if (span = decorations[j]) {
-          if (span.from > from && span.to < to) {
-            decorations[j] = null;
-            (found2 || (found2 = [])).push(span);
-          }
-        }
-      if (!found2)
-        continue;
-      if (children == this.children)
-        children = this.children.slice();
-      let removed = children[i + 2].removeInner(found2, from + 1);
-      if (removed != empty) {
-        children[i + 2] = removed;
-      } else {
-        children.splice(i, 3);
-        i -= 3;
-      }
-    }
-    if (local.length) {
-      for (let i = 0, span; i < decorations.length; i++)
-        if (span = decorations[i]) {
-          for (let j = 0; j < local.length; j++)
-            if (local[j].eq(span, offset)) {
-              if (local == this.local)
-                local = this.local.slice();
-              local.splice(j--, 1);
-            }
-        }
-    }
-    if (children == this.children && local == this.local)
-      return this;
-    return local.length || children.length ? new _DecorationSet(local, children) : empty;
-  }
-  forChild(offset, node) {
-    if (this == empty)
-      return this;
-    if (node.isLeaf)
-      return _DecorationSet.empty;
-    let child, local;
-    for (let i = 0; i < this.children.length; i += 3)
-      if (this.children[i] >= offset) {
-        if (this.children[i] == offset)
-          child = this.children[i + 2];
-        break;
-      }
-    let start = offset + 1, end = start + node.content.size;
-    for (let i = 0; i < this.local.length; i++) {
-      let dec = this.local[i];
-      if (dec.from < end && dec.to > start && dec.type instanceof InlineType) {
-        let from = Math.max(start, dec.from) - start, to = Math.min(end, dec.to) - start;
-        if (from < to)
-          (local || (local = [])).push(dec.copy(from, to));
-      }
-    }
-    if (local) {
-      let localSet = new _DecorationSet(local.sort(byPos), none);
-      return child ? new DecorationGroup([localSet, child]) : localSet;
-    }
-    return child || empty;
-  }
-  /**
-  @internal
-  */
-  eq(other) {
-    if (this == other)
-      return true;
-    if (!(other instanceof _DecorationSet) || this.local.length != other.local.length || this.children.length != other.children.length)
-      return false;
-    for (let i = 0; i < this.local.length; i++)
-      if (!this.local[i].eq(other.local[i]))
-        return false;
-    for (let i = 0; i < this.children.length; i += 3)
-      if (this.children[i] != other.children[i] || this.children[i + 1] != other.children[i + 1] || !this.children[i + 2].eq(other.children[i + 2]))
-        return false;
-    return true;
-  }
-  /**
-  @internal
-  */
-  locals(node) {
-    return removeOverlap(this.localsInner(node));
-  }
-  /**
-  @internal
-  */
-  localsInner(node) {
-    if (this == empty)
-      return none;
-    if (node.inlineContent || !this.local.some(InlineType.is))
-      return this.local;
-    let result = [];
-    for (let i = 0; i < this.local.length; i++) {
-      if (!(this.local[i].type instanceof InlineType))
-        result.push(this.local[i]);
-    }
-    return result;
-  }
-  forEachSet(f) {
-    f(this);
-  }
-};
-DecorationSet.empty = new DecorationSet([], []);
-DecorationSet.removeOverlap = removeOverlap;
-var empty = DecorationSet.empty;
-var DecorationGroup = class _DecorationGroup {
-  constructor(members) {
-    this.members = members;
-  }
-  map(mapping, doc3) {
-    const mappedDecos = this.members.map((member) => member.map(mapping, doc3, noSpec));
-    return _DecorationGroup.from(mappedDecos);
-  }
-  forChild(offset, child) {
-    if (child.isLeaf)
-      return DecorationSet.empty;
-    let found2 = [];
-    for (let i = 0; i < this.members.length; i++) {
-      let result = this.members[i].forChild(offset, child);
-      if (result == empty)
-        continue;
-      if (result instanceof _DecorationGroup)
-        found2 = found2.concat(result.members);
-      else
-        found2.push(result);
-    }
-    return _DecorationGroup.from(found2);
-  }
-  eq(other) {
-    if (!(other instanceof _DecorationGroup) || other.members.length != this.members.length)
-      return false;
-    for (let i = 0; i < this.members.length; i++)
-      if (!this.members[i].eq(other.members[i]))
-        return false;
-    return true;
-  }
-  locals(node) {
-    let result, sorted = true;
-    for (let i = 0; i < this.members.length; i++) {
-      let locals = this.members[i].localsInner(node);
-      if (!locals.length)
-        continue;
-      if (!result) {
-        result = locals;
-      } else {
-        if (sorted) {
-          result = result.slice();
-          sorted = false;
-        }
-        for (let j = 0; j < locals.length; j++)
-          result.push(locals[j]);
-      }
-    }
-    return result ? removeOverlap(sorted ? result : result.sort(byPos)) : none;
-  }
-  // Create a group for the given array of decoration sets, or return
-  // a single set when possible.
-  static from(members) {
-    switch (members.length) {
-      case 0:
-        return empty;
-      case 1:
-        return members[0];
-      default:
-        return new _DecorationGroup(members.every((m) => m instanceof DecorationSet) ? members : members.reduce((r, m) => r.concat(m instanceof DecorationSet ? m : m.members), []));
-    }
-  }
-  forEachSet(f) {
-    for (let i = 0; i < this.members.length; i++)
-      this.members[i].forEachSet(f);
-  }
-};
-function mapChildren(oldChildren, newLocal, mapping, node, offset, oldOffset, options) {
-  let children = oldChildren.slice();
-  for (let i = 0, baseOffset = oldOffset; i < mapping.maps.length; i++) {
-    let moved = 0;
-    mapping.maps[i].forEach((oldStart, oldEnd, newStart, newEnd) => {
-      let dSize = newEnd - newStart - (oldEnd - oldStart);
-      for (let i2 = 0; i2 < children.length; i2 += 3) {
-        let end = children[i2 + 1];
-        if (end < 0 || oldStart > end + baseOffset - moved)
-          continue;
-        let start = children[i2] + baseOffset - moved;
-        if (oldEnd >= start) {
-          children[i2 + 1] = oldStart <= start ? -2 : -1;
-        } else if (oldStart >= baseOffset && dSize) {
-          children[i2] += dSize;
-          children[i2 + 1] += dSize;
-        }
-      }
-      moved += dSize;
-    });
-    baseOffset = mapping.maps[i].map(baseOffset, -1);
-  }
-  let mustRebuild = false;
-  for (let i = 0; i < children.length; i += 3)
-    if (children[i + 1] < 0) {
-      if (children[i + 1] == -2) {
-        mustRebuild = true;
-        children[i + 1] = -1;
-        continue;
-      }
-      let from = mapping.map(oldChildren[i] + oldOffset), fromLocal = from - offset;
-      if (fromLocal < 0 || fromLocal >= node.content.size) {
-        mustRebuild = true;
-        continue;
-      }
-      let to = mapping.map(oldChildren[i + 1] + oldOffset, -1), toLocal = to - offset;
-      let { index, offset: childOffset } = node.content.findIndex(fromLocal);
-      let childNode = node.maybeChild(index);
-      if (childNode && childOffset == fromLocal && childOffset + childNode.nodeSize == toLocal) {
-        let mapped = children[i + 2].mapInner(mapping, childNode, from + 1, oldChildren[i] + oldOffset + 1, options);
-        if (mapped != empty) {
-          children[i] = fromLocal;
-          children[i + 1] = toLocal;
-          children[i + 2] = mapped;
-        } else {
-          children[i + 1] = -2;
-          mustRebuild = true;
-        }
-      } else {
-        mustRebuild = true;
-      }
-    }
-  if (mustRebuild) {
-    let decorations = mapAndGatherRemainingDecorations(children, oldChildren, newLocal, mapping, offset, oldOffset, options);
-    let built = buildTree(decorations, node, 0, options);
-    newLocal = built.local;
-    for (let i = 0; i < children.length; i += 3)
-      if (children[i + 1] < 0) {
-        children.splice(i, 3);
-        i -= 3;
-      }
-    for (let i = 0, j = 0; i < built.children.length; i += 3) {
-      let from = built.children[i];
-      while (j < children.length && children[j] < from)
-        j += 3;
-      children.splice(j, 0, built.children[i], built.children[i + 1], built.children[i + 2]);
-    }
-  }
-  return new DecorationSet(newLocal.sort(byPos), children);
-}
-function moveSpans(spans, offset) {
-  if (!offset || !spans.length)
-    return spans;
-  let result = [];
-  for (let i = 0; i < spans.length; i++) {
-    let span = spans[i];
-    result.push(new Decoration(span.from + offset, span.to + offset, span.type));
-  }
-  return result;
-}
-function mapAndGatherRemainingDecorations(children, oldChildren, decorations, mapping, offset, oldOffset, options) {
-  function gather(set, oldOffset2) {
-    for (let i = 0; i < set.local.length; i++) {
-      let mapped = set.local[i].map(mapping, offset, oldOffset2);
-      if (mapped)
-        decorations.push(mapped);
-      else if (options.onRemove)
-        options.onRemove(set.local[i].spec);
-    }
-    for (let i = 0; i < set.children.length; i += 3)
-      gather(set.children[i + 2], set.children[i] + oldOffset2 + 1);
-  }
-  for (let i = 0; i < children.length; i += 3)
-    if (children[i + 1] == -1)
-      gather(children[i + 2], oldChildren[i] + oldOffset + 1);
-  return decorations;
-}
-function takeSpansForNode(spans, node, offset) {
-  if (node.isLeaf)
-    return null;
-  let end = offset + node.nodeSize, found2 = null;
-  for (let i = 0, span; i < spans.length; i++) {
-    if ((span = spans[i]) && span.from > offset && span.to < end) {
-      (found2 || (found2 = [])).push(span);
-      spans[i] = null;
-    }
-  }
-  return found2;
-}
-function withoutNulls(array) {
-  let result = [];
-  for (let i = 0; i < array.length; i++)
-    if (array[i] != null)
-      result.push(array[i]);
-  return result;
-}
-function buildTree(spans, node, offset, options) {
-  let children = [], hasNulls = false;
-  node.forEach((childNode, localStart) => {
-    let found2 = takeSpansForNode(spans, childNode, localStart + offset);
-    if (found2) {
-      hasNulls = true;
-      let subtree = buildTree(found2, childNode, offset + localStart + 1, options);
-      if (subtree != empty)
-        children.push(localStart, localStart + childNode.nodeSize, subtree);
-    }
-  });
-  let locals = moveSpans(hasNulls ? withoutNulls(spans) : spans, -offset).sort(byPos);
-  for (let i = 0; i < locals.length; i++)
-    if (!locals[i].type.valid(node, locals[i])) {
-      if (options.onRemove)
-        options.onRemove(locals[i].spec);
-      locals.splice(i--, 1);
-    }
-  return locals.length || children.length ? new DecorationSet(locals, children) : empty;
-}
-function byPos(a, b) {
-  return a.from - b.from || a.to - b.to;
-}
-function removeOverlap(spans) {
-  let working = spans;
-  for (let i = 0; i < working.length - 1; i++) {
-    let span = working[i];
-    if (span.from != span.to)
-      for (let j = i + 1; j < working.length; j++) {
-        let next = working[j];
-        if (next.from == span.from) {
-          if (next.to != span.to) {
-            if (working == spans)
-              working = spans.slice();
-            working[j] = next.copy(next.from, span.to);
-            insertAhead(working, j + 1, next.copy(span.to, next.to));
-          }
-          continue;
-        } else {
-          if (next.from < span.to) {
-            if (working == spans)
-              working = spans.slice();
-            working[i] = span.copy(span.from, next.from);
-            insertAhead(working, j, span.copy(next.from, span.to));
-          }
-          break;
-        }
-      }
-  }
-  return working;
-}
-function insertAhead(array, i, deco) {
-  while (i < array.length && byPos(deco, array[i]) > 0)
-    i++;
-  array.splice(i, 0, deco);
-}
-
-// src/components/RichTextEditor/extensions/BskyLinkDecorator.ts
 var URL_REGEX = /https?:\/\/[^\s<>"{}|\\^`[\]]+/g;
-function getDecorations(doc3, linkClass) {
+function getDecorations(doc, linkClass) {
   const decorations = [];
-  doc3.descendants((node, pos) => {
+  doc.descendants((node, pos) => {
     if (!node.isText || !node.text) return;
     const text = node.text;
     URL_REGEX.lastIndex = 0;
@@ -5401,21 +582,21 @@ function getDecorations(doc3, linkClass) {
         to--;
       }
       decorations.push(
-        Decoration.inline(from, to, {
+        view.Decoration.inline(from, to, {
           class: linkClass,
           "data-autolink": ""
         })
       );
     }
   });
-  return DecorationSet.create(doc3, decorations);
+  return view.DecorationSet.create(doc, decorations);
 }
 function createLinkDecoratorPlugin(linkClass) {
-  const key = new PluginKey("bsky-link-decorator");
-  return new Plugin({
+  const key = new state.PluginKey("bsky-link-decorator");
+  return new state.Plugin({
     key,
     state: {
-      init: (_, { doc: doc3 }) => getDecorations(doc3, linkClass),
+      init: (_, { doc }) => getDecorations(doc, linkClass),
       apply: (transaction, decorationSet) => {
         if (transaction.docChanged) {
           return getDecorations(transaction.doc, linkClass);
@@ -5451,9 +632,7 @@ function toInitialHTML(value) {
     return `<p>${escapeHTML(text)}</p>`;
   }
   const atpFacets = facets;
-  const rt = new api.RichText(
-    atpFacets ? { text, facets: atpFacets } : { text }
-  );
+  const rt = new api.RichText(atpFacets ? { text, facets: atpFacets } : { text });
   let html = "";
   for (const segment of rt.segments()) {
     if (segment.mention) {
@@ -5572,6 +751,13 @@ function RichTextEditor({
       extensions,
       editable,
       content: toInitialHTML(initialValue),
+      /**
+       * Disable immediate rendering to prevent SSR/hydration issues in Next.js,
+       * Remix, and other server-rendering frameworks. The editor defers rendering
+       * until after the component mounts on the client.
+       * @see https://github.com/ueberdosis/tiptap/issues/5856
+       */
+      immediatelyRender: false,
       /**
        * Clipboard text serialisation: use '\n' as the block separator so
        * multi-paragraph content is copied as plain newline-delimited text.