@konstructio/ui 0.1.2-alpha.1 → 0.1.2-alpha.101

package/dist/dist-DnGj9MTf.js

@@ -0,0 +1,1692 @@
+import { a as ge, r as Yt } from "./dist-DqKFpce5.js";
+import { t as we } from "./dist-CVy-ulDZ.js";
+import { t as Gt } from "./dist-C6Cif8-U.js";
+import { a as ot, i as Q, r as Pe, t as qt } from "./dist-CfYOvauX.js";
+import { t as Ut } from "./dist-CeuUxVmT.js";
+import { t as Kt } from "./dist-ppXKUlVt.js";
+import { r as Zt, t as Jt } from "./dist-DGqWMRtc.js";
+import { t as it } from "./dist-eAwtFCCA.js";
+import { t as Qt } from "./dist-DvoMuWKO2.js";
+import * as h from "react";
+import { useLayoutEffect as en } from "react";
+import * as tn from "react-dom";
+import { jsx as P, jsxs as nn } from "react/jsx-runtime";
+var rn = [
+  "top",
+  "right",
+  "bottom",
+  "left"
+], U = Math.min, F = Math.max, de = Math.round, fe = Math.floor, j = (e) => ({
+  x: e,
+  y: e
+}), on = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function Se(e, t, n) {
+  return F(e, U(t, n));
+}
+function Y(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function G(e) {
+  return e.split("-")[0];
+}
+function re(e) {
+  return e.split("-")[1];
+}
+function ke(e) {
+  return e === "x" ? "y" : "x";
+}
+function Ne(e) {
+  return e === "y" ? "height" : "width";
+}
+function z(e) {
+  const t = e[0];
+  return t === "t" || t === "b" ? "y" : "x";
+}
+function $e(e) {
+  return ke(z(e));
+}
+function sn(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = re(e), o = $e(e), i = Ne(o);
+  let s = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = pe(s)), [s, pe(s)];
+}
+function cn(e) {
+  const t = pe(e);
+  return [
+    Le(e),
+    t,
+    Le(t)
+  ];
+}
+function Le(e) {
+  return e.includes("start") ? e.replace("start", "end") : e.replace("end", "start");
+}
+var Ge = ["left", "right"], qe = ["right", "left"], an = ["top", "bottom"], ln = ["bottom", "top"];
+function fn(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? qe : Ge : t ? Ge : qe;
+    case "left":
+    case "right":
+      return t ? an : ln;
+    default:
+      return [];
+  }
+}
+function un(e, t, n, r) {
+  const o = re(e);
+  let i = fn(G(e), n === "start", r);
+  return o && (i = i.map((s) => s + "-" + o), t && (i = i.concat(i.map(Le)))), i;
+}
+function pe(e) {
+  const t = G(e);
+  return on[t] + e.slice(t.length);
+}
+function dn(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function st(e) {
+  return typeof e != "number" ? dn(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function me(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 Ue(e, t, n) {
+  let { reference: r, floating: o } = e;
+  const i = z(t), s = $e(t), c = Ne(s), l = G(t), u = i === "y", a = r.x + r.width / 2 - o.width / 2, d = r.y + r.height / 2 - o.height / 2, p = r[c] / 2 - o[c] / 2;
+  let f;
+  switch (l) {
+    case "top":
+      f = {
+        x: a,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      f = {
+        x: a,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      f = {
+        x: r.x + r.width,
+        y: d
+      };
+      break;
+    case "left":
+      f = {
+        x: r.x - o.width,
+        y: d
+      };
+      break;
+    default:
+      f = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (re(t)) {
+    case "start":
+      f[s] -= p * (n && u ? -1 : 1);
+      break;
+    case "end":
+      f[s] += p * (n && u ? -1 : 1);
+      break;
+  }
+  return f;
+}
+async function pn(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const { x: r, y: o, platform: i, rects: s, elements: c, strategy: l } = e, { boundary: u = "clippingAncestors", rootBoundary: a = "viewport", elementContext: d = "floating", altBoundary: p = !1, padding: f = 0 } = Y(t, e), m = st(f), g = c[p ? d === "floating" ? "reference" : "floating" : d], w = me(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(g))) == null || n ? g : g.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(c.floating)),
+    boundary: u,
+    rootBoundary: a,
+    strategy: l
+  })), v = d === "floating" ? {
+    x: r,
+    y: o,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, x = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(c.floating)), b = 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
+  }, y = me(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: v,
+    offsetParent: x,
+    strategy: l
+  }) : v);
+  return {
+    top: (w.top - y.top + m.top) / b.y,
+    bottom: (y.bottom - w.bottom + m.bottom) / b.y,
+    left: (w.left - y.left + m.left) / b.x,
+    right: (y.right - w.right + m.right) / b.x
+  };
+}
+var mn = 50, hn = async (e, t, n) => {
+  const { placement: r = "bottom", strategy: o = "absolute", middleware: i = [], platform: s } = n, c = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: pn
+  }, l = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let u = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), { x: a, y: d } = Ue(u, r, l), p = r, f = 0;
+  const m = {};
+  for (let g = 0; g < i.length; g++) {
+    const w = i[g];
+    if (!w) continue;
+    const { name: v, fn: x } = w, { x: b, y, data: C, reset: R } = await x({
+      x: a,
+      y: d,
+      initialPlacement: r,
+      placement: p,
+      strategy: o,
+      middlewareData: m,
+      rects: u,
+      platform: c,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    a = b ?? a, d = y ?? d, m[v] = {
+      ...m[v],
+      ...C
+    }, R && f < mn && (f++, typeof R == "object" && (R.placement && (p = R.placement), R.rects && (u = R.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : R.rects), { x: a, y: d } = Ue(u, p, l)), g = -1);
+  }
+  return {
+    x: a,
+    y: d,
+    placement: p,
+    strategy: o,
+    middlewareData: m
+  };
+}, gn = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const { x: n, y: r, placement: o, rects: i, platform: s, elements: c, middlewareData: l } = t, { element: u, padding: a = 0 } = Y(e, t) || {};
+    if (u == null) return {};
+    const d = st(a), p = {
+      x: n,
+      y: r
+    }, f = $e(o), m = Ne(f), g = await s.getDimensions(u), w = f === "y", v = w ? "top" : "left", x = w ? "bottom" : "right", b = w ? "clientHeight" : "clientWidth", y = i.reference[m] + i.reference[f] - p[f] - i.floating[m], C = p[f] - i.reference[f], R = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
+    let O = R ? R[b] : 0;
+    (!O || !await (s.isElement == null ? void 0 : s.isElement(R))) && (O = c.floating[b] || i.floating[m]);
+    const M = y / 2 - C / 2, $ = O / 2 - g[m] / 2 - 1, D = U(d[v], $), N = U(d[x], $), k = D, L = O - g[m] - N, T = O / 2 - g[m] / 2 + M, H = Se(k, T, L), E = !l.arrow && re(o) != null && T !== H && i.reference[m] / 2 - (T < k ? D : N) - g[m] / 2 < 0, S = E ? T < k ? T - k : T - L : 0;
+    return {
+      [f]: p[f] + S,
+      data: {
+        [f]: H,
+        centerOffset: T - H - S,
+        ...E && { alignmentOffset: S }
+      },
+      reset: E
+    };
+  }
+}), wn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const { placement: o, middlewareData: i, rects: s, initialPlacement: c, platform: l, elements: u } = t, { mainAxis: a = !0, crossAxis: d = !0, fallbackPlacements: p, fallbackStrategy: f = "bestFit", fallbackAxisSideDirection: m = "none", flipAlignment: g = !0, ...w } = Y(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset) return {};
+      const v = G(o), x = z(c), b = G(c) === c, y = await (l.isRTL == null ? void 0 : l.isRTL(u.floating)), C = p || (b || !g ? [pe(c)] : cn(c)), R = m !== "none";
+      !p && R && C.push(...un(c, g, m, y));
+      const O = [c, ...C], M = await l.detectOverflow(t, w), $ = [];
+      let D = ((r = i.flip) == null ? void 0 : r.overflows) || [];
+      if (a && $.push(M[v]), d) {
+        const T = sn(o, s, y);
+        $.push(M[T[0]], M[T[1]]);
+      }
+      if (D = [...D, {
+        placement: o,
+        overflows: $
+      }], !$.every((T) => T <= 0)) {
+        var N, k;
+        const T = (((N = i.flip) == null ? void 0 : N.index) || 0) + 1, H = O[T];
+        if (H && (!(d === "alignment" && x !== z(H)) || D.every((S) => z(S.placement) === x ? S.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: T,
+              overflows: D
+            },
+            reset: { placement: H }
+          };
+        let E = (k = D.filter((S) => S.overflows[0] <= 0).sort((S, A) => S.overflows[1] - A.overflows[1])[0]) == null ? void 0 : k.placement;
+        if (!E) switch (f) {
+          case "bestFit": {
+            var L;
+            const S = (L = D.filter((A) => {
+              if (R) {
+                const _ = z(A.placement);
+                return _ === x || _ === "y";
+              }
+              return !0;
+            }).map((A) => [A.placement, A.overflows.filter((_) => _ > 0).reduce((_, I) => _ + I, 0)]).sort((A, _) => A[1] - _[1])[0]) == null ? void 0 : L[0];
+            S && (E = S);
+            break;
+          }
+          case "initialPlacement":
+            E = c;
+            break;
+        }
+        if (o !== E) return { reset: { placement: E } };
+      }
+      return {};
+    }
+  };
+};
+function Ke(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function Ze(e) {
+  return rn.some((t) => e[t] >= 0);
+}
+var vn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const { rects: n, platform: r } = t, { strategy: o = "referenceHidden", ...i } = Y(e, t);
+      switch (o) {
+        case "referenceHidden": {
+          const s = Ke(await r.detectOverflow(t, {
+            ...i,
+            elementContext: "reference"
+          }), n.reference);
+          return { data: {
+            referenceHiddenOffsets: s,
+            referenceHidden: Ze(s)
+          } };
+        }
+        case "escaped": {
+          const s = Ke(await r.detectOverflow(t, {
+            ...i,
+            altBoundary: !0
+          }), n.floating);
+          return { data: {
+            escapedOffsets: s,
+            escaped: Ze(s)
+          } };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, ct = /* @__PURE__ */ new Set(["left", "top"]);
+async function xn(e, t) {
+  const { placement: n, platform: r, elements: o } = e, i = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), s = G(n), c = re(n), l = z(n) === "y", u = ct.has(s) ? -1 : 1, a = i && l ? -1 : 1, d = Y(t, e);
+  let { mainAxis: p, crossAxis: f, alignmentAxis: m } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: d.mainAxis || 0,
+    crossAxis: d.crossAxis || 0,
+    alignmentAxis: d.alignmentAxis
+  };
+  return c && typeof m == "number" && (f = c === "end" ? m * -1 : m), l ? {
+    x: f * a,
+    y: p * u
+  } : {
+    x: p * u,
+    y: f * a
+  };
+}
+var yn = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const { x: o, y: i, placement: s, middlewareData: c } = t, l = await xn(t, e);
+      return s === ((n = c.offset) == null ? void 0 : n.placement) && (r = c.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + l.x,
+        y: i + l.y,
+        data: {
+          ...l,
+          placement: s
+        }
+      };
+    }
+  };
+}, bn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const { x: n, y: r, placement: o, platform: i } = t, { mainAxis: s = !0, crossAxis: c = !1, limiter: l = { fn: (v) => {
+        let { x, y: b } = v;
+        return {
+          x,
+          y: b
+        };
+      } }, ...u } = Y(e, t), a = {
+        x: n,
+        y: r
+      }, d = await i.detectOverflow(t, u), p = z(G(o)), f = ke(p);
+      let m = a[f], g = a[p];
+      if (s) {
+        const v = f === "y" ? "top" : "left", x = f === "y" ? "bottom" : "right", b = m + d[v], y = m - d[x];
+        m = Se(b, m, y);
+      }
+      if (c) {
+        const v = p === "y" ? "top" : "left", x = p === "y" ? "bottom" : "right", b = g + d[v], y = g - d[x];
+        g = Se(b, g, y);
+      }
+      const w = l.fn({
+        ...t,
+        [f]: m,
+        [p]: g
+      });
+      return {
+        ...w,
+        data: {
+          x: w.x - n,
+          y: w.y - r,
+          enabled: {
+            [f]: s,
+            [p]: c
+          }
+        }
+      };
+    }
+  };
+}, Rn = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const { x: n, y: r, placement: o, rects: i, middlewareData: s } = t, { offset: c = 0, mainAxis: l = !0, crossAxis: u = !0 } = Y(e, t), a = {
+        x: n,
+        y: r
+      }, d = z(o), p = ke(d);
+      let f = a[p], m = a[d];
+      const g = Y(c, t), w = typeof g == "number" ? {
+        mainAxis: g,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...g
+      };
+      if (l) {
+        const b = p === "y" ? "height" : "width", y = i.reference[p] - i.floating[b] + w.mainAxis, C = i.reference[p] + i.reference[b] - w.mainAxis;
+        f < y ? f = y : f > C && (f = C);
+      }
+      if (u) {
+        var v, x;
+        const b = p === "y" ? "width" : "height", y = ct.has(G(o)), C = i.reference[d] - i.floating[b] + (y && ((v = s.offset) == null ? void 0 : v[d]) || 0) + (y ? 0 : w.crossAxis), R = i.reference[d] + i.reference[b] + (y ? 0 : ((x = s.offset) == null ? void 0 : x[d]) || 0) - (y ? w.crossAxis : 0);
+        m < C ? m = C : m > R && (m = R);
+      }
+      return {
+        [p]: f,
+        [d]: m
+      };
+    }
+  };
+}, Cn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const { placement: o, rects: i, platform: s, elements: c } = t, { apply: l = () => {
+      }, ...u } = Y(e, t), a = await s.detectOverflow(t, u), d = G(o), p = re(o), f = z(o) === "y", { width: m, height: g } = i.floating;
+      let w, v;
+      d === "top" || d === "bottom" ? (w = d, v = p === (await (s.isRTL == null ? void 0 : s.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (v = d, w = p === "end" ? "top" : "bottom");
+      const x = g - a.top - a.bottom, b = m - a.left - a.right, y = U(g - a[w], x), C = U(m - a[v], b), R = !t.middlewareData.shift;
+      let O = y, M = C;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (M = b), (r = t.middlewareData.shift) != null && r.enabled.y && (O = x), R && !p) {
+        const D = F(a.left, 0), N = F(a.right, 0), k = F(a.top, 0), L = F(a.bottom, 0);
+        f ? M = m - 2 * (D !== 0 || N !== 0 ? D + N : F(a.left, a.right)) : O = g - 2 * (k !== 0 || L !== 0 ? k + L : F(a.top, a.bottom));
+      }
+      await l({
+        ...t,
+        availableWidth: M,
+        availableHeight: O
+      });
+      const $ = await s.getDimensions(c.floating);
+      return m !== $.width || g !== $.height ? { reset: { rects: !0 } } : {};
+    }
+  };
+};
+function ve() {
+  return typeof window < "u";
+}
+function oe(e) {
+  return at(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function W(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function X(e) {
+  var t;
+  return (t = (at(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function at(e) {
+  return ve() ? e instanceof Node || e instanceof W(e).Node : !1;
+}
+function B(e) {
+  return ve() ? e instanceof Element || e instanceof W(e).Element : !1;
+}
+function q(e) {
+  return ve() ? e instanceof HTMLElement || e instanceof W(e).HTMLElement : !1;
+}
+function Je(e) {
+  return !ve() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof W(e).ShadowRoot;
+}
+function ce(e) {
+  const { overflow: t, overflowX: n, overflowY: r, display: o } = V(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && o !== "inline" && o !== "contents";
+}
+function An(e) {
+  return /^(table|td|th)$/.test(oe(e));
+}
+function xe(e) {
+  try {
+    if (e.matches(":popover-open")) return !0;
+  } catch {
+  }
+  try {
+    return e.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+var Pn = /transform|translate|scale|rotate|perspective|filter/, On = /paint|layout|strict|content/, Z = (e) => !!e && e !== "none", Oe;
+function He(e) {
+  const t = B(e) ? V(e) : e;
+  return Z(t.transform) || Z(t.translate) || Z(t.scale) || Z(t.rotate) || Z(t.perspective) || !Fe() && (Z(t.backdropFilter) || Z(t.filter)) || Pn.test(t.willChange || "") || On.test(t.contain || "");
+}
+function Tn(e) {
+  let t = K(e);
+  for (; q(t) && !te(t); ) {
+    if (He(t)) return t;
+    if (xe(t)) return null;
+    t = K(t);
+  }
+  return null;
+}
+function Fe() {
+  return Oe == null && (Oe = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), Oe;
+}
+function te(e) {
+  return /^(html|body|#document)$/.test(oe(e));
+}
+function V(e) {
+  return W(e).getComputedStyle(e);
+}
+function ye(e) {
+  return B(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function K(e) {
+  if (oe(e) === "html") return e;
+  const t = e.assignedSlot || e.parentNode || Je(e) && e.host || X(e);
+  return Je(t) ? t.host : t;
+}
+function lt(e) {
+  const t = K(e);
+  return te(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : q(t) && ce(t) ? t : lt(t);
+}
+function ie(e, t, n) {
+  var r;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = lt(e), i = o === ((r = e.ownerDocument) == null ? void 0 : r.body), s = W(o);
+  if (i) {
+    const c = De(s);
+    return t.concat(s, s.visualViewport || [], ce(o) ? o : [], c && n ? ie(c) : []);
+  } else return t.concat(o, ie(o, [], n));
+}
+function De(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function ft(e) {
+  const t = V(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = q(e), i = o ? e.offsetWidth : n, s = o ? e.offsetHeight : r, c = de(n) !== i || de(r) !== s;
+  return c && (n = i, r = s), {
+    width: n,
+    height: r,
+    $: c
+  };
+}
+function We(e) {
+  return B(e) ? e : e.contextElement;
+}
+function ee(e) {
+  const t = We(e);
+  if (!q(t)) return j(1);
+  const n = t.getBoundingClientRect(), { width: r, height: o, $: i } = ft(t);
+  let s = (i ? de(n.width) : n.width) / r, c = (i ? de(n.height) : n.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+var En = /* @__PURE__ */ j(0);
+function ut(e) {
+  const t = W(e);
+  return !Fe() || !t.visualViewport ? En : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Sn(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== W(e) ? !1 : t;
+}
+function J(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = We(e);
+  let s = j(1);
+  t && (r ? B(r) && (s = ee(r)) : s = ee(e));
+  const c = Sn(i, n, r) ? ut(i) : j(0);
+  let l = (o.left + c.x) / s.x, u = (o.top + c.y) / s.y, a = o.width / s.x, d = o.height / s.y;
+  if (i) {
+    const p = W(i), f = r && B(r) ? W(r) : r;
+    let m = p, g = De(m);
+    for (; g && r && f !== m; ) {
+      const w = ee(g), v = g.getBoundingClientRect(), x = V(g), b = v.left + (g.clientLeft + parseFloat(x.paddingLeft)) * w.x, y = v.top + (g.clientTop + parseFloat(x.paddingTop)) * w.y;
+      l *= w.x, u *= w.y, a *= w.x, d *= w.y, l += b, u += y, m = W(g), g = De(m);
+    }
+  }
+  return me({
+    width: a,
+    height: d,
+    x: l,
+    y: u
+  });
+}
+function be(e, t) {
+  const n = ye(e).scrollLeft;
+  return t ? t.left + n : J(X(e)).left + n;
+}
+function dt(e, t) {
+  const n = e.getBoundingClientRect();
+  return {
+    x: n.left + t.scrollLeft - be(e, n),
+    y: n.top + t.scrollTop
+  };
+}
+function Ln(e) {
+  let { elements: t, rect: n, offsetParent: r, strategy: o } = e;
+  const i = o === "fixed", s = X(r), c = t ? xe(t.floating) : !1;
+  if (r === s || c && i) return n;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = j(1);
+  const a = j(0), d = q(r);
+  if ((d || !d && !i) && ((oe(r) !== "body" || ce(s)) && (l = ye(r)), d)) {
+    const f = J(r);
+    u = ee(r), a.x = f.x + r.clientLeft, a.y = f.y + r.clientTop;
+  }
+  const p = s && !d && !i ? dt(s, l) : j(0);
+  return {
+    width: n.width * u.x,
+    height: n.height * u.y,
+    x: n.x * u.x - l.scrollLeft * u.x + a.x + p.x,
+    y: n.y * u.y - l.scrollTop * u.y + a.y + p.y
+  };
+}
+function Dn(e) {
+  return Array.from(e.getClientRects());
+}
+function Mn(e) {
+  const t = X(e), n = ye(e), r = e.ownerDocument.body, o = F(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), i = F(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let s = -n.scrollLeft + be(e);
+  const c = -n.scrollTop;
+  return V(r).direction === "rtl" && (s += F(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: s,
+    y: c
+  };
+}
+var Qe = 25;
+function _n(e, t) {
+  const n = W(e), r = X(e), o = n.visualViewport;
+  let i = r.clientWidth, s = r.clientHeight, c = 0, l = 0;
+  if (o) {
+    i = o.width, s = o.height;
+    const a = Fe();
+    (!a || a && t === "fixed") && (c = o.offsetLeft, l = o.offsetTop);
+  }
+  const u = be(r);
+  if (u <= 0) {
+    const a = r.ownerDocument, d = a.body, p = getComputedStyle(d), f = a.compatMode === "CSS1Compat" && parseFloat(p.marginLeft) + parseFloat(p.marginRight) || 0, m = Math.abs(r.clientWidth - d.clientWidth - f);
+    m <= Qe && (i -= m);
+  } else u <= Qe && (i += u);
+  return {
+    width: i,
+    height: s,
+    x: c,
+    y: l
+  };
+}
+function kn(e, t) {
+  const n = J(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, i = q(e) ? ee(e) : j(1);
+  return {
+    width: e.clientWidth * i.x,
+    height: e.clientHeight * i.y,
+    x: o * i.x,
+    y: r * i.y
+  };
+}
+function et(e, t, n) {
+  let r;
+  if (t === "viewport") r = _n(e, n);
+  else if (t === "document") r = Mn(X(e));
+  else if (B(t)) r = kn(t, n);
+  else {
+    const o = ut(e);
+    r = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return me(r);
+}
+function pt(e, t) {
+  const n = K(e);
+  return n === t || !B(n) || te(n) ? !1 : V(n).position === "fixed" || pt(n, t);
+}
+function Nn(e, t) {
+  const n = t.get(e);
+  if (n) return n;
+  let r = ie(e, [], !1).filter((c) => B(c) && oe(c) !== "body"), o = null;
+  const i = V(e).position === "fixed";
+  let s = i ? K(e) : e;
+  for (; B(s) && !te(s); ) {
+    const c = V(s), l = He(s);
+    !l && c.position === "fixed" && (o = null), (i ? !l && !o : !l && c.position === "static" && o && (o.position === "absolute" || o.position === "fixed") || ce(s) && !l && pt(e, s)) ? r = r.filter((u) => u !== s) : o = c, s = K(s);
+  }
+  return t.set(e, r), r;
+}
+function $n(e) {
+  let { element: t, boundary: n, rootBoundary: r, strategy: o } = e;
+  const i = [...n === "clippingAncestors" ? xe(t) ? [] : Nn(t, this._c) : [].concat(n), r], s = et(t, i[0], o);
+  let c = s.top, l = s.right, u = s.bottom, a = s.left;
+  for (let d = 1; d < i.length; d++) {
+    const p = et(t, i[d], o);
+    c = F(p.top, c), l = U(p.right, l), u = U(p.bottom, u), a = F(p.left, a);
+  }
+  return {
+    width: l - a,
+    height: u - c,
+    x: a,
+    y: c
+  };
+}
+function Hn(e) {
+  const { width: t, height: n } = ft(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function Fn(e, t, n) {
+  const r = q(t), o = X(t), i = n === "fixed", s = J(e, !0, i, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = j(0);
+  function u() {
+    l.x = be(o);
+  }
+  if (r || !r && !i)
+    if ((oe(t) !== "body" || ce(o)) && (c = ye(t)), r) {
+      const d = J(t, !0, i, t);
+      l.x = d.x + t.clientLeft, l.y = d.y + t.clientTop;
+    } else o && u();
+  i && !r && o && u();
+  const a = o && !r && !i ? dt(o, c) : j(0);
+  return {
+    x: s.left + c.scrollLeft - l.x - a.x,
+    y: s.top + c.scrollTop - l.y - a.y,
+    width: s.width,
+    height: s.height
+  };
+}
+function Te(e) {
+  return V(e).position === "static";
+}
+function tt(e, t) {
+  if (!q(e) || V(e).position === "fixed") return null;
+  if (t) return t(e);
+  let n = e.offsetParent;
+  return X(e) === n && (n = n.ownerDocument.body), n;
+}
+function mt(e, t) {
+  const n = W(e);
+  if (xe(e)) return n;
+  if (!q(e)) {
+    let o = K(e);
+    for (; o && !te(o); ) {
+      if (B(o) && !Te(o)) return o;
+      o = K(o);
+    }
+    return n;
+  }
+  let r = tt(e, t);
+  for (; r && An(r) && Te(r); ) r = tt(r, t);
+  return r && te(r) && Te(r) && !He(r) ? n : r || Tn(e) || n;
+}
+var Wn = async function(e) {
+  const t = this.getOffsetParent || mt, n = this.getDimensions, r = await n(e.floating);
+  return {
+    reference: Fn(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function In(e) {
+  return V(e).direction === "rtl";
+}
+var Bn = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ln,
+  getDocumentElement: X,
+  getClippingRect: $n,
+  getOffsetParent: mt,
+  getElementRects: Wn,
+  getClientRects: Dn,
+  getDimensions: Hn,
+  getScale: ee,
+  isElement: B,
+  isRTL: In
+};
+function ht(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Vn(e, t) {
+  let n = null, r;
+  const o = X(e);
+  function i() {
+    var c;
+    clearTimeout(r), (c = n) == null || c.disconnect(), n = null;
+  }
+  function s(c, l) {
+    c === void 0 && (c = !1), l === void 0 && (l = 1), i();
+    const u = e.getBoundingClientRect(), { left: a, top: d, width: p, height: f } = u;
+    if (c || t(), !p || !f) return;
+    const m = fe(d), g = fe(o.clientWidth - (a + p)), w = fe(o.clientHeight - (d + f)), v = fe(a), x = {
+      rootMargin: -m + "px " + -g + "px " + -w + "px " + -v + "px",
+      threshold: F(0, U(1, l)) || 1
+    };
+    let b = !0;
+    function y(C) {
+      const R = C[0].intersectionRatio;
+      if (R !== l) {
+        if (!b) return s();
+        R ? s(!1, R) : r = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      R === 1 && !ht(u, e.getBoundingClientRect()) && s(), b = !1;
+    }
+    try {
+      n = new IntersectionObserver(y, {
+        ...x,
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(y, x);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function zn(e, t, n, r) {
+  r === void 0 && (r = {});
+  const { ancestorScroll: o = !0, ancestorResize: i = !0, elementResize: s = typeof ResizeObserver == "function", layoutShift: c = typeof IntersectionObserver == "function", animationFrame: l = !1 } = r, u = We(e), a = o || i ? [...u ? ie(u) : [], ...t ? ie(t) : []] : [];
+  a.forEach((v) => {
+    o && v.addEventListener("scroll", n, { passive: !0 }), i && v.addEventListener("resize", n);
+  });
+  const d = u && c ? Vn(u, n) : null;
+  let p = -1, f = null;
+  s && (f = new ResizeObserver((v) => {
+    let [x] = v;
+    x && x.target === u && f && t && (f.unobserve(t), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var b;
+      (b = f) == null || b.observe(t);
+    })), n();
+  }), u && !l && f.observe(u), t && f.observe(t));
+  let m, g = l ? J(e) : null;
+  l && w();
+  function w() {
+    const v = J(e);
+    g && !ht(g, v) && n(), g = v, m = requestAnimationFrame(w);
+  }
+  return n(), () => {
+    var v;
+    a.forEach((x) => {
+      o && x.removeEventListener("scroll", n), i && x.removeEventListener("resize", n);
+    }), d?.(), (v = f) == null || v.disconnect(), f = null, l && cancelAnimationFrame(m);
+  };
+}
+var jn = yn, Xn = bn, Yn = wn, Gn = Cn, qn = vn, nt = gn, Un = Rn, Kn = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: Bn,
+    ...n
+  }, i = {
+    ...o.platform,
+    _c: r
+  };
+  return hn(e, t, {
+    ...o,
+    platform: i
+  });
+}, ue = typeof document < "u" ? en : function() {
+};
+function he(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 (!he(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) && !he(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function gt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function rt(e, t) {
+  const n = gt(e);
+  return Math.round(t * n) / n;
+}
+function Ee(e) {
+  const t = h.useRef(e);
+  return ue(() => {
+    t.current = e;
+  }), t;
+}
+function Zn(e) {
+  e === void 0 && (e = {});
+  const { placement: t = "bottom", strategy: n = "absolute", middleware: r = [], platform: o, elements: { reference: i, floating: s } = {}, transform: c = !0, whileElementsMounted: l, open: u } = e, [a, d] = h.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [p, f] = h.useState(r);
+  he(p, r) || f(r);
+  const [m, g] = h.useState(null), [w, v] = h.useState(null), x = h.useCallback((A) => {
+    A !== R.current && (R.current = A, g(A));
+  }, []), b = h.useCallback((A) => {
+    A !== O.current && (O.current = A, v(A));
+  }, []), y = i || m, C = s || w, R = h.useRef(null), O = h.useRef(null), M = h.useRef(a), $ = l != null, D = Ee(l), N = Ee(o), k = Ee(u), L = h.useCallback(() => {
+    if (!R.current || !O.current) return;
+    const A = {
+      placement: t,
+      strategy: n,
+      middleware: p
+    };
+    N.current && (A.platform = N.current), Kn(R.current, O.current, A).then((_) => {
+      const I = {
+        ..._,
+        isPositioned: k.current !== !1
+      };
+      T.current && !he(M.current, I) && (M.current = I, tn.flushSync(() => {
+        d(I);
+      }));
+    });
+  }, [
+    p,
+    t,
+    n,
+    N,
+    k
+  ]);
+  ue(() => {
+    u === !1 && M.current.isPositioned && (M.current.isPositioned = !1, d((A) => ({
+      ...A,
+      isPositioned: !1
+    })));
+  }, [u]);
+  const T = h.useRef(!1);
+  ue(() => (T.current = !0, () => {
+    T.current = !1;
+  }), []), ue(() => {
+    if (y && (R.current = y), C && (O.current = C), y && C) {
+      if (D.current) return D.current(y, C, L);
+      L();
+    }
+  }, [
+    y,
+    C,
+    L,
+    D,
+    $
+  ]);
+  const H = h.useMemo(() => ({
+    reference: R,
+    floating: O,
+    setReference: x,
+    setFloating: b
+  }), [x, b]), E = h.useMemo(() => ({
+    reference: y,
+    floating: C
+  }), [y, C]), S = h.useMemo(() => {
+    const A = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!E.floating) return A;
+    const _ = rt(E.floating, a.x), I = rt(E.floating, a.y);
+    return c ? {
+      ...A,
+      transform: "translate(" + _ + "px, " + I + "px)",
+      ...gt(E.floating) >= 1.5 && { willChange: "transform" }
+    } : {
+      position: n,
+      left: _,
+      top: I
+    };
+  }, [
+    n,
+    c,
+    E.floating,
+    a.x,
+    a.y
+  ]);
+  return h.useMemo(() => ({
+    ...a,
+    update: L,
+    refs: H,
+    elements: E,
+    floatingStyles: S
+  }), [
+    a,
+    L,
+    H,
+    E,
+    S
+  ]);
+}
+var Jn = (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 ? nt({
+        element: r.current,
+        padding: o
+      }).fn(n) : {} : r ? nt({
+        element: r,
+        padding: o
+      }).fn(n) : {};
+    }
+  };
+}, Qn = (e, t) => {
+  const n = jn(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, er = (e, t) => {
+  const n = Xn(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, tr = (e, t) => ({
+  fn: Un(e).fn,
+  options: [e, t]
+}), nr = (e, t) => {
+  const n = Yn(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, rr = (e, t) => {
+  const n = Gn(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, or = (e, t) => {
+  const n = qn(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, ir = (e, t) => {
+  const n = Jn(e);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [e, t]
+  };
+}, sr = "Arrow", wt = h.forwardRef((e, t) => {
+  const { children: n, width: r = 10, height: o = 5, ...i } = e;
+  return /* @__PURE__ */ P(we.svg, {
+    ...i,
+    ref: t,
+    width: r,
+    height: o,
+    viewBox: "0 0 30 10",
+    preserveAspectRatio: "none",
+    children: e.asChild ? n : /* @__PURE__ */ P("polygon", { points: "0,0 30,0 15,10" })
+  });
+});
+wt.displayName = sr;
+var cr = wt, Ie = "Popper", [vt, xt] = ot(Ie), [ar, yt] = vt(Ie), bt = (e) => {
+  const { __scopePopper: t, children: n } = e, [r, o] = h.useState(null), [i, s] = h.useState(void 0);
+  return /* @__PURE__ */ P(ar, {
+    scope: t,
+    anchor: r,
+    onAnchorChange: o,
+    placementState: i,
+    setPlacementState: s,
+    children: n
+  });
+};
+bt.displayName = Ie;
+var Rt = "PopperAnchor", Ct = h.forwardRef((e, t) => {
+  const { __scopePopper: n, virtualRef: r, ...o } = e, i = yt(Rt, n), s = h.useRef(null), c = i.onAnchorChange, l = ge(t, h.useCallback((f) => {
+    s.current = f, f && c(f);
+  }, [c])), u = h.useRef(null);
+  h.useEffect(() => {
+    if (!r) return;
+    const f = u.current;
+    u.current = r.current, f !== u.current && c(u.current);
+  });
+  const a = i.placementState && Ve(i.placementState), d = a?.[0], p = a?.[1];
+  return r ? null : /* @__PURE__ */ P(we.div, {
+    "data-radix-popper-side": d,
+    "data-radix-popper-align": p,
+    ...o,
+    ref: l
+  });
+});
+Ct.displayName = Rt;
+var Be = "PopperContent", [lr, fr] = vt(Be), At = h.forwardRef((e, t) => {
+  const { __scopePopper: n, side: r = "bottom", sideOffset: o = 0, align: i = "center", alignOffset: s = 0, arrowPadding: c = 0, avoidCollisions: l = !0, collisionBoundary: u = [], collisionPadding: a = 0, sticky: d = "partial", hideWhenDetached: p = !1, updatePositionStrategy: f = "optimized", onPlaced: m, ...g } = e, w = yt(Be, n), [v, x] = h.useState(null), b = ge(t, x), [y, C] = h.useState(null), R = Qt(y), O = R?.width ?? 0, M = R?.height ?? 0, $ = r + (i !== "center" ? "-" + i : ""), D = typeof a == "number" ? a : {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...a
+  }, N = Array.isArray(u) ? u : [u], k = N.length > 0, L = {
+    padding: D,
+    boundary: N.filter(dr),
+    altBoundary: k
+  }, { refs: T, floatingStyles: H, placement: E, isPositioned: S, middlewareData: A } = Zn({
+    strategy: "fixed",
+    placement: $,
+    whileElementsMounted: (...Ae) => zn(...Ae, { animationFrame: f === "always" }),
+    elements: { reference: w.anchor },
+    middleware: [
+      Qn({
+        mainAxis: o + M,
+        alignmentAxis: s
+      }),
+      l && er({
+        mainAxis: !0,
+        crossAxis: !1,
+        limiter: d === "partial" ? tr() : void 0,
+        ...L
+      }),
+      l && nr({ ...L }),
+      rr({
+        ...L,
+        apply: ({ elements: Ae, rects: Bt, availableWidth: Vt, availableHeight: zt }) => {
+          const { width: jt, height: Xt } = Bt.reference, le = Ae.floating.style;
+          le.setProperty("--radix-popper-available-width", `${Vt}px`), le.setProperty("--radix-popper-available-height", `${zt}px`), le.setProperty("--radix-popper-anchor-width", `${jt}px`), le.setProperty("--radix-popper-anchor-height", `${Xt}px`);
+        }
+      }),
+      y && ir({
+        element: y,
+        padding: c
+      }),
+      pr({
+        arrowWidth: O,
+        arrowHeight: M
+      }),
+      p && or({
+        strategy: "referenceHidden",
+        ...L,
+        boundary: k ? L.boundary : void 0
+      })
+    ]
+  }), _ = w.setPlacementState;
+  Pe(() => (_(E), () => {
+    _(void 0);
+  }), [E, _]);
+  const [I, Xe] = Ve(E), Ye = Kt(m);
+  Pe(() => {
+    S && Ye?.();
+  }, [S, Ye]);
+  const $t = A.arrow?.x, Ht = A.arrow?.y, Ft = A.arrow?.centerOffset !== 0, [Wt, It] = h.useState();
+  return Pe(() => {
+    v && It(window.getComputedStyle(v).zIndex);
+  }, [v]), /* @__PURE__ */ P("div", {
+    ref: T.setFloating,
+    "data-radix-popper-content-wrapper": "",
+    style: {
+      ...H,
+      transform: S ? H.transform : "translate(0, -200%)",
+      minWidth: "max-content",
+      zIndex: Wt,
+      "--radix-popper-transform-origin": [A.transformOrigin?.x, A.transformOrigin?.y].join(" "),
+      ...A.hide?.referenceHidden && {
+        visibility: "hidden",
+        pointerEvents: "none"
+      }
+    },
+    dir: e.dir,
+    children: /* @__PURE__ */ P(lr, {
+      scope: n,
+      placedSide: I,
+      placedAlign: Xe,
+      onArrowChange: C,
+      arrowX: $t,
+      arrowY: Ht,
+      shouldHideArrow: Ft,
+      children: /* @__PURE__ */ P(we.div, {
+        "data-side": I,
+        "data-align": Xe,
+        ...g,
+        ref: b,
+        style: {
+          ...g.style,
+          animation: S ? void 0 : "none"
+        }
+      })
+    })
+  });
+});
+At.displayName = Be;
+var Pt = "PopperArrow", ur = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, Ot = h.forwardRef(function(t, n) {
+  const { __scopePopper: r, ...o } = t, i = fr(Pt, r), s = ur[i.placedSide];
+  return /* @__PURE__ */ P("span", {
+    ref: i.onArrowChange,
+    style: {
+      position: "absolute",
+      left: i.arrowX,
+      top: i.arrowY,
+      [s]: 0,
+      transformOrigin: {
+        top: "",
+        right: "0 0",
+        bottom: "center 0",
+        left: "100% 0"
+      }[i.placedSide],
+      transform: {
+        top: "translateY(100%)",
+        right: "translateY(50%) rotate(90deg) translateX(-50%)",
+        bottom: "rotate(180deg)",
+        left: "translateY(50%) rotate(-90deg) translateX(50%)"
+      }[i.placedSide],
+      visibility: i.shouldHideArrow ? "hidden" : void 0
+    },
+    children: /* @__PURE__ */ P(cr, {
+      ...o,
+      ref: n,
+      style: {
+        ...o.style,
+        display: "block"
+      }
+    })
+  });
+});
+Ot.displayName = Pt;
+function dr(e) {
+  return e !== null;
+}
+var pr = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(t) {
+    const { placement: n, rects: r, middlewareData: o } = t, i = o.arrow?.centerOffset !== 0, s = i ? 0 : e.arrowWidth, c = i ? 0 : e.arrowHeight, [l, u] = Ve(n), a = {
+      start: "0%",
+      center: "50%",
+      end: "100%"
+    }[u], d = (o.arrow?.x ?? 0) + s / 2, p = (o.arrow?.y ?? 0) + c / 2;
+    let f = "", m = "";
+    return l === "bottom" ? (f = i ? a : `${d}px`, m = `${-c}px`) : l === "top" ? (f = i ? a : `${d}px`, m = `${r.floating.height + c}px`) : l === "right" ? (f = `${-c}px`, m = i ? a : `${p}px`) : l === "left" && (f = `${r.floating.width + c}px`, m = i ? a : `${p}px`), { data: {
+      x: f,
+      y: m
+    } };
+  }
+});
+function Ve(e) {
+  const [t, n = "center"] = e.split("-");
+  return [t, n];
+}
+var mr = bt, hr = Ct, gr = At, wr = Ot, [Re, jr] = ot("Tooltip", [xt]), Ce = xt(), Tt = "TooltipProvider", vr = 700, Me = "tooltip.open", [xr, ze] = Re(Tt), Et = (e) => {
+  const { __scopeTooltip: t, delayDuration: n = vr, skipDelayDuration: r = 300, disableHoverableContent: o = !1, children: i } = e, s = h.useRef(!0), c = h.useRef(!1), l = h.useRef(0);
+  return h.useEffect(() => {
+    const u = l.current;
+    return () => window.clearTimeout(u);
+  }, []), /* @__PURE__ */ P(xr, {
+    scope: t,
+    isOpenDelayedRef: s,
+    delayDuration: n,
+    onOpen: h.useCallback(() => {
+      r <= 0 || (window.clearTimeout(l.current), s.current = !1);
+    }, [r]),
+    onClose: h.useCallback(() => {
+      r <= 0 || (window.clearTimeout(l.current), l.current = window.setTimeout(() => s.current = !0, r));
+    }, [r]),
+    isPointerInTransitRef: c,
+    onPointerInTransitChange: h.useCallback((u) => {
+      c.current = u;
+    }, []),
+    disableHoverableContent: o,
+    children: i
+  });
+};
+Et.displayName = Tt;
+var se = "Tooltip", [yr, ae] = Re(se), St = (e) => {
+  const { __scopeTooltip: t, children: n, open: r, defaultOpen: o, onOpenChange: i, disableHoverableContent: s, delayDuration: c } = e, l = ze(se, e.__scopeTooltip), u = Ce(t), [a, d] = h.useState(null), p = Ut(), f = h.useRef(0), m = s ?? l.disableHoverableContent, g = c ?? l.delayDuration, w = h.useRef(!1), [v, x] = qt({
+    prop: r,
+    defaultProp: o ?? !1,
+    onChange: (O) => {
+      O ? (l.onOpen(), document.dispatchEvent(new CustomEvent(Me))) : l.onClose(), i?.(O);
+    },
+    caller: se
+  }), b = h.useMemo(() => v ? w.current ? "delayed-open" : "instant-open" : "closed", [v]), y = h.useCallback(() => {
+    window.clearTimeout(f.current), f.current = 0, w.current = !1, x(!0);
+  }, [x]), C = h.useCallback(() => {
+    window.clearTimeout(f.current), f.current = 0, x(!1);
+  }, [x]), R = h.useCallback(() => {
+    window.clearTimeout(f.current), f.current = window.setTimeout(() => {
+      w.current = !0, x(!0), f.current = 0;
+    }, g);
+  }, [g, x]);
+  return h.useEffect(() => () => {
+    f.current && (window.clearTimeout(f.current), f.current = 0);
+  }, []), /* @__PURE__ */ P(mr, {
+    ...u,
+    children: /* @__PURE__ */ P(yr, {
+      scope: t,
+      contentId: p,
+      open: v,
+      stateAttribute: b,
+      trigger: a,
+      onTriggerChange: d,
+      onTriggerEnter: h.useCallback(() => {
+        l.isOpenDelayedRef.current ? R() : y();
+      }, [
+        l.isOpenDelayedRef,
+        R,
+        y
+      ]),
+      onTriggerLeave: h.useCallback(() => {
+        m ? C() : (window.clearTimeout(f.current), f.current = 0);
+      }, [C, m]),
+      onOpen: y,
+      onClose: C,
+      disableHoverableContent: m,
+      children: n
+    })
+  });
+};
+St.displayName = se;
+var _e = "TooltipTrigger", Lt = h.forwardRef((e, t) => {
+  const { __scopeTooltip: n, ...r } = e, o = ae(_e, n), i = ze(_e, n), s = Ce(n), c = ge(t, h.useRef(null), o.onTriggerChange), l = h.useRef(!1), u = h.useRef(!1), a = h.useCallback(() => l.current = !1, []);
+  return h.useEffect(() => () => document.removeEventListener("pointerup", a), [a]), /* @__PURE__ */ P(hr, {
+    asChild: !0,
+    ...s,
+    children: /* @__PURE__ */ P(we.button, {
+      "aria-describedby": o.open ? o.contentId : void 0,
+      "data-state": o.stateAttribute,
+      ...r,
+      ref: c,
+      onPointerMove: Q(e.onPointerMove, (d) => {
+        d.pointerType !== "touch" && !u.current && !i.isPointerInTransitRef.current && (o.onTriggerEnter(), u.current = !0);
+      }),
+      onPointerLeave: Q(e.onPointerLeave, () => {
+        o.onTriggerLeave(), u.current = !1;
+      }),
+      onPointerDown: Q(e.onPointerDown, () => {
+        o.open && o.onClose(), l.current = !0, document.addEventListener("pointerup", a, { once: !0 });
+      }),
+      onFocus: Q(e.onFocus, () => {
+        l.current || o.onOpen();
+      }),
+      onBlur: Q(e.onBlur, o.onClose),
+      onClick: Q(e.onClick, o.onClose)
+    })
+  });
+});
+Lt.displayName = _e;
+var je = "TooltipPortal", [br, Rr] = Re(je, { forceMount: void 0 }), Dt = (e) => {
+  const { __scopeTooltip: t, forceMount: n, children: r, container: o } = e, i = ae(je, t);
+  return /* @__PURE__ */ P(br, {
+    scope: t,
+    forceMount: n,
+    children: /* @__PURE__ */ P(it, {
+      present: n || i.open,
+      children: /* @__PURE__ */ P(Jt, {
+        asChild: !0,
+        container: o,
+        children: r
+      })
+    })
+  });
+};
+Dt.displayName = je;
+var ne = "TooltipContent", Mt = h.forwardRef((e, t) => {
+  const n = Rr(ne, e.__scopeTooltip), { forceMount: r = n.forceMount, side: o = "top", ...i } = e, s = ae(ne, e.__scopeTooltip);
+  return /* @__PURE__ */ P(it, {
+    present: r || s.open,
+    children: s.disableHoverableContent ? /* @__PURE__ */ P(_t, {
+      side: o,
+      ...i,
+      ref: t
+    }) : /* @__PURE__ */ P(Cr, {
+      side: o,
+      ...i,
+      ref: t
+    })
+  });
+}), Cr = h.forwardRef((e, t) => {
+  const n = ae(ne, e.__scopeTooltip), r = ze(ne, e.__scopeTooltip), o = h.useRef(null), i = ge(t, o), [s, c] = h.useState(null), { trigger: l, onClose: u } = n, a = o.current, { onPointerInTransitChange: d } = r, p = h.useCallback(() => {
+    c(null), d(!1);
+  }, [d]), f = h.useCallback((m, g) => {
+    const w = m.currentTarget, v = {
+      x: m.clientX,
+      y: m.clientY
+    }, x = Er(v, Tr(v, w.getBoundingClientRect())), b = Sr(g.getBoundingClientRect()), y = Dr([...x, ...b]);
+    c(y), d(!0);
+  }, [d]);
+  return h.useEffect(() => () => p(), [p]), h.useEffect(() => {
+    if (l && a) {
+      const m = (w) => f(w, a), g = (w) => f(w, l);
+      return l.addEventListener("pointerleave", m), a.addEventListener("pointerleave", g), () => {
+        l.removeEventListener("pointerleave", m), a.removeEventListener("pointerleave", g);
+      };
+    }
+  }, [
+    l,
+    a,
+    f,
+    p
+  ]), h.useEffect(() => {
+    if (s) {
+      const m = (g) => {
+        const w = g.target, v = {
+          x: g.clientX,
+          y: g.clientY
+        }, x = l?.contains(w) || a?.contains(w), b = !Lr(v, s);
+        x ? p() : b && (p(), u());
+      };
+      return document.addEventListener("pointermove", m), () => document.removeEventListener("pointermove", m);
+    }
+  }, [
+    l,
+    a,
+    s,
+    u,
+    p
+  ]), /* @__PURE__ */ P(_t, {
+    ...e,
+    ref: i
+  });
+}), [Ar, Pr] = Re(se, { isInside: !1 }), Or = Yt("TooltipContent"), _t = h.forwardRef((e, t) => {
+  const { __scopeTooltip: n, children: r, "aria-label": o, onEscapeKeyDown: i, onPointerDownOutside: s, ...c } = e, l = ae(ne, n), u = Ce(n), { onClose: a } = l;
+  return h.useEffect(() => (document.addEventListener(Me, a), () => document.removeEventListener(Me, a)), [a]), h.useEffect(() => {
+    if (l.trigger) {
+      const d = (p) => {
+        p.target instanceof Node && p.target.contains(l.trigger) && a();
+      };
+      return window.addEventListener("scroll", d, { capture: !0 }), () => window.removeEventListener("scroll", d, { capture: !0 });
+    }
+  }, [l.trigger, a]), /* @__PURE__ */ P(Zt, {
+    asChild: !0,
+    disableOutsidePointerEvents: !1,
+    onEscapeKeyDown: i,
+    onPointerDownOutside: s,
+    onFocusOutside: (d) => d.preventDefault(),
+    onDismiss: a,
+    children: /* @__PURE__ */ nn(gr, {
+      "data-state": l.stateAttribute,
+      ...u,
+      ...c,
+      ref: t,
+      style: {
+        ...c.style,
+        "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
+        "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
+        "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
+        "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
+        "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
+      },
+      children: [/* @__PURE__ */ P(Or, { children: r }), /* @__PURE__ */ P(Ar, {
+        scope: n,
+        isInside: !0,
+        children: /* @__PURE__ */ P(Gt, {
+          id: l.contentId,
+          role: "tooltip",
+          children: o || r
+        })
+      })]
+    })
+  });
+});
+Mt.displayName = ne;
+var kt = "TooltipArrow", Nt = h.forwardRef((e, t) => {
+  const { __scopeTooltip: n, ...r } = e, o = Ce(n);
+  return Pr(kt, n).isInside ? null : /* @__PURE__ */ P(wr, {
+    ...o,
+    ...r,
+    ref: t
+  });
+});
+Nt.displayName = kt;
+function Tr(e, t) {
+  const n = Math.abs(t.top - e.y), r = Math.abs(t.bottom - e.y), o = Math.abs(t.right - e.x), i = Math.abs(t.left - e.x);
+  switch (Math.min(n, r, o, i)) {
+    case i:
+      return "left";
+    case o:
+      return "right";
+    case n:
+      return "top";
+    case r:
+      return "bottom";
+    default:
+      throw new Error("unreachable");
+  }
+}
+function Er(e, t, n = 5) {
+  const r = [];
+  switch (t) {
+    case "top":
+      r.push({
+        x: e.x - n,
+        y: e.y + n
+      }, {
+        x: e.x + n,
+        y: e.y + n
+      });
+      break;
+    case "bottom":
+      r.push({
+        x: e.x - n,
+        y: e.y - n
+      }, {
+        x: e.x + n,
+        y: e.y - n
+      });
+      break;
+    case "left":
+      r.push({
+        x: e.x + n,
+        y: e.y - n
+      }, {
+        x: e.x + n,
+        y: e.y + n
+      });
+      break;
+    case "right":
+      r.push({
+        x: e.x - n,
+        y: e.y - n
+      }, {
+        x: e.x - n,
+        y: e.y + n
+      });
+      break;
+  }
+  return r;
+}
+function Sr(e) {
+  const { top: t, right: n, bottom: r, left: o } = e;
+  return [
+    {
+      x: o,
+      y: t
+    },
+    {
+      x: n,
+      y: t
+    },
+    {
+      x: n,
+      y: r
+    },
+    {
+      x: o,
+      y: r
+    }
+  ];
+}
+function Lr(e, t) {
+  const { x: n, y: r } = e;
+  let o = !1;
+  for (let i = 0, s = t.length - 1; i < t.length; s = i++) {
+    const c = t[i], l = t[s], u = c.x, a = c.y, d = l.x, p = l.y;
+    a > r != p > r && n < (d - u) * (r - a) / (p - a) + u && (o = !o);
+  }
+  return o;
+}
+function Dr(e) {
+  const t = e.slice();
+  return t.sort((n, r) => n.x < r.x ? -1 : n.x > r.x ? 1 : n.y < r.y ? -1 : n.y > r.y ? 1 : 0), Mr(t);
+}
+function Mr(e) {
+  if (e.length <= 1) return e.slice();
+  const t = [];
+  for (let r = 0; r < e.length; r++) {
+    const o = e[r];
+    for (; t.length >= 2; ) {
+      const i = t[t.length - 1], s = t[t.length - 2];
+      if ((i.x - s.x) * (o.y - s.y) >= (i.y - s.y) * (o.x - s.x)) t.pop();
+      else break;
+    }
+    t.push(o);
+  }
+  t.pop();
+  const n = [];
+  for (let r = e.length - 1; r >= 0; r--) {
+    const o = e[r];
+    for (; n.length >= 2; ) {
+      const i = n[n.length - 1], s = n[n.length - 2];
+      if ((i.x - s.x) * (o.y - s.y) >= (i.y - s.y) * (o.x - s.x)) n.pop();
+      else break;
+    }
+    n.push(o);
+  }
+  return n.pop(), t.length === 1 && n.length === 1 && t[0].x === n[0].x && t[0].y === n[0].y ? t : t.concat(n);
+}
+var Xr = Et, Yr = St, Gr = Lt, qr = Dt, Ur = Mt, Kr = Nt;
+export {
+  Yr as a,
+  Xr as i,
+  Ur as n,
+  Gr as o,
+  qr as r,
+  Kr as t
+};