@caspeco/casper-ui-library 10.4.0 → 10.5.1

package/dist/node_modules/prosemirror-transform/dist/index.js

@@ -1,1552 +1,1151 @@
-import { Slice as g, Fragment as w, Mark as se, MarkType as oe, ReplaceError as le } from "../../prosemirror-model/dist/index.js";
-const Q = 65535, U = Math.pow(2, 16);
-function ae(s, e) {
-  return s + e * U;
+import { Fragment as e, Mark as t, MarkType as n, ReplaceError as r, Slice as i } from "../../prosemirror-model/dist/index.js";
+//#region ../../node_modules/prosemirror-transform/dist/index.js
+var a = 65535, o = 2 ** 16;
+function s(e, t) {
+	return e + t * o;
 }
-function H(s) {
-  return s & Q;
+function c(e) {
+	return e & a;
 }
-function he(s) {
-  return (s - (s & Q)) / U;
+function l(e) {
+	return (e - (e & a)) / o;
 }
-const V = 1, X = 2, A = 4, Y = 8;
-class L {
-  /**
-  @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;
-  }
-  /**
-  Tells you whether the token before the mapped position was deleted.
-  */
-  get deletedBefore() {
-    return (this.delInfo & (V | A)) > 0;
-  }
-  /**
-  True when the token after the mapped position was deleted.
-  */
-  get deletedAfter() {
-    return (this.delInfo & (X | A)) > 0;
-  }
-  /**
-  Tells whether any of the steps mapped through deletes across the
-  position (including both the token before and after the
-  position).
-  */
-  get deletedAcross() {
-    return (this.delInfo & A) > 0;
-  }
-}
-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]`.
-  */
-  constructor(e, t = !1) {
-    if (this.ranges = e, this.inverted = t, !e.length && S.empty)
-      return S.empty;
-  }
-  /**
-  @internal
-  */
-  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);
-  }
-  /**
-  @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 : A;
-        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);
-  }
-  /**
-  @internal
-  */
-  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;
-  }
-  /**
-  Calls the given function on each of the changed ranges included in
-  this map.
-  */
-  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;
-    }
-  }
-  /**
-  Create an inverted version of this map. The result can be used to
-  map positions in the post-step document to the pre-step document.
-  */
-  invert() {
-    return new S(this.ranges, !this.inverted);
-  }
-  /**
-  @internal
-  */
-  toString() {
-    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
-  }
-  /**
-  Create a map that moves all positions by offset `n` (which may be
-  negative). This can be useful when applying steps meant for a
-  sub-document to a larger document, or vice-versa.
-  */
-  static offset(e) {
-    return e == 0 ? S.empty : new S(e < 0 ? [0, -e, 0] : [0, 0, e]);
-  }
-}
-S.empty = new S([]);
-class J {
-  /**
-  Create a new mapping with the given position maps.
-  */
-  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);
-  }
-  /**
-  The step maps in this mapping.
-  */
-  get maps() {
-    return this._maps;
-  }
-  /**
-  Create a mapping that maps only through a part of this one.
-  */
-  slice(e = 0, t = this.maps.length) {
-    return new J(this._maps, this.mirror, e, t);
-  }
-  /**
-  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.
-  */
-  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);
-  }
-  /**
-  Add all the step maps in a given mapping to this one (preserving
-  mirroring information).
-  */
-  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);
-    }
-  }
-  /**
-  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`).
-  */
-  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)];
-    }
-  }
-  /**
-  @internal
-  */
-  setMirror(e, t) {
-    this.mirror || (this.mirror = []), this.mirror.push(e, t);
-  }
-  /**
-  Append the inverse of the given mapping to this one.
-  */
-  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);
-    }
-  }
-  /**
-  Create an inverted version of this mapping.
-  */
-  invert() {
-    let e = new J();
-    return e.appendMappingInverted(this), e;
-  }
-  /**
-  Map a position through this mapping.
-  */
-  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;
-  }
-  /**
-  Map a position through this mapping, returning a mapping
-  result.
-  */
-  mapResult(e, t = 1) {
-    return this._map(e, t, !1);
-  }
-  /**
-  @internal
-  */
-  _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);
-  }
-}
-const B = /* @__PURE__ */ Object.create(null);
-class v {
-  /**
-  Get the step map that represents the changes made by this step,
-  and which can be used to transform between positions in the old
-  and the new document.
-  */
-  getMap() {
-    return S.empty;
-  }
-  /**
-  Try to merge this step with another one, to be applied directly
-  after it. Returns the merged step when possible, null if the
-  steps can't be merged.
-  */
-  merge(e) {
-    return null;
-  }
-  /**
-  Deserialize a step from its JSON representation. Will call
-  through to the step class' own implementation of this method.
-  */
-  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);
-  }
-  /**
-  To be able to serialize steps to JSON, each step needs a string
-  ID to attach to its JSON representation. Use this method to
-  register an ID for your step classes. Try to pick something
-  that's unlikely to clash with steps from other modules.
-  */
-  static jsonID(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;
-  }
-}
-class y {
-  /**
-  @internal
-  */
-  constructor(e, t) {
-    this.doc = e, this.failed = t;
-  }
-  /**
-  Create a successful step result.
-  */
-  static ok(e) {
-    return new y(e, null);
-  }
-  /**
-  Create a failed step result.
-  */
-  static fail(e) {
-    return new y(null, e);
-  }
-  /**
-  Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
-  arguments. Create a successful result if it succeeds, and a
-  failed one if it throws a `ReplaceError`.
-  */
-  static fromReplace(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;
-    }
-  }
-}
-function q(s, e, t) {
-  let r = [];
-  for (let n = 0; n < s.childCount; n++) {
-    let i = s.child(n);
-    i.content.size && (i = i.copy(q(i.content, e, i))), i.isInline && (i = e(i, t, n)), r.push(i);
-  }
-  return w.fromArray(r);
-}
-class C extends v {
-  /**
-  Create a mark step.
-  */
-  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(q(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;
-  }
-  toJSON() {
-    return {
-      stepType: "addMark",
-      mark: this.mark.toJSON(),
-      from: this.from,
-      to: this.to
-    };
-  }
-  /**
-  @internal
-  */
-  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));
-  }
-}
-v.jsonID("addMark", C);
-class b extends v {
-  /**
-  Create a mark-removing step.
-  */
-  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(q(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
-    };
-  }
-  /**
-  @internal
-  */
-  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));
-  }
-}
-v.jsonID("removeMark", b);
-class I extends v {
-  /**
-  Create a node mark step.
-  */
-  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 I(this.pos, t.marks[n]);
-        return new I(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 I(t.pos, this.mark);
-  }
-  toJSON() {
-    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-  }
-  /**
-  @internal
-  */
-  static fromJSON(e, t) {
-    if (typeof t.pos != "number")
-      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
-    return new I(t.pos, e.markFromJSON(t.mark));
-  }
-}
-v.jsonID("addNodeMark", I);
-class R extends v {
-  /**
-  Create a mark-removing step.
-  */
-  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 I(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() };
-  }
-  /**
-  @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));
-  }
-}
-v.jsonID("removeNodeMark", R);
-class k extends v {
-  /**
-  The given `slice` should fit the 'gap' between `from` and
-  `to`—the depths must line up, and the surrounding nodes must be
-  able to be joined with the open sides of the slice. When
-  `structure` is true, the step will fail if the content between
-  from and to is not just a sequence of closing and then opening
-  tokens (this is to guard against rebased replace steps
-  overwriting something they weren't supposed to).
-  */
-  constructor(e, t, r, n = !1) {
-    super(), this.from = e, this.to = t, this.slice = r, this.structure = n;
-  }
-  apply(e) {
-    return this.structure && P(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 k(this.from, this.from + this.slice.size, e.slice(this.from, this.to));
-  }
-  map(e) {
-    let t = e.mapResult(this.to, -1), r = this.from == this.to && k.MAP_BIAS < 0 ? t : e.mapResult(this.from, 1);
-    return r.deletedAcross && t.deletedAcross ? null : new k(r.pos, Math.max(r.pos, t.pos), this.slice, this.structure);
-  }
-  merge(e) {
-    if (!(e instanceof k) || 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 k(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 k(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;
-  }
-  /**
-  @internal
-  */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number")
-      throw new RangeError("Invalid input for ReplaceStep.fromJSON");
-    return new k(t.from, t.to, g.fromJSON(e, t.slice), !!t.structure);
-  }
-}
-k.MAP_BIAS = 1;
-v.jsonID("replace", k);
-class M extends v {
-  /**
-  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 && (P(e, this.from, this.gapFrom) || P(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;
-  }
-  /**
-  @internal
-  */
-  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);
-  }
-}
-v.jsonID("replaceAround", M);
-function P(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)));
+var u = 1, d = 2, f = 4, p = 8, m = class {
+	constructor(e, t, n) {
+		this.pos = e, this.delInfo = t, this.recover = n;
+	}
+	get deleted() {
+		return (this.delInfo & p) > 0;
+	}
+	get deletedBefore() {
+		return (this.delInfo & 5) > 0;
+	}
+	get deletedAfter() {
+		return (this.delInfo & 6) > 0;
+	}
+	get deletedAcross() {
+		return (this.delInfo & f) > 0;
+	}
+}, h = class e {
+	constructor(t, n = !1) {
+		if (this.ranges = t, this.inverted = n, !t.length && e.empty) return e.empty;
+	}
+	recover(e) {
+		let t = 0, n = c(e);
+		if (!this.inverted) for (let e = 0; e < n; e++) t += this.ranges[e * 3 + 2] - this.ranges[e * 3 + 1];
+		return this.ranges[n * 3] + t + l(e);
+	}
+	mapResult(e, t = 1) {
+		return this._map(e, t, !1);
+	}
+	map(e, t = 1) {
+		return this._map(e, t, !0);
+	}
+	_map(e, t, n) {
+		let r = 0, i = this.inverted ? 2 : 1, a = this.inverted ? 1 : 2;
+		for (let o = 0; o < this.ranges.length; o += 3) {
+			let c = this.ranges[o] - (this.inverted ? r : 0);
+			if (c > e) break;
+			let l = this.ranges[o + i], h = this.ranges[o + a], g = c + l;
+			if (e <= g) {
+				let i = l ? e == c ? -1 : e == g ? 1 : t : t, a = c + r + (i < 0 ? 0 : h);
+				if (n) return a;
+				let _ = e == (t < 0 ? c : g) ? null : s(o / 3, e - c), v = e == c ? d : e == g ? u : f;
+				return (t < 0 ? e != c : e != g) && (v |= p), new m(a, v, _);
+			}
+			r += h - l;
+		}
+		return n ? e + r : new m(e + r, 0, null);
+	}
+	touches(e, t) {
+		let n = 0, r = c(t), i = this.inverted ? 2 : 1, a = this.inverted ? 1 : 2;
+		for (let t = 0; t < this.ranges.length; t += 3) {
+			let o = this.ranges[t] - (this.inverted ? n : 0);
+			if (o > e) break;
+			let s = this.ranges[t + i];
+			if (e <= o + s && t == r * 3) return !0;
+			n += this.ranges[t + a] - s;
+		}
+		return !1;
+	}
+	forEach(e) {
+		let t = this.inverted ? 2 : 1, n = this.inverted ? 1 : 2;
+		for (let r = 0, i = 0; r < this.ranges.length; r += 3) {
+			let a = this.ranges[r], o = a - (this.inverted ? i : 0), s = a + (this.inverted ? 0 : i), c = this.ranges[r + t], l = this.ranges[r + n];
+			e(o, o + c, s, s + l), i += l - c;
+		}
+	}
+	invert() {
+		return new e(this.ranges, !this.inverted);
+	}
+	toString() {
+		return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
+	}
+	static offset(t) {
+		return t == 0 ? e.empty : new e(t < 0 ? [
+			0,
+			-t,
+			0
+		] : [
+			0,
+			0,
+			t
+		]);
+	}
+};
+h.empty = new h([]);
+var g = class e {
+	constructor(e, t, n = 0, r = e ? e.length : 0) {
+		this.mirror = t, this.from = n, this.to = r, this._maps = e || [], this.ownData = !(e || t);
+	}
+	get maps() {
+		return this._maps;
+	}
+	slice(t = 0, n = this.maps.length) {
+		return new e(this._maps, this.mirror, t, n);
+	}
+	appendMap(e, t) {
+		this.ownData ||= (this._maps = this._maps.slice(), this.mirror = this.mirror && this.mirror.slice(), !0), this.to = this._maps.push(e), t != null && this.setMirror(this._maps.length - 1, t);
+	}
+	appendMapping(e) {
+		for (let t = 0, n = this._maps.length; t < e._maps.length; t++) {
+			let r = e.getMirror(t);
+			this.appendMap(e._maps[t], r != null && r < t ? n + r : void 0);
+		}
+	}
+	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)];
+		}
+	}
+	setMirror(e, t) {
+		this.mirror ||= [], this.mirror.push(e, t);
+	}
+	appendMappingInverted(e) {
+		for (let t = e.maps.length - 1, n = this._maps.length + e._maps.length; t >= 0; t--) {
+			let r = e.getMirror(t);
+			this.appendMap(e._maps[t].invert(), r != null && r > t ? n - r - 1 : void 0);
+		}
+	}
+	invert() {
+		let t = new e();
+		return t.appendMappingInverted(this), t;
+	}
+	map(e, t = 1) {
+		if (this.mirror) return this._map(e, t, !0);
+		for (let n = this.from; n < this.to; n++) e = this._maps[n].map(e, t);
+		return e;
+	}
+	mapResult(e, t = 1) {
+		return this._map(e, t, !1);
+	}
+	_map(e, t, n) {
+		let r = 0;
+		for (let n = this.from; n < this.to; n++) {
+			let i = this._maps[n].mapResult(e, t);
+			if (i.recover != null) {
+				let t = this.getMirror(n);
+				if (t != null && t > n && t < this.to) {
+					n = t, e = this._maps[t].recover(i.recover);
+					continue;
+				}
+			}
+			r |= i.delInfo, e = i.pos;
+		}
+		return n ? e : new m(e, r, null);
+	}
+}, _ = Object.create(null), v = class {
+	getMap() {
+		return h.empty;
+	}
+	merge(e) {
+		return null;
+	}
+	static fromJSON(e, t) {
+		if (!t || !t.stepType) throw RangeError("Invalid input for Step.fromJSON");
+		let n = _[t.stepType];
+		if (!n) throw RangeError(`No step type ${t.stepType} defined`);
+		return n.fromJSON(e, t);
+	}
+	static jsonID(e, t) {
+		if (e in _) throw RangeError("Duplicate use of step JSON ID " + e);
+		return _[e] = t, t.prototype.jsonID = e, t;
+	}
+}, y = class e {
+	constructor(e, t) {
+		this.doc = e, this.failed = t;
+	}
+	static ok(t) {
+		return new e(t, null);
+	}
+	static fail(t) {
+		return new e(null, t);
+	}
+	static fromReplace(t, n, i, a) {
+		try {
+			return e.ok(t.replace(n, i, a));
+		} catch (t) {
+			if (t instanceof r) return e.fail(t.message);
+			throw t;
+		}
+	}
+};
+function b(t, n, r) {
+	let i = [];
+	for (let e = 0; e < t.childCount; e++) {
+		let a = t.child(e);
+		a.content.size && (a = a.copy(b(a.content, n, a))), a.isInline && (a = n(a, r, e)), i.push(a);
+	}
+	return e.fromArray(i);
 }
