@cfx-dev/ui-components 5.0.22 → 5.0.23

package/dist/Combination-BNueeiCk.js

@@ -0,0 +1,2227 @@
+import * as p from "react";
+import { useLayoutEffect as yn } from "react";
+import { a as de, P as ce, c as Ne, g as bn, e as Ve, d as xn, b as En } from "./index-8cuIcSMB.js";
+import { jsx as _ } from "react/jsx-runtime";
+import { r as Sn } from "./index-CUyjBl1Y.js";
+import { c as Dt, _ as Q, d as Cn } from "./tslib.es6-CtHwNPxX.js";
+import { c as An, u as Rn } from "./medium-Bq5NvyU7.js";
+var Mt = function(e) {
+  var t = e.sideCar, n = Dt(e, ["sideCar"]);
+  if (!t)
+    throw new Error("Sidecar: please provide `sideCar` property to import the right car");
+  var r = t.read();
+  if (!r)
+    throw new Error("Sidecar medium not found");
+  return p.createElement(r, Q({}, n));
+};
+Mt.isSideCarExport = !0;
+function Pn(e, t) {
+  return e.useMedium(t), Mt;
+}
+function ie(e) {
+  const t = p.useRef(e);
+  return p.useEffect(() => {
+    t.current = e;
+  }), p.useMemo(() => (...n) => {
+    var r;
+    return (r = t.current) == null ? void 0 : r.call(t, ...n);
+  }, []);
+}
+function On(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = ie(e);
+  p.useEffect(() => {
+    const r = (o) => {
+      o.key === "Escape" && n(o);
+    };
+    return t.addEventListener("keydown", r, { capture: !0 }), () => t.removeEventListener("keydown", r, { capture: !0 });
+  }, [n, t]);
+}
+var Ln = "DismissableLayer", ze = "dismissableLayer.update", Tn = "dismissableLayer.pointerDownOutside", Dn = "dismissableLayer.focusOutside", lt, Nt = p.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), Mn = p.forwardRef(
+  (e, t) => {
+    const {
+      disableOutsidePointerEvents: n = !1,
+      onEscapeKeyDown: r,
+      onPointerDownOutside: o,
+      onFocusOutside: i,
+      onInteractOutside: c,
+      onDismiss: s,
+      ...d
+    } = e, l = p.useContext(Nt), [u, f] = p.useState(null), m = (u == null ? void 0 : u.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document), [, h] = p.useState({}), w = de(t, (E) => f(E)), a = Array.from(l.layers), [v] = [...l.layersWithOutsidePointerEventsDisabled].slice(-1), g = a.indexOf(v), b = u ? a.indexOf(u) : -1, x = l.layersWithOutsidePointerEventsDisabled.size > 0, y = b >= g, S = kn((E) => {
+      const R = E.target, O = [...l.branches].some((P) => P.contains(R));
+      !y || O || (o == null || o(E), c == null || c(E), E.defaultPrevented || s == null || s());
+    }, m), C = Wn((E) => {
+      const R = E.target;
+      [...l.branches].some((P) => P.contains(R)) || (i == null || i(E), c == null || c(E), E.defaultPrevented || s == null || s());
+    }, m);
+    return On((E) => {
+      b === l.layers.size - 1 && (r == null || r(E), !E.defaultPrevented && s && (E.preventDefault(), s()));
+    }, m), p.useEffect(() => {
+      if (u)
+        return n && (l.layersWithOutsidePointerEventsDisabled.size === 0 && (lt = m.body.style.pointerEvents, m.body.style.pointerEvents = "none"), l.layersWithOutsidePointerEventsDisabled.add(u)), l.layers.add(u), ut(), () => {
+          n && l.layersWithOutsidePointerEventsDisabled.size === 1 && (m.body.style.pointerEvents = lt);
+        };
+    }, [u, m, n, l]), p.useEffect(() => () => {
+      u && (l.layers.delete(u), l.layersWithOutsidePointerEventsDisabled.delete(u), ut());
+    }, [u, l]), p.useEffect(() => {
+      const E = () => h({});
+      return document.addEventListener(ze, E), () => document.removeEventListener(ze, E);
+    }, []), /* @__PURE__ */ _(
+      ce.div,
+      {
+        ...d,
+        ref: w,
+        style: {
+          pointerEvents: x ? y ? "auto" : "none" : void 0,
+          ...e.style
+        },
+        onFocusCapture: Ne(e.onFocusCapture, C.onFocusCapture),
+        onBlurCapture: Ne(e.onBlurCapture, C.onBlurCapture),
+        onPointerDownCapture: Ne(
+          e.onPointerDownCapture,
+          S.onPointerDownCapture
+        )
+      }
+    );
+  }
+);
+Mn.displayName = Ln;
+var Nn = "DismissableLayerBranch", Fn = p.forwardRef((e, t) => {
+  const n = p.useContext(Nt), r = p.useRef(null), o = de(t, r);
+  return p.useEffect(() => {
+    const i = r.current;
+    if (i)
+      return n.branches.add(i), () => {
+        n.branches.delete(i);
+      };
+  }, [n.branches]), /* @__PURE__ */ _(ce.div, { ...e, ref: o });
+});
+Fn.displayName = Nn;
+function kn(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = ie(e), r = p.useRef(!1), o = p.useRef(() => {
+  });
+  return p.useEffect(() => {
+    const i = (s) => {
+      if (s.target && !r.current) {
+        let d = function() {
+          Ft(
+            Tn,
+            n,
+            l,
+            { discrete: !0 }
+          );
+        };
+        const l = { originalEvent: s };
+        s.pointerType === "touch" ? (t.removeEventListener("click", o.current), o.current = d, t.addEventListener("click", o.current, { once: !0 })) : d();
+      } else
+        t.removeEventListener("click", o.current);
+      r.current = !1;
+    }, c = window.setTimeout(() => {
+      t.addEventListener("pointerdown", i);
+    }, 0);
+    return () => {
+      window.clearTimeout(c), t.removeEventListener("pointerdown", i), t.removeEventListener("click", o.current);
+    };
+  }, [t, n]), {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => r.current = !0
+  };
+}
+function Wn(e, t = globalThis == null ? void 0 : globalThis.document) {
+  const n = ie(e), r = p.useRef(!1);
+  return p.useEffect(() => {
+    const o = (i) => {
+      i.target && !r.current && Ft(Dn, n, { originalEvent: i }, {
+        discrete: !1
+      });
+    };
+    return t.addEventListener("focusin", o), () => t.removeEventListener("focusin", o);
+  }, [t, n]), {
+    onFocusCapture: () => r.current = !0,
+    onBlurCapture: () => r.current = !1
+  };
+}
+function ut() {
+  const e = new CustomEvent(ze);
+  document.dispatchEvent(e);
+}
+function Ft(e, t, n, { discrete: r }) {
+  const o = n.originalEvent.target, i = new CustomEvent(e, { bubbles: !1, cancelable: !0, detail: n });
+  t && o.addEventListener(e, t, { once: !0 }), r ? bn(o, i) : o.dispatchEvent(i);
+}
+var Fe = 0;
+function Go() {
+  p.useEffect(() => {
+    const e = document.querySelectorAll("[data-radix-focus-guard]");
+    return document.body.insertAdjacentElement("afterbegin", e[0] ?? ft()), document.body.insertAdjacentElement("beforeend", e[1] ?? ft()), Fe++, () => {
+      Fe === 1 && document.querySelectorAll("[data-radix-focus-guard]").forEach((t) => t.remove()), Fe--;
+    };
+  }, []);
+}
+function ft() {
+  const e = document.createElement("span");
+  return e.setAttribute("data-radix-focus-guard", ""), e.tabIndex = 0, e.style.outline = "none", e.style.opacity = "0", e.style.position = "fixed", e.style.pointerEvents = "none", e;
+}
+var ke = "focusScope.autoFocusOnMount", We = "focusScope.autoFocusOnUnmount", dt = { bubbles: !1, cancelable: !0 }, Bn = "FocusScope", In = p.forwardRef((e, t) => {
+  const {
+    loop: n = !1,
+    trapped: r = !1,
+    onMountAutoFocus: o,
+    onUnmountAutoFocus: i,
+    ...c
+  } = e, [s, d] = p.useState(null), l = ie(o), u = ie(i), f = p.useRef(null), m = de(t, (a) => d(a)), h = p.useRef({
+    paused: !1,
+    pause() {
+      this.paused = !0;
+    },
+    resume() {
+      this.paused = !1;
+    }
+  }).current;
+  p.useEffect(() => {
+    if (r) {
+      let a = function(x) {
+        if (h.paused || !s) return;
+        const y = x.target;
+        s.contains(y) ? f.current = y : q(f.current, { select: !0 });
+      }, v = function(x) {
+        if (h.paused || !s) return;
+        const y = x.relatedTarget;
+        y !== null && (s.contains(y) || q(f.current, { select: !0 }));
+      }, g = function(x) {
+        if (document.activeElement === document.body)
+          for (const S of x)
+            S.removedNodes.length > 0 && q(s);
+      };
+      document.addEventListener("focusin", a), document.addEventListener("focusout", v);
+      const b = new MutationObserver(g);
+      return s && b.observe(s, { childList: !0, subtree: !0 }), () => {
+        document.removeEventListener("focusin", a), document.removeEventListener("focusout", v), b.disconnect();
+      };
+    }
+  }, [r, s, h.paused]), p.useEffect(() => {
+    if (s) {
+      mt.add(h);
+      const a = document.activeElement;
+      if (!s.contains(a)) {
+        const g = new CustomEvent(ke, dt);
+        s.addEventListener(ke, l), s.dispatchEvent(g), g.defaultPrevented || (_n(Un(kt(s)), { select: !0 }), document.activeElement === a && q(s));
+      }
+      return () => {
+        s.removeEventListener(ke, l), setTimeout(() => {
+          const g = new CustomEvent(We, dt);
+          s.addEventListener(We, u), s.dispatchEvent(g), g.defaultPrevented || q(a ?? document.body, { select: !0 }), s.removeEventListener(We, u), mt.remove(h);
+        }, 0);
+      };
+    }
+  }, [s, l, u, h]);
+  const w = p.useCallback(
+    (a) => {
+      if (!n && !r || h.paused) return;
+      const v = a.key === "Tab" && !a.altKey && !a.ctrlKey && !a.metaKey, g = document.activeElement;
+      if (v && g) {
+        const b = a.currentTarget, [x, y] = Hn(b);
+        x && y ? !a.shiftKey && g === y ? (a.preventDefault(), n && q(x, { select: !0 })) : a.shiftKey && g === x && (a.preventDefault(), n && q(y, { select: !0 })) : g === b && a.preventDefault();
+      }
+    },
+    [n, r, h.paused]
+  );
+  return /* @__PURE__ */ _(ce.div, { tabIndex: -1, ...c, ref: m, onKeyDown: w });
+});
+In.displayName = Bn;
+function _n(e, { select: t = !1 } = {}) {
+  const n = document.activeElement;
+  for (const r of e)
+    if (q(r, { select: t }), document.activeElement !== n) return;
+}
+function Hn(e) {
+  const t = kt(e), n = ht(t, e), r = ht(t.reverse(), e);
+  return [n, r];
+}
+function kt(e) {
+  const t = [], n = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (r) => {
+      const o = r.tagName === "INPUT" && r.type === "hidden";
+      return r.disabled || r.hidden || o ? NodeFilter.FILTER_SKIP : r.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  for (; n.nextNode(); ) t.push(n.currentNode);
+  return t;
+}
+function ht(e, t) {
+  for (const n of e)
+    if (!$n(n, { upTo: t })) return n;
+}
+function $n(e, { upTo: t }) {
+  if (getComputedStyle(e).visibility === "hidden") return !0;
+  for (; e; ) {
+    if (t !== void 0 && e === t) return !1;
+    if (getComputedStyle(e).display === "none") return !0;
+    e = e.parentElement;
+  }
+  return !1;
+}
+function Vn(e) {
+  return e instanceof HTMLInputElement && "select" in e;
+}
+function q(e, { select: t = !1 } = {}) {
+  if (e && e.focus) {
+    const n = document.activeElement;
+    e.focus({ preventScroll: !0 }), e !== n && Vn(e) && t && e.select();
+  }
+}
+var mt = zn();
+function zn() {
+  let e = [];
+  return {
+    add(t) {
+      const n = e[0];
+      t !== n && (n == null || n.pause()), e = pt(e, t), e.unshift(t);
+    },
+    remove(t) {
+      var n;
+      e = pt(e, t), (n = e[0]) == null || n.resume();
+    }
+  };
+}
+function pt(e, t) {
+  const n = [...e], r = n.indexOf(t);
+  return r !== -1 && n.splice(r, 1), n;
+}
+function Un(e) {
+  return e.filter((t) => t.tagName !== "A");
+}
+var Xn = p[" useId ".trim().toString()] || (() => {
+}), Yn = 0;
+function Qo(e) {
+  const [t, n] = p.useState(Xn());
+  return Ve(() => {
+    n((r) => r ?? String(Yn++));
+  }, [e]), t ? `radix-${t}` : "";
+}
+const jn = ["top", "right", "bottom", "left"], Z = Math.min, B = Math.max, Ce = Math.round, ve = Math.floor, U = (e) => ({
+  x: e,
+  y: e
+}), Kn = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, qn = {
+  start: "end",
+  end: "start"
+};
+function Ue(e, t, n) {
+  return B(e, Z(t, n));
+}
+function j(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function K(e) {
+  return e.split("-")[0];
+}
+function ae(e) {
+  return e.split("-")[1];
+}
+function Ke(e) {
+  return e === "x" ? "y" : "x";
+}
+function qe(e) {
+  return e === "y" ? "height" : "width";
+}
+const Zn = /* @__PURE__ */ new Set(["top", "bottom"]);
+function z(e) {
+  return Zn.has(K(e)) ? "y" : "x";
+}
+function Ze(e) {
+  return Ke(z(e));
+}
+function Gn(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = ae(e), o = Ze(e), i = qe(o);
+  let c = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (c = Ae(c)), [c, Ae(c)];
+}
+function Qn(e) {
+  const t = Ae(e);
+  return [Xe(e), t, Xe(t)];
+}
+function Xe(e) {
+  return e.replace(/start|end/g, (t) => qn[t]);
+}
+const vt = ["left", "right"], gt = ["right", "left"], Jn = ["top", "bottom"], er = ["bottom", "top"];
+function tr(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? gt : vt : t ? vt : gt;
+    case "left":
+    case "right":
+      return t ? Jn : er;
+    default:
+      return [];
+  }
+}
+function nr(e, t, n, r) {
+  const o = ae(e);
+  let i = tr(K(e), n === "start", r);
+  return o && (i = i.map((c) => c + "-" + o), t && (i = i.concat(i.map(Xe)))), i;
+}
+function Ae(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Kn[t]);
+}
+function rr(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Wt(e) {
+  return typeof e != "number" ? rr(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Re(e) {
+  const {
+    x: t,
+    y: n,
+    width: r,
+    height: o
+  } = e;
+  return {
+    width: r,
+    height: o,
+    top: n,
+    left: t,
+    right: t + r,
+    bottom: n + o,
+    x: t,
+    y: n
+  };
+}
+function wt(e, t, n) {
+  let {
+    reference: r,
+    floating: o
+  } = e;
+  const i = z(t), c = Ze(t), s = qe(c), d = K(t), l = i === "y", u = r.x + r.width / 2 - o.width / 2, f = r.y + r.height / 2 - o.height / 2, m = r[s] / 2 - o[s] / 2;
+  let h;
+  switch (d) {
+    case "top":
+      h = {
+        x: u,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      h = {
+        x: u,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      h = {
+        x: r.x + r.width,
+        y: f
+      };
+      break;
+    case "left":
+      h = {
+        x: r.x - o.width,
+        y: f
+      };
+      break;
+    default:
+      h = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (ae(t)) {
+    case "start":
+      h[c] -= m * (n && l ? -1 : 1);
+      break;
+    case "end":
+      h[c] += m * (n && l ? -1 : 1);
+      break;
+  }
+  return h;
+}
+async function or(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: r,
+    y: o,
+    platform: i,
+    rects: c,
+    elements: s,
+    strategy: d
+  } = e, {
+    boundary: l = "clippingAncestors",
+    rootBoundary: u = "viewport",
+    elementContext: f = "floating",
+    altBoundary: m = !1,
+    padding: h = 0
+  } = j(t, e), w = Wt(h), v = s[m ? f === "floating" ? "reference" : "floating" : f], g = Re(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(s.floating)),
+    boundary: l,
+    rootBoundary: u,
+    strategy: d
+  })), b = f === "floating" ? {
+    x: r,
+    y: o,
+    width: c.floating.width,
+    height: c.floating.height
+  } : c.reference, x = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(s.floating)), y = await (i.isElement == null ? void 0 : i.isElement(x)) ? await (i.getScale == null ? void 0 : i.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, S = Re(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: s,
+    rect: b,
+    offsetParent: x,
+    strategy: d
+  }) : b);
+  return {
+    top: (g.top - S.top + w.top) / y.y,
+    bottom: (S.bottom - g.bottom + w.bottom) / y.y,
+    left: (g.left - S.left + w.left) / y.x,
+    right: (S.right - g.right + w.right) / y.x
+  };
+}
+const ir = async (e, t, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: i = [],
+    platform: c
+  } = n, s = i.filter(Boolean), d = await (c.isRTL == null ? void 0 : c.isRTL(t));
+  let l = await c.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: u,
+    y: f
+  } = wt(l, r, d), m = r, h = {}, w = 0;
+  for (let v = 0; v < s.length; v++) {
+    var a;
+    const {
+      name: g,
+      fn: b
+    } = s[v], {
+      x,
+      y,
+      data: S,
+      reset: C
+    } = await b({
+      x: u,
+      y: f,
+      initialPlacement: r,
+      placement: m,
+      strategy: o,
+      middlewareData: h,
+      rects: l,
+      platform: {
+        ...c,
+        detectOverflow: (a = c.detectOverflow) != null ? a : or
+      },
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    u = x ?? u, f = y ?? f, h = {
+      ...h,
+      [g]: {
+        ...h[g],
+        ...S
+      }
+    }, C && w <= 50 && (w++, typeof C == "object" && (C.placement && (m = C.placement), C.rects && (l = C.rects === !0 ? await c.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : C.rects), {
+      x: u,
+      y: f
+    } = wt(l, m, d)), v = -1);
+  }
+  return {
+    x: u,
+    y: f,
+    placement: m,
+    strategy: o,
+    middlewareData: h
+  };
+}, sr = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: r,
+      placement: o,
+      rects: i,
+      platform: c,
+      elements: s,
+      middlewareData: d
+    } = t, {
+      element: l,
+      padding: u = 0
+    } = j(e, t) || {};
+    if (l == null)
+      return {};
+    const f = Wt(u), m = {
+      x: n,
+      y: r
+    }, h = Ze(o), w = qe(h), a = await c.getDimensions(l), v = h === "y", g = v ? "top" : "left", b = v ? "bottom" : "right", x = v ? "clientHeight" : "clientWidth", y = i.reference[w] + i.reference[h] - m[h] - i.floating[w], S = m[h] - i.reference[h], C = await (c.getOffsetParent == null ? void 0 : c.getOffsetParent(l));
+    let E = C ? C[x] : 0;
+    (!E || !await (c.isElement == null ? void 0 : c.isElement(C))) && (E = s.floating[x] || i.floating[w]);
+    const R = y / 2 - S / 2, O = E / 2 - a[w] / 2 - 1, P = Z(f[g], O), T = Z(f[b], O), F = P, D = E - a[w] - T, L = E / 2 - a[w] / 2 + R, W = Ue(F, L, D), M = !d.arrow && ae(o) != null && L !== W && i.reference[w] / 2 - (L < F ? P : T) - a[w] / 2 < 0, N = M ? L < F ? L - F : L - D : 0;
+    return {
+      [h]: m[h] + N,
+      data: {
+        [h]: W,
+        centerOffset: L - W - N,
+        ...M && {
+          alignmentOffset: N
+        }
+      },
+      reset: M
+    };
+  }
+}), cr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        middlewareData: i,
+        rects: c,
+        initialPlacement: s,
+        platform: d,
+        elements: l
+      } = t, {
+        mainAxis: u = !0,
+        crossAxis: f = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: h = "bestFit",
+        fallbackAxisSideDirection: w = "none",
+        flipAlignment: a = !0,
+        ...v
+      } = j(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const g = K(o), b = z(s), x = K(s) === s, y = await (d.isRTL == null ? void 0 : d.isRTL(l.floating)), S = m || (x || !a ? [Ae(s)] : Qn(s)), C = w !== "none";
+      !m && C && S.push(...nr(s, a, w, y));
+      const E = [s, ...S], R = await d.detectOverflow(t, v), O = [];
+      let P = ((r = i.flip) == null ? void 0 : r.overflows) || [];
+      if (u && O.push(R[g]), f) {
+        const L = Gn(o, c, y);
+        O.push(R[L[0]], R[L[1]]);
+      }
+      if (P = [...P, {
+        placement: o,
+        overflows: O
+      }], !O.every((L) => L <= 0)) {
+        var T, F;
+        const L = (((T = i.flip) == null ? void 0 : T.index) || 0) + 1, W = E[L];
+        if (W && (!(f === "alignment" ? b !== z(W) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        P.every((A) => z(A.placement) === b ? A.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: L,
+              overflows: P
+            },
+            reset: {
+              placement: W
+            }
+          };
+        let M = (F = P.filter((N) => N.overflows[0] <= 0).sort((N, A) => N.overflows[1] - A.overflows[1])[0]) == null ? void 0 : F.placement;
+        if (!M)
+          switch (h) {
+            case "bestFit": {
+              var D;
+              const N = (D = P.filter((A) => {
+                if (C) {
+                  const k = z(A.placement);
+                  return k === b || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  k === "y";
+                }
+                return !0;
+              }).map((A) => [A.placement, A.overflows.filter((k) => k > 0).reduce((k, V) => k + V, 0)]).sort((A, k) => A[1] - k[1])[0]) == null ? void 0 : D[0];
+              N && (M = N);
+              break;
+            }
+            case "initialPlacement":
+              M = s;
+              break;
+          }
+        if (o !== M)
+          return {
+            reset: {
+              placement: M
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function yt(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function bt(e) {
+  return jn.some((t) => e[t] >= 0);
+}
+const ar = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: n,
+        platform: r
+      } = t, {
+        strategy: o = "referenceHidden",
+        ...i
+      } = j(e, t);
+      switch (o) {
+        case "referenceHidden": {
+          const c = await r.detectOverflow(t, {
+            ...i,
+            elementContext: "reference"
+          }), s = yt(c, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: s,
+              referenceHidden: bt(s)
+            }
+          };
+        }
+        case "escaped": {
+          const c = await r.detectOverflow(t, {
+            ...i,
+            altBoundary: !0
+          }), s = yt(c, n.floating);
+          return {
+            data: {
+              escapedOffsets: s,
+              escaped: bt(s)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, Bt = /* @__PURE__ */ new Set(["left", "top"]);
+async function lr(e, t) {
+  const {
+    placement: n,
+    platform: r,
+    elements: o
+  } = e, i = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), c = K(n), s = ae(n), d = z(n) === "y", l = Bt.has(c) ? -1 : 1, u = i && d ? -1 : 1, f = j(t, e);
+  let {
+    mainAxis: m,
+    crossAxis: h,
+    alignmentAxis: w
+  } = typeof f == "number" ? {
+    mainAxis: f,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: f.mainAxis || 0,
+    crossAxis: f.crossAxis || 0,
+    alignmentAxis: f.alignmentAxis
+  };
+  return s && typeof w == "number" && (h = s === "end" ? w * -1 : w), d ? {
+    x: h * u,
+    y: m * l
+  } : {
+    x: m * l,
+    y: h * u
+  };
+}
+const ur = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        x: o,
+        y: i,
+        placement: c,
+        middlewareData: s
+      } = t, d = await lr(t, e);
+      return c === ((n = s.offset) == null ? void 0 : n.placement) && (r = s.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + d.x,
+        y: i + d.y,
+        data: {
+          ...d,
+          placement: c
+        }
+      };
+    }
+  };
+}, fr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: r,
+        placement: o,
+        platform: i
+      } = t, {
+        mainAxis: c = !0,
+        crossAxis: s = !1,
+        limiter: d = {
+          fn: (g) => {
+            let {
+              x: b,
+              y: x
+            } = g;
+            return {
+              x: b,
+              y: x
+            };
+          }
+        },
+        ...l
+      } = j(e, t), u = {
+        x: n,
+        y: r
+      }, f = await i.detectOverflow(t, l), m = z(K(o)), h = Ke(m);
+      let w = u[h], a = u[m];
+      if (c) {
+        const g = h === "y" ? "top" : "left", b = h === "y" ? "bottom" : "right", x = w + f[g], y = w - f[b];
+        w = Ue(x, w, y);
+      }
+      if (s) {
+        const g = m === "y" ? "top" : "left", b = m === "y" ? "bottom" : "right", x = a + f[g], y = a - f[b];
+        a = Ue(x, a, y);
+      }
+      const v = d.fn({
+        ...t,
+        [h]: w,
+        [m]: a
+      });
+      return {
+        ...v,
+        data: {
+          x: v.x - n,
+          y: v.y - r,
+          enabled: {
+            [h]: c,
+            [m]: s
+          }
+        }
+      };
+    }
+  };
+}, dr = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const {
+        x: n,
+        y: r,
+        placement: o,
+        rects: i,
+        middlewareData: c
+      } = t, {
+        offset: s = 0,
+        mainAxis: d = !0,
+        crossAxis: l = !0
+      } = j(e, t), u = {
+        x: n,
+        y: r
+      }, f = z(o), m = Ke(f);
+      let h = u[m], w = u[f];
+      const a = j(s, t), v = typeof a == "number" ? {
+        mainAxis: a,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...a
+      };
+      if (d) {
+        const x = m === "y" ? "height" : "width", y = i.reference[m] - i.floating[x] + v.mainAxis, S = i.reference[m] + i.reference[x] - v.mainAxis;
+        h < y ? h = y : h > S && (h = S);
+      }
+      if (l) {
+        var g, b;
+        const x = m === "y" ? "width" : "height", y = Bt.has(K(o)), S = i.reference[f] - i.floating[x] + (y && ((g = c.offset) == null ? void 0 : g[f]) || 0) + (y ? 0 : v.crossAxis), C = i.reference[f] + i.reference[x] + (y ? 0 : ((b = c.offset) == null ? void 0 : b[f]) || 0) - (y ? v.crossAxis : 0);
+        w < S ? w = S : w > C && (w = C);
+      }
+      return {
+        [m]: h,
+        [f]: w
+      };
+    }
+  };
+}, hr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        rects: i,
+        platform: c,
+        elements: s
+      } = t, {
+        apply: d = () => {
+        },
+        ...l
+      } = j(e, t), u = await c.detectOverflow(t, l), f = K(o), m = ae(o), h = z(o) === "y", {
+        width: w,
+        height: a
+      } = i.floating;
+      let v, g;
+      f === "top" || f === "bottom" ? (v = f, g = m === (await (c.isRTL == null ? void 0 : c.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (g = f, v = m === "end" ? "top" : "bottom");
+      const b = a - u.top - u.bottom, x = w - u.left - u.right, y = Z(a - u[v], b), S = Z(w - u[g], x), C = !t.middlewareData.shift;
+      let E = y, R = S;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (R = x), (r = t.middlewareData.shift) != null && r.enabled.y && (E = b), C && !m) {
+        const P = B(u.left, 0), T = B(u.right, 0), F = B(u.top, 0), D = B(u.bottom, 0);
+        h ? R = w - 2 * (P !== 0 || T !== 0 ? P + T : B(u.left, u.right)) : E = a - 2 * (F !== 0 || D !== 0 ? F + D : B(u.top, u.bottom));
+      }
+      await d({
+        ...t,
+        availableWidth: R,
+        availableHeight: E
+      });
+      const O = await c.getDimensions(s.floating);
+      return w !== O.width || a !== O.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function Oe() {
+  return typeof window < "u";
+}
+function le(e) {
+  return It(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function I(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function Y(e) {
+  var t;
+  return (t = (It(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function It(e) {
+  return Oe() ? e instanceof Node || e instanceof I(e).Node : !1;
+}
+function H(e) {
+  return Oe() ? e instanceof Element || e instanceof I(e).Element : !1;
+}
+function X(e) {
+  return Oe() ? e instanceof HTMLElement || e instanceof I(e).HTMLElement : !1;
+}
+function xt(e) {
+  return !Oe() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof I(e).ShadowRoot;
+}
+const mr = /* @__PURE__ */ new Set(["inline", "contents"]);
+function he(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: r,
+    display: o
+  } = $(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && !mr.has(o);
+}
+const pr = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function vr(e) {
+  return pr.has(le(e));
+}
+const gr = [":popover-open", ":modal"];
+function Le(e) {
+  return gr.some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+const wr = ["transform", "translate", "scale", "rotate", "perspective"], yr = ["transform", "translate", "scale", "rotate", "perspective", "filter"], br = ["paint", "layout", "strict", "content"];
+function Ge(e) {
+  const t = Qe(), n = H(e) ? $(e) : e;
+  return wr.some((r) => n[r] ? n[r] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || yr.some((r) => (n.willChange || "").includes(r)) || br.some((r) => (n.contain || "").includes(r));
+}
+function xr(e) {
+  let t = G(e);
+  for (; X(t) && !se(t); ) {
+    if (Ge(t))
+      return t;
+    if (Le(t))
+      return null;
+    t = G(t);
+  }
+  return null;
+}
+function Qe() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const Er = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function se(e) {
+  return Er.has(le(e));
+}
+function $(e) {
+  return I(e).getComputedStyle(e);
+}
+function Te(e) {
+  return H(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function G(e) {
+  if (le(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    xt(e) && e.host || // Fallback.
+    Y(e)
+  );
+  return xt(t) ? t.host : t;
+}
+function _t(e) {
+  const t = G(e);
+  return se(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : X(t) && he(t) ? t : _t(t);
+}
+function fe(e, t, n) {
+  var r;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = _t(e), i = o === ((r = e.ownerDocument) == null ? void 0 : r.body), c = I(o);
+  if (i) {
+    const s = Ye(c);
+    return t.concat(c, c.visualViewport || [], he(o) ? o : [], s && n ? fe(s) : []);
+  }
+  return t.concat(o, fe(o, [], n));
+}
+function Ye(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function Ht(e) {
+  const t = $(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = X(e), i = o ? e.offsetWidth : n, c = o ? e.offsetHeight : r, s = Ce(n) !== i || Ce(r) !== c;
+  return s && (n = i, r = c), {
+    width: n,
+    height: r,
+    $: s
+  };
+}
+function Je(e) {
+  return H(e) ? e : e.contextElement;
+}
+function re(e) {
+  const t = Je(e);
+  if (!X(t))
+    return U(1);
+  const n = t.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: i
+  } = Ht(t);
+  let c = (i ? Ce(n.width) : n.width) / r, s = (i ? Ce(n.height) : n.height) / o;
+  return (!c || !Number.isFinite(c)) && (c = 1), (!s || !Number.isFinite(s)) && (s = 1), {
+    x: c,
+    y: s
+  };
+}
+const Sr = /* @__PURE__ */ U(0);
+function $t(e) {
+  const t = I(e);
+  return !Qe() || !t.visualViewport ? Sr : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Cr(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== I(e) ? !1 : t;
+}
+function J(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = Je(e);
+  let c = U(1);
+  t && (r ? H(r) && (c = re(r)) : c = re(e));
+  const s = Cr(i, n, r) ? $t(i) : U(0);
+  let d = (o.left + s.x) / c.x, l = (o.top + s.y) / c.y, u = o.width / c.x, f = o.height / c.y;
+  if (i) {
+    const m = I(i), h = r && H(r) ? I(r) : r;
+    let w = m, a = Ye(w);
+    for (; a && r && h !== w; ) {
+      const v = re(a), g = a.getBoundingClientRect(), b = $(a), x = g.left + (a.clientLeft + parseFloat(b.paddingLeft)) * v.x, y = g.top + (a.clientTop + parseFloat(b.paddingTop)) * v.y;
+      d *= v.x, l *= v.y, u *= v.x, f *= v.y, d += x, l += y, w = I(a), a = Ye(w);
+    }
+  }
+  return Re({
+    width: u,
+    height: f,
+    x: d,
+    y: l
+  });
+}
+function De(e, t) {
+  const n = Te(e).scrollLeft;
+  return t ? t.left + n : J(Y(e)).left + n;
+}
+function Vt(e, t) {
+  const n = e.getBoundingClientRect(), r = n.left + t.scrollLeft - De(e, n), o = n.top + t.scrollTop;
+  return {
+    x: r,
+    y: o
+  };
+}
+function Ar(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = e;
+  const i = o === "fixed", c = Y(r), s = t ? Le(t.floating) : !1;
+  if (r === c || s && i)
+    return n;
+  let d = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, l = U(1);
+  const u = U(0), f = X(r);
+  if ((f || !f && !i) && ((le(r) !== "body" || he(c)) && (d = Te(r)), X(r))) {
+    const h = J(r);
+    l = re(r), u.x = h.x + r.clientLeft, u.y = h.y + r.clientTop;
+  }
+  const m = c && !f && !i ? Vt(c, d) : U(0);
+  return {
+    width: n.width * l.x,
+    height: n.height * l.y,
+    x: n.x * l.x - d.scrollLeft * l.x + u.x + m.x,
+    y: n.y * l.y - d.scrollTop * l.y + u.y + m.y
+  };
+}
+function Rr(e) {
+  return Array.from(e.getClientRects());
+}
+function Pr(e) {
+  const t = Y(e), n = Te(e), r = e.ownerDocument.body, o = B(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), i = B(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let c = -n.scrollLeft + De(e);
+  const s = -n.scrollTop;
+  return $(r).direction === "rtl" && (c += B(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: c,
+    y: s
+  };
+}
+const Et = 25;
+function Or(e, t) {
+  const n = I(e), r = Y(e), o = n.visualViewport;
+  let i = r.clientWidth, c = r.clientHeight, s = 0, d = 0;
+  if (o) {
+    i = o.width, c = o.height;
+    const u = Qe();
+    (!u || u && t === "fixed") && (s = o.offsetLeft, d = o.offsetTop);
+  }
+  const l = De(r);
+  if (l <= 0) {
+    const u = r.ownerDocument, f = u.body, m = getComputedStyle(f), h = u.compatMode === "CSS1Compat" && parseFloat(m.marginLeft) + parseFloat(m.marginRight) || 0, w = Math.abs(r.clientWidth - f.clientWidth - h);
+    w <= Et && (i -= w);
+  } else l <= Et && (i += l);
+  return {
+    width: i,
+    height: c,
+    x: s,
+    y: d
+  };
+}
+const Lr = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function Tr(e, t) {
+  const n = J(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, i = X(e) ? re(e) : U(1), c = e.clientWidth * i.x, s = e.clientHeight * i.y, d = o * i.x, l = r * i.y;
+  return {
+    width: c,
+    height: s,
+    x: d,
+    y: l
+  };
+}
+function St(e, t, n) {
+  let r;
+  if (t === "viewport")
+    r = Or(e, n);
+  else if (t === "document")
+    r = Pr(Y(e));
+  else if (H(t))
+    r = Tr(t, n);
+  else {
+    const o = $t(e);
+    r = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return Re(r);
+}
+function zt(e, t) {
+  const n = G(e);
+  return n === t || !H(n) || se(n) ? !1 : $(n).position === "fixed" || zt(n, t);
+}
+function Dr(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let r = fe(e, [], !1).filter((s) => H(s) && le(s) !== "body"), o = null;
+  const i = $(e).position === "fixed";
+  let c = i ? G(e) : e;
+  for (; H(c) && !se(c); ) {
+    const s = $(c), d = Ge(c);
+    !d && s.position === "fixed" && (o = null), (i ? !d && !o : !d && s.position === "static" && !!o && Lr.has(o.position) || he(c) && !d && zt(e, c)) ? r = r.filter((u) => u !== c) : o = s, c = G(c);
+  }
+  return t.set(e, r), r;
+}
+function Mr(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = e;
+  const c = [...n === "clippingAncestors" ? Le(t) ? [] : Dr(t, this._c) : [].concat(n), r], s = c[0], d = c.reduce((l, u) => {
+    const f = St(t, u, o);
+    return l.top = B(f.top, l.top), l.right = Z(f.right, l.right), l.bottom = Z(f.bottom, l.bottom), l.left = B(f.left, l.left), l;
+  }, St(t, s, o));
+  return {
+    width: d.right - d.left,
+    height: d.bottom - d.top,
+    x: d.left,
+    y: d.top
+  };
+}
+function Nr(e) {
+  const {
+    width: t,
+    height: n
+  } = Ht(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function Fr(e, t, n) {
+  const r = X(t), o = Y(t), i = n === "fixed", c = J(e, !0, i, t);
+  let s = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const d = U(0);
+  function l() {
+    d.x = De(o);
+  }
+  if (r || !r && !i)
+    if ((le(t) !== "body" || he(o)) && (s = Te(t)), r) {
+      const h = J(t, !0, i, t);
+      d.x = h.x + t.clientLeft, d.y = h.y + t.clientTop;
+    } else o && l();
+  i && !r && o && l();
+  const u = o && !r && !i ? Vt(o, s) : U(0), f = c.left + s.scrollLeft - d.x - u.x, m = c.top + s.scrollTop - d.y - u.y;
+  return {
+    x: f,
+    y: m,
+    width: c.width,
+    height: c.height
+  };
+}
+function Be(e) {
+  return $(e).position === "static";
+}
+function Ct(e, t) {
+  if (!X(e) || $(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return Y(e) === n && (n = n.ownerDocument.body), n;
+}
+function Ut(e, t) {
+  const n = I(e);
+  if (Le(e))
+    return n;
+  if (!X(e)) {
+    let o = G(e);
+    for (; o && !se(o); ) {
+      if (H(o) && !Be(o))
+        return o;
+      o = G(o);
+    }
+    return n;
+  }
+  let r = Ct(e, t);
+  for (; r && vr(r) && Be(r); )
+    r = Ct(r, t);
+  return r && se(r) && Be(r) && !Ge(r) ? n : r || xr(e) || n;
+}
+const kr = async function(e) {
+  const t = this.getOffsetParent || Ut, n = this.getDimensions, r = await n(e.floating);
+  return {
+    reference: Fr(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function Wr(e) {
+  return $(e).direction === "rtl";
+}
+const Br = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ar,
+  getDocumentElement: Y,
+  getClippingRect: Mr,
+  getOffsetParent: Ut,
+  getElementRects: kr,
+  getClientRects: Rr,
+  getDimensions: Nr,
+  getScale: re,
+  isElement: H,
+  isRTL: Wr
+};
+function Xt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Ir(e, t) {
+  let n = null, r;
+  const o = Y(e);
+  function i() {
+    var s;
+    clearTimeout(r), (s = n) == null || s.disconnect(), n = null;
+  }
+  function c(s, d) {
+    s === void 0 && (s = !1), d === void 0 && (d = 1), i();
+    const l = e.getBoundingClientRect(), {
+      left: u,
+      top: f,
+      width: m,
+      height: h
+    } = l;
+    if (s || t(), !m || !h)
+      return;
+    const w = ve(f), a = ve(o.clientWidth - (u + m)), v = ve(o.clientHeight - (f + h)), g = ve(u), x = {
+      rootMargin: -w + "px " + -a + "px " + -v + "px " + -g + "px",
+      threshold: B(0, Z(1, d)) || 1
+    };
+    let y = !0;
+    function S(C) {
+      const E = C[0].intersectionRatio;
+      if (E !== d) {
+        if (!y)
+          return c();
+        E ? c(!1, E) : r = setTimeout(() => {
+          c(!1, 1e-7);
+        }, 1e3);
+      }
+      E === 1 && !Xt(l, e.getBoundingClientRect()) && c(), y = !1;
+    }
+    try {
+      n = new IntersectionObserver(S, {
+        ...x,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(S, x);
+    }
+    n.observe(e);
+  }
+  return c(!0), i;
+}
+function _r(e, t, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: i = !0,
+    elementResize: c = typeof ResizeObserver == "function",
+    layoutShift: s = typeof IntersectionObserver == "function",
+    animationFrame: d = !1
+  } = r, l = Je(e), u = o || i ? [...l ? fe(l) : [], ...fe(t)] : [];
+  u.forEach((g) => {
+    o && g.addEventListener("scroll", n, {
+      passive: !0
+    }), i && g.addEventListener("resize", n);
+  });
+  const f = l && s ? Ir(l, n) : null;
+  let m = -1, h = null;
+  c && (h = new ResizeObserver((g) => {
+    let [b] = g;
+    b && b.target === l && h && (h.unobserve(t), cancelAnimationFrame(m), m = requestAnimationFrame(() => {
+      var x;
+      (x = h) == null || x.observe(t);
+    })), n();
+  }), l && !d && h.observe(l), h.observe(t));
+  let w, a = d ? J(e) : null;
+  d && v();
+  function v() {
+    const g = J(e);
+    a && !Xt(a, g) && n(), a = g, w = requestAnimationFrame(v);
+  }
+  return n(), () => {
+    var g;
+    u.forEach((b) => {
+      o && b.removeEventListener("scroll", n), i && b.removeEventListener("resize", n);
+    }), f == null || f(), (g = h) == null || g.disconnect(), h = null, d && cancelAnimationFrame(w);
+  };
+}
+const Hr = ur, $r = fr, Vr = cr, zr = hr, Ur = ar, At = sr, Xr = dr, Yr = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: Br,
+    ...n
+  }, i = {
+    ...o.platform,
+    _c: r
+  };
+  return ir(e, t, {
+    ...o,
+    platform: i
+  });
+};
+var jr = typeof document < "u", Kr = function() {
+}, xe = jr ? yn : Kr;
+function Pe(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let n, r, o;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!Pe(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (o = Object.keys(e), n = o.length, n !== Object.keys(t).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, o[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      const i = o[r];
+      if (!(i === "_owner" && e.$$typeof) && !Pe(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function Yt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function Rt(e, t) {
+  const n = Yt(e);
+  return Math.round(t * n) / n;
+}
+function Ie(e) {
+  const t = p.useRef(e);
+  return xe(() => {
+    t.current = e;
+  }), t;
+}
+function qr(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: o,
+    elements: {
+      reference: i,
+      floating: c
+    } = {},
+    transform: s = !0,
+    whileElementsMounted: d,
+    open: l
+  } = e, [u, f] = p.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [m, h] = p.useState(r);
+  Pe(m, r) || h(r);
+  const [w, a] = p.useState(null), [v, g] = p.useState(null), b = p.useCallback((A) => {
+    A !== C.current && (C.current = A, a(A));
+  }, []), x = p.useCallback((A) => {
+    A !== E.current && (E.current = A, g(A));
+  }, []), y = i || w, S = c || v, C = p.useRef(null), E = p.useRef(null), R = p.useRef(u), O = d != null, P = Ie(d), T = Ie(o), F = Ie(l), D = p.useCallback(() => {
+    if (!C.current || !E.current)
+      return;
+    const A = {
+      placement: t,
+      strategy: n,
+      middleware: m
+    };
+    T.current && (A.platform = T.current), Yr(C.current, E.current, A).then((k) => {
+      const V = {
+        ...k,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: F.current !== !1
+      };
+      L.current && !Pe(R.current, V) && (R.current = V, Sn.flushSync(() => {
+        f(V);
+      }));
+    });
+  }, [m, t, n, T, F]);
+  xe(() => {
+    l === !1 && R.current.isPositioned && (R.current.isPositioned = !1, f((A) => ({
+      ...A,
+      isPositioned: !1
+    })));
+  }, [l]);
+  const L = p.useRef(!1);
+  xe(() => (L.current = !0, () => {
+    L.current = !1;
+  }), []), xe(() => {
+    if (y && (C.current = y), S && (E.current = S), y && S) {
+      if (P.current)
+        return P.current(y, S, D);
+      D();
+    }
+  }, [y, S, D, P, O]);
+  const W = p.useMemo(() => ({
+    reference: C,
+    floating: E,
+    setReference: b,
+    setFloating: x
+  }), [b, x]), M = p.useMemo(() => ({
+    reference: y,
+    floating: S
+  }), [y, S]), N = p.useMemo(() => {
+    const A = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!M.floating)
+      return A;
+    const k = Rt(M.floating, u.x), V = Rt(M.floating, u.y);
+    return s ? {
+      ...A,
+      transform: "translate(" + k + "px, " + V + "px)",
+      ...Yt(M.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: k,
+      top: V
+    };
+  }, [n, s, M.floating, u.x, u.y]);
+  return p.useMemo(() => ({
+    ...u,
+    update: D,
+    refs: W,
+    elements: M,
+    floatingStyles: N
+  }), [u, D, W, M, N]);
+}
+const Zr = (e) => {
+  function t(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(n) {
+      const {
+        element: r,
+        padding: o
+      } = typeof e == "function" ? e(n) : e;
+      return r && t(r) ? r.current != null ? At({
+        element: r.current,
+        padding: o
+      }).fn(n) : {} : r ? At({
+        element: r,
+        padding: o
+      }).fn(n) : {};
+    }
+  };
+}, Gr = (e, t) => ({
+  ...Hr(e),
+  options: [e, t]
+}), Qr = (e, t) => ({
+  ...$r(e),
+  options: [e, t]
+}), Jr = (e, t) => ({
+  ...Xr(e),
+  options: [e, t]
+}), eo = (e, t) => ({
+  ...Vr(e),
+  options: [e, t]
+}), to = (e, t) => ({
+  ...zr(e),
+  options: [e, t]
+}), no = (e, t) => ({
+  ...Ur(e),
+  options: [e, t]
+}), ro = (e, t) => ({
+  ...Zr(e),
+  options: [e, t]
+});
+var oo = "Arrow", jt = p.forwardRef((e, t) => {
+  const { children: n, width: r = 10, height: o = 5, ...i } = e;
+  return /* @__PURE__ */ _(
+    ce.svg,
+    {
+      ...i,
+      ref: t,
+      width: r,
+      height: o,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: e.asChild ? n : /* @__PURE__ */ _("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+jt.displayName = oo;
+var io = jt, et = "Popper", [Kt, Jo] = xn(et), [so, qt] = Kt(et), Zt = (e) => {
+  const { __scopePopper: t, children: n } = e, [r, o] = p.useState(null);
+  return /* @__PURE__ */ _(so, { scope: t, anchor: r, onAnchorChange: o, children: n });
+};
+Zt.displayName = et;
+var Gt = "PopperAnchor", Qt = p.forwardRef(
+  (e, t) => {
+    const { __scopePopper: n, virtualRef: r, ...o } = e, i = qt(Gt, n), c = p.useRef(null), s = de(t, c), d = p.useRef(null);
+    return p.useEffect(() => {
+      const l = d.current;
+      d.current = (r == null ? void 0 : r.current) || c.current, l !== d.current && i.onAnchorChange(d.current);
+    }), r ? null : /* @__PURE__ */ _(ce.div, { ...o, ref: s });
+  }
+);
+Qt.displayName = Gt;
+var tt = "PopperContent", [co, ao] = Kt(tt), Jt = p.forwardRef(
+  (e, t) => {
+    var nt, rt, ot, it, st, ct;
+    const {
+      __scopePopper: n,
+      side: r = "bottom",
+      sideOffset: o = 0,
+      align: i = "center",
+      alignOffset: c = 0,
+      arrowPadding: s = 0,
+      avoidCollisions: d = !0,
+      collisionBoundary: l = [],
+      collisionPadding: u = 0,
+      sticky: f = "partial",
+      hideWhenDetached: m = !1,
+      updatePositionStrategy: h = "optimized",
+      onPlaced: w,
+      ...a
+    } = e, v = qt(tt, n), [g, b] = p.useState(null), x = de(t, (ue) => b(ue)), [y, S] = p.useState(null), C = En(y), E = (C == null ? void 0 : C.width) ?? 0, R = (C == null ? void 0 : C.height) ?? 0, O = r + (i !== "center" ? "-" + i : ""), P = typeof u == "number" ? u : { top: 0, right: 0, bottom: 0, left: 0, ...u }, T = Array.isArray(l) ? l : [l], F = T.length > 0, D = {
+      padding: P,
+      boundary: T.filter(uo),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: F
+    }, { refs: L, floatingStyles: W, placement: M, isPositioned: N, middlewareData: A } = qr({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: O,
+      whileElementsMounted: (...ue) => _r(...ue, {
+        animationFrame: h === "always"
+      }),
+      elements: {
+        reference: v.anchor
+      },
+      middleware: [
+        Gr({ mainAxis: o + R, alignmentAxis: c }),
+        d && Qr({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: f === "partial" ? Jr() : void 0,
+          ...D
+        }),
+        d && eo({ ...D }),
+        to({
+          ...D,
+          apply: ({ elements: ue, rects: at, availableWidth: pn, availableHeight: vn }) => {
+            const { width: gn, height: wn } = at.reference, pe = ue.floating.style;
+            pe.setProperty("--radix-popper-available-width", `${pn}px`), pe.setProperty("--radix-popper-available-height", `${vn}px`), pe.setProperty("--radix-popper-anchor-width", `${gn}px`), pe.setProperty("--radix-popper-anchor-height", `${wn}px`);
+          }
+        }),
+        y && ro({ element: y, padding: s }),
+        fo({ arrowWidth: E, arrowHeight: R }),
+        m && no({ strategy: "referenceHidden", ...D })
+      ]
+    }), [k, V] = nn(M), me = ie(w);
+    Ve(() => {
+      N && (me == null || me());
+    }, [N, me]);
+    const un = (nt = A.arrow) == null ? void 0 : nt.x, fn = (rt = A.arrow) == null ? void 0 : rt.y, dn = ((ot = A.arrow) == null ? void 0 : ot.centerOffset) !== 0, [hn, mn] = p.useState();
+    return Ve(() => {
+      g && mn(window.getComputedStyle(g).zIndex);
+    }, [g]), /* @__PURE__ */ _(
+      "div",
+      {
+        ref: L.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...W,
+          transform: N ? W.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: hn,
+          "--radix-popper-transform-origin": [
+            (it = A.transformOrigin) == null ? void 0 : it.x,
+            (st = A.transformOrigin) == null ? void 0 : st.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
+          ...((ct = A.hide) == null ? void 0 : ct.referenceHidden) && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        },
+        dir: e.dir,
+        children: /* @__PURE__ */ _(
+          co,
+          {
+            scope: n,
+            placedSide: k,
+            onArrowChange: S,
+            arrowX: un,
+            arrowY: fn,
+            shouldHideArrow: dn,
+            children: /* @__PURE__ */ _(
+              ce.div,
+              {
+                "data-side": k,
+                "data-align": V,
+                ...a,
+                ref: x,
+                style: {
+                  ...a.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"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Jt.displayName = tt;
+var en = "PopperArrow", lo = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, tn = p.forwardRef(function(t, n) {
+  const { __scopePopper: r, ...o } = t, i = ao(en, r), c = lo[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__ */ _(
+      "span",
+      {
+        ref: i.onArrowChange,
+        style: {
+          position: "absolute",
+          left: i.arrowX,
+          top: i.arrowY,
+          [c]: 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__ */ _(
+          io,
+          {
+            ...o,
+            ref: n,
+            style: {
+              ...o.style,
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            }
+          }
+        )
+      }
+    )
+  );
+});
+tn.displayName = en;
+function uo(e) {
+  return e !== null;
+}
+var fo = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(t) {
+    var v, g, b;
+    const { placement: n, rects: r, middlewareData: o } = t, c = ((v = o.arrow) == null ? void 0 : v.centerOffset) !== 0, s = c ? 0 : e.arrowWidth, d = c ? 0 : e.arrowHeight, [l, u] = nn(n), f = { start: "0%", center: "50%", end: "100%" }[u], m = (((g = o.arrow) == null ? void 0 : g.x) ?? 0) + s / 2, h = (((b = o.arrow) == null ? void 0 : b.y) ?? 0) + d / 2;
+    let w = "", a = "";
+    return l === "bottom" ? (w = c ? f : `${m}px`, a = `${-d}px`) : l === "top" ? (w = c ? f : `${m}px`, a = `${r.floating.height + d}px`) : l === "right" ? (w = `${-d}px`, a = c ? f : `${h}px`) : l === "left" && (w = `${r.floating.width + d}px`, a = c ? f : `${h}px`), { data: { x: w, y: a } };
+  }
+});
+function nn(e) {
+  const [t, n = "center"] = e.split("-");
+  return [t, n];
+}
+var ei = Zt, ti = Qt, ni = Jt, ri = tn, ho = function(e) {
+  if (typeof document > "u")
+    return null;
+  var t = Array.isArray(e) ? e[0] : e;
+  return t.ownerDocument.body;
+}, ee = /* @__PURE__ */ new WeakMap(), ge = /* @__PURE__ */ new WeakMap(), we = {}, _e = 0, rn = function(e) {
+  return e && (e.host || rn(e.parentNode));
+}, mo = function(e, t) {
+  return t.map(function(n) {
+    if (e.contains(n))
+      return n;
+    var r = rn(n);
+    return r && e.contains(r) ? r : (console.error("aria-hidden", n, "in not contained inside", e, ". Doing nothing"), null);
+  }).filter(function(n) {
+    return !!n;
+  });
+}, po = function(e, t, n, r) {
+  var o = mo(t, Array.isArray(e) ? e : [e]);
+  we[n] || (we[n] = /* @__PURE__ */ new WeakMap());
+  var i = we[n], c = [], s = /* @__PURE__ */ new Set(), d = new Set(o), l = function(f) {
+    !f || s.has(f) || (s.add(f), l(f.parentNode));
+  };
+  o.forEach(l);
+  var u = function(f) {
+    !f || d.has(f) || Array.prototype.forEach.call(f.children, function(m) {
+      if (s.has(m))
+        u(m);
+      else
+        try {
+          var h = m.getAttribute(r), w = h !== null && h !== "false", a = (ee.get(m) || 0) + 1, v = (i.get(m) || 0) + 1;
+          ee.set(m, a), i.set(m, v), c.push(m), a === 1 && w && ge.set(m, !0), v === 1 && m.setAttribute(n, "true"), w || m.setAttribute(r, "true");
+        } catch (g) {
+          console.error("aria-hidden: cannot operate on ", m, g);
+        }
+    });
+  };
+  return u(t), s.clear(), _e++, function() {
+    c.forEach(function(f) {
+      var m = ee.get(f) - 1, h = i.get(f) - 1;
+      ee.set(f, m), i.set(f, h), m || (ge.has(f) || f.removeAttribute(r), ge.delete(f)), h || f.removeAttribute(n);
+    }), _e--, _e || (ee = /* @__PURE__ */ new WeakMap(), ee = /* @__PURE__ */ new WeakMap(), ge = /* @__PURE__ */ new WeakMap(), we = {});
+  };
+}, oi = function(e, t, n) {
+  n === void 0 && (n = "data-aria-hidden");
+  var r = Array.from(Array.isArray(e) ? e : [e]), o = ho(e);
+  return o ? (r.push.apply(r, Array.from(o.querySelectorAll("[aria-live], script"))), po(r, o, n, "aria-hidden")) : function() {
+    return null;
+  };
+}, Ee = "right-scroll-bar-position", Se = "width-before-scroll-bar", vo = "with-scroll-bars-hidden", go = "--removed-body-scroll-bar-size", on = An(), He = function() {
+}, Me = p.forwardRef(function(e, t) {
+  var n = p.useRef(null), r = p.useState({
+    onScrollCapture: He,
+    onWheelCapture: He,
+    onTouchMoveCapture: He
+  }), o = r[0], i = r[1], c = e.forwardProps, s = e.children, d = e.className, l = e.removeScrollBar, u = e.enabled, f = e.shards, m = e.sideCar, h = e.noRelative, w = e.noIsolation, a = e.inert, v = e.allowPinchZoom, g = e.as, b = g === void 0 ? "div" : g, x = e.gapMode, y = Dt(e, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noRelative", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]), S = m, C = Rn([n, t]), E = Q(Q({}, y), o);
+  return p.createElement(
+    p.Fragment,
+    null,
+    u && p.createElement(S, { sideCar: on, removeScrollBar: l, shards: f, noRelative: h, noIsolation: w, inert: a, setCallbacks: i, allowPinchZoom: !!v, lockRef: n, gapMode: x }),
+    c ? p.cloneElement(p.Children.only(s), Q(Q({}, E), { ref: C })) : p.createElement(b, Q({}, E, { className: d, ref: C }), s)
+  );
+});
+Me.defaultProps = {
+  enabled: !0,
+  removeScrollBar: !0,
+  inert: !1
+};
+Me.classNames = {
+  fullWidth: Se,
+  zeroRight: Ee
+};
+var wo = function() {
+  if (typeof __webpack_nonce__ < "u")
+    return __webpack_nonce__;
+};
+function yo() {
+  if (!document)
+    return null;
+  var e = document.createElement("style");
+  e.type = "text/css";
+  var t = wo();
+  return t && e.setAttribute("nonce", t), e;
+}
+function bo(e, t) {
+  e.styleSheet ? e.styleSheet.cssText = t : e.appendChild(document.createTextNode(t));
+}
+function xo(e) {
+  var t = document.head || document.getElementsByTagName("head")[0];
+  t.appendChild(e);
+}
+var Eo = function() {
+  var e = 0, t = null;
+  return {
+    add: function(n) {
+      e == 0 && (t = yo()) && (bo(t, n), xo(t)), e++;
+    },
+    remove: function() {
+      e--, !e && t && (t.parentNode && t.parentNode.removeChild(t), t = null);
+    }
+  };
+}, So = function() {
+  var e = Eo();
+  return function(t, n) {
+    p.useEffect(function() {
+      return e.add(t), function() {
+        e.remove();
+      };
+    }, [t && n]);
+  };
+}, sn = function() {
+  var e = So(), t = function(n) {
+    var r = n.styles, o = n.dynamic;
+    return e(r, o), null;
+  };
+  return t;
+}, Co = {
+  left: 0,
+  top: 0,
+  right: 0,
+  gap: 0
+}, $e = function(e) {
+  return parseInt(e || "", 10) || 0;
+}, Ao = function(e) {
+  var t = window.getComputedStyle(document.body), n = t[e === "padding" ? "paddingLeft" : "marginLeft"], r = t[e === "padding" ? "paddingTop" : "marginTop"], o = t[e === "padding" ? "paddingRight" : "marginRight"];
+  return [$e(n), $e(r), $e(o)];
+}, Ro = function(e) {
+  if (e === void 0 && (e = "margin"), typeof window > "u")
+    return Co;
+  var t = Ao(e), n = document.documentElement.clientWidth, r = window.innerWidth;
+  return {
+    left: t[0],
+    top: t[1],
+    right: t[2],
+    gap: Math.max(0, r - n + t[2] - t[0])
+  };
+}, Po = sn(), oe = "data-scroll-locked", Oo = function(e, t, n, r) {
+  var o = e.left, i = e.top, c = e.right, s = e.gap;
+  return n === void 0 && (n = "margin"), `
+  .`.concat(vo, ` {
+   overflow: hidden `).concat(r, `;
+   padding-right: `).concat(s, "px ").concat(r, `;
+  }
+  body[`).concat(oe, `] {
+    overflow: hidden `).concat(r, `;
+    overscroll-behavior: contain;
+    `).concat([
+    t && "position: relative ".concat(r, ";"),
+    n === "margin" && `
+    padding-left: `.concat(o, `px;
+    padding-top: `).concat(i, `px;
+    padding-right: `).concat(c, `px;
+    margin-left:0;
+    margin-top:0;
+    margin-right: `).concat(s, "px ").concat(r, `;
+    `),
+    n === "padding" && "padding-right: ".concat(s, "px ").concat(r, ";")
+  ].filter(Boolean).join(""), `
+  }
+  
+  .`).concat(Ee, ` {
+    right: `).concat(s, "px ").concat(r, `;
+  }
+  
+  .`).concat(Se, ` {
+    margin-right: `).concat(s, "px ").concat(r, `;
+  }
+  
+  .`).concat(Ee, " .").concat(Ee, ` {
+    right: 0 `).concat(r, `;
+  }
+  
+  .`).concat(Se, " .").concat(Se, ` {
+    margin-right: 0 `).concat(r, `;
+  }
+  
+  body[`).concat(oe, `] {
+    `).concat(go, ": ").concat(s, `px;
+  }
+`);
+}, Pt = function() {
+  var e = parseInt(document.body.getAttribute(oe) || "0", 10);
+  return isFinite(e) ? e : 0;
+}, Lo = function() {
+  p.useEffect(function() {
+    return document.body.setAttribute(oe, (Pt() + 1).toString()), function() {
+      var e = Pt() - 1;
+      e <= 0 ? document.body.removeAttribute(oe) : document.body.setAttribute(oe, e.toString());
+    };
+  }, []);
+}, To = function(e) {
+  var t = e.noRelative, n = e.noImportant, r = e.gapMode, o = r === void 0 ? "margin" : r;
+  Lo();
+  var i = p.useMemo(function() {
+    return Ro(o);
+  }, [o]);
+  return p.createElement(Po, { styles: Oo(i, !t, o, n ? "" : "!important") });
+}, je = !1;
+if (typeof window < "u")
+  try {
+    var ye = Object.defineProperty({}, "passive", {
+      get: function() {
+        return je = !0, !0;
+      }
+    });
+    window.addEventListener("test", ye, ye), window.removeEventListener("test", ye, ye);
+  } catch {
+    je = !1;
+  }
+var te = je ? { passive: !1 } : !1, Do = function(e) {
+  return e.tagName === "TEXTAREA";
+}, cn = function(e, t) {
+  if (!(e instanceof Element))
+    return !1;
+  var n = window.getComputedStyle(e);
+  return (
+    // not-not-scrollable
+    n[t] !== "hidden" && // contains scroll inside self
+    !(n.overflowY === n.overflowX && !Do(e) && n[t] === "visible")
+  );
+}, Mo = function(e) {
+  return cn(e, "overflowY");
+}, No = function(e) {
+  return cn(e, "overflowX");
+}, Ot = function(e, t) {
+  var n = t.ownerDocument, r = t;
+  do {
+    typeof ShadowRoot < "u" && r instanceof ShadowRoot && (r = r.host);
+    var o = an(e, r);
+    if (o) {
+      var i = ln(e, r), c = i[1], s = i[2];
+      if (c > s)
+        return !0;
+    }
+    r = r.parentNode;
+  } while (r && r !== n.body);
+  return !1;
+}, Fo = function(e) {
+  var t = e.scrollTop, n = e.scrollHeight, r = e.clientHeight;
+  return [
+    t,
+    n,
+    r
+  ];
+}, ko = function(e) {
+  var t = e.scrollLeft, n = e.scrollWidth, r = e.clientWidth;
+  return [
+    t,
+    n,
+    r
+  ];
+}, an = function(e, t) {
+  return e === "v" ? Mo(t) : No(t);
+}, ln = function(e, t) {
+  return e === "v" ? Fo(t) : ko(t);
+}, Wo = function(e, t) {
+  return e === "h" && t === "rtl" ? -1 : 1;
+}, Bo = function(e, t, n, r, o) {
+  var i = Wo(e, window.getComputedStyle(t).direction), c = i * r, s = n.target, d = t.contains(s), l = !1, u = c > 0, f = 0, m = 0;
+  do {
+    if (!s)
+      break;
+    var h = ln(e, s), w = h[0], a = h[1], v = h[2], g = a - v - i * w;
+    (w || g) && an(e, s) && (f += g, m += w);
+    var b = s.parentNode;
+    s = b && b.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? b.host : b;
+  } while (
+    // portaled content
+    !d && s !== document.body || // self content
+    d && (t.contains(s) || t === s)
+  );
+  return (u && Math.abs(f) < 1 || !u && Math.abs(m) < 1) && (l = !0), l;
+}, be = function(e) {
+  return "changedTouches" in e ? [e.changedTouches[0].clientX, e.changedTouches[0].clientY] : [0, 0];
+}, Lt = function(e) {
+  return [e.deltaX, e.deltaY];
+}, Tt = function(e) {
+  return e && "current" in e ? e.current : e;
+}, Io = function(e, t) {
+  return e[0] === t[0] && e[1] === t[1];
+}, _o = function(e) {
+  return `
+  .block-interactivity-`.concat(e, ` {pointer-events: none;}
+  .allow-interactivity-`).concat(e, ` {pointer-events: all;}
+`);
+}, Ho = 0, ne = [];
+function $o(e) {
+  var t = p.useRef([]), n = p.useRef([0, 0]), r = p.useRef(), o = p.useState(Ho++)[0], i = p.useState(sn)[0], c = p.useRef(e);
+  p.useEffect(function() {
+    c.current = e;
+  }, [e]), p.useEffect(function() {
+    if (e.inert) {
+      document.body.classList.add("block-interactivity-".concat(o));
+      var a = Cn([e.lockRef.current], (e.shards || []).map(Tt), !0).filter(Boolean);
+      return a.forEach(function(v) {
+        return v.classList.add("allow-interactivity-".concat(o));
+      }), function() {
+        document.body.classList.remove("block-interactivity-".concat(o)), a.forEach(function(v) {
+          return v.classList.remove("allow-interactivity-".concat(o));
+        });
+      };
+    }
+  }, [e.inert, e.lockRef.current, e.shards]);
+  var s = p.useCallback(function(a, v) {
+    if ("touches" in a && a.touches.length === 2 || a.type === "wheel" && a.ctrlKey)
+      return !c.current.allowPinchZoom;
+    var g = be(a), b = n.current, x = "deltaX" in a ? a.deltaX : b[0] - g[0], y = "deltaY" in a ? a.deltaY : b[1] - g[1], S, C = a.target, E = Math.abs(x) > Math.abs(y) ? "h" : "v";
+    if ("touches" in a && E === "h" && C.type === "range")
+      return !1;
+    var R = window.getSelection(), O = R && R.anchorNode, P = O ? O === C || O.contains(C) : !1;
+    if (P)
+      return !1;
+    var T = Ot(E, C);
+    if (!T)
+      return !0;
+    if (T ? S = E : (S = E === "v" ? "h" : "v", T = Ot(E, C)), !T)
+      return !1;
+    if (!r.current && "changedTouches" in a && (x || y) && (r.current = S), !S)
+      return !0;
+    var F = r.current || S;
+    return Bo(F, v, a, F === "h" ? x : y);
+  }, []), d = p.useCallback(function(a) {
+    var v = a;
+    if (!(!ne.length || ne[ne.length - 1] !== i)) {
+      var g = "deltaY" in v ? Lt(v) : be(v), b = t.current.filter(function(S) {
+        return S.name === v.type && (S.target === v.target || v.target === S.shadowParent) && Io(S.delta, g);
+      })[0];
+      if (b && b.should) {
+        v.cancelable && v.preventDefault();
+        return;
+      }
+      if (!b) {
+        var x = (c.current.shards || []).map(Tt).filter(Boolean).filter(function(S) {
+          return S.contains(v.target);
+        }), y = x.length > 0 ? s(v, x[0]) : !c.current.noIsolation;
+        y && v.cancelable && v.preventDefault();
+      }
+    }
+  }, []), l = p.useCallback(function(a, v, g, b) {
+    var x = { name: a, delta: v, target: g, should: b, shadowParent: Vo(g) };
+    t.current.push(x), setTimeout(function() {
+      t.current = t.current.filter(function(y) {
+        return y !== x;
+      });
+    }, 1);
+  }, []), u = p.useCallback(function(a) {
+    n.current = be(a), r.current = void 0;
+  }, []), f = p.useCallback(function(a) {
+    l(a.type, Lt(a), a.target, s(a, e.lockRef.current));
+  }, []), m = p.useCallback(function(a) {
+    l(a.type, be(a), a.target, s(a, e.lockRef.current));
+  }, []);
+  p.useEffect(function() {
+    return ne.push(i), e.setCallbacks({
+      onScrollCapture: f,
+      onWheelCapture: f,
+      onTouchMoveCapture: m
+    }), document.addEventListener("wheel", d, te), document.addEventListener("touchmove", d, te), document.addEventListener("touchstart", u, te), function() {
+      ne = ne.filter(function(a) {
+        return a !== i;
+      }), document.removeEventListener("wheel", d, te), document.removeEventListener("touchmove", d, te), document.removeEventListener("touchstart", u, te);
+    };
+  }, []);
+  var h = e.removeScrollBar, w = e.inert;
+  return p.createElement(
+    p.Fragment,
+    null,
+    w ? p.createElement(i, { styles: _o(o) }) : null,
+    h ? p.createElement(To, { noRelative: e.noRelative, gapMode: e.gapMode }) : null
+  );
+}
+function Vo(e) {
+  for (var t = null; e !== null; )
+    e instanceof ShadowRoot && (t = e.host, e = e.host), e = e.parentNode;
+  return t;
+}
+const zo = Pn(on, $o);
+var Uo = p.forwardRef(function(e, t) {
+  return p.createElement(Me, Q({}, e, { ref: t, sideCar: zo }));
+});
+Uo.classNames = Me.classNames;
+export {
+  ti as A,
+  ni as C,
+  Mn as D,
+  In as F,
+  Uo as R,
+  ie as a,
+  Go as b,
+  Jo as c,
+  ei as d,
+  ri as e,
+  oi as h,
+  Qo as u
+};