@stihl-design-system/components 1.0.0-RC.46 → 1.0.0-RC.48

package/chunks/floating-ui.react.Chmq0RmI.js

@@ -0,0 +1,3014 @@
+"use client";
+import * as f from "react";
+import { useLayoutEffect as En } from "react";
+import { jsxs as It, jsx as re, Fragment as Gn } from "react/jsx-runtime";
+import * as kt from "react-dom";
+function it() {
+  return typeof window < "u";
+}
+function xe(e) {
+  return Dt(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function ee(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function le(e) {
+  var t;
+  return (t = (Dt(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Dt(e) {
+  return it() ? e instanceof Node || e instanceof ee(e).Node : !1;
+}
+function K(e) {
+  return it() ? e instanceof Element || e instanceof ee(e).Element : !1;
+}
+function X(e) {
+  return it() ? e instanceof HTMLElement || e instanceof ee(e).HTMLElement : !1;
+}
+function Ge(e) {
+  return !it() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof ee(e).ShadowRoot;
+}
+function Be(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: r,
+    display: o
+  } = oe(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && o !== "inline" && o !== "contents";
+}
+function Zn(e) {
+  return /^(table|td|th)$/.test(xe(e));
+}
+function st(e) {
+  try {
+    if (e.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return e.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const Jn = /transform|translate|scale|rotate|perspective|filter/, Qn = /paint|layout|strict|content/, Te = (e) => !!e && e !== "none";
+let pt;
+function Ft(e) {
+  const t = K(e) ? oe(e) : e;
+  return Te(t.transform) || Te(t.translate) || Te(t.scale) || Te(t.rotate) || Te(t.perspective) || !ct() && (Te(t.backdropFilter) || Te(t.filter)) || Jn.test(t.willChange || "") || Qn.test(t.contain || "");
+}
+function er(e) {
+  let t = ge(e);
+  for (; X(t) && !me(t); ) {
+    if (Ft(t))
+      return t;
+    if (st(t))
+      return null;
+    t = ge(t);
+  }
+  return null;
+}
+function ct() {
+  return pt == null && (pt = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), pt;
+}
+function me(e) {
+  return /^(html|body|#document)$/.test(xe(e));
+}
+function oe(e) {
+  return ee(e).getComputedStyle(e);
+}
+function ut(e) {
+  return K(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function ge(e) {
+  if (xe(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.
+    Ge(e) && e.host || // Fallback.
+    le(e)
+  );
+  return Ge(t) ? t.host : t;
+}
+function Tn(e) {
+  const t = ge(e);
+  return me(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : X(t) && Be(t) ? t : Tn(t);
+}
+function Re(e, t, n) {
+  var r;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = Tn(e), i = o === ((r = e.ownerDocument) == null ? void 0 : r.body), s = ee(o);
+  if (i) {
+    const c = Ct(s);
+    return t.concat(s, s.visualViewport || [], Be(o) ? o : [], c && n ? Re(c) : []);
+  } else
+    return t.concat(o, Re(o, [], n));
+}
+function Ct(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+const De = Math.min, Se = Math.max, Ze = Math.round, qe = Math.floor, ue = (e) => ({
+  x: e,
+  y: e
+}), tr = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function St(e, t, n) {
+  return Se(e, De(t, n));
+}
+function _e(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Ae(e) {
+  return e.split("-")[0];
+}
+function Ve(e) {
+  return e.split("-")[1];
+}
+function Cn(e) {
+  return e === "x" ? "y" : "x";
+}
+function Nt(e) {
+  return e === "y" ? "height" : "width";
+}
+function ye(e) {
+  const t = e[0];
+  return t === "t" || t === "b" ? "y" : "x";
+}
+function Wt(e) {
+  return Cn(ye(e));
+}
+function nr(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = Ve(e), o = Wt(e), i = Nt(o);
+  let s = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = Je(s)), [s, Je(s)];
+}
+function rr(e) {
+  const t = Je(e);
+  return [At(e), t, At(t)];
+}
+function At(e) {
+  return e.includes("start") ? e.replace("start", "end") : e.replace("end", "start");
+}
+const qt = ["left", "right"], Ut = ["right", "left"], or = ["top", "bottom"], ir = ["bottom", "top"];
+function sr(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? Ut : qt : t ? qt : Ut;
+    case "left":
+    case "right":
+      return t ? or : ir;
+    default:
+      return [];
+  }
+}
+function cr(e, t, n, r) {
+  const o = Ve(e);
+  let i = sr(Ae(e), n === "start", r);
+  return o && (i = i.map((s) => s + "-" + o), t && (i = i.concat(i.map(At)))), i;
+}
+function Je(e) {
+  const t = Ae(e);
+  return tr[t] + e.slice(t.length);
+}
+function ur(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Sn(e) {
+  return typeof e != "number" ? ur(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Qe(e) {
+  const {
+    x: t,
+    y: n,
+    width: r,
+    height: o
+  } = e;
+  return {
+    width: r,
+    height: o,
+    top: n,
+    left: t,
+    right: t + r,
+    bottom: n + o,
+    x: t,
+    y: n
+  };
+}
+var lr = ["input:not([inert])", "select:not([inert])", "textarea:not([inert])", "a[href]:not([inert])", "button:not([inert])", "[tabindex]:not(slot):not([inert])", "audio[controls]:not([inert])", "video[controls]:not([inert])", '[contenteditable]:not([contenteditable="false"]):not([inert])', "details>summary:first-of-type:not([inert])", "details:not([inert])"], et = /* @__PURE__ */ lr.join(","), An = typeof Element > "u", Fe = An ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, tt = !An && Element.prototype.getRootNode ? function(e) {
+  var t;
+  return e == null || (t = e.getRootNode) === null || t === void 0 ? void 0 : t.call(e);
+} : function(e) {
+  return e?.ownerDocument;
+}, nt = function e(t, n) {
+  var r;
+  n === void 0 && (n = !0);
+  var o = t == null || (r = t.getAttribute) === null || r === void 0 ? void 0 : r.call(t, "inert"), i = o === "" || o === "true", s = i || n && t && e(t.parentNode);
+  return s;
+}, ar = function(t) {
+  var n, r = t == null || (n = t.getAttribute) === null || n === void 0 ? void 0 : n.call(t, "contenteditable");
+  return r === "" || r === "true";
+}, On = function(t, n, r) {
+  if (nt(t))
+    return [];
+  var o = Array.prototype.slice.apply(t.querySelectorAll(et));
+  return n && Fe.call(t, et) && o.unshift(t), o = o.filter(r), o;
+}, Mn = function e(t, n, r) {
+  for (var o = [], i = Array.from(t); i.length; ) {
+    var s = i.shift();
+    if (!nt(s, !1))
+      if (s.tagName === "SLOT") {
+        var c = s.assignedElements(), u = c.length ? c : s.children, a = e(u, !0, r);
+        r.flatten ? o.push.apply(o, a) : o.push({
+          scopeParent: s,
+          candidates: a
+        });
+      } else {
+        var m = Fe.call(s, et);
+        m && r.filter(s) && (n || !t.includes(s)) && o.push(s);
+        var g = s.shadowRoot || // check for an undisclosed shadow
+        typeof r.getShadowRoot == "function" && r.getShadowRoot(s), v = !nt(g, !1) && (!r.shadowRootFilter || r.shadowRootFilter(s));
+        if (g && v) {
+          var l = e(g === !0 ? s.children : g.children, !0, r);
+          r.flatten ? o.push.apply(o, l) : o.push({
+            scopeParent: s,
+            candidates: l
+          });
+        } else
+          i.unshift.apply(i, s.children);
+      }
+  }
+  return o;
+}, Pn = function(t) {
+  return !isNaN(parseInt(t.getAttribute("tabindex"), 10));
+}, Ln = function(t) {
+  if (!t)
+    throw new Error("No node provided");
+  return t.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(t.tagName) || ar(t)) && !Pn(t) ? 0 : t.tabIndex;
+}, fr = function(t, n) {
+  var r = Ln(t);
+  return r < 0 && n && !Pn(t) ? 0 : r;
+}, dr = function(t, n) {
+  return t.tabIndex === n.tabIndex ? t.documentOrder - n.documentOrder : t.tabIndex - n.tabIndex;
+}, In = function(t) {
+  return t.tagName === "INPUT";
+}, mr = function(t) {
+  return In(t) && t.type === "hidden";
+}, gr = function(t) {
+  var n = t.tagName === "DETAILS" && Array.prototype.slice.apply(t.children).some(function(r) {
+    return r.tagName === "SUMMARY";
+  });
+  return n;
+}, pr = function(t, n) {
+  for (var r = 0; r < t.length; r++)
+    if (t[r].checked && t[r].form === n)
+      return t[r];
+}, vr = function(t) {
+  if (!t.name)
+    return !0;
+  var n = t.form || tt(t), r = function(c) {
+    return n.querySelectorAll('input[type="radio"][name="' + c + '"]');
+  }, o;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    o = r(window.CSS.escape(t.name));
+  else
+    try {
+      o = r(t.name);
+    } catch (s) {
+      return console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", s.message), !1;
+    }
+  var i = pr(o, t.form);
+  return !i || i === t;
+}, hr = function(t) {
+  return In(t) && t.type === "radio";
+}, br = function(t) {
+  return hr(t) && !vr(t);
+}, yr = function(t) {
+  var n, r = t && tt(t), o = (n = r) === null || n === void 0 ? void 0 : n.host, i = !1;
+  if (r && r !== t) {
+    var s, c, u;
+    for (i = !!((s = o) !== null && s !== void 0 && (c = s.ownerDocument) !== null && c !== void 0 && c.contains(o) || t != null && (u = t.ownerDocument) !== null && u !== void 0 && u.contains(t)); !i && o; ) {
+      var a, m, g;
+      r = tt(o), o = (a = r) === null || a === void 0 ? void 0 : a.host, i = !!((m = o) !== null && m !== void 0 && (g = m.ownerDocument) !== null && g !== void 0 && g.contains(o));
+    }
+  }
+  return i;
+}, Xt = function(t) {
+  var n = t.getBoundingClientRect(), r = n.width, o = n.height;
+  return r === 0 && o === 0;
+}, wr = function(t, n) {
+  var r = n.displayCheck, o = n.getShadowRoot;
+  if (getComputedStyle(t).visibility === "hidden")
+    return !0;
+  var i = Fe.call(t, "details>summary:first-of-type"), s = i ? t.parentElement : t;
+  if (Fe.call(s, "details:not([open]) *"))
+    return !0;
+  if (!r || r === "full" || r === "legacy-full") {
+    if (typeof o == "function") {
+      for (var c = t; t; ) {
+        var u = t.parentElement, a = tt(t);
+        if (u && !u.shadowRoot && o(u) === !0)
+          return Xt(t);
+        t.assignedSlot ? t = t.assignedSlot : !u && a !== t.ownerDocument ? t = a.host : t = u;
+      }
+      t = c;
+    }
+    if (yr(t))
+      return !t.getClientRects().length;
+    if (r !== "legacy-full")
+      return !0;
+  } else if (r === "non-zero-area")
+    return Xt(t);
+  return !1;
+}, Rr = function(t) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(t.tagName))
+    for (var n = t.parentElement; n; ) {
+      if (n.tagName === "FIELDSET" && n.disabled) {
+        for (var r = 0; r < n.children.length; r++) {
+          var o = n.children.item(r);
+          if (o.tagName === "LEGEND")
+            return Fe.call(n, "fieldset[disabled] *") ? !0 : !o.contains(t);
+        }
+        return !0;
+      }
+      n = n.parentElement;
+    }
+  return !1;
+}, Ot = function(t, n) {
+  return !(n.disabled || // we must do an inert look up to filter out any elements inside an inert ancestor
+  //  because we're limited in the type of selectors we can use in JSDom (see related
+  //  note related to `candidateSelectors`)
+  nt(n) || mr(n) || wr(n, t) || // For a details element with a summary, the summary element gets the focus
+  gr(n) || Rr(n));
+}, Mt = function(t, n) {
+  return !(br(n) || Ln(n) < 0 || !Ot(t, n));
+}, xr = function(t) {
+  var n = parseInt(t.getAttribute("tabindex"), 10);
+  return !!(isNaN(n) || n >= 0);
+}, Er = function e(t) {
+  var n = [], r = [];
+  return t.forEach(function(o, i) {
+    var s = !!o.scopeParent, c = s ? o.scopeParent : o, u = fr(c, s), a = s ? e(o.candidates) : c;
+    u === 0 ? s ? n.push.apply(n, a) : n.push(c) : r.push({
+      documentOrder: i,
+      tabIndex: u,
+      item: o,
+      isScope: s,
+      content: a
+    });
+  }), r.sort(dr).reduce(function(o, i) {
+    return i.isScope ? o.push.apply(o, i.content) : o.push(i.content), o;
+  }, []).concat(n);
+}, lt = function(t, n) {
+  n = n || {};
+  var r;
+  return n.getShadowRoot ? r = Mn([t], n.includeContainer, {
+    filter: Mt.bind(null, n),
+    flatten: !1,
+    getShadowRoot: n.getShadowRoot,
+    shadowRootFilter: xr
+  }) : r = On(t, n.includeContainer, Mt.bind(null, n)), Er(r);
+}, Tr = function(t, n) {
+  n = n || {};
+  var r;
+  return n.getShadowRoot ? r = Mn([t], n.includeContainer, {
+    filter: Ot.bind(null, n),
+    flatten: !0,
+    getShadowRoot: n.getShadowRoot
+  }) : r = On(t, n.includeContainer, Ot.bind(null, n)), r;
+}, kn = function(t, n) {
+  if (n = n || {}, !t)
+    throw new Error("No node provided");
+  return Fe.call(t, et) === !1 ? !1 : Mt(n, t);
+};
+function $t() {
+  const e = navigator.userAgentData;
+  return e != null && e.platform ? e.platform : navigator.platform;
+}
+function Dn() {
+  const e = navigator.userAgentData;
+  return e && Array.isArray(e.brands) ? e.brands.map((t) => {
+    let {
+      brand: n,
+      version: r
+    } = t;
+    return n + "/" + r;
+  }).join(" ") : navigator.userAgent;
+}
+function Fn() {
+  return /apple/i.test(navigator.vendor);
+}
+function Pt() {
+  const e = /android/i;
+  return e.test($t()) || e.test(Dn());
+}
+function Cr() {
+  return $t().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function Nn() {
+  return Dn().includes("jsdom/");
+}
+const Yt = "data-floating-ui-focusable", Sr = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function be(e) {
+  let t = e.activeElement;
+  for (; ((n = t) == null || (n = n.shadowRoot) == null ? void 0 : n.activeElement) != null; ) {
+    var n;
+    t = t.shadowRoot.activeElement;
+  }
+  return t;
+}
+function Z(e, t) {
+  if (!e || !t)
+    return !1;
+  const n = t.getRootNode == null ? void 0 : t.getRootNode();
+  if (e.contains(t))
+    return !0;
+  if (n && Ge(n)) {
+    let r = t;
+    for (; r; ) {
+      if (e === r)
+        return !0;
+      r = r.parentNode || r.host;
+    }
+  }
+  return !1;
+}
+function de(e) {
+  return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+function vt(e, t) {
+  if (t == null)
+    return !1;
+  if ("composedPath" in e)
+    return e.composedPath().includes(t);
+  const n = e;
+  return n.target != null && t.contains(n.target);
+}
+function Ar(e) {
+  return e.matches("html,body");
+}
+function J(e) {
+  return e?.ownerDocument || document;
+}
+function Bt(e) {
+  return X(e) && e.matches(Sr);
+}
+function zt(e) {
+  return e ? e.getAttribute("role") === "combobox" && Bt(e) : !1;
+}
+function Or(e) {
+  if (!e || Nn()) return !0;
+  try {
+    return e.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+function Lt(e) {
+  return e ? e.hasAttribute(Yt) ? e : e.querySelector("[" + Yt + "]") || e : null;
+}
+function Le(e, t, n) {
+  return n === void 0 && (n = !0), e.filter((o) => {
+    var i;
+    return o.parentId === t && (!n || ((i = o.context) == null ? void 0 : i.open));
+  }).flatMap((o) => [o, ...Le(e, o.id, n)]);
+}
+function Gt(e, t) {
+  var n;
+  let r = [], o = (n = e.find((i) => i.id === t)) == null ? void 0 : n.parentId;
+  for (; o; ) {
+    const i = e.find((s) => s.id === o);
+    o = i?.parentId, i && (r = r.concat(i));
+  }
+  return r;
+}
+function ht(e) {
+  e.preventDefault(), e.stopPropagation();
+}
+function Mr(e) {
+  return "nativeEvent" in e;
+}
+function Pr(e) {
+  return e.mozInputSource === 0 && e.isTrusted ? !0 : Pt() && e.pointerType ? e.type === "click" && e.buttons === 1 : e.detail === 0 && !e.pointerType;
+}
+function Lr(e) {
+  return Nn() ? !1 : !Pt() && e.width === 0 && e.height === 0 || Pt() && e.width === 1 && e.height === 1 && e.pressure === 0 && e.detail === 0 && e.pointerType === "mouse" || // iOS VoiceOver returns 0.333• for width/height.
+  e.width < 1 && e.height < 1 && e.pressure === 0 && e.detail === 0 && e.pointerType === "touch";
+}
+function We(e, t) {
+  const n = ["mouse", "pen"];
+  return t || n.push("", void 0), n.includes(e);
+}
+var Ir = typeof document < "u", kr = function() {
+}, G = Ir ? En : kr;
+const Dr = {
+  ...f
+};
+function Ce(e) {
+  const t = f.useRef(e);
+  return G(() => {
+    t.current = e;
+  }), t;
+}
+const Fr = Dr.useInsertionEffect, Nr = Fr || ((e) => e());
+function Q(e) {
+  const t = f.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return Nr(() => {
+    t.current = e;
+  }), f.useCallback(function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    return t.current == null ? void 0 : t.current(...r);
+  }, []);
+}
+const He = () => ({
+  getShadowRoot: !0,
+  displayCheck: (
+    // JSDOM does not support the `tabbable` library. To solve this we can
+    // check if `ResizeObserver` is a real function (not polyfilled), which
+    // determines if the current environment is JSDOM-like.
+    typeof ResizeObserver == "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+  )
+});
+function Wn(e, t) {
+  const n = lt(e, He()), r = n.length;
+  if (r === 0) return;
+  const o = be(J(e)), i = n.indexOf(o), s = i === -1 ? t === 1 ? 0 : r - 1 : i + t;
+  return n[s];
+}
+function $n(e) {
+  return Wn(J(e).body, 1) || e;
+}
+function Bn(e) {
+  return Wn(J(e).body, -1) || e;
+}
+function Ne(e, t) {
+  const n = t || e.currentTarget, r = e.relatedTarget;
+  return !r || !Z(n, r);
+}
+function Wr(e) {
+  lt(e, He()).forEach((n) => {
+    n.dataset.tabindex = n.getAttribute("tabindex") || "", n.setAttribute("tabindex", "-1");
+  });
+}
+function Zt(e) {
+  e.querySelectorAll("[data-tabindex]").forEach((n) => {
+    const r = n.dataset.tabindex;
+    delete n.dataset.tabindex, r ? n.setAttribute("tabindex", r) : n.removeAttribute("tabindex");
+  });
+}
+function Jt(e, t, n) {
+  let {
+    reference: r,
+    floating: o
+  } = e;
+  const i = ye(t), s = Wt(t), c = Nt(s), u = Ae(t), a = i === "y", m = r.x + r.width / 2 - o.width / 2, g = r.y + r.height / 2 - o.height / 2, v = r[c] / 2 - o[c] / 2;
+  let l;
+  switch (u) {
+    case "top":
+      l = {
+        x: m,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      l = {
+        x: m,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      l = {
+        x: r.x + r.width,
+        y: g
+      };
+      break;
+    case "left":
+      l = {
+        x: r.x - o.width,
+        y: g
+      };
+      break;
+    default:
+      l = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (Ve(t)) {
+    case "start":
+      l[s] -= v * (n && a ? -1 : 1);
+      break;
+    case "end":
+      l[s] += v * (n && a ? -1 : 1);
+      break;
+  }
+  return l;
+}
+async function $r(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: r,
+    y: o,
+    platform: i,
+    rects: s,
+    elements: c,
+    strategy: u
+  } = e, {
+    boundary: a = "clippingAncestors",
+    rootBoundary: m = "viewport",
+    elementContext: g = "floating",
+    altBoundary: v = !1,
+    padding: l = 0
+  } = _e(t, e), p = Sn(l), w = c[v ? g === "floating" ? "reference" : "floating" : g], R = Qe(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(w))) == null || n ? w : w.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(c.floating)),
+    boundary: a,
+    rootBoundary: m,
+    strategy: u
+  })), b = g === "floating" ? {
+    x: r,
+    y: o,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, y = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(c.floating)), C = await (i.isElement == null ? void 0 : i.isElement(y)) ? await (i.getScale == null ? void 0 : i.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, P = Qe(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: b,
+    offsetParent: y,
+    strategy: u
+  }) : b);
+  return {
+    top: (R.top - P.top + p.top) / C.y,
+    bottom: (P.bottom - R.bottom + p.bottom) / C.y,
+    left: (R.left - P.left + p.left) / C.x,
+    right: (P.right - R.right + p.right) / C.x
+  };
+}
+const Br = 50, _r = async (e, t, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: i = [],
+    platform: s
+  } = n, c = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: $r
+  }, u = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let a = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: m,
+    y: g
+  } = Jt(a, r, u), v = r, l = 0;
+  const p = {};
+  for (let d = 0; d < i.length; d++) {
+    const w = i[d];
+    if (!w)
+      continue;
+    const {
+      name: R,
+      fn: b
+    } = w, {
+      x: y,
+      y: C,
+      data: P,
+      reset: O
+    } = await b({
+      x: m,
+      y: g,
+      initialPlacement: r,
+      placement: v,
+      strategy: o,
+      middlewareData: p,
+      rects: a,
+      platform: c,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    m = y ?? m, g = C ?? g, p[R] = {
+      ...p[R],
+      ...P
+    }, O && l < Br && (l++, typeof O == "object" && (O.placement && (v = O.placement), O.rects && (a = O.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : O.rects), {
+      x: m,
+      y: g
+    } = Jt(a, v, u)), d = -1);
+  }
+  return {
+    x: m,
+    y: g,
+    placement: v,
+    strategy: o,
+    middlewareData: p
+  };
+}, Vr = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: r,
+      placement: o,
+      rects: i,
+      platform: s,
+      elements: c,
+      middlewareData: u
+    } = t, {
+      element: a,
+      padding: m = 0
+    } = _e(e, t) || {};
+    if (a == null)
+      return {};
+    const g = Sn(m), v = {
+      x: n,
+      y: r
+    }, l = Wt(o), p = Nt(l), d = await s.getDimensions(a), w = l === "y", R = w ? "top" : "left", b = w ? "bottom" : "right", y = w ? "clientHeight" : "clientWidth", C = i.reference[p] + i.reference[l] - v[l] - i.floating[p], P = v[l] - i.reference[l], O = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(a));
+    let M = O ? O[y] : 0;
+    (!M || !await (s.isElement == null ? void 0 : s.isElement(O))) && (M = c.floating[y] || i.floating[p]);
+    const D = C / 2 - P / 2, j = M / 2 - d[p] / 2 - 1, $ = De(g[R], j), W = De(g[b], j), B = $, _ = M - d[p] - W, x = M / 2 - d[p] / 2 + D, E = St(B, x, _), L = !u.arrow && Ve(o) != null && x !== E && i.reference[p] / 2 - (x < B ? $ : W) - d[p] / 2 < 0, T = L ? x < B ? x - B : x - _ : 0;
+    return {
+      [l]: v[l] + T,
+      data: {
+        [l]: E,
+        centerOffset: x - E - T,
+        ...L && {
+          alignmentOffset: T
+        }
+      },
+      reset: L
+    };
+  }
+}), Hr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        middlewareData: i,
+        rects: s,
+        initialPlacement: c,
+        platform: u,
+        elements: a
+      } = t, {
+        mainAxis: m = !0,
+        crossAxis: g = !0,
+        fallbackPlacements: v,
+        fallbackStrategy: l = "bestFit",
+        fallbackAxisSideDirection: p = "none",
+        flipAlignment: d = !0,
+        ...w
+      } = _e(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const R = Ae(o), b = ye(c), y = Ae(c) === c, C = await (u.isRTL == null ? void 0 : u.isRTL(a.floating)), P = v || (y || !d ? [Je(c)] : rr(c)), O = p !== "none";
+      !v && O && P.push(...cr(c, d, p, C));
+      const M = [c, ...P], D = await u.detectOverflow(t, w), j = [];
+      let $ = ((r = i.flip) == null ? void 0 : r.overflows) || [];
+      if (m && j.push(D[R]), g) {
+        const x = nr(o, s, C);
+        j.push(D[x[0]], D[x[1]]);
+      }
+      if ($ = [...$, {
+        placement: o,
+        overflows: j
+      }], !j.every((x) => x <= 0)) {
+        var W, B;
+        const x = (((W = i.flip) == null ? void 0 : W.index) || 0) + 1, E = M[x];
+        if (E && (!(g === "alignment" ? b !== ye(E) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        $.every((h) => ye(h.placement) === b ? h.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: x,
+              overflows: $
+            },
+            reset: {
+              placement: E
+            }
+          };
+        let L = (B = $.filter((T) => T.overflows[0] <= 0).sort((T, h) => T.overflows[1] - h.overflows[1])[0]) == null ? void 0 : B.placement;
+        if (!L)
+          switch (l) {
+            case "bestFit": {
+              var _;
+              const T = (_ = $.filter((h) => {
+                if (O) {
+                  const S = ye(h.placement);
+                  return S === b || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  S === "y";
+                }
+                return !0;
+              }).map((h) => [h.placement, h.overflows.filter((S) => S > 0).reduce((S, I) => S + I, 0)]).sort((h, S) => h[1] - S[1])[0]) == null ? void 0 : _[0];
+              T && (L = T);
+              break;
+            }
+            case "initialPlacement":
+              L = c;
+              break;
+          }
+        if (o !== L)
+          return {
+            reset: {
+              placement: L
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, Kr = /* @__PURE__ */ new Set(["left", "top"]);
+async function jr(e, t) {
+  const {
+    placement: n,
+    platform: r,
+    elements: o
+  } = e, i = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), s = Ae(n), c = Ve(n), u = ye(n) === "y", a = Kr.has(s) ? -1 : 1, m = i && u ? -1 : 1, g = _e(t, e);
+  let {
+    mainAxis: v,
+    crossAxis: l,
+    alignmentAxis: p
+  } = typeof g == "number" ? {
+    mainAxis: g,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: g.mainAxis || 0,
+    crossAxis: g.crossAxis || 0,
+    alignmentAxis: g.alignmentAxis
+  };
+  return c && typeof p == "number" && (l = c === "end" ? p * -1 : p), u ? {
+    x: l * m,
+    y: v * a
+  } : {
+    x: v * a,
+    y: l * m
+  };
+}
+const qr = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        x: o,
+        y: i,
+        placement: s,
+        middlewareData: c
+      } = t, u = await jr(t, e);
+      return s === ((n = c.offset) == null ? void 0 : n.placement) && (r = c.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + u.x,
+        y: i + u.y,
+        data: {
+          ...u,
+          placement: s
+        }
+      };
+    }
+  };
+}, Ur = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: r,
+        placement: o,
+        platform: i
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: c = !1,
+        limiter: u = {
+          fn: (R) => {
+            let {
+              x: b,
+              y
+            } = R;
+            return {
+              x: b,
+              y
+            };
+          }
+        },
+        ...a
+      } = _e(e, t), m = {
+        x: n,
+        y: r
+      }, g = await i.detectOverflow(t, a), v = ye(Ae(o)), l = Cn(v);
+      let p = m[l], d = m[v];
+      if (s) {
+        const R = l === "y" ? "top" : "left", b = l === "y" ? "bottom" : "right", y = p + g[R], C = p - g[b];
+        p = St(y, p, C);
+      }
+      if (c) {
+        const R = v === "y" ? "top" : "left", b = v === "y" ? "bottom" : "right", y = d + g[R], C = d - g[b];
+        d = St(y, d, C);
+      }
+      const w = u.fn({
+        ...t,
+        [l]: p,
+        [v]: d
+      });
+      return {
+        ...w,
+        data: {
+          x: w.x - n,
+          y: w.y - r,
+          enabled: {
+            [l]: s,
+            [v]: c
+          }
+        }
+      };
+    }
+  };
+};
+function _n(e) {
+  const t = oe(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = X(e), i = o ? e.offsetWidth : n, s = o ? e.offsetHeight : r, c = Ze(n) !== i || Ze(r) !== s;
+  return c && (n = i, r = s), {
+    width: n,
+    height: r,
+    $: c
+  };
+}
+function _t(e) {
+  return K(e) ? e : e.contextElement;
+}
+function Ie(e) {
+  const t = _t(e);
+  if (!X(t))
+    return ue(1);
+  const n = t.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: i
+  } = _n(t);
+  let s = (i ? Ze(n.width) : n.width) / r, c = (i ? Ze(n.height) : n.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+const Xr = /* @__PURE__ */ ue(0);
+function Vn(e) {
+  const t = ee(e);
+  return !ct() || !t.visualViewport ? Xr : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Yr(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== ee(e) ? !1 : t;
+}
+function Oe(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = _t(e);
+  let s = ue(1);
+  t && (r ? K(r) && (s = Ie(r)) : s = Ie(e));
+  const c = Yr(i, n, r) ? Vn(i) : ue(0);
+  let u = (o.left + c.x) / s.x, a = (o.top + c.y) / s.y, m = o.width / s.x, g = o.height / s.y;
+  if (i) {
+    const v = ee(i), l = r && K(r) ? ee(r) : r;
+    let p = v, d = Ct(p);
+    for (; d && r && l !== p; ) {
+      const w = Ie(d), R = d.getBoundingClientRect(), b = oe(d), y = R.left + (d.clientLeft + parseFloat(b.paddingLeft)) * w.x, C = R.top + (d.clientTop + parseFloat(b.paddingTop)) * w.y;
+      u *= w.x, a *= w.y, m *= w.x, g *= w.y, u += y, a += C, p = ee(d), d = Ct(p);
+    }
+  }
+  return Qe({
+    width: m,
+    height: g,
+    x: u,
+    y: a
+  });
+}
+function at(e, t) {
+  const n = ut(e).scrollLeft;
+  return t ? t.left + n : Oe(le(e)).left + n;
+}
+function Hn(e, t) {
+  const n = e.getBoundingClientRect(), r = n.left + t.scrollLeft - at(e, n), o = n.top + t.scrollTop;
+  return {
+    x: r,
+    y: o
+  };
+}
+function zr(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = e;
+  const i = o === "fixed", s = le(r), c = t ? st(t.floating) : !1;
+  if (r === s || c && i)
+    return n;
+  let u = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = ue(1);
+  const m = ue(0), g = X(r);
+  if ((g || !g && !i) && ((xe(r) !== "body" || Be(s)) && (u = ut(r)), g)) {
+    const l = Oe(r);
+    a = Ie(r), m.x = l.x + r.clientLeft, m.y = l.y + r.clientTop;
+  }
+  const v = s && !g && !i ? Hn(s, u) : ue(0);
+  return {
+    width: n.width * a.x,
+    height: n.height * a.y,
+    x: n.x * a.x - u.scrollLeft * a.x + m.x + v.x,
+    y: n.y * a.y - u.scrollTop * a.y + m.y + v.y
+  };
+}
+function Gr(e) {
+  return Array.from(e.getClientRects());
+}
+function Zr(e) {
+  const t = le(e), n = ut(e), r = e.ownerDocument.body, o = Se(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), i = Se(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let s = -n.scrollLeft + at(e);
+  const c = -n.scrollTop;
+  return oe(r).direction === "rtl" && (s += Se(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: s,
+    y: c
+  };
+}
+const Qt = 25;
+function Jr(e, t) {
+  const n = ee(e), r = le(e), o = n.visualViewport;
+  let i = r.clientWidth, s = r.clientHeight, c = 0, u = 0;
+  if (o) {
+    i = o.width, s = o.height;
+    const m = ct();
+    (!m || m && t === "fixed") && (c = o.offsetLeft, u = o.offsetTop);
+  }
+  const a = at(r);
+  if (a <= 0) {
+    const m = r.ownerDocument, g = m.body, v = getComputedStyle(g), l = m.compatMode === "CSS1Compat" && parseFloat(v.marginLeft) + parseFloat(v.marginRight) || 0, p = Math.abs(r.clientWidth - g.clientWidth - l);
+    p <= Qt && (i -= p);
+  } else a <= Qt && (i += a);
+  return {
+    width: i,
+    height: s,
+    x: c,
+    y: u
+  };
+}
+function Qr(e, t) {
+  const n = Oe(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, i = X(e) ? Ie(e) : ue(1), s = e.clientWidth * i.x, c = e.clientHeight * i.y, u = o * i.x, a = r * i.y;
+  return {
+    width: s,
+    height: c,
+    x: u,
+    y: a
+  };
+}
+function en(e, t, n) {
+  let r;
+  if (t === "viewport")
+    r = Jr(e, n);
+  else if (t === "document")
+    r = Zr(le(e));
+  else if (K(t))
+    r = Qr(t, n);
+  else {
+    const o = Vn(e);
+    r = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return Qe(r);
+}
+function Kn(e, t) {
+  const n = ge(e);
+  return n === t || !K(n) || me(n) ? !1 : oe(n).position === "fixed" || Kn(n, t);
+}
+function eo(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let r = Re(e, [], !1).filter((c) => K(c) && xe(c) !== "body"), o = null;
+  const i = oe(e).position === "fixed";
+  let s = i ? ge(e) : e;
+  for (; K(s) && !me(s); ) {
+    const c = oe(s), u = Ft(s);
+    !u && c.position === "fixed" && (o = null), (i ? !u && !o : !u && c.position === "static" && !!o && (o.position === "absolute" || o.position === "fixed") || Be(s) && !u && Kn(e, s)) ? r = r.filter((m) => m !== s) : o = c, s = ge(s);
+  }
+  return t.set(e, r), r;
+}
+function to(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = e;
+  const s = [...n === "clippingAncestors" ? st(t) ? [] : eo(t, this._c) : [].concat(n), r], c = en(t, s[0], o);
+  let u = c.top, a = c.right, m = c.bottom, g = c.left;
+  for (let v = 1; v < s.length; v++) {
+    const l = en(t, s[v], o);
+    u = Se(l.top, u), a = De(l.right, a), m = De(l.bottom, m), g = Se(l.left, g);
+  }
+  return {
+    width: a - g,
+    height: m - u,
+    x: g,
+    y: u
+  };
+}
+function no(e) {
+  const {
+    width: t,
+    height: n
+  } = _n(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function ro(e, t, n) {
+  const r = X(t), o = le(t), i = n === "fixed", s = Oe(e, !0, i, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const u = ue(0);
+  function a() {
+    u.x = at(o);
+  }
+  if (r || !r && !i)
+    if ((xe(t) !== "body" || Be(o)) && (c = ut(t)), r) {
+      const l = Oe(t, !0, i, t);
+      u.x = l.x + t.clientLeft, u.y = l.y + t.clientTop;
+    } else o && a();
+  i && !r && o && a();
+  const m = o && !r && !i ? Hn(o, c) : ue(0), g = s.left + c.scrollLeft - u.x - m.x, v = s.top + c.scrollTop - u.y - m.y;
+  return {
+    x: g,
+    y: v,
+    width: s.width,
+    height: s.height
+  };
+}
+function bt(e) {
+  return oe(e).position === "static";
+}
+function tn(e, t) {
+  if (!X(e) || oe(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return le(e) === n && (n = n.ownerDocument.body), n;
+}
+function jn(e, t) {
+  const n = ee(e);
+  if (st(e))
+    return n;
+  if (!X(e)) {
+    let o = ge(e);
+    for (; o && !me(o); ) {
+      if (K(o) && !bt(o))
+        return o;
+      o = ge(o);
+    }
+    return n;
+  }
+  let r = tn(e, t);
+  for (; r && Zn(r) && bt(r); )
+    r = tn(r, t);
+  return r && me(r) && bt(r) && !Ft(r) ? n : r || er(e) || n;
+}
+const oo = async function(e) {
+  const t = this.getOffsetParent || jn, n = this.getDimensions, r = await n(e.floating);
+  return {
+    reference: ro(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function io(e) {
+  return oe(e).direction === "rtl";
+}
+const so = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: zr,
+  getDocumentElement: le,
+  getClippingRect: to,
+  getOffsetParent: jn,
+  getElementRects: oo,
+  getClientRects: Gr,
+  getDimensions: no,
+  getScale: Ie,
+  isElement: K,
+  isRTL: io
+};
+function qn(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function co(e, t) {
+  let n = null, r;
+  const o = le(e);
+  function i() {
+    var c;
+    clearTimeout(r), (c = n) == null || c.disconnect(), n = null;
+  }
+  function s(c, u) {
+    c === void 0 && (c = !1), u === void 0 && (u = 1), i();
+    const a = e.getBoundingClientRect(), {
+      left: m,
+      top: g,
+      width: v,
+      height: l
+    } = a;
+    if (c || t(), !v || !l)
+      return;
+    const p = qe(g), d = qe(o.clientWidth - (m + v)), w = qe(o.clientHeight - (g + l)), R = qe(m), y = {
+      rootMargin: -p + "px " + -d + "px " + -w + "px " + -R + "px",
+      threshold: Se(0, De(1, u)) || 1
+    };
+    let C = !0;
+    function P(O) {
+      const M = O[0].intersectionRatio;
+      if (M !== u) {
+        if (!C)
+          return s();
+        M ? s(!1, M) : r = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      M === 1 && !qn(a, e.getBoundingClientRect()) && s(), C = !1;
+    }
+    try {
+      n = new IntersectionObserver(P, {
+        ...y,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(P, y);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function qo(e, t, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: u = !1
+  } = r, a = _t(e), m = o || i ? [...a ? Re(a) : [], ...t ? Re(t) : []] : [];
+  m.forEach((R) => {
+    o && R.addEventListener("scroll", n, {
+      passive: !0
+    }), i && R.addEventListener("resize", n);
+  });
+  const g = a && c ? co(a, n) : null;
+  let v = -1, l = null;
+  s && (l = new ResizeObserver((R) => {
+    let [b] = R;
+    b && b.target === a && l && t && (l.unobserve(t), cancelAnimationFrame(v), v = requestAnimationFrame(() => {
+      var y;
+      (y = l) == null || y.observe(t);
+    })), n();
+  }), a && !u && l.observe(a), t && l.observe(t));
+  let p, d = u ? Oe(e) : null;
+  u && w();
+  function w() {
+    const R = Oe(e);
+    d && !qn(d, R) && n(), d = R, p = requestAnimationFrame(w);
+  }
+  return n(), () => {
+    var R;
+    m.forEach((b) => {
+      o && b.removeEventListener("scroll", n), i && b.removeEventListener("resize", n);
+    }), g?.(), (R = l) == null || R.disconnect(), l = null, u && cancelAnimationFrame(p);
+  };
+}
+const uo = qr, lo = Ur, ao = Hr, nn = Vr, fo = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: so,
+    ...n
+  }, i = {
+    ...o.platform,
+    _c: r
+  };
+  return _r(e, t, {
+    ...o,
+    platform: i
+  });
+};
+var mo = typeof document < "u", go = function() {
+}, ze = mo ? En : go;
+function rt(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let n, r, o;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!rt(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (o = Object.keys(e), n = o.length, n !== Object.keys(t).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, o[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      const i = o[r];
+      if (!(i === "_owner" && e.$$typeof) && !rt(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function Un(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function rn(e, t) {
+  const n = Un(e);
+  return Math.round(t * n) / n;
+}
+function yt(e) {
+  const t = f.useRef(e);
+  return ze(() => {
+    t.current = e;
+  }), t;
+}
+function po(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: o,
+    elements: {
+      reference: i,
+      floating: s
+    } = {},
+    transform: c = !0,
+    whileElementsMounted: u,
+    open: a
+  } = e, [m, g] = f.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [v, l] = f.useState(r);
+  rt(v, r) || l(r);
+  const [p, d] = f.useState(null), [w, R] = f.useState(null), b = f.useCallback((h) => {
+    h !== O.current && (O.current = h, d(h));
+  }, []), y = f.useCallback((h) => {
+    h !== M.current && (M.current = h, R(h));
+  }, []), C = i || p, P = s || w, O = f.useRef(null), M = f.useRef(null), D = f.useRef(m), j = u != null, $ = yt(u), W = yt(o), B = yt(a), _ = f.useCallback(() => {
+    if (!O.current || !M.current)
+      return;
+    const h = {
+      placement: t,
+      strategy: n,
+      middleware: v
+    };
+    W.current && (h.platform = W.current), fo(O.current, M.current, h).then((S) => {
+      const I = {
+        ...S,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: B.current !== !1
+      };
+      x.current && !rt(D.current, I) && (D.current = I, kt.flushSync(() => {
+        g(I);
+      }));
+    });
+  }, [v, t, n, W, B]);
+  ze(() => {
+    a === !1 && D.current.isPositioned && (D.current.isPositioned = !1, g((h) => ({
+      ...h,
+      isPositioned: !1
+    })));
+  }, [a]);
+  const x = f.useRef(!1);
+  ze(() => (x.current = !0, () => {
+    x.current = !1;
+  }), []), ze(() => {
+    if (C && (O.current = C), P && (M.current = P), C && P) {
+      if ($.current)
+        return $.current(C, P, _);
+      _();
+    }
+  }, [C, P, _, $, j]);
+  const E = f.useMemo(() => ({
+    reference: O,
+    floating: M,
+    setReference: b,
+    setFloating: y
+  }), [b, y]), L = f.useMemo(() => ({
+    reference: C,
+    floating: P
+  }), [C, P]), T = f.useMemo(() => {
+    const h = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!L.floating)
+      return h;
+    const S = rn(L.floating, m.x), I = rn(L.floating, m.y);
+    return c ? {
+      ...h,
+      transform: "translate(" + S + "px, " + I + "px)",
+      ...Un(L.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: S,
+      top: I
+    };
+  }, [n, c, L.floating, m.x, m.y]);
+  return f.useMemo(() => ({
+    ...m,
+    update: _,
+    refs: E,
+    elements: L,
+    floatingStyles: T
+  }), [m, _, E, L, T]);
+}
+const vo = (e) => {
+  function t(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(n) {
+      const {
+        element: r,
+        padding: o
+      } = typeof e == "function" ? e(n) : e;
+      return r && t(r) ? r.current != null ? nn({
+        element: r.current,
+        padding: o
+      }).fn(n) : {} : r ? nn({
+        element: r,
+        padding: o
+      }).fn(n) : {};
+    }
+  };
+}, Uo = (e, t) => {
+  const n = uo(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, Xo = (e, t) => {
+  const n = lo(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, Yo = (e, t) => {
+  const n = ao(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, zo = (e, t) => {
+  const n = vo(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+};
+function Go(e) {
+  const t = f.useRef(void 0), n = f.useCallback((r) => {
+    const o = e.map((i) => {
+      if (i != null) {
+        if (typeof i == "function") {
+          const s = i, c = s(r);
+          return typeof c == "function" ? c : () => {
+            s(null);
+          };
+        }
+        return i.current = r, () => {
+          i.current = null;
+        };
+      }
+    });
+    return () => {
+      o.forEach((i) => i?.());
+    };
+  }, e);
+  return f.useMemo(() => e.every((r) => r == null) ? null : (r) => {
+    t.current && (t.current(), t.current = void 0), r != null && (t.current = n(r));
+  }, e);
+}
+const ho = "data-floating-ui-focusable", on = "active", sn = "selected", bo = {
+  ...f
+};
+let cn = !1, yo = 0;
+const un = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + yo++
+);
+function wo() {
+  const [e, t] = f.useState(() => cn ? un() : void 0);
+  return G(() => {
+    e == null && t(un());
+  }, []), f.useEffect(() => {
+    cn = !0;
+  }, []), e;
+}
+const Ro = bo.useId, ft = Ro || wo;
+let $e;
+process.env.NODE_ENV !== "production" && ($e = /* @__PURE__ */ new Set());
+function xo() {
+  for (var e, t = arguments.length, n = new Array(t), r = 0; r < t; r++)
+    n[r] = arguments[r];
+  const o = "Floating UI: " + n.join(" ");
+  if (!((e = $e) != null && e.has(o))) {
+    var i;
+    (i = $e) == null || i.add(o), console.warn(o);
+  }
+}
+function Eo() {
+  for (var e, t = arguments.length, n = new Array(t), r = 0; r < t; r++)
+    n[r] = arguments[r];
+  const o = "Floating UI: " + n.join(" ");
+  if (!((e = $e) != null && e.has(o))) {
+    var i;
+    (i = $e) == null || i.add(o), console.error(o);
+  }
+}
+const Zo = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const {
+    context: {
+      placement: r,
+      elements: {
+        floating: o
+      },
+      middlewareData: {
+        arrow: i,
+        shift: s
+      }
+    },
+    width: c = 14,
+    height: u = 7,
+    tipRadius: a = 0,
+    strokeWidth: m = 0,
+    staticOffset: g,
+    stroke: v,
+    d: l,
+    style: {
+      transform: p,
+      ...d
+    } = {},
+    ...w
+  } = t;
+  process.env.NODE_ENV !== "production" && (n || xo("The `ref` prop is required for `FloatingArrow`."));
+  const R = ft(), [b, y] = f.useState(!1);
+  if (G(() => {
+    if (!o) return;
+    oe(o).direction === "rtl" && y(!0);
+  }, [o]), !o)
+    return null;
+  const [C, P] = r.split("-"), O = C === "top" || C === "bottom";
+  let M = g;
+  (O && s != null && s.x || !O && s != null && s.y) && (M = null);
+  const D = m * 2, j = D / 2, $ = c / 2 * (a / -8 + 1), W = u / 2 * a / 4, B = !!l, _ = M && P === "end" ? "bottom" : "top";
+  let x = M && P === "end" ? "right" : "left";
+  M && b && (x = P === "end" ? "left" : "right");
+  const E = i?.x != null ? M || i.x : "", L = i?.y != null ? M || i.y : "", T = l || "M0,0" + (" H" + c) + (" L" + (c - $) + "," + (u - W)) + (" Q" + c / 2 + "," + u + " " + $ + "," + (u - W)) + " Z", h = {
+    top: B ? "rotate(180deg)" : "",
+    left: B ? "rotate(90deg)" : "rotate(-90deg)",
+    bottom: B ? "" : "rotate(180deg)",
+    right: B ? "rotate(-90deg)" : "rotate(90deg)"
+  }[C];
+  return /* @__PURE__ */ It("svg", {
+    ...w,
+    "aria-hidden": !0,
+    ref: n,
+    width: B ? c : c + D,
+    height: c,
+    viewBox: "0 0 " + c + " " + (u > c ? u : c),
+    style: {
+      position: "absolute",
+      pointerEvents: "none",
+      [x]: E,
+      [_]: L,
+      [C]: O || B ? "100%" : "calc(100% - " + D / 2 + "px)",
+      transform: [h, p].filter((S) => !!S).join(" "),
+      ...d
+    },
+    children: [D > 0 && /* @__PURE__ */ re("path", {
+      clipPath: "url(#" + R + ")",
+      fill: "none",
+      stroke: v,
+      strokeWidth: D + (l ? 0 : 1),
+      d: T
+    }), /* @__PURE__ */ re("path", {
+      stroke: D && !l ? w.fill : "none",
+      d: T
+    }), /* @__PURE__ */ re("clipPath", {
+      id: R,
+      children: /* @__PURE__ */ re("rect", {
+        x: -j,
+        y: j * (B ? -1 : 1),
+        width: c + D,
+        height: c
+      })
+    })]
+  });
+});
+function To() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    emit(t, n) {
+      var r;
+      (r = e.get(t)) == null || r.forEach((o) => o(n));
+    },
+    on(t, n) {
+      e.has(t) || e.set(t, /* @__PURE__ */ new Set()), e.get(t).add(n);
+    },
+    off(t, n) {
+      var r;
+      (r = e.get(t)) == null || r.delete(n);
+    }
+  };
+}
+const Co = /* @__PURE__ */ f.createContext(null), So = /* @__PURE__ */ f.createContext(null), Vt = () => {
+  var e;
+  return ((e = f.useContext(Co)) == null ? void 0 : e.id) || null;
+}, dt = () => f.useContext(So);
+function Me(e) {
+  return "data-floating-ui-" + e;
+}
+function ne(e) {
+  e.current !== -1 && (clearTimeout(e.current), e.current = -1);
+}
+const ln = /* @__PURE__ */ Me("safe-polygon");
+function wt(e, t, n) {
+  if (n && !We(n))
+    return 0;
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "function") {
+    const r = e();
+    return typeof r == "number" ? r : r?.[t];
+  }
+  return e?.[t];
+}
+function Rt(e) {
+  return typeof e == "function" ? e() : e;
+}
+function Jo(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    dataRef: o,
+    events: i,
+    elements: s
+  } = e, {
+    enabled: c = !0,
+    delay: u = 0,
+    handleClose: a = null,
+    mouseOnly: m = !1,
+    restMs: g = 0,
+    move: v = !0
+  } = t, l = dt(), p = Vt(), d = Ce(a), w = Ce(u), R = Ce(n), b = Ce(g), y = f.useRef(), C = f.useRef(-1), P = f.useRef(), O = f.useRef(-1), M = f.useRef(!0), D = f.useRef(!1), j = f.useRef(() => {
+  }), $ = f.useRef(!1), W = Q(() => {
+    var T;
+    const h = (T = o.current.openEvent) == null ? void 0 : T.type;
+    return h?.includes("mouse") && h !== "mousedown";
+  });
+  f.useEffect(() => {
+    if (!c) return;
+    function T(h) {
+      let {
+        open: S
+      } = h;
+      S || (ne(C), ne(O), M.current = !0, $.current = !1);
+    }
+    return i.on("openchange", T), () => {
+      i.off("openchange", T);
+    };
+  }, [c, i]), f.useEffect(() => {
+    if (!c || !d.current || !n) return;
+    function T(S) {
+      W() && r(!1, S, "hover");
+    }
+    const h = J(s.floating).documentElement;
+    return h.addEventListener("mouseleave", T), () => {
+      h.removeEventListener("mouseleave", T);
+    };
+  }, [s.floating, n, r, c, d, W]);
+  const B = f.useCallback(function(T, h, S) {
+    h === void 0 && (h = !0), S === void 0 && (S = "hover");
+    const I = wt(w.current, "close", y.current);
+    I && !P.current ? (ne(C), C.current = window.setTimeout(() => r(!1, T, S), I)) : h && (ne(C), r(!1, T, S));
+  }, [w, r]), _ = Q(() => {
+    j.current(), P.current = void 0;
+  }), x = Q(() => {
+    if (D.current) {
+      const T = J(s.floating).body;
+      T.style.pointerEvents = "", T.removeAttribute(ln), D.current = !1;
+    }
+  }), E = Q(() => o.current.openEvent ? ["click", "mousedown"].includes(o.current.openEvent.type) : !1);
+  f.useEffect(() => {
+    if (!c) return;
+    function T(F) {
+      if (ne(C), M.current = !1, m && !We(y.current) || Rt(b.current) > 0 && !wt(w.current, "open"))
+        return;
+      const A = wt(w.current, "open", y.current);
+      A ? C.current = window.setTimeout(() => {
+        R.current || r(!0, F, "hover");
+      }, A) : n || r(!0, F, "hover");
+    }
+    function h(F) {
+      if (E()) {
+        x();
+        return;
+      }
+      j.current();
+      const A = J(s.floating);
+      if (ne(O), $.current = !1, d.current && o.current.floatingContext) {
+        n || ne(C), P.current = d.current({
+          ...o.current.floatingContext,
+          tree: l,
+          x: F.clientX,
+          y: F.clientY,
+          onClose() {
+            x(), _(), E() || B(F, !0, "safe-polygon");
+          }
+        });
+        const q = P.current;
+        A.addEventListener("mousemove", q), j.current = () => {
+          A.removeEventListener("mousemove", q);
+        };
+        return;
+      }
+      (y.current !== "touch" || !Z(s.floating, F.relatedTarget)) && B(F);
+    }
+    function S(F) {
+      E() || o.current.floatingContext && (d.current == null || d.current({
+        ...o.current.floatingContext,
+        tree: l,
+        x: F.clientX,
+        y: F.clientY,
+        onClose() {
+          x(), _(), E() || B(F);
+        }
+      })(F));
+    }
+    function I() {
+      ne(C);
+    }
+    function Y(F) {
+      E() || B(F, !1);
+    }
+    if (K(s.domReference)) {
+      const F = s.domReference, A = s.floating;
+      return n && F.addEventListener("mouseleave", S), v && F.addEventListener("mousemove", T, {
+        once: !0
+      }), F.addEventListener("mouseenter", T), F.addEventListener("mouseleave", h), A && (A.addEventListener("mouseleave", S), A.addEventListener("mouseenter", I), A.addEventListener("mouseleave", Y)), () => {
+        n && F.removeEventListener("mouseleave", S), v && F.removeEventListener("mousemove", T), F.removeEventListener("mouseenter", T), F.removeEventListener("mouseleave", h), A && (A.removeEventListener("mouseleave", S), A.removeEventListener("mouseenter", I), A.removeEventListener("mouseleave", Y));
+      };
+    }
+  }, [s, c, e, m, v, B, _, x, r, n, R, l, w, d, o, E, b]), G(() => {
+    var T;
+    if (c && n && (T = d.current) != null && (T = T.__options) != null && T.blockPointerEvents && W()) {
+      D.current = !0;
+      const S = s.floating;
+      if (K(s.domReference) && S) {
+        var h;
+        const I = J(s.floating).body;
+        I.setAttribute(ln, "");
+        const Y = s.domReference, F = l == null || (h = l.nodesRef.current.find((A) => A.id === p)) == null || (h = h.context) == null ? void 0 : h.elements.floating;
+        return F && (F.style.pointerEvents = ""), I.style.pointerEvents = "none", Y.style.pointerEvents = "auto", S.style.pointerEvents = "auto", () => {
+          I.style.pointerEvents = "", Y.style.pointerEvents = "", S.style.pointerEvents = "";
+        };
+      }
+    }
+  }, [c, n, p, s, l, d, W]), G(() => {
+    n || (y.current = void 0, $.current = !1, _(), x());
+  }, [n, _, x]), f.useEffect(() => () => {
+    _(), ne(C), ne(O), x();
+  }, [c, s.domReference, _, x]);
+  const L = f.useMemo(() => {
+    function T(h) {
+      y.current = h.pointerType;
+    }
+    return {
+      onPointerDown: T,
+      onPointerEnter: T,
+      onMouseMove(h) {
+        const {
+          nativeEvent: S
+        } = h;
+        function I() {
+          !M.current && !R.current && r(!0, S, "hover");
+        }
+        m && !We(y.current) || n || Rt(b.current) === 0 || $.current && h.movementX ** 2 + h.movementY ** 2 < 2 || (ne(O), y.current === "touch" ? I() : ($.current = !0, O.current = window.setTimeout(I, Rt(b.current))));
+      }
+    };
+  }, [m, r, n, R, b]);
+  return f.useMemo(() => c ? {
+    reference: L
+  } : {}, [c, L]);
+}
+let an = 0;
+function Pe(e, t) {
+  t === void 0 && (t = {});
+  const {
+    preventScroll: n = !1,
+    cancelPrevious: r = !0,
+    sync: o = !1
+  } = t;
+  r && cancelAnimationFrame(an);
+  const i = () => e?.focus({
+    preventScroll: n
+  });
+  o ? i() : an = requestAnimationFrame(i);
+}
+function Ao(e) {
+  return e?.ownerDocument || document;
+}
+const ke = {
+  inert: /* @__PURE__ */ new WeakMap(),
+  "aria-hidden": /* @__PURE__ */ new WeakMap(),
+  none: /* @__PURE__ */ new WeakMap()
+};
+function fn(e) {
+  return e === "inert" ? ke.inert : e === "aria-hidden" ? ke["aria-hidden"] : ke.none;
+}
+let Ue = /* @__PURE__ */ new WeakSet(), Xe = {}, xt = 0;
+const Oo = () => typeof HTMLElement < "u" && "inert" in HTMLElement.prototype;
+function Xn(e) {
+  return e ? Ge(e) ? e.host : Xn(e.parentNode) : null;
+}
+const Mo = (e, t) => t.map((n) => {
+  if (e.contains(n))
+    return n;
+  const r = Xn(n);
+  return e.contains(r) ? r : null;
+}).filter((n) => n != null);
+function Po(e, t, n, r) {
+  const o = "data-floating-ui-inert", i = r ? "inert" : n ? "aria-hidden" : null, s = Mo(t, e), c = /* @__PURE__ */ new Set(), u = new Set(s), a = [];
+  Xe[o] || (Xe[o] = /* @__PURE__ */ new WeakMap());
+  const m = Xe[o];
+  s.forEach(g), v(t), c.clear();
+  function g(l) {
+    !l || c.has(l) || (c.add(l), l.parentNode && g(l.parentNode));
+  }
+  function v(l) {
+    !l || u.has(l) || [].forEach.call(l.children, (p) => {
+      if (xe(p) !== "script")
+        if (c.has(p))
+          v(p);
+        else {
+          const d = i ? p.getAttribute(i) : null, w = d !== null && d !== "false", R = fn(i), b = (R.get(p) || 0) + 1, y = (m.get(p) || 0) + 1;
+          R.set(p, b), m.set(p, y), a.push(p), b === 1 && w && Ue.add(p), y === 1 && p.setAttribute(o, ""), !w && i && p.setAttribute(i, i === "inert" ? "" : "true");
+        }
+    });
+  }
+  return xt++, () => {
+    a.forEach((l) => {
+      const p = fn(i), w = (p.get(l) || 0) - 1, R = (m.get(l) || 0) - 1;
+      p.set(l, w), m.set(l, R), w || (!Ue.has(l) && i && l.removeAttribute(i), Ue.delete(l)), R || l.removeAttribute(o);
+    }), xt--, xt || (ke.inert = /* @__PURE__ */ new WeakMap(), ke["aria-hidden"] = /* @__PURE__ */ new WeakMap(), ke.none = /* @__PURE__ */ new WeakMap(), Ue = /* @__PURE__ */ new WeakSet(), Xe = {});
+  };
+}
+function dn(e, t, n) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const r = Ao(e[0]).body;
+  return Po(e.concat(Array.from(r.querySelectorAll('[aria-live],[role="status"],output'))), r, t, n);
+}
+const Ht = {
+  border: 0,
+  clip: "rect(0 0 0 0)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: 0,
+  position: "fixed",
+  whiteSpace: "nowrap",
+  width: "1px",
+  top: 0,
+  left: 0
+}, ot = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const [r, o] = f.useState();
+  G(() => {
+    Fn() && o("button");
+  }, []);
+  const i = {
+    ref: n,
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role: r,
+    "aria-hidden": r ? void 0 : !0,
+    [Me("focus-guard")]: "",
+    style: Ht
+  };
+  return /* @__PURE__ */ re("span", {
+    ...t,
+    ...i
+  });
+}), Lo = {
+  clipPath: "inset(50%)",
+  position: "fixed",
+  top: 0,
+  left: 0
+}, Yn = /* @__PURE__ */ f.createContext(null), mn = /* @__PURE__ */ Me("portal");
+function Io(e) {
+  e === void 0 && (e = {});
+  const {
+    id: t,
+    root: n
+  } = e, r = ft(), o = zn(), [i, s] = f.useState(null), c = f.useRef(null);
+  return G(() => () => {
+    i?.remove(), queueMicrotask(() => {
+      c.current = null;
+    });
+  }, [i]), G(() => {
+    if (!r || c.current) return;
+    const u = t ? document.getElementById(t) : null;
+    if (!u) return;
+    const a = document.createElement("div");
+    a.id = r, a.setAttribute(mn, ""), u.appendChild(a), c.current = a, s(a);
+  }, [t, r]), G(() => {
+    if (n === null || !r || c.current) return;
+    let u = n || o?.portalNode;
+    u && !Dt(u) && (u = u.current), u = u || document.body;
+    let a = null;
+    t && (a = document.createElement("div"), a.id = t, u.appendChild(a));
+    const m = document.createElement("div");
+    m.id = r, m.setAttribute(mn, ""), u = a || u, u.appendChild(m), c.current = m, s(m);
+  }, [t, n, r, o]), i;
+}
+function Qo(e) {
+  const {
+    children: t,
+    id: n,
+    root: r,
+    preserveTabOrder: o = !0
+  } = e, i = Io({
+    id: n,
+    root: r
+  }), [s, c] = f.useState(null), u = f.useRef(null), a = f.useRef(null), m = f.useRef(null), g = f.useRef(null), v = s?.modal, l = s?.open, p = (
+    // The FocusManager and therefore floating element are currently open/
+    // rendered.
+    !!s && // Guards are only for non-modal focus management.
+    !s.modal && // Don't render if unmount is transitioning.
+    s.open && o && !!(r || i)
+  );
+  return f.useEffect(() => {
+    if (!i || !o || v)
+      return;
+    function d(w) {
+      i && Ne(w) && (w.type === "focusin" ? Zt : Wr)(i);
+    }
+    return i.addEventListener("focusin", d, !0), i.addEventListener("focusout", d, !0), () => {
+      i.removeEventListener("focusin", d, !0), i.removeEventListener("focusout", d, !0);
+    };
+  }, [i, o, v]), f.useEffect(() => {
+    i && (l || Zt(i));
+  }, [l, i]), /* @__PURE__ */ It(Yn.Provider, {
+    value: f.useMemo(() => ({
+      preserveTabOrder: o,
+      beforeOutsideRef: u,
+      afterOutsideRef: a,
+      beforeInsideRef: m,
+      afterInsideRef: g,
+      portalNode: i,
+      setFocusManagerState: c
+    }), [o, i]),
+    children: [p && i && /* @__PURE__ */ re(ot, {
+      "data-type": "outside",
+      ref: u,
+      onFocus: (d) => {
+        if (Ne(d, i)) {
+          var w;
+          (w = m.current) == null || w.focus();
+        } else {
+          const R = s ? s.domReference : null, b = Bn(R);
+          b?.focus();
+        }
+      }
+    }), p && i && /* @__PURE__ */ re("span", {
+      "aria-owns": i.id,
+      style: Lo
+    }), i && /* @__PURE__ */ kt.createPortal(t, i), p && i && /* @__PURE__ */ re(ot, {
+      "data-type": "outside",
+      ref: a,
+      onFocus: (d) => {
+        if (Ne(d, i)) {
+          var w;
+          (w = g.current) == null || w.focus();
+        } else {
+          const R = s ? s.domReference : null, b = $n(R);
+          b?.focus(), s?.closeOnFocusOut && s?.onOpenChange(!1, d.nativeEvent, "focus-out");
+        }
+      }
+    })]
+  });
+}
+const zn = () => f.useContext(Yn);
+function gn(e) {
+  return f.useMemo(() => (t) => {
+    e.forEach((n) => {
+      n && (n.current = t);
+    });
+  }, e);
+}
+const pn = 20;
+let we = [];
+function Kt() {
+  we = we.filter((e) => {
+    var t;
+    return (t = e.deref()) == null ? void 0 : t.isConnected;
+  });
+}
+function ko(e) {
+  Kt(), e && xe(e) !== "body" && (we.push(new WeakRef(e)), we.length > pn && (we = we.slice(-pn)));
+}
+function vn() {
+  Kt();
+  const e = we[we.length - 1];
+  return e?.deref();
+}
+function Do(e) {
+  const t = He();
+  return kn(e, t) ? e : lt(e, t)[0] || e;
+}
+function hn(e, t) {
+  var n;
+  if (!t.current.includes("floating") && !((n = e.getAttribute("role")) != null && n.includes("dialog")))
+    return;
+  const r = He(), i = Tr(e, r).filter((c) => {
+    const u = c.getAttribute("data-tabindex") || "";
+    return kn(c, r) || c.hasAttribute("data-tabindex") && !u.startsWith("-");
+  }), s = e.getAttribute("tabindex");
+  t.current.includes("floating") || i.length === 0 ? s !== "0" && e.setAttribute("tabindex", "0") : (s !== "-1" || e.hasAttribute("data-tabindex") && e.getAttribute("data-tabindex") !== "-1") && (e.setAttribute("tabindex", "-1"), e.setAttribute("data-tabindex", "-1"));
+}
+const Fo = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  return /* @__PURE__ */ re("button", {
+    ...t,
+    type: "button",
+    ref: n,
+    tabIndex: -1,
+    style: Ht
+  });
+});
+function ei(e) {
+  const {
+    context: t,
+    children: n,
+    disabled: r = !1,
+    order: o = ["content"],
+    guards: i = !0,
+    initialFocus: s = 0,
+    returnFocus: c = !0,
+    restoreFocus: u = !1,
+    modal: a = !0,
+    visuallyHiddenDismiss: m = !1,
+    closeOnFocusOut: g = !0,
+    outsideElementsInert: v = !1,
+    getInsideElements: l = () => []
+  } = e, {
+    open: p,
+    onOpenChange: d,
+    events: w,
+    dataRef: R,
+    elements: {
+      domReference: b,
+      floating: y
+    }
+  } = t, C = Q(() => {
+    var k;
+    return (k = R.current.floatingContext) == null ? void 0 : k.nodeId;
+  }), P = Q(l), O = typeof s == "number" && s < 0, M = zt(b) && O, D = Oo(), j = D ? i : !0, $ = !j || D && v, W = Ce(o), B = Ce(s), _ = Ce(c), x = dt(), E = zn(), L = f.useRef(null), T = f.useRef(null), h = f.useRef(!1), S = f.useRef(!1), I = f.useRef(-1), Y = f.useRef(-1), F = E != null, A = Lt(y), ce = Q(function(k) {
+    return k === void 0 && (k = A), k ? lt(k, He()) : [];
+  }), q = Q((k) => {
+    const V = ce(k);
+    return W.current.map((N) => b && N === "reference" ? b : A && N === "floating" ? A : V).filter(Boolean).flat();
+  });
+  f.useEffect(() => {
+    if (r || !a) return;
+    function k(N) {
+      if (N.key === "Tab") {
+        Z(A, be(J(A))) && ce().length === 0 && !M && ht(N);
+        const U = q(), z = de(N);
+        W.current[0] === "reference" && z === b && (ht(N), N.shiftKey ? Pe(U[U.length - 1]) : Pe(U[1])), W.current[1] === "floating" && z === A && N.shiftKey && (ht(N), Pe(U[0]));
+      }
+    }
+    const V = J(A);
+    return V.addEventListener("keydown", k), () => {
+      V.removeEventListener("keydown", k);
+    };
+  }, [r, b, A, a, W, M, ce, q]), f.useEffect(() => {
+    if (r || !y) return;
+    function k(V) {
+      const N = de(V), z = ce().indexOf(N);
+      z !== -1 && (I.current = z);
+    }
+    return y.addEventListener("focusin", k), () => {
+      y.removeEventListener("focusin", k);
+    };
+  }, [r, y, ce]), f.useEffect(() => {
+    if (r || !g) return;
+    function k() {
+      S.current = !0, setTimeout(() => {
+        S.current = !1;
+      });
+    }
+    function V(z) {
+      const H = z.relatedTarget, ae = z.currentTarget, se = de(z);
+      queueMicrotask(() => {
+        const te = C(), Ee = !(Z(b, H) || Z(y, H) || Z(H, y) || Z(E?.portalNode, H) || H != null && H.hasAttribute(Me("focus-guard")) || x && (Le(x.nodesRef.current, te).find((ve) => {
+          var fe, he;
+          return Z((fe = ve.context) == null ? void 0 : fe.elements.floating, H) || Z((he = ve.context) == null ? void 0 : he.elements.domReference, H);
+        }) || Gt(x.nodesRef.current, te).find((ve) => {
+          var fe, he, jt;
+          return [(fe = ve.context) == null ? void 0 : fe.elements.floating, Lt((he = ve.context) == null ? void 0 : he.elements.floating)].includes(H) || ((jt = ve.context) == null ? void 0 : jt.elements.domReference) === H;
+        })));
+        if (ae === b && A && hn(A, W), u && ae !== b && !(se != null && se.isConnected) && be(J(A)) === J(A).body) {
+          X(A) && A.focus();
+          const ve = I.current, fe = ce(), he = fe[ve] || fe[fe.length - 1] || A;
+          X(he) && he.focus();
+        }
+        if (R.current.insideReactTree) {
+          R.current.insideReactTree = !1;
+          return;
+        }
+        (M || !a) && H && Ee && !S.current && // Fix React 18 Strict Mode returnFocus due to double rendering.
+        H !== vn() && (h.current = !0, d(!1, z, "focus-out"));
+      });
+    }
+    const N = !!(!x && E);
+    function U() {
+      ne(Y), R.current.insideReactTree = !0, Y.current = window.setTimeout(() => {
+        R.current.insideReactTree = !1;
+      });
+    }
+    if (y && X(b))
+      return b.addEventListener("focusout", V), b.addEventListener("pointerdown", k), y.addEventListener("focusout", V), N && y.addEventListener("focusout", U, !0), () => {
+        b.removeEventListener("focusout", V), b.removeEventListener("pointerdown", k), y.removeEventListener("focusout", V), N && y.removeEventListener("focusout", U, !0);
+      };
+  }, [r, b, y, A, a, x, E, d, g, u, ce, M, C, W, R]);
+  const ie = f.useRef(null), pe = f.useRef(null), mt = gn([ie, E?.beforeInsideRef]), gt = gn([pe, E?.afterInsideRef]);
+  f.useEffect(() => {
+    var k, V;
+    if (r || !y) return;
+    const N = Array.from((E == null || (k = E.portalNode) == null ? void 0 : k.querySelectorAll("[" + Me("portal") + "]")) || []), z = (V = (x ? Gt(x.nodesRef.current, C()) : []).find((se) => {
+      var te;
+      return zt(((te = se.context) == null ? void 0 : te.elements.domReference) || null);
+    })) == null || (V = V.context) == null ? void 0 : V.elements.domReference, H = [y, z, ...N, ...P(), L.current, T.current, ie.current, pe.current, E?.beforeOutsideRef.current, E?.afterOutsideRef.current, W.current.includes("reference") || M ? b : null].filter((se) => se != null), ae = a || M ? dn(H, !$, $) : dn(H);
+    return () => {
+      ae();
+    };
+  }, [r, b, y, a, W, E, M, j, $, x, C, P]), G(() => {
+    if (r || !X(A)) return;
+    const k = J(A), V = be(k);
+    queueMicrotask(() => {
+      const N = q(A), U = B.current, z = (typeof U == "number" ? N[U] : U.current) || A, H = Z(A, V);
+      !O && !H && p && Pe(z, {
+        preventScroll: z === A
+      });
+    });
+  }, [r, p, A, O, q, B]), G(() => {
+    if (r || !A) return;
+    const k = J(A), V = be(k);
+    ko(V);
+    function N(H) {
+      let {
+        reason: ae,
+        event: se,
+        nested: te
+      } = H;
+      if (["hover", "safe-polygon"].includes(ae) && se.type === "mouseleave" && (h.current = !0), ae === "outside-press")
+        if (te)
+          h.current = !1;
+        else if (Pr(se) || Lr(se))
+          h.current = !1;
+        else {
+          let Ee = !1;
+          document.createElement("div").focus({
+            get preventScroll() {
+              return Ee = !0, !1;
+            }
+          }), Ee ? h.current = !1 : h.current = !0;
+        }
+    }
+    w.on("openchange", N);
+    const U = k.createElement("span");
+    U.setAttribute("tabindex", "-1"), U.setAttribute("aria-hidden", "true"), Object.assign(U.style, Ht), F && b && b.insertAdjacentElement("afterend", U);
+    function z() {
+      if (typeof _.current == "boolean") {
+        const H = b || vn();
+        return H && H.isConnected ? H : U;
+      }
+      return _.current.current || U;
+    }
+    return () => {
+      w.off("openchange", N);
+      const H = be(k), ae = Z(y, H) || x && Le(x.nodesRef.current, C(), !1).some((te) => {
+        var Ee;
+        return Z((Ee = te.context) == null ? void 0 : Ee.elements.floating, H);
+      }), se = z();
+      queueMicrotask(() => {
+        const te = Do(se);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        _.current && !h.current && X(te) && // If the focus moved somewhere else after mount, avoid returning focus
+        // since it likely entered a different element which should be
+        // respected: https://github.com/floating-ui/floating-ui/issues/2607
+        (!(te !== H && H !== k.body) || ae) && te.focus({
+          preventScroll: !0
+        }), U.remove();
+      });
+    };
+  }, [r, y, A, _, R, w, x, F, b, C]), f.useEffect(() => (queueMicrotask(() => {
+    h.current = !1;
+  }), () => {
+    queueMicrotask(Kt);
+  }), [r]), G(() => {
+    if (!r && E)
+      return E.setFocusManagerState({
+        modal: a,
+        closeOnFocusOut: g,
+        open: p,
+        onOpenChange: d,
+        domReference: b
+      }), () => {
+        E.setFocusManagerState(null);
+      };
+  }, [r, E, a, p, d, g, b]), G(() => {
+    r || A && hn(A, W);
+  }, [r, A, W]);
+  function Ke(k) {
+    return r || !m || !a ? null : /* @__PURE__ */ re(Fo, {
+      ref: k === "start" ? L : T,
+      onClick: (V) => d(!1, V.nativeEvent),
+      children: typeof m == "string" ? m : "Dismiss"
+    });
+  }
+  const je = !r && j && (a ? !M : !0) && (F || a);
+  return /* @__PURE__ */ It(Gn, {
+    children: [je && /* @__PURE__ */ re(ot, {
+      "data-type": "inside",
+      ref: mt,
+      onFocus: (k) => {
+        if (a) {
+          const N = q();
+          Pe(o[0] === "reference" ? N[0] : N[N.length - 1]);
+        } else if (E != null && E.preserveTabOrder && E.portalNode)
+          if (h.current = !1, Ne(k, E.portalNode)) {
+            const N = $n(b);
+            N?.focus();
+          } else {
+            var V;
+            (V = E.beforeOutsideRef.current) == null || V.focus();
+          }
+      }
+    }), !M && Ke("start"), n, Ke("end"), je && /* @__PURE__ */ re(ot, {
+      "data-type": "inside",
+      ref: gt,
+      onFocus: (k) => {
+        if (a)
+          Pe(q()[0]);
+        else if (E != null && E.preserveTabOrder && E.portalNode)
+          if (g && (h.current = !0), Ne(k, E.portalNode)) {
+            const N = Bn(b);
+            N?.focus();
+          } else {
+            var V;
+            (V = E.afterOutsideRef.current) == null || V.focus();
+          }
+      }
+    })]
+  });
+}
+let Ye = 0;
+const bn = "--floating-ui-scrollbar-width";
+function No() {
+  const e = $t(), t = /iP(hone|ad|od)|iOS/.test(e) || // iPads can claim to be MacIntel
+  e === "MacIntel" && navigator.maxTouchPoints > 1, n = document.body.style, o = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft ? "paddingLeft" : "paddingRight", i = window.innerWidth - document.documentElement.clientWidth, s = n.left ? parseFloat(n.left) : window.scrollX, c = n.top ? parseFloat(n.top) : window.scrollY;
+  if (n.overflow = "hidden", n.setProperty(bn, i + "px"), i && (n[o] = i + "px"), t) {
+    var u, a;
+    const m = ((u = window.visualViewport) == null ? void 0 : u.offsetLeft) || 0, g = ((a = window.visualViewport) == null ? void 0 : a.offsetTop) || 0;
+    Object.assign(n, {
+      position: "fixed",
+      top: -(c - Math.floor(g)) + "px",
+      left: -(s - Math.floor(m)) + "px",
+      right: "0"
+    });
+  }
+  return () => {
+    Object.assign(n, {
+      overflow: "",
+      [o]: ""
+    }), n.removeProperty(bn), t && (Object.assign(n, {
+      position: "",
+      top: "",
+      left: "",
+      right: ""
+    }), window.scrollTo(s, c));
+  };
+}
+let yn = () => {
+};
+const ti = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const {
+    lockScroll: r = !1,
+    ...o
+  } = t;
+  return G(() => {
+    if (r)
+      return Ye++, Ye === 1 && (yn = No()), () => {
+        Ye--, Ye === 0 && yn();
+      };
+  }, [r]), /* @__PURE__ */ re("div", {
+    ref: n,
+    ...o,
+    style: {
+      position: "fixed",
+      overflow: "auto",
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...o.style
+    }
+  });
+});
+function wn(e) {
+  return X(e.target) && e.target.tagName === "BUTTON";
+}
+function Wo(e) {
+  return X(e.target) && e.target.tagName === "A";
+}
+function Rn(e) {
+  return Bt(e);
+}
+function ni(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    dataRef: o,
+    elements: {
+      domReference: i
+    }
+  } = e, {
+    enabled: s = !0,
+    event: c = "click",
+    toggle: u = !0,
+    ignoreMouse: a = !1,
+    keyboardHandlers: m = !0,
+    stickIfOpen: g = !0
+  } = t, v = f.useRef(), l = f.useRef(!1), p = f.useMemo(() => ({
+    onPointerDown(d) {
+      v.current = d.pointerType;
+    },
+    onMouseDown(d) {
+      const w = v.current;
+      d.button === 0 && c !== "click" && (We(w, !0) && a || (n && u && (!(o.current.openEvent && g) || o.current.openEvent.type === "mousedown") ? r(!1, d.nativeEvent, "click") : (d.preventDefault(), r(!0, d.nativeEvent, "click"))));
+    },
+    onClick(d) {
+      const w = v.current;
+      if (c === "mousedown" && v.current) {
+        v.current = void 0;
+        return;
+      }
+      We(w, !0) && a || (n && u && (!(o.current.openEvent && g) || o.current.openEvent.type === "click") ? r(!1, d.nativeEvent, "click") : r(!0, d.nativeEvent, "click"));
+    },
+    onKeyDown(d) {
+      v.current = void 0, !(d.defaultPrevented || !m || wn(d)) && (d.key === " " && !Rn(i) && (d.preventDefault(), l.current = !0), !Wo(d) && d.key === "Enter" && r(!(n && u), d.nativeEvent, "click"));
+    },
+    onKeyUp(d) {
+      d.defaultPrevented || !m || wn(d) || Rn(i) || d.key === " " && l.current && (l.current = !1, r(!(n && u), d.nativeEvent, "click"));
+    }
+  }), [o, i, c, a, m, r, n, g, u]);
+  return f.useMemo(() => s ? {
+    reference: p
+  } : {}, [s, p]);
+}
+const $o = {
+  pointerdown: "onPointerDown",
+  mousedown: "onMouseDown",
+  click: "onClick"
+}, Bo = {
+  pointerdown: "onPointerDownCapture",
+  mousedown: "onMouseDownCapture",
+  click: "onClickCapture"
+}, xn = (e) => {
+  var t, n;
+  return {
+    escapeKey: typeof e == "boolean" ? e : (t = e?.escapeKey) != null ? t : !1,
+    outsidePress: typeof e == "boolean" ? e : (n = e?.outsidePress) != null ? n : !0
+  };
+};
+function ri(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    elements: o,
+    dataRef: i
+  } = e, {
+    enabled: s = !0,
+    escapeKey: c = !0,
+    outsidePress: u = !0,
+    outsidePressEvent: a = "pointerdown",
+    referencePress: m = !1,
+    referencePressEvent: g = "pointerdown",
+    ancestorScroll: v = !1,
+    bubbles: l,
+    capture: p
+  } = t, d = dt(), w = Q(typeof u == "function" ? u : () => !1), R = typeof u == "function" ? w : u, b = f.useRef(!1), {
+    escapeKey: y,
+    outsidePress: C
+  } = xn(l), {
+    escapeKey: P,
+    outsidePress: O
+  } = xn(p), M = f.useRef(!1), D = Q((x) => {
+    var E;
+    if (!n || !s || !c || x.key !== "Escape" || M.current)
+      return;
+    const L = (E = i.current.floatingContext) == null ? void 0 : E.nodeId, T = d ? Le(d.nodesRef.current, L) : [];
+    if (!y && (x.stopPropagation(), T.length > 0)) {
+      let h = !0;
+      if (T.forEach((S) => {
+        var I;
+        if ((I = S.context) != null && I.open && !S.context.dataRef.current.__escapeKeyBubbles) {
+          h = !1;
+          return;
+        }
+      }), !h)
+        return;
+    }
+    r(!1, Mr(x) ? x.nativeEvent : x, "escape-key");
+  }), j = Q((x) => {
+    var E;
+    const L = () => {
+      var T;
+      D(x), (T = de(x)) == null || T.removeEventListener("keydown", L);
+    };
+    (E = de(x)) == null || E.addEventListener("keydown", L);
+  }), $ = Q((x) => {
+    var E;
+    const L = i.current.insideReactTree;
+    i.current.insideReactTree = !1;
+    const T = b.current;
+    if (b.current = !1, a === "click" && T || L || typeof R == "function" && !R(x))
+      return;
+    const h = de(x), S = "[" + Me("inert") + "]", I = J(o.floating).querySelectorAll(S);
+    let Y = K(h) ? h : null;
+    for (; Y && !me(Y); ) {
+      const q = ge(Y);
+      if (me(q) || !K(q))
+        break;
+      Y = q;
+    }
+    if (I.length && K(h) && !Ar(h) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !Z(h, o.floating) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(I).every((q) => !Z(Y, q)))
+      return;
+    if (X(h) && _) {
+      const q = me(h), ie = oe(h), pe = /auto|scroll/, mt = q || pe.test(ie.overflowX), gt = q || pe.test(ie.overflowY), Ke = mt && h.clientWidth > 0 && h.scrollWidth > h.clientWidth, je = gt && h.clientHeight > 0 && h.scrollHeight > h.clientHeight, k = ie.direction === "rtl", V = je && (k ? x.offsetX <= h.offsetWidth - h.clientWidth : x.offsetX > h.clientWidth), N = Ke && x.offsetY > h.clientHeight;
+      if (V || N)
+        return;
+    }
+    const F = (E = i.current.floatingContext) == null ? void 0 : E.nodeId, A = d && Le(d.nodesRef.current, F).some((q) => {
+      var ie;
+      return vt(x, (ie = q.context) == null ? void 0 : ie.elements.floating);
+    });
+    if (vt(x, o.floating) || vt(x, o.domReference) || A)
+      return;
+    const ce = d ? Le(d.nodesRef.current, F) : [];
+    if (ce.length > 0) {
+      let q = !0;
+      if (ce.forEach((ie) => {
+        var pe;
+        if ((pe = ie.context) != null && pe.open && !ie.context.dataRef.current.__outsidePressBubbles) {
+          q = !1;
+          return;
+        }
+      }), !q)
+        return;
+    }
+    r(!1, x, "outside-press");
+  }), W = Q((x) => {
+    var E;
+    const L = () => {
+      var T;
+      $(x), (T = de(x)) == null || T.removeEventListener(a, L);
+    };
+    (E = de(x)) == null || E.addEventListener(a, L);
+  });
+  f.useEffect(() => {
+    if (!n || !s)
+      return;
+    i.current.__escapeKeyBubbles = y, i.current.__outsidePressBubbles = C;
+    let x = -1;
+    function E(I) {
+      r(!1, I, "ancestor-scroll");
+    }
+    function L() {
+      window.clearTimeout(x), M.current = !0;
+    }
+    function T() {
+      x = window.setTimeout(
+        () => {
+          M.current = !1;
+        },
+        // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
+        // Only apply to WebKit for the test to remain 0ms.
+        ct() ? 5 : 0
+      );
+    }
+    const h = J(o.floating);
+    c && (h.addEventListener("keydown", P ? j : D, P), h.addEventListener("compositionstart", L), h.addEventListener("compositionend", T)), R && h.addEventListener(a, O ? W : $, O);
+    let S = [];
+    return v && (K(o.domReference) && (S = Re(o.domReference)), K(o.floating) && (S = S.concat(Re(o.floating))), !K(o.reference) && o.reference && o.reference.contextElement && (S = S.concat(Re(o.reference.contextElement)))), S = S.filter((I) => {
+      var Y;
+      return I !== ((Y = h.defaultView) == null ? void 0 : Y.visualViewport);
+    }), S.forEach((I) => {
+      I.addEventListener("scroll", E, {
+        passive: !0
+      });
+    }), () => {
+      c && (h.removeEventListener("keydown", P ? j : D, P), h.removeEventListener("compositionstart", L), h.removeEventListener("compositionend", T)), R && h.removeEventListener(a, O ? W : $, O), S.forEach((I) => {
+        I.removeEventListener("scroll", E);
+      }), window.clearTimeout(x);
+    };
+  }, [i, o, c, R, a, n, r, v, s, y, C, D, P, j, $, O, W]), f.useEffect(() => {
+    i.current.insideReactTree = !1;
+  }, [i, R, a]);
+  const B = f.useMemo(() => ({
+    onKeyDown: D,
+    ...m && {
+      [$o[g]]: (x) => {
+        r(!1, x.nativeEvent, "reference-press");
+      },
+      ...g !== "click" && {
+        onClick(x) {
+          r(!1, x.nativeEvent, "reference-press");
+        }
+      }
+    }
+  }), [D, r, m, g]), _ = f.useMemo(() => {
+    function x(E) {
+      E.button === 0 && (b.current = !0);
+    }
+    return {
+      onKeyDown: D,
+      onMouseDown: x,
+      onMouseUp: x,
+      [Bo[a]]: () => {
+        i.current.insideReactTree = !0;
+      }
+    };
+  }, [D, a, i]);
+  return f.useMemo(() => s ? {
+    reference: B,
+    floating: _
+  } : {}, [s, B, _]);
+}
+function _o(e) {
+  const {
+    open: t = !1,
+    onOpenChange: n,
+    elements: r
+  } = e, o = ft(), i = f.useRef({}), [s] = f.useState(() => To()), c = Vt() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const l = r.reference;
+    l && !K(l) && Eo("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [u, a] = f.useState(r.reference), m = Q((l, p, d) => {
+    i.current.openEvent = l ? p : void 0, s.emit("openchange", {
+      open: l,
+      event: p,
+      reason: d,
+      nested: c
+    }), n?.(l, p, d);
+  }), g = f.useMemo(() => ({
+    setPositionReference: a
+  }), []), v = f.useMemo(() => ({
+    reference: u || r.reference || null,
+    floating: r.floating || null,
+    domReference: r.reference
+  }), [u, r.reference, r.floating]);
+  return f.useMemo(() => ({
+    dataRef: i,
+    open: t,
+    onOpenChange: m,
+    elements: v,
+    events: s,
+    floatingId: o,
+    refs: g
+  }), [t, m, v, s, o, g]);
+}
+function oi(e) {
+  e === void 0 && (e = {});
+  const {
+    nodeId: t
+  } = e, n = _o({
+    ...e,
+    elements: {
+      reference: null,
+      floating: null,
+      ...e.elements
+    }
+  }), r = e.rootContext || n, o = r.elements, [i, s] = f.useState(null), [c, u] = f.useState(null), m = o?.domReference || i, g = f.useRef(null), v = dt();
+  G(() => {
+    m && (g.current = m);
+  }, [m]);
+  const l = po({
+    ...e,
+    elements: {
+      ...o,
+      ...c && {
+        reference: c
+      }
+    }
+  }), p = f.useCallback((y) => {
+    const C = K(y) ? {
+      getBoundingClientRect: () => y.getBoundingClientRect(),
+      getClientRects: () => y.getClientRects(),
+      contextElement: y
+    } : y;
+    u(C), l.refs.setReference(C);
+  }, [l.refs]), d = f.useCallback((y) => {
+    (K(y) || y === null) && (g.current = y, s(y)), (K(l.refs.reference.current) || l.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    y !== null && !K(y)) && l.refs.setReference(y);
+  }, [l.refs]), w = f.useMemo(() => ({
+    ...l.refs,
+    setReference: d,
+    setPositionReference: p,
+    domReference: g
+  }), [l.refs, d, p]), R = f.useMemo(() => ({
+    ...l.elements,
+    domReference: m
+  }), [l.elements, m]), b = f.useMemo(() => ({
+    ...l,
+    ...r,
+    refs: w,
+    elements: R,
+    nodeId: t
+  }), [l, w, R, t, r]);
+  return G(() => {
+    r.dataRef.current.floatingContext = b;
+    const y = v?.nodesRef.current.find((C) => C.id === t);
+    y && (y.context = b);
+  }), f.useMemo(() => ({
+    ...l,
+    context: b,
+    refs: w,
+    elements: R
+  }), [l, w, R, b]);
+}
+function Et() {
+  return Cr() && Fn();
+}
+function ii(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    events: o,
+    dataRef: i,
+    elements: s
+  } = e, {
+    enabled: c = !0,
+    visibleOnly: u = !0
+  } = t, a = f.useRef(!1), m = f.useRef(-1), g = f.useRef(!0);
+  f.useEffect(() => {
+    if (!c) return;
+    const l = ee(s.domReference);
+    function p() {
+      !n && X(s.domReference) && s.domReference === be(J(s.domReference)) && (a.current = !0);
+    }
+    function d() {
+      g.current = !0;
+    }
+    function w() {
+      g.current = !1;
+    }
+    return l.addEventListener("blur", p), Et() && (l.addEventListener("keydown", d, !0), l.addEventListener("pointerdown", w, !0)), () => {
+      l.removeEventListener("blur", p), Et() && (l.removeEventListener("keydown", d, !0), l.removeEventListener("pointerdown", w, !0));
+    };
+  }, [s.domReference, n, c]), f.useEffect(() => {
+    if (!c) return;
+    function l(p) {
+      let {
+        reason: d
+      } = p;
+      (d === "reference-press" || d === "escape-key") && (a.current = !0);
+    }
+    return o.on("openchange", l), () => {
+      o.off("openchange", l);
+    };
+  }, [o, c]), f.useEffect(() => () => {
+    ne(m);
+  }, []);
+  const v = f.useMemo(() => ({
+    onMouseLeave() {
+      a.current = !1;
+    },
+    onFocus(l) {
+      if (a.current) return;
+      const p = de(l.nativeEvent);
+      if (u && K(p)) {
+        if (Et() && !l.relatedTarget) {
+          if (!g.current && !Bt(p))
+            return;
+        } else if (!Or(p))
+          return;
+      }
+      r(!0, l.nativeEvent, "focus");
+    },
+    onBlur(l) {
+      a.current = !1;
+      const p = l.relatedTarget, d = l.nativeEvent, w = K(p) && p.hasAttribute(Me("focus-guard")) && p.getAttribute("data-type") === "outside";
+      m.current = window.setTimeout(() => {
+        var R;
+        const b = be(s.domReference ? s.domReference.ownerDocument : document);
+        !p && b === s.domReference || Z((R = i.current.floatingContext) == null ? void 0 : R.refs.floating.current, b) || Z(s.domReference, b) || w || r(!1, d, "focus");
+      });
+    }
+  }), [i, s.domReference, r, u]);
+  return f.useMemo(() => c ? {
+    reference: v
+  } : {}, [c, v]);
+}
+function Tt(e, t, n) {
+  const r = /* @__PURE__ */ new Map(), o = n === "item";
+  let i = e;
+  if (o && e) {
+    const {
+      [on]: s,
+      [sn]: c,
+      ...u
+    } = e;
+    i = u;
+  }
+  return {
+    ...n === "floating" && {
+      tabIndex: -1,
+      [ho]: ""
+    },
+    ...i,
+    ...t.map((s) => {
+      const c = s ? s[n] : null;
+      return typeof c == "function" ? e ? c(e) : null : c;
+    }).concat(e).reduce((s, c) => (c && Object.entries(c).forEach((u) => {
+      let [a, m] = u;
+      if (!(o && [on, sn].includes(a)))
+        if (a.indexOf("on") === 0) {
+          if (r.has(a) || r.set(a, []), typeof m == "function") {
+            var g;
+            (g = r.get(a)) == null || g.push(m), s[a] = function() {
+              for (var v, l = arguments.length, p = new Array(l), d = 0; d < l; d++)
+                p[d] = arguments[d];
+              return (v = r.get(a)) == null ? void 0 : v.map((w) => w(...p)).find((w) => w !== void 0);
+            };
+          }
+        } else
+          s[a] = m;
+    }), s), {})
+  };
+}
+function si(e) {
+  e === void 0 && (e = []);
+  const t = e.map((c) => c?.reference), n = e.map((c) => c?.floating), r = e.map((c) => c?.item), o = f.useCallback(
+    (c) => Tt(c, e, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), i = f.useCallback(
+    (c) => Tt(c, e, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    n
+  ), s = f.useCallback(
+    (c) => Tt(c, e, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    r
+  );
+  return f.useMemo(() => ({
+    getReferenceProps: o,
+    getFloatingProps: i,
+    getItemProps: s
+  }), [o, i, s]);
+}
+const Vo = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", !1]]);
+function ci(e, t) {
+  var n, r;
+  t === void 0 && (t = {});
+  const {
+    open: o,
+    elements: i,
+    floatingId: s
+  } = e, {
+    enabled: c = !0,
+    role: u = "dialog"
+  } = t, a = ft(), m = ((n = i.domReference) == null ? void 0 : n.id) || a, g = f.useMemo(() => {
+    var b;
+    return ((b = Lt(i.floating)) == null ? void 0 : b.id) || s;
+  }, [i.floating, s]), v = (r = Vo.get(u)) != null ? r : u, p = Vt() != null, d = f.useMemo(() => v === "tooltip" || u === "label" ? {
+    ["aria-" + (u === "label" ? "labelledby" : "describedby")]: o ? g : void 0
+  } : {
+    "aria-expanded": o ? "true" : "false",
+    "aria-haspopup": v === "alertdialog" ? "dialog" : v,
+    "aria-controls": o ? g : void 0,
+    ...v === "listbox" && {
+      role: "combobox"
+    },
+    ...v === "menu" && {
+      id: m
+    },
+    ...v === "menu" && p && {
+      role: "menuitem"
+    },
+    ...u === "select" && {
+      "aria-autocomplete": "none"
+    },
+    ...u === "combobox" && {
+      "aria-autocomplete": "list"
+    }
+  }, [v, g, p, o, m, u]), w = f.useMemo(() => {
+    const b = {
+      id: g,
+      ...v && {
+        role: v
+      }
+    };
+    return v === "tooltip" || u === "label" ? b : {
+      ...b,
+      ...v === "menu" && {
+        "aria-labelledby": m
+      }
+    };
+  }, [v, g, m, u]), R = f.useCallback((b) => {
+    let {
+      active: y,
+      selected: C
+    } = b;
+    const P = {
+      role: "option",
+      ...y && {
+        id: g + "-fui-option"
+      }
+    };
+    switch (u) {
+      case "select":
+      case "combobox":
+        return {
+          ...P,
+          "aria-selected": C
+        };
+    }
+    return {};
+  }, [g, u]);
+  return f.useMemo(() => c ? {
+    reference: d,
+    floating: w,
+    item: R
+  } : {}, [c, d, w, R]);
+}
+function Ho(e, t) {
+  const [n, r] = f.useState(e);
+  return e && !n && r(!0), f.useEffect(() => {
+    if (!e && n) {
+      const o = setTimeout(() => r(!1), t);
+      return () => clearTimeout(o);
+    }
+  }, [e, n, t]), n;
+}
+function ui(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    elements: {
+      floating: r
+    }
+  } = e, {
+    duration: o = 250
+  } = t, s = (typeof o == "number" ? o : o.close) || 0, [c, u] = f.useState("unmounted"), a = Ho(n, s);
+  return !a && c === "close" && u("unmounted"), G(() => {
+    if (r) {
+      if (n) {
+        u("initial");
+        const m = requestAnimationFrame(() => {
+          kt.flushSync(() => {
+            u("open");
+          });
+        });
+        return () => {
+          cancelAnimationFrame(m);
+        };
+      }
+      u("close");
+    }
+  }, [n, r]), {
+    isMounted: a,
+    status: c
+  };
+}
+export {
+  ei as F,
+  qo as a,
+  ni as b,
+  ri as c,
+  ci as d,
+  si as e,
+  Go as f,
+  ui as g,
+  ti as h,
+  Qo as i,
+  Yo as j,
+  zo as k,
+  Zo as l,
+  Jo as m,
+  ii as n,
+  Uo as o,
+  Xo as s,
+  oi as u
+};