@altinn/altinn-components 0.52.3 → 0.52.4

package/dist/index-Dg71_7ad.js

@@ -0,0 +1,2993 @@
+"use client";
+import { jsx as Oe } from "react/jsx-runtime";
+import { c as Ln } from "./lite-1fxw3LjI.js";
+import * as m from "react";
+import { useLayoutEffect as kn, useEffect as Vn, useRef as yr, createContext as jt, useReducer as Rr, useContext as Ut, forwardRef as Qe, useId as Er, useMemo as Cr, isValidElement as Ir } from "react";
+import { B as _n } from "./button-MzZgmHyA.js";
+import * as $n from "react-dom";
+import { S as Sr } from "./index-D7FJjvrv.js";
+import { L as Tr } from "./label-xTmTyPhk.js";
+import { I as Ar } from "./input-wBv_FkEV.js";
+const sn = (e, t) => {
+  const n = {}, r = {};
+  let o = 0;
+  const i = e.length;
+  for (; o < i; )
+    r[e[o]] = 1, o += 1;
+  for (const s in t)
+    Object.hasOwn(r, s) || (n[s] = t[s]);
+  return n;
+};
+function Et() {
+  return typeof window < "u";
+}
+function Ct(e) {
+  return Bn(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function et(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function Or(e) {
+  var t;
+  return (t = (Bn(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Bn(e) {
+  return Et() ? e instanceof Node || e instanceof et(e).Node : !1;
+}
+function ce(e) {
+  return Et() ? e instanceof Element || e instanceof et(e).Element : !1;
+}
+function xe(e) {
+  return Et() ? e instanceof HTMLElement || e instanceof et(e).HTMLElement : !1;
+}
+function Bt(e) {
+  return !Et() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof et(e).ShadowRoot;
+}
+function cn(e) {
+  return ["html", "body", "#document"].includes(Ct(e));
+}
+function Mr(e) {
+  return et(e).getComputedStyle(e);
+}
+function Dr(e) {
+  if (Ct(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    Bt(e) && e.host || // Fallback.
+    Or(e)
+  );
+  return Bt(t) ? t.host : t;
+}
+function we(e) {
+  let t = e.activeElement;
+  for (; ((n = t) == null || (n = n.shadowRoot) == null ? void 0 : n.activeElement) != null; ) {
+    var n;
+    t = t.shadowRoot.activeElement;
+  }
+  return t;
+}
+function ee(e, t) {
+  if (!e || !t)
+    return !1;
+  const n = t.getRootNode == null ? void 0 : t.getRootNode();
+  if (e.contains(t))
+    return !0;
+  if (n && Bt(n)) {
+    let r = t;
+    for (; r; ) {
+      if (e === r)
+        return !0;
+      r = r.parentNode || r.host;
+    }
+  }
+  return !1;
+}
+function Wn() {
+  const e = navigator.userAgentData;
+  return e != null && e.platform ? e.platform : navigator.platform;
+}
+function Kn() {
+  const e = navigator.userAgentData;
+  return e && Array.isArray(e.brands) ? e.brands.map((t) => {
+    let {
+      brand: n,
+      version: r
+    } = t;
+    return n + "/" + r;
+  }).join(" ") : navigator.userAgent;
+}
+function Hn(e) {
+  return e.mozInputSource === 0 && e.isTrusted ? !0 : Wt() && e.pointerType ? e.type === "click" && e.buttons === 1 : e.detail === 0 && !e.pointerType;
+}
+function zn(e) {
+  return Fr() ? !1 : !Wt() && e.width === 0 && e.height === 0 || Wt() && e.width === 1 && e.height === 1 && e.pressure === 0 && e.detail === 0 && e.pointerType === "mouse" || // iOS VoiceOver returns 0.333• for width/height.
+  e.width < 1 && e.height < 1 && e.pressure === 0 && e.detail === 0 && e.pointerType === "touch";
+}
+function qn() {
+  return /apple/i.test(navigator.vendor);
+}
+function Wt() {
+  const e = /android/i;
+  return e.test(Wn()) || e.test(Kn());
+}
+function Pr() {
+  return Wn().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function Fr() {
+  return Kn().includes("jsdom/");
+}
+function Nr(e) {
+  return "nativeEvent" in e;
+}
+function Lr(e) {
+  return e.matches("html,body");
+}
+function oe(e) {
+  return e?.ownerDocument || document;
+}
+function Dt(e, t) {
+  if (t == null)
+    return !1;
+  if ("composedPath" in e)
+    return e.composedPath().includes(t);
+  const n = e;
+  return n.target != null && t.contains(n.target);
+}
+function Ne(e) {
+  return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+const kr = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function Vr(e) {
+  return xe(e) && e.matches(kr);
+}
+function te(e) {
+  e.preventDefault(), e.stopPropagation();
+}
+function jn(e) {
+  return e ? e.getAttribute("role") === "combobox" && Vr(e) : !1;
+}
+const ln = Math.floor;
+var _r = ["input:not([inert])", "select:not([inert])", "textarea:not([inert])", "a[href]:not([inert])", "button:not([inert])", "[tabindex]:not(slot):not([inert])", "audio[controls]:not([inert])", "video[controls]:not([inert])", '[contenteditable]:not([contenteditable="false"]):not([inert])', "details>summary:first-of-type:not([inert])", "details:not([inert])"], gt = /* @__PURE__ */ _r.join(","), Un = typeof Element > "u", $e = Un ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, pt = !Un && Element.prototype.getRootNode ? function(e) {
+  var t;
+  return e == null || (t = e.getRootNode) === null || t === void 0 ? void 0 : t.call(e);
+} : function(e) {
+  return e?.ownerDocument;
+}, ht = function e(t, n) {
+  var r;
+  n === void 0 && (n = !0);
+  var o = t == null || (r = t.getAttribute) === null || r === void 0 ? void 0 : r.call(t, "inert"), i = o === "" || o === "true", s = i || n && t && e(t.parentNode);
+  return s;
+}, $r = function(t) {
+  var n, r = t == null || (n = t.getAttribute) === null || n === void 0 ? void 0 : n.call(t, "contenteditable");
+  return r === "" || r === "true";
+}, Br = function(t, n, r) {
+  if (ht(t))
+    return [];
+  var o = Array.prototype.slice.apply(t.querySelectorAll(gt));
+  return n && $e.call(t, gt) && o.unshift(t), o = o.filter(r), o;
+}, Wr = function e(t, n, r) {
+  for (var o = [], i = Array.from(t); i.length; ) {
+    var s = i.shift();
+    if (!ht(s, !1))
+      if (s.tagName === "SLOT") {
+        var l = s.assignedElements(), a = l.length ? l : s.children, c = e(a, !0, r);
+        r.flatten ? o.push.apply(o, c) : o.push({
+          scopeParent: s,
+          candidates: c
+        });
+      } else {
+        var d = $e.call(s, gt);
+        d && r.filter(s) && (n || !t.includes(s)) && o.push(s);
+        var u = s.shadowRoot || // check for an undisclosed shadow
+        typeof r.getShadowRoot == "function" && r.getShadowRoot(s), p = !ht(u, !1) && (!r.shadowRootFilter || r.shadowRootFilter(s));
+        if (u && p) {
+          var f = e(u === !0 ? s.children : u.children, !0, r);
+          r.flatten ? o.push.apply(o, f) : o.push({
+            scopeParent: s,
+            candidates: f
+          });
+        } else
+          i.unshift.apply(i, s.children);
+      }
+  }
+  return o;
+}, Xn = function(t) {
+  return !isNaN(parseInt(t.getAttribute("tabindex"), 10));
+}, Yn = function(t) {
+  if (!t)
+    throw new Error("No node provided");
+  return t.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(t.tagName) || $r(t)) && !Xn(t) ? 0 : t.tabIndex;
+}, Kr = function(t, n) {
+  var r = Yn(t);
+  return r < 0 && n && !Xn(t) ? 0 : r;
+}, Hr = function(t, n) {
+  return t.tabIndex === n.tabIndex ? t.documentOrder - n.documentOrder : t.tabIndex - n.tabIndex;
+}, Gn = function(t) {
+  return t.tagName === "INPUT";
+}, zr = function(t) {
+  return Gn(t) && t.type === "hidden";
+}, qr = function(t) {
+  var n = t.tagName === "DETAILS" && Array.prototype.slice.apply(t.children).some(function(r) {
+    return r.tagName === "SUMMARY";
+  });
+  return n;
+}, jr = function(t, n) {
+  for (var r = 0; r < t.length; r++)
+    if (t[r].checked && t[r].form === n)
+      return t[r];
+}, Ur = function(t) {
+  if (!t.name)
+    return !0;
+  var n = t.form || pt(t), r = function(l) {
+    return n.querySelectorAll('input[type="radio"][name="' + l + '"]');
+  }, o;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    o = r(window.CSS.escape(t.name));
+  else
+    try {
+      o = r(t.name);
+    } catch (s) {
+      return console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", s.message), !1;
+    }
+  var i = jr(o, t.form);
+  return !i || i === t;
+}, Xr = function(t) {
+  return Gn(t) && t.type === "radio";
+}, Yr = function(t) {
+  return Xr(t) && !Ur(t);
+}, Gr = function(t) {
+  var n, r = t && pt(t), o = (n = r) === null || n === void 0 ? void 0 : n.host, i = !1;
+  if (r && r !== t) {
+    var s, l, a;
+    for (i = !!((s = o) !== null && s !== void 0 && (l = s.ownerDocument) !== null && l !== void 0 && l.contains(o) || t != null && (a = t.ownerDocument) !== null && a !== void 0 && a.contains(t)); !i && o; ) {
+      var c, d, u;
+      r = pt(o), o = (c = r) === null || c === void 0 ? void 0 : c.host, i = !!((d = o) !== null && d !== void 0 && (u = d.ownerDocument) !== null && u !== void 0 && u.contains(o));
+    }
+  }
+  return i;
+}, an = function(t) {
+  var n = t.getBoundingClientRect(), r = n.width, o = n.height;
+  return r === 0 && o === 0;
+}, Zr = function(t, n) {
+  var r = n.displayCheck, o = n.getShadowRoot;
+  if (getComputedStyle(t).visibility === "hidden")
+    return !0;
+  var i = $e.call(t, "details>summary:first-of-type"), s = i ? t.parentElement : t;
+  if ($e.call(s, "details:not([open]) *"))
+    return !0;
+  if (!r || r === "full" || r === "legacy-full") {
+    if (typeof o == "function") {
+      for (var l = t; t; ) {
+        var a = t.parentElement, c = pt(t);
+        if (a && !a.shadowRoot && o(a) === !0)
+          return an(t);
+        t.assignedSlot ? t = t.assignedSlot : !a && c !== t.ownerDocument ? t = c.host : t = a;
+      }
+      t = l;
+    }
+    if (Gr(t))
+      return !t.getClientRects().length;
+    if (r !== "legacy-full")
+      return !0;
+  } else if (r === "non-zero-area")
+    return an(t);
+  return !1;
+}, Jr = function(t) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(t.tagName))
+    for (var n = t.parentElement; n; ) {
+      if (n.tagName === "FIELDSET" && n.disabled) {
+        for (var r = 0; r < n.children.length; r++) {
+          var o = n.children.item(r);
+          if (o.tagName === "LEGEND")
+            return $e.call(n, "fieldset[disabled] *") ? !0 : !o.contains(t);
+        }
+        return !0;
+      }
+      n = n.parentElement;
+    }
+  return !1;
+}, Qr = function(t, n) {
+  return !(n.disabled || // we must do an inert look up to filter out any elements inside an inert ancestor
+  //  because we're limited in the type of selectors we can use in JSDom (see related
+  //  note related to `candidateSelectors`)
+  ht(n) || zr(n) || Zr(n, t) || // For a details element with a summary, the summary element gets the focus
+  qr(n) || Jr(n));
+}, Kt = function(t, n) {
+  return !(Yr(n) || Yn(n) < 0 || !Qr(t, n));
+}, eo = function(t) {
+  var n = parseInt(t.getAttribute("tabindex"), 10);
+  return !!(isNaN(n) || n >= 0);
+}, to = function e(t) {
+  var n = [], r = [];
+  return t.forEach(function(o, i) {
+    var s = !!o.scopeParent, l = s ? o.scopeParent : o, a = Kr(l, s), c = s ? e(o.candidates) : l;
+    a === 0 ? s ? n.push.apply(n, c) : n.push(l) : r.push({
+      documentOrder: i,
+      tabIndex: a,
+      item: o,
+      isScope: s,
+      content: c
+    });
+  }), r.sort(Hr).reduce(function(o, i) {
+    return i.isScope ? o.push.apply(o, i.content) : o.push(i.content), o;
+  }, []).concat(n);
+}, Ze = function(t, n) {
+  n = n || {};
+  var r;
+  return n.getShadowRoot ? r = Wr([t], n.includeContainer, {
+    filter: Kt.bind(null, n),
+    flatten: !1,
+    getShadowRoot: n.getShadowRoot,
+    shadowRootFilter: eo
+  }) : r = Br(t, n.includeContainer, Kt.bind(null, n)), to(r);
+}, no = function(t, n) {
+  if (n = n || {}, !t)
+    throw new Error("No node provided");
+  return $e.call(t, gt) === !1 ? !1 : Kt(n, t);
+};
+const Be = Math.min, ie = Math.max, bt = Math.round, lt = Math.floor, pe = (e) => ({
+  x: e,
+  y: e
+}), ro = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, oo = {
+  start: "end",
+  end: "start"
+};
+function un(e, t, n) {
+  return ie(e, Be(t, n));
+}
+function tt(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Me(e) {
+  return e.split("-")[0];
+}
+function nt(e) {
+  return e.split("-")[1];
+}
+function Zn(e) {
+  return e === "x" ? "y" : "x";
+}
+function Jn(e) {
+  return e === "y" ? "height" : "width";
+}
+const io = /* @__PURE__ */ new Set(["top", "bottom"]);
+function ye(e) {
+  return io.has(Me(e)) ? "y" : "x";
+}
+function Qn(e) {
+  return Zn(ye(e));
+}
+function so(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = nt(e), o = Qn(e), i = Jn(o);
+  let s = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = vt(s)), [s, vt(s)];
+}
+function co(e) {
+  const t = vt(e);
+  return [Ht(e), t, Ht(t)];
+}
+function Ht(e) {
+  return e.replace(/start|end/g, (t) => oo[t]);
+}
+const fn = ["left", "right"], dn = ["right", "left"], lo = ["top", "bottom"], ao = ["bottom", "top"];
+function uo(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? dn : fn : t ? fn : dn;
+    case "left":
+    case "right":
+      return t ? lo : ao;
+    default:
+      return [];
+  }
+}
+function fo(e, t, n, r) {
+  const o = nt(e);
+  let i = uo(Me(e), n === "start", r);
+  return o && (i = i.map((s) => s + "-" + o), t && (i = i.concat(i.map(Ht)))), i;
+}
+function vt(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => ro[t]);
+}
+function mo(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function go(e) {
+  return typeof e != "number" ? mo(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function xt(e) {
+  const {
+    x: t,
+    y: n,
+    width: r,
+    height: o
+  } = e;
+  return {
+    width: r,
+    height: o,
+    top: n,
+    left: t,
+    right: t + r,
+    bottom: n + o,
+    x: t,
+    y: n
+  };
+}
+function mn(e, t, n) {
+  let {
+    reference: r,
+    floating: o
+  } = e;
+  const i = ye(t), s = Qn(t), l = Jn(s), a = Me(t), c = i === "y", d = r.x + r.width / 2 - o.width / 2, u = r.y + r.height / 2 - o.height / 2, p = r[l] / 2 - o[l] / 2;
+  let f;
+  switch (a) {
+    case "top":
+      f = {
+        x: d,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      f = {
+        x: d,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      f = {
+        x: r.x + r.width,
+        y: u
+      };
+      break;
+    case "left":
+      f = {
+        x: r.x - o.width,
+        y: u
+      };
+      break;
+    default:
+      f = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (nt(t)) {
+    case "start":
+      f[s] -= p * (n && c ? -1 : 1);
+      break;
+    case "end":
+      f[s] += p * (n && c ? -1 : 1);
+      break;
+  }
+  return f;
+}
+const po = async (e, t, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: i = [],
+    platform: s
+  } = n, l = i.filter(Boolean), a = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let c = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: d,
+    y: u
+  } = mn(c, r, a), p = r, f = {}, g = 0;
+  for (let h = 0; h < l.length; h++) {
+    const {
+      name: x,
+      fn: v
+    } = l[h], {
+      x: R,
+      y: b,
+      data: y,
+      reset: P
+    } = await v({
+      x: d,
+      y: u,
+      initialPlacement: r,
+      placement: p,
+      strategy: o,
+      middlewareData: f,
+      rects: c,
+      platform: s,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    d = R ?? d, u = b ?? u, f = {
+      ...f,
+      [x]: {
+        ...f[x],
+        ...y
+      }
+    }, P && g <= 50 && (g++, typeof P == "object" && (P.placement && (p = P.placement), P.rects && (c = P.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : P.rects), {
+      x: d,
+      y: u
+    } = mn(c, p, a)), h = -1);
+  }
+  return {
+    x: d,
+    y: u,
+    placement: p,
+    strategy: o,
+    middlewareData: f
+  };
+};
+async function Xt(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: r,
+    y: o,
+    platform: i,
+    rects: s,
+    elements: l,
+    strategy: a
+  } = e, {
+    boundary: c = "clippingAncestors",
+    rootBoundary: d = "viewport",
+    elementContext: u = "floating",
+    altBoundary: p = !1,
+    padding: f = 0
+  } = tt(t, e), g = go(f), x = l[p ? u === "floating" ? "reference" : "floating" : u], v = xt(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(x))) == null || n ? x : x.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(l.floating)),
+    boundary: c,
+    rootBoundary: d,
+    strategy: a
+  })), R = u === "floating" ? {
+    x: r,
+    y: o,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, b = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(l.floating)), y = await (i.isElement == null ? void 0 : i.isElement(b)) ? await (i.getScale == null ? void 0 : i.getScale(b)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, P = xt(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: R,
+    offsetParent: b,
+    strategy: a
+  }) : R);
+  return {
+    top: (v.top - P.top + g.top) / y.y,
+    bottom: (P.bottom - v.bottom + g.bottom) / y.y,
+    left: (v.left - P.left + g.left) / y.x,
+    right: (P.right - v.right + g.right) / y.x
+  };
+}
+const ho = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        middlewareData: i,
+        rects: s,
+        initialPlacement: l,
+        platform: a,
+        elements: c
+      } = t, {
+        mainAxis: d = !0,
+        crossAxis: u = !0,
+        fallbackPlacements: p,
+        fallbackStrategy: f = "bestFit",
+        fallbackAxisSideDirection: g = "none",
+        flipAlignment: h = !0,
+        ...x
+      } = tt(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const v = Me(o), R = ye(l), b = Me(l) === l, y = await (a.isRTL == null ? void 0 : a.isRTL(c.floating)), P = p || (b || !h ? [vt(l)] : co(l)), N = g !== "none";
+      !p && N && P.push(...fo(l, h, g, y));
+      const $ = [l, ...P], _ = await Xt(t, x), Y = [];
+      let K = ((r = i.flip) == null ? void 0 : r.overflows) || [];
+      if (d && Y.push(_[v]), u) {
+        const S = so(o, s, y);
+        Y.push(_[S[0]], _[S[1]]);
+      }
+      if (K = [...K, {
+        placement: o,
+        overflows: Y
+      }], !Y.every((S) => S <= 0)) {
+        var W, I;
+        const S = (((W = i.flip) == null ? void 0 : W.index) || 0) + 1, w = $[S];
+        if (w && (!(u === "alignment" ? R !== ye(w) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        K.every((E) => ye(E.placement) === R ? E.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: S,
+              overflows: K
+            },
+            reset: {
+              placement: w
+            }
+          };
+        let O = (I = K.filter((D) => D.overflows[0] <= 0).sort((D, E) => D.overflows[1] - E.overflows[1])[0]) == null ? void 0 : I.placement;
+        if (!O)
+          switch (f) {
+            case "bestFit": {
+              var L;
+              const D = (L = K.filter((E) => {
+                if (N) {
+                  const C = ye(E.placement);
+                  return C === R || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  C === "y";
+                }
+                return !0;
+              }).map((E) => [E.placement, E.overflows.filter((C) => C > 0).reduce((C, B) => C + B, 0)]).sort((E, C) => E[1] - C[1])[0]) == null ? void 0 : L[0];
+              D && (O = D);
+              break;
+            }
+            case "initialPlacement":
+              O = l;
+              break;
+          }
+        if (o !== O)
+          return {
+            reset: {
+              placement: O
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, bo = /* @__PURE__ */ new Set(["left", "top"]);
+async function vo(e, t) {
+  const {
+    placement: n,
+    platform: r,
+    elements: o
+  } = e, i = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), s = Me(n), l = nt(n), a = ye(n) === "y", c = bo.has(s) ? -1 : 1, d = i && a ? -1 : 1, u = tt(t, e);
+  let {
+    mainAxis: p,
+    crossAxis: f,
+    alignmentAxis: g
+  } = typeof u == "number" ? {
+    mainAxis: u,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: u.mainAxis || 0,
+    crossAxis: u.crossAxis || 0,
+    alignmentAxis: u.alignmentAxis
+  };
+  return l && typeof g == "number" && (f = l === "end" ? g * -1 : g), a ? {
+    x: f * d,
+    y: p * c
+  } : {
+    x: p * c,
+    y: f * d
+  };
+}
+const xo = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        x: o,
+        y: i,
+        placement: s,
+        middlewareData: l
+      } = t, a = await vo(t, e);
+      return s === ((n = l.offset) == null ? void 0 : n.placement) && (r = l.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + a.x,
+        y: i + a.y,
+        data: {
+          ...a,
+          placement: s
+        }
+      };
+    }
+  };
+}, wo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: r,
+        placement: o
+      } = t, {
+        mainAxis: i = !0,
+        crossAxis: s = !1,
+        limiter: l = {
+          fn: (x) => {
+            let {
+              x: v,
+              y: R
+            } = x;
+            return {
+              x: v,
+              y: R
+            };
+          }
+        },
+        ...a
+      } = tt(e, t), c = {
+        x: n,
+        y: r
+      }, d = await Xt(t, a), u = ye(Me(o)), p = Zn(u);
+      let f = c[p], g = c[u];
+      if (i) {
+        const x = p === "y" ? "top" : "left", v = p === "y" ? "bottom" : "right", R = f + d[x], b = f - d[v];
+        f = un(R, f, b);
+      }
+      if (s) {
+        const x = u === "y" ? "top" : "left", v = u === "y" ? "bottom" : "right", R = g + d[x], b = g - d[v];
+        g = un(R, g, b);
+      }
+      const h = l.fn({
+        ...t,
+        [p]: f,
+        [u]: g
+      });
+      return {
+        ...h,
+        data: {
+          x: h.x - n,
+          y: h.y - r,
+          enabled: {
+            [p]: i,
+            [u]: s
+          }
+        }
+      };
+    }
+  };
+}, yo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        rects: i,
+        platform: s,
+        elements: l
+      } = t, {
+        apply: a = () => {
+        },
+        ...c
+      } = tt(e, t), d = await Xt(t, c), u = Me(o), p = nt(o), f = ye(o) === "y", {
+        width: g,
+        height: h
+      } = i.floating;
+      let x, v;
+      u === "top" || u === "bottom" ? (x = u, v = p === (await (s.isRTL == null ? void 0 : s.isRTL(l.floating)) ? "start" : "end") ? "left" : "right") : (v = u, x = p === "end" ? "top" : "bottom");
+      const R = h - d.top - d.bottom, b = g - d.left - d.right, y = Be(h - d[x], R), P = Be(g - d[v], b), N = !t.middlewareData.shift;
+      let $ = y, _ = P;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (_ = b), (r = t.middlewareData.shift) != null && r.enabled.y && ($ = R), N && !p) {
+        const K = ie(d.left, 0), W = ie(d.right, 0), I = ie(d.top, 0), L = ie(d.bottom, 0);
+        f ? _ = g - 2 * (K !== 0 || W !== 0 ? K + W : ie(d.left, d.right)) : $ = h - 2 * (I !== 0 || L !== 0 ? I + L : ie(d.top, d.bottom));
+      }
+      await a({
+        ...t,
+        availableWidth: _,
+        availableHeight: $
+      });
+      const Y = await s.getDimensions(l.floating);
+      return g !== Y.width || h !== Y.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function It() {
+  return typeof window < "u";
+}
+function qe(e) {
+  return er(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function se(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function be(e) {
+  var t;
+  return (t = (er(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function er(e) {
+  return It() ? e instanceof Node || e instanceof se(e).Node : !1;
+}
+function ue(e) {
+  return It() ? e instanceof Element || e instanceof se(e).Element : !1;
+}
+function he(e) {
+  return It() ? e instanceof HTMLElement || e instanceof se(e).HTMLElement : !1;
+}
+function gn(e) {
+  return !It() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof se(e).ShadowRoot;
+}
+const Ro = /* @__PURE__ */ new Set(["inline", "contents"]);
+function rt(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: r,
+    display: o
+  } = fe(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && !Ro.has(o);
+}
+const Eo = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function Co(e) {
+  return Eo.has(qe(e));
+}
+const Io = [":popover-open", ":modal"];
+function St(e) {
+  return Io.some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+const So = ["transform", "translate", "scale", "rotate", "perspective"], To = ["transform", "translate", "scale", "rotate", "perspective", "filter"], Ao = ["paint", "layout", "strict", "content"];
+function Yt(e) {
+  const t = Gt(), n = ue(e) ? fe(e) : e;
+  return So.some((r) => n[r] ? n[r] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || To.some((r) => (n.willChange || "").includes(r)) || Ao.some((r) => (n.contain || "").includes(r));
+}
+function Oo(e) {
+  let t = De(e);
+  for (; he(t) && !We(t); ) {
+    if (Yt(t))
+      return t;
+    if (St(t))
+      return null;
+    t = De(t);
+  }
+  return null;
+}
+function Gt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const Mo = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function We(e) {
+  return Mo.has(qe(e));
+}
+function fe(e) {
+  return se(e).getComputedStyle(e);
+}
+function Tt(e) {
+  return ue(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function De(e) {
+  if (qe(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    gn(e) && e.host || // Fallback.
+    be(e)
+  );
+  return gn(t) ? t.host : t;
+}
+function tr(e) {
+  const t = De(e);
+  return We(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : he(t) && rt(t) ? t : tr(t);
+}
+function Ae(e, t, n) {
+  var r;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = tr(e), i = o === ((r = e.ownerDocument) == null ? void 0 : r.body), s = se(o);
+  if (i) {
+    const l = zt(s);
+    return t.concat(s, s.visualViewport || [], rt(o) ? o : [], l && n ? Ae(l) : []);
+  }
+  return t.concat(o, Ae(o, [], n));
+}
+function zt(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function nr(e) {
+  const t = fe(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = he(e), i = o ? e.offsetWidth : n, s = o ? e.offsetHeight : r, l = bt(n) !== i || bt(r) !== s;
+  return l && (n = i, r = s), {
+    width: n,
+    height: r,
+    $: l
+  };
+}
+function Zt(e) {
+  return ue(e) ? e : e.contextElement;
+}
+function Ve(e) {
+  const t = Zt(e);
+  if (!he(t))
+    return pe(1);
+  const n = t.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: i
+  } = nr(t);
+  let s = (i ? bt(n.width) : n.width) / r, l = (i ? bt(n.height) : n.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: s,
+    y: l
+  };
+}
+const Do = /* @__PURE__ */ pe(0);
+function rr(e) {
+  const t = se(e);
+  return !Gt() || !t.visualViewport ? Do : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Po(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== se(e) ? !1 : t;
+}
+function Le(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = Zt(e);
+  let s = pe(1);
+  t && (r ? ue(r) && (s = Ve(r)) : s = Ve(e));
+  const l = Po(i, n, r) ? rr(i) : pe(0);
+  let a = (o.left + l.x) / s.x, c = (o.top + l.y) / s.y, d = o.width / s.x, u = o.height / s.y;
+  if (i) {
+    const p = se(i), f = r && ue(r) ? se(r) : r;
+    let g = p, h = zt(g);
+    for (; h && r && f !== g; ) {
+      const x = Ve(h), v = h.getBoundingClientRect(), R = fe(h), b = v.left + (h.clientLeft + parseFloat(R.paddingLeft)) * x.x, y = v.top + (h.clientTop + parseFloat(R.paddingTop)) * x.y;
+      a *= x.x, c *= x.y, d *= x.x, u *= x.y, a += b, c += y, g = se(h), h = zt(g);
+    }
+  }
+  return xt({
+    width: d,
+    height: u,
+    x: a,
+    y: c
+  });
+}
+function At(e, t) {
+  const n = Tt(e).scrollLeft;
+  return t ? t.left + n : Le(be(e)).left + n;
+}
+function or(e, t) {
+  const n = e.getBoundingClientRect(), r = n.left + t.scrollLeft - At(e, n), o = n.top + t.scrollTop;
+  return {
+    x: r,
+    y: o
+  };
+}
+function Fo(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = e;
+  const i = o === "fixed", s = be(r), l = t ? St(t.floating) : !1;
+  if (r === s || l && i)
+    return n;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, c = pe(1);
+  const d = pe(0), u = he(r);
+  if ((u || !u && !i) && ((qe(r) !== "body" || rt(s)) && (a = Tt(r)), he(r))) {
+    const f = Le(r);
+    c = Ve(r), d.x = f.x + r.clientLeft, d.y = f.y + r.clientTop;
+  }
+  const p = s && !u && !i ? or(s, a) : pe(0);
+  return {
+    width: n.width * c.x,
+    height: n.height * c.y,
+    x: n.x * c.x - a.scrollLeft * c.x + d.x + p.x,
+    y: n.y * c.y - a.scrollTop * c.y + d.y + p.y
+  };
+}
+function No(e) {
+  return Array.from(e.getClientRects());
+}
+function Lo(e) {
+  const t = be(e), n = Tt(e), r = e.ownerDocument.body, o = ie(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), i = ie(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let s = -n.scrollLeft + At(e);
+  const l = -n.scrollTop;
+  return fe(r).direction === "rtl" && (s += ie(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: s,
+    y: l
+  };
+}
+const pn = 25;
+function ko(e, t) {
+  const n = se(e), r = be(e), o = n.visualViewport;
+  let i = r.clientWidth, s = r.clientHeight, l = 0, a = 0;
+  if (o) {
+    i = o.width, s = o.height;
+    const d = Gt();
+    (!d || d && t === "fixed") && (l = o.offsetLeft, a = o.offsetTop);
+  }
+  const c = At(r);
+  if (c <= 0) {
+    const d = r.ownerDocument, u = d.body, p = getComputedStyle(u), f = d.compatMode === "CSS1Compat" && parseFloat(p.marginLeft) + parseFloat(p.marginRight) || 0, g = Math.abs(r.clientWidth - u.clientWidth - f);
+    g <= pn && (i -= g);
+  } else c <= pn && (i += c);
+  return {
+    width: i,
+    height: s,
+    x: l,
+    y: a
+  };
+}
+const Vo = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function _o(e, t) {
+  const n = Le(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, i = he(e) ? Ve(e) : pe(1), s = e.clientWidth * i.x, l = e.clientHeight * i.y, a = o * i.x, c = r * i.y;
+  return {
+    width: s,
+    height: l,
+    x: a,
+    y: c
+  };
+}
+function hn(e, t, n) {
+  let r;
+  if (t === "viewport")
+    r = ko(e, n);
+  else if (t === "document")
+    r = Lo(be(e));
+  else if (ue(t))
+    r = _o(t, n);
+  else {
+    const o = rr(e);
+    r = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return xt(r);
+}
+function ir(e, t) {
+  const n = De(e);
+  return n === t || !ue(n) || We(n) ? !1 : fe(n).position === "fixed" || ir(n, t);
+}
+function $o(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let r = Ae(e, [], !1).filter((l) => ue(l) && qe(l) !== "body"), o = null;
+  const i = fe(e).position === "fixed";
+  let s = i ? De(e) : e;
+  for (; ue(s) && !We(s); ) {
+    const l = fe(s), a = Yt(s);
+    !a && l.position === "fixed" && (o = null), (i ? !a && !o : !a && l.position === "static" && !!o && Vo.has(o.position) || rt(s) && !a && ir(e, s)) ? r = r.filter((d) => d !== s) : o = l, s = De(s);
+  }
+  return t.set(e, r), r;
+}
+function Bo(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = e;
+  const s = [...n === "clippingAncestors" ? St(t) ? [] : $o(t, this._c) : [].concat(n), r], l = s[0], a = s.reduce((c, d) => {
+    const u = hn(t, d, o);
+    return c.top = ie(u.top, c.top), c.right = Be(u.right, c.right), c.bottom = Be(u.bottom, c.bottom), c.left = ie(u.left, c.left), c;
+  }, hn(t, l, o));
+  return {
+    width: a.right - a.left,
+    height: a.bottom - a.top,
+    x: a.left,
+    y: a.top
+  };
+}
+function Wo(e) {
+  const {
+    width: t,
+    height: n
+  } = nr(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function Ko(e, t, n) {
+  const r = he(t), o = be(t), i = n === "fixed", s = Le(e, !0, i, t);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = pe(0);
+  function c() {
+    a.x = At(o);
+  }
+  if (r || !r && !i)
+    if ((qe(t) !== "body" || rt(o)) && (l = Tt(t)), r) {
+      const f = Le(t, !0, i, t);
+      a.x = f.x + t.clientLeft, a.y = f.y + t.clientTop;
+    } else o && c();
+  i && !r && o && c();
+  const d = o && !r && !i ? or(o, l) : pe(0), u = s.left + l.scrollLeft - a.x - d.x, p = s.top + l.scrollTop - a.y - d.y;
+  return {
+    x: u,
+    y: p,
+    width: s.width,
+    height: s.height
+  };
+}
+function Pt(e) {
+  return fe(e).position === "static";
+}
+function bn(e, t) {
+  if (!he(e) || fe(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return be(e) === n && (n = n.ownerDocument.body), n;
+}
+function sr(e, t) {
+  const n = se(e);
+  if (St(e))
+    return n;
+  if (!he(e)) {
+    let o = De(e);
+    for (; o && !We(o); ) {
+      if (ue(o) && !Pt(o))
+        return o;
+      o = De(o);
+    }
+    return n;
+  }
+  let r = bn(e, t);
+  for (; r && Co(r) && Pt(r); )
+    r = bn(r, t);
+  return r && We(r) && Pt(r) && !Yt(r) ? n : r || Oo(e) || n;
+}
+const Ho = async function(e) {
+  const t = this.getOffsetParent || sr, n = this.getDimensions, r = await n(e.floating);
+  return {
+    reference: Ko(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function zo(e) {
+  return fe(e).direction === "rtl";
+}
+const qo = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Fo,
+  getDocumentElement: be,
+  getClippingRect: Bo,
+  getOffsetParent: sr,
+  getElementRects: Ho,
+  getClientRects: No,
+  getDimensions: Wo,
+  getScale: Ve,
+  isElement: ue,
+  isRTL: zo
+};
+function cr(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function jo(e, t) {
+  let n = null, r;
+  const o = be(e);
+  function i() {
+    var l;
+    clearTimeout(r), (l = n) == null || l.disconnect(), n = null;
+  }
+  function s(l, a) {
+    l === void 0 && (l = !1), a === void 0 && (a = 1), i();
+    const c = e.getBoundingClientRect(), {
+      left: d,
+      top: u,
+      width: p,
+      height: f
+    } = c;
+    if (l || t(), !p || !f)
+      return;
+    const g = lt(u), h = lt(o.clientWidth - (d + p)), x = lt(o.clientHeight - (u + f)), v = lt(d), b = {
+      rootMargin: -g + "px " + -h + "px " + -x + "px " + -v + "px",
+      threshold: ie(0, Be(1, a)) || 1
+    };
+    let y = !0;
+    function P(N) {
+      const $ = N[0].intersectionRatio;
+      if ($ !== a) {
+        if (!y)
+          return s();
+        $ ? s(!1, $) : r = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      $ === 1 && !cr(c, e.getBoundingClientRect()) && s(), y = !1;
+    }
+    try {
+      n = new IntersectionObserver(P, {
+        ...b,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(P, b);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function zi(e, t, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = r, c = Zt(e), d = o || i ? [...c ? Ae(c) : [], ...Ae(t)] : [];
+  d.forEach((v) => {
+    o && v.addEventListener("scroll", n, {
+      passive: !0
+    }), i && v.addEventListener("resize", n);
+  });
+  const u = c && l ? jo(c, n) : null;
+  let p = -1, f = null;
+  s && (f = new ResizeObserver((v) => {
+    let [R] = v;
+    R && R.target === c && f && (f.unobserve(t), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var b;
+      (b = f) == null || b.observe(t);
+    })), n();
+  }), c && !a && f.observe(c), f.observe(t));
+  let g, h = a ? Le(e) : null;
+  a && x();
+  function x() {
+    const v = Le(e);
+    h && !cr(h, v) && n(), h = v, g = requestAnimationFrame(x);
+  }
+  return n(), () => {
+    var v;
+    d.forEach((R) => {
+      o && R.removeEventListener("scroll", n), i && R.removeEventListener("resize", n);
+    }), u?.(), (v = f) == null || v.disconnect(), f = null, a && cancelAnimationFrame(g);
+  };
+}
+const Uo = xo, qi = wo, Xo = ho, Yo = yo, Go = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: qo,
+    ...n
+  }, i = {
+    ...o.platform,
+    _c: r
+  };
+  return po(e, t, {
+    ...o,
+    platform: i
+  });
+};
+var dt = typeof document < "u" ? kn : Vn;
+function wt(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let n, r, o;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!wt(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (o = Object.keys(e), n = o.length, n !== Object.keys(t).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, o[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      const i = o[r];
+      if (!(i === "_owner" && e.$$typeof) && !wt(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function lr(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function vn(e, t) {
+  const n = lr(e);
+  return Math.round(t * n) / n;
+}
+function Ft(e) {
+  const t = m.useRef(e);
+  return dt(() => {
+    t.current = e;
+  }), t;
+}
+function Zo(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: o,
+    elements: {
+      reference: i,
+      floating: s
+    } = {},
+    transform: l = !0,
+    whileElementsMounted: a,
+    open: c
+  } = e, [d, u] = m.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [p, f] = m.useState(r);
+  wt(p, r) || f(r);
+  const [g, h] = m.useState(null), [x, v] = m.useState(null), R = m.useCallback((E) => {
+    E !== N.current && (N.current = E, h(E));
+  }, []), b = m.useCallback((E) => {
+    E !== $.current && ($.current = E, v(E));
+  }, []), y = i || g, P = s || x, N = m.useRef(null), $ = m.useRef(null), _ = m.useRef(d), Y = a != null, K = Ft(a), W = Ft(o), I = Ft(c), L = m.useCallback(() => {
+    if (!N.current || !$.current)
+      return;
+    const E = {
+      placement: t,
+      strategy: n,
+      middleware: p
+    };
+    W.current && (E.platform = W.current), Go(N.current, $.current, E).then((C) => {
+      const B = {
+        ...C,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: I.current !== !1
+      };
+      S.current && !wt(_.current, B) && (_.current = B, $n.flushSync(() => {
+        u(B);
+      }));
+    });
+  }, [p, t, n, W, I]);
+  dt(() => {
+    c === !1 && _.current.isPositioned && (_.current.isPositioned = !1, u((E) => ({
+      ...E,
+      isPositioned: !1
+    })));
+  }, [c]);
+  const S = m.useRef(!1);
+  dt(() => (S.current = !0, () => {
+    S.current = !1;
+  }), []), dt(() => {
+    if (y && (N.current = y), P && ($.current = P), y && P) {
+      if (K.current)
+        return K.current(y, P, L);
+      L();
+    }
+  }, [y, P, L, K, Y]);
+  const w = m.useMemo(() => ({
+    reference: N,
+    floating: $,
+    setReference: R,
+    setFloating: b
+  }), [R, b]), O = m.useMemo(() => ({
+    reference: y,
+    floating: P
+  }), [y, P]), D = m.useMemo(() => {
+    const E = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!O.floating)
+      return E;
+    const C = vn(O.floating, d.x), B = vn(O.floating, d.y);
+    return l ? {
+      ...E,
+      transform: "translate(" + C + "px, " + B + "px)",
+      ...lr(O.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: C,
+      top: B
+    };
+  }, [n, l, O.floating, d.x, d.y]);
+  return m.useMemo(() => ({
+    ...d,
+    update: L,
+    refs: w,
+    elements: O,
+    floatingStyles: D
+  }), [d, L, w, O, D]);
+}
+const ji = (e, t) => ({
+  ...Uo(e),
+  options: [e, t]
+}), Ui = (e, t) => ({
+  ...Xo(e),
+  options: [e, t]
+}), Xi = (e, t) => ({
+  ...Yo(e),
+  options: [e, t]
+});
+function Jo(e) {
+  return m.useMemo(() => e.every((t) => t == null) ? null : (t) => {
+    e.forEach((n) => {
+      typeof n == "function" ? n(t) : n != null && (n.current = t);
+    });
+  }, e);
+}
+const ar = {
+  ...m
+}, Qo = ar.useInsertionEffect, ei = Qo || ((e) => e());
+function ae(e) {
+  const t = m.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return ei(() => {
+    t.current = e;
+  }), m.useCallback(function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    return t.current == null ? void 0 : t.current(...r);
+  }, []);
+}
+const Jt = "ArrowUp", ot = "ArrowDown", Ke = "ArrowLeft", je = "ArrowRight";
+function at(e, t, n) {
+  return Math.floor(e / t) !== n;
+}
+function Ye(e, t) {
+  return t < 0 || t >= e.current.length;
+}
+function Nt(e, t) {
+  return J(e, {
+    disabledIndices: t
+  });
+}
+function xn(e, t) {
+  return J(e, {
+    decrement: !0,
+    startingIndex: e.current.length,
+    disabledIndices: t
+  });
+}
+function J(e, t) {
+  let {
+    startingIndex: n = -1,
+    decrement: r = !1,
+    disabledIndices: o,
+    amount: i = 1
+  } = t === void 0 ? {} : t;
+  const s = e.current;
+  let l = n;
+  do
+    l += r ? -i : i;
+  while (l >= 0 && l <= s.length - 1 && mt(s, l, o));
+  return l;
+}
+function ti(e, t) {
+  let {
+    event: n,
+    orientation: r,
+    loop: o,
+    cols: i,
+    disabledIndices: s,
+    minIndex: l,
+    maxIndex: a,
+    prevIndex: c,
+    stopEvent: d = !1
+  } = t, u = c;
+  if (n.key === Jt) {
+    if (d && te(n), c === -1)
+      u = a;
+    else if (u = J(e, {
+      startingIndex: u,
+      amount: i,
+      decrement: !0,
+      disabledIndices: s
+    }), o && (c - i < l || u < 0)) {
+      const p = c % i, f = a % i, g = a - (f - p);
+      f === p ? u = a : u = f > p ? g : g - i;
+    }
+    Ye(e, u) && (u = c);
+  }
+  if (n.key === ot && (d && te(n), c === -1 ? u = l : (u = J(e, {
+    startingIndex: c,
+    amount: i,
+    disabledIndices: s
+  }), o && c + i > a && (u = J(e, {
+    startingIndex: c % i - i,
+    amount: i,
+    disabledIndices: s
+  }))), Ye(e, u) && (u = c)), r === "both") {
+    const p = ln(c / i);
+    n.key === je && (d && te(n), c % i !== i - 1 ? (u = J(e, {
+      startingIndex: c,
+      disabledIndices: s
+    }), o && at(u, i, p) && (u = J(e, {
+      startingIndex: c - c % i - 1,
+      disabledIndices: s
+    }))) : o && (u = J(e, {
+      startingIndex: c - c % i - 1,
+      disabledIndices: s
+    })), at(u, i, p) && (u = c)), n.key === Ke && (d && te(n), c % i !== 0 ? (u = J(e, {
+      startingIndex: c,
+      decrement: !0,
+      disabledIndices: s
+    }), o && at(u, i, p) && (u = J(e, {
+      startingIndex: c + (i - c % i),
+      decrement: !0,
+      disabledIndices: s
+    }))) : o && (u = J(e, {
+      startingIndex: c + (i - c % i),
+      decrement: !0,
+      disabledIndices: s
+    })), at(u, i, p) && (u = c));
+    const f = ln(a / i) === p;
+    Ye(e, u) && (o && f ? u = n.key === Ke ? a : J(e, {
+      startingIndex: c - c % i - 1,
+      disabledIndices: s
+    }) : u = c);
+  }
+  return u;
+}
+function ni(e, t, n) {
+  const r = [];
+  let o = 0;
+  return e.forEach((i, s) => {
+    let {
+      width: l,
+      height: a
+    } = i;
+    if (l > t && process.env.NODE_ENV !== "production")
+      throw new Error("[Floating UI]: Invalid grid - item width at index " + s + " is greater than grid columns");
+    let c = !1;
+    for (n && (o = 0); !c; ) {
+      const d = [];
+      for (let u = 0; u < l; u++)
+        for (let p = 0; p < a; p++)
+          d.push(o + u + p * t);
+      o % t + l <= t && d.every((u) => r[u] == null) ? (d.forEach((u) => {
+        r[u] = s;
+      }), c = !0) : o++;
+    }
+  }), [...r];
+}
+function ri(e, t, n, r, o) {
+  if (e === -1) return -1;
+  const i = n.indexOf(e), s = t[e];
+  switch (o) {
+    case "tl":
+      return i;
+    case "tr":
+      return s ? i + s.width - 1 : i;
+    case "bl":
+      return s ? i + (s.height - 1) * r : i;
+    case "br":
+      return n.lastIndexOf(e);
+  }
+}
+function oi(e, t) {
+  return t.flatMap((n, r) => e.includes(n) ? [r] : []);
+}
+function mt(e, t, n) {
+  if (n)
+    return n.includes(t);
+  const r = e[t];
+  return r == null || r.hasAttribute("disabled") || r.getAttribute("aria-disabled") === "true";
+}
+let wn = 0;
+function Se(e, t) {
+  t === void 0 && (t = {});
+  const {
+    preventScroll: n = !1,
+    cancelPrevious: r = !0,
+    sync: o = !1
+  } = t;
+  r && cancelAnimationFrame(wn);
+  const i = () => e?.focus({
+    preventScroll: n
+  });
+  o ? i() : wn = requestAnimationFrame(i);
+}
+var X = typeof document < "u" ? kn : Vn;
+function yt() {
+  return yt = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var r in n)
+        Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]);
+    }
+    return e;
+  }, yt.apply(this, arguments);
+}
+let yn = !1, ii = 0;
+const Rn = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + ii++
+);
+function si() {
+  const [e, t] = m.useState(() => yn ? Rn() : void 0);
+  return X(() => {
+    e == null && t(Rn());
+  }, []), m.useEffect(() => {
+    yn = !0;
+  }, []), e;
+}
+const ci = ar.useId, Qt = ci || si;
+let Je;
+process.env.NODE_ENV !== "production" && (Je = /* @__PURE__ */ new Set());
+function Lt() {
+  for (var e, t = arguments.length, n = new Array(t), r = 0; r < t; r++)
+    n[r] = arguments[r];
+  const o = "Floating UI: " + n.join(" ");
+  if (!((e = Je) != null && e.has(o))) {
+    var i;
+    (i = Je) == null || i.add(o), console.warn(o);
+  }
+}
+function li() {
+  for (var e, t = arguments.length, n = new Array(t), r = 0; r < t; r++)
+    n[r] = arguments[r];
+  const o = "Floating UI: " + n.join(" ");
+  if (!((e = Je) != null && e.has(o))) {
+    var i;
+    (i = Je) == null || i.add(o), console.error(o);
+  }
+}
+function ai() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    emit(t, n) {
+      var r;
+      (r = e.get(t)) == null || r.forEach((o) => o(n));
+    },
+    on(t, n) {
+      e.set(t, [...e.get(t) || [], n]);
+    },
+    off(t, n) {
+      var r;
+      e.set(t, ((r = e.get(t)) == null ? void 0 : r.filter((o) => o !== n)) || []);
+    }
+  };
+}
+const ui = /* @__PURE__ */ m.createContext(null), fi = /* @__PURE__ */ m.createContext(null), en = () => {
+  var e;
+  return ((e = m.useContext(ui)) == null ? void 0 : e.id) || null;
+}, Ot = () => m.useContext(fi);
+function He(e) {
+  return "data-floating-ui-" + e;
+}
+function Te(e) {
+  const t = yr(e);
+  return X(() => {
+    t.current = e;
+  }), t;
+}
+function di(e, t) {
+  var n;
+  let r = [], o = (n = e.find((i) => i.id === t)) == null ? void 0 : n.parentId;
+  for (; o; ) {
+    const i = e.find((s) => s.id === o);
+    o = i?.parentId, i && (r = r.concat(i));
+  }
+  return r;
+}
+function _e(e, t) {
+  let n = e.filter((o) => {
+    var i;
+    return o.parentId === t && ((i = o.context) == null ? void 0 : i.open);
+  }), r = n;
+  for (; r.length; )
+    r = e.filter((o) => {
+      var i;
+      return (i = r) == null ? void 0 : i.some((s) => {
+        var l;
+        return o.parentId === s.id && ((l = o.context) == null ? void 0 : l.open);
+      });
+    }), n = n.concat(r);
+  return n;
+}
+function mi(e, t) {
+  let n, r = -1;
+  function o(i, s) {
+    s > r && (n = i, r = s), _e(e, i).forEach((a) => {
+      o(a.id, s + 1);
+    });
+  }
+  return o(t, 0), e.find((i) => i.id === n);
+}
+let ke = /* @__PURE__ */ new WeakMap(), ut = /* @__PURE__ */ new WeakSet(), ft = {}, kt = 0;
+const gi = () => typeof HTMLElement < "u" && "inert" in HTMLElement.prototype, ur = (e) => e && (e.host || ur(e.parentNode)), pi = (e, t) => t.map((n) => {
+  if (e.contains(n))
+    return n;
+  const r = ur(n);
+  return e.contains(r) ? r : null;
+}).filter((n) => n != null);
+function hi(e, t, n, r) {
+  const o = "data-floating-ui-inert", i = r ? "inert" : n ? "aria-hidden" : null, s = pi(t, e), l = /* @__PURE__ */ new Set(), a = new Set(s), c = [];
+  ft[o] || (ft[o] = /* @__PURE__ */ new WeakMap());
+  const d = ft[o];
+  s.forEach(u), p(t), l.clear();
+  function u(f) {
+    !f || l.has(f) || (l.add(f), f.parentNode && u(f.parentNode));
+  }
+  function p(f) {
+    !f || a.has(f) || [].forEach.call(f.children, (g) => {
+      if (Ct(g) !== "script")
+        if (l.has(g))
+          p(g);
+        else {
+          const h = i ? g.getAttribute(i) : null, x = h !== null && h !== "false", v = (ke.get(g) || 0) + 1, R = (d.get(g) || 0) + 1;
+          ke.set(g, v), d.set(g, R), c.push(g), v === 1 && x && ut.add(g), R === 1 && g.setAttribute(o, ""), !x && i && g.setAttribute(i, "true");
+        }
+    });
+  }
+  return kt++, () => {
+    c.forEach((f) => {
+      const g = (ke.get(f) || 0) - 1, h = (d.get(f) || 0) - 1;
+      ke.set(f, g), d.set(f, h), g || (!ut.has(f) && i && f.removeAttribute(i), ut.delete(f)), h || f.removeAttribute(o);
+    }), kt--, kt || (ke = /* @__PURE__ */ new WeakMap(), ke = /* @__PURE__ */ new WeakMap(), ut = /* @__PURE__ */ new WeakSet(), ft = {});
+  };
+}
+function En(e, t, n) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const r = oe(e[0]).body;
+  return hi(e.concat(Array.from(r.querySelectorAll("[aria-live]"))), r, t, n);
+}
+const ze = () => ({
+  getShadowRoot: !0,
+  displayCheck: (
+    // JSDOM does not support the `tabbable` library. To solve this we can
+    // check if `ResizeObserver` is a real function (not polyfilled), which
+    // determines if the current environment is JSDOM-like.
+    typeof ResizeObserver == "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+  )
+});
+function fr(e, t) {
+  const n = Ze(e, ze());
+  t === "prev" && n.reverse();
+  const r = n.indexOf(we(oe(e)));
+  return n.slice(r + 1)[0];
+}
+function dr() {
+  return fr(document.body, "next");
+}
+function mr() {
+  return fr(document.body, "prev");
+}
+function Ge(e, t) {
+  const n = t || e.currentTarget, r = e.relatedTarget;
+  return !r || !ee(n, r);
+}
+function bi(e) {
+  Ze(e, ze()).forEach((n) => {
+    n.dataset.tabindex = n.getAttribute("tabindex") || "", n.setAttribute("tabindex", "-1");
+  });
+}
+function Cn(e) {
+  e.querySelectorAll("[data-tabindex]").forEach((n) => {
+    const r = n.dataset.tabindex;
+    delete n.dataset.tabindex, r ? n.setAttribute("tabindex", r) : n.removeAttribute("tabindex");
+  });
+}
+function vi(e, t, n) {
+  const r = e.indexOf(t);
+  function o(s) {
+    const l = He("focus-guard");
+    let a = r + (s ? 1 : 0), c = e[a];
+    for (; c && (!c.isConnected || c.hasAttribute(l) || ee(n, c)); )
+      s ? a++ : a--, c = e[a];
+    return c;
+  }
+  const i = o(!0);
+  return i || o(!1);
+}
+const tn = {
+  border: 0,
+  clip: "rect(0 0 0 0)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: 0,
+  position: "fixed",
+  whiteSpace: "nowrap",
+  width: "1px",
+  top: 0,
+  left: 0
+};
+let xi;
+function In(e) {
+  e.key === "Tab" && (e.target, clearTimeout(xi));
+}
+const Rt = /* @__PURE__ */ m.forwardRef(function(t, n) {
+  const [r, o] = m.useState();
+  X(() => (qn() && o("button"), document.addEventListener("keydown", In), () => {
+    document.removeEventListener("keydown", In);
+  }), []);
+  const i = {
+    ref: n,
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role: r,
+    "aria-hidden": r ? void 0 : !0,
+    [He("focus-guard")]: "",
+    style: tn
+  };
+  return /* @__PURE__ */ m.createElement("span", yt({}, t, i));
+}), gr = /* @__PURE__ */ m.createContext(null), Sn = /* @__PURE__ */ He("portal");
+function wi(e) {
+  e === void 0 && (e = {});
+  const {
+    id: t,
+    root: n
+  } = e, r = Qt(), o = pr(), [i, s] = m.useState(null), l = m.useRef(null);
+  return X(() => () => {
+    i?.remove(), queueMicrotask(() => {
+      l.current = null;
+    });
+  }, [i]), X(() => {
+    if (!r || l.current) return;
+    const a = t ? document.getElementById(t) : null;
+    if (!a) return;
+    const c = document.createElement("div");
+    c.id = r, c.setAttribute(Sn, ""), a.appendChild(c), l.current = c, s(c);
+  }, [t, r]), X(() => {
+    if (!r || l.current) return;
+    let a = n || o?.portalNode;
+    a && !ce(a) && (a = a.current), a = a || document.body;
+    let c = null;
+    t && (c = document.createElement("div"), c.id = t, a.appendChild(c));
+    const d = document.createElement("div");
+    d.id = r, d.setAttribute(Sn, ""), a = c || a, a.appendChild(d), l.current = d, s(d);
+  }, [t, n, r, o]), i;
+}
+function Yi(e) {
+  const {
+    children: t,
+    id: n,
+    root: r = null,
+    preserveTabOrder: o = !0
+  } = e, i = wi({
+    id: n,
+    root: r
+  }), [s, l] = m.useState(null), a = m.useRef(null), c = m.useRef(null), d = m.useRef(null), u = m.useRef(null), p = s?.modal, f = s?.open, g = (
+    // The FocusManager and therefore floating element are currently open/
+    // rendered.
+    !!s && // Guards are only for non-modal focus management.
+    !s.modal && // Don't render if unmount is transitioning.
+    s.open && o && !!(r || i)
+  );
+  return m.useEffect(() => {
+    if (!i || !o || p)
+      return;
+    function h(x) {
+      i && Ge(x) && (x.type === "focusin" ? Cn : bi)(i);
+    }
+    return i.addEventListener("focusin", h, !0), i.addEventListener("focusout", h, !0), () => {
+      i.removeEventListener("focusin", h, !0), i.removeEventListener("focusout", h, !0);
+    };
+  }, [i, o, p]), m.useEffect(() => {
+    i && (f || Cn(i));
+  }, [f, i]), /* @__PURE__ */ m.createElement(gr.Provider, {
+    value: m.useMemo(() => ({
+      preserveTabOrder: o,
+      beforeOutsideRef: a,
+      afterOutsideRef: c,
+      beforeInsideRef: d,
+      afterInsideRef: u,
+      portalNode: i,
+      setFocusManagerState: l
+    }), [o, i])
+  }, g && i && /* @__PURE__ */ m.createElement(Rt, {
+    "data-type": "outside",
+    ref: a,
+    onFocus: (h) => {
+      if (Ge(h, i)) {
+        var x;
+        (x = d.current) == null || x.focus();
+      } else {
+        const v = mr() || s?.refs.domReference.current;
+        v?.focus();
+      }
+    }
+  }), g && i && /* @__PURE__ */ m.createElement("span", {
+    "aria-owns": i.id,
+    style: tn
+  }), i && /* @__PURE__ */ $n.createPortal(t, i), g && i && /* @__PURE__ */ m.createElement(Rt, {
+    "data-type": "outside",
+    ref: c,
+    onFocus: (h) => {
+      if (Ge(h, i)) {
+        var x;
+        (x = u.current) == null || x.focus();
+      } else {
+        const v = dr() || s?.refs.domReference.current;
+        v?.focus(), s?.closeOnFocusOut && s?.onOpenChange(!1, h.nativeEvent, "focus-out");
+      }
+    }
+  }));
+}
+const pr = () => m.useContext(gr), qt = "data-floating-ui-focusable";
+function hr(e) {
+  return e ? e.hasAttribute(qt) ? e : e.querySelector("[" + qt + "]") || e : null;
+}
+const Tn = 20;
+let Fe = [];
+function Vt(e) {
+  Fe = Fe.filter((n) => n.isConnected);
+  let t = e;
+  if (!(!t || Ct(t) === "body")) {
+    if (!no(t, ze())) {
+      const n = Ze(t, ze())[0];
+      n && (t = n);
+    }
+    Fe.push(t), Fe.length > Tn && (Fe = Fe.slice(-Tn));
+  }
+}
+function An() {
+  return Fe.slice().reverse().find((e) => e.isConnected);
+}
+const yi = /* @__PURE__ */ m.forwardRef(function(t, n) {
+  return /* @__PURE__ */ m.createElement("button", yt({}, t, {
+    type: "button",
+    ref: n,
+    tabIndex: -1,
+    style: tn
+  }));
+});
+function Gi(e) {
+  const {
+    context: t,
+    children: n,
+    disabled: r = !1,
+    order: o = ["content"],
+    guards: i = !0,
+    initialFocus: s = 0,
+    returnFocus: l = !0,
+    restoreFocus: a = !1,
+    modal: c = !0,
+    visuallyHiddenDismiss: d = !1,
+    closeOnFocusOut: u = !0
+  } = e, {
+    open: p,
+    refs: f,
+    nodeId: g,
+    onOpenChange: h,
+    events: x,
+    dataRef: v,
+    floatingId: R,
+    elements: {
+      domReference: b,
+      floating: y
+    }
+  } = t, P = typeof s == "number" && s < 0, N = jn(b) && P, $ = gi() ? i : !0, _ = Te(o), Y = Te(s), K = Te(l), W = Ot(), I = pr(), L = m.useRef(null), S = m.useRef(null), w = m.useRef(!1), O = m.useRef(!1), D = m.useRef(-1), E = I != null, C = hr(y), B = ae(function(V) {
+    return V === void 0 && (V = C), V ? Ze(V, ze()) : [];
+  }), Z = ae((V) => {
+    const M = B(V);
+    return _.current.map((T) => b && T === "reference" ? b : C && T === "floating" ? C : M).filter(Boolean).flat();
+  });
+  m.useEffect(() => {
+    w.current = !1;
+  }, [r]), m.useEffect(() => {
+    if (r || !c) return;
+    function V(T) {
+      if (T.key === "Tab") {
+        ee(C, we(oe(C))) && B().length === 0 && !N && te(T);
+        const F = Z(), q = Ne(T);
+        _.current[0] === "reference" && q === b && (te(T), T.shiftKey ? Se(F[F.length - 1]) : Se(F[1])), _.current[1] === "floating" && q === C && T.shiftKey && (te(T), Se(F[0]));
+      }
+    }
+    const M = oe(C);
+    return M.addEventListener("keydown", V), () => {
+      M.removeEventListener("keydown", V);
+    };
+  }, [r, b, C, c, _, N, B, Z]), m.useEffect(() => {
+    if (r || !y) return;
+    function V(M) {
+      const T = Ne(M), q = B().indexOf(T);
+      q !== -1 && (D.current = q);
+    }
+    return y.addEventListener("focusin", V), () => {
+      y.removeEventListener("focusin", V);
+    };
+  }, [r, y, B]), m.useEffect(() => {
+    if (r || !u) return;
+    function V() {
+      O.current = !0, setTimeout(() => {
+        O.current = !1;
+      });
+    }
+    function M(T) {
+      const F = T.relatedTarget;
+      queueMicrotask(() => {
+        const q = !(ee(b, F) || ee(y, F) || ee(F, y) || ee(I?.portalNode, F) || F != null && F.hasAttribute(He("focus-guard")) || W && (_e(W.nodesRef.current, g).find((G) => {
+          var Q, U;
+          return ee((Q = G.context) == null ? void 0 : Q.elements.floating, F) || ee((U = G.context) == null ? void 0 : U.elements.domReference, F);
+        }) || di(W.nodesRef.current, g).find((G) => {
+          var Q, U;
+          return ((Q = G.context) == null ? void 0 : Q.elements.floating) === F || ((U = G.context) == null ? void 0 : U.elements.domReference) === F;
+        })));
+        if (a && q && we(oe(C)) === oe(C).body) {
+          xe(C) && C.focus();
+          const G = D.current, Q = B(), U = Q[G] || Q[Q.length - 1] || C;
+          xe(U) && U.focus();
+        }
+        (N || !c) && F && q && !O.current && // Fix React 18 Strict Mode returnFocus due to double rendering.
+        F !== An() && (w.current = !0, h(!1, T, "focus-out"));
+      });
+    }
+    if (y && xe(b))
+      return b.addEventListener("focusout", M), b.addEventListener("pointerdown", V), y.addEventListener("focusout", M), () => {
+        b.removeEventListener("focusout", M), b.removeEventListener("pointerdown", V), y.removeEventListener("focusout", M);
+      };
+  }, [r, b, y, C, c, g, W, I, h, u, a, B, N]), m.useEffect(() => {
+    var V;
+    if (r) return;
+    const M = Array.from((I == null || (V = I.portalNode) == null ? void 0 : V.querySelectorAll("[" + He("portal") + "]")) || []);
+    if (y) {
+      const T = [y, ...M, L.current, S.current, _.current.includes("reference") || N ? b : null].filter((q) => q != null), F = c || N ? En(T, $, !$) : En(T);
+      return () => {
+        F();
+      };
+    }
+  }, [r, b, y, c, _, I, N, $]), X(() => {
+    if (r || !xe(C)) return;
+    const V = oe(C), M = we(V);
+    queueMicrotask(() => {
+      const T = Z(C), F = Y.current, q = (typeof F == "number" ? T[F] : F.current) || C, G = ee(C, M);
+      !P && !G && p && Se(q, {
+        preventScroll: q === C
+      });
+    });
+  }, [r, p, C, P, Z, Y]), X(() => {
+    if (r || !C) return;
+    let V = !1;
+    const M = oe(C), T = we(M);
+    let q = v.current.openEvent;
+    const G = f.domReference.current;
+    Vt(T);
+    function Q(U) {
+      let {
+        open: Pe,
+        reason: Re,
+        event: ne,
+        nested: Ee
+      } = U;
+      Pe && (q = ne), Re === "escape-key" && f.domReference.current && Vt(f.domReference.current), Re === "hover" && ne.type === "mouseleave" && (w.current = !0), Re === "outside-press" && (Ee ? (w.current = !1, V = !0) : w.current = !(Hn(ne) || zn(ne)));
+    }
+    return x.on("openchange", Q), () => {
+      x.off("openchange", Q);
+      const U = we(M), Pe = ee(y, U) || W && _e(W.nodesRef.current, g).some((me) => {
+        var Ue;
+        return ee((Ue = me.context) == null ? void 0 : Ue.elements.floating, U);
+      });
+      (Pe || q && ["click", "mousedown"].includes(q.type)) && f.domReference.current && Vt(f.domReference.current);
+      const ne = G || T, Ee = Ze(oe(ne).body, ze());
+      queueMicrotask(() => {
+        let me = An();
+        !me && xe(ne) && y && (me = vi(Ee, ne, y)), // eslint-disable-next-line react-hooks/exhaustive-deps
+        K.current && !w.current && xe(me) && // If the focus moved somewhere else after mount, avoid returning focus
+        // since it likely entered a different element which should be
+        // respected: https://github.com/floating-ui/floating-ui/issues/2607
+        (!(me !== U && U !== M.body) || Pe) && me.focus({
+          preventScroll: V
+        });
+      });
+    };
+  }, [r, y, C, K, v, f, x, W, g]), X(() => {
+    if (!r && I)
+      return I.setFocusManagerState({
+        modal: c,
+        closeOnFocusOut: u,
+        open: p,
+        onOpenChange: h,
+        refs: f
+      }), () => {
+        I.setFocusManagerState(null);
+      };
+  }, [r, I, c, p, h, f, u]), X(() => {
+    if (r || !C || typeof MutationObserver != "function" || P) return;
+    const V = () => {
+      const T = C.getAttribute("tabindex"), F = B(), q = we(oe(y)), G = F.indexOf(q);
+      G !== -1 && (D.current = G), _.current.includes("floating") || q !== f.domReference.current && F.length === 0 ? T !== "0" && C.setAttribute("tabindex", "0") : T !== "-1" && C.setAttribute("tabindex", "-1");
+    };
+    V();
+    const M = new MutationObserver(V);
+    return M.observe(C, {
+      childList: !0,
+      subtree: !0,
+      attributes: !0
+    }), () => {
+      M.disconnect();
+    };
+  }, [r, y, C, f, _, B, P]);
+  function ve(V) {
+    return r || !d || !c ? null : /* @__PURE__ */ m.createElement(yi, {
+      ref: V === "start" ? L : S,
+      onClick: (M) => h(!1, M.nativeEvent)
+    }, typeof d == "string" ? d : "Dismiss");
+  }
+  const de = !r && $ && (c ? !N : !0) && (E || c);
+  return /* @__PURE__ */ m.createElement(m.Fragment, null, de && /* @__PURE__ */ m.createElement(Rt, {
+    "data-type": "inside",
+    ref: I?.beforeInsideRef,
+    onFocus: (V) => {
+      if (c) {
+        const T = Z();
+        Se(o[0] === "reference" ? T[0] : T[T.length - 1]);
+      } else if (I != null && I.preserveTabOrder && I.portalNode)
+        if (w.current = !1, Ge(V, I.portalNode)) {
+          const T = dr() || b;
+          T?.focus();
+        } else {
+          var M;
+          (M = I.beforeOutsideRef.current) == null || M.focus();
+        }
+    }
+  }), !N && ve("start"), n, ve("end"), de && /* @__PURE__ */ m.createElement(Rt, {
+    "data-type": "inside",
+    ref: I?.afterInsideRef,
+    onFocus: (V) => {
+      if (c)
+        Se(Z()[0]);
+      else if (I != null && I.preserveTabOrder && I.portalNode)
+        if (u && (w.current = !0), Ge(V, I.portalNode)) {
+          const T = mr() || b;
+          T?.focus();
+        } else {
+          var M;
+          (M = I.afterOutsideRef.current) == null || M.focus();
+        }
+    }
+  }));
+}
+const Ri = {
+  pointerdown: "onPointerDown",
+  mousedown: "onMouseDown",
+  click: "onClick"
+}, Ei = {
+  pointerdown: "onPointerDownCapture",
+  mousedown: "onMouseDownCapture",
+  click: "onClickCapture"
+}, On = (e) => {
+  var t, n;
+  return {
+    escapeKey: typeof e == "boolean" ? e : (t = e?.escapeKey) != null ? t : !1,
+    outsidePress: typeof e == "boolean" ? e : (n = e?.outsidePress) != null ? n : !0
+  };
+};
+function Zi(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    elements: o,
+    dataRef: i
+  } = e, {
+    enabled: s = !0,
+    escapeKey: l = !0,
+    outsidePress: a = !0,
+    outsidePressEvent: c = "pointerdown",
+    referencePress: d = !1,
+    referencePressEvent: u = "pointerdown",
+    ancestorScroll: p = !1,
+    bubbles: f,
+    capture: g
+  } = t, h = Ot(), x = ae(typeof a == "function" ? a : () => !1), v = typeof a == "function" ? x : a, R = m.useRef(!1), b = m.useRef(!1), {
+    escapeKey: y,
+    outsidePress: P
+  } = On(f), {
+    escapeKey: N,
+    outsidePress: $
+  } = On(g), _ = ae((S) => {
+    var w;
+    if (!n || !s || !l || S.key !== "Escape")
+      return;
+    const O = (w = i.current.floatingContext) == null ? void 0 : w.nodeId, D = h ? _e(h.nodesRef.current, O) : [];
+    if (!y && (S.stopPropagation(), D.length > 0)) {
+      let E = !0;
+      if (D.forEach((C) => {
+        var B;
+        if ((B = C.context) != null && B.open && !C.context.dataRef.current.__escapeKeyBubbles) {
+          E = !1;
+          return;
+        }
+      }), !E)
+        return;
+    }
+    r(!1, Nr(S) ? S.nativeEvent : S, "escape-key");
+  }), Y = ae((S) => {
+    var w;
+    const O = () => {
+      var D;
+      _(S), (D = Ne(S)) == null || D.removeEventListener("keydown", O);
+    };
+    (w = Ne(S)) == null || w.addEventListener("keydown", O);
+  }), K = ae((S) => {
+    var w;
+    const O = R.current;
+    R.current = !1;
+    const D = b.current;
+    if (b.current = !1, c === "click" && D || O || typeof v == "function" && !v(S))
+      return;
+    const E = Ne(S), C = "[" + He("inert") + "]", B = oe(o.floating).querySelectorAll(C);
+    let Z = ce(E) ? E : null;
+    for (; Z && !cn(Z); ) {
+      const M = Dr(Z);
+      if (cn(M) || !ce(M))
+        break;
+      Z = M;
+    }
+    if (B.length && ce(E) && !Lr(E) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !ee(E, o.floating) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(B).every((M) => !ee(Z, M)))
+      return;
+    if (xe(E) && L) {
+      const M = E.clientWidth > 0 && E.scrollWidth > E.clientWidth, T = E.clientHeight > 0 && E.scrollHeight > E.clientHeight;
+      let F = T && S.offsetX > E.clientWidth;
+      if (T && Mr(E).direction === "rtl" && (F = S.offsetX <= E.offsetWidth - E.clientWidth), F || M && S.offsetY > E.clientHeight)
+        return;
+    }
+    const ve = (w = i.current.floatingContext) == null ? void 0 : w.nodeId, de = h && _e(h.nodesRef.current, ve).some((M) => {
+      var T;
+      return Dt(S, (T = M.context) == null ? void 0 : T.elements.floating);
+    });
+    if (Dt(S, o.floating) || Dt(S, o.domReference) || de)
+      return;
+    const V = h ? _e(h.nodesRef.current, ve) : [];
+    if (V.length > 0) {
+      let M = !0;
+      if (V.forEach((T) => {
+        var F;
+        if ((F = T.context) != null && F.open && !T.context.dataRef.current.__outsidePressBubbles) {
+          M = !1;
+          return;
+        }
+      }), !M)
+        return;
+    }
+    r(!1, S, "outside-press");
+  }), W = ae((S) => {
+    var w;
+    const O = () => {
+      var D;
+      K(S), (D = Ne(S)) == null || D.removeEventListener(c, O);
+    };
+    (w = Ne(S)) == null || w.addEventListener(c, O);
+  });
+  m.useEffect(() => {
+    if (!n || !s)
+      return;
+    i.current.__escapeKeyBubbles = y, i.current.__outsidePressBubbles = P;
+    function S(D) {
+      r(!1, D, "ancestor-scroll");
+    }
+    const w = oe(o.floating);
+    l && w.addEventListener("keydown", N ? Y : _, N), v && w.addEventListener(c, $ ? W : K, $);
+    let O = [];
+    return p && (ce(o.domReference) && (O = Ae(o.domReference)), ce(o.floating) && (O = O.concat(Ae(o.floating))), !ce(o.reference) && o.reference && o.reference.contextElement && (O = O.concat(Ae(o.reference.contextElement)))), O = O.filter((D) => {
+      var E;
+      return D !== ((E = w.defaultView) == null ? void 0 : E.visualViewport);
+    }), O.forEach((D) => {
+      D.addEventListener("scroll", S, {
+        passive: !0
+      });
+    }), () => {
+      l && w.removeEventListener("keydown", N ? Y : _, N), v && w.removeEventListener(c, $ ? W : K, $), O.forEach((D) => {
+        D.removeEventListener("scroll", S);
+      });
+    };
+  }, [i, o, l, v, c, n, r, p, s, y, P, _, N, Y, K, $, W]), m.useEffect(() => {
+    R.current = !1;
+  }, [v, c]);
+  const I = m.useMemo(() => ({
+    onKeyDown: _,
+    [Ri[u]]: (S) => {
+      d && r(!1, S.nativeEvent, "reference-press");
+    }
+  }), [_, r, d, u]), L = m.useMemo(() => ({
+    onKeyDown: _,
+    onMouseDown() {
+      b.current = !0;
+    },
+    onMouseUp() {
+      b.current = !0;
+    },
+    [Ei[c]]: () => {
+      R.current = !0;
+    }
+  }), [_, c]);
+  return m.useMemo(() => s ? {
+    reference: I,
+    floating: L
+  } : {}, [s, I, L]);
+}
+function Ci(e) {
+  const {
+    open: t = !1,
+    onOpenChange: n,
+    elements: r
+  } = e, o = Qt(), i = m.useRef({}), [s] = m.useState(() => ai()), l = en() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const f = r.reference;
+    f && !ce(f) && li("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [a, c] = m.useState(r.reference), d = ae((f, g, h) => {
+    i.current.openEvent = f ? g : void 0, s.emit("openchange", {
+      open: f,
+      event: g,
+      reason: h,
+      nested: l
+    }), n?.(f, g, h);
+  }), u = m.useMemo(() => ({
+    setPositionReference: c
+  }), []), p = m.useMemo(() => ({
+    reference: a || r.reference || null,
+    floating: r.floating || null,
+    domReference: r.reference
+  }), [a, r.reference, r.floating]);
+  return m.useMemo(() => ({
+    dataRef: i,
+    open: t,
+    onOpenChange: d,
+    elements: p,
+    events: s,
+    floatingId: o,
+    refs: u
+  }), [t, d, p, s, o, u]);
+}
+function Ji(e) {
+  e === void 0 && (e = {});
+  const {
+    nodeId: t
+  } = e, n = Ci({
+    ...e,
+    elements: {
+      reference: null,
+      floating: null,
+      ...e.elements
+    }
+  }), r = e.rootContext || n, o = r.elements, [i, s] = m.useState(null), [l, a] = m.useState(null), d = o?.reference || i, u = m.useRef(null), p = Ot();
+  X(() => {
+    d && (u.current = d);
+  }, [d]);
+  const f = Zo({
+    ...e,
+    elements: {
+      ...o,
+      ...l && {
+        reference: l
+      }
+    }
+  }), g = m.useCallback((b) => {
+    const y = ce(b) ? {
+      getBoundingClientRect: () => b.getBoundingClientRect(),
+      contextElement: b
+    } : b;
+    a(y), f.refs.setReference(y);
+  }, [f.refs]), h = m.useCallback((b) => {
+    (ce(b) || b === null) && (u.current = b, s(b)), (ce(f.refs.reference.current) || f.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    b !== null && !ce(b)) && f.refs.setReference(b);
+  }, [f.refs]), x = m.useMemo(() => ({
+    ...f.refs,
+    setReference: h,
+    setPositionReference: g,
+    domReference: u
+  }), [f.refs, h, g]), v = m.useMemo(() => ({
+    ...f.elements,
+    domReference: d
+  }), [f.elements, d]), R = m.useMemo(() => ({
+    ...f,
+    ...r,
+    refs: x,
+    elements: v,
+    nodeId: t
+  }), [f, x, v, t, r]);
+  return X(() => {
+    r.dataRef.current.floatingContext = R;
+    const b = p?.nodesRef.current.find((y) => y.id === t);
+    b && (b.context = R);
+  }), m.useMemo(() => ({
+    ...f,
+    context: R,
+    refs: x,
+    elements: v
+  }), [f, x, v, R]);
+}
+const Mn = "active", Dn = "selected";
+function _t(e, t, n) {
+  const r = /* @__PURE__ */ new Map(), o = n === "item";
+  let i = e;
+  if (o && e) {
+    const {
+      [Mn]: s,
+      [Dn]: l,
+      ...a
+    } = e;
+    i = a;
+  }
+  return {
+    ...n === "floating" && {
+      tabIndex: -1,
+      [qt]: ""
+    },
+    ...i,
+    ...t.map((s) => {
+      const l = s ? s[n] : null;
+      return typeof l == "function" ? e ? l(e) : null : l;
+    }).concat(e).reduce((s, l) => (l && Object.entries(l).forEach((a) => {
+      let [c, d] = a;
+      if (!(o && [Mn, Dn].includes(c)))
+        if (c.indexOf("on") === 0) {
+          if (r.has(c) || r.set(c, []), typeof d == "function") {
+            var u;
+            (u = r.get(c)) == null || u.push(d), s[c] = function() {
+              for (var p, f = arguments.length, g = new Array(f), h = 0; h < f; h++)
+                g[h] = arguments[h];
+              return (p = r.get(c)) == null ? void 0 : p.map((x) => x(...g)).find((x) => x !== void 0);
+            };
+          }
+        } else
+          s[c] = d;
+    }), s), {})
+  };
+}
+function Qi(e) {
+  e === void 0 && (e = []);
+  const t = e.map((l) => l?.reference), n = e.map((l) => l?.floating), r = e.map((l) => l?.item), o = m.useCallback(
+    (l) => _t(l, e, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), i = m.useCallback(
+    (l) => _t(l, e, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    n
+  ), s = m.useCallback(
+    (l) => _t(l, e, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    r
+  );
+  return m.useMemo(() => ({
+    getReferenceProps: o,
+    getFloatingProps: i,
+    getItemProps: s
+  }), [o, i, s]);
+}
+let Pn = !1;
+function Mt(e, t, n) {
+  switch (e) {
+    case "vertical":
+      return t;
+    case "horizontal":
+      return n;
+    default:
+      return t || n;
+  }
+}
+function Fn(e, t) {
+  return Mt(t, e === Jt || e === ot, e === Ke || e === je);
+}
+function $t(e, t, n) {
+  return Mt(t, e === ot, n ? e === Ke : e === je) || e === "Enter" || e === " " || e === "";
+}
+function Ii(e, t, n) {
+  return Mt(t, n ? e === Ke : e === je, e === ot);
+}
+function Nn(e, t, n) {
+  return Mt(t, n ? e === je : e === Ke, e === Jt);
+}
+function es(e, t) {
+  const {
+    open: n,
+    onOpenChange: r,
+    elements: o
+  } = e, {
+    listRef: i,
+    activeIndex: s,
+    onNavigate: l = () => {
+    },
+    enabled: a = !0,
+    selectedIndex: c = null,
+    allowEscape: d = !1,
+    loop: u = !1,
+    nested: p = !1,
+    rtl: f = !1,
+    virtual: g = !1,
+    focusItemOnOpen: h = "auto",
+    focusItemOnHover: x = !0,
+    openOnArrowKeyDown: v = !0,
+    disabledIndices: R = void 0,
+    orientation: b = "vertical",
+    cols: y = 1,
+    scrollItemIntoView: P = !0,
+    virtualItemRef: N,
+    itemSizes: $,
+    dense: _ = !1
+  } = t;
+  process.env.NODE_ENV !== "production" && (d && (u || Lt("`useListNavigation` looping must be enabled to allow escaping."), g || Lt("`useListNavigation` must be virtual to allow escaping.")), b === "vertical" && y > 1 && Lt("In grid list navigation mode (`cols` > 1), the `orientation` should", 'be either "horizontal" or "both".'));
+  const Y = hr(o.floating), K = Te(Y), W = en(), I = Ot(), L = ae(l), S = m.useRef(h), w = m.useRef(c ?? -1), O = m.useRef(null), D = m.useRef(!0), E = m.useRef(L), C = m.useRef(!!o.floating), B = m.useRef(n), Z = m.useRef(!1), ve = m.useRef(!1), de = Te(R), V = Te(n), M = Te(P), T = Te(c), [F, q] = m.useState(), [G, Q] = m.useState(), U = ae(function(k, j, A) {
+    A === void 0 && (A = !1);
+    function H(z) {
+      g ? (q(z.id), I?.events.emit("virtualfocus", z), N && (N.current = z)) : Se(z, {
+        preventScroll: !0,
+        // Mac Safari does not move the virtual cursor unless the focus call
+        // is sync. However, for the very first focus call, we need to wait
+        // for the position to be ready in order to prevent unwanted
+        // scrolling. This means the virtual cursor will not move to the first
+        // item when first opening the floating element, but will on
+        // subsequent calls. `preventScroll` is supported in modern Safari,
+        // so we can use that instead.
+        // iOS Safari must be async or the first item will not be focused.
+        sync: Pr() && qn() ? Pn || Z.current : !1
+      });
+    }
+    const re = k.current[j.current];
+    re && H(re), requestAnimationFrame(() => {
+      const z = k.current[j.current] || re;
+      if (!z) return;
+      re || H(z);
+      const ge = M.current;
+      ge && Re && (A || !D.current) && (z.scrollIntoView == null || z.scrollIntoView(typeof ge == "boolean" ? {
+        block: "nearest",
+        inline: "nearest"
+      } : ge));
+    });
+  });
+  X(() => {
+    document.createElement("div").focus({
+      get preventScroll() {
+        return Pn = !0, !1;
+      }
+    });
+  }, []), X(() => {
+    a && (n && o.floating ? S.current && c != null && (ve.current = !0, w.current = c, L(c)) : C.current && (w.current = -1, E.current(null)));
+  }, [a, n, o.floating, c, L]), X(() => {
+    if (a && n && o.floating)
+      if (s == null) {
+        if (Z.current = !1, T.current != null)
+          return;
+        if (C.current && (w.current = -1, U(i, w)), (!B.current || !C.current) && S.current && (O.current != null || S.current === !0 && O.current == null)) {
+          let k = 0;
+          const j = () => {
+            i.current[0] == null ? (k < 2 && (k ? requestAnimationFrame : queueMicrotask)(j), k++) : (w.current = O.current == null || $t(O.current, b, f) || p ? Nt(i, de.current) : xn(i, de.current), O.current = null, L(w.current));
+          };
+          j();
+        }
+      } else Ye(i, s) || (w.current = s, U(i, w, ve.current), ve.current = !1);
+  }, [a, n, o.floating, s, T, p, i, b, f, L, U, de]), X(() => {
+    var k;
+    if (!a || o.floating || !I || g || !C.current)
+      return;
+    const j = I.nodesRef.current, A = (k = j.find((z) => z.id === W)) == null || (k = k.context) == null ? void 0 : k.elements.floating, H = we(oe(o.floating)), re = j.some((z) => z.context && ee(z.context.elements.floating, H));
+    A && !re && D.current && A.focus({
+      preventScroll: !0
+    });
+  }, [a, o.floating, I, W, g]), X(() => {
+    if (!a || !I || !g || W) return;
+    function k(j) {
+      Q(j.id), N && (N.current = j);
+    }
+    return I.events.on("virtualfocus", k), () => {
+      I.events.off("virtualfocus", k);
+    };
+  }, [a, I, g, W, N]), X(() => {
+    E.current = L, C.current = !!o.floating;
+  }), X(() => {
+    n || (O.current = null);
+  }, [n]), X(() => {
+    B.current = n;
+  }, [n]);
+  const Pe = s != null, Re = m.useMemo(() => {
+    function k(A) {
+      if (!n) return;
+      const H = i.current.indexOf(A);
+      H !== -1 && L(H);
+    }
+    return {
+      onFocus(A) {
+        let {
+          currentTarget: H
+        } = A;
+        k(H);
+      },
+      onClick: (A) => {
+        let {
+          currentTarget: H
+        } = A;
+        return H.focus({
+          preventScroll: !0
+        });
+      },
+      // Safari
+      ...x && {
+        onMouseMove(A) {
+          let {
+            currentTarget: H
+          } = A;
+          k(H);
+        },
+        onPointerLeave(A) {
+          let {
+            pointerType: H
+          } = A;
+          !D.current || H === "touch" || (w.current = -1, U(i, w), L(null), g || Se(K.current, {
+            preventScroll: !0
+          }));
+        }
+      }
+    };
+  }, [n, K, U, x, i, L, g]), ne = ae((k) => {
+    if (D.current = !1, Z.current = !0, !V.current && k.currentTarget === K.current)
+      return;
+    if (p && Nn(k.key, b, f)) {
+      te(k), r(!1, k.nativeEvent, "list-navigation"), xe(o.domReference) && !g && o.domReference.focus();
+      return;
+    }
+    const j = w.current, A = Nt(i, R), H = xn(i, R);
+    if (k.key === "Home" && (te(k), w.current = A, L(w.current)), k.key === "End" && (te(k), w.current = H, L(w.current)), y > 1) {
+      const re = $ || Array.from({
+        length: i.current.length
+      }, () => ({
+        width: 1,
+        height: 1
+      })), z = ni(re, y, _), ge = z.findIndex((le) => le != null && !mt(i.current, le, R)), it = z.reduce((le, Ce, st) => Ce != null && !mt(i.current, Ce, R) ? st : le, -1), Xe = z[ti({
+        current: z.map((le) => le != null ? i.current[le] : null)
+      }, {
+        event: k,
+        orientation: b,
+        loop: u,
+        cols: y,
+        // treat undefined (empty grid spaces) as disabled indices so we
+        // don't end up in them
+        disabledIndices: oi([...R || i.current.map((le, Ce) => mt(i.current, Ce) ? Ce : void 0), void 0], z),
+        minIndex: ge,
+        maxIndex: it,
+        prevIndex: ri(
+          w.current > H ? A : w.current,
+          re,
+          z,
+          y,
+          // use a corner matching the edge closest to the direction
+          // we're moving in so we don't end up in the same item. Prefer
+          // top/left over bottom/right.
+          k.key === ot ? "bl" : k.key === je ? "tr" : "tl"
+        ),
+        stopEvent: !0
+      })];
+      if (Xe != null && (w.current = Xe, L(w.current)), b === "both")
+        return;
+    }
+    if (Fn(k.key, b)) {
+      if (te(k), n && !g && we(k.currentTarget.ownerDocument) === k.currentTarget) {
+        w.current = $t(k.key, b, f) ? A : H, L(w.current);
+        return;
+      }
+      $t(k.key, b, f) ? u ? w.current = j >= H ? d && j !== i.current.length ? -1 : A : J(i, {
+        startingIndex: j,
+        disabledIndices: R
+      }) : w.current = Math.min(H, J(i, {
+        startingIndex: j,
+        disabledIndices: R
+      })) : u ? w.current = j <= A ? d && j !== -1 ? i.current.length : H : J(i, {
+        startingIndex: j,
+        decrement: !0,
+        disabledIndices: R
+      }) : w.current = Math.max(A, J(i, {
+        startingIndex: j,
+        decrement: !0,
+        disabledIndices: R
+      })), Ye(i, w.current) ? L(null) : L(w.current);
+    }
+  }), Ee = m.useMemo(() => g && n && Pe && {
+    "aria-activedescendant": G || F
+  }, [g, n, Pe, G, F]), me = m.useMemo(() => ({
+    "aria-orientation": b === "both" ? void 0 : b,
+    ...!jn(o.domReference) && Ee,
+    onKeyDown: ne,
+    onPointerMove() {
+      D.current = !0;
+    }
+  }), [Ee, ne, o.domReference, b]), Ue = m.useMemo(() => {
+    function k(A) {
+      h === "auto" && Hn(A.nativeEvent) && (S.current = !0);
+    }
+    function j(A) {
+      S.current = h, h === "auto" && zn(A.nativeEvent) && (S.current = !0);
+    }
+    return {
+      ...Ee,
+      onKeyDown(A) {
+        D.current = !1;
+        const H = A.key.indexOf("Arrow") === 0, re = Ii(A.key, b, f), z = Nn(A.key, b, f), ge = Fn(A.key, b), it = (p ? re : ge) || A.key === "Enter" || A.key.trim() === "";
+        if (g && n) {
+          const st = I?.nodesRef.current.find((ct) => ct.parentId == null), Ie = I && st ? mi(I.nodesRef.current, st.id) : null;
+          if (H && Ie && N) {
+            const ct = new KeyboardEvent("keydown", {
+              key: A.key,
+              bubbles: !0
+            });
+            if (re || z) {
+              var Xe, le;
+              const wr = ((Xe = Ie.context) == null ? void 0 : Xe.elements.domReference) === A.currentTarget, rn = z && !wr ? (le = Ie.context) == null ? void 0 : le.elements.domReference : re ? i.current.find((on) => on?.id === F) : null;
+              rn && (te(A), rn.dispatchEvent(ct), Q(void 0));
+            }
+            if (ge && Ie.context && Ie.context.open && Ie.parentId && A.currentTarget !== Ie.context.elements.domReference) {
+              var Ce;
+              te(A), (Ce = Ie.context.elements.domReference) == null || Ce.dispatchEvent(ct);
+              return;
+            }
+          }
+          return ne(A);
+        }
+        if (!(!n && !v && H)) {
+          if (it && (O.current = p && ge ? null : A.key), p) {
+            re && (te(A), n ? (w.current = Nt(i, de.current), L(w.current)) : r(!0, A.nativeEvent, "list-navigation"));
+            return;
+          }
+          ge && (c != null && (w.current = c), te(A), !n && v ? r(!0, A.nativeEvent, "list-navigation") : ne(A), n && L(w.current));
+        }
+      },
+      onFocus() {
+        n && !g && L(null);
+      },
+      onPointerDown: j,
+      onMouseDown: k,
+      onClick: k
+    };
+  }, [F, Ee, ne, de, h, i, p, L, r, n, v, b, f, c, I, g, N]);
+  return m.useMemo(() => a ? {
+    reference: Ue,
+    floating: me,
+    item: Re
+  } : {}, [a, Ue, me, Re]);
+}
+const Si = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", !1]]);
+function ts(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    open: r,
+    floatingId: o
+  } = e, {
+    enabled: i = !0,
+    role: s = "dialog"
+  } = t, l = (n = Si.get(s)) != null ? n : s, a = Qt(), d = en() != null, u = m.useMemo(() => l === "tooltip" || s === "label" ? {
+    ["aria-" + (s === "label" ? "labelledby" : "describedby")]: r ? o : void 0
+  } : {
+    "aria-expanded": r ? "true" : "false",
+    "aria-haspopup": l === "alertdialog" ? "dialog" : l,
+    "aria-controls": r ? o : void 0,
+    ...l === "listbox" && {
+      role: "combobox"
+    },
+    ...l === "menu" && {
+      id: a
+    },
+    ...l === "menu" && d && {
+      role: "menuitem"
+    },
+    ...s === "select" && {
+      "aria-autocomplete": "none"
+    },
+    ...s === "combobox" && {
+      "aria-autocomplete": "list"
+    }
+  }, [l, o, d, r, a, s]), p = m.useMemo(() => {
+    const g = {
+      id: o,
+      ...l && {
+        role: l
+      }
+    };
+    return l === "tooltip" || s === "label" ? g : {
+      ...g,
+      ...l === "menu" && {
+        "aria-labelledby": a
+      }
+    };
+  }, [l, o, a, s]), f = m.useCallback((g) => {
+    let {
+      active: h,
+      selected: x
+    } = g;
+    const v = {
+      role: "option",
+      ...h && {
+        id: o + "-option"
+      }
+    };
+    switch (s) {
+      case "select":
+        return {
+          ...v,
+          "aria-selected": h && x
+        };
+      case "combobox":
+        return {
+          ...v,
+          ...h && {
+            "aria-selected": !0
+          }
+        };
+    }
+    return {};
+  }, [o, s]);
+  return m.useMemo(() => i ? {
+    reference: u,
+    floating: p,
+    item: f
+  } : {}, [i, u, p, f]);
+}
+const Ti = jt(void 0), br = jt({
+  activeIndex: 0
+}), Ai = (e, t) => t.type === "SET_ACTIVE_INDEX" ? {
+  ...e,
+  activeIndex: t.payload
+} : e, vr = jt(() => {
+  throw new Error("ComboboxIdDispatch must be used within a provider");
+}), ns = ({ children: e }) => {
+  const [t, n] = Rr(Ai, {
+    activeIndex: 0
+  });
+  return Oe(br.Provider, { value: t, children: Oe(vr.Provider, { value: n, children: e }) });
+};
+function rs() {
+  return Ut(vr);
+}
+function Oi() {
+  return Ut(br);
+}
+const Mi = Qe(({ asChild: e, interactive: t, id: n, className: r, ...o }, i) => {
+  if (t && !n)
+    throw new Error("If ComboboxCustom is interactive, it must have an id");
+  const s = e ? Sr : "div", l = Er(), { activeIndex: a } = Oi(), c = Ut(Ti);
+  if (!c)
+    throw new Error("ComboboxCustom must be used within a Combobox");
+  const { customIds: d, setListRef: u, getItemProps: p, size: f } = c, g = Cr(() => n && d.indexOf(n) || 0, [n, d]), h = Jo([
+    (x) => {
+      u(g, x);
+    },
+    i
+  ]);
+  return Oe(Tr, { "data-size": f, asChild: !0, children: Oe(s, { ref: h, tabIndex: -1, className: Ln("ds-combobox__custom", r), id: n || l, role: "option", "aria-selected": a === g, "data-active": a === g, ...sn(["interactive"], o), ...sn(["onClick", "onPointerLeave"], p()) }) });
+});
+function Di(e) {
+  return Ir(e) && e.type === Mi;
+}
+function os(e) {
+  return Di(e) && e.props.interactive === !0;
+}
+const xr = "internal-option-", is = (e) => xr + e, ss = (e) => e.slice(xr.length), Pi = (e, t) => {
+  const n = e.value;
+  e.value = t;
+  const r = e._valueTracker;
+  typeof r < "u" && r.setValue(n), e.dispatchEvent(new Event("change", { bubbles: !0 }));
+}, Fi = Qe(function({ className: t, ...n }, r) {
+  return Oe("div", { ref: r, className: Ln("ds-search", t), ...n });
+}), Ni = Qe(function({ children: t = "Søk", ...n }, r) {
+  return Oe(_n, { ref: r, type: "submit", ...n, children: t });
+}), Li = Qe(function({ "aria-label": t = "Tøm", onClick: n, ...r }, o) {
+  return Oe(_n, { ref: o, variant: "tertiary", type: "reset", "aria-label": t, onClick: (s) => {
+    const l = s.target;
+    let a = null;
+    if (l instanceof HTMLElement && (a = l.closest(".ds-search")?.querySelector("input")), !a)
+      throw new Error("Input is missing");
+    if (!(a instanceof HTMLInputElement))
+      throw new Error("Input is not an input element");
+    s.preventDefault(), Pi(a, ""), a.focus(), n?.(s);
+  }, icon: !0, ...r });
+}), ki = Qe(function({ ...t }, n) {
+  return Oe(Ar, {
+    ref: n,
+    type: "search",
+    /* We need an empty placeholder for the clear button to be able to show/hide */
+    placeholder: "",
+    ...t
+  });
+}), nn = Object.assign(Fi, {
+  Clear: Li,
+  Button: Ni,
+  Input: ki
+});
+nn.Clear.displayName = "Search.Clear";
+nn.Button.displayName = "Search.Button";
+nn.Input.displayName = "Search.Input";
+export {
+  Ti as C,
+  Yi as F,
+  nn as S,
+  Jo as a,
+  Oi as b,
+  Ji as c,
+  ts as d,
+  Zi as e,
+  es as f,
+  Qi as g,
+  Ui as h,
+  os as i,
+  ji as j,
+  zi as k,
+  ns as l,
+  Pi as m,
+  Gi as n,
+  sn as o,
+  is as p,
+  Mi as q,
+  ss as r,
+  Xi as s,
+  Go as t,
+  rs as u,
+  Uo as v,
+  Xo as w,
+  qi as x
+};