@krosoft/react 0.0.86 → 0.0.88

package/dist/index-DUnCfjrC.js

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