reactjs-tiptap-editor 1.0.25 → 1.0.28

package/lib/Blockquote.js

@@ -1,10 +1,1453 @@
-import { N as k, w as h, m as g } from "./index-BblvcbTH.js";
-import { h as p } from "./jsx-runtime-CT7Pcg-t.js";
-import { jsx as m, Fragment as b } from "react/jsx-runtime";
-import { u as f, d as q, A as v } from "./index-X6WZUM9O.js";
+import { N as Rt, w as At, m as Ot } from "./index-n4kM0Ll-.js";
+import { h as Z } from "./jsx-runtime-DE8oVoME.js";
+import { jsx as j, Fragment as Et } from "react/jsx-runtime";
+import { u as Tt, d as It, A as zt } from "./index-DRcwHivm.js";
 import "react";
 import "./theme.js";
-var B = /^\s*>\s$/, A = k.create({
+function st(n, t, e) {
+  for (let r = 0; ; r++) {
+    if (r == n.childCount || r == t.childCount)
+      return n.childCount == t.childCount ? null : e;
+    let i = n.child(r), s = t.child(r);
+    if (i == s) {
+      e += i.nodeSize;
+      continue;
+    }
+    if (!i.sameMarkup(s))
+      return e;
+    if (i.isText && i.text != s.text) {
+      let o = i.text, a = s.text, l = 0;
+      for (; o[l] == a[l]; l++)
+        e++;
+      return l && l < o.length && l < a.length && lt(o.charCodeAt(l - 1)) && at(o.charCodeAt(l)) && e--, e;
+    }
+    if (i.content.size || s.content.size) {
+      let o = st(i.content, s.content, e + 1);
+      if (o != null)
+        return o;
+    }
+    e += i.nodeSize;
+  }
+}
+function ot(n, t, e, r) {
+  for (let i = n.childCount, s = t.childCount; ; ) {
+    if (i == 0 || s == 0)
+      return i == s ? null : { a: e, b: r };
+    let o = n.child(--i), 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 u = o.text, h = a.text, f = u.length, k = h.length;
+      for (; f > 0 && k > 0 && u[f - 1] == h[k - 1]; )
+        f--, k--, e--, r--;
+      return f && k && f < u.length && lt(u.charCodeAt(f - 1)) && at(u.charCodeAt(f)) && (e++, r++), { a: e, b: r };
+    }
+    if (o.content.size || a.content.size) {
+      let u = ot(o.content, a.content, e - 1, r - 1);
+      if (u)
+        return u;
+    }
+    e -= l, r -= l;
+  }
+}
+function at(n) {
+  return n >= 56320 && n < 57344;
+}
+function lt(n) {
+  return n >= 55296 && n < 56320;
+}
+var g = class d {
+  /**
+  @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, i = 0, s) {
+    for (let o = 0, a = 0; a < e; o++) {
+      let l = this.content[o], u = a + l.nodeSize;
+      if (u > t && r(l, i + a, s || null, o) !== !1 && l.content.size) {
+        let h = a + 1;
+        l.nodesBetween(Math.max(0, t - h), Math.min(l.content.size, e - h), r, i + h);
+      }
+      a = u;
+    }
+  }
+  /**
+  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, i) {
+    let s = "", o = !0;
+    return this.nodesBetween(t, e, (a, l) => {
+      let u = a.isText ? a.text.slice(Math.max(t, l) - l, e - l) : a.isLeaf ? i ? typeof i == "function" ? i(a) : i : a.type.spec.leafText ? a.type.spec.leafText(a) : "" : "";
+      a.isBlock && (a.isLeaf && u || a.isTextblock) && r && (o ? o = !1 : s += r), s += u;
+    }, 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, i = this.content.slice(), s = 0;
+    for (e.isText && e.sameMarkup(r) && (i[i.length - 1] = e.withText(e.text + r.text), s = 1); s < t.content.length; s++)
+      i.push(t.content[s]);
+    return new d(i, 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 = [], i = 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), i += a.nodeSize), o = l;
+      }
+    return new d(r, i);
+  }
+  /**
+  @internal
+  */
+  cutByIndex(t, e) {
+    return t == e ? d.empty : t == 0 && e == this.content.length ? this : new d(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 i = this.content.slice(), s = this.size + e.nodeSize - r.nodeSize;
+    return i[t] = e, new d(i, s);
+  }
+  /**
+  Create a new fragment by prepending the given node to this
+  fragment.
+  */
+  addToStart(t) {
+    return new d([t].concat(this.content), this.size + t.nodeSize);
+  }
+  /**
+  Create a new fragment by appending the given node to this
+  fragment.
+  */
+  addToEnd(t) {
+    return new d(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 i = this.content[e];
+      t(i, r, e), r += i.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 st(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 ot(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 i = this.child(e), s = r + i.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 d.empty;
+    if (!Array.isArray(e))
+      throw new RangeError("Invalid input for Fragment.fromJSON");
+    return d.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 d.empty;
+    let e, r = 0;
+    for (let i = 0; i < t.length; i++) {
+      let s = t[i];
+      r += s.nodeSize, i && s.isText && t[i - 1].sameMarkup(s) ? (e || (e = t.slice(0, i)), e[e.length - 1] = s.withText(e[e.length - 1].text + s.text)) : e && e.push(s);
+    }
+    return new d(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 d.empty;
+    if (t instanceof d)
+      return t;
+    if (Array.isArray(t))
+      return this.fromArray(t);
+    if (t.attrs)
+      return new d([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 $ = { index: 0, offset: 0 };
+function F(n, t) {
+  return $.index = n, $.offset = t, $;
+}
+var Jt = class extends Error {
+}, c = class x {
+  /**
+  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 = ht(this.content, t + this.openStart, e, this.openStart + 1, this.openEnd + 1);
+    return r && new x(r, this.openStart, this.openEnd);
+  }
+  /**
+  @internal
+  */
+  removeBetween(t, e) {
+    return new x(ut(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 x.empty;
+    let r = e.openStart || 0, i = e.openEnd || 0;
+    if (typeof r != "number" || typeof i != "number")
+      throw new RangeError("Invalid input for Slice.fromJSON");
+    return new x(g.fromJSON(t, e.content), r, i);
+  }
+  /**
+  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, i = 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)
+      i++;
+    return new x(t, r, i);
+  }
+};
+c.empty = new c(g.empty, 0, 0);
+function ut(n, t, e) {
+  let { index: r, offset: i } = n.findIndex(t), s = n.maybeChild(r), { index: o, offset: a } = n.findIndex(e);
+  if (i == t || s.isText) {
+    if (a != e && !n.child(o).isText)
+      throw new RangeError("Removing non-flat range");
+    return n.cut(0, t).append(n.cut(e));
+  }
+  if (r != o)
+    throw new RangeError("Removing non-flat range");
+  return n.replaceChild(r, s.copy(ut(s.content, t - i - 1, e - i - 1)));
+}
+function ht(n, t, e, r, i, s) {
+  let { index: o, offset: a } = n.findIndex(t), l = n.maybeChild(o);
+  if (a == t || l.isText)
+    return s && r <= 0 && i <= 0 && !s.canReplace(o, o, e) ? null : n.cut(0, t).append(e).append(n.cut(t));
+  let u = ht(l.content, t - a - 1, e, o == 0 ? r - 1 : 0, o == n.childCount - 1 ? i - 1 : 0, l);
+  return u && n.replaceChild(o, l.copy(u));
+}
+var ct = 65535, ft = Math.pow(2, 16);
+function Mt(n, t) {
+  return n + t * ft;
+}
+function _(n) {
+  return n & ct;
+}
+function bt(n) {
+  return (n - (n & ct)) / ft;
+}
+var pt = 1, mt = 2, q = 4, dt = 8, tt = class {
+  /**
+  @internal
+  */
+  constructor(n, t, e) {
+    this.pos = n, 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 & dt) > 0;
+  }
+  /**
+  Tells you whether the token before the mapped position was deleted.
+  */
+  get deletedBefore() {
+    return (this.delInfo & (pt | q)) > 0;
+  }
+  /**
+  True when the token after the mapped position was deleted.
+  */
+  get deletedAfter() {
+    return (this.delInfo & (mt | q)) > 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 & q) > 0;
+  }
+}, v = class N {
+  /**
+  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 && N.empty)
+      return N.empty;
+  }
+  /**
+  @internal
+  */
+  recover(t) {
+    let e = 0, r = _(t);
+    if (!this.inverted)
+      for (let i = 0; i < r; i++)
+        e += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
+    return this.ranges[r * 3] + e + bt(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 i = 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 ? i : 0);
+      if (l > t)
+        break;
+      let u = this.ranges[a + s], h = this.ranges[a + o], f = l + u;
+      if (t <= f) {
+        let k = u ? t == l ? -1 : t == f ? 1 : e : e, E = l + i + (k < 0 ? 0 : h);
+        if (r)
+          return E;
+        let y = t == (e < 0 ? l : f) ? null : Mt(a / 3, t - l), Y = t == l ? mt : t == f ? pt : q;
+        return (e < 0 ? t != l : t != f) && (Y |= dt), new tt(E, Y, y);
+      }
+      i += h - u;
+    }
+    return r ? t + i : new tt(t + i, 0, null);
+  }
+  /**
+  @internal
+  */
+  touches(t, e) {
+    let r = 0, i = _(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 u = this.ranges[a + s], h = l + u;
+      if (t <= h && a == i * 3)
+        return !0;
+      r += this.ranges[a + o] - u;
+    }
+    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 i = 0, s = 0; i < this.ranges.length; i += 3) {
+      let o = this.ranges[i], a = o - (this.inverted ? s : 0), l = o + (this.inverted ? 0 : s), u = this.ranges[i + e], h = this.ranges[i + r];
+      t(a, a + u, l, l + h), s += h - u;
+    }
+  }
+  /**
+  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 N(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 ? N.empty : new N(t < 0 ? [0, -t, 0] : [0, 0, t]);
+  }
+};
+v.empty = new v([]);
+var K = /* @__PURE__ */ Object.create(null), m = 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 v.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(n) {
+    return null;
+  }
+  /**
+  Deserialize a step from its JSON representation. Will call
+  through to the step class' own implementation of this method.
+  */
+  static fromJSON(n, t) {
+    if (!t || !t.stepType)
+      throw new RangeError("Invalid input for Step.fromJSON");
+    let e = K[t.stepType];
+    if (!e)
+      throw new RangeError(`No step type ${t.stepType} defined`);
+    return e.fromJSON(n, 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(n, t) {
+    if (n in K)
+      throw new RangeError("Duplicate use of step JSON ID " + n);
+    return K[n] = t, t.prototype.jsonID = n, t;
+  }
+}, S = class T {
+  /**
+  @internal
+  */
+  constructor(t, e) {
+    this.doc = t, this.failed = e;
+  }
+  /**
+  Create a successful step result.
+  */
+  static ok(t) {
+    return new T(t, null);
+  }
+  /**
+  Create a failed step result.
+  */
+  static fail(t) {
+    return new T(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, i) {
+    try {
+      return T.ok(t.replace(e, r, i));
+    } catch (s) {
+      if (s instanceof Jt)
+        return T.fail(s.message);
+      throw s;
+    }
+  }
+};
+function U(n, t, e) {
+  let r = [];
+  for (let i = 0; i < n.childCount; i++) {
+    let s = n.child(i);
+    s.content.size && (s = s.copy(U(s.content, t, s))), s.isInline && (s = t(s, e, i)), r.push(s);
+  }
+  return g.fromArray(r);
+}
+var St = class I extends m {
+  /**
+  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), i = r.node(r.sharedDepth(this.to)), s = new c(U(e.content, (o, a) => !o.isAtom || !a.type.allowsMarkType(this.mark.type) ? o : o.mark(this.mark.addToSet(o.marks)), i), e.openStart, e.openEnd);
+    return S.fromReplace(t, this.from, this.to, s);
+  }
+  invert() {
+    return new gt(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 I(e.pos, r.pos, this.mark);
+  }
+  merge(t) {
+    return t instanceof I && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new I(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 I(e.from, e.to, t.markFromJSON(e.mark));
+  }
+};
+m.jsonID("addMark", St);
+var gt = class z extends m {
+  /**
+  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(U(e.content, (i) => i.mark(this.mark.removeFromSet(i.marks)), t), e.openStart, e.openEnd);
+    return S.fromReplace(t, this.from, this.to, r);
+  }
+  invert() {
+    return new St(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: "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 z(e.from, e.to, t.markFromJSON(e.mark));
+  }
+};
+m.jsonID("removeMark", gt);
+var wt = class J extends m {
+  /**
+  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 S.fail("No node at mark step's position");
+    let r = e.type.create(e.attrs, null, this.mark.addToSet(e.marks));
+    return S.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 i = 0; i < e.marks.length; i++)
+          if (!e.marks[i].isInSet(r))
+            return new J(this.pos, e.marks[i]);
+        return new J(this.pos, this.mark);
+      }
+    }
+    return new kt(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));
+  }
+};
+m.jsonID("addNodeMark", wt);
+var kt = class V extends m {
+  /**
+  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 S.fail("No node at mark step's position");
+    let r = e.type.create(e.attrs, null, this.mark.removeFromSet(e.marks));
+    return S.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 wt(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));
+  }
+};
+m.jsonID("removeNodeMark", kt);
+var X = class w extends m {
+  /**
+  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, i = !1) {
+    super(), this.from = t, this.to = e, this.slice = r, this.structure = i;
+  }
+  apply(t) {
+    return this.structure && G(t, this.from, this.to) ? S.fail("Structure replace would overwrite content") : S.fromReplace(t, this.from, this.to, this.slice);
+  }
+  getMap() {
+    return new v([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);
+  }
+};
+X.MAP_BIAS = 1;
+m.jsonID("replace", X);
+var vt = class L extends m {
+  /**
+  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, i, s, o, a = !1) {
+    super(), this.from = t, this.to = e, this.gapFrom = r, this.gapTo = i, 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 S.fail("Structure gap-replace would overwrite content");
+    let e = t.slice(this.gapFrom, this.gapTo);
+    if (e.openStart || e.openEnd)
+      return S.fail("Gap is not a flat range");
+    let r = this.slice.insertAt(this.insert, e.content);
+    return r ? S.fromReplace(t, this.from, this.to, r) : S.fail("Content does not fit in gap");
+  }
+  getMap() {
+    return new v([
+      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 L(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), i = 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 || i < e.pos || s > r.pos ? null : new L(e.pos, r.pos, i, 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 L(e.from, e.to, e.gapFrom, e.gapTo, c.fromJSON(t, e.slice), e.insert, !!e.structure);
+  }
+};
+m.jsonID("replaceAround", vt);
+function G(n, t, e) {
+  let r = n.resolve(t), i = e - t, s = r.depth;
+  for (; i > 0 && s > 0 && r.indexAfter(s) == r.node(s).childCount; )
+    s--, i--;
+  if (i > 0) {
+    let o = r.node(s).maybeChild(r.indexAfter(s));
+    for (; i > 0; ) {
+      if (!o || o.isLeaf)
+        return !0;
+      o = o.firstChild, i--;
+    }
+  }
+  return !1;
+}
+var Ct = class P extends m {
+  /**
+  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 S.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 i = e.type.create(r, null, e.marks);
+    return S.fromReplace(t, this.pos, this.pos + 1, new c(g.from(i), 0, e.isLeaf ? 0 : 1));
+  }
+  getMap() {
+    return v.empty;
+  }
+  invert(t) {
+    return new P(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 P(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 P(e.pos, e.attr, e.value);
+  }
+};
+m.jsonID("attr", Ct);
+var Bt = class Q extends m {
+  /**
+  Construct an attribute step.
+  */
+  constructor(t, e) {
+    super(), this.attr = t, this.value = e;
+  }
+  apply(t) {
+    let e = /* @__PURE__ */ Object.create(null);
+    for (let i in t.attrs)
+      e[i] = t.attrs[i];
+    e[this.attr] = this.value;
+    let r = t.type.create(e, t.content, t.marks);
+    return S.ok(r);
+  }
+  getMap() {
+    return v.empty;
+  }
+  invert(t) {
+    return new Q(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 Q(e.attr, e.value);
+  }
+};
+m.jsonID("docAttr", Bt);
+var B = class extends Error {
+};
+B = function n(t) {
+  let e = Error.call(this, t);
+  return e.__proto__ = n.prototype, e;
+};
+B.prototype = Object.create(Error.prototype);
+B.prototype.constructor = B;
+B.prototype.name = "TransformError";
+var W = /* @__PURE__ */ Object.create(null), p = 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(n, t, e) {
+    this.$anchor = n, this.$head = t, this.ranges = e || [new Ft(n.min(t), n.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 n = this.ranges;
+    for (let t = 0; t < n.length; t++)
+      if (n[t].$from.pos != n[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(n, t = c.empty) {
+    let e = t.content.lastChild, r = null;
+    for (let o = 0; o < t.openEnd; o++)
+      r = e, e = e.lastChild;
+    let i = n.steps.length, s = this.ranges;
+    for (let o = 0; o < s.length; o++) {
+      let { $from: a, $to: l } = s[o], u = n.mapping.slice(i);
+      n.replaceRange(u.map(a.pos), u.map(l.pos), o ? c.empty : t), o == 0 && nt(n, i, (e ? e.isInline : r && r.isTextblock) ? -1 : 1);
+    }
+  }
+  /**
+  Replace the selection with the given node, appending the changes
+  to the given transaction.
+  */
+  replaceWith(n, t) {
+    let e = n.steps.length, r = this.ranges;
+    for (let i = 0; i < r.length; i++) {
+      let { $from: s, $to: o } = r[i], a = n.mapping.slice(e), l = a.map(s.pos), u = a.map(o.pos);
+      i ? n.deleteRange(l, u) : (n.replaceRangeWith(l, u, t), nt(n, 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(n, t, e = !1) {
+    let r = n.parent.inlineContent ? new A(n) : R(n.node(0), n.parent, n.pos, n.index(), t, e);
+    if (r)
+      return r;
+    for (let i = n.depth - 1; i >= 0; i--) {
+      let s = t < 0 ? R(n.node(0), n.node(i), n.before(i + 1), n.index(i), t, e) : R(n.node(0), n.node(i), n.after(i + 1), n.index(i) + 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(n, t = 1) {
+    return this.findFrom(n, t) || this.findFrom(n, -t) || new C(n.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(n) {
+    return R(n, n, 0, 0, 1) || new C(n);
+  }
+  /**
+  Find the cursor or leaf node selection closest to the end of the
+  given document.
+  */
+  static atEnd(n) {
+    return R(n, n, n.content.size, n.childCount, -1) || new C(n);
+  }
+  /**
+  Deserialize the JSON representation of a selection. Must be
+  implemented for custom classes (as a static class method).
+  */
+  static fromJSON(n, t) {
+    if (!t || !t.type)
+      throw new RangeError("Invalid input for Selection.fromJSON");
+    let e = W[t.type];
+    if (!e)
+      throw new RangeError(`No selection type ${t.type} defined`);
+    return e.fromJSON(n, 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(n, t) {
+    if (n in W)
+      throw new RangeError("Duplicate use of selection JSON ID " + n);
+    return W[n] = t, t.prototype.jsonID = n, 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 A.between(this.$anchor, this.$head).getBookmark();
+  }
+};
+p.prototype.visible = !0;
+var Ft = class {
+  /**
+  Create a range.
+  */
+  constructor(n, t) {
+    this.$from = n, this.$to = t;
+  }
+}, et = !1;
+function rt(n) {
+  !et && !n.parent.inlineContent && (et = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + n.parent.type.name + ")"));
+}
+var A = class M extends p {
+  /**
+  Construct a text selection between the given points.
+  */
+  constructor(t, e = t) {
+    rt(t), rt(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 p.near(r);
+    let i = t.resolve(e.map(this.anchor));
+    return new M(i.parent.inlineContent ? i : 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 M && t.anchor == this.anchor && t.head == this.head;
+  }
+  getBookmark() {
+    return new yt(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 M(t.resolve(e.anchor), t.resolve(e.head));
+  }
+  /**
+  Create a text selection from non-resolved positions.
+  */
+  static create(t, e, r = e) {
+    let i = t.resolve(e);
+    return new this(i, r == e ? i : 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 i = t.pos - e.pos;
+    if ((!r || i) && (r = i >= 0 ? 1 : -1), !e.parent.inlineContent) {
+      let s = p.findFrom(e, r, !0) || p.findFrom(e, -r, !0);
+      if (s)
+        e = s.$head;
+      else
+        return p.near(e, r);
+    }
+    return t.parent.inlineContent || (i == 0 ? t = e : (t = (p.findFrom(t, -r, !0) || p.findFrom(t, r, !0)).$anchor, t.pos < e.pos != i < 0 && (t = e))), new M(t, e);
+  }
+};
+p.jsonID("text", A);
+var yt = class xt {
+  constructor(t, e) {
+    this.anchor = t, this.head = e;
+  }
+  map(t) {
+    return new xt(t.map(this.anchor), t.map(this.head));
+  }
+  resolve(t) {
+    return A.between(t.resolve(this.anchor), t.resolve(this.head));
+  }
+}, O = class b extends p {
+  /**
+  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: i } = e.mapResult(this.anchor), s = t.resolve(i);
+    return r ? p.near(s) : new b(s);
+  }
+  content() {
+    return new c(g.from(this.node), 0, 0);
+  }
+  eq(t) {
+    return t instanceof b && t.anchor == this.anchor;
+  }
+  toJSON() {
+    return { type: "node", anchor: this.anchor };
+  }
+  getBookmark() {
+    return new Dt(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON");
+    return new b(t.resolve(e.anchor));
+  }
+  /**
+  Create a node selection from non-resolved positions.
+  */
+  static create(t, e) {
+    return new b(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;
+  }
+};
+O.prototype.visible = !1;
+p.jsonID("node", O);
+var Dt = class Nt {
+  constructor(t) {
+    this.anchor = t;
+  }
+  map(t) {
+    let { deleted: e, pos: r } = t.mapResult(this.anchor);
+    return e ? new yt(r, r) : new Nt(r);
+  }
+  resolve(t) {
+    let e = t.resolve(this.anchor), r = e.nodeAfter;
+    return r && O.isSelectable(r) ? new O(e) : p.near(e);
+  }
+}, C = class H extends p {
+  /**
+  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 = p.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 H(t);
+  }
+  map(t) {
+    return new H(t);
+  }
+  eq(t) {
+    return t instanceof H;
+  }
+  getBookmark() {
+    return qt;
+  }
+};
+p.jsonID("all", C);
+var qt = {
+  map() {
+    return this;
+  },
+  resolve(n) {
+    return new C(n);
+  }
+};
+function R(n, t, e, r, i, s = !1) {
+  if (t.inlineContent)
+    return A.create(n, e);
+  for (let o = r - (i > 0 ? 0 : 1); i > 0 ? o < t.childCount : o >= 0; o += i) {
+    let a = t.child(o);
+    if (a.isAtom) {
+      if (!s && O.isSelectable(a))
+        return O.create(n, e - (i < 0 ? a.nodeSize : 0));
+    } else {
+      let l = R(n, a, e + i, i < 0 ? a.childCount : 0, i, s);
+      if (l)
+        return l;
+    }
+    e += a.nodeSize * i;
+  }
+  return null;
+}
+function nt(n, t, e) {
+  let r = n.steps.length - 1;
+  if (r < t)
+    return;
+  let i = n.steps[r];
+  if (!(i instanceof X || i instanceof vt))
+    return;
+  let s = n.mapping.maps[r], o;
+  s.forEach((a, l, u, h) => {
+    o == null && (o = h);
+  }), n.setSelection(p.near(n.doc.resolve(o), e));
+}
+function it(n, t) {
+  return !t || !n ? n : n.bind(t);
+}
+var D = class {
+  constructor(n, t, e) {
+    this.name = n, this.init = it(t.init, e), this.apply = it(t.apply, e);
+  }
+};
+new D("doc", {
+  init(n) {
+    return n.doc || n.schema.topNodeType.createAndFill();
+  },
+  apply(n) {
+    return n.doc;
+  }
+}), new D("selection", {
+  init(n, t) {
+    return n.selection || p.atStart(t.doc);
+  },
+  apply(n) {
+    return n.selection;
+  }
+}), new D("storedMarks", {
+  init(n) {
+    return n.storedMarks || null;
+  },
+  apply(n, t, e, r) {
+    return r.selection.$cursor ? n.storedMarks : null;
+  }
+}), new D("scrollToSelection", {
+  init() {
+    return 0;
+  },
+  apply(n, t) {
+    return n.scrolledIntoView ? t + 1 : t;
+  }
+});
+var Lt = (n, t) => {
+  var e;
+  const { state: r, view: i } = n, { 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), u = o.index(a);
+  if (u === 0) return !1;
+  if (l.type === t)
+    return n.commands.lift(t.name);
+  const h = l.child(u - 1);
+  if (h.type !== t || !((e = h.lastChild) != null && e.isTextblock))
+    return !1;
+  const f = o.before(), E = f - 1 - 1, { tr: y } = r;
+  return y.delete(f, o.after()).insert(E, o.parent.content), y.setSelection(A.create(y.doc, E)), i.dispatch(y.scrollIntoView()), !0;
+}, Pt = /^\s*>\s$/, Ht = Rt.create({
   name: "blockquote",
   addOptions() {
     return {
@@ -17,89 +1460,90 @@ var B = /^\s*>\s$/, A = k.create({
   parseHTML() {
     return [{ tag: "blockquote" }];
   },
-  renderHTML({ HTMLAttributes: t }) {
-    return /* @__PURE__ */ p("blockquote", { ...g(this.options.HTMLAttributes, t), children: /* @__PURE__ */ p("slot", {}) });
+  renderHTML({ HTMLAttributes: n }) {
+    return /* @__PURE__ */ Z("blockquote", { ...Ot(this.options.HTMLAttributes, n), children: /* @__PURE__ */ Z("slot", {}) });
   },
-  parseMarkdown: (t, o) => {
+  parseMarkdown: (n, t) => {
     var e;
-    const n = (e = o.parseBlockChildren) != null ? e : o.parseChildren;
-    return o.createNode("blockquote", void 0, n(t.tokens || []));
+    const r = (e = t.parseBlockChildren) != null ? e : t.parseChildren;
+    return t.createNode("blockquote", void 0, r(n.tokens || []));
   },
-  renderMarkdown: (t, o) => {
-    if (!t.content)
+  renderMarkdown: (n, t) => {
+    if (!n.content)
       return "";
-    const e = ">", n = [];
-    return t.content.forEach((r, i) => {
-      var s, c;
-      const a = ((c = (s = o.renderChild) == null ? void 0 : s.call(o, r, i)) != null ? c : o.renderChildren([r])).split(`
-`).map((d) => d.trim() === "" ? e : `${e} ${d}`);
-      n.push(a.join(`
+    const e = ">", r = [];
+    return n.content.forEach((i, s) => {
+      var o, a;
+      const h = ((a = (o = t.renderChild) == null ? void 0 : o.call(t, i, s)) != null ? a : t.renderChildren([i])).split(`
+`).map((f) => f.trim() === "" ? e : `${e} ${f}`);
+      r.push(h.join(`
 `));
-    }), n.join(`
+    }), 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: n }) => n.wrapIn(this.name),
+      toggleBlockquote: () => ({ commands: n }) => n.toggleWrap(this.name),
+      unsetBlockquote: () => ({ commands: n }) => n.lift(this.name)
     };
   },
   addKeyboardShortcuts() {
     return {
-      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote(),
+      Backspace: () => Lt(this.editor, this.type)
     };
   },
   addInputRules() {
     return [
-      h({
-        find: B,
+      At({
+        find: Pt,
         type: this.type
       })
     ];
   }
 });
-function L() {
-  const t = f(x.name), {
-    icon: o = void 0,
+function Xt() {
+  const n = Tt($t.name), {
+    icon: t = void 0,
     tooltip: e = void 0,
-    shortcutKeys: n = void 0,
-    tooltipOptions: r = {},
-    action: i = void 0,
-    isActive: s = void 0
-  } = (t == null ? void 0 : t.componentProps) ?? {}, { dataState: c, disabled: u, update: l } = q(s), a = () => {
-    u || i && (i(), l());
+    shortcutKeys: r = void 0,
+    tooltipOptions: i = {},
+    action: s = void 0,
+    isActive: o = void 0
+  } = (n == null ? void 0 : n.componentProps) ?? {}, { dataState: a, disabled: l, update: u } = It(o), h = () => {
+    l || s && (s(), u());
   };
-  return t ? /* @__PURE__ */ m(
-    v,
+  return n ? /* @__PURE__ */ j(
+    zt,
     {
-      action: a,
-      dataState: c,
-      disabled: u,
-      icon: o,
-      shortcutKeys: n,
+      action: h,
+      dataState: a,
+      disabled: l,
+      icon: t,
+      shortcutKeys: r,
       tooltip: e,
-      tooltipOptions: r
+      tooltipOptions: i
     }
-  ) : /* @__PURE__ */ m(b, {});
+  ) : /* @__PURE__ */ j(Et, {});
 }
-const x = /* @__PURE__ */ A.extend({
+const $t = /* @__PURE__ */ Ht.extend({
   //@ts-expect-error
   addOptions() {
-    var t;
+    var n;
     return {
-      ...(t = this.parent) == null ? void 0 : t.call(this),
+      ...(n = this.parent) == null ? void 0 : n.call(this),
       HTMLAttributes: {
         class: "blockquote"
       },
-      button: ({ editor: o, t: e, extension: n }) => ({
+      button: ({ editor: t, t: e, extension: r }) => ({
         componentProps: {
-          action: () => o.commands.toggleBlockquote(),
-          isActive: () => o.isActive("blockquote"),
-          disabled: !o.can().toggleBlockquote(),
+          action: () => t.commands.toggleBlockquote(),
+          isActive: () => t.isActive("blockquote"),
+          disabled: !t.can().toggleBlockquote(),
           icon: "TextQuote",
-          shortcutKeys: n.options.shortcutKeys ?? ["shift", "mod", "B"],
+          shortcutKeys: r.options.shortcutKeys ?? ["shift", "mod", "B"],
           tooltip: e("editor.blockquote.tooltip")
         }
       })
@@ -107,6 +1551,6 @@ const x = /* @__PURE__ */ A.extend({
   }
 });
 export {
-  x as Blockquote,
-  L as RichTextBlockquote
+  $t as Blockquote,
+  Xt as RichTextBlockquote
 };