@sovann72-dev/lynqify-ui 1.0.0 → 1.0.1

package/dist/lynqify-ui.js

@@ -0,0 +1,3264 @@
+import Tt from "@tiptap/extension-bold";
+import { default as hi } from "@tiptap/extension-bold";
+import Et from "@tiptap/extension-color";
+import { default as mi } from "@tiptap/extension-color";
+import kt from "@tiptap/extension-document";
+import { default as yi } from "@tiptap/extension-document";
+import _r from "@tiptap/extension-file-handler";
+import { default as Ii } from "@tiptap/extension-file-handler";
+import Rt from "@tiptap/extension-hard-break";
+import { default as xi } from "@tiptap/extension-hard-break";
+import Jr from "@tiptap/extension-heading";
+import { default as bi } from "@tiptap/extension-heading";
+import Fr from "@tiptap/extension-highlight";
+import { default as Ei } from "@tiptap/extension-highlight";
+import Hr from "@tiptap/extension-image";
+import { default as Ri } from "@tiptap/extension-image";
+import Ot from "@tiptap/extension-italic";
+import { default as Ni } from "@tiptap/extension-italic";
+import Br from "@tiptap/extension-link";
+import { default as Ci } from "@tiptap/extension-link";
+import { BulletList as Nt, ListItem as At, OrderedList as Ct, TaskItem as Lt, ListKeymap as $r, TaskList as jr } from "@tiptap/extension-list";
+import { BulletList as Mi, ListItem as Pi, ListKeymap as Di, OrderedList as zi, TaskItem as _i, TaskList as Ji } from "@tiptap/extension-list";
+import qr from "@tiptap/extension-mention";
+import { default as Hi } from "@tiptap/extension-mention";
+import Mt from "@tiptap/extension-paragraph";
+import { default as $i } from "@tiptap/extension-paragraph";
+import { Table as Vr, TableCell as Wr, TableHeader as Ur, TableRow as Yr } from "@tiptap/extension-table";
+import { Table as qi, TableCell as Vi, TableHeader as Wi, TableRow as Ui } from "@tiptap/extension-table";
+import Pt from "@tiptap/extension-text";
+import { default as Ki } from "@tiptap/extension-text";
+import Dt from "@tiptap/extension-text-align";
+import { default as Xi } from "@tiptap/extension-text-align";
+import { TextStyle as zt } from "@tiptap/extension-text-style";
+import { TextStyle as Qi } from "@tiptap/extension-text-style";
+import _t from "@tiptap/extension-underline";
+import { default as ts } from "@tiptap/extension-underline";
+import { UndoRedo as Jt, CharacterCount as Kr, Placeholder as Gr } from "@tiptap/extensions";
+import { CharacterCount as ns, UndoRedo as is, Placeholder as ss } from "@tiptap/extensions";
+import { Extension as Xr } from "@tiptap/react";
+import { Extension as fe, Node as Zr } from "@tiptap/core";
+import * as Le from "react";
+import Ft from "react";
+import Qr from "react-dom";
+const en = Mt.extend({
+  // Keep name as 'paragraph' for schema compatibility
+  addNodeView() {
+    return ({ node: n }) => {
+      const e = n.attrs.indent || 0, t = document.createElement("p");
+      return t.setAttribute("data-indent", String(e)), e > 0 && (t.style.paddingLeft = `${e * 20}px`), { dom: t, contentDOM: t };
+    };
+  },
+  // Placeholder positioning based on indent level
+  addAttributes() {
+    var n;
+    return {
+      ...(n = this.parent) == null ? void 0 : n.call(this),
+      indent: {
+        default: 0,
+        parseHTML: (e) => parseInt(e.getAttribute("data-indent") || "0"),
+        renderHTML: (e) => e.indent ? {
+          "data-indent": e.indent,
+          // CSS custom property for dynamic placeholder offset
+          style: `--indent-level: ${e.indent};`
+        } : {}
+      }
+    };
+  }
+});
+function Ht(n, e, t) {
+  for (let r = 0; ; r++) {
+    if (r == n.childCount || r == e.childCount)
+      return n.childCount == e.childCount ? null : t;
+    let i = n.child(r), s = e.child(r);
+    if (i == s) {
+      t += i.nodeSize;
+      continue;
+    }
+    if (!i.sameMarkup(s))
+      return t;
+    if (i.isText && i.text != s.text) {
+      for (let l = 0; i.text[l] == s.text[l]; l++)
+        t++;
+      return t;
+    }
+    if (i.content.size || s.content.size) {
+      let l = Ht(i.content, s.content, t + 1);
+      if (l != null)
+        return l;
+    }
+    t += i.nodeSize;
+  }
+}
+function Bt(n, e, t, r) {
+  for (let i = n.childCount, s = e.childCount; ; ) {
+    if (i == 0 || s == 0)
+      return i == s ? null : { a: t, b: r };
+    let l = n.child(--i), a = e.child(--s), u = l.nodeSize;
+    if (l == a) {
+      t -= u, r -= u;
+      continue;
+    }
+    if (!l.sameMarkup(a))
+      return { a: t, b: r };
+    if (l.isText && l.text != a.text) {
+      let f = 0, d = Math.min(l.text.length, a.text.length);
+      for (; f < d && l.text[l.text.length - f - 1] == a.text[a.text.length - f - 1]; )
+        f++, t--, r--;
+      return { a: t, b: r };
+    }
+    if (l.content.size || a.content.size) {
+      let f = Bt(l.content, a.content, t - 1, r - 1);
+      if (f)
+        return f;
+    }
+    t -= u, r -= u;
+  }
+}
+class k {
+  /**
+  @internal
+  */
+  constructor(e, t) {
+    if (this.content = e, this.size = t || 0, t == null)
+      for (let r = 0; r < e.length; r++)
+        this.size += e[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(e, t, r, i = 0, s) {
+    for (let l = 0, a = 0; a < t; l++) {
+      let u = this.content[l], f = a + u.nodeSize;
+      if (f > e && r(u, i + a, s || null, l) !== !1 && u.content.size) {
+        let d = a + 1;
+        u.nodesBetween(Math.max(0, e - d), Math.min(u.content.size, t - d), r, i + d);
+      }
+      a = f;
+    }
+  }
+  /**
+  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(e) {
+    this.nodesBetween(0, this.size, e);
+  }
+  /**
+  Extract the text between `from` and `to`. See the same method on
+  [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
+  */
+  textBetween(e, t, r, i) {
+    let s = "", l = !0;
+    return this.nodesBetween(e, t, (a, u) => {
+      let f = a.isText ? a.text.slice(Math.max(e, u) - u, t - u) : a.isLeaf ? i ? typeof i == "function" ? i(a) : i : a.type.spec.leafText ? a.type.spec.leafText(a) : "" : "";
+      a.isBlock && (a.isLeaf && f || a.isTextblock) && r && (l ? l = !1 : s += r), s += f;
+    }, 0), s;
+  }
+  /**
+  Create a new fragment containing the combined content of this
+  fragment and the other.
+  */
+  append(e) {
+    if (!e.size)
+      return this;
+    if (!this.size)
+      return e;
+    let t = this.lastChild, r = e.firstChild, i = this.content.slice(), s = 0;
+    for (t.isText && t.sameMarkup(r) && (i[i.length - 1] = t.withText(t.text + r.text), s = 1); s < e.content.length; s++)
+      i.push(e.content[s]);
+    return new k(i, this.size + e.size);
+  }
+  /**
+  Cut out the sub-fragment between the two given positions.
+  */
+  cut(e, t = this.size) {
+    if (e == 0 && t == this.size)
+      return this;
+    let r = [], i = 0;
+    if (t > e)
+      for (let s = 0, l = 0; l < t; s++) {
+        let a = this.content[s], u = l + a.nodeSize;
+        u > e && ((l < e || u > t) && (a.isText ? a = a.cut(Math.max(0, e - l), Math.min(a.text.length, t - l)) : a = a.cut(Math.max(0, e - l - 1), Math.min(a.content.size, t - l - 1))), r.push(a), i += a.nodeSize), l = u;
+      }
+    return new k(r, i);
+  }
+  /**
+  @internal
+  */
+  cutByIndex(e, t) {
+    return e == t ? k.empty : e == 0 && t == this.content.length ? this : new k(this.content.slice(e, t));
+  }
+  /**
+  Create a new fragment in which the node at the given index is
+  replaced by the given node.
+  */
+  replaceChild(e, t) {
+    let r = this.content[e];
+    if (r == t)
+      return this;
+    let i = this.content.slice(), s = this.size + t.nodeSize - r.nodeSize;
+    return i[e] = t, new k(i, s);
+  }
+  /**
+  Create a new fragment by prepending the given node to this
+  fragment.
+  */
+  addToStart(e) {
+    return new k([e].concat(this.content), this.size + e.nodeSize);
+  }
+  /**
+  Create a new fragment by appending the given node to this
+  fragment.
+  */
+  addToEnd(e) {
+    return new k(this.content.concat(e), this.size + e.nodeSize);
+  }
+  /**
+  Compare this fragment to another one.
+  */
+  eq(e) {
+    if (this.content.length != e.content.length)
+      return !1;
+    for (let t = 0; t < this.content.length; t++)
+      if (!this.content[t].eq(e.content[t]))
+        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(e) {
+    let t = this.content[e];
+    if (!t)
+      throw new RangeError("Index " + e + " out of range for " + this);
+    return t;
+  }
+  /**
+  Get the child node at the given index, if it exists.
+  */
+  maybeChild(e) {
+    return this.content[e] || null;
+  }
+  /**
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
+  */
+  forEach(e) {
+    for (let t = 0, r = 0; t < this.content.length; t++) {
+      let i = this.content[t];
+      e(i, r, t), r += i.nodeSize;
+    }
+  }
+  /**
+  Find the first position at which this fragment and another
+  fragment differ, or `null` if they are the same.
+  */
+  findDiffStart(e, t = 0) {
+    return Ht(this, e, t);
+  }
+  /**
+  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(e, t = this.size, r = e.size) {
+    return Bt(this, e, t, 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(e) {
+    if (e == 0)
+      return ye(0, e);
+    if (e == this.size)
+      return ye(this.content.length, e);
+    if (e > this.size || e < 0)
+      throw new RangeError(`Position ${e} outside of fragment (${this})`);
+    for (let t = 0, r = 0; ; t++) {
+      let i = this.child(t), s = r + i.nodeSize;
+      if (s >= e)
+        return s == e ? ye(t + 1, s) : ye(t, 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((e) => e.toJSON()) : null;
+  }
+  /**
+  Deserialize a fragment from its JSON representation.
+  */
+  static fromJSON(e, t) {
+    if (!t)
+      return k.empty;
+    if (!Array.isArray(t))
+      throw new RangeError("Invalid input for Fragment.fromJSON");
+    return new k(t.map(e.nodeFromJSON));
+  }
+  /**
+  Build a fragment from an array of nodes. Ensures that adjacent
+  text nodes with the same marks are joined together.
+  */
+  static fromArray(e) {
+    if (!e.length)
+      return k.empty;
+    let t, r = 0;
+    for (let i = 0; i < e.length; i++) {
+      let s = e[i];
+      r += s.nodeSize, i && s.isText && e[i - 1].sameMarkup(s) ? (t || (t = e.slice(0, i)), t[t.length - 1] = s.withText(t[t.length - 1].text + s.text)) : t && t.push(s);
+    }
+    return new k(t || e, 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(e) {
+    if (!e)
+      return k.empty;
+    if (e instanceof k)
+      return e;
+    if (Array.isArray(e))
+      return this.fromArray(e);
+    if (e.attrs)
+      return new k([e], e.nodeSize);
+    throw new RangeError("Can not convert " + e + " to a Fragment" + (e.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
+  }
+}
+k.empty = new k([], 0);
+const Me = { index: 0, offset: 0 };
+function ye(n, e) {
+  return Me.index = n, Me.offset = e, Me;
+}
+class tn extends Error {
+}
+class T {
+  /**
+  Create a slice. When specifying a non-zero open depth, you must
+  make sure that there are nodes of at least that depth at the
+  appropriate side of the fragment—i.e. if the fragment is an
+  empty paragraph node, `openStart` and `openEnd` can't be greater
+  than 1.
+  
+  It is not necessary for the content of open nodes to conform to
+  the schema's content constraints, though it should be a valid
+  start/end/middle for such a node, depending on which sides are
+  open.
+  */
+  constructor(e, t, r) {
+    this.content = e, this.openStart = t, 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(e, t) {
+    let r = jt(this.content, e + this.openStart, t);
+    return r && new T(r, this.openStart, this.openEnd);
+  }
+  /**
+  @internal
+  */
+  removeBetween(e, t) {
+    return new T($t(this.content, e + this.openStart, t + this.openStart), this.openStart, this.openEnd);
+  }
+  /**
+  Tests whether this slice is equal to another slice.
+  */
+  eq(e) {
+    return this.content.eq(e.content) && this.openStart == e.openStart && this.openEnd == e.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 e = { content: this.content.toJSON() };
+    return this.openStart > 0 && (e.openStart = this.openStart), this.openEnd > 0 && (e.openEnd = this.openEnd), e;
+  }
+  /**
+  Deserialize a slice from its JSON representation.
+  */
+  static fromJSON(e, t) {
+    if (!t)
+      return T.empty;
+    let r = t.openStart || 0, i = t.openEnd || 0;
+    if (typeof r != "number" || typeof i != "number")
+      throw new RangeError("Invalid input for Slice.fromJSON");
+    return new T(k.fromJSON(e, t.content), r, i);
+  }
+  /**
+  Create a slice from a fragment by taking the maximum possible
+  open value on both side of the fragment.
+  */
+  static maxOpen(e, t = !0) {
+    let r = 0, i = 0;
+    for (let s = e.firstChild; s && !s.isLeaf && (t || !s.type.spec.isolating); s = s.firstChild)
+      r++;
+    for (let s = e.lastChild; s && !s.isLeaf && (t || !s.type.spec.isolating); s = s.lastChild)
+      i++;
+    return new T(e, r, i);
+  }
+}
+T.empty = new T(k.empty, 0, 0);
+function $t(n, e, t) {
+  let { index: r, offset: i } = n.findIndex(e), s = n.maybeChild(r), { index: l, offset: a } = n.findIndex(t);
+  if (i == e || s.isText) {
+    if (a != t && !n.child(l).isText)
+      throw new RangeError("Removing non-flat range");
+    return n.cut(0, e).append(n.cut(t));
+  }
+  if (r != l)
+    throw new RangeError("Removing non-flat range");
+  return n.replaceChild(r, s.copy($t(s.content, e - i - 1, t - i - 1)));
+}
+function jt(n, e, t, r) {
+  let { index: i, offset: s } = n.findIndex(e), l = n.maybeChild(i);
+  if (s == e || l.isText)
+    return r && !r.canReplace(i, i, t) ? null : n.cut(0, e).append(t).append(n.cut(e));
+  let a = jt(l.content, e - s - 1, t, l);
+  return a && n.replaceChild(i, l.copy(a));
+}
+class qt {
+  /**
+  Construct a node range. `$from` and `$to` should point into the
+  same node until at least the given `depth`, since a node range
+  denotes an adjacent set of nodes in a single parent node.
+  */
+  constructor(e, t, r) {
+    this.$from = e, this.$to = t, this.depth = r;
+  }
+  /**
+  The position at the start of the range.
+  */
+  get start() {
+    return this.$from.before(this.depth + 1);
+  }
+  /**
+  The position at the end of the range.
+  */
+  get end() {
+    return this.$to.after(this.depth + 1);
+  }
+  /**
+  The parent node that the range points into.
+  */
+  get parent() {
+    return this.$from.node(this.depth);
+  }
+  /**
+  The start index of the range in the parent node.
+  */
+  get startIndex() {
+    return this.$from.index(this.depth);
+  }
+  /**
+  The end index of the range in the parent node.
+  */
+  get endIndex() {
+    return this.$to.indexAfter(this.depth);
+  }
+}
+const Vt = 65535, Wt = Math.pow(2, 16);
+function rn(n, e) {
+  return n + e * Wt;
+}
+function ht(n) {
+  return n & Vt;
+}
+function nn(n) {
+  return (n - (n & Vt)) / Wt;
+}
+const Ut = 1, Yt = 2, we = 4, Kt = 8;
+class pt {
+  /**
+  @internal
+  */
+  constructor(e, t, r) {
+    this.pos = e, this.delInfo = t, this.recover = r;
+  }
+  /**
+  Tells you whether the position was deleted, that is, whether the
+  step removed the token on the side queried (via the `assoc`)
+  argument from the document.
+  */
+  get deleted() {
+    return (this.delInfo & Kt) > 0;
+  }
+  /**
+  Tells you whether the token before the mapped position was deleted.
+  */
+  get deletedBefore() {
+    return (this.delInfo & (Ut | we)) > 0;
+  }
+  /**
+  True when the token after the mapped position was deleted.
+  */
+  get deletedAfter() {
+    return (this.delInfo & (Yt | we)) > 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 & we) > 0;
+  }
+}
+class F {
+  /**
+  Create a position map. The modifications to the document are
+  represented as an array of numbers, in which each group of three
+  represents a modified chunk as `[start, oldSize, newSize]`.
+  */
+  constructor(e, t = !1) {
+    if (this.ranges = e, this.inverted = t, !e.length && F.empty)
+      return F.empty;
+  }
+  /**
+  @internal
+  */
+  recover(e) {
+    let t = 0, r = ht(e);
+    if (!this.inverted)
+      for (let i = 0; i < r; i++)
+        t += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
+    return this.ranges[r * 3] + t + nn(e);
+  }
+  mapResult(e, t = 1) {
+    return this._map(e, t, !1);
+  }
+  map(e, t = 1) {
+    return this._map(e, t, !0);
+  }
+  /**
+  @internal
+  */
+  _map(e, t, r) {
+    let i = 0, s = this.inverted ? 2 : 1, l = this.inverted ? 1 : 2;
+    for (let a = 0; a < this.ranges.length; a += 3) {
+      let u = this.ranges[a] - (this.inverted ? i : 0);
+      if (u > e)
+        break;
+      let f = this.ranges[a + s], d = this.ranges[a + l], p = u + f;
+      if (e <= p) {
+        let y = f ? e == u ? -1 : e == p ? 1 : t : t, w = u + i + (y < 0 ? 0 : d);
+        if (r)
+          return w;
+        let m = e == (t < 0 ? u : p) ? null : rn(a / 3, e - u), S = e == u ? Yt : e == p ? Ut : we;
+        return (t < 0 ? e != u : e != p) && (S |= Kt), new pt(w, S, m);
+      }
+      i += d - f;
+    }
+    return r ? e + i : new pt(e + i, 0, null);
+  }
+  /**
+  @internal
+  */
+  touches(e, t) {
+    let r = 0, i = ht(t), s = this.inverted ? 2 : 1, l = this.inverted ? 1 : 2;
+    for (let a = 0; a < this.ranges.length; a += 3) {
+      let u = this.ranges[a] - (this.inverted ? r : 0);
+      if (u > e)
+        break;
+      let f = this.ranges[a + s], d = u + f;
+      if (e <= d && a == i * 3)
+        return !0;
+      r += this.ranges[a + l] - f;
+    }
+    return !1;
+  }
+  /**
+  Calls the given function on each of the changed ranges included in
+  this map.
+  */
+  forEach(e) {
+    let t = this.inverted ? 2 : 1, r = this.inverted ? 1 : 2;
+    for (let i = 0, s = 0; i < this.ranges.length; i += 3) {
+      let l = this.ranges[i], a = l - (this.inverted ? s : 0), u = l + (this.inverted ? 0 : s), f = this.ranges[i + t], d = this.ranges[i + r];
+      e(a, a + f, u, u + d), s += d - f;
+    }
+  }
+  /**
+  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 F(this.ranges, !this.inverted);
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
+  }
+  /**
+  Create a map that moves all positions by offset `n` (which may be
+  negative). This can be useful when applying steps meant for a
+  sub-document to a larger document, or vice-versa.
+  */
+  static offset(e) {
+    return e == 0 ? F.empty : new F(e < 0 ? [0, -e, 0] : [0, 0, e]);
+  }
+}
+F.empty = new F([]);
+const Pe = /* @__PURE__ */ Object.create(null);
+class M {
+  /**
+  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 F.empty;
+  }
+  /**
+  Try to merge this step with another one, to be applied directly
+  after it. Returns the merged step when possible, null if the
+  steps can't be merged.
+  */
+  merge(e) {
+    return null;
+  }
+  /**
+  Deserialize a step from its JSON representation. Will call
+  through to the step class' own implementation of this method.
+  */
+  static fromJSON(e, t) {
+    if (!t || !t.stepType)
+      throw new RangeError("Invalid input for Step.fromJSON");
+    let r = Pe[t.stepType];
+    if (!r)
+      throw new RangeError(`No step type ${t.stepType} defined`);
+    return r.fromJSON(e, t);
+  }
+  /**
+  To be able to serialize steps to JSON, each step needs a string
+  ID to attach to its JSON representation. Use this method to
+  register an ID for your step classes. Try to pick something
+  that's unlikely to clash with steps from other modules.
+  */
+  static jsonID(e, t) {
+    if (e in Pe)
+      throw new RangeError("Duplicate use of step JSON ID " + e);
+    return Pe[e] = t, t.prototype.jsonID = e, t;
+  }
+}
+class N {
+  /**
+  @internal
+  */
+  constructor(e, t) {
+    this.doc = e, this.failed = t;
+  }
+  /**
+  Create a successful step result.
+  */
+  static ok(e) {
+    return new N(e, null);
+  }
+  /**
+  Create a failed step result.
+  */
+  static fail(e) {
+    return new N(null, e);
+  }
+  /**
+  Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
+  arguments. Create a successful result if it succeeds, and a
+  failed one if it throws a `ReplaceError`.
+  */
+  static fromReplace(e, t, r, i) {
+    try {
+      return N.ok(e.replace(t, r, i));
+    } catch (s) {
+      if (s instanceof tn)
+        return N.fail(s.message);
+      throw s;
+    }
+  }
+}
+function He(n, e, t) {
+  let r = [];
+  for (let i = 0; i < n.childCount; i++) {
+    let s = n.child(i);
+    s.content.size && (s = s.copy(He(s.content, e, s))), s.isInline && (s = e(s, t, i)), r.push(s);
+  }
+  return k.fromArray(r);
+}
+class U extends M {
+  /**
+  Create a mark step.
+  */
+  constructor(e, t, r) {
+    super(), this.from = e, this.to = t, this.mark = r;
+  }
+  apply(e) {
+    let t = e.slice(this.from, this.to), r = e.resolve(this.from), i = r.node(r.sharedDepth(this.to)), s = new T(He(t.content, (l, a) => !l.isAtom || !a.type.allowsMarkType(this.mark.type) ? l : l.mark(this.mark.addToSet(l.marks)), i), t.openStart, t.openEnd);
+    return N.fromReplace(e, this.from, this.to, s);
+  }
+  invert() {
+    return new Y(this.from, this.to, this.mark);
+  }
+  map(e) {
+    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
+    return t.deleted && r.deleted || t.pos >= r.pos ? null : new U(t.pos, r.pos, this.mark);
+  }
+  merge(e) {
+    return e instanceof U && e.mark.eq(this.mark) && this.from <= e.to && this.to >= e.from ? new U(Math.min(this.from, e.from), Math.max(this.to, e.to), this.mark) : null;
+  }
+  toJSON() {
+    return {
+      stepType: "addMark",
+      mark: this.mark.toJSON(),
+      from: this.from,
+      to: this.to
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.from != "number" || typeof t.to != "number")
+      throw new RangeError("Invalid input for AddMarkStep.fromJSON");
+    return new U(t.from, t.to, e.markFromJSON(t.mark));
+  }
+}
+M.jsonID("addMark", U);
+class Y extends M {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(e, t, r) {
+    super(), this.from = e, this.to = t, this.mark = r;
+  }
+  apply(e) {
+    let t = e.slice(this.from, this.to), r = new T(He(t.content, (i) => i.mark(this.mark.removeFromSet(i.marks)), e), t.openStart, t.openEnd);
+    return N.fromReplace(e, this.from, this.to, r);
+  }
+  invert() {
+    return new U(this.from, this.to, this.mark);
+  }
+  map(e) {
+    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
+    return t.deleted && r.deleted || t.pos >= r.pos ? null : new Y(t.pos, r.pos, this.mark);
+  }
+  merge(e) {
+    return e instanceof Y && e.mark.eq(this.mark) && this.from <= e.to && this.to >= e.from ? new Y(Math.min(this.from, e.from), Math.max(this.to, e.to), this.mark) : null;
+  }
+  toJSON() {
+    return {
+      stepType: "removeMark",
+      mark: this.mark.toJSON(),
+      from: this.from,
+      to: this.to
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.from != "number" || typeof t.to != "number")
+      throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
+    return new Y(t.from, t.to, e.markFromJSON(t.mark));
+  }
+}
+M.jsonID("removeMark", Y);
+class K extends M {
+  /**
+  Create a node mark step.
+  */
+  constructor(e, t) {
+    super(), this.pos = e, this.mark = t;
+  }
+  apply(e) {
+    let t = e.nodeAt(this.pos);
+    if (!t)
+      return N.fail("No node at mark step's position");
+    let r = t.type.create(t.attrs, null, this.mark.addToSet(t.marks));
+    return N.fromReplace(e, this.pos, this.pos + 1, new T(k.from(r), 0, t.isLeaf ? 0 : 1));
+  }
+  invert(e) {
+    let t = e.nodeAt(this.pos);
+    if (t) {
+      let r = this.mark.addToSet(t.marks);
+      if (r.length == t.marks.length) {
+        for (let i = 0; i < t.marks.length; i++)
+          if (!t.marks[i].isInSet(r))
+            return new K(this.pos, t.marks[i]);
+        return new K(this.pos, this.mark);
+      }
+    }
+    return new ue(this.pos, this.mark);
+  }
+  map(e) {
+    let t = e.mapResult(this.pos, 1);
+    return t.deletedAfter ? null : new K(t.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.pos != "number")
+      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+    return new K(t.pos, e.markFromJSON(t.mark));
+  }
+}
+M.jsonID("addNodeMark", K);
+class ue extends M {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(e, t) {
+    super(), this.pos = e, this.mark = t;
+  }
+  apply(e) {
+    let t = e.nodeAt(this.pos);
+    if (!t)
+      return N.fail("No node at mark step's position");
+    let r = t.type.create(t.attrs, null, this.mark.removeFromSet(t.marks));
+    return N.fromReplace(e, this.pos, this.pos + 1, new T(k.from(r), 0, t.isLeaf ? 0 : 1));
+  }
+  invert(e) {
+    let t = e.nodeAt(this.pos);
+    return !t || !this.mark.isInSet(t.marks) ? this : new K(this.pos, this.mark);
+  }
+  map(e) {
+    let t = e.mapResult(this.pos, 1);
+    return t.deletedAfter ? null : new ue(t.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.pos != "number")
+      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+    return new ue(t.pos, e.markFromJSON(t.mark));
+  }
+}
+M.jsonID("removeNodeMark", ue);
+class B 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(e, t, r, i = !1) {
+    super(), this.from = e, this.to = t, this.slice = r, this.structure = i;
+  }
+  apply(e) {
+    return this.structure && Fe(e, this.from, this.to) ? N.fail("Structure replace would overwrite content") : N.fromReplace(e, this.from, this.to, this.slice);
+  }
+  getMap() {
+    return new F([this.from, this.to - this.from, this.slice.size]);
+  }
+  invert(e) {
+    return new B(this.from, this.from + this.slice.size, e.slice(this.from, this.to));
+  }
+  map(e) {
+    let t = e.mapResult(this.to, -1), r = this.from == this.to && B.MAP_BIAS < 0 ? t : e.mapResult(this.from, 1);
+    return r.deletedAcross && t.deletedAcross ? null : new B(r.pos, Math.max(r.pos, t.pos), this.slice, this.structure);
+  }
+  merge(e) {
+    if (!(e instanceof B) || e.structure || this.structure)
+      return null;
+    if (this.from + this.slice.size == e.from && !this.slice.openEnd && !e.slice.openStart) {
+      let t = this.slice.size + e.slice.size == 0 ? T.empty : new T(this.slice.content.append(e.slice.content), this.slice.openStart, e.slice.openEnd);
+      return new B(this.from, this.to + (e.to - e.from), t, this.structure);
+    } else if (e.to == this.from && !this.slice.openStart && !e.slice.openEnd) {
+      let t = this.slice.size + e.slice.size == 0 ? T.empty : new T(e.slice.content.append(this.slice.content), e.slice.openStart, this.slice.openEnd);
+      return new B(e.from, this.to, t, this.structure);
+    } else
+      return null;
+  }
+  toJSON() {
+    let e = { stepType: "replace", from: this.from, to: this.to };
+    return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.from != "number" || typeof t.to != "number")
+      throw new RangeError("Invalid input for ReplaceStep.fromJSON");
+    return new B(t.from, t.to, T.fromJSON(e, t.slice), !!t.structure);
+  }
+}
+B.MAP_BIAS = 1;
+M.jsonID("replace", B);
+class ee 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(e, t, r, i, s, l, a = !1) {
+    super(), this.from = e, this.to = t, this.gapFrom = r, this.gapTo = i, this.slice = s, this.insert = l, this.structure = a;
+  }
+  apply(e) {
+    if (this.structure && (Fe(e, this.from, this.gapFrom) || Fe(e, this.gapTo, this.to)))
+      return N.fail("Structure gap-replace would overwrite content");
+    let t = e.slice(this.gapFrom, this.gapTo);
+    if (t.openStart || t.openEnd)
+      return N.fail("Gap is not a flat range");
+    let r = this.slice.insertAt(this.insert, t.content);
+    return r ? N.fromReplace(e, this.from, this.to, r) : N.fail("Content does not fit in gap");
+  }
+  getMap() {
+    return new F([
+      this.from,
+      this.gapFrom - this.from,
+      this.insert,
+      this.gapTo,
+      this.to - this.gapTo,
+      this.slice.size - this.insert
+    ]);
+  }
+  invert(e) {
+    let t = this.gapTo - this.gapFrom;
+    return new ee(this.from, this.from + this.slice.size + t, this.from + this.insert, this.from + this.insert + t, e.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+  }
+  map(e) {
+    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1), i = this.from == this.gapFrom ? t.pos : e.map(this.gapFrom, -1), s = this.to == this.gapTo ? r.pos : e.map(this.gapTo, 1);
+    return t.deletedAcross && r.deletedAcross || i < t.pos || s > r.pos ? null : new ee(t.pos, r.pos, i, s, this.slice, this.insert, this.structure);
+  }
+  toJSON() {
+    let e = {
+      stepType: "replaceAround",
+      from: this.from,
+      to: this.to,
+      gapFrom: this.gapFrom,
+      gapTo: this.gapTo,
+      insert: this.insert
+    };
+    return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.from != "number" || typeof t.to != "number" || typeof t.gapFrom != "number" || typeof t.gapTo != "number" || typeof t.insert != "number")
+      throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
+    return new ee(t.from, t.to, t.gapFrom, t.gapTo, T.fromJSON(e, t.slice), t.insert, !!t.structure);
+  }
+}
+M.jsonID("replaceAround", ee);
+function Fe(n, e, t) {
+  let r = n.resolve(e), i = t - e, s = r.depth;
+  for (; i > 0 && s > 0 && r.indexAfter(s) == r.node(s).childCount; )
+    s--, i--;
+  if (i > 0) {
+    let l = r.node(s).maybeChild(r.indexAfter(s));
+    for (; i > 0; ) {
+      if (!l || l.isLeaf)
+        return !0;
+      l = l.firstChild, i--;
+    }
+  }
+  return !1;
+}
+function sn(n, e, t) {
+  return (e == 0 || n.canReplace(e, n.childCount)) && (t == n.childCount || n.canReplace(0, t));
+}
+function Gt(n) {
+  let t = n.parent.content.cutByIndex(n.startIndex, n.endIndex);
+  for (let r = n.depth, i = 0, s = 0; ; --r) {
+    let l = n.$from.node(r), a = n.$from.index(r) + i, u = n.$to.indexAfter(r) - s;
+    if (r < n.depth && l.canReplace(a, u, t))
+      return r;
+    if (r == 0 || l.type.spec.isolating || !sn(l, a, u))
+      break;
+    a && (i = 1), u < l.childCount && (s = 1);
+  }
+  return null;
+}
+class le extends M {
+  /**
+  Construct an attribute step.
+  */
+  constructor(e, t, r) {
+    super(), this.pos = e, this.attr = t, this.value = r;
+  }
+  apply(e) {
+    let t = e.nodeAt(this.pos);
+    if (!t)
+      return N.fail("No node at attribute step's position");
+    let r = /* @__PURE__ */ Object.create(null);
+    for (let s in t.attrs)
+      r[s] = t.attrs[s];
+    r[this.attr] = this.value;
+    let i = t.type.create(r, null, t.marks);
+    return N.fromReplace(e, this.pos, this.pos + 1, new T(k.from(i), 0, t.isLeaf ? 0 : 1));
+  }
+  getMap() {
+    return F.empty;
+  }
+  invert(e) {
+    return new le(this.pos, this.attr, e.nodeAt(this.pos).attrs[this.attr]);
+  }
+  map(e) {
+    let t = e.mapResult(this.pos, 1);
+    return t.deletedAfter ? null : new le(t.pos, this.attr, this.value);
+  }
+  toJSON() {
+    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
+  }
+  static fromJSON(e, t) {
+    if (typeof t.pos != "number" || typeof t.attr != "string")
+      throw new RangeError("Invalid input for AttrStep.fromJSON");
+    return new le(t.pos, t.attr, t.value);
+  }
+}
+M.jsonID("attr", le);
+class xe extends M {
+  /**
+  Construct an attribute step.
+  */
+  constructor(e, t) {
+    super(), this.attr = e, this.value = t;
+  }
+  apply(e) {
+    let t = /* @__PURE__ */ Object.create(null);
+    for (let i in e.attrs)
+      t[i] = e.attrs[i];
+    t[this.attr] = this.value;
+    let r = e.type.create(t, e.content, e.marks);
+    return N.ok(r);
+  }
+  getMap() {
+    return F.empty;
+  }
+  invert(e) {
+    return new xe(this.attr, e.attrs[this.attr]);
+  }
+  map(e) {
+    return this;
+  }
+  toJSON() {
+    return { stepType: "docAttr", attr: this.attr, value: this.value };
+  }
+  static fromJSON(e, t) {
+    if (typeof t.attr != "string")
+      throw new RangeError("Invalid input for DocAttrStep.fromJSON");
+    return new xe(t.attr, t.value);
+  }
+}
+M.jsonID("docAttr", xe);
+let ce = class extends Error {
+};
+ce = function n(e) {
+  let t = Error.call(this, e);
+  return t.__proto__ = n.prototype, t;
+};
+ce.prototype = Object.create(Error.prototype);
+ce.prototype.constructor = ce;
+ce.prototype.name = "TransformError";
+const De = /* @__PURE__ */ Object.create(null);
+class L {
+  /**
+  Initialize a selection with the head and anchor and ranges. If no
+  ranges are given, constructs a single range across `$anchor` and
+  `$head`.
+  */
+  constructor(e, t, r) {
+    this.$anchor = e, this.$head = t, this.ranges = r || [new on(e.min(t), e.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 e = this.ranges;
+    for (let t = 0; t < e.length; t++)
+      if (e[t].$from.pos != e[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(e, t = T.empty) {
+    let r = t.content.lastChild, i = null;
+    for (let a = 0; a < t.openEnd; a++)
+      i = r, r = r.lastChild;
+    let s = e.steps.length, l = this.ranges;
+    for (let a = 0; a < l.length; a++) {
+      let { $from: u, $to: f } = l[a], d = e.mapping.slice(s);
+      e.replaceRange(d.map(u.pos), d.map(f.pos), a ? T.empty : t), a == 0 && yt(e, s, (r ? r.isInline : i && i.isTextblock) ? -1 : 1);
+    }
+  }
+  /**
+  Replace the selection with the given node, appending the changes
+  to the given transaction.
+  */
+  replaceWith(e, t) {
+    let r = e.steps.length, i = this.ranges;
+    for (let s = 0; s < i.length; s++) {
+      let { $from: l, $to: a } = i[s], u = e.mapping.slice(r), f = u.map(l.pos), d = u.map(a.pos);
+      s ? e.deleteRange(f, d) : (e.replaceRangeWith(f, d, t), yt(e, r, 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(e, t, r = !1) {
+    let i = e.parent.inlineContent ? new D(e) : Q(e.node(0), e.parent, e.pos, e.index(), t, r);
+    if (i)
+      return i;
+    for (let s = e.depth - 1; s >= 0; s--) {
+      let l = t < 0 ? Q(e.node(0), e.node(s), e.before(s + 1), e.index(s), t, r) : Q(e.node(0), e.node(s), e.after(s + 1), e.index(s) + 1, t, r);
+      if (l)
+        return l;
+    }
+    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(e, t = 1) {
+    return this.findFrom(e, t) || this.findFrom(e, -t) || new j(e.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(e) {
+    return Q(e, e, 0, 0, 1) || new j(e);
+  }
+  /**
+  Find the cursor or leaf node selection closest to the end of the
+  given document.
+  */
+  static atEnd(e) {
+    return Q(e, e, e.content.size, e.childCount, -1) || new j(e);
+  }
+  /**
+  Deserialize the JSON representation of a selection. Must be
+  implemented for custom classes (as a static class method).
+  */
+  static fromJSON(e, t) {
+    if (!t || !t.type)
+      throw new RangeError("Invalid input for Selection.fromJSON");
+    let r = De[t.type];
+    if (!r)
+      throw new RangeError(`No selection type ${t.type} defined`);
+    return r.fromJSON(e, 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(e, t) {
+    if (e in De)
+      throw new RangeError("Duplicate use of selection JSON ID " + e);
+    return De[e] = t, t.prototype.jsonID = e, 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 D.between(this.$anchor, this.$head).getBookmark();
+  }
+}
+L.prototype.visible = !0;
+class on {
+  /**
+  Create a range.
+  */
+  constructor(e, t) {
+    this.$from = e, this.$to = t;
+  }
+}
+let mt = !1;
+function gt(n) {
+  !mt && !n.parent.inlineContent && (mt = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + n.parent.type.name + ")"));
+}
+class D extends L {
+  /**
+  Construct a text selection between the given points.
+  */
+  constructor(e, t = e) {
+    gt(e), gt(t), super(e, t);
+  }
+  /**
+  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(e, t) {
+    let r = e.resolve(t.map(this.head));
+    if (!r.parent.inlineContent)
+      return L.near(r);
+    let i = e.resolve(t.map(this.anchor));
+    return new D(i.parent.inlineContent ? i : r, r);
+  }
+  replace(e, t = T.empty) {
+    if (super.replace(e, t), t == T.empty) {
+      let r = this.$from.marksAcross(this.$to);
+      r && e.ensureMarks(r);
+    }
+  }
+  eq(e) {
+    return e instanceof D && e.anchor == this.anchor && e.head == this.head;
+  }
+  getBookmark() {
+    return new Se(this.anchor, this.head);
+  }
+  toJSON() {
+    return { type: "text", anchor: this.anchor, head: this.head };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.anchor != "number" || typeof t.head != "number")
+      throw new RangeError("Invalid input for TextSelection.fromJSON");
+    return new D(e.resolve(t.anchor), e.resolve(t.head));
+  }
+  /**
+  Create a text selection from non-resolved positions.
+  */
+  static create(e, t, r = t) {
+    let i = e.resolve(t);
+    return new this(i, r == t ? i : e.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(e, t, r) {
+    let i = e.pos - t.pos;
+    if ((!r || i) && (r = i >= 0 ? 1 : -1), !t.parent.inlineContent) {
+      let s = L.findFrom(t, r, !0) || L.findFrom(t, -r, !0);
+      if (s)
+        t = s.$head;
+      else
+        return L.near(t, r);
+    }
+    return e.parent.inlineContent || (i == 0 ? e = t : (e = (L.findFrom(e, -r, !0) || L.findFrom(e, r, !0)).$anchor, e.pos < t.pos != i < 0 && (e = t))), new D(e, t);
+  }
+}
+L.jsonID("text", D);
+class Se {
+  constructor(e, t) {
+    this.anchor = e, this.head = t;
+  }
+  map(e) {
+    return new Se(e.map(this.anchor), e.map(this.head));
+  }
+  resolve(e) {
+    return D.between(e.resolve(this.anchor), e.resolve(this.head));
+  }
+}
+class z extends L {
+  /**
+  Create a node selection. Does not verify the validity of its
+  argument.
+  */
+  constructor(e) {
+    let t = e.nodeAfter, r = e.node(0).resolve(e.pos + t.nodeSize);
+    super(e, r), this.node = t;
+  }
+  map(e, t) {
+    let { deleted: r, pos: i } = t.mapResult(this.anchor), s = e.resolve(i);
+    return r ? L.near(s) : new z(s);
+  }
+  content() {
+    return new T(k.from(this.node), 0, 0);
+  }
+  eq(e) {
+    return e instanceof z && e.anchor == this.anchor;
+  }
+  toJSON() {
+    return { type: "node", anchor: this.anchor };
+  }
+  getBookmark() {
+    return new Be(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON");
+    return new z(e.resolve(t.anchor));
+  }
+  /**
+  Create a node selection from non-resolved positions.
+  */
+  static create(e, t) {
+    return new z(e.resolve(t));
+  }
+  /**
+  Determines whether the given node may be selected as a node
+  selection.
+  */
+  static isSelectable(e) {
+    return !e.isText && e.type.spec.selectable !== !1;
+  }
+}
+z.prototype.visible = !1;
+L.jsonID("node", z);
+class Be {
+  constructor(e) {
+    this.anchor = e;
+  }
+  map(e) {
+    let { deleted: t, pos: r } = e.mapResult(this.anchor);
+    return t ? new Se(r, r) : new Be(r);
+  }
+  resolve(e) {
+    let t = e.resolve(this.anchor), r = t.nodeAfter;
+    return r && z.isSelectable(r) ? new z(t) : L.near(t);
+  }
+}
+class j extends L {
+  /**
+  Create an all-selection over the given document.
+  */
+  constructor(e) {
+    super(e.resolve(0), e.resolve(e.content.size));
+  }
+  replace(e, t = T.empty) {
+    if (t == T.empty) {
+      e.delete(0, e.doc.content.size);
+      let r = L.atStart(e.doc);
+      r.eq(e.selection) || e.setSelection(r);
+    } else
+      super.replace(e, t);
+  }
+  toJSON() {
+    return { type: "all" };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e) {
+    return new j(e);
+  }
+  map(e) {
+    return new j(e);
+  }
+  eq(e) {
+    return e instanceof j;
+  }
+  getBookmark() {
+    return an;
+  }
+}
+L.jsonID("all", j);
+const an = {
+  map() {
+    return this;
+  },
+  resolve(n) {
+    return new j(n);
+  }
+};
+function Q(n, e, t, r, i, s = !1) {
+  if (e.inlineContent)
+    return D.create(n, t);
+  for (let l = r - (i > 0 ? 0 : 1); i > 0 ? l < e.childCount : l >= 0; l += i) {
+    let a = e.child(l);
+    if (a.isAtom) {
+      if (!s && z.isSelectable(a))
+        return z.create(n, t - (i < 0 ? a.nodeSize : 0));
+    } else {
+      let u = Q(n, a, t + i, i < 0 ? a.childCount : 0, i, s);
+      if (u)
+        return u;
+    }
+    t += a.nodeSize * i;
+  }
+  return null;
+}
+function yt(n, e, t) {
+  let r = n.steps.length - 1;
+  if (r < e)
+    return;
+  let i = n.steps[r];
+  if (!(i instanceof B || i instanceof ee))
+    return;
+  let s = n.mapping.maps[r], l;
+  s.forEach((a, u, f, d) => {
+    l == null && (l = d);
+  }), n.setSelection(L.near(n.doc.resolve(l), t));
+}
+function vt(n, e) {
+  return !e || !n ? n : n.bind(e);
+}
+class ve {
+  constructor(e, t, r) {
+    this.name = e, this.init = vt(t.init, r), this.apply = vt(t.apply, r);
+  }
+}
+new ve("doc", {
+  init(n) {
+    return n.doc || n.schema.topNodeType.createAndFill();
+  },
+  apply(n) {
+    return n.doc;
+  }
+}), new ve("selection", {
+  init(n, e) {
+    return n.selection || L.atStart(e.doc);
+  },
+  apply(n) {
+    return n.selection;
+  }
+}), new ve("storedMarks", {
+  init(n) {
+    return n.storedMarks || null;
+  },
+  apply(n, e, t, r) {
+    return r.selection.$cursor ? n.storedMarks : null;
+  }
+}), new ve("scrollToSelection", {
+  init() {
+    return 0;
+  },
+  apply(n, e) {
+    return n.scrolledIntoView ? e + 1 : e;
+  }
+});
+function Xt(n, e, t) {
+  for (let r in n) {
+    let i = n[r];
+    i instanceof Function ? i = i.bind(e) : r == "handleDOMEvents" && (i = Xt(i, e, {})), t[r] = i;
+  }
+  return t;
+}
+class de {
+  /**
+  Create a plugin.
+  */
+  constructor(e) {
+    this.spec = e, this.props = {}, e.props && Xt(e.props, this, this.props), this.key = e.key ? e.key.key : Zt("plugin");
+  }
+  /**
+  Extract the plugin's state field from an editor state.
+  */
+  getState(e) {
+    return e[this.key];
+  }
+}
+const ze = /* @__PURE__ */ Object.create(null);
+function Zt(n) {
+  return n in ze ? n + "$" + ++ze[n] : (ze[n] = 0, n + "$");
+}
+class ln {
+  /**
+  Create a plugin key.
+  */
+  constructor(e = "key") {
+    this.key = Zt(e);
+  }
+  /**
+  Get the active plugin with this key, if any, from an editor
+  state.
+  */
+  get(e) {
+    return e.config.pluginsByKey[this.key];
+  }
+  /**
+  Get the plugin's state from an editor state.
+  */
+  getState(e) {
+    return e[this.key];
+  }
+}
+const $ = (n) => n === "bulletList" || n === "orderedList", be = (n) => n === "listItem", _ = (n) => n === "paragraph" || n === "heading";
+function _e(n, e) {
+  for (const t of n)
+    if (t(e))
+      return !0;
+  return !1;
+}
+function un(n, e) {
+  for (const t of n)
+    if (t(e)) return !0;
+  return !1;
+}
+const It = ({
+  state: n,
+  view: e,
+  $from: t,
+  $to: r,
+  selectionIsEmpty: i
+}) => {
+  if (i) return !1;
+  let s = 0;
+  if (n.doc.nodesBetween(t.pos, r.pos, (p) => {
+    (be(p.type.name) || _(p.type.name)) && s++;
+  }), !(s > 1)) return !1;
+  const { tr: a, doc: u } = n;
+  let f = !1;
+  const d = /* @__PURE__ */ new Set();
+  return u.nodesBetween(t.pos, r.pos, (p, y) => {
+    if ($(p.type.name) && (p.attrs.indent ?? 0) > 0) {
+      if (!d.has(y)) {
+        d.add(y);
+        const w = p.attrs.indent ?? 0;
+        a.setNodeAttribute(y, "indent", Math.max(0, w - 1)), f = !0;
+        const m = n.doc.resolve(y), S = n.doc.resolve(y + p.nodeSize), C = new qt(m, S, m.depth), A = Gt(C);
+        A != null && (a.lift(C, A), f = !0);
+      }
+      return !1;
+    }
+    if (_(p.type.name) && (p.attrs.indent ?? 0) > 0) {
+      const w = p.attrs.indent ?? 0;
+      a.setNodeAttribute(y, "indent", Math.max(0, w - 1)), f = !0;
+    }
+    return !0;
+  }), f ? (a.setMeta("addToHistory", !0), e.dispatch(a), !0) : !1;
+}, cn = ({
+  editor: n,
+  $from: e,
+  currentNode: t
+}) => {
+  const r = e.pos === e.start(), i = t.attrs.indent > 0;
+  return _(t.type.name) && i && r ? n.commands.outdent() : !1;
+}, dn = ({
+  state: n,
+  view: e,
+  $from: t,
+  currentNode: r
+}) => {
+  const i = r.content.size === 0, s = r.attrs.indent > 0;
+  if (!(_(r.type.name) && s && i)) return !1;
+  const a = t.before(t.depth), u = n.tr;
+  return u.delete(a, a + r.nodeSize), e.dispatch(u), !0;
+}, fn = ({
+  state: n,
+  view: e,
+  $from: t,
+  currentNode: r
+}) => {
+  const i = t.pos === t.start(), s = r.content.size === 0, l = r.attrs.indent > 0, a = t.before(t.depth), u = n.doc.resolve(a).nodeBefore, f = u != null && $(u.type.name);
+  if (_(r.type.name) && !l && s && i && f) {
+    const p = n.tr;
+    return p.delete(a, a + r.nodeSize), e.dispatch(p), !0;
+  }
+  return !1;
+}, hn = (n) => {
+  const { tr: e, state: t, dispatch: r } = n, { selection: i } = t, { $from: s, $to: l } = i;
+  if (i.empty) return !1;
+  let a = 0;
+  if (t.doc.nodesBetween(s.pos, l.pos, (d) => {
+    ($(d.type.name) || _(d.type.name)) && a++;
+  }), a <= 1) return !1;
+  const u = /* @__PURE__ */ new Set();
+  let f = !1;
+  return t.doc.nodesBetween(s.pos, l.pos, (d, p) => {
+    var w;
+    return !($(d.type.name) || _(d.type.name)) || u.has(p) ? !0 : (u.add(p), e.setNodeAttribute(p, "indent", (((w = d.attrs) == null ? void 0 : w.indent) ?? 0) + 1), f = !0, !1);
+  }), f ? (e.setMeta("addToHistory", !0), r == null || r(e), !0) : !1;
+}, pn = (n) => {
+  var f;
+  const { tr: e, state: t, dispatch: r } = n, { selection: i } = t, { $from: s } = i;
+  let l = null, a = null;
+  for (let d = s.depth; d > 0; d--) {
+    const p = s.node(d);
+    if ($(p.type.name)) {
+      l = { ...p, pos: s.before(d) }, a = { ...s.node(d + 1), pos: s.before(d + 1) };
+      break;
+    }
+  }
+  if (!l || !a) return !1;
+  if (((f = l.content) == null ? void 0 : f.childCount) === 1 && i instanceof D) {
+    const d = l.attrs.indent ?? 0;
+    return e.setNodeAttribute(l.pos, "indent", d + 1), e.setMeta("addToHistory", !1), r == null || r(e), !0;
+  }
+  return n.chain().focus().sinkListItem("listItem").updateAttributes("bulletList", { indent: 1 }).updateAttributes("orderedList", { indent: 1 }).run(), !0;
+}, mn = (n) => {
+  const { tr: e, state: t, dispatch: r } = n, { selection: i } = t, { $from: s } = i, l = s.node();
+  if (!(_(l.type.name) && i instanceof D)) return !1;
+  const u = l.attrs.indent ?? 0;
+  return e.setNodeAttribute(s.before(s.depth), "indent", u + 1), e.setMeta("addToHistory", !1), r == null || r(e), !0;
+}, gn = ({
+  state: n,
+  view: e,
+  $from: t,
+  $to: r,
+  selectionIsEmpty: i
+}) => {
+  if (i) return !1;
+  let s = 0;
+  if (n.doc.nodesBetween(t.pos, r.pos, (p) => {
+    (be(p.type.name) || _(p.type.name)) && s++;
+  }), !(s > 1)) return !1;
+  const { tr: a, doc: u } = n;
+  let f = !1;
+  const d = /* @__PURE__ */ new Set();
+  return u.nodesBetween(t.pos, r.pos, (p, y) => {
+    if ($(p.type.name) && (p.attrs.indent ?? 0) > 0) {
+      if (!d.has(y)) {
+        d.add(y);
+        const w = p.attrs.indent ?? 0;
+        a.setNodeAttribute(y, "indent", Math.max(0, w - 1)), f = !0;
+        const m = n.doc.resolve(y), S = n.doc.resolve(y + p.nodeSize), C = new qt(m, S, m.depth), A = Gt(C);
+        A != null && (a.lift(C, A), f = !0);
+      }
+      return !1;
+    }
+    if (_(p.type.name) && (p.attrs.indent ?? 0) > 0) {
+      const w = p.attrs.indent ?? 0;
+      a.setNodeAttribute(y, "indent", Math.max(0, w - 1)), f = !0;
+    }
+    return !0;
+  }), f ? (a.setMeta("addToHistory", !0), e.dispatch(a), !0) : !1;
+}, yn = ({ $from: n, selectionIsEmpty: e }) => {
+  var l;
+  if (!e) return !1;
+  let t = !1, r = !1, i = 0;
+  for (let a = n.depth; a > 0; a--) {
+    const u = n.node(a);
+    if ($(u.type.name))
+      if (!t)
+        t = !0, i = ((l = u.attrs) == null ? void 0 : l.indent) ?? 0;
+      else {
+        r = !0;
+        break;
+      }
+  }
+  return t && !r ? i === 0 : !1;
+}, vn = ({
+  state: n,
+  view: e,
+  $from: t,
+  currentNode: r,
+  selectionIsEmpty: i
+}) => {
+  if (!i || !(r.type.name === "paragraph" && r.content.size === 0)) return !1;
+  const l = t.before(t.depth), a = n.doc.resolve(l).nodeBefore;
+  if (!(a != null && $(a.type.name))) return !1;
+  const f = n.doc.resolve(l - 1), d = n.tr.setSelection(D.near(f, -1));
+  return e.dispatch(d), !0;
+}, In = ({
+  state: n,
+  view: e,
+  $from: t,
+  $to: r,
+  selectionIsEmpty: i
+}) => {
+  if (i) return !1;
+  let s = 0;
+  if (n.doc.nodesBetween(t.pos, r.pos, (p) => {
+    (be(p.type.name) || _(p.type.name)) && s++;
+  }), !(s > 1)) return !1;
+  const { tr: a, doc: u } = n;
+  let f = !1;
+  const d = /* @__PURE__ */ new Set();
+  return u.nodesBetween(t.pos, r.pos, (p, y) => {
+    if (($(p.type.name) || _(p.type.name)) && !d.has(y)) {
+      d.add(y);
+      const m = p.attrs.indent ?? 0;
+      return a.setNodeAttribute(y, "indent", m + 1), f = !0, !1;
+    }
+    return !0;
+  }), f ? (a.setMeta("addToHistory", !0), e.dispatch(a), !0) : !1;
+}, wn = ({
+  state: n,
+  view: e,
+  $from: t,
+  selectionIsEmpty: r
+}) => r || t.path.some((s) => {
+  var l;
+  return ((l = s == null ? void 0 : s.type) == null ? void 0 : l.name) === "listItem";
+}) ? !1 : (e.dispatch(n.tr.insertText("	")), !0), xn = ({ editor: n, currentNode: e, $from: t }) => {
+  const r = e.content.size === 0, i = t.node(t.depth - 1);
+  return i && be(i.type.name) && !r ? (n.chain().focus().indent().focus().run(), !0) : !1;
+}, Sn = ({ state: n, view: e, $from: t, currentNode: r }) => {
+  const i = t.pos === t.start(), s = r.content.size === 0;
+  return !i && !s ? (e.dispatch(n.tr.insertText("	")), !0) : !1;
+};
+function Je(n) {
+  const { state: e, view: t } = n, { $from: r, $to: i, empty: s } = e.selection;
+  return { editor: n, state: e, view: t, $from: r, $to: i, selectionIsEmpty: s, currentNode: r.node() };
+}
+const bn = Xr.create({
+  name: "indent",
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => this.editor.commands._handleEnterKeyDown(),
+      Tab: () => {
+        const n = Je(this.editor);
+        return _e(
+          [
+            In,
+            wn,
+            xn,
+            Sn
+          ],
+          n
+        ) || this.editor.commands.indent();
+      },
+      Backspace: () => {
+        const n = Je(this.editor);
+        return _e(
+          [
+            cn,
+            dn,
+            fn
+          ],
+          n
+        );
+      },
+      "Shift-Tab": () => {
+        const n = Je(this.editor);
+        return _e(
+          [
+            gn,
+            vn,
+            yn
+          ],
+          n
+        ) || this.editor.chain().outdentShiftTab().run();
+      },
+      Space: () => this.editor.commands._handleSpaceKeyDown()
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new de({
+        // WHY: When a paragraph/heading inside a listItem gets an indent attribute (e.g. from a
+        // paste or undo), the indent belongs on the parent list node, not the text node inside it.
+        // This plugin corrects that automatically on every document change.
+        appendTransaction: (n, e, t) => {
+          if (!n.some((s) => s.docChanged)) return null;
+          let i = null;
+          return t.doc.descendants((s, l) => {
+            var y;
+            if (!(_(s.type.name) && (((y = s == null ? void 0 : s.attrs) == null ? void 0 : y.indent) ?? 0) > 0)) return;
+            const u = t.doc.resolve(l);
+            if (!(u.parent.type.name === "listItem")) return;
+            let d = null;
+            for (let w = u.depth - 1; w > 0; w--)
+              if ($(u.node(w).type.name)) {
+                d = u.start(w) - 1;
+                break;
+              }
+            if (d === null || d < 0) return;
+            i || (i = t.tr);
+            const p = s.attrs.indent;
+            i.setNodeAttribute(l, "indent", 0), i.setNodeAttribute(d, "indent", p);
+          }), i;
+        }
+      })
+    ];
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types ?? ["orderedList", "bulletList", "paragraph", "heading"],
+        attributes: {
+          indent: {
+            default: 1,
+            parseHTML: (n) => parseInt(n.getAttribute("data-indent") || "1", 10),
+            renderHTML: (n) => n != null && n.indent ? { style: `padding-left: ${n.indent * 20}px` } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      _handleEnterKeyDown: () => (n) => {
+        var u;
+        const { tr: e, state: t, dispatch: r } = n, { $from: i } = t.selection, s = i.node();
+        if (!(((u = s == null ? void 0 : s.type) == null ? void 0 : u.name) === "paragraph" && s.attrs.indent)) return !1;
+        const a = s.attrs.indent;
+        return e.split(i.pos), e.setNodeAttribute(e.selection.$from.before(), "indent", a), e.scrollIntoView(), e.setMeta("addToHistory", !1), r == null || r(e), !0;
+      },
+      _handleSpaceKeyDown: () => () => !1,
+      indent: () => (n) => un(
+        [hn, pn, mn],
+        n
+      ),
+      // WHY: `outdent` is used by Backspace. It only reduces indent when the cursor
+      // is at the very start of the node, preventing accidental outdenting mid-sentence.
+      outdent: () => (n) => {
+        const { state: e, view: t, tr: r, dispatch: i } = n, { $from: s, $to: l, empty: a } = e.selection, u = {
+          editor: n.editor,
+          state: e,
+          view: t,
+          $from: s,
+          $to: l,
+          selectionIsEmpty: a,
+          currentNode: s.node()
+        };
+        if (It(u)) return !0;
+        const f = s.node();
+        if (!(_(f.type.name) && f.attrs.indent > 0) || !(s.pos === s.start())) return !1;
+        const y = Math.max(0, f.attrs.indent - 1);
+        return r.setNodeAttribute(s.before(s.depth), "indent", y), r.setMeta("addToHistory", !1), i == null || i(r), !0;
+      },
+      // WHY: `outdentShiftTab` is used by Shift+Tab. Unlike `outdent`, it reduces indent
+      // regardless of where the cursor is — Shift+Tab is an explicit intent to un-indent.
+      outdentShiftTab: () => (n) => {
+        const { state: e, tr: t, dispatch: r } = n, { $from: i } = e.selection, s = i.node();
+        if (!(_(s.type.name) && s.attrs.indent > 0)) return !1;
+        const a = Math.max(0, s.attrs.indent - 1);
+        return t.setNodeAttribute(i.before(i.depth), "indent", a), t.setMeta("addToHistory", !1), r == null || r(t), !0;
+      },
+      increaseIndent: () => ({ commands: n }) => n.indent(),
+      decreaseIndent: () => (n) => {
+        const { state: e, view: t } = n, { $from: r, $to: i, empty: s } = e.selection, l = {
+          editor: n.editor,
+          state: e,
+          view: t,
+          $from: r,
+          $to: i,
+          selectionIsEmpty: s,
+          currentNode: r.node()
+        };
+        return It(l) ? !0 : n.chain().outdentShiftTab().run();
+      }
+    };
+  }
+});
+var Tn = Nt, En = At, kn = Ct;
+const Rn = Tn.extend({
+  addAttributes() {
+    var n;
+    return {
+      ...(n = this.parent) == null ? void 0 : n.call(this),
+      indent: {
+        default: 0,
+        // Backward compatibility (FR-030)
+        parseHTML: (e) => parseInt(e.getAttribute("data-indent") || "0", 10),
+        renderHTML: (e) => e.indent ? { "data-indent": e.indent } : {}
+      }
+    };
+  },
+  addNodeView() {
+    return ({ node: n }) => {
+      const e = n.attrs.indent || 0, t = document.createElement("ul");
+      return t.setAttribute("data-indent", String(e)), e > 0 && (t.style.paddingLeft = `${e * 20}px`), { dom: t, contentDOM: t };
+    };
+  }
+}), On = kn.extend({
+  addAttributes() {
+    var n;
+    return {
+      ...(n = this.parent) == null ? void 0 : n.call(this),
+      indent: {
+        default: 0,
+        // Backward compatibility (FR-030)
+        parseHTML: (e) => parseInt(e.getAttribute("data-indent") || "0", 10),
+        renderHTML: (e) => e.indent ? { "data-indent": e.indent } : {}
+      }
+    };
+  },
+  addNodeView() {
+    return ({ node: n }) => {
+      const e = n.attrs.indent || 0, t = document.createElement("ol");
+      return t.setAttribute("data-indent", String(e)), e > 0 && (t.style.paddingLeft = `${e * 20}px`), { dom: t, contentDOM: t };
+    };
+  }
+}), Qt = En.extend({
+  addAttributes() {
+    var n;
+    return {
+      ...(n = this.parent) == null ? void 0 : n.call(this),
+      class: {
+        default: null,
+        parseHTML: (e) => e.getAttribute("class"),
+        renderHTML: (e) => e.class ? { class: e.class, ...e } : {}
+      },
+      indent: {
+        default: 0,
+        // Backward compatibility (FR-030)
+        parseHTML: (e) => parseInt(e.getAttribute("data-indent") || "0", 10),
+        renderHTML: (e) => e.indent ? { "data-indent": e.indent } : {}
+      }
+    };
+  }
+}), er = fe.create({
+  name: "dynamicBulletStyling",
+  addProseMirrorPlugins() {
+    return [
+      new de({
+        key: new ln("dynamicBulletStyling"),
+        appendTransaction: (n, e, t) => {
+          const r = t.tr;
+          let i = !1;
+          return t.doc.descendants((s, l) => {
+            if (s.type.name === "listItem") {
+              let a = 0;
+              const u = t.doc.resolve(l);
+              for (let f = u.depth; f > 0; f--)
+                if (u.node(f).type.name === "bulletList") {
+                  a = 1;
+                  break;
+                }
+              a > 0 && (r.setNodeAttribute(u.pos, "[data-style]", "line-height: inherit"), i = !0);
+            }
+          }), i ? r : null;
+        }
+      })
+    ];
+  }
+}), Nn = (n) => n === "bulletList" || n === "orderedList", An = (n) => n === "paragraph" || n === "heading", Cn = fe.create({
+  name: "listIndentIntegration",
+  addProseMirrorPlugins() {
+    return [
+      // Indent attribute transfer plugin
+      new de({
+        appendTransaction: (n, e, t) => {
+          if (!n.find((i) => i.docChanged))
+            return null;
+          let r = null;
+          return t.doc.descendants((i, s) => {
+            var l;
+            if (An(i.type.name) && (((l = i == null ? void 0 : i.attrs) == null ? void 0 : l.indent) ?? 0) > 0) {
+              const a = t.doc.resolve(s);
+              if (a.parent.type.name === "listItem") {
+                let f = null;
+                for (let d = a.depth - 1; d > 0; d--) {
+                  const p = a.node(d);
+                  if (Nn(p.type.name)) {
+                    f = a.start(d) - 1;
+                    break;
+                  }
+                }
+                if (f !== null && f >= 0) {
+                  r || (r = t.tr);
+                  const d = i.attrs.indent;
+                  r.setNodeAttribute(s, "indent", 0), r.setNodeAttribute(f, "indent", d);
+                }
+              }
+            }
+          }), r;
+        }
+      }),
+      // T088, T089, T090: Paste transformation plugin
+      new de({
+        props: {
+          transformPastedHTML(n) {
+            const e = /<p[^>]*style="[^"]*(?:padding|margin)-left:\s*(\d+)(?:px|pt|em)[^"]*"[^>]*>/gi;
+            n = n.replace(e, (i, s) => `<p data-indent="${Math.floor(parseInt(s, 10) / 40)}">`);
+            const t = /<ol[^>]*style="[^"]*list-style-type:\s*(upper-roman|lower-roman|upper-alpha|lower-alpha)[^"]*"[^>]*>/gi;
+            n = n.replace(t, () => "<ol>");
+            const r = /<li[^>]*style="[^"]*list-style-type:\s*[^;"\s]+[^"]*"[^>]*>/gi;
+            return n = n.replace(r, (i) => i.replace(/list-style-type:\s*[^;"\s]+;?/gi, "")), n;
+          }
+        }
+      })
+    ];
+  }
+}), tr = fe.create({
+  name: "fontSize",
+  addOptions() {
+    return {
+      types: ["textStyle"],
+      getStyle: (n) => `font-size: ${n}`
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            parseHTML: (n) => n.style.fontSize.replace(/['"]+/g, ""),
+            renderHTML: (n) => n.fontSize ? {
+              style: this.options.getStyle(n.fontSize)
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontSize: (n) => ({ chain: e }) => e().setMark("textStyle", { fontSize: n }).run(),
+      unsetFontSize: () => ({ chain: n }) => n().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run()
+    };
+  }
+}), rr = fe.create({
+  name: "lineHeight",
+  addOptions() {
+    return {
+      types: ["textStyle"],
+      getStyle: (n) => `line-height: ${n};`
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          lineHeight: {
+            default: null,
+            parseHTML: (n) => n.style.lineHeight.replace(/['"]+/g, ""),
+            renderHTML: (n) => n.lineHeight ? {
+              style: this.options.getStyle(n.lineHeight)
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setLineHeight: (n) => ({ chain: e }) => e().setMark("textStyle", { lineHeight: n }).run(),
+      unsetLineHeight: () => ({ chain: n }) => n().setMark("textStyle", { lineHeight: null }).removeEmptyTextStyle().run()
+    };
+  }
+}), ai = [
+  Tt,
+  Kr,
+  Et,
+  kt,
+  _r,
+  Jr,
+  Fr,
+  Hr,
+  Br,
+  At,
+  $r,
+  qr,
+  Ct,
+  Gr,
+  Vr,
+  Wr,
+  Ur,
+  Yr,
+  Lt,
+  jr,
+  Dt,
+  zt,
+  _t,
+  // Missing from BASE_EXTENSIONS
+  Mt,
+  Pt,
+  Ot,
+  // Gapcursor,
+  Rt,
+  Jt,
+  Qt,
+  tr,
+  rr,
+  Nt,
+  er
+], li = [
+  en,
+  // CONVENTION - Replaces Paragraph with selectable indent spacing (T006-T007)
+  zt,
+  Et,
+  Jt.configure({
+    // T012, T091: Pause-based undo/redo granularity (FR-032, FR-033)
+    // Verified: Rapid Tab presses within 500ms are grouped as single undo unit
+    // This matches Google Docs behavior (spec requirement)
+    newGroupDelay: 500,
+    // Group operations within 500ms window
+    depth: 100
+    // Max undo stack depth
+  }),
+  // COMMENTED OUT TEMPORARILY THE GAPCURSOR FIRST BECAUSE WE DON'T NEED VISUAL EFFECT FROM GAPCUROSR AND WE DO CUSTOM IMAGES CURSOR ANYWAY. UNCOMMENT IT IF NEEDED LATER.
+  // Gapcursor,
+  Rt,
+  _t,
+  Tt,
+  Ot,
+  Lt,
+  Qt,
+  // T011: ListItem with indent attribute
+  kt,
+  Pt,
+  tr,
+  rr,
+  Rn,
+  // T009: BulletList with indent attribute
+  // No custom keymap, just dynamic styling
+  er,
+  Cn,
+  // T029: Indent attribute transfer (FR-020, FR-021, FR-023)
+  Dt.configure({
+    types: ["heading", "paragraph"]
+  }),
+  On.configure({
+    // T010: OrderedList with indent attribute
+    itemTypeName: "listItem",
+    keepMarks: !0,
+    keepAttributes: !0
+  }),
+  // Must be last to have highest keyboard shortcut priority
+  bn
+], ui = fe.create({
+  name: "MentionStorage",
+  addStorage() {
+    return {
+      suggestions: []
+    };
+  }
+});
+var Z = {}, wt;
+function Ln() {
+  if (wt) return Z;
+  wt = 1;
+  var n = Qr;
+  if (process.env.NODE_ENV === "production")
+    Z.createRoot = n.createRoot, Z.hydrateRoot = n.hydrateRoot;
+  else {
+    var e = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    Z.createRoot = function(t, r) {
+      e.usingClientEntryPoint = !0;
+      try {
+        return n.createRoot(t, r);
+      } finally {
+        e.usingClientEntryPoint = !1;
+      }
+    }, Z.hydrateRoot = function(t, r, i) {
+      e.usingClientEntryPoint = !0;
+      try {
+        return n.hydrateRoot(t, r, i);
+      } finally {
+        e.usingClientEntryPoint = !1;
+      }
+    };
+  }
+  return Z;
+}
+var Mn = Ln(), Ie = { exports: {} }, ie = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var xt;
+function Pn() {
+  if (xt) return ie;
+  xt = 1;
+  var n = Ft, e = Symbol.for("react.element"), t = Symbol.for("react.fragment"), r = Object.prototype.hasOwnProperty, i = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, s = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function l(a, u, f) {
+    var d, p = {}, y = null, w = null;
+    f !== void 0 && (y = "" + f), u.key !== void 0 && (y = "" + u.key), u.ref !== void 0 && (w = u.ref);
+    for (d in u) r.call(u, d) && !s.hasOwnProperty(d) && (p[d] = u[d]);
+    if (a && a.defaultProps) for (d in u = a.defaultProps, u) p[d] === void 0 && (p[d] = u[d]);
+    return { $$typeof: e, type: a, key: y, ref: w, props: p, _owner: i.current };
+  }
+  return ie.Fragment = t, ie.jsx = l, ie.jsxs = l, ie;
+}
+var se = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var St;
+function Dn() {
+  return St || (St = 1, process.env.NODE_ENV !== "production" && (function() {
+    var n = Ft, e = Symbol.for("react.element"), t = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), i = Symbol.for("react.strict_mode"), s = Symbol.for("react.profiler"), l = Symbol.for("react.provider"), a = Symbol.for("react.context"), u = Symbol.for("react.forward_ref"), f = Symbol.for("react.suspense"), d = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), w = Symbol.for("react.offscreen"), m = Symbol.iterator, S = "@@iterator";
+    function C(o) {
+      if (o === null || typeof o != "object")
+        return null;
+      var c = m && o[m] || o[S];
+      return typeof c == "function" ? c : null;
+    }
+    var A = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function E(o) {
+      {
+        for (var c = arguments.length, h = new Array(c > 1 ? c - 1 : 0), g = 1; g < c; g++)
+          h[g - 1] = arguments[g];
+        te("error", o, h);
+      }
+    }
+    function te(o, c, h) {
+      {
+        var g = A.ReactDebugCurrentFrame, x = g.getStackAddendum();
+        x !== "" && (c += "%s", h = h.concat([x]));
+        var b = h.map(function(I) {
+          return String(I);
+        });
+        b.unshift("Warning: " + c), Function.prototype.apply.call(console[o], console, b);
+      }
+    }
+    var nr = !1, ir = !1, sr = !1, or = !1, ar = !1, $e;
+    $e = Symbol.for("react.module.reference");
+    function lr(o) {
+      return !!(typeof o == "string" || typeof o == "function" || o === r || o === s || ar || o === i || o === f || o === d || or || o === w || nr || ir || sr || typeof o == "object" && o !== null && (o.$$typeof === y || o.$$typeof === p || o.$$typeof === l || o.$$typeof === a || o.$$typeof === u || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      o.$$typeof === $e || o.getModuleId !== void 0));
+    }
+    function ur(o, c, h) {
+      var g = o.displayName;
+      if (g)
+        return g;
+      var x = c.displayName || c.name || "";
+      return x !== "" ? h + "(" + x + ")" : h;
+    }
+    function je(o) {
+      return o.displayName || "Context";
+    }
+    function q(o) {
+      if (o == null)
+        return null;
+      if (typeof o.tag == "number" && E("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof o == "function")
+        return o.displayName || o.name || null;
+      if (typeof o == "string")
+        return o;
+      switch (o) {
+        case r:
+          return "Fragment";
+        case t:
+          return "Portal";
+        case s:
+          return "Profiler";
+        case i:
+          return "StrictMode";
+        case f:
+          return "Suspense";
+        case d:
+          return "SuspenseList";
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case a:
+            var c = o;
+            return je(c) + ".Consumer";
+          case l:
+            var h = o;
+            return je(h._context) + ".Provider";
+          case u:
+            return ur(o, o.render, "ForwardRef");
+          case p:
+            var g = o.displayName || null;
+            return g !== null ? g : q(o.type) || "Memo";
+          case y: {
+            var x = o, b = x._payload, I = x._init;
+            try {
+              return q(I(b));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var V = Object.assign, re = 0, qe, Ve, We, Ue, Ye, Ke, Ge;
+    function Xe() {
+    }
+    Xe.__reactDisabledLog = !0;
+    function cr() {
+      {
+        if (re === 0) {
+          qe = console.log, Ve = console.info, We = console.warn, Ue = console.error, Ye = console.group, Ke = console.groupCollapsed, Ge = console.groupEnd;
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            value: Xe,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: o,
+            log: o,
+            warn: o,
+            error: o,
+            group: o,
+            groupCollapsed: o,
+            groupEnd: o
+          });
+        }
+        re++;
+      }
+    }
+    function dr() {
+      {
+        if (re--, re === 0) {
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: V({}, o, {
+              value: qe
+            }),
+            info: V({}, o, {
+              value: Ve
+            }),
+            warn: V({}, o, {
+              value: We
+            }),
+            error: V({}, o, {
+              value: Ue
+            }),
+            group: V({}, o, {
+              value: Ye
+            }),
+            groupCollapsed: V({}, o, {
+              value: Ke
+            }),
+            groupEnd: V({}, o, {
+              value: Ge
+            })
+          });
+        }
+        re < 0 && E("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var Te = A.ReactCurrentDispatcher, Ee;
+    function he(o, c, h) {
+      {
+        if (Ee === void 0)
+          try {
+            throw Error();
+          } catch (x) {
+            var g = x.stack.trim().match(/\n( *(at )?)/);
+            Ee = g && g[1] || "";
+          }
+        return `
+` + Ee + o;
+      }
+    }
+    var ke = !1, pe;
+    {
+      var fr = typeof WeakMap == "function" ? WeakMap : Map;
+      pe = new fr();
+    }
+    function Ze(o, c) {
+      if (!o || ke)
+        return "";
+      {
+        var h = pe.get(o);
+        if (h !== void 0)
+          return h;
+      }
+      var g;
+      ke = !0;
+      var x = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var b;
+      b = Te.current, Te.current = null, cr();
+      try {
+        if (c) {
+          var I = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(I.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(I, []);
+            } catch (J) {
+              g = J;
+            }
+            Reflect.construct(o, [], I);
+          } else {
+            try {
+              I.call();
+            } catch (J) {
+              g = J;
+            }
+            o.call(I.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (J) {
+            g = J;
+          }
+          o();
+        }
+      } catch (J) {
+        if (J && g && typeof J.stack == "string") {
+          for (var v = J.stack.split(`
+`), P = g.stack.split(`
+`), R = v.length - 1, O = P.length - 1; R >= 1 && O >= 0 && v[R] !== P[O]; )
+            O--;
+          for (; R >= 1 && O >= 0; R--, O--)
+            if (v[R] !== P[O]) {
+              if (R !== 1 || O !== 1)
+                do
+                  if (R--, O--, O < 0 || v[R] !== P[O]) {
+                    var H = `
+` + v[R].replace(" at new ", " at ");
+                    return o.displayName && H.includes("<anonymous>") && (H = H.replace("<anonymous>", o.displayName)), typeof o == "function" && pe.set(o, H), H;
+                  }
+                while (R >= 1 && O >= 0);
+              break;
+            }
+        }
+      } finally {
+        ke = !1, Te.current = b, dr(), Error.prepareStackTrace = x;
+      }
+      var X = o ? o.displayName || o.name : "", W = X ? he(X) : "";
+      return typeof o == "function" && pe.set(o, W), W;
+    }
+    function hr(o, c, h) {
+      return Ze(o, !1);
+    }
+    function pr(o) {
+      var c = o.prototype;
+      return !!(c && c.isReactComponent);
+    }
+    function me(o, c, h) {
+      if (o == null)
+        return "";
+      if (typeof o == "function")
+        return Ze(o, pr(o));
+      if (typeof o == "string")
+        return he(o);
+      switch (o) {
+        case f:
+          return he("Suspense");
+        case d:
+          return he("SuspenseList");
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case u:
+            return hr(o.render);
+          case p:
+            return me(o.type, c, h);
+          case y: {
+            var g = o, x = g._payload, b = g._init;
+            try {
+              return me(b(x), c, h);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var ne = Object.prototype.hasOwnProperty, Qe = {}, et = A.ReactDebugCurrentFrame;
+    function ge(o) {
+      if (o) {
+        var c = o._owner, h = me(o.type, o._source, c ? c.type : null);
+        et.setExtraStackFrame(h);
+      } else
+        et.setExtraStackFrame(null);
+    }
+    function mr(o, c, h, g, x) {
+      {
+        var b = Function.call.bind(ne);
+        for (var I in o)
+          if (b(o, I)) {
+            var v = void 0;
+            try {
+              if (typeof o[I] != "function") {
+                var P = Error((g || "React class") + ": " + h + " type `" + I + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof o[I] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw P.name = "Invariant Violation", P;
+              }
+              v = o[I](c, I, g, h, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (R) {
+              v = R;
+            }
+            v && !(v instanceof Error) && (ge(x), E("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", g || "React class", h, I, typeof v), ge(null)), v instanceof Error && !(v.message in Qe) && (Qe[v.message] = !0, ge(x), E("Failed %s type: %s", h, v.message), ge(null));
+          }
+      }
+    }
+    var gr = Array.isArray;
+    function Re(o) {
+      return gr(o);
+    }
+    function yr(o) {
+      {
+        var c = typeof Symbol == "function" && Symbol.toStringTag, h = c && o[Symbol.toStringTag] || o.constructor.name || "Object";
+        return h;
+      }
+    }
+    function vr(o) {
+      try {
+        return tt(o), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function tt(o) {
+      return "" + o;
+    }
+    function rt(o) {
+      if (vr(o))
+        return E("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", yr(o)), tt(o);
+    }
+    var nt = A.ReactCurrentOwner, Ir = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, it, st;
+    function wr(o) {
+      if (ne.call(o, "ref")) {
+        var c = Object.getOwnPropertyDescriptor(o, "ref").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return o.ref !== void 0;
+    }
+    function xr(o) {
+      if (ne.call(o, "key")) {
+        var c = Object.getOwnPropertyDescriptor(o, "key").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return o.key !== void 0;
+    }
+    function Sr(o, c) {
+      typeof o.ref == "string" && nt.current;
+    }
+    function br(o, c) {
+      {
+        var h = function() {
+          it || (it = !0, E("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", c));
+        };
+        h.isReactWarning = !0, Object.defineProperty(o, "key", {
+          get: h,
+          configurable: !0
+        });
+      }
+    }
+    function Tr(o, c) {
+      {
+        var h = function() {
+          st || (st = !0, E("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", c));
+        };
+        h.isReactWarning = !0, Object.defineProperty(o, "ref", {
+          get: h,
+          configurable: !0
+        });
+      }
+    }
+    var Er = function(o, c, h, g, x, b, I) {
+      var v = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: e,
+        // Built-in properties that belong on the element
+        type: o,
+        key: c,
+        ref: h,
+        props: I,
+        // Record the component responsible for creating this element.
+        _owner: b
+      };
+      return v._store = {}, Object.defineProperty(v._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(v, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: g
+      }), Object.defineProperty(v, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: x
+      }), Object.freeze && (Object.freeze(v.props), Object.freeze(v)), v;
+    };
+    function kr(o, c, h, g, x) {
+      {
+        var b, I = {}, v = null, P = null;
+        h !== void 0 && (rt(h), v = "" + h), xr(c) && (rt(c.key), v = "" + c.key), wr(c) && (P = c.ref, Sr(c, x));
+        for (b in c)
+          ne.call(c, b) && !Ir.hasOwnProperty(b) && (I[b] = c[b]);
+        if (o && o.defaultProps) {
+          var R = o.defaultProps;
+          for (b in R)
+            I[b] === void 0 && (I[b] = R[b]);
+        }
+        if (v || P) {
+          var O = typeof o == "function" ? o.displayName || o.name || "Unknown" : o;
+          v && br(I, O), P && Tr(I, O);
+        }
+        return Er(o, v, P, x, g, nt.current, I);
+      }
+    }
+    var Oe = A.ReactCurrentOwner, ot = A.ReactDebugCurrentFrame;
+    function G(o) {
+      if (o) {
+        var c = o._owner, h = me(o.type, o._source, c ? c.type : null);
+        ot.setExtraStackFrame(h);
+      } else
+        ot.setExtraStackFrame(null);
+    }
+    var Ne;
+    Ne = !1;
+    function Ae(o) {
+      return typeof o == "object" && o !== null && o.$$typeof === e;
+    }
+    function at() {
+      {
+        if (Oe.current) {
+          var o = q(Oe.current.type);
+          if (o)
+            return `
+
+Check the render method of \`` + o + "`.";
+        }
+        return "";
+      }
+    }
+    function Rr(o) {
+      return "";
+    }
+    var lt = {};
+    function Or(o) {
+      {
+        var c = at();
+        if (!c) {
+          var h = typeof o == "string" ? o : o.displayName || o.name;
+          h && (c = `
+
+Check the top-level render call using <` + h + ">.");
+        }
+        return c;
+      }
+    }
+    function ut(o, c) {
+      {
+        if (!o._store || o._store.validated || o.key != null)
+          return;
+        o._store.validated = !0;
+        var h = Or(c);
+        if (lt[h])
+          return;
+        lt[h] = !0;
+        var g = "";
+        o && o._owner && o._owner !== Oe.current && (g = " It was passed a child from " + q(o._owner.type) + "."), G(o), E('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', h, g), G(null);
+      }
+    }
+    function ct(o, c) {
+      {
+        if (typeof o != "object")
+          return;
+        if (Re(o))
+          for (var h = 0; h < o.length; h++) {
+            var g = o[h];
+            Ae(g) && ut(g, c);
+          }
+        else if (Ae(o))
+          o._store && (o._store.validated = !0);
+        else if (o) {
+          var x = C(o);
+          if (typeof x == "function" && x !== o.entries)
+            for (var b = x.call(o), I; !(I = b.next()).done; )
+              Ae(I.value) && ut(I.value, c);
+        }
+      }
+    }
+    function Nr(o) {
+      {
+        var c = o.type;
+        if (c == null || typeof c == "string")
+          return;
+        var h;
+        if (typeof c == "function")
+          h = c.propTypes;
+        else if (typeof c == "object" && (c.$$typeof === u || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        c.$$typeof === p))
+          h = c.propTypes;
+        else
+          return;
+        if (h) {
+          var g = q(c);
+          mr(h, o.props, "prop", g, o);
+        } else if (c.PropTypes !== void 0 && !Ne) {
+          Ne = !0;
+          var x = q(c);
+          E("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", x || "Unknown");
+        }
+        typeof c.getDefaultProps == "function" && !c.getDefaultProps.isReactClassApproved && E("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Ar(o) {
+      {
+        for (var c = Object.keys(o.props), h = 0; h < c.length; h++) {
+          var g = c[h];
+          if (g !== "children" && g !== "key") {
+            G(o), E("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", g), G(null);
+            break;
+          }
+        }
+        o.ref !== null && (G(o), E("Invalid attribute `ref` supplied to `React.Fragment`."), G(null));
+      }
+    }
+    var dt = {};
+    function ft(o, c, h, g, x, b) {
+      {
+        var I = lr(o);
+        if (!I) {
+          var v = "";
+          (o === void 0 || typeof o == "object" && o !== null && Object.keys(o).length === 0) && (v += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var P = Rr();
+          P ? v += P : v += at();
+          var R;
+          o === null ? R = "null" : Re(o) ? R = "array" : o !== void 0 && o.$$typeof === e ? (R = "<" + (q(o.type) || "Unknown") + " />", v = " Did you accidentally export a JSX literal instead of a component?") : R = typeof o, E("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", R, v);
+        }
+        var O = kr(o, c, h, x, b);
+        if (O == null)
+          return O;
+        if (I) {
+          var H = c.children;
+          if (H !== void 0)
+            if (g)
+              if (Re(H)) {
+                for (var X = 0; X < H.length; X++)
+                  ct(H[X], o);
+                Object.freeze && Object.freeze(H);
+              } else
+                E("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              ct(H, o);
+        }
+        if (ne.call(c, "key")) {
+          var W = q(o), J = Object.keys(c).filter(function(zr) {
+            return zr !== "key";
+          }), Ce = J.length > 0 ? "{key: someKey, " + J.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!dt[W + Ce]) {
+            var Dr = J.length > 0 ? "{" + J.join(": ..., ") + ": ...}" : "{}";
+            E(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, Ce, W, Dr, W), dt[W + Ce] = !0;
+          }
+        }
+        return o === r ? Ar(O) : Nr(O), O;
+      }
+    }
+    function Cr(o, c, h) {
+      return ft(o, c, h, !0);
+    }
+    function Lr(o, c, h) {
+      return ft(o, c, h, !1);
+    }
+    var Mr = Lr, Pr = Cr;
+    se.Fragment = r, se.jsx = Mr, se.jsxs = Pr;
+  })()), se;
+}
+var bt;
+function zn() {
+  return bt || (bt = 1, process.env.NODE_ENV === "production" ? Ie.exports = Pn() : Ie.exports = Dn()), Ie.exports;
+}
+var oe = zn();
+const _n = ({
+  images: n,
+  onAdd: e,
+  onDelete: t,
+  onImageClick: r,
+  focusedImageIndex: i
+}) => /* @__PURE__ */ oe.jsxs("div", { className: "batch-image-gallery", style: { display: "flex", gap: "8px", overflowX: "auto", padding: "8px" }, children: [
+  n.map((s, l) => /* @__PURE__ */ oe.jsxs(
+    "div",
+    {
+      style: {
+        position: "relative",
+        border: i === l ? "2px solid blue" : "2px solid transparent",
+        cursor: "pointer"
+      },
+      onClick: () => r(s),
+      children: [
+        /* @__PURE__ */ oe.jsx("img", { src: s.src, alt: s.alt, style: { width: "80px", height: "80px", objectFit: "cover" } }),
+        /* @__PURE__ */ oe.jsx(
+          "button",
+          {
+            onClick: (a) => {
+              a.stopPropagation(), t(l);
+            },
+            style: { position: "absolute", top: 0, right: 0 },
+            children: "×"
+          }
+        )
+      ]
+    },
+    s.id
+  )),
+  /* @__PURE__ */ oe.jsx("button", { onClick: e, style: { width: "80px", height: "80px" }, children: "+" })
+] });
+let ae = null;
+const ci = Zr.create({
+  name: "batchSegmentImages",
+  group: "block",
+  inline: !1,
+  atom: !0,
+  addOptions() {
+    return {
+      maxImageAmount: void 0,
+      height: void 0,
+      onAdd: void 0,
+      onRemove: void 0,
+      onImageClick: void 0,
+      initialImageRegistry: void 0
+    };
+  },
+  // Create a storage registry for this extension storage
+  addStorage() {
+    return {
+      imageRegistry: new Map(this.options.initialImageRegistry)
+    };
+  },
+  addAttributes() {
+    return {
+      batchId: {
+        default: null,
+        parseHTML: (n) => n.getAttribute("data-batch-id"),
+        renderHTML: (n) => ({ "data-batch-id": n.batchId })
+      },
+      id: {
+        default: null,
+        parseHTML: (n) => n.getAttribute("data-id"),
+        renderHTML: (n) => ({
+          "data-id": n.id
+        })
+      },
+      images: {
+        default: [],
+        parseHTML: (n) => {
+          const e = n.querySelectorAll("img"), t = [];
+          return e.forEach((r) => {
+            const i = r.getAttribute("data-id"), s = r.getAttribute("src"), l = r.getAttribute("alt"), a = r.getAttribute("title");
+            i && s && t.push({
+              id: i,
+              src: s,
+              alt: l ?? void 0,
+              title: a ?? void 0
+            });
+          }), t;
+        },
+        renderHTML: () => ({})
+      },
+      imageVersion: {
+        default: 0,
+        parseHTML: () => 0,
+        renderHTML: () => ({})
+      },
+      // Ephemeral UI state — not persisted in HTML
+      focusedImageIndex: {
+        default: null,
+        parseHTML: () => null,
+        renderHTML: () => ({})
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new de({
+        props: {
+          handleKeyDown(n, e) {
+            return e.key === "ArrowLeft" || e.key === "ArrowUp" ? ae = "left" : e.key === "ArrowRight" || e.key === "ArrowDown" ? ae = "right" : ae = null, !1;
+          }
+        }
+      })
+    ];
+  },
+  addKeyboardShortcuts() {
+    const n = (r, i) => {
+      const s = this.editor.state.tr.setNodeMarkup(r, void 0, { ...i.attrs, focusedImageIndex: null }).setMeta("addToHistory", !1);
+      s.setSelection(D.near(s.doc.resolve(r))), this.editor.view.dispatch(s);
+    }, e = (r, i) => {
+      const s = r + i.nodeSize, l = this.editor.state.tr.setNodeMarkup(r, void 0, { ...i.attrs, focusedImageIndex: null }).setMeta("addToHistory", !1);
+      l.setSelection(D.near(l.doc.resolve(s))), this.editor.view.dispatch(l);
+    }, t = (r) => {
+      var p, y;
+      const { selection: i } = this.editor.state;
+      if (!(i instanceof z)) return !1;
+      const s = i.node;
+      if (s.type.name !== "batchSegmentImages") return !1;
+      const l = ((y = (p = this.editor.storage.batchSegmentImages) == null ? void 0 : p.imageRegistry) == null ? void 0 : y.get(s.attrs.batchId)) ?? s.attrs.images;
+      if (!l.length) return !1;
+      const a = i.from, u = s.attrs.focusedImageIndex, f = !!this.options.onAdd;
+      let d;
+      if (r === "right") {
+        if (u === null)
+          return e(a, s), !0;
+        if (u < l.length - 1)
+          d = u + 1;
+        else if (u === l.length - 1 && f)
+          d = null;
+        else
+          return e(a, s), !0;
+      } else if (u === null)
+        d = l.length - 1;
+      else if (u > 0)
+        d = u - 1;
+      else
+        return n(a, s), !0;
+      if (this.editor.view.dispatch(
+        this.editor.state.tr.setNodeMarkup(a, void 0, { ...s.attrs, focusedImageIndex: d }).setMeta("addToHistory", !1)
+      ), d !== null && d >= 0 && d < l.length) {
+        const w = this.editor.view.nodeDOM(a);
+        w instanceof HTMLElement && requestAnimationFrame(() => {
+          var S;
+          (S = w.querySelectorAll("img")[d]) == null || S.scrollIntoView({ block: "nearest", inline: "nearest" });
+        });
+      }
+      return !0;
+    };
+    return {
+      ArrowLeft: () => t("left"),
+      ArrowRight: () => t("right"),
+      Space: () => {
+        var u, f, d, p, y, w;
+        const { selection: r } = this.editor.state;
+        if (!(r instanceof z)) return !1;
+        const i = r.node;
+        if (i.type.name !== "batchSegmentImages") return !1;
+        const s = ((f = (u = this.editor.storage.batchSegmentImages) == null ? void 0 : u.imageRegistry) == null ? void 0 : f.get(i.attrs.batchId)) ?? i.attrs.images, l = i.attrs.focusedImageIndex, a = r.from;
+        if (l === null)
+          return (p = (d = this.options).onAdd) == null || p.call(d, {
+            position: "last",
+            batchId: i.attrs.batchId,
+            currentImages: s,
+            getPos: () => a,
+            editor: this.editor
+          }), !0;
+        if (l >= 0 && l < s.length) {
+          const m = s[l];
+          return (w = (y = this.options).onImageClick) == null || w.call(y, {
+            imageId: m.id,
+            batchId: i.attrs.batchId,
+            src: m.src,
+            getPos: () => a,
+            editor: this.editor
+          }), !0;
+        }
+        return !1;
+      }
+    };
+  },
+  renderHTML({ node: n }) {
+    const e = n.attrs.images ?? [];
+    return [
+      "div",
+      {
+        "data-batch-id": n.attrs.batchId,
+        style: "display: flex; overflow-x: auto; gap: 10px; white-space: nowrap; padding: 10px 0;"
+      },
+      ...e.map(
+        (t) => [
+          "img",
+          {
+            "data-id": t.id,
+            src: t.src,
+            alt: t.alt ?? "",
+            title: t.title ?? "",
+            style: "width: 80px; height: 80px; object-fit: cover; flex-shrink: 0;"
+          }
+        ]
+      )
+    ];
+  },
+  addNodeView() {
+    return ({ node: n, getPos: e, editor: t }) => {
+      const r = this.options, i = this.storage, s = document.createElement("div");
+      s.style.width = "100%", s.classList.add("batch-segment-gallery"), i.imageRegistry.has(n.attrs.batchId) || i.imageRegistry.set(n.attrs.batchId, n.attrs.images ?? []);
+      const l = Mn.createRoot(s), a = { current: n };
+      let u = null;
+      const f = () => {
+        var m;
+        (m = r.onAdd) == null || m.call(r, {
+          position: "last",
+          batchId: a.current.attrs.batchId,
+          currentImages: i.imageRegistry.get(a.current.attrs.batchId) ?? [],
+          getPos: e,
+          editor: t
+        });
+      }, d = (m) => {
+        var S, C;
+        (C = r.onRemove) == null || C.call(r, {
+          index: m,
+          imageId: (S = (i.imageRegistry.get(a.current.attrs.batchId) ?? [])[m]) == null ? void 0 : S.id,
+          batchId: a.current.attrs.batchId,
+          getPos: e,
+          editor: t
+        });
+      }, p = (m) => {
+        var C;
+        const S = e();
+        if (S !== void 0) {
+          const A = (i.imageRegistry.get(a.current.attrs.batchId) ?? []).findIndex((E) => E.id === m.id);
+          t.view.dispatch(
+            t.state.tr.setNodeMarkup(S, void 0, {
+              ...a.current.attrs,
+              focusedImageIndex: A
+            }).setMeta("addToHistory", !1)
+          );
+        }
+        (C = r.onImageClick) == null || C.call(r, {
+          imageId: m.id,
+          batchId: a.current.attrs.batchId,
+          src: m.src,
+          getPos: e,
+          editor: t
+        });
+      }, y = () => {
+        const [m, S] = Le.useState({
+          images: i.imageRegistry.get(n.attrs.batchId) ?? [],
+          focusedImageIndex: n.attrs.focusedImageIndex,
+          batchId: n.attrs.batchId
+        });
+        return u = S, Le.createElement(_n, {
+          batchId: m.batchId,
+          images: m.images,
+          maxImageAmount: r.maxImageAmount,
+          height: r.height,
+          focusedImageIndex: m.focusedImageIndex,
+          onAdd: f,
+          onDelete: d,
+          onImageClick: p
+        });
+      };
+      l.render(Le.createElement(y));
+      let w = n;
+      return s.addEventListener("click", () => {
+        const m = e();
+        if (m !== void 0) {
+          const { state: S, view: C } = t, A = S.doc.nodeAt(m);
+          if (!A) return;
+          const E = S.tr.setNodeMarkup(m, void 0, { ...A.attrs, focusedImageIndex: null }).setMeta("addToHistory", !1);
+          C.dispatch(E.setSelection(z.create(E.doc, m)));
+        }
+      }), {
+        dom: s,
+        update: (m) => m.type !== n.type ? !1 : (m === w || (w = m, a.current = m, u == null || u({
+          images: i.imageRegistry.get(m.attrs.batchId) ?? [],
+          focusedImageIndex: m.attrs.focusedImageIndex,
+          batchId: m.attrs.batchId
+        })), !0),
+        // selectNode fires when node becomes selected (ArrowUp/Down/Left/Right from outside).
+        // Deferred via queueMicrotask — safe since selectNode is called during view.dispatch.
+        selectNode: () => {
+          const m = ae;
+          ae = null;
+          const S = e();
+          if (S === void 0) return;
+          const C = t.state.doc.nodeAt(S);
+          if (!C || C.attrs.focusedImageIndex !== null) return;
+          const A = m === "left" ? null : 0;
+          queueMicrotask(() => {
+            const E = e();
+            if (E === void 0) return;
+            const te = t.state.doc.nodeAt(E);
+            !te || te.attrs.focusedImageIndex !== null || t.state.selection instanceof z && t.view.dispatch(
+              t.state.tr.setNodeMarkup(E, void 0, { ...te.attrs, focusedImageIndex: A }).setMeta("addToHistory", !1)
+            );
+          });
+        },
+        deselectNode: () => {
+          const m = e();
+          if (m === void 0) return;
+          const S = t.state.doc.nodeAt(m);
+          !S || S.attrs.focusedImageIndex === null || t.view.dispatch(
+            t.state.tr.setNodeMarkup(m, void 0, { ...S.attrs, focusedImageIndex: null }).setMeta("addToHistory", !1)
+          );
+        },
+        destroy: () => {
+          i.imageRegistry.delete(n.attrs.batchId), queueMicrotask(() => l.unmount());
+        }
+      };
+    };
+  },
+  addCommands() {
+    return {
+      insertBatchImages: ({ batchId: n, images: e }) => (t) => (t.editor.storage.batchSegmentImages.imageRegistry.set(n, e), t.chain().insertContent({
+        type: "batchSegmentImages",
+        attrs: {
+          batchId: n,
+          images: e,
+          id: crypto.randomUUID()
+        }
+      }).run())
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-batch-id]"
+      }
+    ];
+  }
+});
+export {
+  ai as ALL_EXTENSIONS,
+  li as BASE_EXTENSIONS,
+  ci as BatchSegmentImagesExtension,
+  hi as Bold,
+  Mi as BulletList,
+  ns as CharacterCount,
+  mi as Color,
+  Rn as CustomBulletList,
+  Qt as CustomListItem,
+  On as CustomOrderedList,
+  en as CustomParagraph,
+  yi as Document,
+  er as DynamicBulletStyling,
+  Ii as FileHandler,
+  tr as FontSize,
+  xi as HardBreak,
+  bi as Heading,
+  Ei as Highlight,
+  is as History,
+  Ri as Image,
+  bn as IndentExtension,
+  Ni as Italic,
+  rr as LineHeight,
+  Ci as Link,
+  Cn as ListIndentIntegration,
+  Pi as ListItem,
+  Di as ListKeymap,
+  Hi as Mention,
+  ui as MentionStorage,
+  zi as OrderedList,
+  $i as Paragraph,
+  ss as Placeholder,
+  qi as Table,
+  Vi as TableCell,
+  Wi as TableHeader,
+  Ui as TableRow,
+  _i as TaskItem,
+  Ji as TaskList,
+  Ki as Text,
+  Xi as TextAlign,
+  Qi as TextStyle,
+  ts as Underline
+};