@krosoft/react 0.0.69 → 0.0.70

package/dist/Topbar-CtXJ337W.js

@@ -0,0 +1,2314 @@
+import { jsx as y, jsxs as $, Fragment as nt } from "react/jsx-runtime";
+import * as h from "react";
+import { useLayoutEffect as un } from "react";
+import { d as dn, u as ne, e as pn, f as X, g as He, h as ie, a as gt, j as hn, i as mn, B as gn } from "./index-BNCR478R.js";
+import * as vt from "react-dom";
+import { c as G } from "./index-gWiv5-6R.js";
+import { c as xt } from "./createLucideIcon-CRdjzt2A.js";
+/**
+ * @license lucide-react v1.16.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const vn = [["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]], xn = xt("chevron-down", vn);
+/**
+ * @license lucide-react v1.16.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const wn = [
+  ["path", { d: "M4 5h16", key: "1tepv9" }],
+  ["path", { d: "M4 12h16", key: "1lakjw" }],
+  ["path", { d: "M4 19h16", key: "1djgab" }]
+], yn = xt("menu", wn);
+var bn = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+], re = bn.reduce((e, t) => {
+  const n = dn(`Primitive.${t}`), r = h.forwardRef((o, i) => {
+    const { asChild: s, ...a } = o, c = s ? n : t;
+    return typeof window < "u" && (window[Symbol.for("radix-ui")] = !0), /* @__PURE__ */ y(c, { ...a, ref: i });
+  });
+  return r.displayName = `Primitive.${t}`, { ...e, [t]: r };
+}, {});
+function Cn(e, t) {
+  e && vt.flushSync(() => e.dispatchEvent(t));
+}
+var An = "DismissableLayer", Me = "dismissableLayer.update", Rn = "dismissableLayer.pointerDownOutside", En = "dismissableLayer.focusOutside", rt, wt = h.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), yt = h.forwardRef(
+  (e, t) => {
+    const {
+      disableOutsidePointerEvents: n = !1,
+      onEscapeKeyDown: r,
+      onPointerDownOutside: o,
+      onFocusOutside: i,
+      onInteractOutside: s,
+      onDismiss: a,
+      ...c
+    } = e, l = h.useContext(wt), [f, d] = h.useState(null), p = (f == null ? void 0 : f.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document), [, u] = h.useState({}), g = ne(t, (A) => d(A)), m = Array.from(l.layers), [v] = [...l.layersWithOutsidePointerEventsDisabled].slice(-1), x = m.indexOf(v), w = f ? m.indexOf(f) : -1, C = l.layersWithOutsidePointerEventsDisabled.size > 0, b = w >= x, E = Tn((A) => {
+      const P = A.target, M = [...l.branches].some((T) => T.contains(P));
+      !b || M || (o == null || o(A), s == null || s(A), A.defaultPrevented || a == null || a());
+    }, p), R = Sn((A) => {
+      const P = A.target;
+      [...l.branches].some((T) => T.contains(P)) || (i == null || i(A), s == null || s(A), A.defaultPrevented || a == null || a());
+    }, p);
+    return pn((A) => {
+      w === l.layers.size - 1 && (r == null || r(A), !A.defaultPrevented && a && (A.preventDefault(), a()));
+    }, p), h.useEffect(() => {
+      if (f)
+        return n && (l.layersWithOutsidePointerEventsDisabled.size === 0 && (rt = p.body.style.pointerEvents, p.body.style.pointerEvents = "none"), l.layersWithOutsidePointerEventsDisabled.add(f)), l.layers.add(f), ot(), () => {
+          n && l.layersWithOutsidePointerEventsDisabled.size === 1 && (p.body.style.pointerEvents = rt);
+        };
+    }, [f, p, n, l]), h.useEffect(() => () => {
+      f && (l.layers.delete(f), l.layersWithOutsidePointerEventsDisabled.delete(f), ot());
+    }, [f, l]), h.useEffect(() => {
+      const A = () => u({});
+      return document.addEventListener(Me, A), () => document.removeEventListener(Me, A);
+    }, []), /* @__PURE__ */ y(
+      re.div,
+      {
+        ...c,
+        ref: g,
+        style: {
+          pointerEvents: C ? b ? "auto" : "none" : void 0,
+          ...e.style
+        },
+        onFocusCapture: X(e.onFocusCapture, R.onFocusCapture),
+        onBlurCapture: X(e.onBlurCapture, R.onBlurCapture),
+        onPointerDownCapture: X(
+          e.onPointerDownCapture,
+          E.onPointerDownCapture
+        )
+      }
+    );
+  }
+);
+yt.displayName = An;
+var On = "DismissableLayerBranch", Pn = h.forwardRef((e, t) => {
+  const n = h.useContext(wt), r = h.useRef(null), o = ne(t, r);
+  return h.useEffect(() => {
+    const i = r.current;
+    if (i)
+      return n.branches.add(i), () => {
+        n.branches.delete(i);
+      };
+  }, [n.branches]), /* @__PURE__ */ y(re.div, { ...e, ref: o });
+});
+Pn.displayName = On;
+function Tn(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = He(e), r = h.useRef(!1), o = h.useRef(() => {
+  });
+  return h.useEffect(() => {
+    const i = (a) => {
+      if (a.target && !r.current) {
+        let c = function() {
+          bt(
+            Rn,
+            n,
+            l,
+            { discrete: !0 }
+          );
+        };
+        const l = { originalEvent: a };
+        a.pointerType === "touch" ? (t.removeEventListener("click", o.current), o.current = c, t.addEventListener("click", o.current, { once: !0 })) : c();
+      } else
+        t.removeEventListener("click", o.current);
+      r.current = !1;
+    }, s = window.setTimeout(() => {
+      t.addEventListener("pointerdown", i);
+    }, 0);
+    return () => {
+      window.clearTimeout(s), t.removeEventListener("pointerdown", i), t.removeEventListener("click", o.current);
+    };
+  }, [t, n]), {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => r.current = !0
+  };
+}
+function Sn(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = He(e), r = h.useRef(!1);
+  return h.useEffect(() => {
+    const o = (i) => {
+      i.target && !r.current && bt(En, n, { originalEvent: i }, {
+        discrete: !1
+      });
+    };
+    return t.addEventListener("focusin", o), () => t.removeEventListener("focusin", o);
+  }, [t, n]), {
+    onFocusCapture: () => r.current = !0,
+    onBlurCapture: () => r.current = !1
+  };
+}
+function ot() {
+  const e = new CustomEvent(Me);
+  document.dispatchEvent(e);
+}
+function bt(e, t, n, { discrete: r }) {
+  const o = n.originalEvent.target, i = new CustomEvent(e, { bubbles: !1, cancelable: !0, detail: n });
+  t && o.addEventListener(e, t, { once: !0 }), r ? Cn(o, i) : o.dispatchEvent(i);
+}
+var Nn = h[" useId ".trim().toString()] || (() => {
+}), Dn = 0;
+function Ln(e) {
+  const [t, n] = h.useState(Nn());
+  return ie(() => {
+    n((r) => r ?? String(Dn++));
+  }, [e]), t ? `radix-${t}` : "";
+}
+const Mn = ["top", "right", "bottom", "left"], J = Math.min, H = Math.max, we = Math.round, ge = Math.floor, U = (e) => ({
+  x: e,
+  y: e
+}), kn = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function ke(e, t, n) {
+  return H(e, J(t, n));
+}
+function q(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function K(e) {
+  return e.split("-")[0];
+}
+function ae(e) {
+  return e.split("-")[1];
+}
+function Be(e) {
+  return e === "x" ? "y" : "x";
+}
+function ze(e) {
+  return e === "y" ? "height" : "width";
+}
+function V(e) {
+  const t = e[0];
+  return t === "t" || t === "b" ? "y" : "x";
+}
+function Ie(e) {
+  return Be(V(e));
+}
+function _n(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = ae(e), o = Ie(e), i = ze(o);
+  let s = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = ye(s)), [s, ye(s)];
+}
+function Wn(e) {
+  const t = ye(e);
+  return [_e(e), t, _e(t)];
+}
+function _e(e) {
+  return e.includes("start") ? e.replace("start", "end") : e.replace("end", "start");
+}
+const it = ["left", "right"], st = ["right", "left"], $n = ["top", "bottom"], Fn = ["bottom", "top"];
+function Hn(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? st : it : t ? it : st;
+    case "left":
+    case "right":
+      return t ? $n : Fn;
+    default:
+      return [];
+  }
+}
+function Bn(e, t, n, r) {
+  const o = ae(e);
+  let i = Hn(K(e), n === "start", r);
+  return o && (i = i.map((s) => s + "-" + o), t && (i = i.concat(i.map(_e)))), i;
+}
+function ye(e) {
+  const t = K(e);
+  return kn[t] + e.slice(t.length);
+}
+function zn(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Ct(e) {
+  return typeof e != "number" ? zn(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function be(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
+  };
+}
+function ct(e, t, n) {
+  let {
+    reference: r,
+    floating: o
+  } = e;
+  const i = V(t), s = Ie(t), a = ze(s), c = K(t), l = i === "y", f = r.x + r.width / 2 - o.width / 2, d = r.y + r.height / 2 - o.height / 2, p = r[a] / 2 - o[a] / 2;
+  let u;
+  switch (c) {
+    case "top":
+      u = {
+        x: f,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      u = {
+        x: f,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      u = {
+        x: r.x + r.width,
+        y: d
+      };
+      break;
+    case "left":
+      u = {
+        x: r.x - o.width,
+        y: d
+      };
+      break;
+    default:
+      u = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (ae(t)) {
+    case "start":
+      u[s] -= p * (n && l ? -1 : 1);
+      break;
+    case "end":
+      u[s] += p * (n && l ? -1 : 1);
+      break;
+  }
+  return u;
+}
+async function In(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: r,
+    y: o,
+    platform: i,
+    rects: s,
+    elements: a,
+    strategy: c
+  } = e, {
+    boundary: l = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: d = "floating",
+    altBoundary: p = !1,
+    padding: u = 0
+  } = q(t, e), g = Ct(u), v = a[p ? d === "floating" ? "reference" : "floating" : d], x = be(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(v))) == null || n ? v : v.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(a.floating)),
+    boundary: l,
+    rootBoundary: f,
+    strategy: c
+  })), w = d === "floating" ? {
+    x: r,
+    y: o,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, C = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(a.floating)), b = await (i.isElement == null ? void 0 : i.isElement(C)) ? await (i.getScale == null ? void 0 : i.getScale(C)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, E = be(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: w,
+    offsetParent: C,
+    strategy: c
+  }) : w);
+  return {
+    top: (x.top - E.top + g.top) / b.y,
+    bottom: (E.bottom - x.bottom + g.bottom) / b.y,
+    left: (x.left - E.left + g.left) / b.x,
+    right: (E.right - x.right + g.right) / b.x
+  };
+}
+const jn = 50, Vn = async (e, t, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: i = [],
+    platform: s
+  } = n, a = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: In
+  }, c = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let l = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: f,
+    y: d
+  } = ct(l, r, c), p = r, u = 0;
+  const g = {};
+  for (let m = 0; m < i.length; m++) {
+    const v = i[m];
+    if (!v)
+      continue;
+    const {
+      name: x,
+      fn: w
+    } = v, {
+      x: C,
+      y: b,
+      data: E,
+      reset: R
+    } = await w({
+      x: f,
+      y: d,
+      initialPlacement: r,
+      placement: p,
+      strategy: o,
+      middlewareData: g,
+      rects: l,
+      platform: a,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    f = C ?? f, d = b ?? d, g[x] = {
+      ...g[x],
+      ...E
+    }, R && u < jn && (u++, typeof R == "object" && (R.placement && (p = R.placement), R.rects && (l = R.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : R.rects), {
+      x: f,
+      y: d
+    } = ct(l, p, c)), m = -1);
+  }
+  return {
+    x: f,
+    y: d,
+    placement: p,
+    strategy: o,
+    middlewareData: g
+  };
+}, Un = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: r,
+      placement: o,
+      rects: i,
+      platform: s,
+      elements: a,
+      middlewareData: c
+    } = t, {
+      element: l,
+      padding: f = 0
+    } = q(e, t) || {};
+    if (l == null)
+      return {};
+    const d = Ct(f), p = {
+      x: n,
+      y: r
+    }, u = Ie(o), g = ze(u), m = await s.getDimensions(l), v = u === "y", x = v ? "top" : "left", w = v ? "bottom" : "right", C = v ? "clientHeight" : "clientWidth", b = i.reference[g] + i.reference[u] - p[u] - i.floating[g], E = p[u] - i.reference[u], R = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(l));
+    let A = R ? R[C] : 0;
+    (!A || !await (s.isElement == null ? void 0 : s.isElement(R))) && (A = a.floating[C] || i.floating[g]);
+    const P = b / 2 - E / 2, M = A / 2 - m[g] / 2 - 1, T = J(d[x], M), _ = J(d[w], M), W = T, N = A - m[g] - _, S = A / 2 - m[g] / 2 + P, F = ke(W, S, N), D = !c.arrow && ae(o) != null && S !== F && i.reference[g] / 2 - (S < W ? T : _) - m[g] / 2 < 0, L = D ? S < W ? S - W : S - N : 0;
+    return {
+      [u]: p[u] + L,
+      data: {
+        [u]: F,
+        centerOffset: S - F - L,
+        ...D && {
+          alignmentOffset: L
+        }
+      },
+      reset: D
+    };
+  }
+}), Yn = 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: a,
+        platform: c,
+        elements: l
+      } = t, {
+        mainAxis: f = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: p,
+        fallbackStrategy: u = "bestFit",
+        fallbackAxisSideDirection: g = "none",
+        flipAlignment: m = !0,
+        ...v
+      } = q(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const x = K(o), w = V(a), C = K(a) === a, b = await (c.isRTL == null ? void 0 : c.isRTL(l.floating)), E = p || (C || !m ? [ye(a)] : Wn(a)), R = g !== "none";
+      !p && R && E.push(...Bn(a, m, g, b));
+      const A = [a, ...E], P = await c.detectOverflow(t, v), M = [];
+      let T = ((r = i.flip) == null ? void 0 : r.overflows) || [];
+      if (f && M.push(P[x]), d) {
+        const S = _n(o, s, b);
+        M.push(P[S[0]], P[S[1]]);
+      }
+      if (T = [...T, {
+        placement: o,
+        overflows: M
+      }], !M.every((S) => S <= 0)) {
+        var _, W;
+        const S = (((_ = i.flip) == null ? void 0 : _.index) || 0) + 1, F = A[S];
+        if (F && (!(d === "alignment" ? w !== V(F) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        T.every((O) => V(O.placement) === w ? O.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: S,
+              overflows: T
+            },
+            reset: {
+              placement: F
+            }
+          };
+        let D = (W = T.filter((L) => L.overflows[0] <= 0).sort((L, O) => L.overflows[1] - O.overflows[1])[0]) == null ? void 0 : W.placement;
+        if (!D)
+          switch (u) {
+            case "bestFit": {
+              var N;
+              const L = (N = T.filter((O) => {
+                if (R) {
+                  const k = V(O.placement);
+                  return k === w || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  k === "y";
+                }
+                return !0;
+              }).map((O) => [O.placement, O.overflows.filter((k) => k > 0).reduce((k, j) => k + j, 0)]).sort((O, k) => O[1] - k[1])[0]) == null ? void 0 : N[0];
+              L && (D = L);
+              break;
+            }
+            case "initialPlacement":
+              D = a;
+              break;
+          }
+        if (o !== D)
+          return {
+            reset: {
+              placement: D
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function at(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function lt(e) {
+  return Mn.some((t) => e[t] >= 0);
+}
+const Xn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: n,
+        platform: r
+      } = t, {
+        strategy: o = "referenceHidden",
+        ...i
+      } = q(e, t);
+      switch (o) {
+        case "referenceHidden": {
+          const s = await r.detectOverflow(t, {
+            ...i,
+            elementContext: "reference"
+          }), a = at(s, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: a,
+              referenceHidden: lt(a)
+            }
+          };
+        }
+        case "escaped": {
+          const s = await r.detectOverflow(t, {
+            ...i,
+            altBoundary: !0
+          }), a = at(s, n.floating);
+          return {
+            data: {
+              escapedOffsets: a,
+              escaped: lt(a)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, At = /* @__PURE__ */ new Set(["left", "top"]);
+async function Gn(e, t) {
+  const {
+    placement: n,
+    platform: r,
+    elements: o
+  } = e, i = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), s = K(n), a = ae(n), c = V(n) === "y", l = At.has(s) ? -1 : 1, f = i && c ? -1 : 1, d = q(t, e);
+  let {
+    mainAxis: p,
+    crossAxis: u,
+    alignmentAxis: g
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: d.mainAxis || 0,
+    crossAxis: d.crossAxis || 0,
+    alignmentAxis: d.alignmentAxis
+  };
+  return a && typeof g == "number" && (u = a === "end" ? g * -1 : g), c ? {
+    x: u * f,
+    y: p * l
+  } : {
+    x: p * l,
+    y: u * f
+  };
+}
+const qn = 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: a
+      } = t, c = await Gn(t, e);
+      return s === ((n = a.offset) == null ? void 0 : n.placement) && (r = a.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + c.x,
+        y: i + c.y,
+        data: {
+          ...c,
+          placement: s
+        }
+      };
+    }
+  };
+}, Kn = 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: a = !1,
+        limiter: c = {
+          fn: (x) => {
+            let {
+              x: w,
+              y: C
+            } = x;
+            return {
+              x: w,
+              y: C
+            };
+          }
+        },
+        ...l
+      } = q(e, t), f = {
+        x: n,
+        y: r
+      }, d = await i.detectOverflow(t, l), p = V(K(o)), u = Be(p);
+      let g = f[u], m = f[p];
+      if (s) {
+        const x = u === "y" ? "top" : "left", w = u === "y" ? "bottom" : "right", C = g + d[x], b = g - d[w];
+        g = ke(C, g, b);
+      }
+      if (a) {
+        const x = p === "y" ? "top" : "left", w = p === "y" ? "bottom" : "right", C = m + d[x], b = m - d[w];
+        m = ke(C, m, b);
+      }
+      const v = c.fn({
+        ...t,
+        [u]: g,
+        [p]: m
+      });
+      return {
+        ...v,
+        data: {
+          x: v.x - n,
+          y: v.y - r,
+          enabled: {
+            [u]: s,
+            [p]: a
+          }
+        }
+      };
+    }
+  };
+}, Zn = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const {
+        x: n,
+        y: r,
+        placement: o,
+        rects: i,
+        middlewareData: s
+      } = t, {
+        offset: a = 0,
+        mainAxis: c = !0,
+        crossAxis: l = !0
+      } = q(e, t), f = {
+        x: n,
+        y: r
+      }, d = V(o), p = Be(d);
+      let u = f[p], g = f[d];
+      const m = q(a, t), v = typeof m == "number" ? {
+        mainAxis: m,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...m
+      };
+      if (c) {
+        const C = p === "y" ? "height" : "width", b = i.reference[p] - i.floating[C] + v.mainAxis, E = i.reference[p] + i.reference[C] - v.mainAxis;
+        u < b ? u = b : u > E && (u = E);
+      }
+      if (l) {
+        var x, w;
+        const C = p === "y" ? "width" : "height", b = At.has(K(o)), E = i.reference[d] - i.floating[C] + (b && ((x = s.offset) == null ? void 0 : x[d]) || 0) + (b ? 0 : v.crossAxis), R = i.reference[d] + i.reference[C] + (b ? 0 : ((w = s.offset) == null ? void 0 : w[d]) || 0) - (b ? v.crossAxis : 0);
+        g < E ? g = E : g > R && (g = R);
+      }
+      return {
+        [p]: u,
+        [d]: g
+      };
+    }
+  };
+}, Jn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        rects: i,
+        platform: s,
+        elements: a
+      } = t, {
+        apply: c = () => {
+        },
+        ...l
+      } = q(e, t), f = await s.detectOverflow(t, l), d = K(o), p = ae(o), u = V(o) === "y", {
+        width: g,
+        height: m
+      } = i.floating;
+      let v, x;
+      d === "top" || d === "bottom" ? (v = d, x = p === (await (s.isRTL == null ? void 0 : s.isRTL(a.floating)) ? "start" : "end") ? "left" : "right") : (x = d, v = p === "end" ? "top" : "bottom");
+      const w = m - f.top - f.bottom, C = g - f.left - f.right, b = J(m - f[v], w), E = J(g - f[x], C), R = !t.middlewareData.shift;
+      let A = b, P = E;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (P = C), (r = t.middlewareData.shift) != null && r.enabled.y && (A = w), R && !p) {
+        const T = H(f.left, 0), _ = H(f.right, 0), W = H(f.top, 0), N = H(f.bottom, 0);
+        u ? P = g - 2 * (T !== 0 || _ !== 0 ? T + _ : H(f.left, f.right)) : A = m - 2 * (W !== 0 || N !== 0 ? W + N : H(f.top, f.bottom));
+      }
+      await c({
+        ...t,
+        availableWidth: P,
+        availableHeight: A
+      });
+      const M = await s.getDimensions(a.floating);
+      return g !== M.width || m !== M.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function Ae() {
+  return typeof window < "u";
+}
+function le(e) {
+  return Rt(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function B(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function Y(e) {
+  var t;
+  return (t = (Rt(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Rt(e) {
+  return Ae() ? e instanceof Node || e instanceof B(e).Node : !1;
+}
+function z(e) {
+  return Ae() ? e instanceof Element || e instanceof B(e).Element : !1;
+}
+function Z(e) {
+  return Ae() ? e instanceof HTMLElement || e instanceof B(e).HTMLElement : !1;
+}
+function ft(e) {
+  return !Ae() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof B(e).ShadowRoot;
+}
+function pe(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: r,
+    display: o
+  } = I(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && o !== "inline" && o !== "contents";
+}
+function Qn(e) {
+  return /^(table|td|th)$/.test(le(e));
+}
+function Re(e) {
+  try {
+    if (e.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return e.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const er = /transform|translate|scale|rotate|perspective|filter/, tr = /paint|layout|strict|content/, ee = (e) => !!e && e !== "none";
+let Ne;
+function je(e) {
+  const t = z(e) ? I(e) : e;
+  return ee(t.transform) || ee(t.translate) || ee(t.scale) || ee(t.rotate) || ee(t.perspective) || !Ve() && (ee(t.backdropFilter) || ee(t.filter)) || er.test(t.willChange || "") || tr.test(t.contain || "");
+}
+function nr(e) {
+  let t = Q(e);
+  for (; Z(t) && !se(t); ) {
+    if (je(t))
+      return t;
+    if (Re(t))
+      return null;
+    t = Q(t);
+  }
+  return null;
+}
+function Ve() {
+  return Ne == null && (Ne = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), Ne;
+}
+function se(e) {
+  return /^(html|body|#document)$/.test(le(e));
+}
+function I(e) {
+  return B(e).getComputedStyle(e);
+}
+function Ee(e) {
+  return z(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function Q(e) {
+  if (le(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.
+    ft(e) && e.host || // Fallback.
+    Y(e)
+  );
+  return ft(t) ? t.host : t;
+}
+function Et(e) {
+  const t = Q(e);
+  return se(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : Z(t) && pe(t) ? t : Et(t);
+}
+function ue(e, t, n) {
+  var r;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = Et(e), i = o === ((r = e.ownerDocument) == null ? void 0 : r.body), s = B(o);
+  if (i) {
+    const a = We(s);
+    return t.concat(s, s.visualViewport || [], pe(o) ? o : [], a && n ? ue(a) : []);
+  } else
+    return t.concat(o, ue(o, [], n));
+}
+function We(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function Ot(e) {
+  const t = I(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = Z(e), i = o ? e.offsetWidth : n, s = o ? e.offsetHeight : r, a = we(n) !== i || we(r) !== s;
+  return a && (n = i, r = s), {
+    width: n,
+    height: r,
+    $: a
+  };
+}
+function Ue(e) {
+  return z(e) ? e : e.contextElement;
+}
+function oe(e) {
+  const t = Ue(e);
+  if (!Z(t))
+    return U(1);
+  const n = t.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: i
+  } = Ot(t);
+  let s = (i ? we(n.width) : n.width) / r, a = (i ? we(n.height) : n.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!a || !Number.isFinite(a)) && (a = 1), {
+    x: s,
+    y: a
+  };
+}
+const rr = /* @__PURE__ */ U(0);
+function Pt(e) {
+  const t = B(e);
+  return !Ve() || !t.visualViewport ? rr : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function or(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== B(e) ? !1 : t;
+}
+function te(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = Ue(e);
+  let s = U(1);
+  t && (r ? z(r) && (s = oe(r)) : s = oe(e));
+  const a = or(i, n, r) ? Pt(i) : U(0);
+  let c = (o.left + a.x) / s.x, l = (o.top + a.y) / s.y, f = o.width / s.x, d = o.height / s.y;
+  if (i) {
+    const p = B(i), u = r && z(r) ? B(r) : r;
+    let g = p, m = We(g);
+    for (; m && r && u !== g; ) {
+      const v = oe(m), x = m.getBoundingClientRect(), w = I(m), C = x.left + (m.clientLeft + parseFloat(w.paddingLeft)) * v.x, b = x.top + (m.clientTop + parseFloat(w.paddingTop)) * v.y;
+      c *= v.x, l *= v.y, f *= v.x, d *= v.y, c += C, l += b, g = B(m), m = We(g);
+    }
+  }
+  return be({
+    width: f,
+    height: d,
+    x: c,
+    y: l
+  });
+}
+function Oe(e, t) {
+  const n = Ee(e).scrollLeft;
+  return t ? t.left + n : te(Y(e)).left + n;
+}
+function Tt(e, t) {
+  const n = e.getBoundingClientRect(), r = n.left + t.scrollLeft - Oe(e, n), o = n.top + t.scrollTop;
+  return {
+    x: r,
+    y: o
+  };
+}
+function ir(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = e;
+  const i = o === "fixed", s = Y(r), a = t ? Re(t.floating) : !1;
+  if (r === s || a && i)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, l = U(1);
+  const f = U(0), d = Z(r);
+  if ((d || !d && !i) && ((le(r) !== "body" || pe(s)) && (c = Ee(r)), d)) {
+    const u = te(r);
+    l = oe(r), f.x = u.x + r.clientLeft, f.y = u.y + r.clientTop;
+  }
+  const p = s && !d && !i ? Tt(s, c) : U(0);
+  return {
+    width: n.width * l.x,
+    height: n.height * l.y,
+    x: n.x * l.x - c.scrollLeft * l.x + f.x + p.x,
+    y: n.y * l.y - c.scrollTop * l.y + f.y + p.y
+  };
+}
+function sr(e) {
+  return Array.from(e.getClientRects());
+}
+function cr(e) {
+  const t = Y(e), n = Ee(e), r = e.ownerDocument.body, o = H(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), i = H(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let s = -n.scrollLeft + Oe(e);
+  const a = -n.scrollTop;
+  return I(r).direction === "rtl" && (s += H(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: s,
+    y: a
+  };
+}
+const ut = 25;
+function ar(e, t) {
+  const n = B(e), r = Y(e), o = n.visualViewport;
+  let i = r.clientWidth, s = r.clientHeight, a = 0, c = 0;
+  if (o) {
+    i = o.width, s = o.height;
+    const f = Ve();
+    (!f || f && t === "fixed") && (a = o.offsetLeft, c = o.offsetTop);
+  }
+  const l = Oe(r);
+  if (l <= 0) {
+    const f = r.ownerDocument, d = f.body, p = getComputedStyle(d), u = f.compatMode === "CSS1Compat" && parseFloat(p.marginLeft) + parseFloat(p.marginRight) || 0, g = Math.abs(r.clientWidth - d.clientWidth - u);
+    g <= ut && (i -= g);
+  } else l <= ut && (i += l);
+  return {
+    width: i,
+    height: s,
+    x: a,
+    y: c
+  };
+}
+function lr(e, t) {
+  const n = te(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, i = Z(e) ? oe(e) : U(1), s = e.clientWidth * i.x, a = e.clientHeight * i.y, c = o * i.x, l = r * i.y;
+  return {
+    width: s,
+    height: a,
+    x: c,
+    y: l
+  };
+}
+function dt(e, t, n) {
+  let r;
+  if (t === "viewport")
+    r = ar(e, n);
+  else if (t === "document")
+    r = cr(Y(e));
+  else if (z(t))
+    r = lr(t, n);
+  else {
+    const o = Pt(e);
+    r = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return be(r);
+}
+function St(e, t) {
+  const n = Q(e);
+  return n === t || !z(n) || se(n) ? !1 : I(n).position === "fixed" || St(n, t);
+}
+function fr(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let r = ue(e, [], !1).filter((a) => z(a) && le(a) !== "body"), o = null;
+  const i = I(e).position === "fixed";
+  let s = i ? Q(e) : e;
+  for (; z(s) && !se(s); ) {
+    const a = I(s), c = je(s);
+    !c && a.position === "fixed" && (o = null), (i ? !c && !o : !c && a.position === "static" && !!o && (o.position === "absolute" || o.position === "fixed") || pe(s) && !c && St(e, s)) ? r = r.filter((f) => f !== s) : o = a, s = Q(s);
+  }
+  return t.set(e, r), r;
+}
+function ur(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = e;
+  const s = [...n === "clippingAncestors" ? Re(t) ? [] : fr(t, this._c) : [].concat(n), r], a = dt(t, s[0], o);
+  let c = a.top, l = a.right, f = a.bottom, d = a.left;
+  for (let p = 1; p < s.length; p++) {
+    const u = dt(t, s[p], o);
+    c = H(u.top, c), l = J(u.right, l), f = J(u.bottom, f), d = H(u.left, d);
+  }
+  return {
+    width: l - d,
+    height: f - c,
+    x: d,
+    y: c
+  };
+}
+function dr(e) {
+  const {
+    width: t,
+    height: n
+  } = Ot(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function pr(e, t, n) {
+  const r = Z(t), o = Y(t), i = n === "fixed", s = te(e, !0, i, t);
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = U(0);
+  function l() {
+    c.x = Oe(o);
+  }
+  if (r || !r && !i)
+    if ((le(t) !== "body" || pe(o)) && (a = Ee(t)), r) {
+      const u = te(t, !0, i, t);
+      c.x = u.x + t.clientLeft, c.y = u.y + t.clientTop;
+    } else o && l();
+  i && !r && o && l();
+  const f = o && !r && !i ? Tt(o, a) : U(0), d = s.left + a.scrollLeft - c.x - f.x, p = s.top + a.scrollTop - c.y - f.y;
+  return {
+    x: d,
+    y: p,
+    width: s.width,
+    height: s.height
+  };
+}
+function De(e) {
+  return I(e).position === "static";
+}
+function pt(e, t) {
+  if (!Z(e) || I(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return Y(e) === n && (n = n.ownerDocument.body), n;
+}
+function Nt(e, t) {
+  const n = B(e);
+  if (Re(e))
+    return n;
+  if (!Z(e)) {
+    let o = Q(e);
+    for (; o && !se(o); ) {
+      if (z(o) && !De(o))
+        return o;
+      o = Q(o);
+    }
+    return n;
+  }
+  let r = pt(e, t);
+  for (; r && Qn(r) && De(r); )
+    r = pt(r, t);
+  return r && se(r) && De(r) && !je(r) ? n : r || nr(e) || n;
+}
+const hr = async function(e) {
+  const t = this.getOffsetParent || Nt, n = this.getDimensions, r = await n(e.floating);
+  return {
+    reference: pr(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function mr(e) {
+  return I(e).direction === "rtl";
+}
+const gr = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: ir,
+  getDocumentElement: Y,
+  getClippingRect: ur,
+  getOffsetParent: Nt,
+  getElementRects: hr,
+  getClientRects: sr,
+  getDimensions: dr,
+  getScale: oe,
+  isElement: z,
+  isRTL: mr
+};
+function Dt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function vr(e, t) {
+  let n = null, r;
+  const o = Y(e);
+  function i() {
+    var a;
+    clearTimeout(r), (a = n) == null || a.disconnect(), n = null;
+  }
+  function s(a, c) {
+    a === void 0 && (a = !1), c === void 0 && (c = 1), i();
+    const l = e.getBoundingClientRect(), {
+      left: f,
+      top: d,
+      width: p,
+      height: u
+    } = l;
+    if (a || t(), !p || !u)
+      return;
+    const g = ge(d), m = ge(o.clientWidth - (f + p)), v = ge(o.clientHeight - (d + u)), x = ge(f), C = {
+      rootMargin: -g + "px " + -m + "px " + -v + "px " + -x + "px",
+      threshold: H(0, J(1, c)) || 1
+    };
+    let b = !0;
+    function E(R) {
+      const A = R[0].intersectionRatio;
+      if (A !== c) {
+        if (!b)
+          return s();
+        A ? s(!1, A) : r = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      A === 1 && !Dt(l, e.getBoundingClientRect()) && s(), b = !1;
+    }
+    try {
+      n = new IntersectionObserver(E, {
+        ...C,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(E, C);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function xr(e, t, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: a = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = r, l = Ue(e), f = o || i ? [...l ? ue(l) : [], ...t ? ue(t) : []] : [];
+  f.forEach((x) => {
+    o && x.addEventListener("scroll", n, {
+      passive: !0
+    }), i && x.addEventListener("resize", n);
+  });
+  const d = l && a ? vr(l, n) : null;
+  let p = -1, u = null;
+  s && (u = new ResizeObserver((x) => {
+    let [w] = x;
+    w && w.target === l && u && t && (u.unobserve(t), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var C;
+      (C = u) == null || C.observe(t);
+    })), n();
+  }), l && !c && u.observe(l), t && u.observe(t));
+  let g, m = c ? te(e) : null;
+  c && v();
+  function v() {
+    const x = te(e);
+    m && !Dt(m, x) && n(), m = x, g = requestAnimationFrame(v);
+  }
+  return n(), () => {
+    var x;
+    f.forEach((w) => {
+      o && w.removeEventListener("scroll", n), i && w.removeEventListener("resize", n);
+    }), d == null || d(), (x = u) == null || x.disconnect(), u = null, c && cancelAnimationFrame(g);
+  };
+}
+const wr = qn, yr = Kn, br = Yn, Cr = Jn, Ar = Xn, ht = Un, Rr = Zn, Er = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: gr,
+    ...n
+  }, i = {
+    ...o.platform,
+    _c: r
+  };
+  return Vn(e, t, {
+    ...o,
+    platform: i
+  });
+};
+var Or = typeof document < "u", Pr = function() {
+}, xe = Or ? un : Pr;
+function Ce(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 (!Ce(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) && !Ce(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function Lt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function mt(e, t) {
+  const n = Lt(e);
+  return Math.round(t * n) / n;
+}
+function Le(e) {
+  const t = h.useRef(e);
+  return xe(() => {
+    t.current = e;
+  }), t;
+}
+function Tr(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: o,
+    elements: {
+      reference: i,
+      floating: s
+    } = {},
+    transform: a = !0,
+    whileElementsMounted: c,
+    open: l
+  } = e, [f, d] = h.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [p, u] = h.useState(r);
+  Ce(p, r) || u(r);
+  const [g, m] = h.useState(null), [v, x] = h.useState(null), w = h.useCallback((O) => {
+    O !== R.current && (R.current = O, m(O));
+  }, []), C = h.useCallback((O) => {
+    O !== A.current && (A.current = O, x(O));
+  }, []), b = i || g, E = s || v, R = h.useRef(null), A = h.useRef(null), P = h.useRef(f), M = c != null, T = Le(c), _ = Le(o), W = Le(l), N = h.useCallback(() => {
+    if (!R.current || !A.current)
+      return;
+    const O = {
+      placement: t,
+      strategy: n,
+      middleware: p
+    };
+    _.current && (O.platform = _.current), Er(R.current, A.current, O).then((k) => {
+      const j = {
+        ...k,
+        // 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: W.current !== !1
+      };
+      S.current && !Ce(P.current, j) && (P.current = j, vt.flushSync(() => {
+        d(j);
+      }));
+    });
+  }, [p, t, n, _, W]);
+  xe(() => {
+    l === !1 && P.current.isPositioned && (P.current.isPositioned = !1, d((O) => ({
+      ...O,
+      isPositioned: !1
+    })));
+  }, [l]);
+  const S = h.useRef(!1);
+  xe(() => (S.current = !0, () => {
+    S.current = !1;
+  }), []), xe(() => {
+    if (b && (R.current = b), E && (A.current = E), b && E) {
+      if (T.current)
+        return T.current(b, E, N);
+      N();
+    }
+  }, [b, E, N, T, M]);
+  const F = h.useMemo(() => ({
+    reference: R,
+    floating: A,
+    setReference: w,
+    setFloating: C
+  }), [w, C]), D = h.useMemo(() => ({
+    reference: b,
+    floating: E
+  }), [b, E]), L = h.useMemo(() => {
+    const O = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!D.floating)
+      return O;
+    const k = mt(D.floating, f.x), j = mt(D.floating, f.y);
+    return a ? {
+      ...O,
+      transform: "translate(" + k + "px, " + j + "px)",
+      ...Lt(D.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: k,
+      top: j
+    };
+  }, [n, a, D.floating, f.x, f.y]);
+  return h.useMemo(() => ({
+    ...f,
+    update: N,
+    refs: F,
+    elements: D,
+    floatingStyles: L
+  }), [f, N, F, D, L]);
+}
+const Sr = (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 ? ht({
+        element: r.current,
+        padding: o
+      }).fn(n) : {} : r ? ht({
+        element: r,
+        padding: o
+      }).fn(n) : {};
+    }
+  };
+}, Nr = (e, t) => {
+  const n = wr(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, Dr = (e, t) => {
+  const n = yr(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, Lr = (e, t) => ({
+  fn: Rr(e).fn,
+  options: [e, t]
+}), Mr = (e, t) => {
+  const n = br(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, kr = (e, t) => {
+  const n = Cr(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, _r = (e, t) => {
+  const n = Ar(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, Wr = (e, t) => {
+  const n = Sr(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+};
+var $r = "Arrow", Mt = h.forwardRef((e, t) => {
+  const { children: n, width: r = 10, height: o = 5, ...i } = e;
+  return /* @__PURE__ */ y(
+    re.svg,
+    {
+      ...i,
+      ref: t,
+      width: r,
+      height: o,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: e.asChild ? n : /* @__PURE__ */ y("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+Mt.displayName = $r;
+var Fr = Mt;
+function Hr(e) {
+  const [t, n] = h.useState(void 0);
+  return ie(() => {
+    if (e) {
+      n({ width: e.offsetWidth, height: e.offsetHeight });
+      const r = new ResizeObserver((o) => {
+        if (!Array.isArray(o) || !o.length)
+          return;
+        const i = o[0];
+        let s, a;
+        if ("borderBoxSize" in i) {
+          const c = i.borderBoxSize, l = Array.isArray(c) ? c[0] : c;
+          s = l.inlineSize, a = l.blockSize;
+        } else
+          s = e.offsetWidth, a = e.offsetHeight;
+        n({ width: s, height: a });
+      });
+      return r.observe(e, { box: "border-box" }), () => r.unobserve(e);
+    } else
+      n(void 0);
+  }, [e]), t;
+}
+var Ye = "Popper", [kt, _t] = gt(Ye), [Br, Wt] = kt(Ye), $t = (e) => {
+  const { __scopePopper: t, children: n } = e, [r, o] = h.useState(null);
+  return /* @__PURE__ */ y(Br, { scope: t, anchor: r, onAnchorChange: o, children: n });
+};
+$t.displayName = Ye;
+var Ft = "PopperAnchor", Ht = h.forwardRef(
+  (e, t) => {
+    const { __scopePopper: n, virtualRef: r, ...o } = e, i = Wt(Ft, n), s = h.useRef(null), a = ne(t, s), c = h.useRef(null);
+    return h.useEffect(() => {
+      const l = c.current;
+      c.current = (r == null ? void 0 : r.current) || s.current, l !== c.current && i.onAnchorChange(c.current);
+    }), r ? null : /* @__PURE__ */ y(re.div, { ...o, ref: a });
+  }
+);
+Ht.displayName = Ft;
+var Xe = "PopperContent", [zr, Ir] = kt(Xe), Bt = h.forwardRef(
+  (e, t) => {
+    var qe, Ke, Ze, Je, Qe, et;
+    const {
+      __scopePopper: n,
+      side: r = "bottom",
+      sideOffset: o = 0,
+      align: i = "center",
+      alignOffset: s = 0,
+      arrowPadding: a = 0,
+      avoidCollisions: c = !0,
+      collisionBoundary: l = [],
+      collisionPadding: f = 0,
+      sticky: d = "partial",
+      hideWhenDetached: p = !1,
+      updatePositionStrategy: u = "optimized",
+      onPlaced: g,
+      ...m
+    } = e, v = Wt(Xe, n), [x, w] = h.useState(null), C = ne(t, (fe) => w(fe)), [b, E] = h.useState(null), R = Hr(b), A = (R == null ? void 0 : R.width) ?? 0, P = (R == null ? void 0 : R.height) ?? 0, M = r + (i !== "center" ? "-" + i : ""), T = typeof f == "number" ? f : { top: 0, right: 0, bottom: 0, left: 0, ...f }, _ = Array.isArray(l) ? l : [l], W = _.length > 0, N = {
+      padding: T,
+      boundary: _.filter(Vr),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: W
+    }, { refs: S, floatingStyles: F, placement: D, isPositioned: L, middlewareData: O } = Tr({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: M,
+      whileElementsMounted: (...fe) => xr(...fe, {
+        animationFrame: u === "always"
+      }),
+      elements: {
+        reference: v.anchor
+      },
+      middleware: [
+        Nr({ mainAxis: o + P, alignmentAxis: s }),
+        c && Dr({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: d === "partial" ? Lr() : void 0,
+          ...N
+        }),
+        c && Mr({ ...N }),
+        kr({
+          ...N,
+          apply: ({ elements: fe, rects: tt, availableWidth: cn, availableHeight: an }) => {
+            const { width: ln, height: fn } = tt.reference, me = fe.floating.style;
+            me.setProperty("--radix-popper-available-width", `${cn}px`), me.setProperty("--radix-popper-available-height", `${an}px`), me.setProperty("--radix-popper-anchor-width", `${ln}px`), me.setProperty("--radix-popper-anchor-height", `${fn}px`);
+          }
+        }),
+        b && Wr({ element: b, padding: a }),
+        Ur({ arrowWidth: A, arrowHeight: P }),
+        p && _r({ strategy: "referenceHidden", ...N })
+      ]
+    }), [k, j] = jt(D), he = He(g);
+    ie(() => {
+      L && (he == null || he());
+    }, [L, he]);
+    const tn = (qe = O.arrow) == null ? void 0 : qe.x, nn = (Ke = O.arrow) == null ? void 0 : Ke.y, rn = ((Ze = O.arrow) == null ? void 0 : Ze.centerOffset) !== 0, [on, sn] = h.useState();
+    return ie(() => {
+      x && sn(window.getComputedStyle(x).zIndex);
+    }, [x]), /* @__PURE__ */ y(
+      "div",
+      {
+        ref: S.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...F,
+          transform: L ? F.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: on,
+          "--radix-popper-transform-origin": [
+            (Je = O.transformOrigin) == null ? void 0 : Je.x,
+            (Qe = O.transformOrigin) == null ? void 0 : Qe.y
+          ].join(" "),
+          // hide the content if using the hide middleware and should be hidden
+          // set visibility to hidden and disable pointer events so the UI behaves
+          // as if the PopperContent isn't there at all
+          ...((et = O.hide) == null ? void 0 : et.referenceHidden) && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        },
+        dir: e.dir,
+        children: /* @__PURE__ */ y(
+          zr,
+          {
+            scope: n,
+            placedSide: k,
+            onArrowChange: E,
+            arrowX: tn,
+            arrowY: nn,
+            shouldHideArrow: rn,
+            children: /* @__PURE__ */ y(
+              re.div,
+              {
+                "data-side": k,
+                "data-align": j,
+                ...m,
+                ref: C,
+                style: {
+                  ...m.style,
+                  // if the PopperContent hasn't been placed yet (not all measurements done)
+                  // we prevent animations so that users's animation don't kick in too early referring wrong sides
+                  animation: L ? void 0 : "none"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Bt.displayName = Xe;
+var zt = "PopperArrow", jr = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, It = h.forwardRef(function(t, n) {
+  const { __scopePopper: r, ...o } = t, i = Ir(zt, r), s = jr[i.placedSide];
+  return (
+    // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)
+    // doesn't report size as we'd expect on SVG elements.
+    // it reports their bounding box which is effectively the largest path inside the SVG.
+    /* @__PURE__ */ y(
+      "span",
+      {
+        ref: i.onArrowChange,
+        style: {
+          position: "absolute",
+          left: i.arrowX,
+          top: i.arrowY,
+          [s]: 0,
+          transformOrigin: {
+            top: "",
+            right: "0 0",
+            bottom: "center 0",
+            left: "100% 0"
+          }[i.placedSide],
+          transform: {
+            top: "translateY(100%)",
+            right: "translateY(50%) rotate(90deg) translateX(-50%)",
+            bottom: "rotate(180deg)",
+            left: "translateY(50%) rotate(-90deg) translateX(50%)"
+          }[i.placedSide],
+          visibility: i.shouldHideArrow ? "hidden" : void 0
+        },
+        children: /* @__PURE__ */ y(
+          Fr,
+          {
+            ...o,
+            ref: n,
+            style: {
+              ...o.style,
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            }
+          }
+        )
+      }
+    )
+  );
+});
+It.displayName = zt;
+function Vr(e) {
+  return e !== null;
+}
+var Ur = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(t) {
+    var v, x, w;
+    const { placement: n, rects: r, middlewareData: o } = t, s = ((v = o.arrow) == null ? void 0 : v.centerOffset) !== 0, a = s ? 0 : e.arrowWidth, c = s ? 0 : e.arrowHeight, [l, f] = jt(n), d = { start: "0%", center: "50%", end: "100%" }[f], p = (((x = o.arrow) == null ? void 0 : x.x) ?? 0) + a / 2, u = (((w = o.arrow) == null ? void 0 : w.y) ?? 0) + c / 2;
+    let g = "", m = "";
+    return l === "bottom" ? (g = s ? d : `${p}px`, m = `${-c}px`) : l === "top" ? (g = s ? d : `${p}px`, m = `${r.floating.height + c}px`) : l === "right" ? (g = `${-c}px`, m = s ? d : `${u}px`) : l === "left" && (g = `${r.floating.width + c}px`, m = s ? d : `${u}px`), { data: { x: g, y: m } };
+  }
+});
+function jt(e) {
+  const [t, n = "center"] = e.split("-");
+  return [t, n];
+}
+var Yr = $t, Xr = Ht, Gr = Bt, qr = It;
+function Kr(e, t) {
+  return h.useReducer((n, r) => t[n][r] ?? n, e);
+}
+var Vt = (e) => {
+  const { present: t, children: n } = e, r = Zr(t), o = typeof n == "function" ? n({ present: r.isPresent }) : h.Children.only(n), i = ne(r.ref, Jr(o));
+  return typeof n == "function" || r.isPresent ? h.cloneElement(o, { ref: i }) : null;
+};
+Vt.displayName = "Presence";
+function Zr(e) {
+  const [t, n] = h.useState(), r = h.useRef(null), o = h.useRef(e), i = h.useRef("none"), s = e ? "mounted" : "unmounted", [a, c] = Kr(s, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: {
+      MOUNT: "mounted"
+    }
+  });
+  return h.useEffect(() => {
+    const l = ve(r.current);
+    i.current = a === "mounted" ? l : "none";
+  }, [a]), ie(() => {
+    const l = r.current, f = o.current;
+    if (f !== e) {
+      const p = i.current, u = ve(l);
+      e ? c("MOUNT") : u === "none" || (l == null ? void 0 : l.display) === "none" ? c("UNMOUNT") : c(f && p !== u ? "ANIMATION_OUT" : "UNMOUNT"), o.current = e;
+    }
+  }, [e, c]), ie(() => {
+    if (t) {
+      let l;
+      const f = t.ownerDocument.defaultView ?? window, d = (u) => {
+        const m = ve(r.current).includes(CSS.escape(u.animationName));
+        if (u.target === t && m && (c("ANIMATION_END"), !o.current)) {
+          const v = t.style.animationFillMode;
+          t.style.animationFillMode = "forwards", l = f.setTimeout(() => {
+            t.style.animationFillMode === "forwards" && (t.style.animationFillMode = v);
+          });
+        }
+      }, p = (u) => {
+        u.target === t && (i.current = ve(r.current));
+      };
+      return t.addEventListener("animationstart", p), t.addEventListener("animationcancel", d), t.addEventListener("animationend", d), () => {
+        f.clearTimeout(l), t.removeEventListener("animationstart", p), t.removeEventListener("animationcancel", d), t.removeEventListener("animationend", d);
+      };
+    } else
+      c("ANIMATION_END");
+  }, [t, c]), {
+    isPresent: ["mounted", "unmountSuspended"].includes(a),
+    ref: h.useCallback((l) => {
+      r.current = l ? getComputedStyle(l) : null, n(l);
+    }, [])
+  };
+}
+function ve(e) {
+  return (e == null ? void 0 : e.animationName) || "none";
+}
+function Jr(e) {
+  var r, o;
+  let t = (r = Object.getOwnPropertyDescriptor(e.props, "ref")) == null ? void 0 : r.get, n = t && "isReactWarning" in t && t.isReactWarning;
+  return n ? e.ref : (t = (o = Object.getOwnPropertyDescriptor(e, "ref")) == null ? void 0 : o.get, n = t && "isReactWarning" in t && t.isReactWarning, n ? e.props.ref : e.props.ref || e.ref);
+}
+var Qr = Object.freeze({
+  // See: https://github.com/twbs/bootstrap/blob/main/scss/mixins/_visually-hidden.scss
+  position: "absolute",
+  border: 0,
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  wordWrap: "normal"
+}), eo = "VisuallyHidden", Ut = h.forwardRef(
+  (e, t) => /* @__PURE__ */ y(
+    re.span,
+    {
+      ...e,
+      ref: t,
+      style: { ...Qr, ...e.style }
+    }
+  )
+);
+Ut.displayName = eo;
+var to = Ut, [Pe] = gt("Tooltip", [
+  _t
+]), Te = _t(), Yt = "TooltipProvider", no = 700, $e = "tooltip.open", [ro, Ge] = Pe(Yt), Xt = (e) => {
+  const {
+    __scopeTooltip: t,
+    delayDuration: n = no,
+    skipDelayDuration: r = 300,
+    disableHoverableContent: o = !1,
+    children: i
+  } = e, s = h.useRef(!0), a = h.useRef(!1), c = h.useRef(0);
+  return h.useEffect(() => {
+    const l = c.current;
+    return () => window.clearTimeout(l);
+  }, []), /* @__PURE__ */ y(
+    ro,
+    {
+      scope: t,
+      isOpenDelayedRef: s,
+      delayDuration: n,
+      onOpen: h.useCallback(() => {
+        window.clearTimeout(c.current), s.current = !1;
+      }, []),
+      onClose: h.useCallback(() => {
+        window.clearTimeout(c.current), c.current = window.setTimeout(
+          () => s.current = !0,
+          r
+        );
+      }, [r]),
+      isPointerInTransitRef: a,
+      onPointerInTransitChange: h.useCallback((l) => {
+        a.current = l;
+      }, []),
+      disableHoverableContent: o,
+      children: i
+    }
+  );
+};
+Xt.displayName = Yt;
+var de = "Tooltip", [oo, Se] = Pe(de), Gt = (e) => {
+  const {
+    __scopeTooltip: t,
+    children: n,
+    open: r,
+    defaultOpen: o,
+    onOpenChange: i,
+    disableHoverableContent: s,
+    delayDuration: a
+  } = e, c = Ge(de, e.__scopeTooltip), l = Te(t), [f, d] = h.useState(null), p = Ln(), u = h.useRef(0), g = s ?? c.disableHoverableContent, m = a ?? c.delayDuration, v = h.useRef(!1), [x, w] = mn({
+    prop: r,
+    defaultProp: o ?? !1,
+    onChange: (A) => {
+      A ? (c.onOpen(), document.dispatchEvent(new CustomEvent($e))) : c.onClose(), i == null || i(A);
+    },
+    caller: de
+  }), C = h.useMemo(() => x ? v.current ? "delayed-open" : "instant-open" : "closed", [x]), b = h.useCallback(() => {
+    window.clearTimeout(u.current), u.current = 0, v.current = !1, w(!0);
+  }, [w]), E = h.useCallback(() => {
+    window.clearTimeout(u.current), u.current = 0, w(!1);
+  }, [w]), R = h.useCallback(() => {
+    window.clearTimeout(u.current), u.current = window.setTimeout(() => {
+      v.current = !0, w(!0), u.current = 0;
+    }, m);
+  }, [m, w]);
+  return h.useEffect(() => () => {
+    u.current && (window.clearTimeout(u.current), u.current = 0);
+  }, []), /* @__PURE__ */ y(Yr, { ...l, children: /* @__PURE__ */ y(
+    oo,
+    {
+      scope: t,
+      contentId: p,
+      open: x,
+      stateAttribute: C,
+      trigger: f,
+      onTriggerChange: d,
+      onTriggerEnter: h.useCallback(() => {
+        c.isOpenDelayedRef.current ? R() : b();
+      }, [c.isOpenDelayedRef, R, b]),
+      onTriggerLeave: h.useCallback(() => {
+        g ? E() : (window.clearTimeout(u.current), u.current = 0);
+      }, [E, g]),
+      onOpen: b,
+      onClose: E,
+      disableHoverableContent: g,
+      children: n
+    }
+  ) });
+};
+Gt.displayName = de;
+var Fe = "TooltipTrigger", qt = h.forwardRef(
+  (e, t) => {
+    const { __scopeTooltip: n, ...r } = e, o = Se(Fe, n), i = Ge(Fe, n), s = Te(n), a = h.useRef(null), c = ne(t, a, o.onTriggerChange), l = h.useRef(!1), f = h.useRef(!1), d = h.useCallback(() => l.current = !1, []);
+    return h.useEffect(() => () => document.removeEventListener("pointerup", d), [d]), /* @__PURE__ */ y(Xr, { asChild: !0, ...s, children: /* @__PURE__ */ y(
+      re.button,
+      {
+        "aria-describedby": o.open ? o.contentId : void 0,
+        "data-state": o.stateAttribute,
+        ...r,
+        ref: c,
+        onPointerMove: X(e.onPointerMove, (p) => {
+          p.pointerType !== "touch" && !f.current && !i.isPointerInTransitRef.current && (o.onTriggerEnter(), f.current = !0);
+        }),
+        onPointerLeave: X(e.onPointerLeave, () => {
+          o.onTriggerLeave(), f.current = !1;
+        }),
+        onPointerDown: X(e.onPointerDown, () => {
+          o.open && o.onClose(), l.current = !0, document.addEventListener("pointerup", d, { once: !0 });
+        }),
+        onFocus: X(e.onFocus, () => {
+          l.current || o.onOpen();
+        }),
+        onBlur: X(e.onBlur, o.onClose),
+        onClick: X(e.onClick, o.onClose)
+      }
+    ) });
+  }
+);
+qt.displayName = Fe;
+var io = "TooltipPortal", [Do, so] = Pe(io, {
+  forceMount: void 0
+}), ce = "TooltipContent", Kt = h.forwardRef(
+  (e, t) => {
+    const n = so(ce, e.__scopeTooltip), { forceMount: r = n.forceMount, side: o = "top", ...i } = e, s = Se(ce, e.__scopeTooltip);
+    return /* @__PURE__ */ y(Vt, { present: r || s.open, children: s.disableHoverableContent ? /* @__PURE__ */ y(Zt, { side: o, ...i, ref: t }) : /* @__PURE__ */ y(co, { side: o, ...i, ref: t }) });
+  }
+), co = h.forwardRef((e, t) => {
+  const n = Se(ce, e.__scopeTooltip), r = Ge(ce, e.__scopeTooltip), o = h.useRef(null), i = ne(t, o), [s, a] = h.useState(null), { trigger: c, onClose: l } = n, f = o.current, { onPointerInTransitChange: d } = r, p = h.useCallback(() => {
+    a(null), d(!1);
+  }, [d]), u = h.useCallback(
+    (g, m) => {
+      const v = g.currentTarget, x = { x: g.clientX, y: g.clientY }, w = po(x, v.getBoundingClientRect()), C = ho(x, w), b = mo(m.getBoundingClientRect()), E = vo([...C, ...b]);
+      a(E), d(!0);
+    },
+    [d]
+  );
+  return h.useEffect(() => () => p(), [p]), h.useEffect(() => {
+    if (c && f) {
+      const g = (v) => u(v, f), m = (v) => u(v, c);
+      return c.addEventListener("pointerleave", g), f.addEventListener("pointerleave", m), () => {
+        c.removeEventListener("pointerleave", g), f.removeEventListener("pointerleave", m);
+      };
+    }
+  }, [c, f, u, p]), h.useEffect(() => {
+    if (s) {
+      const g = (m) => {
+        const v = m.target, x = { x: m.clientX, y: m.clientY }, w = (c == null ? void 0 : c.contains(v)) || (f == null ? void 0 : f.contains(v)), C = !go(x, s);
+        w ? p() : C && (p(), l());
+      };
+      return document.addEventListener("pointermove", g), () => document.removeEventListener("pointermove", g);
+    }
+  }, [c, f, s, l, p]), /* @__PURE__ */ y(Zt, { ...e, ref: i });
+}), [ao, lo] = Pe(de, { isInside: !1 }), fo = hn("TooltipContent"), Zt = h.forwardRef(
+  (e, t) => {
+    const {
+      __scopeTooltip: n,
+      children: r,
+      "aria-label": o,
+      onEscapeKeyDown: i,
+      onPointerDownOutside: s,
+      ...a
+    } = e, c = Se(ce, n), l = Te(n), { onClose: f } = c;
+    return h.useEffect(() => (document.addEventListener($e, f), () => document.removeEventListener($e, f)), [f]), h.useEffect(() => {
+      if (c.trigger) {
+        const d = (p) => {
+          const u = p.target;
+          u != null && u.contains(c.trigger) && f();
+        };
+        return window.addEventListener("scroll", d, { capture: !0 }), () => window.removeEventListener("scroll", d, { capture: !0 });
+      }
+    }, [c.trigger, f]), /* @__PURE__ */ y(
+      yt,
+      {
+        asChild: !0,
+        disableOutsidePointerEvents: !1,
+        onEscapeKeyDown: i,
+        onPointerDownOutside: s,
+        onFocusOutside: (d) => d.preventDefault(),
+        onDismiss: f,
+        children: /* @__PURE__ */ $(
+          Gr,
+          {
+            "data-state": c.stateAttribute,
+            ...l,
+            ...a,
+            ref: t,
+            style: {
+              ...a.style,
+              "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
+              "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
+              "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
+              "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
+              "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
+            },
+            children: [
+              /* @__PURE__ */ y(fo, { children: r }),
+              /* @__PURE__ */ y(ao, { scope: n, isInside: !0, children: /* @__PURE__ */ y(to, { id: c.contentId, role: "tooltip", children: o || r }) })
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+Kt.displayName = ce;
+var Jt = "TooltipArrow", uo = h.forwardRef(
+  (e, t) => {
+    const { __scopeTooltip: n, ...r } = e, o = Te(n);
+    return lo(
+      Jt,
+      n
+    ).isInside ? null : /* @__PURE__ */ y(qr, { ...o, ...r, ref: t });
+  }
+);
+uo.displayName = Jt;
+function po(e, t) {
+  const n = Math.abs(t.top - e.y), r = Math.abs(t.bottom - e.y), o = Math.abs(t.right - e.x), i = Math.abs(t.left - e.x);
+  switch (Math.min(n, r, o, i)) {
+    case i:
+      return "left";
+    case o:
+      return "right";
+    case n:
+      return "top";
+    case r:
+      return "bottom";
+    default:
+      throw new Error("unreachable");
+  }
+}
+function ho(e, t, n = 5) {
+  const r = [];
+  switch (t) {
+    case "top":
+      r.push(
+        { x: e.x - n, y: e.y + n },
+        { x: e.x + n, y: e.y + n }
+      );
+      break;
+    case "bottom":
+      r.push(
+        { x: e.x - n, y: e.y - n },
+        { x: e.x + n, y: e.y - n }
+      );
+      break;
+    case "left":
+      r.push(
+        { x: e.x + n, y: e.y - n },
+        { x: e.x + n, y: e.y + n }
+      );
+      break;
+    case "right":
+      r.push(
+        { x: e.x - n, y: e.y - n },
+        { x: e.x - n, y: e.y + n }
+      );
+      break;
+  }
+  return r;
+}
+function mo(e) {
+  const { top: t, right: n, bottom: r, left: o } = e;
+  return [
+    { x: o, y: t },
+    { x: n, y: t },
+    { x: n, y: r },
+    { x: o, y: r }
+  ];
+}
+function go(e, t) {
+  const { x: n, y: r } = e;
+  let o = !1;
+  for (let i = 0, s = t.length - 1; i < t.length; s = i++) {
+    const a = t[i], c = t[s], l = a.x, f = a.y, d = c.x, p = c.y;
+    f > r != p > r && n < (d - l) * (r - f) / (p - f) + l && (o = !o);
+  }
+  return o;
+}
+function vo(e) {
+  const t = e.slice();
+  return t.sort((n, r) => n.x < r.x ? -1 : n.x > r.x ? 1 : n.y < r.y ? -1 : n.y > r.y ? 1 : 0), xo(t);
+}
+function xo(e) {
+  if (e.length <= 1) return e.slice();
+  const t = [];
+  for (let r = 0; r < e.length; r++) {
+    const o = e[r];
+    for (; t.length >= 2; ) {
+      const i = t[t.length - 1], s = t[t.length - 2];
+      if ((i.x - s.x) * (o.y - s.y) >= (i.y - s.y) * (o.x - s.x)) t.pop();
+      else break;
+    }
+    t.push(o);
+  }
+  t.pop();
+  const n = [];
+  for (let r = e.length - 1; r >= 0; r--) {
+    const o = e[r];
+    for (; n.length >= 2; ) {
+      const i = n[n.length - 1], s = n[n.length - 2];
+      if ((i.x - s.x) * (o.y - s.y) >= (i.y - s.y) * (o.x - s.x)) n.pop();
+      else break;
+    }
+    n.push(o);
+  }
+  return n.pop(), t.length === 1 && n.length === 1 && t[0].x === n[0].x && t[0].y === n[0].y ? t : t.concat(n);
+}
+var wo = Xt, yo = Gt, bo = qt, Qt = Kt;
+const Co = wo, Ao = yo, Ro = bo, en = h.forwardRef(
+  ({ className: e, sideOffset: t = 4, ...n }, r) => /* @__PURE__ */ y(
+    Qt,
+    {
+      ref: r,
+      sideOffset: t,
+      className: G(
+        "z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+        e
+      ),
+      ...n
+    }
+  )
+);
+en.displayName = Qt.displayName;
+const Eo = ({
+  path: e,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  icon: t,
+  label: n,
+  badge: r,
+  subItems: o,
+  currentPath: i,
+  collapsed: s,
+  onItemClick: a
+}) => {
+  const [c, l] = h.useState((o == null ? void 0 : o.some((m) => i === m.path || i.startsWith(`${m.path}/`))) || !1), f = e ? i === e || e !== "/" && i.startsWith(`${e}/`) : !1, d = o == null ? void 0 : o.some((m) => i === m.path || i.startsWith(`${m.path}/`)), g = /* @__PURE__ */ $(
+    "a",
+    {
+      href: e || "#",
+      onClick: (m) => {
+        m.preventDefault(), o && o.length > 0 ? s || l(!c) : e && a(e);
+      },
+      className: G(
+        "flex items-center gap-3 rounded-2xl cursor-pointer mb-2 transition-all duration-200 group",
+        s ? "justify-center p-3 h-12 w-12 mx-auto" : "px-4 py-3 h-12",
+        f || !s && d ? "bg-sidebar-primary text-sidebar-primary-foreground shadow-lg" : "hover:bg-sidebar-accent text-sidebar-foreground hover:text-sidebar-accent-foreground"
+      ),
+      children: [
+        /* @__PURE__ */ y("div", { className: G("flex-shrink-0 transition-transform group-hover:scale-110", s ? "flex items-center justify-center" : ""), children: /* @__PURE__ */ y(t, { className: "size-4" }) }),
+        !s && /* @__PURE__ */ $(nt, { children: [
+          /* @__PURE__ */ y("span", { className: "flex-grow transition-opacity duration-150 font-medium", children: n }),
+          r !== void 0 && /* @__PURE__ */ y("span", { className: "bg-red-500 text-white text-xs rounded-full py-1 min-w-[20px] text-center px-2 font-semibold", children: r }),
+          o && o.length > 0 && /* @__PURE__ */ y(xn, { className: G("size-4 transition-transform duration-200", c ? "rotate-180" : "") })
+        ] })
+      ]
+    }
+  );
+  return /* @__PURE__ */ $(nt, { children: [
+    s ? /* @__PURE__ */ $(Ao, { children: [
+      /* @__PURE__ */ y(Ro, { asChild: !0, children: g }),
+      /* @__PURE__ */ y(
+        en,
+        {
+          side: "right",
+          sideOffset: 6,
+          className: "rounded-xl z-[99999] flex gap-2 bg-sidebar text-sidebar-foreground border border-sidebar-border py-2 text-sm shadow-lg",
+          children: /* @__PURE__ */ y("div", { className: "flex flex-col gap-2", children: /* @__PURE__ */ $("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ y("p", { className: "font-semibold", children: n }),
+            r !== void 0 && /* @__PURE__ */ $("span", { className: "ml-1 text-xs", children: [
+              "(",
+              r,
+              ")"
+            ] })
+          ] }) })
+        }
+      )
+    ] }) : g,
+    !s && o && o.length > 0 && c && /* @__PURE__ */ y("div", { className: "flex flex-col gap-1 mb-2 ml-4 pl-4 border-l-2 border-sidebar-border/50 animate-in slide-in-from-top-2 fade-in duration-200", children: o.map((m, v) => {
+      const x = i === m.path || m.path !== "/" && i.startsWith(`${m.path}/`);
+      return /* @__PURE__ */ $(
+        "a",
+        {
+          href: m.path,
+          onClick: (w) => {
+            w.preventDefault(), a(m.path);
+          },
+          className: G(
+            "flex items-center justify-between px-4 py-2 rounded-xl text-sm transition-all duration-200",
+            x ? "bg-sidebar-accent/50 text-sidebar-primary font-semibold" : "text-sidebar-muted hover:bg-sidebar-accent hover:text-sidebar-foreground"
+          ),
+          children: [
+            /* @__PURE__ */ y("span", { children: m.label }),
+            m.badge !== void 0 && /* @__PURE__ */ y("span", { className: "bg-sidebar-primary/20 text-sidebar-primary text-[10px] rounded-full py-0.5 px-2 font-semibold", children: m.badge })
+          ]
+        },
+        v
+      );
+    }) })
+  ] });
+}, Lo = ({
+  groups: e,
+  collapsed: t,
+  mobileOpen: n,
+  isMobile: r,
+  onMobileClose: o,
+  onItemClick: i,
+  currentPath: s,
+  appName: a = "appname",
+  appSubName: c = "appsubname",
+  appIcon: l,
+  headerNode: f,
+  footerNode: d
+}) => {
+  const p = (u) => {
+    i(u), r && o();
+  };
+  return /* @__PURE__ */ y(Co, { delayDuration: 0, children: /* @__PURE__ */ $(
+    "aside",
+    {
+      className: G(
+        "flex flex-col bg-sidebar h-screen transition-all duration-300",
+        t ? "w-[--navbar-width-icon]" : "w-[--navbar-width]",
+        r && !n ? "hidden" : "flex"
+      ),
+      style: {
+        "--navbar-width": "16rem",
+        "--navbar-width-icon": "5rem"
+      },
+      children: [
+        f || /* @__PURE__ */ $("div", { className: G("flex items-center h-16 md:h-20 flex-shrink-0 gap-3 px-4", t ? "justify-center" : ""), children: [
+          l !== void 0 && /* @__PURE__ */ y("div", { className: "flex-shrink-0 text-sidebar-foreground", children: /* @__PURE__ */ y(l, { className: "size-6" }) }),
+          !t && /* @__PURE__ */ $("div", { className: "flex flex-col", children: [
+            /* @__PURE__ */ y("h1", { className: "font-bold text-lg text-sidebar-foreground leading-tight", children: a }),
+            /* @__PURE__ */ y("span", { className: "text-xs text-sidebar-muted font-medium", children: c })
+          ] })
+        ] }),
+        /* @__PURE__ */ y("div", { className: "flex-1 overflow-y-auto py-4 px-2 scrollbar-modern", children: e.map((u, g) => /* @__PURE__ */ $("div", { className: "mb-6", children: [
+          !t && u.title !== void 0 && u.title !== "" && /* @__PURE__ */ y("h3", { className: "px-4 mb-2 text-xs uppercase tracking-wider font-semibold text-sidebar-muted", children: u.title }),
+          /* @__PURE__ */ y("nav", { className: "flex flex-col gap-1", children: u.items.map((m, v) => /* @__PURE__ */ y(Eo, { ...m, currentPath: s, collapsed: t, onItemClick: p }, v)) })
+        ] }, g)) }),
+        d && /* @__PURE__ */ y("div", { className: G("p-4 border-t border-sidebar-border", t ? "flex justify-center" : ""), children: d })
+      ]
+    }
+  ) });
+}, Mo = ({ collapsed: e, isMobile: t, onToggleSidebar: n, actionsNode: r, userMenuNode: o }) => /* @__PURE__ */ $(
+  "header",
+  {
+    className: G(
+      "fixed top-0 right-0 z-[60] h-16 md:h-20 bg-topbar text-topbar-foreground flex items-center justify-between px-4 transition-all duration-300",
+      t && "left-0",
+      !t && e && "left-[5rem]",
+      !t && !e && "left-[16rem]"
+    ),
+    tabIndex: -1,
+    children: [
+      /* @__PURE__ */ y("div", { className: "flex items-center min-w-0 flex-1", children: /* @__PURE__ */ y(
+        gn,
+        {
+          variant: "ghost",
+          size: "icon",
+          onClick: n,
+          className: "text-topbar-foreground hover:bg-topbar-accent hover:text-topbar-accent-foreground",
+          children: /* @__PURE__ */ y(yn, { className: "size-4" })
+        }
+      ) }),
+      /* @__PURE__ */ $("div", { className: "flex items-center gap-2 md:gap-4 flex-shrink-0", children: [
+        r,
+        o
+      ] })
+    ]
+  }
+);
+export {
+  Lo as S,
+  Mo as T
+};