@quoreadmin/ui 1.10.24 → 1.10.25

package/dist/index319.js

@@ -1,1536 +1,2733 @@
-import { Slice as g, Fragment as w, Mark as se, MarkType as oe, ReplaceError as le } from "./index321.js";
-const Q = 65535, U = Math.pow(2, 16);
-function ae(s, e) {
-  return s + e * U;
-}
-function H(s) {
-  return s & Q;
+import q from "./index394.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;
+      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 (i.content.size || r.content.size) {
+      let s = Y(i.content, r.content, e + 1);
+      if (s != null)
+        return s;
+    }
+    e += i.nodeSize;
+  }
 }
-function he(s) {
-  return (s - (s & Q)) / U;
+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;
+      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 (s.content.size || o.content.size) {
+      let a = Z(s.content, o.content, e - 1, n - 1);
+      if (a)
+        return a;
+    }
+    e -= h, n -= h;
+  }
 }
-const V = 1, X = 2, J = 4, Y = 8;
-class L {
+class c {
   /**
   @internal
   */
-  constructor(e, t, r) {
-    this.pos = e, this.delInfo = t, this.recover = r;
-  }
-  /**
-  Tells you whether the position was deleted, that is, whether the
-  step removed the token on the side queried (via the `assoc`)
-  argument from the document.
-  */
-  get deleted() {
-    return (this.delInfo & Y) > 0;
+  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;
   }
   /**
-  Tells you whether the token before the mapped position was deleted.
+  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`.
   */
-  get deletedBefore() {
-    return (this.delInfo & (V | J)) > 0;
+  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);
+      }
+      o = a;
+    }
   }
   /**
-  True when the token after the mapped position was deleted.
+  Call the given callback for every descendant node. `pos` will be
+  relative to the start of the fragment. The callback may return
+  `false` to prevent traversal of a given node's children.
   */
