@fewangsit/wangsvue 1.5.219-alpha.0 → 1.5.219-alpha.2

package/vendor/prosemirror-model/dist/index.es.js

@@ -1,75 +1,82 @@
-import { O as q } from "../../orderedmap/dist/index.es.js";
-function Y(l, t, e) {
-  for (let n = 0; ; n++) {
-    if (n == l.childCount || n == t.childCount)
-      return l.childCount == t.childCount ? null : e;
-    let i = l.child(n), r = t.child(n);
-    if (i == r) {
-      e += i.nodeSize;
+import { O as OrderedMap } from "../../orderedmap/dist/index.es.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 (!i.sameMarkup(r))
-      return e;
-    if (i.isText && i.text != r.text) {
-      for (let s = 0; i.text[s] == r.text[s]; s++)
-        e++;
-      return e;
+    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 (i.content.size || r.content.size) {
-      let s = Y(i.content, r.content, e + 1);
-      if (s != null)
-        return s;
+    if (childA.content.size || childB.content.size) {
+      let inner = findDiffStart(childA.content, childB.content, pos + 1);
+      if (inner != null)
+        return inner;
     }
-    e += i.nodeSize;
+    pos += childA.nodeSize;
   }
 }
-function Z(l, t, e, n) {
-  for (let i = l.childCount, r = t.childCount; ; ) {
-    if (i == 0 || r == 0)
-      return i == r ? null : { a: e, b: n };
-    let s = l.child(--i), o = t.child(--r), h = s.nodeSize;
-    if (s == o) {
-      e -= h, n -= h;
+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 (!s.sameMarkup(o))
-      return { a: e, b: n };
-    if (s.isText && s.text != o.text) {
-      let a = 0, f = Math.min(s.text.length, o.text.length);
-      for (; a < f && s.text[s.text.length - a - 1] == o.text[o.text.length - a - 1]; )
-        a++, e--, n--;
-      return { a: e, b: n };
+    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 (s.content.size || o.content.size) {
-      let a = Z(s.content, o.content, e - 1, n - 1);
-      if (a)
-        return a;
+    if (childA.content.size || childB.content.size) {
+      let inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
+      if (inner)
+        return inner;
     }
-    e -= h, n -= h;
+    posA -= size;
+    posB -= size;
   }
 }
-class c {
+class Fragment {
   /**
   @internal
   */
-  constructor(t, e) {
-    if (this.content = t, this.size = e || 0, e == null)
-      for (let n = 0; n < t.length; n++)
-        this.size += t[n].nodeSize;
+  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(t, e, n, i = 0, r) {
-    for (let s = 0, o = 0; o < e; s++) {
-      let h = this.content[s], a = o + h.nodeSize;
-      if (a > t && n(h, i + o, r || null, s) !== !1 && h.content.size) {
-        let f = o + 1;
-        h.nodesBetween(Math.max(0, t - f), Math.min(h.content.size, e - f), n, i + f);
+  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);
       }
-      o = a;
+      pos = end;
     }
   }
   /**
@@ -77,89 +84,116 @@ class c {
   relative to the start of the fragment. The callback may return
   `false` to prevent traversal of a given node's children.
   */
-  descendants(t) {
-    this.nodesBetween(0, this.size, t);
+  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(t, e, n, i) {
-    let r = "", s = !0;
-    return this.nodesBetween(t, e, (o, h) => {
-      let a = o.isText ? o.text.slice(Math.max(t, h) - h, e - h) : o.isLeaf ? i ? typeof i == "function" ? i(o) : i : o.type.spec.leafText ? o.type.spec.leafText(o) : "" : "";
-      o.isBlock && (o.isLeaf && a || o.isTextblock) && n && (s ? s = !1 : r += n), r += a;
-    }, 0), r;
+  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(t) {
-    if (!t.size)
+  append(other) {
+    if (!other.size)
       return this;
     if (!this.size)
-      return t;
-    let e = this.lastChild, n = t.firstChild, i = this.content.slice(), r = 0;
-    for (e.isText && e.sameMarkup(n) && (i[i.length - 1] = e.withText(e.text + n.text), r = 1); r < t.content.length; r++)
-      i.push(t.content[r]);
-    return new c(i, this.size + t.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(t, e = this.size) {
-    if (t == 0 && e == this.size)
+  cut(from, to = this.size) {
+    if (from == 0 && to == this.size)
       return this;
-    let n = [], i = 0;
-    if (e > t)
-      for (let r = 0, s = 0; s < e; r++) {
-        let o = this.content[r], h = s + o.nodeSize;
-        h > t && ((s < t || h > e) && (o.isText ? o = o.cut(Math.max(0, t - s), Math.min(o.text.length, e - s)) : o = o.cut(Math.max(0, t - s - 1), Math.min(o.content.size, e - s - 1))), n.push(o), i += o.nodeSize), s = h;
+    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 c(n, i);
+    return new Fragment(result, size);
   }
   /**
   @internal
   */
-  cutByIndex(t, e) {
-    return t == e ? c.empty : t == 0 && e == this.content.length ? this : new c(this.content.slice(t, e));
+  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(t, e) {
-    let n = this.content[t];
-    if (n == e)
+  replaceChild(index, node) {
+    let current = this.content[index];
+    if (current == node)
       return this;
-    let i = this.content.slice(), r = this.size + e.nodeSize - n.nodeSize;
-    return i[t] = e, new c(i, r);
+    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(t) {
-    return new c([t].concat(this.content), this.size + t.nodeSize);
+  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(t) {
-    return new c(this.content.concat(t), this.size + t.nodeSize);
+  addToEnd(node) {
+    return new Fragment(this.content.concat(node), this.size + node.nodeSize);
   }
   /**
   Compare this fragment to another one.
   */
-  eq(t) {
-    if (this.content.length != t.content.length)
-      return !1;
-    for (let e = 0; e < this.content.length; e++)
-      if (!this.content[e].eq(t.content[e]))
-        return !1;
-    return !0;
+  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.
@@ -183,34 +217,35 @@ class c {
   Get the child node at the given index. Raise an error when the
   index is out of range.
   */
-  child(t) {
-    let e = this.content[t];
-    if (!e)
-      throw new RangeError("Index " + t + " out of range for " + this);
-    return e;
+  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(t) {
-    return this.content[t] || null;
+  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(t) {
-    for (let e = 0, n = 0; e < this.content.length; e++) {
-      let i = this.content[e];
-      t(i, n, e), n += i.nodeSize;
+  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(t, e = 0) {
-    return Y(this, t, e);
+  findDiffStart(other, pos = 0) {
+    return findDiffStart(this, other, pos);
   }
   /**
   Find the first position, searching from the end, at which this
@@ -218,26 +253,29 @@ class c {
   the same. Since this position will not be the same in both
   nodes, an object with two separate positions is returned.
   */
-  findDiffEnd(t, e = this.size, n = t.size) {
-    return Z(this, t, e, n);
+  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(t, e = -1) {
-    if (t == 0)
-      return O(0, t);
-    if (t == this.size)
-      return O(this.content.length, t);
-    if (t > this.size || t < 0)
-      throw new RangeError(`Position ${t} outside of fragment (${this})`);
-    for (let n = 0, i = 0; ; n++) {
-      let r = this.child(n), s = i + r.nodeSize;
-      if (s >= t)
-        return s == t || e > 0 ? O(n + 1, s) : O(n, i);
-      i = s;
+  findIndex(pos, round = -1) {
+    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 || round > 0)
+          return retIndex(i + 1, end);
+        return retIndex(i, curPos);
+      }
+      curPos = end;
     }
   }
   /**
@@ -256,31 +294,38 @@ class c {
   Create a JSON-serializeable representation of this fragment.
   */
   toJSON() {
-    return this.content.length ? this.content.map((t) => t.toJSON()) : null;
+    return this.content.length ? this.content.map((n) => n.toJSON()) : null;
   }
   /**
   Deserialize a fragment from its JSON representation.
   */
-  static fromJSON(t, e) {
-    if (!e)
-      return c.empty;
-    if (!Array.isArray(e))
+  static fromJSON(schema, value) {
+    if (!value)
+      return Fragment.empty;
+    if (!Array.isArray(value))
       throw new RangeError("Invalid input for Fragment.fromJSON");
-    return new c(e.map(t.nodeFromJSON));
+    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(t) {
-    if (!t.length)
-      return c.empty;
-    let e, n = 0;
-    for (let i = 0; i < t.length; i++) {
-      let r = t[i];
-      n += r.nodeSize, i && r.isText && t[i - 1].sameMarkup(r) ? (e || (e = t.slice(0, i)), e[e.length - 1] = r.withText(e[e.length - 1].text + r.text)) : e && e.push(r);
+  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 c(e || t, n);
+    return new Fragment(joined || array, size);
   }
   /**
   Create a fragment from something that can be interpreted as a
@@ -288,53 +333,56 @@ class c {
   fragment, the fragment itself. For a node or array of nodes, a
   fragment containing those nodes.
   */
-  static from(t) {
-    if (!t)
-      return c.empty;
-    if (t instanceof c)
-      return t;
-    if (Array.isArray(t))
-      return this.fromArray(t);
-    if (t.attrs)
-      return new c([t], t.nodeSize);
-    throw new RangeError("Can not convert " + t + " to a Fragment" + (t.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
-  }
-}
-c.empty = new c([], 0);
-const v = { index: 0, offset: 0 };
-function O(l, t) {
-  return v.index = l, v.offset = t, v;
-}
-function M(l, t) {
-  if (l === t)
-    return !0;
-  if (!(l && typeof l == "object") || !(t && typeof t == "object"))
-    return !1;
-  let e = Array.isArray(l);
-  if (Array.isArray(t) != e)
-    return !1;
-  if (e) {
-    if (l.length != t.length)
-      return !1;
-    for (let n = 0; n < l.length; n++)
-      if (!M(l[n], t[n]))
-        return !1;
+  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);
+const 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 n in l)
-      if (!(n in t) || !M(l[n], t[n]))
-        return !1;
-    for (let n in t)
-      if (!(n in l))
-        return !1;
+    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 !0;
+  return true;
 }
-class u {
+class Mark {
   /**
   @internal
   */
-  constructor(t, e) {
-    this.type = t, this.attrs = e;
+  constructor(type, attrs) {
+    this.type = type;
+    this.attrs = attrs;
   }
   /**
   Given a set of marks, create a new set which contains this one as
@@ -343,101 +391,115 @@ class u {
   [exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
   those are replaced by this one.
   */
-  addToSet(t) {
-    let e, n = !1;
-    for (let i = 0; i < t.length; i++) {
-      let r = t[i];
-      if (this.eq(r))
-        return t;
-      if (this.type.excludes(r.type))
-        e || (e = t.slice(0, i));
-      else {
-        if (r.type.excludes(this.type))
-          return t;
-        !n && r.type.rank > this.type.rank && (e || (e = t.slice(0, i)), e.push(this), n = !0), e && e.push(r);
+  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);
       }
     }
-    return e || (e = t.slice()), n || e.push(this), e;
+    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(t) {
-    for (let e = 0; e < t.length; e++)
-      if (this.eq(t[e]))
-        return t.slice(0, e).concat(t.slice(e + 1));
-    return t;
+  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(t) {
-    for (let e = 0; e < t.length; e++)
-      if (this.eq(t[e]))
-        return !0;
-    return !1;
+  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(t) {
-    return this == t || this.type == t.type && M(this.attrs, t.attrs);
+  eq(other) {
+    return this == other || this.type == other.type && compareDeep(this.attrs, other.attrs);
   }
   /**
   Convert this mark to a JSON-serializeable representation.
   */
   toJSON() {
-    let t = { type: this.type.name };
-    for (let e in this.attrs) {
-      t.attrs = this.attrs;
+    let obj = { type: this.type.name };
+    for (let _ in this.attrs) {
+      obj.attrs = this.attrs;
       break;
     }
-    return t;
+    return obj;
   }
   /**
   Deserialize a mark from JSON.
   */
-  static fromJSON(t, e) {
-    if (!e)
+  static fromJSON(schema, json) {
+    if (!json)
       throw new RangeError("Invalid input for Mark.fromJSON");
-    let n = t.marks[e.type];
-    if (!n)
-      throw new RangeError(`There is no mark type ${e.type} in this schema`);
-    let i = n.create(e.attrs);
-    return n.checkAttrs(i.attrs), i;
+    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(t, e) {
-    if (t == e)
-      return !0;
-    if (t.length != e.length)
-      return !1;
-    for (let n = 0; n < t.length; n++)
-      if (!t[n].eq(e[n]))
-        return !1;
-    return !0;
+  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(t) {
-    if (!t || Array.isArray(t) && t.length == 0)
-      return u.none;
-    if (t instanceof u)
-      return [t];
-    let e = t.slice();
-    return e.sort((n, i) => n.type.rank - i.type.rank), e;
+  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;
   }
 }
-u.none = [];
-class I extends Error {
+Mark.none = [];
+class ReplaceError extends Error {
 }
-class d {
+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
@@ -450,8 +512,10 @@ class d {
   start/end/middle for such a node, depending on which sides are
   open.
   */
-  constructor(t, e, n) {
-    this.content = t, this.openStart = e, this.openEnd = n;
+  constructor(content, openStart, openEnd) {
+    this.content = content;
+    this.openStart = openStart;
+    this.openEnd = openEnd;
   }
   /**
   The size this slice would add when inserted into a document.
@@ -462,21 +526,21 @@ class d {
   /**
   @internal
   */
-  insertAt(t, e) {
-    let n = $(this.content, t + this.openStart, e);
-    return n && new d(n, this.openStart, this.openEnd);
+  insertAt(pos, fragment) {
+    let content = insertInto(this.content, pos + this.openStart, fragment);
+    return content && new Slice(content, this.openStart, this.openEnd);
   }
   /**
   @internal
   */
-  removeBetween(t, e) {
-    return new d(_(this.content, t + this.openStart, e + this.openStart), this.openStart, this.openEnd);
+  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(t) {
-    return this.content.eq(t.content) && this.openStart == t.openStart && this.openEnd == t.openEnd;
+  eq(other) {
+    return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
   }
   /**
   @internal
@@ -490,129 +554,174 @@ class d {
   toJSON() {
     if (!this.content.size)
       return null;
-    let t = { content: this.content.toJSON() };
-    return this.openStart > 0 && (t.openStart = this.openStart), this.openEnd > 0 && (t.openEnd = this.openEnd), t;
+    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(t, e) {
-    if (!e)
-      return d.empty;
-    let n = e.openStart || 0, i = e.openEnd || 0;
-    if (typeof n != "number" || typeof i != "number")
+  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 d(c.fromJSON(t, e.content), n, i);
+    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(t, e = !0) {
-    let n = 0, i = 0;
-    for (let r = t.firstChild; r && !r.isLeaf && (e || !r.type.spec.isolating); r = r.firstChild)
-      n++;
-    for (let r = t.lastChild; r && !r.isLeaf && (e || !r.type.spec.isolating); r = r.lastChild)
-      i++;
-    return new d(t, n, i);
-  }
-}
-d.empty = new d(c.empty, 0, 0);
-function _(l, t, e) {
-  let { index: n, offset: i } = l.findIndex(t), r = l.maybeChild(n), { index: s, offset: o } = l.findIndex(e);
-  if (i == t || r.isText) {
-    if (o != e && !l.child(s).isText)
+  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 l.cut(0, t).append(l.cut(e));
+    return content.cut(0, from).append(content.cut(to));
   }
-  if (n != s)
+  if (index != indexTo)
     throw new RangeError("Removing non-flat range");
-  return l.replaceChild(n, r.copy(_(r.content, t - i - 1, e - i - 1)));
-}
-function $(l, t, e, n) {
-  let { index: i, offset: r } = l.findIndex(t), s = l.maybeChild(i);
-  if (r == t || s.isText)
-    return l.cut(0, t).append(e).append(l.cut(t));
-  let o = $(s.content, t - r - 1, e);
-  return o && l.replaceChild(i, s.copy(o));
-}
-function dt(l, t, e) {
-  if (e.openStart > l.depth)
-    throw new I("Inserted content deeper than insertion position");
-  if (l.depth - e.openStart != t.depth - e.openEnd)
-    throw new I("Inconsistent open depths");
-  return tt(l, t, e, 0);
-}
-function tt(l, t, e, n) {
-  let i = l.index(n), r = l.node(n);
-  if (i == t.index(n) && n < l.depth - e.openStart) {
-    let s = tt(l, t, e, n + 1);
-    return r.copy(r.content.replaceChild(i, s));
-  } else if (e.content.size)
-    if (!e.openStart && !e.openEnd && l.depth == n && t.depth == n) {
-      let s = l.parent, o = s.content;
-      return m(s, o.cut(0, l.parentOffset).append(e.content).append(o.cut(t.parentOffset)));
-    } else {
-      let { start: s, end: o } = gt(e, l);
-      return m(r, nt(l, s, o, t, n));
+  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) {
+    return content.cut(0, dist).append(insert).append(content.cut(dist));
+  }
+  let inner = insertInto(child.content, dist - offset - 1, insert);
+  return inner && content.replaceChild(index, child.copy(inner));
+}
+function replace($from, $to, slice) {
+  if (slice.openStart > $from.depth)
+    throw new ReplaceError("Inserted content deeper than insertion position");
+  if ($from.depth - slice.openStart != $to.depth - slice.openEnd)
+    throw new ReplaceError("Inconsistent open depths");
+  return replaceOuter($from, $to, slice, 0);
+}
+function replaceOuter($from, $to, slice, depth) {
+  let index = $from.index(depth), node = $from.node(depth);
+  if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
+    let inner = replaceOuter($from, $to, slice, depth + 1);
+    return node.copy(node.content.replaceChild(index, inner));
+  } else if (!slice.content.size) {
+    return close(node, replaceTwoWay($from, $to, depth));
+  } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
+    let parent = $from.parent, content = parent.content;
+    return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
+  } else {
+    let { start, end } = prepareSliceForReplace(slice, $from);
+    return close(node, replaceThreeWay($from, start, end, $to, depth));
+  }
+}
+function checkJoin(main, sub) {
+  if (!sub.type.compatibleContent(main.type))
+    throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main.type.name);
+}
+function joinable($before, $after, depth) {
+  let node = $before.node(depth);
+  checkJoin(node, $after.node(depth));
+  return node;
+}
+function addNode(child, target) {
+  let last = target.length - 1;
+  if (last >= 0 && child.isText && child.sameMarkup(target[last]))
+    target[last] = child.withText(target[last].text + child.text);
+  else
+    target.push(child);
+}
+function addRange($start, $end, depth, target) {
+  let node = ($end || $start).node(depth);
+  let startIndex = 0, endIndex = $end ? $end.index(depth) : node.childCount;
+  if ($start) {
+    startIndex = $start.index(depth);
+    if ($start.depth > depth) {
+      startIndex++;
+    } else if ($start.textOffset) {
+      addNode($start.nodeAfter, target);
+      startIndex++;
     }
-  else return m(r, A(l, t, n));
-}
-function et(l, t) {
-  if (!t.type.compatibleContent(l.type))
-    throw new I("Cannot join " + t.type.name + " onto " + l.type.name);
-}
-function D(l, t, e) {
-  let n = l.node(e);
-  return et(n, t.node(e)), n;
-}
-function x(l, t) {
-  let e = t.length - 1;
-  e >= 0 && l.isText && l.sameMarkup(t[e]) ? t[e] = l.withText(t[e].text + l.text) : t.push(l);
-}
-function k(l, t, e, n) {
-  let i = (t || l).node(e), r = 0, s = t ? t.index(e) : i.childCount;
-  l && (r = l.index(e), l.depth > e ? r++ : l.textOffset && (x(l.nodeAfter, n), r++));
-  for (let o = r; o < s; o++)
-    x(i.child(o), n);
-  t && t.depth == e && t.textOffset && x(t.nodeBefore, n);
-}
-function m(l, t) {
-  return l.type.checkContent(t), l.copy(t);
-}
-function nt(l, t, e, n, i) {
-  let r = l.depth > i && D(l, t, i + 1), s = n.depth > i && D(e, n, i + 1), o = [];
-  return k(null, l, i, o), r && s && t.index(i) == e.index(i) ? (et(r, s), x(m(r, nt(l, t, e, n, i + 1)), o)) : (r && x(m(r, A(l, t, i + 1)), o), k(t, e, i, o), s && x(m(s, A(e, n, i + 1)), o)), k(n, null, i, o), new c(o);
-}
-function A(l, t, e) {
-  let n = [];
-  if (k(null, l, e, n), l.depth > e) {
-    let i = D(l, t, e + 1);
-    x(m(i, A(l, t, e + 1)), n);
-  }
-  return k(t, null, e, n), new c(n);
-}
-function gt(l, t) {
-  let e = t.depth - l.openStart, i = t.node(e).copy(l.content);
-  for (let r = e - 1; r >= 0; r--)
-    i = t.node(r).copy(c.from(i));
+  }
+  for (let i = startIndex; i < endIndex; i++)
+    addNode(node.child(i), target);
+  if ($end && $end.depth == depth && $end.textOffset)
+    addNode($end.nodeBefore, target);
+}
+function close(node, content) {
+  node.type.checkContent(content);
+  return node.copy(content);
+}
+function replaceThreeWay($from, $start, $end, $to, depth) {
+  let openStart = $from.depth > depth && joinable($from, $start, depth + 1);
+  let openEnd = $to.depth > depth && joinable($end, $to, depth + 1);
+  let content = [];
+  addRange(null, $from, depth, content);
+  if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
+    checkJoin(openStart, openEnd);
+    addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
+  } else {
+    if (openStart)
+      addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
+    addRange($start, $end, depth, content);
+    if (openEnd)
+      addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
+  }
+  addRange($to, null, depth, content);
+  return new Fragment(content);
+}
+function replaceTwoWay($from, $to, depth) {
+  let content = [];
+  addRange(null, $from, depth, content);
+  if ($from.depth > depth) {
+    let type = joinable($from, $to, depth + 1);
+    addNode(close(type, replaceTwoWay($from, $to, depth + 1)), content);
+  }
+  addRange($to, null, depth, content);
+  return new Fragment(content);
+}
+function prepareSliceForReplace(slice, $along) {
+  let extra = $along.depth - slice.openStart, parent = $along.node(extra);
+  let node = parent.copy(slice.content);
+  for (let i = extra - 1; i >= 0; i--)
+    node = $along.node(i).copy(Fragment.from(node));
   return {
-    start: i.resolveNoCache(l.openStart + e),
-    end: i.resolveNoCache(i.content.size - l.openEnd - e)
+    start: node.resolveNoCache(slice.openStart + extra),
+    end: node.resolveNoCache(node.content.size - slice.openEnd - extra)
   };
 }
-class S {
+class ResolvedPos {
   /**
   @internal
   */
-  constructor(t, e, n) {
-    this.pos = t, this.path = e, this.parentOffset = n, this.depth = e.length / 3 - 1;
+  constructor(pos, path, parentOffset) {
+    this.pos = pos;
+    this.path = path;
+    this.parentOffset = parentOffset;
+    this.depth = path.length / 3 - 1;
   }
   /**
   @internal
   */
-  resolveDepth(t) {
-    return t == null ? this.depth : t < 0 ? this.depth + t : t;
+  resolveDepth(val) {
+    if (val == null)
+      return this.depth;
+    if (val < 0)
+      return this.depth + val;
+    return val;
   }
   /**
   The parent node that the position points into. Note that even if
@@ -632,56 +741,61 @@ class S {
   The ancestor node at the given level. `p.node(p.depth)` is the
   same as `p.parent`.
   */
-  node(t) {
-    return this.path[this.resolveDepth(t) * 3];
+  node(depth) {
+    return this.path[this.resolveDepth(depth) * 3];
   }
   /**
   The index into the ancestor at the given level. If this points
   at the 3rd node in the 2nd paragraph on the top level, for
   example, `p.index(0)` is 1 and `p.index(1)` is 2.
   */
-  index(t) {
-    return this.path[this.resolveDepth(t) * 3 + 1];
+  index(depth) {
+    return this.path[this.resolveDepth(depth) * 3 + 1];
   }
   /**
   The index pointing after this position into the ancestor at the
   given level.
   */
-  indexAfter(t) {
-    return t = this.resolveDepth(t), this.index(t) + (t == this.depth && !this.textOffset ? 0 : 1);
+  indexAfter(depth) {
+    depth = this.resolveDepth(depth);
+    return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1);
   }
   /**
   The (absolute) position at the start of the node at the given
   level.
   */
-  start(t) {
-    return t = this.resolveDepth(t), t == 0 ? 0 : this.path[t * 3 - 1] + 1;
+  start(depth) {
+    depth = this.resolveDepth(depth);
+    return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
   }
   /**
   The (absolute) position at the end of the node at the given
   level.
   */
-  end(t) {
-    return t = this.resolveDepth(t), this.start(t) + this.node(t).content.size;
+  end(depth) {
+    depth = this.resolveDepth(depth);
+    return this.start(depth) + this.node(depth).content.size;
   }
   /**
   The (absolute) position directly before the wrapping node at the
   given level, or, when `depth` is `this.depth + 1`, the original
   position.
   */
-  before(t) {
-    if (t = this.resolveDepth(t), !t)
+  before(depth) {
+    depth = this.resolveDepth(depth);
+    if (!depth)
       throw new RangeError("There is no position before the top-level node");
-    return t == this.depth + 1 ? this.pos : this.path[t * 3 - 1];
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
   }
   /**
   The (absolute) position directly after the wrapping node at the
   given level, or the original position when `depth` is `this.depth + 1`.
   */
-  after(t) {
-    if (t = this.resolveDepth(t), !t)
+  after(depth) {
+    depth = this.resolveDepth(depth);
+    if (!depth)
       throw new RangeError("There is no position after the top-level node");
-    return t == this.depth + 1 ? this.pos : this.path[t * 3 - 1] + this.path[t * 3].nodeSize;
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
   }
   /**
   When this position points into a text node, this returns the
@@ -697,11 +811,11 @@ class S {
   position is returned.
   */
   get nodeAfter() {
-    let t = this.parent, e = this.index(this.depth);
-    if (e == t.childCount)
+    let parent = this.parent, index = this.index(this.depth);
+    if (index == parent.childCount)
       return null;
-    let n = this.pos - this.path[this.path.length - 1], i = t.child(e);
-    return n ? t.child(e).cut(n) : i;
+    let dOff = this.pos - this.path[this.path.length - 1], child = parent.child(index);
+    return dOff ? parent.child(index).cut(dOff) : child;
   }
   /**
   Get the node directly before the position, if any. If the
@@ -709,19 +823,22 @@ class S {
   before the position is returned.
   */
   get nodeBefore() {
-    let t = this.index(this.depth), e = this.pos - this.path[this.path.length - 1];
-    return e ? this.parent.child(t).cut(0, e) : t == 0 ? null : this.parent.child(t - 1);
+    let index = this.index(this.depth);
+    let dOff = this.pos - this.path[this.path.length - 1];
+    if (dOff)
+      return this.parent.child(index).cut(0, dOff);
+    return index == 0 ? null : this.parent.child(index - 1);
   }
   /**
   Get the position at the given index in the parent node at the
   given depth (which defaults to `this.depth`).
   */
-  posAtIndex(t, e) {
-    e = this.resolveDepth(e);
-    let n = this.path[e * 3], i = e == 0 ? 0 : this.path[e * 3 - 1] + 1;
-    for (let r = 0; r < t; r++)
-      i += n.child(r).nodeSize;
-    return i;
+  posAtIndex(index, depth) {
+    depth = this.resolveDepth(depth);
+    let node = this.path[depth * 3], pos = depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
+    for (let i = 0; i < index; i++)
+      pos += node.child(i).nodeSize;
+    return pos;
   }
   /**
   Get the marks at this position, factoring in the surrounding
@@ -730,20 +847,22 @@ class S {
   node after it (if any) are returned.
   */
   marks() {
-    let t = this.parent, e = this.index();
-    if (t.content.size == 0)
-      return u.none;
+    let parent = this.parent, index = this.index();
+    if (parent.content.size == 0)
+      return Mark.none;
     if (this.textOffset)
-      return t.child(e).marks;
-    let n = t.maybeChild(e - 1), i = t.maybeChild(e);
-    if (!n) {
-      let o = n;
-      n = i, i = o;
+      return parent.child(index).marks;
+    let main = parent.maybeChild(index - 1), other = parent.maybeChild(index);
+    if (!main) {
+      let tmp = main;
+      main = other;
+      other = tmp;
     }
-    let r = n.marks;
-    for (var s = 0; s < r.length; s++)
-      r[s].type.spec.inclusive === !1 && (!i || !r[s].isInSet(i.marks)) && (r = r[s--].removeFromSet(r));
-    return r;
+    let marks = main.marks;
+    for (var i = 0; i < marks.length; i++)
+      if (marks[i].type.spec.inclusive === false && (!other || !marks[i].isInSet(other.marks)))
+        marks = marks[i--].removeFromSet(marks);
+    return marks;
   }
   /**
   Get the marks after the current position, if any, except those
@@ -753,23 +872,24 @@ class S {
   its parent node or its parent node isn't a textblock (in which
   case no marks should be preserved).
   */
-  marksAcross(t) {
-    let e = this.parent.maybeChild(this.index());
-    if (!e || !e.isInline)
+  marksAcross($end) {
+    let after = this.parent.maybeChild(this.index());
+    if (!after || !after.isInline)
       return null;
-    let n = e.marks, i = t.parent.maybeChild(t.index());
-    for (var r = 0; r < n.length; r++)
-      n[r].type.spec.inclusive === !1 && (!i || !n[r].isInSet(i.marks)) && (n = n[r--].removeFromSet(n));
-    return n;
+    let marks = after.marks, next = $end.parent.maybeChild($end.index());
+    for (var i = 0; i < marks.length; i++)
+      if (marks[i].type.spec.inclusive === false && (!next || !marks[i].isInSet(next.marks)))
+        marks = marks[i--].removeFromSet(marks);
+    return marks;
   }
   /**
   The depth up to which this position and the given (non-resolved)
   position share the same parent nodes.
   */
-  sharedDepth(t) {
-    for (let e = this.depth; e > 0; e--)
-      if (this.start(e) <= t && this.end(e) >= t)
-        return e;
+  sharedDepth(pos) {
+    for (let depth = this.depth; depth > 0; depth--)
+      if (this.start(depth) <= pos && this.end(depth) >= pos)
+        return depth;
     return 0;
   }
   /**
@@ -781,87 +901,99 @@ class S {
   pass in an optional predicate that will be called with a parent
   node to see if a range into that parent is acceptable.
   */
-  blockRange(t = this, e) {
-    if (t.pos < this.pos)
-      return t.blockRange(this);
-    for (let n = this.depth - (this.parent.inlineContent || this.pos == t.pos ? 1 : 0); n >= 0; n--)
-      if (t.pos <= this.end(n) && (!e || e(this.node(n))))
-        return new mt(this, t, n);
+  blockRange(other = this, pred) {
+    if (other.pos < this.pos)
+      return other.blockRange(this);
+    for (let d = this.depth - (this.parent.inlineContent || this.pos == other.pos ? 1 : 0); d >= 0; d--)
+      if (other.pos <= this.end(d) && (!pred || pred(this.node(d))))
+        return new NodeRange(this, other, d);
     return null;
   }
   /**
   Query whether the given position shares the same parent node.
   */
-  sameParent(t) {
-    return this.pos - this.parentOffset == t.pos - t.parentOffset;
+  sameParent(other) {
+    return this.pos - this.parentOffset == other.pos - other.parentOffset;
   }
   /**
   Return the greater of this and the given position.
   */
-  max(t) {
-    return t.pos > this.pos ? t : this;
+  max(other) {
+    return other.pos > this.pos ? other : this;
   }
   /**
   Return the smaller of this and the given position.
   */
-  min(t) {
-    return t.pos < this.pos ? t : this;
+  min(other) {
+    return other.pos < this.pos ? other : this;
   }
   /**
   @internal
   */
   toString() {
-    let t = "";
-    for (let e = 1; e <= this.depth; e++)
-      t += (t ? "/" : "") + this.node(e).type.name + "_" + this.index(e - 1);
-    return t + ":" + this.parentOffset;
+    let str = "";
+    for (let i = 1; i <= this.depth; i++)
+      str += (str ? "/" : "") + this.node(i).type.name + "_" + this.index(i - 1);
+    return str + ":" + this.parentOffset;
   }
   /**
   @internal
   */
-  static resolve(t, e) {
-    if (!(e >= 0 && e <= t.content.size))
-      throw new RangeError("Position " + e + " out of range");
-    let n = [], i = 0, r = e;
-    for (let s = t; ; ) {
-      let { index: o, offset: h } = s.content.findIndex(r), a = r - h;
-      if (n.push(s, o, i + h), !a || (s = s.child(o), s.isText))
+  static resolve(doc2, pos) {
+    if (!(pos >= 0 && pos <= doc2.content.size))
+      throw new RangeError("Position " + pos + " out of range");
+    let path = [];
+    let start = 0, parentOffset = pos;
+    for (let node = doc2; ; ) {
+      let { index, offset } = node.content.findIndex(parentOffset);
+      let rem = parentOffset - offset;
+      path.push(node, index, start + offset);
+      if (!rem)
         break;
-      r = a - 1, i += h + 1;
+      node = node.child(index);
+      if (node.isText)
+        break;
+      parentOffset = rem - 1;
+      start += offset + 1;
     }
-    return new S(e, n, r);
+    return new ResolvedPos(pos, path, parentOffset);
   }
   /**
   @internal
   */
-  static resolveCached(t, e) {
-    let n = L.get(t);
-    if (n)
-      for (let r = 0; r < n.elts.length; r++) {
-        let s = n.elts[r];
-        if (s.pos == e)
-          return s;
+  static resolveCached(doc2, pos) {
+    let cache = resolveCache.get(doc2);
+    if (cache) {
+      for (let i = 0; i < cache.elts.length; i++) {
+        let elt = cache.elts[i];
+        if (elt.pos == pos)
+          return elt;
       }
-    else
-      L.set(t, n = new yt());
-    let i = n.elts[n.i] = S.resolve(t, e);
-    return n.i = (n.i + 1) % xt, i;
+    } else {
+      resolveCache.set(doc2, cache = new ResolveCache());
+    }
+    let result = cache.elts[cache.i] = ResolvedPos.resolve(doc2, pos);
+    cache.i = (cache.i + 1) % resolveCacheSize;
+    return result;
   }
 }
-class yt {
+class ResolveCache {
   constructor() {
-    this.elts = [], this.i = 0;
+    this.elts = [];
+    this.i = 0;
   }
 }
-const xt = 12, L = /* @__PURE__ */ new WeakMap();
-class mt {
+const resolveCacheSize = 12, resolveCache = /* @__PURE__ */ new WeakMap();
+class NodeRange {
   /**
   Construct a node range. `$from` and `$to` should point into the
   same node until at least the given `depth`, since a node range
   denotes an adjacent set of nodes in a single parent node.
   */
-  constructor(t, e, n) {
-    this.$from = t, this.$to = e, this.depth = n;
+  constructor($from, $to, depth) {
+    this.$from = $from;
+    this.$to = $to;
+    this.depth = depth;
   }
   /**
   The position at the start of the range.
@@ -894,13 +1026,16 @@ class mt {
     return this.$to.indexAfter(this.depth);
   }
 }
-const wt = /* @__PURE__ */ Object.create(null);
-class y {
+const emptyAttrs = /* @__PURE__ */ Object.create(null);
+class Node {
   /**
   @internal
   */
-  constructor(t, e, n, i = u.none) {
-    this.type = t, this.attrs = e, this.marks = i, this.content = n || c.empty;
+  constructor(type, attrs, content, marks = Mark.none) {
+    this.type = type;
+    this.attrs = attrs;
+    this.marks = marks;
+    this.content = content || Fragment.empty;
   }
   /**
   The array of this node's child nodes.
@@ -928,21 +1063,21 @@ class y {
   Get the child node at the given index. Raises an error when the
   index is out of range.
   */
-  child(t) {
-    return this.content.child(t);
+  child(index) {
+    return this.content.child(index);
   }
   /**
   Get the child node at the given index, if it exists.
   */
-  maybeChild(t) {
-    return this.content.maybeChild(t);
+  maybeChild(index) {
+    return this.content.maybeChild(index);
   }
   /**
   Call `f` for every child node, passing the node, its offset
   into this parent node, and its index.
   */
-  forEach(t) {
-    this.content.forEach(t);
+  forEach(f) {
+    this.content.forEach(f);
   }
   /**
   Invoke a callback for all descendant nodes recursively between
@@ -954,15 +1089,15 @@ class y {
   recursed over. The last parameter can be used to specify a
   starting position to count from.
   */
-  nodesBetween(t, e, n, i = 0) {
-    this.content.nodesBetween(t, e, n, i, this);
+  nodesBetween(from, to, f, startPos = 0) {
+    this.content.nodesBetween(from, to, f, startPos, this);
   }
   /**
   Call the given callback for every descendant node. Doesn't
   descend into a node when the callback returns `false`.
   */
-  descendants(t) {
-    this.nodesBetween(0, this.content.size, t);
+  descendants(f) {
+    this.nodesBetween(0, this.content.size, f);
   }
   /**
   Concatenates all the text nodes found in this fragment and its
@@ -978,8 +1113,8 @@ class y {
   inserted for every non-text leaf node encountered, otherwise
   [`leafText`](https://prosemirror.net/docs/ref/#model.NodeSpec^leafText) will be used.
   */
-  textBetween(t, e, n, i) {
-    return this.content.textBetween(t, e, n, i);
+  textBetween(from, to, blockSeparator, leafText) {
+    return this.content.textBetween(from, to, blockSeparator, leafText);
   }
   /**
   Returns this node's first child, or `null` if there are no
@@ -998,54 +1133,61 @@ class y {
   /**
   Test whether two nodes represent the same piece of document.
   */
-  eq(t) {
-    return this == t || this.sameMarkup(t) && this.content.eq(t.content);
+  eq(other) {
+    return this == other || this.sameMarkup(other) && this.content.eq(other.content);
   }
   /**
   Compare the markup (type, attributes, and marks) of this node to
   those of another. Returns `true` if both have the same markup.
   */
-  sameMarkup(t) {
-    return this.hasMarkup(t.type, t.attrs, t.marks);
+  sameMarkup(other) {
+    return this.hasMarkup(other.type, other.attrs, other.marks);
   }
   /**
   Check whether this node's markup correspond to the given type,
   attributes, and marks.
   */
-  hasMarkup(t, e, n) {
-    return this.type == t && M(this.attrs, e || t.defaultAttrs || wt) && u.sameSet(this.marks, n || u.none);
+  hasMarkup(type, attrs, marks) {
+    return this.type == type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks || Mark.none);
   }
   /**
   Create a new node with the same markup as this node, containing
   the given content (or empty, if no content is given).
   */
-  copy(t = null) {
-    return t == this.content ? this : new y(this.type, this.attrs, t, this.marks);
+  copy(content = null) {
+    if (content == this.content)
+      return this;
+    return new Node(this.type, this.attrs, content, this.marks);
   }
   /**
   Create a copy of this node, with the given set of marks instead
   of the node's own marks.
   */
-  mark(t) {
-    return t == this.marks ? this : new y(this.type, this.attrs, this.content, t);
+  mark(marks) {
+    return marks == this.marks ? this : new Node(this.type, this.attrs, this.content, marks);
   }
   /**
   Create a copy of this node with only the content between the
   given positions. If `to` is not given, it defaults to the end of
   the node.
   */
-  cut(t, e = this.content.size) {
-    return t == 0 && e == this.content.size ? this : this.copy(this.content.cut(t, e));
+  cut(from, to = this.content.size) {
+    if (from == 0 && to == this.content.size)
+      return this;
+    return this.copy(this.content.cut(from, to));
   }
   /**
   Cut out the part of the document between the given positions, and
   return it as a `Slice` object.
   */
-  slice(t, e = this.content.size, n = !1) {
-    if (t == e)
-      return d.empty;
-    let i = this.resolve(t), r = this.resolve(e), s = n ? 0 : i.sharedDepth(e), o = i.start(s), a = i.node(s).content.cut(i.pos - o, r.pos - o);
-    return new d(a, i.depth - s, r.depth - s);
+  slice(from, to = this.content.size, includeParents = false) {
+    if (from == to)
+      return Slice.empty;
+    let $from = this.resolve(from), $to = this.resolve(to);
+    let depth = includeParents ? 0 : $from.sharedDepth(to);
+    let start = $from.start(depth), node = $from.node(depth);
+    let content = node.content.cut($from.pos - start, $to.pos - start);
+    return new Slice(content, $from.depth - depth, $to.depth - depth);
   }
   /**
   Replace the part of the document between the given positions with
@@ -1055,20 +1197,21 @@ class y {
   into. If any of this is violated, an error of type
   [`ReplaceError`](https://prosemirror.net/docs/ref/#model.ReplaceError) is thrown.
   */
-  replace(t, e, n) {
-    return dt(this.resolve(t), this.resolve(e), n);
+  replace(from, to, slice) {
+    return replace(this.resolve(from), this.resolve(to), slice);
   }
   /**
   Find the node directly after the given position.
   */
-  nodeAt(t) {
-    for (let e = this; ; ) {
-      let { index: n, offset: i } = e.content.findIndex(t);
-      if (e = e.maybeChild(n), !e)
+  nodeAt(pos) {
+    for (let node = this; ; ) {
+      let { index, offset } = node.content.findIndex(pos);
+      node = node.maybeChild(index);
+      if (!node)
         return null;
-      if (i == t || e.isText)
-        return e;
-      t -= i + 1;
+      if (offset == pos || node.isText)
+        return node;
+      pos -= offset + 1;
     }
   }
   /**
@@ -1076,44 +1219,50 @@ class y {
   and return it along with its index and offset relative to this
   node.
   */
-  childAfter(t) {
-    let { index: e, offset: n } = this.content.findIndex(t);
-    return { node: this.content.maybeChild(e), index: e, offset: n };
+  childAfter(pos) {
+    let { index, offset } = this.content.findIndex(pos);
+    return { node: this.content.maybeChild(index), index, offset };
   }
   /**
   Find the (direct) child node before the given offset, if any,
   and return it along with its index and offset relative to this
   node.
   */
-  childBefore(t) {
-    if (t == 0)
+  childBefore(pos) {
+    if (pos == 0)
       return { node: null, index: 0, offset: 0 };
-    let { index: e, offset: n } = this.content.findIndex(t);
-    if (n < t)
-      return { node: this.content.child(e), index: e, offset: n };
-    let i = this.content.child(e - 1);
-    return { node: i, index: e - 1, offset: n - i.nodeSize };
+    let { index, offset } = this.content.findIndex(pos);
+    if (offset < pos)
+      return { node: this.content.child(index), index, offset };
+    let node = this.content.child(index - 1);
+    return { node, index: index - 1, offset: offset - node.nodeSize };
   }
   /**
   Resolve the given position in the document, returning an
   [object](https://prosemirror.net/docs/ref/#model.ResolvedPos) with information about its context.
   */
-  resolve(t) {
-    return S.resolveCached(this, t);
+  resolve(pos) {
+    return ResolvedPos.resolveCached(this, pos);
   }
   /**
   @internal
   */
-  resolveNoCache(t) {
-    return S.resolve(this, t);
+  resolveNoCache(pos) {
+    return ResolvedPos.resolve(this, pos);
   }
   /**
   Test whether a given mark or mark type occurs in this document
   between the two given positions.
   */
-  rangeHasMark(t, e, n) {
-    let i = !1;
-    return e > t && this.nodesBetween(t, e, (r) => (n.isInSet(r.marks) && (i = !0), !i)), i;
+  rangeHasMark(from, to, type) {
+    let found2 = false;
+    if (to > from)
+      this.nodesBetween(from, to, (node) => {
+        if (type.isInSet(node.marks))
+          found2 = true;
+        return !found2;
+      });
+    return found2;
   }
   /**
   True when this is a block (non-inline node)
@@ -1170,17 +1319,19 @@ class y {
   toString() {
     if (this.type.spec.toDebugString)
       return this.type.spec.toDebugString(this);
-    let t = this.type.name;
-    return this.content.size && (t += "(" + this.content.toStringInner() + ")"), it(this.marks, t);
+    let name = this.type.name;
+    if (this.content.size)
+      name += "(" + this.content.toStringInner() + ")";
+    return wrapMarks(this.marks, name);
   }
   /**
   Get the content match in this node at the given index.
   */
-  contentMatchAt(t) {
-    let e = this.type.contentMatch.matchFragment(this.content, 0, t);
-    if (!e)
+  contentMatchAt(index) {
+    let match = this.type.contentMatch.matchFragment(this.content, 0, index);
+    if (!match)
       throw new Error("Called contentMatchAt on a node with invalid content");
-    return e;
+    return match;
   }
   /**
   Test whether replacing the range between `from` and `to` (by
@@ -1189,24 +1340,26 @@ class y {
   can optionally pass `start` and `end` indices into the
   replacement fragment.
   */
-  canReplace(t, e, n = c.empty, i = 0, r = n.childCount) {
-    let s = this.contentMatchAt(t).matchFragment(n, i, r), o = s && s.matchFragment(this.content, e);
-    if (!o || !o.validEnd)
-      return !1;
-    for (let h = i; h < r; h++)
-      if (!this.type.allowsMarks(n.child(h).marks))
-        return !1;
-    return !0;
+  canReplace(from, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
+    let one = this.contentMatchAt(from).matchFragment(replacement, start, end);
+    let two = one && one.matchFragment(this.content, to);
+    if (!two || !two.validEnd)
+      return false;
+    for (let i = start; i < end; i++)
+      if (!this.type.allowsMarks(replacement.child(i).marks))
+        return false;
+    return true;
   }
   /**
   Test whether replacing the range `from` to `to` (by index) with
   a node of the given type would leave the node's content valid.
   */
-  canReplaceWith(t, e, n, i) {
-    if (i && !this.type.allowsMarks(i))
-      return !1;
-    let r = this.contentMatchAt(t).matchType(n), s = r && r.matchFragment(this.content, e);
-    return s ? s.validEnd : !1;
+  canReplaceWith(from, to, type, marks) {
+    if (marks && !this.type.allowsMarks(marks))
+      return false;
+    let start = this.contentMatchAt(from).matchType(type);
+    let end = start && start.matchFragment(this.content, to);
+    return end ? end.validEnd : false;
   }
   /**
   Test whether the given node's content could be appended to this
@@ -1214,138 +1367,161 @@ class y {
   is at least one node type that can appear in both nodes (to avoid
   merging completely incompatible nodes).
   */
-  canAppend(t) {
-    return t.content.size ? this.canReplace(this.childCount, this.childCount, t.content) : this.type.compatibleContent(t.type);
+  canAppend(other) {
+    if (other.content.size)
+      return this.canReplace(this.childCount, this.childCount, other.content);
+    else
+      return this.type.compatibleContent(other.type);
   }
   /**
   Check whether this node and its descendants conform to the
   schema, and raise an exception when they do not.
   */
   check() {
-    this.type.checkContent(this.content), this.type.checkAttrs(this.attrs);
-    let t = u.none;
-    for (let e = 0; e < this.marks.length; e++) {
-      let n = this.marks[e];
-      n.type.checkAttrs(n.attrs), t = n.addToSet(t);
+    this.type.checkContent(this.content);
+    this.type.checkAttrs(this.attrs);
+    let copy2 = Mark.none;
+    for (let i = 0; i < this.marks.length; i++) {
+      let mark = this.marks[i];
+      mark.type.checkAttrs(mark.attrs);
+      copy2 = mark.addToSet(copy2);
     }
-    if (!u.sameSet(t, this.marks))
-      throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((e) => e.type.name)}`);
-    this.content.forEach((e) => e.check());
+    if (!Mark.sameSet(copy2, this.marks))
+      throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((m) => m.type.name)}`);
+    this.content.forEach((node) => node.check());
   }
   /**
   Return a JSON-serializeable representation of this node.
   */
   toJSON() {
-    let t = { type: this.type.name };
-    for (let e in this.attrs) {
-      t.attrs = this.attrs;
+    let obj = { type: this.type.name };
+    for (let _ in this.attrs) {
+      obj.attrs = this.attrs;
       break;
     }
-    return this.content.size && (t.content = this.content.toJSON()), this.marks.length && (t.marks = this.marks.map((e) => e.toJSON())), t;
+    if (this.content.size)
+      obj.content = this.content.toJSON();
+    if (this.marks.length)
+      obj.marks = this.marks.map((n) => n.toJSON());
+    return obj;
   }
   /**
   Deserialize a node from its JSON representation.
   */
-  static fromJSON(t, e) {
-    if (!e)
+  static fromJSON(schema, json) {
+    if (!json)
       throw new RangeError("Invalid input for Node.fromJSON");
-    let n;
-    if (e.marks) {
-      if (!Array.isArray(e.marks))
+    let marks = void 0;
+    if (json.marks) {
+      if (!Array.isArray(json.marks))
         throw new RangeError("Invalid mark data for Node.fromJSON");
-      n = e.marks.map(t.markFromJSON);
+      marks = json.marks.map(schema.markFromJSON);
     }
-    if (e.type == "text") {
-      if (typeof e.text != "string")
+    if (json.type == "text") {
+      if (typeof json.text != "string")
         throw new RangeError("Invalid text node in JSON");
-      return t.text(e.text, n);
+      return schema.text(json.text, marks);
     }
-    let i = c.fromJSON(t, e.content), r = t.nodeType(e.type).create(e.attrs, i, n);
-    return r.type.checkAttrs(r.attrs), r;
+    let content = Fragment.fromJSON(schema, json.content);
+    let node = schema.nodeType(json.type).create(json.attrs, content, marks);
+    node.type.checkAttrs(node.attrs);
+    return node;
   }
 }
-y.prototype.text = void 0;
-class N extends y {
+Node.prototype.text = void 0;
+class TextNode extends Node {
   /**
   @internal
   */
-  constructor(t, e, n, i) {
-    if (super(t, e, null, i), !n)
+  constructor(type, attrs, content, marks) {
+    super(type, attrs, null, marks);
+    if (!content)
       throw new RangeError("Empty text nodes are not allowed");
-    this.text = n;
+    this.text = content;
   }
   toString() {
-    return this.type.spec.toDebugString ? this.type.spec.toDebugString(this) : it(this.marks, JSON.stringify(this.text));
+    if (this.type.spec.toDebugString)
+      return this.type.spec.toDebugString(this);
+    return wrapMarks(this.marks, JSON.stringify(this.text));
   }
   get textContent() {
     return this.text;
   }
-  textBetween(t, e) {
-    return this.text.slice(t, e);
+  textBetween(from, to) {
+    return this.text.slice(from, to);
   }
   get nodeSize() {
     return this.text.length;
   }
-  mark(t) {
-    return t == this.marks ? this : new N(this.type, this.attrs, this.text, t);
+  mark(marks) {
+    return marks == this.marks ? this : new TextNode(this.type, this.attrs, this.text, marks);
   }
-  withText(t) {
-    return t == this.text ? this : new N(this.type, this.attrs, t, this.marks);
+  withText(text) {
+    if (text == this.text)
+      return this;
+    return new TextNode(this.type, this.attrs, text, this.marks);
   }
-  cut(t = 0, e = this.text.length) {
-    return t == 0 && e == this.text.length ? this : this.withText(this.text.slice(t, e));
+  cut(from = 0, to = this.text.length) {
+    if (from == 0 && to == this.text.length)
+      return this;
+    return this.withText(this.text.slice(from, to));
   }
-  eq(t) {
-    return this.sameMarkup(t) && this.text == t.text;
+  eq(other) {
+    return this.sameMarkup(other) && this.text == other.text;
   }
   toJSON() {
-    let t = super.toJSON();
-    return t.text = this.text, t;
+    let base = super.toJSON();
+    base.text = this.text;
+    return base;
   }
 }
-function it(l, t) {
-  for (let e = l.length - 1; e >= 0; e--)
-    t = l[e].type.name + "(" + t + ")";
-  return t;
+function wrapMarks(marks, str) {
+  for (let i = marks.length - 1; i >= 0; i--)
+    str = marks[i].type.name + "(" + str + ")";
+  return str;
 }
-class w {
+class ContentMatch {
   /**
   @internal
   */
-  constructor(t) {
-    this.validEnd = t, this.next = [], this.wrapCache = [];
+  constructor(validEnd) {
+    this.validEnd = validEnd;
+    this.next = [];
+    this.wrapCache = [];
   }
   /**
   @internal
   */
-  static parse(t, e) {
-    let n = new kt(t, e);
-    if (n.next == null)
-      return w.empty;
-    let i = rt(n);
-    n.next && n.err("Unexpected trailing text");
-    let r = Mt(Tt(i));
-    return At(r, n), r;
+  static parse(string, nodeTypes) {
+    let stream = new TokenStream(string, nodeTypes);
+    if (stream.next == null)
+      return ContentMatch.empty;
+    let expr = parseExpr(stream);
+    if (stream.next)
+      stream.err("Unexpected trailing text");
+    let match = dfa(nfa(expr));
+    checkForDeadEnds(match, stream);
+    return match;
   }
   /**
   Match a node type, returning a match after that node if
   successful.
   */
-  matchType(t) {
-    for (let e = 0; e < this.next.length; e++)
-      if (this.next[e].type == t)
-        return this.next[e].next;
+  matchType(type) {
+    for (let i = 0; i < this.next.length; i++)
+      if (this.next[i].type == type)
+        return this.next[i].next;
     return null;
   }
   /**
   Try to match a fragment. Returns the resulting match when
   successful.
   */
-  matchFragment(t, e = 0, n = t.childCount) {
-    let i = this;
-    for (let r = e; i && r < n; r++)
-      i = i.matchType(t.child(r).type);
-    return i;
+  matchFragment(frag, start = 0, end = frag.childCount) {
+    let cur = this;
+    for (let i = start; cur && i < end; i++)
+      cur = cur.matchType(frag.child(i).type);
+    return cur;
   }
   /**
   @internal
@@ -1358,22 +1534,22 @@ class w {
   be generated.
   */
   get defaultType() {
-    for (let t = 0; t < this.next.length; t++) {
-      let { type: e } = this.next[t];
-      if (!(e.isText || e.hasRequiredAttrs()))
-        return e;
+    for (let i = 0; i < this.next.length; i++) {
+      let { type } = this.next[i];
+      if (!(type.isText || type.hasRequiredAttrs()))
+        return type;
     }
     return null;
   }
   /**
   @internal
   */
-  compatible(t) {
-    for (let e = 0; e < this.next.length; e++)
-      for (let n = 0; n < t.next.length; n++)
-        if (this.next[e].type == t.next[n].type)
-          return !0;
-    return !1;
+  compatible(other) {
+    for (let i = 0; i < this.next.length; i++)
+      for (let j = 0; j < other.next.length; j++)
+        if (this.next[i].type == other.next[j].type)
+          return true;
+    return false;
   }
   /**
   Try to match the given fragment, and if that fails, see if it can
@@ -1383,24 +1559,24 @@ class w {
   return a fragment if the resulting match goes to the end of the
   content expression.
   */
-  fillBefore(t, e = !1, n = 0) {
-    let i = [this];
-    function r(s, o) {
-      let h = s.matchFragment(t, n);
-      if (h && (!e || h.validEnd))
-        return c.from(o.map((a) => a.createAndFill()));
-      for (let a = 0; a < s.next.length; a++) {
-        let { type: f, next: p } = s.next[a];
-        if (!(f.isText || f.hasRequiredAttrs()) && i.indexOf(p) == -1) {
-          i.push(p);
-          let g = r(p, o.concat(f));
-          if (g)
-            return g;
+  fillBefore(after, toEnd = false, startIndex = 0) {
+    let seen = [this];
+    function search(match, types) {
+      let finished = match.matchFragment(after, startIndex);
+      if (finished && (!toEnd || finished.validEnd))
+        return Fragment.from(types.map((tp) => tp.createAndFill()));
+      for (let i = 0; i < match.next.length; i++) {
+        let { type, next } = match.next[i];
+        if (!(type.isText || type.hasRequiredAttrs()) && seen.indexOf(next) == -1) {
+          seen.push(next);
+          let found2 = search(next, types.concat(type));
+          if (found2)
+            return found2;
         }
       }
       return null;
     }
-    return r(this, []);
+    return search(this, []);
   }
   /**
   Find a set of wrapping node types that would allow a node of the
@@ -1408,29 +1584,33 @@ class w {
   (when it fits directly) and will be null when no such wrapping
   exists.
   */
-  findWrapping(t) {
-    for (let n = 0; n < this.wrapCache.length; n += 2)
-      if (this.wrapCache[n] == t)
-        return this.wrapCache[n + 1];
-    let e = this.computeWrapping(t);
-    return this.wrapCache.push(t, e), e;
+  findWrapping(target) {
+    for (let i = 0; i < this.wrapCache.length; i += 2)
+      if (this.wrapCache[i] == target)
+        return this.wrapCache[i + 1];
+    let computed = this.computeWrapping(target);
+    this.wrapCache.push(target, computed);
+    return computed;
   }
   /**
   @internal
   */
-  computeWrapping(t) {
-    let e = /* @__PURE__ */ Object.create(null), n = [{ match: this, type: null, via: null }];
-    for (; n.length; ) {
-      let i = n.shift(), r = i.match;
-      if (r.matchType(t)) {
-        let s = [];
-        for (let o = i; o.type; o = o.via)
-          s.push(o.type);
-        return s.reverse();
+  computeWrapping(target) {
+    let seen = /* @__PURE__ */ Object.create(null), active = [{ match: this, type: null, via: null }];
+    while (active.length) {
+      let current = active.shift(), match = current.match;
+      if (match.matchType(target)) {
+        let result = [];
+        for (let obj = current; obj.type; obj = obj.via)
+          result.push(obj.type);
+        return result.reverse();
       }
-      for (let s = 0; s < r.next.length; s++) {
-        let { type: o, next: h } = r.next[s];
-        !o.isLeaf && !o.hasRequiredAttrs() && !(o.name in e) && (!i.type || h.validEnd) && (n.push({ match: o.contentMatch, type: o, via: i }), e[o.name] = !0);
+      for (let i = 0; i < match.next.length; i++) {
+        let { type, next } = match.next[i];
+        if (!type.isLeaf && !type.hasRequiredAttrs() && !(type.name in seen) && (!current.type || next.validEnd)) {
+          active.push({ match: type.contentMatch, type, via: current });
+          seen[type.name] = true;
+        }
       }
     }
     return null;
@@ -1446,258 +1626,320 @@ class w {
   Get the _n_​th outgoing edge from this node in the finite
   automaton that describes the content expression.
   */
-  edge(t) {
-    if (t >= this.next.length)
-      throw new RangeError(`There's no ${t}th edge in this content match`);
-    return this.next[t];
+  edge(n) {
+    if (n >= this.next.length)
+      throw new RangeError(`There's no ${n}th edge in this content match`);
+    return this.next[n];
   }
   /**
   @internal
   */
   toString() {
-    let t = [];
-    function e(n) {
-      t.push(n);
-      for (let i = 0; i < n.next.length; i++)
-        t.indexOf(n.next[i].next) == -1 && e(n.next[i].next);
+    let seen = [];
+    function scan(m) {
+      seen.push(m);
+      for (let i = 0; i < m.next.length; i++)
+        if (seen.indexOf(m.next[i].next) == -1)
+          scan(m.next[i].next);
     }
-    return e(this), t.map((n, i) => {
-      let r = i + (n.validEnd ? "*" : " ") + " ";
-      for (let s = 0; s < n.next.length; s++)
-        r += (s ? ", " : "") + n.next[s].type.name + "->" + t.indexOf(n.next[s].next);
-      return r;
-    }).join(`
-`);
-  }
-}
-w.empty = new w(!0);
-class kt {
-  constructor(t, e) {
-    this.string = t, this.nodeTypes = e, this.inline = null, this.pos = 0, this.tokens = t.split(/\s*(?=\b|\W|$)/), this.tokens[this.tokens.length - 1] == "" && this.tokens.pop(), this.tokens[0] == "" && this.tokens.shift();
+    scan(this);
+    return seen.map((m, i) => {
+      let out = i + (m.validEnd ? "*" : " ") + " ";
+      for (let i2 = 0; i2 < m.next.length; i2++)
+        out += (i2 ? ", " : "") + m.next[i2].type.name + "->" + seen.indexOf(m.next[i2].next);
+      return out;
+    }).join("\n");
+  }
+}
+ContentMatch.empty = new ContentMatch(true);
+class TokenStream {
+  constructor(string, nodeTypes) {
+    this.string = string;
+    this.nodeTypes = nodeTypes;
+    this.inline = null;
+    this.pos = 0;
+    this.tokens = string.split(/\s*(?=\b|\W|$)/);
+    if (this.tokens[this.tokens.length - 1] == "")
+      this.tokens.pop();
+    if (this.tokens[0] == "")
+      this.tokens.shift();
   }
   get next() {
     return this.tokens[this.pos];
   }
-  eat(t) {
-    return this.next == t && (this.pos++ || !0);
-  }
-  err(t) {
-    throw new SyntaxError(t + " (in content expression '" + this.string + "')");
-  }
-}
-function rt(l) {
-  let t = [];
-  do
-    t.push(St(l));
-  while (l.eat("|"));
-  return t.length == 1 ? t[0] : { type: "choice", exprs: t };
-}
-function St(l) {
-  let t = [];
-  do
-    t.push(Et(l));
-  while (l.next && l.next != ")" && l.next != "|");
-  return t.length == 1 ? t[0] : { type: "seq", exprs: t };
-}
-function Et(l) {
-  let t = bt(l);
-  for (; ; )
-    if (l.eat("+"))
-      t = { type: "plus", expr: t };
-    else if (l.eat("*"))
-      t = { type: "star", expr: t };
-    else if (l.eat("?"))
-      t = { type: "opt", expr: t };
-    else if (l.eat("{"))
-      t = Ot(l, t);
+  eat(tok) {
+    return this.next == tok && (this.pos++ || true);
+  }
+  err(str) {
+    throw new SyntaxError(str + " (in content expression '" + this.string + "')");
+  }
+}
+function parseExpr(stream) {
+  let exprs = [];
+  do {
+    exprs.push(parseExprSeq(stream));
+  } while (stream.eat("|"));
+  return exprs.length == 1 ? exprs[0] : { type: "choice", exprs };
+}
+function parseExprSeq(stream) {
+  let exprs = [];
+  do {
+    exprs.push(parseExprSubscript(stream));
+  } while (stream.next && stream.next != ")" && stream.next != "|");
+  return exprs.length == 1 ? exprs[0] : { type: "seq", exprs };
+}
+function parseExprSubscript(stream) {
+  let expr = parseExprAtom(stream);
+  for (; ; ) {
+    if (stream.eat("+"))
+      expr = { type: "plus", expr };
+    else if (stream.eat("*"))
+      expr = { type: "star", expr };
+    else if (stream.eat("?"))
+      expr = { type: "opt", expr };
+    else if (stream.eat("{"))
+      expr = parseExprRange(stream, expr);
     else
       break;
-  return t;
-}
-function W(l) {
-  /\D/.test(l.next) && l.err("Expected number, got '" + l.next + "'");
-  let t = Number(l.next);
-  return l.pos++, t;
-}
-function Ot(l, t) {
-  let e = W(l), n = e;
-  return l.eat(",") && (l.next != "}" ? n = W(l) : n = -1), l.eat("}") || l.err("Unclosed braced range"), { type: "range", min: e, max: n, expr: t };
-}
-function Ct(l, t) {
-  let e = l.nodeTypes, n = e[t];
-  if (n)
-    return [n];
-  let i = [];
-  for (let r in e) {
-    let s = e[r];
-    s.isInGroup(t) && i.push(s);
-  }
-  return i.length == 0 && l.err("No node type or group '" + t + "' found"), i;
-}
-function bt(l) {
-  if (l.eat("(")) {
-    let t = rt(l);
-    return l.eat(")") || l.err("Missing closing paren"), t;
-  } else if (/\W/.test(l.next))
-    l.err("Unexpected token '" + l.next + "'");
-  else {
-    let t = Ct(l, l.next).map((e) => (l.inline == null ? l.inline = e.isInline : l.inline != e.isInline && l.err("Mixing inline and block content"), { type: "name", value: e }));
-    return l.pos++, t.length == 1 ? t[0] : { type: "choice", exprs: t };
-  }
-}
-function Tt(l) {
-  let t = [[]];
-  return i(r(l, 0), e()), t;
-  function e() {
-    return t.push([]) - 1;
-  }
-  function n(s, o, h) {
-    let a = { term: h, to: o };
-    return t[s].push(a), a;
-  }
-  function i(s, o) {
-    s.forEach((h) => h.to = o);
-  }
-  function r(s, o) {
-    if (s.type == "choice")
-      return s.exprs.reduce((h, a) => h.concat(r(a, o)), []);
-    if (s.type == "seq")
-      for (let h = 0; ; h++) {
-        let a = r(s.exprs[h], o);
-        if (h == s.exprs.length - 1)
-          return a;
-        i(a, o = e());
+  }
+  return expr;
+}
+function parseNum(stream) {
+  if (/\D/.test(stream.next))
+    stream.err("Expected number, got '" + stream.next + "'");
+  let result = Number(stream.next);
+  stream.pos++;
+  return result;
+}
+function parseExprRange(stream, expr) {
+  let min = parseNum(stream), max = min;
+  if (stream.eat(",")) {
+    if (stream.next != "}")
+      max = parseNum(stream);
+    else
+      max = -1;
+  }
+  if (!stream.eat("}"))
+    stream.err("Unclosed braced range");
+  return { type: "range", min, max, expr };
+}
+function resolveName(stream, name) {
+  let types = stream.nodeTypes, type = types[name];
+  if (type)
+    return [type];
+  let result = [];
+  for (let typeName in types) {
+    let type2 = types[typeName];
+    if (type2.isInGroup(name))
+      result.push(type2);
+  }
+  if (result.length == 0)
+    stream.err("No node type or group '" + name + "' found");
+  return result;
+}
+function parseExprAtom(stream) {
+  if (stream.eat("(")) {
+    let expr = parseExpr(stream);
+    if (!stream.eat(")"))
+      stream.err("Missing closing paren");
+    return expr;
+  } else if (!/\W/.test(stream.next)) {
+    let exprs = resolveName(stream, stream.next).map((type) => {
+      if (stream.inline == null)
+        stream.inline = type.isInline;
+      else if (stream.inline != type.isInline)
+        stream.err("Mixing inline and block content");
+      return { type: "name", value: type };
+    });
+    stream.pos++;
+    return exprs.length == 1 ? exprs[0] : { type: "choice", exprs };
+  } else {
+    stream.err("Unexpected token '" + stream.next + "'");
+  }
+}
+function nfa(expr) {
+  let nfa2 = [[]];
+  connect(compile(expr, 0), node());
+  return nfa2;
+  function node() {
+    return nfa2.push([]) - 1;
+  }
+  function edge(from, to, term) {
+    let edge2 = { term, to };
+    nfa2[from].push(edge2);
+    return edge2;
+  }
+  function connect(edges, to) {
+    edges.forEach((edge2) => edge2.to = to);
+  }
+  function compile(expr2, from) {
+    if (expr2.type == "choice") {
+      return expr2.exprs.reduce((out, expr3) => out.concat(compile(expr3, from)), []);
+    } else if (expr2.type == "seq") {
+      for (let i = 0; ; i++) {
+        let next = compile(expr2.exprs[i], from);
+        if (i == expr2.exprs.length - 1)
+          return next;
+        connect(next, from = node());
       }
-    else if (s.type == "star") {
-      let h = e();
-      return n(o, h), i(r(s.expr, h), h), [n(h)];
-    } else if (s.type == "plus") {
-      let h = e();
-      return i(r(s.expr, o), h), i(r(s.expr, h), h), [n(h)];
-    } else {
-      if (s.type == "opt")
-        return [n(o)].concat(r(s.expr, o));
-      if (s.type == "range") {
-        let h = o;
-        for (let a = 0; a < s.min; a++) {
-          let f = e();
-          i(r(s.expr, h), f), h = f;
-        }
-        if (s.max == -1)
-          i(r(s.expr, h), h);
-        else
-          for (let a = s.min; a < s.max; a++) {
-            let f = e();
-            n(h, f), i(r(s.expr, h), f), h = f;
-          }
-        return [n(h)];
+    } else if (expr2.type == "star") {
+      let loop = node();
+      edge(from, loop);
+      connect(compile(expr2.expr, loop), loop);
+      return [edge(loop)];
+    } else if (expr2.type == "plus") {
+      let loop = node();
+      connect(compile(expr2.expr, from), loop);
+      connect(compile(expr2.expr, loop), loop);
+      return [edge(loop)];
+    } else if (expr2.type == "opt") {
+      return [edge(from)].concat(compile(expr2.expr, from));
+    } else if (expr2.type == "range") {
+      let cur = from;
+      for (let i = 0; i < expr2.min; i++) {
+        let next = node();
+        connect(compile(expr2.expr, cur), next);
+        cur = next;
+      }
+      if (expr2.max == -1) {
+        connect(compile(expr2.expr, cur), cur);
       } else {
-        if (s.type == "name")
-          return [n(o, void 0, s.value)];
-        throw new Error("Unknown expr type");
+        for (let i = expr2.min; i < expr2.max; i++) {
+          let next = node();
+          edge(cur, next);
+          connect(compile(expr2.expr, cur), next);
+          cur = next;
+        }
       }
+      return [edge(cur)];
+    } else if (expr2.type == "name") {
+      return [edge(from, void 0, expr2.value)];
+    } else {
+      throw new Error("Unknown expr type");
     }
   }
 }
-function st(l, t) {
-  return t - l;
-}
-function j(l, t) {
-  let e = [];
-  return n(t), e.sort(st);
-  function n(i) {
-    let r = l[i];
-    if (r.length == 1 && !r[0].term)
-      return n(r[0].to);
-    e.push(i);
-    for (let s = 0; s < r.length; s++) {
-      let { term: o, to: h } = r[s];
-      !o && e.indexOf(h) == -1 && n(h);
+function cmp(a, b) {
+  return b - a;
+}
+function nullFrom(nfa2, node) {
+  let result = [];
+  scan(node);
+  return result.sort(cmp);
+  function scan(node2) {
+    let edges = nfa2[node2];
+    if (edges.length == 1 && !edges[0].term)
+      return scan(edges[0].to);
+    result.push(node2);
+    for (let i = 0; i < edges.length; i++) {
+      let { term, to } = edges[i];
+      if (!term && result.indexOf(to) == -1)
+        scan(to);
     }
   }
 }
-function Mt(l) {
-  let t = /* @__PURE__ */ Object.create(null);
-  return e(j(l, 0));
-  function e(n) {
-    let i = [];
-    n.forEach((s) => {
-      l[s].forEach(({ term: o, to: h }) => {
-        if (!o)
+function dfa(nfa2) {
+  let labeled = /* @__PURE__ */ Object.create(null);
+  return explore(nullFrom(nfa2, 0));
+  function explore(states) {
+    let out = [];
+    states.forEach((node) => {
+      nfa2[node].forEach(({ term, to }) => {
+        if (!term)
           return;
-        let a;
-        for (let f = 0; f < i.length; f++)
-          i[f][0] == o && (a = i[f][1]);
-        j(l, h).forEach((f) => {
-          a || i.push([o, a = []]), a.indexOf(f) == -1 && a.push(f);
+        let set;
+        for (let i = 0; i < out.length; i++)
+          if (out[i][0] == term)
+            set = out[i][1];
+        nullFrom(nfa2, to).forEach((node2) => {
+          if (!set)
+            out.push([term, set = []]);
+          if (set.indexOf(node2) == -1)
+            set.push(node2);
         });
       });
     });
-    let r = t[n.join(",")] = new w(n.indexOf(l.length - 1) > -1);
-    for (let s = 0; s < i.length; s++) {
-      let o = i[s][1].sort(st);
-      r.next.push({ type: i[s][0], next: t[o.join(",")] || e(o) });
+    let state = labeled[states.join(",")] = new ContentMatch(states.indexOf(nfa2.length - 1) > -1);
+    for (let i = 0; i < out.length; i++) {
+      let states2 = out[i][1].sort(cmp);
+      state.next.push({ type: out[i][0], next: labeled[states2.join(",")] || explore(states2) });
     }
-    return r;
-  }
-}
-function At(l, t) {
-  for (let e = 0, n = [l]; e < n.length; e++) {
-    let i = n[e], r = !i.validEnd, s = [];
-    for (let o = 0; o < i.next.length; o++) {
-      let { type: h, next: a } = i.next[o];
-      s.push(h.name), r && !(h.isText || h.hasRequiredAttrs()) && (r = !1), n.indexOf(a) == -1 && n.push(a);
+    return state;
+  }
+}
+function checkForDeadEnds(match, stream) {
+  for (let i = 0, work = [match]; i < work.length; i++) {
+    let state = work[i], dead = !state.validEnd, nodes = [];
+    for (let j = 0; j < state.next.length; j++) {
+      let { type, next } = state.next[j];
+      nodes.push(type.name);
+      if (dead && !(type.isText || type.hasRequiredAttrs()))
+        dead = false;
+      if (work.indexOf(next) == -1)
+        work.push(next);
     }
-    r && t.err("Only non-generatable nodes (" + s.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable)");
+    if (dead)
+      stream.err("Only non-generatable nodes (" + nodes.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable)");
   }
 }
-function lt(l) {
-  let t = /* @__PURE__ */ Object.create(null);
-  for (let e in l) {
-    let n = l[e];
-    if (!n.hasDefault)
+function defaultAttrs(attrs) {
+  let defaults = /* @__PURE__ */ Object.create(null);
+  for (let attrName in attrs) {
+    let attr = attrs[attrName];
+    if (!attr.hasDefault)
       return null;
-    t[e] = n.default;
-  }
-  return t;
-}
-function ot(l, t) {
-  let e = /* @__PURE__ */ Object.create(null);
-  for (let n in l) {
-    let i = t && t[n];
-    if (i === void 0) {
-      let r = l[n];
-      if (r.hasDefault)
-        i = r.default;
+    defaults[attrName] = attr.default;
+  }
+  return defaults;
+}
+function computeAttrs(attrs, value) {
+  let built = /* @__PURE__ */ Object.create(null);
+  for (let name in attrs) {
+    let given = value && value[name];
+    if (given === void 0) {
+      let attr = attrs[name];
+      if (attr.hasDefault)
+        given = attr.default;
       else
-        throw new RangeError("No value supplied for attribute " + n);
+        throw new RangeError("No value supplied for attribute " + name);
     }
-    e[n] = i;
+    built[name] = given;
   }
-  return e;
+  return built;
 }
-function ht(l, t, e, n) {
-  for (let i in t)
-    if (!(i in l))
-      throw new RangeError(`Unsupported attribute ${i} for ${e} of type ${i}`);
-  for (let i in l) {
-    let r = l[i];
-    r.validate && r.validate(t[i]);
+function checkAttrs(attrs, values, type, name) {
+  for (let name2 in values)
+    if (!(name2 in attrs))
+      throw new RangeError(`Unsupported attribute ${name2} for ${type} of type ${name2}`);
+  for (let name2 in attrs) {
+    let attr = attrs[name2];
+    if (attr.validate)
+      attr.validate(values[name2]);
   }
 }
-function at(l, t) {
-  let e = /* @__PURE__ */ Object.create(null);
-  if (t)
-    for (let n in t)
-      e[n] = new zt(l, n, t[n]);
-  return e;
+function initAttrs(typeName, attrs) {
+  let result = /* @__PURE__ */ Object.create(null);
+  if (attrs)
+    for (let name in attrs)
+      result[name] = new Attribute(typeName, name, attrs[name]);
+  return result;
 }
-class z {
+class NodeType {
   /**
   @internal
   */
-  constructor(t, e, n) {
-    this.name = t, this.schema = e, this.spec = n, this.markSet = null, this.groups = n.group ? n.group.split(" ") : [], this.attrs = at(t, n.attrs), this.defaultAttrs = lt(this.attrs), this.contentMatch = null, this.inlineContent = null, this.isBlock = !(n.inline || t == "text"), this.isText = t == "text";
+  constructor(name, schema, spec) {
+    this.name = name;
+    this.schema = schema;
+    this.spec = spec;
+    this.markSet = null;
+    this.groups = spec.group ? spec.group.split(" ") : [];
+    this.attrs = initAttrs(name, spec.attrs);
+    this.defaultAttrs = defaultAttrs(this.attrs);
+    this.contentMatch = null;
+    this.inlineContent = null;
+    this.isBlock = !(spec.inline || name == "text");
+    this.isText = name == "text";
   }
   /**
   True if this is an inline type.
@@ -1716,7 +1958,7 @@ class z {
   True for node types that allow no content.
   */
   get isLeaf() {
-    return this.contentMatch == w.empty;
+    return this.contentMatch == ContentMatch.empty;
   }
   /**
   True when this node is an atom, i.e. when it does not have
@@ -1729,8 +1971,8 @@ class z {
   Return true when this node type is part of the given
   [group](https://prosemirror.net/docs/ref/#model.NodeSpec.group).
   */
-  isInGroup(t) {
-    return this.groups.indexOf(t) > -1;
+  isInGroup(group) {
+    return this.groups.indexOf(group) > -1;
   }
   /**
   The node type's [whitespace](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) option.
@@ -1742,23 +1984,26 @@ class z {
   Tells you whether this node type has any required attributes.
   */
   hasRequiredAttrs() {
-    for (let t in this.attrs)
-      if (this.attrs[t].isRequired)
-        return !0;
-    return !1;
+    for (let n in this.attrs)
+      if (this.attrs[n].isRequired)
+        return true;
+    return false;
   }
   /**
   Indicates whether this node allows some of the same content as
   the given node type.
   */
-  compatibleContent(t) {
-    return this == t || this.contentMatch.compatible(t.contentMatch);
+  compatibleContent(other) {
+    return this == other || this.contentMatch.compatible(other.contentMatch);
   }
   /**
   @internal
   */
-  computeAttrs(t) {
-    return !t && this.defaultAttrs ? this.defaultAttrs : ot(this.attrs, t);
+  computeAttrs(attrs) {
+    if (!attrs && this.defaultAttrs)
+      return this.defaultAttrs;
+    else
+      return computeAttrs(this.attrs, attrs);
   }
   /**
   Create a `Node` of this type. The given attributes are
@@ -1768,18 +2013,20 @@ class z {
   `null`. Similarly `marks` may be `null` to default to the empty
   set of marks.
   */
-  create(t = null, e, n) {
+  create(attrs = null, content, marks) {
     if (this.isText)
       throw new Error("NodeType.create can't construct text nodes");
-    return new y(this, this.computeAttrs(t), c.from(e), u.setFrom(n));
+    return new Node(this, this.computeAttrs(attrs), Fragment.from(content), Mark.setFrom(marks));
   }
   /**
   Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but check the given content
   against the node type's content restrictions, and throw an error
   if it doesn't match.
   */
-  createChecked(t = null, e, n) {
-    return e = c.from(e), this.checkContent(e), new y(this, this.computeAttrs(t), e, u.setFrom(n));
+  createChecked(attrs = null, content, marks) {
+    content = Fragment.from(content);
+    this.checkContent(content);
+    return new Node(this, this.computeAttrs(attrs), content, Mark.setFrom(marks));
   }
   /**
   Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but see if it is
@@ -1789,188 +2036,219 @@ class z {
   always be created, this will always succeed if you pass null or
   `Fragment.empty` as content.
   */
-  createAndFill(t = null, e, n) {
-    if (t = this.computeAttrs(t), e = c.from(e), e.size) {
-      let s = this.contentMatch.fillBefore(e);
-      if (!s)
+  createAndFill(attrs = null, content, marks) {
+    attrs = this.computeAttrs(attrs);
+    content = Fragment.from(content);
+    if (content.size) {
+      let before = this.contentMatch.fillBefore(content);
+      if (!before)
         return null;
-      e = s.append(e);
+      content = before.append(content);
     }
-    let i = this.contentMatch.matchFragment(e), r = i && i.fillBefore(c.empty, !0);
-    return r ? new y(this, t, e.append(r), u.setFrom(n)) : null;
+    let matched = this.contentMatch.matchFragment(content);
+    let after = matched && matched.fillBefore(Fragment.empty, true);
+    if (!after)
+      return null;
+    return new Node(this, attrs, content.append(after), Mark.setFrom(marks));
   }
   /**
   Returns true if the given fragment is valid content for this node
   type.
   */
-  validContent(t) {
-    let e = this.contentMatch.matchFragment(t);
-    if (!e || !e.validEnd)
-      return !1;
-    for (let n = 0; n < t.childCount; n++)
-      if (!this.allowsMarks(t.child(n).marks))
-        return !1;
-    return !0;
+  validContent(content) {
+    let result = this.contentMatch.matchFragment(content);
+    if (!result || !result.validEnd)
+      return false;
+    for (let i = 0; i < content.childCount; i++)
+      if (!this.allowsMarks(content.child(i).marks))
+        return false;
+    return true;
   }
   /**
   Throws a RangeError if the given fragment is not valid content for this
   node type.
   @internal
   */
-  checkContent(t) {
-    if (!this.validContent(t))
-      throw new RangeError(`Invalid content for node ${this.name}: ${t.toString().slice(0, 50)}`);
+  checkContent(content) {
+    if (!this.validContent(content))
+      throw new RangeError(`Invalid content for node ${this.name}: ${content.toString().slice(0, 50)}`);
   }
   /**
   @internal
   */
-  checkAttrs(t) {
-    ht(this.attrs, t, "node", this.name);
+  checkAttrs(attrs) {
+    checkAttrs(this.attrs, attrs, "node", this.name);
   }
   /**
   Check whether the given mark type is allowed in this node.
   */
-  allowsMarkType(t) {
-    return this.markSet == null || this.markSet.indexOf(t) > -1;
+  allowsMarkType(markType) {
+    return this.markSet == null || this.markSet.indexOf(markType) > -1;
   }
   /**
   Test whether the given set of marks are allowed in this node.
   */
-  allowsMarks(t) {
+  allowsMarks(marks) {
     if (this.markSet == null)
-      return !0;
-    for (let e = 0; e < t.length; e++)
-      if (!this.allowsMarkType(t[e].type))
-        return !1;
-    return !0;
+      return true;
+    for (let i = 0; i < marks.length; i++)
+      if (!this.allowsMarkType(marks[i].type))
+        return false;
+    return true;
   }
   /**
   Removes the marks that are not allowed in this node from the given set.
   */
-  allowedMarks(t) {
+  allowedMarks(marks) {
     if (this.markSet == null)
-      return t;
-    let e;
-    for (let n = 0; n < t.length; n++)
-      this.allowsMarkType(t[n].type) ? e && e.push(t[n]) : e || (e = t.slice(0, n));
-    return e ? e.length ? e : u.none : t;
+      return marks;
+    let copy2;
+    for (let i = 0; i < marks.length; i++) {
+      if (!this.allowsMarkType(marks[i].type)) {
+        if (!copy2)
+          copy2 = marks.slice(0, i);
+      } else if (copy2) {
+        copy2.push(marks[i]);
+      }
+    }
+    return !copy2 ? marks : copy2.length ? copy2 : Mark.none;
   }
   /**
   @internal
   */
-  static compile(t, e) {
-    let n = /* @__PURE__ */ Object.create(null);
-    t.forEach((r, s) => n[r] = new z(r, e, s));
-    let i = e.spec.topNode || "doc";
-    if (!n[i])
-      throw new RangeError("Schema is missing its top node type ('" + i + "')");
-    if (!n.text)
+  static compile(nodes, schema) {
+    let result = /* @__PURE__ */ Object.create(null);
+    nodes.forEach((name, spec) => result[name] = new NodeType(name, schema, spec));
+    let topType = schema.spec.topNode || "doc";
+    if (!result[topType])
+      throw new RangeError("Schema is missing its top node type ('" + topType + "')");
+    if (!result.text)
       throw new RangeError("Every schema needs a 'text' type");
-    for (let r in n.text.attrs)
+    for (let _ in result.text.attrs)
       throw new RangeError("The text node type should not have attributes");
-    return n;
+    return result;
   }
 }
-function Nt(l, t, e) {
-  let n = e.split("|");
-  return (i) => {
-    let r = i === null ? "null" : typeof i;
-    if (n.indexOf(r) < 0)
-      throw new RangeError(`Expected value of type ${n} for attribute ${t} on type ${l}, got ${r}`);
+function validateType(typeName, attrName, type) {
+  let types = type.split("|");
+  return (value) => {
+    let name = value === null ? "null" : typeof value;
+    if (types.indexOf(name) < 0)
+      throw new RangeError(`Expected value of type ${types} for attribute ${attrName} on type ${typeName}, got ${name}`);
   };
 }
-class zt {
-  constructor(t, e, n) {
-    this.hasDefault = Object.prototype.hasOwnProperty.call(n, "default"), this.default = n.default, this.validate = typeof n.validate == "string" ? Nt(t, e, n.validate) : n.validate;
+class Attribute {
+  constructor(typeName, attrName, options) {
+    this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
+    this.default = options.default;
+    this.validate = typeof options.validate == "string" ? validateType(typeName, attrName, options.validate) : options.validate;
   }
   get isRequired() {
     return !this.hasDefault;
   }
 }
-class F {
+class MarkType {
   /**
   @internal
   */
-  constructor(t, e, n, i) {
-    this.name = t, this.rank = e, this.schema = n, this.spec = i, this.attrs = at(t, i.attrs), this.excluded = null;
-    let r = lt(this.attrs);
-    this.instance = r ? new u(this, r) : null;
+  constructor(name, rank, schema, spec) {
+    this.name = name;
+    this.rank = rank;
+    this.schema = schema;
+    this.spec = spec;
+    this.attrs = initAttrs(name, spec.attrs);
+    this.excluded = null;
+    let defaults = defaultAttrs(this.attrs);
+    this.instance = defaults ? new Mark(this, defaults) : null;
   }
   /**
   Create a mark of this type. `attrs` may be `null` or an object
   containing only some of the mark's attributes. The others, if
   they have defaults, will be added.
   */
-  create(t = null) {
-    return !t && this.instance ? this.instance : new u(this, ot(this.attrs, t));
+  create(attrs = null) {
+    if (!attrs && this.instance)
+      return this.instance;
+    return new Mark(this, computeAttrs(this.attrs, attrs));
   }
   /**
   @internal
   */
-  static compile(t, e) {
-    let n = /* @__PURE__ */ Object.create(null), i = 0;
-    return t.forEach((r, s) => n[r] = new F(r, i++, e, s)), n;
+  static compile(marks, schema) {
+    let result = /* @__PURE__ */ Object.create(null), rank = 0;
+    marks.forEach((name, spec) => result[name] = new MarkType(name, rank++, schema, spec));
+    return result;
   }
   /**
   When there is a mark of this type in the given set, a new set
   without it is returned. Otherwise, the input set is returned.
   */
-  removeFromSet(t) {
-    for (var e = 0; e < t.length; e++)
-      t[e].type == this && (t = t.slice(0, e).concat(t.slice(e + 1)), e--);
-    return t;
+  removeFromSet(set) {
+    for (var i = 0; i < set.length; i++)
+      if (set[i].type == this) {
+        set = set.slice(0, i).concat(set.slice(i + 1));
+        i--;
+      }
+    return set;
   }
   /**
   Tests whether there is a mark of this type in the given set.
   */
-  isInSet(t) {
-    for (let e = 0; e < t.length; e++)
-      if (t[e].type == this)
-        return t[e];
+  isInSet(set) {
+    for (let i = 0; i < set.length; i++)
+      if (set[i].type == this)
+        return set[i];
   }
   /**
   @internal
   */
-  checkAttrs(t) {
-    ht(this.attrs, t, "mark", this.name);
+  checkAttrs(attrs) {
+    checkAttrs(this.attrs, attrs, "mark", this.name);
   }
   /**
   Queries whether a given mark type is
   [excluded](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) by this one.
   */
-  excludes(t) {
-    return this.excluded.indexOf(t) > -1;
+  excludes(other) {
+    return this.excluded.indexOf(other) > -1;
   }
 }
-class qt {
+class Schema {
   /**
   Construct a schema from a schema [specification](https://prosemirror.net/docs/ref/#model.SchemaSpec).
   */
-  constructor(t) {
-    this.linebreakReplacement = null, this.cached = /* @__PURE__ */ Object.create(null);
-    let e = this.spec = {};
-    for (let i in t)
-      e[i] = t[i];
-    e.nodes = q.from(t.nodes), e.marks = q.from(t.marks || {}), this.nodes = z.compile(this.spec.nodes, this), this.marks = F.compile(this.spec.marks, this);
-    let n = /* @__PURE__ */ Object.create(null);
-    for (let i in this.nodes) {
-      if (i in this.marks)
-        throw new RangeError(i + " can not be both a node and a mark");
-      let r = this.nodes[i], s = r.spec.content || "", o = r.spec.marks;
-      if (r.contentMatch = n[s] || (n[s] = w.parse(s, this.nodes)), r.inlineContent = r.contentMatch.inlineContent, r.spec.linebreakReplacement) {
+  constructor(spec) {
+    this.linebreakReplacement = null;
+    this.cached = /* @__PURE__ */ Object.create(null);
+    let instanceSpec = this.spec = {};
+    for (let prop in spec)
+      instanceSpec[prop] = spec[prop];
+    instanceSpec.nodes = OrderedMap.from(spec.nodes), instanceSpec.marks = OrderedMap.from(spec.marks || {}), this.nodes = NodeType.compile(this.spec.nodes, this);
+    this.marks = MarkType.compile(this.spec.marks, this);
+    let contentExprCache = /* @__PURE__ */ Object.create(null);
+    for (let prop in this.nodes) {
+      if (prop in this.marks)
+        throw new RangeError(prop + " can not be both a node and a mark");
+      let type = this.nodes[prop], contentExpr = type.spec.content || "", markExpr = type.spec.marks;
+      type.contentMatch = contentExprCache[contentExpr] || (contentExprCache[contentExpr] = ContentMatch.parse(contentExpr, this.nodes));
+      type.inlineContent = type.contentMatch.inlineContent;
+      if (type.spec.linebreakReplacement) {
         if (this.linebreakReplacement)
           throw new RangeError("Multiple linebreak nodes defined");
-        if (!r.isInline || !r.isLeaf)
+        if (!type.isInline || !type.isLeaf)
           throw new RangeError("Linebreak replacement nodes must be inline leaf nodes");
-        this.linebreakReplacement = r;
+        this.linebreakReplacement = type;
       }
-      r.markSet = o == "_" ? null : o ? U(this, o.split(" ")) : o == "" || !r.inlineContent ? [] : null;
+      type.markSet = markExpr == "_" ? null : markExpr ? gatherMarks(this, markExpr.split(" ")) : markExpr == "" || !type.inlineContent ? [] : null;
     }
-    for (let i in this.marks) {
-      let r = this.marks[i], s = r.spec.excludes;
-      r.excluded = s == null ? [r] : s == "" ? [] : U(this, s.split(" "));
+    for (let prop in this.marks) {
+      let type = this.marks[prop], excl = type.spec.excludes;
+      type.excluded = excl == null ? [type] : excl == "" ? [] : gatherMarks(this, excl.split(" "));
     }
-    this.nodeFromJSON = this.nodeFromJSON.bind(this), this.markFromJSON = this.markFromJSON.bind(this), this.topNodeType = this.nodes[this.spec.topNode || "doc"], this.cached.wrappings = /* @__PURE__ */ Object.create(null);
+    this.nodeFromJSON = this.nodeFromJSON.bind(this);
+    this.markFromJSON = this.markFromJSON.bind(this);
+    this.topNodeType = this.nodes[this.spec.topNode || "doc"];
+    this.cached.wrappings = /* @__PURE__ */ Object.create(null);
   }
   /**
   Create a node in this schema. The `type` may be a string or a
@@ -1978,103 +2256,114 @@ class qt {
   `content` may be a `Fragment`, `null`, a `Node`, or an array of
   nodes.
   */
-  node(t, e = null, n, i) {
-    if (typeof t == "string")
-      t = this.nodeType(t);
-    else if (t instanceof z) {
-      if (t.schema != this)
-        throw new RangeError("Node type from different schema used (" + t.name + ")");
-    } else throw new RangeError("Invalid node type: " + t);
-    return t.createChecked(e, n, i);
+  node(type, attrs = null, content, marks) {
+    if (typeof type == "string")
+      type = this.nodeType(type);
+    else if (!(type instanceof NodeType))
+      throw new RangeError("Invalid node type: " + type);
+    else if (type.schema != this)
+      throw new RangeError("Node type from different schema used (" + type.name + ")");
+    return type.createChecked(attrs, content, marks);
   }
   /**
   Create a text node in the schema. Empty text nodes are not
   allowed.
   */
-  text(t, e) {
-    let n = this.nodes.text;
-    return new N(n, n.defaultAttrs, t, u.setFrom(e));
+  text(text, marks) {
+    let type = this.nodes.text;
+    return new TextNode(type, type.defaultAttrs, text, Mark.setFrom(marks));
   }
   /**
   Create a mark with the given type and attributes.
   */
-  mark(t, e) {
-    return typeof t == "string" && (t = this.marks[t]), t.create(e);
+  mark(type, attrs) {
+    if (typeof type == "string")
+      type = this.marks[type];
+    return type.create(attrs);
   }
   /**
   Deserialize a node from its JSON representation. This method is
   bound.
   */
-  nodeFromJSON(t) {
-    return y.fromJSON(this, t);
+  nodeFromJSON(json) {
+    return Node.fromJSON(this, json);
   }
   /**
   Deserialize a mark from its JSON representation. This method is
   bound.
   */
-  markFromJSON(t) {
-    return u.fromJSON(this, t);
+  markFromJSON(json) {
+    return Mark.fromJSON(this, json);
   }
   /**
   @internal
   */
-  nodeType(t) {
-    let e = this.nodes[t];
-    if (!e)
-      throw new RangeError("Unknown node type: " + t);
-    return e;
+  nodeType(name) {
+    let found2 = this.nodes[name];
+    if (!found2)
+      throw new RangeError("Unknown node type: " + name);
+    return found2;
   }
 }
-function U(l, t) {
-  let e = [];
-  for (let n = 0; n < t.length; n++) {
-    let i = t[n], r = l.marks[i], s = r;
-    if (r)
-      e.push(r);
-    else
-      for (let o in l.marks) {
-        let h = l.marks[o];
-        (i == "_" || h.spec.group && h.spec.group.split(" ").indexOf(i) > -1) && e.push(s = h);
+function gatherMarks(schema, marks) {
+  let found2 = [];
+  for (let i = 0; i < marks.length; i++) {
+    let name = marks[i], mark = schema.marks[name], ok = mark;
+    if (mark) {
+      found2.push(mark);
+    } else {
+      for (let prop in schema.marks) {
+        let mark2 = schema.marks[prop];
+        if (name == "_" || mark2.spec.group && mark2.spec.group.split(" ").indexOf(name) > -1)
+          found2.push(ok = mark2);
       }
-    if (!s)
-      throw new SyntaxError("Unknown mark type: '" + t[n] + "'");
+    }
+    if (!ok)
+      throw new SyntaxError("Unknown mark type: '" + marks[i] + "'");
   }
-  return e;
+  return found2;
 }
-function vt(l) {
-  return l.tag != null;
+function isTagRule(rule) {
+  return rule.tag != null;
 }
-function Rt(l) {
-  return l.style != null;
+function isStyleRule(rule) {
+  return rule.style != null;
 }
-class P {
+class DOMParser {
   /**
   Create a parser that targets the given schema, using the given
   parsing rules.
   */
-  constructor(t, e) {
-    this.schema = t, this.rules = e, this.tags = [], this.styles = [];
-    let n = this.matchedStyles = [];
-    e.forEach((i) => {
-      if (vt(i))
-        this.tags.push(i);
-      else if (Rt(i)) {
-        let r = /[^=]*/.exec(i.style)[0];
-        n.indexOf(r) < 0 && n.push(r), this.styles.push(i);
+  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((i) => {
-      if (!/^(ul|ol)\b/.test(i.tag) || !i.node)
-        return !1;
-      let r = t.nodes[i.node];
-      return r.contentMatch.matchType(r);
+    });
+    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(t, e = {}) {
-    let n = new G(this, e, !1);
-    return n.addAll(t, u.none, e.from, e.to), n.finish();
+  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
@@ -2084,166 +2373,212 @@ class P {
   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(t, e = {}) {
-    let n = new G(this, e, !0);
-    return n.addAll(t, u.none, e.from, e.to), d.maxOpen(n.finish());
+  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(t, e, n) {
-    for (let i = n ? this.tags.indexOf(n) + 1 : 0; i < this.tags.length; i++) {
-      let r = this.tags[i];
-      if (Pt(t, r.tag) && (r.namespace === void 0 || t.namespaceURI == r.namespace) && (!r.context || e.matchesContext(r.context))) {
-        if (r.getAttrs) {
-          let s = r.getAttrs(t);
-          if (s === !1)
+  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;
-          r.attrs = s || void 0;
+          rule.attrs = result || void 0;
         }
-        return r;
+        return rule;
       }
     }
   }
   /**
   @internal
   */
-  matchStyle(t, e, n, i) {
-    for (let r = i ? this.styles.indexOf(i) + 1 : 0; r < this.styles.length; r++) {
-      let s = this.styles[r], o = s.style;
-      if (!(o.indexOf(t) != 0 || s.context && !n.matchesContext(s.context) || // Test that the style string either precisely matches the prop,
+  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.
-      o.length > t.length && (o.charCodeAt(t.length) != 61 || o.slice(t.length + 1) != e))) {
-        if (s.getAttrs) {
-          let h = s.getAttrs(e);
-          if (h === !1)
-            continue;
-          s.attrs = h || void 0;
-        }
-        return s;
+      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(t) {
-    let e = [];
-    function n(i) {
-      let r = i.priority == null ? 50 : i.priority, s = 0;
-      for (; s < e.length; s++) {
-        let o = e[s];
-        if ((o.priority == null ? 50 : o.priority) < r)
+  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;
       }
-      e.splice(s, 0, i);
+      result.splice(i, 0, rule);
     }
-    for (let i in t.marks) {
-      let r = t.marks[i].spec.parseDOM;
-      r && r.forEach((s) => {
-        n(s = H(s)), s.mark || s.ignore || s.clearMark || (s.mark = i);
-      });
+    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 i in t.nodes) {
-      let r = t.nodes[i].spec.parseDOM;
-      r && r.forEach((s) => {
-        n(s = H(s)), s.node || s.ignore || s.mark || (s.node = i);
-      });
+    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 e;
+    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.ParseRule.priority).
   */
-  static fromSchema(t) {
-    return t.cached.domParser || (t.cached.domParser = new P(t, P.schemaRules(t)));
-  }
-}
-const ft = {
-  address: !0,
-  article: !0,
-  aside: !0,
-  blockquote: !0,
-  canvas: !0,
-  dd: !0,
-  div: !0,
-  dl: !0,
-  fieldset: !0,
-  figcaption: !0,
-  figure: !0,
-  footer: !0,
-  form: !0,
-  h1: !0,
-  h2: !0,
-  h3: !0,
-  h4: !0,
-  h5: !0,
-  h6: !0,
-  header: !0,
-  hgroup: !0,
-  hr: !0,
-  li: !0,
-  noscript: !0,
-  ol: !0,
-  output: !0,
-  p: !0,
-  pre: !0,
-  section: !0,
-  table: !0,
-  tfoot: !0,
-  ul: !0
-}, It = {
-  head: !0,
-  noscript: !0,
-  object: !0,
-  script: !0,
-  style: !0,
-  title: !0
-}, ct = { ol: !0, ul: !0 }, E = 1, B = 2, b = 4;
-function V(l, t, e) {
-  return t != null ? (t ? E : 0) | (t === "full" ? B : 0) : l && l.whitespace == "pre" ? E | B : e & -5;
-}
-class C {
-  constructor(t, e, n, i, r, s) {
-    this.type = t, this.attrs = e, this.marks = n, this.solid = i, this.options = s, this.content = [], this.activeMarks = u.none, this.match = r || (s & b ? null : t.contentMatch);
-  }
-  findWrapping(t) {
+  static fromSchema(schema) {
+    return schema.cached.domParser || (schema.cached.domParser = new DOMParser(schema, DOMParser.schemaRules(schema)));
+  }
+}
+const 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
+};
+const ignoreTags = {
+  head: true,
+  noscript: true,
+  object: true,
+  script: true,
+  style: true,
+  title: true
+};
+const listTags = { ol: true, ul: true };
+const OPT_PRESERVE_WS = 1, OPT_PRESERVE_WS_FULL = 2, 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 & -5;
+}
+class NodeContext {
+  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 e = this.type.contentMatch.fillBefore(c.from(t));
-      if (e)
-        this.match = this.type.contentMatch.matchFragment(e);
-      else {
-        let n = this.type.contentMatch, i;
-        return (i = n.findWrapping(t.type)) ? (this.match = n, i) : null;
+      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(t.type);
-  }
-  finish(t) {
-    if (!(this.options & E)) {
-      let n = this.content[this.content.length - 1], i;
-      if (n && n.isText && (i = /[ \t\r\n\u000c]+$/.exec(n.text))) {
-        let r = n;
-        n.text.length == i[0].length ? this.content.pop() : this.content[this.content.length - 1] = r.withText(r.text.slice(0, r.text.length - i[0].length));
+    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 e = c.from(this.content);
-    return !t && this.match && (e = e.append(this.match.fillBefore(c.empty, !0))), this.type ? this.type.create(this.attrs, e, this.marks) : e;
-  }
-  inlineContext(t) {
-    return this.type ? this.type.inlineContent : this.content.length ? this.content[0].isInline : t.parentNode && !ft.hasOwnProperty(t.parentNode.nodeName.toLowerCase());
-  }
-}
-class G {
-  constructor(t, e, n) {
-    this.parser = t, this.options = e, this.isOpen = n, this.open = 0, this.localPreserveWS = !1;
-    let i = e.topNode, r, s = V(null, e.preserveWhitespace, 0) | (n ? b : 0);
-    i ? r = new C(i.type, i.attrs, u.none, !0, e.topMatch || i.type.contentMatch, s) : n ? r = new C(null, null, u.none, !0, null, s) : r = new C(t.schema.topNodeType, null, u.none, !0, null, s), this.nodes = [r], this.find = e.findPositions, this.needsBlock = !1;
+    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());
+  }
+}
+class ParseContext {
+  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];
@@ -2251,302 +2586,404 @@ class G {
   // 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(t, e) {
-    t.nodeType == 3 ? this.addTextNode(t, e) : t.nodeType == 1 && this.addElement(t, e);
-  }
-  addTextNode(t, e) {
-    let n = t.nodeValue, i = this.top, r = i.options & B ? "full" : this.localPreserveWS || (i.options & E) > 0;
-    if (r === "full" || i.inlineContext(t) || /[^ \t\r\n\u000c]/.test(n)) {
-      if (r)
-        r !== "full" ? n = n.replace(/\r?\n|\r/g, " ") : n = n.replace(/\r\n?/g, `
-`);
-      else if (n = n.replace(/[ \t\r\n\u000c]+/g, " "), /^[ \t\r\n\u000c]/.test(n) && this.open == this.nodes.length - 1) {
-        let s = i.content[i.content.length - 1], o = t.previousSibling;
-        (!s || o && o.nodeName == "BR" || s.isText && /[ \t\r\n\u000c]$/.test(s.text)) && (n = n.slice(1));
+  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;
+    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|\r/g, " ");
+      } else {
+        value = value.replace(/\r\n?/g, "\n");
       }
-      n && this.insertNode(this.parser.schema.text(n), e, !/\S/.test(n)), this.findInText(t);
-    } else
-      this.findInside(t);
+      if (value)
+        this.insertNode(this.parser.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(t, e, n) {
-    let i = this.localPreserveWS, r = this.top;
-    (t.tagName == "PRE" || /pre/.test(t.style && t.style.whiteSpace)) && (this.localPreserveWS = !0);
-    let s = t.nodeName.toLowerCase(), o;
-    ct.hasOwnProperty(s) && this.parser.normalizeLists && Dt(t);
-    let h = this.options.ruleFromNode && this.options.ruleFromNode(t) || (o = this.parser.matchTag(t, this, n));
-    t: if (h ? h.ignore : It.hasOwnProperty(s))
-      this.findInside(t), this.ignoreFallback(t, e);
-    else if (!h || h.skip || h.closeParent) {
-      h && h.closeParent ? this.open = Math.max(0, this.open - 1) : h && h.skip.nodeType && (t = h.skip);
-      let a, f = this.needsBlock;
-      if (ft.hasOwnProperty(s))
-        r.content.length && r.content[0].isInline && this.open && (this.open--, r = this.top), a = !0, r.type || (this.needsBlock = !0);
-      else if (!t.firstChild) {
-        this.leafFallback(t, e);
-        break t;
+  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 p = h && h.skip ? e : this.readStyles(t, e);
-      p && this.addAll(t, p), a && this.sync(r), this.needsBlock = f;
+      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 a = this.readStyles(t, e);
-      a && this.addElementByRule(t, h, a, h.consuming === !1 ? o : void 0);
+      let innerMarks = this.readStyles(dom, marks);
+      if (innerMarks)
+        this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : void 0);
     }
-    this.localPreserveWS = i;
+    this.localPreserveWS = outerWS;
   }
   // Called for leaf DOM nodes that would otherwise be ignored
-  leafFallback(t, e) {
-    t.nodeName == "BR" && this.top.type && this.top.type.inlineContent && this.addTextNode(t.ownerDocument.createTextNode(`
-`), e);
+  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(t, e) {
-    t.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent) && this.findPlace(this.parser.schema.text("-"), e, !0);
+  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(t, e) {
-    let n = t.style;
-    if (n && n.length)
+  readStyles(dom, marks) {
+    let styles = dom.style;
+    if (styles && styles.length)
       for (let i = 0; i < this.parser.matchedStyles.length; i++) {
-        let r = this.parser.matchedStyles[i], s = n.getPropertyValue(r);
-        if (s)
-          for (let o = void 0; ; ) {
-            let h = this.parser.matchStyle(r, s, this, o);
-            if (!h)
+        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 (h.ignore)
+            if (rule.ignore)
               return null;
-            if (h.clearMark ? e = e.filter((a) => !h.clearMark(a)) : e = e.concat(this.parser.schema.marks[h.mark].create(h.attrs)), h.consuming === !1)
-              o = h;
+            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 e;
+    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(t, e, n, i) {
-    let r, s;
-    if (e.node)
-      if (s = this.parser.schema.nodes[e.node], s.isLeaf)
-        this.insertNode(s.create(e.attrs), n, t.nodeName == "BR") || this.leafFallback(t, n);
-      else {
-        let h = this.enter(s, e.attrs || null, n, e.preserveWhitespace);
-        h && (r = !0, n = h);
+  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 h = this.parser.schema.marks[e.mark];
-      n = n.concat(h.create(e.attrs));
+    } else {
+      let markType = this.parser.schema.marks[rule.mark];
+      marks = marks.concat(markType.create(rule.attrs));
     }
-    let o = this.top;
-    if (s && s.isLeaf)
-      this.findInside(t);
-    else if (i)
-      this.addElement(t, n, i);
-    else if (e.getContent)
-      this.findInside(t), e.getContent(t, this.parser.schema).forEach((h) => this.insertNode(h, n, !1));
-    else {
-      let h = t;
-      typeof e.contentElement == "string" ? h = t.querySelector(e.contentElement) : typeof e.contentElement == "function" ? h = e.contentElement(t) : e.contentElement && (h = e.contentElement), this.findAround(t, h, !0), this.addAll(h, n), this.findAround(t, h, !1);
+    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);
     }
-    r && this.sync(o) && this.open--;
+    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(t, e, n, i) {
-    let r = n || 0;
-    for (let s = n ? t.childNodes[n] : t.firstChild, o = i == null ? null : t.childNodes[i]; s != o; s = s.nextSibling, ++r)
-      this.findAtPoint(t, r), this.addDOM(s, e);
-    this.findAtPoint(t, r);
+  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(t, e, n) {
-    let i, r;
-    for (let s = this.open, o = 0; s >= 0; s--) {
-      let h = this.nodes[s], a = h.findWrapping(t);
-      if (a && (!i || i.length > a.length + o) && (i = a, r = h, !a.length))
-        break;
-      if (h.solid) {
-        if (n)
+  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;
-        o += 2;
+      }
+      if (cx.solid) {
+        if (cautious)
+          break;
+        penalty += 2;
       }
     }
-    if (!i)
+    if (!route)
       return null;
-    this.sync(r);
-    for (let s = 0; s < i.length; s++)
-      e = this.enterInner(i[s], null, e, !1);
-    return e;
+    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(t, e, n) {
-    if (t.isInline && this.needsBlock && !this.top.type) {
-      let r = this.textblockFromContext();
-      r && (e = this.enterInner(r, null, e));
+  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 i = this.findPlace(t, e, n);
-    if (i) {
+    let innerMarks = this.findPlace(node, marks, cautious);
+    if (innerMarks) {
       this.closeExtra();
-      let r = this.top;
-      r.match && (r.match = r.match.matchType(t.type));
-      let s = u.none;
-      for (let o of i.concat(t.marks))
-        (r.type ? r.type.allowsMarkType(o.type) : K(o.type, t.type)) && (s = o.addToSet(s));
-      return r.content.push(t.mark(s)), !0;
+      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 !1;
+    return false;
   }
   // Try to start a node of the given type, adjusting the context when
   // necessary.
-  enter(t, e, n, i) {
-    let r = this.findPlace(t.create(e), n, !1);
-    return r && (r = this.enterInner(t, e, n, !0, i)), r;
+  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(t, e, n, i = !1, r) {
+  enterInner(type, attrs, marks, solid = false, preserveWS) {
     this.closeExtra();
-    let s = this.top;
-    s.match = s.match && s.match.matchType(t);
-    let o = V(t, r, s.options);
-    s.options & b && s.content.length == 0 && (o |= b);
-    let h = u.none;
-    return n = n.filter((a) => (s.type ? s.type.allowsMarkType(a.type) : K(a.type, t)) ? (h = a.addToSet(h), !1) : !0), this.nodes.push(new C(t, e, h, i, null, o)), this.open++, n;
+    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(t = !1) {
-    let e = this.nodes.length - 1;
-    if (e > this.open) {
-      for (; e > this.open; e--)
-        this.nodes[e - 1].content.push(this.nodes[e].finish(t));
+  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() {
-    return this.open = 0, this.closeExtra(this.isOpen), this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
-  }
-  sync(t) {
-    for (let e = this.open; e >= 0; e--) {
-      if (this.nodes[e] == t)
-        return this.open = e, !0;
-      this.localPreserveWS && (this.nodes[e].options |= E);
+    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 !1;
+    return false;
   }
   get currentPos() {
     this.closeExtra();
-    let t = 0;
-    for (let e = this.open; e >= 0; e--) {
-      let n = this.nodes[e].content;
-      for (let i = n.length - 1; i >= 0; i--)
-        t += n[i].nodeSize;
-      e && t++;
+    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 t;
+    return pos;
   }
-  findAtPoint(t, e) {
+  findAtPoint(parent, offset) {
     if (this.find)
-      for (let n = 0; n < this.find.length; n++)
-        this.find[n].node == t && this.find[n].offset == e && (this.find[n].pos = this.currentPos);
+      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(t) {
+  findInside(parent) {
     if (this.find)
-      for (let e = 0; e < this.find.length; e++)
-        this.find[e].pos == null && t.nodeType == 1 && t.contains(this.find[e].node) && (this.find[e].pos = this.currentPos);
+      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(t, e, n) {
-    if (t != e && this.find)
-      for (let i = 0; i < this.find.length; i++)
-        this.find[i].pos == null && t.nodeType == 1 && t.contains(this.find[i].node) && e.compareDocumentPosition(this.find[i].node) & (n ? 2 : 4) && (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(t) {
+  findInText(textNode) {
     if (this.find)
-      for (let e = 0; e < this.find.length; e++)
-        this.find[e].node == t && (this.find[e].pos = this.currentPos - (t.nodeValue.length - this.find[e].offset));
+      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(t) {
-    if (t.indexOf("|") > -1)
-      return t.split(/\s*\|\s*/).some(this.matchesContext, this);
-    let e = t.split("/"), n = this.options.context, i = !this.isOpen && (!n || n.parent.type == this.nodes[0].type), r = -(n ? n.depth + 1 : 0) + (i ? 0 : 1), s = (o, h) => {
-      for (; o >= 0; o--) {
-        let a = e[o];
-        if (a == "") {
-          if (o == e.length - 1 || o == 0)
+  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 (; h >= r; h--)
-            if (s(o - 1, h))
-              return !0;
-          return !1;
+          for (; depth >= minDepth; depth--)
+            if (match(i - 1, depth))
+              return true;
+          return false;
         } else {
-          let f = h > 0 || h == 0 && i ? this.nodes[h].type : n && h >= r ? n.node(h - r).type : null;
-          if (!f || f.name != a && !f.isInGroup(a))
-            return !1;
-          h--;
+          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 !0;
+      return true;
     };
-    return s(e.length - 1, this.open);
+    return match(parts.length - 1, this.open);
   }
   textblockFromContext() {
-    let t = this.options.context;
-    if (t)
-      for (let e = t.depth; e >= 0; e--) {
-        let n = t.node(e).contentMatchAt(t.indexAfter(e)).defaultType;
-        if (n && n.isTextblock && n.defaultAttrs)
-          return n;
+    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 e in this.parser.schema.nodes) {
-      let n = this.parser.schema.nodes[e];
-      if (n.isTextblock && n.defaultAttrs)
-        return n;
+    for (let name in this.parser.schema.nodes) {
+      let type = this.parser.schema.nodes[name];
+      if (type.isTextblock && type.defaultAttrs)
+        return type;
     }
   }
 }
-function Dt(l) {
-  for (let t = l.firstChild, e = null; t; t = t.nextSibling) {
-    let n = t.nodeType == 1 ? t.nodeName.toLowerCase() : null;
-    n && ct.hasOwnProperty(n) && e ? (e.appendChild(t), t = e) : n == "li" ? e = t : n && (e = null);
+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 Pt(l, t) {
-  return (l.matches || l.msMatchesSelector || l.webkitMatchesSelector || l.mozMatchesSelector).call(l, t);
+function matches(dom, selector) {
+  return (dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector).call(dom, selector);
 }
-function H(l) {
-  let t = {};
-  for (let e in l)
-    t[e] = l[e];
-  return t;
+function copy(obj) {
+  let copy2 = {};
+  for (let prop in obj)
+    copy2[prop] = obj[prop];
+  return copy2;
 }
-function K(l, t) {
-  let e = t.schema.nodes;
-  for (let n in e) {
-    let i = e[n];
-    if (!i.allowsMarkType(l))
+function markMayApply(markType, nodeType) {
+  let nodes = nodeType.schema.nodes;
+  for (let name in nodes) {
+    let parent = nodes[name];
+    if (!parent.allowsMarkType(markType))
       continue;
-    let r = [], s = (o) => {
-      r.push(o);
-      for (let h = 0; h < o.edgeCount; h++) {
-        let { type: a, next: f } = o.edge(h);
-        if (a == t || r.indexOf(f) < 0 && s(f))
-          return !0;
+    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 (s(i.contentMatch))
-      return !0;
+    if (scan(parent.contentMatch))
+      return true;
   }
 }
-class ut {
+class DOMSerializer {
   /**
   Create a serializer. `nodes` should map node names to functions
   that take a node and return a description of the corresponding
@@ -2556,8 +2993,9 @@ class ut {
   serializer may be `null` to indicate that marks of that type
   should not be serialized.
   */
-  constructor(t, e) {
-    this.nodes = t, this.marks = e;
+  constructor(nodes, marks) {
+    this.nodes = nodes;
+    this.marks = marks;
   }
   /**
   Serialize the content of this fragment to a DOM fragment. When
@@ -2565,43 +3003,51 @@ class ut {
   document, should be passed so that the serializer can create
   nodes.
   */
-  serializeFragment(t, e = {}, n) {
-    n || (n = R(e).createDocumentFragment());
-    let i = n, r = [];
-    return t.forEach((s) => {
-      if (r.length || s.marks.length) {
-        let o = 0, h = 0;
-        for (; o < r.length && h < s.marks.length; ) {
-          let a = s.marks[h];
-          if (!this.marks[a.type.name]) {
-            h++;
+  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 (!a.eq(r[o][0]) || a.type.spec.spanning === !1)
+          if (!next.eq(active[keep][0]) || next.type.spec.spanning === false)
             break;
-          o++, h++;
+          keep++;
+          rendered++;
         }
-        for (; o < r.length; )
-          i = r.pop()[1];
-        for (; h < s.marks.length; ) {
-          let a = s.marks[h++], f = this.serializeMark(a, s.isInline, e);
-          f && (r.push([a, i]), i.appendChild(f.dom), i = f.contentDOM || f.dom);
+        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;
+          }
         }
       }
-      i.appendChild(this.serializeNodeInner(s, e));
-    }), n;
+      top.appendChild(this.serializeNodeInner(node, options));
+    });
+    return target;
   }
   /**
   @internal
   */
-  serializeNodeInner(t, e) {
-    let { dom: n, contentDOM: i } = T(R(e), this.nodes[t.type.name](t), null, t.attrs);
-    if (i) {
-      if (t.isLeaf)
+  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(t.content, e, i);
+      this.serializeFragment(node.content, options, contentDOM);
     }
-    return n;
+    return dom;
   }
   /**
   Serialize this node to a DOM node. This can be useful when you
@@ -2610,127 +3056,150 @@ class ut {
   [`serializeFragment`](https://prosemirror.net/docs/ref/#model.DOMSerializer.serializeFragment) on
   its [content](https://prosemirror.net/docs/ref/#model.Node.content).
   */
-  serializeNode(t, e = {}) {
-    let n = this.serializeNodeInner(t, e);
-    for (let i = t.marks.length - 1; i >= 0; i--) {
-      let r = this.serializeMark(t.marks[i], t.isInline, e);
-      r && ((r.contentDOM || r.dom).appendChild(n), n = r.dom);
+  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 n;
+    return dom;
   }
   /**
   @internal
   */
-  serializeMark(t, e, n = {}) {
-    let i = this.marks[t.type.name];
-    return i && T(R(n), i(t, e), null, t.attrs);
+  serializeMark(mark, inline, options = {}) {
+    let toDOM = this.marks[mark.type.name];
+    return toDOM && renderSpec(doc(options), toDOM(mark, inline), null, mark.attrs);
   }
-  static renderSpec(t, e, n = null, i) {
-    return T(t, e, n, i);
+  static renderSpec(doc2, structure, xmlNS = null, blockArraysIn) {
+    return renderSpec(doc2, 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(t) {
-    return t.cached.domSerializer || (t.cached.domSerializer = new ut(this.nodesFromSchema(t), this.marksFromSchema(t)));
+  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(t) {
-    let e = Q(t.nodes);
-    return e.text || (e.text = (n) => n.text), e;
+  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(t) {
-    return Q(t.marks);
-  }
-}
-function Q(l) {
-  let t = {};
-  for (let e in l) {
-    let n = l[e].spec.toDOM;
-    n && (t[e] = n);
+  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;
+}
+const 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]);
+      }
+    }
   }
-  return t;
-}
-function R(l) {
-  return l.document || window.document;
-}
-const X = /* @__PURE__ */ new WeakMap();
-function Bt(l) {
-  let t = X.get(l);
-  return t === void 0 && X.set(l, t = Ft(l)), t;
-}
-function Ft(l) {
-  let t = null;
-  function e(n) {
-    if (n && typeof n == "object")
-      if (Array.isArray(n))
-        if (typeof n[0] == "string")
-          t || (t = []), t.push(n);
-        else
-          for (let i = 0; i < n.length; i++)
-            e(n[i]);
-      else
-        for (let i in n)
-          e(n[i]);
-  }
-  return e(l), t;
-}
-function T(l, t, e, n) {
-  if (typeof t == "string")
-    return { dom: l.createTextNode(t) };
-  if (t.nodeType != null)
-    return { dom: t };
-  if (t.dom && t.dom.nodeType != null)
-    return t;
-  let i = t[0], r;
-  if (typeof i != "string")
+  scan(attrs);
+  return result;
+}
+function renderSpec(doc2, structure, xmlNS, blockArraysIn) {
+  if (typeof structure == "string")
+    return { dom: doc2.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 (n && (r = Bt(n)) && r.indexOf(t) > -1)
+  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 s = i.indexOf(" ");
-  s > 0 && (e = i.slice(0, s), i = i.slice(s + 1));
-  let o, h = e ? l.createElementNS(e, i) : l.createElement(i), a = t[1], f = 1;
-  if (a && typeof a == "object" && a.nodeType == null && !Array.isArray(a)) {
-    f = 2;
-    for (let p in a)
-      if (a[p] != null) {
-        let g = p.indexOf(" ");
-        g > 0 ? h.setAttributeNS(p.slice(0, g), p.slice(g + 1), a[p]) : h.setAttribute(p, a[p]);
+  let space = tagName.indexOf(" ");
+  if (space > 0) {
+    xmlNS = tagName.slice(0, space);
+    tagName = tagName.slice(space + 1);
+  }
+  let contentDOM;
+  let dom = xmlNS ? doc2.createElementNS(xmlNS, tagName) : doc2.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
+          dom.setAttribute(name, attrs[name]);
       }
   }
-  for (let p = f; p < t.length; p++) {
-    let g = t[p];
-    if (g === 0) {
-      if (p < t.length - 1 || p > f)
+  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: h, contentDOM: h };
+      return { dom, contentDOM: dom };
     } else {
-      let { dom: pt, contentDOM: J } = T(l, g, e, n);
-      if (h.appendChild(pt), J) {
-        if (o)
+      let { dom: inner, contentDOM: innerContent } = renderSpec(doc2, child, xmlNS, blockArraysIn);
+      dom.appendChild(inner);
+      if (innerContent) {
+        if (contentDOM)
           throw new RangeError("Multiple content holes");
-        o = J;
+        contentDOM = innerContent;
       }
     }
   }
-  return { dom: h, contentDOM: o };
+  return { dom, contentDOM };
 }
 export {
-  ut as D,
-  c as F,
-  u as M,
-  y as N,
-  I as R,
-  qt as S,
-  P as a,
-  d as b,
-  mt as c,
-  F as d
+  DOMSerializer as D,
+  Fragment as F,
+  Mark as M,
+  Node as N,
+  ReplaceError as R,
+  Schema as S,
+  DOMParser as a,
+  Slice as b,
+  NodeRange as c,
+  MarkType as d
 };