reactjs-tiptap-editor 0.3.30 → 0.4.0

package/lib/dom-dataset-lYeH6gfI.js

@@ -0,0 +1,2361 @@
+import B, { createContext as st, useRef as Pt, useState as at, useDebugValue as ct, useEffect as lt, forwardRef as qt, useLayoutEffect as Mt, useContext as ut, createRef as Nt, memo as Vt, createElement as jt, version as Le } from "react";
+import It, { flushSync as Bt } from "react-dom";
+import { jsxs as Wt, Fragment as ft, jsx as Z } from "react/jsx-runtime";
+import { Q as $t, R as kt, U as Ft } from "./index-kbO3iWqL.js";
+var ae = { exports: {} }, ve = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Pe;
+function Ht() {
+  if (Pe) return ve;
+  Pe = 1;
+  var e = B;
+  function t(c, m) {
+    return c === m && (c !== 0 || 1 / c === 1 / m) || c !== c && m !== m;
+  }
+  var r = typeof Object.is == "function" ? Object.is : t, n = e.useState, i = e.useEffect, o = e.useLayoutEffect, s = e.useDebugValue;
+  function a(c, m) {
+    var f = m(), g = n({ inst: { value: f, getSnapshot: m } }), d = g[0].inst, p = g[1];
+    return o(
+      function() {
+        d.value = f, d.getSnapshot = m, l(d) && p({ inst: d });
+      },
+      [c, f, m]
+    ), i(
+      function() {
+        return l(d) && p({ inst: d }), c(function() {
+          l(d) && p({ inst: d });
+        });
+      },
+      [c]
+    ), s(f), f;
+  }
+  function l(c) {
+    var m = c.getSnapshot;
+    c = c.value;
+    try {
+      var f = m();
+      return !r(c, f);
+    } catch {
+      return !0;
+    }
+  }
+  function u(c, m) {
+    return m();
+  }
+  var h = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? u : a;
+  return ve.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : h, ve;
+}
+var ye = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var qe;
+function Ut() {
+  return qe || (qe = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(f, g) {
+      return f === g && (f !== 0 || 1 / f === 1 / g) || f !== f && g !== g;
+    }
+    function t(f, g) {
+      h || i.startTransition === void 0 || (h = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var d = g();
+      if (!c) {
+        var p = g();
+        o(d, p) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), c = !0);
+      }
+      p = s({
+        inst: { value: d, getSnapshot: g }
+      });
+      var v = p[0].inst, y = p[1];
+      return l(
+        function() {
+          v.value = d, v.getSnapshot = g, r(v) && y({ inst: v });
+        },
+        [f, d, g]
+      ), a(
+        function() {
+          return r(v) && y({ inst: v }), f(function() {
+            r(v) && y({ inst: v });
+          });
+        },
+        [f]
+      ), u(d), d;
+    }
+    function r(f) {
+      var g = f.getSnapshot;
+      f = f.value;
+      try {
+        var d = g();
+        return !o(f, d);
+      } catch {
+        return !0;
+      }
+    }
+    function n(f, g) {
+      return g();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var i = B, o = typeof Object.is == "function" ? Object.is : e, s = i.useState, a = i.useEffect, l = i.useLayoutEffect, u = i.useDebugValue, h = !1, c = !1, m = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? n : t;
+    ye.useSyncExternalStore = i.useSyncExternalStore !== void 0 ? i.useSyncExternalStore : m, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), ye;
+}
+var Me;
+function Re() {
+  return Me || (Me = 1, process.env.NODE_ENV === "production" ? ae.exports = Ht() : ae.exports = Ut()), ae.exports;
+}
+var dt = Re(), Gt = Object.getOwnPropertyNames, zt = Object.getOwnPropertySymbols, Kt = Object.prototype.hasOwnProperty;
+function Ne(e, t) {
+  return function(n, i, o) {
+    return e(n, i, o) && t(n, i, o);
+  };
+}
+function ce(e) {
+  return function(r, n, i) {
+    if (!r || !n || typeof r != "object" || typeof n != "object")
+      return e(r, n, i);
+    var o = i.cache, s = o.get(r), a = o.get(n);
+    if (s && a)
+      return s === n && a === r;
+    o.set(r, n), o.set(n, r);
+    var l = e(r, n, i);
+    return o.delete(r), o.delete(n), l;
+  };
+}
+function Xt(e) {
+  return e != null ? e[Symbol.toStringTag] : void 0;
+}
+function Ve(e) {
+  return Gt(e).concat(zt(e));
+}
+var Yt = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  Object.hasOwn || (function(e, t) {
+    return Kt.call(e, t);
+  })
+);
+function J(e, t) {
+  return e === t || !e && !t && e !== e && t !== t;
+}
+var Jt = "__v", Qt = "__o", Zt = "_owner", je = Object.getOwnPropertyDescriptor, Ie = Object.keys;
+function en(e, t, r) {
+  var n = e.length;
+  if (t.length !== n)
+    return !1;
+  for (; n-- > 0; )
+    if (!r.equals(e[n], t[n], n, n, e, t, r))
+      return !1;
+  return !0;
+}
+function tn(e, t) {
+  return J(e.getTime(), t.getTime());
+}
+function nn(e, t) {
+  return e.name === t.name && e.message === t.message && e.cause === t.cause && e.stack === t.stack;
+}
+function rn(e, t) {
+  return e === t;
+}
+function Be(e, t, r) {
+  var n = e.size;
+  if (n !== t.size)
+    return !1;
+  if (!n)
+    return !0;
+  for (var i = new Array(n), o = e.entries(), s, a, l = 0; (s = o.next()) && !s.done; ) {
+    for (var u = t.entries(), h = !1, c = 0; (a = u.next()) && !a.done; ) {
+      if (i[c]) {
+        c++;
+        continue;
+      }
+      var m = s.value, f = a.value;
+      if (r.equals(m[0], f[0], l, c, e, t, r) && r.equals(m[1], f[1], m[0], f[0], e, t, r)) {
+        h = i[c] = !0;
+        break;
+      }
+      c++;
+    }
+    if (!h)
+      return !1;
+    l++;
+  }
+  return !0;
+}
+var on = J;
+function sn(e, t, r) {
+  var n = Ie(e), i = n.length;
+  if (Ie(t).length !== i)
+    return !1;
+  for (; i-- > 0; )
+    if (!ht(e, t, r, n[i]))
+      return !1;
+  return !0;
+}
+function ie(e, t, r) {
+  var n = Ve(e), i = n.length;
+  if (Ve(t).length !== i)
+    return !1;
+  for (var o, s, a; i-- > 0; )
+    if (o = n[i], !ht(e, t, r, o) || (s = je(e, o), a = je(t, o), (s || a) && (!s || !a || s.configurable !== a.configurable || s.enumerable !== a.enumerable || s.writable !== a.writable)))
+      return !1;
+  return !0;
+}
+function an(e, t) {
+  return J(e.valueOf(), t.valueOf());
+}
+function cn(e, t) {
+  return e.source === t.source && e.flags === t.flags;
+}
+function We(e, t, r) {
+  var n = e.size;
+  if (n !== t.size)
+    return !1;
+  if (!n)
+    return !0;
+  for (var i = new Array(n), o = e.values(), s, a; (s = o.next()) && !s.done; ) {
+    for (var l = t.values(), u = !1, h = 0; (a = l.next()) && !a.done; ) {
+      if (!i[h] && r.equals(s.value, a.value, s.value, a.value, e, t, r)) {
+        u = i[h] = !0;
+        break;
+      }
+      h++;
+    }
+    if (!u)
+      return !1;
+  }
+  return !0;
+}
+function ln(e, t) {
+  var r = e.length;
+  if (t.length !== r)
+    return !1;
+  for (; r-- > 0; )
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+function un(e, t) {
+  return e.hostname === t.hostname && e.pathname === t.pathname && e.protocol === t.protocol && e.port === t.port && e.hash === t.hash && e.username === t.username && e.password === t.password;
+}
+function ht(e, t, r, n) {
+  return (n === Zt || n === Qt || n === Jt) && (e.$$typeof || t.$$typeof) ? !0 : Yt(t, n) && r.equals(e[n], t[n], n, n, e, t, r);
+}
+var fn = "[object Arguments]", dn = "[object Boolean]", hn = "[object Date]", pn = "[object Error]", mn = "[object Map]", gn = "[object Number]", vn = "[object Object]", yn = "[object RegExp]", wn = "[object Set]", En = "[object String]", bn = "[object URL]", Sn = Array.isArray, $e = typeof ArrayBuffer < "u" && typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView : null, ke = Object.assign, xn = Object.prototype.toString.call.bind(Object.prototype.toString);
+function On(e) {
+  var t = e.areArraysEqual, r = e.areDatesEqual, n = e.areErrorsEqual, i = e.areFunctionsEqual, o = e.areMapsEqual, s = e.areNumbersEqual, a = e.areObjectsEqual, l = e.arePrimitiveWrappersEqual, u = e.areRegExpsEqual, h = e.areSetsEqual, c = e.areTypedArraysEqual, m = e.areUrlsEqual, f = e.unknownTagComparators;
+  return function(d, p, v) {
+    if (d === p)
+      return !0;
+    if (d == null || p == null)
+      return !1;
+    var y = typeof d;
+    if (y !== typeof p)
+      return !1;
+    if (y !== "object")
+      return y === "number" ? s(d, p, v) : y === "function" ? i(d, p, v) : !1;
+    var w = d.constructor;
+    if (w !== p.constructor)
+      return !1;
+    if (w === Object)
+      return a(d, p, v);
+    if (Sn(d))
+      return t(d, p, v);
+    if ($e != null && $e(d))
+      return c(d, p, v);
+    if (w === Date)
+      return r(d, p, v);
+    if (w === RegExp)
+      return u(d, p, v);
+    if (w === Map)
+      return o(d, p, v);
+    if (w === Set)
+      return h(d, p, v);
+    var E = xn(d);
+    if (E === hn)
+      return r(d, p, v);
+    if (E === yn)
+      return u(d, p, v);
+    if (E === mn)
+      return o(d, p, v);
+    if (E === wn)
+      return h(d, p, v);
+    if (E === vn)
+      return typeof d.then != "function" && typeof p.then != "function" && a(d, p, v);
+    if (E === bn)
+      return m(d, p, v);
+    if (E === pn)
+      return n(d, p, v);
+    if (E === fn)
+      return a(d, p, v);
+    if (E === dn || E === gn || E === En)
+      return l(d, p, v);
+    if (f) {
+      var S = f[E];
+      if (!S) {
+        var b = Xt(d);
+        b && (S = f[b]);
+      }
+      if (S)
+        return S(d, p, v);
+    }
+    return !1;
+  };
+}
+function Rn(e) {
+  var t = e.circular, r = e.createCustomConfig, n = e.strict, i = {
+    areArraysEqual: n ? ie : en,
+    areDatesEqual: tn,
+    areErrorsEqual: nn,
+    areFunctionsEqual: rn,
+    areMapsEqual: n ? Ne(Be, ie) : Be,
+    areNumbersEqual: on,
+    areObjectsEqual: n ? ie : sn,
+    arePrimitiveWrappersEqual: an,
+    areRegExpsEqual: cn,
+    areSetsEqual: n ? Ne(We, ie) : We,
+    areTypedArraysEqual: n ? ie : ln,
+    areUrlsEqual: un,
+    unknownTagComparators: void 0
+  };
+  if (r && (i = ke({}, i, r(i))), t) {
+    var o = ce(i.areArraysEqual), s = ce(i.areMapsEqual), a = ce(i.areObjectsEqual), l = ce(i.areSetsEqual);
+    i = ke({}, i, {
+      areArraysEqual: o,
+      areMapsEqual: s,
+      areObjectsEqual: a,
+      areSetsEqual: l
+    });
+  }
+  return i;
+}
+function An(e) {
+  return function(t, r, n, i, o, s, a) {
+    return e(t, r, a);
+  };
+}
+function Cn(e) {
+  var t = e.circular, r = e.comparator, n = e.createState, i = e.equals, o = e.strict;
+  if (n)
+    return function(l, u) {
+      var h = n(), c = h.cache, m = c === void 0 ? t ? /* @__PURE__ */ new WeakMap() : void 0 : c, f = h.meta;
+      return r(l, u, {
+        cache: m,
+        equals: i,
+        meta: f,
+        strict: o
+      });
+    };
+  if (t)
+    return function(l, u) {
+      return r(l, u, {
+        cache: /* @__PURE__ */ new WeakMap(),
+        equals: i,
+        meta: void 0,
+        strict: o
+      });
+    };
+  var s = {
+    cache: void 0,
+    equals: i,
+    meta: void 0,
+    strict: o
+  };
+  return function(l, u) {
+    return r(l, u, s);
+  };
+}
+var _n = Y();
+Y({ strict: !0 });
+Y({ circular: !0 });
+Y({
+  circular: !0,
+  strict: !0
+});
+Y({
+  createInternalComparator: function() {
+    return J;
+  }
+});
+Y({
+  strict: !0,
+  createInternalComparator: function() {
+    return J;
+  }
+});
+Y({
+  circular: !0,
+  createInternalComparator: function() {
+    return J;
+  }
+});
+Y({
+  circular: !0,
+  createInternalComparator: function() {
+    return J;
+  },
+  strict: !0
+});
+function Y(e) {
+  e === void 0 && (e = {});
+  var t = e.circular, r = t === void 0 ? !1 : t, n = e.createInternalComparator, i = e.createState, o = e.strict, s = o === void 0 ? !1 : o, a = Rn(e), l = On(a), u = n ? n(l) : An(l);
+  return Cn({ circular: r, comparator: l, createState: i, equals: u, strict: s });
+}
+var le = { exports: {} }, we = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Fe;
+function Dn() {
+  if (Fe) return we;
+  Fe = 1;
+  var e = B, t = Re();
+  function r(u, h) {
+    return u === h && (u !== 0 || 1 / u === 1 / h) || u !== u && h !== h;
+  }
+  var n = typeof Object.is == "function" ? Object.is : r, i = t.useSyncExternalStore, o = e.useRef, s = e.useEffect, a = e.useMemo, l = e.useDebugValue;
+  return we.useSyncExternalStoreWithSelector = function(u, h, c, m, f) {
+    var g = o(null);
+    if (g.current === null) {
+      var d = { hasValue: !1, value: null };
+      g.current = d;
+    } else d = g.current;
+    g = a(
+      function() {
+        function v(b) {
+          if (!y) {
+            if (y = !0, w = b, b = m(b), f !== void 0 && d.hasValue) {
+              var O = d.value;
+              if (f(O, b))
+                return E = O;
+            }
+            return E = b;
+          }
+          if (O = E, n(w, b)) return O;
+          var R = m(b);
+          return f !== void 0 && f(O, R) ? (w = b, O) : (w = b, E = R);
+        }
+        var y = !1, w, E, S = c === void 0 ? null : c;
+        return [
+          function() {
+            return v(h());
+          },
+          S === null ? void 0 : function() {
+            return v(S());
+          }
+        ];
+      },
+      [h, c, m, f]
+    );
+    var p = i(u, g[0], g[1]);
+    return s(
+      function() {
+        d.hasValue = !0, d.value = p;
+      },
+      [p]
+    ), l(p), p;
+  }, we;
+}
+var Ee = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var He;
+function Tn() {
+  return He || (He = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(u, h) {
+      return u === h && (u !== 0 || 1 / u === 1 / h) || u !== u && h !== h;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var t = B, r = Re(), n = typeof Object.is == "function" ? Object.is : e, i = r.useSyncExternalStore, o = t.useRef, s = t.useEffect, a = t.useMemo, l = t.useDebugValue;
+    Ee.useSyncExternalStoreWithSelector = function(u, h, c, m, f) {
+      var g = o(null);
+      if (g.current === null) {
+        var d = { hasValue: !1, value: null };
+        g.current = d;
+      } else d = g.current;
+      g = a(
+        function() {
+          function v(b) {
+            if (!y) {
+              if (y = !0, w = b, b = m(b), f !== void 0 && d.hasValue) {
+                var O = d.value;
+                if (f(O, b))
+                  return E = O;
+              }
+              return E = b;
+            }
+            if (O = E, n(w, b))
+              return O;
+            var R = m(b);
+            return f !== void 0 && f(O, R) ? (w = b, O) : (w = b, E = R);
+          }
+          var y = !1, w, E, S = c === void 0 ? null : c;
+          return [
+            function() {
+              return v(h());
+            },
+            S === null ? void 0 : function() {
+              return v(S());
+            }
+          ];
+        },
+        [h, c, m, f]
+      );
+      var p = i(u, g[0], g[1]);
+      return s(
+        function() {
+          d.hasValue = !0, d.value = p;
+        },
+        [p]
+      ), l(p), p;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Ee;
+}
+var Ue;
+function Ln() {
+  return Ue || (Ue = 1, process.env.NODE_ENV === "production" ? le.exports = Dn() : le.exports = Tn()), le.exports;
+}
+var Pn = Ln(), qn = (...e) => (t) => {
+  e.forEach((r) => {
+    typeof r == "function" ? r(t) : r && (r.current = t);
+  });
+}, Mn = ({ contentComponent: e }) => {
+  const t = dt.useSyncExternalStore(
+    e.subscribe,
+    e.getSnapshot,
+    e.getServerSnapshot
+  );
+  return /* @__PURE__ */ Z(ft, { children: Object.values(t) });
+};
+function Nn() {
+  const e = /* @__PURE__ */ new Set();
+  let t = {};
+  return {
+    /**
+     * Subscribe to the editor instance's changes.
+     */
+    subscribe(r) {
+      return e.add(r), () => {
+        e.delete(r);
+      };
+    },
+    getSnapshot() {
+      return t;
+    },
+    getServerSnapshot() {
+      return t;
+    },
+    /**
+     * Adds a new NodeView Renderer to the editor.
+     */
+    setRenderer(r, n) {
+      t = {
+        ...t,
+        [r]: It.createPortal(n.reactElement, n.element, r)
+      }, e.forEach((i) => i());
+    },
+    /**
+     * Removes a NodeView Renderer from the editor.
+     */
+    removeRenderer(r) {
+      const n = { ...t };
+      delete n[r], t = n, e.forEach((i) => i());
+    }
+  };
+}
+var Vn = class extends B.Component {
+  constructor(e) {
+    var t;
+    super(e), this.editorContentRef = B.createRef(), this.initialized = !1, this.state = {
+      hasContentComponentInitialized: !!((t = e.editor) != null && t.contentComponent)
+    };
+  }
+  componentDidMount() {
+    this.init();
+  }
+  componentDidUpdate() {
+    this.init();
+  }
+  init() {
+    const e = this.props.editor;
+    if (e && !e.isDestroyed && e.options.element) {
+      if (e.contentComponent)
+        return;
+      const t = this.editorContentRef.current;
+      t.append(e.view.dom), e.setOptions({
+        element: t
+      }), e.contentComponent = Nn(), this.state.hasContentComponentInitialized || (this.unsubscribeToContentComponent = e.contentComponent.subscribe(() => {
+        this.setState((r) => r.hasContentComponentInitialized ? r : {
+          hasContentComponentInitialized: !0
+        }), this.unsubscribeToContentComponent && this.unsubscribeToContentComponent();
+      })), e.createNodeViews(), this.initialized = !0;
+    }
+  }
+  componentWillUnmount() {
+    var e;
+    const t = this.props.editor;
+    if (t) {
+      this.initialized = !1, t.isDestroyed || t.view.setProps({
+        nodeViews: {}
+      }), this.unsubscribeToContentComponent && this.unsubscribeToContentComponent(), t.contentComponent = null;
+      try {
+        if (!((e = t.view.dom) != null && e.firstChild))
+          return;
+        const r = document.createElement("div");
+        r.append(t.view.dom), t.setOptions({
+          element: r
+        });
+      } catch {
+      }
+    }
+  }
+  render() {
+    const { editor: e, innerRef: t, ...r } = this.props;
+    return /* @__PURE__ */ Wt(ft, { children: [
+      /* @__PURE__ */ Z("div", { ref: qn(t, this.editorContentRef), ...r }),
+      (e == null ? void 0 : e.contentComponent) && /* @__PURE__ */ Z(Mn, { contentComponent: e.contentComponent })
+    ] });
+  }
+}, jn = qt(
+  (e, t) => {
+    const r = B.useMemo(() => Math.floor(Math.random() * 4294967295).toString(), [e.editor]);
+    return B.createElement(Vn, {
+      key: r,
+      innerRef: t,
+      ...e
+    });
+  }
+), Gr = B.memo(jn), In = typeof window < "u" ? Mt : lt, Bn = class {
+  constructor(e) {
+    this.transactionNumber = 0, this.lastTransactionNumber = 0, this.subscribers = /* @__PURE__ */ new Set(), this.editor = e, this.lastSnapshot = { editor: e, transactionNumber: 0 }, this.getSnapshot = this.getSnapshot.bind(this), this.getServerSnapshot = this.getServerSnapshot.bind(this), this.watch = this.watch.bind(this), this.subscribe = this.subscribe.bind(this);
+  }
+  /**
+   * Get the current editor instance.
+   */
+  getSnapshot() {
+    return this.transactionNumber === this.lastTransactionNumber ? this.lastSnapshot : (this.lastTransactionNumber = this.transactionNumber, this.lastSnapshot = { editor: this.editor, transactionNumber: this.transactionNumber }, this.lastSnapshot);
+  }
+  /**
+   * Always disable the editor on the server-side.
+   */
+  getServerSnapshot() {
+    return { editor: null, transactionNumber: 0 };
+  }
+  /**
+   * Subscribe to the editor instance's changes.
+   */
+  subscribe(e) {
+    return this.subscribers.add(e), () => {
+      this.subscribers.delete(e);
+    };
+  }
+  /**
+   * Watch the editor instance for changes.
+   */
+  watch(e) {
+    if (this.editor = e, this.editor) {
+      const t = () => {
+        this.transactionNumber += 1, this.subscribers.forEach((n) => n());
+      }, r = this.editor;
+      return r.on("transaction", t), () => {
+        r.off("transaction", t);
+      };
+    }
+  }
+};
+function Wn(e) {
+  var t;
+  const [r] = at(() => new Bn(e.editor)), n = Pn.useSyncExternalStoreWithSelector(
+    r.subscribe,
+    r.getSnapshot,
+    r.getServerSnapshot,
+    e.selector,
+    (t = e.equalityFn) != null ? t : _n
+  );
+  return In(() => r.watch(e.editor), [e.editor, r]), ct(n), n;
+}
+var Ge = process.env.NODE_ENV !== "production", Se = typeof window > "u", $n = Se || !!(typeof window < "u" && window.next), kn = class pt {
+  constructor(t) {
+    this.editor = null, this.subscriptions = /* @__PURE__ */ new Set(), this.isComponentMounted = !1, this.previousDeps = null, this.instanceId = "", this.options = t, this.subscriptions = /* @__PURE__ */ new Set(), this.setEditor(this.getInitialEditor()), this.scheduleDestroy(), this.getEditor = this.getEditor.bind(this), this.getServerSnapshot = this.getServerSnapshot.bind(this), this.subscribe = this.subscribe.bind(this), this.refreshEditorInstance = this.refreshEditorInstance.bind(this), this.scheduleDestroy = this.scheduleDestroy.bind(this), this.onRender = this.onRender.bind(this), this.createEditor = this.createEditor.bind(this);
+  }
+  setEditor(t) {
+    this.editor = t, this.instanceId = Math.random().toString(36).slice(2, 9), this.subscriptions.forEach((r) => r());
+  }
+  getInitialEditor() {
+    if (this.options.current.immediatelyRender === void 0) {
+      if (Se || $n) {
+        if (Ge)
+          throw new Error(
+            "Tiptap Error: SSR has been detected, please set `immediatelyRender` explicitly to `false` to avoid hydration mismatches."
+          );
+        return null;
+      }
+      return this.createEditor();
+    }
+    if (this.options.current.immediatelyRender && Se && Ge)
+      throw new Error(
+        "Tiptap Error: SSR has been detected, and `immediatelyRender` has been set to `true` this is an unsupported configuration that may result in errors, explicitly set `immediatelyRender` to `false` to avoid hydration mismatches."
+      );
+    return this.options.current.immediatelyRender ? this.createEditor() : null;
+  }
+  /**
+   * Create a new editor instance. And attach event listeners.
+   */
+  createEditor() {
+    const t = {
+      ...this.options.current,
+      // Always call the most recent version of the callback function by default
+      onBeforeCreate: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onBeforeCreate) == null ? void 0 : o.call(i, ...n);
+      },
+      onBlur: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onBlur) == null ? void 0 : o.call(i, ...n);
+      },
+      onCreate: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onCreate) == null ? void 0 : o.call(i, ...n);
+      },
+      onDestroy: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onDestroy) == null ? void 0 : o.call(i, ...n);
+      },
+      onFocus: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onFocus) == null ? void 0 : o.call(i, ...n);
+      },
+      onSelectionUpdate: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onSelectionUpdate) == null ? void 0 : o.call(i, ...n);
+      },
+      onTransaction: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onTransaction) == null ? void 0 : o.call(i, ...n);
+      },
+      onUpdate: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onUpdate) == null ? void 0 : o.call(i, ...n);
+      },
+      onContentError: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onContentError) == null ? void 0 : o.call(i, ...n);
+      },
+      onDrop: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onDrop) == null ? void 0 : o.call(i, ...n);
+      },
+      onPaste: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onPaste) == null ? void 0 : o.call(i, ...n);
+      },
+      onDelete: (...n) => {
+        var i, o;
+        return (o = (i = this.options.current).onDelete) == null ? void 0 : o.call(i, ...n);
+      }
+    };
+    return new $t(t);
+  }
+  /**
+   * Get the current editor instance.
+   */
+  getEditor() {
+    return this.editor;
+  }
+  /**
+   * Always disable the editor on the server-side.
+   */
+  getServerSnapshot() {
+    return null;
+  }
+  /**
+   * Subscribe to the editor instance's changes.
+   */
+  subscribe(t) {
+    return this.subscriptions.add(t), () => {
+      this.subscriptions.delete(t);
+    };
+  }
+  static compareOptions(t, r) {
+    return Object.keys(t).every((n) => [
+      "onCreate",
+      "onBeforeCreate",
+      "onDestroy",
+      "onUpdate",
+      "onTransaction",
+      "onFocus",
+      "onBlur",
+      "onSelectionUpdate",
+      "onContentError",
+      "onDrop",
+      "onPaste"
+    ].includes(n) ? !0 : n === "extensions" && t.extensions && r.extensions ? t.extensions.length !== r.extensions.length ? !1 : t.extensions.every((i, o) => {
+      var s;
+      return i === ((s = r.extensions) == null ? void 0 : s[o]);
+    }) : t[n] === r[n]);
+  }
+  /**
+   * On each render, we will create, update, or destroy the editor instance.
+   * @param deps The dependencies to watch for changes
+   * @returns A cleanup function
+   */
+  onRender(t) {
+    return () => (this.isComponentMounted = !0, clearTimeout(this.scheduledDestructionTimeout), this.editor && !this.editor.isDestroyed && t.length === 0 ? pt.compareOptions(this.options.current, this.editor.options) || this.editor.setOptions({
+      ...this.options.current,
+      editable: this.editor.isEditable
+    }) : this.refreshEditorInstance(t), () => {
+      this.isComponentMounted = !1, this.scheduleDestroy();
+    });
+  }
+  /**
+   * Recreate the editor instance if the dependencies have changed.
+   */
+  refreshEditorInstance(t) {
+    if (this.editor && !this.editor.isDestroyed) {
+      if (this.previousDeps === null) {
+        this.previousDeps = t;
+        return;
+      }
+      if (this.previousDeps.length === t.length && this.previousDeps.every((n, i) => n === t[i]))
+        return;
+    }
+    this.editor && !this.editor.isDestroyed && this.editor.destroy(), this.setEditor(this.createEditor()), this.previousDeps = t;
+  }
+  /**
+   * Schedule the destruction of the editor instance.
+   * This will only destroy the editor if it was not mounted on the next tick.
+   * This is to avoid destroying the editor instance when it's actually still mounted.
+   */
+  scheduleDestroy() {
+    const t = this.instanceId, r = this.editor;
+    this.scheduledDestructionTimeout = setTimeout(() => {
+      if (this.isComponentMounted && this.instanceId === t) {
+        r && r.setOptions(this.options.current);
+        return;
+      }
+      r && !r.isDestroyed && (r.destroy(), this.instanceId === t && this.setEditor(null));
+    }, 1);
+  }
+};
+function zr(e = {}, t = []) {
+  const r = Pt(e);
+  r.current = e;
+  const [n] = at(() => new kn(r)), i = dt.useSyncExternalStore(
+    n.subscribe,
+    n.getEditor,
+    n.getServerSnapshot
+  );
+  return ct(i), lt(n.onRender(t)), Wn({
+    editor: i,
+    selector: ({ transactionNumber: o }) => e.shouldRerenderOnTransaction === !1 || e.shouldRerenderOnTransaction === void 0 ? null : e.immediatelyRender && o === 0 ? 0 : o + 1
+  }), i;
+}
+var mt = st({
+  editor: null
+});
+mt.Consumer;
+var Kr = () => ut(mt), gt = st({
+  onDragStart: () => {
+  },
+  nodeViewContentChildren: void 0,
+  nodeViewContentRef: () => {
+  }
+}), Fn = () => ut(gt), Xr = B.forwardRef((e, t) => {
+  const { onDragStart: r } = Fn(), n = e.as || "div";
+  return (
+    // @ts-ignore
+    /* @__PURE__ */ Z(
+      n,
+      {
+        ...e,
+        ref: t,
+        "data-node-view-wrapper": "",
+        onDragStart: r,
+        style: {
+          whiteSpace: "normal",
+          ...e.style
+        }
+      }
+    )
+  );
+});
+function ze(e) {
+  return !!(typeof e == "function" && e.prototype && e.prototype.isReactComponent);
+}
+function Ke(e) {
+  return !!(typeof e == "object" && e.$$typeof && (e.$$typeof.toString() === "Symbol(react.forward_ref)" || e.$$typeof.description === "react.forward_ref"));
+}
+function Hn(e) {
+  return !!(typeof e == "object" && e.$$typeof && (e.$$typeof.toString() === "Symbol(react.memo)" || e.$$typeof.description === "react.memo"));
+}
+function Un(e) {
+  if (ze(e) || Ke(e))
+    return !0;
+  if (Hn(e)) {
+    const t = e.type;
+    if (t)
+      return ze(t) || Ke(t);
+  }
+  return !1;
+}
+function Gn() {
+  try {
+    if (Le)
+      return parseInt(Le.split(".")[0], 10) >= 19;
+  } catch {
+  }
+  return !1;
+}
+var zn = class {
+  /**
+   * Immediately creates element and renders the provided React component.
+   */
+  constructor(e, { editor: t, props: r = {}, as: n = "div", className: i = "" }) {
+    this.ref = null, this.id = Math.floor(Math.random() * 4294967295).toString(), this.component = e, this.editor = t, this.props = r, this.element = document.createElement(n), this.element.classList.add("react-renderer"), i && this.element.classList.add(...i.split(" ")), this.editor.isInitialized ? Bt(() => {
+      this.render();
+    }) : queueMicrotask(() => {
+      this.render();
+    });
+  }
+  /**
+   * Render the React component.
+   */
+  render() {
+    var e;
+    const t = this.component, r = this.props, n = this.editor, i = Gn(), o = Un(t), s = { ...r };
+    s.ref && !(i || o) && delete s.ref, !s.ref && (i || o) && (s.ref = (a) => {
+      this.ref = a;
+    }), this.reactElement = /* @__PURE__ */ Z(t, { ...s }), (e = n == null ? void 0 : n.contentComponent) == null || e.setRenderer(this.id, this);
+  }
+  /**
+   * Re-renders the React component with new props.
+   */
+  updateProps(e = {}) {
+    this.props = {
+      ...this.props,
+      ...e
+    }, this.render();
+  }
+  /**
+   * Destroy the React component.
+   */
+  destroy() {
+    var e;
+    const t = this.editor;
+    (e = t == null ? void 0 : t.contentComponent) == null || e.removeRenderer(this.id);
+    try {
+      this.element && this.element.parentNode && this.element.parentNode.removeChild(this.element);
+    } catch {
+    }
+  }
+  /**
+   * Update the attributes of the element that holds the React component.
+   */
+  updateAttributes(e) {
+    Object.keys(e).forEach((t) => {
+      this.element.setAttribute(t, e[t]);
+    });
+  }
+};
+B.createContext({
+  markViewContentRef: () => {
+  }
+});
+var Kn = class extends kt {
+  constructor(e, t, r) {
+    if (super(e, t, r), this.selectionRafId = null, !this.node.isLeaf) {
+      this.options.contentDOMElementTag ? this.contentDOMElement = document.createElement(this.options.contentDOMElementTag) : this.contentDOMElement = document.createElement(this.node.isInline ? "span" : "div"), this.contentDOMElement.dataset.nodeViewContentReact = "", this.contentDOMElement.dataset.nodeViewWrapper = "", this.contentDOMElement.style.whiteSpace = "inherit";
+      const n = this.dom.querySelector("[data-node-view-content]");
+      if (!n)
+        return;
+      n.appendChild(this.contentDOMElement);
+    }
+  }
+  /**
+   * Setup the React component.
+   * Called on initialization.
+   */
+  mount() {
+    const e = {
+      editor: this.editor,
+      node: this.node,
+      decorations: this.decorations,
+      innerDecorations: this.innerDecorations,
+      view: this.view,
+      selected: !1,
+      extension: this.extension,
+      HTMLAttributes: this.HTMLAttributes,
+      getPos: () => this.getPos(),
+      updateAttributes: (l = {}) => this.updateAttributes(l),
+      deleteNode: () => this.deleteNode(),
+      ref: Nt()
+    };
+    if (!this.component.displayName) {
+      const l = (u) => u.charAt(0).toUpperCase() + u.substring(1);
+      this.component.displayName = l(this.extension.name);
+    }
+    const n = { onDragStart: this.onDragStart.bind(this), nodeViewContentRef: (l) => {
+      l && this.contentDOMElement && l.firstChild !== this.contentDOMElement && (l.hasAttribute("data-node-view-wrapper") && l.removeAttribute("data-node-view-wrapper"), l.appendChild(this.contentDOMElement));
+    } }, i = this.component, o = Vt((l) => /* @__PURE__ */ Z(gt.Provider, { value: n, children: jt(i, l) }));
+    o.displayName = "ReactNodeView";
+    let s = this.node.isInline ? "span" : "div";
+    this.options.as && (s = this.options.as);
+    const { className: a = "" } = this.options;
+    this.handleSelectionUpdate = this.handleSelectionUpdate.bind(this), this.renderer = new zn(o, {
+      editor: this.editor,
+      props: e,
+      as: s,
+      className: `node-${this.node.type.name} ${a}`.trim()
+    }), this.editor.on("selectionUpdate", this.handleSelectionUpdate), this.updateElementAttributes();
+  }
+  /**
+   * Return the DOM element.
+   * This is the element that will be used to display the node view.
+   */
+  get dom() {
+    var e;
+    if (this.renderer.element.firstElementChild && !((e = this.renderer.element.firstElementChild) != null && e.hasAttribute("data-node-view-wrapper")))
+      throw Error("Please use the NodeViewWrapper component for your node view.");
+    return this.renderer.element;
+  }
+  /**
+   * Return the content DOM element.
+   * This is the element that will be used to display the rich-text content of the node.
+   */
+  get contentDOM() {
+    return this.node.isLeaf ? null : this.contentDOMElement;
+  }
+  /**
+   * On editor selection update, check if the node is selected.
+   * If it is, call `selectNode`, otherwise call `deselectNode`.
+   */
+  handleSelectionUpdate() {
+    this.selectionRafId && (cancelAnimationFrame(this.selectionRafId), this.selectionRafId = null), this.selectionRafId = requestAnimationFrame(() => {
+      this.selectionRafId = null;
+      const { from: e, to: t } = this.editor.state.selection, r = this.getPos();
+      if (typeof r == "number")
+        if (e <= r && t >= r + this.node.nodeSize) {
+          if (this.renderer.props.selected)
+            return;
+          this.selectNode();
+        } else {
+          if (!this.renderer.props.selected)
+            return;
+          this.deselectNode();
+        }
+    });
+  }
+  /**
+   * On update, update the React component.
+   * To prevent unnecessary updates, the `update` option can be used.
+   */
+  update(e, t, r) {
+    const n = (i) => {
+      this.renderer.updateProps(i), typeof this.options.attrs == "function" && this.updateElementAttributes();
+    };
+    if (e.type !== this.node.type)
+      return !1;
+    if (typeof this.options.update == "function") {
+      const i = this.node, o = this.decorations, s = this.innerDecorations;
+      return this.node = e, this.decorations = t, this.innerDecorations = r, this.options.update({
+        oldNode: i,
+        oldDecorations: o,
+        newNode: e,
+        newDecorations: t,
+        oldInnerDecorations: s,
+        innerDecorations: r,
+        updateProps: () => n({ node: e, decorations: t, innerDecorations: r })
+      });
+    }
+    return e === this.node && this.decorations === t && this.innerDecorations === r || (this.node = e, this.decorations = t, this.innerDecorations = r, n({ node: e, decorations: t, innerDecorations: r })), !0;
+  }
+  /**
+   * Select the node.
+   * Add the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  selectNode() {
+    this.renderer.updateProps({
+      selected: !0
+    }), this.renderer.element.classList.add("ProseMirror-selectednode");
+  }
+  /**
+   * Deselect the node.
+   * Remove the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  deselectNode() {
+    this.renderer.updateProps({
+      selected: !1
+    }), this.renderer.element.classList.remove("ProseMirror-selectednode");
+  }
+  /**
+   * Destroy the React component instance.
+   */
+  destroy() {
+    this.renderer.destroy(), this.editor.off("selectionUpdate", this.handleSelectionUpdate), this.contentDOMElement = null, this.selectionRafId && (cancelAnimationFrame(this.selectionRafId), this.selectionRafId = null);
+  }
+  /**
+   * Update the attributes of the top-level element that holds the React component.
+   * Applying the attributes defined in the `attrs` option.
+   */
+  updateElementAttributes() {
+    if (this.options.attrs) {
+      let e = {};
+      if (typeof this.options.attrs == "function") {
+        const t = this.editor.extensionManager.attributes, r = Ft(this.node, t);
+        e = this.options.attrs({ node: this.node, HTMLAttributes: r });
+      } else
+        e = this.options.attrs;
+      this.renderer.updateAttributes(e);
+    }
+  }
+};
+function Yr(e, t) {
+  return (r) => r.editor.contentComponent ? new Kn(e, r, t) : {};
+}
+function vt(e) {
+  var t, r, n = "";
+  if (typeof e == "string" || typeof e == "number") n += e;
+  else if (typeof e == "object") if (Array.isArray(e)) {
+    var i = e.length;
+    for (t = 0; t < i; t++) e[t] && (r = vt(e[t])) && (n && (n += " "), n += r);
+  } else for (r in e) e[r] && (n && (n += " "), n += r);
+  return n;
+}
+function Jr() {
+  for (var e, t, r = 0, n = "", i = arguments.length; r < i; r++) (e = arguments[r]) && (t = vt(e)) && (n && (n += " "), n += t);
+  return n;
+}
+const yt = ["top", "right", "bottom", "left"], Xe = ["start", "end"], Ye = /* @__PURE__ */ yt.reduce((e, t) => e.concat(t, t + "-" + Xe[0], t + "-" + Xe[1]), []), H = Math.min, T = Math.max, ue = Math.round, F = (e) => ({
+  x: e,
+  y: e
+}), Xn = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Yn = {
+  start: "end",
+  end: "start"
+};
+function xe(e, t, r) {
+  return T(e, H(t, r));
+}
+function G(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function V(e) {
+  return e.split("-")[0];
+}
+function I(e) {
+  return e.split("-")[1];
+}
+function wt(e) {
+  return e === "x" ? "y" : "x";
+}
+function Ae(e) {
+  return e === "y" ? "height" : "width";
+}
+const Jn = /* @__PURE__ */ new Set(["top", "bottom"]);
+function k(e) {
+  return Jn.has(V(e)) ? "y" : "x";
+}
+function Ce(e) {
+  return wt(k(e));
+}
+function Et(e, t, r) {
+  r === void 0 && (r = !1);
+  const n = I(e), i = Ce(e), o = Ae(i);
+  let s = i === "x" ? n === (r ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return t.reference[o] > t.floating[o] && (s = de(s)), [s, de(s)];
+}
+function Qn(e) {
+  const t = de(e);
+  return [fe(e), t, fe(t)];
+}
+function fe(e) {
+  return e.replace(/start|end/g, (t) => Yn[t]);
+}
+const Je = ["left", "right"], Qe = ["right", "left"], Zn = ["top", "bottom"], er = ["bottom", "top"];
+function tr(e, t, r) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return r ? t ? Qe : Je : t ? Je : Qe;
+    case "left":
+    case "right":
+      return t ? Zn : er;
+    default:
+      return [];
+  }
+}
+function nr(e, t, r, n) {
+  const i = I(e);
+  let o = tr(V(e), r === "start", n);
+  return i && (o = o.map((s) => s + "-" + i), t && (o = o.concat(o.map(fe)))), o;
+}
+function de(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Xn[t]);
+}
+function rr(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function _e(e) {
+  return typeof e != "number" ? rr(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function ee(e) {
+  const {
+    x: t,
+    y: r,
+    width: n,
+    height: i
+  } = e;
+  return {
+    width: n,
+    height: i,
+    top: r,
+    left: t,
+    right: t + n,
+    bottom: r + i,
+    x: t,
+    y: r
+  };
+}
+function Ze(e, t, r) {
+  let {
+    reference: n,
+    floating: i
+  } = e;
+  const o = k(t), s = Ce(t), a = Ae(s), l = V(t), u = o === "y", h = n.x + n.width / 2 - i.width / 2, c = n.y + n.height / 2 - i.height / 2, m = n[a] / 2 - i[a] / 2;
+  let f;
+  switch (l) {
+    case "top":
+      f = {
+        x: h,
+        y: n.y - i.height
+      };
+      break;
+    case "bottom":
+      f = {
+        x: h,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      f = {
+        x: n.x + n.width,
+        y: c
+      };
+      break;
+    case "left":
+      f = {
+        x: n.x - i.width,
+        y: c
+      };
+      break;
+    default:
+      f = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (I(t)) {
+    case "start":
+      f[s] -= m * (r && u ? -1 : 1);
+      break;
+    case "end":
+      f[s] += m * (r && u ? -1 : 1);
+      break;
+  }
+  return f;
+}
+const ir = async (e, t, r) => {
+  const {
+    placement: n = "bottom",
+    strategy: i = "absolute",
+    middleware: o = [],
+    platform: s
+  } = r, a = o.filter(Boolean), l = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let u = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: i
+  }), {
+    x: h,
+    y: c
+  } = Ze(u, n, l), m = n, f = {}, g = 0;
+  for (let d = 0; d < a.length; d++) {
+    const {
+      name: p,
+      fn: v
+    } = a[d], {
+      x: y,
+      y: w,
+      data: E,
+      reset: S
+    } = await v({
+      x: h,
+      y: c,
+      initialPlacement: n,
+      placement: m,
+      strategy: i,
+      middlewareData: f,
+      rects: u,
+      platform: s,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    h = y ?? h, c = w ?? c, f = {
+      ...f,
+      [p]: {
+        ...f[p],
+        ...E
+      }
+    }, S && g <= 50 && (g++, typeof S == "object" && (S.placement && (m = S.placement), S.rects && (u = S.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: i
+    }) : S.rects), {
+      x: h,
+      y: c
+    } = Ze(u, m, l)), d = -1);
+  }
+  return {
+    x: h,
+    y: c,
+    placement: m,
+    strategy: i,
+    middlewareData: f
+  };
+};
+async function te(e, t) {
+  var r;
+  t === void 0 && (t = {});
+  const {
+    x: n,
+    y: i,
+    platform: o,
+    rects: s,
+    elements: a,
+    strategy: l
+  } = e, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: h = "viewport",
+    elementContext: c = "floating",
+    altBoundary: m = !1,
+    padding: f = 0
+  } = G(t, e), g = _e(f), p = a[m ? c === "floating" ? "reference" : "floating" : c], v = ee(await o.getClippingRect({
+    element: (r = await (o.isElement == null ? void 0 : o.isElement(p))) == null || r ? p : p.contextElement || await (o.getDocumentElement == null ? void 0 : o.getDocumentElement(a.floating)),
+    boundary: u,
+    rootBoundary: h,
+    strategy: l
+  })), y = c === "floating" ? {
+    x: n,
+    y: i,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, w = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(a.floating)), E = await (o.isElement == null ? void 0 : o.isElement(w)) ? await (o.getScale == null ? void 0 : o.getScale(w)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, S = ee(o.convertOffsetParentRelativeRectToViewportRelativeRect ? await o.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: y,
+    offsetParent: w,
+    strategy: l
+  }) : y);
+  return {
+    top: (v.top - S.top + g.top) / E.y,
+    bottom: (S.bottom - v.bottom + g.bottom) / E.y,
+    left: (v.left - S.left + g.left) / E.x,
+    right: (S.right - v.right + g.right) / E.x
+  };
+}
+const or = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: r,
+      y: n,
+      placement: i,
+      rects: o,
+      platform: s,
+      elements: a,
+      middlewareData: l
+    } = t, {
+      element: u,
+      padding: h = 0
+    } = G(e, t) || {};
+    if (u == null)
+      return {};
+    const c = _e(h), m = {
+      x: r,
+      y: n
+    }, f = Ce(i), g = Ae(f), d = await s.getDimensions(u), p = f === "y", v = p ? "top" : "left", y = p ? "bottom" : "right", w = p ? "clientHeight" : "clientWidth", E = o.reference[g] + o.reference[f] - m[f] - o.floating[g], S = m[f] - o.reference[f], b = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
+    let O = b ? b[w] : 0;
+    (!O || !await (s.isElement == null ? void 0 : s.isElement(b))) && (O = a.floating[w] || o.floating[g]);
+    const R = E / 2 - S / 2, _ = O / 2 - d[g] / 2 - 1, x = H(c[v], _), A = H(c[y], _), D = x, L = O - d[g] - A, C = O / 2 - d[g] / 2 + R, j = xe(D, C, L), N = !l.arrow && I(i) != null && C !== j && o.reference[g] / 2 - (C < D ? x : A) - d[g] / 2 < 0, P = N ? C < D ? C - D : C - L : 0;
+    return {
+      [f]: m[f] + P,
+      data: {
+        [f]: j,
+        centerOffset: C - j - P,
+        ...N && {
+          alignmentOffset: P
+        }
+      },
+      reset: N
+    };
+  }
+});
+function sr(e, t, r) {
+  return (e ? [...r.filter((i) => I(i) === e), ...r.filter((i) => I(i) !== e)] : r.filter((i) => V(i) === i)).filter((i) => e ? I(i) === e || (t ? fe(i) !== i : !1) : !0);
+}
+const ar = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "autoPlacement",
+    options: e,
+    async fn(t) {
+      var r, n, i;
+      const {
+        rects: o,
+        middlewareData: s,
+        placement: a,
+        platform: l,
+        elements: u
+      } = t, {
+        crossAxis: h = !1,
+        alignment: c,
+        allowedPlacements: m = Ye,
+        autoAlignment: f = !0,
+        ...g
+      } = G(e, t), d = c !== void 0 || m === Ye ? sr(c || null, f, m) : m, p = await te(t, g), v = ((r = s.autoPlacement) == null ? void 0 : r.index) || 0, y = d[v];
+      if (y == null)
+        return {};
+      const w = Et(y, o, await (l.isRTL == null ? void 0 : l.isRTL(u.floating)));
+      if (a !== y)
+        return {
+          reset: {
+            placement: d[0]
+          }
+        };
+      const E = [p[V(y)], p[w[0]], p[w[1]]], S = [...((n = s.autoPlacement) == null ? void 0 : n.overflows) || [], {
+        placement: y,
+        overflows: E
+      }], b = d[v + 1];
+      if (b)
+        return {
+          data: {
+            index: v + 1,
+            overflows: S
+          },
+          reset: {
+            placement: b
+          }
+        };
+      const O = S.map((x) => {
+        const A = I(x.placement);
+        return [x.placement, A && h ? (
+          // Check along the mainAxis and main crossAxis side.
+          x.overflows.slice(0, 2).reduce((D, L) => D + L, 0)
+        ) : (
+          // Check only the mainAxis.
+          x.overflows[0]
+        ), x.overflows];
+      }).sort((x, A) => x[1] - A[1]), _ = ((i = O.filter((x) => x[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        I(x[0]) ? 2 : 3
+      ).every((A) => A <= 0))[0]) == null ? void 0 : i[0]) || O[0][0];
+      return _ !== a ? {
+        data: {
+          index: v + 1,
+          overflows: S
+        },
+        reset: {
+          placement: _
+        }
+      } : {};
+    }
+  };
+}, cr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        placement: i,
+        middlewareData: o,
+        rects: s,
+        initialPlacement: a,
+        platform: l,
+        elements: u
+      } = t, {
+        mainAxis: h = !0,
+        crossAxis: c = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: f = "bestFit",
+        fallbackAxisSideDirection: g = "none",
+        flipAlignment: d = !0,
+        ...p
+      } = G(e, t);
+      if ((r = o.arrow) != null && r.alignmentOffset)
+        return {};
+      const v = V(i), y = k(a), w = V(a) === a, E = await (l.isRTL == null ? void 0 : l.isRTL(u.floating)), S = m || (w || !d ? [de(a)] : Qn(a)), b = g !== "none";
+      !m && b && S.push(...nr(a, d, g, E));
+      const O = [a, ...S], R = await te(t, p), _ = [];
+      let x = ((n = o.flip) == null ? void 0 : n.overflows) || [];
+      if (h && _.push(R[v]), c) {
+        const C = Et(i, s, E);
+        _.push(R[C[0]], R[C[1]]);
+      }
+      if (x = [...x, {
+        placement: i,
+        overflows: _
+      }], !_.every((C) => C <= 0)) {
+        var A, D;
+        const C = (((A = o.flip) == null ? void 0 : A.index) || 0) + 1, j = O[C];
+        if (j && (!(c === "alignment" ? y !== k(j) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        x.every((q) => k(q.placement) === y ? q.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: C,
+              overflows: x
+            },
+            reset: {
+              placement: j
+            }
+          };
+        let N = (D = x.filter((P) => P.overflows[0] <= 0).sort((P, q) => P.overflows[1] - q.overflows[1])[0]) == null ? void 0 : D.placement;
+        if (!N)
+          switch (f) {
+            case "bestFit": {
+              var L;
+              const P = (L = x.filter((q) => {
+                if (b) {
+                  const K = k(q.placement);
+                  return K === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  K === "y";
+                }
+                return !0;
+              }).map((q) => [q.placement, q.overflows.filter((K) => K > 0).reduce((K, Lt) => K + Lt, 0)]).sort((q, K) => q[1] - K[1])[0]) == null ? void 0 : L[0];
+              P && (N = P);
+              break;
+            }
+            case "initialPlacement":
+              N = a;
+              break;
+          }
+        if (i !== N)
+          return {
+            reset: {
+              placement: N
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function et(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function tt(e) {
+  return yt.some((t) => e[t] >= 0);
+}
+const lr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: r
+      } = t, {
+        strategy: n = "referenceHidden",
+        ...i
+      } = G(e, t);
+      switch (n) {
+        case "referenceHidden": {
+          const o = await te(t, {
+            ...i,
+            elementContext: "reference"
+          }), s = et(o, r.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: s,
+              referenceHidden: tt(s)
+            }
+          };
+        }
+        case "escaped": {
+          const o = await te(t, {
+            ...i,
+            altBoundary: !0
+          }), s = et(o, r.floating);
+          return {
+            data: {
+              escapedOffsets: s,
+              escaped: tt(s)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+function bt(e) {
+  const t = H(...e.map((o) => o.left)), r = H(...e.map((o) => o.top)), n = T(...e.map((o) => o.right)), i = T(...e.map((o) => o.bottom));
+  return {
+    x: t,
+    y: r,
+    width: n - t,
+    height: i - r
+  };
+}
+function ur(e) {
+  const t = e.slice().sort((i, o) => i.y - o.y), r = [];
+  let n = null;
+  for (let i = 0; i < t.length; i++) {
+    const o = t[i];
+    !n || o.y - n.y > n.height / 2 ? r.push([o]) : r[r.length - 1].push(o), n = o;
+  }
+  return r.map((i) => ee(bt(i)));
+}
+const fr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "inline",
+    options: e,
+    async fn(t) {
+      const {
+        placement: r,
+        elements: n,
+        rects: i,
+        platform: o,
+        strategy: s
+      } = t, {
+        padding: a = 2,
+        x: l,
+        y: u
+      } = G(e, t), h = Array.from(await (o.getClientRects == null ? void 0 : o.getClientRects(n.reference)) || []), c = ur(h), m = ee(bt(h)), f = _e(a);
+      function g() {
+        if (c.length === 2 && c[0].left > c[1].right && l != null && u != null)
+          return c.find((p) => l > p.left - f.left && l < p.right + f.right && u > p.top - f.top && u < p.bottom + f.bottom) || m;
+        if (c.length >= 2) {
+          if (k(r) === "y") {
+            const x = c[0], A = c[c.length - 1], D = V(r) === "top", L = x.top, C = A.bottom, j = D ? x.left : A.left, N = D ? x.right : A.right, P = N - j, q = C - L;
+            return {
+              top: L,
+              bottom: C,
+              left: j,
+              right: N,
+              width: P,
+              height: q,
+              x: j,
+              y: L
+            };
+          }
+          const p = V(r) === "left", v = T(...c.map((x) => x.right)), y = H(...c.map((x) => x.left)), w = c.filter((x) => p ? x.left === y : x.right === v), E = w[0].top, S = w[w.length - 1].bottom, b = y, O = v, R = O - b, _ = S - E;
+          return {
+            top: E,
+            bottom: S,
+            left: b,
+            right: O,
+            width: R,
+            height: _,
+            x: b,
+            y: E
+          };
+        }
+        return m;
+      }
+      const d = await o.getElementRects({
+        reference: {
+          getBoundingClientRect: g
+        },
+        floating: n.floating,
+        strategy: s
+      });
+      return i.reference.x !== d.reference.x || i.reference.y !== d.reference.y || i.reference.width !== d.reference.width || i.reference.height !== d.reference.height ? {
+        reset: {
+          rects: d
+        }
+      } : {};
+    }
+  };
+}, dr = /* @__PURE__ */ new Set(["left", "top"]);
+async function hr(e, t) {
+  const {
+    placement: r,
+    platform: n,
+    elements: i
+  } = e, o = await (n.isRTL == null ? void 0 : n.isRTL(i.floating)), s = V(r), a = I(r), l = k(r) === "y", u = dr.has(s) ? -1 : 1, h = o && l ? -1 : 1, c = G(t, e);
+  let {
+    mainAxis: m,
+    crossAxis: f,
+    alignmentAxis: g
+  } = typeof c == "number" ? {
+    mainAxis: c,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: c.mainAxis || 0,
+    crossAxis: c.crossAxis || 0,
+    alignmentAxis: c.alignmentAxis
+  };
+  return a && typeof g == "number" && (f = a === "end" ? g * -1 : g), l ? {
+    x: f * h,
+    y: m * u
+  } : {
+    x: m * u,
+    y: f * h
+  };
+}
+const pr = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        x: i,
+        y: o,
+        placement: s,
+        middlewareData: a
+      } = t, l = await hr(t, e);
+      return s === ((r = a.offset) == null ? void 0 : r.placement) && (n = a.arrow) != null && n.alignmentOffset ? {} : {
+        x: i + l.x,
+        y: o + l.y,
+        data: {
+          ...l,
+          placement: s
+        }
+      };
+    }
+  };
+}, mr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: r,
+        y: n,
+        placement: i
+      } = t, {
+        mainAxis: o = !0,
+        crossAxis: s = !1,
+        limiter: a = {
+          fn: (p) => {
+            let {
+              x: v,
+              y
+            } = p;
+            return {
+              x: v,
+              y
+            };
+          }
+        },
+        ...l
+      } = G(e, t), u = {
+        x: r,
+        y: n
+      }, h = await te(t, l), c = k(V(i)), m = wt(c);
+      let f = u[m], g = u[c];
+      if (o) {
+        const p = m === "y" ? "top" : "left", v = m === "y" ? "bottom" : "right", y = f + h[p], w = f - h[v];
+        f = xe(y, f, w);
+      }
+      if (s) {
+        const p = c === "y" ? "top" : "left", v = c === "y" ? "bottom" : "right", y = g + h[p], w = g - h[v];
+        g = xe(y, g, w);
+      }
+      const d = a.fn({
+        ...t,
+        [m]: f,
+        [c]: g
+      });
+      return {
+        ...d,
+        data: {
+          x: d.x - r,
+          y: d.y - n,
+          enabled: {
+            [m]: o,
+            [c]: s
+          }
+        }
+      };
+    }
+  };
+}, gr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var r, n;
+      const {
+        placement: i,
+        rects: o,
+        platform: s,
+        elements: a
+      } = t, {
+        apply: l = () => {
+        },
+        ...u
+      } = G(e, t), h = await te(t, u), c = V(i), m = I(i), f = k(i) === "y", {
+        width: g,
+        height: d
+      } = o.floating;
+      let p, v;
+      c === "top" || c === "bottom" ? (p = c, v = m === (await (s.isRTL == null ? void 0 : s.isRTL(a.floating)) ? "start" : "end") ? "left" : "right") : (v = c, p = m === "end" ? "top" : "bottom");
+      const y = d - h.top - h.bottom, w = g - h.left - h.right, E = H(d - h[p], y), S = H(g - h[v], w), b = !t.middlewareData.shift;
+      let O = E, R = S;
+      if ((r = t.middlewareData.shift) != null && r.enabled.x && (R = w), (n = t.middlewareData.shift) != null && n.enabled.y && (O = y), b && !m) {
+        const x = T(h.left, 0), A = T(h.right, 0), D = T(h.top, 0), L = T(h.bottom, 0);
+        f ? R = g - 2 * (x !== 0 || A !== 0 ? x + A : T(h.left, h.right)) : O = d - 2 * (D !== 0 || L !== 0 ? D + L : T(h.top, h.bottom));
+      }
+      await l({
+        ...t,
+        availableWidth: R,
+        availableHeight: O
+      });
+      const _ = await s.getDimensions(a.floating);
+      return g !== _.width || d !== _.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function he() {
+  return typeof window < "u";
+}
+function re(e) {
+  return St(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function M(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function z(e) {
+  var t;
+  return (t = (St(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function St(e) {
+  return he() ? e instanceof Node || e instanceof M(e).Node : !1;
+}
+function W(e) {
+  return he() ? e instanceof Element || e instanceof M(e).Element : !1;
+}
+function U(e) {
+  return he() ? e instanceof HTMLElement || e instanceof M(e).HTMLElement : !1;
+}
+function nt(e) {
+  return !he() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof M(e).ShadowRoot;
+}
+const vr = /* @__PURE__ */ new Set(["inline", "contents"]);
+function se(e) {
+  const {
+    overflow: t,
+    overflowX: r,
+    overflowY: n,
+    display: i
+  } = $(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + n + r) && !vr.has(i);
+}
+const yr = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function wr(e) {
+  return yr.has(re(e));
+}
+const Er = [":popover-open", ":modal"];
+function pe(e) {
+  return Er.some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+const br = ["transform", "translate", "scale", "rotate", "perspective"], Sr = ["transform", "translate", "scale", "rotate", "perspective", "filter"], xr = ["paint", "layout", "strict", "content"];
+function De(e) {
+  const t = Te(), r = W(e) ? $(e) : e;
+  return br.some((n) => r[n] ? r[n] !== "none" : !1) || (r.containerType ? r.containerType !== "normal" : !1) || !t && (r.backdropFilter ? r.backdropFilter !== "none" : !1) || !t && (r.filter ? r.filter !== "none" : !1) || Sr.some((n) => (r.willChange || "").includes(n)) || xr.some((n) => (r.contain || "").includes(n));
+}
+function Or(e) {
+  let t = X(e);
+  for (; U(t) && !ne(t); ) {
+    if (De(t))
+      return t;
+    if (pe(t))
+      return null;
+    t = X(t);
+  }
+  return null;
+}
+function Te() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const Rr = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function ne(e) {
+  return Rr.has(re(e));
+}
+function $(e) {
+  return M(e).getComputedStyle(e);
+}
+function me(e) {
+  return W(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function X(e) {
+  if (re(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    nt(e) && e.host || // Fallback.
+    z(e)
+  );
+  return nt(t) ? t.host : t;
+}
+function xt(e) {
+  const t = X(e);
+  return ne(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : U(t) && se(t) ? t : xt(t);
+}
+function Ot(e, t, r) {
+  var n;
+  t === void 0 && (t = []);
+  const i = xt(e), o = i === ((n = e.ownerDocument) == null ? void 0 : n.body), s = M(i);
+  return o ? (Oe(s), t.concat(s, s.visualViewport || [], se(i) ? i : [], [])) : t.concat(i, Ot(i, []));
+}
+function Oe(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function Rt(e) {
+  const t = $(e);
+  let r = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
+  const i = U(e), o = i ? e.offsetWidth : r, s = i ? e.offsetHeight : n, a = ue(r) !== o || ue(n) !== s;
+  return a && (r = o, n = s), {
+    width: r,
+    height: n,
+    $: a
+  };
+}
+function At(e) {
+  return W(e) ? e : e.contextElement;
+}
+function Q(e) {
+  const t = At(e);
+  if (!U(t))
+    return F(1);
+  const r = t.getBoundingClientRect(), {
+    width: n,
+    height: i,
+    $: o
+  } = Rt(t);
+  let s = (o ? ue(r.width) : r.width) / n, a = (o ? ue(r.height) : r.height) / i;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!a || !Number.isFinite(a)) && (a = 1), {
+    x: s,
+    y: a
+  };
+}
+const Ar = /* @__PURE__ */ F(0);
+function Ct(e) {
+  const t = M(e);
+  return !Te() || !t.visualViewport ? Ar : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Cr(e, t, r) {
+  return t === void 0 && (t = !1), !r || t && r !== M(e) ? !1 : t;
+}
+function oe(e, t, r, n) {
+  t === void 0 && (t = !1), r === void 0 && (r = !1);
+  const i = e.getBoundingClientRect(), o = At(e);
+  let s = F(1);
+  t && (n ? W(n) && (s = Q(n)) : s = Q(e));
+  const a = Cr(o, r, n) ? Ct(o) : F(0);
+  let l = (i.left + a.x) / s.x, u = (i.top + a.y) / s.y, h = i.width / s.x, c = i.height / s.y;
+  if (o) {
+    const m = M(o), f = n && W(n) ? M(n) : n;
+    let g = m, d = Oe(g);
+    for (; d && n && f !== g; ) {
+      const p = Q(d), v = d.getBoundingClientRect(), y = $(d), w = v.left + (d.clientLeft + parseFloat(y.paddingLeft)) * p.x, E = v.top + (d.clientTop + parseFloat(y.paddingTop)) * p.y;
+      l *= p.x, u *= p.y, h *= p.x, c *= p.y, l += w, u += E, g = M(d), d = Oe(g);
+    }
+  }
+  return ee({
+    width: h,
+    height: c,
+    x: l,
+    y: u
+  });
+}
+function ge(e, t) {
+  const r = me(e).scrollLeft;
+  return t ? t.left + r : oe(z(e)).left + r;
+}
+function _t(e, t) {
+  const r = e.getBoundingClientRect(), n = r.left + t.scrollLeft - ge(e, r), i = r.top + t.scrollTop;
+  return {
+    x: n,
+    y: i
+  };
+}
+function _r(e) {
+  let {
+    elements: t,
+    rect: r,
+    offsetParent: n,
+    strategy: i
+  } = e;
+  const o = i === "fixed", s = z(n), a = t ? pe(t.floating) : !1;
+  if (n === s || a && o)
+    return r;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = F(1);
+  const h = F(0), c = U(n);
+  if ((c || !c && !o) && ((re(n) !== "body" || se(s)) && (l = me(n)), U(n))) {
+    const f = oe(n);
+    u = Q(n), h.x = f.x + n.clientLeft, h.y = f.y + n.clientTop;
+  }
+  const m = s && !c && !o ? _t(s, l) : F(0);
+  return {
+    width: r.width * u.x,
+    height: r.height * u.y,
+    x: r.x * u.x - l.scrollLeft * u.x + h.x + m.x,
+    y: r.y * u.y - l.scrollTop * u.y + h.y + m.y
+  };
+}
+function Dr(e) {
+  return Array.from(e.getClientRects());
+}
+function Tr(e) {
+  const t = z(e), r = me(e), n = e.ownerDocument.body, i = T(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), o = T(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let s = -r.scrollLeft + ge(e);
+  const a = -r.scrollTop;
+  return $(n).direction === "rtl" && (s += T(t.clientWidth, n.clientWidth) - i), {
+    width: i,
+    height: o,
+    x: s,
+    y: a
+  };
+}
+const rt = 25;
+function Lr(e, t) {
+  const r = M(e), n = z(e), i = r.visualViewport;
+  let o = n.clientWidth, s = n.clientHeight, a = 0, l = 0;
+  if (i) {
+    o = i.width, s = i.height;
+    const h = Te();
+    (!h || h && t === "fixed") && (a = i.offsetLeft, l = i.offsetTop);
+  }
+  const u = ge(n);
+  if (u <= 0) {
+    const h = n.ownerDocument, c = h.body, m = getComputedStyle(c), f = h.compatMode === "CSS1Compat" && parseFloat(m.marginLeft) + parseFloat(m.marginRight) || 0, g = Math.abs(n.clientWidth - c.clientWidth - f);
+    g <= rt && (o -= g);
+  } else u <= rt && (o += u);
+  return {
+    width: o,
+    height: s,
+    x: a,
+    y: l
+  };
+}
+const Pr = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function qr(e, t) {
+  const r = oe(e, !0, t === "fixed"), n = r.top + e.clientTop, i = r.left + e.clientLeft, o = U(e) ? Q(e) : F(1), s = e.clientWidth * o.x, a = e.clientHeight * o.y, l = i * o.x, u = n * o.y;
+  return {
+    width: s,
+    height: a,
+    x: l,
+    y: u
+  };
+}
+function it(e, t, r) {
+  let n;
+  if (t === "viewport")
+    n = Lr(e, r);
+  else if (t === "document")
+    n = Tr(z(e));
+  else if (W(t))
+    n = qr(t, r);
+  else {
+    const i = Ct(e);
+    n = {
+      x: t.x - i.x,
+      y: t.y - i.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return ee(n);
+}
+function Dt(e, t) {
+  const r = X(e);
+  return r === t || !W(r) || ne(r) ? !1 : $(r).position === "fixed" || Dt(r, t);
+}
+function Mr(e, t) {
+  const r = t.get(e);
+  if (r)
+    return r;
+  let n = Ot(e, []).filter((a) => W(a) && re(a) !== "body"), i = null;
+  const o = $(e).position === "fixed";
+  let s = o ? X(e) : e;
+  for (; W(s) && !ne(s); ) {
+    const a = $(s), l = De(s);
+    !l && a.position === "fixed" && (i = null), (o ? !l && !i : !l && a.position === "static" && !!i && Pr.has(i.position) || se(s) && !l && Dt(e, s)) ? n = n.filter((h) => h !== s) : i = a, s = X(s);
+  }
+  return t.set(e, n), n;
+}
+function Nr(e) {
+  let {
+    element: t,
+    boundary: r,
+    rootBoundary: n,
+    strategy: i
+  } = e;
+  const s = [...r === "clippingAncestors" ? pe(t) ? [] : Mr(t, this._c) : [].concat(r), n], a = s[0], l = s.reduce((u, h) => {
+    const c = it(t, h, i);
+    return u.top = T(c.top, u.top), u.right = H(c.right, u.right), u.bottom = H(c.bottom, u.bottom), u.left = T(c.left, u.left), u;
+  }, it(t, a, i));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+function Vr(e) {
+  const {
+    width: t,
+    height: r
+  } = Rt(e);
+  return {
+    width: t,
+    height: r
+  };
+}
+function jr(e, t, r) {
+  const n = U(t), i = z(t), o = r === "fixed", s = oe(e, !0, o, t);
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = F(0);
+  function u() {
+    l.x = ge(i);
+  }
+  if (n || !n && !o)
+    if ((re(t) !== "body" || se(i)) && (a = me(t)), n) {
+      const f = oe(t, !0, o, t);
+      l.x = f.x + t.clientLeft, l.y = f.y + t.clientTop;
+    } else i && u();
+  o && !n && i && u();
+  const h = i && !n && !o ? _t(i, a) : F(0), c = s.left + a.scrollLeft - l.x - h.x, m = s.top + a.scrollTop - l.y - h.y;
+  return {
+    x: c,
+    y: m,
+    width: s.width,
+    height: s.height
+  };
+}
+function be(e) {
+  return $(e).position === "static";
+}
+function ot(e, t) {
+  if (!U(e) || $(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let r = e.offsetParent;
+  return z(e) === r && (r = r.ownerDocument.body), r;
+}
+function Tt(e, t) {
+  const r = M(e);
+  if (pe(e))
+    return r;
+  if (!U(e)) {
+    let i = X(e);
+    for (; i && !ne(i); ) {
+      if (W(i) && !be(i))
+        return i;
+      i = X(i);
+    }
+    return r;
+  }
+  let n = ot(e, t);
+  for (; n && wr(n) && be(n); )
+    n = ot(n, t);
+  return n && ne(n) && be(n) && !De(n) ? r : n || Or(e) || r;
+}
+const Ir = async function(e) {
+  const t = this.getOffsetParent || Tt, r = this.getDimensions, n = await r(e.floating);
+  return {
+    reference: jr(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function Br(e) {
+  return $(e).direction === "rtl";
+}
+const Wr = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: _r,
+  getDocumentElement: z,
+  getClippingRect: Nr,
+  getOffsetParent: Tt,
+  getElementRects: Ir,
+  getClientRects: Dr,
+  getDimensions: Vr,
+  getScale: Q,
+  isElement: W,
+  isRTL: Br
+}, Qr = pr, Zr = ar, ei = mr, ti = cr, ni = gr, ri = lr, ii = or, oi = fr, si = (e, t, r) => {
+  const n = /* @__PURE__ */ new Map(), i = {
+    platform: Wr,
+    ...r
+  }, o = {
+    ...i.platform,
+    _c: n
+  };
+  return ir(e, t, {
+    ...i,
+    platform: o
+  });
+};
+function $r(e) {
+  try {
+    return JSON.stringify(e);
+  } catch {
+    return JSON.stringify({});
+  }
+}
+function ai(e, t = !1) {
+  return (r) => {
+    const n = e.startsWith("data-") ? e : `data-${e}`;
+    let i = decodeURIComponent(r.getAttribute(n));
+    if (i == null || typeof i == "string" && i === "null")
+      try {
+        const a = r.outerHTML.match(/([\S\s])+?="([\S\s])+?"/g);
+        a && a.length > 0 && (i = (a.map((u) => u.trim()).reduce((u, h) => {
+          const c = h.indexOf("="), m = [h.slice(0, c), h.slice(c + 1).slice(1, -1)];
+          return u[m[0]] = m[1], u;
+        }, {})[e.toLowerCase()] || "").replaceAll("&quot;", '"'));
+      } catch (s) {
+        console.error("Error getDatasetAttribute ", s.message, r);
+      }
+    if (t)
+      try {
+        return JSON.parse(i);
+      } catch {
+        return {};
+      }
+    if (i.includes("%") || i.includes("auto"))
+      return i;
+    const o = Number.parseInt(i);
+    return o !== o ? i : o;
+  };
+}
+function ci(e) {
+  const { attrs: t } = e;
+  return Object.keys(t).reduce((r, n) => {
+    const i = t[n];
+    if (i == null)
+      return r;
+    let o = "";
+    return typeof i == "object" ? o = $r(i) : o = i, r[n] = o, r;
+  }, /* @__PURE__ */ Object.create(null));
+}
+export {
+  mt as E,
+  Xr as N,
+  Yr as R,
+  zn as a,
+  si as b,
+  Jr as c,
+  ei as d,
+  ii as e,
+  ti as f,
+  ai as g,
+  ni as h,
+  Zr as i,
+  ri as j,
+  oi as k,
+  Wn as l,
+  zr as m,
+  ci as n,
+  Qr as o,
+  Gr as p,
+  dt as s,
+  Kr as u
+};