reactjs-tiptap-editor 1.0.25 → 1.0.26

package/lib/index-Dbm_Mans.js

@@ -0,0 +1,1756 @@
+import { PluginKey as Yt, Plugin as Kt } from "@tiptap/pm/state";
+import { J as Jt } from "./index-Dx-Dh7KS.js";
+import { DecorationSet as Qt, Decoration as Gt } from "@tiptap/pm/view";
+const Bt = ["top", "right", "bottom", "left"], Ot = ["start", "end"], Ct = /* @__PURE__ */ Bt.reduce((t, e) => t.concat(e, e + "-" + Ot[0], e + "-" + Ot[1]), []), q = Math.min, _ = Math.max, st = Math.round, it = Math.floor, z = (t) => ({
+  x: t,
+  y: t
+}), Zt = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function ht(t, e, o) {
+  return _(t, q(e, o));
+}
+function X(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function k(t) {
+  return t.split("-")[0];
+}
+function N(t) {
+  return t.split("-")[1];
+}
+function kt(t) {
+  return t === "x" ? "y" : "x";
+}
+function wt(t) {
+  return t === "y" ? "height" : "width";
+}
+function I(t) {
+  const e = t[0];
+  return e === "t" || e === "b" ? "y" : "x";
+}
+function xt(t) {
+  return kt(I(t));
+}
+function Wt(t, e, o) {
+  o === void 0 && (o = !1);
+  const n = N(t), i = xt(t), r = wt(i);
+  let s = i === "x" ? n === (o ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return e.reference[r] > e.floating[r] && (s = ct(s)), [s, ct(s)];
+}
+function te(t) {
+  const e = ct(t);
+  return [rt(t), e, rt(e)];
+}
+function rt(t) {
+  return t.includes("start") ? t.replace("start", "end") : t.replace("end", "start");
+}
+const Et = ["left", "right"], Pt = ["right", "left"], ee = ["top", "bottom"], ne = ["bottom", "top"];
+function oe(t, e, o) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return o ? e ? Pt : Et : e ? Et : Pt;
+    case "left":
+    case "right":
+      return e ? ee : ne;
+    default:
+      return [];
+  }
+}
+function ie(t, e, o, n) {
+  const i = N(t);
+  let r = oe(k(t), o === "start", n);
+  return i && (r = r.map((s) => s + "-" + i), e && (r = r.concat(r.map(rt)))), r;
+}
+function ct(t) {
+  const e = k(t);
+  return Zt[e] + t.slice(e.length);
+}
+function se(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function yt(t) {
+  return typeof t != "number" ? se(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function G(t) {
+  const {
+    x: e,
+    y: o,
+    width: n,
+    height: i
+  } = t;
+  return {
+    width: n,
+    height: i,
+    top: o,
+    left: e,
+    right: e + n,
+    bottom: o + i,
+    x: e,
+    y: o
+  };
+}
+function Dt(t, e, o) {
+  let {
+    reference: n,
+    floating: i
+  } = t;
+  const r = I(e), s = xt(e), c = wt(s), a = k(e), u = r === "y", f = n.x + n.width / 2 - i.width / 2, l = n.y + n.height / 2 - i.height / 2, g = n[c] / 2 - i[c] / 2;
+  let d;
+  switch (a) {
+    case "top":
+      d = {
+        x: f,
+        y: n.y - i.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: f,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      d = {
+        x: n.x + n.width,
+        y: l
+      };
+      break;
+    case "left":
+      d = {
+        x: n.x - i.width,
+        y: l
+      };
+      break;
+    default:
+      d = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (N(e)) {
+    case "start":
+      d[s] -= g * (o && u ? -1 : 1);
+      break;
+    case "end":
+      d[s] += g * (o && u ? -1 : 1);
+      break;
+  }
+  return d;
+}
+async function re(t, e) {
+  var o;
+  e === void 0 && (e = {});
+  const {
+    x: n,
+    y: i,
+    platform: r,
+    rects: s,
+    elements: c,
+    strategy: a
+  } = t, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: l = "floating",
+    altBoundary: g = !1,
+    padding: d = 0
+  } = X(e, t), p = yt(d), h = c[g ? l === "floating" ? "reference" : "floating" : l], x = G(await r.getClippingRect({
+    element: (o = await (r.isElement == null ? void 0 : r.isElement(h))) == null || o ? h : h.contextElement || await (r.getDocumentElement == null ? void 0 : r.getDocumentElement(c.floating)),
+    boundary: u,
+    rootBoundary: f,
+    strategy: a
+  })), v = l === "floating" ? {
+    x: n,
+    y: i,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, y = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(c.floating)), m = await (r.isElement == null ? void 0 : r.isElement(y)) ? await (r.getScale == null ? void 0 : r.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, A = G(r.convertOffsetParentRelativeRectToViewportRelativeRect ? await r.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: v,
+    offsetParent: y,
+    strategy: a
+  }) : v);
+  return {
+    top: (x.top - A.top + p.top) / m.y,
+    bottom: (A.bottom - x.bottom + p.bottom) / m.y,
+    left: (x.left - A.left + p.left) / m.x,
+    right: (A.right - x.right + p.right) / m.x
+  };
+}
+const ce = 50, le = async (t, e, o) => {
+  const {
+    placement: n = "bottom",
+    strategy: i = "absolute",
+    middleware: r = [],
+    platform: s
+  } = o, c = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: re
+  }, a = await (s.isRTL == null ? void 0 : s.isRTL(e));
+  let u = await s.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), {
+    x: f,
+    y: l
+  } = Dt(u, n, a), g = n, d = 0;
+  const p = {};
+  for (let w = 0; w < r.length; w++) {
+    const h = r[w];
+    if (!h)
+      continue;
+    const {
+      name: x,
+      fn: v
+    } = h, {
+      x: y,
+      y: m,
+      data: A,
+      reset: b
+    } = await v({
+      x: f,
+      y: l,
+      initialPlacement: n,
+      placement: g,
+      strategy: i,
+      middlewareData: p,
+      rects: u,
+      platform: c,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    f = y ?? f, l = m ?? l, p[x] = {
+      ...p[x],
+      ...A
+    }, b && d < ce && (d++, typeof b == "object" && (b.placement && (g = b.placement), b.rects && (u = b.rects === !0 ? await s.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: i
+    }) : b.rects), {
+      x: f,
+      y: l
+    } = Dt(u, g, a)), w = -1);
+  }
+  return {
+    x: f,
+    y: l,
+    placement: g,
+    strategy: i,
+    middlewareData: p
+  };
+}, ae = (t) => ({
+  name: "arrow",
+  options: t,
+  async fn(e) {
+    const {
+      x: o,
+      y: n,
+      placement: i,
+      rects: r,
+      platform: s,
+      elements: c,
+      middlewareData: a
+    } = e, {
+      element: u,
+      padding: f = 0
+    } = X(t, e) || {};
+    if (u == null)
+      return {};
+    const l = yt(f), g = {
+      x: o,
+      y: n
+    }, d = xt(i), p = wt(d), w = await s.getDimensions(u), h = d === "y", x = h ? "top" : "left", v = h ? "bottom" : "right", y = h ? "clientHeight" : "clientWidth", m = r.reference[p] + r.reference[d] - g[d] - r.floating[p], A = g[d] - r.reference[d], b = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
+    let O = b ? b[y] : 0;
+    (!O || !await (s.isElement == null ? void 0 : s.isElement(b))) && (O = c.floating[y] || r.floating[p]);
+    const D = m / 2 - A / 2, L = O / 2 - w[p] / 2 - 1, R = q(l[x], L), C = q(l[v], L), S = R, M = O - w[p] - C, P = O / 2 - w[p] / 2 + D, $ = ht(S, P, M), T = !a.arrow && N(i) != null && P !== $ && r.reference[p] / 2 - (P < S ? R : C) - w[p] / 2 < 0, E = T ? P < S ? P - S : P - M : 0;
+    return {
+      [d]: g[d] + E,
+      data: {
+        [d]: $,
+        centerOffset: P - $ - E,
+        ...T && {
+          alignmentOffset: E
+        }
+      },
+      reset: T
+    };
+  }
+});
+function fe(t, e, o) {
+  return (t ? [...o.filter((i) => N(i) === t), ...o.filter((i) => N(i) !== t)] : o.filter((i) => k(i) === i)).filter((i) => t ? N(i) === t || (e ? rt(i) !== i : !1) : !0);
+}
+const ue = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(e) {
+      var o, n, i;
+      const {
+        rects: r,
+        middlewareData: s,
+        placement: c,
+        platform: a,
+        elements: u
+      } = e, {
+        crossAxis: f = !1,
+        alignment: l,
+        allowedPlacements: g = Ct,
+        autoAlignment: d = !0,
+        ...p
+      } = X(t, e), w = l !== void 0 || g === Ct ? fe(l || null, d, g) : g, h = await a.detectOverflow(e, p), x = ((o = s.autoPlacement) == null ? void 0 : o.index) || 0, v = w[x];
+      if (v == null)
+        return {};
+      const y = Wt(v, r, await (a.isRTL == null ? void 0 : a.isRTL(u.floating)));
+      if (c !== v)
+        return {
+          reset: {
+            placement: w[0]
+          }
+        };
+      const m = [h[k(v)], h[y[0]], h[y[1]]], A = [...((n = s.autoPlacement) == null ? void 0 : n.overflows) || [], {
+        placement: v,
+        overflows: m
+      }], b = w[x + 1];
+      if (b)
+        return {
+          data: {
+            index: x + 1,
+            overflows: A
+          },
+          reset: {
+            placement: b
+          }
+        };
+      const O = A.map((R) => {
+        const C = N(R.placement);
+        return [R.placement, C && f ? (
+          // Check along the mainAxis and main crossAxis side.
+          R.overflows.slice(0, 2).reduce((S, M) => S + M, 0)
+        ) : (
+          // Check only the mainAxis.
+          R.overflows[0]
+        ), R.overflows];
+      }).sort((R, C) => R[1] - C[1]), L = ((i = O.filter((R) => R[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        N(R[0]) ? 2 : 3
+      ).every((C) => C <= 0))[0]) == null ? void 0 : i[0]) || O[0][0];
+      return L !== c ? {
+        data: {
+          index: x + 1,
+          overflows: A
+        },
+        reset: {
+          placement: L
+        }
+      } : {};
+    }
+  };
+}, de = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var o, n;
+      const {
+        placement: i,
+        middlewareData: r,
+        rects: s,
+        initialPlacement: c,
+        platform: a,
+        elements: u
+      } = e, {
+        mainAxis: f = !0,
+        crossAxis: l = !0,
+        fallbackPlacements: g,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: p = "none",
+        flipAlignment: w = !0,
+        ...h
+      } = X(t, e);
+      if ((o = r.arrow) != null && o.alignmentOffset)
+        return {};
+      const x = k(i), v = I(c), y = k(c) === c, m = await (a.isRTL == null ? void 0 : a.isRTL(u.floating)), A = g || (y || !w ? [ct(c)] : te(c)), b = p !== "none";
+      !g && b && A.push(...ie(c, w, p, m));
+      const O = [c, ...A], D = await a.detectOverflow(e, h), L = [];
+      let R = ((n = r.flip) == null ? void 0 : n.overflows) || [];
+      if (f && L.push(D[x]), l) {
+        const P = Wt(i, s, m);
+        L.push(D[P[0]], D[P[1]]);
+      }
+      if (R = [...R, {
+        placement: i,
+        overflows: L
+      }], !L.every((P) => P <= 0)) {
+        var C, S;
+        const P = (((C = r.flip) == null ? void 0 : C.index) || 0) + 1, $ = O[P];
+        if ($ && (!(l === "alignment" ? v !== I($) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        R.every((F) => I(F.placement) === v ? F.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: P,
+              overflows: R
+            },
+            reset: {
+              placement: $
+            }
+          };
+        let T = (S = R.filter((E) => E.overflows[0] <= 0).sort((E, F) => E.overflows[1] - F.overflows[1])[0]) == null ? void 0 : S.placement;
+        if (!T)
+          switch (d) {
+            case "bestFit": {
+              var M;
+              const E = (M = R.filter((F) => {
+                if (b) {
+                  const W = I(F.placement);
+                  return W === v || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  W === "y";
+                }
+                return !0;
+              }).map((F) => [F.placement, F.overflows.filter((W) => W > 0).reduce((W, dt) => W + dt, 0)]).sort((F, W) => F[1] - W[1])[0]) == null ? void 0 : M[0];
+              E && (T = E);
+              break;
+            }
+            case "initialPlacement":
+              T = c;
+              break;
+          }
+        if (i !== T)
+          return {
+            reset: {
+              placement: T
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function Lt(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function Tt(t) {
+  return Bt.some((e) => t[e] >= 0);
+}
+const ge = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {
+        rects: o,
+        platform: n
+      } = e, {
+        strategy: i = "referenceHidden",
+        ...r
+      } = X(t, e);
+      switch (i) {
+        case "referenceHidden": {
+          const s = await n.detectOverflow(e, {
+            ...r,
+            elementContext: "reference"
+          }), c = Lt(s, o.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: c,
+              referenceHidden: Tt(c)
+            }
+          };
+        }
+        case "escaped": {
+          const s = await n.detectOverflow(e, {
+            ...r,
+            altBoundary: !0
+          }), c = Lt(s, o.floating);
+          return {
+            data: {
+              escapedOffsets: c,
+              escaped: Tt(c)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+function Nt(t) {
+  const e = q(...t.map((r) => r.left)), o = q(...t.map((r) => r.top)), n = _(...t.map((r) => r.right)), i = _(...t.map((r) => r.bottom));
+  return {
+    x: e,
+    y: o,
+    width: n - e,
+    height: i - o
+  };
+}
+function me(t) {
+  const e = t.slice().sort((i, r) => i.y - r.y), o = [];
+  let n = null;
+  for (let i = 0; i < e.length; i++) {
+    const r = e[i];
+    !n || r.y - n.y > n.height / 2 ? o.push([r]) : o[o.length - 1].push(r), n = r;
+  }
+  return o.map((i) => G(Nt(i)));
+}
+const he = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "inline",
+    options: t,
+    async fn(e) {
+      const {
+        placement: o,
+        elements: n,
+        rects: i,
+        platform: r,
+        strategy: s
+      } = e, {
+        padding: c = 2,
+        x: a,
+        y: u
+      } = X(t, e), f = Array.from(await (r.getClientRects == null ? void 0 : r.getClientRects(n.reference)) || []), l = me(f), g = G(Nt(f)), d = yt(c);
+      function p() {
+        if (l.length === 2 && l[0].left > l[1].right && a != null && u != null)
+          return l.find((h) => a > h.left - d.left && a < h.right + d.right && u > h.top - d.top && u < h.bottom + d.bottom) || g;
+        if (l.length >= 2) {
+          if (I(o) === "y") {
+            const R = l[0], C = l[l.length - 1], S = k(o) === "top", M = R.top, P = C.bottom, $ = S ? R.left : C.left, T = S ? R.right : C.right, E = T - $, F = P - M;
+            return {
+              top: M,
+              bottom: P,
+              left: $,
+              right: T,
+              width: E,
+              height: F,
+              x: $,
+              y: M
+            };
+          }
+          const h = k(o) === "left", x = _(...l.map((R) => R.right)), v = q(...l.map((R) => R.left)), y = l.filter((R) => h ? R.left === v : R.right === x), m = y[0].top, A = y[y.length - 1].bottom, b = v, O = x, D = O - b, L = A - m;
+          return {
+            top: m,
+            bottom: A,
+            left: b,
+            right: O,
+            width: D,
+            height: L,
+            x: b,
+            y: m
+          };
+        }
+        return g;
+      }
+      const w = await r.getElementRects({
+        reference: {
+          getBoundingClientRect: p
+        },
+        floating: n.floating,
+        strategy: s
+      });
+      return i.reference.x !== w.reference.x || i.reference.y !== w.reference.y || i.reference.width !== w.reference.width || i.reference.height !== w.reference.height ? {
+        reset: {
+          rects: w
+        }
+      } : {};
+    }
+  };
+}, pe = /* @__PURE__ */ new Set(["left", "top"]);
+async function we(t, e) {
+  const {
+    placement: o,
+    platform: n,
+    elements: i
+  } = t, r = await (n.isRTL == null ? void 0 : n.isRTL(i.floating)), s = k(o), c = N(o), a = I(o) === "y", u = pe.has(s) ? -1 : 1, f = r && a ? -1 : 1, l = X(e, t);
+  let {
+    mainAxis: g,
+    crossAxis: d,
+    alignmentAxis: p
+  } = typeof l == "number" ? {
+    mainAxis: l,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: l.mainAxis || 0,
+    crossAxis: l.crossAxis || 0,
+    alignmentAxis: l.alignmentAxis
+  };
+  return c && typeof p == "number" && (d = c === "end" ? p * -1 : p), a ? {
+    x: d * f,
+    y: g * u
+  } : {
+    x: g * u,
+    y: d * f
+  };
+}
+const xe = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var o, n;
+      const {
+        x: i,
+        y: r,
+        placement: s,
+        middlewareData: c
+      } = e, a = await we(e, t);
+      return s === ((o = c.offset) == null ? void 0 : o.placement) && (n = c.arrow) != null && n.alignmentOffset ? {} : {
+        x: i + a.x,
+        y: r + a.y,
+        data: {
+          ...a,
+          placement: s
+        }
+      };
+    }
+  };
+}, ye = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: o,
+        y: n,
+        placement: i,
+        platform: r
+      } = e, {
+        mainAxis: s = !0,
+        crossAxis: c = !1,
+        limiter: a = {
+          fn: (x) => {
+            let {
+              x: v,
+              y
+            } = x;
+            return {
+              x: v,
+              y
+            };
+          }
+        },
+        ...u
+      } = X(t, e), f = {
+        x: o,
+        y: n
+      }, l = await r.detectOverflow(e, u), g = I(k(i)), d = kt(g);
+      let p = f[d], w = f[g];
+      if (s) {
+        const x = d === "y" ? "top" : "left", v = d === "y" ? "bottom" : "right", y = p + l[x], m = p - l[v];
+        p = ht(y, p, m);
+      }
+      if (c) {
+        const x = g === "y" ? "top" : "left", v = g === "y" ? "bottom" : "right", y = w + l[x], m = w - l[v];
+        w = ht(y, w, m);
+      }
+      const h = a.fn({
+        ...e,
+        [d]: p,
+        [g]: w
+      });
+      return {
+        ...h,
+        data: {
+          x: h.x - o,
+          y: h.y - n,
+          enabled: {
+            [d]: s,
+            [g]: c
+          }
+        }
+      };
+    }
+  };
+}, ve = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      var o, n;
+      const {
+        placement: i,
+        rects: r,
+        platform: s,
+        elements: c
+      } = e, {
+        apply: a = () => {
+        },
+        ...u
+      } = X(t, e), f = await s.detectOverflow(e, u), l = k(i), g = N(i), d = I(i) === "y", {
+        width: p,
+        height: w
+      } = r.floating;
+      let h, x;
+      l === "top" || l === "bottom" ? (h = l, x = g === (await (s.isRTL == null ? void 0 : s.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (x = l, h = g === "end" ? "top" : "bottom");
+      const v = w - f.top - f.bottom, y = p - f.left - f.right, m = q(w - f[h], v), A = q(p - f[x], y), b = !e.middlewareData.shift;
+      let O = m, D = A;
+      if ((o = e.middlewareData.shift) != null && o.enabled.x && (D = y), (n = e.middlewareData.shift) != null && n.enabled.y && (O = v), b && !g) {
+        const R = _(f.left, 0), C = _(f.right, 0), S = _(f.top, 0), M = _(f.bottom, 0);
+        d ? D = p - 2 * (R !== 0 || C !== 0 ? R + C : _(f.left, f.right)) : O = w - 2 * (S !== 0 || M !== 0 ? S + M : _(f.top, f.bottom));
+      }
+      await a({
+        ...e,
+        availableWidth: D,
+        availableHeight: O
+      });
+      const L = await s.getDimensions(c.floating);
+      return p !== L.width || w !== L.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function lt() {
+  return typeof window < "u";
+}
+function tt(t) {
+  return qt(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function B(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function j(t) {
+  var e;
+  return (e = (qt(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function qt(t) {
+  return lt() ? t instanceof Node || t instanceof B(t).Node : !1;
+}
+function H(t) {
+  return lt() ? t instanceof Element || t instanceof B(t).Element : !1;
+}
+function U(t) {
+  return lt() ? t instanceof HTMLElement || t instanceof B(t).HTMLElement : !1;
+}
+function Mt(t) {
+  return !lt() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof B(t).ShadowRoot;
+}
+function ot(t) {
+  const {
+    overflow: e,
+    overflowX: o,
+    overflowY: n,
+    display: i
+  } = V(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + n + o) && i !== "inline" && i !== "contents";
+}
+function be(t) {
+  return /^(table|td|th)$/.test(tt(t));
+}
+function at(t) {
+  try {
+    if (t.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return t.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const Re = /transform|translate|scale|rotate|perspective|filter/, Se = /paint|layout|strict|content/, K = (t) => !!t && t !== "none";
+let gt;
+function vt(t) {
+  const e = H(t) ? V(t) : t;
+  return K(e.transform) || K(e.translate) || K(e.scale) || K(e.rotate) || K(e.perspective) || !bt() && (K(e.backdropFilter) || K(e.filter)) || Re.test(e.willChange || "") || Se.test(e.contain || "");
+}
+function Ae(t) {
+  let e = Y(t);
+  for (; U(e) && !Z(e); ) {
+    if (vt(e))
+      return e;
+    if (at(e))
+      return null;
+    e = Y(e);
+  }
+  return null;
+}
+function bt() {
+  return gt == null && (gt = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), gt;
+}
+function Z(t) {
+  return /^(html|body|#document)$/.test(tt(t));
+}
+function V(t) {
+  return B(t).getComputedStyle(t);
+}
+function ft(t) {
+  return H(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function Y(t) {
+  if (tt(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    Mt(t) && t.host || // Fallback.
+    j(t)
+  );
+  return Mt(e) ? e.host : e;
+}
+function Ht(t) {
+  const e = Y(t);
+  return Z(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : U(e) && ot(e) ? e : Ht(e);
+}
+function nt(t, e, o) {
+  var n;
+  e === void 0 && (e = []), o === void 0 && (o = !0);
+  const i = Ht(t), r = i === ((n = t.ownerDocument) == null ? void 0 : n.body), s = B(i);
+  if (r) {
+    const c = pt(s);
+    return e.concat(s, s.visualViewport || [], ot(i) ? i : [], c && o ? nt(c) : []);
+  } else
+    return e.concat(i, nt(i, [], o));
+}
+function pt(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function Vt(t) {
+  const e = V(t);
+  let o = parseFloat(e.width) || 0, n = parseFloat(e.height) || 0;
+  const i = U(t), r = i ? t.offsetWidth : o, s = i ? t.offsetHeight : n, c = st(o) !== r || st(n) !== s;
+  return c && (o = r, n = s), {
+    width: o,
+    height: n,
+    $: c
+  };
+}
+function Rt(t) {
+  return H(t) ? t : t.contextElement;
+}
+function Q(t) {
+  const e = Rt(t);
+  if (!U(e))
+    return z(1);
+  const o = e.getBoundingClientRect(), {
+    width: n,
+    height: i,
+    $: r
+  } = Vt(e);
+  let s = (r ? st(o.width) : o.width) / n, c = (r ? st(o.height) : o.height) / i;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+const Oe = /* @__PURE__ */ z(0);
+function It(t) {
+  const e = B(t);
+  return !bt() || !e.visualViewport ? Oe : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function Ce(t, e, o) {
+  return e === void 0 && (e = !1), !o || e && o !== B(t) ? !1 : e;
+}
+function J(t, e, o, n) {
+  e === void 0 && (e = !1), o === void 0 && (o = !1);
+  const i = t.getBoundingClientRect(), r = Rt(t);
+  let s = z(1);
+  e && (n ? H(n) && (s = Q(n)) : s = Q(t));
+  const c = Ce(r, o, n) ? It(r) : z(0);
+  let a = (i.left + c.x) / s.x, u = (i.top + c.y) / s.y, f = i.width / s.x, l = i.height / s.y;
+  if (r) {
+    const g = B(r), d = n && H(n) ? B(n) : n;
+    let p = g, w = pt(p);
+    for (; w && n && d !== p; ) {
+      const h = Q(w), x = w.getBoundingClientRect(), v = V(w), y = x.left + (w.clientLeft + parseFloat(v.paddingLeft)) * h.x, m = x.top + (w.clientTop + parseFloat(v.paddingTop)) * h.y;
+      a *= h.x, u *= h.y, f *= h.x, l *= h.y, a += y, u += m, p = B(w), w = pt(p);
+    }
+  }
+  return G({
+    width: f,
+    height: l,
+    x: a,
+    y: u
+  });
+}
+function ut(t, e) {
+  const o = ft(t).scrollLeft;
+  return e ? e.left + o : J(j(t)).left + o;
+}
+function zt(t, e) {
+  const o = t.getBoundingClientRect(), n = o.left + e.scrollLeft - ut(t, o), i = o.top + e.scrollTop;
+  return {
+    x: n,
+    y: i
+  };
+}
+function Ee(t) {
+  let {
+    elements: e,
+    rect: o,
+    offsetParent: n,
+    strategy: i
+  } = t;
+  const r = i === "fixed", s = j(n), c = e ? at(e.floating) : !1;
+  if (n === s || c && r)
+    return o;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = z(1);
+  const f = z(0), l = U(n);
+  if ((l || !l && !r) && ((tt(n) !== "body" || ot(s)) && (a = ft(n)), l)) {
+    const d = J(n);
+    u = Q(n), f.x = d.x + n.clientLeft, f.y = d.y + n.clientTop;
+  }
+  const g = s && !l && !r ? zt(s, a) : z(0);
+  return {
+    width: o.width * u.x,
+    height: o.height * u.y,
+    x: o.x * u.x - a.scrollLeft * u.x + f.x + g.x,
+    y: o.y * u.y - a.scrollTop * u.y + f.y + g.y
+  };
+}
+function Pe(t) {
+  return Array.from(t.getClientRects());
+}
+function De(t) {
+  const e = j(t), o = ft(t), n = t.ownerDocument.body, i = _(e.scrollWidth, e.clientWidth, n.scrollWidth, n.clientWidth), r = _(e.scrollHeight, e.clientHeight, n.scrollHeight, n.clientHeight);
+  let s = -o.scrollLeft + ut(t);
+  const c = -o.scrollTop;
+  return V(n).direction === "rtl" && (s += _(e.clientWidth, n.clientWidth) - i), {
+    width: i,
+    height: r,
+    x: s,
+    y: c
+  };
+}
+const $t = 25;
+function Le(t, e) {
+  const o = B(t), n = j(t), i = o.visualViewport;
+  let r = n.clientWidth, s = n.clientHeight, c = 0, a = 0;
+  if (i) {
+    r = i.width, s = i.height;
+    const f = bt();
+    (!f || f && e === "fixed") && (c = i.offsetLeft, a = i.offsetTop);
+  }
+  const u = ut(n);
+  if (u <= 0) {
+    const f = n.ownerDocument, l = f.body, g = getComputedStyle(l), d = f.compatMode === "CSS1Compat" && parseFloat(g.marginLeft) + parseFloat(g.marginRight) || 0, p = Math.abs(n.clientWidth - l.clientWidth - d);
+    p <= $t && (r -= p);
+  } else u <= $t && (r += u);
+  return {
+    width: r,
+    height: s,
+    x: c,
+    y: a
+  };
+}
+function Te(t, e) {
+  const o = J(t, !0, e === "fixed"), n = o.top + t.clientTop, i = o.left + t.clientLeft, r = U(t) ? Q(t) : z(1), s = t.clientWidth * r.x, c = t.clientHeight * r.y, a = i * r.x, u = n * r.y;
+  return {
+    width: s,
+    height: c,
+    x: a,
+    y: u
+  };
+}
+function Ft(t, e, o) {
+  let n;
+  if (e === "viewport")
+    n = Le(t, o);
+  else if (e === "document")
+    n = De(j(t));
+  else if (H(e))
+    n = Te(e, o);
+  else {
+    const i = It(t);
+    n = {
+      x: e.x - i.x,
+      y: e.y - i.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return G(n);
+}
+function jt(t, e) {
+  const o = Y(t);
+  return o === e || !H(o) || Z(o) ? !1 : V(o).position === "fixed" || jt(o, e);
+}
+function Me(t, e) {
+  const o = e.get(t);
+  if (o)
+    return o;
+  let n = nt(t, [], !1).filter((c) => H(c) && tt(c) !== "body"), i = null;
+  const r = V(t).position === "fixed";
+  let s = r ? Y(t) : t;
+  for (; H(s) && !Z(s); ) {
+    const c = V(s), a = vt(s);
+    !a && c.position === "fixed" && (i = null), (r ? !a && !i : !a && c.position === "static" && !!i && (i.position === "absolute" || i.position === "fixed") || ot(s) && !a && jt(t, s)) ? n = n.filter((f) => f !== s) : i = c, s = Y(s);
+  }
+  return e.set(t, n), n;
+}
+function $e(t) {
+  let {
+    element: e,
+    boundary: o,
+    rootBoundary: n,
+    strategy: i
+  } = t;
+  const s = [...o === "clippingAncestors" ? at(e) ? [] : Me(e, this._c) : [].concat(o), n], c = Ft(e, s[0], i);
+  let a = c.top, u = c.right, f = c.bottom, l = c.left;
+  for (let g = 1; g < s.length; g++) {
+    const d = Ft(e, s[g], i);
+    a = _(d.top, a), u = q(d.right, u), f = q(d.bottom, f), l = _(d.left, l);
+  }
+  return {
+    width: u - l,
+    height: f - a,
+    x: l,
+    y: a
+  };
+}
+function Fe(t) {
+  const {
+    width: e,
+    height: o
+  } = Vt(t);
+  return {
+    width: e,
+    height: o
+  };
+}
+function _e(t, e, o) {
+  const n = U(e), i = j(e), r = o === "fixed", s = J(t, !0, r, e);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = z(0);
+  function u() {
+    a.x = ut(i);
+  }
+  if (n || !n && !r)
+    if ((tt(e) !== "body" || ot(i)) && (c = ft(e)), n) {
+      const d = J(e, !0, r, e);
+      a.x = d.x + e.clientLeft, a.y = d.y + e.clientTop;
+    } else i && u();
+  r && !n && i && u();
+  const f = i && !n && !r ? zt(i, c) : z(0), l = s.left + c.scrollLeft - a.x - f.x, g = s.top + c.scrollTop - a.y - f.y;
+  return {
+    x: l,
+    y: g,
+    width: s.width,
+    height: s.height
+  };
+}
+function mt(t) {
+  return V(t).position === "static";
+}
+function _t(t, e) {
+  if (!U(t) || V(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let o = t.offsetParent;
+  return j(t) === o && (o = o.ownerDocument.body), o;
+}
+function Xt(t, e) {
+  const o = B(t);
+  if (at(t))
+    return o;
+  if (!U(t)) {
+    let i = Y(t);
+    for (; i && !Z(i); ) {
+      if (H(i) && !mt(i))
+        return i;
+      i = Y(i);
+    }
+    return o;
+  }
+  let n = _t(t, e);
+  for (; n && be(n) && mt(n); )
+    n = _t(n, e);
+  return n && Z(n) && mt(n) && !vt(n) ? o : n || Ae(t) || o;
+}
+const Be = async function(t) {
+  const e = this.getOffsetParent || Xt, o = this.getDimensions, n = await o(t.floating);
+  return {
+    reference: _e(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function ke(t) {
+  return V(t).direction === "rtl";
+}
+const We = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ee,
+  getDocumentElement: j,
+  getClippingRect: $e,
+  getOffsetParent: Xt,
+  getElementRects: Be,
+  getClientRects: Pe,
+  getDimensions: Fe,
+  getScale: Q,
+  isElement: H,
+  isRTL: ke
+};
+function Ut(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function Ne(t, e) {
+  let o = null, n;
+  const i = j(t);
+  function r() {
+    var c;
+    clearTimeout(n), (c = o) == null || c.disconnect(), o = null;
+  }
+  function s(c, a) {
+    c === void 0 && (c = !1), a === void 0 && (a = 1), r();
+    const u = t.getBoundingClientRect(), {
+      left: f,
+      top: l,
+      width: g,
+      height: d
+    } = u;
+    if (c || e(), !g || !d)
+      return;
+    const p = it(l), w = it(i.clientWidth - (f + g)), h = it(i.clientHeight - (l + d)), x = it(f), y = {
+      rootMargin: -p + "px " + -w + "px " + -h + "px " + -x + "px",
+      threshold: _(0, q(1, a)) || 1
+    };
+    let m = !0;
+    function A(b) {
+      const O = b[0].intersectionRatio;
+      if (O !== a) {
+        if (!m)
+          return s();
+        O ? s(!1, O) : n = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      O === 1 && !Ut(u, t.getBoundingClientRect()) && s(), m = !1;
+    }
+    try {
+      o = new IntersectionObserver(A, {
+        ...y,
+        // Handle <iframe>s
+        root: i.ownerDocument
+      });
+    } catch {
+      o = new IntersectionObserver(A, y);
+    }
+    o.observe(t);
+  }
+  return s(!0), r;
+}
+function qe(t, e, o, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: r = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = n, u = Rt(t), f = i || r ? [...u ? nt(u) : [], ...e ? nt(e) : []] : [];
+  f.forEach((x) => {
+    i && x.addEventListener("scroll", o, {
+      passive: !0
+    }), r && x.addEventListener("resize", o);
+  });
+  const l = u && c ? Ne(u, o) : null;
+  let g = -1, d = null;
+  s && (d = new ResizeObserver((x) => {
+    let [v] = x;
+    v && v.target === u && d && e && (d.unobserve(e), cancelAnimationFrame(g), g = requestAnimationFrame(() => {
+      var y;
+      (y = d) == null || y.observe(e);
+    })), o();
+  }), u && !a && d.observe(u), e && d.observe(e));
+  let p, w = a ? J(t) : null;
+  a && h();
+  function h() {
+    const x = J(t);
+    w && !Ut(w, x) && o(), w = x, p = requestAnimationFrame(h);
+  }
+  return o(), () => {
+    var x;
+    f.forEach((v) => {
+      i && v.removeEventListener("scroll", o), r && v.removeEventListener("resize", o);
+    }), l == null || l(), (x = d) == null || x.disconnect(), d = null, a && cancelAnimationFrame(p);
+  };
+}
+const He = xe, ln = ue, an = ye, Ve = de, fn = ve, un = ge, dn = ae, gn = he, Ie = (t, e, o) => {
+  const n = /* @__PURE__ */ new Map(), i = {
+    platform: We,
+    ...o
+  }, r = {
+    ...i.platform,
+    _c: n
+  };
+  return le(t, e, {
+    ...i,
+    platform: r
+  });
+};
+function ze(t) {
+  var e;
+  const {
+    char: o,
+    allowSpaces: n,
+    allowToIncludeChar: i,
+    allowedPrefixes: r,
+    startOfLine: s,
+    $position: c
+  } = t, a = n && !i, u = Jt(o), f = new RegExp(`\\s${u}$`), l = s ? "^" : "", g = i ? "" : u, d = a ? new RegExp(`${l}${u}.*?(?=\\s${g}|$)`, "gm") : new RegExp(`${l}(?:^)?${u}[^\\s${g}]*`, "gm"), p = ((e = c.nodeBefore) == null ? void 0 : e.isText) && c.nodeBefore.text;
+  if (!p)
+    return null;
+  const w = c.pos - p.length, h = Array.from(p.matchAll(d)).pop();
+  if (!h || h.input === void 0 || h.index === void 0)
+    return null;
+  const x = h.input.slice(Math.max(0, h.index - 1), h.index), v = new RegExp(`^[${r == null ? void 0 : r.join("")}\0]?$`).test(x);
+  if (r !== null && !v)
+    return null;
+  const y = w + h.index;
+  let m = y + h[0].length;
+  return a && f.test(p.slice(m - 1, m + 1)) && (h[0] += " ", m += 1), y < c.pos && m >= c.pos ? {
+    range: {
+      from: y,
+      to: m
+    },
+    query: h[0].slice(o.length),
+    text: h[0]
+  } : null;
+}
+function je(t) {
+  return t.docChanged ? t.steps.some((e) => {
+    const o = e.slice;
+    if (!(o != null && o.content))
+      return !1;
+    const n = o.content.textBetween(0, o.content.size, `
+`);
+    return /\s/.test(n);
+  }) : !1;
+}
+function Xe(t) {
+  return () => {
+    const e = t.state.selection.$anchor.pos, o = t.view.coordsAtPos(e), { top: n, right: i, bottom: r, left: s } = o;
+    try {
+      return new DOMRect(s, n, i - s, r - n);
+    } catch {
+      return null;
+    }
+  };
+}
+function Ue(t, e, o, n) {
+  return o ? () => {
+    const i = n.getState(t.state), r = i == null ? void 0 : i.decorationId, s = e.dom.querySelector(`[data-decoration-id="${r}"]`);
+    return (s == null ? void 0 : s.getBoundingClientRect()) || null;
+  } : Xe(t);
+}
+function Ye({
+  match: t,
+  dismissedRange: e,
+  state: o,
+  transaction: n,
+  editor: i,
+  shouldResetDismissed: r,
+  effectiveAllowSpaces: s
+}) {
+  return r != null && r({
+    editor: i,
+    state: o,
+    range: e,
+    match: t,
+    transaction: n,
+    allowSpaces: s
+  }) ? !1 : s ? t.range.from === e.from : t.range.from === e.from && !je(n);
+}
+function Ke({
+  view: t,
+  pluginKeyRef: e
+}) {
+  const o = t.state.tr.setMeta(e, { exit: !0 });
+  t.dispatch(o);
+}
+function Je({
+  pluginKey: t,
+  decorationTag: e,
+  decorationClass: o,
+  decorationContent: n,
+  decorationEmptyClass: i,
+  renderer: r,
+  dispatchExit: s
+}) {
+  return {
+    /**
+     * Call the keydown hook if suggestion is active.
+     */
+    handleKeyDown(c, a) {
+      var u, f;
+      const l = t.getState(c.state);
+      return l.active ? a.key === "Escape" || a.key === "Esc" ? ((u = r == null ? void 0 : r.onKeyDown) == null || u.call(r, { view: c, event: a, range: l.range }), s(c), !0) : ((f = r == null ? void 0 : r.onKeyDown) == null ? void 0 : f.call(r, { view: c, event: a, range: l.range })) || !1 : !1;
+    },
+    /**
+     * Setup decorator on the currently active suggestion.
+     */
+    decorations(c) {
+      const a = t.getState(c), { active: u, range: f, decorationId: l, query: g } = a;
+      if (!u)
+        return null;
+      const d = !(g != null && g.length), p = [o];
+      return d && p.push(i), Qt.create(c.doc, [
+        Gt.inline(f.from, f.to, {
+          nodeName: e,
+          class: p.join(" "),
+          "data-decoration-id": l || void 0,
+          "data-decoration-content": n
+        })
+      ]);
+    }
+  };
+}
+function Qe({
+  editor: t,
+  char: e,
+  effectiveAllowSpaces: o,
+  allowToIncludeChar: n,
+  allowedPrefixes: i,
+  startOfLine: r,
+  findSuggestionMatch: s,
+  allow: c,
+  shouldShow: a,
+  shouldKeepDismissed: u,
+  pluginKey: f
+}) {
+  return {
+    /**
+     * Initialize the plugin's internal state.
+     */
+    init() {
+      return {
+        active: !1,
+        range: { from: 0, to: 0 },
+        query: null,
+        text: null,
+        composing: !1,
+        dismissedRange: null
+      };
+    },
+    /**
+     * Apply changes to the plugin state from a view transaction.
+     */
+    apply(l, g, d, p) {
+      const { isEditable: w } = t, { composing: h } = t.view, { selection: x } = l, { empty: v, from: y } = x, m = { ...g }, A = l.getMeta(f);
+      if (A && A.exit)
+        return m.active = !1, m.decorationId = null, m.range = { from: 0, to: 0 }, m.query = null, m.text = null, m.dismissedRange = g.active ? { ...g.range } : g.dismissedRange, m;
+      if (m.composing = h, l.docChanged && m.dismissedRange !== null && (m.dismissedRange = {
+        from: l.mapping.map(m.dismissedRange.from),
+        to: l.mapping.map(m.dismissedRange.to)
+      }), w && (v || t.view.composing)) {
+        (y < g.range.from || y > g.range.to) && !h && !g.composing && (m.active = !1);
+        const b = s({
+          char: e,
+          allowSpaces: o,
+          allowToIncludeChar: n,
+          allowedPrefixes: i,
+          startOfLine: r,
+          $position: x.$from
+        }), O = `id_${Math.floor(Math.random() * 4294967295)}`;
+        b && c({
+          editor: t,
+          state: p,
+          range: b.range,
+          isActive: g.active
+        }) && (!a || a({
+          editor: t,
+          range: b.range,
+          query: b.query,
+          text: b.text,
+          transaction: l
+        })) ? (m.dismissedRange !== null && !u({
+          match: b,
+          dismissedRange: m.dismissedRange,
+          state: p,
+          transaction: l
+        }) && (m.dismissedRange = null), m.dismissedRange === null ? (m.active = !0, m.decorationId = g.decorationId || O, m.range = b.range, m.query = b.query, m.text = b.text) : m.active = !1) : (b || (m.dismissedRange = null), m.active = !1);
+      } else
+        m.active = !1;
+      return m.active || (m.decorationId = null, m.range = { from: 0, to: 0 }, m.query = null, m.text = null), m;
+    }
+  };
+}
+function Ge({
+  editor: t,
+  items: e
+}) {
+  let o = null, n = null, i = null;
+  const r = () => {
+    n !== null && (clearTimeout(n), n = null), i == null || i(), i = null;
+  }, s = (u) => new Promise((f) => {
+    i = f, n = setTimeout(() => {
+      n = null;
+      const l = i;
+      i = null, l == null || l();
+    }, u);
+  }), c = () => {
+    o == null || o.abort(), r(), o = null;
+  };
+  return {
+    abort: c,
+    fetch: async (u, f) => {
+      c(), o = new AbortController();
+      const l = o;
+      if (f > 0 && await s(f), o !== l || l.signal.aborted)
+        return { status: "aborted" };
+      try {
+        const g = await e({
+          editor: t,
+          query: u,
+          signal: l.signal
+        });
+        return o !== l || l.signal.aborted ? { status: "aborted" } : { status: "resolved", items: g };
+      } catch {
+        return o !== l || l.signal.aborted ? { status: "aborted" } : { status: "error" };
+      }
+    }
+  };
+}
+function Ze({
+  placement: t,
+  offset: e,
+  flip: o,
+  floatingUi: n
+}) {
+  var i, r, s, c;
+  const a = [
+    He({
+      mainAxis: (i = e.mainAxis) != null ? i : 4,
+      crossAxis: (r = e.crossAxis) != null ? r : 0
+    })
+  ];
+  return o && a.push(Ve()), (s = n == null ? void 0 : n.middleware) != null && s.length && a.push(...n.middleware), {
+    placement: t,
+    strategy: (c = n == null ? void 0 : n.strategy) != null ? c : "absolute",
+    middleware: a
+  };
+}
+function tn(t) {
+  if (t instanceof HTMLElement)
+    return t;
+  if (typeof t == "string")
+    try {
+      const e = document.querySelector(t);
+      if (e)
+        return e;
+    } catch {
+      return document.body;
+    }
+  return document.body;
+}
+function en({
+  getReferenceRect: t,
+  contextElement: e,
+  config: o,
+  container: n,
+  dismissOnOutsideClick: i,
+  dismiss: r
+}) {
+  return (s, c = {}) => {
+    const a = {
+      getBoundingClientRect: () => {
+        var p;
+        return (p = t()) != null ? p : new DOMRect();
+      },
+      contextElement: e
+    };
+    let u = !1;
+    const f = !s.isConnected;
+    f && tn(n).appendChild(s), c.onPosition || (s.style.visibility = "hidden", s.style.width = "max-content");
+    const g = qe(a, s, () => {
+      Ie(a, s, {
+        placement: o.placement,
+        strategy: o.strategy,
+        middleware: o.middleware
+      }).then(({ x: p, y: w, placement: h, strategy: x }) => {
+        if (c.onPosition) {
+          c.onPosition({ x: p, y: w, placement: h, strategy: x });
+          return;
+        }
+        Object.assign(s.style, {
+          position: x,
+          left: `${p}px`,
+          top: `${w}px`
+        }), u || (u = !0, s.style.visibility = "");
+      });
+    }, c.autoUpdate);
+    let d;
+    return i && (d = (p) => {
+      const w = p.target;
+      !(w instanceof Node) || s.contains(w) || e.contains(w) || r();
+    }, document.addEventListener("pointerdown", d, !0)), () => {
+      g(), d && document.removeEventListener("pointerdown", d, !0), f && s.remove();
+    };
+  };
+}
+function nn({
+  editor: t,
+  pluginKey: e,
+  items: o,
+  renderer: n,
+  minQueryLength: i,
+  debounce: r,
+  initialItems: s,
+  placement: c,
+  offset: a,
+  container: u,
+  flip: f,
+  floatingUi: l,
+  dismissOnOutsideClick: g,
+  command: d,
+  clientRectFor: p,
+  dispatchExit: w
+}) {
+  let h;
+  const x = Ge({
+    editor: t,
+    items: o
+  }), v = Ze({
+    placement: c,
+    offset: a,
+    flip: f,
+    floatingUi: l
+  });
+  function y(m, A) {
+    var b, O, D;
+    switch (m) {
+      case "started":
+        (b = n == null ? void 0 : n.onStart) == null || b.call(n, A);
+        break;
+      case "updated":
+        (O = n == null ? void 0 : n.onUpdate) == null || O.call(n, A);
+        break;
+      case "stopped":
+        (D = n == null ? void 0 : n.onExit) == null || D.call(n, A);
+        break;
+    }
+  }
+  return {
+    update: async (m, A) => {
+      var b, O, D, L;
+      const R = e.getState(A), C = e.getState(m.state);
+      if (!R || !C)
+        return;
+      let S = null;
+      const M = R.query !== C.query, P = R.text !== C.text, $ = R.range.from !== C.range.from || R.range.to !== C.range.to, T = M || P || $;
+      if (!R.active && C.active)
+        S = "started";
+      else if (R.active && !C.active)
+        S = "stopped";
+      else if (C.active && T)
+        S = "updated";
+      else
+        return;
+      const E = S === "stopped" ? R : C, F = m.dom.querySelector(`[data-decoration-id="${E.decorationId}"]`), W = p(m, F), dt = i === 0 || (E.query ? E.query.length >= i : !1), St = (S === "started" || S === "updated") && dt;
+      if (h = {
+        editor: t,
+        range: E.range,
+        query: E.query || "",
+        text: E.text || "",
+        items: s ?? [],
+        command: (et) => d({
+          editor: t,
+          range: E.range,
+          props: et
+        }),
+        decorationNode: F,
+        clientRect: W,
+        loading: St,
+        placement: c,
+        offset: { mainAxis: (b = a.mainAxis) != null ? b : 4, crossAxis: (O = a.crossAxis) != null ? O : 0 },
+        container: u,
+        flip: f,
+        floatingUi: v,
+        mount: en({
+          getReferenceRect: W,
+          contextElement: m.dom,
+          config: v,
+          container: u,
+          dismissOnOutsideClick: g,
+          dismiss: () => w(t.view)
+        })
+      }, S === "started" && ((D = n == null ? void 0 : n.onBeforeStart) == null || D.call(n, h)), S === "updated" && ((L = n == null ? void 0 : n.onBeforeUpdate) == null || L.call(n, h)), S === "started" && y(S, h), S === "started" || S === "updated")
+        if (!St)
+          x.abort(), h = { ...h, items: s ?? [], loading: !1 };
+        else {
+          h = { ...h, items: s ?? [], loading: !0 }, S = "updated", y(S, h);
+          const et = await x.fetch(E.query || "", r);
+          if (et.status === "aborted")
+            return;
+          const At = e.getState(m.state);
+          if (!(At != null && At.active)) {
+            x.abort();
+            return;
+          }
+          h = et.status === "resolved" ? {
+            ...h,
+            items: et.items,
+            loading: !1
+          } : {
+            ...h,
+            loading: !1
+          };
+        }
+      if (S === "stopped") {
+        x.abort(), y(S, h), h = void 0;
+        return;
+      }
+      S === "updated" && y(S, h);
+    },
+    destroy: () => {
+      var m;
+      x.abort(), h && ((m = n == null ? void 0 : n.onExit) == null || m.call(n, h));
+    }
+  };
+}
+var on = new Yt("suggestion");
+function mn({
+  pluginKey: t = on,
+  editor: e,
+  char: o = "@",
+  allowSpaces: n = !1,
+  allowToIncludeChar: i = !1,
+  allowedPrefixes: r = [" "],
+  startOfLine: s = !1,
+  decorationTag: c = "span",
+  decorationClass: a = "suggestion",
+  decorationContent: u = "",
+  decorationEmptyClass: f = "is-empty",
+  command: l = () => null,
+  items: g = () => [],
+  minQueryLength: d = 0,
+  debounce: p = 0,
+  initialItems: w,
+  placement: h = "bottom-start",
+  offset: x = {},
+  container: v,
+  flip: y = !0,
+  floatingUi: m,
+  dismissOnOutsideClick: A = !0,
+  render: b = () => ({}),
+  allow: O = () => !0,
+  findSuggestionMatch: D = ze,
+  shouldShow: L,
+  shouldResetDismissed: R
+}) {
+  const C = b == null ? void 0 : b(), S = n && !i, M = (T, E) => Ue(e, T, E, t);
+  function P(T) {
+    return Ye({
+      ...T,
+      editor: e,
+      shouldResetDismissed: R,
+      effectiveAllowSpaces: S
+    });
+  }
+  const $ = (T) => Ke({
+    view: T,
+    pluginKeyRef: t
+  });
+  return new Kt({
+    key: t,
+    view: () => nn({
+      editor: e,
+      pluginKey: t,
+      items: g,
+      renderer: C,
+      minQueryLength: d,
+      debounce: p,
+      initialItems: w,
+      placement: h,
+      offset: x,
+      container: v,
+      flip: y,
+      floatingUi: m,
+      dismissOnOutsideClick: A,
+      command: l,
+      clientRectFor: M,
+      dispatchExit: $
+    }),
+    state: Qe({
+      editor: e,
+      char: o,
+      effectiveAllowSpaces: S,
+      allowToIncludeChar: i,
+      allowedPrefixes: r,
+      startOfLine: s,
+      findSuggestionMatch: D,
+      allow: O,
+      shouldShow: L,
+      shouldKeepDismissed: P,
+      pluginKey: t
+    }),
+    props: Je({
+      pluginKey: t,
+      decorationTag: c,
+      decorationClass: a,
+      decorationContent: u,
+      decorationEmptyClass: f,
+      renderer: C,
+      dispatchExit: $
+    })
+  });
+}
+export {
+  mn as S,
+  dn as a,
+  fn as b,
+  Ie as c,
+  ln as d,
+  Ve as f,
+  un as h,
+  gn as i,
+  He as o,
+  an as s
+};