@caspeco/casper-ui-library 9.12.0 → 10.0.0

package/dist/node_modules/@tiptap/extension-blockquote/dist/index.js

@@ -1,6 +1,1442 @@
-import { Node as c, wrappingInputRule as p, mergeAttributes as k } from "../../core/dist/index.js";
-import { createElement as s } from "../../core/dist/jsx-runtime/jsx-runtime.js";
-var m = /^\s*>\s$/, q = c.create({
+import { Node as yt, wrappingInputRule as xt, mergeAttributes as Nt } from "../../core/dist/index.js";
+import { createElement as Z } from "../../core/dist/jsx-runtime/jsx-runtime.js";
+function it(i, t, e) {
+  for (let r = 0; ; r++) {
+    if (r == i.childCount || r == t.childCount)
+      return i.childCount == t.childCount ? null : e;
+    let n = i.child(r), s = t.child(r);
+    if (n == s) {
+      e += n.nodeSize;
+      continue;
+    }
+    if (!n.sameMarkup(s))
+      return e;
+    if (n.isText && n.text != s.text) {
+      for (let o = 0; n.text[o] == s.text[o]; o++)
+        e++;
+      return e;
+    }
+    if (n.content.size || s.content.size) {
+      let o = it(n.content, s.content, e + 1);
+      if (o != null)
+        return o;
+    }
+    e += n.nodeSize;
+  }
+}
+function st(i, t, e, r) {
+  for (let n = i.childCount, s = t.childCount; ; ) {
+    if (n == 0 || s == 0)
+      return n == s ? null : { a: e, b: r };
+    let o = i.child(--n), a = t.child(--s), l = o.nodeSize;
+    if (o == a) {
+      e -= l, r -= l;
+      continue;
+    }
+    if (!o.sameMarkup(a))
+      return { a: e, b: r };
+    if (o.isText && o.text != a.text) {
+      let h = 0, u = Math.min(o.text.length, a.text.length);
+      for (; h < u && o.text[o.text.length - h - 1] == a.text[a.text.length - h - 1]; )
+        h++, e--, r--;
+      return { a: e, b: r };
+    }
+    if (o.content.size || a.content.size) {
+      let h = st(o.content, a.content, e - 1, r - 1);
+      if (h)
+        return h;
+    }
+    e -= l, r -= l;
+  }
+}
+var g = class m {
+  /**
+  @internal
+  */
+  constructor(t, e) {
+    if (this.content = t, this.size = e || 0, e == null)
+      for (let r = 0; r < t.length; r++)
+        this.size += t[r].nodeSize;
+  }
+  /**
+  Invoke a callback for all descendant nodes between the given two
+  positions (relative to start of this fragment). Doesn't descend
+  into a node when the callback returns `false`.
+  */
+  nodesBetween(t, e, r, n = 0, s) {
+    for (let o = 0, a = 0; a < e; o++) {
+      let l = this.content[o], h = a + l.nodeSize;
+      if (h > t && r(l, n + a, s || null, o) !== !1 && l.content.size) {
+        let u = a + 1;
+        l.nodesBetween(Math.max(0, t - u), Math.min(l.content.size, e - u), r, n + u);
+      }
+      a = h;
+    }
+  }
+  /**
+  Call the given callback for every descendant node. `pos` will be
+  relative to the start of the fragment. The callback may return
+  `false` to prevent traversal of a given node's children.
+  */
+  descendants(t) {
+    this.nodesBetween(0, this.size, t);
+  }
+  /**
+  Extract the text between `from` and `to`. See the same method on
+  [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
+  */
+  textBetween(t, e, r, n) {
+    let s = "", o = !0;
+    return this.nodesBetween(t, e, (a, l) => {
+      let h = a.isText ? a.text.slice(Math.max(t, l) - l, e - l) : a.isLeaf ? n ? typeof n == "function" ? n(a) : n : a.type.spec.leafText ? a.type.spec.leafText(a) : "" : "";
+      a.isBlock && (a.isLeaf && h || a.isTextblock) && r && (o ? o = !1 : s += r), s += h;
+    }, 0), s;
+  }
+  /**
+  Create a new fragment containing the combined content of this
+  fragment and the other.
+  */
+  append(t) {
+    if (!t.size)
+      return this;
+    if (!this.size)
+      return t;
+    let e = this.lastChild, r = t.firstChild, n = this.content.slice(), s = 0;
+    for (e.isText && e.sameMarkup(r) && (n[n.length - 1] = e.withText(e.text + r.text), s = 1); s < t.content.length; s++)
+      n.push(t.content[s]);
+    return new m(n, this.size + t.size);
+  }
+  /**
+  Cut out the sub-fragment between the two given positions.
+  */
+  cut(t, e = this.size) {
+    if (t == 0 && e == this.size)
+      return this;
+    let r = [], n = 0;
+    if (e > t)
+      for (let s = 0, o = 0; o < e; s++) {
+        let a = this.content[s], l = o + a.nodeSize;
+        l > t && ((o < t || l > e) && (a.isText ? a = a.cut(Math.max(0, t - o), Math.min(a.text.length, e - o)) : a = a.cut(Math.max(0, t - o - 1), Math.min(a.content.size, e - o - 1))), r.push(a), n += a.nodeSize), o = l;
+      }
+    return new m(r, n);
+  }
+  /**
+  @internal
+  */
+  cutByIndex(t, e) {
+    return t == e ? m.empty : t == 0 && e == this.content.length ? this : new m(this.content.slice(t, e));
+  }
+  /**
+  Create a new fragment in which the node at the given index is
+  replaced by the given node.
+  */
+  replaceChild(t, e) {
+    let r = this.content[t];
+    if (r == e)
+      return this;
+    let n = this.content.slice(), s = this.size + e.nodeSize - r.nodeSize;
+    return n[t] = e, new m(n, s);
+  }
+  /**
+  Create a new fragment by prepending the given node to this
+  fragment.
+  */
+  addToStart(t) {
+    return new m([t].concat(this.content), this.size + t.nodeSize);
+  }
+  /**
+  Create a new fragment by appending the given node to this
+  fragment.
+  */
+  addToEnd(t) {
+    return new m(this.content.concat(t), this.size + t.nodeSize);
+  }
+  /**
+  Compare this fragment to another one.
+  */
+  eq(t) {
+    if (this.content.length != t.content.length)
+      return !1;
+    for (let e = 0; e < this.content.length; e++)
+      if (!this.content[e].eq(t.content[e]))
+        return !1;
+    return !0;
+  }
+  /**
+  The first child of the fragment, or `null` if it is empty.
+  */
+  get firstChild() {
+    return this.content.length ? this.content[0] : null;
+  }
+  /**
+  The last child of the fragment, or `null` if it is empty.
+  */
+  get lastChild() {
+    return this.content.length ? this.content[this.content.length - 1] : null;
+  }
+  /**
+  The number of child nodes in this fragment.
+  */
+  get childCount() {
+    return this.content.length;
+  }
+  /**
+  Get the child node at the given index. Raise an error when the
+  index is out of range.
+  */
+  child(t) {
+    let e = this.content[t];
+    if (!e)
+      throw new RangeError("Index " + t + " out of range for " + this);
+    return e;
+  }
+  /**
+  Get the child node at the given index, if it exists.
+  */
+  maybeChild(t) {
+    return this.content[t] || null;
+  }
+  /**
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
+  */
+  forEach(t) {
+    for (let e = 0, r = 0; e < this.content.length; e++) {
+      let n = this.content[e];
+      t(n, r, e), r += n.nodeSize;
+    }
+  }
+  /**
+  Find the first position at which this fragment and another
+  fragment differ, or `null` if they are the same.
+  */
+  findDiffStart(t, e = 0) {
+    return it(this, t, e);
+  }
+  /**
+  Find the first position, searching from the end, at which this
+  fragment and the given fragment differ, or `null` if they are
+  the same. Since this position will not be the same in both
+  nodes, an object with two separate positions is returned.
+  */
+  findDiffEnd(t, e = this.size, r = t.size) {
+    return st(this, t, e, r);
+  }
+  /**
+  Find the index and inner offset corresponding to a given relative
+  position in this fragment. The result object will be reused
+  (overwritten) the next time the function is called. @internal
+  */
+  findIndex(t) {
+    if (t == 0)
+      return F(0, t);
+    if (t == this.size)
+      return F(this.content.length, t);
+    if (t > this.size || t < 0)
+      throw new RangeError(`Position ${t} outside of fragment (${this})`);
+    for (let e = 0, r = 0; ; e++) {
+      let n = this.child(e), s = r + n.nodeSize;
+      if (s >= t)
+        return s == t ? F(e + 1, s) : F(e, r);
+      r = s;
+    }
+  }
+  /**
+  Return a debugging string that describes this fragment.
+  */
+  toString() {
+    return "<" + this.toStringInner() + ">";
+  }
+  /**
+  @internal
+  */
+  toStringInner() {
+    return this.content.join(", ");
+  }
+  /**
+  Create a JSON-serializeable representation of this fragment.
+  */
+  toJSON() {
+    return this.content.length ? this.content.map((t) => t.toJSON()) : null;
+  }
+  /**
+  Deserialize a fragment from its JSON representation.
+  */
+  static fromJSON(t, e) {
+    if (!e)
+      return m.empty;
+    if (!Array.isArray(e))
+      throw new RangeError("Invalid input for Fragment.fromJSON");
+    return m.fromArray(e.map(t.nodeFromJSON));
+  }
+  /**
+  Build a fragment from an array of nodes. Ensures that adjacent
+  text nodes with the same marks are joined together.
+  */
+  static fromArray(t) {
+    if (!t.length)
+      return m.empty;
+    let e, r = 0;
+    for (let n = 0; n < t.length; n++) {
+      let s = t[n];
+      r += s.nodeSize, n && s.isText && t[n - 1].sameMarkup(s) ? (e || (e = t.slice(0, n)), e[e.length - 1] = s.withText(e[e.length - 1].text + s.text)) : e && e.push(s);
+    }
+    return new m(e || t, r);
+  }
+  /**
+  Create a fragment from something that can be interpreted as a
+  set of nodes. For `null`, it returns the empty fragment. For a
+  fragment, the fragment itself. For a node or array of nodes, a
+  fragment containing those nodes.
+  */
+  static from(t) {
+    if (!t)
+      return m.empty;
+    if (t instanceof m)
+      return t;
+    if (Array.isArray(t))
+      return this.fromArray(t);
+    if (t.attrs)
+      return new m([t], t.nodeSize);
+    throw new RangeError("Can not convert " + t + " to a Fragment" + (t.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
+  }
+};
+g.empty = new g([], 0);
+var H = { index: 0, offset: 0 };
+function F(i, t) {
+  return H.index = i, H.offset = t, H;
+}
+var Rt = class extends Error {
+}, c = class y {
+  /**
+  Create a slice. When specifying a non-zero open depth, you must
+  make sure that there are nodes of at least that depth at the
+  appropriate side of the fragment—i.e. if the fragment is an
+  empty paragraph node, `openStart` and `openEnd` can't be greater
+  than 1.
+  
+  It is not necessary for the content of open nodes to conform to
+  the schema's content constraints, though it should be a valid
+  start/end/middle for such a node, depending on which sides are
+  open.
+  */
+  constructor(t, e, r) {
+    this.content = t, this.openStart = e, this.openEnd = r;
+  }
+  /**
+  The size this slice would add when inserted into a document.
+  */
+  get size() {
+    return this.content.size - this.openStart - this.openEnd;
+  }
+  /**
+  @internal
+  */
+  insertAt(t, e) {
+    let r = at(this.content, t + this.openStart, e, this.openStart + 1, this.openEnd + 1);
+    return r && new y(r, this.openStart, this.openEnd);
+  }
+  /**
+  @internal
+  */
+  removeBetween(t, e) {
+    return new y(ot(this.content, t + this.openStart, e + this.openStart), this.openStart, this.openEnd);
+  }
+  /**
+  Tests whether this slice is equal to another slice.
+  */
+  eq(t) {
+    return this.content.eq(t.content) && this.openStart == t.openStart && this.openEnd == t.openEnd;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.content + "(" + this.openStart + "," + this.openEnd + ")";
+  }
+  /**
+  Convert a slice to a JSON-serializable representation.
+  */
+  toJSON() {
+    if (!this.content.size)
+      return null;
+    let t = { content: this.content.toJSON() };
+    return this.openStart > 0 && (t.openStart = this.openStart), this.openEnd > 0 && (t.openEnd = this.openEnd), t;
+  }
+  /**
+  Deserialize a slice from its JSON representation.
+  */
+  static fromJSON(t, e) {
+    if (!e)
+      return y.empty;
+    let r = e.openStart || 0, n = e.openEnd || 0;
+    if (typeof r != "number" || typeof n != "number")
+      throw new RangeError("Invalid input for Slice.fromJSON");
+    return new y(g.fromJSON(t, e.content), r, n);
+  }
+  /**
+  Create a slice from a fragment by taking the maximum possible
+  open value on both side of the fragment.
+  */
+  static maxOpen(t, e = !0) {
+    let r = 0, n = 0;
+    for (let s = t.firstChild; s && !s.isLeaf && (e || !s.type.spec.isolating); s = s.firstChild)
+      r++;
+    for (let s = t.lastChild; s && !s.isLeaf && (e || !s.type.spec.isolating); s = s.lastChild)
+      n++;
+    return new y(t, r, n);
+  }
+};
+c.empty = new c(g.empty, 0, 0);
+function ot(i, t, e) {
+  let { index: r, offset: n } = i.findIndex(t), s = i.maybeChild(r), { index: o, offset: a } = i.findIndex(e);
+  if (n == t || s.isText) {
+    if (a != e && !i.child(o).isText)
+      throw new RangeError("Removing non-flat range");
+    return i.cut(0, t).append(i.cut(e));
+  }
+  if (r != o)
+    throw new RangeError("Removing non-flat range");
+  return i.replaceChild(r, s.copy(ot(s.content, t - n - 1, e - n - 1)));
+}
+function at(i, t, e, r, n, s) {
+  let { index: o, offset: a } = i.findIndex(t), l = i.maybeChild(o);
+  if (a == t || l.isText)
+    return s && r <= 0 && n <= 0 && !s.canReplace(o, o, e) ? null : i.cut(0, t).append(e).append(i.cut(t));
+  let h = at(l.content, t - a - 1, e, o == 0 ? r - 1 : 0, o == i.childCount - 1 ? n - 1 : 0, l);
+  return h && i.replaceChild(o, l.copy(h));
+}
+var lt = 65535, ht = Math.pow(2, 16);
+function Et(i, t) {
+  return i + t * ht;
+}
+function j(i) {
+  return i & lt;
+}
+function Ot(i) {
+  return (i - (i & lt)) / ht;
+}
+var ut = 1, ct = 2, D = 4, ft = 8, _ = class {
+  /**
+  @internal
+  */
+  constructor(i, t, e) {
+    this.pos = i, this.delInfo = t, this.recover = e;
+  }
+  /**
+  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 & ft) > 0;
+  }
+  /**
+  Tells you whether the token before the mapped position was deleted.
+  */
+  get deletedBefore() {
+    return (this.delInfo & (ut | D)) > 0;
+  }
+  /**
+  True when the token after the mapped position was deleted.
+  */
+  get deletedAfter() {
+    return (this.delInfo & (ct | D)) > 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 & D) > 0;
+  }
+}, k = class x {
+  /**
+  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(t, e = !1) {
+    if (this.ranges = t, this.inverted = e, !t.length && x.empty)
+      return x.empty;
+  }
+  /**
+  @internal
+  */
+  recover(t) {
+    let e = 0, r = j(t);
+    if (!this.inverted)
+      for (let n = 0; n < r; n++)
+        e += this.ranges[n * 3 + 2] - this.ranges[n * 3 + 1];
+    return this.ranges[r * 3] + e + Ot(t);
+  }
+  mapResult(t, e = 1) {
+    return this._map(t, e, !1);
+  }
+  map(t, e = 1) {
+    return this._map(t, e, !0);
+  }
+  /**
+  @internal
+  */
+  _map(t, e, r) {
+    let n = 0, s = this.inverted ? 2 : 1, o = this.inverted ? 1 : 2;
+    for (let a = 0; a < this.ranges.length; a += 3) {
+      let l = this.ranges[a] - (this.inverted ? n : 0);
+      if (l > t)
+        break;
+      let h = this.ranges[a + s], u = this.ranges[a + o], S = l + h;
+      if (t <= S) {
+        let X = h ? t == l ? -1 : t == S ? 1 : e : e, O = l + n + (X < 0 ? 0 : u);
+        if (r)
+          return O;
+        let v = t == (e < 0 ? l : S) ? null : Et(a / 3, t - l), Y = t == l ? ct : t == S ? ut : D;
+        return (e < 0 ? t != l : t != S) && (Y |= ft), new _(O, Y, v);
+      }
+      n += u - h;
+    }
+    return r ? t + n : new _(t + n, 0, null);
+  }
+  /**
+  @internal
+  */
+  touches(t, e) {
+    let r = 0, n = j(e), s = this.inverted ? 2 : 1, o = this.inverted ? 1 : 2;
+    for (let a = 0; a < this.ranges.length; a += 3) {
+      let l = this.ranges[a] - (this.inverted ? r : 0);
+      if (l > t)
+        break;
+      let h = this.ranges[a + s], u = l + h;
+      if (t <= u && a == n * 3)
+        return !0;
+      r += this.ranges[a + o] - h;
+    }
+    return !1;
+  }
+  /**
+  Calls the given function on each of the changed ranges included in
+  this map.
+  */
+  forEach(t) {
+    let e = this.inverted ? 2 : 1, r = this.inverted ? 1 : 2;
+    for (let n = 0, s = 0; n < this.ranges.length; n += 3) {
+      let o = this.ranges[n], a = o - (this.inverted ? s : 0), l = o + (this.inverted ? 0 : s), h = this.ranges[n + e], u = this.ranges[n + r];
+      t(a, a + h, l, l + u), s += u - 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 x(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(t) {
+    return t == 0 ? x.empty : new x(t < 0 ? [0, -t, 0] : [0, 0, t]);
+  }
+};
+k.empty = new k([]);
+var W = /* @__PURE__ */ Object.create(null), p = class {
+  /**
+  Get the step map that represents the changes made by this step,
+  and which can be used to transform between positions in the old
+  and the new document.
+  */
+  getMap() {
+    return k.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(i) {
+    return null;
+  }
+  /**
+  Deserialize a step from its JSON representation. Will call
+  through to the step class' own implementation of this method.
+  */
+  static fromJSON(i, t) {
+    if (!t || !t.stepType)
+      throw new RangeError("Invalid input for Step.fromJSON");
+    let e = W[t.stepType];
+    if (!e)
+      throw new RangeError(`No step type ${t.stepType} defined`);
+    return e.fromJSON(i, 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(i, t) {
+    if (i in W)
+      throw new RangeError("Duplicate use of step JSON ID " + i);
+    return W[i] = t, t.prototype.jsonID = i, t;
+  }
+}, d = class I {
+  /**
+  @internal
+  */
+  constructor(t, e) {
+    this.doc = t, this.failed = e;
+  }
+  /**
+  Create a successful step result.
+  */
+  static ok(t) {
+    return new I(t, null);
+  }
+  /**
+  Create a failed step result.
+  */
+  static fail(t) {
+    return new I(null, t);
+  }
+  /**
+  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(t, e, r, n) {
+    try {
+      return I.ok(t.replace(e, r, n));
+    } catch (s) {
+      if (s instanceof Rt)
+        return I.fail(s.message);
+      throw s;
+    }
+  }
+};
+function Q(i, t, e) {
+  let r = [];
+  for (let n = 0; n < i.childCount; n++) {
+    let s = i.child(n);
+    s.content.size && (s = s.copy(Q(s.content, t, s))), s.isInline && (s = t(s, e, n)), r.push(s);
+  }
+  return g.fromArray(r);
+}
+var pt = class z extends p {
+  /**
+  Create a mark step.
+  */
+  constructor(t, e, r) {
+    super(), this.from = t, this.to = e, this.mark = r;
+  }
+  apply(t) {
+    let e = t.slice(this.from, this.to), r = t.resolve(this.from), n = r.node(r.sharedDepth(this.to)), s = new c(Q(e.content, (o, a) => !o.isAtom || !a.type.allowsMarkType(this.mark.type) ? o : o.mark(this.mark.addToSet(o.marks)), n), e.openStart, e.openEnd);
+    return d.fromReplace(t, this.from, this.to, s);
+  }
+  invert() {
+    return new mt(this.from, this.to, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+    return e.deleted && r.deleted || e.pos >= r.pos ? null : new z(e.pos, r.pos, this.mark);
+  }
+  merge(t) {
+    return t instanceof z && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new z(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
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number")
+      throw new RangeError("Invalid input for AddMarkStep.fromJSON");
+    return new z(e.from, e.to, t.markFromJSON(e.mark));
+  }
+};
+p.jsonID("addMark", pt);
+var mt = class T extends p {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(t, e, r) {
+    super(), this.from = t, this.to = e, this.mark = r;
+  }
+  apply(t) {
+    let e = t.slice(this.from, this.to), r = new c(Q(e.content, (n) => n.mark(this.mark.removeFromSet(n.marks)), t), e.openStart, e.openEnd);
+    return d.fromReplace(t, this.from, this.to, r);
+  }
+  invert() {
+    return new pt(this.from, this.to, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+    return e.deleted && r.deleted || e.pos >= r.pos ? null : new T(e.pos, r.pos, this.mark);
+  }
+  merge(t) {
+    return t instanceof T && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new T(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
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number")
+      throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
+    return new T(e.from, e.to, t.markFromJSON(e.mark));
+  }
+};
+p.jsonID("removeMark", mt);
+var dt = class J extends p {
+  /**
+  Create a node mark step.
+  */
+  constructor(t, e) {
+    super(), this.pos = t, this.mark = e;
+  }
+  apply(t) {
+    let e = t.nodeAt(this.pos);
+    if (!e)
+      return d.fail("No node at mark step's position");
+    let r = e.type.create(e.attrs, null, this.mark.addToSet(e.marks));
+    return d.fromReplace(t, this.pos, this.pos + 1, new c(g.from(r), 0, e.isLeaf ? 0 : 1));
+  }
+  invert(t) {
+    let e = t.nodeAt(this.pos);
+    if (e) {
+      let r = this.mark.addToSet(e.marks);
+      if (r.length == e.marks.length) {
+        for (let n = 0; n < e.marks.length; n++)
+          if (!e.marks[n].isInSet(r))
+            return new J(this.pos, e.marks[n]);
+        return new J(this.pos, this.mark);
+      }
+    }
+    return new St(this.pos, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.pos, 1);
+    return e.deletedAfter ? null : new J(e.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.pos != "number")
+      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+    return new J(e.pos, t.markFromJSON(e.mark));
+  }
+};
+p.jsonID("addNodeMark", dt);
+var St = class V extends p {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(t, e) {
+    super(), this.pos = t, this.mark = e;
+  }
+  apply(t) {
+    let e = t.nodeAt(this.pos);
+    if (!e)
+      return d.fail("No node at mark step's position");
+    let r = e.type.create(e.attrs, null, this.mark.removeFromSet(e.marks));
+    return d.fromReplace(t, this.pos, this.pos + 1, new c(g.from(r), 0, e.isLeaf ? 0 : 1));
+  }
+  invert(t) {
+    let e = t.nodeAt(this.pos);
+    return !e || !this.mark.isInSet(e.marks) ? this : new dt(this.pos, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.pos, 1);
+    return e.deletedAfter ? null : new V(e.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.pos != "number")
+      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+    return new V(e.pos, t.markFromJSON(e.mark));
+  }
+};
+p.jsonID("removeNodeMark", St);
+var U = class w extends p {
+  /**
+  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(t, e, r, n = !1) {
+    super(), this.from = t, this.to = e, this.slice = r, this.structure = n;
+  }
+  apply(t) {
+    return this.structure && G(t, this.from, this.to) ? d.fail("Structure replace would overwrite content") : d.fromReplace(t, this.from, this.to, this.slice);
+  }
+  getMap() {
+    return new k([this.from, this.to - this.from, this.slice.size]);
+  }
+  invert(t) {
+    return new w(this.from, this.from + this.slice.size, t.slice(this.from, this.to));
+  }
+  map(t) {
+    let e = t.mapResult(this.to, -1), r = this.from == this.to && w.MAP_BIAS < 0 ? e : t.mapResult(this.from, 1);
+    return r.deletedAcross && e.deletedAcross ? null : new w(r.pos, Math.max(r.pos, e.pos), this.slice, this.structure);
+  }
+  merge(t) {
+    if (!(t instanceof w) || t.structure || this.structure)
+      return null;
+    if (this.from + this.slice.size == t.from && !this.slice.openEnd && !t.slice.openStart) {
+      let e = this.slice.size + t.slice.size == 0 ? c.empty : new c(this.slice.content.append(t.slice.content), this.slice.openStart, t.slice.openEnd);
+      return new w(this.from, this.to + (t.to - t.from), e, this.structure);
+    } else if (t.to == this.from && !this.slice.openStart && !t.slice.openEnd) {
+      let e = this.slice.size + t.slice.size == 0 ? c.empty : new c(t.slice.content.append(this.slice.content), t.slice.openStart, this.slice.openEnd);
+      return new w(t.from, this.to, e, this.structure);
+    } else
+      return null;
+  }
+  toJSON() {
+    let t = { stepType: "replace", from: this.from, to: this.to };
+    return this.slice.size && (t.slice = this.slice.toJSON()), this.structure && (t.structure = !0), t;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number")
+      throw new RangeError("Invalid input for ReplaceStep.fromJSON");
+    return new w(e.from, e.to, c.fromJSON(t, e.slice), !!e.structure);
+  }
+};
+U.MAP_BIAS = 1;
+p.jsonID("replace", U);
+var gt = class q extends p {
+  /**
+  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(t, e, r, n, s, o, a = !1) {
+    super(), this.from = t, this.to = e, this.gapFrom = r, this.gapTo = n, this.slice = s, this.insert = o, this.structure = a;
+  }
+  apply(t) {
+    if (this.structure && (G(t, this.from, this.gapFrom) || G(t, this.gapTo, this.to)))
+      return d.fail("Structure gap-replace would overwrite content");
+    let e = t.slice(this.gapFrom, this.gapTo);
+    if (e.openStart || e.openEnd)
+      return d.fail("Gap is not a flat range");
+    let r = this.slice.insertAt(this.insert, e.content);
+    return r ? d.fromReplace(t, this.from, this.to, r) : d.fail("Content does not fit in gap");
+  }
+  getMap() {
+    return new k([
+      this.from,
+      this.gapFrom - this.from,
+      this.insert,
+      this.gapTo,
+      this.to - this.gapTo,
+      this.slice.size - this.insert
+    ]);
+  }
+  invert(t) {
+    let e = this.gapTo - this.gapFrom;
+    return new q(this.from, this.from + this.slice.size + e, this.from + this.insert, this.from + this.insert + e, t.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+  }
+  map(t) {
+    let e = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1), n = this.from == this.gapFrom ? e.pos : t.map(this.gapFrom, -1), s = this.to == this.gapTo ? r.pos : t.map(this.gapTo, 1);
+    return e.deletedAcross && r.deletedAcross || n < e.pos || s > r.pos ? null : new q(e.pos, r.pos, n, s, this.slice, this.insert, this.structure);
+  }
+  toJSON() {
+    let t = {
+      stepType: "replaceAround",
+      from: this.from,
+      to: this.to,
+      gapFrom: this.gapFrom,
+      gapTo: this.gapTo,
+      insert: this.insert
+    };
+    return this.slice.size && (t.slice = this.slice.toJSON()), this.structure && (t.structure = !0), t;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number" || typeof e.gapFrom != "number" || typeof e.gapTo != "number" || typeof e.insert != "number")
+      throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
+    return new q(e.from, e.to, e.gapFrom, e.gapTo, c.fromJSON(t, e.slice), e.insert, !!e.structure);
+  }
+};
+p.jsonID("replaceAround", gt);
+function G(i, t, e) {
+  let r = i.resolve(t), n = e - t, s = r.depth;
+  for (; n > 0 && s > 0 && r.indexAfter(s) == r.node(s).childCount; )
+    s--, n--;
+  if (n > 0) {
+    let o = r.node(s).maybeChild(r.indexAfter(s));
+    for (; n > 0; ) {
+      if (!o || o.isLeaf)
+        return !0;
+      o = o.firstChild, n--;
+    }
+  }
+  return !1;
+}
+var It = class L extends p {
+  /**
+  Construct an attribute step.
+  */
+  constructor(t, e, r) {
+    super(), this.pos = t, this.attr = e, this.value = r;
+  }
+  apply(t) {
+    let e = t.nodeAt(this.pos);
+    if (!e)
+      return d.fail("No node at attribute step's position");
+    let r = /* @__PURE__ */ Object.create(null);
+    for (let s in e.attrs)
+      r[s] = e.attrs[s];
+    r[this.attr] = this.value;
+    let n = e.type.create(r, null, e.marks);
+    return d.fromReplace(t, this.pos, this.pos + 1, new c(g.from(n), 0, e.isLeaf ? 0 : 1));
+  }
+  getMap() {
+    return k.empty;
+  }
+  invert(t) {
+    return new L(this.pos, this.attr, t.nodeAt(this.pos).attrs[this.attr]);
+  }
+  map(t) {
+    let e = t.mapResult(this.pos, 1);
+    return e.deletedAfter ? null : new L(e.pos, this.attr, this.value);
+  }
+  toJSON() {
+    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
+  }
+  static fromJSON(t, e) {
+    if (typeof e.pos != "number" || typeof e.attr != "string")
+      throw new RangeError("Invalid input for AttrStep.fromJSON");
+    return new L(e.pos, e.attr, e.value);
+  }
+};
+p.jsonID("attr", It);
+var zt = class K extends p {
+  /**
+  Construct an attribute step.
+  */
+  constructor(t, e) {
+    super(), this.attr = t, this.value = e;
+  }
+  apply(t) {
+    let e = /* @__PURE__ */ Object.create(null);
+    for (let n in t.attrs)
+      e[n] = t.attrs[n];
+    e[this.attr] = this.value;
+    let r = t.type.create(e, t.content, t.marks);
+    return d.ok(r);
+  }
+  getMap() {
+    return k.empty;
+  }
+  invert(t) {
+    return new K(this.attr, t.attrs[this.attr]);
+  }
+  map(t) {
+    return this;
+  }
+  toJSON() {
+    return { stepType: "docAttr", attr: this.attr, value: this.value };
+  }
+  static fromJSON(t, e) {
+    if (typeof e.attr != "string")
+      throw new RangeError("Invalid input for DocAttrStep.fromJSON");
+    return new K(e.attr, e.value);
+  }
+};
+p.jsonID("docAttr", zt);
+var C = class extends Error {
+};
+C = function i(t) {
+  let e = Error.call(this, t);
+  return e.__proto__ = i.prototype, e;
+};
+C.prototype = Object.create(Error.prototype);
+C.prototype.constructor = C;
+C.prototype.name = "TransformError";
+var $ = /* @__PURE__ */ Object.create(null), f = class {
+  /**
+  Initialize a selection with the head and anchor and ranges. If no
+  ranges are given, constructs a single range across `$anchor` and
+  `$head`.
+  */
+  constructor(i, t, e) {
+    this.$anchor = i, this.$head = t, this.ranges = e || [new Tt(i.min(t), i.max(t))];
+  }
+  /**
+  The selection's anchor, as an unresolved position.
+  */
+  get anchor() {
+    return this.$anchor.pos;
+  }
+  /**
+  The selection's head.
+  */
+  get head() {
+    return this.$head.pos;
+  }
+  /**
+  The lower bound of the selection's main range.
+  */
+  get from() {
+    return this.$from.pos;
+  }
+  /**
+  The upper bound of the selection's main range.
+  */
+  get to() {
+    return this.$to.pos;
+  }
+  /**
+  The resolved lower  bound of the selection's main range.
+  */
+  get $from() {
+    return this.ranges[0].$from;
+  }
+  /**
+  The resolved upper bound of the selection's main range.
+  */
+  get $to() {
+    return this.ranges[0].$to;
+  }
+  /**
+  Indicates whether the selection contains any content.
+  */
+  get empty() {
+    let i = this.ranges;
+    for (let t = 0; t < i.length; t++)
+      if (i[t].$from.pos != i[t].$to.pos)
+        return !1;
+    return !0;
+  }
+  /**
+  Get the content of this selection as a slice.
+  */
+  content() {
+    return this.$from.doc.slice(this.from, this.to, !0);
+  }
+  /**
+  Replace the selection with a slice or, if no slice is given,
+  delete the selection. Will append to the given transaction.
+  */
+  replace(i, t = c.empty) {
+    let e = t.content.lastChild, r = null;
+    for (let o = 0; o < t.openEnd; o++)
+      r = e, e = e.lastChild;
+    let n = i.steps.length, s = this.ranges;
+    for (let o = 0; o < s.length; o++) {
+      let { $from: a, $to: l } = s[o], h = i.mapping.slice(n);
+      i.replaceRange(h.map(a.pos), h.map(l.pos), o ? c.empty : t), o == 0 && rt(i, n, (e ? e.isInline : r && r.isTextblock) ? -1 : 1);
+    }
+  }
+  /**
+  Replace the selection with the given node, appending the changes
+  to the given transaction.
+  */
+  replaceWith(i, t) {
+    let e = i.steps.length, r = this.ranges;
+    for (let n = 0; n < r.length; n++) {
+      let { $from: s, $to: o } = r[n], a = i.mapping.slice(e), l = a.map(s.pos), h = a.map(o.pos);
+      n ? i.deleteRange(l, h) : (i.replaceRangeWith(l, h, t), rt(i, e, t.isInline ? -1 : 1));
+    }
+  }
+  /**
+  Find a valid cursor or leaf node selection starting at the given
+  position and searching back if `dir` is negative, and forward if
+  positive. When `textOnly` is true, only consider cursor
+  selections. Will return null when no valid selection position is
+  found.
+  */
+  static findFrom(i, t, e = !1) {
+    let r = i.parent.inlineContent ? new R(i) : N(i.node(0), i.parent, i.pos, i.index(), t, e);
+    if (r)
+      return r;
+    for (let n = i.depth - 1; n >= 0; n--) {
+      let s = t < 0 ? N(i.node(0), i.node(n), i.before(n + 1), i.index(n), t, e) : N(i.node(0), i.node(n), i.after(n + 1), i.index(n) + 1, t, e);
+      if (s)
+        return s;
+    }
+    return null;
+  }
+  /**
+  Find a valid cursor or leaf node selection near the given
+  position. Searches forward first by default, but if `bias` is
+  negative, it will search backwards first.
+  */
+  static near(i, t = 1) {
+    return this.findFrom(i, t) || this.findFrom(i, -t) || new b(i.node(0));
+  }
+  /**
+  Find the cursor or leaf node selection closest to the start of
+  the given document. Will return an
+  [`AllSelection`](https://prosemirror.net/docs/ref/#state.AllSelection) if no valid position
+  exists.
+  */
+  static atStart(i) {
+    return N(i, i, 0, 0, 1) || new b(i);
+  }
+  /**
+  Find the cursor or leaf node selection closest to the end of the
+  given document.
+  */
+  static atEnd(i) {
+    return N(i, i, i.content.size, i.childCount, -1) || new b(i);
+  }
+  /**
+  Deserialize the JSON representation of a selection. Must be
+  implemented for custom classes (as a static class method).
+  */
+  static fromJSON(i, t) {
+    if (!t || !t.type)
+      throw new RangeError("Invalid input for Selection.fromJSON");
+    let e = $[t.type];
+    if (!e)
+      throw new RangeError(`No selection type ${t.type} defined`);
+    return e.fromJSON(i, t);
+  }
+  /**
+  To be able to deserialize selections from JSON, custom selection
+  classes must register themselves with an ID string, so that they
+  can be disambiguated. Try to pick something that's unlikely to
+  clash with classes from other modules.
+  */
+  static jsonID(i, t) {
+    if (i in $)
+      throw new RangeError("Duplicate use of selection JSON ID " + i);
+    return $[i] = t, t.prototype.jsonID = i, t;
+  }
+  /**
+  Get a [bookmark](https://prosemirror.net/docs/ref/#state.SelectionBookmark) for this selection,
+  which is a value that can be mapped without having access to a
+  current document, and later resolved to a real selection for a
+  given document again. (This is used mostly by the history to
+  track and restore old selections.) The default implementation of
+  this method just converts the selection to a text selection and
+  returns the bookmark for that.
+  */
+  getBookmark() {
+    return R.between(this.$anchor, this.$head).getBookmark();
+  }
+};
+f.prototype.visible = !0;
+var Tt = class {
+  /**
+  Create a range.
+  */
+  constructor(i, t) {
+    this.$from = i, this.$to = t;
+  }
+}, tt = !1;
+function et(i) {
+  !tt && !i.parent.inlineContent && (tt = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + i.parent.type.name + ")"));
+}
+var R = class A extends f {
+  /**
+  Construct a text selection between the given points.
+  */
+  constructor(t, e = t) {
+    et(t), et(e), super(t, e);
+  }
+  /**
+  Returns a resolved position if this is a cursor selection (an
+  empty text selection), and null otherwise.
+  */
+  get $cursor() {
+    return this.$anchor.pos == this.$head.pos ? this.$head : null;
+  }
+  map(t, e) {
+    let r = t.resolve(e.map(this.head));
+    if (!r.parent.inlineContent)
+      return f.near(r);
+    let n = t.resolve(e.map(this.anchor));
+    return new A(n.parent.inlineContent ? n : r, r);
+  }
+  replace(t, e = c.empty) {
+    if (super.replace(t, e), e == c.empty) {
+      let r = this.$from.marksAcross(this.$to);
+      r && t.ensureMarks(r);
+    }
+  }
+  eq(t) {
+    return t instanceof A && t.anchor == this.anchor && t.head == this.head;
+  }
+  getBookmark() {
+    return new wt(this.anchor, this.head);
+  }
+  toJSON() {
+    return { type: "text", anchor: this.anchor, head: this.head };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.anchor != "number" || typeof e.head != "number")
+      throw new RangeError("Invalid input for TextSelection.fromJSON");
+    return new A(t.resolve(e.anchor), t.resolve(e.head));
+  }
+  /**
+  Create a text selection from non-resolved positions.
+  */
+  static create(t, e, r = e) {
+    let n = t.resolve(e);
+    return new this(n, r == e ? n : t.resolve(r));
+  }
+  /**
+  Return a text selection that spans the given positions or, if
+  they aren't text positions, find a text selection near them.
+  `bias` determines whether the method searches forward (default)
+  or backwards (negative number) first. Will fall back to calling
+  [`Selection.near`](https://prosemirror.net/docs/ref/#state.Selection^near) when the document
+  doesn't contain a valid text position.
+  */
+  static between(t, e, r) {
+    let n = t.pos - e.pos;
+    if ((!r || n) && (r = n >= 0 ? 1 : -1), !e.parent.inlineContent) {
+      let s = f.findFrom(e, r, !0) || f.findFrom(e, -r, !0);
+      if (s)
+        e = s.$head;
+      else
+        return f.near(e, r);
+    }
+    return t.parent.inlineContent || (n == 0 ? t = e : (t = (f.findFrom(t, -r, !0) || f.findFrom(t, r, !0)).$anchor, t.pos < e.pos != n < 0 && (t = e))), new A(t, e);
+  }
+};
+f.jsonID("text", R);
+var wt = class kt {
+  constructor(t, e) {
+    this.anchor = t, this.head = e;
+  }
+  map(t) {
+    return new kt(t.map(this.anchor), t.map(this.head));
+  }
+  resolve(t) {
+    return R.between(t.resolve(this.anchor), t.resolve(this.head));
+  }
+}, E = class M extends f {
+  /**
+  Create a node selection. Does not verify the validity of its
+  argument.
+  */
+  constructor(t) {
+    let e = t.nodeAfter, r = t.node(0).resolve(t.pos + e.nodeSize);
+    super(t, r), this.node = e;
+  }
+  map(t, e) {
+    let { deleted: r, pos: n } = e.mapResult(this.anchor), s = t.resolve(n);
+    return r ? f.near(s) : new M(s);
+  }
+  content() {
+    return new c(g.from(this.node), 0, 0);
+  }
+  eq(t) {
+    return t instanceof M && t.anchor == this.anchor;
+  }
+  toJSON() {
+    return { type: "node", anchor: this.anchor };
+  }
+  getBookmark() {
+    return new Jt(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON");
+    return new M(t.resolve(e.anchor));
+  }
+  /**
+  Create a node selection from non-resolved positions.
+  */
+  static create(t, e) {
+    return new M(t.resolve(e));
+  }
+  /**
+  Determines whether the given node may be selected as a node
+  selection.
+  */
+  static isSelectable(t) {
+    return !t.isText && t.type.spec.selectable !== !1;
+  }
+};
+E.prototype.visible = !1;
+f.jsonID("node", E);
+var Jt = class vt {
+  constructor(t) {
+    this.anchor = t;
+  }
+  map(t) {
+    let { deleted: e, pos: r } = t.mapResult(this.anchor);
+    return e ? new wt(r, r) : new vt(r);
+  }
+  resolve(t) {
+    let e = t.resolve(this.anchor), r = e.nodeAfter;
+    return r && E.isSelectable(r) ? new E(e) : f.near(e);
+  }
+}, b = class P extends f {
+  /**
+  Create an all-selection over the given document.
+  */
+  constructor(t) {
+    super(t.resolve(0), t.resolve(t.content.size));
+  }
+  replace(t, e = c.empty) {
+    if (e == c.empty) {
+      t.delete(0, t.doc.content.size);
+      let r = f.atStart(t.doc);
+      r.eq(t.selection) || t.setSelection(r);
+    } else
+      super.replace(t, e);
+  }
+  toJSON() {
+    return { type: "all" };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t) {
+    return new P(t);
+  }
+  map(t) {
+    return new P(t);
+  }
+  eq(t) {
+    return t instanceof P;
+  }
+  getBookmark() {
+    return At;
+  }
+};
+f.jsonID("all", b);
+var At = {
+  map() {
+    return this;
+  },
+  resolve(i) {
+    return new b(i);
+  }
+};
+function N(i, t, e, r, n, s = !1) {
+  if (t.inlineContent)
+    return R.create(i, e);
+  for (let o = r - (n > 0 ? 0 : 1); n > 0 ? o < t.childCount : o >= 0; o += n) {
+    let a = t.child(o);
+    if (a.isAtom) {
+      if (!s && E.isSelectable(a))
+        return E.create(i, e - (n < 0 ? a.nodeSize : 0));
+    } else {
+      let l = N(i, a, e + n, n < 0 ? a.childCount : 0, n, s);
+      if (l)
+        return l;
+    }
+    e += a.nodeSize * n;
+  }
+  return null;
+}
+function rt(i, t, e) {
+  let r = i.steps.length - 1;
+  if (r < t)
+    return;
+  let n = i.steps[r];
+  if (!(n instanceof U || n instanceof gt))
+    return;
+  let s = i.mapping.maps[r], o;
+  s.forEach((a, l, h, u) => {
+    o == null && (o = u);
+  }), i.setSelection(f.near(i.doc.resolve(o), e));
+}
+function nt(i, t) {
+  return !t || !i ? i : i.bind(t);
+}
+var B = class {
+  constructor(i, t, e) {
+    this.name = i, this.init = nt(t.init, e), this.apply = nt(t.apply, e);
+  }
+};
+new B("doc", {
+  init(i) {
+    return i.doc || i.schema.topNodeType.createAndFill();
+  },
+  apply(i) {
+    return i.doc;
+  }
+}), new B("selection", {
+  init(i, t) {
+    return i.selection || f.atStart(t.doc);
+  },
+  apply(i) {
+    return i.selection;
+  }
+}), new B("storedMarks", {
+  init(i) {
+    return i.storedMarks || null;
+  },
+  apply(i, t, e, r) {
+    return r.selection.$cursor ? i.storedMarks : null;
+  }
+}), new B("scrollToSelection", {
+  init() {
+    return 0;
+  },
+  apply(i, t) {
+    return i.scrolledIntoView ? t + 1 : t;
+  }
+});
+var Mt = (i, t) => {
+  var e;
+  const { state: r, view: n } = i, { selection: s } = r;
+  if (!s.empty) return !1;
+  const { $from: o } = s;
+  if (o.parentOffset !== 0) return !1;
+  const a = o.depth - 1, l = o.node(a), h = o.index(a);
+  if (h === 0) return !1;
+  if (l.type === t)
+    return i.commands.lift(t.name);
+  const u = l.child(h - 1);
+  if (u.type !== t || !((e = u.lastChild) != null && e.isTextblock))
+    return !1;
+  const S = o.before(), O = S - 1 - 1, { tr: v } = r;
+  return v.delete(S, o.after()).insert(O, o.parent.content), v.setSelection(R.create(v.doc, O)), n.dispatch(v.scrollIntoView()), !0;
+}, bt = /^\s*>\s$/, Bt = yt.create({
   name: "blockquote",
   addOptions() {
     return {
@@ -13,50 +1449,51 @@ var m = /^\s*>\s$/, q = c.create({
   parseHTML() {
     return [{ tag: "blockquote" }];
   },
-  renderHTML({ HTMLAttributes: t }) {
-    return /* @__PURE__ */ s("blockquote", { ...k(this.options.HTMLAttributes, t), children: /* @__PURE__ */ s("slot", {}) });
+  renderHTML({ HTMLAttributes: i }) {
+    return /* @__PURE__ */ Z("blockquote", { ...Nt(this.options.HTMLAttributes, i), children: /* @__PURE__ */ Z("slot", {}) });
   },
-  parseMarkdown: (t, e) => {
-    var r;
-    const n = (r = e.parseBlockChildren) != null ? r : e.parseChildren;
-    return e.createNode("blockquote", void 0, n(t.tokens || []));
+  parseMarkdown: (i, t) => {
+    var e;
+    const r = (e = t.parseBlockChildren) != null ? e : t.parseChildren;
+    return t.createNode("blockquote", void 0, r(i.tokens || []));
   },
-  renderMarkdown: (t, e) => {
-    if (!t.content)
+  renderMarkdown: (i, t) => {
+    if (!i.content)
       return "";
-    const r = ">", n = [];
-    return t.content.forEach((o, a) => {
-      var i, u;
-      const d = ((u = (i = e.renderChild) == null ? void 0 : i.call(e, o, a)) != null ? u : e.renderChildren([o])).split(`
-`).map((l) => l.trim() === "" ? r : `${r} ${l}`);
-      n.push(d.join(`
+    const e = ">", r = [];
+    return i.content.forEach((n, s) => {
+      var o, a;
+      const u = ((a = (o = t.renderChild) == null ? void 0 : o.call(t, n, s)) != null ? a : t.renderChildren([n])).split(`
+`).map((S) => S.trim() === "" ? e : `${e} ${S}`);
+      r.push(u.join(`
 `));
-    }), n.join(`
-${r}
+    }), r.join(`
+${e}
 `);
   },
   addCommands() {
     return {
-      setBlockquote: () => ({ commands: t }) => t.wrapIn(this.name),
-      toggleBlockquote: () => ({ commands: t }) => t.toggleWrap(this.name),
-      unsetBlockquote: () => ({ commands: t }) => t.lift(this.name)
+      setBlockquote: () => ({ commands: i }) => i.wrapIn(this.name),
+      toggleBlockquote: () => ({ commands: i }) => i.toggleWrap(this.name),
+      unsetBlockquote: () => ({ commands: i }) => i.lift(this.name)
     };
   },
   addKeyboardShortcuts() {
     return {
-      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote(),
+      Backspace: () => Mt(this.editor, this.type)
     };
   },
   addInputRules() {
     return [
-      p({
-        find: m,
+      xt({
+        find: bt,
         type: this.type
       })
     ];
   }
 });
 export {
-  q as Blockquote,
-  m as inputRegex
+  Bt as Blockquote,
+  bt as inputRegex
 };