-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 k(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 k(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]);
+var x = class e extends v {
+	constructor(e, t, n) {
+		super(), this.from = e, this.to = t, this.mark = n;
+	}
+	apply(e) {
+		let t = e.slice(this.from, this.to), n = e.resolve(this.from), r = n.node(n.sharedDepth(this.to)), a = new i(b(t.content, (e, t) => !e.isAtom || !t.type.allowsMarkType(this.mark.type) ? e : e.mark(this.mark.addToSet(e.marks)), r), t.openStart, t.openEnd);
+		return y.fromReplace(e, this.from, this.to, a);
+	}
+	invert() {
+		return new S(this.from, this.to, this.mark);
+	}
+	map(t) {
+		let n = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+		return n.deleted && r.deleted || n.pos >= r.pos ? null : new e(n.pos, r.pos, this.mark);
+	}
+	merge(t) {
+		return t instanceof e && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new e(Math.min(this.from, t.from), Math.max(this.to, t.to), this.mark) : null;
+	}
+	toJSON() {
+		return {
+			stepType: "addMark",
+			mark: this.mark.toJSON(),
+			from: this.from,
+			to: this.to
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.from != "number" || typeof n.to != "number") throw RangeError("Invalid input for AddMarkStep.fromJSON");
+		return new e(n.from, n.to, t.markFromJSON(n.mark));
+	}
+};
+v.jsonID("addMark", x);
+var S = class e extends v {
+	constructor(e, t, n) {
+		super(), this.from = e, this.to = t, this.mark = n;
+	}
+	apply(e) {
+		let t = e.slice(this.from, this.to), n = new i(b(t.content, (e) => e.mark(this.mark.removeFromSet(e.marks)), e), t.openStart, t.openEnd);
+		return y.fromReplace(e, this.from, this.to, n);
+	}
+	invert() {
+		return new x(this.from, this.to, this.mark);
+	}
+	map(t) {
+		let n = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+		return n.deleted && r.deleted || n.pos >= r.pos ? null : new e(n.pos, r.pos, this.mark);
+	}
+	merge(t) {
+		return t instanceof e && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new e(Math.min(this.from, t.from), Math.max(this.to, t.to), this.mark) : null;
+	}
+	toJSON() {
+		return {
+			stepType: "removeMark",
+			mark: this.mark.toJSON(),
+			from: this.from,
+			to: this.to
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.from != "number" || typeof n.to != "number") throw RangeError("Invalid input for RemoveMarkStep.fromJSON");
+		return new e(n.from, n.to, t.markFromJSON(n.mark));
+	}
+};
+v.jsonID("removeMark", S);
+var C = class t extends v {
+	constructor(e, t) {
+		super(), this.pos = e, this.mark = t;
+	}
+	apply(t) {
+		let n = t.nodeAt(this.pos);
+		if (!n) return y.fail("No node at mark step's position");
+		let r = n.type.create(n.attrs, null, this.mark.addToSet(n.marks));
+		return y.fromReplace(t, this.pos, this.pos + 1, new i(e.from(r), 0, +!n.isLeaf));
+	}
+	invert(e) {
+		let n = e.nodeAt(this.pos);
+		if (n) {
+			let e = this.mark.addToSet(n.marks);
+			if (e.length == n.marks.length) {
+				for (let r = 0; r < n.marks.length; r++) if (!n.marks[r].isInSet(e)) return new t(this.pos, n.marks[r]);
+				return new t(this.pos, this.mark);
+			}
+		}
+		return new w(this.pos, this.mark);
+	}
+	map(e) {
+		let n = e.mapResult(this.pos, 1);
+		return n.deletedAfter ? null : new t(n.pos, this.mark);
+	}
+	toJSON() {
+		return {
+			stepType: "addNodeMark",
+			pos: this.pos,
+			mark: this.mark.toJSON()
+		};
+	}
+	static fromJSON(e, n) {
+		if (typeof n.pos != "number") throw RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+		return new t(n.pos, e.markFromJSON(n.mark));
+	}
+};
+v.jsonID("addNodeMark", C);
+var w = class t extends v {
+	constructor(e, t) {
+		super(), this.pos = e, this.mark = t;
+	}
+	apply(t) {
+		let n = t.nodeAt(this.pos);
+		if (!n) return y.fail("No node at mark step's position");
+		let r = n.type.create(n.attrs, null, this.mark.removeFromSet(n.marks));
+		return y.fromReplace(t, this.pos, this.pos + 1, new i(e.from(r), 0, +!n.isLeaf));
+	}
+	invert(e) {
+		let t = e.nodeAt(this.pos);
+		return !t || !this.mark.isInSet(t.marks) ? this : new C(this.pos, this.mark);
+	}
+	map(e) {
+		let n = e.mapResult(this.pos, 1);
+		return n.deletedAfter ? null : new t(n.pos, this.mark);
+	}
+	toJSON() {
+		return {
+			stepType: "removeNodeMark",
+			pos: this.pos,
+			mark: this.mark.toJSON()
+		};
+	}
+	static fromJSON(e, n) {
+		if (typeof n.pos != "number") throw RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+		return new t(n.pos, e.markFromJSON(n.mark));
+	}
+};
+v.jsonID("removeNodeMark", w);
+var T = class e extends v {
+	constructor(e, t, n, r = !1) {
+		super(), this.from = e, this.to = t, this.slice = n, this.structure = r;
+	}
+	apply(e) {
+		return this.structure && D(e, this.from, this.to) ? y.fail("Structure replace would overwrite content") : y.fromReplace(e, this.from, this.to, this.slice);
+	}
+	getMap() {
+		return new h([
+			this.from,
+			this.to - this.from,
+			this.slice.size
+		]);
+	}
+	invert(t) {
+		return new e(this.from, this.from + this.slice.size, t.slice(this.from, this.to));
+	}
+	map(t) {
+		let n = t.mapResult(this.to, -1), r = this.from == this.to && e.MAP_BIAS < 0 ? n : t.mapResult(this.from, 1);
+		return r.deletedAcross && n.deletedAcross ? null : new e(r.pos, Math.max(r.pos, n.pos), this.slice, this.structure);
+	}
+	merge(t) {
+		if (!(t instanceof e) || t.structure || this.structure) return null;
+		if (this.from + this.slice.size == t.from && !this.slice.openEnd && !t.slice.openStart) {
+			let n = this.slice.size + t.slice.size == 0 ? i.empty : new i(this.slice.content.append(t.slice.content), this.slice.openStart, t.slice.openEnd);
+			return new e(this.from, this.to + (t.to - t.from), n, this.structure);
+		}
+		if (t.to == this.from && !this.slice.openStart && !t.slice.openEnd) {
+			let n = this.slice.size + t.slice.size == 0 ? i.empty : new i(t.slice.content.append(this.slice.content), t.slice.openStart, this.slice.openEnd);
+			return new e(t.from, this.to, n, this.structure);
+		}
+		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;
+	}
+	static fromJSON(t, n) {
+		if (typeof n.from != "number" || typeof n.to != "number") throw RangeError("Invalid input for ReplaceStep.fromJSON");
+		return new e(n.from, n.to, i.fromJSON(t, n.slice), !!n.structure);
+	}
+};
+T.MAP_BIAS = 1, v.jsonID("replace", T);
+var E = class e extends v {
+	constructor(e, t, n, r, i, a, o = !1) {
+		super(), this.from = e, this.to = t, this.gapFrom = n, this.gapTo = r, this.slice = i, this.insert = a, this.structure = o;
+	}
+	apply(e) {
+		if (this.structure && (D(e, this.from, this.gapFrom) || D(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 n = this.slice.insertAt(this.insert, t.content);
+		return n ? y.fromReplace(e, this.from, this.to, n) : y.fail("Content does not fit in gap");
+	}
+	getMap() {
+		return new h([
+			this.from,
+			this.gapFrom - this.from,
+			this.insert,
+			this.gapTo,
+			this.to - this.gapTo,
+			this.slice.size - this.insert
+		]);
+	}
+	invert(t) {
+		let n = this.gapTo - this.gapFrom;
+		return new e(this.from, this.from + this.slice.size + n, this.from + this.insert, this.from + this.insert + n, t.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+	}
+	map(t) {
+		let n = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1), i = this.from == this.gapFrom ? n.pos : t.map(this.gapFrom, -1), a = this.to == this.gapTo ? r.pos : t.map(this.gapTo, 1);
+		return n.deletedAcross && r.deletedAcross || i < n.pos || a > r.pos ? null : new e(n.pos, r.pos, i, a, 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, n) {
+		if (typeof n.from != "number" || typeof n.to != "number" || typeof n.gapFrom != "number" || typeof n.gapTo != "number" || typeof n.insert != "number") throw RangeError("Invalid input for ReplaceAroundStep.fromJSON");
+		return new e(n.from, n.to, n.gapFrom, n.gapTo, i.fromJSON(t, n.slice), n.insert, !!n.structure);
+	}
+};
+v.jsonID("replaceAround", E);
+function D(e, t, n) {
+	let r = e.resolve(t), i = n - t, a = r.depth;
+	for (; i > 0 && a > 0 && r.indexAfter(a) == r.node(a).childCount;) a--, i--;
+	if (i > 0) {
+		let e = r.node(a).maybeChild(r.indexAfter(a));
+		for (; i > 0;) {
+			if (!e || e.isLeaf) return !0;
+			e = e.firstChild, i--;
+		}
+	}
+	return !1;
 }
-function ce(s, e, t) {
-  return (e == 0 || s.canReplace(e, s.childCount)) && (t == s.childCount || s.canReplace(0, t));
+function ee(e, t, n, r) {
+	let i = [], a = [], o, s;
+	e.doc.nodesBetween(t, n, (e, c, l) => {
+		if (!e.isInline) return;
+		let u = e.marks;
+		if (!r.isInSet(u) && l.type.allowsMarkType(r.type)) {
+			let l = Math.max(c, t), d = Math.min(c + e.nodeSize, n), f = r.addToSet(u);
+			for (let e = 0; e < u.length; e++) u[e].isInSet(f) || (o && o.to == l && o.mark.eq(u[e]) ? o.to = d : i.push(o = new S(l, d, u[e])));
+			s && s.to == l ? s.to = d : a.push(s = new x(l, d, r));
+		}
+	}), i.forEach((t) => e.step(t)), a.forEach((t) => e.step(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);
-  }
-  return null;
+function te(e, t, r, i) {
+	let a = [], o = 0;
+	e.doc.nodesBetween(t, r, (e, s) => {
+		if (!e.isInline) return;
+		o++;
+		let c = null;
+		if (i instanceof n) {
+			let t = e.marks, n;
+			for (; n = i.isInSet(t);) (c ||= []).push(n), t = n.removeFromSet(t);
+		} else i ? i.isInSet(e.marks) && (c = [i]) : c = e.marks;
+		if (c && c.length) {
+			let n = Math.min(s + e.nodeSize, r);
+			for (let e = 0; e < c.length; e++) {
+				let r = c[e], i;
+				for (let e = 0; e < a.length; e++) {
+					let t = a[e];
+					t.step == o - 1 && r.eq(a[e].style) && (i = t);
+				}
+				i ? (i.to = n, i.step = o) : a.push({
+					style: r,
+					from: Math.max(s, t),
+					to: n,
+					step: o
+				});
+			}
+		}
+	}), a.forEach((t) => e.step(new S(t.from, t.to, t.style)));
 }
-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 O(t, n, r, a = r.contentMatch, o = !0) {
+	let s = t.doc.nodeAt(n), c = [], l = n + 1;
+	for (let n = 0; n < s.childCount; n++) {
+		let u = s.child(n), d = l + u.nodeSize, f = a.matchType(u.type);
+		if (!f) c.push(new T(l, d, i.empty));
+		else {
+			a = f;
+			for (let e = 0; e < u.marks.length; e++) r.allowsMarkType(u.marks[e].type) || t.step(new S(l, d, u.marks[e]));
+			if (o && u.isText && r.whitespace != "pre") {
+				let t, n = /\r?\n|\r/g, a;
+				for (; t = n.exec(u.text);) a ||= new i(e.from(r.schema.text(" ", r.allowedMarks(u.marks))), 0, 0), c.push(new T(l + t.index, l + t.index + t[0].length, a));
+			}
+		}
+		l = d;
+	}
+	if (!a.validEnd) {
+		let n = a.fillBefore(e.empty, !0);
+		t.replace(l, l, new i(n, 0, 0));
+	}
+	for (let e = c.length - 1; e >= 0; e--) t.step(c[e]);
 }
-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;
+function ne(e, t, n) {
+	return (t == 0 || e.canReplace(t, e.childCount)) && (n == e.childCount || e.canReplace(0, n));
 }
-function K(s) {
-  return { type: s, attrs: null };
+function re(e) {
+	let t = e.parent.content.cutByIndex(e.startIndex, e.endIndex);
+	for (let n = e.depth, r = 0, i = 0;; --n) {
+		let a = e.$from.node(n), o = e.$from.index(n) + r, s = e.$to.indexAfter(n) - i;
+		if (n < e.depth && a.canReplace(o, s, t)) return n;
+		if (n == 0 || a.type.spec.isolating || !ne(a, o, s)) break;
+		o && (r = 1), s < a.childCount && (i = 1);
+	}
+	return null;
 }
-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 ie(t, n, r) {
+	let { $from: a, $to: o, depth: s } = n, c = a.before(s + 1), l = o.after(s + 1), u = c, d = l, f = e.empty, p = 0;
+	for (let t = s, n = !1; t > r; t--) n || a.index(t) > 0 ? (n = !0, f = e.from(a.node(t).copy(f)), p++) : u--;
+	let m = e.empty, h = 0;
+	for (let t = s, n = !1; t > r; t--) n || o.after(t + 1) < o.end(t) ? (n = !0, m = e.from(o.node(t).copy(m)), h++) : d++;
+	t.step(new E(u, d, c, l, new i(f.append(m), p, h), f.size - p, !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 ae(e, t, n = null, r = e) {
+	let i = oe(e, t), a = i && se(r, t);
+	return a ? i.map(k).concat({
+		type: t,
+		attrs: n
+	}).concat(a.map(k)) : null;
 }
-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 k(e) {
+	return {
+		type: e,
+		attrs: null
+	};
 }
-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 oe(e, t) {
+	let { parent: n, startIndex: r, endIndex: i } = e, a = n.contentMatchAt(r).findWrapping(t);
+	if (!a) return null;
+	let o = a.length ? a[0] : t;
+	return n.canReplaceWith(r, i, o) ? a : null;
 }
-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 se(e, t) {
+	let { parent: n, startIndex: r, endIndex: i } = e, a = n.child(r), o = t.contentMatch.findWrapping(a.type);
+	if (!o) return null;
+	let s = (o.length ? o[o.length - 1] : t).contentMatch;
+	for (let e = r; s && e < i; e++) s = s.matchType(n.child(e).type);
+	return !s || !s.validEnd ? null : o;
 }
-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 A(t, n, r) {
+	let a = e.empty;
+	for (let t = r.length - 1; t >= 0; t--) {
+		if (a.size) {
+			let e = r[t].type.contentMatch.matchFragment(a);
+			if (!e || !e.validEnd) throw RangeError("Wrapper type given to Transform.wrap does not form valid content of its parent wrapper");
+		}
+		a = e.from(r[t].type.create(r[t].attrs, a));
+	}
+	let o = n.start, s = n.end;
+	t.step(new E(o, s, o, s, new i(a, 0, 0), r.length, !0));
 }
-function ye(s, e, t) {
-  let r = s.resolve(e), n = r.index();
-  return r.parent.canReplaceWith(n, n + 1, t);
+function j(t, n, r, a, o) {
+	if (!a.isTextblock) throw RangeError("Type given to setBlockType should be a textblock");
+	let s = t.steps.length;
+	t.doc.nodesBetween(n, r, (n, r) => {
+		let c = typeof o == "function" ? o(n) : o;
+		if (n.isTextblock && !n.hasMarkup(a, c) && P(t.doc, t.mapping.slice(s).map(r), a)) {
+			let o = null;
+			if (a.schema.linebreakReplacement) {
+				let e = a.whitespace == "pre", t = !!a.contentMatch.matchType(a.schema.linebreakReplacement);
+				e && !t ? o = !1 : !e && t && (o = !0);
+			}
+			o === !1 && N(t, n, r, s), O(t, t.mapping.slice(s).map(r, 1), a, void 0, o === null);
+			let l = t.mapping.slice(s), u = l.map(r, 1), d = l.map(r + n.nodeSize, 1);
+			return t.step(new E(u, d, u + 1, d - 1, new i(e.from(a.create(c, null, n.marks)), 0, 0), 1, !0)), o === !0 && M(t, n, r, s), !1;
+		}
+	});
 }
-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 M(e, t, n, r) {
+	t.forEach((i, a) => {
+		if (i.isText) {
+			let o, s = /\r?\n|\r/g;
+			for (; o = s.exec(i.text);) {
+				let i = e.mapping.slice(r).map(n + 1 + a + o.index);
+				e.replaceWith(i, i + 1, t.type.schema.linebreakReplacement.create());
+			}
+		}
+	});
 }
-function Ae(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 N(e, t, n, r) {
+	t.forEach((i, a) => {
+		if (i.type == i.type.schema.linebreakReplacement) {
+			let i = e.mapping.slice(r).map(n + 1 + a);
+			e.replaceWith(i, i + 1, t.type.schema.text("\n"));
+		}
+	});
 }
-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 k(e, e, new g(i.append(o), t, t), !0));
+function P(e, t, n) {
+	let r = e.resolve(t), i = r.index();
+	return r.parent.canReplaceWith(i, i + 1, n);
 }
-function Je(s, e) {
-  let t = s.resolve(e), r = t.index();
-  return j(t.nodeBefore, t.nodeAfter) && t.parent.canReplace(r, r + 1);
+function F(t, n, r, a, o) {
+	let s = t.doc.nodeAt(n);
+	if (!s) throw RangeError("No node at given position");
+	r ||= s.type;
+	let c = r.create(a, null, o || s.marks);
+	if (s.isLeaf) return t.replaceWith(n, n + s.nodeSize, c);
+	if (!r.validContent(s.content)) throw RangeError("Invalid content for node type " + r.name);
+	t.step(new E(n, n + s.nodeSize, n + 1, n + s.nodeSize - 1, new i(e.from(c), 0, 0), 1, !0));
 }
-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 ce(e, t, n = 1, r) {
+	let i = e.resolve(t), a = i.depth - n, o = r && r[r.length - 1] || i.parent;
+	if (a < 0 || i.parent.type.spec.isolating || !i.parent.canReplace(i.index(), i.parent.childCount) || !o.type.validContent(i.parent.content.cutByIndex(i.index(), i.parent.childCount))) return !1;
+	for (let e = i.depth - 1, t = n - 2; e > a; e--, t--) {
+		let n = i.node(e), a = i.index(e);
+		if (n.type.spec.isolating) return !1;
+		let o = n.content.cutByIndex(a, n.childCount), s = r && r[t + 1];
+		s && (o = o.replaceChild(0, s.type.create(s.attrs)));
+		let c = r && r[t] || n;
+		if (!n.canReplace(a + 1, n.childCount) || !c.type.validContent(o)) return !1;
+	}
+	let s = i.indexAfter(a), c = r && r[0];
+	return i.node(a).canReplaceWith(s, s, c ? c.type : i.node(a + 1).type);
 }
-function j(s, e) {
-  return !!(s && e && !s.isLeaf && xe(s, e));
+function le(t, n, r = 1, a) {
+	let o = t.doc.resolve(n), s = e.empty, c = e.empty;
+	for (let t = o.depth, n = o.depth - r, i = r - 1; t > n; t--, i--) {
+		s = e.from(o.node(t).copy(s));
+		let n = a && a[i];
+		c = e.from(n ? n.type.create(n.attrs, c) : o.node(t).copy(c));
+	}
+	t.step(new T(n, n, new i(s.append(c), r, r), !0));
 }
-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 ue(e, t) {
+	let n = e.resolve(t), r = n.index();
+	return I(n.nodeBefore, n.nodeAfter) && n.parent.canReplace(r, r + 1);
 }
-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 k(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 de(e, t) {
+	t.content.size || e.type.compatibleContent(t.type);
+	let n = e.contentMatchAt(e.childCount), { linebreakReplacement: r } = e.type.schema;
+	for (let i = 0; i < t.childCount; i++) {
+		let a = t.child(i), o = a.type == r ? e.type.schema.nodes.text : a.type;
+		if (n = n.matchType(o), !n || !e.type.allowsMarks(a.marks)) return !1;
+	}
+	return n.validEnd;
 }
-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 I(e, t) {
+	return !!(e && t && !e.isLeaf && de(e, t));
 }
-function De(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 L(e, t, n = -1) {
+	let r = e.resolve(t);
+	for (let e = r.depth;; e--) {
+		let i, a, o = r.index(e);
+		if (e == r.depth ? (i = r.nodeBefore, a = r.nodeAfter) : n > 0 ? (i = r.node(e + 1), o++, a = r.node(e).maybeChild(o)) : (i = r.node(e).maybeChild(o - 1), a = r.node(e + 1)), i && !i.isTextblock && I(i, a) && r.node(e).canReplace(o, o + 1)) return t;
+		if (e == 0) break;
+		t = n < 0 ? r.before(e) : r.after(e);
+	}
 }
-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 k(e, t, r) : new Ce(n, i, r).fit();
+function R(e, t, n) {
+	let r = null, { linebreakReplacement: a } = e.doc.type.schema, o = e.doc.resolve(t - n), s = o.node().type;
+	if (a && s.inlineContent) {
+		let e = s.whitespace == "pre", t = !!s.contentMatch.matchType(a);
+		e && !t ? r = !1 : !e && t && (r = !0);
+	}
+	let c = e.steps.length;
+	if (r === !1) {
+		let r = e.doc.resolve(t + n);
+		N(e, r.node(), r.before(), c);
+	}
+	s.inlineContent && O(e, t + n - 1, s, o.node().contentMatchAt(o.index()), r == null);
+	let l = e.mapping.slice(c), u = l.map(t - n);
+	if (e.step(new T(u, l.map(t + n, -1), i.empty, !0)), r === !0) {
+		let t = e.doc.resolve(u);
+		M(e, t.node(), t.before(), e.steps.length);
+	}
+	return e;
 }
-function ee(s, e, t) {
-  return !t.openStart && !t.openEnd && s.start() == e.start() && s.parent.canReplace(s.index(), e.index(), t.content);
+function z(e, t, n) {
+	let r = e.resolve(t);
+	if (r.parent.canReplaceWith(r.index(), r.index(), n)) return t;
+	if (r.parentOffset == 0) for (let e = r.depth - 1; e >= 0; e--) {
+		let t = r.index(e);
+		if (r.node(e).canReplaceWith(t, t, n)) return r.before(e + 1);
+		if (t > 0) return null;
+	}
+	if (r.parentOffset == r.parent.content.size) for (let e = r.depth - 1; e >= 0; e--) {
+		let t = r.indexAfter(e);
+		if (r.node(e).canReplaceWith(t, t, n)) return r.after(e + 1);
+		if (t < r.node(e).childCount) return null;
+	}
+	return null;
 }
-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 k(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 = D(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 = D(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 = D(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 N = x.lastChild;
-      this.frontier.push({ type: N.type, match: N.contentMatchAt(N.childCount) }), x = N.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 || !W(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 = W(e, t, n, r, i);
-      if (o) {
-        for (let l = t - 1; l >= 0; l--) {
-          let { match: a, type: h } = this.frontier[l], p = W(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 B(e, t, n) {
+	let r = e.resolve(t);
+	if (!n.content.size) return t;
+	let i = n.content;
+	for (let e = 0; e < n.openStart; e++) i = i.firstChild.content;
+	for (let e = 1; e <= (n.openStart == 0 && n.size ? 2 : 1); e++) for (let t = r.depth; t >= 0; t--) {
+		let n = t == r.depth ? 0 : r.pos <= (r.start(t + 1) + r.end(t + 1)) / 2 ? -1 : 1, a = r.index(t) + +(n > 0), o = r.node(t), s = !1;
+		if (e == 1) s = o.canReplace(a, a, i);
+		else {
+			let e = o.contentMatchAt(a).findWrapping(i.firstChild.type);
+			s = e && o.canReplaceWith(a, a, e[0]);
+		}
+		if (s) return n == 0 ? r.pos : n < 0 ? r.before(t + 1) : r.after(t + 1);
+	}
+	return null;
 }
-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 V(e, t, n = t, r = i.empty) {
+	if (t == n && !r.size) return null;
+	let a = e.resolve(t), o = e.resolve(n);
+	return H(a, o, r) ? new T(t, n, r) : new fe(a, o, r).fit();
 }
-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 H(e, t, n) {
+	return !n.openStart && !n.openEnd && e.start() == t.start() && e.parent.canReplace(e.index(), t.index(), n.content);
 }
-function D(s, e) {
-  for (let t = 0; t < e; t++)
-    s = s.firstChild.content;
-  return s;
+var fe = class {
+	constructor(t, n, r) {
+		this.$from = t, this.$to = n, this.unplaced = r, this.frontier = [], this.placed = e.empty;
+		for (let e = 0; e <= t.depth; e++) {
+			let n = t.node(e);
+			this.frontier.push({
+				type: n.type,
+				match: n.contentMatchAt(t.indexAfter(e))
+			});
+		}
+		for (let n = t.depth; n > 0; n--) this.placed = e.from(t.node(n).copy(this.placed));
+	}
+	get depth() {
+		return this.frontier.length - 1;
+	}
+	fit() {
+		for (; this.unplaced.size;) {
+			let e = this.findFittable();
+			e ? this.placeNodes(e) : this.openMore() || this.dropNode();
+		}
+		let e = this.mustMoveInline(), t = this.placed.size - this.depth - this.$from.depth, n = this.$from, r = this.close(e < 0 ? this.$to : n.doc.resolve(e));
+		if (!r) return null;
+		let a = this.placed, o = n.depth, s = r.depth;
+		for (; o && s && a.childCount == 1;) a = a.firstChild.content, o--, s--;
+		let c = new i(a, o, s);
+		return e > -1 ? new E(n.pos, e, this.$to.pos, this.$to.end(), c, t) : c.size || n.pos != this.$to.pos ? new T(n.pos, r.pos, c) : null;
+	}
+	findFittable() {
+		let t = this.unplaced.openStart;
+		for (let e = this.unplaced.content, n = 0, r = this.unplaced.openEnd; n < t; n++) {
+			let i = e.firstChild;
+			if (e.childCount > 1 && (r = 0), i.type.spec.isolating && r <= n) {
+				t = n;
+				break;
+			}
+			e = i.content;
+		}
+		for (let n = 1; n <= 2; n++) for (let r = n == 1 ? t : this.unplaced.openStart; r >= 0; r--) {
+			let t, i = null;
+			r ? (i = G(this.unplaced.content, r - 1).firstChild, t = i.content) : t = this.unplaced.content;
+			let a = t.firstChild;
+			for (let t = this.depth; t >= 0; t--) {
+				let { type: o, match: s } = this.frontier[t], c, l = null;
+				if (n == 1 && (a ? s.matchType(a.type) || (l = s.fillBefore(e.from(a), !1)) : i && o.compatibleContent(i.type))) return {
+					sliceDepth: r,
+					frontierDepth: t,
+					parent: i,
+					inject: l
+				};
+				if (n == 2 && a && (c = s.findWrapping(a.type))) return {
+					sliceDepth: r,
+					frontierDepth: t,
+					parent: i,
+					wrap: c
+				};
+				if (i && s.matchType(i.type)) break;
+			}
+		}
+	}
+	openMore() {
+		let { content: e, openStart: t, openEnd: n } = this.unplaced, r = G(e, t);
+		return !r.childCount || r.firstChild.isLeaf ? !1 : (this.unplaced = new i(e, t + 1, Math.max(n, r.size + t >= e.size - n ? t + 1 : 0)), !0);
+	}
+	dropNode() {
+		let { content: e, openStart: t, openEnd: n } = this.unplaced, r = G(e, t);
+		if (r.childCount <= 1 && t > 0) {
+			let a = e.size - t <= t + r.size;
+			this.unplaced = new i(U(e, t - 1, 1), t - 1, a ? t - 1 : n);
+		} else this.unplaced = new i(U(e, t, 1), t, n);
+	}
+	placeNodes({ sliceDepth: t, frontierDepth: n, parent: r, inject: a, wrap: o }) {
+		for (; this.depth > n;) this.closeFrontierNode();
+		if (o) for (let e = 0; e < o.length; e++) this.openFrontierNode(o[e]);
+		let s = this.unplaced, c = r ? r.content : s.content, l = s.openStart - t, u = 0, d = [], { match: f, type: p } = this.frontier[n];
+		if (a) {
+			for (let e = 0; e < a.childCount; e++) d.push(a.child(e));
+			f = f.matchFragment(a);
+		}
+		let m = c.size + t - (s.content.size - s.openEnd);
+		for (; u < c.childCount;) {
+			let e = c.child(u), t = f.matchType(e.type);
+			if (!t) break;
+			u++, (u > 1 || l == 0 || e.content.size) && (f = t, d.push(K(e.mark(p.allowedMarks(e.marks)), u == 1 ? l : 0, u == c.childCount ? m : -1)));
+		}
+		let h = u == c.childCount;
+		h || (m = -1), this.placed = W(this.placed, n, e.from(d)), this.frontier[n].match = f, h && m < 0 && r && r.type == this.frontier[this.depth].type && this.frontier.length > 1 && this.closeFrontierNode();
+		for (let e = 0, t = c; e < m; e++) {
+			let e = t.lastChild;
+			this.frontier.push({
+				type: e.type,
+				match: e.contentMatchAt(e.childCount)
+			}), t = e.content;
+		}
+		this.unplaced = h ? t == 0 ? i.empty : new i(U(s.content, t - 1, 1), t - 1, m < 0 ? s.openEnd : t - 1) : new i(U(s.content, t, u), s.openStart, s.openEnd);
+	}
+	mustMoveInline() {
+		if (!this.$to.parent.isTextblock) return -1;
+		let e = this.frontier[this.depth], t;
+		if (!e.type.isTextblock || !q(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: n } = this.$to, r = this.$to.after(n);
+		for (; n > 1 && r == this.$to.end(--n);) ++r;
+		return r;
+	}
+	findCloseLevel(e) {
+		scan: for (let t = Math.min(this.depth, e.depth); t >= 0; t--) {
+			let { match: n, type: r } = this.frontier[t], i = t < e.depth && e.end(t + 1) == e.pos + (e.depth - (t + 1)), a = q(e, t, r, n, i);
+			if (a) {
+				for (let n = t - 1; n >= 0; n--) {
+					let { match: t, type: r } = this.frontier[n], i = q(e, n, r, t, !0);
+					if (!i || i.childCount) continue scan;
+				}
+				return {
+					depth: t,
+					fit: a,
+					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 = W(this.placed, t.depth, t.fit)), e = t.move;
+		for (let n = t.depth + 1; n <= e.depth; n++) {
+			let t = e.node(n), r = t.type.contentMatch.fillBefore(t.content, !0, e.index(n));
+			this.openFrontierNode(t.type, t.attrs, r);
+		}
+		return e;
+	}
+	openFrontierNode(t, n = null, r) {
+		let i = this.frontier[this.depth];
+		i.match = i.match.matchType(t), this.placed = W(this.placed, this.depth, e.from(t.create(n, r))), this.frontier.push({
+			type: t,
+			match: t.contentMatch
+		});
+	}
+	closeFrontierNode() {
+		let t = this.frontier.pop().match.fillBefore(e.empty, !0);
+		t.childCount && (this.placed = W(this.placed, this.frontier.length, t));
+	}
+};
+function U(e, t, n) {
+	return t == 0 ? e.cutByIndex(n, e.childCount) : e.replaceChild(0, e.firstChild.copy(U(e.firstChild.content, t - 1, n)));
 }
-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 W(e, t, n) {
+	return t == 0 ? e.append(n) : e.replaceChild(e.childCount - 1, e.lastChild.copy(W(e.lastChild.content, t - 1, n)));
 }
-function W(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 && !Ie(t, i.content, o) ? l : null;
+function G(e, t) {
+	for (let n = 0; n < t; n++) e = e.firstChild.content;
+	return e;
 }
-function Ie(s, e, t) {
-  for (let r = t; r < e.childCount; r++)
-    if (!s.allowsMarks(e.child(r).marks))
-      return !0;
-  return !1;
+function K(t, n, r) {
+	if (n <= 0) return t;
+	let i = t.content;
+	return n > 1 && (i = i.replaceChild(0, K(i.firstChild, n - 1, i.childCount == 1 ? r - 1 : 0))), n > 0 && (i = t.type.contentMatch.fillBefore(i).append(i), r <= 0 && (i = i.append(t.type.contentMatch.matchFragment(i).fillBefore(e.empty, !0)))), t.copy(i);
 }
-function Ne(s) {
-  return s.spec.defining || s.spec.definingForContent;
+function q(e, t, n, r, i) {
+	let a = e.node(t), o = i ? e.indexAfter(t) : e.index(t);
+	if (o == a.childCount && !n.compatibleContent(a.type)) return null;
+	let s = r.fillBefore(a.content, !0, o);
+	return s && !pe(n, a.content, o) ? s : null;
 }
-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 k(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 = Ne(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], N = !0;
-        x < 0 && (N = !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), N ? 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 pe(e, t, n) {
+	for (let r = n; r < t.childCount; r++) if (!e.allowsMarks(t.child(r).marks)) return !0;
+	return !1;
 }
-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 me(e) {
+	return e.spec.defining || e.spec.definingForContent;
 }
-function Te(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 he(e, t, n, r) {
+	if (!r.size) return e.deleteRange(t, n);
+	let a = e.doc.resolve(t), o = e.doc.resolve(n);
+	if (H(a, o, r)) return e.step(new T(t, n, r));
+	let s = X(a, o);
+	s[s.length - 1] == 0 && s.pop();
+	let c = -(a.depth + 1);
+	s.unshift(c);
+	for (let e = a.depth, t = a.pos - 1; e > 0; e--, t--) {
+		let n = a.node(e).type.spec;
+		if (n.defining || n.definingAsContext || n.isolating) break;
+		s.indexOf(e) > -1 ? c = e : a.before(e) == t && s.splice(1, 0, -e);
+	}
+	let l = s.indexOf(c), u = [], d = r.openStart;
+	for (let e = r.content, t = 0;; t++) {
+		let n = e.firstChild;
+		if (u.push(n), t == r.openStart) break;
+		e = n.content;
+	}
+	for (let e = d - 1; e >= 0; e--) {
+		let t = u[e], n = me(t.type);
+		if (n && !t.sameMarkup(a.node(Math.abs(c) - 1))) d = e;
+		else if (n || !t.type.isTextblock) break;
+	}
+	for (let t = r.openStart; t >= 0; t--) {
+		let c = (t + d + 1) % (r.openStart + 1), f = u[c];
+		if (f) for (let t = 0; t < s.length; t++) {
+			let u = s[(t + l) % s.length], d = !0;
+			u < 0 && (d = !1, u = -u);
+			let p = a.node(u - 1), m = a.index(u - 1);
+			if (p.canReplaceWith(m, m, f.type, f.marks)) return e.replace(a.before(u), d ? o.after(u) : n, new i(J(r.content, 0, r.openStart, c), c, r.openEnd));
+		}
+	}
+	let f = e.steps.length;
+	for (let i = s.length - 1; i >= 0 && (e.replace(t, n, r), !(e.steps.length > f)); i--) {
+		let e = s[i];
+		e < 0 || (t = a.before(e), n = o.after(e));
+	}
 }
-function Ee(s, e, t) {
-  let r = s.doc.resolve(e), n = s.doc.resolve(t);
-  if (r.parent.isTextblock && n.parent.isTextblock && r.start() != n.start() && r.parentOffset == 0 && n.parentOffset == 0) {
-    let o = r.sharedDepth(t), l = !1;
-    for (let a = r.depth; a > o; a--)
-      r.node(a).type.spec.isolating && (l = !0);
-    for (let a = n.depth; a > o; a--)
-      n.node(a).type.spec.isolating && (l = !0);
-    if (!l) {
-      for (let a = r.depth; a > 0 && e == r.start(a); a--)
-        e = r.before(a);
-      for (let a = n.depth; a > 0 && t == n.start(a); a--)
-        t = n.before(a);
-      r = s.doc.resolve(e), n = s.doc.resolve(t);
-    }
-  }
-  let 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 J(t, n, r, i, a) {
+	if (n < r) {
+		let e = t.firstChild;
+		t = t.replaceChild(0, e.copy(J(e.content, n + 1, r, i, e)));
+	}
+	if (n > i) {
+		let n = a.contentMatchAt(0), r = n.fillBefore(t).append(t);
+		t = r.append(n.matchFragment(r).fillBefore(e.empty, !0));
+	}
+	return 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 Y(t, n, r, a) {
+	if (!a.isInline && n == r && t.doc.resolve(n).parent.content.size) {
+		let e = z(t.doc, n, a.type);
+		e != null && (n = r = e);
+	}
+	t.replaceRange(n, r, new i(e.from(a), 0, 0));
 }
-class T extends v {
-  /**
-  Construct an attribute step.
-  */
-  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 T(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 T(t.pos, this.attr, this.value);
-  }
-  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 T(t.pos, t.attr, t.value);
-  }
+function ge(e, t, n) {
+	let r = e.doc.resolve(t), i = e.doc.resolve(n);
+	if (r.parent.isTextblock && i.parent.isTextblock && r.start() != i.start() && r.parentOffset == 0 && i.parentOffset == 0) {
+		let a = r.sharedDepth(n), o = !1;
+		for (let e = r.depth; e > a; e--) r.node(e).type.spec.isolating && (o = !0);
+		for (let e = i.depth; e > a; e--) i.node(e).type.spec.isolating && (o = !0);
+		if (!o) {
+			for (let e = r.depth; e > 0 && t == r.start(e); e--) t = r.before(e);
+			for (let e = i.depth; e > 0 && n == i.start(e); e--) n = i.before(e);
+			r = e.doc.resolve(t), i = e.doc.resolve(n);
+		}
+	}
+	let a = X(r, i);
+	for (let t = 0; t < a.length; t++) {
+		let n = a[t], o = t == a.length - 1;
+		if (o && n == 0 || r.node(n).type.contentMatch.validEnd) return e.delete(r.start(n), i.end(n));
+		if (n > 0 && (o || r.node(n - 1).canReplace(r.index(n - 1), i.indexAfter(n - 1)))) return e.delete(r.before(n), i.after(n));
+	}
+	for (let a = 1; a <= r.depth && a <= i.depth; a++) if (t - r.start(a) == r.depth - a && n > r.end(a) && i.end(a) - n != i.depth - a && r.start(a - 1) == i.start(a - 1) && r.node(a - 1).canReplace(r.index(a - 1), i.index(a - 1))) return e.delete(r.before(a), n);
+	e.delete(t, n);
 }
-v.jsonID("attr", T);
-class z extends v {
-  /**
-  Construct an attribute step.
-  */
-  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);
-  }
+function X(e, t) {
+	let n = [], r = Math.min(e.depth, t.depth);
+	for (let i = r; i >= 0; i--) {
+		let r = e.start(i);
+		if (r < e.pos - (e.depth - i) || t.end(i) > t.pos + (t.depth - i) || e.node(i).type.spec.isolating || t.node(i).type.spec.isolating) break;
+		(r == t.start(i) || i == e.depth && i == t.depth && e.parent.inlineContent && t.parent.inlineContent && i && t.start(i - 1) == r - 1) && n.push(i);
+	}
+	return n;
 }
-v.jsonID("docAttr", z);
-let E = class extends Error {
+var Z = class t extends v {
+	constructor(e, t, n) {
+		super(), this.pos = e, this.attr = t, this.value = n;
+	}
+	apply(t) {
+		let n = t.nodeAt(this.pos);
+		if (!n) return y.fail("No node at attribute step's position");
+		let r = Object.create(null);
+		for (let e in n.attrs) r[e] = n.attrs[e];
+		r[this.attr] = this.value;
+		let a = n.type.create(r, null, n.marks);
+		return y.fromReplace(t, this.pos, this.pos + 1, new i(e.from(a), 0, +!n.isLeaf));
+	}
+	getMap() {
+		return h.empty;
+	}
+	invert(e) {
+		return new t(this.pos, this.attr, e.nodeAt(this.pos).attrs[this.attr]);
+	}
+	map(e) {
+		let n = e.mapResult(this.pos, 1);
+		return n.deletedAfter ? null : new t(n.pos, this.attr, this.value);
+	}
+	toJSON() {
+		return {
+			stepType: "attr",
+			pos: this.pos,
+			attr: this.attr,
+			value: this.value
+		};
+	}
+	static fromJSON(e, n) {
+		if (typeof n.pos != "number" || typeof n.attr != "string") throw RangeError("Invalid input for AttrStep.fromJSON");
+		return new t(n.pos, n.attr, n.value);
+	}
 };
-E = function s(e) {
-  let t = Error.call(this, e);
-  return t.__proto__ = s.prototype, t;
+v.jsonID("attr", Z);
+var Q = class e extends v {
+	constructor(e, t) {
+		super(), this.attr = e, this.value = t;
+	}
+	apply(e) {
+		let t = Object.create(null);
+		for (let n in e.attrs) t[n] = e.attrs[n];
+		t[this.attr] = this.value;
+		let n = e.type.create(t, e.content, e.marks);
+		return y.ok(n);
+	}
+	getMap() {
+		return h.empty;
+	}
+	invert(t) {
+		return new e(this.attr, t.attrs[this.attr]);
+	}
+	map(e) {
+		return this;
+	}
+	toJSON() {
+		return {
+			stepType: "docAttr",
+			attr: this.attr,
+			value: this.value
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.attr != "string") throw RangeError("Invalid input for DocAttrStep.fromJSON");
+		return new e(n.attr, n.value);
+	}
 };
-E.prototype = Object.create(Error.prototype);
-E.prototype.constructor = E;
-E.prototype.name = "TransformError";
-class We {
-  /**
-  Create a transform that starts with the given document.
-  */
-  constructor(e) {
-    this.doc = e, this.steps = [], this.docs = [], this.mapping = new J();
-  }
-  /**
-  The starting document.
-  */
-  get before() {
-    return this.docs.length ? this.docs[0] : this.doc;
-  }
-  /**
-  Apply a new step in this transform, saving the result. Throws an
-  error when the step fails.
-  */
-  step(e) {
-    let t = this.maybeStep(e);
-    if (t.failed)
-      throw new E(t.failed);
-    return this;
-  }
-  /**
-  Try to apply a step in this transformation, ignoring it if it
-  fails. Returns the step result.
-  */
-  maybeStep(e) {
-    let t = e.apply(this.doc);
-    return t.failed || this.addStep(e, t.doc), t;
-  }
-  /**
-  True when the document has been changed (when there are any
-  steps).
-  */
-  get docChanged() {
-    return this.steps.length > 0;
-  }
-  /**
-  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.
-  */
-  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 };
-  }
-  /**
-  @internal
-  */
-  addStep(e, t) {
-    this.docs.push(this.doc), this.steps.push(e), this.mapping.appendMap(e.getMap()), this.doc = t;
-  }
-  /**
-  Replace the part of the document between `from` and `to` with the
-  given `slice`.
-  */
-  replace(e, t = e, r = g.empty) {
-    let n = Me(this.doc, e, t, r);
-    return n && this.step(n), this;
-  }
-  /**
-  Replace the given range with the given content, which may be a
-  fragment, node, or array of nodes.
-  */
-  replaceWith(e, t, r) {
-    return this.replace(e, t, new g(w.from(r), 0, 0));
-  }
-  /**
-  Delete the content between the given positions.
-  */
-  delete(e, t) {
-    return this.replace(e, t, g.empty);
-  }
-  /**
-  Insert the given content at the given position.
-  */
-  insert(e, t) {
-    return this.replaceWith(e, e, t);
-  }
-  /**
-  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.
-  */
-  replaceRange(e, t, r) {
-    return Re(this, e, t, r), this;
-  }
-  /**
-  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.
-  */
-  replaceRangeWith(e, t, r) {
-    return Te(this, e, t, r), this;
-  }
-  /**
-  Delete the given range, expanding it to cover fully covered
-  parent nodes until a valid replace is found.
-  */
-  deleteRange(e, t) {
-    return Ee(this, e, t), this;
-  }
-  /**
-  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.
-  */
-  lift(e, t) {
-    return de(this, e, t), this;
-  }
-  /**
-  Join the blocks around the given position. If depth is 2, their
-  last and first siblings are also joined, and so on.
-  */
-  join(e, t = 1) {
-    return Se(this, e, t), this;
-  }
-  /**
-  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).
-  */
-  wrap(e, t) {
-    return ge(this, e, t), this;
-  }
-  /**
-  Set the type of all textblocks (partly) between `from` and `to` to
-  the given node type with the given attributes.
-  */
-  setBlockType(e, t = e, r, n = null) {
-    return we(this, e, t, r, n), this;
-  }
-  /**
-  Change the type, attributes, and/or marks of the node at `pos`.
-  When `type` isn't given, the existing node type is preserved,
-  */
-  setNodeMarkup(e, t, r = null, n) {
-    return ke(this, e, t, r, n), 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.
-  */
-  setNodeAttribute(e, t, r) {
-    return this.step(new T(e, t, r)), this;
-  }
-  /**
-  Set a single attribute on the document to a new value.
-  */
-  setDocAttribute(e, t) {
-    return this.step(new z(e, t)), this;
-  }
-  /**
-  Add a mark to the node at position `pos`.
-  */
-  addNodeMark(e, t) {
-    return this.step(new I(e, t)), this;
-  }
-  /**
-  Remove a mark (or all marks of the given type) from the node at
-  position `pos`.
-  */
-  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));
-    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]);
-    }
-    return this;
-  }
-  /**
-  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).
-  */
-  split(e, t = 1, r) {
-    return ve(this, e, t, r), this;
-  }
-  /**
-  Add the given mark to the inline content between `from` and `to`.
-  */
-  addMark(e, t, r) {
-    return pe(this, e, t, r), this;
-  }
-  /**
-  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.
-  */
-  removeMark(e, t, r) {
-    return fe(this, e, t, r), this;
-  }
-  /**
-  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.
-  */
-  clearIncompatible(e, t, r) {
-    return $(this, e, t, r), this;
-  }
-}
-export {
-  C as AddMarkStep,
-  I as AddNodeMarkStep,
-  T as AttrStep,
-  z as DocAttrStep,
-  L as MapResult,
-  J as Mapping,
-  b as RemoveMarkStep,
-  R as RemoveNodeMarkStep,
-  M as ReplaceAroundStep,
-  k as ReplaceStep,
-  v as Step,
-  S as StepMap,
-  y as StepResult,
-  We as Transform,
-  E as TransformError,
-  Je as canJoin,
-  Ae as canSplit,
-  De as dropPoint,
-  ze as findWrapping,
-  be as insertPoint,
-  Be as joinPoint,
-  Fe as liftTarget,
-  Me as replaceStep
+v.jsonID("docAttr", Q);
+var $ = class extends Error {};
+$ = function e(t) {
+	let n = Error.call(this, t);
+	return n.__proto__ = e.prototype, n;
+}, $.prototype = Object.create(Error.prototype), $.prototype.constructor = $, $.prototype.name = "TransformError";
+var _e = class {
+	constructor(e) {
+		this.doc = e, this.steps = [], this.docs = [], this.mapping = new g();
+	}
+	get before() {
+		return this.docs.length ? this.docs[0] : this.doc;
+	}
+	step(e) {
+		let t = this.maybeStep(e);
+		if (t.failed) throw new $(t.failed);
+		return this;
+	}
+	maybeStep(e) {
+		let t = e.apply(this.doc);
+		return t.failed || this.addStep(e, t.doc), t;
+	}
+	get docChanged() {
+		return this.steps.length > 0;
+	}
+	changedRange() {
+		let e = 1e9, t = -1e9;
+		for (let n = 0; n < this.mapping.maps.length; n++) {
+			let r = this.mapping.maps[n];
+			n && (e = r.map(e, 1), t = r.map(t, -1)), r.forEach((n, r, i, a) => {
+				e = Math.min(e, i), t = Math.max(t, a);
+			});
+		}
+		return e == 1e9 ? null : {
+			from: e,
+			to: t
+		};
+	}
+	addStep(e, t) {
+		this.docs.push(this.doc), this.steps.push(e), this.mapping.appendMap(e.getMap()), this.doc = t;
+	}
+	replace(e, t = e, n = i.empty) {
+		let r = V(this.doc, e, t, n);
+		return r && this.step(r), this;
+	}
+	replaceWith(t, n, r) {
+		return this.replace(t, n, new i(e.from(r), 0, 0));
+	}
+	delete(e, t) {
+		return this.replace(e, t, i.empty);
+	}
+	insert(e, t) {
+		return this.replaceWith(e, e, t);
+	}
+	replaceRange(e, t, n) {
+		return he(this, e, t, n), this;
+	}
+	replaceRangeWith(e, t, n) {
+		return Y(this, e, t, n), this;
+	}
+	deleteRange(e, t) {
+		return ge(this, e, t), this;
+	}
+	lift(e, t) {
+		return ie(this, e, t), this;
+	}
+	join(e, t = 1) {
+		return R(this, e, t), this;
+	}
+	wrap(e, t) {
+		return A(this, e, t), this;
+	}
+	setBlockType(e, t = e, n, r = null) {
+		return j(this, e, t, n, r), this;
+	}
+	setNodeMarkup(e, t, n = null, r) {
+		return F(this, e, t, n, r), this;
+	}
+	setNodeAttribute(e, t, n) {
+		return this.step(new Z(e, t, n)), this;
+	}
+	setDocAttribute(e, t) {
+		return this.step(new Q(e, t)), this;
+	}
+	addNodeMark(e, t) {
+		return this.step(new C(e, t)), this;
+	}
+	removeNodeMark(e, n) {
+		let r = this.doc.nodeAt(e);
+		if (!r) throw RangeError("No node at position " + e);
+		if (n instanceof t) n.isInSet(r.marks) && this.step(new w(e, n));
+		else {
+			let t = r.marks, i, a = [];
+			for (; i = n.isInSet(t);) a.push(new w(e, i)), t = i.removeFromSet(t);
+			for (let e = a.length - 1; e >= 0; e--) this.step(a[e]);
+		}
+		return this;
+	}
+	split(e, t = 1, n) {
+		return le(this, e, t, n), this;
+	}
+	addMark(e, t, n) {
+		return ee(this, e, t, n), this;
+	}
+	removeMark(e, t, n) {
+		return te(this, e, t, n), this;
+	}
+	clearIncompatible(e, t, n) {
+		return O(this, e, t, n), this;
+	}
 };
+//#endregion
+export { x as AddMarkStep, C as AddNodeMarkStep, Z as AttrStep, Q as DocAttrStep, m as MapResult, g as Mapping, S as RemoveMarkStep, w as RemoveNodeMarkStep, E as ReplaceAroundStep, T as ReplaceStep, v as Step, h as StepMap, y as StepResult, _e as Transform, $ as TransformError, ue as canJoin, ce as canSplit, B as dropPoint, ae as findWrapping, z as insertPoint, L as joinPoint, re as liftTarget, V as replaceStep };