-  get deletedAfter() {
-    return (this.delInfo & (X | J)) > 0;
+  descendants(t) {
+    this.nodesBetween(0, this.size, t);
   }
   /**
-  Tells whether any of the steps mapped through deletes across the
-  position (including both the token before and after the
-  position).
+  Extract the text between `from` and `to`. See the same method on
+  [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
   */
-  get deletedAcross() {
-    return (this.delInfo & J) > 0;
+  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;
   }
-}
-class S {
   /**
-  Create a position map. The modifications to the document are
-  represented as an array of numbers, in which each group of three
-  represents a modified chunk as `[start, oldSize, newSize]`.
+  Create a new fragment containing the combined content of this
+  fragment and the other.
   */
-  constructor(e, t = !1) {
-    if (this.ranges = e, this.inverted = t, !e.length && S.empty)
-      return S.empty;
+  append(t) {
+    if (!t.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);
   }
   /**
-  @internal
+  Cut out the sub-fragment between the two given positions.
   */
-  recover(e) {
-    let t = 0, r = H(e);
-    if (!this.inverted)
-      for (let n = 0; n < r; n++)
-        t += this.ranges[n * 3 + 2] - this.ranges[n * 3 + 1];
-    return this.ranges[r * 3] + t + he(e);
-  }
-  mapResult(e, t = 1) {
-    return this._map(e, t, !1);
-  }
-  map(e, t = 1) {
-    return this._map(e, t, !0);
+  cut(t, e = this.size) {
+    if (t == 0 && e == 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;
+      }
+    return new c(n, i);
   }
   /**
   @internal
   */
-  _map(e, t, r) {
-    let n = 0, i = this.inverted ? 2 : 1, o = this.inverted ? 1 : 2;
-    for (let l = 0; l < this.ranges.length; l += 3) {
-      let a = this.ranges[l] - (this.inverted ? n : 0);
-      if (a > e)
-        break;
-      let h = this.ranges[l + i], p = this.ranges[l + o], c = a + h;
-      if (e <= c) {
-        let f = h ? e == a ? -1 : e == c ? 1 : t : t, d = a + n + (f < 0 ? 0 : p);
-        if (r)
-          return d;
-        let u = e == (t < 0 ? a : c) ? null : ae(l / 3, e - a), m = e == a ? X : e == c ? V : J;
-        return (t < 0 ? e != a : e != c) && (m |= Y), new L(d, m, u);
-      }
-      n += p - h;
-    }
-    return r ? e + n : new L(e + n, 0, null);
+  cutByIndex(t, e) {
+    return t == e ? c.empty : t == 0 && e == this.content.length ? this : new c(this.content.slice(t, e));
   }
   /**
-  @internal
+  Create a new fragment in which the node at the given index is
+  replaced by the given node.
   */
-  touches(e, t) {
-    let r = 0, n = H(t), i = this.inverted ? 2 : 1, o = this.inverted ? 1 : 2;
-    for (let l = 0; l < this.ranges.length; l += 3) {
-      let a = this.ranges[l] - (this.inverted ? r : 0);
-      if (a > e)
-        break;
-      let h = this.ranges[l + i], p = a + h;
-      if (e <= p && l == n * 3)
-        return !0;
-      r += this.ranges[l + o] - h;
-    }
-    return !1;
+  replaceChild(t, e) {
+    let n = this.content[t];
+    if (n == e)
+      return this;
+    let i = this.content.slice(), r = this.size + e.nodeSize - n.nodeSize;
+    return i[t] = e, new c(i, r);
   }
   /**
-  Calls the given function on each of the changed ranges included in
-  this map.
+  Create a new fragment by prepending the given node to this
+  fragment.
   */
-  forEach(e) {
-    let t = this.inverted ? 2 : 1, r = this.inverted ? 1 : 2;
-    for (let n = 0, i = 0; n < this.ranges.length; n += 3) {
-      let o = this.ranges[n], l = o - (this.inverted ? i : 0), a = o + (this.inverted ? 0 : i), h = this.ranges[n + t], p = this.ranges[n + r];
-      e(l, l + h, a, a + p), i += p - h;
-    }
+  addToStart(t) {
+    return new c([t].concat(this.content), this.size + t.nodeSize);
   }
   /**
-  Create an inverted version of this map. The result can be used to
-  map positions in the post-step document to the pre-step document.
+  Create a new fragment by appending the given node to this
+  fragment.
   */
-  invert() {
-    return new S(this.ranges, !this.inverted);
+  addToEnd(t) {
+    return new c(this.content.concat(t), this.size + t.nodeSize);
   }
   /**
-  @internal
+  Compare this fragment to another one.
   */
-  toString() {
-    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
+  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;
   }
   /**
-  Create a map that moves all positions by offset `n` (which may be
-  negative). This can be useful when applying steps meant for a
-  sub-document to a larger document, or vice-versa.
+  The first child of the fragment, or `null` if it is empty.
   */
-  static offset(e) {
-    return e == 0 ? S.empty : new S(e < 0 ? [0, -e, 0] : [0, 0, e]);
+  get firstChild() {
+    return this.content.length ? this.content[0] : null;
   }
-}
-S.empty = new S([]);
-class A {
   /**
-  Create a new mapping with the given position maps.
+  The last child of the fragment, or `null` if it is empty.
   */
-  constructor(e, t, r = 0, n = e ? e.length : 0) {
-    this.mirror = t, this.from = r, this.to = n, this._maps = e || [], this.ownData = !(e || t);
+  get lastChild() {
+    return this.content.length ? this.content[this.content.length - 1] : null;
   }
   /**
-  The step maps in this mapping.
+  The number of child nodes in this fragment.
   */
-  get maps() {
-    return this._maps;
+  get childCount() {
+    return this.content.length;
   }
   /**
-  Create a mapping that maps only through a part of this one.
+  Get the child node at the given index. Raise an error when the
+  index is out of range.
   */
-  slice(e = 0, t = this.maps.length) {
-    return new A(this._maps, this.mirror, e, t);
+  child(t) {
+    let e = this.content[t];
+    if (!e)
+      throw new RangeError("Index " + t + " out of range for " + this);
+    return e;
   }
   /**
-  Add a step map to the end of this mapping. If `mirrors` is
-  given, it should be the index of the step map that is the mirror
-  image of this one.
+  Get the child node at the given index, if it exists.
   */
-  appendMap(e, t) {
-    this.ownData || (this._maps = this._maps.slice(), this.mirror = this.mirror && this.mirror.slice(), this.ownData = !0), this.to = this._maps.push(e), t != null && this.setMirror(this._maps.length - 1, t);
+  maybeChild(t) {
+    return this.content[t] || null;
   }
   /**
-  Add all the step maps in a given mapping to this one (preserving
-  mirroring information).
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
   */
-  appendMapping(e) {
-    for (let t = 0, r = this._maps.length; t < e._maps.length; t++) {
-      let n = e.getMirror(t);
-      this.appendMap(e._maps[t], n != null && n < t ? r + n : void 0);
+  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;
     }
   }
   /**
-  Finds the offset of the step map that mirrors the map at the
-  given offset, in this mapping (as per the second argument to
-  `appendMap`).
+  Find the first position at which this fragment and another
+  fragment differ, or `null` if they are the same.
   */
-  getMirror(e) {
-    if (this.mirror) {
-      for (let t = 0; t < this.mirror.length; t++)
-        if (this.mirror[t] == e)
-          return this.mirror[t + (t % 2 ? -1 : 1)];
-    }
+  findDiffStart(t, e = 0) {
+    return Y(this, t, e);
   }
   /**
-  @internal
+  Find the first position, searching from the end, at which this
+  fragment and the given fragment differ, or `null` if they are
+  the same. Since this position will not be the same in both
+  nodes, an object with two separate positions is returned.
   */
-  setMirror(e, t) {
-    this.mirror || (this.mirror = []), this.mirror.push(e, t);
+  findDiffEnd(t, e = this.size, n = t.size) {
+    return Z(this, t, e, n);
   }
   /**
-  Append the inverse of the given mapping to this one.
+  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
   */
-  appendMappingInverted(e) {
-    for (let t = e.maps.length - 1, r = this._maps.length + e._maps.length; t >= 0; t--) {
-      let n = e.getMirror(t);
-      this.appendMap(e._maps[t].invert(), n != null && n > t ? r - n - 1 : void 0);
+  findIndex(t) {
+    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 e = 0, n = 0; ; e++) {
+      let i = this.child(e), r = n + i.nodeSize;
+      if (r >= t)
+        return r == t ? O(e + 1, r) : O(e, n);
+      n = r;
     }
   }
   /**
-  Create an inverted version of this mapping.
+  Return a debugging string that describes this fragment.
   */
-  invert() {
-    let e = new A();
-    return e.appendMappingInverted(this), e;
+  toString() {
+    return "<" + this.toStringInner() + ">";
   }
   /**
-  Map a position through this mapping.
+  @internal
   */
-  map(e, t = 1) {
-    if (this.mirror)
-      return this._map(e, t, !0);
-    for (let r = this.from; r < this.to; r++)
-      e = this._maps[r].map(e, t);
-    return e;
+  toStringInner() {
+    return this.content.join(", ");
   }
   /**
-  Map a position through this mapping, returning a mapping
-  result.
+  Create a JSON-serializeable representation of this fragment.
   */
-  mapResult(e, t = 1) {
-    return this._map(e, t, !1);
+  toJSON() {
+    return this.content.length ? this.content.map((t) => t.toJSON()) : null;
   }
   /**
-  @internal
+  Deserialize a fragment from its JSON representation.
   */
-  _map(e, t, r) {
-    let n = 0;
-    for (let i = this.from; i < this.to; i++) {
-      let o = this._maps[i], l = o.mapResult(e, t);
-      if (l.recover != null) {
-        let a = this.getMirror(i);
-        if (a != null && a > i && a < this.to) {
-          i = a, e = this._maps[a].recover(l.recover);
-          continue;
-        }
-      }
-      n |= l.delInfo, e = l.pos;
-    }
-    return r ? e : new L(e, n, null);
+  static fromJSON(t, e) {
+    if (!e)
+      return c.empty;
+    if (!Array.isArray(e))
+      throw new RangeError("Invalid input for Fragment.fromJSON");
+    return new c(e.map(t.nodeFromJSON));
   }
-}
-const B = /* @__PURE__ */ Object.create(null);
-class k {
   /**
-  Get the step map that represents the changes made by this step,
-  and which can be used to transform between positions in the old
-  and the new document.
+  Build a fragment from an array of nodes. Ensures that adjacent
+  text nodes with the same marks are joined together.
   */
-  getMap() {
-    return S.empty;
+  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);
+    }
+    return new c(e || t, n);
   }
   /**
-  Try to merge this step with another one, to be applied directly
-  after it. Returns the merged step when possible, null if the
-  steps can't be merged.
+  Create a fragment from something that can be interpreted as a
+  set of nodes. For `null`, it returns the empty fragment. For a
+  fragment, the fragment itself. For a node or array of nodes, a
+  fragment containing those nodes.
   */
-  merge(e) {
-    return null;
+  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 N = { index: 0, offset: 0 };
+function O(l, t) {
+  return N.index = l, N.offset = t, N;
+}
+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;
+  } 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;
+  }
+  return !0;
+}
+class u {
   /**
-  Deserialize a step from its JSON representation. Will call
-  through to the step class' own implementation of this method.
+  @internal
   */
-  static fromJSON(e, t) {
-    if (!t || !t.stepType)
-      throw new RangeError("Invalid input for Step.fromJSON");
-    let r = B[t.stepType];
-    if (!r)
-      throw new RangeError(`No step type ${t.stepType} defined`);
-    return r.fromJSON(e, t);
+  constructor(t, e) {
+    this.type = t, this.attrs = e;
   }
   /**
-  To be able to serialize steps to JSON, each step needs a string
-  ID to attach to its JSON representation. Use this method to
-  register an ID for your step classes. Try to pick something
-  that's unlikely to clash with steps from other modules.
+  Given a set of marks, create a new set which contains this one as
+  well, in the right position. If this mark is already in the set,
+  the set itself is returned. If any marks that are set to be
+  [exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
+  those are replaced by this one.
   */
-  static jsonID(e, t) {
-    if (e in B)
-      throw new RangeError("Duplicate use of step JSON ID " + e);
-    return B[e] = t, t.prototype.jsonID = e, t;
+  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);
+      }
+    }
+    return e || (e = t.slice()), n || e.push(this), e;
   }
-}
-class y {
   /**
-  @internal
+  Remove this mark from the given set, returning a new set. If this
+  mark is not in the set, the set itself is returned.
   */
-  constructor(e, t) {
-    this.doc = e, this.failed = t;
+  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;
   }
   /**
-  Create a successful step result.
+  Test whether this mark is in the given set of marks.
   */
-  static ok(e) {
-    return new y(e, null);
+  isInSet(t) {
+    for (let e = 0; e < t.length; e++)
+      if (this.eq(t[e]))
+        return !0;
+    return !1;
   }
   /**
-  Create a failed step result.
+  Test whether this mark has the same type and attributes as
+  another mark.
   */
-  static fail(e) {
-    return new y(null, e);
+  eq(t) {
+    return this == t || this.type == t.type && M(this.attrs, t.attrs);
   }
   /**
-  Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
-  arguments. Create a successful result if it succeeds, and a
-  failed one if it throws a `ReplaceError`.
+  Convert this mark to a JSON-serializeable representation.
   */
-  static fromReplace(e, t, r, n) {
-    try {
-      return y.ok(e.replace(t, r, n));
-    } catch (i) {
-      if (i instanceof le)
-        return y.fail(i.message);
-      throw i;
+  toJSON() {
+    let t = { type: this.type.name };
+    for (let e in this.attrs) {
+      t.attrs = this.attrs;
+      break;
     }
+    return t;
   }
-}
-function P(s, e, t) {
-  let r = [];
-  for (let n = 0; n < s.childCount; n++) {
-    let i = s.child(n);
-    i.content.size && (i = i.copy(P(i.content, e, i))), i.isInline && (i = e(i, t, n)), r.push(i);
-  }
-  return w.fromArray(r);
-}
-class C extends k {
   /**
-  Create a mark step.
+  Deserialize a mark from JSON.
   */
-  constructor(e, t, r) {
-    super(), this.from = e, this.to = t, this.mark = r;
-  }
-  apply(e) {
-    let t = e.slice(this.from, this.to), r = e.resolve(this.from), n = r.node(r.sharedDepth(this.to)), i = new g(P(t.content, (o, l) => !o.isAtom || !l.type.allowsMarkType(this.mark.type) ? o : o.mark(this.mark.addToSet(o.marks)), n), t.openStart, t.openEnd);
-    return y.fromReplace(e, this.from, this.to, i);
-  }
-  invert() {
-    return new b(this.from, this.to, this.mark);
-  }
-  map(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
-    return t.deleted && r.deleted || t.pos >= r.pos ? null : new C(t.pos, r.pos, this.mark);
-  }
-  merge(e) {
-    return e instanceof C && e.mark.eq(this.mark) && this.from <= e.to && this.to >= e.from ? new C(Math.min(this.from, e.from), Math.max(this.to, e.to), this.mark) : null;
+  static fromJSON(t, e) {
+    if (!e)
+      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;
   }
-  toJSON() {
-    return {
-      stepType: "addMark",
-      mark: this.mark.toJSON(),
-      from: this.from,
-      to: this.to
-    };
+  /**
+  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;
   }
   /**
-  @internal
+  Create a properly sorted mark set from null, a single mark, or an
+  unsorted array of marks.
   */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number")
-      throw new RangeError("Invalid input for AddMarkStep.fromJSON");
-    return new C(t.from, t.to, e.markFromJSON(t.mark));
+  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;
   }
 }
-k.jsonID("addMark", C);
-class b extends k {
+u.none = [];
+class I extends Error {
+}
+class d {
   /**
-  Create a mark-removing step.
+  Create a slice. When specifying a non-zero open depth, you must
+  make sure that there are nodes of at least that depth at the
+  appropriate side of the fragment—i.e. if the fragment is an
+  empty paragraph node, `openStart` and `openEnd` can't be greater
+  than 1.
+  
+  It is not necessary for the content of open nodes to conform to
+  the schema's content constraints, though it should be a valid
+  start/end/middle for such a node, depending on which sides are
+  open.
   */
-  constructor(e, t, r) {
-    super(), this.from = e, this.to = t, this.mark = r;
-  }
-  apply(e) {
-    let t = e.slice(this.from, this.to), r = new g(P(t.content, (n) => n.mark(this.mark.removeFromSet(n.marks)), e), t.openStart, t.openEnd);
-    return y.fromReplace(e, this.from, this.to, r);
-  }
-  invert() {
-    return new C(this.from, this.to, this.mark);
-  }
-  map(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
-    return t.deleted && r.deleted || t.pos >= r.pos ? null : new b(t.pos, r.pos, this.mark);
-  }
-  merge(e) {
-    return e instanceof b && e.mark.eq(this.mark) && this.from <= e.to && this.to >= e.from ? new b(Math.min(this.from, e.from), Math.max(this.to, e.to), this.mark) : null;
-  }
-  toJSON() {
-    return {
-      stepType: "removeMark",
-      mark: this.mark.toJSON(),
-      from: this.from,
-      to: this.to
-    };
+  constructor(t, e, n) {
+    this.content = t, this.openStart = e, this.openEnd = n;
   }
   /**
-  @internal
+  The size this slice would add when inserted into a document.
   */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number")
-      throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
-    return new b(t.from, t.to, e.markFromJSON(t.mark));
+  get size() {
+    return this.content.size - this.openStart - this.openEnd;
   }
-}
-k.jsonID("removeMark", b);
-class N extends k {
   /**
-  Create a node mark step.
+  @internal
   */
-  constructor(e, t) {
-    super(), this.pos = e, this.mark = t;
-  }
-  apply(e) {
-    let t = e.nodeAt(this.pos);
-    if (!t)
-      return y.fail("No node at mark step's position");
-    let r = t.type.create(t.attrs, null, this.mark.addToSet(t.marks));
-    return y.fromReplace(e, this.pos, this.pos + 1, new g(w.from(r), 0, t.isLeaf ? 0 : 1));
-  }
-  invert(e) {
-    let t = e.nodeAt(this.pos);
-    if (t) {
-      let r = this.mark.addToSet(t.marks);
-      if (r.length == t.marks.length) {
-        for (let n = 0; n < t.marks.length; n++)
-          if (!t.marks[n].isInSet(r))
-            return new N(this.pos, t.marks[n]);
-        return new N(this.pos, this.mark);
-      }
-    }
-    return new R(this.pos, this.mark);
-  }
-  map(e) {
-    let t = e.mapResult(this.pos, 1);
-    return t.deletedAfter ? null : new N(t.pos, this.mark);
-  }
-  toJSON() {
-    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  insertAt(t, e) {
+    let n = $(this.content, t + this.openStart, e);
+    return n && new d(n, this.openStart, this.openEnd);
   }
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.pos != "number")
-      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
-    return new N(t.pos, e.markFromJSON(t.mark));
+  removeBetween(t, e) {
+    return new d(_(this.content, t + this.openStart, e + this.openStart), this.openStart, this.openEnd);
   }
-}
-k.jsonID("addNodeMark", N);
-class R extends k {
   /**
-  Create a mark-removing step.
+  Tests whether this slice is equal to another slice.
   */
-  constructor(e, t) {
-    super(), this.pos = e, this.mark = t;
-  }
-  apply(e) {
-    let t = e.nodeAt(this.pos);
-    if (!t)
-      return y.fail("No node at mark step's position");
-    let r = t.type.create(t.attrs, null, this.mark.removeFromSet(t.marks));
-    return y.fromReplace(e, this.pos, this.pos + 1, new g(w.from(r), 0, t.isLeaf ? 0 : 1));
-  }
-  invert(e) {
-    let t = e.nodeAt(this.pos);
-    return !t || !this.mark.isInSet(t.marks) ? this : new N(this.pos, this.mark);
-  }
-  map(e) {
-    let t = e.mapResult(this.pos, 1);
-    return t.deletedAfter ? null : new R(t.pos, this.mark);
-  }
-  toJSON() {
-    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  eq(t) {
+    return this.content.eq(t.content) && this.openStart == t.openStart && this.openEnd == t.openEnd;
   }
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.pos != "number")
-      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
-    return new R(t.pos, e.markFromJSON(t.mark));
+  toString() {
+    return this.content + "(" + this.openStart + "," + this.openEnd + ")";
   }
-}
-k.jsonID("removeNodeMark", R);
-class v extends k {
   /**
-  The given `slice` should fit the 'gap' between `from` and
-  `to`—the depths must line up, and the surrounding nodes must be
-  able to be joined with the open sides of the slice. When
-  `structure` is true, the step will fail if the content between
-  from and to is not just a sequence of closing and then opening
-  tokens (this is to guard against rebased replace steps
-  overwriting something they weren't supposed to).
+  Convert a slice to a JSON-serializable representation.
   */
-  constructor(e, t, r, n = !1) {
-    super(), this.from = e, this.to = t, this.slice = r, this.structure = n;
-  }
-  apply(e) {
-    return this.structure && q(e, this.from, this.to) ? y.fail("Structure replace would overwrite content") : y.fromReplace(e, this.from, this.to, this.slice);
-  }
-  getMap() {
-    return new S([this.from, this.to - this.from, this.slice.size]);
-  }
-  invert(e) {
-    return new v(this.from, this.from + this.slice.size, e.slice(this.from, this.to));
-  }
-  map(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
-    return t.deletedAcross && r.deletedAcross ? null : new v(t.pos, Math.max(t.pos, r.pos), this.slice, this.structure);
-  }
-  merge(e) {
-    if (!(e instanceof v) || e.structure || this.structure)
-      return null;
-    if (this.from + this.slice.size == e.from && !this.slice.openEnd && !e.slice.openStart) {
-      let t = this.slice.size + e.slice.size == 0 ? g.empty : new g(this.slice.content.append(e.slice.content), this.slice.openStart, e.slice.openEnd);
-      return new v(this.from, this.to + (e.to - e.from), t, this.structure);
-    } else if (e.to == this.from && !this.slice.openStart && !e.slice.openEnd) {
-      let t = this.slice.size + e.slice.size == 0 ? g.empty : new g(e.slice.content.append(this.slice.content), e.slice.openStart, this.slice.openEnd);
-      return new v(e.from, this.to, t, this.structure);
-    } else
-      return null;
-  }
   toJSON() {
-    let e = { stepType: "replace", from: this.from, to: this.to };
-    return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+    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;
   }
   /**
-  @internal
+  Deserialize a slice from its JSON representation.
   */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number")
-      throw new RangeError("Invalid input for ReplaceStep.fromJSON");
-    return new v(t.from, t.to, g.fromJSON(e, t.slice), !!t.structure);
-  }
-}
-k.jsonID("replace", v);
-class M extends k {
-  /**
-  Create a replace-around step with the given range and gap.
-  `insert` should be the point in the slice into which the content
-  of the gap should be moved. `structure` has the same meaning as
-  it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
-  */
-  constructor(e, t, r, n, i, o, l = !1) {
-    super(), this.from = e, this.to = t, this.gapFrom = r, this.gapTo = n, this.slice = i, this.insert = o, this.structure = l;
-  }
-  apply(e) {
-    if (this.structure && (q(e, this.from, this.gapFrom) || q(e, this.gapTo, this.to)))
-      return y.fail("Structure gap-replace would overwrite content");
-    let t = e.slice(this.gapFrom, this.gapTo);
-    if (t.openStart || t.openEnd)
-      return y.fail("Gap is not a flat range");
-    let r = this.slice.insertAt(this.insert, t.content);
-    return r ? y.fromReplace(e, this.from, this.to, r) : y.fail("Content does not fit in gap");
-  }
-  getMap() {
-    return new S([
-      this.from,
-      this.gapFrom - this.from,
-      this.insert,
-      this.gapTo,
-      this.to - this.gapTo,
-      this.slice.size - this.insert
-    ]);
-  }
-  invert(e) {
-    let t = this.gapTo - this.gapFrom;
-    return new M(this.from, this.from + this.slice.size + t, this.from + this.insert, this.from + this.insert + t, e.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
-  }
-  map(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1), n = this.from == this.gapFrom ? t.pos : e.map(this.gapFrom, -1), i = this.to == this.gapTo ? r.pos : e.map(this.gapTo, 1);
-    return t.deletedAcross && r.deletedAcross || n < t.pos || i > r.pos ? null : new M(t.pos, r.pos, n, i, this.slice, this.insert, this.structure);
-  }
-  toJSON() {
-    let e = {
-      stepType: "replaceAround",
-      from: this.from,
-      to: this.to,
-      gapFrom: this.gapFrom,
-      gapTo: this.gapTo,
-      insert: this.insert
-    };
-    return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+  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")
+      throw new RangeError("Invalid input for Slice.fromJSON");
+    return new d(c.fromJSON(t, e.content), n, i);
   }
   /**
-  @internal
+  Create a slice from a fragment by taking the maximum possible
+  open value on both side of the fragment.
   */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number" || typeof t.gapFrom != "number" || typeof t.gapTo != "number" || typeof t.insert != "number")
-      throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
-    return new M(t.from, t.to, t.gapFrom, t.gapTo, g.fromJSON(e, t.slice), t.insert, !!t.structure);
-  }
-}
-k.jsonID("replaceAround", M);
-function q(s, e, t) {
-  let r = s.resolve(e), n = t - e, i = r.depth;
-  for (; n > 0 && i > 0 && r.indexAfter(i) == r.node(i).childCount; )
-    i--, n--;
-  if (n > 0) {
-    let o = r.node(i).maybeChild(r.indexAfter(i));
-    for (; n > 0; ) {
-      if (!o || o.isLeaf)
-        return !0;
-      o = o.firstChild, n--;
-    }
-  }
-  return !1;
-}
-function pe(s, e, t, r) {
-  let n = [], i = [], o, l;
-  s.doc.nodesBetween(e, t, (a, h, p) => {
-    if (!a.isInline)
-      return;
-    let c = a.marks;
-    if (!r.isInSet(c) && p.type.allowsMarkType(r.type)) {
-      let f = Math.max(h, e), d = Math.min(h + a.nodeSize, t), u = r.addToSet(c);
-      for (let m = 0; m < c.length; m++)
-        c[m].isInSet(u) || (o && o.to == f && o.mark.eq(c[m]) ? o.to = d : n.push(o = new b(f, d, c[m])));
-      l && l.to == f ? l.to = d : i.push(l = new C(f, d, r));
-    }
-  }), n.forEach((a) => s.step(a)), i.forEach((a) => s.step(a));
-}
-function fe(s, e, t, r) {
-  let n = [], i = 0;
-  s.doc.nodesBetween(e, t, (o, l) => {
-    if (!o.isInline)
-      return;
-    i++;
-    let a = null;
-    if (r instanceof oe) {
-      let h = o.marks, p;
-      for (; p = r.isInSet(h); )
-        (a || (a = [])).push(p), h = p.removeFromSet(h);
-    } else r ? r.isInSet(o.marks) && (a = [r]) : a = o.marks;
-    if (a && a.length) {
-      let h = Math.min(l + o.nodeSize, t);
-      for (let p = 0; p < a.length; p++) {
-        let c = a[p], f;
-        for (let d = 0; d < n.length; d++) {
-          let u = n[d];
-          u.step == i - 1 && c.eq(n[d].style) && (f = u);
-        }
-        f ? (f.to = h, f.step = i) : n.push({ style: c, from: Math.max(l, e), to: h, step: i });
-      }
-    }
-  }), n.forEach((o) => s.step(new b(o.from, o.to, o.style)));
-}
-function $(s, e, t, r = t.contentMatch, n = !0) {
-  let i = s.doc.nodeAt(e), o = [], l = e + 1;
-  for (let a = 0; a < i.childCount; a++) {
-    let h = i.child(a), p = l + h.nodeSize, c = r.matchType(h.type);
-    if (!c)
-      o.push(new v(l, p, g.empty));
-    else {
-      r = c;
-      for (let f = 0; f < h.marks.length; f++)
-        t.allowsMarkType(h.marks[f].type) || s.step(new b(l, p, h.marks[f]));
-      if (n && h.isText && t.whitespace != "pre") {
-        let f, d = /\r?\n|\r/g, u;
-        for (; f = d.exec(h.text); )
-          u || (u = new g(w.from(t.schema.text(" ", t.allowedMarks(h.marks))), 0, 0)), o.push(new v(l + f.index, l + f.index + f[0].length, u));
-      }
-    }
-    l = p;
-  }
-  if (!r.validEnd) {
-    let a = r.fillBefore(w.empty, !0);
-    s.replace(l, l, new g(a, 0, 0));
-  }
-  for (let a = o.length - 1; a >= 0; a--)
-    s.step(o[a]);
-}
-function ce(s, e, t) {
-  return (e == 0 || s.canReplace(e, s.childCount)) && (t == s.childCount || s.canReplace(0, t));
-}
-function Fe(s) {
-  let t = s.parent.content.cutByIndex(s.startIndex, s.endIndex);
-  for (let r = s.depth, n = 0, i = 0; ; --r) {
-    let o = s.$from.node(r), l = s.$from.index(r) + n, a = s.$to.indexAfter(r) - i;
-    if (r < s.depth && o.canReplace(l, a, t))
-      return r;
-    if (r == 0 || o.type.spec.isolating || !ce(o, l, a))
-      break;
-    l && (n = 1), a < o.childCount && (i = 1);
+  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);
   }
-  return null;
-}
-function de(s, e, t) {
-  let { $from: r, $to: n, depth: i } = e, o = r.before(i + 1), l = n.after(i + 1), a = o, h = l, p = w.empty, c = 0;
-  for (let u = i, m = !1; u > t; u--)
-    m || r.index(u) > 0 ? (m = !0, p = w.from(r.node(u).copy(p)), c++) : a--;
-  let f = w.empty, d = 0;
-  for (let u = i, m = !1; u > t; u--)
-    m || n.after(u + 1) < n.end(u) ? (m = !0, f = w.from(n.node(u).copy(f)), d++) : h++;
-  s.step(new M(a, h, o, l, new g(p.append(f), c, d), p.size - c, !0));
 }
-function ze(s, e, t = null, r = s) {
-  let n = ue(s, e), i = n && me(r, e);
-  return i ? n.map(K).concat({ type: e, attrs: t }).concat(i.map(K)) : null;
+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)
+      throw new RangeError("Removing non-flat range");
+    return l.cut(0, t).append(l.cut(e));
+  }
+  if (n != s)
+    throw new RangeError("Removing non-flat range");
+  return l.replaceChild(n, r.copy(_(r.content, t - i - 1, e - i - 1)));
 }
-function K(s) {
-  return { type: s, attrs: null };
+function $(l, t, e, n) {
+  let { index: i, offset: r } = l.findIndex(t), s = l.maybeChild(i);
+  if (r == t || s.isText)
+    return n && !n.canReplace(i, i, e) ? null : l.cut(0, t).append(e).append(l.cut(t));
+  let o = $(s.content, t - r - 1, e, s);
+  return o && l.replaceChild(i, s.copy(o));
 }
-function ue(s, e) {
-  let { parent: t, startIndex: r, endIndex: n } = s, i = t.contentMatchAt(r).findWrapping(e);
-  if (!i)
-    return null;
-  let o = i.length ? i[0] : e;
-  return t.canReplaceWith(r, n, o) ? i : null;
+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 me(s, e) {
-  let { parent: t, startIndex: r, endIndex: n } = s, i = t.child(r), o = e.contentMatch.findWrapping(i.type);
-  if (!o)
-    return null;
-  let a = (o.length ? o[o.length - 1] : e).contentMatch;
-  for (let h = r; a && h < n; h++)
-    a = a.matchType(t.child(h).type);
-  return !a || !a.validEnd ? null : o;
-}
-function ge(s, e, t) {
-  let r = w.empty;
-  for (let o = t.length - 1; o >= 0; o--) {
-    if (r.size) {
-      let l = t[o].type.contentMatch.matchFragment(r);
-      if (!l || !l.validEnd)
-        throw new RangeError("Wrapper type given to Transform.wrap does not form valid content of its parent wrapper");
-    }
-    r = w.from(t[o].type.create(t[o].attrs, r));
-  }
-  let n = e.start, i = e.end;
-  s.step(new M(n, i, n, i, new g(r, 0, 0), t.length, !0));
-}
-function we(s, e, t, r, n) {
-  if (!r.isTextblock)
-    throw new RangeError("Type given to setBlockType should be a textblock");
-  let i = s.steps.length;
-  s.doc.nodesBetween(e, t, (o, l) => {
-    let a = typeof n == "function" ? n(o) : n;
-    if (o.isTextblock && !o.hasMarkup(r, a) && ye(s.doc, s.mapping.slice(i).map(l), r)) {
-      let h = null;
-      if (r.schema.linebreakReplacement) {
-        let d = r.whitespace == "pre", u = !!r.contentMatch.matchType(r.schema.linebreakReplacement);
-        d && !u ? h = !1 : !d && u && (h = !0);
-      }
-      h === !1 && _(s, o, l, i), $(s, s.mapping.slice(i).map(l, 1), r, void 0, h === null);
-      let p = s.mapping.slice(i), c = p.map(l, 1), f = p.map(l + o.nodeSize, 1);
-      return s.step(new M(c, f, c + 1, f - 1, new g(w.from(r.create(a, null, o.marks)), 0, 0), 1, !0)), h === !0 && Z(s, o, l, i), !1;
+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 } = yt(e, l);
+      return m(r, nt(l, s, o, t, n));
     }
-  });
-}
-function Z(s, e, t, r) {
-  e.forEach((n, i) => {
-    if (n.isText) {
-      let o, l = /\r?\n|\r/g;
-      for (; o = l.exec(n.text); ) {
-        let a = s.mapping.slice(r).map(t + 1 + i + o.index);
-        s.replaceWith(a, a + 1, e.type.schema.linebreakReplacement.create());
-      }
-    }
-  });
-}
-function _(s, e, t, r) {
-  e.forEach((n, i) => {
-    if (n.type == n.type.schema.linebreakReplacement) {
-      let o = s.mapping.slice(r).map(t + 1 + i);
-      s.replaceWith(o, o + 1, e.type.schema.text(`
-`));
-    }
-  });
-}
-function ye(s, e, t) {
-  let r = s.resolve(e), n = r.index();
-  return r.parent.canReplaceWith(n, n + 1, t);
-}
-function ke(s, e, t, r, n) {
-  let i = s.doc.nodeAt(e);
-  if (!i)
-    throw new RangeError("No node at given position");
-  t || (t = i.type);
-  let o = t.create(r, null, n || i.marks);
-  if (i.isLeaf)
-    return s.replaceWith(e, e + i.nodeSize, o);
-  if (!t.validContent(i.content))
-    throw new RangeError("Invalid content for node type " + t.name);
-  s.step(new M(e, e + i.nodeSize, e + 1, e + i.nodeSize - 1, new g(w.from(o), 0, 0), 1, !0));
-}
-function Je(s, e, t = 1, r) {
-  let n = s.resolve(e), i = n.depth - t, o = r && r[r.length - 1] || n.parent;
-  if (i < 0 || n.parent.type.spec.isolating || !n.parent.canReplace(n.index(), n.parent.childCount) || !o.type.validContent(n.parent.content.cutByIndex(n.index(), n.parent.childCount)))
-    return !1;
-  for (let h = n.depth - 1, p = t - 2; h > i; h--, p--) {
-    let c = n.node(h), f = n.index(h);
-    if (c.type.spec.isolating)
-      return !1;
-    let d = c.content.cutByIndex(f, c.childCount), u = r && r[p + 1];
-    u && (d = d.replaceChild(0, u.type.create(u.attrs)));
-    let m = r && r[p] || c;
-    if (!c.canReplace(f + 1, c.childCount) || !m.type.validContent(d))
-      return !1;
-  }
-  let l = n.indexAfter(i), a = r && r[0];
-  return n.node(i).canReplaceWith(l, l, a ? a.type : n.node(i + 1).type);
-}
-function ve(s, e, t = 1, r) {
-  let n = s.doc.resolve(e), i = w.empty, o = w.empty;
-  for (let l = n.depth, a = n.depth - t, h = t - 1; l > a; l--, h--) {
-    i = w.from(n.node(l).copy(i));
-    let p = r && r[h];
-    o = w.from(p ? p.type.create(p.attrs, o) : n.node(l).copy(o));
-  }
-  s.step(new v(e, e, new g(i.append(o), t, t), !0));
-}
-function Ae(s, e) {
-  let t = s.resolve(e), r = t.index();
-  return j(t.nodeBefore, t.nodeAfter) && t.parent.canReplace(r, r + 1);
+  else return m(r, A(l, t, n));
 }
-function xe(s, e) {
-  e.content.size || s.type.compatibleContent(e.type);
-  let t = s.contentMatchAt(s.childCount), { linebreakReplacement: r } = s.type.schema;
-  for (let n = 0; n < e.childCount; n++) {
-    let i = e.child(n), o = i.type == r ? s.type.schema.nodes.text : i.type;
-    if (t = t.matchType(o), !t || !s.type.allowsMarks(i.marks))
-      return !1;
-  }
-  return t.validEnd;
+function et(l, t) {
+  if (!t.type.compatibleContent(l.type))
+    throw new I("Cannot join " + t.type.name + " onto " + l.type.name);
 }
-function j(s, e) {
-  return !!(s && e && !s.isLeaf && xe(s, e));
+function D(l, t, e) {
+  let n = l.node(e);
+  return et(n, t.node(e)), n;
 }
-function Be(s, e, t = -1) {
-  let r = s.resolve(e);
-  for (let n = r.depth; ; n--) {
-    let i, o, l = r.index(n);
-    if (n == r.depth ? (i = r.nodeBefore, o = r.nodeAfter) : t > 0 ? (i = r.node(n + 1), l++, o = r.node(n).maybeChild(l)) : (i = r.node(n).maybeChild(l - 1), o = r.node(n + 1)), i && !i.isTextblock && j(i, o) && r.node(n).canReplace(l, l + 1))
-      return e;
-    if (n == 0)
-      break;
-    e = t < 0 ? r.before(n) : r.after(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 Se(s, e, t) {
-  let r = null, { linebreakReplacement: n } = s.doc.type.schema, i = s.doc.resolve(e - t), o = i.node().type;
-  if (n && o.inlineContent) {
-    let p = o.whitespace == "pre", c = !!o.contentMatch.matchType(n);
-    p && !c ? r = !1 : !p && c && (r = !0);
-  }
-  let l = s.steps.length;
-  if (r === !1) {
-    let p = s.doc.resolve(e + t);
-    _(s, p.node(), p.before(), l);
-  }
-  o.inlineContent && $(s, e + t - 1, o, i.node().contentMatchAt(i.index()), r == null);
-  let a = s.mapping.slice(l), h = a.map(e - t);
-  if (s.step(new v(h, a.map(e + t, -1), g.empty, !0)), r === !0) {
-    let p = s.doc.resolve(h);
-    Z(s, p.node(), p.before(), s.steps.length);
-  }
-  return s;
+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 be(s, e, t) {
-  let r = s.resolve(e);
-  if (r.parent.canReplaceWith(r.index(), r.index(), t))
-    return e;
-  if (r.parentOffset == 0)
-    for (let n = r.depth - 1; n >= 0; n--) {
-      let i = r.index(n);
-      if (r.node(n).canReplaceWith(i, i, t))
-        return r.before(n + 1);
-      if (i > 0)
-        return null;
-    }
-  if (r.parentOffset == r.parent.content.size)
-    for (let n = r.depth - 1; n >= 0; n--) {
-      let i = r.indexAfter(n);
-      if (r.node(n).canReplaceWith(i, i, t))
-        return r.after(n + 1);
-      if (i < r.node(n).childCount)
-        return null;
-    }
-  return null;
+function m(l, t) {
+  return l.type.checkContent(t), l.copy(t);
 }
-function We(s, e, t) {
-  let r = s.resolve(e);
-  if (!t.content.size)
-    return e;
-  let n = t.content;
-  for (let i = 0; i < t.openStart; i++)
-    n = n.firstChild.content;
-  for (let i = 1; i <= (t.openStart == 0 && t.size ? 2 : 1); i++)
-    for (let o = r.depth; o >= 0; o--) {
-      let l = o == r.depth ? 0 : r.pos <= (r.start(o + 1) + r.end(o + 1)) / 2 ? -1 : 1, a = r.index(o) + (l > 0 ? 1 : 0), h = r.node(o), p = !1;
-      if (i == 1)
-        p = h.canReplace(a, a, n);
-      else {
-        let c = h.contentMatchAt(a).findWrapping(n.firstChild.type);
-        p = c && h.canReplaceWith(a, a, c[0]);
-      }
-      if (p)
-        return l == 0 ? r.pos : l < 0 ? r.before(o + 1) : r.after(o + 1);
-    }
-  return null;
+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 Me(s, e, t = e, r = g.empty) {
-  if (e == t && !r.size)
-    return null;
-  let n = s.resolve(e), i = s.resolve(t);
-  return ee(n, i, r) ? new v(e, t, r) : new Ce(n, i, r).fit();
-}
-function ee(s, e, t) {
-  return !t.openStart && !t.openEnd && s.start() == e.start() && s.parent.canReplace(s.index(), e.index(), t.content);
-}
-class Ce {
-  constructor(e, t, r) {
-    this.$from = e, this.$to = t, this.unplaced = r, this.frontier = [], this.placed = w.empty;
-    for (let n = 0; n <= e.depth; n++) {
-      let i = e.node(n);
-      this.frontier.push({
-        type: i.type,
-        match: i.contentMatchAt(e.indexAfter(n))
-      });
-    }
-    for (let n = e.depth; n > 0; n--)
-      this.placed = w.from(e.node(n).copy(this.placed));
-  }
-  get depth() {
-    return this.frontier.length - 1;
-  }
-  fit() {
-    for (; this.unplaced.size; ) {
-      let h = this.findFittable();
-      h ? this.placeNodes(h) : this.openMore() || this.dropNode();
-    }
-    let e = this.mustMoveInline(), t = this.placed.size - this.depth - this.$from.depth, r = this.$from, n = this.close(e < 0 ? this.$to : r.doc.resolve(e));
-    if (!n)
-      return null;
-    let i = this.placed, o = r.depth, l = n.depth;
-    for (; o && l && i.childCount == 1; )
-      i = i.firstChild.content, o--, l--;
-    let a = new g(i, o, l);
-    return e > -1 ? new M(r.pos, e, this.$to.pos, this.$to.end(), a, t) : a.size || r.pos != this.$to.pos ? new v(r.pos, n.pos, a) : null;
-  }
-  // Find a position on the start spine of `this.unplaced` that has
-  // content that can be moved somewhere on the frontier. Returns two
-  // depths, one for the slice and one for the frontier.
-  findFittable() {
-    let e = this.unplaced.openStart;
-    for (let t = this.unplaced.content, r = 0, n = this.unplaced.openEnd; r < e; r++) {
-      let i = t.firstChild;
-      if (t.childCount > 1 && (n = 0), i.type.spec.isolating && n <= r) {
-        e = r;
-        break;
-      }
-      t = i.content;
-    }
-    for (let t = 1; t <= 2; t++)
-      for (let r = t == 1 ? e : this.unplaced.openStart; r >= 0; r--) {
-        let n, i = null;
-        r ? (i = W(this.unplaced.content, r - 1).firstChild, n = i.content) : n = this.unplaced.content;
-        let o = n.firstChild;
-        for (let l = this.depth; l >= 0; l--) {
-          let { type: a, match: h } = this.frontier[l], p, c = null;
-          if (t == 1 && (o ? h.matchType(o.type) || (c = h.fillBefore(w.from(o), !1)) : i && a.compatibleContent(i.type)))
-            return { sliceDepth: r, frontierDepth: l, parent: i, inject: c };
-          if (t == 2 && o && (p = h.findWrapping(o.type)))
-            return { sliceDepth: r, frontierDepth: l, parent: i, wrap: p };
-          if (i && h.matchType(i.type))
-            break;
-        }
-      }
-  }
-  openMore() {
-    let { content: e, openStart: t, openEnd: r } = this.unplaced, n = W(e, t);
-    return !n.childCount || n.firstChild.isLeaf ? !1 : (this.unplaced = new g(e, t + 1, Math.max(r, n.size + t >= e.size - r ? t + 1 : 0)), !0);
-  }
-  dropNode() {
-    let { content: e, openStart: t, openEnd: r } = this.unplaced, n = W(e, t);
-    if (n.childCount <= 1 && t > 0) {
-      let i = e.size - t <= t + n.size;
-      this.unplaced = new g(O(e, t - 1, 1), t - 1, i ? t - 1 : r);
-    } else
-      this.unplaced = new g(O(e, t, 1), t, r);
-  }
-  // Move content from the unplaced slice at `sliceDepth` to the
-  // frontier node at `frontierDepth`. Close that frontier node when
-  // applicable.
-  placeNodes({ sliceDepth: e, frontierDepth: t, parent: r, inject: n, wrap: i }) {
-    for (; this.depth > t; )
-      this.closeFrontierNode();
-    if (i)
-      for (let m = 0; m < i.length; m++)
-        this.openFrontierNode(i[m]);
-    let o = this.unplaced, l = r ? r.content : o.content, a = o.openStart - e, h = 0, p = [], { match: c, type: f } = this.frontier[t];
-    if (n) {
-      for (let m = 0; m < n.childCount; m++)
-        p.push(n.child(m));
-      c = c.matchFragment(n);
-    }
-    let d = l.size + e - (o.content.size - o.openEnd);
-    for (; h < l.childCount; ) {
-      let m = l.child(h), x = c.matchType(m.type);
-      if (!x)
-        break;
-      h++, (h > 1 || a == 0 || m.content.size) && (c = x, p.push(te(m.mark(f.allowedMarks(m.marks)), h == 1 ? a : 0, h == l.childCount ? d : -1)));
-    }
-    let u = h == l.childCount;
-    u || (d = -1), this.placed = F(this.placed, t, w.from(p)), this.frontier[t].match = c, u && d < 0 && r && r.type == this.frontier[this.depth].type && this.frontier.length > 1 && this.closeFrontierNode();
-    for (let m = 0, x = l; m < d; m++) {
-      let I = x.lastChild;
-      this.frontier.push({ type: I.type, match: I.contentMatchAt(I.childCount) }), x = I.content;
-    }
-    this.unplaced = u ? e == 0 ? g.empty : new g(O(o.content, e - 1, 1), e - 1, d < 0 ? o.openEnd : e - 1) : new g(O(o.content, e, h), o.openStart, o.openEnd);
-  }
-  mustMoveInline() {
-    if (!this.$to.parent.isTextblock)
-      return -1;
-    let e = this.frontier[this.depth], t;
-    if (!e.type.isTextblock || !D(this.$to, this.$to.depth, e.type, e.match, !1) || this.$to.depth == this.depth && (t = this.findCloseLevel(this.$to)) && t.depth == this.depth)
-      return -1;
-    let { depth: r } = this.$to, n = this.$to.after(r);
-    for (; r > 1 && n == this.$to.end(--r); )
-      ++n;
-    return n;
-  }
-  findCloseLevel(e) {
-    e: for (let t = Math.min(this.depth, e.depth); t >= 0; t--) {
-      let { match: r, type: n } = this.frontier[t], i = t < e.depth && e.end(t + 1) == e.pos + (e.depth - (t + 1)), o = D(e, t, n, r, i);
-      if (o) {
-        for (let l = t - 1; l >= 0; l--) {
-          let { match: a, type: h } = this.frontier[l], p = D(e, l, h, a, !0);
-          if (!p || p.childCount)
-            continue e;
-        }
-        return { depth: t, fit: o, move: i ? e.doc.resolve(e.after(t + 1)) : e };
-      }
-    }
-  }
-  close(e) {
-    let t = this.findCloseLevel(e);
-    if (!t)
-      return null;
-    for (; this.depth > t.depth; )
-      this.closeFrontierNode();
-    t.fit.childCount && (this.placed = F(this.placed, t.depth, t.fit)), e = t.move;
-    for (let r = t.depth + 1; r <= e.depth; r++) {
-      let n = e.node(r), i = n.type.contentMatch.fillBefore(n.content, !0, e.index(r));
-      this.openFrontierNode(n.type, n.attrs, i);
-    }
-    return e;
-  }
-  openFrontierNode(e, t = null, r) {
-    let n = this.frontier[this.depth];
-    n.match = n.match.matchType(e), this.placed = F(this.placed, this.depth, w.from(e.create(t, r))), this.frontier.push({ type: e, match: e.contentMatch });
-  }
-  closeFrontierNode() {
-    let t = this.frontier.pop().match.fillBefore(w.empty, !0);
-    t.childCount && (this.placed = F(this.placed, this.frontier.length, t));
+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 O(s, e, t) {
-  return e == 0 ? s.cutByIndex(t, s.childCount) : s.replaceChild(0, s.firstChild.copy(O(s.firstChild.content, e - 1, t)));
-}
-function F(s, e, t) {
-  return e == 0 ? s.append(t) : s.replaceChild(s.childCount - 1, s.lastChild.copy(F(s.lastChild.content, e - 1, t)));
-}
-function W(s, e) {
-  for (let t = 0; t < e; t++)
-    s = s.firstChild.content;
-  return s;
-}
-function te(s, e, t) {
-  if (e <= 0)
-    return s;
-  let r = s.content;
-  return e > 1 && (r = r.replaceChild(0, te(r.firstChild, e - 1, r.childCount == 1 ? t - 1 : 0))), e > 0 && (r = s.type.contentMatch.fillBefore(r).append(r), t <= 0 && (r = r.append(s.type.contentMatch.matchFragment(r).fillBefore(w.empty, !0)))), s.copy(r);
-}
-function D(s, e, t, r, n) {
-  let i = s.node(e), o = n ? s.indexAfter(e) : s.index(e);
-  if (o == i.childCount && !t.compatibleContent(i.type))
-    return null;
-  let l = r.fillBefore(i.content, !0, o);
-  return l && !Ne(t, i.content, o) ? l : null;
-}
-function Ne(s, e, t) {
-  for (let r = t; r < e.childCount; r++)
-    if (!s.allowsMarks(e.child(r).marks))
-      return !0;
-  return !1;
-}
-function Ie(s) {
-  return s.spec.defining || s.spec.definingForContent;
-}
-function Re(s, e, t, r) {
-  if (!r.size)
-    return s.deleteRange(e, t);
-  let n = s.doc.resolve(e), i = s.doc.resolve(t);
-  if (ee(n, i, r))
-    return s.step(new v(e, t, r));
-  let o = ne(n, i);
-  o[o.length - 1] == 0 && o.pop();
-  let l = -(n.depth + 1);
-  o.unshift(l);
-  for (let f = n.depth, d = n.pos - 1; f > 0; f--, d--) {
-    let u = n.node(f).type.spec;
-    if (u.defining || u.definingAsContext || u.isolating)
-      break;
-    o.indexOf(f) > -1 ? l = f : n.before(f) == d && o.splice(1, 0, -f);
-  }
-  let a = o.indexOf(l), h = [], p = r.openStart;
-  for (let f = r.content, d = 0; ; d++) {
-    let u = f.firstChild;
-    if (h.push(u), d == r.openStart)
-      break;
-    f = u.content;
-  }
-  for (let f = p - 1; f >= 0; f--) {
-    let d = h[f], u = Ie(d.type);
-    if (u && !d.sameMarkup(n.node(Math.abs(l) - 1)))
-      p = f;
-    else if (u || !d.type.isTextblock)
-      break;
-  }
-  for (let f = r.openStart; f >= 0; f--) {
-    let d = (f + p + 1) % (r.openStart + 1), u = h[d];
-    if (u)
-      for (let m = 0; m < o.length; m++) {
-        let x = o[(m + a) % o.length], I = !0;
-        x < 0 && (I = !1, x = -x);
-        let ie = n.node(x - 1), G = n.index(x - 1);
-        if (ie.canReplaceWith(G, G, u.type, u.marks))
-          return s.replace(n.before(x), I ? i.after(x) : t, new g(re(r.content, 0, r.openStart, d), d, r.openEnd));
-      }
-  }
-  let c = s.steps.length;
-  for (let f = o.length - 1; f >= 0 && (s.replace(e, t, r), !(s.steps.length > c)); f--) {
-    let d = o[f];
-    d < 0 || (e = n.before(d), t = i.after(d));
-  }
-}
-function re(s, e, t, r, n) {
-  if (e < t) {
-    let i = s.firstChild;
-    s = s.replaceChild(0, i.copy(re(i.content, e + 1, t, r, i)));
-  }
-  if (e > r) {
-    let i = n.contentMatchAt(0), o = i.fillBefore(s).append(s);
-    s = o.append(i.matchFragment(o).fillBefore(w.empty, !0));
-  }
-  return s;
-}
-function Ee(s, e, t, r) {
-  if (!r.isInline && e == t && s.doc.resolve(e).parent.content.size) {
-    let n = be(s.doc, e, r.type);
-    n != null && (e = t = n);
-  }
-  s.replaceRange(e, t, new g(w.from(r), 0, 0));
-}
-function Te(s, e, t) {
-  let r = s.doc.resolve(e), n = s.doc.resolve(t), i = ne(r, n);
-  for (let o = 0; o < i.length; o++) {
-    let l = i[o], a = o == i.length - 1;
-    if (a && l == 0 || r.node(l).type.contentMatch.validEnd)
-      return s.delete(r.start(l), n.end(l));
-    if (l > 0 && (a || r.node(l - 1).canReplace(r.index(l - 1), n.indexAfter(l - 1))))
-      return s.delete(r.before(l), n.after(l));
-  }
-  for (let o = 1; o <= r.depth && o <= n.depth; o++)
-    if (e - r.start(o) == r.depth - o && t > r.end(o) && n.end(o) - t != n.depth - o && r.start(o - 1) == n.start(o - 1) && r.node(o - 1).canReplace(r.index(o - 1), n.index(o - 1)))
-      return s.delete(r.before(o), t);
-  s.delete(e, t);
-}
-function ne(s, e) {
-  let t = [], r = Math.min(s.depth, e.depth);
-  for (let n = r; n >= 0; n--) {
-    let i = s.start(n);
-    if (i < s.pos - (s.depth - n) || e.end(n) > e.pos + (e.depth - n) || s.node(n).type.spec.isolating || e.node(n).type.spec.isolating)
-      break;
-    (i == e.start(n) || n == s.depth && n == e.depth && s.parent.inlineContent && e.parent.inlineContent && n && e.start(n - 1) == i - 1) && t.push(n);
-  }
-  return t;
+function yt(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));
+  return {
+    start: i.resolveNoCache(l.openStart + e),
+    end: i.resolveNoCache(i.content.size - l.openEnd - e)
+  };
 }
-class E extends k {
+class E {
   /**
-  Construct an attribute step.
+  @internal
   */
-  constructor(e, t, r) {
-    super(), this.pos = e, this.attr = t, this.value = r;
-  }
-  apply(e) {
-    let t = e.nodeAt(this.pos);
-    if (!t)
-      return y.fail("No node at attribute step's position");
-    let r = /* @__PURE__ */ Object.create(null);
-    for (let i in t.attrs)
-      r[i] = t.attrs[i];
-    r[this.attr] = this.value;
-    let n = t.type.create(r, null, t.marks);
-    return y.fromReplace(e, this.pos, this.pos + 1, new g(w.from(n), 0, t.isLeaf ? 0 : 1));
-  }
-  getMap() {
-    return S.empty;
-  }
-  invert(e) {
-    return new E(this.pos, this.attr, e.nodeAt(this.pos).attrs[this.attr]);
-  }
-  map(e) {
-    let t = e.mapResult(this.pos, 1);
-    return t.deletedAfter ? null : new E(t.pos, this.attr, this.value);
+  constructor(t, e, n) {
+    this.pos = t, this.path = e, this.parentOffset = n, this.depth = e.length / 3 - 1;
   }
-  toJSON() {
-    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
-  }
-  static fromJSON(e, t) {
-    if (typeof t.pos != "number" || typeof t.attr != "string")
-      throw new RangeError("Invalid input for AttrStep.fromJSON");
-    return new E(t.pos, t.attr, t.value);
-  }
-}
-k.jsonID("attr", E);
-class z extends k {
   /**
-  Construct an attribute step.
+  @internal
   */
-  constructor(e, t) {
-    super(), this.attr = e, this.value = t;
-  }
-  apply(e) {
-    let t = /* @__PURE__ */ Object.create(null);
-    for (let n in e.attrs)
-      t[n] = e.attrs[n];
-    t[this.attr] = this.value;
-    let r = e.type.create(t, e.content, e.marks);
-    return y.ok(r);
-  }
-  getMap() {
-    return S.empty;
-  }
-  invert(e) {
-    return new z(this.attr, e.attrs[this.attr]);
-  }
-  map(e) {
-    return this;
-  }
-  toJSON() {
-    return { stepType: "docAttr", attr: this.attr, value: this.value };
-  }
-  static fromJSON(e, t) {
-    if (typeof t.attr != "string")
-      throw new RangeError("Invalid input for DocAttrStep.fromJSON");
-    return new z(t.attr, t.value);
+  resolveDepth(t) {
+    return t == null ? this.depth : t < 0 ? this.depth + t : t;
   }
-}
-k.jsonID("docAttr", z);
-let T = class extends Error {
-};
-T = function s(e) {
-  let t = Error.call(this, e);
-  return t.__proto__ = s.prototype, t;
-};
-T.prototype = Object.create(Error.prototype);
-T.prototype.constructor = T;
-T.prototype.name = "TransformError";
-class De {
   /**
-  Create a transform that starts with the given document.
+  The parent node that the position points into. Note that even if
+  a position points into a text node, that node is not considered
+  the parent—text nodes are ‘flat’ in this model, and have no content.
   */
-  constructor(e) {
-    this.doc = e, this.steps = [], this.docs = [], this.mapping = new A();
+  get parent() {
+    return this.node(this.depth);
   }
   /**
-  The starting document.
+  The root node in which the position was resolved.
   */
-  get before() {
-    return this.docs.length ? this.docs[0] : this.doc;
+  get doc() {
+    return this.node(0);
   }
   /**
-  Apply a new step in this transform, saving the result. Throws an
-  error when the step fails.
+  The ancestor node at the given level. `p.node(p.depth)` is the
+  same as `p.parent`.
   */
-  step(e) {
-    let t = this.maybeStep(e);
-    if (t.failed)
-      throw new T(t.failed);
-    return this;
+  node(t) {
+    return this.path[this.resolveDepth(t) * 3];
   }
   /**
-  Try to apply a step in this transformation, ignoring it if it
-  fails. Returns the step result.
+  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.
   */
-  maybeStep(e) {
-    let t = e.apply(this.doc);
-    return t.failed || this.addStep(e, t.doc), t;
+  index(t) {
+    return this.path[this.resolveDepth(t) * 3 + 1];
   }
   /**
-  True when the document has been changed (when there are any
-  steps).
+  The index pointing after this position into the ancestor at the
+  given level.
   */
-  get docChanged() {
-    return this.steps.length > 0;
+  indexAfter(t) {
+    return t = this.resolveDepth(t), this.index(t) + (t == this.depth && !this.textOffset ? 0 : 1);
   }
   /**
-  Return a single range, in post-transform document positions,
-  that covers all content changed by this transform. Returns null
-  if no replacements are made. Note that this will ignore changes
-  that add/remove marks without replacing the underlying content.
+  The (absolute) position at the start of the node at the given
+  level.
   */
-  changedRange() {
-    let e = 1e9, t = -1e9;
-    for (let r = 0; r < this.mapping.maps.length; r++) {
-      let n = this.mapping.maps[r];
-      r && (e = n.map(e, 1), t = n.map(t, -1)), n.forEach((i, o, l, a) => {
-        e = Math.min(e, l), t = Math.max(t, a);
-      });
-    }
-    return e == 1e9 ? null : { from: e, to: t };
+  start(t) {
+    return t = this.resolveDepth(t), t == 0 ? 0 : this.path[t * 3 - 1] + 1;
   }
   /**
-  @internal
+  The (absolute) position at the end of the node at the given
+  level.
   */
-  addStep(e, t) {
-    this.docs.push(this.doc), this.steps.push(e), this.mapping.appendMap(e.getMap()), this.doc = t;
+  end(t) {
+    return t = this.resolveDepth(t), this.start(t) + this.node(t).content.size;
   }
   /**
-  Replace the part of the document between `from` and `to` with the
-  given `slice`.
+  The (absolute) position directly before the wrapping node at the
+  given level, or, when `depth` is `this.depth + 1`, the original
+  position.
   */
-  replace(e, t = e, r = g.empty) {
-    let n = Me(this.doc, e, t, r);
-    return n && this.step(n), this;
+  before(t) {
+    if (t = this.resolveDepth(t), !t)
+      throw new RangeError("There is no position before the top-level node");
+    return t == this.depth + 1 ? this.pos : this.path[t * 3 - 1];
   }
   /**
-  Replace the given range with the given content, which may be a
-  fragment, node, or array of nodes.
+  The (absolute) position directly after the wrapping node at the
+  given level, or the original position when `depth` is `this.depth + 1`.
   */
-  replaceWith(e, t, r) {
-    return this.replace(e, t, new g(w.from(r), 0, 0));
+  after(t) {
+    if (t = this.resolveDepth(t), !t)
+      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;
   }
   /**
-  Delete the content between the given positions.
+  When this position points into a text node, this returns the
+  distance between the position and the start of the text node.
+  Will be zero for positions that point between nodes.
   */
-  delete(e, t) {
-    return this.replace(e, t, g.empty);
+  get textOffset() {
+    return this.pos - this.path[this.path.length - 1];
   }
   /**
-  Insert the given content at the given position.
+  Get the node directly after the position, if any. If the position
+  points into a text node, only the part of that node after the
+  position is returned.
   */
-  insert(e, t) {
-    return this.replaceWith(e, e, t);
+  get nodeAfter() {
+    let t = this.parent, e = this.index(this.depth);
+    if (e == t.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;
   }
   /**
-  Replace a range of the document with a given slice, using
-  `from`, `to`, and the slice's
-  [`openStart`](https://prosemirror.net/docs/ref/#model.Slice.openStart) property as hints, rather
-  than fixed start and end points. This method may grow the
-  replaced area or close open nodes in the slice in order to get a
-  fit that is more in line with WYSIWYG expectations, by dropping
-  fully covered parent nodes of the replaced region when they are
-  marked [non-defining as
-  context](https://prosemirror.net/docs/ref/#model.NodeSpec.definingAsContext), or including an
-  open parent node from the slice that _is_ marked as [defining
-  its content](https://prosemirror.net/docs/ref/#model.NodeSpec.definingForContent).
-  
-  This is the method, for example, to handle paste. The similar
-  [`replace`](https://prosemirror.net/docs/ref/#transform.Transform.replace) method is a more
-  primitive tool which will _not_ move the start and end of its given
-  range, and is useful in situations where you need more precise
-  control over what happens.
+  Get the node directly before the position, if any. If the
+  position points into a text node, only the part of that node
+  before the position is returned.
   */
-  replaceRange(e, t, r) {
-    return Re(this, e, t, r), this;
+  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);
   }
   /**
-  Replace the given range with a node, but use `from` and `to` as
-  hints, rather than precise positions. When from and to are the same
-  and are at the start or end of a parent node in which the given
-  node doesn't fit, this method may _move_ them out towards a parent
-  that does allow the given node to be placed. When the given range
-  completely covers a parent node, this method may completely replace
-  that parent node.
+  Get the position at the given index in the parent node at the
+  given depth (which defaults to `this.depth`).
   */
-  replaceRangeWith(e, t, r) {
-    return Ee(this, e, t, r), this;
+  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;
   }
   /**
-  Delete the given range, expanding it to cover fully covered
-  parent nodes until a valid replace is found.
+  Get the marks at this position, factoring in the surrounding
+  marks' [`inclusive`](https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive) property. If the
+  position is at the start of a non-empty node, the marks of the
+  node after it (if any) are returned.
   */
-  deleteRange(e, t) {
-    return Te(this, e, t), this;
+  marks() {
+    let t = this.parent, e = this.index();
+    if (t.content.size == 0)
+      return u.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;
+    }
+    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;
+  }
+  /**
+  Get the marks after the current position, if any, except those
+  that are non-inclusive and not present at position `$end`. This
+  is mostly useful for getting the set of marks to preserve after a
+  deletion. Will return `null` if this position is at the end of
+  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)
+      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;
   }
   /**
-  Split the content in the given range off from its parent, if there
-  is sibling content before or after it, and move it up the tree to
-  the depth specified by `target`. You'll probably want to use
-  [`liftTarget`](https://prosemirror.net/docs/ref/#transform.liftTarget) to compute `target`, to make
-  sure the lift is valid.
+  The depth up to which this position and the given (non-resolved)
+  position share the same parent nodes.
   */
-  lift(e, t) {
-    return de(this, e, t), this;
+  sharedDepth(t) {
+    for (let e = this.depth; e > 0; e--)
+      if (this.start(e) <= t && this.end(e) >= t)
+        return e;
+    return 0;
   }
   /**
-  Join the blocks around the given position. If depth is 2, their
-  last and first siblings are also joined, and so on.
+  Returns a range based on the place where this position and the
+  given position diverge around block content. If both point into
+  the same textblock, for example, a range around that textblock
+  will be returned. If they point into different blocks, the range
+  around those blocks in their shared ancestor is returned. You can
+  pass in an optional predicate that will be called with a parent
+  node to see if a range into that parent is acceptable.
   */
-  join(e, t = 1) {
-    return Se(this, e, t), this;
+  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);
+    return null;
   }
   /**
-  Wrap the given [range](https://prosemirror.net/docs/ref/#model.NodeRange) in the given set of wrappers.
-  The wrappers are assumed to be valid in this position, and should
-  probably be computed with [`findWrapping`](https://prosemirror.net/docs/ref/#transform.findWrapping).
+  Query whether the given position shares the same parent node.
   */
-  wrap(e, t) {
-    return ge(this, e, t), this;
+  sameParent(t) {
+    return this.pos - this.parentOffset == t.pos - t.parentOffset;
   }
   /**
-  Set the type of all textblocks (partly) between `from` and `to` to
-  the given node type with the given attributes.
+  Return the greater of this and the given position.
   */
-  setBlockType(e, t = e, r, n = null) {
-    return we(this, e, t, r, n), this;
+  max(t) {
+    return t.pos > this.pos ? t : this;
   }
   /**
-  Change the type, attributes, and/or marks of the node at `pos`.
-  When `type` isn't given, the existing node type is preserved,
+  Return the smaller of this and the given position.
   */
-  setNodeMarkup(e, t, r = null, n) {
-    return ke(this, e, t, r, n), this;
+  min(t) {
+    return t.pos < this.pos ? t : this;
   }
   /**
-  Set a single attribute on a given node to a new value.
-  The `pos` addresses the document content. Use `setDocAttribute`
-  to set attributes on the document itself.
+  @internal
   */
-  setNodeAttribute(e, t, r) {
-    return this.step(new E(e, t, r)), this;
+  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;
   }
   /**
-  Set a single attribute on the document to a new value.
+  @internal
   */
-  setDocAttribute(e, t) {
-    return this.step(new z(e, t)), this;
-  }
+  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))
+        break;
+      r = a - 1, i += h + 1;
+    }
+    return new E(e, n, r);
+  }
+  /**
+  @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;
+      }
+    else
+      L.set(t, n = new gt());
+    let i = n.elts[n.i] = E.resolve(t, e);
+    return n.i = (n.i + 1) % xt, i;
+  }
+}
+class gt {
+  constructor() {
+    this.elts = [], this.i = 0;
+  }
+}
+const xt = 12, L = /* @__PURE__ */ new WeakMap();
+class mt {
+  /**
+  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;
+  }
+  /**
+  The position at the start of the range.
+  */
+  get start() {
+    return this.$from.before(this.depth + 1);
+  }
+  /**
+  The position at the end of the range.
+  */
+  get end() {
+    return this.$to.after(this.depth + 1);
+  }
+  /**
+  The parent node that the range points into.
+  */
+  get parent() {
+    return this.$from.node(this.depth);
+  }
+  /**
+  The start index of the range in the parent node.
+  */
+  get startIndex() {
+    return this.$from.index(this.depth);
+  }
+  /**
+  The end index of the range in the parent node.
+  */
+  get endIndex() {
+    return this.$to.indexAfter(this.depth);
+  }
+}
+const wt = /* @__PURE__ */ Object.create(null);
+class g {
+  /**
+  @internal
+  */
+  constructor(t, e, n, i = u.none) {
+    this.type = t, this.attrs = e, this.marks = i, this.content = n || c.empty;
+  }
+  /**
+  The array of this node's child nodes.
+  */
+  get children() {
+    return this.content.content;
+  }
+  /**
+  The size of this node, as defined by the integer-based [indexing
+  scheme](https://prosemirror.net/docs/guide/#doc.indexing). For text nodes, this is the
+  amount of characters. For other leaf nodes, it is one. For
+  non-leaf nodes, it is the size of the content plus two (the
+  start and end token).
+  */
+  get nodeSize() {
+    return this.isLeaf ? 1 : 2 + this.content.size;
+  }
+  /**
+  The number of children that the node has.
+  */
+  get childCount() {
+    return this.content.childCount;
+  }
+  /**
+  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);
+  }
+  /**
+  Get the child node at the given index, if it exists.
+  */
+  maybeChild(t) {
+    return this.content.maybeChild(t);
+  }
+  /**
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
+  */
+  forEach(t) {
+    this.content.forEach(t);
+  }
+  /**
+  Invoke a callback for all descendant nodes recursively between
+  the given two positions that are relative to start of this
+  node's content. The callback is invoked with the node, its
+  position relative to the original node (method receiver),
+  its parent node, and its child index. When the callback returns
+  false for a given node, that node's children will not be
+  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);
+  }
+  /**
+  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);
+  }
+  /**
+  Concatenates all the text nodes found in this fragment and its
+  children.
+  */
+  get textContent() {
+    return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
+  }
+  /**
+  Get all text between positions `from` and `to`. When
+  `blockSeparator` is given, it will be inserted to separate text
+  from different block nodes. If `leafText` is given, it'll be
+  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);
+  }
+  /**
+  Returns this node's first child, or `null` if there are no
+  children.
+  */
+  get firstChild() {
+    return this.content.firstChild;
+  }
+  /**
+  Returns this node's last child, or `null` if there are no
+  children.
+  */
+  get lastChild() {
+    return this.content.lastChild;
+  }
+  /**
+  Test whether two nodes represent the same piece of document.
+  */
+  eq(t) {
+    return this == t || this.sameMarkup(t) && this.content.eq(t.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);
+  }
+  /**
+  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);
+  }
+  /**
+  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 g(this.type, this.attrs, t, 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 g(this.type, this.attrs, this.content, t);
+  }
+  /**
+  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 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);
+  }
+  /**
+  Replace the part of the document between the given positions with
+  the given slice. The slice must 'fit', meaning its open sides
+  must be able to connect to the surrounding content, and its
+  content nodes must be valid children for the node they are placed
+  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);
+  }
+  /**
+  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)
+        return null;
+      if (i == t || e.isText)
+        return e;
+      t -= i + 1;
+    }
+  }
+  /**
+  Find the (direct) child node after the given offset, if any,
+  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 };
+  }
+  /**
+  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)
+      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 };
+  }
+  /**
+  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 E.resolveCached(this, t);
+  }
+  /**
+  @internal
+  */
+  resolveNoCache(t) {
+    return E.resolve(this, t);
+  }
+  /**
+  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;
+  }
+  /**
+  True when this is a block (non-inline node)
+  */
+  get isBlock() {
+    return this.type.isBlock;
+  }
+  /**
+  True when this is a textblock node, a block node with inline
+  content.
+  */
+  get isTextblock() {
+    return this.type.isTextblock;
+  }
+  /**
+  True when this node allows inline content.
+  */
+  get inlineContent() {
+    return this.type.inlineContent;
+  }
+  /**
+  True when this is an inline node (a text node or a node that can
+  appear among text).
+  */
+  get isInline() {
+    return this.type.isInline;
+  }
+  /**
+  True when this is a text node.
+  */
+  get isText() {
+    return this.type.isText;
+  }
+  /**
+  True when this is a leaf node.
+  */
+  get isLeaf() {
+    return this.type.isLeaf;
+  }
+  /**
+  True when this is an atom, i.e. when it does not have directly
+  editable content. This is usually the same as `isLeaf`, but can
+  be configured with the [`atom` property](https://prosemirror.net/docs/ref/#model.NodeSpec.atom)
+  on a node's spec (typically used when the node is displayed as
+  an uneditable [node view](https://prosemirror.net/docs/ref/#view.NodeView)).
+  */
+  get isAtom() {
+    return this.type.isAtom;
+  }
+  /**
+  Return a string representation of this node for debugging
+  purposes.
+  */
+  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);
+  }
+  /**
+  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)
+      throw new Error("Called contentMatchAt on a node with invalid content");
+    return e;
+  }
+  /**
+  Test whether replacing the range between `from` and `to` (by
+  child index) with the given replacement fragment (which defaults
+  to the empty fragment) would leave the node's content valid. You
+  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;
+  }
+  /**
+  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;
+  }
+  /**
+  Test whether the given node's content could be appended to this
+  node. If that node is empty, this will only return true if there
+  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);
+  }
+  /**
+  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);
+    }
+    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());
+  }
+  /**
+  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;
+      break;
+    }
+    return this.content.size && (t.content = this.content.toJSON()), this.marks.length && (t.marks = this.marks.map((e) => e.toJSON())), t;
+  }
+  /**
+  Deserialize a node from its JSON representation.
+  */
+  static fromJSON(t, e) {
+    if (!e)
+      throw new RangeError("Invalid input for Node.fromJSON");
+    let n;
+    if (e.marks) {
+      if (!Array.isArray(e.marks))
+        throw new RangeError("Invalid mark data for Node.fromJSON");
+      n = e.marks.map(t.markFromJSON);
+    }
+    if (e.type == "text") {
+      if (typeof e.text != "string")
+        throw new RangeError("Invalid text node in JSON");
+      return t.text(e.text, n);
+    }
+    let i = c.fromJSON(t, e.content), r = t.nodeType(e.type).create(e.attrs, i, n);
+    return r.type.checkAttrs(r.attrs), r;
+  }
+}
+g.prototype.text = void 0;
+class z extends g {
+  /**
+  @internal
+  */
+  constructor(t, e, n, i) {
+    if (super(t, e, null, i), !n)
+      throw new RangeError("Empty text nodes are not allowed");
+    this.text = n;
+  }
+  toString() {
+    return this.type.spec.toDebugString ? this.type.spec.toDebugString(this) : it(this.marks, JSON.stringify(this.text));
+  }
+  get textContent() {
+    return this.text;
+  }
+  textBetween(t, e) {
+    return this.text.slice(t, e);
+  }
+  get nodeSize() {
+    return this.text.length;
+  }
+  mark(t) {
+    return t == this.marks ? this : new z(this.type, this.attrs, this.text, t);
+  }
+  withText(t) {
+    return t == this.text ? this : new z(this.type, this.attrs, t, this.marks);
+  }
+  cut(t = 0, e = this.text.length) {
+    return t == 0 && e == this.text.length ? this : this.withText(this.text.slice(t, e));
+  }
+  eq(t) {
+    return this.sameMarkup(t) && this.text == t.text;
+  }
+  toJSON() {
+    let t = super.toJSON();
+    return t.text = this.text, t;
+  }
+}
+function it(l, t) {
+  for (let e = l.length - 1; e >= 0; e--)
+    t = l[e].type.name + "(" + t + ")";
+  return t;
+}
+class w {
+  /**
+  @internal
+  */
+  constructor(t) {
+    this.validEnd = t, 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(bt(i));
+    return At(r, n), r;
+  }
+  /**
+  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;
+    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;
+  }
+  /**
+  @internal
+  */
+  get inlineContent() {
+    return this.next.length != 0 && this.next[0].type.isInline;
+  }
+  /**
+  Get the first matching node type at this match position that can
+  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;
+    }
+    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;
+  }
+  /**
+  Try to match the given fragment, and if that fails, see if it can
+  be made to match by inserting nodes in front of it. When
+  successful, return a fragment of inserted nodes (which may be
+  empty if nothing had to be inserted). When `toEnd` is true, only
+  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 y = r(p, o.concat(f));
+          if (y)
+            return y;
+        }
+      }
+      return null;
+    }
+    return r(this, []);
+  }
+  /**
+  Find a set of wrapping node types that would allow a node of the
+  given type to appear at this position. The result may be empty
+  (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;
+  }
+  /**
+  @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();
+      }
+      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);
+      }
+    }
+    return null;
+  }
+  /**
+  The number of outgoing edges this node has in the finite
+  automaton that describes the content expression.
+  */
+  get edgeCount() {
+    return this.next.length;
+  }
+  /**
+  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];
+  }
+  /**
+  @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);
+    }
+    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();
+  }
+  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 = Tt(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 = Ct(l, t);
+    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 Ct(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 Ot(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 Tt(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 = Ot(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 bt(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());
+      }
+    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 (s.type == "name")
+          return [n(o, void 0, s.value)];
+        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 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)
+          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 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) });
+    }
+    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);
+    }
+    r && t.err("Only non-generatable nodes (" + s.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)
+      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;
+      else
+        throw new RangeError("No value supplied for attribute " + n);
+    }
+    e[n] = i;
+  }
+  return e;
+}
+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 at(l, t) {
+  let e = /* @__PURE__ */ Object.create(null);
+  if (t)
+    for (let n in t)
+      e[n] = new vt(l, n, t[n]);
+  return e;
+}
+class v {
+  /**
+  @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";
+  }
+  /**
+  True if this is an inline type.
+  */
+  get isInline() {
+    return !this.isBlock;
+  }
+  /**
+  True if this is a textblock type, a block that contains inline
+  content.
+  */
+  get isTextblock() {
+    return this.isBlock && this.inlineContent;
+  }
+  /**
+  True for node types that allow no content.
+  */
+  get isLeaf() {
+    return this.contentMatch == w.empty;
+  }
+  /**
+  True when this node is an atom, i.e. when it does not have
+  directly editable content.
+  */
+  get isAtom() {
+    return this.isLeaf || !!this.spec.atom;
+  }
+  /**
+  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;
+  }
+  /**
+  The node type's [whitespace](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) option.
+  */
+  get whitespace() {
+    return this.spec.whitespace || (this.spec.code ? "pre" : "normal");
+  }
+  /**
+  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;
+  }
+  /**
+  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);
+  }
+  /**
+  @internal
+  */
+  computeAttrs(t) {
+    return !t && this.defaultAttrs ? this.defaultAttrs : ot(this.attrs, t);
+  }
+  /**
+  Create a `Node` of this type. The given attributes are
+  checked and defaulted (you can pass `null` to use the type's
+  defaults entirely, if no required attributes exist). `content`
+  may be a `Fragment`, a node, an array of nodes, or
+  `null`. Similarly `marks` may be `null` to default to the empty
+  set of marks.
+  */
+  create(t = null, e, n) {
+    if (this.isText)
+      throw new Error("NodeType.create can't construct text nodes");
+    return new g(this, this.computeAttrs(t), c.from(e), u.setFrom(n));
+  }
+  /**
+  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 g(this, this.computeAttrs(t), e, u.setFrom(n));
+  }
+  /**
+  Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but see if it is
+  necessary to add nodes to the start or end of the given fragment
+  to make it fit the node. If no fitting wrapping can be found,
+  return null. Note that, due to the fact that required nodes can
+  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)
+        return null;
+      e = s.append(e);
+    }
+    let i = this.contentMatch.matchFragment(e), r = i && i.fillBefore(c.empty, !0);
+    return r ? new g(this, t, e.append(r), u.setFrom(n)) : null;
+  }
+  /**
+  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;
+  }
+  /**
+  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)}`);
+  }
+  /**
+  @internal
+  */
+  checkAttrs(t) {
+    ht(this.attrs, t, "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;
+  }
+  /**
+  Test whether the given set of marks are allowed in this node.
+  */
+  allowsMarks(t) {
+    if (this.markSet == null)
+      return !0;
+    for (let e = 0; e < t.length; e++)
+      if (!this.allowsMarkType(t[e].type))
+        return !1;
+    return !0;
+  }
+  /**
+  Removes the marks that are not allowed in this node from the given set.
+  */
+  allowedMarks(t) {
+    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;
+  }
+  /**
+  @internal
+  */
+  static compile(t, e) {
+    let n = /* @__PURE__ */ Object.create(null);
+    t.forEach((r, s) => n[r] = new v(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)
+      throw new RangeError("Every schema needs a 'text' type");
+    for (let r in n.text.attrs)
+      throw new RangeError("The text node type should not have attributes");
+    return n;
+  }
+}
+function zt(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}`);
+  };
+}
+class vt {
+  constructor(t, e, n) {
+    this.hasDefault = Object.prototype.hasOwnProperty.call(n, "default"), this.default = n.default, this.validate = typeof n.validate == "string" ? zt(t, e, n.validate) : n.validate;
+  }
+  get isRequired() {
+    return !this.hasDefault;
+  }
+}
+class F {
+  /**
+  @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;
+  }
+  /**
+  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));
+  }
+  /**
+  @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;
+  }
+  /**
+  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;
+  }
+  /**
+  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];
+  }
+  /**
+  @internal
+  */
+  checkAttrs(t) {
+    ht(this.attrs, t, "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;
+  }
+}
+class qt {
+  /**
+  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 = v.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) {
+        if (this.linebreakReplacement)
+          throw new RangeError("Multiple linebreak nodes defined");
+        if (!r.isInline || !r.isLeaf)
+          throw new RangeError("Linebreak replacement nodes must be inline leaf nodes");
+        this.linebreakReplacement = r;
+      }
+      r.markSet = o == "_" ? null : o ? U(this, o.split(" ")) : o == "" || !r.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(" "));
+    }
+    this.nodeFromJSON = (i) => g.fromJSON(this, i), this.markFromJSON = (i) => u.fromJSON(this, i), 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
+  `NodeType` instance. Attributes will be extended with defaults,
+  `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 v) {
+      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);
+  }
+  /**
+  Create a text node in the schema. Empty text nodes are not
+  allowed.
+  */
+  text(t, e) {
+    let n = this.nodes.text;
+    return new z(n, n.defaultAttrs, t, u.setFrom(e));
+  }
+  /**
+  Create a mark with the given type and attributes.
+  */
+  mark(t, e) {
+    return typeof t == "string" && (t = this.marks[t]), t.create(e);
+  }
+  /**
+  @internal
+  */
+  nodeType(t) {
+    let e = this.nodes[t];
+    if (!e)
+      throw new RangeError("Unknown node type: " + t);
+    return e;
+  }
+}
+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);
+      }
+    if (!s)
+      throw new SyntaxError("Unknown mark type: '" + t[n] + "'");
+  }
+  return e;
+}
+function Nt(l) {
+  return l.tag != null;
+}
+function Rt(l) {
+  return l.style != null;
+}
+class P {
+  /**
+  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 (Nt(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);
+      }
+    }), 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);
+    });
+  }
+  /**
+  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();
+  }
+  /**
+  Parses the content of the given DOM node, like
+  [`parse`](https://prosemirror.net/docs/ref/#model.DOMParser.parse), and takes the same set of
+  options. But unlike that method, which produces a whole node,
+  this one returns a slice that is open at the sides, meaning that
+  the schema constraints aren't applied to the start of nodes to
+  the left of the input and the end of nodes at the end.
+  */
+  parseSlice(t, e = {}) {
+    let n = new G(this, e, !0);
+    return n.addAll(t, u.none, e.from, e.to), d.maxOpen(n.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)
+            continue;
+          r.attrs = s || void 0;
+        }
+        return r;
+      }
+    }
+  }
+  /**
+  @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,
+      // 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;
+      }
+    }
+  }
   /**
-  Add a mark to the node at position `pos`.
+  @internal
   */
-  addNodeMark(e, t) {
-    return this.step(new N(e, t)), this;
+  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)
+          break;
+      }
+      e.splice(s, 0, i);
+    }
+    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 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);
+      });
+    }
+    return e;
   }
   /**
-  Remove a mark (or all marks of the given type) from the node at
-  position `pos`.
+  Construct a DOM parser using the parsing rules listed in a
+  schema's [node specs](https://prosemirror.net/docs/ref/#model.NodeSpec.parseDOM), reordered by
+  [priority](https://prosemirror.net/docs/ref/#model.GenericParseRule.priority).
   */
-  removeNodeMark(e, t) {
-    let r = this.doc.nodeAt(e);
-    if (!r)
-      throw new RangeError("No node at position " + e);
-    if (t instanceof se)
-      t.isInSet(r.marks) && this.step(new R(e, t));
+  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 }, C = 1, B = 2, S = 4;
+function V(l, t, e) {
+  return t != null ? (t ? C : 0) | (t === "full" ? B : 0) : l && l.whitespace == "pre" ? C | B : e & ~S;
+}
+class T {
+  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 & S ? null : t.contentMatch);
+  }
+  findWrapping(t) {
+    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;
+      }
+    }
+    return this.match.findWrapping(t.type);
+  }
+  finish(t) {
+    if (!(this.options & C)) {
+      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));
+      }
+    }
+    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 ? S : 0);
+    i ? r = new T(i.type, i.attrs, u.none, !0, e.topMatch || i.type.contentMatch, s) : n ? r = new T(null, null, u.none, !0, null, s) : r = new T(t.schema.topNodeType, null, u.none, !0, null, s), this.nodes = [r], this.find = e.findPositions, this.needsBlock = !1;
+  }
+  get top() {
+    return this.nodes[this.open];
+  }
+  // Add a DOM node to the content. Text is inserted as text node,
+  // otherwise, the node is passed to `addElement` or, if it has a
+  // `style` attribute, `addElementWithStyles`.
+  addDOM(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 & C) > 0, { schema: s } = this.parser;
+    if (r === "full" || i.inlineContext(t) || /[^ \t\r\n\u000c]/.test(n)) {
+      if (r)
+        if (r === "full")
+          n = n.replace(/\r\n?/g, `
+`);
+        else if (s.linebreakReplacement && /[\r\n]/.test(n) && this.top.findWrapping(s.linebreakReplacement.create())) {
+          let o = n.split(/\r?\n|\r/);
+          for (let h = 0; h < o.length; h++)
+            h && this.insertNode(s.linebreakReplacement.create(), e, !0), o[h] && this.insertNode(s.text(o[h]), e, !/\S/.test(o[h]));
+          n = "";
+        } else
+          n = n.replace(/\r?\n|\r/g, " ");
+      else if (n = n.replace(/[ \t\r\n\u000c]+/g, " "), /^[ \t\r\n\u000c]/.test(n) && this.open == this.nodes.length - 1) {
+        let o = i.content[i.content.length - 1], h = t.previousSibling;
+        (!o || h && h.nodeName == "BR" || o.isText && /[ \t\r\n\u000c]$/.test(o.text)) && (n = n.slice(1));
+      }
+      n && this.insertNode(s.text(n), e, !/\S/.test(n)), this.findInText(t);
+    } else
+      this.findInside(t);
+  }
+  // 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;
+      }
+      let p = h && h.skip ? e : this.readStyles(t, e);
+      p && this.addAll(t, p), a && this.sync(r), this.needsBlock = f;
+    } else {
+      let a = this.readStyles(t, e);
+      a && this.addElementByRule(t, h, a, h.consuming === !1 ? o : void 0);
+    }
+    this.localPreserveWS = i;
+  }
+  // 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);
+  }
+  // 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);
+  }
+  // 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)
+      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)
+              break;
+            if (h.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;
+            else
+              break;
+          }
+      }
+    return e;
+  }
+  // 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);
+      }
+    else {
+      let h = this.parser.schema.marks[e.mark];
+      n = n.concat(h.create(e.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 n = r.marks, i, o = [];
-      for (; i = t.isInSet(n); )
-        o.push(new R(e, i)), n = i.removeFromSet(n);
-      for (let l = o.length - 1; l >= 0; l--)
-        this.step(o[l]);
+      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);
     }
-    return this;
+    r && this.sync(o) && 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);
+  }
+  // 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)
+          break;
+        o += 2;
+      }
+    }
+    if (!i)
+      return null;
+    this.sync(r);
+    for (let s = 0; s < i.length; s++)
+      e = this.enterInner(i[s], null, e, !1);
+    return e;
+  }
+  // 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));
+    }
+    let i = this.findPlace(t, e, n);
+    if (i) {
+      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;
+    }
+    return !1;
+  }
+  // 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;
+  }
+  // Open a node of the given type
+  enterInner(t, e, n, i = !1, r) {
+    this.closeExtra();
+    let s = this.top;
+    s.match = s.match && s.match.matchType(t);
+    let o = V(t, r, s.options);
+    s.options & S && s.content.length == 0 && (o |= S);
+    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 T(t, e, h, i, null, o)), this.open++, n;
+  }
+  // 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));
+      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 |= C);
+    }
+    return !1;
+  }
+  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++;
+    }
+    return t;
+  }
+  findAtPoint(t, e) {
+    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);
+  }
+  findInside(t) {
+    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);
+  }
+  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);
+  }
+  findInText(t) {
+    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));
+  }
+  // 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)
+            continue;
+          for (; h >= r; h--)
+            if (s(o - 1, h))
+              return !0;
+          return !1;
+        } 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--;
+        }
+      }
+      return !0;
+    };
+    return s(e.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;
+      }
+    for (let e in this.parser.schema.nodes) {
+      let n = this.parser.schema.nodes[e];
+      if (n.isTextblock && n.defaultAttrs)
+        return n;
+    }
+  }
+}
+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 Pt(l, t) {
+  return (l.matches || l.msMatchesSelector || l.webkitMatchesSelector || l.mozMatchesSelector).call(l, t);
+}
+function H(l) {
+  let t = {};
+  for (let e in l)
+    t[e] = l[e];
+  return t;
+}
+function K(l, t) {
+  let e = t.schema.nodes;
+  for (let n in e) {
+    let i = e[n];
+    if (!i.allowsMarkType(l))
+      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;
+      }
+    };
+    if (s(i.contentMatch))
+      return !0;
+  }
+}
+class ut {
+  /**
+  Create a serializer. `nodes` should map node names to functions
+  that take a node and return a description of the corresponding
+  DOM. `marks` does the same for mark names, but also gets an
+  argument that tells it whether the mark's content is block or
+  inline content (for typical use, it'll always be inline). A mark
+  serializer may be `null` to indicate that marks of that type
+  should not be serialized.
+  */
+  constructor(t, e) {
+    this.nodes = t, this.marks = e;
+  }
+  /**
+  Serialize the content of this fragment to a DOM fragment. When
+  not in the browser, the `document` option, containing a DOM
+  document, should be passed so that the serializer can create
+  nodes.
+  */
+  serializeFragment(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++;
+            continue;
+          }
+          if (!a.eq(r[o][0]) || a.type.spec.spanning === !1)
+            break;
+          o++, h++;
+        }
+        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);
+        }
+      }
+      i.appendChild(this.serializeNodeInner(s, e));
+    }), n;
+  }
+  /**
+  @internal
+  */
+  serializeNodeInner(t, e) {
+    let { dom: n, contentDOM: i } = b(R(e), this.nodes[t.type.name](t), null, t.attrs);
+    if (i) {
+      if (t.isLeaf)
+        throw new RangeError("Content hole not allowed in a leaf node spec");
+      this.serializeFragment(t.content, e, i);
+    }
+    return n;
+  }
+  /**
+  Serialize this node to a DOM node. This can be useful when you
+  need to serialize a part of a document, as opposed to the whole
+  document. To serialize a whole document, use
+  [`serializeFragment`](https://prosemirror.net/docs/ref/#model.DOMSerializer.serializeFragment) on
+  its [content](https://prosemirror.net/docs/ref/#model.Node.content).
+  */
+  serializeNode(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);
+    }
+    return n;
   }
   /**
-  Split the node at the given position, and optionally, if `depth` is
-  greater than one, any number of nodes above that. By default, the
-  parts split off will inherit the node type of the original node.
-  This can be changed by passing an array of types and attributes to
-  use after the split (with the outermost nodes coming first).
+  @internal
   */
