@marimo-team/islands 0.19.12-dev1 → 0.20.0

package/dist/dist-B8Y11RWn.js

@@ -0,0 +1,1381 @@
+import { s as __toESM } from "./chunk-BNovOVIE.js";
+import { t as require_react } from "./react-Bs6Z0kvn.js";
+import { m as useComposedRefs } from "./button-KYalaJYu.js";
+import { _t as createContextScope, dt as useCallbackRef, ft as Primitive, lt as useLayoutEffect2 } from "./Combination-Du-o_hC9.js";
+import { t as require_jsx_runtime } from "./jsx-runtime-CTBg5pdT.js";
+import { t as require_react_dom } from "./react-dom-CqtLRVZP.js";
+/**
+* @license lucide-react v0.563.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+var mergeClasses = (...e) => e.filter((e2, s, c) => !!e2 && e2.trim() !== "" && c.indexOf(e2) === s).join(" ").trim(), toKebabCase = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toCamelCase = (e) => e.replace(/^([A-Z])|[\s-_]+(\w)/g, (e2, s, c) => c ? c.toUpperCase() : s.toLowerCase()), toPascalCase = (e) => {
+  let s = toCamelCase(e);
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}, defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+}, hasA11yProp = (e) => {
+  for (let s in e) if (s.startsWith("aria-") || s === "role" || s === "title") return true;
+  return false;
+}, import_react = /* @__PURE__ */ __toESM(require_react()), Icon = (0, import_react.forwardRef)(({ color: e = "currentColor", size: s = 24, strokeWidth: c = 2, absoluteStrokeWidth: l, className: u = "", children: d, iconNode: f, ...p }, m) => (0, import_react.createElement)("svg", {
+  ref: m,
+  ...defaultAttributes,
+  width: s,
+  height: s,
+  stroke: e,
+  strokeWidth: l ? Number(c) * 24 / Number(s) : c,
+  className: mergeClasses("lucide", u),
+  ...!d && !hasA11yProp(p) && { "aria-hidden": "true" },
+  ...p
+}, [...f.map(([e2, s2]) => (0, import_react.createElement)(e2, s2)), ...Array.isArray(d) ? d : [d]])), createLucideIcon = (e, s) => {
+  let c = (0, import_react.forwardRef)(({ className: c2, ...l }, u) => (0, import_react.createElement)(Icon, {
+    ref: u,
+    iconNode: s,
+    className: mergeClasses(`lucide-${toKebabCase(toPascalCase(e))}`, `lucide-${e}`, c2),
+    ...l
+  }));
+  return c.displayName = toPascalCase(e), c;
+}, sides = [
+  "top",
+  "right",
+  "bottom",
+  "left"
+], min = Math.min, max = Math.max, round = Math.round, floor = Math.floor, createCoords = (e) => ({
+  x: e,
+  y: e
+}), oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function clamp(e, s, c) {
+  return max(e, min(s, c));
+}
+function evaluate(e, s) {
+  return typeof e == "function" ? e(s) : e;
+}
+function getSide(e) {
+  return e.split("-")[0];
+}
+function getAlignment(e) {
+  return e.split("-")[1];
+}
+function getOppositeAxis(e) {
+  return e === "x" ? "y" : "x";
+}
+function getAxisLength(e) {
+  return e === "y" ? "height" : "width";
+}
+var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(e) {
+  return yAxisSides.has(getSide(e)) ? "y" : "x";
+}
+function getAlignmentAxis(e) {
+  return getOppositeAxis(getSideAxis(e));
+}
+function getAlignmentSides(e, s, c) {
+  c === void 0 && (c = false);
+  let l = getAlignment(e), u = getAlignmentAxis(e), d = getAxisLength(u), f = u === "x" ? l === (c ? "end" : "start") ? "right" : "left" : l === "start" ? "bottom" : "top";
+  return s.reference[d] > s.floating[d] && (f = getOppositePlacement(f)), [f, getOppositePlacement(f)];
+}
+function getExpandedPlacements(e) {
+  let s = getOppositePlacement(e);
+  return [
+    getOppositeAlignmentPlacement(e),
+    s,
+    getOppositeAlignmentPlacement(s)
+  ];
+}
+function getOppositeAlignmentPlacement(e) {
+  return e.replace(/start|end/g, (e2) => oppositeAlignmentMap[e2]);
+}
+var lrPlacement = ["left", "right"], rlPlacement = ["right", "left"], tbPlacement = ["top", "bottom"], btPlacement = ["bottom", "top"];
+function getSideList(e, s, c) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return c ? s ? rlPlacement : lrPlacement : s ? lrPlacement : rlPlacement;
+    case "left":
+    case "right":
+      return s ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(e, s, c, l) {
+  let u = getAlignment(e), d = getSideList(getSide(e), c === "start", l);
+  return u && (d = d.map((e2) => e2 + "-" + u), s && (d = d.concat(d.map(getOppositeAlignmentPlacement)))), d;
+}
+function getOppositePlacement(e) {
+  return e.replace(/left|right|bottom|top/g, (e2) => oppositeSideMap[e2]);
+}
+function expandPaddingObject(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function getPaddingObject(e) {
+  return typeof e == "number" ? {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  } : expandPaddingObject(e);
+}
+function rectToClientRect(e) {
+  let { x: s, y: c, width: l, height: u } = e;
+  return {
+    width: l,
+    height: u,
+    top: c,
+    left: s,
+    right: s + l,
+    bottom: c + u,
+    x: s,
+    y: c
+  };
+}
+function computeCoordsFromPlacement(e, s, c) {
+  let { reference: l, floating: u } = e, d = getSideAxis(s), f = getAlignmentAxis(s), p = getAxisLength(f), m = getSide(s), h = d === "y", g = l.x + l.width / 2 - u.width / 2, _ = l.y + l.height / 2 - u.height / 2, v = l[p] / 2 - u[p] / 2, y;
+  switch (m) {
+    case "top":
+      y = {
+        x: g,
+        y: l.y - u.height
+      };
+      break;
+    case "bottom":
+      y = {
+        x: g,
+        y: l.y + l.height
+      };
+      break;
+    case "right":
+      y = {
+        x: l.x + l.width,
+        y: _
+      };
+      break;
+    case "left":
+      y = {
+        x: l.x - u.width,
+        y: _
+      };
+      break;
+    default:
+      y = {
+        x: l.x,
+        y: l.y
+      };
+  }
+  switch (getAlignment(s)) {
+    case "start":
+      y[f] -= v * (c && h ? -1 : 1);
+      break;
+    case "end":
+      y[f] += v * (c && h ? -1 : 1);
+      break;
+  }
+  return y;
+}
+var computePosition$1 = async (e, s, c) => {
+  let { placement: l = "bottom", strategy: u = "absolute", middleware: d = [], platform: f } = c, p = d.filter(Boolean), m = await (f.isRTL == null ? void 0 : f.isRTL(s)), h = await f.getElementRects({
+    reference: e,
+    floating: s,
+    strategy: u
+  }), { x: g, y: _ } = computeCoordsFromPlacement(h, l, m), v = l, y = {}, b = 0;
+  for (let c2 = 0; c2 < p.length; c2++) {
+    let { name: d2, fn: x } = p[c2], { x: S, y: C, data: w, reset: T } = await x({
+      x: g,
+      y: _,
+      initialPlacement: l,
+      placement: v,
+      strategy: u,
+      middlewareData: y,
+      rects: h,
+      platform: f,
+      elements: {
+        reference: e,
+        floating: s
+      }
+    });
+    g = S ?? g, _ = C ?? _, y = {
+      ...y,
+      [d2]: {
+        ...y[d2],
+        ...w
+      }
+    }, T && b <= 50 && (b++, typeof T == "object" && (T.placement && (v = T.placement), T.rects && (h = T.rects === true ? await f.getElementRects({
+      reference: e,
+      floating: s,
+      strategy: u
+    }) : T.rects), { x: g, y: _ } = computeCoordsFromPlacement(h, v, m)), c2 = -1);
+  }
+  return {
+    x: g,
+    y: _,
+    placement: v,
+    strategy: u,
+    middlewareData: y
+  };
+};
+async function detectOverflow$1(e, s) {
+  s === void 0 && (s = {});
+  let { x: c, y: l, platform: u, rects: d, elements: f, strategy: p } = e, { boundary: m = "clippingAncestors", rootBoundary: h = "viewport", elementContext: g = "floating", altBoundary: _ = false, padding: v = 0 } = evaluate(s, e), y = getPaddingObject(v), b = f[_ ? g === "floating" ? "reference" : "floating" : g], x = rectToClientRect(await u.getClippingRect({
+    element: await (u.isElement == null ? void 0 : u.isElement(b)) ?? true ? b : b.contextElement || await (u.getDocumentElement == null ? void 0 : u.getDocumentElement(f.floating)),
+    boundary: m,
+    rootBoundary: h,
+    strategy: p
+  })), S = g === "floating" ? {
+    x: c,
+    y: l,
+    width: d.floating.width,
+    height: d.floating.height
+  } : d.reference, C = await (u.getOffsetParent == null ? void 0 : u.getOffsetParent(f.floating)), w = await (u.isElement == null ? void 0 : u.isElement(C)) && await (u.getScale == null ? void 0 : u.getScale(C)) || {
+    x: 1,
+    y: 1
+  }, T = rectToClientRect(u.convertOffsetParentRelativeRectToViewportRelativeRect ? await u.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: f,
+    rect: S,
+    offsetParent: C,
+    strategy: p
+  }) : S);
+  return {
+    top: (x.top - T.top + y.top) / w.y,
+    bottom: (T.bottom - x.bottom + y.bottom) / w.y,
+    left: (x.left - T.left + y.left) / w.x,
+    right: (T.right - x.right + y.right) / w.x
+  };
+}
+var arrow$2 = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(s) {
+    let { x: c, y: l, placement: u, rects: d, platform: f, elements: p, middlewareData: m } = s, { element: h, padding: g = 0 } = evaluate(e, s) || {};
+    if (h == null) return {};
+    let _ = getPaddingObject(g), v = {
+      x: c,
+      y: l
+    }, y = getAlignmentAxis(u), b = getAxisLength(y), x = await f.getDimensions(h), S = y === "y", C = S ? "top" : "left", w = S ? "bottom" : "right", E = S ? "clientHeight" : "clientWidth", D = d.reference[b] + d.reference[y] - v[y] - d.floating[b], O = v[y] - d.reference[y], k = await (f.getOffsetParent == null ? void 0 : f.getOffsetParent(h)), A = k ? k[E] : 0;
+    (!A || !await (f.isElement == null ? void 0 : f.isElement(k))) && (A = p.floating[E] || d.floating[b]);
+    let j = D / 2 - O / 2, P = A / 2 - x[b] / 2 - 1, I = min(_[C], P), R = min(_[w], P), z = I, V = A - x[b] - R, H = A / 2 - x[b] / 2 + j, U = clamp(z, H, V), W = !m.arrow && getAlignment(u) != null && H !== U && d.reference[b] / 2 - (H < z ? I : R) - x[b] / 2 < 0, G = W ? H < z ? H - z : H - V : 0;
+    return {
+      [y]: v[y] + G,
+      data: {
+        [y]: U,
+        centerOffset: H - U - G,
+        ...W && { alignmentOffset: G }
+      },
+      reset: W
+    };
+  }
+}), flip$2 = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(s) {
+      var _a, _b, _c, _d;
+      var c;
+      let { placement: l, middlewareData: u, rects: d, initialPlacement: f, platform: p, elements: m } = s, { mainAxis: h = true, crossAxis: g = true, fallbackPlacements: _, fallbackStrategy: v = "bestFit", fallbackAxisSideDirection: y = "none", flipAlignment: b = true, ...x } = evaluate(e, s);
+      if ((c = u.arrow) != null && c.alignmentOffset) return {};
+      let S = getSide(l), C = getSideAxis(f), w = getSide(f) === f, T = await (p.isRTL == null ? void 0 : p.isRTL(m.floating)), E = _ || (w || !b ? [getOppositePlacement(f)] : getExpandedPlacements(f)), D = y !== "none";
+      !_ && D && E.push(...getOppositeAxisPlacements(f, b, y, T));
+      let O = [f, ...E], k = await detectOverflow$1(s, x), A = [], j = ((_a = u.flip) == null ? void 0 : _a.overflows) || [];
+      if (h && A.push(k[S]), g) {
+        let e2 = getAlignmentSides(l, d, T);
+        A.push(k[e2[0]], k[e2[1]]);
+      }
+      if (j = [...j, {
+        placement: l,
+        overflows: A
+      }], !A.every((e2) => e2 <= 0)) {
+        let e2 = (((_b = u.flip) == null ? void 0 : _b.index) || 0) + 1, s2 = O[e2];
+        if (s2 && (!(g === "alignment" && C !== getSideAxis(s2)) || j.every((e3) => e3.overflows[0] > 0 && getSideAxis(e3.placement) === C))) return {
+          data: {
+            index: e2,
+            overflows: j
+          },
+          reset: { placement: s2 }
+        };
+        let c2 = (_c = j.filter((e3) => e3.overflows[0] <= 0).sort((e3, s3) => e3.overflows[1] - s3.overflows[1])[0]) == null ? void 0 : _c.placement;
+        if (!c2) switch (v) {
+          case "bestFit": {
+            let e3 = (_d = j.filter((e4) => {
+              if (D) {
+                let s3 = getSideAxis(e4.placement);
+                return s3 === C || s3 === "y";
+              }
+              return true;
+            }).map((e4) => [e4.placement, e4.overflows.filter((e5) => e5 > 0).reduce((e5, s3) => e5 + s3, 0)]).sort((e4, s3) => e4[1] - s3[1])[0]) == null ? void 0 : _d[0];
+            e3 && (c2 = e3);
+            break;
+          }
+          case "initialPlacement":
+            c2 = f;
+            break;
+        }
+        if (l !== c2) return { reset: { placement: c2 } };
+      }
+      return {};
+    }
+  };
+};
+function getSideOffsets(e, s) {
+  return {
+    top: e.top - s.height,
+    right: e.right - s.width,
+    bottom: e.bottom - s.height,
+    left: e.left - s.width
+  };
+}
+function isAnySideFullyClipped(e) {
+  return sides.some((s) => e[s] >= 0);
+}
+var hide$2 = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(s) {
+      let { rects: c } = s, { strategy: l = "referenceHidden", ...u } = evaluate(e, s);
+      switch (l) {
+        case "referenceHidden": {
+          let e2 = getSideOffsets(await detectOverflow$1(s, {
+            ...u,
+            elementContext: "reference"
+          }), c.reference);
+          return { data: {
+            referenceHiddenOffsets: e2,
+            referenceHidden: isAnySideFullyClipped(e2)
+          } };
+        }
+        case "escaped": {
+          let e2 = getSideOffsets(await detectOverflow$1(s, {
+            ...u,
+            altBoundary: true
+          }), c.floating);
+          return { data: {
+            escapedOffsets: e2,
+            escaped: isAnySideFullyClipped(e2)
+          } };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(e, s) {
+  let { placement: c, platform: l, elements: u } = e, d = await (l.isRTL == null ? void 0 : l.isRTL(u.floating)), f = getSide(c), p = getAlignment(c), m = getSideAxis(c) === "y", h = originSides.has(f) ? -1 : 1, g = d && m ? -1 : 1, _ = evaluate(s, e), { mainAxis: v, crossAxis: y, alignmentAxis: b } = typeof _ == "number" ? {
+    mainAxis: _,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: _.mainAxis || 0,
+    crossAxis: _.crossAxis || 0,
+    alignmentAxis: _.alignmentAxis
+  };
+  return p && typeof b == "number" && (y = p === "end" ? b * -1 : b), m ? {
+    x: y * g,
+    y: v * h
+  } : {
+    x: v * h,
+    y: y * g
+  };
+}
+var offset$2 = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(s) {
+      var _a;
+      var c;
+      let { x: l, y: u, placement: d, middlewareData: f } = s, p = await convertValueToCoords(s, e);
+      return d === ((_a = f.offset) == null ? void 0 : _a.placement) && (c = f.arrow) != null && c.alignmentOffset ? {} : {
+        x: l + p.x,
+        y: u + p.y,
+        data: {
+          ...p,
+          placement: d
+        }
+      };
+    }
+  };
+}, shift$2 = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(s) {
+      let { x: c, y: l, placement: u } = s, { mainAxis: d = true, crossAxis: f = false, limiter: p = { fn: (e2) => {
+        let { x: s2, y: c2 } = e2;
+        return {
+          x: s2,
+          y: c2
+        };
+      } }, ...m } = evaluate(e, s), h = {
+        x: c,
+        y: l
+      }, g = await detectOverflow$1(s, m), _ = getSideAxis(getSide(u)), v = getOppositeAxis(_), y = h[v], b = h[_];
+      if (d) {
+        let e2 = v === "y" ? "top" : "left", s2 = v === "y" ? "bottom" : "right", c2 = y + g[e2], l2 = y - g[s2];
+        y = clamp(c2, y, l2);
+      }
+      if (f) {
+        let e2 = _ === "y" ? "top" : "left", s2 = _ === "y" ? "bottom" : "right", c2 = b + g[e2], l2 = b - g[s2];
+        b = clamp(c2, b, l2);
+      }
+      let x = p.fn({
+        ...s,
+        [v]: y,
+        [_]: b
+      });
+      return {
+        ...x,
+        data: {
+          x: x.x - c,
+          y: x.y - l,
+          enabled: {
+            [v]: d,
+            [_]: f
+          }
+        }
+      };
+    }
+  };
+}, limitShift$2 = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(s) {
+      var _a, _b;
+      let { x: c, y: l, placement: u, rects: d, middlewareData: f } = s, { offset: p = 0, mainAxis: m = true, crossAxis: h = true } = evaluate(e, s), g = {
+        x: c,
+        y: l
+      }, _ = getSideAxis(u), v = getOppositeAxis(_), y = g[v], b = g[_], x = evaluate(p, s), S = typeof x == "number" ? {
+        mainAxis: x,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...x
+      };
+      if (m) {
+        let e2 = v === "y" ? "height" : "width", s2 = d.reference[v] - d.floating[e2] + S.mainAxis, c2 = d.reference[v] + d.reference[e2] - S.mainAxis;
+        y < s2 ? y = s2 : y > c2 && (y = c2);
+      }
+      if (h) {
+        let e2 = v === "y" ? "width" : "height", s2 = originSides.has(getSide(u)), c2 = d.reference[_] - d.floating[e2] + (s2 && ((_a = f.offset) == null ? void 0 : _a[_]) || 0) + (s2 ? 0 : S.crossAxis), l2 = d.reference[_] + d.reference[e2] + (s2 ? 0 : ((_b = f.offset) == null ? void 0 : _b[_]) || 0) - (s2 ? S.crossAxis : 0);
+        b < c2 ? b = c2 : b > l2 && (b = l2);
+      }
+      return {
+        [v]: y,
+        [_]: b
+      };
+    }
+  };
+}, size$2 = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(s) {
+      var c, l;
+      let { placement: u, rects: d, platform: f, elements: p } = s, { apply: m = () => {
+      }, ...h } = evaluate(e, s), g = await detectOverflow$1(s, h), _ = getSide(u), v = getAlignment(u), y = getSideAxis(u) === "y", { width: b, height: x } = d.floating, S, C;
+      _ === "top" || _ === "bottom" ? (S = _, C = v === (await (f.isRTL == null ? void 0 : f.isRTL(p.floating)) ? "start" : "end") ? "left" : "right") : (C = _, S = v === "end" ? "top" : "bottom");
+      let w = x - g.top - g.bottom, D = b - g.left - g.right, O = min(x - g[S], w), k = min(b - g[C], D), A = !s.middlewareData.shift, j = O, M = k;
+      if ((c = s.middlewareData.shift) != null && c.enabled.x && (M = D), (l = s.middlewareData.shift) != null && l.enabled.y && (j = w), A && !v) {
+        let e2 = max(g.left, 0), s2 = max(g.right, 0), c2 = max(g.top, 0), l2 = max(g.bottom, 0);
+        y ? M = b - 2 * (e2 !== 0 || s2 !== 0 ? e2 + s2 : max(g.left, g.right)) : j = x - 2 * (c2 !== 0 || l2 !== 0 ? c2 + l2 : max(g.top, g.bottom));
+      }
+      await m({
+        ...s,
+        availableWidth: M,
+        availableHeight: j
+      });
+      let I = await f.getDimensions(p.floating);
+      return b !== I.width || x !== I.height ? { reset: { rects: true } } : {};
+    }
+  };
+};
+function hasWindow() {
+  return typeof window < "u";
+}
+function getNodeName(e) {
+  return isNode(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function getWindow(e) {
+  var s;
+  return (e == null || (s = e.ownerDocument) == null ? void 0 : s.defaultView) || window;
+}
+function getDocumentElement(e) {
+  var _a;
+  return (_a = (isNode(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : _a.documentElement;
+}
+function isNode(e) {
+  return hasWindow() ? e instanceof Node || e instanceof getWindow(e).Node : false;
+}
+function isElement(e) {
+  return hasWindow() ? e instanceof Element || e instanceof getWindow(e).Element : false;
+}
+function isHTMLElement(e) {
+  return hasWindow() ? e instanceof HTMLElement || e instanceof getWindow(e).HTMLElement : false;
+}
+function isShadowRoot(e) {
+  return !hasWindow() || typeof ShadowRoot > "u" ? false : e instanceof ShadowRoot || e instanceof getWindow(e).ShadowRoot;
+}
+var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(e) {
+  let { overflow: s, overflowX: c, overflowY: l, display: u } = getComputedStyle(e);
+  return /auto|scroll|overlay|hidden|clip/.test(s + l + c) && !invalidOverflowDisplayValues.has(u);
+}
+var tableElements = /* @__PURE__ */ new Set([
+  "table",
+  "td",
+  "th"
+]);
+function isTableElement(e) {
+  return tableElements.has(getNodeName(e));
+}
+var topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(e) {
+  return topLayerSelectors.some((s) => {
+    try {
+      return e.matches(s);
+    } catch {
+      return false;
+    }
+  });
+}
+var transformProperties = [
+  "transform",
+  "translate",
+  "scale",
+  "rotate",
+  "perspective"
+], willChangeValues = [
+  "transform",
+  "translate",
+  "scale",
+  "rotate",
+  "perspective",
+  "filter"
+], containValues = [
+  "paint",
+  "layout",
+  "strict",
+  "content"
+];
+function isContainingBlock(e) {
+  let s = isWebKit(), c = isElement(e) ? getComputedStyle(e) : e;
+  return transformProperties.some((e2) => c[e2] ? c[e2] !== "none" : false) || (c.containerType ? c.containerType !== "normal" : false) || !s && (c.backdropFilter ? c.backdropFilter !== "none" : false) || !s && (c.filter ? c.filter !== "none" : false) || willChangeValues.some((e2) => (c.willChange || "").includes(e2)) || containValues.some((e2) => (c.contain || "").includes(e2));
+}
+function getContainingBlock(e) {
+  let s = getParentNode(e);
+  for (; isHTMLElement(s) && !isLastTraversableNode(s); ) {
+    if (isContainingBlock(s)) return s;
+    if (isTopLayer(s)) return null;
+    s = getParentNode(s);
+  }
+  return null;
+}
+function isWebKit() {
+  return typeof CSS > "u" || !CSS.supports ? false : CSS.supports("-webkit-backdrop-filter", "none");
+}
+var lastTraversableNodeNames = /* @__PURE__ */ new Set([
+  "html",
+  "body",
+  "#document"
+]);
+function isLastTraversableNode(e) {
+  return lastTraversableNodeNames.has(getNodeName(e));
+}
+function getComputedStyle(e) {
+  return getWindow(e).getComputedStyle(e);
+}
+function getNodeScroll(e) {
+  return isElement(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function getParentNode(e) {
+  if (getNodeName(e) === "html") return e;
+  let s = e.assignedSlot || e.parentNode || isShadowRoot(e) && e.host || getDocumentElement(e);
+  return isShadowRoot(s) ? s.host : s;
+}
+function getNearestOverflowAncestor(e) {
+  let s = getParentNode(e);
+  return isLastTraversableNode(s) ? e.ownerDocument ? e.ownerDocument.body : e.body : isHTMLElement(s) && isOverflowElement(s) ? s : getNearestOverflowAncestor(s);
+}
+function getOverflowAncestors(e, s, c) {
+  var _a;
+  s === void 0 && (s = []), c === void 0 && (c = true);
+  let l = getNearestOverflowAncestor(e), u = l === ((_a = e.ownerDocument) == null ? void 0 : _a.body), d = getWindow(l);
+  if (u) {
+    let e2 = getFrameElement(d);
+    return s.concat(d, d.visualViewport || [], isOverflowElement(l) ? l : [], e2 && c ? getOverflowAncestors(e2) : []);
+  }
+  return s.concat(l, getOverflowAncestors(l, [], c));
+}
+function getFrameElement(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function getCssDimensions(e) {
+  let s = getComputedStyle(e), c = parseFloat(s.width) || 0, l = parseFloat(s.height) || 0, u = isHTMLElement(e), d = u ? e.offsetWidth : c, f = u ? e.offsetHeight : l, p = round(c) !== d || round(l) !== f;
+  return p && (c = d, l = f), {
+    width: c,
+    height: l,
+    $: p
+  };
+}
+function unwrapElement(e) {
+  return isElement(e) ? e : e.contextElement;
+}
+function getScale(e) {
+  let s = unwrapElement(e);
+  if (!isHTMLElement(s)) return createCoords(1);
+  let c = s.getBoundingClientRect(), { width: l, height: u, $: d } = getCssDimensions(s), f = (d ? round(c.width) : c.width) / l, p = (d ? round(c.height) : c.height) / u;
+  return (!f || !Number.isFinite(f)) && (f = 1), (!p || !Number.isFinite(p)) && (p = 1), {
+    x: f,
+    y: p
+  };
+}
+var noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(e) {
+  let s = getWindow(e);
+  return !isWebKit() || !s.visualViewport ? noOffsets : {
+    x: s.visualViewport.offsetLeft,
+    y: s.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(e, s, c) {
+  return s === void 0 && (s = false), !c || s && c !== getWindow(e) ? false : s;
+}
+function getBoundingClientRect(e, s, c, l) {
+  s === void 0 && (s = false), c === void 0 && (c = false);
+  let u = e.getBoundingClientRect(), d = unwrapElement(e), f = createCoords(1);
+  s && (l ? isElement(l) && (f = getScale(l)) : f = getScale(e));
+  let p = shouldAddVisualOffsets(d, c, l) ? getVisualOffsets(d) : createCoords(0), m = (u.left + p.x) / f.x, h = (u.top + p.y) / f.y, g = u.width / f.x, _ = u.height / f.y;
+  if (d) {
+    let e2 = getWindow(d), s2 = l && isElement(l) ? getWindow(l) : l, c2 = e2, u2 = getFrameElement(c2);
+    for (; u2 && l && s2 !== c2; ) {
+      let e3 = getScale(u2), s3 = u2.getBoundingClientRect(), l2 = getComputedStyle(u2), d2 = s3.left + (u2.clientLeft + parseFloat(l2.paddingLeft)) * e3.x, f2 = s3.top + (u2.clientTop + parseFloat(l2.paddingTop)) * e3.y;
+      m *= e3.x, h *= e3.y, g *= e3.x, _ *= e3.y, m += d2, h += f2, c2 = getWindow(u2), u2 = getFrameElement(c2);
+    }
+  }
+  return rectToClientRect({
+    width: g,
+    height: _,
+    x: m,
+    y: h
+  });
+}
+function getWindowScrollBarX(e, s) {
+  let c = getNodeScroll(e).scrollLeft;
+  return s ? s.left + c : getBoundingClientRect(getDocumentElement(e)).left + c;
+}
+function getHTMLOffset(e, s, c) {
+  c === void 0 && (c = false);
+  let l = e.getBoundingClientRect();
+  return {
+    x: l.left + s.scrollLeft - (c ? 0 : getWindowScrollBarX(e, l)),
+    y: l.top + s.scrollTop
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(e) {
+  let { elements: s, rect: c, offsetParent: l, strategy: u } = e, d = u === "fixed", f = getDocumentElement(l), p = s ? isTopLayer(s.floating) : false;
+  if (l === f || p && d) return c;
+  let m = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, h = createCoords(1), g = createCoords(0), _ = isHTMLElement(l);
+  if ((_ || !_ && !d) && ((getNodeName(l) !== "body" || isOverflowElement(f)) && (m = getNodeScroll(l)), isHTMLElement(l))) {
+    let e2 = getBoundingClientRect(l);
+    h = getScale(l), g.x = e2.x + l.clientLeft, g.y = e2.y + l.clientTop;
+  }
+  let v = f && !_ && !d ? getHTMLOffset(f, m, true) : createCoords(0);
+  return {
+    width: c.width * h.x,
+    height: c.height * h.y,
+    x: c.x * h.x - m.scrollLeft * h.x + g.x + v.x,
+    y: c.y * h.y - m.scrollTop * h.y + g.y + v.y
+  };
+}
+function getClientRects(e) {
+  return Array.from(e.getClientRects());
+}
+function getDocumentRect(e) {
+  let s = getDocumentElement(e), c = getNodeScroll(e), l = e.ownerDocument.body, u = max(s.scrollWidth, s.clientWidth, l.scrollWidth, l.clientWidth), d = max(s.scrollHeight, s.clientHeight, l.scrollHeight, l.clientHeight), f = -c.scrollLeft + getWindowScrollBarX(e), p = -c.scrollTop;
+  return getComputedStyle(l).direction === "rtl" && (f += max(s.clientWidth, l.clientWidth) - u), {
+    width: u,
+    height: d,
+    x: f,
+    y: p
+  };
+}
+function getViewportRect(e, s) {
+  let c = getWindow(e), l = getDocumentElement(e), u = c.visualViewport, d = l.clientWidth, f = l.clientHeight, p = 0, m = 0;
+  if (u) {
+    d = u.width, f = u.height;
+    let e2 = isWebKit();
+    (!e2 || e2 && s === "fixed") && (p = u.offsetLeft, m = u.offsetTop);
+  }
+  return {
+    width: d,
+    height: f,
+    x: p,
+    y: m
+  };
+}
+var absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function getInnerBoundingClientRect(e, s) {
+  let c = getBoundingClientRect(e, true, s === "fixed"), l = c.top + e.clientTop, u = c.left + e.clientLeft, d = isHTMLElement(e) ? getScale(e) : createCoords(1);
+  return {
+    width: e.clientWidth * d.x,
+    height: e.clientHeight * d.y,
+    x: u * d.x,
+    y: l * d.y
+  };
+}
+function getClientRectFromClippingAncestor(e, s, c) {
+  let l;
+  if (s === "viewport") l = getViewportRect(e, c);
+  else if (s === "document") l = getDocumentRect(getDocumentElement(e));
+  else if (isElement(s)) l = getInnerBoundingClientRect(s, c);
+  else {
+    let c2 = getVisualOffsets(e);
+    l = {
+      x: s.x - c2.x,
+      y: s.y - c2.y,
+      width: s.width,
+      height: s.height
+    };
+  }
+  return rectToClientRect(l);
+}
+function hasFixedPositionAncestor(e, s) {
+  let c = getParentNode(e);
+  return c === s || !isElement(c) || isLastTraversableNode(c) ? false : getComputedStyle(c).position === "fixed" || hasFixedPositionAncestor(c, s);
+}
+function getClippingElementAncestors(e, s) {
+  let c = s.get(e);
+  if (c) return c;
+  let l = getOverflowAncestors(e, [], false).filter((e2) => isElement(e2) && getNodeName(e2) !== "body"), u = null, d = getComputedStyle(e).position === "fixed", f = d ? getParentNode(e) : e;
+  for (; isElement(f) && !isLastTraversableNode(f); ) {
+    let s2 = getComputedStyle(f), c2 = isContainingBlock(f);
+    !c2 && s2.position === "fixed" && (u = null), (d ? !c2 && !u : !c2 && s2.position === "static" && u && absoluteOrFixed.has(u.position) || isOverflowElement(f) && !c2 && hasFixedPositionAncestor(e, f)) ? l = l.filter((e2) => e2 !== f) : u = s2, f = getParentNode(f);
+  }
+  return s.set(e, l), l;
+}
+function getClippingRect(e) {
+  let { element: s, boundary: c, rootBoundary: l, strategy: u } = e, d = [...c === "clippingAncestors" ? isTopLayer(s) ? [] : getClippingElementAncestors(s, this._c) : [].concat(c), l], f = d[0], p = d.reduce((e2, c2) => {
+    let l2 = getClientRectFromClippingAncestor(s, c2, u);
+    return e2.top = max(l2.top, e2.top), e2.right = min(l2.right, e2.right), e2.bottom = min(l2.bottom, e2.bottom), e2.left = max(l2.left, e2.left), e2;
+  }, getClientRectFromClippingAncestor(s, f, u));
+  return {
+    width: p.right - p.left,
+    height: p.bottom - p.top,
+    x: p.left,
+    y: p.top
+  };
+}
+function getDimensions(e) {
+  let { width: s, height: c } = getCssDimensions(e);
+  return {
+    width: s,
+    height: c
+  };
+}
+function getRectRelativeToOffsetParent(e, s, c) {
+  let l = isHTMLElement(s), u = getDocumentElement(s), d = c === "fixed", f = getBoundingClientRect(e, true, d, s), p = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, m = createCoords(0);
+  function h() {
+    m.x = getWindowScrollBarX(u);
+  }
+  if (l || !l && !d) if ((getNodeName(s) !== "body" || isOverflowElement(u)) && (p = getNodeScroll(s)), l) {
+    let e2 = getBoundingClientRect(s, true, d, s);
+    m.x = e2.x + s.clientLeft, m.y = e2.y + s.clientTop;
+  } else u && h();
+  d && !l && u && h();
+  let g = u && !l && !d ? getHTMLOffset(u, p) : createCoords(0);
+  return {
+    x: f.left + p.scrollLeft - m.x - g.x,
+    y: f.top + p.scrollTop - m.y - g.y,
+    width: f.width,
+    height: f.height
+  };
+}
+function isStaticPositioned(e) {
+  return getComputedStyle(e).position === "static";
+}
+function getTrueOffsetParent(e, s) {
+  if (!isHTMLElement(e) || getComputedStyle(e).position === "fixed") return null;
+  if (s) return s(e);
+  let c = e.offsetParent;
+  return getDocumentElement(e) === c && (c = c.ownerDocument.body), c;
+}
+function getOffsetParent(e, s) {
+  let c = getWindow(e);
+  if (isTopLayer(e)) return c;
+  if (!isHTMLElement(e)) {
+    let s2 = getParentNode(e);
+    for (; s2 && !isLastTraversableNode(s2); ) {
+      if (isElement(s2) && !isStaticPositioned(s2)) return s2;
+      s2 = getParentNode(s2);
+    }
+    return c;
+  }
+  let l = getTrueOffsetParent(e, s);
+  for (; l && isTableElement(l) && isStaticPositioned(l); ) l = getTrueOffsetParent(l, s);
+  return l && isLastTraversableNode(l) && isStaticPositioned(l) && !isContainingBlock(l) ? c : l || getContainingBlock(e) || c;
+}
+var getElementRects = async function(e) {
+  let s = this.getOffsetParent || getOffsetParent, c = this.getDimensions, l = await c(e.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(e.reference, await s(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: l.width,
+      height: l.height
+    }
+  };
+};
+function isRTL(e) {
+  return getComputedStyle(e).direction === "rtl";
+}
+var platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function rectsAreEqual(e, s) {
+  return e.x === s.x && e.y === s.y && e.width === s.width && e.height === s.height;
+}
+function observeMove(e, s) {
+  let c = null, l, u = getDocumentElement(e);
+  function d() {
+    var e2;
+    clearTimeout(l), (e2 = c) == null || e2.disconnect(), c = null;
+  }
+  function f(p, m) {
+    p === void 0 && (p = false), m === void 0 && (m = 1), d();
+    let h = e.getBoundingClientRect(), { left: g, top: _, width: v, height: y } = h;
+    if (p || s(), !v || !y) return;
+    let b = floor(_), x = floor(u.clientWidth - (g + v)), S = floor(u.clientHeight - (_ + y)), C = floor(g), w = {
+      rootMargin: -b + "px " + -x + "px " + -S + "px " + -C + "px",
+      threshold: max(0, min(1, m)) || 1
+    }, D = true;
+    function k(s2) {
+      let c2 = s2[0].intersectionRatio;
+      if (c2 !== m) {
+        if (!D) return f();
+        c2 ? f(false, c2) : l = setTimeout(() => {
+          f(false, 1e-7);
+        }, 1e3);
+      }
+      c2 === 1 && !rectsAreEqual(h, e.getBoundingClientRect()) && f(), D = false;
+    }
+    try {
+      c = new IntersectionObserver(k, {
+        ...w,
+        root: u.ownerDocument
+      });
+    } catch {
+      c = new IntersectionObserver(k, w);
+    }
+    c.observe(e);
+  }
+  return f(true), d;
+}
+function autoUpdate(e, s, c, l) {
+  l === void 0 && (l = {});
+  let { ancestorScroll: u = true, ancestorResize: d = true, elementResize: f = typeof ResizeObserver == "function", layoutShift: p = typeof IntersectionObserver == "function", animationFrame: m = false } = l, h = unwrapElement(e), g = u || d ? [...h ? getOverflowAncestors(h) : [], ...getOverflowAncestors(s)] : [];
+  g.forEach((e2) => {
+    u && e2.addEventListener("scroll", c, { passive: true }), d && e2.addEventListener("resize", c);
+  });
+  let _ = h && p ? observeMove(h, c) : null, v = -1, y = null;
+  f && (y = new ResizeObserver((e2) => {
+    let [l2] = e2;
+    l2 && l2.target === h && y && (y.unobserve(s), cancelAnimationFrame(v), v = requestAnimationFrame(() => {
+      var e3;
+      (e3 = y) == null || e3.observe(s);
+    })), c();
+  }), h && !m && y.observe(h), y.observe(s));
+  let b, x = m ? getBoundingClientRect(e) : null;
+  m && S();
+  function S() {
+    let s2 = getBoundingClientRect(e);
+    x && !rectsAreEqual(x, s2) && c(), x = s2, b = requestAnimationFrame(S);
+  }
+  return c(), () => {
+    var e2;
+    g.forEach((e3) => {
+      u && e3.removeEventListener("scroll", c), d && e3.removeEventListener("resize", c);
+    }), _ == null ? void 0 : _(), (e2 = y) == null || e2.disconnect(), y = null, m && cancelAnimationFrame(b);
+  };
+}
+var offset$1 = offset$2, shift$1 = shift$2, flip$1 = flip$2, size$1 = size$2, hide$1 = hide$2, arrow$1 = arrow$2, limitShift$1 = limitShift$2, computePosition = (e, s, c) => {
+  let l = /* @__PURE__ */ new Map(), u = {
+    platform,
+    ...c
+  }, d = {
+    ...u.platform,
+    _c: l
+  };
+  return computePosition$1(e, s, {
+    ...u,
+    platform: d
+  });
+}, import_react_dom = /* @__PURE__ */ __toESM(require_react_dom(), 1), index = typeof document < "u" ? import_react.useLayoutEffect : function() {
+};
+function deepEqual(e, s) {
+  if (e === s) return true;
+  if (typeof e != typeof s) return false;
+  if (typeof e == "function" && e.toString() === s.toString()) return true;
+  let c, l, u;
+  if (e && s && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (c = e.length, c !== s.length) return false;
+      for (l = c; l-- !== 0; ) if (!deepEqual(e[l], s[l])) return false;
+      return true;
+    }
+    if (u = Object.keys(e), c = u.length, c !== Object.keys(s).length) return false;
+    for (l = c; l-- !== 0; ) if (!{}.hasOwnProperty.call(s, u[l])) return false;
+    for (l = c; l-- !== 0; ) {
+      let c2 = u[l];
+      if (!(c2 === "_owner" && e.$$typeof) && !deepEqual(e[c2], s[c2])) return false;
+    }
+    return true;
+  }
+  return e !== e && s !== s;
+}
+function getDPR(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(e, s) {
+  let c = getDPR(e);
+  return Math.round(s * c) / c;
+}
+function useLatestRef(e) {
+  let s = import_react.useRef(e);
+  return index(() => {
+    s.current = e;
+  }), s;
+}
+function useFloating(e) {
+  e === void 0 && (e = {});
+  let { placement: s = "bottom", strategy: c = "absolute", middleware: l = [], platform: u, elements: { reference: d, floating: f } = {}, transform: p = true, whileElementsMounted: m, open: h } = e, [g, _] = import_react.useState({
+    x: 0,
+    y: 0,
+    strategy: c,
+    placement: s,
+    middlewareData: {},
+    isPositioned: false
+  }), [v, y] = import_react.useState(l);
+  deepEqual(v, l) || y(l);
+  let [b, S] = import_react.useState(null), [C, w] = import_react.useState(null), T = import_react.useCallback((e2) => {
+    e2 !== k.current && (k.current = e2, S(e2));
+  }, []), E = import_react.useCallback((e2) => {
+    e2 !== A.current && (A.current = e2, w(e2));
+  }, []), D = d || b, O = f || C, k = import_react.useRef(null), A = import_react.useRef(null), j = import_react.useRef(g), M = m != null, N = useLatestRef(m), P = useLatestRef(u), F = useLatestRef(h), I = import_react.useCallback(() => {
+    if (!k.current || !A.current) return;
+    let e2 = {
+      placement: s,
+      strategy: c,
+      middleware: v
+    };
+    P.current && (e2.platform = P.current), computePosition(k.current, A.current, e2).then((e3) => {
+      let s2 = {
+        ...e3,
+        isPositioned: F.current !== false
+      };
+      L.current && !deepEqual(j.current, s2) && (j.current = s2, import_react_dom.flushSync(() => {
+        _(s2);
+      }));
+    });
+  }, [
+    v,
+    s,
+    c,
+    P,
+    F
+  ]);
+  index(() => {
+    h === false && j.current.isPositioned && (j.current.isPositioned = false, _((e2) => ({
+      ...e2,
+      isPositioned: false
+    })));
+  }, [h]);
+  let L = import_react.useRef(false);
+  index(() => (L.current = true, () => {
+    L.current = false;
+  }), []), index(() => {
+    if (D && (k.current = D), O && (A.current = O), D && O) {
+      if (N.current) return N.current(D, O, I);
+      I();
+    }
+  }, [
+    D,
+    O,
+    I,
+    N,
+    M
+  ]);
+  let R = import_react.useMemo(() => ({
+    reference: k,
+    floating: A,
+    setReference: T,
+    setFloating: E
+  }), [T, E]), z = import_react.useMemo(() => ({
+    reference: D,
+    floating: O
+  }), [D, O]), B = import_react.useMemo(() => {
+    let e2 = {
+      position: c,
+      left: 0,
+      top: 0
+    };
+    if (!z.floating) return e2;
+    let s2 = roundByDPR(z.floating, g.x), l2 = roundByDPR(z.floating, g.y);
+    return p ? {
+      ...e2,
+      transform: "translate(" + s2 + "px, " + l2 + "px)",
+      ...getDPR(z.floating) >= 1.5 && { willChange: "transform" }
+    } : {
+      position: c,
+      left: s2,
+      top: l2
+    };
+  }, [
+    c,
+    p,
+    z.floating,
+    g.x,
+    g.y
+  ]);
+  return import_react.useMemo(() => ({
+    ...g,
+    update: I,
+    refs: R,
+    elements: z,
+    floatingStyles: B
+  }), [
+    g,
+    I,
+    R,
+    z,
+    B
+  ]);
+}
+var arrow$1$1 = (e) => {
+  function s(e2) {
+    return {}.hasOwnProperty.call(e2, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(c) {
+      let { element: l, padding: u } = typeof e == "function" ? e(c) : e;
+      return l && s(l) ? l.current == null ? {} : arrow$1({
+        element: l.current,
+        padding: u
+      }).fn(c) : l ? arrow$1({
+        element: l,
+        padding: u
+      }).fn(c) : {};
+    }
+  };
+}, offset = (e, s) => ({
+  ...offset$1(e),
+  options: [e, s]
+}), shift = (e, s) => ({
+  ...shift$1(e),
+  options: [e, s]
+}), limitShift = (e, s) => ({
+  ...limitShift$1(e),
+  options: [e, s]
+}), flip = (e, s) => ({
+  ...flip$1(e),
+  options: [e, s]
+}), size = (e, s) => ({
+  ...size$1(e),
+  options: [e, s]
+}), hide = (e, s) => ({
+  ...hide$1(e),
+  options: [e, s]
+}), arrow = (e, s) => ({
+  ...arrow$1$1(e),
+  options: [e, s]
+}), import_jsx_runtime = /* @__PURE__ */ __toESM(require_jsx_runtime(), 1), NAME$1 = "Arrow", Arrow$1 = import_react.forwardRef((e, s) => {
+  let { children: c, width: l = 10, height: u = 5, ...f } = e;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.svg, {
+    ...f,
+    ref: s,
+    width: l,
+    height: u,
+    viewBox: "0 0 30 10",
+    preserveAspectRatio: "none",
+    children: e.asChild ? c : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("polygon", { points: "0,0 30,0 15,10" })
+  });
+});
+Arrow$1.displayName = NAME$1;
+var Root$1 = Arrow$1;
+function useSize(e) {
+  let [s, c] = import_react.useState(void 0);
+  return useLayoutEffect2(() => {
+    if (e) {
+      c({
+        width: e.offsetWidth,
+        height: e.offsetHeight
+      });
+      let s2 = new ResizeObserver((s3) => {
+        if (!Array.isArray(s3) || !s3.length) return;
+        let l = s3[0], u, d;
+        if ("borderBoxSize" in l) {
+          let e2 = l.borderBoxSize, s4 = Array.isArray(e2) ? e2[0] : e2;
+          u = s4.inlineSize, d = s4.blockSize;
+        } else u = e.offsetWidth, d = e.offsetHeight;
+        c({
+          width: u,
+          height: d
+        });
+      });
+      return s2.observe(e, { box: "border-box" }), () => s2.unobserve(e);
+    } else c(void 0);
+  }, [e]), s;
+}
+var POPPER_NAME = "Popper", [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME), [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME), Popper = (e) => {
+  let { __scopePopper: s, children: c } = e, [l, u] = import_react.useState(null);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopperProvider, {
+    scope: s,
+    anchor: l,
+    onAnchorChange: u,
+    children: c
+  });
+};
+Popper.displayName = POPPER_NAME;
+var ANCHOR_NAME = "PopperAnchor", PopperAnchor = import_react.forwardRef((e, s) => {
+  let { __scopePopper: l, virtualRef: u, ...f } = e, p = usePopperContext(ANCHOR_NAME, l), m = import_react.useRef(null), h = useComposedRefs(s, m), g = import_react.useRef(null);
+  return import_react.useEffect(() => {
+    let e2 = g.current;
+    g.current = (u == null ? void 0 : u.current) || m.current, e2 !== g.current && p.onAnchorChange(g.current);
+  }), u ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+    ...f,
+    ref: h
+  });
+});
+PopperAnchor.displayName = ANCHOR_NAME;
+var CONTENT_NAME = "PopperContent", [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME), PopperContent = import_react.forwardRef((e, s) => {
+  var _a, _b, _c, _d, _e, _f;
+  let { __scopePopper: l, side: p = "bottom", sideOffset: m = 0, align: h = "center", alignOffset: g = 0, arrowPadding: _ = 0, avoidCollisions: v = true, collisionBoundary: y = [], collisionPadding: b = 0, sticky: S = "partial", hideWhenDetached: C = false, updatePositionStrategy: w = "optimized", onPlaced: T, ...E } = e, D = usePopperContext(CONTENT_NAME, l), [O, k] = import_react.useState(null), A = useComposedRefs(s, (e2) => k(e2)), [j, M] = import_react.useState(null), N = useSize(j), P = (N == null ? void 0 : N.width) ?? 0, F = (N == null ? void 0 : N.height) ?? 0, I = p + (h === "center" ? "" : "-" + h), L = typeof b == "number" ? b : {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...b
+  }, R = Array.isArray(y) ? y : [y], z = R.length > 0, B = {
+    padding: L,
+    boundary: R.filter(isNotNull),
+    altBoundary: z
+  }, { refs: V, floatingStyles: H, placement: U, isPositioned: W, middlewareData: G } = useFloating({
+    strategy: "fixed",
+    placement: I,
+    whileElementsMounted: (...e2) => autoUpdate(...e2, { animationFrame: w === "always" }),
+    elements: { reference: D.anchor },
+    middleware: [
+      offset({
+        mainAxis: m + F,
+        alignmentAxis: g
+      }),
+      v && shift({
+        mainAxis: true,
+        crossAxis: false,
+        limiter: S === "partial" ? limitShift() : void 0,
+        ...B
+      }),
+      v && flip({ ...B }),
+      size({
+        ...B,
+        apply: ({ elements: e2, rects: s2, availableWidth: c, availableHeight: l2 }) => {
+          let { width: u, height: d } = s2.reference, f = e2.floating.style;
+          f.setProperty("--radix-popper-available-width", `${c}px`), f.setProperty("--radix-popper-available-height", `${l2}px`), f.setProperty("--radix-popper-anchor-width", `${u}px`), f.setProperty("--radix-popper-anchor-height", `${d}px`);
+        }
+      }),
+      j && arrow({
+        element: j,
+        padding: _
+      }),
+      transformOrigin({
+        arrowWidth: P,
+        arrowHeight: F
+      }),
+      C && hide({
+        strategy: "referenceHidden",
+        ...B
+      })
+    ]
+  }), [K, q] = getSideAndAlignFromPlacement(U), J = useCallbackRef(T);
+  useLayoutEffect2(() => {
+    W && (J == null ? void 0 : J());
+  }, [W, J]);
+  let Y = (_a = G.arrow) == null ? void 0 : _a.x, X = (_b = G.arrow) == null ? void 0 : _b.y, Z = ((_c = G.arrow) == null ? void 0 : _c.centerOffset) !== 0, [Q, $] = import_react.useState();
+  return useLayoutEffect2(() => {
+    O && $(window.getComputedStyle(O).zIndex);
+  }, [O]), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+    ref: V.setFloating,
+    "data-radix-popper-content-wrapper": "",
+    style: {
+      ...H,
+      transform: W ? H.transform : "translate(0, -200%)",
+      minWidth: "max-content",
+      zIndex: Q,
+      "--radix-popper-transform-origin": [(_d = G.transformOrigin) == null ? void 0 : _d.x, (_e = G.transformOrigin) == null ? void 0 : _e.y].join(" "),
+      ...((_f = G.hide) == null ? void 0 : _f.referenceHidden) && {
+        visibility: "hidden",
+        pointerEvents: "none"
+      }
+    },
+    dir: e.dir,
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopperContentProvider, {
+      scope: l,
+      placedSide: K,
+      onArrowChange: M,
+      arrowX: Y,
+      arrowY: X,
+      shouldHideArrow: Z,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+        "data-side": K,
+        "data-align": q,
+        ...E,
+        ref: A,
+        style: {
+          ...E.style,
+          animation: W ? void 0 : "none"
+        }
+      })
+    })
+  });
+});
+PopperContent.displayName = CONTENT_NAME;
+var ARROW_NAME = "PopperArrow", OPPOSITE_SIDE = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, PopperArrow = import_react.forwardRef(function(e, s) {
+  let { __scopePopper: c, ...l } = e, u = useContentContext(ARROW_NAME, c), d = OPPOSITE_SIDE[u.placedSide];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+    ref: u.onArrowChange,
+    style: {
+      position: "absolute",
+      left: u.arrowX,
+      top: u.arrowY,
+      [d]: 0,
+      transformOrigin: {
+        top: "",
+        right: "0 0",
+        bottom: "center 0",
+        left: "100% 0"
+      }[u.placedSide],
+      transform: {
+        top: "translateY(100%)",
+        right: "translateY(50%) rotate(90deg) translateX(-50%)",
+        bottom: "rotate(180deg)",
+        left: "translateY(50%) rotate(-90deg) translateX(50%)"
+      }[u.placedSide],
+      visibility: u.shouldHideArrow ? "hidden" : void 0
+    },
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Root$1, {
+      ...l,
+      ref: s,
+      style: {
+        ...l.style,
+        display: "block"
+      }
+    })
+  });
+});
+PopperArrow.displayName = ARROW_NAME;
+function isNotNull(e) {
+  return e !== null;
+}
+var transformOrigin = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(s) {
+    var _a, _b, _c;
+    let { placement: c, rects: l, middlewareData: u } = s, d = ((_a = u.arrow) == null ? void 0 : _a.centerOffset) !== 0, f = d ? 0 : e.arrowWidth, p = d ? 0 : e.arrowHeight, [m, h] = getSideAndAlignFromPlacement(c), g = {
+      start: "0%",
+      center: "50%",
+      end: "100%"
+    }[h], _ = (((_b = u.arrow) == null ? void 0 : _b.x) ?? 0) + f / 2, v = (((_c = u.arrow) == null ? void 0 : _c.y) ?? 0) + p / 2, y = "", b = "";
+    return m === "bottom" ? (y = d ? g : `${_}px`, b = `${-p}px`) : m === "top" ? (y = d ? g : `${_}px`, b = `${l.floating.height + p}px`) : m === "right" ? (y = `${-p}px`, b = d ? g : `${v}px`) : m === "left" && (y = `${l.floating.width + p}px`, b = d ? g : `${v}px`), { data: {
+      x: y,
+      y: b
+    } };
+  }
+});
+function getSideAndAlignFromPlacement(e) {
+  let [s, c = "center"] = e.split("-");
+  return [s, c];
+}
+var Root2 = Popper, Anchor = PopperAnchor, Content = PopperContent, Arrow = PopperArrow, VISUALLY_HIDDEN_STYLES = Object.freeze({
+  position: "absolute",
+  border: 0,
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  wordWrap: "normal"
+}), NAME = "VisuallyHidden", VisuallyHidden = import_react.forwardRef((e, s) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.span, {
+  ...e,
+  ref: s,
+  style: {
+    ...VISUALLY_HIDDEN_STYLES,
+    ...e.style
+  }
+}));
+VisuallyHidden.displayName = NAME;
+var Root = VisuallyHidden;
+export {
+  Content as a,
+  useSize as c,
+  Arrow as i,
+  createLucideIcon as l,
+  VISUALLY_HIDDEN_STYLES as n,
+  Root2 as o,
+  Anchor as r,
+  createPopperScope as s,
+  Root as t
+};