@prokodo/ui 0.0.4 → 0.0.6

package/dist/components/Select-BMyrX8V0.js

@@ -0,0 +1,3081 @@
+import { j as _ } from "./jsx-runtime-C5mzlN2N.js";
+import * as a from "react";
+import { useLayoutEffect as hn, useEffect as Vt, memo as mn, useState as ft, useCallback as bn } from "react";
+import { c as xn } from "./bem-CYKrPjje.js";
+import { i as dt, d as pt, a as gt } from "./validations-B_cxltQ_.js";
+import { L as yn } from "./Label-DRUCdGoX.js";
+import { a as tt, g as nt, u as le, e as ae, i as ht, b as Pe, c as ot, d as rt, P as m, s as mt } from "./ClassNameConfigurator-Ce5BUPXc.js";
+import * as At from "react-dom";
+import { a as bt, u as Oe, v as wn } from "./areArraysEqual-CJkStQkx.js";
+const Cn = "exact-prop: ​";
+function Rn(e) {
+  return process.env.NODE_ENV === "production" ? e : {
+    ...e,
+    [Cn]: (t) => {
+      const n = Object.keys(t).filter((o) => !e.hasOwnProperty(o));
+      return n.length > 0 ? new Error(`The following props are not supported: ${n.map((o) => `\`${o}\``).join(", ")}. Please remove them.`) : null;
+    }
+  };
+}
+function Xe(e, t, n, o, r) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const i = e[t], s = r || t;
+  return i == null ? null : i && i.nodeType !== 1 ? new Error(`Invalid ${o} \`${s}\` supplied to \`${n}\`. Expected an HTMLElement.`) : null;
+}
+let xt = 0;
+function vn(e) {
+  const [t, n] = a.useState(e), o = e || t;
+  return a.useEffect(() => {
+    t == null && (xt += 1, n(`mui-${xt}`));
+  }, [t]), o;
+}
+const yt = a.useId;
+function Mt(e) {
+  if (yt !== void 0) {
+    const t = yt();
+    return e ?? t;
+  }
+  return vn(e);
+}
+function Sn(e) {
+  return !e || !/* @__PURE__ */ a.isValidElement(e) ? null : e.props.propertyIsEnumerable("ref") ? e.props.ref : (
+    // @ts-expect-error element.ref is not included in the ReactElement type
+    // We cannot check for it, but isValidElement is true at this point
+    // https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/70189
+    e.ref
+  );
+}
+const Dt = "Option";
+function Pn(e) {
+  return tt(Dt, e);
+}
+nt(Dt, ["root", "disabled", "selected", "highlighted"]);
+function On(e) {
+  const {
+    rootElementName: t = "",
+    componentName: n
+  } = e, [o, r] = a.useState(t.toUpperCase());
+  process.env.NODE_ENV !== "production" && a.useEffect(() => {
+    t && o !== t.toUpperCase() && console.error(`useRootElementName: the \`rootElementName\` prop of ${n ? `the ${n} component` : "a component"} expected the '${t}' element, but a '${o.toLowerCase()}' was rendered instead`, "This may cause hydration issues in an SSR context, for example in a Next.js app");
+  }, [t, o, n]);
+  const i = a.useCallback((s) => {
+    r((s == null ? void 0 : s.tagName) ?? "");
+  }, []);
+  return [o, i];
+}
+const z = {
+  blur: "list:blur",
+  itemClick: "list:itemClick",
+  itemHover: "list:itemHover",
+  itemsChange: "list:itemsChange",
+  keyDown: "list:keyDown",
+  resetHighlight: "list:resetHighlight",
+  highlightLast: "list:highlightLast",
+  textNavigation: "list:textNavigation",
+  clearSelection: "list:clearSelection"
+};
+function kn(e, t, n, o, r, i) {
+  if (n.length === 0 || !o && n.every((l, c) => r(l, c)))
+    return -1;
+  let s = e;
+  for (; ; ) {
+    if (!i && t === "next" && s === n.length || !i && t === "previous" && s === -1)
+      return -1;
+    if (o ? !1 : r(n[s], s))
+      s += t === "next" ? 1 : -1, i && (s = (s + n.length) % n.length);
+    else
+      return s;
+  }
+}
+function J(e, t, n) {
+  const {
+    items: o,
+    isItemDisabled: r,
+    disableListWrap: i,
+    disabledItemsFocusable: s,
+    itemComparer: l,
+    focusManagement: c
+  } = n, u = c === "DOM" ? 0 : -1, p = o.length - 1, f = e == null ? -1 : o.findIndex((R) => l(R, e));
+  let g, d, h = !i;
+  switch (t) {
+    case "reset":
+      if (u === -1)
+        return null;
+      g = 0, d = "next", h = !1;
+      break;
+    case "start":
+      g = 0, d = "next", h = !1;
+      break;
+    case "end":
+      g = p, d = "previous", h = !1;
+      break;
+    default: {
+      const R = f + t;
+      R < 0 ? !h && f !== -1 || Math.abs(t) > 1 ? (g = 0, d = "next") : (g = p, d = "previous") : R > p ? !h || Math.abs(t) > 1 ? (g = p, d = "previous") : (g = 0, d = "next") : (g = R, d = t >= 0 ? "next" : "previous");
+    }
+  }
+  const w = kn(g, d, o, s, r, h);
+  return w === -1 && e !== null && !r(e, f) ? e : o[w] ?? null;
+}
+function En(e, t, n, o) {
+  return n === "none" ? [] : n === "single" ? o(t[0], e) ? t : [e] : t.some((r) => o(r, e)) ? t.filter((r) => !o(r, e)) : [...t, e];
+}
+function it(e, t, n) {
+  const {
+    itemComparer: o,
+    isItemDisabled: r,
+    selectionMode: i,
+    items: s
+  } = n, {
+    selectedValues: l
+  } = t, c = s.findIndex((p) => o(e, p));
+  if (r(e, c))
+    return t;
+  const u = En(e, l, i, o);
+  return {
+    ...t,
+    selectedValues: u,
+    highlightedValue: e
+  };
+}
+function Tn(e, t, n) {
+  const o = t.highlightedValue, {
+    orientation: r,
+    pageSize: i
+  } = n;
+  switch (e) {
+    case "Home":
+      return {
+        ...t,
+        highlightedValue: J(o, "start", n)
+      };
+    case "End":
+      return {
+        ...t,
+        highlightedValue: J(o, "end", n)
+      };
+    case "PageUp":
+      return {
+        ...t,
+        highlightedValue: J(o, -i, n)
+      };
+    case "PageDown":
+      return {
+        ...t,
+        highlightedValue: J(o, i, n)
+      };
+    case "ArrowUp":
+      if (r !== "vertical")
+        break;
+      return {
+        ...t,
+        highlightedValue: J(o, -1, n)
+      };
+    case "ArrowDown":
+      if (r !== "vertical")
+        break;
+      return {
+        ...t,
+        highlightedValue: J(o, 1, n)
+      };
+    case "ArrowLeft": {
+      if (r === "vertical")
+        break;
+      return {
+        ...t,
+        highlightedValue: J(o, r === "horizontal-ltr" ? -1 : 1, n)
+      };
+    }
+    case "ArrowRight": {
+      if (r === "vertical")
+        break;
+      return {
+        ...t,
+        highlightedValue: J(o, r === "horizontal-ltr" ? 1 : -1, n)
+      };
+    }
+    case "Enter":
+    case " ":
+      return t.highlightedValue === null ? t : it(t.highlightedValue, t, n);
+  }
+  return t;
+}
+function Nn(e, t) {
+  return t.focusManagement === "DOM" ? e : {
+    ...e,
+    highlightedValue: null
+  };
+}
+function Vn(e, t, n) {
+  var r;
+  const o = (r = n(e)) == null ? void 0 : r.trim().toLowerCase();
+  return !o || o.length === 0 ? !1 : o.startsWith(t);
+}
+function An(e, t, n) {
+  const {
+    items: o,
+    isItemDisabled: r,
+    disabledItemsFocusable: i,
+    getItemAsString: s
+  } = n, l = t.length > 1;
+  let c = l ? e.highlightedValue : J(e.highlightedValue, 1, n);
+  for (let u = 0; u < o.length; u += 1) {
+    if (!c || !l && e.highlightedValue === c)
+      return e;
+    if (Vn(c, t, s) && (!r(c, o.indexOf(c)) || i))
+      return {
+        ...e,
+        highlightedValue: c
+      };
+    c = J(c, 1, n);
+  }
+  return e;
+}
+function Mn(e, t, n, o) {
+  const {
+    itemComparer: r,
+    focusManagement: i
+  } = o;
+  let s = null;
+  n.highlightedValue != null ? s = e.find((u) => r(u, n.highlightedValue)) ?? null : i === "DOM" && t.length === 0 && (s = J(null, "reset", o));
+  const c = (n.selectedValues ?? []).filter((u) => e.some((p) => r(p, u)));
+  return {
+    ...n,
+    highlightedValue: s,
+    selectedValues: c
+  };
+}
+function Dn(e, t) {
+  return {
+    ...e,
+    highlightedValue: J(null, "reset", t)
+  };
+}
+function In(e, t) {
+  return {
+    ...e,
+    highlightedValue: J(null, "end", t)
+  };
+}
+function _n(e, t) {
+  return {
+    ...e,
+    selectedValues: [],
+    highlightedValue: J(null, "reset", t)
+  };
+}
+function It(e, t) {
+  const {
+    type: n,
+    context: o
+  } = t;
+  switch (n) {
+    case z.keyDown:
+      return Tn(t.key, e, o);
+    case z.itemClick:
+      return it(t.item, e, o);
+    case z.blur:
+      return Nn(e, o);
+    case z.textNavigation:
+      return An(e, t.searchString, o);
+    case z.itemsChange:
+      return Mn(t.items, t.previousItems, e, o);
+    case z.resetHighlight:
+      return Dn(e, o);
+    case z.highlightLast:
+      return In(e, o);
+    case z.clearSelection:
+      return _n(e, o);
+    default:
+      return e;
+  }
+}
+function Ln(e, t) {
+  return e === t;
+}
+const Ye = {}, wt = () => {
+};
+function Qe(e, t) {
+  const n = {
+    ...e
+  };
+  return Object.keys(t).forEach((o) => {
+    t[o] !== void 0 && (n[o] = t[o]);
+  }), n;
+}
+function Fn(e) {
+  const {
+    nextState: t,
+    initialState: n,
+    stateComparers: o,
+    onStateChange: r,
+    controlledProps: i,
+    lastActionRef: s
+  } = e, l = a.useRef(n);
+  a.useEffect(() => {
+    if (s.current === null)
+      return;
+    const c = Qe(l.current, i);
+    Object.keys(t).forEach((u) => {
+      const p = o[u] ?? Ln, f = t[u], g = c[u];
+      (g == null && f != null || g != null && f == null || g != null && f != null && !p(f, g)) && (r == null || r(s.current.event ?? null, u, f, s.current.type ?? "", t));
+    }), l.current = t, s.current = null;
+  }, [l, t, s, r, o, i]);
+}
+function jn(e) {
+  const t = a.useRef(null), {
+    reducer: n,
+    initialState: o,
+    controlledProps: r = Ye,
+    stateComparers: i = Ye,
+    onStateChange: s = wt,
+    actionContext: l,
+    componentName: c = ""
+  } = e, u = a.useRef(r);
+  process.env.NODE_ENV !== "production" && a.useEffect(() => {
+    Object.keys(r).forEach((h) => {
+      u.current[h] !== void 0 && r[h] === void 0 && console.error(`useControllableReducer: ${c ? `The ${c} component` : "A component"} is changing a controlled prop to be uncontrolled: ${h}`), u.current[h] === void 0 && r[h] !== void 0 && console.error(`useControllableReducer: ${c ? `The ${c} component` : "A component"} is changing an uncontrolled prop to be controlled: ${h}`);
+    });
+  }, [r, c]);
+  const p = a.useCallback((h, w) => {
+    t.current = w;
+    const R = Qe(h, r);
+    return n(R, w);
+  }, [r, n]), [f, g] = a.useReducer(p, o), d = a.useCallback((h) => {
+    g({
+      ...h,
+      context: l
+    });
+  }, [l]);
+  return Fn({
+    nextState: f,
+    initialState: o,
+    stateComparers: i ?? Ye,
+    onStateChange: s ?? wt,
+    controlledProps: r,
+    lastActionRef: t
+  }), [Qe(f, r), d];
+}
+const Bn = 500;
+function $n(e) {
+  const t = a.useRef({
+    searchString: "",
+    lastTime: null
+  });
+  return a.useCallback((n) => {
+    if (n.key.length === 1 && n.key !== " ") {
+      const o = t.current, r = n.key.toLowerCase(), i = performance.now();
+      o.searchString.length > 0 && o.lastTime && i - o.lastTime > Bn ? o.searchString = r : (o.searchString.length !== 1 || r !== o.searchString) && (o.searchString += r), o.lastTime = i, e(o.searchString, n);
+    }
+  }, [e]);
+}
+const Ct = {}, Un = () => {
+}, Wn = (e, t) => e === t, Kn = () => !1, zn = (e) => typeof e == "string" ? e : String(e), qn = () => ({
+  highlightedValue: null,
+  selectedValues: []
+});
+function Yn(e) {
+  const {
+    controlledProps: t = Ct,
+    disabledItemsFocusable: n = !1,
+    disableListWrap: o = !1,
+    focusManagement: r = "activeDescendant",
+    getInitialState: i = qn,
+    getItemDomElement: s,
+    getItemId: l,
+    isItemDisabled: c = Kn,
+    rootRef: u,
+    onStateChange: p = Un,
+    items: f,
+    itemComparer: g = Wn,
+    getItemAsString: d = zn,
+    onChange: h,
+    onHighlightChange: w,
+    onItemsChange: R,
+    orientation: P = "vertical",
+    pageSize: C = 5,
+    reducerActionContext: O = Ct,
+    selectionMode: k = "single",
+    stateReducer: E,
+    componentName: A = "useList"
+  } = e;
+  if (process.env.NODE_ENV !== "production") {
+    if (r === "DOM" && s == null)
+      throw new Error("useList: The `getItemDomElement` prop is required when using the `DOM` focus management.");
+    if (r === "activeDescendant" && l == null)
+      throw new Error("useList: The `getItemId` prop is required when using the `activeDescendant` focus management.");
+  }
+  const L = a.useRef(null), W = le(u, L), D = a.useCallback(($, M, U) => {
+    var Y;
+    w == null || w($, M, U), r === "DOM" && M != null && (U === z.itemClick || U === z.keyDown || U === z.textNavigation) && ((Y = s == null ? void 0 : s(M)) == null || Y.focus());
+  }, [s, w, r]), F = a.useMemo(() => ({
+    highlightedValue: g,
+    selectedValues: ($, M) => bt($, M, g)
+  }), [g]), y = a.useCallback(($, M, U, Y, se) => {
+    switch (p == null || p($, M, U, Y, se), M) {
+      case "highlightedValue":
+        D($, U, Y);
+        break;
+      case "selectedValues":
+        h == null || h($, U, Y);
+        break;
+    }
+  }, [D, h, p]), b = a.useMemo(() => ({
+    disabledItemsFocusable: n,
+    disableListWrap: o,
+    focusManagement: r,
+    isItemDisabled: c,
+    itemComparer: g,
+    items: f,
+    getItemAsString: d,
+    onHighlightChange: D,
+    orientation: P,
+    pageSize: C,
+    selectionMode: k,
+    stateComparers: F
+  }), [n, o, r, c, g, f, d, D, P, C, k, F]), T = i(), j = E ?? It, q = a.useMemo(() => ({
+    ...O,
+    ...b
+  }), [O, b]), [S, V] = jn({
+    reducer: j,
+    actionContext: q,
+    initialState: T,
+    controlledProps: t,
+    stateComparers: F,
+    onStateChange: y,
+    componentName: A
+  }), {
+    highlightedValue: N,
+    selectedValues: I
+  } = S, B = $n(($, M) => V({
+    type: z.textNavigation,
+    event: M,
+    searchString: $
+  })), H = a.useRef([]);
+  a.useEffect(() => {
+    bt(H.current, f, g) || (V({
+      type: z.itemsChange,
+      event: null,
+      items: f,
+      previousItems: H.current
+    }), H.current = f, R == null || R(f));
+  }, [f, g, V, R]);
+  const G = ($) => (M) => {
+    var Y;
+    if ((Y = $.onKeyDown) == null || Y.call($, M), M.defaultMuiPrevented)
+      return;
+    const U = ["Home", "End", "PageUp", "PageDown"];
+    P === "vertical" ? U.push("ArrowUp", "ArrowDown") : U.push("ArrowLeft", "ArrowRight"), r === "activeDescendant" && U.push(" ", "Enter"), U.includes(M.key) && M.preventDefault(), V({
+      type: z.keyDown,
+      key: M.key,
+      event: M
+    }), B(M);
+  }, ie = ($) => (M) => {
+    var U, Y;
+    (U = $.onBlur) == null || U.call($, M), !M.defaultMuiPrevented && ((Y = L.current) != null && Y.contains(M.relatedTarget) || V({
+      type: z.blur,
+      event: M
+    }));
+  }, ve = ($ = {}) => {
+    const M = ae($);
+    return {
+      ...$,
+      "aria-activedescendant": r === "activeDescendant" && N != null ? l(N) : void 0,
+      tabIndex: r === "DOM" ? -1 : 0,
+      ref: W,
+      ...M,
+      onBlur: ie(M),
+      onKeyDown: G(M)
+    };
+  }, xe = a.useCallback(($) => {
+    const M = (I ?? []).some((se) => se != null && g($, se)), U = N != null && g($, N);
+    return {
+      focusable: r === "DOM",
+      highlighted: U,
+      selected: M
+    };
+  }, [g, I, N, r]), ye = a.useMemo(() => ({
+    dispatch: V,
+    getItemState: xe
+  }), [V, xe]);
+  return a.useDebugValue({
+    state: S
+  }), {
+    contextValue: ye,
+    dispatch: V,
+    getRootProps: ve,
+    rootRef: W,
+    state: S
+  };
+}
+const Ee = /* @__PURE__ */ a.createContext(null);
+process.env.NODE_ENV !== "production" && (Ee.displayName = "ListContext");
+function Gn(e) {
+  const {
+    handlePointerOverEvents: t = !1,
+    item: n
+  } = e, o = a.useContext(Ee);
+  if (!o)
+    throw new Error("useListItem must be used within a ListProvider");
+  const {
+    dispatch: r,
+    getItemState: i
+  } = o, {
+    highlighted: s,
+    selected: l,
+    focusable: c
+  } = i(n), u = a.useCallback((d) => (h) => {
+    var w;
+    if ((w = d.onClick) == null || w.call(d, h), !h.defaultPrevented) {
+      if (process.env.NODE_ENV !== "production" && n === void 0)
+        throw new Error(["MUI: The `item` provided to useListItem() is undefined.", "This should happen only during server-side rendering under React 17."].join(`
+`));
+      r({
+        type: z.itemClick,
+        item: n,
+        event: h
+      });
+    }
+  }, [r, n]), p = a.useCallback((d) => (h) => {
+    var w;
+    if ((w = d.onMouseOver) == null || w.call(d, h), !h.defaultPrevented) {
+      if (process.env.NODE_ENV !== "production" && n === void 0)
+        throw new Error(["MUI: The `item` provided to useListItem() is undefined.", "This should happen only during server-side rendering under React 17."].join(`
+`));
+      r({
+        type: z.itemHover,
+        item: n,
+        event: h
+      });
+    }
+  }, [r, n]);
+  let f;
+  return c && (f = s ? 0 : -1), {
+    getRootProps: (d = {}) => {
+      const h = ae(d);
+      return {
+        ...d,
+        onClick: u(h),
+        onPointerOver: t ? p(h) : void 0,
+        tabIndex: f
+      };
+    },
+    highlighted: s,
+    selected: l
+  };
+}
+const st = /* @__PURE__ */ a.createContext(null);
+process.env.NODE_ENV !== "production" && (st.displayName = "CompoundComponentContext");
+function Jn(e) {
+  const t = Array.from(e.keys()).map((n) => {
+    const o = e.get(n);
+    return {
+      key: n,
+      subitem: o
+    };
+  });
+  return t.sort((n, o) => {
+    const r = n.subitem.ref.current, i = o.subitem.ref.current;
+    return r === null || i === null || r === i ? 0 : r.compareDocumentPosition(i) & Node.DOCUMENT_POSITION_PRECEDING ? 1 : -1;
+  }), new Map(t.map((n) => [n.key, n.subitem]));
+}
+function Xn() {
+  const [e, t] = a.useState(/* @__PURE__ */ new Map()), n = a.useRef(/* @__PURE__ */ new Set()), o = a.useCallback(function(u) {
+    n.current.delete(u), t((p) => {
+      const f = new Map(p);
+      return f.delete(u), f;
+    });
+  }, []), r = a.useCallback(function(u, p) {
+    let f;
+    return typeof u == "function" ? f = u(n.current) : f = u, n.current.add(f), t((g) => {
+      const d = new Map(g);
+      return d.set(f, p), d;
+    }), {
+      id: f,
+      deregister: () => o(f)
+    };
+  }, [o]), i = a.useMemo(() => Jn(e), [e]), s = a.useCallback(function(u) {
+    return Array.from(i.keys()).indexOf(u);
+  }, [i]);
+  return {
+    contextValue: a.useMemo(() => ({
+      getItemIndex: s,
+      registerItem: r,
+      totalSubitemCount: e.size
+    }), [s, r, e.size]),
+    subitems: i
+  };
+}
+function Qn(e, t) {
+  const n = a.useContext(st);
+  if (n === null)
+    throw new Error("useCompoundItem must be used within a useCompoundParent");
+  const {
+    registerItem: o
+  } = n, [r, i] = a.useState(typeof e == "function" ? void 0 : e);
+  return Oe(() => {
+    const {
+      id: s,
+      deregister: l
+    } = o(e, t);
+    return i(s), l;
+  }, [o, t, e]), {
+    id: r,
+    index: r !== void 0 ? n.getItemIndex(r) : -1,
+    totalItemCount: n.totalSubitemCount
+  };
+}
+function _t(e = {}) {
+  const {
+    disabled: t = !1,
+    focusableWhenDisabled: n,
+    href: o,
+    rootRef: r,
+    tabIndex: i,
+    to: s,
+    type: l,
+    rootElementName: c
+  } = e, u = a.useRef(null), [p, f] = a.useState(!1), [g, d] = a.useState(!1);
+  t && !n && g && d(!1);
+  const [h, w] = On({
+    rootElementName: c ?? (o || s ? "a" : void 0),
+    componentName: "Button"
+  }), R = (y) => (b) => {
+    var T;
+    g && b.preventDefault(), (T = y.onMouseLeave) == null || T.call(y, b);
+  }, P = (y) => (b) => {
+    var T;
+    ht(b.target) || d(!1), (T = y.onBlur) == null || T.call(y, b);
+  }, C = (y) => (b) => {
+    var T, j;
+    u.current || (u.current = b.currentTarget), ht(b.target) && (d(!0), (T = y.onFocusVisible) == null || T.call(y, b)), (j = y.onFocus) == null || j.call(y, b);
+  }, O = () => {
+    const y = u.current;
+    return h === "BUTTON" || h === "INPUT" && ["button", "submit", "reset"].includes(y == null ? void 0 : y.type) || h === "A" && (y == null ? void 0 : y.href);
+  }, k = (y) => (b) => {
+    var T;
+    t || (T = y.onClick) == null || T.call(y, b);
+  }, E = (y) => (b) => {
+    var T;
+    t || (f(!0), document.addEventListener("mouseup", () => {
+      f(!1);
+    }, {
+      once: !0
+    })), (T = y.onMouseDown) == null || T.call(y, b);
+  }, A = (y) => (b) => {
+    var T, j;
+    (T = y.onKeyDown) == null || T.call(y, b), !b.defaultMuiPrevented && (b.target === b.currentTarget && !O() && b.key === " " && b.preventDefault(), b.target === b.currentTarget && b.key === " " && !t && f(!0), b.target === b.currentTarget && !O() && b.key === "Enter" && !t && ((j = y.onClick) == null || j.call(y, b), b.preventDefault()));
+  }, L = (y) => (b) => {
+    var T, j;
+    b.target === b.currentTarget && f(!1), (T = y.onKeyUp) == null || T.call(y, b), b.target === b.currentTarget && !O() && !t && b.key === " " && !b.defaultMuiPrevented && ((j = y.onClick) == null || j.call(y, b));
+  }, W = le(w, r, u), D = {};
+  return i !== void 0 && (D.tabIndex = i), h === "BUTTON" ? (D.type = l ?? "button", n ? D["aria-disabled"] = t : D.disabled = t) : h === "INPUT" ? l && ["button", "submit", "reset"].includes(l) && (n ? D["aria-disabled"] = t : D.disabled = t) : h !== "" && (!o && !s && (D.role = "button", D.tabIndex = i ?? 0), t && (D["aria-disabled"] = t, D.tabIndex = n ? i ?? 0 : -1)), {
+    getRootProps: (y = {}) => {
+      const b = {
+        ...ae(e),
+        ...ae(y)
+      }, T = {
+        type: l,
+        ...b,
+        ...D,
+        ...y,
+        onBlur: P(b),
+        onClick: k(b),
+        onFocus: C(b),
+        onKeyDown: A(b),
+        onKeyUp: L(b),
+        onMouseDown: E(b),
+        onMouseLeave: R(b),
+        ref: W
+      };
+      return delete T.onFocusVisible, T;
+    },
+    focusVisible: g,
+    setFocusVisible: d,
+    active: p,
+    rootRef: W
+  };
+}
+function Ae(e, t) {
+  return function(o = {}) {
+    const r = {
+      ...o,
+      ...e(o)
+    };
+    return {
+      ...r,
+      ...t(r)
+    };
+  };
+}
+function Zn(e) {
+  const {
+    value: t,
+    label: n,
+    disabled: o,
+    rootRef: r,
+    id: i
+  } = e, {
+    getRootProps: s,
+    highlighted: l,
+    selected: c
+  } = Gn({
+    item: t
+  }), {
+    getRootProps: u,
+    rootRef: p
+  } = _t({
+    disabled: o,
+    focusableWhenDisabled: !0
+  }), f = Mt(i), g = a.useRef(null), d = a.useMemo(() => ({
+    disabled: o,
+    label: n,
+    value: t,
+    ref: g,
+    id: f
+  }), [o, n, t, f]), {
+    index: h
+  } = Qn(t, d), w = le(r, g, p), R = (C) => (O) => {
+    var k;
+    (k = C.onKeyDown) == null || k.call(C, O), !O.defaultMuiPrevented && [" ", "Enter"].includes(O.key) && (O.defaultMuiPrevented = !0);
+  }, P = (C = {}) => ({
+    onKeyDown: R(C)
+  });
+  return {
+    getRootProps: (C = {}) => {
+      const O = ae(C), k = Ae(s, Ae(u, P));
+      return {
+        ...C,
+        ...O,
+        ...k(O),
+        id: f,
+        ref: w,
+        role: "option",
+        "aria-selected": c
+      };
+    },
+    highlighted: l,
+    index: h,
+    selected: c,
+    rootRef: w
+  };
+}
+function Hn(e) {
+  const t = a.useContext(Ee);
+  if (!t)
+    throw new Error("Option: ListContext was not found.");
+  const {
+    getItemState: n,
+    dispatch: o
+  } = t, {
+    highlighted: r,
+    selected: i,
+    focusable: s
+  } = n(e), l = a.useCallback((u) => {
+    if (u !== e)
+      throw new Error(["Base UI Option: Tried to access the state of another Option.", "This is unsupported when the Option uses the OptionContextStabilizer as a performance optimization."].join("/n"));
+    return {
+      highlighted: r,
+      selected: i,
+      focusable: s
+    };
+  }, [r, i, s, e]);
+  return {
+    contextValue: a.useMemo(() => ({
+      dispatch: o,
+      getItemState: l
+    }), [o, l])
+  };
+}
+function eo(e) {
+  const {
+    disabled: t,
+    highlighted: n,
+    selected: o
+  } = e;
+  return ot({
+    root: ["root", t && "disabled", n && "highlighted", o && "selected"]
+  }, rt(Pn));
+}
+const to = /* @__PURE__ */ a.memo(/* @__PURE__ */ a.forwardRef(function(t, n) {
+  var E, A;
+  const {
+    children: o,
+    disabled: r = !1,
+    label: i,
+    slotProps: s = {},
+    slots: l = {},
+    value: c,
+    ...u
+  } = t, p = l.root ?? "li", f = a.useRef(null), g = le(f, n), d = i ?? (typeof o == "string" ? o : (A = (E = f.current) == null ? void 0 : E.textContent) == null ? void 0 : A.trim()), {
+    getRootProps: h,
+    selected: w,
+    highlighted: R,
+    index: P
+  } = Zn({
+    disabled: r,
+    label: d,
+    rootRef: g,
+    value: c
+  }), C = {
+    ...t,
+    disabled: r,
+    highlighted: R,
+    index: P,
+    selected: w
+  }, O = eo(C), k = Pe({
+    getSlotProps: h,
+    elementType: p,
+    externalSlotProps: s.root,
+    externalForwardedProps: u,
+    className: O.root,
+    ownerState: C
+  });
+  return /* @__PURE__ */ _.jsx(p, {
+    ...k,
+    children: o
+  });
+})), Ze = /* @__PURE__ */ a.forwardRef(function(t, n) {
+  const {
+    value: o
+  } = t, {
+    contextValue: r
+  } = Hn(o);
+  return /* @__PURE__ */ _.jsx(Ee.Provider, {
+    value: r,
+    children: /* @__PURE__ */ _.jsx(to, {
+      ...t,
+      ref: n
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Ze.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: m.node,
+  /**
+   * @ignore
+   */
+  className: m.string,
+  /**
+   * If `true`, the option will be disabled.
+   * @default false
+   */
+  disabled: m.bool,
+  /**
+   * A text representation of the option's content.
+   * Used for keyboard text navigation matching.
+   */
+  label: m.string,
+  /**
+   * The props used for each slot inside the Option.
+   * @default {}
+   */
+  slotProps: m.shape({
+    root: m.oneOfType([m.func, m.object])
+  }),
+  /**
+   * The components used for each slot inside the Option.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: m.shape({
+    root: m.elementType
+  }),
+  /**
+   * The value of the option.
+   */
+  value: m.any.isRequired
+});
+const Me = {
+  buttonClick: "buttonClick",
+  browserAutoFill: "browserAutoFill"
+}, Lt = (e) => {
+  const {
+    label: t,
+    value: n
+  } = e;
+  return typeof t == "string" ? t : typeof n == "string" ? n : String(e);
+};
+function no(e, t) {
+  const {
+    open: n
+  } = e, {
+    context: {
+      selectionMode: o
+    }
+  } = t;
+  if (t.type === Me.buttonClick) {
+    const i = e.selectedValues[0] ?? J(null, "start", t.context);
+    return {
+      ...e,
+      open: !n,
+      highlightedValue: n ? null : i
+    };
+  }
+  if (t.type === Me.browserAutoFill)
+    return it(t.item, e, t.context);
+  const r = It(e, t);
+  switch (t.type) {
+    case z.keyDown:
+      if (e.open) {
+        if (t.event.key === "Escape")
+          return {
+            ...r,
+            open: !1
+          };
+      } else {
+        if (t.event.key === "ArrowDown")
+          return {
+            ...e,
+            open: !0,
+            highlightedValue: e.selectedValues[0] ?? J(null, "start", t.context)
+          };
+        if (t.event.key === "ArrowUp")
+          return {
+            ...e,
+            open: !0,
+            highlightedValue: e.selectedValues[0] ?? J(null, "end", t.context)
+          };
+      }
+      break;
+    case z.itemClick:
+      if (o === "single")
+        return {
+          ...r,
+          open: !1
+        };
+      break;
+    case z.blur:
+      return {
+        ...r,
+        open: !1
+      };
+    default:
+      return r;
+  }
+  return r;
+}
+function oo(e) {
+  return Array.isArray(e) ? e.length === 0 ? "" : JSON.stringify(e.map((t) => t.value)) : (e == null ? void 0 : e.value) == null ? "" : typeof e.value == "string" || typeof e.value == "number" ? e.value : JSON.stringify(e.value);
+}
+function ro(e) {
+  const {
+    areOptionsEqual: t,
+    buttonRef: n,
+    defaultOpen: o = !1,
+    defaultValue: r,
+    disabled: i = !1,
+    listboxId: s,
+    listboxRef: l,
+    multiple: c = !1,
+    name: u,
+    required: p,
+    onChange: f,
+    onHighlightChange: g,
+    onOpenChange: d,
+    open: h,
+    options: w,
+    getOptionAsString: R = Lt,
+    getSerializedValue: P = oo,
+    value: C,
+    componentName: O = "useSelect"
+  } = e, k = a.useRef(null), E = le(n, k), A = a.useRef(null), L = Mt(s);
+  let W;
+  C === void 0 && r === void 0 ? W = [] : r !== void 0 && (c ? W = r : W = r == null ? [] : [r]);
+  const D = a.useMemo(() => {
+    if (C !== void 0)
+      return c ? C : C == null ? [] : [C];
+  }, [C, c]), {
+    subitems: F,
+    contextValue: y
+  } = Xn(), b = a.useMemo(() => w != null ? new Map(w.map((x, v) => [x.value, {
+    value: x.value,
+    label: x.label,
+    disabled: x.disabled,
+    ref: /* @__PURE__ */ a.createRef(),
+    id: `${L}_${v}`
+  }])) : F, [w, F, L]), T = le(l, A), {
+    getRootProps: j,
+    active: q,
+    focusVisible: S,
+    rootRef: V
+  } = _t({
+    disabled: i,
+    rootRef: E
+  }), N = a.useMemo(() => Array.from(b.keys()), [b]), I = a.useCallback((x) => {
+    if (t !== void 0) {
+      const v = N.find((K) => t(K, x));
+      return b.get(v);
+    }
+    return b.get(x);
+  }, [b, t, N]), B = a.useCallback((x) => {
+    const v = I(x);
+    return (v == null ? void 0 : v.disabled) ?? !1;
+  }, [I]), H = a.useCallback((x) => {
+    const v = I(x);
+    return v ? R(v) : "";
+  }, [I, R]), G = a.useMemo(() => ({
+    selectedValues: D,
+    open: h
+  }), [D, h]), ie = a.useCallback((x) => {
+    var v;
+    return (v = b.get(x)) == null ? void 0 : v.id;
+  }, [b]), ve = a.useCallback((x, v) => {
+    c ? f == null || f(x, v) : f == null || f(x, v[0] ?? null);
+  }, [c, f]), xe = a.useCallback((x, v) => {
+    g == null || g(x, v ?? null);
+  }, [g]), ye = a.useCallback((x, v, K) => {
+    var X;
+    v === "open" && (d == null || d(K), K === !1 && (x == null ? void 0 : x.type) !== "blur" && ((X = k.current) == null || X.focus()));
+  }, [d]), $ = a.useCallback((x) => {
+    var v;
+    return x == null ? null : ((v = F.get(x)) == null ? void 0 : v.ref.current) ?? null;
+  }, [F]), M = {
+    getInitialState: () => ({
+      highlightedValue: null,
+      selectedValues: W ?? [],
+      open: o
+    }),
+    getItemId: ie,
+    controlledProps: G,
+    focusManagement: "DOM",
+    getItemDomElement: $,
+    itemComparer: t,
+    isItemDisabled: B,
+    rootRef: T,
+    onChange: ve,
+    onHighlightChange: xe,
+    onStateChange: ye,
+    reducerActionContext: a.useMemo(() => ({
+      multiple: c
+    }), [c]),
+    items: N,
+    getItemAsString: H,
+    selectionMode: c ? "multiple" : "single",
+    stateReducer: no,
+    componentName: O
+  }, {
+    dispatch: U,
+    getRootProps: Y,
+    contextValue: se,
+    state: {
+      open: ce,
+      highlightedValue: de,
+      selectedValues: ue
+    },
+    rootRef: pe
+  } = Yn(M), on = a.useRef(ce);
+  Oe(() => {
+    var x;
+    if (ce && de !== null) {
+      const v = (x = I(de)) == null ? void 0 : x.ref;
+      if (!A.current || !(v != null && v.current))
+        return;
+      on.current || v.current.focus({
+        preventScroll: !0
+      });
+      const K = A.current.getBoundingClientRect(), X = v.current.getBoundingClientRect();
+      X.top < K.top ? A.current.scrollTop -= K.top - X.top : X.bottom > K.bottom && (A.current.scrollTop += X.bottom - K.bottom);
+    }
+  }, [ce, de, I]);
+  const ze = a.useCallback((x) => I(x), [I]), rn = (x) => (v) => {
+    var K;
+    if ((K = x == null ? void 0 : x.onClick) == null || K.call(x, v), !v.defaultMuiPrevented) {
+      const X = {
+        type: Me.buttonClick,
+        event: v
+      };
+      U(X);
+    }
+  }, sn = (x) => (v) => {
+    var K;
+    (K = x.onKeyDown) == null || K.call(x, v), !v.defaultMuiPrevented && (v.key === "ArrowDown" || v.key === "ArrowUp") && (v.preventDefault(), U({
+      type: z.keyDown,
+      key: v.key,
+      event: v
+    }));
+  }, ln = (x = {}) => ({
+    onClick: rn(x),
+    onKeyDown: sn(x)
+  }), cn = (x = {}) => ({
+    ...x,
+    ...ln(x),
+    role: "combobox",
+    "aria-expanded": ce,
+    "aria-controls": L
+  }), un = (x = {}) => {
+    const v = ae(x), K = Ae(cn, j);
+    return {
+      ...x,
+      ...K(v)
+    };
+  }, an = (x) => (v) => {
+    var K, X;
+    (K = x.onBlur) == null || K.call(x, v), !v.defaultMuiPrevented && ((X = A.current) != null && X.contains(v.relatedTarget) || v.relatedTarget === k.current) && (v.defaultMuiPrevented = !0);
+  }, fn = (x = {}) => ({
+    onBlur: an(x)
+  }), dn = (x = {}) => {
+    const v = ae(x), K = Ae(fn, Y);
+    return {
+      id: L,
+      role: "listbox",
+      "aria-multiselectable": c ? "true" : void 0,
+      ...x,
+      ...K(v)
+    };
+  };
+  a.useDebugValue({
+    selectedOptions: ue,
+    highlightedOption: de,
+    open: ce
+  });
+  const pn = a.useMemo(() => ({
+    ...se,
+    ...y
+  }), [se, y]);
+  let Se;
+  e.multiple ? Se = ue : Se = ue.length > 0 ? ue[0] : null;
+  let qe;
+  c ? qe = Se.map((x) => ze(x)).filter((x) => x !== void 0) : qe = ze(Se) ?? null;
+  const gn = (x) => (v) => {
+    var X;
+    if ((X = x == null ? void 0 : x.onChange) == null || X.call(x, v), v.defaultMuiPrevented)
+      return;
+    const K = b.get(v.target.value);
+    v.target.value === "" ? U({
+      type: z.clearSelection
+    }) : K !== void 0 && U({
+      type: Me.browserAutoFill,
+      item: K.value,
+      event: v
+    });
+  };
+  return {
+    buttonActive: q,
+    buttonFocusVisible: S,
+    buttonRef: V,
+    contextValue: pn,
+    disabled: i,
+    dispatch: U,
+    getButtonProps: un,
+    getHiddenInputProps: (x = {}) => {
+      const v = ae(x);
+      return {
+        name: u,
+        tabIndex: -1,
+        "aria-hidden": !0,
+        required: p ? !0 : void 0,
+        value: P(qe),
+        style: wn,
+        ...x,
+        onChange: gn(v)
+      };
+    },
+    getListboxProps: dn,
+    getOptionMetadata: ze,
+    listboxRef: pe,
+    open: ce,
+    options: N,
+    value: Se,
+    highlightedOption: de
+  };
+}
+function io(e) {
+  const {
+    value: t,
+    children: n
+  } = e, {
+    dispatch: o,
+    getItemIndex: r,
+    getItemState: i,
+    registerItem: s,
+    totalSubitemCount: l
+  } = t, c = a.useMemo(() => ({
+    dispatch: o,
+    getItemState: i,
+    getItemIndex: r
+  }), [o, r, i]), u = a.useMemo(() => ({
+    getItemIndex: r,
+    registerItem: s,
+    totalSubitemCount: l
+  }), [s, r, l]);
+  return /* @__PURE__ */ _.jsx(st.Provider, {
+    value: u,
+    children: /* @__PURE__ */ _.jsx(Ee.Provider, {
+      value: c,
+      children: n
+    })
+  });
+}
+const De = Math.min, ge = Math.max, Ie = Math.round, Ne = Math.floor, ne = (e) => ({
+  x: e,
+  y: e
+}), so = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, lo = {
+  start: "end",
+  end: "start"
+};
+function Rt(e, t, n) {
+  return ge(e, De(t, n));
+}
+function Be(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function me(e) {
+  return e.split("-")[0];
+}
+function $e(e) {
+  return e.split("-")[1];
+}
+function Ft(e) {
+  return e === "x" ? "y" : "x";
+}
+function jt(e) {
+  return e === "y" ? "height" : "width";
+}
+function he(e) {
+  return ["top", "bottom"].includes(me(e)) ? "y" : "x";
+}
+function Bt(e) {
+  return Ft(he(e));
+}
+function co(e, t, n) {
+  n === void 0 && (n = !1);
+  const o = $e(e), r = Bt(e), i = jt(r);
+  let s = r === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = _e(s)), [s, _e(s)];
+}
+function uo(e) {
+  const t = _e(e);
+  return [He(e), t, He(t)];
+}
+function He(e) {
+  return e.replace(/start|end/g, (t) => lo[t]);
+}
+function ao(e, t, n) {
+  const o = ["left", "right"], r = ["right", "left"], i = ["top", "bottom"], s = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? r : o : t ? o : r;
+    case "left":
+    case "right":
+      return t ? i : s;
+    default:
+      return [];
+  }
+}
+function fo(e, t, n, o) {
+  const r = $e(e);
+  let i = ao(me(e), n === "start", o);
+  return r && (i = i.map((s) => s + "-" + r), t && (i = i.concat(i.map(He)))), i;
+}
+function _e(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => so[t]);
+}
+function po(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function go(e) {
+  return typeof e != "number" ? po(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Le(e) {
+  const {
+    x: t,
+    y: n,
+    width: o,
+    height: r
+  } = e;
+  return {
+    width: o,
+    height: r,
+    top: n,
+    left: t,
+    right: t + o,
+    bottom: n + r,
+    x: t,
+    y: n
+  };
+}
+function vt(e, t, n) {
+  let {
+    reference: o,
+    floating: r
+  } = e;
+  const i = he(t), s = Bt(t), l = jt(s), c = me(t), u = i === "y", p = o.x + o.width / 2 - r.width / 2, f = o.y + o.height / 2 - r.height / 2, g = o[l] / 2 - r[l] / 2;
+  let d;
+  switch (c) {
+    case "top":
+      d = {
+        x: p,
+        y: o.y - r.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: p,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      d = {
+        x: o.x + o.width,
+        y: f
+      };
+      break;
+    case "left":
+      d = {
+        x: o.x - r.width,
+        y: f
+      };
+      break;
+    default:
+      d = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch ($e(t)) {
+    case "start":
+      d[s] -= g * (n && u ? -1 : 1);
+      break;
+    case "end":
+      d[s] += g * (n && u ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const ho = async (e, t, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: r = "absolute",
+    middleware: i = [],
+    platform: s
+  } = n, l = i.filter(Boolean), c = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let u = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: r
+  }), {
+    x: p,
+    y: f
+  } = vt(u, o, c), g = o, d = {}, h = 0;
+  for (let w = 0; w < l.length; w++) {
+    const {
+      name: R,
+      fn: P
+    } = l[w], {
+      x: C,
+      y: O,
+      data: k,
+      reset: E
+    } = await P({
+      x: p,
+      y: f,
+      initialPlacement: o,
+      placement: g,
+      strategy: r,
+      middlewareData: d,
+      rects: u,
+      platform: s,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    p = C ?? p, f = O ?? f, d = {
+      ...d,
+      [R]: {
+        ...d[R],
+        ...k
+      }
+    }, E && h <= 50 && (h++, typeof E == "object" && (E.placement && (g = E.placement), E.rects && (u = E.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: r
+    }) : E.rects), {
+      x: p,
+      y: f
+    } = vt(u, g, c)), w = -1);
+  }
+  return {
+    x: p,
+    y: f,
+    placement: g,
+    strategy: r,
+    middlewareData: d
+  };
+};
+async function $t(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: o,
+    y: r,
+    platform: i,
+    rects: s,
+    elements: l,
+    strategy: c
+  } = e, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: p = "viewport",
+    elementContext: f = "floating",
+    altBoundary: g = !1,
+    padding: d = 0
+  } = Be(t, e), h = go(d), R = l[g ? f === "floating" ? "reference" : "floating" : f], P = Le(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(R))) == null || n ? R : R.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(l.floating)),
+    boundary: u,
+    rootBoundary: p,
+    strategy: c
+  })), C = f === "floating" ? {
+    x: o,
+    y: r,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, O = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(l.floating)), k = await (i.isElement == null ? void 0 : i.isElement(O)) ? await (i.getScale == null ? void 0 : i.getScale(O)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, E = Le(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: C,
+    offsetParent: O,
+    strategy: c
+  }) : C);
+  return {
+    top: (P.top - E.top + h.top) / k.y,
+    bottom: (E.bottom - P.bottom + h.bottom) / k.y,
+    left: (P.left - E.left + h.left) / k.x,
+    right: (E.right - P.right + h.right) / k.x
+  };
+}
+const mo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        placement: r,
+        middlewareData: i,
+        rects: s,
+        initialPlacement: l,
+        platform: c,
+        elements: u
+      } = t, {
+        mainAxis: p = !0,
+        crossAxis: f = !0,
+        fallbackPlacements: g,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: h = "none",
+        flipAlignment: w = !0,
+        ...R
+      } = Be(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const P = me(r), C = he(l), O = me(l) === l, k = await (c.isRTL == null ? void 0 : c.isRTL(u.floating)), E = g || (O || !w ? [_e(l)] : uo(l)), A = h !== "none";
+      !g && A && E.push(...fo(l, w, h, k));
+      const L = [l, ...E], W = await $t(t, R), D = [];
+      let F = ((o = i.flip) == null ? void 0 : o.overflows) || [];
+      if (p && D.push(W[P]), f) {
+        const q = co(r, s, k);
+        D.push(W[q[0]], W[q[1]]);
+      }
+      if (F = [...F, {
+        placement: r,
+        overflows: D
+      }], !D.every((q) => q <= 0)) {
+        var y, b;
+        const q = (((y = i.flip) == null ? void 0 : y.index) || 0) + 1, S = L[q];
+        if (S) {
+          var T;
+          const N = f === "alignment" ? C !== he(S) : !1, I = ((T = F[0]) == null ? void 0 : T.overflows[0]) > 0;
+          if (!N || I)
+            return {
+              data: {
+                index: q,
+                overflows: F
+              },
+              reset: {
+                placement: S
+              }
+            };
+        }
+        let V = (b = F.filter((N) => N.overflows[0] <= 0).sort((N, I) => N.overflows[1] - I.overflows[1])[0]) == null ? void 0 : b.placement;
+        if (!V)
+          switch (d) {
+            case "bestFit": {
+              var j;
+              const N = (j = F.filter((I) => {
+                if (A) {
+                  const B = he(I.placement);
+                  return B === C || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  B === "y";
+                }
+                return !0;
+              }).map((I) => [I.placement, I.overflows.filter((B) => B > 0).reduce((B, H) => B + H, 0)]).sort((I, B) => I[1] - B[1])[0]) == null ? void 0 : j[0];
+              N && (V = N);
+              break;
+            }
+            case "initialPlacement":
+              V = l;
+              break;
+          }
+        if (r !== V)
+          return {
+            reset: {
+              placement: V
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function bo(e, t) {
+  const {
+    placement: n,
+    platform: o,
+    elements: r
+  } = e, i = await (o.isRTL == null ? void 0 : o.isRTL(r.floating)), s = me(n), l = $e(n), c = he(n) === "y", u = ["left", "top"].includes(s) ? -1 : 1, p = i && c ? -1 : 1, f = Be(t, e);
+  let {
+    mainAxis: g,
+    crossAxis: d,
+    alignmentAxis: h
+  } = typeof f == "number" ? {
+    mainAxis: f,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: f.mainAxis || 0,
+    crossAxis: f.crossAxis || 0,
+    alignmentAxis: f.alignmentAxis
+  };
+  return l && typeof h == "number" && (d = l === "end" ? h * -1 : h), c ? {
+    x: d * p,
+    y: g * u
+  } : {
+    x: g * u,
+    y: d * p
+  };
+}
+const xo = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        x: r,
+        y: i,
+        placement: s,
+        middlewareData: l
+      } = t, c = await bo(t, e);
+      return s === ((n = l.offset) == null ? void 0 : n.placement) && (o = l.arrow) != null && o.alignmentOffset ? {} : {
+        x: r + c.x,
+        y: i + c.y,
+        data: {
+          ...c,
+          placement: s
+        }
+      };
+    }
+  };
+}, yo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: o,
+        placement: r
+      } = t, {
+        mainAxis: i = !0,
+        crossAxis: s = !1,
+        limiter: l = {
+          fn: (R) => {
+            let {
+              x: P,
+              y: C
+            } = R;
+            return {
+              x: P,
+              y: C
+            };
+          }
+        },
+        ...c
+      } = Be(e, t), u = {
+        x: n,
+        y: o
+      }, p = await $t(t, c), f = he(me(r)), g = Ft(f);
+      let d = u[g], h = u[f];
+      if (i) {
+        const R = g === "y" ? "top" : "left", P = g === "y" ? "bottom" : "right", C = d + p[R], O = d - p[P];
+        d = Rt(C, d, O);
+      }
+      if (s) {
+        const R = f === "y" ? "top" : "left", P = f === "y" ? "bottom" : "right", C = h + p[R], O = h - p[P];
+        h = Rt(C, h, O);
+      }
+      const w = l.fn({
+        ...t,
+        [g]: d,
+        [f]: h
+      });
+      return {
+        ...w,
+        data: {
+          x: w.x - n,
+          y: w.y - o,
+          enabled: {
+            [g]: i,
+            [f]: s
+          }
+        }
+      };
+    }
+  };
+};
+function Ue() {
+  return typeof window < "u";
+}
+function Re(e) {
+  return Ut(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function Z(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function re(e) {
+  var t;
+  return (t = (Ut(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Ut(e) {
+  return Ue() ? e instanceof Node || e instanceof Z(e).Node : !1;
+}
+function ee(e) {
+  return Ue() ? e instanceof Element || e instanceof Z(e).Element : !1;
+}
+function oe(e) {
+  return Ue() ? e instanceof HTMLElement || e instanceof Z(e).HTMLElement : !1;
+}
+function St(e) {
+  return !Ue() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof Z(e).ShadowRoot;
+}
+function Te(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: o,
+    display: r
+  } = te(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + o + n) && !["inline", "contents"].includes(r);
+}
+function wo(e) {
+  return ["table", "td", "th"].includes(Re(e));
+}
+function We(e) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function lt(e) {
+  const t = ct(), n = ee(e) ? te(e) : e;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((o) => n[o] ? n[o] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((o) => (n.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (n.contain || "").includes(o));
+}
+function Co(e) {
+  let t = fe(e);
+  for (; oe(t) && !Ce(t); ) {
+    if (lt(t))
+      return t;
+    if (We(t))
+      return null;
+    t = fe(t);
+  }
+  return null;
+}
+function ct() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function Ce(e) {
+  return ["html", "body", "#document"].includes(Re(e));
+}
+function te(e) {
+  return Z(e).getComputedStyle(e);
+}
+function Ke(e) {
+  return ee(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function fe(e) {
+  if (Re(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.
+    St(e) && e.host || // Fallback.
+    re(e)
+  );
+  return St(t) ? t.host : t;
+}
+function Wt(e) {
+  const t = fe(e);
+  return Ce(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : oe(t) && Te(t) ? t : Wt(t);
+}
+function ke(e, t, n) {
+  var o;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const r = Wt(e), i = r === ((o = e.ownerDocument) == null ? void 0 : o.body), s = Z(r);
+  if (i) {
+    const l = et(s);
+    return t.concat(s, s.visualViewport || [], Te(r) ? r : [], l && n ? ke(l) : []);
+  }
+  return t.concat(r, ke(r, [], n));
+}
+function et(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function Kt(e) {
+  const t = te(e);
+  let n = parseFloat(t.width) || 0, o = parseFloat(t.height) || 0;
+  const r = oe(e), i = r ? e.offsetWidth : n, s = r ? e.offsetHeight : o, l = Ie(n) !== i || Ie(o) !== s;
+  return l && (n = i, o = s), {
+    width: n,
+    height: o,
+    $: l
+  };
+}
+function ut(e) {
+  return ee(e) ? e : e.contextElement;
+}
+function we(e) {
+  const t = ut(e);
+  if (!oe(t))
+    return ne(1);
+  const n = t.getBoundingClientRect(), {
+    width: o,
+    height: r,
+    $: i
+  } = Kt(t);
+  let s = (i ? Ie(n.width) : n.width) / o, l = (i ? Ie(n.height) : n.height) / r;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: s,
+    y: l
+  };
+}
+const Ro = /* @__PURE__ */ ne(0);
+function zt(e) {
+  const t = Z(e);
+  return !ct() || !t.visualViewport ? Ro : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function vo(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== Z(e) ? !1 : t;
+}
+function be(e, t, n, o) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const r = e.getBoundingClientRect(), i = ut(e);
+  let s = ne(1);
+  t && (o ? ee(o) && (s = we(o)) : s = we(e));
+  const l = vo(i, n, o) ? zt(i) : ne(0);
+  let c = (r.left + l.x) / s.x, u = (r.top + l.y) / s.y, p = r.width / s.x, f = r.height / s.y;
+  if (i) {
+    const g = Z(i), d = o && ee(o) ? Z(o) : o;
+    let h = g, w = et(h);
+    for (; w && o && d !== h; ) {
+      const R = we(w), P = w.getBoundingClientRect(), C = te(w), O = P.left + (w.clientLeft + parseFloat(C.paddingLeft)) * R.x, k = P.top + (w.clientTop + parseFloat(C.paddingTop)) * R.y;
+      c *= R.x, u *= R.y, p *= R.x, f *= R.y, c += O, u += k, h = Z(w), w = et(h);
+    }
+  }
+  return Le({
+    width: p,
+    height: f,
+    x: c,
+    y: u
+  });
+}
+function at(e, t) {
+  const n = Ke(e).scrollLeft;
+  return t ? t.left + n : be(re(e)).left + n;
+}
+function qt(e, t, n) {
+  n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), r = o.left + t.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    at(e, o)
+  )), i = o.top + t.scrollTop;
+  return {
+    x: r,
+    y: i
+  };
+}
+function So(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: o,
+    strategy: r
+  } = e;
+  const i = r === "fixed", s = re(o), l = t ? We(t.floating) : !1;
+  if (o === s || l && i)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = ne(1);
+  const p = ne(0), f = oe(o);
+  if ((f || !f && !i) && ((Re(o) !== "body" || Te(s)) && (c = Ke(o)), oe(o))) {
+    const d = be(o);
+    u = we(o), p.x = d.x + o.clientLeft, p.y = d.y + o.clientTop;
+  }
+  const g = s && !f && !i ? qt(s, c, !0) : ne(0);
+  return {
+    width: n.width * u.x,
+    height: n.height * u.y,
+    x: n.x * u.x - c.scrollLeft * u.x + p.x + g.x,
+    y: n.y * u.y - c.scrollTop * u.y + p.y + g.y
+  };
+}
+function Po(e) {
+  return Array.from(e.getClientRects());
+}
+function Oo(e) {
+  const t = re(e), n = Ke(e), o = e.ownerDocument.body, r = ge(t.scrollWidth, t.clientWidth, o.scrollWidth, o.clientWidth), i = ge(t.scrollHeight, t.clientHeight, o.scrollHeight, o.clientHeight);
+  let s = -n.scrollLeft + at(e);
+  const l = -n.scrollTop;
+  return te(o).direction === "rtl" && (s += ge(t.clientWidth, o.clientWidth) - r), {
+    width: r,
+    height: i,
+    x: s,
+    y: l
+  };
+}
+function ko(e, t) {
+  const n = Z(e), o = re(e), r = n.visualViewport;
+  let i = o.clientWidth, s = o.clientHeight, l = 0, c = 0;
+  if (r) {
+    i = r.width, s = r.height;
+    const u = ct();
+    (!u || u && t === "fixed") && (l = r.offsetLeft, c = r.offsetTop);
+  }
+  return {
+    width: i,
+    height: s,
+    x: l,
+    y: c
+  };
+}
+function Eo(e, t) {
+  const n = be(e, !0, t === "fixed"), o = n.top + e.clientTop, r = n.left + e.clientLeft, i = oe(e) ? we(e) : ne(1), s = e.clientWidth * i.x, l = e.clientHeight * i.y, c = r * i.x, u = o * i.y;
+  return {
+    width: s,
+    height: l,
+    x: c,
+    y: u
+  };
+}
+function Pt(e, t, n) {
+  let o;
+  if (t === "viewport")
+    o = ko(e, n);
+  else if (t === "document")
+    o = Oo(re(e));
+  else if (ee(t))
+    o = Eo(t, n);
+  else {
+    const r = zt(e);
+    o = {
+      x: t.x - r.x,
+      y: t.y - r.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return Le(o);
+}
+function Yt(e, t) {
+  const n = fe(e);
+  return n === t || !ee(n) || Ce(n) ? !1 : te(n).position === "fixed" || Yt(n, t);
+}
+function To(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let o = ke(e, [], !1).filter((l) => ee(l) && Re(l) !== "body"), r = null;
+  const i = te(e).position === "fixed";
+  let s = i ? fe(e) : e;
+  for (; ee(s) && !Ce(s); ) {
+    const l = te(s), c = lt(s);
+    !c && l.position === "fixed" && (r = null), (i ? !c && !r : !c && l.position === "static" && !!r && ["absolute", "fixed"].includes(r.position) || Te(s) && !c && Yt(e, s)) ? o = o.filter((p) => p !== s) : r = l, s = fe(s);
+  }
+  return t.set(e, o), o;
+}
+function No(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: o,
+    strategy: r
+  } = e;
+  const s = [...n === "clippingAncestors" ? We(t) ? [] : To(t, this._c) : [].concat(n), o], l = s[0], c = s.reduce((u, p) => {
+    const f = Pt(t, p, r);
+    return u.top = ge(f.top, u.top), u.right = De(f.right, u.right), u.bottom = De(f.bottom, u.bottom), u.left = ge(f.left, u.left), u;
+  }, Pt(t, l, r));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function Vo(e) {
+  const {
+    width: t,
+    height: n
+  } = Kt(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function Ao(e, t, n) {
+  const o = oe(t), r = re(t), i = n === "fixed", s = be(e, !0, i, t);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = ne(0);
+  function u() {
+    c.x = at(r);
+  }
+  if (o || !o && !i)
+    if ((Re(t) !== "body" || Te(r)) && (l = Ke(t)), o) {
+      const d = be(t, !0, i, t);
+      c.x = d.x + t.clientLeft, c.y = d.y + t.clientTop;
+    } else r && u();
+  i && !o && r && u();
+  const p = r && !o && !i ? qt(r, l) : ne(0), f = s.left + l.scrollLeft - c.x - p.x, g = s.top + l.scrollTop - c.y - p.y;
+  return {
+    x: f,
+    y: g,
+    width: s.width,
+    height: s.height
+  };
+}
+function Ge(e) {
+  return te(e).position === "static";
+}
+function Ot(e, t) {
+  if (!oe(e) || te(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return re(e) === n && (n = n.ownerDocument.body), n;
+}
+function Gt(e, t) {
+  const n = Z(e);
+  if (We(e))
+    return n;
+  if (!oe(e)) {
+    let r = fe(e);
+    for (; r && !Ce(r); ) {
+      if (ee(r) && !Ge(r))
+        return r;
+      r = fe(r);
+    }
+    return n;
+  }
+  let o = Ot(e, t);
+  for (; o && wo(o) && Ge(o); )
+    o = Ot(o, t);
+  return o && Ce(o) && Ge(o) && !lt(o) ? n : o || Co(e) || n;
+}
+const Mo = async function(e) {
+  const t = this.getOffsetParent || Gt, n = this.getDimensions, o = await n(e.floating);
+  return {
+    reference: Ao(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function Do(e) {
+  return te(e).direction === "rtl";
+}
+const Io = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: So,
+  getDocumentElement: re,
+  getClippingRect: No,
+  getOffsetParent: Gt,
+  getElementRects: Mo,
+  getClientRects: Po,
+  getDimensions: Vo,
+  getScale: we,
+  isElement: ee,
+  isRTL: Do
+};
+function Jt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function _o(e, t) {
+  let n = null, o;
+  const r = re(e);
+  function i() {
+    var l;
+    clearTimeout(o), (l = n) == null || l.disconnect(), n = null;
+  }
+  function s(l, c) {
+    l === void 0 && (l = !1), c === void 0 && (c = 1), i();
+    const u = e.getBoundingClientRect(), {
+      left: p,
+      top: f,
+      width: g,
+      height: d
+    } = u;
+    if (l || t(), !g || !d)
+      return;
+    const h = Ne(f), w = Ne(r.clientWidth - (p + g)), R = Ne(r.clientHeight - (f + d)), P = Ne(p), O = {
+      rootMargin: -h + "px " + -w + "px " + -R + "px " + -P + "px",
+      threshold: ge(0, De(1, c)) || 1
+    };
+    let k = !0;
+    function E(A) {
+      const L = A[0].intersectionRatio;
+      if (L !== c) {
+        if (!k)
+          return s();
+        L ? s(!1, L) : o = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      L === 1 && !Jt(u, e.getBoundingClientRect()) && s(), k = !1;
+    }
+    try {
+      n = new IntersectionObserver(E, {
+        ...O,
+        // Handle <iframe>s
+        root: r.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(E, O);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function kt(e, t, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: r = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = o, u = ut(e), p = r || i ? [...u ? ke(u) : [], ...ke(t)] : [];
+  p.forEach((P) => {
+    r && P.addEventListener("scroll", n, {
+      passive: !0
+    }), i && P.addEventListener("resize", n);
+  });
+  const f = u && l ? _o(u, n) : null;
+  let g = -1, d = null;
+  s && (d = new ResizeObserver((P) => {
+    let [C] = P;
+    C && C.target === u && d && (d.unobserve(t), cancelAnimationFrame(g), g = requestAnimationFrame(() => {
+      var O;
+      (O = d) == null || O.observe(t);
+    })), n();
+  }), u && !c && d.observe(u), d.observe(t));
+  let h, w = c ? be(e) : null;
+  c && R();
+  function R() {
+    const P = be(e);
+    w && !Jt(w, P) && n(), w = P, h = requestAnimationFrame(R);
+  }
+  return n(), () => {
+    var P;
+    p.forEach((C) => {
+      r && C.removeEventListener("scroll", n), i && C.removeEventListener("resize", n);
+    }), f == null || f(), (P = d) == null || P.disconnect(), d = null, c && cancelAnimationFrame(h);
+  };
+}
+const Lo = xo, Fo = yo, jo = mo, Bo = (e, t, n) => {
+  const o = /* @__PURE__ */ new Map(), r = {
+    platform: Io,
+    ...n
+  }, i = {
+    ...r.platform,
+    _c: o
+  };
+  return ho(e, t, {
+    ...r,
+    platform: i
+  });
+};
+var Ve = typeof document < "u" ? hn : Vt;
+function Fe(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, o, r;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (o = n; o-- !== 0; )
+        if (!Fe(e[o], t[o]))
+          return !1;
+      return !0;
+    }
+    if (r = Object.keys(e), n = r.length, n !== Object.keys(t).length)
+      return !1;
+    for (o = n; o-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, r[o]))
+        return !1;
+    for (o = n; o-- !== 0; ) {
+      const i = r[o];
+      if (!(i === "_owner" && e.$$typeof) && !Fe(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function Xt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function Et(e, t) {
+  const n = Xt(e);
+  return Math.round(t * n) / n;
+}
+function Je(e) {
+  const t = a.useRef(e);
+  return Ve(() => {
+    t.current = e;
+  }), t;
+}
+function $o(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: o = [],
+    platform: r,
+    elements: {
+      reference: i,
+      floating: s
+    } = {},
+    transform: l = !0,
+    whileElementsMounted: c,
+    open: u
+  } = e, [p, f] = a.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [g, d] = a.useState(o);
+  Fe(g, o) || d(o);
+  const [h, w] = a.useState(null), [R, P] = a.useState(null), C = a.useCallback((N) => {
+    N !== A.current && (A.current = N, w(N));
+  }, []), O = a.useCallback((N) => {
+    N !== L.current && (L.current = N, P(N));
+  }, []), k = i || h, E = s || R, A = a.useRef(null), L = a.useRef(null), W = a.useRef(p), D = c != null, F = Je(c), y = Je(r), b = Je(u), T = a.useCallback(() => {
+    if (!A.current || !L.current)
+      return;
+    const N = {
+      placement: t,
+      strategy: n,
+      middleware: g
+    };
+    y.current && (N.platform = y.current), Bo(A.current, L.current, N).then((I) => {
+      const B = {
+        ...I,
+        // 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: b.current !== !1
+      };
+      j.current && !Fe(W.current, B) && (W.current = B, At.flushSync(() => {
+        f(B);
+      }));
+    });
+  }, [g, t, n, y, b]);
+  Ve(() => {
+    u === !1 && W.current.isPositioned && (W.current.isPositioned = !1, f((N) => ({
+      ...N,
+      isPositioned: !1
+    })));
+  }, [u]);
+  const j = a.useRef(!1);
+  Ve(() => (j.current = !0, () => {
+    j.current = !1;
+  }), []), Ve(() => {
+    if (k && (A.current = k), E && (L.current = E), k && E) {
+      if (F.current)
+        return F.current(k, E, T);
+      T();
+    }
+  }, [k, E, T, F, D]);
+  const q = a.useMemo(() => ({
+    reference: A,
+    floating: L,
+    setReference: C,
+    setFloating: O
+  }), [C, O]), S = a.useMemo(() => ({
+    reference: k,
+    floating: E
+  }), [k, E]), V = a.useMemo(() => {
+    const N = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!S.floating)
+      return N;
+    const I = Et(S.floating, p.x), B = Et(S.floating, p.y);
+    return l ? {
+      ...N,
+      transform: "translate(" + I + "px, " + B + "px)",
+      ...Xt(S.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: I,
+      top: B
+    };
+  }, [n, l, S.floating, p.x, p.y]);
+  return a.useMemo(() => ({
+    ...p,
+    update: T,
+    refs: q,
+    elements: S,
+    floatingStyles: V
+  }), [p, T, q, S, V]);
+}
+const Tt = (e, t) => ({
+  ...Lo(e),
+  options: [e, t]
+}), Uo = (e, t) => ({
+  ...Fo(e),
+  options: [e, t]
+}), Wo = (e, t) => ({
+  ...jo(e),
+  options: [e, t]
+});
+function Ko(e) {
+  return typeof e == "function" ? e() : e;
+}
+const je = /* @__PURE__ */ a.forwardRef(function(t, n) {
+  const {
+    children: o,
+    container: r,
+    disablePortal: i = !1
+  } = t, [s, l] = a.useState(null), c = le(Sn(o), n);
+  if (Oe(() => {
+    i || l(Ko(r) || document.body);
+  }, [r, i]), Oe(() => {
+    if (s && !i)
+      return mt(n, s), () => {
+        mt(n, null);
+      };
+  }, [n, s, i]), i) {
+    if (/* @__PURE__ */ a.isValidElement(o)) {
+      const u = {
+        ref: c
+      };
+      return /* @__PURE__ */ a.cloneElement(o, u);
+    }
+    return /* @__PURE__ */ _.jsx(a.Fragment, {
+      children: o
+    });
+  }
+  return /* @__PURE__ */ _.jsx(a.Fragment, {
+    children: s && /* @__PURE__ */ At.createPortal(o, s)
+  });
+});
+process.env.NODE_ENV !== "production" && (je.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The children to render into the `container`.
+   */
+  children: m.node,
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: m.oneOfType([Xe, m.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: m.bool
+});
+process.env.NODE_ENV !== "production" && (je.propTypes = Rn(je.propTypes));
+const Qt = "Popup";
+function zo(e) {
+  return tt(Qt, e);
+}
+nt(Qt, ["root", "open"]);
+const Zt = /* @__PURE__ */ a.createContext(null);
+process.env.NODE_ENV !== "production" && (Zt.displayName = "TransitionContext");
+function qo(e) {
+  const [t, n] = a.useState(!0), o = a.useRef(!1), r = a.useRef(0), [i, s] = a.useState(!1), l = a.useRef(e);
+  a.useEffect(() => {
+    !e && // checking registeredTransitions.current instead of hasTransition to avoid this effect re-firing whenever hasTransition changes
+    r.current > 0 && // prevents waiting for a pending transition right after mounting
+    l.current !== e && (o.current = !0, n(!1)), l.current = e;
+  }, [e]);
+  const c = a.useCallback(() => {
+    o.current = !1, n(!0);
+  }, []), u = a.useCallback(() => (r.current += 1, s(!0), () => {
+    r.current -= 1, r.current === 0 && s(!1);
+  }), []);
+  let p;
+  return i ? e ? p = !1 : p = !o.current && t : p = !e, {
+    contextValue: a.useMemo(() => ({
+      requestedEnter: e,
+      onExited: c,
+      registerTransition: u,
+      hasExited: p
+    }), [c, e, u, p]),
+    hasExited: p
+  };
+}
+const Ht = /* @__PURE__ */ a.createContext(null);
+process.env.NODE_ENV !== "production" && (Ht.displayName = "PopupContext");
+function Yo(e) {
+  const {
+    open: t
+  } = e;
+  return ot({
+    root: ["root", t && "open"]
+  }, rt(zo));
+}
+function Go(e) {
+  return typeof e == "function" ? e() : e;
+}
+const en = /* @__PURE__ */ a.forwardRef(function(t, n) {
+  const {
+    anchor: o,
+    children: r,
+    container: i,
+    disablePortal: s = !1,
+    keepMounted: l = !1,
+    middleware: c,
+    offset: u = 0,
+    open: p = !1,
+    placement: f = "bottom",
+    slotProps: g = {},
+    slots: d = {},
+    strategy: h = "absolute",
+    ...w
+  } = t, {
+    refs: R,
+    elements: P,
+    floatingStyles: C,
+    update: O,
+    placement: k
+  } = $o({
+    elements: {
+      reference: Go(o)
+    },
+    open: p,
+    middleware: c ?? [Tt(u ?? 0), Wo(), Uo()],
+    placement: f,
+    strategy: h,
+    whileElementsMounted: l ? void 0 : kt
+  }), E = le(R.setFloating, n);
+  Oe(() => {
+    if (l && p && P.reference && P.floating)
+      return kt(P.reference, P.floating, O);
+  }, [l, p, P, O]);
+  const A = {
+    ...t,
+    disablePortal: s,
+    keepMounted: l,
+    offset: Tt,
+    open: p,
+    placement: f,
+    finalPlacement: k,
+    strategy: h
+  }, {
+    contextValue: L,
+    hasExited: W
+  } = qo(p), D = l && W ? "hidden" : void 0, F = Yo(A), y = (d == null ? void 0 : d.root) ?? "div", b = Pe({
+    elementType: y,
+    externalSlotProps: g.root,
+    externalForwardedProps: w,
+    ownerState: A,
+    className: F.root,
+    additionalProps: {
+      ref: E,
+      role: "tooltip",
+      style: {
+        ...C,
+        visibility: D
+      }
+    }
+  }), T = a.useMemo(() => ({
+    placement: k
+  }), [k]);
+  return l || !W ? /* @__PURE__ */ _.jsx(je, {
+    disablePortal: s,
+    container: i,
+    children: /* @__PURE__ */ _.jsx(Ht.Provider, {
+      value: T,
+      children: /* @__PURE__ */ _.jsx(Zt.Provider, {
+        value: L,
+        children: /* @__PURE__ */ _.jsx(y, {
+          ...b,
+          children: r
+        })
+      })
+    })
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (en.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * An HTML element, [virtual element](https://floating-ui.com/docs/virtual-elements),
+   * or a function that returns either.
+   * It's used to set the position of the popup.
+   */
+  anchor: m.oneOfType([Xe, m.object, m.func]),
+  /**
+   * @ignore
+   */
+  children: m.oneOfType([m.node, m.func]),
+  /**
+   * An HTML element or function that returns one. The container will have the portal children appended to it.
+   * By default, it uses the body of the top-level document object, so it's `document.body` in these cases.
+   */
+  container: m.oneOfType([Xe, m.func]),
+  /**
+   * If `true`, the popup will be rendered where it is defined, without the use of portals.
+   * @default false
+   */
+  disablePortal: m.bool,
+  /**
+   * If `true`, the popup will exist in the DOM even if it's closed.
+   * Its visibility will be controlled by the `visibility` CSS property.
+   *
+   * Otherwise, a closed popup will be removed from the DOM.
+   *
+   * @default false
+   */
+  keepMounted: m.bool,
+  /**
+   * Collection of Floating UI middleware to use when positioning the popup.
+   * If not provided, the [`offset`](https://floating-ui.com/docs/offset)
+   * and [`flip`](https://floating-ui.com/docs/flip) functions will be used.
+   *
+   * @see https://floating-ui.com/docs/computePosition#middleware
+   */
+  middleware: m.arrayOf(m.oneOfType([m.oneOf([!1]), m.shape({
+    fn: m.func.isRequired,
+    name: m.string.isRequired,
+    options: m.any
+  })])),
+  /**
+   * Distance between a popup and the trigger element.
+   * This prop is ignored when custom `middleware` is provided.
+   *
+   * @default 0
+   * @see https://floating-ui.com/docs/offset
+   */
+  offset: m.oneOfType([m.func, m.number, m.shape({
+    alignmentAxis: m.number,
+    crossAxis: m.number,
+    mainAxis: m.number
+  })]),
+  /**
+   * If `true`, the popup is visible.
+   *
+   * @default false
+   */
+  open: m.bool,
+  /**
+   * Determines where to place the popup relative to the trigger element.
+   *
+   * @default 'bottom'
+   * @see https://floating-ui.com/docs/computePosition#placement
+   */
+  placement: m.oneOf(["bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]),
+  /**
+   * The props used for each slot inside the Popup.
+   *
+   * @default {}
+   */
+  slotProps: m.shape({
+    root: m.oneOfType([m.func, m.object])
+  }),
+  /**
+   * The components used for each slot inside the Popup.
+   * Either a string to use a HTML element or a component.
+   *
+   * @default {}
+   */
+  slots: m.shape({
+    root: m.elementType
+  }),
+  /**
+   * The type of CSS position property to use (absolute or fixed).
+   *
+   * @default 'absolute'
+   * @see https://floating-ui.com/docs/computePosition#strategy
+   */
+  strategy: m.oneOf(["absolute", "fixed"])
+});
+const tn = "Select";
+function Jo(e) {
+  return tt(tn, e);
+}
+nt(tn, ["root", "button", "listbox", "popup", "active", "expanded", "disabled", "focusVisible"]);
+var Nt;
+function Xo(e) {
+  return Array.isArray(e) ? /* @__PURE__ */ _.jsx(a.Fragment, {
+    children: e.map((t) => t.label).join(", ")
+  }) : (e == null ? void 0 : e.label) ?? null;
+}
+function Qo(e) {
+  const {
+    active: t,
+    disabled: n,
+    open: o,
+    focusVisible: r
+  } = e;
+  return ot({
+    root: ["root", n && "disabled", r && "focusVisible", t && "active", o && "expanded"],
+    listbox: ["listbox", n && "disabled"],
+    popup: ["popup"]
+  }, rt(Jo));
+}
+const nn = /* @__PURE__ */ a.forwardRef(function(t, n) {
+  const {
+    areOptionsEqual: o,
+    autoComplete: r,
+    autoFocus: i,
+    children: s,
+    defaultValue: l,
+    defaultListboxOpen: c = !1,
+    disabled: u,
+    getSerializedValue: p,
+    listboxId: f,
+    listboxOpen: g,
+    multiple: d = !1,
+    name: h,
+    required: w = !1,
+    onChange: R,
+    onListboxOpenChange: P,
+    getOptionAsString: C = Lt,
+    renderValue: O,
+    placeholder: k,
+    slotProps: E = {},
+    slots: A = {},
+    value: L,
+    ...W
+  } = t, D = O ?? Xo, [F, y] = a.useState(!1), b = a.useRef(null), T = a.useRef(null), j = A.root ?? "button", q = A.listbox ?? "ul", S = A.popup ?? "div", V = a.useCallback((pe) => {
+    y(pe != null);
+  }, []), N = le(n, b, V);
+  a.useEffect(() => {
+    i && b.current.focus();
+  }, [i]);
+  const {
+    buttonActive: I,
+    buttonFocusVisible: B,
+    contextValue: H,
+    disabled: G,
+    getButtonProps: ie,
+    getListboxProps: ve,
+    getHiddenInputProps: xe,
+    getOptionMetadata: ye,
+    value: $,
+    open: M
+  } = ro({
+    name: h,
+    required: w,
+    getSerializedValue: p,
+    areOptionsEqual: o,
+    buttonRef: N,
+    defaultOpen: c,
+    defaultValue: l,
+    disabled: u,
+    listboxId: f,
+    multiple: d,
+    open: g,
+    onChange: R,
+    onOpenChange: P,
+    getOptionAsString: C,
+    value: L,
+    componentName: "Select"
+  }), U = {
+    ...t,
+    active: I,
+    defaultListboxOpen: c,
+    disabled: G,
+    focusVisible: B,
+    open: M,
+    multiple: d,
+    renderValue: D,
+    value: $
+  }, Y = Qo(U), se = Pe({
+    elementType: j,
+    getSlotProps: ie,
+    externalSlotProps: E.root,
+    externalForwardedProps: W,
+    ownerState: U,
+    className: Y.root
+  }), ce = Pe({
+    elementType: q,
+    getSlotProps: ve,
+    externalSlotProps: E.listbox,
+    additionalProps: {
+      ref: T
+    },
+    ownerState: U,
+    className: Y.listbox
+  }), de = Pe({
+    elementType: S,
+    externalSlotProps: E.popup,
+    additionalProps: {
+      anchor: b.current,
+      keepMounted: !0,
+      open: M,
+      placement: "bottom-start",
+      role: void 0
+    },
+    ownerState: U,
+    className: Y.popup
+  });
+  let ue;
+  return d ? ue = $.map((pe) => ye(pe)).filter((pe) => pe !== void 0) : ue = ye($) ?? null, /* @__PURE__ */ _.jsxs(a.Fragment, {
+    children: [/* @__PURE__ */ _.jsx(j, {
+      ...se,
+      children: D(ue) ?? k ?? // fall back to a zero-width space to prevent layout shift
+      // from https://github.com/mui/material-ui/pull/24563
+      (Nt || (Nt = /* @__PURE__ */ _.jsx("span", {
+        className: "notranslate",
+        children: "​"
+      })))
+    }), F && /* @__PURE__ */ _.jsx(en, {
+      slots: {
+        root: S
+      },
+      ...de,
+      children: /* @__PURE__ */ _.jsx(q, {
+        ...ce,
+        children: /* @__PURE__ */ _.jsx(io, {
+          value: H,
+          children: s
+        })
+      })
+    }), /* @__PURE__ */ _.jsx("input", {
+      ...xe(),
+      autoComplete: r
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (nn.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A function used to determine if two options' values are equal.
+   * By default, reference equality is used.
+   *
+   * There is a performance impact when using the `areOptionsEqual` prop (proportional to the number of options).
+   * Therefore, it's recommented to use the default reference equality comparison whenever possible.
+   */
+  areOptionsEqual: m.func,
+  /**
+   * This prop helps users to fill forms faster, especially on mobile devices.
+   * The name can be confusing, as it's more like an autofill.
+   * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
+   */
+  autoComplete: m.string,
+  /**
+   * If `true`, the select element is focused during the first mount
+   * @default false
+   */
+  autoFocus: m.bool,
+  /**
+   * @ignore
+   */
+  children: m.node,
+  /**
+   * @ignore
+   */
+  className: m.string,
+  /**
+   * If `true`, the select will be initially open.
+   * @default false
+   */
+  defaultListboxOpen: m.bool,
+  /**
+   * The default selected value. Use when the component is not controlled.
+   */
+  defaultValue: m.any,
+  /**
+   * If `true`, the select is disabled.
+   * @default false
+   */
+  disabled: m.bool,
+  /**
+   * A function used to convert the option label to a string.
+   * It's useful when labels are elements and need to be converted to plain text
+   * to enable navigation using character keys on a keyboard.
+   *
+   * @default defaultOptionStringifier
+   */
+  getOptionAsString: m.func,
+  /**
+   * A function to convert the currently selected value to a string.
+   * Used to set a value of a hidden input associated with the select,
+   * so that the selected value can be posted with a form.
+   */
+  getSerializedValue: m.func,
+  /**
+   * `id` attribute of the listbox element.
+   */
+  listboxId: m.string,
+  /**
+   * Controls the open state of the select's listbox.
+   * @default undefined
+   */
+  listboxOpen: m.bool,
+  /**
+   * If `true`, selecting multiple values is allowed.
+   * This affects the type of the `value`, `defaultValue`, and `onChange` props.
+   *
+   * @default false
+   */
+  multiple: m.bool,
+  /**
+   * Name of the element. For example used by the server to identify the fields in form submits.
+   */
+  name: m.string,
+  /**
+   * Callback fired when an option is selected.
+   */
+  onChange: m.func,
+  /**
+   * Callback fired when the component requests to be opened.
+   * Use in controlled mode (see listboxOpen).
+   */
+  onListboxOpenChange: m.func,
+  /**
+   * Text to show when there is no selected value.
+   */
+  placeholder: m.node,
+  /**
+   * Function that customizes the rendering of the selected value.
+   */
+  renderValue: m.func,
+  /**
+   * If `true`, the Select cannot be empty when submitting form.
+   * @default false
+   */
+  required: m.bool,
+  /**
+   * The props used for each slot inside the Input.
+   * @default {}
+   */
+  slotProps: m.shape({
+    listbox: m.oneOfType([m.func, m.object]),
+    popup: m.oneOfType([m.func, m.object]),
+    root: m.oneOfType([m.func, m.object])
+  }),
+  /**
+   * The components used for each slot inside the Select.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: m.shape({
+    listbox: m.elementType,
+    popup: m.elementType,
+    root: m.elementType
+  }),
+  /**
+   * The selected value.
+   * Set to `null` to deselect all options.
+   */
+  value: m.any
+});
+const Zo = "open", Ho = "closed", er = "disabled", tr = "gradientMove", nr = "fadeInKeyframe", or = {
+  "prokodo-Select": "prokodo-Select",
+  "prokodo-Select__field": "prokodo-Select__field",
+  "prokodo-Select__field--expanded": "prokodo-Select__field--expanded",
+  "prokodo-Select__button": "prokodo-Select__button",
+  "prokodo-Select__button__inner": "prokodo-Select__button__inner",
+  "prokodo-Select__button--expanded": "prokodo-Select__button--expanded",
+  "prokodo-Select__listbox": "prokodo-Select__listbox",
+  open: Zo,
+  "fade-in": "fade-in",
+  closed: Ho,
+  "fade-out": "fade-out",
+  "placement-top": "placement-top",
+  "placement-bottom": "placement-bottom",
+  "prokodo-Select__item": "prokodo-Select__item",
+  disabled: er,
+  "prokodo-Select__item--selected": "prokodo-Select__item--selected",
+  "base-Option-highlighted": "base-Option-highlighted",
+  "base--selected": "base--selected",
+  "prokodo-Select__item--disabled": "prokodo-Select__item--disabled",
+  "prokodo-Select__popup": "prokodo-Select__popup",
+  "prokodo-Select__checkbox": "prokodo-Select__checkbox",
+  "prokodo-Select__checkbox--checked": "prokodo-Select__checkbox--checked",
+  gradientMove: tr,
+  fadeInKeyframe: nr
+}, Q = xn(or, "Select"), rr = mn(
+  ({
+    id: e,
+    iconVisible: t,
+    required: n,
+    multiple: o,
+    value: r,
+    placeholder: i,
+    color: s = "primary",
+    label: l,
+    labelProps: c = {},
+    hideLabel: u,
+    className: p,
+    classNameSelect: f,
+    items: g,
+    slotProps: d,
+    errorText: h,
+    helperText: w,
+    onChange: R,
+    ...P
+  }) => {
+    const [C, O] = ft(
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      r ?? o ? [] : "default"
+    );
+    Vt(() => {
+      r !== void 0 && O(r);
+    }, [r, C]);
+    const k = bn(
+      (S, V) => {
+        V !== null && (O(V), R == null || R(S, V));
+      },
+      [R]
+    ), E = `${e}-label`, A = `${e}-error`, L = `${e}-helper`, [W, D] = ft(!1);
+    if (Array.isArray(g) ? g.length === 0 : Object.keys(g).length === 0)
+      return null;
+    const F = {
+      expanded: W
+    }, y = i ?? "-- Please choose --", b = dt(h), T = n === !0, j = o === !0, q = dt(w);
+    return /* @__PURE__ */ _.jsxs("div", { className: Q(void 0, void 0, p), children: [
+      (u === void 0 || u === !1) && /* @__PURE__ */ _.jsx(
+        yn,
+        {
+          ...c,
+          error: b,
+          htmlFor: E,
+          label: l,
+          required: n
+        }
+      ),
+      /* @__PURE__ */ _.jsx(
+        "div",
+        {
+          className: Q("field", {
+            ...F,
+            [s]: !!s
+          }),
+          children: /* @__PURE__ */ _.jsxs(
+            nn,
+            {
+              ...P,
+              "aria-invalid": b,
+              "aria-labelledby": E,
+              "aria-required": n ? "true" : void 0,
+              className: Q("select", void 0, f),
+              id: e,
+              multiple: o,
+              required: n,
+              slots: { root: "button", listbox: "ul", popup: "div" },
+              value: C,
+              "aria-describedby": b ? A : q ? L : void 0,
+              renderValue: (S) => {
+                var N, I, B, H;
+                if (S === null && (T || j) || Array.isArray(S) && S.length === 0 && (T || j))
+                  return /* @__PURE__ */ _.jsx(
+                    "span",
+                    {
+                      className: Q("button__inner", {
+                        "is-placeholder": !0
+                      }),
+                      children: y
+                    }
+                  );
+                if (Array.isArray(S)) {
+                  const G = g == null ? void 0 : g.find((ie) => ie.value === r);
+                  return /* @__PURE__ */ _.jsxs("span", { className: Q("button__inner", F), children: [
+                    pt(t) && !gt((N = G == null ? void 0 : G.icon) == null ? void 0 : N.call(G)) && ((I = G == null ? void 0 : G.icon) == null ? void 0 : I.call(G)),
+                    S.map((ie) => ie.label).join(", ")
+                  ] });
+                }
+                const V = g == null ? void 0 : g.find(
+                  (G) => G.value === (S == null ? void 0 : S.value)
+                );
+                return /* @__PURE__ */ _.jsxs("span", { className: Q("button__inner", F), children: [
+                  pt(t) && !gt((B = V == null ? void 0 : V.icon) == null ? void 0 : B.call(V)) && ((H = V == null ? void 0 : V.icon) == null ? void 0 : H.call(V)),
+                  S == null ? void 0 : S.label
+                ] });
+              },
+              slotProps: {
+                ...d,
+                root: {
+                  ...d == null ? void 0 : d.root,
+                  className: Q("button", F),
+                  role: "button",
+                  "aria-haspopup": "listbox",
+                  "aria-expanded": W ? "true" : "false"
+                },
+                listbox: {
+                  ...d == null ? void 0 : d.listbox,
+                  className: Q("listbox"),
+                  role: "listbox"
+                },
+                popup: {
+                  ...d == null ? void 0 : d.popup,
+                  disablePortal: !0,
+                  className: Q("popup", {
+                    "is-expanded": W
+                  })
+                }
+              },
+              onChange: k,
+              onListboxOpenChange: (S) => D(S),
+              children: [
+                !T && !j && /* @__PURE__ */ _.jsx(
+                  Ze,
+                  {
+                    "aria-label": y.toString(),
+                    "aria-selected": C === "default" ? "true" : "false",
+                    value: "default",
+                    className: Q("item", {
+                      selected: C === "default"
+                    }),
+                    children: y
+                  }
+                ),
+                g.map((S) => {
+                  const { icon: V, ...N } = S, B = ((S == null ? void 0 : S.value) === C || (C == null ? void 0 : C.includes(S == null ? void 0 : S.value))) === !0;
+                  return /* @__PURE__ */ _.jsxs(
+                    Ze,
+                    {
+                      className: Q(
+                        "item",
+                        {
+                          selected: B && !j
+                        },
+                        S == null ? void 0 : S.className
+                      ),
+                      ...N,
+                      "aria-label": S == null ? void 0 : S.label,
+                      "aria-selected": B ? "true" : "false",
+                      children: [
+                        j && /* @__PURE__ */ _.jsx(
+                          "input",
+                          {
+                            "aria-hidden": "true",
+                            defaultChecked: B,
+                            type: "checkbox",
+                            className: Q("checkbox", {
+                              checked: B
+                            })
+                          }
+                        ),
+                        V && V(),
+                        S == null ? void 0 : S.label
+                      ]
+                    },
+                    `${E}-item-${S == null ? void 0 : S.value}`
+                  );
+                })
+              ]
+            }
+          )
+        }
+      ),
+      (b || q) && /* @__PURE__ */ _.jsx(
+        "div",
+        {
+          "aria-live": b ? "assertive" : "polite",
+          className: Q("helperText", { "is-error": b }),
+          id: b ? A : L,
+          role: b ? "alert" : void 0,
+          children: /* @__PURE__ */ _.jsx("span", { className: Q("helperText__content"), children: h ?? w })
+        }
+      )
+    ] });
+  }
+);
+rr.displayName = "Select";
+export {
+  rr as S
+};