-  split(e, t = 1, r) {
-    return ve(this, e, t, r), this;
+  serializeMark(t, e, n = {}) {
+    let i = this.marks[t.type.name];
+    return i && b(R(n), i(t, e), null, t.attrs);
+  }
+  static renderSpec(t, e, n = null, i) {
+    return b(t, e, n, i);
   }
   /**
-  Add the given mark to the inline content between `from` and `to`.
+  Build a serializer using the [`toDOM`](https://prosemirror.net/docs/ref/#model.NodeSpec.toDOM)
+  properties in a schema's node and mark specs.
   */
-  addMark(e, t, r) {
-    return pe(this, e, t, r), this;
+  static fromSchema(t) {
+    return t.cached.domSerializer || (t.cached.domSerializer = new ut(this.nodesFromSchema(t), this.marksFromSchema(t)));
   }
   /**
-  Remove marks from inline nodes between `from` and `to`. When
-  `mark` is a single mark, remove precisely that mark. When it is
-  a mark type, remove all marks of that type. When it is null,
-  remove all marks of any type.
+  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.
   */
-  removeMark(e, t, r) {
-    return fe(this, e, t, r), this;
+  static nodesFromSchema(t) {
+    let e = Q(t.nodes);
+    return e.text || (e.text = (n) => n.text), e;
   }
   /**
-  Removes all marks and nodes from the content of the node at
-  `pos` that don't match the given new parent node type. Accepts
-  an optional starting [content match](https://prosemirror.net/docs/ref/#model.ContentMatch) as
-  third argument.
+  Gather the serializers in a schema's mark specs into an object.
   */
-  clearIncompatible(e, t, r) {
-    return $(this, e, t, r), this;
+  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);
+  }
+  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 b(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")
+    throw new RangeError("Invalid array passed to renderSpec");
+  if (n && (r = Bt(n)) && r.indexOf(t) > -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 y = p.indexOf(" ");
+        y > 0 ? h.setAttributeNS(p.slice(0, y), p.slice(y + 1), a[p]) : p == "style" && h.style ? h.style.cssText = a[p] : h.setAttribute(p, a[p]);
+      }
+  }
+  for (let p = f; p < t.length; p++) {
+    let y = t[p];
+    if (y === 0) {
+      if (p < t.length - 1 || p > f)
+        throw new RangeError("Content hole must be the only child of its parent node");
+      return { dom: h, contentDOM: h };
+    } else {
+      let { dom: pt, contentDOM: J } = b(l, y, e, n);
+      if (h.appendChild(pt), J) {
+        if (o)
+          throw new RangeError("Multiple content holes");
+        o = J;
+      }
+    }
   }
+  return { dom: h, contentDOM: o };
 }
 export {
-  C as AddMarkStep,
-  N as AddNodeMarkStep,
-  E as AttrStep,
-  z as DocAttrStep,
-  L as MapResult,
-  A as Mapping,
-  b as RemoveMarkStep,
-  R as RemoveNodeMarkStep,
-  M as ReplaceAroundStep,
-  v as ReplaceStep,
-  k as Step,
-  S as StepMap,
-  y as StepResult,
-  De as Transform,
-  T as TransformError,
-  Ae as canJoin,
-  Je as canSplit,
-  We as dropPoint,
-  ze as findWrapping,
-  be as insertPoint,
-  Be as joinPoint,
-  Fe as liftTarget,
-  Me as replaceStep
+  w as ContentMatch,
+  P as DOMParser,
+  ut as DOMSerializer,
+  c as Fragment,
+  u as Mark,
+  F as MarkType,
+  g as Node,
+  mt as NodeRange,
+  v as NodeType,
+  I as ReplaceError,
+  E as ResolvedPos,
+  qt as Schema,
+  d as Slice
 };