@marimo-team/islands 0.18.0 → 0.18.1

package/dist/Combination-DN9sfYvo.js

@@ -0,0 +1,2569 @@
+import { s as __toESM } from "./chunk-DgPTj83v.js";
+import { t as require_react } from "./react-DXQlph6m.js";
+import { t as require_compiler_runtime } from "./compiler-runtime-DTozApu4.js";
+import { c as useComposedRefs, o as useEventListener, s as composeRefs } from "./button-Css_i-3R.js";
+import { t as require_jsx_runtime } from "./jsx-runtime-Duz3IlLt.js";
+import { t as require_react_dom } from "./react-dom-DBPBYhx0.js";
+typeof window < "u" && window.document && window.document.createElement;
+function composeEventHandlers(r, s, { checkForDefaultPrevented: c = true } = {}) {
+  return function(l) {
+    if (r == null ? void 0 : r(l), c === false || !l.defaultPrevented) return s == null ? void 0 : s(l);
+  };
+}
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1), import_jsx_runtime = /* @__PURE__ */ __toESM(require_jsx_runtime(), 1);
+function createContext2(r, s) {
+  let c = import_react.createContext(s), l = (r2) => {
+    let { children: s2, ...l2 } = r2, u2 = import_react.useMemo(() => l2, Object.values(l2));
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(c.Provider, {
+      value: u2,
+      children: s2
+    });
+  };
+  l.displayName = r + "Provider";
+  function u(l2) {
+    let u2 = import_react.useContext(c);
+    if (u2) return u2;
+    if (s !== void 0) return s;
+    throw Error(`\`${l2}\` must be used within \`${r}\``);
+  }
+  return [l, u];
+}
+function createContextScope(r, s = []) {
+  let c = [];
+  function l(s2, l2) {
+    let u2 = import_react.createContext(l2), d = c.length;
+    c = [...c, l2];
+    let f = (s3) => {
+      var _a;
+      let { scope: c2, children: l3, ...f2 } = s3, p2 = ((_a = c2 == null ? void 0 : c2[r]) == null ? void 0 : _a[d]) || u2, m = import_react.useMemo(() => f2, Object.values(f2));
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(p2.Provider, {
+        value: m,
+        children: l3
+      });
+    };
+    f.displayName = s2 + "Provider";
+    function p(c2, f2) {
+      var _a;
+      let p2 = ((_a = f2 == null ? void 0 : f2[r]) == null ? void 0 : _a[d]) || u2, m = import_react.useContext(p2);
+      if (m) return m;
+      if (l2 !== void 0) return l2;
+      throw Error(`\`${c2}\` must be used within \`${s2}\``);
+    }
+    return [f, p];
+  }
+  let u = () => {
+    let s2 = c.map((r2) => import_react.createContext(r2));
+    return function(c2) {
+      let l2 = (c2 == null ? void 0 : c2[r]) || s2;
+      return import_react.useMemo(() => ({ [`__scope${r}`]: {
+        ...c2,
+        [r]: l2
+      } }), [c2, l2]);
+    };
+  };
+  return u.scopeName = r, [l, composeContextScopes(u, ...s)];
+}
+function composeContextScopes(...r) {
+  let s = r[0];
+  if (r.length === 1) return s;
+  let c = () => {
+    let c2 = r.map((r2) => ({
+      useScope: r2(),
+      scopeName: r2.scopeName
+    }));
+    return function(r2) {
+      let l = c2.reduce((s2, { useScope: c3, scopeName: l2 }) => {
+        let u = c3(r2)[`__scope${l2}`];
+        return {
+          ...s2,
+          ...u
+        };
+      }, {});
+      return import_react.useMemo(() => ({ [`__scope${s.scopeName}`]: l }), [l]);
+    };
+  };
+  return c.scopeName = s.scopeName, c;
+}
+// @__NO_SIDE_EFFECTS__
+function createSlot(r) {
+  let s = /* @__PURE__ */ createSlotClone(r), c = import_react.forwardRef((r2, c2) => {
+    let { children: l, ...u } = r2, d = import_react.Children.toArray(l), f = d.find(isSlottable);
+    if (f) {
+      let r3 = f.props.children, l2 = d.map((s2) => s2 === f ? import_react.Children.count(r3) > 1 ? import_react.Children.only(null) : import_react.isValidElement(r3) ? r3.props.children : null : s2);
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(s, {
+        ...u,
+        ref: c2,
+        children: import_react.isValidElement(r3) ? import_react.cloneElement(r3, void 0, l2) : null
+      });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(s, {
+      ...u,
+      ref: c2,
+      children: l
+    });
+  });
+  return c.displayName = `${r}.Slot`, c;
+}
+// @__NO_SIDE_EFFECTS__
+function createSlotClone(r) {
+  let s = import_react.forwardRef((r2, s2) => {
+    let { children: c, ...l } = r2;
+    if (import_react.isValidElement(c)) {
+      let r3 = getElementRef$1(c), u = mergeProps(l, c.props);
+      return c.type !== import_react.Fragment && (u.ref = s2 ? composeRefs(s2, r3) : r3), import_react.cloneElement(c, u);
+    }
+    return import_react.Children.count(c) > 1 ? import_react.Children.only(null) : null;
+  });
+  return s.displayName = `${r}.SlotClone`, s;
+}
+var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
+// @__NO_SIDE_EFFECTS__
+function createSlottable(r) {
+  let s = ({ children: r2 }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: r2 });
+  return s.displayName = `${r}.Slottable`, s.__radixId = SLOTTABLE_IDENTIFIER, s;
+}
+function isSlottable(r) {
+  return import_react.isValidElement(r) && typeof r.type == "function" && "__radixId" in r.type && r.type.__radixId === SLOTTABLE_IDENTIFIER;
+}
+function mergeProps(r, s) {
+  let c = { ...s };
+  for (let l in s) {
+    let u = r[l], d = s[l];
+    /^on[A-Z]/.test(l) ? u && d ? c[l] = (...r2) => {
+      let s2 = d(...r2);
+      return u(...r2), s2;
+    } : u && (c[l] = u) : l === "style" ? c[l] = {
+      ...u,
+      ...d
+    } : l === "className" && (c[l] = [u, d].filter(Boolean).join(" "));
+  }
+  return {
+    ...r,
+    ...c
+  };
+}
+function getElementRef$1(r) {
+  var _a, _b;
+  let s = (_a = Object.getOwnPropertyDescriptor(r.props, "ref")) == null ? void 0 : _a.get, c = s && "isReactWarning" in s && s.isReactWarning;
+  return c ? r.ref : (s = (_b = Object.getOwnPropertyDescriptor(r, "ref")) == null ? void 0 : _b.get, c = s && "isReactWarning" in s && s.isReactWarning, c ? r.props.ref : r.props.ref || r.ref);
+}
+var import_react_dom$2 = /* @__PURE__ */ __toESM(require_react_dom(), 1), Primitive = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+].reduce((r, s) => {
+  let c = /* @__PURE__ */ createSlot(`Primitive.${s}`), l = import_react.forwardRef((r2, l2) => {
+    let { asChild: u, ...d } = r2, f = u ? c : s;
+    return typeof window < "u" && (window[Symbol.for("radix-ui")] = true), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(f, {
+      ...d,
+      ref: l2
+    });
+  });
+  return l.displayName = `Primitive.${s}`, {
+    ...r,
+    [s]: l
+  };
+}, {});
+function dispatchDiscreteCustomEvent(r, s) {
+  r && import_react_dom$2.flushSync(() => r.dispatchEvent(s));
+}
+function useCallbackRef$1(r) {
+  let s = import_react.useRef(r);
+  return import_react.useEffect(() => {
+    s.current = r;
+  }), import_react.useMemo(() => (...r2) => {
+    var _a;
+    return (_a = s.current) == null ? void 0 : _a.call(s, ...r2);
+  }, []);
+}
+function useEscapeKeydown(r, s = globalThis == null ? void 0 : globalThis.document) {
+  let c = useCallbackRef$1(r);
+  import_react.useEffect(() => {
+    let r2 = (r3) => {
+      r3.key === "Escape" && c(r3);
+    };
+    return s.addEventListener("keydown", r2, { capture: true }), () => s.removeEventListener("keydown", r2, { capture: true });
+  }, [c, s]);
+}
+var DISMISSABLE_LAYER_NAME = "DismissableLayer", CONTEXT_UPDATE = "dismissableLayer.update", POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside", FOCUS_OUTSIDE = "dismissableLayer.focusOutside", originalBodyPointerEvents, DismissableLayerContext = import_react.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), DismissableLayer = import_react.forwardRef((r, s) => {
+  let { disableOutsidePointerEvents: c = false, onEscapeKeyDown: u, onPointerDownOutside: d, onFocusOutside: f, onInteractOutside: p, onDismiss: _, ...v } = r, y = import_react.useContext(DismissableLayerContext), [b, x] = import_react.useState(null), S = (b == null ? void 0 : b.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document), [, C] = import_react.useState({}), w = useComposedRefs(s, (r2) => x(r2)), T = Array.from(y.layers), [E] = [...y.layersWithOutsidePointerEventsDisabled].slice(-1), D = T.indexOf(E), k = b ? T.indexOf(b) : -1, A = y.layersWithOutsidePointerEventsDisabled.size > 0, M = k >= D, P = usePointerDownOutside((r2) => {
+    let s2 = r2.target, c2 = [...y.branches].some((r3) => r3.contains(s2));
+    !M || c2 || (d == null ? void 0 : d(r2), p == null ? void 0 : p(r2), r2.defaultPrevented || (_ == null ? void 0 : _()));
+  }, S), F = useFocusOutside((r2) => {
+    let s2 = r2.target;
+    [...y.branches].some((r3) => r3.contains(s2)) || (f == null ? void 0 : f(r2), p == null ? void 0 : p(r2), r2.defaultPrevented || (_ == null ? void 0 : _()));
+  }, S);
+  return useEscapeKeydown((r2) => {
+    k === y.layers.size - 1 && (u == null ? void 0 : u(r2), !r2.defaultPrevented && _ && (r2.preventDefault(), _()));
+  }, S), import_react.useEffect(() => {
+    if (b) return c && (y.layersWithOutsidePointerEventsDisabled.size === 0 && (originalBodyPointerEvents = S.body.style.pointerEvents, S.body.style.pointerEvents = "none"), y.layersWithOutsidePointerEventsDisabled.add(b)), y.layers.add(b), dispatchUpdate(), () => {
+      c && y.layersWithOutsidePointerEventsDisabled.size === 1 && (S.body.style.pointerEvents = originalBodyPointerEvents);
+    };
+  }, [
+    b,
+    S,
+    c,
+    y
+  ]), import_react.useEffect(() => () => {
+    b && (y.layers.delete(b), y.layersWithOutsidePointerEventsDisabled.delete(b), dispatchUpdate());
+  }, [b, y]), import_react.useEffect(() => {
+    let r2 = () => C({});
+    return document.addEventListener(CONTEXT_UPDATE, r2), () => document.removeEventListener(CONTEXT_UPDATE, r2);
+  }, []), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+    ...v,
+    ref: w,
+    style: {
+      pointerEvents: A ? M ? "auto" : "none" : void 0,
+      ...r.style
+    },
+    onFocusCapture: composeEventHandlers(r.onFocusCapture, F.onFocusCapture),
+    onBlurCapture: composeEventHandlers(r.onBlurCapture, F.onBlurCapture),
+    onPointerDownCapture: composeEventHandlers(r.onPointerDownCapture, P.onPointerDownCapture)
+  });
+});
+DismissableLayer.displayName = DISMISSABLE_LAYER_NAME;
+var BRANCH_NAME = "DismissableLayerBranch", DismissableLayerBranch = import_react.forwardRef((r, s) => {
+  let c = import_react.useContext(DismissableLayerContext), u = import_react.useRef(null), d = useComposedRefs(s, u);
+  return import_react.useEffect(() => {
+    let r2 = u.current;
+    if (r2) return c.branches.add(r2), () => {
+      c.branches.delete(r2);
+    };
+  }, [c.branches]), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+    ...r,
+    ref: d
+  });
+});
+DismissableLayerBranch.displayName = BRANCH_NAME;
+function usePointerDownOutside(r, s = globalThis == null ? void 0 : globalThis.document) {
+  let c = useCallbackRef$1(r), l = import_react.useRef(false), u = import_react.useRef(() => {
+  });
+  return import_react.useEffect(() => {
+    let r2 = (r3) => {
+      if (r3.target && !l.current) {
+        let l2 = function() {
+          handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, c, d2, { discrete: true });
+        }, d2 = { originalEvent: r3 };
+        r3.pointerType === "touch" ? (s.removeEventListener("click", u.current), u.current = l2, s.addEventListener("click", u.current, { once: true })) : l2();
+      } else s.removeEventListener("click", u.current);
+      l.current = false;
+    }, d = window.setTimeout(() => {
+      s.addEventListener("pointerdown", r2);
+    }, 0);
+    return () => {
+      window.clearTimeout(d), s.removeEventListener("pointerdown", r2), s.removeEventListener("click", u.current);
+    };
+  }, [s, c]), { onPointerDownCapture: () => l.current = true };
+}
+function useFocusOutside(r, s = globalThis == null ? void 0 : globalThis.document) {
+  let c = useCallbackRef$1(r), l = import_react.useRef(false);
+  return import_react.useEffect(() => {
+    let r2 = (r3) => {
+      r3.target && !l.current && handleAndDispatchCustomEvent(FOCUS_OUTSIDE, c, { originalEvent: r3 }, { discrete: false });
+    };
+    return s.addEventListener("focusin", r2), () => s.removeEventListener("focusin", r2);
+  }, [s, c]), {
+    onFocusCapture: () => l.current = true,
+    onBlurCapture: () => l.current = false
+  };
+}
+function dispatchUpdate() {
+  let r = new CustomEvent(CONTEXT_UPDATE);
+  document.dispatchEvent(r);
+}
+function handleAndDispatchCustomEvent(r, s, c, { discrete: l }) {
+  let u = c.originalEvent.target, d = new CustomEvent(r, {
+    bubbles: false,
+    cancelable: true,
+    detail: c
+  });
+  s && u.addEventListener(r, s, { once: true }), l ? dispatchDiscreteCustomEvent(u, d) : u.dispatchEvent(d);
+}
+var useLayoutEffect2 = (globalThis == null ? void 0 : globalThis.document) ? import_react.useLayoutEffect : () => {
+}, useReactId = import_react.useId || (() => void 0), count$1 = 0;
+function useId(r) {
+  let [s, c] = import_react.useState(useReactId());
+  return useLayoutEffect2(() => {
+    r || c((r2) => r2 ?? String(count$1++));
+  }, [r]), r || (s ? `radix-${s}` : "");
+}
+var sides = [
+  "top",
+  "right",
+  "bottom",
+  "left"
+], min = Math.min, max = Math.max, round = Math.round, floor = Math.floor, createCoords = (r) => ({
+  x: r,
+  y: r
+}), oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function clamp(r, s, c) {
+  return max(r, min(s, c));
+}
+function evaluate(r, s) {
+  return typeof r == "function" ? r(s) : r;
+}
+function getSide(r) {
+  return r.split("-")[0];
+}
+function getAlignment(r) {
+  return r.split("-")[1];
+}
+function getOppositeAxis(r) {
+  return r === "x" ? "y" : "x";
+}
+function getAxisLength(r) {
+  return r === "y" ? "height" : "width";
+}
+var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(r) {
+  return yAxisSides.has(getSide(r)) ? "y" : "x";
+}
+function getAlignmentAxis(r) {
+  return getOppositeAxis(getSideAxis(r));
+}
+function getAlignmentSides(r, s, c) {
+  c === void 0 && (c = false);
+  let l = getAlignment(r), u = getAlignmentAxis(r), 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(r) {
+  let s = getOppositePlacement(r);
+  return [
+    getOppositeAlignmentPlacement(r),
+    s,
+    getOppositeAlignmentPlacement(s)
+  ];
+}
+function getOppositeAlignmentPlacement(r) {
+  return r.replace(/start|end/g, (r2) => oppositeAlignmentMap[r2]);
+}
+var lrPlacement = ["left", "right"], rlPlacement = ["right", "left"], tbPlacement = ["top", "bottom"], btPlacement = ["bottom", "top"];
+function getSideList(r, s, c) {
+  switch (r) {
+    case "top":
+    case "bottom":
+      return c ? s ? rlPlacement : lrPlacement : s ? lrPlacement : rlPlacement;
+    case "left":
+    case "right":
+      return s ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(r, s, c, l) {
+  let u = getAlignment(r), d = getSideList(getSide(r), c === "start", l);
+  return u && (d = d.map((r2) => r2 + "-" + u), s && (d = d.concat(d.map(getOppositeAlignmentPlacement)))), d;
+}
+function getOppositePlacement(r) {
+  return r.replace(/left|right|bottom|top/g, (r2) => oppositeSideMap[r2]);
+}
+function expandPaddingObject(r) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...r
+  };
+}
+function getPaddingObject(r) {
+  return typeof r == "number" ? {
+    top: r,
+    right: r,
+    bottom: r,
+    left: r
+  } : expandPaddingObject(r);
+}
+function rectToClientRect(r) {
+  let { x: s, y: c, width: l, height: u } = r;
+  return {
+    width: l,
+    height: u,
+    top: c,
+    left: s,
+    right: s + l,
+    bottom: c + u,
+    x: s,
+    y: c
+  };
+}
+function computeCoordsFromPlacement(r, s, c) {
+  let { reference: l, floating: u } = r, 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 (r, 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: r,
+    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: r,
+        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: r,
+      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(r, s) {
+  s === void 0 && (s = {});
+  let { x: c, y: l, platform: u, rects: d, elements: f, strategy: p } = r, { boundary: m = "clippingAncestors", rootBoundary: h = "viewport", elementContext: g = "floating", altBoundary: _ = false, padding: v = 0 } = evaluate(s, r), 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 = (r) => ({
+  name: "arrow",
+  options: r,
+  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(r, 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", T = S ? "clientHeight" : "clientWidth", E = d.reference[b] + d.reference[y] - v[y] - d.floating[b], D = v[y] - d.reference[y], O = await (f.getOffsetParent == null ? void 0 : f.getOffsetParent(h)), k = O ? O[T] : 0;
+    (!k || !await (f.isElement == null ? void 0 : f.isElement(O))) && (k = p.floating[T] || d.floating[b]);
+    let A = E / 2 - D / 2, j = k / 2 - x[b] / 2 - 1, M = min(_[C], j), N = min(_[w], j), P = M, F = k - x[b] - N, I = k / 2 - x[b] / 2 + A, L = clamp(P, I, F), R = !m.arrow && getAlignment(u) != null && I !== L && d.reference[b] / 2 - (I < P ? M : N) - x[b] / 2 < 0, z = R ? I < P ? I - P : I - F : 0;
+    return {
+      [y]: v[y] + z,
+      data: {
+        [y]: L,
+        centerOffset: I - L - z,
+        ...R && { alignmentOffset: z }
+      },
+      reset: R
+    };
+  }
+}), flip$2 = function(r) {
+  return r === void 0 && (r = {}), {
+    name: "flip",
+    options: r,
+    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(r, 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 r2 = getAlignmentSides(l, d, T);
+        A.push(k[r2[0]], k[r2[1]]);
+      }
+      if (j = [...j, {
+        placement: l,
+        overflows: A
+      }], !A.every((r2) => r2 <= 0)) {
+        let r2 = (((_b = u.flip) == null ? void 0 : _b.index) || 0) + 1, s2 = O[r2];
+        if (s2 && (!(g === "alignment" && C !== getSideAxis(s2)) || j.every((r3) => r3.overflows[0] > 0 && getSideAxis(r3.placement) === C))) return {
+          data: {
+            index: r2,
+            overflows: j
+          },
+          reset: { placement: s2 }
+        };
+        let c2 = (_c = j.filter((r3) => r3.overflows[0] <= 0).sort((r3, s3) => r3.overflows[1] - s3.overflows[1])[0]) == null ? void 0 : _c.placement;
+        if (!c2) switch (v) {
+          case "bestFit": {
+            let r3 = (_d = j.filter((r4) => {
+              if (D) {
+                let s3 = getSideAxis(r4.placement);
+                return s3 === C || s3 === "y";
+              }
+              return true;
+            }).map((r4) => [r4.placement, r4.overflows.filter((r5) => r5 > 0).reduce((r5, s3) => r5 + s3, 0)]).sort((r4, s3) => r4[1] - s3[1])[0]) == null ? void 0 : _d[0];
+            r3 && (c2 = r3);
+            break;
+          }
+          case "initialPlacement":
+            c2 = f;
+            break;
+        }
+        if (l !== c2) return { reset: { placement: c2 } };
+      }
+      return {};
+    }
+  };
+};
+function getSideOffsets(r, s) {
+  return {
+    top: r.top - s.height,
+    right: r.right - s.width,
+    bottom: r.bottom - s.height,
+    left: r.left - s.width
+  };
+}
+function isAnySideFullyClipped(r) {
+  return sides.some((s) => r[s] >= 0);
+}
+var hide$2 = function(r) {
+  return r === void 0 && (r = {}), {
+    name: "hide",
+    options: r,
+    async fn(s) {
+      let { rects: c } = s, { strategy: l = "referenceHidden", ...u } = evaluate(r, s);
+      switch (l) {
+        case "referenceHidden": {
+          let r2 = getSideOffsets(await detectOverflow$1(s, {
+            ...u,
+            elementContext: "reference"
+          }), c.reference);
+          return { data: {
+            referenceHiddenOffsets: r2,
+            referenceHidden: isAnySideFullyClipped(r2)
+          } };
+        }
+        case "escaped": {
+          let r2 = getSideOffsets(await detectOverflow$1(s, {
+            ...u,
+            altBoundary: true
+          }), c.floating);
+          return { data: {
+            escapedOffsets: r2,
+            escaped: isAnySideFullyClipped(r2)
+          } };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(r, s) {
+  let { placement: c, platform: l, elements: u } = r, 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, r), { 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(r) {
+  return r === void 0 && (r = 0), {
+    name: "offset",
+    options: r,
+    async fn(s) {
+      var _a;
+      var c;
+      let { x: l, y: u, placement: d, middlewareData: f } = s, p = await convertValueToCoords(s, r);
+      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(r) {
+  return r === void 0 && (r = {}), {
+    name: "shift",
+    options: r,
+    async fn(s) {
+      let { x: c, y: l, placement: u } = s, { mainAxis: d = true, crossAxis: f = false, limiter: p = { fn: (r2) => {
+        let { x: s2, y: c2 } = r2;
+        return {
+          x: s2,
+          y: c2
+        };
+      } }, ...m } = evaluate(r, 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 r2 = v === "y" ? "top" : "left", s2 = v === "y" ? "bottom" : "right", c2 = y + g[r2], l2 = y - g[s2];
+        y = clamp(c2, y, l2);
+      }
+      if (f) {
+        let r2 = _ === "y" ? "top" : "left", s2 = _ === "y" ? "bottom" : "right", c2 = b + g[r2], 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(r) {
+  return r === void 0 && (r = {}), {
+    options: r,
+    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(r, 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 r2 = v === "y" ? "height" : "width", s2 = d.reference[v] - d.floating[r2] + S.mainAxis, c2 = d.reference[v] + d.reference[r2] - S.mainAxis;
+        y < s2 ? y = s2 : y > c2 && (y = c2);
+      }
+      if (h) {
+        let r2 = v === "y" ? "width" : "height", s2 = originSides.has(getSide(u)), c2 = d.reference[_] - d.floating[r2] + (s2 && ((_a = f.offset) == null ? void 0 : _a[_]) || 0) + (s2 ? 0 : S.crossAxis), l2 = d.reference[_] + d.reference[r2] + (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(r) {
+  return r === void 0 && (r = {}), {
+    name: "size",
+    options: r,
+    async fn(s) {
+      var c, l;
+      let { placement: u, rects: d, platform: f, elements: p } = s, { apply: m = () => {
+      }, ...h } = evaluate(r, 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, T = b - g.left - g.right, E = min(x - g[S], w), D = min(b - g[C], T), O = !s.middlewareData.shift, k = E, A = D;
+      if ((c = s.middlewareData.shift) != null && c.enabled.x && (A = T), (l = s.middlewareData.shift) != null && l.enabled.y && (k = w), O && !v) {
+        let r2 = max(g.left, 0), s2 = max(g.right, 0), c2 = max(g.top, 0), l2 = max(g.bottom, 0);
+        y ? A = b - 2 * (r2 !== 0 || s2 !== 0 ? r2 + s2 : max(g.left, g.right)) : k = x - 2 * (c2 !== 0 || l2 !== 0 ? c2 + l2 : max(g.top, g.bottom));
+      }
+      await m({
+        ...s,
+        availableWidth: A,
+        availableHeight: k
+      });
+      let j = await f.getDimensions(p.floating);
+      return b !== j.width || x !== j.height ? { reset: { rects: true } } : {};
+    }
+  };
+};
+function hasWindow() {
+  return typeof window < "u";
+}
+function getNodeName(r) {
+  return isNode(r) ? (r.nodeName || "").toLowerCase() : "#document";
+}
+function getWindow(r) {
+  var s;
+  return (r == null || (s = r.ownerDocument) == null ? void 0 : s.defaultView) || window;
+}
+function getDocumentElement(r) {
+  var _a;
+  return (_a = (isNode(r) ? r.ownerDocument : r.document) || window.document) == null ? void 0 : _a.documentElement;
+}
+function isNode(r) {
+  return hasWindow() ? r instanceof Node || r instanceof getWindow(r).Node : false;
+}
+function isElement(r) {
+  return hasWindow() ? r instanceof Element || r instanceof getWindow(r).Element : false;
+}
+function isHTMLElement(r) {
+  return hasWindow() ? r instanceof HTMLElement || r instanceof getWindow(r).HTMLElement : false;
+}
+function isShadowRoot(r) {
+  return !hasWindow() || typeof ShadowRoot > "u" ? false : r instanceof ShadowRoot || r instanceof getWindow(r).ShadowRoot;
+}
+var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(r) {
+  let { overflow: s, overflowX: c, overflowY: l, display: u } = getComputedStyle$1(r);
+  return /auto|scroll|overlay|hidden|clip/.test(s + l + c) && !invalidOverflowDisplayValues.has(u);
+}
+var tableElements = /* @__PURE__ */ new Set([
+  "table",
+  "td",
+  "th"
+]);
+function isTableElement(r) {
+  return tableElements.has(getNodeName(r));
+}
+var topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(r) {
+  return topLayerSelectors.some((s) => {
+    try {
+      return r.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(r) {
+  let s = isWebKit(), c = isElement(r) ? getComputedStyle$1(r) : r;
+  return transformProperties.some((r2) => c[r2] ? c[r2] !== "none" : false) || (c.containerType ? c.containerType !== "normal" : false) || !s && (c.backdropFilter ? c.backdropFilter !== "none" : false) || !s && (c.filter ? c.filter !== "none" : false) || willChangeValues.some((r2) => (c.willChange || "").includes(r2)) || containValues.some((r2) => (c.contain || "").includes(r2));
+}
+function getContainingBlock(r) {
+  let s = getParentNode(r);
+  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(r) {
+  return lastTraversableNodeNames.has(getNodeName(r));
+}
+function getComputedStyle$1(r) {
+  return getWindow(r).getComputedStyle(r);
+}
+function getNodeScroll(r) {
+  return isElement(r) ? {
+    scrollLeft: r.scrollLeft,
+    scrollTop: r.scrollTop
+  } : {
+    scrollLeft: r.scrollX,
+    scrollTop: r.scrollY
+  };
+}
+function getParentNode(r) {
+  if (getNodeName(r) === "html") return r;
+  let s = r.assignedSlot || r.parentNode || isShadowRoot(r) && r.host || getDocumentElement(r);
+  return isShadowRoot(s) ? s.host : s;
+}
+function getNearestOverflowAncestor(r) {
+  let s = getParentNode(r);
+  return isLastTraversableNode(s) ? r.ownerDocument ? r.ownerDocument.body : r.body : isHTMLElement(s) && isOverflowElement(s) ? s : getNearestOverflowAncestor(s);
+}
+function getOverflowAncestors(r, s, c) {
+  var _a;
+  s === void 0 && (s = []), c === void 0 && (c = true);
+  let l = getNearestOverflowAncestor(r), u = l === ((_a = r.ownerDocument) == null ? void 0 : _a.body), d = getWindow(l);
+  if (u) {
+    let r2 = getFrameElement(d);
+    return s.concat(d, d.visualViewport || [], isOverflowElement(l) ? l : [], r2 && c ? getOverflowAncestors(r2) : []);
+  }
+  return s.concat(l, getOverflowAncestors(l, [], c));
+}
+function getFrameElement(r) {
+  return r.parent && Object.getPrototypeOf(r.parent) ? r.frameElement : null;
+}
+function getCssDimensions(r) {
+  let s = getComputedStyle$1(r), c = parseFloat(s.width) || 0, l = parseFloat(s.height) || 0, u = isHTMLElement(r), d = u ? r.offsetWidth : c, f = u ? r.offsetHeight : l, p = round(c) !== d || round(l) !== f;
+  return p && (c = d, l = f), {
+    width: c,
+    height: l,
+    $: p
+  };
+}
+function unwrapElement(r) {
+  return isElement(r) ? r : r.contextElement;
+}
+function getScale(r) {
+  let s = unwrapElement(r);
+  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(r) {
+  let s = getWindow(r);
+  return !isWebKit() || !s.visualViewport ? noOffsets : {
+    x: s.visualViewport.offsetLeft,
+    y: s.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(r, s, c) {
+  return s === void 0 && (s = false), !c || s && c !== getWindow(r) ? false : s;
+}
+function getBoundingClientRect(r, s, c, l) {
+  s === void 0 && (s = false), c === void 0 && (c = false);
+  let u = r.getBoundingClientRect(), d = unwrapElement(r), f = createCoords(1);
+  s && (l ? isElement(l) && (f = getScale(l)) : f = getScale(r));
+  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 r2 = getWindow(d), s2 = l && isElement(l) ? getWindow(l) : l, c2 = r2, u2 = getFrameElement(c2);
+    for (; u2 && l && s2 !== c2; ) {
+      let r3 = getScale(u2), s3 = u2.getBoundingClientRect(), l2 = getComputedStyle$1(u2), d2 = s3.left + (u2.clientLeft + parseFloat(l2.paddingLeft)) * r3.x, f2 = s3.top + (u2.clientTop + parseFloat(l2.paddingTop)) * r3.y;
+      m *= r3.x, h *= r3.y, g *= r3.x, _ *= r3.y, m += d2, h += f2, c2 = getWindow(u2), u2 = getFrameElement(c2);
+    }
+  }
+  return rectToClientRect({
+    width: g,
+    height: _,
+    x: m,
+    y: h
+  });
+}
+function getWindowScrollBarX(r, s) {
+  let c = getNodeScroll(r).scrollLeft;
+  return s ? s.left + c : getBoundingClientRect(getDocumentElement(r)).left + c;
+}
+function getHTMLOffset(r, s, c) {
+  c === void 0 && (c = false);
+  let l = r.getBoundingClientRect();
+  return {
+    x: l.left + s.scrollLeft - (c ? 0 : getWindowScrollBarX(r, l)),
+    y: l.top + s.scrollTop
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(r) {
+  let { elements: s, rect: c, offsetParent: l, strategy: u } = r, 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 r2 = getBoundingClientRect(l);
+    h = getScale(l), g.x = r2.x + l.clientLeft, g.y = r2.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(r) {
+  return Array.from(r.getClientRects());
+}
+function getDocumentRect(r) {
+  let s = getDocumentElement(r), c = getNodeScroll(r), l = r.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(r), p = -c.scrollTop;
+  return getComputedStyle$1(l).direction === "rtl" && (f += max(s.clientWidth, l.clientWidth) - u), {
+    width: u,
+    height: d,
+    x: f,
+    y: p
+  };
+}
+function getViewportRect(r, s) {
+  let c = getWindow(r), l = getDocumentElement(r), u = c.visualViewport, d = l.clientWidth, f = l.clientHeight, p = 0, m = 0;
+  if (u) {
+    d = u.width, f = u.height;
+    let r2 = isWebKit();
+    (!r2 || r2 && 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(r, s) {
+  let c = getBoundingClientRect(r, true, s === "fixed"), l = c.top + r.clientTop, u = c.left + r.clientLeft, d = isHTMLElement(r) ? getScale(r) : createCoords(1);
+  return {
+    width: r.clientWidth * d.x,
+    height: r.clientHeight * d.y,
+    x: u * d.x,
+    y: l * d.y
+  };
+}
+function getClientRectFromClippingAncestor(r, s, c) {
+  let l;
+  if (s === "viewport") l = getViewportRect(r, c);
+  else if (s === "document") l = getDocumentRect(getDocumentElement(r));
+  else if (isElement(s)) l = getInnerBoundingClientRect(s, c);
+  else {
+    let c2 = getVisualOffsets(r);
+    l = {
+      x: s.x - c2.x,
+      y: s.y - c2.y,
+      width: s.width,
+      height: s.height
+    };
+  }
+  return rectToClientRect(l);
+}
+function hasFixedPositionAncestor(r, s) {
+  let c = getParentNode(r);
+  return c === s || !isElement(c) || isLastTraversableNode(c) ? false : getComputedStyle$1(c).position === "fixed" || hasFixedPositionAncestor(c, s);
+}
+function getClippingElementAncestors(r, s) {
+  let c = s.get(r);
+  if (c) return c;
+  let l = getOverflowAncestors(r, [], false).filter((r2) => isElement(r2) && getNodeName(r2) !== "body"), u = null, d = getComputedStyle$1(r).position === "fixed", f = d ? getParentNode(r) : r;
+  for (; isElement(f) && !isLastTraversableNode(f); ) {
+    let s2 = getComputedStyle$1(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(r, f)) ? l = l.filter((r2) => r2 !== f) : u = s2, f = getParentNode(f);
+  }
+  return s.set(r, l), l;
+}
+function getClippingRect(r) {
+  let { element: s, boundary: c, rootBoundary: l, strategy: u } = r, d = [...c === "clippingAncestors" ? isTopLayer(s) ? [] : getClippingElementAncestors(s, this._c) : [].concat(c), l], f = d[0], p = d.reduce((r2, c2) => {
+    let l2 = getClientRectFromClippingAncestor(s, c2, u);
+    return r2.top = max(l2.top, r2.top), r2.right = min(l2.right, r2.right), r2.bottom = min(l2.bottom, r2.bottom), r2.left = max(l2.left, r2.left), r2;
+  }, getClientRectFromClippingAncestor(s, f, u));
+  return {
+    width: p.right - p.left,
+    height: p.bottom - p.top,
+    x: p.left,
+    y: p.top
+  };
+}
+function getDimensions(r) {
+  let { width: s, height: c } = getCssDimensions(r);
+  return {
+    width: s,
+    height: c
+  };
+}
+function getRectRelativeToOffsetParent(r, s, c) {
+  let l = isHTMLElement(s), u = getDocumentElement(s), d = c === "fixed", f = getBoundingClientRect(r, 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 r2 = getBoundingClientRect(s, true, d, s);
+    m.x = r2.x + s.clientLeft, m.y = r2.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(r) {
+  return getComputedStyle$1(r).position === "static";
+}
+function getTrueOffsetParent(r, s) {
+  if (!isHTMLElement(r) || getComputedStyle$1(r).position === "fixed") return null;
+  if (s) return s(r);
+  let c = r.offsetParent;
+  return getDocumentElement(r) === c && (c = c.ownerDocument.body), c;
+}
+function getOffsetParent(r, s) {
+  let c = getWindow(r);
+  if (isTopLayer(r)) return c;
+  if (!isHTMLElement(r)) {
+    let s2 = getParentNode(r);
+    for (; s2 && !isLastTraversableNode(s2); ) {
+      if (isElement(s2) && !isStaticPositioned(s2)) return s2;
+      s2 = getParentNode(s2);
+    }
+    return c;
+  }
+  let l = getTrueOffsetParent(r, s);
+  for (; l && isTableElement(l) && isStaticPositioned(l); ) l = getTrueOffsetParent(l, s);
+  return l && isLastTraversableNode(l) && isStaticPositioned(l) && !isContainingBlock(l) ? c : l || getContainingBlock(r) || c;
+}
+var getElementRects = async function(r) {
+  let s = this.getOffsetParent || getOffsetParent, c = this.getDimensions, l = await c(r.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(r.reference, await s(r.floating), r.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: l.width,
+      height: l.height
+    }
+  };
+};
+function isRTL(r) {
+  return getComputedStyle$1(r).direction === "rtl";
+}
+var platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function rectsAreEqual(r, s) {
+  return r.x === s.x && r.y === s.y && r.width === s.width && r.height === s.height;
+}
+function observeMove(r, s) {
+  let c = null, l, u = getDocumentElement(r);
+  function d() {
+    var r2;
+    clearTimeout(l), (r2 = c) == null || r2.disconnect(), c = null;
+  }
+  function f(p, m) {
+    p === void 0 && (p = false), m === void 0 && (m = 1), d();
+    let h = r.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
+    }, T = true;
+    function E(s2) {
+      let c2 = s2[0].intersectionRatio;
+      if (c2 !== m) {
+        if (!T) return f();
+        c2 ? f(false, c2) : l = setTimeout(() => {
+          f(false, 1e-7);
+        }, 1e3);
+      }
+      c2 === 1 && !rectsAreEqual(h, r.getBoundingClientRect()) && f(), T = false;
+    }
+    try {
+      c = new IntersectionObserver(E, {
+        ...w,
+        root: u.ownerDocument
+      });
+    } catch {
+      c = new IntersectionObserver(E, w);
+    }
+    c.observe(r);
+  }
+  return f(true), d;
+}
+function autoUpdate(r, 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(r), g = u || d ? [...h ? getOverflowAncestors(h) : [], ...getOverflowAncestors(s)] : [];
+  g.forEach((r2) => {
+    u && r2.addEventListener("scroll", c, { passive: true }), d && r2.addEventListener("resize", c);
+  });
+  let _ = h && p ? observeMove(h, c) : null, v = -1, y = null;
+  f && (y = new ResizeObserver((r2) => {
+    let [l2] = r2;
+    l2 && l2.target === h && y && (y.unobserve(s), cancelAnimationFrame(v), v = requestAnimationFrame(() => {
+      var r3;
+      (r3 = y) == null || r3.observe(s);
+    })), c();
+  }), h && !m && y.observe(h), y.observe(s));
+  let b, x = m ? getBoundingClientRect(r) : null;
+  m && S();
+  function S() {
+    let s2 = getBoundingClientRect(r);
+    x && !rectsAreEqual(x, s2) && c(), x = s2, b = requestAnimationFrame(S);
+  }
+  return c(), () => {
+    var r2;
+    g.forEach((r3) => {
+      u && r3.removeEventListener("scroll", c), d && r3.removeEventListener("resize", c);
+    }), _ == null ? void 0 : _(), (r2 = y) == null || r2.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 = (r, s, c) => {
+  let l = /* @__PURE__ */ new Map(), u = {
+    platform,
+    ...c
+  }, d = {
+    ...u.platform,
+    _c: l
+  };
+  return computePosition$1(r, s, {
+    ...u,
+    platform: d
+  });
+}, import_react_dom$1 = /* @__PURE__ */ __toESM(require_react_dom(), 1), index = typeof document < "u" ? import_react.useLayoutEffect : function() {
+};
+function deepEqual(r, s) {
+  if (r === s) return true;
+  if (typeof r != typeof s) return false;
+  if (typeof r == "function" && r.toString() === s.toString()) return true;
+  let c, l, u;
+  if (r && s && typeof r == "object") {
+    if (Array.isArray(r)) {
+      if (c = r.length, c !== s.length) return false;
+      for (l = c; l-- !== 0; ) if (!deepEqual(r[l], s[l])) return false;
+      return true;
+    }
+    if (u = Object.keys(r), 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" && r.$$typeof) && !deepEqual(r[c2], s[c2])) return false;
+    }
+    return true;
+  }
+  return r !== r && s !== s;
+}
+function getDPR(r) {
+  return typeof window > "u" ? 1 : (r.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(r, s) {
+  let c = getDPR(r);
+  return Math.round(s * c) / c;
+}
+function useLatestRef(r) {
+  let s = import_react.useRef(r);
+  return index(() => {
+    s.current = r;
+  }), s;
+}
+function useFloating(r) {
+  r === void 0 && (r = {});
+  let { placement: s = "bottom", strategy: c = "absolute", middleware: l = [], platform: u, elements: { reference: d, floating: f } = {}, transform: p = true, whileElementsMounted: m, open: g } = r, [_, v] = import_react.useState({
+    x: 0,
+    y: 0,
+    strategy: c,
+    placement: s,
+    middlewareData: {},
+    isPositioned: false
+  }), [y, b] = import_react.useState(l);
+  deepEqual(y, l) || b(l);
+  let [x, S] = import_react.useState(null), [C, w] = import_react.useState(null), T = import_react.useCallback((r2) => {
+    r2 !== k.current && (k.current = r2, S(r2));
+  }, []), E = import_react.useCallback((r2) => {
+    r2 !== A.current && (A.current = r2, w(r2));
+  }, []), D = d || x, O = f || C, k = import_react.useRef(null), A = import_react.useRef(null), j = import_react.useRef(_), M = m != null, N = useLatestRef(m), P = useLatestRef(u), F = useLatestRef(g), I = import_react.useCallback(() => {
+    if (!k.current || !A.current) return;
+    let r2 = {
+      placement: s,
+      strategy: c,
+      middleware: y
+    };
+    P.current && (r2.platform = P.current), computePosition(k.current, A.current, r2).then((r3) => {
+      let s2 = {
+        ...r3,
+        isPositioned: F.current !== false
+      };
+      L.current && !deepEqual(j.current, s2) && (j.current = s2, import_react_dom$1.flushSync(() => {
+        v(s2);
+      }));
+    });
+  }, [
+    y,
+    s,
+    c,
+    P,
+    F
+  ]);
+  index(() => {
+    g === false && j.current.isPositioned && (j.current.isPositioned = false, v((r2) => ({
+      ...r2,
+      isPositioned: false
+    })));
+  }, [g]);
+  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 r2 = {
+      position: c,
+      left: 0,
+      top: 0
+    };
+    if (!z.floating) return r2;
+    let s2 = roundByDPR(z.floating, _.x), l2 = roundByDPR(z.floating, _.y);
+    return p ? {
+      ...r2,
+      transform: "translate(" + s2 + "px, " + l2 + "px)",
+      ...getDPR(z.floating) >= 1.5 && { willChange: "transform" }
+    } : {
+      position: c,
+      left: s2,
+      top: l2
+    };
+  }, [
+    c,
+    p,
+    z.floating,
+    _.x,
+    _.y
+  ]);
+  return import_react.useMemo(() => ({
+    ..._,
+    update: I,
+    refs: R,
+    elements: z,
+    floatingStyles: B
+  }), [
+    _,
+    I,
+    R,
+    z,
+    B
+  ]);
+}
+var arrow$1$1 = (r) => {
+  function s(r2) {
+    return {}.hasOwnProperty.call(r2, "current");
+  }
+  return {
+    name: "arrow",
+    options: r,
+    fn(c) {
+      let { element: l, padding: u } = typeof r == "function" ? r(c) : r;
+      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 = (r, s) => ({
+  ...offset$1(r),
+  options: [r, s]
+}), shift = (r, s) => ({
+  ...shift$1(r),
+  options: [r, s]
+}), limitShift = (r, s) => ({
+  ...limitShift$1(r),
+  options: [r, s]
+}), flip = (r, s) => ({
+  ...flip$1(r),
+  options: [r, s]
+}), size = (r, s) => ({
+  ...size$1(r),
+  options: [r, s]
+}), hide = (r, s) => ({
+  ...hide$1(r),
+  options: [r, s]
+}), arrow = (r, s) => ({
+  ...arrow$1$1(r),
+  options: [r, s]
+}), NAME$1 = "Arrow", Arrow$1 = import_react.forwardRef((r, s) => {
+  let { children: c, width: l = 10, height: u = 5, ...d } = r;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.svg, {
+    ...d,
+    ref: s,
+    width: l,
+    height: u,
+    viewBox: "0 0 30 10",
+    preserveAspectRatio: "none",
+    children: r.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(r) {
+  let [s, c] = import_react.useState(void 0);
+  return useLayoutEffect2(() => {
+    if (r) {
+      c({
+        width: r.offsetWidth,
+        height: r.offsetHeight
+      });
+      let s2 = new ResizeObserver((s3) => {
+        if (!Array.isArray(s3) || !s3.length) return;
+        let l = s3[0], u, d;
+        if ("borderBoxSize" in l) {
+          let r2 = l.borderBoxSize, s4 = Array.isArray(r2) ? r2[0] : r2;
+          u = s4.inlineSize, d = s4.blockSize;
+        } else u = r.offsetWidth, d = r.offsetHeight;
+        c({
+          width: u,
+          height: d
+        });
+      });
+      return s2.observe(r, { box: "border-box" }), () => s2.unobserve(r);
+    } else c(void 0);
+  }, [r]), s;
+}
+var POPPER_NAME = "Popper", [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME), [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME), Popper = (r) => {
+  let { __scopePopper: s, children: c } = r, [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((r, s) => {
+  let { __scopePopper: c, virtualRef: u, ...d } = r, f = usePopperContext(ANCHOR_NAME, c), p = import_react.useRef(null), m = useComposedRefs(s, p), _ = import_react.useRef(null);
+  return import_react.useEffect(() => {
+    let r2 = _.current;
+    _.current = (u == null ? void 0 : u.current) || p.current, r2 !== _.current && f.onAnchorChange(_.current);
+  }), u ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+    ...d,
+    ref: m
+  });
+});
+PopperAnchor.displayName = ANCHOR_NAME;
+var CONTENT_NAME = "PopperContent", [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME), PopperContent = import_react.forwardRef((r, s) => {
+  var _a, _b, _c, _d, _e, _f;
+  let { __scopePopper: c, side: u = "bottom", sideOffset: d = 0, align: f = "center", alignOffset: p = 0, arrowPadding: m = 0, avoidCollisions: _ = true, collisionBoundary: v = [], collisionPadding: y = 0, sticky: b = "partial", hideWhenDetached: x = false, updatePositionStrategy: S = "optimized", onPlaced: C, ...w } = r, T = usePopperContext(CONTENT_NAME, c), [E, D] = import_react.useState(null), k = useComposedRefs(s, (r2) => D(r2)), [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 = u + (f === "center" ? "" : "-" + f), L = typeof y == "number" ? y : {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...y
+  }, R = Array.isArray(v) ? v : [v], 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: (...r2) => autoUpdate(...r2, { animationFrame: S === "always" }),
+    elements: { reference: T.anchor },
+    middleware: [
+      offset({
+        mainAxis: d + F,
+        alignmentAxis: p
+      }),
+      _ && shift({
+        mainAxis: true,
+        crossAxis: false,
+        limiter: b === "partial" ? limitShift() : void 0,
+        ...B
+      }),
+      _ && flip({ ...B }),
+      size({
+        ...B,
+        apply: ({ elements: r2, rects: s2, availableWidth: c2, availableHeight: l }) => {
+          let { width: u2, height: d2 } = s2.reference, f2 = r2.floating.style;
+          f2.setProperty("--radix-popper-available-width", `${c2}px`), f2.setProperty("--radix-popper-available-height", `${l}px`), f2.setProperty("--radix-popper-anchor-width", `${u2}px`), f2.setProperty("--radix-popper-anchor-height", `${d2}px`);
+        }
+      }),
+      j && arrow({
+        element: j,
+        padding: m
+      }),
+      transformOrigin({
+        arrowWidth: P,
+        arrowHeight: F
+      }),
+      x && hide({
+        strategy: "referenceHidden",
+        ...B
+      })
+    ]
+  }), [K, q] = getSideAndAlignFromPlacement(U), J = useCallbackRef$1(C);
+  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(() => {
+    E && $(window.getComputedStyle(E).zIndex);
+  }, [E]), /* @__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: r.dir,
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopperContentProvider, {
+      scope: c,
+      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,
+        ...w,
+        ref: k,
+        style: {
+          ...w.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(r, s) {
+  let { __scopePopper: c, ...l } = r, 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(r) {
+  return r !== null;
+}
+var transformOrigin = (r) => ({
+  name: "transformOrigin",
+  options: r,
+  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 : r.arrowWidth, p = d ? 0 : r.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(r) {
+  let [s, c = "center"] = r.split("-");
+  return [s, c];
+}
+var Root2 = Popper, Anchor = PopperAnchor, Content = PopperContent, Arrow = PopperArrow, import_react_dom = /* @__PURE__ */ __toESM(require_react_dom(), 1), PORTAL_NAME = "Portal", Portal = import_react.forwardRef((r, s) => {
+  var _a;
+  let { container: c, ...l } = r, [u, d] = import_react.useState(false);
+  useLayoutEffect2(() => d(true), []);
+  let f = c || u && ((_a = globalThis == null ? void 0 : globalThis.document) == null ? void 0 : _a.body);
+  return f ? import_react_dom.createPortal(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+    ...l,
+    ref: s
+  }), f) : null;
+});
+Portal.displayName = PORTAL_NAME;
+function useStateMachine(r, s) {
+  return import_react.useReducer((r2, c) => s[r2][c] ?? r2, r);
+}
+var Presence = (r) => {
+  let { present: s, children: c } = r, u = usePresence(s), d = typeof c == "function" ? c({ present: u.isPresent }) : import_react.Children.only(c), f = useComposedRefs(u.ref, getElementRef(d));
+  return typeof c == "function" || u.isPresent ? import_react.cloneElement(d, { ref: f }) : null;
+};
+Presence.displayName = "Presence";
+function usePresence(r) {
+  let [s, c] = import_react.useState(), l = import_react.useRef(null), u = import_react.useRef(r), d = import_react.useRef("none"), [f, p] = useStateMachine(r ? "mounted" : "unmounted", {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: { MOUNT: "mounted" }
+  });
+  return import_react.useEffect(() => {
+    let r2 = getAnimationName(l.current);
+    d.current = f === "mounted" ? r2 : "none";
+  }, [f]), useLayoutEffect2(() => {
+    let s2 = l.current, c2 = u.current;
+    if (c2 !== r) {
+      let l2 = d.current, f2 = getAnimationName(s2);
+      r ? p("MOUNT") : f2 === "none" || (s2 == null ? void 0 : s2.display) === "none" ? p("UNMOUNT") : p(c2 && l2 !== f2 ? "ANIMATION_OUT" : "UNMOUNT"), u.current = r;
+    }
+  }, [r, p]), useLayoutEffect2(() => {
+    if (s) {
+      let r2, c2 = s.ownerDocument.defaultView ?? window, f2 = (d2) => {
+        let f3 = getAnimationName(l.current).includes(CSS.escape(d2.animationName));
+        if (d2.target === s && f3 && (p("ANIMATION_END"), !u.current)) {
+          let l2 = s.style.animationFillMode;
+          s.style.animationFillMode = "forwards", r2 = c2.setTimeout(() => {
+            s.style.animationFillMode === "forwards" && (s.style.animationFillMode = l2);
+          });
+        }
+      }, m = (r3) => {
+        r3.target === s && (d.current = getAnimationName(l.current));
+      };
+      return s.addEventListener("animationstart", m), s.addEventListener("animationcancel", f2), s.addEventListener("animationend", f2), () => {
+        c2.clearTimeout(r2), s.removeEventListener("animationstart", m), s.removeEventListener("animationcancel", f2), s.removeEventListener("animationend", f2);
+      };
+    } else p("ANIMATION_END");
+  }, [s, p]), {
+    isPresent: ["mounted", "unmountSuspended"].includes(f),
+    ref: import_react.useCallback((r2) => {
+      l.current = r2 ? getComputedStyle(r2) : null, c(r2);
+    }, [])
+  };
+}
+function getAnimationName(r) {
+  return (r == null ? void 0 : r.animationName) || "none";
+}
+function getElementRef(r) {
+  var _a, _b;
+  let s = (_a = Object.getOwnPropertyDescriptor(r.props, "ref")) == null ? void 0 : _a.get, c = s && "isReactWarning" in s && s.isReactWarning;
+  return c ? r.ref : (s = (_b = Object.getOwnPropertyDescriptor(r, "ref")) == null ? void 0 : _b.get, c = s && "isReactWarning" in s && s.isReactWarning, c ? r.props.ref : r.props.ref || r.ref);
+}
+var useInsertionEffect = import_react.useInsertionEffect || useLayoutEffect2;
+function useControllableState({ prop: r, defaultProp: s, onChange: c = () => {
+}, caller: l }) {
+  let [u, d, f] = useUncontrolledState({
+    defaultProp: s,
+    onChange: c
+  }), p = r !== void 0, m = p ? r : u;
+  {
+    let s2 = import_react.useRef(r !== void 0);
+    import_react.useEffect(() => {
+      let r2 = s2.current;
+      if (r2 !== p) {
+        let s3 = r2 ? "controlled" : "uncontrolled", c2 = p ? "controlled" : "uncontrolled";
+        console.warn(`${l} is changing from ${s3} to ${c2}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`);
+      }
+      s2.current = p;
+    }, [p, l]);
+  }
+  return [m, import_react.useCallback((s2) => {
+    var _a;
+    if (p) {
+      let c2 = isFunction(s2) ? s2(r) : s2;
+      c2 !== r && ((_a = f.current) == null ? void 0 : _a.call(f, c2));
+    } else d(s2);
+  }, [
+    p,
+    r,
+    d,
+    f
+  ])];
+}
+function useUncontrolledState({ defaultProp: r, onChange: s }) {
+  let [c, l] = import_react.useState(r), u = import_react.useRef(c), d = import_react.useRef(s);
+  return useInsertionEffect(() => {
+    d.current = s;
+  }, [s]), import_react.useEffect(() => {
+    var _a;
+    u.current !== c && ((_a = d.current) == null ? void 0 : _a.call(d, c), u.current = c);
+  }, [c, u]), [
+    c,
+    l,
+    d
+  ];
+}
+function isFunction(r) {
+  return typeof r == "function";
+}
+var 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((r, s) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.span, {
+  ...r,
+  ref: s,
+  style: {
+    ...VISUALLY_HIDDEN_STYLES,
+    ...r.style
+  }
+}));
+VisuallyHidden.displayName = NAME;
+var Root = VisuallyHidden, import_compiler_runtime$1 = /* @__PURE__ */ __toESM(require_compiler_runtime(), 1), style = { display: "contents" };
+const StyleNamespace = import_react.forwardRef((r, s) => {
+  let c = (0, import_compiler_runtime$1.c)(3), { children: l } = r, u;
+  return c[0] !== l || c[1] !== s ? (u = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+    ref: s,
+    className: "marimo",
+    style,
+    children: l
+  }), c[0] = l, c[1] = s, c[2] = u) : u = c[2], u;
+});
+StyleNamespace.displayName = "StyleNamespace";
+function isInVscodeExtension() {
+  return document.querySelector("[data-vscode-theme-kind]") !== null;
+}
+var import_compiler_runtime = /* @__PURE__ */ __toESM(require_compiler_runtime(), 1), VSCODE_OUTPUT_CONTAINER_SELECTOR = "[data-vscode-output-container]";
+const MAX_HEIGHT_OFFSET = isInVscodeExtension() ? 0 : 30;
+function useFullScreenElement() {
+  let r = (0, import_compiler_runtime.c)(1), [s, c] = (0, import_react.useState)(document.fullscreenElement), l;
+  return r[0] === Symbol.for("react.memo_cache_sentinel") ? (l = () => {
+    c(document.fullscreenElement);
+  }, r[0] = l) : l = r[0], useEventListener(document, "fullscreenchange", l), s;
+}
+function withFullScreenAsRoot(r) {
+  let s = (s2) => {
+    let c2 = (0, import_compiler_runtime.c)(6), [l, u] = import_react.useState(null), d = import_react.useRef(null), f, p;
+    c2[0] === Symbol.for("react.memo_cache_sentinel") ? (f = () => {
+      d.current && u(closestThroughShadowDOMs(d.current, VSCODE_OUTPUT_CONTAINER_SELECTOR));
+    }, p = [], c2[0] = f, c2[1] = p) : (f = c2[0], p = c2[1]), import_react.useLayoutEffect(f, p);
+    let m;
+    c2[2] === Symbol.for("react.memo_cache_sentinel") ? (m = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+      ref: d,
+      className: "contents invisible"
+    }), c2[2] = m) : m = c2[2];
+    let _;
+    return c2[3] !== l || c2[4] !== s2 ? (_ = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [m, /* @__PURE__ */ (0, import_jsx_runtime.jsx)(r, {
+      ...s2,
+      container: l
+    })] }), c2[3] = l, c2[4] = s2, c2[5] = _) : _ = c2[5], _;
+  }, c = (c2) => {
+    let l = (0, import_compiler_runtime.c)(7), u = useFullScreenElement();
+    if (isInVscodeExtension()) {
+      let r2;
+      return l[0] === c2 ? r2 = l[1] : (r2 = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(s, { ...c2 }), l[0] = c2, l[1] = r2), r2;
+    }
+    if (!u) {
+      let s2;
+      return l[2] === c2 ? s2 = l[3] : (s2 = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(r, { ...c2 }), l[2] = c2, l[3] = s2), s2;
+    }
+    let d;
+    return l[4] !== u || l[5] !== c2 ? (d = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(r, {
+      ...c2,
+      container: u
+    }), l[4] = u, l[5] = c2, l[6] = d) : d = l[6], d;
+  };
+  return c.displayName = r.displayName, c;
+}
+function withSmartCollisionBoundary(r) {
+  let s = (s2) => {
+    let c2 = (0, import_compiler_runtime.c)(6), [l, u] = import_react.useState(null), d = import_react.useRef(null), f, p;
+    c2[0] === Symbol.for("react.memo_cache_sentinel") ? (f = () => {
+      d.current && u(closestThroughShadowDOMs(d.current, VSCODE_OUTPUT_CONTAINER_SELECTOR));
+    }, p = [], c2[0] = f, c2[1] = p) : (f = c2[0], p = c2[1]), import_react.useLayoutEffect(f, p);
+    let m;
+    c2[2] === Symbol.for("react.memo_cache_sentinel") ? (m = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+      ref: d,
+      className: "contents invisible"
+    }), c2[2] = m) : m = c2[2];
+    let _;
+    return c2[3] !== l || c2[4] !== s2 ? (_ = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [m, /* @__PURE__ */ (0, import_jsx_runtime.jsx)(r, {
+      ...s2,
+      collisionBoundary: l
+    })] }), c2[3] = l, c2[4] = s2, c2[5] = _) : _ = c2[5], _;
+  }, c = (c2) => {
+    let l = (0, import_compiler_runtime.c)(4);
+    if (isInVscodeExtension()) {
+      let r2;
+      return l[0] === c2 ? r2 = l[1] : (r2 = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(s, { ...c2 }), l[0] = c2, l[1] = r2), r2;
+    }
+    let u;
+    return l[2] === c2 ? u = l[3] : (u = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(r, { ...c2 }), l[2] = c2, l[3] = u), u;
+  };
+  return c.displayName = r.displayName, c;
+}
+function closestThroughShadowDOMs(r, s) {
+  let c = r;
+  for (; c; ) {
+    let r2 = c.closest(s);
+    if (r2) return r2;
+    let l = c.getRootNode();
+    if (c = l instanceof ShadowRoot ? l.host : c.parentElement, c === l) break;
+  }
+  return null;
+}
+var __assign = function() {
+  return __assign = Object.assign || function(r) {
+    for (var s, c = 1, l = arguments.length; c < l; c++) for (var u in s = arguments[c], s) Object.prototype.hasOwnProperty.call(s, u) && (r[u] = s[u]);
+    return r;
+  }, __assign.apply(this, arguments);
+};
+function __rest(r, s) {
+  var c = {};
+  for (var l in r) Object.prototype.hasOwnProperty.call(r, l) && s.indexOf(l) < 0 && (c[l] = r[l]);
+  if (r != null && typeof Object.getOwnPropertySymbols == "function") for (var u = 0, l = Object.getOwnPropertySymbols(r); u < l.length; u++) s.indexOf(l[u]) < 0 && Object.prototype.propertyIsEnumerable.call(r, l[u]) && (c[l[u]] = r[l[u]]);
+  return c;
+}
+function __awaiter(r, s, c, l) {
+  function u(r2) {
+    return r2 instanceof c ? r2 : new c(function(s2) {
+      s2(r2);
+    });
+  }
+  return new (c || (c = Promise))(function(c2, d) {
+    function f(r2) {
+      try {
+        m(l.next(r2));
+      } catch (r3) {
+        d(r3);
+      }
+    }
+    function p(r2) {
+      try {
+        m(l.throw(r2));
+      } catch (r3) {
+        d(r3);
+      }
+    }
+    function m(r2) {
+      r2.done ? c2(r2.value) : u(r2.value).then(f, p);
+    }
+    m((l = l.apply(r, s || [])).next());
+  });
+}
+function __spreadArray(r, s, c) {
+  if (c || arguments.length === 2) for (var l = 0, u = s.length, d; l < u; l++) (d || !(l in s)) && (d || (d = Array.prototype.slice.call(s, 0, l)), d[l] = s[l]);
+  return r.concat(d || Array.prototype.slice.call(s));
+}
+var count = 0;
+function useFocusGuards() {
+  import_react.useEffect(() => {
+    let r = document.querySelectorAll("[data-radix-focus-guard]");
+    return document.body.insertAdjacentElement("afterbegin", r[0] ?? createFocusGuard()), document.body.insertAdjacentElement("beforeend", r[1] ?? createFocusGuard()), count++, () => {
+      count === 1 && document.querySelectorAll("[data-radix-focus-guard]").forEach((r2) => r2.remove()), count--;
+    };
+  }, []);
+}
+function createFocusGuard() {
+  let r = document.createElement("span");
+  return r.setAttribute("data-radix-focus-guard", ""), r.tabIndex = 0, r.style.outline = "none", r.style.opacity = "0", r.style.position = "fixed", r.style.pointerEvents = "none", r;
+}
+var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount", AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount", EVENT_OPTIONS = {
+  bubbles: false,
+  cancelable: true
+}, FOCUS_SCOPE_NAME = "FocusScope", FocusScope = import_react.forwardRef((r, s) => {
+  let { loop: c = false, trapped: u = false, onMountAutoFocus: d, onUnmountAutoFocus: f, ...p } = r, [m, _] = import_react.useState(null), v = useCallbackRef$1(d), y = useCallbackRef$1(f), b = import_react.useRef(null), x = useComposedRefs(s, (r2) => _(r2)), S = import_react.useRef({
+    paused: false,
+    pause() {
+      this.paused = true;
+    },
+    resume() {
+      this.paused = false;
+    }
+  }).current;
+  import_react.useEffect(() => {
+    if (u) {
+      let r2 = function(r3) {
+        if (S.paused || !m) return;
+        let s3 = r3.target;
+        m.contains(s3) ? b.current = s3 : focus(b.current, { select: true });
+      }, s2 = function(r3) {
+        if (S.paused || !m) return;
+        let s3 = r3.relatedTarget;
+        s3 !== null && (m.contains(s3) || focus(b.current, { select: true }));
+      }, c2 = function(r3) {
+        if (document.activeElement === document.body) for (let s3 of r3) s3.removedNodes.length > 0 && focus(m);
+      };
+      document.addEventListener("focusin", r2), document.addEventListener("focusout", s2);
+      let l = new MutationObserver(c2);
+      return m && l.observe(m, {
+        childList: true,
+        subtree: true
+      }), () => {
+        document.removeEventListener("focusin", r2), document.removeEventListener("focusout", s2), l.disconnect();
+      };
+    }
+  }, [
+    u,
+    m,
+    S.paused
+  ]), import_react.useEffect(() => {
+    if (m) {
+      focusScopesStack.add(S);
+      let r2 = document.activeElement;
+      if (!m.contains(r2)) {
+        let s2 = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
+        m.addEventListener(AUTOFOCUS_ON_MOUNT, v), m.dispatchEvent(s2), s2.defaultPrevented || (focusFirst(removeLinks(getTabbableCandidates(m)), { select: true }), document.activeElement === r2 && focus(m));
+      }
+      return () => {
+        m.removeEventListener(AUTOFOCUS_ON_MOUNT, v), setTimeout(() => {
+          let s2 = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
+          m.addEventListener(AUTOFOCUS_ON_UNMOUNT, y), m.dispatchEvent(s2), s2.defaultPrevented || focus(r2 ?? document.body, { select: true }), m.removeEventListener(AUTOFOCUS_ON_UNMOUNT, y), focusScopesStack.remove(S);
+        }, 0);
+      };
+    }
+  }, [
+    m,
+    v,
+    y,
+    S
+  ]);
+  let C = import_react.useCallback((r2) => {
+    if (!c && !u || S.paused) return;
+    let s2 = r2.key === "Tab" && !r2.altKey && !r2.ctrlKey && !r2.metaKey, l = document.activeElement;
+    if (s2 && l) {
+      let s3 = r2.currentTarget, [u2, d2] = getTabbableEdges(s3);
+      u2 && d2 ? !r2.shiftKey && l === d2 ? (r2.preventDefault(), c && focus(u2, { select: true })) : r2.shiftKey && l === u2 && (r2.preventDefault(), c && focus(d2, { select: true })) : l === s3 && r2.preventDefault();
+    }
+  }, [
+    c,
+    u,
+    S.paused
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+    tabIndex: -1,
+    ...p,
+    ref: x,
+    onKeyDown: C
+  });
+});
+FocusScope.displayName = FOCUS_SCOPE_NAME;
+function focusFirst(r, { select: s = false } = {}) {
+  let c = document.activeElement;
+  for (let l of r) if (focus(l, { select: s }), document.activeElement !== c) return;
+}
+function getTabbableEdges(r) {
+  let s = getTabbableCandidates(r);
+  return [findVisible(s, r), findVisible(s.reverse(), r)];
+}
+function getTabbableCandidates(r) {
+  let s = [], c = document.createTreeWalker(r, NodeFilter.SHOW_ELEMENT, { acceptNode: (r2) => {
+    let s2 = r2.tagName === "INPUT" && r2.type === "hidden";
+    return r2.disabled || r2.hidden || s2 ? NodeFilter.FILTER_SKIP : r2.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+  } });
+  for (; c.nextNode(); ) s.push(c.currentNode);
+  return s;
+}
+function findVisible(r, s) {
+  for (let c of r) if (!isHidden(c, { upTo: s })) return c;
+}
+function isHidden(r, { upTo: s }) {
+  if (getComputedStyle(r).visibility === "hidden") return true;
+  for (; r; ) {
+    if (s !== void 0 && r === s) return false;
+    if (getComputedStyle(r).display === "none") return true;
+    r = r.parentElement;
+  }
+  return false;
+}
+function isSelectableInput(r) {
+  return r instanceof HTMLInputElement && "select" in r;
+}
+function focus(r, { select: s = false } = {}) {
+  if (r && r.focus) {
+    let c = document.activeElement;
+    r.focus({ preventScroll: true }), r !== c && isSelectableInput(r) && s && r.select();
+  }
+}
+var focusScopesStack = createFocusScopesStack();
+function createFocusScopesStack() {
+  let r = [];
+  return {
+    add(s) {
+      let c = r[0];
+      s !== c && (c == null ? void 0 : c.pause()), r = arrayRemove(r, s), r.unshift(s);
+    },
+    remove(s) {
+      var _a;
+      r = arrayRemove(r, s), (_a = r[0]) == null ? void 0 : _a.resume();
+    }
+  };
+}
+function arrayRemove(r, s) {
+  let c = [...r], l = c.indexOf(s);
+  return l !== -1 && c.splice(l, 1), c;
+}
+function removeLinks(r) {
+  return r.filter((r2) => r2.tagName !== "A");
+}
+var getDefaultParent = function(r) {
+  return typeof document > "u" ? null : (Array.isArray(r) ? r[0] : r).ownerDocument.body;
+}, counterMap = /* @__PURE__ */ new WeakMap(), uncontrolledNodes = /* @__PURE__ */ new WeakMap(), markerMap = {}, lockCount = 0, unwrapHost = function(r) {
+  return r && (r.host || unwrapHost(r.parentNode));
+}, correctTargets = function(r, s) {
+  return s.map(function(s2) {
+    if (r.contains(s2)) return s2;
+    var c = unwrapHost(s2);
+    return c && r.contains(c) ? c : (console.error("aria-hidden", s2, "in not contained inside", r, ". Doing nothing"), null);
+  }).filter(function(r2) {
+    return !!r2;
+  });
+}, applyAttributeToOthers = function(r, s, c, l) {
+  var u = correctTargets(s, Array.isArray(r) ? r : [r]);
+  markerMap[c] || (markerMap[c] = /* @__PURE__ */ new WeakMap());
+  var d = markerMap[c], f = [], p = /* @__PURE__ */ new Set(), m = new Set(u), h = function(r2) {
+    !r2 || p.has(r2) || (p.add(r2), h(r2.parentNode));
+  };
+  u.forEach(h);
+  var g = function(r2) {
+    !r2 || m.has(r2) || Array.prototype.forEach.call(r2.children, function(r3) {
+      if (p.has(r3)) g(r3);
+      else try {
+        var s2 = r3.getAttribute(l), u2 = s2 !== null && s2 !== "false", m2 = (counterMap.get(r3) || 0) + 1, h2 = (d.get(r3) || 0) + 1;
+        counterMap.set(r3, m2), d.set(r3, h2), f.push(r3), m2 === 1 && u2 && uncontrolledNodes.set(r3, true), h2 === 1 && r3.setAttribute(c, "true"), u2 || r3.setAttribute(l, "true");
+      } catch (s3) {
+        console.error("aria-hidden: cannot operate on ", r3, s3);
+      }
+    });
+  };
+  return g(s), p.clear(), lockCount++, function() {
+    f.forEach(function(r2) {
+      var s2 = counterMap.get(r2) - 1, u2 = d.get(r2) - 1;
+      counterMap.set(r2, s2), d.set(r2, u2), s2 || (uncontrolledNodes.has(r2) || r2.removeAttribute(l), uncontrolledNodes.delete(r2)), u2 || r2.removeAttribute(c);
+    }), lockCount--, lockCount || (counterMap = /* @__PURE__ */ new WeakMap(), counterMap = /* @__PURE__ */ new WeakMap(), uncontrolledNodes = /* @__PURE__ */ new WeakMap(), markerMap = {});
+  };
+}, hideOthers = function(r, s, c) {
+  c === void 0 && (c = "data-aria-hidden");
+  var l = Array.from(Array.isArray(r) ? r : [r]), u = s || getDefaultParent(r);
+  return u ? (l.push.apply(l, Array.from(u.querySelectorAll("[aria-live], script"))), applyAttributeToOthers(l, u, c, "aria-hidden")) : function() {
+    return null;
+  };
+}, zeroRightClassName = "right-scroll-bar-position", fullWidthClassName = "width-before-scroll-bar", noScrollbarsClassName = "with-scroll-bars-hidden", removedBarSizeVariable = "--removed-body-scroll-bar-size";
+function assignRef(r, s) {
+  return typeof r == "function" ? r(s) : r && (r.current = s), r;
+}
+function useCallbackRef(r, s) {
+  var c = (0, import_react.useState)(function() {
+    return {
+      value: r,
+      callback: s,
+      facade: {
+        get current() {
+          return c.value;
+        },
+        set current(r2) {
+          var s2 = c.value;
+          s2 !== r2 && (c.value = r2, c.callback(r2, s2));
+        }
+      }
+    };
+  })[0];
+  return c.callback = s, c.facade;
+}
+var useIsomorphicLayoutEffect = typeof window < "u" ? import_react.useLayoutEffect : import_react.useEffect, currentValues = /* @__PURE__ */ new WeakMap();
+function useMergeRefs(r, s) {
+  var c = useCallbackRef(s || null, function(s2) {
+    return r.forEach(function(r2) {
+      return assignRef(r2, s2);
+    });
+  });
+  return useIsomorphicLayoutEffect(function() {
+    var s2 = currentValues.get(c);
+    if (s2) {
+      var l = new Set(s2), u = new Set(r), d = c.current;
+      l.forEach(function(r2) {
+        u.has(r2) || assignRef(r2, null);
+      }), u.forEach(function(r2) {
+        l.has(r2) || assignRef(r2, d);
+      });
+    }
+    currentValues.set(c, r);
+  }, [r]), c;
+}
+function ItoI(r) {
+  return r;
+}
+function innerCreateMedium(r, s) {
+  s === void 0 && (s = ItoI);
+  var c = [], l = false;
+  return {
+    read: function() {
+      if (l) throw Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.");
+      return c.length ? c[c.length - 1] : r;
+    },
+    useMedium: function(r2) {
+      var u = s(r2, l);
+      return c.push(u), function() {
+        c = c.filter(function(r3) {
+          return r3 !== u;
+        });
+      };
+    },
+    assignSyncMedium: function(r2) {
+      for (l = true; c.length; ) {
+        var s2 = c;
+        c = [], s2.forEach(r2);
+      }
+      c = {
+        push: function(s3) {
+          return r2(s3);
+        },
+        filter: function() {
+          return c;
+        }
+      };
+    },
+    assignMedium: function(r2) {
+      l = true;
+      var s2 = [];
+      if (c.length) {
+        var u = c;
+        c = [], u.forEach(r2), s2 = c;
+      }
+      var d = function() {
+        var c2 = s2;
+        s2 = [], c2.forEach(r2);
+      }, f = function() {
+        return Promise.resolve().then(d);
+      };
+      f(), c = {
+        push: function(r3) {
+          s2.push(r3), f();
+        },
+        filter: function(r3) {
+          return s2 = s2.filter(r3), c;
+        }
+      };
+    }
+  };
+}
+function createSidecarMedium(r) {
+  r === void 0 && (r = {});
+  var s = innerCreateMedium(null);
+  return s.options = __assign({
+    async: true,
+    ssr: false
+  }, r), s;
+}
+var SideCar = function(r) {
+  var s = r.sideCar, c = __rest(r, ["sideCar"]);
+  if (!s) throw Error("Sidecar: please provide `sideCar` property to import the right car");
+  var l = s.read();
+  if (!l) throw Error("Sidecar medium not found");
+  return import_react.createElement(l, __assign({}, c));
+};
+SideCar.isSideCarExport = true;
+function exportSidecar(r, s) {
+  return r.useMedium(s), SideCar;
+}
+var effectCar = createSidecarMedium(), nothing = function() {
+}, RemoveScroll = import_react.forwardRef(function(r, s) {
+  var c = import_react.useRef(null), l = import_react.useState({
+    onScrollCapture: nothing,
+    onWheelCapture: nothing,
+    onTouchMoveCapture: nothing
+  }), u = l[0], d = l[1], f = r.forwardProps, p = r.children, m = r.className, g = r.removeScrollBar, _ = r.enabled, v = r.shards, y = r.sideCar, b = r.noRelative, x = r.noIsolation, S = r.inert, C = r.allowPinchZoom, w = r.as, T = w === void 0 ? "div" : w, E = r.gapMode, D = __rest(r, [
+    "forwardProps",
+    "children",
+    "className",
+    "removeScrollBar",
+    "enabled",
+    "shards",
+    "sideCar",
+    "noRelative",
+    "noIsolation",
+    "inert",
+    "allowPinchZoom",
+    "as",
+    "gapMode"
+  ]), O = y, k = useMergeRefs([c, s]), A = __assign(__assign({}, D), u);
+  return import_react.createElement(import_react.Fragment, null, _ && import_react.createElement(O, {
+    sideCar: effectCar,
+    removeScrollBar: g,
+    shards: v,
+    noRelative: b,
+    noIsolation: x,
+    inert: S,
+    setCallbacks: d,
+    allowPinchZoom: !!C,
+    lockRef: c,
+    gapMode: E
+  }), f ? import_react.cloneElement(import_react.Children.only(p), __assign(__assign({}, A), { ref: k })) : import_react.createElement(T, __assign({}, A, {
+    className: m,
+    ref: k
+  }), p));
+});
+RemoveScroll.defaultProps = {
+  enabled: true,
+  removeScrollBar: true,
+  inert: false
+}, RemoveScroll.classNames = {
+  fullWidth: fullWidthClassName,
+  zeroRight: zeroRightClassName
+};
+var currentNonce, getNonce = function() {
+  if (currentNonce) return currentNonce;
+  if (typeof __webpack_nonce__ < "u") return __webpack_nonce__;
+};
+function makeStyleTag() {
+  if (!document) return null;
+  var r = document.createElement("style");
+  r.type = "text/css";
+  var s = getNonce();
+  return s && r.setAttribute("nonce", s), r;
+}
+function injectStyles(r, s) {
+  r.styleSheet ? r.styleSheet.cssText = s : r.appendChild(document.createTextNode(s));
+}
+function insertStyleTag(r) {
+  (document.head || document.getElementsByTagName("head")[0]).appendChild(r);
+}
+var stylesheetSingleton = function() {
+  var r = 0, s = null;
+  return {
+    add: function(c) {
+      r == 0 && (s = makeStyleTag()) && (injectStyles(s, c), insertStyleTag(s)), r++;
+    },
+    remove: function() {
+      r--, !r && s && (s.parentNode && s.parentNode.removeChild(s), s = null);
+    }
+  };
+}, styleHookSingleton = function() {
+  var r = stylesheetSingleton();
+  return function(s, c) {
+    import_react.useEffect(function() {
+      return r.add(s), function() {
+        r.remove();
+      };
+    }, [s && c]);
+  };
+}, styleSingleton = function() {
+  var r = styleHookSingleton();
+  return function(s) {
+    var c = s.styles, l = s.dynamic;
+    return r(c, l), null;
+  };
+}, zeroGap = {
+  left: 0,
+  top: 0,
+  right: 0,
+  gap: 0
+}, parse = function(r) {
+  return parseInt(r || "", 10) || 0;
+}, getOffset = function(r) {
+  var s = window.getComputedStyle(document.body), c = s[r === "padding" ? "paddingLeft" : "marginLeft"], l = s[r === "padding" ? "paddingTop" : "marginTop"], u = s[r === "padding" ? "paddingRight" : "marginRight"];
+  return [
+    parse(c),
+    parse(l),
+    parse(u)
+  ];
+}, getGapWidth = function(r) {
+  if (r === void 0 && (r = "margin"), typeof window > "u") return zeroGap;
+  var s = getOffset(r), c = document.documentElement.clientWidth, l = window.innerWidth;
+  return {
+    left: s[0],
+    top: s[1],
+    right: s[2],
+    gap: Math.max(0, l - c + s[2] - s[0])
+  };
+}, Style = styleSingleton(), lockAttribute = "data-scroll-locked", getStyles = function(r, s, c, l) {
+  var u = r.left, d = r.top, f = r.right, p = r.gap;
+  return c === void 0 && (c = "margin"), `
+  .${noScrollbarsClassName} {
+   overflow: hidden ${l};
+   padding-right: ${p}px ${l};
+  }
+  body[${lockAttribute}] {
+    overflow: hidden ${l};
+    overscroll-behavior: contain;
+    ${[
+    s && `position: relative ${l};`,
+    c === "margin" && `
+    padding-left: ${u}px;
+    padding-top: ${d}px;
+    padding-right: ${f}px;
+    margin-left:0;
+    margin-top:0;
+    margin-right: ${p}px ${l};
+    `,
+    c === "padding" && `padding-right: ${p}px ${l};`
+  ].filter(Boolean).join("")}
+  }
+  
+  .${zeroRightClassName} {
+    right: ${p}px ${l};
+  }
+  
+  .${fullWidthClassName} {
+    margin-right: ${p}px ${l};
+  }
+  
+  .${zeroRightClassName} .${zeroRightClassName} {
+    right: 0 ${l};
+  }
+  
+  .${fullWidthClassName} .${fullWidthClassName} {
+    margin-right: 0 ${l};
+  }
+  
+  body[${lockAttribute}] {
+    ${removedBarSizeVariable}: ${p}px;
+  }
+`;
+}, getCurrentUseCounter = function() {
+  var r = parseInt(document.body.getAttribute("data-scroll-locked") || "0", 10);
+  return isFinite(r) ? r : 0;
+}, useLockAttribute = function() {
+  import_react.useEffect(function() {
+    return document.body.setAttribute(lockAttribute, (getCurrentUseCounter() + 1).toString()), function() {
+      var r = getCurrentUseCounter() - 1;
+      r <= 0 ? document.body.removeAttribute(lockAttribute) : document.body.setAttribute(lockAttribute, r.toString());
+    };
+  }, []);
+}, RemoveScrollBar = function(r) {
+  var s = r.noRelative, c = r.noImportant, l = r.gapMode, u = l === void 0 ? "margin" : l;
+  useLockAttribute();
+  var d = import_react.useMemo(function() {
+    return getGapWidth(u);
+  }, [u]);
+  return import_react.createElement(Style, { styles: getStyles(d, !s, u, c ? "" : "!important") });
+}, passiveSupported = false;
+if (typeof window < "u") try {
+  var options = Object.defineProperty({}, "passive", { get: function() {
+    return passiveSupported = true, true;
+  } });
+  window.addEventListener("test", options, options), window.removeEventListener("test", options, options);
+} catch {
+  passiveSupported = false;
+}
+var nonPassive = passiveSupported ? { passive: false } : false, alwaysContainsScroll = function(r) {
+  return r.tagName === "TEXTAREA";
+}, elementCanBeScrolled = function(r, s) {
+  if (!(r instanceof Element)) return false;
+  var c = window.getComputedStyle(r);
+  return c[s] !== "hidden" && !(c.overflowY === c.overflowX && !alwaysContainsScroll(r) && c[s] === "visible");
+}, elementCouldBeVScrolled = function(r) {
+  return elementCanBeScrolled(r, "overflowY");
+}, elementCouldBeHScrolled = function(r) {
+  return elementCanBeScrolled(r, "overflowX");
+}, locationCouldBeScrolled = function(r, s) {
+  var c = s.ownerDocument, l = s;
+  do {
+    if (typeof ShadowRoot < "u" && l instanceof ShadowRoot && (l = l.host), elementCouldBeScrolled(r, l)) {
+      var u = getScrollVariables(r, l);
+      if (u[1] > u[2]) return true;
+    }
+    l = l.parentNode;
+  } while (l && l !== c.body);
+  return false;
+}, getVScrollVariables = function(r) {
+  return [
+    r.scrollTop,
+    r.scrollHeight,
+    r.clientHeight
+  ];
+}, getHScrollVariables = function(r) {
+  return [
+    r.scrollLeft,
+    r.scrollWidth,
+    r.clientWidth
+  ];
+}, elementCouldBeScrolled = function(r, s) {
+  return r === "v" ? elementCouldBeVScrolled(s) : elementCouldBeHScrolled(s);
+}, getScrollVariables = function(r, s) {
+  return r === "v" ? getVScrollVariables(s) : getHScrollVariables(s);
+}, getDirectionFactor = function(r, s) {
+  return r === "h" && s === "rtl" ? -1 : 1;
+}, handleScroll = function(r, s, c, l, u) {
+  var d = getDirectionFactor(r, window.getComputedStyle(s).direction), f = d * l, p = c.target, m = s.contains(p), h = false, g = f > 0, _ = 0, v = 0;
+  do {
+    if (!p) break;
+    var y = getScrollVariables(r, p), b = y[0], x = y[1] - y[2] - d * b;
+    (b || x) && elementCouldBeScrolled(r, p) && (_ += x, v += b);
+    var S = p.parentNode;
+    p = S && S.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? S.host : S;
+  } while (!m && p !== document.body || m && (s.contains(p) || s === p));
+  return (g && (u && Math.abs(_) < 1 || !u && f > _) || !g && (u && Math.abs(v) < 1 || !u && -f > v)) && (h = true), h;
+}, getTouchXY = function(r) {
+  return "changedTouches" in r ? [r.changedTouches[0].clientX, r.changedTouches[0].clientY] : [0, 0];
+}, getDeltaXY = function(r) {
+  return [r.deltaX, r.deltaY];
+}, extractRef = function(r) {
+  return r && "current" in r ? r.current : r;
+}, deltaCompare = function(r, s) {
+  return r[0] === s[0] && r[1] === s[1];
+}, generateStyle = function(r) {
+  return `
+  .block-interactivity-${r} {pointer-events: none;}
+  .allow-interactivity-${r} {pointer-events: all;}
+`;
+}, idCounter = 0, lockStack = [];
+function RemoveScrollSideCar(r) {
+  var s = import_react.useRef([]), c = import_react.useRef([0, 0]), l = import_react.useRef(), u = import_react.useState(idCounter++)[0], d = import_react.useState(styleSingleton)[0], f = import_react.useRef(r);
+  import_react.useEffect(function() {
+    f.current = r;
+  }, [r]), import_react.useEffect(function() {
+    if (r.inert) {
+      document.body.classList.add(`block-interactivity-${u}`);
+      var s2 = __spreadArray([r.lockRef.current], (r.shards || []).map(extractRef), true).filter(Boolean);
+      return s2.forEach(function(r2) {
+        return r2.classList.add(`allow-interactivity-${u}`);
+      }), function() {
+        document.body.classList.remove(`block-interactivity-${u}`), s2.forEach(function(r2) {
+          return r2.classList.remove(`allow-interactivity-${u}`);
+        });
+      };
+    }
+  }, [
+    r.inert,
+    r.lockRef.current,
+    r.shards
+  ]);
+  var p = import_react.useCallback(function(r2, s2) {
+    if ("touches" in r2 && r2.touches.length === 2 || r2.type === "wheel" && r2.ctrlKey) return !f.current.allowPinchZoom;
+    var u2 = getTouchXY(r2), d2 = c.current, p2 = "deltaX" in r2 ? r2.deltaX : d2[0] - u2[0], m2 = "deltaY" in r2 ? r2.deltaY : d2[1] - u2[1], h, g2 = r2.target, _2 = Math.abs(p2) > Math.abs(m2) ? "h" : "v";
+    if ("touches" in r2 && _2 === "h" && g2.type === "range") return false;
+    var v2 = locationCouldBeScrolled(_2, g2);
+    if (!v2) return true;
+    if (v2 ? h = _2 : (h = _2 === "v" ? "h" : "v", v2 = locationCouldBeScrolled(_2, g2)), !v2) return false;
+    if (!l.current && "changedTouches" in r2 && (p2 || m2) && (l.current = h), !h) return true;
+    var y2 = l.current || h;
+    return handleScroll(y2, s2, r2, y2 === "h" ? p2 : m2, true);
+  }, []), m = import_react.useCallback(function(r2) {
+    var c2 = r2;
+    if (!(!lockStack.length || lockStack[lockStack.length - 1] !== d)) {
+      var l2 = "deltaY" in c2 ? getDeltaXY(c2) : getTouchXY(c2), u2 = s.current.filter(function(r3) {
+        return r3.name === c2.type && (r3.target === c2.target || c2.target === r3.shadowParent) && deltaCompare(r3.delta, l2);
+      })[0];
+      if (u2 && u2.should) {
+        c2.cancelable && c2.preventDefault();
+        return;
+      }
+      if (!u2) {
+        var m2 = (f.current.shards || []).map(extractRef).filter(Boolean).filter(function(r3) {
+          return r3.contains(c2.target);
+        });
+        (m2.length > 0 ? p(c2, m2[0]) : !f.current.noIsolation) && c2.cancelable && c2.preventDefault();
+      }
+    }
+  }, []), g = import_react.useCallback(function(r2, c2, l2, u2) {
+    var d2 = {
+      name: r2,
+      delta: c2,
+      target: l2,
+      should: u2,
+      shadowParent: getOutermostShadowParent(l2)
+    };
+    s.current.push(d2), setTimeout(function() {
+      s.current = s.current.filter(function(r3) {
+        return r3 !== d2;
+      });
+    }, 1);
+  }, []), _ = import_react.useCallback(function(r2) {
+    c.current = getTouchXY(r2), l.current = void 0;
+  }, []), v = import_react.useCallback(function(s2) {
+    g(s2.type, getDeltaXY(s2), s2.target, p(s2, r.lockRef.current));
+  }, []), y = import_react.useCallback(function(s2) {
+    g(s2.type, getTouchXY(s2), s2.target, p(s2, r.lockRef.current));
+  }, []);
+  import_react.useEffect(function() {
+    return lockStack.push(d), r.setCallbacks({
+      onScrollCapture: v,
+      onWheelCapture: v,
+      onTouchMoveCapture: y
+    }), document.addEventListener("wheel", m, nonPassive), document.addEventListener("touchmove", m, nonPassive), document.addEventListener("touchstart", _, nonPassive), function() {
+      lockStack = lockStack.filter(function(r2) {
+        return r2 !== d;
+      }), document.removeEventListener("wheel", m, nonPassive), document.removeEventListener("touchmove", m, nonPassive), document.removeEventListener("touchstart", _, nonPassive);
+    };
+  }, []);
+  var b = r.removeScrollBar, x = r.inert;
+  return import_react.createElement(import_react.Fragment, null, x ? import_react.createElement(d, { styles: generateStyle(u) }) : null, b ? import_react.createElement(RemoveScrollBar, {
+    noRelative: r.noRelative,
+    gapMode: r.gapMode
+  }) : null);
+}
+function getOutermostShadowParent(r) {
+  for (var s = null; r !== null; ) r instanceof ShadowRoot && (s = r.host, r = r.host), r = r.parentNode;
+  return s;
+}
+var sidecar_default = exportSidecar(effectCar, RemoveScrollSideCar), ReactRemoveScroll = import_react.forwardRef(function(r, s) {
+  return import_react.createElement(RemoveScroll, __assign({}, r, {
+    ref: s,
+    sideCar: sidecar_default
+  }));
+});
+ReactRemoveScroll.classNames = RemoveScroll.classNames;
+var Combination_default = ReactRemoveScroll;
+export {
+  createContext2 as A,
+  useLayoutEffect2 as C,
+  dispatchDiscreteCustomEvent as D,
+  Primitive as E,
+  composeEventHandlers as M,
+  createSlot as O,
+  useId as S,
+  useCallbackRef$1 as T,
+  Arrow as _,
+  __awaiter as a,
+  createPopperScope as b,
+  withSmartCollisionBoundary as c,
+  Root as d,
+  VISUALLY_HIDDEN_STYLES as f,
+  Anchor as g,
+  Portal as h,
+  useFocusGuards as i,
+  createContextScope as j,
+  createSlottable as k,
+  isInVscodeExtension as l,
+  Presence as m,
+  hideOthers as n,
+  MAX_HEIGHT_OFFSET as o,
+  useControllableState as p,
+  FocusScope as r,
+  withFullScreenAsRoot as s,
+  Combination_default as t,
+  StyleNamespace as u,
+  Content as v,
+  DismissableLayer as w,
+  useSize as x,
+  Root2 as y
+};