ics-ui-kit 0.1.0-alpha.12 → 0.1.0-alpha.13

package/dist/index-n71RB2rx.js

@@ -0,0 +1,1592 @@
+var Fe = Object.defineProperty, Ne = Object.defineProperties;
+var He = Object.getOwnPropertyDescriptors;
+var dt = Object.getOwnPropertySymbols;
+var Kt = Object.prototype.hasOwnProperty, Gt = Object.prototype.propertyIsEnumerable;
+var Zt = (t, e, n) => e in t ? Fe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, b = (t, e) => {
+  for (var n in e || (e = {}))
+    Kt.call(e, n) && Zt(t, n, e[n]);
+  if (dt)
+    for (var n of dt(e))
+      Gt.call(e, n) && Zt(t, n, e[n]);
+  return t;
+}, O = (t, e) => Ne(t, He(e));
+var K = (t, e) => {
+  var n = {};
+  for (var o in t)
+    Kt.call(t, o) && e.indexOf(o) < 0 && (n[o] = t[o]);
+  if (t != null && dt)
+    for (var o of dt(t))
+      e.indexOf(o) < 0 && Gt.call(t, o) && (n[o] = t[o]);
+  return n;
+};
+var I = (t, e, n) => new Promise((o, i) => {
+  var r = (c) => {
+    try {
+      l(n.next(c));
+    } catch (a) {
+      i(a);
+    }
+  }, s = (c) => {
+    try {
+      l(n.throw(c));
+    } catch (a) {
+      i(a);
+    }
+  }, l = (c) => c.done ? o(c.value) : Promise.resolve(c.value).then(r, s);
+  l((n = n.apply(t, e)).next());
+});
+import * as C from "react";
+import { useLayoutEffect as We } from "react";
+import * as _e from "react-dom";
+import { u as Ct, P as Dt } from "./index-B6K06mzp.js";
+import { jsx as G } from "react/jsx-runtime";
+import { u as se } from "./index-Bj6ZBhqh.js";
+import { c as Be, u as ze } from "./index-Mbnk_gHS.js";
+function Ve(t) {
+  const [e, n] = C.useState(void 0);
+  return Ct(() => {
+    if (t) {
+      n({ width: t.offsetWidth, height: t.offsetHeight });
+      const o = new ResizeObserver((i) => {
+        if (!Array.isArray(i) || !i.length)
+          return;
+        const r = i[0];
+        let s, l;
+        if ("borderBoxSize" in r) {
+          const c = r.borderBoxSize, a = Array.isArray(c) ? c[0] : c;
+          s = a.inlineSize, l = a.blockSize;
+        } else
+          s = t.offsetWidth, l = t.offsetHeight;
+        n({ width: s, height: l });
+      });
+      return o.observe(t, { box: "border-box" }), () => o.unobserve(t);
+    } else
+      n(void 0);
+  }, [t]), e;
+}
+const Ie = ["top", "right", "bottom", "left"], tt = Math.min, z = Math.max, ht = Math.round, pt = Math.floor, q = (t) => ({
+  x: t,
+  y: t
+}), Ye = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, je = {
+  start: "end",
+  end: "start"
+};
+function Pt(t, e, n) {
+  return z(t, tt(e, n));
+}
+function J(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function Q(t) {
+  return t.split("-")[0];
+}
+function rt(t) {
+  return t.split("-")[1];
+}
+function Lt(t) {
+  return t === "x" ? "y" : "x";
+}
+function Tt(t) {
+  return t === "y" ? "height" : "width";
+}
+function X(t) {
+  return ["top", "bottom"].includes(Q(t)) ? "y" : "x";
+}
+function Mt(t) {
+  return Lt(X(t));
+}
+function Xe(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = rt(t), i = Mt(t), r = Tt(i);
+  let s = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return e.reference[r] > e.floating[r] && (s = gt(s)), [s, gt(s)];
+}
+function qe(t) {
+  const e = gt(t);
+  return [St(t), e, St(e)];
+}
+function St(t) {
+  return t.replace(/start|end/g, (e) => je[e]);
+}
+function Ue(t, e, n) {
+  const o = ["left", "right"], i = ["right", "left"], r = ["top", "bottom"], s = ["bottom", "top"];
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? i : o : e ? o : i;
+    case "left":
+    case "right":
+      return e ? r : s;
+    default:
+      return [];
+  }
+}
+function Ze(t, e, n, o) {
+  const i = rt(t);
+  let r = Ue(Q(t), n === "start", o);
+  return i && (r = r.map((s) => s + "-" + i), e && (r = r.concat(r.map(St)))), r;
+}
+function gt(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => Ye[e]);
+}
+function Ke(t) {
+  return b({
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  }, t);
+}
+function ce(t) {
+  return typeof t != "number" ? Ke(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function wt(t) {
+  const {
+    x: e,
+    y: n,
+    width: o,
+    height: i
+  } = t;
+  return {
+    width: o,
+    height: i,
+    top: n,
+    left: e,
+    right: e + o,
+    bottom: n + i,
+    x: e,
+    y: n
+  };
+}
+function Jt(t, e, n) {
+  let {
+    reference: o,
+    floating: i
+  } = t;
+  const r = X(e), s = Mt(e), l = Tt(s), c = Q(e), a = r === "y", d = o.x + o.width / 2 - i.width / 2, f = o.y + o.height / 2 - i.height / 2, p = o[l] / 2 - i[l] / 2;
+  let u;
+  switch (c) {
+    case "top":
+      u = {
+        x: d,
+        y: o.y - i.height
+      };
+      break;
+    case "bottom":
+      u = {
+        x: d,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      u = {
+        x: o.x + o.width,
+        y: f
+      };
+      break;
+    case "left":
+      u = {
+        x: o.x - i.width,
+        y: f
+      };
+      break;
+    default:
+      u = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (rt(e)) {
+    case "start":
+      u[s] -= p * (n && a ? -1 : 1);
+      break;
+    case "end":
+      u[s] += p * (n && a ? -1 : 1);
+      break;
+  }
+  return u;
+}
+const Ge = (t, e, n) => I(void 0, null, function* () {
+  const {
+    placement: o = "bottom",
+    strategy: i = "absolute",
+    middleware: r = [],
+    platform: s
+  } = n, l = r.filter(Boolean), c = yield s.isRTL == null ? void 0 : s.isRTL(e);
+  let a = yield s.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), {
+    x: d,
+    y: f
+  } = Jt(a, o, c), p = o, u = {}, h = 0;
+  for (let m = 0; m < l.length; m++) {
+    const {
+      name: w,
+      fn: x
+    } = l[m], {
+      x: A,
+      y,
+      data: g,
+      reset: v
+    } = yield x({
+      x: d,
+      y: f,
+      initialPlacement: o,
+      placement: p,
+      strategy: i,
+      middlewareData: u,
+      rects: a,
+      platform: s,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    d = A != null ? A : d, f = y != null ? y : f, u = O(b({}, u), {
+      [w]: b(b({}, u[w]), g)
+    }), v && h <= 50 && (h++, typeof v == "object" && (v.placement && (p = v.placement), v.rects && (a = v.rects === !0 ? yield s.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: i
+    }) : v.rects), {
+      x: d,
+      y: f
+    } = Jt(a, p, c)), m = -1);
+  }
+  return {
+    x: d,
+    y: f,
+    placement: p,
+    strategy: i,
+    middlewareData: u
+  };
+});
+function lt(t, e) {
+  return I(this, null, function* () {
+    var n;
+    e === void 0 && (e = {});
+    const {
+      x: o,
+      y: i,
+      platform: r,
+      rects: s,
+      elements: l,
+      strategy: c
+    } = t, {
+      boundary: a = "clippingAncestors",
+      rootBoundary: d = "viewport",
+      elementContext: f = "floating",
+      altBoundary: p = !1,
+      padding: u = 0
+    } = J(e, t), h = ce(u), w = l[p ? f === "floating" ? "reference" : "floating" : f], x = wt(yield r.getClippingRect({
+      element: (n = yield r.isElement == null ? void 0 : r.isElement(w)) == null || n ? w : w.contextElement || (yield r.getDocumentElement == null ? void 0 : r.getDocumentElement(l.floating)),
+      boundary: a,
+      rootBoundary: d,
+      strategy: c
+    })), A = f === "floating" ? {
+      x: o,
+      y: i,
+      width: s.floating.width,
+      height: s.floating.height
+    } : s.reference, y = yield r.getOffsetParent == null ? void 0 : r.getOffsetParent(l.floating), g = (yield r.isElement == null ? void 0 : r.isElement(y)) ? (yield r.getScale == null ? void 0 : r.getScale(y)) || {
+      x: 1,
+      y: 1
+    } : {
+      x: 1,
+      y: 1
+    }, v = wt(r.convertOffsetParentRelativeRectToViewportRelativeRect ? yield r.convertOffsetParentRelativeRectToViewportRelativeRect({
+      elements: l,
+      rect: A,
+      offsetParent: y,
+      strategy: c
+    }) : A);
+    return {
+      top: (x.top - v.top + h.top) / g.y,
+      bottom: (v.bottom - x.bottom + h.bottom) / g.y,
+      left: (x.left - v.left + h.left) / g.x,
+      right: (v.right - x.right + h.right) / g.x
+    };
+  });
+}
+const Je = (t) => ({
+  name: "arrow",
+  options: t,
+  fn(n) {
+    return I(this, null, function* () {
+      const {
+        x: o,
+        y: i,
+        placement: r,
+        rects: s,
+        platform: l,
+        elements: c,
+        middlewareData: a
+      } = n, {
+        element: d,
+        padding: f = 0
+      } = J(t, n) || {};
+      if (d == null)
+        return {};
+      const p = ce(f), u = {
+        x: o,
+        y: i
+      }, h = Mt(r), m = Tt(h), w = yield l.getDimensions(d), x = h === "y", A = x ? "top" : "left", y = x ? "bottom" : "right", g = x ? "clientHeight" : "clientWidth", v = s.reference[m] + s.reference[h] - u[h] - s.floating[m], P = u[h] - s.reference[h], S = yield l.getOffsetParent == null ? void 0 : l.getOffsetParent(d);
+      let T = S ? S[g] : 0;
+      (!T || !(yield l.isElement == null ? void 0 : l.isElement(S))) && (T = c.floating[g] || s.floating[m]);
+      const W = v / 2 - P / 2, k = T / 2 - w[m] / 2 - 1, M = tt(p[A], k), _ = tt(p[y], k), E = M, H = T - w[m] - _, $ = T / 2 - w[m] / 2 + W, D = Pt(E, $, H), F = !a.arrow && rt(r) != null && $ !== D && s.reference[m] / 2 - ($ < E ? M : _) - w[m] / 2 < 0, R = F ? $ < E ? $ - E : $ - H : 0;
+      return {
+        [h]: u[h] + R,
+        data: b({
+          [h]: D,
+          centerOffset: $ - D - R
+        }, F && {
+          alignmentOffset: R
+        }),
+        reset: F
+      };
+    });
+  }
+}), Qe = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    fn(n) {
+      return I(this, null, function* () {
+        var o, i;
+        const {
+          placement: r,
+          middlewareData: s,
+          rects: l,
+          initialPlacement: c,
+          platform: a,
+          elements: d
+        } = n, $ = J(t, n), {
+          mainAxis: f = !0,
+          crossAxis: p = !0,
+          fallbackPlacements: u,
+          fallbackStrategy: h = "bestFit",
+          fallbackAxisSideDirection: m = "none",
+          flipAlignment: w = !0
+        } = $, x = K($, [
+          "mainAxis",
+          "crossAxis",
+          "fallbackPlacements",
+          "fallbackStrategy",
+          "fallbackAxisSideDirection",
+          "flipAlignment"
+        ]);
+        if ((o = s.arrow) != null && o.alignmentOffset)
+          return {};
+        const A = Q(r), y = X(c), g = Q(c) === c, v = yield a.isRTL == null ? void 0 : a.isRTL(d.floating), P = u || (g || !w ? [gt(c)] : qe(c)), S = m !== "none";
+        !u && S && P.push(...Ze(c, w, m, v));
+        const T = [c, ...P], W = yield lt(n, x), k = [];
+        let M = ((i = s.flip) == null ? void 0 : i.overflows) || [];
+        if (f && k.push(W[A]), p) {
+          const D = Xe(r, l, v);
+          k.push(W[D[0]], W[D[1]]);
+        }
+        if (M = [...M, {
+          placement: r,
+          overflows: k
+        }], !k.every((D) => D <= 0)) {
+          var _, E;
+          const D = (((_ = s.flip) == null ? void 0 : _.index) || 0) + 1, F = T[D];
+          if (F && (!(p === "alignment" ? y !== X(F) : !1) || // We leave the current main axis only if every placement on that axis
+          // overflows the main axis.
+          M.every((L) => L.overflows[0] > 0 && X(L.placement) === y)))
+            return {
+              data: {
+                index: D,
+                overflows: M
+              },
+              reset: {
+                placement: F
+              }
+            };
+          let R = (E = M.filter((N) => N.overflows[0] <= 0).sort((N, L) => N.overflows[1] - L.overflows[1])[0]) == null ? void 0 : E.placement;
+          if (!R)
+            switch (h) {
+              case "bestFit": {
+                var H;
+                const N = (H = M.filter((L) => {
+                  if (S) {
+                    const B = X(L.placement);
+                    return B === y || // Create a bias to the `y` side axis due to horizontal
+                    // reading directions favoring greater width.
+                    B === "y";
+                  }
+                  return !0;
+                }).map((L) => [L.placement, L.overflows.filter((B) => B > 0).reduce((B, At) => B + At, 0)]).sort((L, B) => L[1] - B[1])[0]) == null ? void 0 : H[0];
+                N && (R = N);
+                break;
+              }
+              case "initialPlacement":
+                R = c;
+                break;
+            }
+          if (r !== R)
+            return {
+              reset: {
+                placement: R
+              }
+            };
+        }
+        return {};
+      });
+    }
+  };
+};
+function Qt(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function te(t) {
+  return Ie.some((e) => t[e] >= 0);
+}
+const tn = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    fn(n) {
+      return I(this, null, function* () {
+        const {
+          rects: o
+        } = n, s = J(t, n), {
+          strategy: i = "referenceHidden"
+        } = s, r = K(s, [
+          "strategy"
+        ]);
+        switch (i) {
+          case "referenceHidden": {
+            const l = yield lt(n, O(b({}, r), {
+              elementContext: "reference"
+            })), c = Qt(l, o.reference);
+            return {
+              data: {
+                referenceHiddenOffsets: c,
+                referenceHidden: te(c)
+              }
+            };
+          }
+          case "escaped": {
+            const l = yield lt(n, O(b({}, r), {
+              altBoundary: !0
+            })), c = Qt(l, o.floating);
+            return {
+              data: {
+                escapedOffsets: c,
+                escaped: te(c)
+              }
+            };
+          }
+          default:
+            return {};
+        }
+      });
+    }
+  };
+};
+function en(t, e) {
+  return I(this, null, function* () {
+    const {
+      placement: n,
+      platform: o,
+      elements: i
+    } = t, r = yield o.isRTL == null ? void 0 : o.isRTL(i.floating), s = Q(n), l = rt(n), c = X(n) === "y", a = ["left", "top"].includes(s) ? -1 : 1, d = r && c ? -1 : 1, f = J(e, t);
+    let {
+      mainAxis: p,
+      crossAxis: u,
+      alignmentAxis: h
+    } = typeof f == "number" ? {
+      mainAxis: f,
+      crossAxis: 0,
+      alignmentAxis: null
+    } : {
+      mainAxis: f.mainAxis || 0,
+      crossAxis: f.crossAxis || 0,
+      alignmentAxis: f.alignmentAxis
+    };
+    return l && typeof h == "number" && (u = l === "end" ? h * -1 : h), c ? {
+      x: u * d,
+      y: p * a
+    } : {
+      x: p * a,
+      y: u * d
+    };
+  });
+}
+const nn = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    fn(n) {
+      return I(this, null, function* () {
+        var o, i;
+        const {
+          x: r,
+          y: s,
+          placement: l,
+          middlewareData: c
+        } = n, a = yield en(n, t);
+        return l === ((o = c.offset) == null ? void 0 : o.placement) && (i = c.arrow) != null && i.alignmentOffset ? {} : {
+          x: r + a.x,
+          y: s + a.y,
+          data: O(b({}, a), {
+            placement: l
+          })
+        };
+      });
+    }
+  };
+}, on = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    fn(n) {
+      return I(this, null, function* () {
+        const {
+          x: o,
+          y: i,
+          placement: r
+        } = n, x = J(t, n), {
+          mainAxis: s = !0,
+          crossAxis: l = !1,
+          limiter: c = {
+            fn: (A) => {
+              let {
+                x: y,
+                y: g
+              } = A;
+              return {
+                x: y,
+                y: g
+              };
+            }
+          }
+        } = x, a = K(x, [
+          "mainAxis",
+          "crossAxis",
+          "limiter"
+        ]), d = {
+          x: o,
+          y: i
+        }, f = yield lt(n, a), p = X(Q(r)), u = Lt(p);
+        let h = d[u], m = d[p];
+        if (s) {
+          const A = u === "y" ? "top" : "left", y = u === "y" ? "bottom" : "right", g = h + f[A], v = h - f[y];
+          h = Pt(g, h, v);
+        }
+        if (l) {
+          const A = p === "y" ? "top" : "left", y = p === "y" ? "bottom" : "right", g = m + f[A], v = m - f[y];
+          m = Pt(g, m, v);
+        }
+        const w = c.fn(O(b({}, n), {
+          [u]: h,
+          [p]: m
+        }));
+        return O(b({}, w), {
+          data: {
+            x: w.x - o,
+            y: w.y - i,
+            enabled: {
+              [u]: s,
+              [p]: l
+            }
+          }
+        });
+      });
+    }
+  };
+}, rn = function(t) {
+  return t === void 0 && (t = {}), {
+    options: t,
+    fn(e) {
+      const {
+        x: n,
+        y: o,
+        placement: i,
+        rects: r,
+        middlewareData: s
+      } = e, {
+        offset: l = 0,
+        mainAxis: c = !0,
+        crossAxis: a = !0
+      } = J(t, e), d = {
+        x: n,
+        y: o
+      }, f = X(i), p = Lt(f);
+      let u = d[p], h = d[f];
+      const m = J(l, e), w = typeof m == "number" ? {
+        mainAxis: m,
+        crossAxis: 0
+      } : b({
+        mainAxis: 0,
+        crossAxis: 0
+      }, m);
+      if (c) {
+        const y = p === "y" ? "height" : "width", g = r.reference[p] - r.floating[y] + w.mainAxis, v = r.reference[p] + r.reference[y] - w.mainAxis;
+        u < g ? u = g : u > v && (u = v);
+      }
+      if (a) {
+        var x, A;
+        const y = p === "y" ? "width" : "height", g = ["top", "left"].includes(Q(i)), v = r.reference[f] - r.floating[y] + (g && ((x = s.offset) == null ? void 0 : x[f]) || 0) + (g ? 0 : w.crossAxis), P = r.reference[f] + r.reference[y] + (g ? 0 : ((A = s.offset) == null ? void 0 : A[f]) || 0) - (g ? w.crossAxis : 0);
+        h < v ? h = v : h > P && (h = P);
+      }
+      return {
+        [p]: u,
+        [f]: h
+      };
+    }
+  };
+}, sn = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    fn(n) {
+      return I(this, null, function* () {
+        var o, i;
+        const {
+          placement: r,
+          rects: s,
+          platform: l,
+          elements: c
+        } = n, M = J(t, n), {
+          apply: a = () => {
+          }
+        } = M, d = K(M, [
+          "apply"
+        ]), f = yield lt(n, d), p = Q(r), u = rt(r), h = X(r) === "y", {
+          width: m,
+          height: w
+        } = s.floating;
+        let x, A;
+        p === "top" || p === "bottom" ? (x = p, A = u === ((yield l.isRTL == null ? void 0 : l.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (A = p, x = u === "end" ? "top" : "bottom");
+        const y = w - f.top - f.bottom, g = m - f.left - f.right, v = tt(w - f[x], y), P = tt(m - f[A], g), S = !n.middlewareData.shift;
+        let T = v, W = P;
+        if ((o = n.middlewareData.shift) != null && o.enabled.x && (W = g), (i = n.middlewareData.shift) != null && i.enabled.y && (T = y), S && !u) {
+          const _ = z(f.left, 0), E = z(f.right, 0), H = z(f.top, 0), $ = z(f.bottom, 0);
+          h ? W = m - 2 * (_ !== 0 || E !== 0 ? _ + E : z(f.left, f.right)) : T = w - 2 * (H !== 0 || $ !== 0 ? H + $ : z(f.top, f.bottom));
+        }
+        yield a(O(b({}, n), {
+          availableWidth: W,
+          availableHeight: T
+        }));
+        const k = yield l.getDimensions(c.floating);
+        return m !== k.width || w !== k.height ? {
+          reset: {
+            rects: !0
+          }
+        } : {};
+      });
+    }
+  };
+};
+function yt() {
+  return typeof window != "undefined";
+}
+function st(t) {
+  return le(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function V(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function Z(t) {
+  var e;
+  return (e = (le(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function le(t) {
+  return yt() ? t instanceof Node || t instanceof V(t).Node : !1;
+}
+function Y(t) {
+  return yt() ? t instanceof Element || t instanceof V(t).Element : !1;
+}
+function U(t) {
+  return yt() ? t instanceof HTMLElement || t instanceof V(t).HTMLElement : !1;
+}
+function ee(t) {
+  return !yt() || typeof ShadowRoot == "undefined" ? !1 : t instanceof ShadowRoot || t instanceof V(t).ShadowRoot;
+}
+function ft(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: o,
+    display: i
+  } = j(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !["inline", "contents"].includes(i);
+}
+function cn(t) {
+  return ["table", "td", "th"].includes(st(t));
+}
+function vt(t) {
+  return [":popover-open", ":modal"].some((e) => {
+    try {
+      return t.matches(e);
+    } catch (n) {
+      return !1;
+    }
+  });
+}
+function $t(t) {
+  const e = kt(), n = Y(t) ? j(t) : t;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((o) => n[o] ? n[o] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (n.filter ? n.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((o) => (n.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (n.contain || "").includes(o));
+}
+function ln(t) {
+  let e = et(t);
+  for (; U(e) && !it(e); ) {
+    if ($t(e))
+      return e;
+    if (vt(e))
+      return null;
+    e = et(e);
+  }
+  return null;
+}
+function kt() {
+  return typeof CSS == "undefined" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function it(t) {
+  return ["html", "body", "#document"].includes(st(t));
+}
+function j(t) {
+  return V(t).getComputedStyle(t);
+}
+function bt(t) {
+  return Y(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function et(t) {
+  if (st(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    ee(t) && t.host || // Fallback.
+    Z(t)
+  );
+  return ee(e) ? e.host : e;
+}
+function ae(t) {
+  const e = et(t);
+  return it(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : U(e) && ft(e) ? e : ae(e);
+}
+function at(t, e, n) {
+  var o;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const i = ae(t), r = i === ((o = t.ownerDocument) == null ? void 0 : o.body), s = V(i);
+  if (r) {
+    const l = Et(s);
+    return e.concat(s, s.visualViewport || [], ft(i) ? i : [], l && n ? at(l) : []);
+  }
+  return e.concat(i, at(i, [], n));
+}
+function Et(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function fe(t) {
+  const e = j(t);
+  let n = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
+  const i = U(t), r = i ? t.offsetWidth : n, s = i ? t.offsetHeight : o, l = ht(n) !== r || ht(o) !== s;
+  return l && (n = r, o = s), {
+    width: n,
+    height: o,
+    $: l
+  };
+}
+function Ft(t) {
+  return Y(t) ? t : t.contextElement;
+}
+function ot(t) {
+  const e = Ft(t);
+  if (!U(e))
+    return q(1);
+  const n = e.getBoundingClientRect(), {
+    width: o,
+    height: i,
+    $: r
+  } = fe(e);
+  let s = (r ? ht(n.width) : n.width) / o, l = (r ? ht(n.height) : n.height) / i;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: s,
+    y: l
+  };
+}
+const an = /* @__PURE__ */ q(0);
+function ue(t) {
+  const e = V(t);
+  return !kt() || !e.visualViewport ? an : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function fn(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== V(t) ? !1 : e;
+}
+function nt(t, e, n, o) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const i = t.getBoundingClientRect(), r = Ft(t);
+  let s = q(1);
+  e && (o ? Y(o) && (s = ot(o)) : s = ot(t));
+  const l = fn(r, n, o) ? ue(r) : q(0);
+  let c = (i.left + l.x) / s.x, a = (i.top + l.y) / s.y, d = i.width / s.x, f = i.height / s.y;
+  if (r) {
+    const p = V(r), u = o && Y(o) ? V(o) : o;
+    let h = p, m = Et(h);
+    for (; m && o && u !== h; ) {
+      const w = ot(m), x = m.getBoundingClientRect(), A = j(m), y = x.left + (m.clientLeft + parseFloat(A.paddingLeft)) * w.x, g = x.top + (m.clientTop + parseFloat(A.paddingTop)) * w.y;
+      c *= w.x, a *= w.y, d *= w.x, f *= w.y, c += y, a += g, h = V(m), m = Et(h);
+    }
+  }
+  return wt({
+    width: d,
+    height: f,
+    x: c,
+    y: a
+  });
+}
+function Nt(t, e) {
+  const n = bt(t).scrollLeft;
+  return e ? e.left + n : nt(Z(t)).left + n;
+}
+function de(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = t.getBoundingClientRect(), i = o.left + e.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    Nt(t, o)
+  )), r = o.top + e.scrollTop;
+  return {
+    x: i,
+    y: r
+  };
+}
+function un(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: o,
+    strategy: i
+  } = t;
+  const r = i === "fixed", s = Z(o), l = e ? vt(e.floating) : !1;
+  if (o === s || l && r)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = q(1);
+  const d = q(0), f = U(o);
+  if ((f || !f && !r) && ((st(o) !== "body" || ft(s)) && (c = bt(o)), U(o))) {
+    const u = nt(o);
+    a = ot(o), d.x = u.x + o.clientLeft, d.y = u.y + o.clientTop;
+  }
+  const p = s && !f && !r ? de(s, c, !0) : q(0);
+  return {
+    width: n.width * a.x,
+    height: n.height * a.y,
+    x: n.x * a.x - c.scrollLeft * a.x + d.x + p.x,
+    y: n.y * a.y - c.scrollTop * a.y + d.y + p.y
+  };
+}
+function dn(t) {
+  return Array.from(t.getClientRects());
+}
+function pn(t) {
+  const e = Z(t), n = bt(t), o = t.ownerDocument.body, i = z(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), r = z(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let s = -n.scrollLeft + Nt(t);
+  const l = -n.scrollTop;
+  return j(o).direction === "rtl" && (s += z(e.clientWidth, o.clientWidth) - i), {
+    width: i,
+    height: r,
+    x: s,
+    y: l
+  };
+}
+function mn(t, e) {
+  const n = V(t), o = Z(t), i = n.visualViewport;
+  let r = o.clientWidth, s = o.clientHeight, l = 0, c = 0;
+  if (i) {
+    r = i.width, s = i.height;
+    const a = kt();
+    (!a || a && e === "fixed") && (l = i.offsetLeft, c = i.offsetTop);
+  }
+  return {
+    width: r,
+    height: s,
+    x: l,
+    y: c
+  };
+}
+function hn(t, e) {
+  const n = nt(t, !0, e === "fixed"), o = n.top + t.clientTop, i = n.left + t.clientLeft, r = U(t) ? ot(t) : q(1), s = t.clientWidth * r.x, l = t.clientHeight * r.y, c = i * r.x, a = o * r.y;
+  return {
+    width: s,
+    height: l,
+    x: c,
+    y: a
+  };
+}
+function ne(t, e, n) {
+  let o;
+  if (e === "viewport")
+    o = mn(t, n);
+  else if (e === "document")
+    o = pn(Z(t));
+  else if (Y(e))
+    o = hn(e, n);
+  else {
+    const i = ue(t);
+    o = {
+      x: e.x - i.x,
+      y: e.y - i.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return wt(o);
+}
+function pe(t, e) {
+  const n = et(t);
+  return n === e || !Y(n) || it(n) ? !1 : j(n).position === "fixed" || pe(n, e);
+}
+function gn(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let o = at(t, [], !1).filter((l) => Y(l) && st(l) !== "body"), i = null;
+  const r = j(t).position === "fixed";
+  let s = r ? et(t) : t;
+  for (; Y(s) && !it(s); ) {
+    const l = j(s), c = $t(s);
+    !c && l.position === "fixed" && (i = null), (r ? !c && !i : !c && l.position === "static" && !!i && ["absolute", "fixed"].includes(i.position) || ft(s) && !c && pe(t, s)) ? o = o.filter((d) => d !== s) : i = l, s = et(s);
+  }
+  return e.set(t, o), o;
+}
+function wn(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: o,
+    strategy: i
+  } = t;
+  const s = [...n === "clippingAncestors" ? vt(e) ? [] : gn(e, this._c) : [].concat(n), o], l = s[0], c = s.reduce((a, d) => {
+    const f = ne(e, d, i);
+    return a.top = z(f.top, a.top), a.right = tt(f.right, a.right), a.bottom = tt(f.bottom, a.bottom), a.left = z(f.left, a.left), a;
+  }, ne(e, l, i));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function xn(t) {
+  const {
+    width: e,
+    height: n
+  } = fe(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function yn(t, e, n) {
+  const o = U(e), i = Z(e), r = n === "fixed", s = nt(t, !0, r, e);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = q(0);
+  function a() {
+    c.x = Nt(i);
+  }
+  if (o || !o && !r)
+    if ((st(e) !== "body" || ft(i)) && (l = bt(e)), o) {
+      const u = nt(e, !0, r, e);
+      c.x = u.x + e.clientLeft, c.y = u.y + e.clientTop;
+    } else i && a();
+  r && !o && i && a();
+  const d = i && !o && !r ? de(i, l) : q(0), f = s.left + l.scrollLeft - c.x - d.x, p = s.top + l.scrollTop - c.y - d.y;
+  return {
+    x: f,
+    y: p,
+    width: s.width,
+    height: s.height
+  };
+}
+function Rt(t) {
+  return j(t).position === "static";
+}
+function oe(t, e) {
+  if (!U(t) || j(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let n = t.offsetParent;
+  return Z(t) === n && (n = n.ownerDocument.body), n;
+}
+function me(t, e) {
+  const n = V(t);
+  if (vt(t))
+    return n;
+  if (!U(t)) {
+    let i = et(t);
+    for (; i && !it(i); ) {
+      if (Y(i) && !Rt(i))
+        return i;
+      i = et(i);
+    }
+    return n;
+  }
+  let o = oe(t, e);
+  for (; o && cn(o) && Rt(o); )
+    o = oe(o, e);
+  return o && it(o) && Rt(o) && !$t(o) ? n : o || ln(t) || n;
+}
+const vn = function(t) {
+  return I(this, null, function* () {
+    const e = this.getOffsetParent || me, n = this.getDimensions, o = yield n(t.floating);
+    return {
+      reference: yn(t.reference, yield e(t.floating), t.strategy),
+      floating: {
+        x: 0,
+        y: 0,
+        width: o.width,
+        height: o.height
+      }
+    };
+  });
+};
+function bn(t) {
+  return j(t).direction === "rtl";
+}
+const An = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: un,
+  getDocumentElement: Z,
+  getClippingRect: wn,
+  getOffsetParent: me,
+  getElementRects: vn,
+  getClientRects: dn,
+  getDimensions: xn,
+  getScale: ot,
+  isElement: Y,
+  isRTL: bn
+};
+function he(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function Rn(t, e) {
+  let n = null, o;
+  const i = Z(t);
+  function r() {
+    var l;
+    clearTimeout(o), (l = n) == null || l.disconnect(), n = null;
+  }
+  function s(l, c) {
+    l === void 0 && (l = !1), c === void 0 && (c = 1), r();
+    const a = t.getBoundingClientRect(), {
+      left: d,
+      top: f,
+      width: p,
+      height: u
+    } = a;
+    if (l || e(), !p || !u)
+      return;
+    const h = pt(f), m = pt(i.clientWidth - (d + p)), w = pt(i.clientHeight - (f + u)), x = pt(d), y = {
+      rootMargin: -h + "px " + -m + "px " + -w + "px " + -x + "px",
+      threshold: z(0, tt(1, c)) || 1
+    };
+    let g = !0;
+    function v(P) {
+      const S = P[0].intersectionRatio;
+      if (S !== c) {
+        if (!g)
+          return s();
+        S ? s(!1, S) : o = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      S === 1 && !he(a, t.getBoundingClientRect()) && s(), g = !1;
+    }
+    try {
+      n = new IntersectionObserver(v, O(b({}, y), {
+        // Handle <iframe>s
+        root: i.ownerDocument
+      }));
+    } catch (P) {
+      n = new IntersectionObserver(v, y);
+    }
+    n.observe(t);
+  }
+  return s(!0), r;
+}
+function On(t, e, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: r = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = o, a = Ft(t), d = i || r ? [...a ? at(a) : [], ...at(e)] : [];
+  d.forEach((x) => {
+    i && x.addEventListener("scroll", n, {
+      passive: !0
+    }), r && x.addEventListener("resize", n);
+  });
+  const f = a && l ? Rn(a, n) : null;
+  let p = -1, u = null;
+  s && (u = new ResizeObserver((x) => {
+    let [A] = x;
+    A && A.target === a && u && (u.unobserve(e), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var y;
+      (y = u) == null || y.observe(e);
+    })), n();
+  }), a && !c && u.observe(a), u.observe(e));
+  let h, m = c ? nt(t) : null;
+  c && w();
+  function w() {
+    const x = nt(t);
+    m && !he(m, x) && n(), m = x, h = requestAnimationFrame(w);
+  }
+  return n(), () => {
+    var x;
+    d.forEach((A) => {
+      i && A.removeEventListener("scroll", n), r && A.removeEventListener("resize", n);
+    }), f == null || f(), (x = u) == null || x.disconnect(), u = null, c && cancelAnimationFrame(h);
+  };
+}
+const Cn = nn, Pn = on, Sn = Qe, En = sn, Dn = tn, ie = Je, Ln = rn, Tn = (t, e, n) => {
+  const o = /* @__PURE__ */ new Map(), i = b({
+    platform: An
+  }, n), r = O(b({}, i.platform), {
+    _c: o
+  });
+  return Ge(t, e, O(b({}, i), {
+    platform: r
+  }));
+};
+var Mn = typeof document != "undefined", $n = function() {
+}, mt = Mn ? We : $n;
+function xt(t, e) {
+  if (t === e)
+    return !0;
+  if (typeof t != typeof e)
+    return !1;
+  if (typeof t == "function" && t.toString() === e.toString())
+    return !0;
+  let n, o, i;
+  if (t && e && typeof t == "object") {
+    if (Array.isArray(t)) {
+      if (n = t.length, n !== e.length) return !1;
+      for (o = n; o-- !== 0; )
+        if (!xt(t[o], e[o]))
+          return !1;
+      return !0;
+    }
+    if (i = Object.keys(t), n = i.length, n !== Object.keys(e).length)
+      return !1;
+    for (o = n; o-- !== 0; )
+      if (!{}.hasOwnProperty.call(e, i[o]))
+        return !1;
+    for (o = n; o-- !== 0; ) {
+      const r = i[o];
+      if (!(r === "_owner" && t.$$typeof) && !xt(t[r], e[r]))
+        return !1;
+    }
+    return !0;
+  }
+  return t !== t && e !== e;
+}
+function ge(t) {
+  return typeof window == "undefined" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function re(t, e) {
+  const n = ge(t);
+  return Math.round(e * n) / n;
+}
+function Ot(t) {
+  const e = C.useRef(t);
+  return mt(() => {
+    e.current = t;
+  }), e;
+}
+function kn(t) {
+  t === void 0 && (t = {});
+  const {
+    placement: e = "bottom",
+    strategy: n = "absolute",
+    middleware: o = [],
+    platform: i,
+    elements: {
+      reference: r,
+      floating: s
+    } = {},
+    transform: l = !0,
+    whileElementsMounted: c,
+    open: a
+  } = t, [d, f] = C.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: e,
+    middlewareData: {},
+    isPositioned: !1
+  }), [p, u] = C.useState(o);
+  xt(p, o) || u(o);
+  const [h, m] = C.useState(null), [w, x] = C.useState(null), A = C.useCallback((R) => {
+    R !== P.current && (P.current = R, m(R));
+  }, []), y = C.useCallback((R) => {
+    R !== S.current && (S.current = R, x(R));
+  }, []), g = r || h, v = s || w, P = C.useRef(null), S = C.useRef(null), T = C.useRef(d), W = c != null, k = Ot(c), M = Ot(i), _ = Ot(a), E = C.useCallback(() => {
+    if (!P.current || !S.current)
+      return;
+    const R = {
+      placement: e,
+      strategy: n,
+      middleware: p
+    };
+    M.current && (R.platform = M.current), Tn(P.current, S.current, R).then((N) => {
+      const L = O(b({}, N), {
+        // 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: _.current !== !1
+      });
+      H.current && !xt(T.current, L) && (T.current = L, _e.flushSync(() => {
+        f(L);
+      }));
+    });
+  }, [p, e, n, M, _]);
+  mt(() => {
+    a === !1 && T.current.isPositioned && (T.current.isPositioned = !1, f((R) => O(b({}, R), {
+      isPositioned: !1
+    })));
+  }, [a]);
+  const H = C.useRef(!1);
+  mt(() => (H.current = !0, () => {
+    H.current = !1;
+  }), []), mt(() => {
+    if (g && (P.current = g), v && (S.current = v), g && v) {
+      if (k.current)
+        return k.current(g, v, E);
+      E();
+    }
+  }, [g, v, E, k, W]);
+  const $ = C.useMemo(() => ({
+    reference: P,
+    floating: S,
+    setReference: A,
+    setFloating: y
+  }), [A, y]), D = C.useMemo(() => ({
+    reference: g,
+    floating: v
+  }), [g, v]), F = C.useMemo(() => {
+    const R = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!D.floating)
+      return R;
+    const N = re(D.floating, d.x), L = re(D.floating, d.y);
+    return l ? b(O(b({}, R), {
+      transform: "translate(" + N + "px, " + L + "px)"
+    }), ge(D.floating) >= 1.5 && {
+      willChange: "transform"
+    }) : {
+      position: n,
+      left: N,
+      top: L
+    };
+  }, [n, l, D.floating, d.x, d.y]);
+  return C.useMemo(() => O(b({}, d), {
+    update: E,
+    refs: $,
+    elements: D,
+    floatingStyles: F
+  }), [d, E, $, D, F]);
+}
+const Fn = (t) => {
+  function e(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: t,
+    fn(n) {
+      const {
+        element: o,
+        padding: i
+      } = typeof t == "function" ? t(n) : t;
+      return o && e(o) ? o.current != null ? ie({
+        element: o.current,
+        padding: i
+      }).fn(n) : {} : o ? ie({
+        element: o,
+        padding: i
+      }).fn(n) : {};
+    }
+  };
+}, Nn = (t, e) => O(b({}, Cn(t)), {
+  options: [t, e]
+}), Hn = (t, e) => O(b({}, Pn(t)), {
+  options: [t, e]
+}), Wn = (t, e) => O(b({}, Ln(t)), {
+  options: [t, e]
+}), _n = (t, e) => O(b({}, Sn(t)), {
+  options: [t, e]
+}), Bn = (t, e) => O(b({}, En(t)), {
+  options: [t, e]
+}), zn = (t, e) => O(b({}, Dn(t)), {
+  options: [t, e]
+}), Vn = (t, e) => O(b({}, Fn(t)), {
+  options: [t, e]
+});
+var In = "Arrow", we = C.forwardRef((t, e) => {
+  const s = t, { children: n, width: o = 10, height: i = 5 } = s, r = K(s, ["children", "width", "height"]);
+  return /* @__PURE__ */ G(
+    Dt.svg,
+    O(b({}, r), {
+      ref: e,
+      width: o,
+      height: i,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: t.asChild ? n : /* @__PURE__ */ G("polygon", { points: "0,0 30,0 15,10" })
+    })
+  );
+});
+we.displayName = In;
+var Yn = we, Ht = "Popper", [xe, oo] = Be(Ht), [jn, ye] = xe(Ht), ve = (t) => {
+  const { __scopePopper: e, children: n } = t, [o, i] = C.useState(null);
+  return /* @__PURE__ */ G(jn, { scope: e, anchor: o, onAnchorChange: i, children: n });
+};
+ve.displayName = Ht;
+var be = "PopperAnchor", Ae = C.forwardRef(
+  (t, e) => {
+    const c = t, { __scopePopper: n, virtualRef: o } = c, i = K(c, ["__scopePopper", "virtualRef"]), r = ye(be, n), s = C.useRef(null), l = se(e, s);
+    return C.useEffect(() => {
+      r.onAnchorChange((o == null ? void 0 : o.current) || s.current);
+    }), o ? null : /* @__PURE__ */ G(Dt.div, O(b({}, i), { ref: l }));
+  }
+);
+Ae.displayName = be;
+var Wt = "PopperContent", [Xn, qn] = xe(Wt), Re = C.forwardRef(
+  (t, e) => {
+    var Bt, zt, Vt, It, Yt, jt, Xt, qt;
+    const _t = t, {
+      __scopePopper: n,
+      side: o = "bottom",
+      sideOffset: i = 0,
+      align: r = "center",
+      alignOffset: s = 0,
+      arrowPadding: l = 0,
+      avoidCollisions: c = !0,
+      collisionBoundary: a = [],
+      collisionPadding: d = 0,
+      sticky: f = "partial",
+      hideWhenDetached: p = !1,
+      updatePositionStrategy: u = "optimized",
+      onPlaced: h
+    } = _t, m = K(_t, [
+      "__scopePopper",
+      "side",
+      "sideOffset",
+      "align",
+      "alignOffset",
+      "arrowPadding",
+      "avoidCollisions",
+      "collisionBoundary",
+      "collisionPadding",
+      "sticky",
+      "hideWhenDetached",
+      "updatePositionStrategy",
+      "onPlaced"
+    ]), w = ye(Wt, n), [x, A] = C.useState(null), y = se(e, (ct) => A(ct)), [g, v] = C.useState(null), P = Ve(g), S = (Bt = P == null ? void 0 : P.width) != null ? Bt : 0, T = (zt = P == null ? void 0 : P.height) != null ? zt : 0, W = o + (r !== "center" ? "-" + r : ""), k = typeof d == "number" ? d : b({ top: 0, right: 0, bottom: 0, left: 0 }, d), M = Array.isArray(a) ? a : [a], _ = M.length > 0, E = {
+      padding: k,
+      boundary: M.filter(Zn),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: _
+    }, { refs: H, floatingStyles: $, placement: D, isPositioned: F, middlewareData: R } = kn({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: W,
+      whileElementsMounted: (...ct) => On(...ct, {
+        animationFrame: u === "always"
+      }),
+      elements: {
+        reference: w.anchor
+      },
+      middleware: [
+        Nn({ mainAxis: i + T, alignmentAxis: s }),
+        c && Hn(b({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: f === "partial" ? Wn() : void 0
+        }, E)),
+        c && _n(b({}, E)),
+        Bn(O(b({}, E), {
+          apply: ({ elements: ct, rects: Ut, availableWidth: Te, availableHeight: Me }) => {
+            const { width: $e, height: ke } = Ut.reference, ut = ct.floating.style;
+            ut.setProperty("--radix-popper-available-width", `${Te}px`), ut.setProperty("--radix-popper-available-height", `${Me}px`), ut.setProperty("--radix-popper-anchor-width", `${$e}px`), ut.setProperty("--radix-popper-anchor-height", `${ke}px`);
+          }
+        })),
+        g && Vn({ element: g, padding: l }),
+        Kn({ arrowWidth: S, arrowHeight: T }),
+        p && zn(b({ strategy: "referenceHidden" }, E))
+      ]
+    }), [N, L] = Pe(D), B = ze(h);
+    Ct(() => {
+      F && (B == null || B());
+    }, [F, B]);
+    const At = (Vt = R.arrow) == null ? void 0 : Vt.x, Se = (It = R.arrow) == null ? void 0 : It.y, Ee = ((Yt = R.arrow) == null ? void 0 : Yt.centerOffset) !== 0, [De, Le] = C.useState();
+    return Ct(() => {
+      x && Le(window.getComputedStyle(x).zIndex);
+    }, [x]), /* @__PURE__ */ G(
+      "div",
+      {
+        ref: H.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: b(O(b({}, $), {
+          transform: F ? $.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: De,
+          "--radix-popper-transform-origin": [
+            (jt = R.transformOrigin) == null ? void 0 : jt.x,
+            (Xt = R.transformOrigin) == null ? void 0 : Xt.y
+          ].join(" ")
+        }), ((qt = R.hide) == null ? void 0 : qt.referenceHidden) && {
+          visibility: "hidden",
+          pointerEvents: "none"
+        }),
+        dir: t.dir,
+        children: /* @__PURE__ */ G(
+          Xn,
+          {
+            scope: n,
+            placedSide: N,
+            onArrowChange: v,
+            arrowX: At,
+            arrowY: Se,
+            shouldHideArrow: Ee,
+            children: /* @__PURE__ */ G(
+              Dt.div,
+              O(b({
+                "data-side": N,
+                "data-align": L
+              }, m), {
+                ref: y,
+                style: O(b({}, m.style), {
+                  // if the PopperContent hasn't been placed yet (not all measurements done)
+                  // we prevent animations so that users's animation don't kick in too early referring wrong sides
+                  animation: F ? void 0 : "none"
+                })
+              })
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Re.displayName = Wt;
+var Oe = "PopperArrow", Un = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, Ce = C.forwardRef(function(e, n) {
+  const l = e, { __scopePopper: o } = l, i = K(l, ["__scopePopper"]), r = qn(Oe, o), s = Un[r.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__ */ G(
+      "span",
+      {
+        ref: r.onArrowChange,
+        style: {
+          position: "absolute",
+          left: r.arrowX,
+          top: r.arrowY,
+          [s]: 0,
+          transformOrigin: {
+            top: "",
+            right: "0 0",
+            bottom: "center 0",
+            left: "100% 0"
+          }[r.placedSide],
+          transform: {
+            top: "translateY(100%)",
+            right: "translateY(50%) rotate(90deg) translateX(-50%)",
+            bottom: "rotate(180deg)",
+            left: "translateY(50%) rotate(-90deg) translateX(50%)"
+          }[r.placedSide],
+          visibility: r.shouldHideArrow ? "hidden" : void 0
+        },
+        children: /* @__PURE__ */ G(
+          Yn,
+          O(b({}, i), {
+            ref: n,
+            style: O(b({}, i.style), {
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            })
+          })
+        )
+      }
+    )
+  );
+});
+Ce.displayName = Oe;
+function Zn(t) {
+  return t !== null;
+}
+var Kn = (t) => ({
+  name: "transformOrigin",
+  options: t,
+  fn(e) {
+    var w, x, A, y, g;
+    const { placement: n, rects: o, middlewareData: i } = e, s = ((w = i.arrow) == null ? void 0 : w.centerOffset) !== 0, l = s ? 0 : t.arrowWidth, c = s ? 0 : t.arrowHeight, [a, d] = Pe(n), f = { start: "0%", center: "50%", end: "100%" }[d], p = ((A = (x = i.arrow) == null ? void 0 : x.x) != null ? A : 0) + l / 2, u = ((g = (y = i.arrow) == null ? void 0 : y.y) != null ? g : 0) + c / 2;
+    let h = "", m = "";
+    return a === "bottom" ? (h = s ? f : `${p}px`, m = `${-c}px`) : a === "top" ? (h = s ? f : `${p}px`, m = `${o.floating.height + c}px`) : a === "right" ? (h = `${-c}px`, m = s ? f : `${u}px`) : a === "left" && (h = `${o.floating.width + c}px`, m = s ? f : `${u}px`), { data: { x: h, y: m } };
+  }
+});
+function Pe(t) {
+  const [e, n = "center"] = t.split("-");
+  return [e, n];
+}
+var io = ve, ro = Ae, so = Re, co = Ce;
+export {
+  ro as A,
+  so as C,
+  io as R,
+  co as a,
+  oo as c,
+  Ve as u
+};
+//# sourceMappingURL=index-n71RB2rx.js.map