@sovann72-dev/lynqify-ui 1.0.0 → 1.0.2

package/dist/lynqify-ui.js

@@ -0,0 +1,3806 @@
+var Ur = Object.defineProperty;
+var qr = (n, e, t) => e in n ? Ur(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var b = (n, e, t) => qr(n, typeof e != "symbol" ? e + "" : e, t);
+import Nt from "@tiptap/extension-bold";
+import { default as Li } from "@tiptap/extension-bold";
+import Lt from "@tiptap/extension-color";
+import { default as zi } from "@tiptap/extension-color";
+import At from "@tiptap/extension-document";
+import { default as Pi } from "@tiptap/extension-document";
+import Kr from "@tiptap/extension-file-handler";
+import { default as _i } from "@tiptap/extension-file-handler";
+import zt from "@tiptap/extension-hard-break";
+import { default as Bi } from "@tiptap/extension-hard-break";
+import Yr from "@tiptap/extension-heading";
+import { default as Ji } from "@tiptap/extension-heading";
+import Xr from "@tiptap/extension-highlight";
+import { default as Hi } from "@tiptap/extension-highlight";
+import Gr from "@tiptap/extension-image";
+import { default as ji } from "@tiptap/extension-image";
+import Mt from "@tiptap/extension-italic";
+import { default as qi } from "@tiptap/extension-italic";
+import Zr from "@tiptap/extension-link";
+import { default as Yi } from "@tiptap/extension-link";
+import { BulletList as Pt, ListItem as Dt, OrderedList as _t, TaskItem as $t, ListKeymap as Qr, TaskList as en } from "@tiptap/extension-list";
+import { BulletList as Gi, ListItem as Zi, ListKeymap as Qi, OrderedList as es, TaskItem as ts, TaskList as rs } from "@tiptap/extension-list";
+import tn from "@tiptap/extension-mention";
+import { default as is } from "@tiptap/extension-mention";
+import Bt from "@tiptap/extension-paragraph";
+import { default as os } from "@tiptap/extension-paragraph";
+import { Table as rn, TableCell as nn, TableHeader as sn, TableRow as on } from "@tiptap/extension-table";
+import { Table as ls, TableCell as cs, TableHeader as ds, TableRow as us } from "@tiptap/extension-table";
+import Ft from "@tiptap/extension-text";
+import { default as hs } from "@tiptap/extension-text";
+import Jt from "@tiptap/extension-text-align";
+import { default as ms } from "@tiptap/extension-text-align";
+import { TextStyle as Wt } from "@tiptap/extension-text-style";
+import { TextStyle as ys } from "@tiptap/extension-text-style";
+import Ht from "@tiptap/extension-underline";
+import { default as ws } from "@tiptap/extension-underline";
+import { UndoRedo as Vt, CharacterCount as an, Placeholder as ln } from "@tiptap/extensions";
+import { CharacterCount as Is, UndoRedo as Ss, Placeholder as Es } from "@tiptap/extensions";
+import { Extension as ge, Node as cn } from "@tiptap/core";
+import { Extension as dn } from "@tiptap/react";
+import { Editor as Ts, EditorContent as Rs, useEditor as Cs } from "@tiptap/react";
+import * as De from "react";
+import jt from "react";
+import un from "react-dom";
+function Ut(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 = Ut(i.content, s.content, t + 1);
+      if (l != null)
+        return l;
+    }
+    t += i.nodeSize;
+  }
+}
+function qt(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), c = l.nodeSize;
+    if (l == a) {
+      t -= c, r -= c;
+      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 = qt(l.content, a.content, t - 1, r - 1);
+      if (f)
+        return f;
+    }
+    t -= c, r -= c;
+  }
+}
+class C {
+  /**
+  @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 c = this.content[l], f = a + c.nodeSize;
+      if (f > e && r(c, i + a, s || null, l) !== !1 && c.content.size) {
+        let d = a + 1;
+        c.nodesBetween(Math.max(0, e - d), Math.min(c.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, c) => {
+      let f = a.isText ? a.text.slice(Math.max(e, c) - c, t - c) : 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 C(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], c = l + a.nodeSize;
+        c > e && ((l < e || c > 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 = c;
+      }
+    return new C(r, i);
+  }
+  /**
+  @internal
+  */
+  cutByIndex(e, t) {
+    return e == t ? C.empty : e == 0 && t == this.content.length ? this : new C(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 C(i, s);
+  }
+  /**
+  Create a new fragment by prepending the given node to this
+  fragment.
+  */
+  addToStart(e) {
+    return new C([e].concat(this.content), this.size + e.nodeSize);
+  }
+  /**
+  Create a new fragment by appending the given node to this
+  fragment.
+  */
+  addToEnd(e) {
+    return new C(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 Ut(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 qt(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 Ie(0, e);
+    if (e == this.size)
+      return Ie(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 ? Ie(t + 1, s) : Ie(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 C.empty;
+    if (!Array.isArray(t))
+      throw new RangeError("Invalid input for Fragment.fromJSON");
+    return new C(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 C.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 C(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 C.empty;
+    if (e instanceof C)
+      return e;
+    if (Array.isArray(e))
+      return this.fromArray(e);
+    if (e.attrs)
+      return new C([e], e.nodeSize);
+    throw new RangeError("Can not convert " + e + " to a Fragment" + (e.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
+  }
+}
+C.empty = new C([], 0);
+const _e = { index: 0, offset: 0 };
+function Ie(n, e) {
+  return _e.index = n, _e.offset = e, _e;
+}
+class fn 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 = Yt(this.content, e + this.openStart, t);
+    return r && new T(r, this.openStart, this.openEnd);
+  }
+  /**
+  @internal
+  */
+  removeBetween(e, t) {
+    return new T(Kt(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(C.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(C.empty, 0, 0);
+function Kt(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(Kt(s.content, e - i - 1, t - i - 1)));
+}
+function Yt(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 = Yt(l.content, e - s - 1, t, l);
+  return a && n.replaceChild(i, l.copy(a));
+}
+class Xt {
+  /**
+  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 Gt = 65535, Zt = Math.pow(2, 16);
+function hn(n, e) {
+  return n + e * Zt;
+}
+function wt(n) {
+  return n & Gt;
+}
+function pn(n) {
+  return (n - (n & Gt)) / Zt;
+}
+const Qt = 1, er = 2, be = 4, tr = 8;
+class xt {
+  /**
+  @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 & tr) > 0;
+  }
+  /**
+  Tells you whether the token before the mapped position was deleted.
+  */
+  get deletedBefore() {
+    return (this.delInfo & (Qt | be)) > 0;
+  }
+  /**
+  True when the token after the mapped position was deleted.
+  */
+  get deletedAfter() {
+    return (this.delInfo & (er | be)) > 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 & be) > 0;
+  }
+}
+class J {
+  /**
+  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 && J.empty)
+      return J.empty;
+  }
+  /**
+  @internal
+  */
+  recover(e) {
+    let t = 0, r = wt(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 + pn(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 c = this.ranges[a] - (this.inverted ? i : 0);
+      if (c > e)
+        break;
+      let f = this.ranges[a + s], d = this.ranges[a + l], h = c + f;
+      if (e <= h) {
+        let g = f ? e == c ? -1 : e == h ? 1 : t : t, v = c + i + (g < 0 ? 0 : d);
+        if (r)
+          return v;
+        let m = e == (t < 0 ? c : h) ? null : hn(a / 3, e - c), I = e == c ? er : e == h ? Qt : be;
+        return (t < 0 ? e != c : e != h) && (I |= tr), new xt(v, I, m);
+      }
+      i += d - f;
+    }
+    return r ? e + i : new xt(e + i, 0, null);
+  }
+  /**
+  @internal
+  */
+  touches(e, t) {
+    let r = 0, i = wt(t), s = this.inverted ? 2 : 1, l = this.inverted ? 1 : 2;
+    for (let a = 0; a < this.ranges.length; a += 3) {
+      let c = this.ranges[a] - (this.inverted ? r : 0);
+      if (c > e)
+        break;
+      let f = this.ranges[a + s], d = c + 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), c = l + (this.inverted ? 0 : s), f = this.ranges[i + t], d = this.ranges[i + r];
+      e(a, a + f, c, c + 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 J(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 ? J.empty : new J(e < 0 ? [0, -e, 0] : [0, 0, e]);
+  }
+}
+J.empty = new J([]);
+const $e = /* @__PURE__ */ Object.create(null);
+class D {
+  /**
+  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 J.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 = $e[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 $e)
+      throw new RangeError("Duplicate use of step JSON ID " + e);
+    return $e[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 fn)
+        return N.fail(s.message);
+      throw s;
+    }
+  }
+}
+function Ue(n, e, t) {
+  let r = [];
+  for (let i = 0; i < n.childCount; i++) {
+    let s = n.child(i);
+    s.content.size && (s = s.copy(Ue(s.content, e, s))), s.isInline && (s = e(s, t, i)), r.push(s);
+  }
+  return C.fromArray(r);
+}
+class Y extends D {
+  /**
+  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(Ue(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 X(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: "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 Y(t.from, t.to, e.markFromJSON(t.mark));
+  }
+}
+D.jsonID("addMark", Y);
+class X extends D {
+  /**
+  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(Ue(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 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 X(t.pos, r.pos, this.mark);
+  }
+  merge(e) {
+    return e instanceof X && e.mark.eq(this.mark) && this.from <= e.to && this.to >= e.from ? new X(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 X(t.from, t.to, e.markFromJSON(t.mark));
+  }
+}
+D.jsonID("removeMark", X);
+class G extends D {
+  /**
+  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(C.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 G(this.pos, t.marks[i]);
+        return new G(this.pos, this.mark);
+      }
+    }
+    return new pe(this.pos, this.mark);
+  }
+  map(e) {
+    let t = e.mapResult(this.pos, 1);
+    return t.deletedAfter ? null : new G(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 G(t.pos, e.markFromJSON(t.mark));
+  }
+}
+D.jsonID("addNodeMark", G);
+class pe extends D {
+  /**
+  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(C.from(r), 0, t.isLeaf ? 0 : 1));
+  }
+  invert(e) {
+    let t = e.nodeAt(this.pos);
+    return !t || !this.mark.isInSet(t.marks) ? this : new G(this.pos, this.mark);
+  }
+  map(e) {
+    let t = e.mapResult(this.pos, 1);
+    return t.deletedAfter ? null : new pe(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 pe(t.pos, e.markFromJSON(t.mark));
+  }
+}
+D.jsonID("removeNodeMark", pe);
+class H extends D {
+  /**
+  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 && Ve(e, this.from, this.to) ? N.fail("Structure replace would overwrite content") : N.fromReplace(e, this.from, this.to, this.slice);
+  }
+  getMap() {
+    return new J([this.from, this.to - this.from, this.slice.size]);
+  }
+  invert(e) {
+    return new H(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 && H.MAP_BIAS < 0 ? t : e.mapResult(this.from, 1);
+    return r.deletedAcross && t.deletedAcross ? null : new H(r.pos, Math.max(r.pos, t.pos), this.slice, this.structure);
+  }
+  merge(e) {
+    if (!(e instanceof H) || 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 H(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 H(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 H(t.from, t.to, T.fromJSON(e, t.slice), !!t.structure);
+  }
+}
+H.MAP_BIAS = 1;
+D.jsonID("replace", H);
+class ie extends D {
+  /**
+  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 && (Ve(e, this.from, this.gapFrom) || Ve(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 J([
+      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 ie(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 ie(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 ie(t.from, t.to, t.gapFrom, t.gapTo, T.fromJSON(e, t.slice), t.insert, !!t.structure);
+  }
+}
+D.jsonID("replaceAround", ie);
+function Ve(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 mn(n, e, t) {
+  return (e == 0 || n.canReplace(e, n.childCount)) && (t == n.childCount || n.canReplace(0, t));
+}
+function rr(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, c = n.$to.indexAfter(r) - s;
+    if (r < n.depth && l.canReplace(a, c, t))
+      return r;
+    if (r == 0 || l.type.spec.isolating || !mn(l, a, c))
+      break;
+    a && (i = 1), c < l.childCount && (s = 1);
+  }
+  return null;
+}
+class he extends D {
+  /**
+  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(C.from(i), 0, t.isLeaf ? 0 : 1));
+  }
+  getMap() {
+    return J.empty;
+  }
+  invert(e) {
+    return new he(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 he(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 he(t.pos, t.attr, t.value);
+  }
+}
+D.jsonID("attr", he);
+class Te extends D {
+  /**
+  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 J.empty;
+  }
+  invert(e) {
+    return new Te(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 Te(t.attr, t.value);
+  }
+}
+D.jsonID("docAttr", Te);
+let me = class extends Error {
+};
+me = function n(e) {
+  let t = Error.call(this, e);
+  return t.__proto__ = n.prototype, t;
+};
+me.prototype = Object.create(Error.prototype);
+me.prototype.constructor = me;
+me.prototype.name = "TransformError";
+const Be = /* @__PURE__ */ Object.create(null);
+class z {
+  /**
+  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 gn(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: c, $to: f } = l[a], d = e.mapping.slice(s);
+      e.replaceRange(d.map(c.pos), d.map(f.pos), a ? T.empty : t), a == 0 && Et(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], c = e.mapping.slice(r), f = c.map(l.pos), d = c.map(a.pos);
+      s ? e.deleteRange(f, d) : (e.replaceRangeWith(f, d, t), Et(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 $(e) : re(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 ? re(e.node(0), e.node(s), e.before(s + 1), e.index(s), t, r) : re(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 re(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 re(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 = Be[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 Be)
+      throw new RangeError("Duplicate use of selection JSON ID " + e);
+    return Be[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 $.between(this.$anchor, this.$head).getBookmark();
+  }
+}
+z.prototype.visible = !0;
+class gn {
+  /**
+  Create a range.
+  */
+  constructor(e, t) {
+    this.$from = e, this.$to = t;
+  }
+}
+let It = !1;
+function St(n) {
+  !It && !n.parent.inlineContent && (It = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + n.parent.type.name + ")"));
+}
+class $ extends z {
+  /**
+  Construct a text selection between the given points.
+  */
+  constructor(e, t = e) {
+    St(e), St(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 z.near(r);
+    let i = e.resolve(t.map(this.anchor));
+    return new $(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 $ && e.anchor == this.anchor && e.head == this.head;
+  }
+  getBookmark() {
+    return new Re(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 $(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 = z.findFrom(t, r, !0) || z.findFrom(t, -r, !0);
+      if (s)
+        t = s.$head;
+      else
+        return z.near(t, r);
+    }
+    return e.parent.inlineContent || (i == 0 ? e = t : (e = (z.findFrom(e, -r, !0) || z.findFrom(e, r, !0)).$anchor, e.pos < t.pos != i < 0 && (e = t))), new $(e, t);
+  }
+}
+z.jsonID("text", $);
+class Re {
+  constructor(e, t) {
+    this.anchor = e, this.head = t;
+  }
+  map(e) {
+    return new Re(e.map(this.anchor), e.map(this.head));
+  }
+  resolve(e) {
+    return $.between(e.resolve(this.anchor), e.resolve(this.head));
+  }
+}
+class P extends z {
+  /**
+  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 ? z.near(s) : new P(s);
+  }
+  content() {
+    return new T(C.from(this.node), 0, 0);
+  }
+  eq(e) {
+    return e instanceof P && e.anchor == this.anchor;
+  }
+  toJSON() {
+    return { type: "node", anchor: this.anchor };
+  }
+  getBookmark() {
+    return new qe(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON");
+    return new P(e.resolve(t.anchor));
+  }
+  /**
+  Create a node selection from non-resolved positions.
+  */
+  static create(e, t) {
+    return new P(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;
+  }
+}
+P.prototype.visible = !1;
+z.jsonID("node", P);
+class qe {
+  constructor(e) {
+    this.anchor = e;
+  }
+  map(e) {
+    let { deleted: t, pos: r } = e.mapResult(this.anchor);
+    return t ? new Re(r, r) : new qe(r);
+  }
+  resolve(e) {
+    let t = e.resolve(this.anchor), r = t.nodeAfter;
+    return r && P.isSelectable(r) ? new P(t) : z.near(t);
+  }
+}
+class j extends z {
+  /**
+  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 = z.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 yn;
+  }
+}
+z.jsonID("all", j);
+const yn = {
+  map() {
+    return this;
+  },
+  resolve(n) {
+    return new j(n);
+  }
+};
+function re(n, e, t, r, i, s = !1) {
+  if (e.inlineContent)
+    return $.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 && P.isSelectable(a))
+        return P.create(n, t - (i < 0 ? a.nodeSize : 0));
+    } else {
+      let c = re(n, a, t + i, i < 0 ? a.childCount : 0, i, s);
+      if (c)
+        return c;
+    }
+    t += a.nodeSize * i;
+  }
+  return null;
+}
+function Et(n, e, t) {
+  let r = n.steps.length - 1;
+  if (r < e)
+    return;
+  let i = n.steps[r];
+  if (!(i instanceof H || i instanceof ie))
+    return;
+  let s = n.mapping.maps[r], l;
+  s.forEach((a, c, f, d) => {
+    l == null && (l = d);
+  }), n.setSelection(z.near(n.doc.resolve(l), t));
+}
+function bt(n, e) {
+  return !e || !n ? n : n.bind(e);
+}
+class Se {
+  constructor(e, t, r) {
+    this.name = e, this.init = bt(t.init, r), this.apply = bt(t.apply, r);
+  }
+}
+new Se("doc", {
+  init(n) {
+    return n.doc || n.schema.topNodeType.createAndFill();
+  },
+  apply(n) {
+    return n.doc;
+  }
+}), new Se("selection", {
+  init(n, e) {
+    return n.selection || z.atStart(e.doc);
+  },
+  apply(n) {
+    return n.selection;
+  }
+}), new Se("storedMarks", {
+  init(n) {
+    return n.storedMarks || null;
+  },
+  apply(n, e, t, r) {
+    return r.selection.$cursor ? n.storedMarks : null;
+  }
+}), new Se("scrollToSelection", {
+  init() {
+    return 0;
+  },
+  apply(n, e) {
+    return n.scrolledIntoView ? e + 1 : e;
+  }
+});
+function nr(n, e, t) {
+  for (let r in n) {
+    let i = n[r];
+    i instanceof Function ? i = i.bind(e) : r == "handleDOMEvents" && (i = nr(i, e, {})), t[r] = i;
+  }
+  return t;
+}
+class se {
+  /**
+  Create a plugin.
+  */
+  constructor(e) {
+    this.spec = e, this.props = {}, e.props && nr(e.props, this, this.props), this.key = e.key ? e.key.key : ir("plugin");
+  }
+  /**
+  Extract the plugin's state field from an editor state.
+  */
+  getState(e) {
+    return e[this.key];
+  }
+}
+const Fe = /* @__PURE__ */ Object.create(null);
+function ir(n) {
+  return n in Fe ? n + "$" + ++Fe[n] : (Fe[n] = 0, n + "$");
+}
+class vn {
+  /**
+  Create a plugin key.
+  */
+  constructor(e = "key") {
+    this.key = ir(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 sr = Zr.extend({
+  addAttributes() {
+    var n;
+    return {
+      ...(n = this.parent) == null ? void 0 : n.call(this),
+      "data-note-file-id": {
+        default: null,
+        parseHTML: (e) => e.getAttribute("data-note-file-id"),
+        renderHTML: (e) => e["data-note-file-id"] ? { "data-note-file-id": e["data-note-file-id"] } : {}
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new se({
+        appendTransaction(n, e, t) {
+          if (!n.some((h) => h.docChanged)) return null;
+          const { selection: r } = t;
+          if (!r.empty) return null;
+          const { $from: i } = r;
+          if (i.parent.type.name !== "paragraph" || i.parent.content.size !== 0) return null;
+          const s = i.before(i.depth), l = e.selection.$from;
+          if (l.depth < 1) return null;
+          const a = l.before(l.depth);
+          if (s !== a) return null;
+          const c = e.doc.nodeAt(s);
+          if (!c || c.type.name !== "paragraph") return null;
+          let f = !1;
+          if (c.forEach((h) => {
+            h.marks.some((g) => g.type.name === "link") && (f = !0);
+          }), !f) return null;
+          const d = t.tr;
+          try {
+            d.join(s);
+          } catch {
+          }
+          return d.setStoredMarks([]);
+        }
+      })
+    ];
+  }
+}), wn = Bt.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};`
+        } : {}
+      }
+    };
+  }
+}), M = {
+  MOBILE_BREAKPOINT: 768,
+  ICON_SIZE: "24px",
+  CONTROLLER_HEIGHT: "25px",
+  DOT_SIZE: {
+    MOBILE: 16,
+    DESKTOP: 9
+  },
+  DOT_POSITION: {
+    MOBILE: "-8px",
+    DESKTOP: "-4px"
+  },
+  COLORS: {
+    BORDER: "#6C6C6C",
+    BACKGROUND: "rgba(255, 255, 255, 1)"
+  },
+  ICONS: {
+    LEFT: "https://fonts.gstatic.com/s/i/short-term/release/materialsymbolsoutlined/format_align_left/default/20px.svg",
+    CENTER: "https://fonts.gstatic.com/s/i/short-term/release/materialsymbolsoutlined/format_align_center/default/20px.svg",
+    RIGHT: "https://fonts.gstatic.com/s/i/short-term/release/materialsymbolsoutlined/format_align_right/default/20px.svg"
+  }
+}, Z = {
+  isMobile() {
+    return document.documentElement.clientWidth < M.MOBILE_BREAKPOINT;
+  },
+  getDotPosition() {
+    return Z.isMobile() ? M.DOT_POSITION.MOBILE : M.DOT_POSITION.DESKTOP;
+  },
+  getDotSize() {
+    return Z.isMobile() ? M.DOT_SIZE.MOBILE : M.DOT_SIZE.DESKTOP;
+  },
+  clearContainerBorder(n) {
+    const e = n.getAttribute("style"), t = e == null ? void 0 : e.replace("border: 1px dashed #6C6C6C;", "").replace("border: 1px dashed rgb(108, 108, 108)", "");
+    n.setAttribute("style", t);
+  },
+  removeResizeElements(n) {
+    if (n.childElementCount > 3)
+      for (let e = 0; e < 5; e++)
+        n.removeChild(n.lastChild);
+  }
+};
+class Je {
+  static parseImageAttributes(e, t) {
+    Object.entries(e).forEach(([r, i]) => {
+      if (!(i == null || r === "wrapperStyle")) {
+        if (r === "containerStyle") {
+          const s = i.match(/width:\s*([0-9.]+)px/);
+          s && t.setAttribute("width", s[1]);
+          return;
+        }
+        t.setAttribute(r, i);
+      }
+    });
+  }
+  static extractWidthFromStyle(e) {
+    const t = e.match(/width:\s*([0-9.]+)px/);
+    return t ? (t == null ? void 0 : t.at(1)) ?? null : null;
+  }
+}
+function je(n, e) {
+  const { minWidth: t, maxWidth: r } = e, i = t !== void 0 ? Math.max(0, t) : 0;
+  let s = Math.max(i, n);
+  return r !== void 0 && s > r && (s = r), s;
+}
+class ne {
+  static getContainerStyle(e, t) {
+    return `${`width: ${t && t !== "0px" && t !== "0" ? t : "100%"}; height: auto; cursor: pointer;`} ${e ? "display: inline-block;" : ""}`;
+  }
+  static getWrapperStyle(e) {
+    return e ? "display: inline-block; float: left; padding-right: 8px;" : "display: flex";
+  }
+  static getPositionControllerStyle(e) {
+    return `
+      position: absolute; 
+      top: 0%; 
+      left: 50%; 
+      width: ${e ? "66px" : "100px"}; 
+      height: ${M.CONTROLLER_HEIGHT}; 
+      z-index: 999; 
+      background-color: ${M.COLORS.BACKGROUND}; 
+      border-radius: 3px; 
+      border: 1px solid ${M.COLORS.BORDER}; 
+      cursor: pointer; 
+      transform: translate(-50%, -50%); 
+      justify-content: space-between; 
+      align-items: center; 
+      padding: 0 6px;
+      display: none;
+      `.replace(/\s+/g, " ").trim();
+  }
+  static getDotStyle(e) {
+    const t = Z.getDotPosition(), r = Z.getDotSize(), i = [
+      `top: ${t}; left: ${t}; cursor: nwse-resize;`,
+      `top: ${t}; right: ${t}; cursor: nesw-resize;`,
+      `bottom: ${t}; left: ${t}; cursor: nesw-resize;`,
+      `bottom: ${t}; right: ${t}; cursor: nwse-resize;`
+    ];
+    return `
+      position: absolute; 
+      width: ${r}px; 
+      height: ${r}px; 
+      border: 1.5px solid ${M.COLORS.BORDER}; 
+      border-radius: 50%; 
+      ${i[e]}
+    `.replace(/\s+/g, " ").trim();
+  }
+}
+class xn {
+  constructor(e, t, r) {
+    b(this, "elements");
+    b(this, "inline");
+    b(this, "dispatchNodeView");
+    this.elements = e, this.inline = t, this.dispatchNodeView = r;
+  }
+  createControllerIcon(e) {
+    const t = document.createElement("img");
+    return t.setAttribute("src", e), t.setAttribute(
+      "style",
+      `width: ${M.ICON_SIZE}; height: ${M.ICON_SIZE}; cursor: pointer;`
+    ), t.addEventListener("mouseover", (r) => {
+      r.target.style.opacity = "0.6";
+    }), t.addEventListener("mouseout", (r) => {
+      r.target.style.opacity = "1";
+    }), t;
+  }
+  handleLeftClick() {
+    if (!this.inline)
+      this.elements.container.setAttribute(
+        "style",
+        `${this.elements.container.style.cssText} margin: 0 auto 0 0;`
+      );
+    else {
+      const e = "display: inline-block; float: left; padding-right: 8px;";
+      this.elements.wrapper.setAttribute("style", e), this.elements.container.setAttribute("style", e);
+    }
+    this.dispatchNodeView();
+  }
+  handleCenterClick() {
+    this.elements.container.setAttribute(
+      "style",
+      `${this.elements.container.style.cssText} margin: 0 auto;`
+    ), this.dispatchNodeView();
+  }
+  handleRightClick() {
+    if (!this.inline)
+      this.elements.container.setAttribute(
+        "style",
+        `${this.elements.container.style.cssText} margin: 0 0 0 auto;`
+      );
+    else {
+      const e = "display: inline-block; float: right; padding-left: 8px;";
+      this.elements.wrapper.setAttribute("style", e), this.elements.container.setAttribute("style", e);
+    }
+    this.dispatchNodeView();
+  }
+  createPositionControls() {
+    const e = document.createElement("div");
+    e.setAttribute("style", ne.getPositionControllerStyle(this.inline));
+    const t = this.createControllerIcon(M.ICONS.LEFT);
+    if (t.addEventListener("click", () => this.handleLeftClick()), e.appendChild(t), !this.inline) {
+      const i = this.createControllerIcon(M.ICONS.CENTER);
+      i.addEventListener("click", () => this.handleCenterClick()), e.appendChild(i);
+    }
+    const r = this.createControllerIcon(M.ICONS.RIGHT);
+    return r.addEventListener("click", () => this.handleRightClick()), e.appendChild(r), this.elements.container.appendChild(e), this;
+  }
+}
+class In {
+  constructor(e, t, r = () => ({})) {
+    b(this, "elements");
+    b(this, "dispatchNodeView");
+    b(this, "getResizeLimits");
+    b(this, "state", {
+      isResizing: !1,
+      startX: 0,
+      startWidth: 0
+    });
+    b(this, "handleMouseMove", (e, t) => {
+      if (!this.state.isResizing) return;
+      const r = t % 2 === 0 ? -(e.clientX - this.state.startX) : e.clientX - this.state.startX, i = je(this.state.startWidth + r, this.getResizeLimits());
+      this.elements.container.style.width = i + "px", this.elements.img.style.width = i + "px";
+    });
+    b(this, "handleMouseUp", () => {
+      this.state.isResizing && (this.state.isResizing = !1), this.dispatchNodeView();
+    });
+    b(this, "handleTouchMove", (e, t) => {
+      if (!this.state.isResizing) return;
+      const r = t % 2 === 0 ? -(e.touches[0].clientX - this.state.startX) : e.touches[0].clientX - this.state.startX, i = je(this.state.startWidth + r, this.getResizeLimits());
+      this.elements.container.style.width = i + "px", this.elements.img.style.width = i + "px";
+    });
+    b(this, "handleTouchEnd", () => {
+      this.state.isResizing && (this.state.isResizing = !1), this.dispatchNodeView();
+    });
+    this.elements = e, this.dispatchNodeView = t, this.getResizeLimits = r;
+  }
+  createResizeHandle(e) {
+    const t = document.createElement("div");
+    return t.setAttribute("style", ne.getDotStyle(e)), t.addEventListener("mousedown", (r) => {
+      r.preventDefault(), this.state.isResizing = !0, this.state.startX = r.clientX, this.state.startWidth = this.elements.container.offsetWidth;
+      const i = (l) => this.handleMouseMove(l, e), s = () => {
+        this.handleMouseUp(), document.removeEventListener("mousemove", i), document.removeEventListener("mouseup", s);
+      };
+      document.addEventListener("mousemove", i), document.addEventListener("mouseup", s);
+    }), t.addEventListener(
+      "touchstart",
+      (r) => {
+        r.cancelable && r.preventDefault(), this.state.isResizing = !0, this.state.startX = r.touches[0].clientX, this.state.startWidth = this.elements.container.offsetWidth;
+        const i = (l) => this.handleTouchMove(l, e), s = () => {
+          this.handleTouchEnd(), document.removeEventListener("touchmove", i), document.removeEventListener("touchend", s);
+        };
+        document.addEventListener("touchmove", i), document.addEventListener("touchend", s);
+      },
+      { passive: !1 }
+    ), t;
+  }
+}
+class Sn {
+  constructor(e = {}) {
+    b(this, "limits");
+    this.limits = e;
+  }
+  update(e) {
+    this.limits = { ...this.limits, ...e };
+  }
+  get() {
+    return this.limits;
+  }
+}
+class En {
+  constructor(e, t, r = {}, i) {
+    b(this, "context");
+    b(this, "elements");
+    b(this, "inline");
+    b(this, "resizeLimitsRef");
+    b(this, "resizeEventName");
+    b(this, "handleResizeEvent");
+    b(this, "clearContainerBorder", () => {
+      Z.clearContainerBorder(this.elements.container);
+    });
+    b(this, "dispatchNodeView", () => {
+      const { view: e, getPos: t } = this.context;
+      if (typeof t == "function") {
+        this.clearContainerBorder();
+        const r = {
+          ...this.context.node.attrs,
+          width: Je.extractWidthFromStyle(this.elements.container.style.cssText) ?? this.context.node.attrs.width,
+          containerStyle: `${this.elements.container.style.cssText}`,
+          wrapperStyle: `${this.elements.wrapper.style.cssText}`
+        };
+        e.dispatch(e.state.tr.setNodeMarkup(t(), null, r));
+      }
+    });
+    b(this, "removeResizeElements", () => {
+      Z.removeResizeElements(this.elements.container);
+    });
+    this.context = e, this.inline = t, this.resizeLimitsRef = new Sn(r), this.resizeEventName = i, this.elements = this.createElements(), i && (this.handleResizeEvent = ((s) => {
+      const l = s;
+      l.detail && this.updateResizeLimits({ maxWidth: l.detail.maxWidth });
+    }), window.addEventListener(i, this.handleResizeEvent));
+  }
+  destroy() {
+    this.resizeEventName && this.handleResizeEvent && window.removeEventListener(this.resizeEventName, this.handleResizeEvent);
+  }
+  updateResizeLimits(e) {
+    this.resizeLimitsRef.update(e);
+  }
+  createElements() {
+    return {
+      wrapper: document.createElement("div"),
+      container: document.createElement("div"),
+      img: document.createElement("img")
+    };
+  }
+  setupImageAttributes() {
+    Je.parseImageAttributes(this.context.node.attrs, this.elements.img);
+  }
+  setupDOMStructure() {
+    const { wrapperStyle: e, containerStyle: t } = this.context.node.attrs;
+    this.elements.wrapper.setAttribute("style", e), this.elements.wrapper.appendChild(this.elements.container), this.elements.container.setAttribute("style", t), this.elements.container.appendChild(this.elements.img);
+  }
+  /**
+   * Applies min/max width limits to the container and image.
+   * Enforces configured limits on initial render and when container style is re-applied.
+   */
+  applyResizeLimits() {
+    const e = this.resizeLimitsRef.get();
+    let t = Je.extractWidthFromStyle(this.elements.container.style.cssText);
+    if (t === null) {
+      const l = e.maxWidth;
+      if (!l) return;
+      t = l.toString();
+    }
+    const r = Number(t);
+    if (Number.isNaN(r)) return;
+    const i = je(r, e), s = `${i}px`;
+    this.elements.container.style.width = s, this.elements.img.style.width = s, this.elements.img.setAttribute("width", String(i));
+  }
+  createPositionController() {
+    new xn(
+      this.elements,
+      this.inline,
+      this.dispatchNodeView
+    ).createPositionControls();
+  }
+  createResizeHandler() {
+    const e = new In(
+      this.elements,
+      this.dispatchNodeView,
+      // eslint-disable-next-line prettier/prettier
+      () => this.resizeLimitsRef.get()
+    );
+    Array.from({ length: 4 }, (t, r) => {
+      const i = e.createResizeHandle(r);
+      this.elements.container.appendChild(i);
+    });
+  }
+  setupContainerClick() {
+    this.elements.container.addEventListener("click", () => {
+      var t;
+      Z.isMobile() && ((t = document.querySelector(".ProseMirror-focused")) == null || t.blur()), this.removeResizeElements(), this.createPositionController(), this.elements.container.setAttribute(
+        "style",
+        `position: relative; border: 1px dashed ${M.COLORS.BORDER}; ${this.context.node.attrs.containerStyle}`
+      ), this.applyResizeLimits(), this.createResizeHandler();
+    });
+  }
+  setupContentClick() {
+    document.addEventListener("click", (e) => {
+      const t = e.target;
+      this.elements.container.contains(t) || t.style.cssText === `width: ${M.ICON_SIZE}; height: ${M.ICON_SIZE}; cursor: pointer;` || (this.clearContainerBorder(), this.removeResizeElements());
+    });
+  }
+  initialize() {
+    this.setupDOMStructure(), this.setupImageAttributes(), this.applyResizeLimits();
+    const { editable: e } = this.context.editor.options;
+    return e ? (this.setupContainerClick(), this.setupContentClick(), {
+      dom: this.elements.wrapper,
+      destroy: () => this.destroy()
+    }) : { dom: this.elements.container, destroy: () => this.destroy() };
+  }
+}
+const or = "image-resize-limit-update";
+class bn {
+  constructor(e) {
+    b(this, "currentMaxWidth");
+    b(this, "resizeTimeout");
+    b(this, "rafId");
+    b(this, "handleResize", () => {
+      this.resizeTimeout && clearTimeout(this.resizeTimeout), this.resizeTimeout = window.setTimeout(() => {
+        this.rafId && cancelAnimationFrame(this.rafId), this.rafId = requestAnimationFrame(() => {
+          const e = this.measureContainerWidth();
+          if (e !== this.currentMaxWidth) {
+            this.currentMaxWidth = e;
+            const t = new CustomEvent(or, {
+              detail: { maxWidth: e }
+            });
+            window.dispatchEvent(t);
+          }
+        });
+      }, 150);
+    });
+    this.editorElement = e, this.currentMaxWidth = this.measureContainerWidth(), window.addEventListener("resize", this.handleResize);
+  }
+  measureContainerWidth() {
+    return this.editorElement.clientWidth;
+  }
+  getCurrentMaxWidth() {
+    return this.currentMaxWidth;
+  }
+  destroy() {
+    window.removeEventListener("resize", this.handleResize), this.resizeTimeout && clearTimeout(this.resizeTimeout), this.rafId && cancelAnimationFrame(this.rafId);
+  }
+}
+const ar = Gr.extend({
+  name: "imageResize",
+  addOptions() {
+    var n;
+    return {
+      ...(n = this.parent) == null ? void 0 : n.call(this),
+      inline: !1,
+      minWidth: void 0,
+      maxWidth: void 0,
+      allowBase64: !1
+    };
+  },
+  onCreate() {
+    const n = new bn(this.editor.view.dom);
+    return this.resizeHandler = n, () => {
+      n.destroy();
+    };
+  },
+  renderHTML({ HTMLAttributes: n }) {
+    const e = { ...n };
+    if (n != null && n.id && (e["data-id"] = n.id), !(n != null && n.wrapperStyle))
+      return ["img", e];
+    const t = (n == null ? void 0 : n.width) ?? this.options.maxWidth ?? 0, r = this.options.inline, i = (n == null ? void 0 : n.containerStyle) ?? ne.getContainerStyle(r, `${t}px`), s = (n == null ? void 0 : n.wrapperStyle) ?? ne.getWrapperStyle(r);
+    return ["div", { style: i }, ["div", { style: s }, ["img", e]]];
+  },
+  addAttributes() {
+    var e;
+    const n = this.options.inline;
+    return {
+      ...(e = this.parent) == null ? void 0 : e.call(this),
+      id: {
+        default: null,
+        parseHTML: (t) => t.getAttribute("data-id"),
+        renderHTML: (t) => t.id ? { "data-id": t.id, style: "margin-block: 10px;" } : {}
+      },
+      width: {
+        renderHTML: (t) => t.width ? { width: t.width } : {}
+      },
+      containerStyle: {
+        default: null,
+        parseHTML: (t) => {
+          const r = t.getAttribute("containerstyle");
+          if (r)
+            return r;
+          const i = t.getAttribute("width");
+          return i ? ne.getContainerStyle(n, `${i}px`) : `${t.style.cssText}`;
+        },
+        renderHTML: (t) => t.width ? { width: t.width } : {}
+      },
+      wrapperStyle: {
+        default: ne.getWrapperStyle(n)
+      }
+    };
+  },
+  addNodeView() {
+    return ({ node: n, editor: e, getPos: t }) => {
+      var d;
+      if (n.type.name !== "imageResize") {
+        const h = document.createElement("img");
+        return h.src = n.attrs.src, h.alt = n.attrs.alt || "", n.attrs.width && (h.width = n.attrs.width), n.attrs.height && (h.height = n.attrs.height), { dom: h };
+      }
+      const { inline: r, minWidth: i, maxWidth: s } = this.options, l = {
+        node: n,
+        editor: e,
+        view: e.view,
+        getPos: typeof t == "function" ? t : void 0
+      }, a = {
+        minWidth: i,
+        maxWidth: s ?? ((d = this.resizeHandler) == null ? void 0 : d.getCurrentMaxWidth())
+      }, f = new En(l, r, a, or).initialize();
+      return f.dom.addEventListener("click", (h) => {
+        h.preventDefault();
+        const g = t();
+        if (g !== void 0) {
+          const { state: v, view: m } = e, I = v.tr.setSelection(P.create(v.doc, g));
+          m.dispatch(I);
+        }
+      }), f;
+    };
+  },
+  addCommands() {
+    var n;
+    return {
+      ...(n = this.parent) == null ? void 0 : n.call(this),
+      setResizableImage: (e) => ({ commands: t }) => t.insertContent({
+        type: this.name,
+        attrs: e
+      })
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Backspace: () => Tn(this.editor)
+    };
+  }
+}), Tn = (n) => {
+  var t, r;
+  const e = [];
+  return n.state.doc.nodesBetween(
+    n.state.selection.$from.pos,
+    n.state.selection.$to.pos,
+    (i) => {
+      e == null || e.push(i);
+    }
+  ), e.length !== 1 || ((r = (t = e.at(0)) == null ? void 0 : t.type) == null ? void 0 : r.name) !== "imageResize" ? (console.log("trace 1: handled?"), !1) : (n.commands.deleteSelection(), !0);
+}, V = (n) => n === "bulletList" || n === "orderedList", Ce = (n) => n === "listItem", B = (n) => n === "paragraph" || n === "heading";
+function We(n, e) {
+  for (const t of n)
+    if (t(e))
+      return !0;
+  return !1;
+}
+function Rn(n, e) {
+  for (const t of n)
+    if (t(e)) return !0;
+  return !1;
+}
+const Cn = ({
+  editor: n,
+  $from: e,
+  currentNode: t
+}) => {
+  const r = e.pos === e.start(), i = t.attrs.indent > 0;
+  return B(t.type.name) && i && r ? n.commands.outdent() : !1;
+}, kn = ({
+  state: n,
+  view: e,
+  $from: t,
+  currentNode: r
+}) => {
+  const i = r.content.size === 0, s = r.attrs.indent > 0;
+  if (!(B(r.type.name) && s && i)) return !1;
+  const a = t.before(t.depth), c = n.tr;
+  return c.delete(a, a + r.nodeSize), e.dispatch(c), !0;
+}, On = ({
+  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), c = n.doc.resolve(a).nodeBefore, f = c != null && V(c.type.name);
+  if (B(r.type.name) && !l && s && i && f) {
+    const h = n.tr;
+    return h.delete(a, a + r.nodeSize), e.dispatch(h), !0;
+  }
+  return !1;
+}, Nn = (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) => {
+    (V(d.type.name) || B(d.type.name)) && a++;
+  }), a <= 1) return !1;
+  const c = /* @__PURE__ */ new Set();
+  let f = !1;
+  return t.doc.nodesBetween(s.pos, l.pos, (d, h) => {
+    var v;
+    return !(V(d.type.name) || B(d.type.name)) || c.has(h) ? !0 : (c.add(h), e.setNodeAttribute(h, "indent", (((v = d.attrs) == null ? void 0 : v.indent) ?? 0) + 1), f = !0, !1);
+  }), f ? (e.setMeta("addToHistory", !0), r == null || r(e), !0) : !1;
+}, Ln = (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 h = s.node(d);
+    if (V(h.type.name)) {
+      l = { ...h, 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 $) {
+    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;
+}, An = (n) => {
+  const { tr: e, state: t, dispatch: r } = n, { selection: i } = t, { $from: s } = i, l = s.node();
+  if (!(B(l.type.name) && i instanceof $)) return !1;
+  const c = l.attrs.indent ?? 0;
+  return e.setNodeAttribute(s.before(s.depth), "indent", c + 1), e.setMeta("addToHistory", !1), r == null || r(e), !0;
+}, Tt = ({
+  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, (h) => {
+    (Ce(h.type.name) || B(h.type.name)) && s++;
+  }), !(s > 1)) return !1;
+  const { tr: a, doc: c } = n;
+  let f = !1;
+  const d = /* @__PURE__ */ new Set();
+  return c.nodesBetween(t.pos, r.pos, (h, g) => {
+    if (V(h.type.name) && (h.attrs.indent ?? 0) > 0) {
+      if (!d.has(g)) {
+        d.add(g);
+        const v = h.attrs.indent ?? 0;
+        a.setNodeAttribute(g, "indent", Math.max(0, v - 1)), f = !0;
+        const m = n.doc.resolve(g), I = n.doc.resolve(g + h.nodeSize), A = new Xt(m, I, m.depth), L = rr(A);
+        L != null && (a.lift(A, L), f = !0);
+      }
+      return !1;
+    }
+    if (B(h.type.name) && (h.attrs.indent ?? 0) > 0) {
+      const v = h.attrs.indent ?? 0;
+      a.setNodeAttribute(g, "indent", Math.max(0, v - 1)), f = !0;
+    }
+    return !0;
+  }), f ? (a.setMeta("addToHistory", !0), e.dispatch(a), !0) : !1;
+}, zn = ({
+  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, (h) => {
+    (Ce(h.type.name) || B(h.type.name)) && s++;
+  }), !(s > 1)) return !1;
+  const { tr: a, doc: c } = n;
+  let f = !1;
+  const d = /* @__PURE__ */ new Set();
+  return c.nodesBetween(t.pos, r.pos, (h, g) => {
+    if (V(h.type.name) && (h.attrs.indent ?? 0) > 0) {
+      if (!d.has(g)) {
+        d.add(g);
+        const v = h.attrs.indent ?? 0;
+        a.setNodeAttribute(g, "indent", Math.max(0, v - 1)), f = !0;
+        const m = n.doc.resolve(g), I = n.doc.resolve(g + h.nodeSize), A = new Xt(m, I, m.depth), L = rr(A);
+        L != null && (a.lift(A, L), f = !0);
+      }
+      return !1;
+    }
+    if (B(h.type.name) && (h.attrs.indent ?? 0) > 0) {
+      const v = h.attrs.indent ?? 0;
+      a.setNodeAttribute(g, "indent", Math.max(0, v - 1)), f = !0;
+    }
+    return !0;
+  }), f ? (a.setMeta("addToHistory", !0), e.dispatch(a), !0) : !1;
+}, Mn = ({ $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 c = n.node(a);
+    if (V(c.type.name))
+      if (!t)
+        t = !0, i = ((l = c.attrs) == null ? void 0 : l.indent) ?? 0;
+      else {
+        r = !0;
+        break;
+      }
+  }
+  return t && !r ? i === 0 : !1;
+}, Pn = ({
+  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 && V(a.type.name))) return !1;
+  const f = n.doc.resolve(l - 1), d = n.tr.setSelection($.near(f, -1));
+  return e.dispatch(d), !0;
+}, Dn = ({
+  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, (h) => {
+    (Ce(h.type.name) || B(h.type.name)) && s++;
+  }), !(s > 1)) return !1;
+  const { tr: a, doc: c } = n;
+  let f = !1;
+  const d = /* @__PURE__ */ new Set();
+  return c.nodesBetween(t.pos, r.pos, (h, g) => {
+    if ((V(h.type.name) || B(h.type.name)) && !d.has(g)) {
+      d.add(g);
+      const m = h.attrs.indent ?? 0;
+      return a.setNodeAttribute(g, "indent", m + 1), f = !0, !1;
+    }
+    return !0;
+  }), f ? (a.setMeta("addToHistory", !0), e.dispatch(a), !0) : !1;
+}, _n = ({
+  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), $n = ({ editor: n, currentNode: e, $from: t }) => {
+  const r = e.content.size === 0, i = t.node(t.depth - 1);
+  return i && Ce(i.type.name) && !r ? (n.chain().focus().indent().focus().run(), !0) : !1;
+}, Bn = ({ 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 He(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 Fn = dn.create({
+  name: "indent",
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => this.editor.commands._handleEnterKeyDown(),
+      Tab: () => {
+        const n = He(this.editor);
+        return We(
+          [
+            Dn,
+            _n,
+            $n,
+            Bn
+          ],
+          n
+        ) || this.editor.commands.indent();
+      },
+      Backspace: () => {
+        const n = He(this.editor);
+        return We(
+          [
+            Cn,
+            kn,
+            On
+          ],
+          n
+        );
+      },
+      "Shift-Tab": () => {
+        const n = He(this.editor);
+        return We(
+          [
+            zn,
+            Pn,
+            Mn
+          ],
+          n
+        ) || this.editor.chain().outdentShiftTab().run();
+      },
+      Space: () => this.editor.commands._handleSpaceKeyDown()
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new se({
+        // 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 g;
+            if (!(B(s.type.name) && (((g = s == null ? void 0 : s.attrs) == null ? void 0 : g.indent) ?? 0) > 0)) return;
+            const c = t.doc.resolve(l);
+            if (!(c.parent.type.name === "listItem")) return;
+            let d = null;
+            for (let v = c.depth - 1; v > 0; v--)
+              if (V(c.node(v).type.name)) {
+                d = c.start(v) - 1;
+                break;
+              }
+            if (d === null || d < 0) return;
+            i || (i = t.tr);
+            const h = s.attrs.indent;
+            i.setNodeAttribute(l, "indent", 0), i.setNodeAttribute(d, "indent", h);
+          }), 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 c;
+        const { tr: e, state: t, dispatch: r } = n, { $from: i } = t.selection, s = i.node();
+        if (!(((c = s == null ? void 0 : s.type) == null ? void 0 : c.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) => Rn(
+        [Nn, Ln, An],
+        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, c = {
+          editor: n.editor,
+          state: e,
+          view: t,
+          $from: s,
+          $to: l,
+          selectionIsEmpty: a,
+          currentNode: s.node()
+        };
+        if (Tt(c)) return !0;
+        const f = s.node();
+        if (!(B(f.type.name) && f.attrs.indent > 0) || !(s.pos === s.start())) return !1;
+        const g = Math.max(0, f.attrs.indent - 1);
+        return r.setNodeAttribute(s.before(s.depth), "indent", g), 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 (!(B(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 Tt(l) ? !0 : n.chain().outdentShiftTab().run();
+      }
+    };
+  }
+});
+var Jn = Pt, Wn = Dt, Hn = _t;
+const Vn = Jn.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 };
+    };
+  }
+}), jn = Hn.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 };
+    };
+  }
+}), lr = Wn.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 } : {}
+      }
+    };
+  }
+}), cr = ge.create({
+  name: "dynamicBulletStyling",
+  addProseMirrorPlugins() {
+    return [
+      new se({
+        key: new vn("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 c = t.doc.resolve(l);
+              for (let f = c.depth; f > 0; f--)
+                if (c.node(f).type.name === "bulletList") {
+                  a = 1;
+                  break;
+                }
+              a > 0 && (r.setNodeAttribute(c.pos, "[data-style]", "line-height: inherit"), i = !0);
+            }
+          }), i ? r : null;
+        }
+      })
+    ];
+  }
+}), Un = (n) => n === "bulletList" || n === "orderedList", qn = (n) => n === "paragraph" || n === "heading", Kn = ge.create({
+  name: "listIndentIntegration",
+  addProseMirrorPlugins() {
+    return [
+      // Indent attribute transfer plugin
+      new se({
+        appendTransaction: (n, e, t) => {
+          if (!n.find((i) => i.docChanged))
+            return null;
+          let r = null;
+          return t.doc.descendants((i, s) => {
+            var l;
+            if (qn(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 h = a.node(d);
+                  if (Un(h.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 se({
+        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;
+          }
+        }
+      })
+    ];
+  }
+}), dr = ge.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()
+    };
+  }
+}), ur = ge.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()
+    };
+  }
+}), Ti = [
+  Nt,
+  an,
+  Lt,
+  At,
+  Kr,
+  Yr,
+  Xr,
+  ar,
+  sr,
+  Dt,
+  Qr,
+  tn,
+  _t,
+  ln,
+  rn,
+  nn,
+  sn,
+  on,
+  $t,
+  en,
+  Jt,
+  Wt,
+  Ht,
+  // Missing from BASE_EXTENSIONS
+  Bt,
+  Ft,
+  Mt,
+  // Gapcursor,
+  zt,
+  Vt,
+  lr,
+  dr,
+  ur,
+  Pt,
+  cr
+], Ri = [
+  wn,
+  // CONVENTION - Replaces Paragraph with selectable indent spacing (T006-T007)
+  Wt,
+  Lt,
+  Vt.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,
+  zt,
+  Ht,
+  Nt,
+  Mt,
+  $t,
+  lr,
+  // T011: ListItem with indent attribute
+  At,
+  Ft,
+  dr,
+  ur,
+  Vn,
+  // T009: BulletList with indent attribute
+  // No custom keymap, just dynamic styling
+  cr,
+  ar,
+  Kn,
+  // T029: Indent attribute transfer (FR-020, FR-021, FR-023)
+  Jt.configure({
+    types: ["heading", "paragraph"]
+  }),
+  jn.configure({
+    // T010: OrderedList with indent attribute
+    itemTypeName: "listItem",
+    keepMarks: !0,
+    keepAttributes: !0
+  }),
+  sr,
+  // Must be last to have highest keyboard shortcut priority
+  Fn
+], Ci = ge.create({
+  name: "MentionStorage",
+  addStorage() {
+    return {
+      suggestions: []
+    };
+  }
+});
+var te = {}, Rt;
+function Yn() {
+  if (Rt) return te;
+  Rt = 1;
+  var n = un;
+  if (process.env.NODE_ENV === "production")
+    te.createRoot = n.createRoot, te.hydrateRoot = n.hydrateRoot;
+  else {
+    var e = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    te.createRoot = function(t, r) {
+      e.usingClientEntryPoint = !0;
+      try {
+        return n.createRoot(t, r);
+      } finally {
+        e.usingClientEntryPoint = !1;
+      }
+    }, te.hydrateRoot = function(t, r, i) {
+      e.usingClientEntryPoint = !0;
+      try {
+        return n.hydrateRoot(t, r, i);
+      } finally {
+        e.usingClientEntryPoint = !1;
+      }
+    };
+  }
+  return te;
+}
+var Xn = Yn(), Ee = { exports: {} }, ce = {};
+/**
+ * @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 Ct;
+function Gn() {
+  if (Ct) return ce;
+  Ct = 1;
+  var n = jt, 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, c, f) {
+    var d, h = {}, g = null, v = null;
+    f !== void 0 && (g = "" + f), c.key !== void 0 && (g = "" + c.key), c.ref !== void 0 && (v = c.ref);
+    for (d in c) r.call(c, d) && !s.hasOwnProperty(d) && (h[d] = c[d]);
+    if (a && a.defaultProps) for (d in c = a.defaultProps, c) h[d] === void 0 && (h[d] = c[d]);
+    return { $$typeof: e, type: a, key: g, ref: v, props: h, _owner: i.current };
+  }
+  return ce.Fragment = t, ce.jsx = l, ce.jsxs = l, ce;
+}
+var de = {};
+/**
+ * @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 kt;
+function Zn() {
+  return kt || (kt = 1, process.env.NODE_ENV !== "production" && (function() {
+    var n = jt, 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"), c = Symbol.for("react.forward_ref"), f = Symbol.for("react.suspense"), d = Symbol.for("react.suspense_list"), h = Symbol.for("react.memo"), g = Symbol.for("react.lazy"), v = Symbol.for("react.offscreen"), m = Symbol.iterator, I = "@@iterator";
+    function A(o) {
+      if (o === null || typeof o != "object")
+        return null;
+      var u = m && o[m] || o[I];
+      return typeof u == "function" ? u : null;
+    }
+    var L = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function R(o) {
+      {
+        for (var u = arguments.length, p = new Array(u > 1 ? u - 1 : 0), y = 1; y < u; y++)
+          p[y - 1] = arguments[y];
+        oe("error", o, p);
+      }
+    }
+    function oe(o, u, p) {
+      {
+        var y = L.ReactDebugCurrentFrame, S = y.getStackAddendum();
+        S !== "" && (u += "%s", p = p.concat([S]));
+        var E = p.map(function(x) {
+          return String(x);
+        });
+        E.unshift("Warning: " + u), Function.prototype.apply.call(console[o], console, E);
+      }
+    }
+    var fr = !1, hr = !1, pr = !1, mr = !1, gr = !1, Ke;
+    Ke = Symbol.for("react.module.reference");
+    function yr(o) {
+      return !!(typeof o == "string" || typeof o == "function" || o === r || o === s || gr || o === i || o === f || o === d || mr || o === v || fr || hr || pr || typeof o == "object" && o !== null && (o.$$typeof === g || o.$$typeof === h || o.$$typeof === l || o.$$typeof === a || o.$$typeof === c || // 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 === Ke || o.getModuleId !== void 0));
+    }
+    function vr(o, u, p) {
+      var y = o.displayName;
+      if (y)
+        return y;
+      var S = u.displayName || u.name || "";
+      return S !== "" ? p + "(" + S + ")" : p;
+    }
+    function Ye(o) {
+      return o.displayName || "Context";
+    }
+    function U(o) {
+      if (o == null)
+        return null;
+      if (typeof o.tag == "number" && R("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 u = o;
+            return Ye(u) + ".Consumer";
+          case l:
+            var p = o;
+            return Ye(p._context) + ".Provider";
+          case c:
+            return vr(o, o.render, "ForwardRef");
+          case h:
+            var y = o.displayName || null;
+            return y !== null ? y : U(o.type) || "Memo";
+          case g: {
+            var S = o, E = S._payload, x = S._init;
+            try {
+              return U(x(E));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var q = Object.assign, ae = 0, Xe, Ge, Ze, Qe, et, tt, rt;
+    function nt() {
+    }
+    nt.__reactDisabledLog = !0;
+    function wr() {
+      {
+        if (ae === 0) {
+          Xe = console.log, Ge = console.info, Ze = console.warn, Qe = console.error, et = console.group, tt = console.groupCollapsed, rt = console.groupEnd;
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            value: nt,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: o,
+            log: o,
+            warn: o,
+            error: o,
+            group: o,
+            groupCollapsed: o,
+            groupEnd: o
+          });
+        }
+        ae++;
+      }
+    }
+    function xr() {
+      {
+        if (ae--, ae === 0) {
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: q({}, o, {
+              value: Xe
+            }),
+            info: q({}, o, {
+              value: Ge
+            }),
+            warn: q({}, o, {
+              value: Ze
+            }),
+            error: q({}, o, {
+              value: Qe
+            }),
+            group: q({}, o, {
+              value: et
+            }),
+            groupCollapsed: q({}, o, {
+              value: tt
+            }),
+            groupEnd: q({}, o, {
+              value: rt
+            })
+          });
+        }
+        ae < 0 && R("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ke = L.ReactCurrentDispatcher, Oe;
+    function ye(o, u, p) {
+      {
+        if (Oe === void 0)
+          try {
+            throw Error();
+          } catch (S) {
+            var y = S.stack.trim().match(/\n( *(at )?)/);
+            Oe = y && y[1] || "";
+          }
+        return `
+` + Oe + o;
+      }
+    }
+    var Ne = !1, ve;
+    {
+      var Ir = typeof WeakMap == "function" ? WeakMap : Map;
+      ve = new Ir();
+    }
+    function it(o, u) {
+      if (!o || Ne)
+        return "";
+      {
+        var p = ve.get(o);
+        if (p !== void 0)
+          return p;
+      }
+      var y;
+      Ne = !0;
+      var S = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var E;
+      E = ke.current, ke.current = null, wr();
+      try {
+        if (u) {
+          var x = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(x.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(x, []);
+            } catch (F) {
+              y = F;
+            }
+            Reflect.construct(o, [], x);
+          } else {
+            try {
+              x.call();
+            } catch (F) {
+              y = F;
+            }
+            o.call(x.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (F) {
+            y = F;
+          }
+          o();
+        }
+      } catch (F) {
+        if (F && y && typeof F.stack == "string") {
+          for (var w = F.stack.split(`
+`), _ = y.stack.split(`
+`), k = w.length - 1, O = _.length - 1; k >= 1 && O >= 0 && w[k] !== _[O]; )
+            O--;
+          for (; k >= 1 && O >= 0; k--, O--)
+            if (w[k] !== _[O]) {
+              if (k !== 1 || O !== 1)
+                do
+                  if (k--, O--, O < 0 || w[k] !== _[O]) {
+                    var W = `
+` + w[k].replace(" at new ", " at ");
+                    return o.displayName && W.includes("<anonymous>") && (W = W.replace("<anonymous>", o.displayName)), typeof o == "function" && ve.set(o, W), W;
+                  }
+                while (k >= 1 && O >= 0);
+              break;
+            }
+        }
+      } finally {
+        Ne = !1, ke.current = E, xr(), Error.prepareStackTrace = S;
+      }
+      var ee = o ? o.displayName || o.name : "", K = ee ? ye(ee) : "";
+      return typeof o == "function" && ve.set(o, K), K;
+    }
+    function Sr(o, u, p) {
+      return it(o, !1);
+    }
+    function Er(o) {
+      var u = o.prototype;
+      return !!(u && u.isReactComponent);
+    }
+    function we(o, u, p) {
+      if (o == null)
+        return "";
+      if (typeof o == "function")
+        return it(o, Er(o));
+      if (typeof o == "string")
+        return ye(o);
+      switch (o) {
+        case f:
+          return ye("Suspense");
+        case d:
+          return ye("SuspenseList");
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case c:
+            return Sr(o.render);
+          case h:
+            return we(o.type, u, p);
+          case g: {
+            var y = o, S = y._payload, E = y._init;
+            try {
+              return we(E(S), u, p);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var le = Object.prototype.hasOwnProperty, st = {}, ot = L.ReactDebugCurrentFrame;
+    function xe(o) {
+      if (o) {
+        var u = o._owner, p = we(o.type, o._source, u ? u.type : null);
+        ot.setExtraStackFrame(p);
+      } else
+        ot.setExtraStackFrame(null);
+    }
+    function br(o, u, p, y, S) {
+      {
+        var E = Function.call.bind(le);
+        for (var x in o)
+          if (E(o, x)) {
+            var w = void 0;
+            try {
+              if (typeof o[x] != "function") {
+                var _ = Error((y || "React class") + ": " + p + " type `" + x + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof o[x] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw _.name = "Invariant Violation", _;
+              }
+              w = o[x](u, x, y, p, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (k) {
+              w = k;
+            }
+            w && !(w instanceof Error) && (xe(S), R("%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).", y || "React class", p, x, typeof w), xe(null)), w instanceof Error && !(w.message in st) && (st[w.message] = !0, xe(S), R("Failed %s type: %s", p, w.message), xe(null));
+          }
+      }
+    }
+    var Tr = Array.isArray;
+    function Le(o) {
+      return Tr(o);
+    }
+    function Rr(o) {
+      {
+        var u = typeof Symbol == "function" && Symbol.toStringTag, p = u && o[Symbol.toStringTag] || o.constructor.name || "Object";
+        return p;
+      }
+    }
+    function Cr(o) {
+      try {
+        return at(o), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function at(o) {
+      return "" + o;
+    }
+    function lt(o) {
+      if (Cr(o))
+        return R("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Rr(o)), at(o);
+    }
+    var ct = L.ReactCurrentOwner, kr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, dt, ut;
+    function Or(o) {
+      if (le.call(o, "ref")) {
+        var u = Object.getOwnPropertyDescriptor(o, "ref").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return o.ref !== void 0;
+    }
+    function Nr(o) {
+      if (le.call(o, "key")) {
+        var u = Object.getOwnPropertyDescriptor(o, "key").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return o.key !== void 0;
+    }
+    function Lr(o, u) {
+      typeof o.ref == "string" && ct.current;
+    }
+    function Ar(o, u) {
+      {
+        var p = function() {
+          dt || (dt = !0, R("%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)", u));
+        };
+        p.isReactWarning = !0, Object.defineProperty(o, "key", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    function zr(o, u) {
+      {
+        var p = function() {
+          ut || (ut = !0, R("%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)", u));
+        };
+        p.isReactWarning = !0, Object.defineProperty(o, "ref", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    var Mr = function(o, u, p, y, S, E, x) {
+      var w = {
+        // 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: u,
+        ref: p,
+        props: x,
+        // Record the component responsible for creating this element.
+        _owner: E
+      };
+      return w._store = {}, Object.defineProperty(w._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(w, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: y
+      }), Object.defineProperty(w, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: S
+      }), Object.freeze && (Object.freeze(w.props), Object.freeze(w)), w;
+    };
+    function Pr(o, u, p, y, S) {
+      {
+        var E, x = {}, w = null, _ = null;
+        p !== void 0 && (lt(p), w = "" + p), Nr(u) && (lt(u.key), w = "" + u.key), Or(u) && (_ = u.ref, Lr(u, S));
+        for (E in u)
+          le.call(u, E) && !kr.hasOwnProperty(E) && (x[E] = u[E]);
+        if (o && o.defaultProps) {
+          var k = o.defaultProps;
+          for (E in k)
+            x[E] === void 0 && (x[E] = k[E]);
+        }
+        if (w || _) {
+          var O = typeof o == "function" ? o.displayName || o.name || "Unknown" : o;
+          w && Ar(x, O), _ && zr(x, O);
+        }
+        return Mr(o, w, _, S, y, ct.current, x);
+      }
+    }
+    var Ae = L.ReactCurrentOwner, ft = L.ReactDebugCurrentFrame;
+    function Q(o) {
+      if (o) {
+        var u = o._owner, p = we(o.type, o._source, u ? u.type : null);
+        ft.setExtraStackFrame(p);
+      } else
+        ft.setExtraStackFrame(null);
+    }
+    var ze;
+    ze = !1;
+    function Me(o) {
+      return typeof o == "object" && o !== null && o.$$typeof === e;
+    }
+    function ht() {
+      {
+        if (Ae.current) {
+          var o = U(Ae.current.type);
+          if (o)
+            return `
+
+Check the render method of \`` + o + "`.";
+        }
+        return "";
+      }
+    }
+    function Dr(o) {
+      return "";
+    }
+    var pt = {};
+    function _r(o) {
+      {
+        var u = ht();
+        if (!u) {
+          var p = typeof o == "string" ? o : o.displayName || o.name;
+          p && (u = `
+
+Check the top-level render call using <` + p + ">.");
+        }
+        return u;
+      }
+    }
+    function mt(o, u) {
+      {
+        if (!o._store || o._store.validated || o.key != null)
+          return;
+        o._store.validated = !0;
+        var p = _r(u);
+        if (pt[p])
+          return;
+        pt[p] = !0;
+        var y = "";
+        o && o._owner && o._owner !== Ae.current && (y = " It was passed a child from " + U(o._owner.type) + "."), Q(o), R('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', p, y), Q(null);
+      }
+    }
+    function gt(o, u) {
+      {
+        if (typeof o != "object")
+          return;
+        if (Le(o))
+          for (var p = 0; p < o.length; p++) {
+            var y = o[p];
+            Me(y) && mt(y, u);
+          }
+        else if (Me(o))
+          o._store && (o._store.validated = !0);
+        else if (o) {
+          var S = A(o);
+          if (typeof S == "function" && S !== o.entries)
+            for (var E = S.call(o), x; !(x = E.next()).done; )
+              Me(x.value) && mt(x.value, u);
+        }
+      }
+    }
+    function $r(o) {
+      {
+        var u = o.type;
+        if (u == null || typeof u == "string")
+          return;
+        var p;
+        if (typeof u == "function")
+          p = u.propTypes;
+        else if (typeof u == "object" && (u.$$typeof === c || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        u.$$typeof === h))
+          p = u.propTypes;
+        else
+          return;
+        if (p) {
+          var y = U(u);
+          br(p, o.props, "prop", y, o);
+        } else if (u.PropTypes !== void 0 && !ze) {
+          ze = !0;
+          var S = U(u);
+          R("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", S || "Unknown");
+        }
+        typeof u.getDefaultProps == "function" && !u.getDefaultProps.isReactClassApproved && R("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Br(o) {
+      {
+        for (var u = Object.keys(o.props), p = 0; p < u.length; p++) {
+          var y = u[p];
+          if (y !== "children" && y !== "key") {
+            Q(o), R("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", y), Q(null);
+            break;
+          }
+        }
+        o.ref !== null && (Q(o), R("Invalid attribute `ref` supplied to `React.Fragment`."), Q(null));
+      }
+    }
+    var yt = {};
+    function vt(o, u, p, y, S, E) {
+      {
+        var x = yr(o);
+        if (!x) {
+          var w = "";
+          (o === void 0 || typeof o == "object" && o !== null && Object.keys(o).length === 0) && (w += " 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 _ = Dr();
+          _ ? w += _ : w += ht();
+          var k;
+          o === null ? k = "null" : Le(o) ? k = "array" : o !== void 0 && o.$$typeof === e ? (k = "<" + (U(o.type) || "Unknown") + " />", w = " Did you accidentally export a JSX literal instead of a component?") : k = typeof o, R("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", k, w);
+        }
+        var O = Pr(o, u, p, S, E);
+        if (O == null)
+          return O;
+        if (x) {
+          var W = u.children;
+          if (W !== void 0)
+            if (y)
+              if (Le(W)) {
+                for (var ee = 0; ee < W.length; ee++)
+                  gt(W[ee], o);
+                Object.freeze && Object.freeze(W);
+              } else
+                R("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
+              gt(W, o);
+        }
+        if (le.call(u, "key")) {
+          var K = U(o), F = Object.keys(u).filter(function(jr) {
+            return jr !== "key";
+          }), Pe = F.length > 0 ? "{key: someKey, " + F.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!yt[K + Pe]) {
+            var Vr = F.length > 0 ? "{" + F.join(": ..., ") + ": ...}" : "{}";
+            R(`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} />`, Pe, K, Vr, K), yt[K + Pe] = !0;
+          }
+        }
+        return o === r ? Br(O) : $r(O), O;
+      }
+    }
+    function Fr(o, u, p) {
+      return vt(o, u, p, !0);
+    }
+    function Jr(o, u, p) {
+      return vt(o, u, p, !1);
+    }
+    var Wr = Jr, Hr = Fr;
+    de.Fragment = r, de.jsx = Wr, de.jsxs = Hr;
+  })()), de;
+}
+var Ot;
+function Qn() {
+  return Ot || (Ot = 1, process.env.NODE_ENV === "production" ? Ee.exports = Gn() : Ee.exports = Zn()), Ee.exports;
+}
+var ue = Qn();
+const ei = ({
+  images: n,
+  onAdd: e,
+  onDelete: t,
+  onImageClick: r,
+  focusedImageIndex: i
+}) => /* @__PURE__ */ ue.jsxs(
+  "div",
+  {
+    className: "batch-image-gallery",
+    style: { display: "flex", gap: "8px", overflowX: "auto", padding: "8px" },
+    children: [
+      n.map((s, l) => /* @__PURE__ */ ue.jsxs(
+        "div",
+        {
+          style: {
+            position: "relative",
+            border: i === l ? "2px solid blue" : "2px solid transparent",
+            cursor: "pointer"
+          },
+          onClick: () => r(s),
+          children: [
+            /* @__PURE__ */ ue.jsx(
+              "img",
+              {
+                src: s.src,
+                alt: s.alt,
+                style: { width: "80px", height: "80px", objectFit: "cover" }
+              }
+            ),
+            /* @__PURE__ */ ue.jsx(
+              "button",
+              {
+                onClick: (a) => {
+                  a.stopPropagation(), t(l);
+                },
+                style: { position: "absolute", top: 0, right: 0 },
+                children: "×"
+              }
+            )
+          ]
+        },
+        s.id
+      )),
+      /* @__PURE__ */ ue.jsx("button", { onClick: e, style: { width: "80px", height: "80px" }, children: "+" })
+    ]
+  }
+);
+let fe = null;
+const ki = cn.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 se({
+        props: {
+          handleKeyDown(n, e) {
+            return e.key === "ArrowLeft" || e.key === "ArrowUp" ? fe = "left" : e.key === "ArrowRight" || e.key === "ArrowDown" ? fe = "right" : fe = 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($.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($.near(l.doc.resolve(s))), this.editor.view.dispatch(l);
+    }, t = (r) => {
+      var h, g;
+      const { selection: i } = this.editor.state;
+      if (!(i instanceof P)) return !1;
+      const s = i.node;
+      if (s.type.name !== "batchSegmentImages") return !1;
+      const l = ((g = (h = this.editor.storage.batchSegmentImages) == null ? void 0 : h.imageRegistry) == null ? void 0 : g.get(s.attrs.batchId)) ?? s.attrs.images;
+      if (!l.length) return !1;
+      const a = i.from, c = s.attrs.focusedImageIndex, f = !!this.options.onAdd;
+      let d;
+      if (r === "right") {
+        if (c === null)
+          return e(a, s), !0;
+        if (c < l.length - 1)
+          d = c + 1;
+        else if (c === l.length - 1 && f)
+          d = null;
+        else
+          return e(a, s), !0;
+      } else if (c === null)
+        d = l.length - 1;
+      else if (c > 0)
+        d = c - 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 v = this.editor.view.nodeDOM(a);
+        v instanceof HTMLElement && requestAnimationFrame(() => {
+          var I;
+          (I = v.querySelectorAll("img")[d]) == null || I.scrollIntoView({ block: "nearest", inline: "nearest" });
+        });
+      }
+      return !0;
+    };
+    return {
+      ArrowLeft: () => t("left"),
+      ArrowRight: () => t("right"),
+      Space: () => {
+        var c, f, d, h, g, v;
+        const { selection: r } = this.editor.state;
+        if (!(r instanceof P)) return !1;
+        const i = r.node;
+        if (i.type.name !== "batchSegmentImages") return !1;
+        const s = ((f = (c = this.editor.storage.batchSegmentImages) == null ? void 0 : c.imageRegistry) == null ? void 0 : f.get(i.attrs.batchId)) ?? i.attrs.images, l = i.attrs.focusedImageIndex, a = r.from;
+        if (l === null)
+          return (h = (d = this.options).onAdd) == null || h.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 (v = (g = this.options).onImageClick) == null || v.call(g, {
+            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 = Xn.createRoot(s), a = { current: n };
+      let c = 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 I, A;
+        (A = r.onRemove) == null || A.call(r, {
+          index: m,
+          imageId: (I = (i.imageRegistry.get(a.current.attrs.batchId) ?? [])[m]) == null ? void 0 : I.id,
+          batchId: a.current.attrs.batchId,
+          getPos: e,
+          editor: t
+        });
+      }, h = (m) => {
+        var A;
+        const I = e();
+        if (I !== void 0) {
+          const L = (i.imageRegistry.get(a.current.attrs.batchId) ?? []).findIndex((R) => R.id === m.id);
+          t.view.dispatch(
+            t.state.tr.setNodeMarkup(I, void 0, {
+              ...a.current.attrs,
+              focusedImageIndex: L
+            }).setMeta("addToHistory", !1)
+          );
+        }
+        (A = r.onImageClick) == null || A.call(r, {
+          imageId: m.id,
+          batchId: a.current.attrs.batchId,
+          src: m.src,
+          getPos: e,
+          editor: t
+        });
+      }, g = () => {
+        const [m, I] = De.useState({
+          images: i.imageRegistry.get(n.attrs.batchId) ?? [],
+          focusedImageIndex: n.attrs.focusedImageIndex,
+          batchId: n.attrs.batchId
+        });
+        return c = I, De.createElement(ei, {
+          batchId: m.batchId,
+          images: m.images,
+          maxImageAmount: r.maxImageAmount,
+          height: r.height,
+          focusedImageIndex: m.focusedImageIndex,
+          onAdd: f,
+          onDelete: d,
+          onImageClick: h
+        });
+      };
+      l.render(De.createElement(g));
+      let v = n;
+      return s.addEventListener("click", () => {
+        const m = e();
+        if (m !== void 0) {
+          const { state: I, view: A } = t, L = I.doc.nodeAt(m);
+          if (!L) return;
+          const R = I.tr.setNodeMarkup(m, void 0, { ...L.attrs, focusedImageIndex: null }).setMeta("addToHistory", !1);
+          A.dispatch(R.setSelection(P.create(R.doc, m)));
+        }
+      }), {
+        dom: s,
+        update: (m) => m.type !== n.type ? !1 : (m === v || (v = m, a.current = m, c == null || c({
+          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 = fe;
+          fe = null;
+          const I = e();
+          if (I === void 0) return;
+          const A = t.state.doc.nodeAt(I);
+          if (!A || A.attrs.focusedImageIndex !== null) return;
+          const L = m === "left" ? null : 0;
+          queueMicrotask(() => {
+            const R = e();
+            if (R === void 0) return;
+            const oe = t.state.doc.nodeAt(R);
+            !oe || oe.attrs.focusedImageIndex !== null || t.state.selection instanceof P && t.view.dispatch(
+              t.state.tr.setNodeMarkup(R, void 0, { ...oe.attrs, focusedImageIndex: L }).setMeta("addToHistory", !1)
+            );
+          });
+        },
+        deselectNode: () => {
+          const m = e();
+          if (m === void 0) return;
+          const I = t.state.doc.nodeAt(m);
+          !I || I.attrs.focusedImageIndex === null || t.view.dispatch(
+            t.state.tr.setNodeMarkup(m, void 0, { ...I.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 {
+  Ti as ALL_EXTENSIONS,
+  Ri as BASE_EXTENSIONS,
+  ki as BatchSegmentImagesExtension,
+  Li as Bold,
+  Gi as BulletList,
+  Is as CharacterCount,
+  zi as Color,
+  Vn as CustomBulletList,
+  sr as CustomLink,
+  lr as CustomListItem,
+  jn as CustomOrderedList,
+  wn as CustomParagraph,
+  Pi as Document,
+  cr as DynamicBulletStyling,
+  Ts as Editor,
+  Rs as EditorContent,
+  _i as FileHandler,
+  dr as FontSize,
+  Bi as HardBreak,
+  Ji as Heading,
+  Hi as Highlight,
+  Ss as History,
+  ji as Image,
+  ar as ImageResize,
+  Fn as IndentExtension,
+  qi as Italic,
+  ur as LineHeight,
+  Yi as Link,
+  Kn as ListIndentIntegration,
+  Zi as ListItem,
+  Qi as ListKeymap,
+  is as Mention,
+  Ci as MentionStorage,
+  es as OrderedList,
+  os as Paragraph,
+  Es as Placeholder,
+  ls as Table,
+  cs as TableCell,
+  ds as TableHeader,
+  us as TableRow,
+  ts as TaskItem,
+  rs as TaskList,
+  hs as Text,
+  ms as TextAlign,
+  ys as TextStyle,
+  ws as Underline,
+  Cs as useEditor
+};