@krosoft/react 0.0.88 → 0.0.89

package/dist/tooltip-BzTGwm2E.js

@@ -0,0 +1,2505 @@
+import { c as mn } from "./createLucideIcon-CRdjzt2A.js";
+import { jsx as P, Fragment as hn, jsxs as gn } from "react/jsx-runtime";
+import { a as vn, c as wt } from "./index-gWiv5-6R.js";
+import * as f from "react";
+import { useLayoutEffect as yn } from "react";
+import * as xt from "react-dom";
+const ot = (e) => typeof e == "boolean" ? `${e}` : e === 0 ? "0" : e, rt = vn, wn = (e, t) => (n) => {
+  var o;
+  if ((t == null ? void 0 : t.variants) == null) return rt(e, n == null ? void 0 : n.class, n == null ? void 0 : n.className);
+  const { variants: r, defaultVariants: i } = t, s = Object.keys(r).map((l) => {
+    const u = n == null ? void 0 : n[l], d = i == null ? void 0 : i[l];
+    if (u === null) return null;
+    const m = ot(u) || ot(d);
+    return r[l][m];
+  }), c = n && Object.entries(n).reduce((l, u) => {
+    let [d, m] = u;
+    return m === void 0 || (l[d] = m), l;
+  }, {}), a = t == null || (o = t.compoundVariants) === null || o === void 0 ? void 0 : o.reduce((l, u) => {
+    let { class: d, className: m, ...p } = u;
+    return Object.entries(p).every((h) => {
+      let [g, v] = h;
+      return Array.isArray(v) ? v.includes({
+        ...i,
+        ...c
+      }[g]) : {
+        ...i,
+        ...c
+      }[g] === v;
+    }) ? [
+      ...l,
+      d,
+      m
+    ] : l;
+  }, []);
+  return rt(e, s, a, n == null ? void 0 : n.class, n == null ? void 0 : n.className);
+};
+function it(e, t) {
+  if (typeof e == "function")
+    return e(t);
+  e != null && (e.current = t);
+}
+function Fe(...e) {
+  return (t) => {
+    let n = !1;
+    const o = e.map((r) => {
+      const i = it(r, t);
+      return !n && typeof i == "function" && (n = !0), i;
+    });
+    if (n)
+      return () => {
+        for (let r = 0; r < o.length; r++) {
+          const i = o[r];
+          typeof i == "function" ? i() : it(e[r], null);
+        }
+      };
+  };
+}
+function te(...e) {
+  return f.useCallback(Fe(...e), e);
+}
+function Zr(e, t) {
+  const n = f.createContext(t), o = (i) => {
+    const { children: s, ...c } = i, a = f.useMemo(() => c, Object.values(c));
+    return /* @__PURE__ */ P(n.Provider, { value: a, children: s });
+  };
+  o.displayName = e + "Provider";
+  function r(i) {
+    const s = f.useContext(n);
+    if (s) return s;
+    if (t !== void 0) return t;
+    throw new Error(`\`${i}\` must be used within \`${e}\``);
+  }
+  return [o, r];
+}
+function bt(e, t = []) {
+  let n = [];
+  function o(i, s) {
+    const c = f.createContext(s), a = n.length;
+    n = [...n, s];
+    const l = (d) => {
+      var y;
+      const { scope: m, children: p, ...h } = d, g = ((y = m == null ? void 0 : m[e]) == null ? void 0 : y[a]) || c, v = f.useMemo(() => h, Object.values(h));
+      return /* @__PURE__ */ P(g.Provider, { value: v, children: p });
+    };
+    l.displayName = i + "Provider";
+    function u(d, m) {
+      var g;
+      const p = ((g = m == null ? void 0 : m[e]) == null ? void 0 : g[a]) || c, h = f.useContext(p);
+      if (h) return h;
+      if (s !== void 0) return s;
+      throw new Error(`\`${d}\` must be used within \`${i}\``);
+    }
+    return [l, u];
+  }
+  const r = () => {
+    const i = n.map((s) => f.createContext(s));
+    return function(c) {
+      const a = (c == null ? void 0 : c[e]) || i;
+      return f.useMemo(
+        () => ({ [`__scope${e}`]: { ...c, [e]: a } }),
+        [c, a]
+      );
+    };
+  };
+  return r.scopeName = e, [o, xn(r, ...t)];
+}
+function xn(...e) {
+  const t = e[0];
+  if (e.length === 1) return t;
+  const n = () => {
+    const o = e.map((r) => ({
+      useScope: r(),
+      scopeName: r.scopeName
+    }));
+    return function(i) {
+      const s = o.reduce((c, { useScope: a, scopeName: l }) => {
+        const d = a(i)[`__scope${l}`];
+        return { ...c, ...d };
+      }, {});
+      return f.useMemo(() => ({ [`__scope${t.scopeName}`]: s }), [s]);
+    };
+  };
+  return n.scopeName = t.scopeName, n;
+}
+function Y(e, t, { checkForDefaultPrevented: n = !0 } = {}) {
+  return function(r) {
+    if (e == null || e(r), n === !1 || !r.defaultPrevented)
+      return t == null ? void 0 : t(r);
+  };
+}
+var Q = globalThis != null && globalThis.document ? f.useLayoutEffect : () => {
+}, bn = f[" useInsertionEffect ".trim().toString()] || Q;
+function Cn({
+  prop: e,
+  defaultProp: t,
+  onChange: n = () => {
+  },
+  caller: o
+}) {
+  const [r, i, s] = En({
+    defaultProp: t,
+    onChange: n
+  }), c = e !== void 0, a = c ? e : r;
+  {
+    const u = f.useRef(e !== void 0);
+    f.useEffect(() => {
+      const d = u.current;
+      d !== c && console.warn(
+        `${o} is changing from ${d ? "controlled" : "uncontrolled"} to ${c ? "controlled" : "uncontrolled"}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+      ), u.current = c;
+    }, [c, o]);
+  }
+  const l = f.useCallback(
+    (u) => {
+      var d;
+      if (c) {
+        const m = Rn(u) ? u(e) : u;
+        m !== e && ((d = s.current) == null || d.call(s, m));
+      } else
+        i(u);
+    },
+    [c, e, i, s]
+  );
+  return [a, l];
+}
+function En({
+  defaultProp: e,
+  onChange: t
+}) {
+  const [n, o] = f.useState(e), r = f.useRef(n), i = f.useRef(t);
+  return bn(() => {
+    i.current = t;
+  }, [t]), f.useEffect(() => {
+    var s;
+    r.current !== n && ((s = i.current) == null || s.call(i, n), r.current = n);
+  }, [n, r]), [n, o, i];
+}
+function Rn(e) {
+  return typeof e == "function";
+}
+function Pn(e) {
+  const [t, n] = f.useState(void 0);
+  return Q(() => {
+    if (e) {
+      n({ width: e.offsetWidth, height: e.offsetHeight });
+      const o = new ResizeObserver((r) => {
+        if (!Array.isArray(r) || !r.length)
+          return;
+        const i = r[0];
+        let s, c;
+        if ("borderBoxSize" in i) {
+          const a = i.borderBoxSize, l = Array.isArray(a) ? a[0] : a;
+          s = l.inlineSize, c = l.blockSize;
+        } else
+          s = e.offsetWidth, c = e.offsetHeight;
+        n({ width: s, height: c });
+      });
+      return o.observe(e, { box: "border-box" }), () => o.unobserve(e);
+    } else
+      n(void 0);
+  }, [e]), t;
+}
+function An(e, t) {
+  return f.useReducer((n, o) => t[n][o] ?? n, e);
+}
+var Ct = (e) => {
+  const { present: t, children: n } = e, o = On(t), r = typeof n == "function" ? n({ present: o.isPresent }) : f.Children.only(n), i = te(o.ref, Sn(r));
+  return typeof n == "function" || o.isPresent ? f.cloneElement(r, { ref: i }) : null;
+};
+Ct.displayName = "Presence";
+function On(e) {
+  const [t, n] = f.useState(), o = f.useRef(null), r = f.useRef(e), i = f.useRef("none"), s = e ? "mounted" : "unmounted", [c, a] = An(s, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: {
+      MOUNT: "mounted"
+    }
+  });
+  return f.useEffect(() => {
+    const l = me(o.current);
+    i.current = c === "mounted" ? l : "none";
+  }, [c]), Q(() => {
+    const l = o.current, u = r.current;
+    if (u !== e) {
+      const m = i.current, p = me(l);
+      e ? a("MOUNT") : p === "none" || (l == null ? void 0 : l.display) === "none" ? a("UNMOUNT") : a(u && m !== p ? "ANIMATION_OUT" : "UNMOUNT"), r.current = e;
+    }
+  }, [e, a]), Q(() => {
+    if (t) {
+      let l;
+      const u = t.ownerDocument.defaultView ?? window, d = (p) => {
+        const g = me(o.current).includes(CSS.escape(p.animationName));
+        if (p.target === t && g && (a("ANIMATION_END"), !r.current)) {
+          const v = t.style.animationFillMode;
+          t.style.animationFillMode = "forwards", l = u.setTimeout(() => {
+            t.style.animationFillMode === "forwards" && (t.style.animationFillMode = v);
+          });
+        }
+      }, m = (p) => {
+        p.target === t && (i.current = me(o.current));
+      };
+      return t.addEventListener("animationstart", m), t.addEventListener("animationcancel", d), t.addEventListener("animationend", d), () => {
+        u.clearTimeout(l), t.removeEventListener("animationstart", m), t.removeEventListener("animationcancel", d), t.removeEventListener("animationend", d);
+      };
+    } else
+      a("ANIMATION_END");
+  }, [t, a]), {
+    isPresent: ["mounted", "unmountSuspended"].includes(c),
+    ref: f.useCallback((l) => {
+      o.current = l ? getComputedStyle(l) : null, n(l);
+    }, [])
+  };
+}
+function me(e) {
+  return (e == null ? void 0 : e.animationName) || "none";
+}
+function Sn(e) {
+  var o, r;
+  let t = (o = Object.getOwnPropertyDescriptor(e.props, "ref")) == null ? void 0 : o.get, n = t && "isReactWarning" in t && t.isReactWarning;
+  return n ? e.ref : (t = (r = Object.getOwnPropertyDescriptor(e, "ref")) == null ? void 0 : r.get, n = t && "isReactWarning" in t && t.isReactWarning, n ? e.props.ref : e.props.ref || e.ref);
+}
+// @__NO_SIDE_EFFECTS__
+function Tn(e) {
+  const t = /* @__PURE__ */ Dn(e), n = f.forwardRef((o, r) => {
+    const { children: i, ...s } = o, c = f.Children.toArray(i), a = c.find(Nn);
+    if (a) {
+      const l = a.props.children, u = c.map((d) => d === a ? f.Children.count(l) > 1 ? f.Children.only(null) : f.isValidElement(l) ? l.props.children : null : d);
+      return /* @__PURE__ */ P(t, { ...s, ref: r, children: f.isValidElement(l) ? f.cloneElement(l, void 0, u) : null });
+    }
+    return /* @__PURE__ */ P(t, { ...s, ref: r, children: i });
+  });
+  return n.displayName = `${e}.Slot`, n;
+}
+// @__NO_SIDE_EFFECTS__
+function Dn(e) {
+  const t = f.forwardRef((n, o) => {
+    const { children: r, ...i } = n;
+    if (f.isValidElement(r)) {
+      const s = Mn(r), c = _n(i, r.props);
+      return r.type !== f.Fragment && (c.ref = o ? Fe(o, s) : s), f.cloneElement(r, c);
+    }
+    return f.Children.count(r) > 1 ? f.Children.only(null) : null;
+  });
+  return t.displayName = `${e}.SlotClone`, t;
+}
+var Ln = Symbol("radix.slottable");
+function Nn(e) {
+  return f.isValidElement(e) && typeof e.type == "function" && "__radixId" in e.type && e.type.__radixId === Ln;
+}
+function _n(e, t) {
+  const n = { ...t };
+  for (const o in t) {
+    const r = e[o], i = t[o];
+    /^on[A-Z]/.test(o) ? r && i ? n[o] = (...c) => {
+      const a = i(...c);
+      return r(...c), a;
+    } : r && (n[o] = r) : o === "style" ? n[o] = { ...r, ...i } : o === "className" && (n[o] = [r, i].filter(Boolean).join(" "));
+  }
+  return { ...e, ...n };
+}
+function Mn(e) {
+  var o, r;
+  let t = (o = Object.getOwnPropertyDescriptor(e.props, "ref")) == null ? void 0 : o.get, n = t && "isReactWarning" in t && t.isReactWarning;
+  return n ? e.ref : (t = (r = Object.getOwnPropertyDescriptor(e, "ref")) == null ? void 0 : r.get, n = t && "isReactWarning" in t && t.isReactWarning, n ? e.props.ref : e.props.ref || e.ref);
+}
+var $n = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+], ne = $n.reduce((e, t) => {
+  const n = /* @__PURE__ */ Tn(`Primitive.${t}`), o = f.forwardRef((r, i) => {
+    const { asChild: s, ...c } = r, a = s ? n : t;
+    return typeof window < "u" && (window[Symbol.for("radix-ui")] = !0), /* @__PURE__ */ P(a, { ...c, ref: i });
+  });
+  return o.displayName = `Primitive.${t}`, { ...e, [t]: o };
+}, {});
+function kn(e, t) {
+  e && xt.flushSync(() => e.dispatchEvent(t));
+}
+/**
+ * @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 In = [["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]], Jr = mn("chevron-down", In);
+var Wn = Symbol.for("react.lazy"), ve = f[" use ".trim().toString()];
+function Fn(e) {
+  return typeof e == "object" && e !== null && "then" in e;
+}
+function Et(e) {
+  return e != null && typeof e == "object" && "$$typeof" in e && e.$$typeof === Wn && "_payload" in e && Fn(e._payload);
+}
+// @__NO_SIDE_EFFECTS__
+function Bn(e) {
+  const t = /* @__PURE__ */ Vn(e), n = f.forwardRef((o, r) => {
+    let { children: i, ...s } = o;
+    Et(i) && typeof ve == "function" && (i = ve(i._payload));
+    const c = f.Children.toArray(i), a = c.find(jn);
+    if (a) {
+      const l = a.props.children, u = c.map((d) => d === a ? f.Children.count(l) > 1 ? f.Children.only(null) : f.isValidElement(l) ? l.props.children : null : d);
+      return /* @__PURE__ */ P(t, { ...s, ref: r, children: f.isValidElement(l) ? f.cloneElement(l, void 0, u) : null });
+    }
+    return /* @__PURE__ */ P(t, { ...s, ref: r, children: i });
+  });
+  return n.displayName = `${e}.Slot`, n;
+}
+var Hn = /* @__PURE__ */ Bn("Slot");
+// @__NO_SIDE_EFFECTS__
+function Vn(e) {
+  const t = f.forwardRef((n, o) => {
+    let { children: r, ...i } = n;
+    if (Et(r) && typeof ve == "function" && (r = ve(r._payload)), f.isValidElement(r)) {
+      const s = Yn(r), c = Un(i, r.props);
+      return r.type !== f.Fragment && (c.ref = o ? Fe(o, s) : s), f.cloneElement(r, c);
+    }
+    return f.Children.count(r) > 1 ? f.Children.only(null) : null;
+  });
+  return t.displayName = `${e}.SlotClone`, t;
+}
+var zn = Symbol("radix.slottable");
+function jn(e) {
+  return f.isValidElement(e) && typeof e.type == "function" && "__radixId" in e.type && e.type.__radixId === zn;
+}
+function Un(e, t) {
+  const n = { ...t };
+  for (const o in t) {
+    const r = e[o], i = t[o];
+    /^on[A-Z]/.test(o) ? r && i ? n[o] = (...c) => {
+      const a = i(...c);
+      return r(...c), a;
+    } : r && (n[o] = r) : o === "style" ? n[o] = { ...r, ...i } : o === "className" && (n[o] = [r, i].filter(Boolean).join(" "));
+  }
+  return { ...e, ...n };
+}
+function Yn(e) {
+  var o, r;
+  let t = (o = Object.getOwnPropertyDescriptor(e.props, "ref")) == null ? void 0 : o.get, n = t && "isReactWarning" in t && t.isReactWarning;
+  return n ? e.ref : (t = (r = Object.getOwnPropertyDescriptor(e, "ref")) == null ? void 0 : r.get, n = t && "isReactWarning" in t && t.isReactWarning, n ? e.props.ref : e.props.ref || e.ref);
+}
+const Xn = wn(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline",
+        styled: "bg-gradient-to-r from-slate-900 to-purple-700 hover:from-slate-800 hover:to-purple-600 text-white shadow-lg shadow-purple-500/25 px-6 h-12"
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 rounded-md px-8",
+        icon: "h-10 w-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+), qn = f.forwardRef(({ className: e, variant: t, size: n, asChild: o = !1, ...r }, i) => /* @__PURE__ */ P(o ? Hn : "button", { className: wt(Xn({ variant: t, size: n, className: e })), ref: i, ...r }));
+qn.displayName = "Button";
+function Ce(e) {
+  const t = f.useRef(e);
+  return f.useEffect(() => {
+    t.current = e;
+  }), f.useMemo(() => (...n) => {
+    var o;
+    return (o = t.current) == null ? void 0 : o.call(t, ...n);
+  }, []);
+}
+function Gn(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = Ce(e);
+  f.useEffect(() => {
+    const o = (r) => {
+      r.key === "Escape" && n(r);
+    };
+    return t.addEventListener("keydown", o, { capture: !0 }), () => t.removeEventListener("keydown", o, { capture: !0 });
+  }, [n, t]);
+}
+var Kn = "DismissableLayer", _e = "dismissableLayer.update", Zn = "dismissableLayer.pointerDownOutside", Jn = "dismissableLayer.focusOutside", st, Rt = f.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), Be = f.forwardRef(
+  (e, t) => {
+    const {
+      disableOutsidePointerEvents: n = !1,
+      onEscapeKeyDown: o,
+      onPointerDownOutside: r,
+      onFocusOutside: i,
+      onInteractOutside: s,
+      onDismiss: c,
+      ...a
+    } = e, l = f.useContext(Rt), [u, d] = f.useState(null), m = (u == null ? void 0 : u.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document), [, p] = f.useState({}), h = te(t, (C) => d(C)), g = Array.from(l.layers), [v] = [...l.layersWithOutsidePointerEventsDisabled].slice(-1), y = g.indexOf(v), w = u ? g.indexOf(u) : -1, b = l.layersWithOutsidePointerEventsDisabled.size > 0, x = w >= y, R = eo((C) => {
+      const O = C.target, _ = [...l.branches].some((S) => S.contains(O));
+      !x || _ || (r == null || r(C), s == null || s(C), C.defaultPrevented || c == null || c());
+    }, m), E = to((C) => {
+      const O = C.target;
+      [...l.branches].some((S) => S.contains(O)) || (i == null || i(C), s == null || s(C), C.defaultPrevented || c == null || c());
+    }, m);
+    return Gn((C) => {
+      w === l.layers.size - 1 && (o == null || o(C), !C.defaultPrevented && c && (C.preventDefault(), c()));
+    }, m), f.useEffect(() => {
+      if (u)
+        return n && (l.layersWithOutsidePointerEventsDisabled.size === 0 && (st = m.body.style.pointerEvents, m.body.style.pointerEvents = "none"), l.layersWithOutsidePointerEventsDisabled.add(u)), l.layers.add(u), ct(), () => {
+          n && l.layersWithOutsidePointerEventsDisabled.size === 1 && (m.body.style.pointerEvents = st);
+        };
+    }, [u, m, n, l]), f.useEffect(() => () => {
+      u && (l.layers.delete(u), l.layersWithOutsidePointerEventsDisabled.delete(u), ct());
+    }, [u, l]), f.useEffect(() => {
+      const C = () => p({});
+      return document.addEventListener(_e, C), () => document.removeEventListener(_e, C);
+    }, []), /* @__PURE__ */ P(
+      ne.div,
+      {
+        ...a,
+        ref: h,
+        style: {
+          pointerEvents: b ? x ? "auto" : "none" : void 0,
+          ...e.style
+        },
+        onFocusCapture: Y(e.onFocusCapture, E.onFocusCapture),
+        onBlurCapture: Y(e.onBlurCapture, E.onBlurCapture),
+        onPointerDownCapture: Y(
+          e.onPointerDownCapture,
+          R.onPointerDownCapture
+        )
+      }
+    );
+  }
+);
+Be.displayName = Kn;
+var Qn = "DismissableLayerBranch", Pt = f.forwardRef((e, t) => {
+  const n = f.useContext(Rt), o = f.useRef(null), r = te(t, o);
+  return f.useEffect(() => {
+    const i = o.current;
+    if (i)
+      return n.branches.add(i), () => {
+        n.branches.delete(i);
+      };
+  }, [n.branches]), /* @__PURE__ */ P(ne.div, { ...e, ref: r });
+});
+Pt.displayName = Qn;
+function eo(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = Ce(e), o = f.useRef(!1), r = f.useRef(() => {
+  });
+  return f.useEffect(() => {
+    const i = (c) => {
+      if (c.target && !o.current) {
+        let a = function() {
+          At(
+            Zn,
+            n,
+            l,
+            { discrete: !0 }
+          );
+        };
+        const l = { originalEvent: c };
+        c.pointerType === "touch" ? (t.removeEventListener("click", r.current), r.current = a, t.addEventListener("click", r.current, { once: !0 })) : a();
+      } else
+        t.removeEventListener("click", r.current);
+      o.current = !1;
+    }, s = window.setTimeout(() => {
+      t.addEventListener("pointerdown", i);
+    }, 0);
+    return () => {
+      window.clearTimeout(s), t.removeEventListener("pointerdown", i), t.removeEventListener("click", r.current);
+    };
+  }, [t, n]), {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => o.current = !0
+  };
+}
+function to(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = Ce(e), o = f.useRef(!1);
+  return f.useEffect(() => {
+    const r = (i) => {
+      i.target && !o.current && At(Jn, n, { originalEvent: i }, {
+        discrete: !1
+      });
+    };
+    return t.addEventListener("focusin", r), () => t.removeEventListener("focusin", r);
+  }, [t, n]), {
+    onFocusCapture: () => o.current = !0,
+    onBlurCapture: () => o.current = !1
+  };
+}
+function ct() {
+  const e = new CustomEvent(_e);
+  document.dispatchEvent(e);
+}
+function At(e, t, n, { discrete: o }) {
+  const r = n.originalEvent.target, i = new CustomEvent(e, { bubbles: !1, cancelable: !0, detail: n });
+  t && r.addEventListener(e, t, { once: !0 }), o ? kn(r, i) : r.dispatchEvent(i);
+}
+var Qr = Be, ei = Pt, no = 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"
+}), oo = "VisuallyHidden", Ot = f.forwardRef(
+  (e, t) => /* @__PURE__ */ P(
+    ne.span,
+    {
+      ...e,
+      ref: t,
+      style: { ...no, ...e.style }
+    }
+  )
+);
+Ot.displayName = oo;
+var ro = Ot, io = f[" useId ".trim().toString()] || (() => {
+}), so = 0;
+function co(e) {
+  const [t, n] = f.useState(io());
+  return Q(() => {
+    n((o) => o ?? String(so++));
+  }, [e]), t ? `radix-${t}` : "";
+}
+const ao = ["top", "right", "bottom", "left"], K = Math.min, W = Math.max, ye = Math.round, he = Math.floor, j = (e) => ({
+  x: e,
+  y: e
+}), lo = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function Me(e, t, n) {
+  return W(e, K(t, n));
+}
+function X(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function q(e) {
+  return e.split("-")[0];
+}
+function se(e) {
+  return e.split("-")[1];
+}
+function He(e) {
+  return e === "x" ? "y" : "x";
+}
+function Ve(e) {
+  return e === "y" ? "height" : "width";
+}
+function z(e) {
+  const t = e[0];
+  return t === "t" || t === "b" ? "y" : "x";
+}
+function ze(e) {
+  return He(z(e));
+}
+function uo(e, t, n) {
+  n === void 0 && (n = !1);
+  const o = se(e), r = ze(e), i = Ve(r);
+  let s = r === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = we(s)), [s, we(s)];
+}
+function fo(e) {
+  const t = we(e);
+  return [$e(e), t, $e(t)];
+}
+function $e(e) {
+  return e.includes("start") ? e.replace("start", "end") : e.replace("end", "start");
+}
+const at = ["left", "right"], lt = ["right", "left"], po = ["top", "bottom"], mo = ["bottom", "top"];
+function ho(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? lt : at : t ? at : lt;
+    case "left":
+    case "right":
+      return t ? po : mo;
+    default:
+      return [];
+  }
+}
+function go(e, t, n, o) {
+  const r = se(e);
+  let i = ho(q(e), n === "start", o);
+  return r && (i = i.map((s) => s + "-" + r), t && (i = i.concat(i.map($e)))), i;
+}
+function we(e) {
+  const t = q(e);
+  return lo[t] + e.slice(t.length);
+}
+function vo(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function St(e) {
+  return typeof e != "number" ? vo(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function xe(e) {
+  const {
+    x: t,
+    y: n,
+    width: o,
+    height: r
+  } = e;
+  return {
+    width: o,
+    height: r,
+    top: n,
+    left: t,
+    right: t + o,
+    bottom: n + r,
+    x: t,
+    y: n
+  };
+}
+function ut(e, t, n) {
+  let {
+    reference: o,
+    floating: r
+  } = e;
+  const i = z(t), s = ze(t), c = Ve(s), a = q(t), l = i === "y", u = o.x + o.width / 2 - r.width / 2, d = o.y + o.height / 2 - r.height / 2, m = o[c] / 2 - r[c] / 2;
+  let p;
+  switch (a) {
+    case "top":
+      p = {
+        x: u,
+        y: o.y - r.height
+      };
+      break;
+    case "bottom":
+      p = {
+        x: u,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      p = {
+        x: o.x + o.width,
+        y: d
+      };
+      break;
+    case "left":
+      p = {
+        x: o.x - r.width,
+        y: d
+      };
+      break;
+    default:
+      p = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (se(t)) {
+    case "start":
+      p[s] -= m * (n && l ? -1 : 1);
+      break;
+    case "end":
+      p[s] += m * (n && l ? -1 : 1);
+      break;
+  }
+  return p;
+}
+async function yo(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: o,
+    y: r,
+    platform: i,
+    rects: s,
+    elements: c,
+    strategy: a
+  } = e, {
+    boundary: l = "clippingAncestors",
+    rootBoundary: u = "viewport",
+    elementContext: d = "floating",
+    altBoundary: m = !1,
+    padding: p = 0
+  } = X(t, e), h = St(p), v = c[m ? d === "floating" ? "reference" : "floating" : d], y = xe(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(c.floating)),
+    boundary: l,
+    rootBoundary: u,
+    strategy: a
+  })), w = d === "floating" ? {
+    x: o,
+    y: r,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, b = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(c.floating)), x = await (i.isElement == null ? void 0 : i.isElement(b)) ? await (i.getScale == null ? void 0 : i.getScale(b)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, R = xe(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: w,
+    offsetParent: b,
+    strategy: a
+  }) : w);
+  return {
+    top: (y.top - R.top + h.top) / x.y,
+    bottom: (R.bottom - y.bottom + h.bottom) / x.y,
+    left: (y.left - R.left + h.left) / x.x,
+    right: (R.right - y.right + h.right) / x.x
+  };
+}
+const wo = 50, xo = async (e, t, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: r = "absolute",
+    middleware: i = [],
+    platform: s
+  } = n, c = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: yo
+  }, a = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let l = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: r
+  }), {
+    x: u,
+    y: d
+  } = ut(l, o, a), m = o, p = 0;
+  const h = {};
+  for (let g = 0; g < i.length; g++) {
+    const v = i[g];
+    if (!v)
+      continue;
+    const {
+      name: y,
+      fn: w
+    } = v, {
+      x: b,
+      y: x,
+      data: R,
+      reset: E
+    } = await w({
+      x: u,
+      y: d,
+      initialPlacement: o,
+      placement: m,
+      strategy: r,
+      middlewareData: h,
+      rects: l,
+      platform: c,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    u = b ?? u, d = x ?? d, h[y] = {
+      ...h[y],
+      ...R
+    }, E && p < wo && (p++, typeof E == "object" && (E.placement && (m = E.placement), E.rects && (l = E.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: r
+    }) : E.rects), {
+      x: u,
+      y: d
+    } = ut(l, m, a)), g = -1);
+  }
+  return {
+    x: u,
+    y: d,
+    placement: m,
+    strategy: r,
+    middlewareData: h
+  };
+}, bo = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: o,
+      placement: r,
+      rects: i,
+      platform: s,
+      elements: c,
+      middlewareData: a
+    } = t, {
+      element: l,
+      padding: u = 0
+    } = X(e, t) || {};
+    if (l == null)
+      return {};
+    const d = St(u), m = {
+      x: n,
+      y: o
+    }, p = ze(r), h = Ve(p), g = await s.getDimensions(l), v = p === "y", y = v ? "top" : "left", w = v ? "bottom" : "right", b = v ? "clientHeight" : "clientWidth", x = i.reference[h] + i.reference[p] - m[p] - i.floating[h], R = m[p] - i.reference[p], E = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(l));
+    let C = E ? E[b] : 0;
+    (!C || !await (s.isElement == null ? void 0 : s.isElement(E))) && (C = c.floating[b] || i.floating[h]);
+    const O = x / 2 - R / 2, _ = C / 2 - g[h] / 2 - 1, S = K(d[y], _), $ = K(d[w], _), k = S, D = C - g[h] - $, T = C / 2 - g[h] / 2 + O, I = Me(k, T, D), L = !a.arrow && se(r) != null && T !== I && i.reference[h] / 2 - (T < k ? S : $) - g[h] / 2 < 0, N = L ? T < k ? T - k : T - D : 0;
+    return {
+      [p]: m[p] + N,
+      data: {
+        [p]: I,
+        centerOffset: T - I - N,
+        ...L && {
+          alignmentOffset: N
+        }
+      },
+      reset: L
+    };
+  }
+}), Co = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        placement: r,
+        middlewareData: i,
+        rects: s,
+        initialPlacement: c,
+        platform: a,
+        elements: l
+      } = t, {
+        mainAxis: u = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: p = "bestFit",
+        fallbackAxisSideDirection: h = "none",
+        flipAlignment: g = !0,
+        ...v
+      } = X(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const y = q(r), w = z(c), b = q(c) === c, x = await (a.isRTL == null ? void 0 : a.isRTL(l.floating)), R = m || (b || !g ? [we(c)] : fo(c)), E = h !== "none";
+      !m && E && R.push(...go(c, g, h, x));
+      const C = [c, ...R], O = await a.detectOverflow(t, v), _ = [];
+      let S = ((o = i.flip) == null ? void 0 : o.overflows) || [];
+      if (u && _.push(O[y]), d) {
+        const T = uo(r, s, x);
+        _.push(O[T[0]], O[T[1]]);
+      }
+      if (S = [...S, {
+        placement: r,
+        overflows: _
+      }], !_.every((T) => T <= 0)) {
+        var $, k;
+        const T = ((($ = i.flip) == null ? void 0 : $.index) || 0) + 1, I = C[T];
+        if (I && (!(d === "alignment" ? w !== z(I) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        S.every((A) => z(A.placement) === w ? A.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: T,
+              overflows: S
+            },
+            reset: {
+              placement: I
+            }
+          };
+        let L = (k = S.filter((N) => N.overflows[0] <= 0).sort((N, A) => N.overflows[1] - A.overflows[1])[0]) == null ? void 0 : k.placement;
+        if (!L)
+          switch (p) {
+            case "bestFit": {
+              var D;
+              const N = (D = S.filter((A) => {
+                if (E) {
+                  const M = z(A.placement);
+                  return M === w || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  M === "y";
+                }
+                return !0;
+              }).map((A) => [A.placement, A.overflows.filter((M) => M > 0).reduce((M, V) => M + V, 0)]).sort((A, M) => A[1] - M[1])[0]) == null ? void 0 : D[0];
+              N && (L = N);
+              break;
+            }
+            case "initialPlacement":
+              L = c;
+              break;
+          }
+        if (r !== L)
+          return {
+            reset: {
+              placement: L
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function ft(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function dt(e) {
+  return ao.some((t) => e[t] >= 0);
+}
+const Eo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: n,
+        platform: o
+      } = t, {
+        strategy: r = "referenceHidden",
+        ...i
+      } = X(e, t);
+      switch (r) {
+        case "referenceHidden": {
+          const s = await o.detectOverflow(t, {
+            ...i,
+            elementContext: "reference"
+          }), c = ft(s, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: c,
+              referenceHidden: dt(c)
+            }
+          };
+        }
+        case "escaped": {
+          const s = await o.detectOverflow(t, {
+            ...i,
+            altBoundary: !0
+          }), c = ft(s, n.floating);
+          return {
+            data: {
+              escapedOffsets: c,
+              escaped: dt(c)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, Tt = /* @__PURE__ */ new Set(["left", "top"]);
+async function Ro(e, t) {
+  const {
+    placement: n,
+    platform: o,
+    elements: r
+  } = e, i = await (o.isRTL == null ? void 0 : o.isRTL(r.floating)), s = q(n), c = se(n), a = z(n) === "y", l = Tt.has(s) ? -1 : 1, u = i && a ? -1 : 1, d = X(t, e);
+  let {
+    mainAxis: m,
+    crossAxis: p,
+    alignmentAxis: h
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: d.mainAxis || 0,
+    crossAxis: d.crossAxis || 0,
+    alignmentAxis: d.alignmentAxis
+  };
+  return c && typeof h == "number" && (p = c === "end" ? h * -1 : h), a ? {
+    x: p * u,
+    y: m * l
+  } : {
+    x: m * l,
+    y: p * u
+  };
+}
+const Po = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        x: r,
+        y: i,
+        placement: s,
+        middlewareData: c
+      } = t, a = await Ro(t, e);
+      return s === ((n = c.offset) == null ? void 0 : n.placement) && (o = c.arrow) != null && o.alignmentOffset ? {} : {
+        x: r + a.x,
+        y: i + a.y,
+        data: {
+          ...a,
+          placement: s
+        }
+      };
+    }
+  };
+}, Ao = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: o,
+        placement: r,
+        platform: i
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: c = !1,
+        limiter: a = {
+          fn: (y) => {
+            let {
+              x: w,
+              y: b
+            } = y;
+            return {
+              x: w,
+              y: b
+            };
+          }
+        },
+        ...l
+      } = X(e, t), u = {
+        x: n,
+        y: o
+      }, d = await i.detectOverflow(t, l), m = z(q(r)), p = He(m);
+      let h = u[p], g = u[m];
+      if (s) {
+        const y = p === "y" ? "top" : "left", w = p === "y" ? "bottom" : "right", b = h + d[y], x = h - d[w];
+        h = Me(b, h, x);
+      }
+      if (c) {
+        const y = m === "y" ? "top" : "left", w = m === "y" ? "bottom" : "right", b = g + d[y], x = g - d[w];
+        g = Me(b, g, x);
+      }
+      const v = a.fn({
+        ...t,
+        [p]: h,
+        [m]: g
+      });
+      return {
+        ...v,
+        data: {
+          x: v.x - n,
+          y: v.y - o,
+          enabled: {
+            [p]: s,
+            [m]: c
+          }
+        }
+      };
+    }
+  };
+}, Oo = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const {
+        x: n,
+        y: o,
+        placement: r,
+        rects: i,
+        middlewareData: s
+      } = t, {
+        offset: c = 0,
+        mainAxis: a = !0,
+        crossAxis: l = !0
+      } = X(e, t), u = {
+        x: n,
+        y: o
+      }, d = z(r), m = He(d);
+      let p = u[m], h = u[d];
+      const g = X(c, t), v = typeof g == "number" ? {
+        mainAxis: g,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...g
+      };
+      if (a) {
+        const b = m === "y" ? "height" : "width", x = i.reference[m] - i.floating[b] + v.mainAxis, R = i.reference[m] + i.reference[b] - v.mainAxis;
+        p < x ? p = x : p > R && (p = R);
+      }
+      if (l) {
+        var y, w;
+        const b = m === "y" ? "width" : "height", x = Tt.has(q(r)), R = i.reference[d] - i.floating[b] + (x && ((y = s.offset) == null ? void 0 : y[d]) || 0) + (x ? 0 : v.crossAxis), E = i.reference[d] + i.reference[b] + (x ? 0 : ((w = s.offset) == null ? void 0 : w[d]) || 0) - (x ? v.crossAxis : 0);
+        h < R ? h = R : h > E && (h = E);
+      }
+      return {
+        [m]: p,
+        [d]: h
+      };
+    }
+  };
+}, So = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        placement: r,
+        rects: i,
+        platform: s,
+        elements: c
+      } = t, {
+        apply: a = () => {
+        },
+        ...l
+      } = X(e, t), u = await s.detectOverflow(t, l), d = q(r), m = se(r), p = z(r) === "y", {
+        width: h,
+        height: g
+      } = i.floating;
+      let v, y;
+      d === "top" || d === "bottom" ? (v = d, y = m === (await (s.isRTL == null ? void 0 : s.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (y = d, v = m === "end" ? "top" : "bottom");
+      const w = g - u.top - u.bottom, b = h - u.left - u.right, x = K(g - u[v], w), R = K(h - u[y], b), E = !t.middlewareData.shift;
+      let C = x, O = R;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (O = b), (o = t.middlewareData.shift) != null && o.enabled.y && (C = w), E && !m) {
+        const S = W(u.left, 0), $ = W(u.right, 0), k = W(u.top, 0), D = W(u.bottom, 0);
+        p ? O = h - 2 * (S !== 0 || $ !== 0 ? S + $ : W(u.left, u.right)) : C = g - 2 * (k !== 0 || D !== 0 ? k + D : W(u.top, u.bottom));
+      }
+      await a({
+        ...t,
+        availableWidth: O,
+        availableHeight: C
+      });
+      const _ = await s.getDimensions(c.floating);
+      return h !== _.width || g !== _.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function Ee() {
+  return typeof window < "u";
+}
+function ce(e) {
+  return Dt(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function F(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function U(e) {
+  var t;
+  return (t = (Dt(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Dt(e) {
+  return Ee() ? e instanceof Node || e instanceof F(e).Node : !1;
+}
+function B(e) {
+  return Ee() ? e instanceof Element || e instanceof F(e).Element : !1;
+}
+function G(e) {
+  return Ee() ? e instanceof HTMLElement || e instanceof F(e).HTMLElement : !1;
+}
+function pt(e) {
+  return !Ee() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof F(e).ShadowRoot;
+}
+function fe(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: o,
+    display: r
+  } = H(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + o + n) && r !== "inline" && r !== "contents";
+}
+function To(e) {
+  return /^(table|td|th)$/.test(ce(e));
+}
+function Re(e) {
+  try {
+    if (e.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return e.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const Do = /transform|translate|scale|rotate|perspective|filter/, Lo = /paint|layout|strict|content/, J = (e) => !!e && e !== "none";
+let De;
+function je(e) {
+  const t = B(e) ? H(e) : e;
+  return J(t.transform) || J(t.translate) || J(t.scale) || J(t.rotate) || J(t.perspective) || !Ue() && (J(t.backdropFilter) || J(t.filter)) || Do.test(t.willChange || "") || Lo.test(t.contain || "");
+}
+function No(e) {
+  let t = Z(e);
+  for (; G(t) && !re(t); ) {
+    if (je(t))
+      return t;
+    if (Re(t))
+      return null;
+    t = Z(t);
+  }
+  return null;
+}
+function Ue() {
+  return De == null && (De = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), De;
+}
+function re(e) {
+  return /^(html|body|#document)$/.test(ce(e));
+}
+function H(e) {
+  return F(e).getComputedStyle(e);
+}
+function Pe(e) {
+  return B(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function Z(e) {
+  if (ce(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.
+    pt(e) && e.host || // Fallback.
+    U(e)
+  );
+  return pt(t) ? t.host : t;
+}
+function Lt(e) {
+  const t = Z(e);
+  return re(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : G(t) && fe(t) ? t : Lt(t);
+}
+function le(e, t, n) {
+  var o;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const r = Lt(e), i = r === ((o = e.ownerDocument) == null ? void 0 : o.body), s = F(r);
+  if (i) {
+    const c = ke(s);
+    return t.concat(s, s.visualViewport || [], fe(r) ? r : [], c && n ? le(c) : []);
+  } else
+    return t.concat(r, le(r, [], n));
+}
+function ke(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function Nt(e) {
+  const t = H(e);
+  let n = parseFloat(t.width) || 0, o = parseFloat(t.height) || 0;
+  const r = G(e), i = r ? e.offsetWidth : n, s = r ? e.offsetHeight : o, c = ye(n) !== i || ye(o) !== s;
+  return c && (n = i, o = s), {
+    width: n,
+    height: o,
+    $: c
+  };
+}
+function Ye(e) {
+  return B(e) ? e : e.contextElement;
+}
+function oe(e) {
+  const t = Ye(e);
+  if (!G(t))
+    return j(1);
+  const n = t.getBoundingClientRect(), {
+    width: o,
+    height: r,
+    $: i
+  } = Nt(t);
+  let s = (i ? ye(n.width) : n.width) / o, c = (i ? ye(n.height) : n.height) / r;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+const _o = /* @__PURE__ */ j(0);
+function _t(e) {
+  const t = F(e);
+  return !Ue() || !t.visualViewport ? _o : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Mo(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== F(e) ? !1 : t;
+}
+function ee(e, t, n, o) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const r = e.getBoundingClientRect(), i = Ye(e);
+  let s = j(1);
+  t && (o ? B(o) && (s = oe(o)) : s = oe(e));
+  const c = Mo(i, n, o) ? _t(i) : j(0);
+  let a = (r.left + c.x) / s.x, l = (r.top + c.y) / s.y, u = r.width / s.x, d = r.height / s.y;
+  if (i) {
+    const m = F(i), p = o && B(o) ? F(o) : o;
+    let h = m, g = ke(h);
+    for (; g && o && p !== h; ) {
+      const v = oe(g), y = g.getBoundingClientRect(), w = H(g), b = y.left + (g.clientLeft + parseFloat(w.paddingLeft)) * v.x, x = y.top + (g.clientTop + parseFloat(w.paddingTop)) * v.y;
+      a *= v.x, l *= v.y, u *= v.x, d *= v.y, a += b, l += x, h = F(g), g = ke(h);
+    }
+  }
+  return xe({
+    width: u,
+    height: d,
+    x: a,
+    y: l
+  });
+}
+function Ae(e, t) {
+  const n = Pe(e).scrollLeft;
+  return t ? t.left + n : ee(U(e)).left + n;
+}
+function Mt(e, t) {
+  const n = e.getBoundingClientRect(), o = n.left + t.scrollLeft - Ae(e, n), r = n.top + t.scrollTop;
+  return {
+    x: o,
+    y: r
+  };
+}
+function $o(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: o,
+    strategy: r
+  } = e;
+  const i = r === "fixed", s = U(o), c = t ? Re(t.floating) : !1;
+  if (o === s || c && i)
+    return n;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, l = j(1);
+  const u = j(0), d = G(o);
+  if ((d || !d && !i) && ((ce(o) !== "body" || fe(s)) && (a = Pe(o)), d)) {
+    const p = ee(o);
+    l = oe(o), u.x = p.x + o.clientLeft, u.y = p.y + o.clientTop;
+  }
+  const m = s && !d && !i ? Mt(s, a) : j(0);
+  return {
+    width: n.width * l.x,
+    height: n.height * l.y,
+    x: n.x * l.x - a.scrollLeft * l.x + u.x + m.x,
+    y: n.y * l.y - a.scrollTop * l.y + u.y + m.y
+  };
+}
+function ko(e) {
+  return Array.from(e.getClientRects());
+}
+function Io(e) {
+  const t = U(e), n = Pe(e), o = e.ownerDocument.body, r = W(t.scrollWidth, t.clientWidth, o.scrollWidth, o.clientWidth), i = W(t.scrollHeight, t.clientHeight, o.scrollHeight, o.clientHeight);
+  let s = -n.scrollLeft + Ae(e);
+  const c = -n.scrollTop;
+  return H(o).direction === "rtl" && (s += W(t.clientWidth, o.clientWidth) - r), {
+    width: r,
+    height: i,
+    x: s,
+    y: c
+  };
+}
+const mt = 25;
+function Wo(e, t) {
+  const n = F(e), o = U(e), r = n.visualViewport;
+  let i = o.clientWidth, s = o.clientHeight, c = 0, a = 0;
+  if (r) {
+    i = r.width, s = r.height;
+    const u = Ue();
+    (!u || u && t === "fixed") && (c = r.offsetLeft, a = r.offsetTop);
+  }
+  const l = Ae(o);
+  if (l <= 0) {
+    const u = o.ownerDocument, d = u.body, m = getComputedStyle(d), p = u.compatMode === "CSS1Compat" && parseFloat(m.marginLeft) + parseFloat(m.marginRight) || 0, h = Math.abs(o.clientWidth - d.clientWidth - p);
+    h <= mt && (i -= h);
+  } else l <= mt && (i += l);
+  return {
+    width: i,
+    height: s,
+    x: c,
+    y: a
+  };
+}
+function Fo(e, t) {
+  const n = ee(e, !0, t === "fixed"), o = n.top + e.clientTop, r = n.left + e.clientLeft, i = G(e) ? oe(e) : j(1), s = e.clientWidth * i.x, c = e.clientHeight * i.y, a = r * i.x, l = o * i.y;
+  return {
+    width: s,
+    height: c,
+    x: a,
+    y: l
+  };
+}
+function ht(e, t, n) {
+  let o;
+  if (t === "viewport")
+    o = Wo(e, n);
+  else if (t === "document")
+    o = Io(U(e));
+  else if (B(t))
+    o = Fo(t, n);
+  else {
+    const r = _t(e);
+    o = {
+      x: t.x - r.x,
+      y: t.y - r.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return xe(o);
+}
+function $t(e, t) {
+  const n = Z(e);
+  return n === t || !B(n) || re(n) ? !1 : H(n).position === "fixed" || $t(n, t);
+}
+function Bo(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let o = le(e, [], !1).filter((c) => B(c) && ce(c) !== "body"), r = null;
+  const i = H(e).position === "fixed";
+  let s = i ? Z(e) : e;
+  for (; B(s) && !re(s); ) {
+    const c = H(s), a = je(s);
+    !a && c.position === "fixed" && (r = null), (i ? !a && !r : !a && c.position === "static" && !!r && (r.position === "absolute" || r.position === "fixed") || fe(s) && !a && $t(e, s)) ? o = o.filter((u) => u !== s) : r = c, s = Z(s);
+  }
+  return t.set(e, o), o;
+}
+function Ho(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: o,
+    strategy: r
+  } = e;
+  const s = [...n === "clippingAncestors" ? Re(t) ? [] : Bo(t, this._c) : [].concat(n), o], c = ht(t, s[0], r);
+  let a = c.top, l = c.right, u = c.bottom, d = c.left;
+  for (let m = 1; m < s.length; m++) {
+    const p = ht(t, s[m], r);
+    a = W(p.top, a), l = K(p.right, l), u = K(p.bottom, u), d = W(p.left, d);
+  }
+  return {
+    width: l - d,
+    height: u - a,
+    x: d,
+    y: a
+  };
+}
+function Vo(e) {
+  const {
+    width: t,
+    height: n
+  } = Nt(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function zo(e, t, n) {
+  const o = G(t), r = U(t), i = n === "fixed", s = ee(e, !0, i, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = j(0);
+  function l() {
+    a.x = Ae(r);
+  }
+  if (o || !o && !i)
+    if ((ce(t) !== "body" || fe(r)) && (c = Pe(t)), o) {
+      const p = ee(t, !0, i, t);
+      a.x = p.x + t.clientLeft, a.y = p.y + t.clientTop;
+    } else r && l();
+  i && !o && r && l();
+  const u = r && !o && !i ? Mt(r, c) : j(0), d = s.left + c.scrollLeft - a.x - u.x, m = s.top + c.scrollTop - a.y - u.y;
+  return {
+    x: d,
+    y: m,
+    width: s.width,
+    height: s.height
+  };
+}
+function Le(e) {
+  return H(e).position === "static";
+}
+function gt(e, t) {
+  if (!G(e) || H(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return U(e) === n && (n = n.ownerDocument.body), n;
+}
+function kt(e, t) {
+  const n = F(e);
+  if (Re(e))
+    return n;
+  if (!G(e)) {
+    let r = Z(e);
+    for (; r && !re(r); ) {
+      if (B(r) && !Le(r))
+        return r;
+      r = Z(r);
+    }
+    return n;
+  }
+  let o = gt(e, t);
+  for (; o && To(o) && Le(o); )
+    o = gt(o, t);
+  return o && re(o) && Le(o) && !je(o) ? n : o || No(e) || n;
+}
+const jo = async function(e) {
+  const t = this.getOffsetParent || kt, n = this.getDimensions, o = await n(e.floating);
+  return {
+    reference: zo(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function Uo(e) {
+  return H(e).direction === "rtl";
+}
+const Yo = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: $o,
+  getDocumentElement: U,
+  getClippingRect: Ho,
+  getOffsetParent: kt,
+  getElementRects: jo,
+  getClientRects: ko,
+  getDimensions: Vo,
+  getScale: oe,
+  isElement: B,
+  isRTL: Uo
+};
+function It(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Xo(e, t) {
+  let n = null, o;
+  const r = U(e);
+  function i() {
+    var c;
+    clearTimeout(o), (c = n) == null || c.disconnect(), n = null;
+  }
+  function s(c, a) {
+    c === void 0 && (c = !1), a === void 0 && (a = 1), i();
+    const l = e.getBoundingClientRect(), {
+      left: u,
+      top: d,
+      width: m,
+      height: p
+    } = l;
+    if (c || t(), !m || !p)
+      return;
+    const h = he(d), g = he(r.clientWidth - (u + m)), v = he(r.clientHeight - (d + p)), y = he(u), b = {
+      rootMargin: -h + "px " + -g + "px " + -v + "px " + -y + "px",
+      threshold: W(0, K(1, a)) || 1
+    };
+    let x = !0;
+    function R(E) {
+      const C = E[0].intersectionRatio;
+      if (C !== a) {
+        if (!x)
+          return s();
+        C ? s(!1, C) : o = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      C === 1 && !It(l, e.getBoundingClientRect()) && s(), x = !1;
+    }
+    try {
+      n = new IntersectionObserver(R, {
+        ...b,
+        // Handle <iframe>s
+        root: r.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(R, b);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function qo(e, t, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: r = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = o, l = Ye(e), u = r || i ? [...l ? le(l) : [], ...t ? le(t) : []] : [];
+  u.forEach((y) => {
+    r && y.addEventListener("scroll", n, {
+      passive: !0
+    }), i && y.addEventListener("resize", n);
+  });
+  const d = l && c ? Xo(l, n) : null;
+  let m = -1, p = null;
+  s && (p = new ResizeObserver((y) => {
+    let [w] = y;
+    w && w.target === l && p && t && (p.unobserve(t), cancelAnimationFrame(m), m = requestAnimationFrame(() => {
+      var b;
+      (b = p) == null || b.observe(t);
+    })), n();
+  }), l && !a && p.observe(l), t && p.observe(t));
+  let h, g = a ? ee(e) : null;
+  a && v();
+  function v() {
+    const y = ee(e);
+    g && !It(g, y) && n(), g = y, h = requestAnimationFrame(v);
+  }
+  return n(), () => {
+    var y;
+    u.forEach((w) => {
+      r && w.removeEventListener("scroll", n), i && w.removeEventListener("resize", n);
+    }), d == null || d(), (y = p) == null || y.disconnect(), p = null, a && cancelAnimationFrame(h);
+  };
+}
+const Go = Po, Ko = Ao, Zo = Co, Jo = So, Qo = Eo, vt = bo, er = Oo, tr = (e, t, n) => {
+  const o = /* @__PURE__ */ new Map(), r = {
+    platform: Yo,
+    ...n
+  }, i = {
+    ...r.platform,
+    _c: o
+  };
+  return xo(e, t, {
+    ...r,
+    platform: i
+  });
+};
+var nr = typeof document < "u", or = function() {
+}, ge = nr ? yn : or;
+function be(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, o, r;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (o = n; o-- !== 0; )
+        if (!be(e[o], t[o]))
+          return !1;
+      return !0;
+    }
+    if (r = Object.keys(e), n = r.length, n !== Object.keys(t).length)
+      return !1;
+    for (o = n; o-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, r[o]))
+        return !1;
+    for (o = n; o-- !== 0; ) {
+      const i = r[o];
+      if (!(i === "_owner" && e.$$typeof) && !be(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function Wt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function yt(e, t) {
+  const n = Wt(e);
+  return Math.round(t * n) / n;
+}
+function Ne(e) {
+  const t = f.useRef(e);
+  return ge(() => {
+    t.current = e;
+  }), t;
+}
+function rr(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: o = [],
+    platform: r,
+    elements: {
+      reference: i,
+      floating: s
+    } = {},
+    transform: c = !0,
+    whileElementsMounted: a,
+    open: l
+  } = e, [u, d] = f.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [m, p] = f.useState(o);
+  be(m, o) || p(o);
+  const [h, g] = f.useState(null), [v, y] = f.useState(null), w = f.useCallback((A) => {
+    A !== E.current && (E.current = A, g(A));
+  }, []), b = f.useCallback((A) => {
+    A !== C.current && (C.current = A, y(A));
+  }, []), x = i || h, R = s || v, E = f.useRef(null), C = f.useRef(null), O = f.useRef(u), _ = a != null, S = Ne(a), $ = Ne(r), k = Ne(l), D = f.useCallback(() => {
+    if (!E.current || !C.current)
+      return;
+    const A = {
+      placement: t,
+      strategy: n,
+      middleware: m
+    };
+    $.current && (A.platform = $.current), tr(E.current, C.current, A).then((M) => {
+      const V = {
+        ...M,
+        // 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: k.current !== !1
+      };
+      T.current && !be(O.current, V) && (O.current = V, xt.flushSync(() => {
+        d(V);
+      }));
+    });
+  }, [m, t, n, $, k]);
+  ge(() => {
+    l === !1 && O.current.isPositioned && (O.current.isPositioned = !1, d((A) => ({
+      ...A,
+      isPositioned: !1
+    })));
+  }, [l]);
+  const T = f.useRef(!1);
+  ge(() => (T.current = !0, () => {
+    T.current = !1;
+  }), []), ge(() => {
+    if (x && (E.current = x), R && (C.current = R), x && R) {
+      if (S.current)
+        return S.current(x, R, D);
+      D();
+    }
+  }, [x, R, D, S, _]);
+  const I = f.useMemo(() => ({
+    reference: E,
+    floating: C,
+    setReference: w,
+    setFloating: b
+  }), [w, b]), L = f.useMemo(() => ({
+    reference: x,
+    floating: R
+  }), [x, R]), N = f.useMemo(() => {
+    const A = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!L.floating)
+      return A;
+    const M = yt(L.floating, u.x), V = yt(L.floating, u.y);
+    return c ? {
+      ...A,
+      transform: "translate(" + M + "px, " + V + "px)",
+      ...Wt(L.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: M,
+      top: V
+    };
+  }, [n, c, L.floating, u.x, u.y]);
+  return f.useMemo(() => ({
+    ...u,
+    update: D,
+    refs: I,
+    elements: L,
+    floatingStyles: N
+  }), [u, D, I, L, N]);
+}
+const ir = (e) => {
+  function t(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(n) {
+      const {
+        element: o,
+        padding: r
+      } = typeof e == "function" ? e(n) : e;
+      return o && t(o) ? o.current != null ? vt({
+        element: o.current,
+        padding: r
+      }).fn(n) : {} : o ? vt({
+        element: o,
+        padding: r
+      }).fn(n) : {};
+    }
+  };
+}, sr = (e, t) => {
+  const n = Go(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, cr = (e, t) => {
+  const n = Ko(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, ar = (e, t) => ({
+  fn: er(e).fn,
+  options: [e, t]
+}), lr = (e, t) => {
+  const n = Zo(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, ur = (e, t) => {
+  const n = Jo(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, fr = (e, t) => {
+  const n = Qo(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, dr = (e, t) => {
+  const n = ir(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+};
+var pr = "Arrow", Ft = f.forwardRef((e, t) => {
+  const { children: n, width: o = 10, height: r = 5, ...i } = e;
+  return /* @__PURE__ */ P(
+    ne.svg,
+    {
+      ...i,
+      ref: t,
+      width: o,
+      height: r,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: e.asChild ? n : /* @__PURE__ */ P("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+Ft.displayName = pr;
+var mr = Ft, Xe = "Popper", [Bt, Ht] = bt(Xe), [hr, Vt] = Bt(Xe), zt = (e) => {
+  const { __scopePopper: t, children: n } = e, [o, r] = f.useState(null);
+  return /* @__PURE__ */ P(hr, { scope: t, anchor: o, onAnchorChange: r, children: n });
+};
+zt.displayName = Xe;
+var jt = "PopperAnchor", Ut = f.forwardRef(
+  (e, t) => {
+    const { __scopePopper: n, virtualRef: o, ...r } = e, i = Vt(jt, n), s = f.useRef(null), c = te(t, s), a = f.useRef(null);
+    return f.useEffect(() => {
+      const l = a.current;
+      a.current = (o == null ? void 0 : o.current) || s.current, l !== a.current && i.onAnchorChange(a.current);
+    }), o ? null : /* @__PURE__ */ P(ne.div, { ...r, ref: c });
+  }
+);
+Ut.displayName = jt;
+var qe = "PopperContent", [gr, vr] = Bt(qe), Yt = f.forwardRef(
+  (e, t) => {
+    var Ke, Ze, Je, Qe, et, tt;
+    const {
+      __scopePopper: n,
+      side: o = "bottom",
+      sideOffset: r = 0,
+      align: i = "center",
+      alignOffset: s = 0,
+      arrowPadding: c = 0,
+      avoidCollisions: a = !0,
+      collisionBoundary: l = [],
+      collisionPadding: u = 0,
+      sticky: d = "partial",
+      hideWhenDetached: m = !1,
+      updatePositionStrategy: p = "optimized",
+      onPlaced: h,
+      ...g
+    } = e, v = Vt(qe, n), [y, w] = f.useState(null), b = te(t, (ae) => w(ae)), [x, R] = f.useState(null), E = Pn(x), C = (E == null ? void 0 : E.width) ?? 0, O = (E == null ? void 0 : E.height) ?? 0, _ = o + (i !== "center" ? "-" + i : ""), S = typeof u == "number" ? u : { top: 0, right: 0, bottom: 0, left: 0, ...u }, $ = Array.isArray(l) ? l : [l], k = $.length > 0, D = {
+      padding: S,
+      boundary: $.filter(wr),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: k
+    }, { refs: T, floatingStyles: I, placement: L, isPositioned: N, middlewareData: A } = rr({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: _,
+      whileElementsMounted: (...ae) => qo(...ae, {
+        animationFrame: p === "always"
+      }),
+      elements: {
+        reference: v.anchor
+      },
+      middleware: [
+        sr({ mainAxis: r + O, alignmentAxis: s }),
+        a && cr({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: d === "partial" ? ar() : void 0,
+          ...D
+        }),
+        a && lr({ ...D }),
+        ur({
+          ...D,
+          apply: ({ elements: ae, rects: nt, availableWidth: un, availableHeight: fn }) => {
+            const { width: dn, height: pn } = nt.reference, pe = ae.floating.style;
+            pe.setProperty("--radix-popper-available-width", `${un}px`), pe.setProperty("--radix-popper-available-height", `${fn}px`), pe.setProperty("--radix-popper-anchor-width", `${dn}px`), pe.setProperty("--radix-popper-anchor-height", `${pn}px`);
+          }
+        }),
+        x && dr({ element: x, padding: c }),
+        xr({ arrowWidth: C, arrowHeight: O }),
+        m && fr({ strategy: "referenceHidden", ...D })
+      ]
+    }), [M, V] = Gt(L), de = Ce(h);
+    Q(() => {
+      N && (de == null || de());
+    }, [N, de]);
+    const rn = (Ke = A.arrow) == null ? void 0 : Ke.x, sn = (Ze = A.arrow) == null ? void 0 : Ze.y, cn = ((Je = A.arrow) == null ? void 0 : Je.centerOffset) !== 0, [an, ln] = f.useState();
+    return Q(() => {
+      y && ln(window.getComputedStyle(y).zIndex);
+    }, [y]), /* @__PURE__ */ P(
+      "div",
+      {
+        ref: T.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...I,
+          transform: N ? I.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: an,
+          "--radix-popper-transform-origin": [
+            (Qe = A.transformOrigin) == null ? void 0 : Qe.x,
+            (et = A.transformOrigin) == null ? void 0 : et.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
+          ...((tt = A.hide) == null ? void 0 : tt.referenceHidden) && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        },
+        dir: e.dir,
+        children: /* @__PURE__ */ P(
+          gr,
+          {
+            scope: n,
+            placedSide: M,
+            onArrowChange: R,
+            arrowX: rn,
+            arrowY: sn,
+            shouldHideArrow: cn,
+            children: /* @__PURE__ */ P(
+              ne.div,
+              {
+                "data-side": M,
+                "data-align": V,
+                ...g,
+                ref: b,
+                style: {
+                  ...g.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: N ? void 0 : "none"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Yt.displayName = qe;
+var Xt = "PopperArrow", yr = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, qt = f.forwardRef(function(t, n) {
+  const { __scopePopper: o, ...r } = t, i = vr(Xt, o), s = yr[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__ */ P(
+      "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__ */ P(
+          mr,
+          {
+            ...r,
+            ref: n,
+            style: {
+              ...r.style,
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            }
+          }
+        )
+      }
+    )
+  );
+});
+qt.displayName = Xt;
+function wr(e) {
+  return e !== null;
+}
+var xr = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(t) {
+    var v, y, w;
+    const { placement: n, rects: o, middlewareData: r } = t, s = ((v = r.arrow) == null ? void 0 : v.centerOffset) !== 0, c = s ? 0 : e.arrowWidth, a = s ? 0 : e.arrowHeight, [l, u] = Gt(n), d = { start: "0%", center: "50%", end: "100%" }[u], m = (((y = r.arrow) == null ? void 0 : y.x) ?? 0) + c / 2, p = (((w = r.arrow) == null ? void 0 : w.y) ?? 0) + a / 2;
+    let h = "", g = "";
+    return l === "bottom" ? (h = s ? d : `${m}px`, g = `${-a}px`) : l === "top" ? (h = s ? d : `${m}px`, g = `${o.floating.height + a}px`) : l === "right" ? (h = `${-a}px`, g = s ? d : `${p}px`) : l === "left" && (h = `${o.floating.width + a}px`, g = s ? d : `${p}px`), { data: { x: h, y: g } };
+  }
+});
+function Gt(e) {
+  const [t, n = "center"] = e.split("-");
+  return [t, n];
+}
+var br = zt, Cr = Ut, Er = Yt, Rr = qt, Pr = Symbol("radix.slottable");
+// @__NO_SIDE_EFFECTS__
+function Ar(e) {
+  const t = ({ children: n }) => /* @__PURE__ */ P(hn, { children: n });
+  return t.displayName = `${e}.Slottable`, t.__radixId = Pr, t;
+}
+var [Oe] = bt("Tooltip", [
+  Ht
+]), Se = Ht(), Kt = "TooltipProvider", Or = 700, Ie = "tooltip.open", [Sr, Ge] = Oe(Kt), Zt = (e) => {
+  const {
+    __scopeTooltip: t,
+    delayDuration: n = Or,
+    skipDelayDuration: o = 300,
+    disableHoverableContent: r = !1,
+    children: i
+  } = e, s = f.useRef(!0), c = f.useRef(!1), a = f.useRef(0);
+  return f.useEffect(() => {
+    const l = a.current;
+    return () => window.clearTimeout(l);
+  }, []), /* @__PURE__ */ P(
+    Sr,
+    {
+      scope: t,
+      isOpenDelayedRef: s,
+      delayDuration: n,
+      onOpen: f.useCallback(() => {
+        window.clearTimeout(a.current), s.current = !1;
+      }, []),
+      onClose: f.useCallback(() => {
+        window.clearTimeout(a.current), a.current = window.setTimeout(
+          () => s.current = !0,
+          o
+        );
+      }, [o]),
+      isPointerInTransitRef: c,
+      onPointerInTransitChange: f.useCallback((l) => {
+        c.current = l;
+      }, []),
+      disableHoverableContent: r,
+      children: i
+    }
+  );
+};
+Zt.displayName = Kt;
+var ue = "Tooltip", [Tr, Te] = Oe(ue), Jt = (e) => {
+  const {
+    __scopeTooltip: t,
+    children: n,
+    open: o,
+    defaultOpen: r,
+    onOpenChange: i,
+    disableHoverableContent: s,
+    delayDuration: c
+  } = e, a = Ge(ue, e.__scopeTooltip), l = Se(t), [u, d] = f.useState(null), m = co(), p = f.useRef(0), h = s ?? a.disableHoverableContent, g = c ?? a.delayDuration, v = f.useRef(!1), [y, w] = Cn({
+    prop: o,
+    defaultProp: r ?? !1,
+    onChange: (C) => {
+      C ? (a.onOpen(), document.dispatchEvent(new CustomEvent(Ie))) : a.onClose(), i == null || i(C);
+    },
+    caller: ue
+  }), b = f.useMemo(() => y ? v.current ? "delayed-open" : "instant-open" : "closed", [y]), x = f.useCallback(() => {
+    window.clearTimeout(p.current), p.current = 0, v.current = !1, w(!0);
+  }, [w]), R = f.useCallback(() => {
+    window.clearTimeout(p.current), p.current = 0, w(!1);
+  }, [w]), E = f.useCallback(() => {
+    window.clearTimeout(p.current), p.current = window.setTimeout(() => {
+      v.current = !0, w(!0), p.current = 0;
+    }, g);
+  }, [g, w]);
+  return f.useEffect(() => () => {
+    p.current && (window.clearTimeout(p.current), p.current = 0);
+  }, []), /* @__PURE__ */ P(br, { ...l, children: /* @__PURE__ */ P(
+    Tr,
+    {
+      scope: t,
+      contentId: m,
+      open: y,
+      stateAttribute: b,
+      trigger: u,
+      onTriggerChange: d,
+      onTriggerEnter: f.useCallback(() => {
+        a.isOpenDelayedRef.current ? E() : x();
+      }, [a.isOpenDelayedRef, E, x]),
+      onTriggerLeave: f.useCallback(() => {
+        h ? R() : (window.clearTimeout(p.current), p.current = 0);
+      }, [R, h]),
+      onOpen: x,
+      onClose: R,
+      disableHoverableContent: h,
+      children: n
+    }
+  ) });
+};
+Jt.displayName = ue;
+var We = "TooltipTrigger", Qt = f.forwardRef(
+  (e, t) => {
+    const { __scopeTooltip: n, ...o } = e, r = Te(We, n), i = Ge(We, n), s = Se(n), c = f.useRef(null), a = te(t, c, r.onTriggerChange), l = f.useRef(!1), u = f.useRef(!1), d = f.useCallback(() => l.current = !1, []);
+    return f.useEffect(() => () => document.removeEventListener("pointerup", d), [d]), /* @__PURE__ */ P(Cr, { asChild: !0, ...s, children: /* @__PURE__ */ P(
+      ne.button,
+      {
+        "aria-describedby": r.open ? r.contentId : void 0,
+        "data-state": r.stateAttribute,
+        ...o,
+        ref: a,
+        onPointerMove: Y(e.onPointerMove, (m) => {
+          m.pointerType !== "touch" && !u.current && !i.isPointerInTransitRef.current && (r.onTriggerEnter(), u.current = !0);
+        }),
+        onPointerLeave: Y(e.onPointerLeave, () => {
+          r.onTriggerLeave(), u.current = !1;
+        }),
+        onPointerDown: Y(e.onPointerDown, () => {
+          r.open && r.onClose(), l.current = !0, document.addEventListener("pointerup", d, { once: !0 });
+        }),
+        onFocus: Y(e.onFocus, () => {
+          l.current || r.onOpen();
+        }),
+        onBlur: Y(e.onBlur, r.onClose),
+        onClick: Y(e.onClick, r.onClose)
+      }
+    ) });
+  }
+);
+Qt.displayName = We;
+var Dr = "TooltipPortal", [ti, Lr] = Oe(Dr, {
+  forceMount: void 0
+}), ie = "TooltipContent", en = f.forwardRef(
+  (e, t) => {
+    const n = Lr(ie, e.__scopeTooltip), { forceMount: o = n.forceMount, side: r = "top", ...i } = e, s = Te(ie, e.__scopeTooltip);
+    return /* @__PURE__ */ P(Ct, { present: o || s.open, children: s.disableHoverableContent ? /* @__PURE__ */ P(tn, { side: r, ...i, ref: t }) : /* @__PURE__ */ P(Nr, { side: r, ...i, ref: t }) });
+  }
+), Nr = f.forwardRef((e, t) => {
+  const n = Te(ie, e.__scopeTooltip), o = Ge(ie, e.__scopeTooltip), r = f.useRef(null), i = te(t, r), [s, c] = f.useState(null), { trigger: a, onClose: l } = n, u = r.current, { onPointerInTransitChange: d } = o, m = f.useCallback(() => {
+    c(null), d(!1);
+  }, [d]), p = f.useCallback(
+    (h, g) => {
+      const v = h.currentTarget, y = { x: h.clientX, y: h.clientY }, w = Ir(y, v.getBoundingClientRect()), b = Wr(y, w), x = Fr(g.getBoundingClientRect()), R = Hr([...b, ...x]);
+      c(R), d(!0);
+    },
+    [d]
+  );
+  return f.useEffect(() => () => m(), [m]), f.useEffect(() => {
+    if (a && u) {
+      const h = (v) => p(v, u), g = (v) => p(v, a);
+      return a.addEventListener("pointerleave", h), u.addEventListener("pointerleave", g), () => {
+        a.removeEventListener("pointerleave", h), u.removeEventListener("pointerleave", g);
+      };
+    }
+  }, [a, u, p, m]), f.useEffect(() => {
+    if (s) {
+      const h = (g) => {
+        const v = g.target, y = { x: g.clientX, y: g.clientY }, w = (a == null ? void 0 : a.contains(v)) || (u == null ? void 0 : u.contains(v)), b = !Br(y, s);
+        w ? m() : b && (m(), l());
+      };
+      return document.addEventListener("pointermove", h), () => document.removeEventListener("pointermove", h);
+    }
+  }, [a, u, s, l, m]), /* @__PURE__ */ P(tn, { ...e, ref: i });
+}), [_r, Mr] = Oe(ue, { isInside: !1 }), $r = /* @__PURE__ */ Ar("TooltipContent"), tn = f.forwardRef(
+  (e, t) => {
+    const {
+      __scopeTooltip: n,
+      children: o,
+      "aria-label": r,
+      onEscapeKeyDown: i,
+      onPointerDownOutside: s,
+      ...c
+    } = e, a = Te(ie, n), l = Se(n), { onClose: u } = a;
+    return f.useEffect(() => (document.addEventListener(Ie, u), () => document.removeEventListener(Ie, u)), [u]), f.useEffect(() => {
+      if (a.trigger) {
+        const d = (m) => {
+          const p = m.target;
+          p != null && p.contains(a.trigger) && u();
+        };
+        return window.addEventListener("scroll", d, { capture: !0 }), () => window.removeEventListener("scroll", d, { capture: !0 });
+      }
+    }, [a.trigger, u]), /* @__PURE__ */ P(
+      Be,
+      {
+        asChild: !0,
+        disableOutsidePointerEvents: !1,
+        onEscapeKeyDown: i,
+        onPointerDownOutside: s,
+        onFocusOutside: (d) => d.preventDefault(),
+        onDismiss: u,
+        children: /* @__PURE__ */ gn(
+          Er,
+          {
+            "data-state": a.stateAttribute,
+            ...l,
+            ...c,
+            ref: t,
+            style: {
+              ...c.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__ */ P($r, { children: o }),
+              /* @__PURE__ */ P(_r, { scope: n, isInside: !0, children: /* @__PURE__ */ P(ro, { id: a.contentId, role: "tooltip", children: r || o }) })
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+en.displayName = ie;
+var nn = "TooltipArrow", kr = f.forwardRef(
+  (e, t) => {
+    const { __scopeTooltip: n, ...o } = e, r = Se(n);
+    return Mr(
+      nn,
+      n
+    ).isInside ? null : /* @__PURE__ */ P(Rr, { ...r, ...o, ref: t });
+  }
+);
+kr.displayName = nn;
+function Ir(e, t) {
+  const n = Math.abs(t.top - e.y), o = Math.abs(t.bottom - e.y), r = Math.abs(t.right - e.x), i = Math.abs(t.left - e.x);
+  switch (Math.min(n, o, r, i)) {
+    case i:
+      return "left";
+    case r:
+      return "right";
+    case n:
+      return "top";
+    case o:
+      return "bottom";
+    default:
+      throw new Error("unreachable");
+  }
+}
+function Wr(e, t, n = 5) {
+  const o = [];
+  switch (t) {
+    case "top":
+      o.push(
+        { x: e.x - n, y: e.y + n },
+        { x: e.x + n, y: e.y + n }
+      );
+      break;
+    case "bottom":
+      o.push(
+        { x: e.x - n, y: e.y - n },
+        { x: e.x + n, y: e.y - n }
+      );
+      break;
+    case "left":
+      o.push(
+        { x: e.x + n, y: e.y - n },
+        { x: e.x + n, y: e.y + n }
+      );
+      break;
+    case "right":
+      o.push(
+        { x: e.x - n, y: e.y - n },
+        { x: e.x - n, y: e.y + n }
+      );
+      break;
+  }
+  return o;
+}
+function Fr(e) {
+  const { top: t, right: n, bottom: o, left: r } = e;
+  return [
+    { x: r, y: t },
+    { x: n, y: t },
+    { x: n, y: o },
+    { x: r, y: o }
+  ];
+}
+function Br(e, t) {
+  const { x: n, y: o } = e;
+  let r = !1;
+  for (let i = 0, s = t.length - 1; i < t.length; s = i++) {
+    const c = t[i], a = t[s], l = c.x, u = c.y, d = a.x, m = a.y;
+    u > o != m > o && n < (d - l) * (o - u) / (m - u) + l && (r = !r);
+  }
+  return r;
+}
+function Hr(e) {
+  const t = e.slice();
+  return t.sort((n, o) => n.x < o.x ? -1 : n.x > o.x ? 1 : n.y < o.y ? -1 : n.y > o.y ? 1 : 0), Vr(t);
+}
+function Vr(e) {
+  if (e.length <= 1) return e.slice();
+  const t = [];
+  for (let o = 0; o < e.length; o++) {
+    const r = e[o];
+    for (; t.length >= 2; ) {
+      const i = t[t.length - 1], s = t[t.length - 2];
+      if ((i.x - s.x) * (r.y - s.y) >= (i.y - s.y) * (r.x - s.x)) t.pop();
+      else break;
+    }
+    t.push(r);
+  }
+  t.pop();
+  const n = [];
+  for (let o = e.length - 1; o >= 0; o--) {
+    const r = e[o];
+    for (; n.length >= 2; ) {
+      const i = n[n.length - 1], s = n[n.length - 2];
+      if ((i.x - s.x) * (r.y - s.y) >= (i.y - s.y) * (r.x - s.x)) n.pop();
+      else break;
+    }
+    n.push(r);
+  }
+  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 zr = Zt, jr = Jt, Ur = Qt, on = en;
+const ni = zr, oi = jr, ri = Ur, Yr = f.forwardRef(
+  ({ className: e, sideOffset: t = 4, ...n }, o) => /* @__PURE__ */ P(
+    on,
+    {
+      ref: o,
+      sideOffset: t,
+      className: wt(
+        "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
+    }
+  )
+);
+Yr.displayName = on.displayName;
+export {
+  Cr as A,
+  qn as B,
+  Jr as C,
+  Be as D,
+  ne as P,
+  br as R,
+  oi as T,
+  no as V,
+  Yr as a,
+  ni as b,
+  ri as c,
+  Xn as d,
+  wn as e,
+  Fe as f,
+  bt as g,
+  Q as h,
+  Ce as i,
+  Y as j,
+  co as k,
+  Ht as l,
+  Er as m,
+  Cn as n,
+  Rr as o,
+  Ct as p,
+  Pn as q,
+  ei as r,
+  Ot as s,
+  Qr as t,
+  te as u,
+  kn as v,
+  Bn as w,
+  Zr as x
+};