tmex-cli 0.3.1 → 0.4.0

package/resources/fe-dist/assets/select-BNsiC9zT.js

@@ -0,0 +1,2805 @@
+var Yt = (e) => {
+  throw TypeError(e);
+};
+var Ct = (e, t, n) => t.has(e) || Yt('Cannot ' + n);
+var le = (e, t, n) => (Ct(e, t, 'read from private field'), n ? n.call(e) : t.get(e)),
+  Xe = (e, t, n) =>
+    t.has(e)
+      ? Yt('Cannot add the same private member more than once')
+      : t instanceof WeakSet
+        ? t.add(e)
+        : t.set(e, n),
+  Je = (e, t, n, r) => (Ct(e, t, 'write to private field'), r ? r.call(e, n) : t.set(e, n), n),
+  Ze = (e, t, n) => (Ct(e, t, 'access private method'), n);
+import {
+  bh as $n,
+  aW as $t,
+  ah as At,
+  bd as Be,
+  ba as Bn,
+  bj as Bt,
+  aV as Dn,
+  Y as Dt,
+  aX as Fn,
+  bu as Ft,
+  az as Ge,
+  bi as Gn,
+  b4 as Gt,
+  j as H,
+  a as Hn,
+  bl as Jn,
+  bf as Jt,
+  b2 as Ke,
+  a4 as Kn,
+  bk as L,
+  aU as Ln,
+  b6 as Lt,
+  b0 as Me,
+  z as Mt,
+  q as Ot,
+  br as Pt,
+  a0 as Q,
+  ap as Qn,
+  an as Qt,
+  p as St,
+  a_ as Un,
+  c as Ut,
+  y as Ve,
+  b5 as Vt,
+  b3 as We,
+  ax as Wn,
+  a7 as Xn,
+  b9 as Xt,
+  bg as Yn,
+  ak as Zn,
+  as as Zt,
+  bb as _n,
+  aY as an,
+  L as ar,
+  K as bn,
+  F as br,
+  b8 as cn,
+  M as cr,
+  ag as dn,
+  Q as dr,
+  a5 as ee,
+  bs as en,
+  a2 as er,
+  bc as fn,
+  N as fr,
+  b1 as ft,
+  ac as ge,
+  w as gn,
+  bq as gr,
+  E as he,
+  H as hn,
+  aE as hr,
+  aA as ir,
+  aa as je,
+  aZ as jn,
+  k as ke,
+  bp as lr,
+  s as mn,
+  bt as mr,
+  bn as nr,
+  C as or,
+  v as pn,
+  R as pr,
+  be as qn,
+  bo as rr,
+  r as s,
+  aJ as sr,
+  bm as tr,
+  Z as un,
+  ab as ur,
+  av as ut,
+  b7 as wt,
+  G as xn,
+  bv as xr,
+  J as yr,
+  ae as zn,
+  a$ as zt,
+} from './index-dsVN7rgz.js';
+import {
+  j as Kt,
+  k as Rn,
+  m as Rr,
+  u as _t,
+  l as vn,
+  n as vr,
+  i as yn,
+} from './useValueChanged-V23H0VpC.js';
+var Fe,
+  _e,
+  Ie,
+  He,
+  Ue,
+  Rt,
+  Ht,
+  ln,
+  wr =
+    ((ln = class extends Ln {
+      constructor(n, r) {
+        super();
+        Xe(this, Ue);
+        Xe(this, Fe);
+        Xe(this, _e);
+        Xe(this, Ie);
+        Xe(this, He);
+        Je(this, Fe, n), this.setOptions(r), this.bindMethods(), Ze(this, Ue, Rt).call(this);
+      }
+      bindMethods() {
+        (this.mutate = this.mutate.bind(this)), (this.reset = this.reset.bind(this));
+      }
+      setOptions(n) {
+        var u;
+        const r = this.options;
+        (this.options = le(this, Fe).defaultMutationOptions(n)),
+          Dn(this.options, r) ||
+            le(this, Fe)
+              .getMutationCache()
+              .notify({ type: 'observerOptionsUpdated', mutation: le(this, Ie), observer: this }),
+          r != null &&
+          r.mutationKey &&
+          this.options.mutationKey &&
+          $t(r.mutationKey) !== $t(this.options.mutationKey)
+            ? this.reset()
+            : ((u = le(this, Ie)) == null ? void 0 : u.state.status) === 'pending' &&
+              le(this, Ie).setOptions(this.options);
+      }
+      onUnsubscribe() {
+        var n;
+        this.hasListeners() || (n = le(this, Ie)) == null || n.removeObserver(this);
+      }
+      onMutationUpdate(n) {
+        Ze(this, Ue, Rt).call(this), Ze(this, Ue, Ht).call(this, n);
+      }
+      getCurrentResult() {
+        return le(this, _e);
+      }
+      reset() {
+        var n;
+        (n = le(this, Ie)) == null || n.removeObserver(this),
+          Je(this, Ie, void 0),
+          Ze(this, Ue, Rt).call(this),
+          Ze(this, Ue, Ht).call(this);
+      }
+      mutate(n, r) {
+        var u;
+        return (
+          Je(this, He, r),
+          (u = le(this, Ie)) == null || u.removeObserver(this),
+          Je(this, Ie, le(this, Fe).getMutationCache().build(le(this, Fe), this.options)),
+          le(this, Ie).addObserver(this),
+          le(this, Ie).execute(n)
+        );
+      }
+    }),
+    (Fe = new WeakMap()),
+    (_e = new WeakMap()),
+    (Ie = new WeakMap()),
+    (He = new WeakMap()),
+    (Ue = new WeakSet()),
+    (Rt = function () {
+      var r;
+      const n = ((r = le(this, Ie)) == null ? void 0 : r.state) ?? Fn();
+      Je(this, _e, {
+        ...n,
+        isPending: n.status === 'pending',
+        isSuccess: n.status === 'success',
+        isError: n.status === 'error',
+        isIdle: n.status === 'idle',
+        mutate: this.mutate,
+        reset: this.reset,
+      });
+    }),
+    (Ht = function (n) {
+      an.batch(() => {
+        var r, u, o, d, l, f, p, x;
+        if (le(this, He) && this.hasListeners()) {
+          const i = le(this, _e).variables,
+            b = le(this, _e).context,
+            M = {
+              client: le(this, Fe),
+              meta: this.options.meta,
+              mutationKey: this.options.mutationKey,
+            };
+          if ((n == null ? void 0 : n.type) === 'success') {
+            try {
+              (u = (r = le(this, He)).onSuccess) == null || u.call(r, n.data, i, b, M);
+            } catch (I) {
+              Promise.reject(I);
+            }
+            try {
+              (d = (o = le(this, He)).onSettled) == null || d.call(o, n.data, null, i, b, M);
+            } catch (I) {
+              Promise.reject(I);
+            }
+          } else if ((n == null ? void 0 : n.type) === 'error') {
+            try {
+              (f = (l = le(this, He)).onError) == null || f.call(l, n.error, i, b, M);
+            } catch (I) {
+              Promise.reject(I);
+            }
+            try {
+              (x = (p = le(this, He)).onSettled) == null || x.call(p, void 0, n.error, i, b, M);
+            } catch (I) {
+              Promise.reject(I);
+            }
+          }
+        }
+        this.listeners.forEach((i) => {
+          i(le(this, _e));
+        });
+      });
+    }),
+    ln);
+function Po(e, t) {
+  const n = Hn(),
+    [r] = s.useState(() => new wr(n, e));
+  s.useEffect(() => {
+    r.setOptions(e);
+  }, [r, e]);
+  const u = s.useSyncExternalStore(
+      s.useCallback((d) => r.subscribe(an.batchCalls(d)), [r]),
+      () => r.getCurrentResult(),
+      () => r.getCurrentResult()
+    ),
+    o = s.useCallback(
+      (d, l) => {
+        r.mutate(d, l).catch(jn);
+      },
+      [r]
+    );
+  if (u.error && Un(r.options.throwOnError, [u.error])) throw u.error;
+  return { ...u, mutate: o, mutateAsync: u.mutate };
+} /**
+ * @license lucide-react v0.564.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Sr = [['path', { d: 'M20 6 9 17l-5-5', key: '1gmf2c' }]],
+  Mr = Ut('check', Sr); /**
+ * @license lucide-react v0.564.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Tr = [['path', { d: 'm6 9 6 6 6-6', key: 'qrunsl' }]],
+  wn = Ut('chevron-down', Tr); /**
+ * @license lucide-react v0.564.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Ir = [['path', { d: 'm18 15-6-6-6 6', key: '153udz' }]],
+  Er = Ut('chevron-up', Ir);
+function bt(e, t, n) {
+  return Math.floor(e / t) !== n;
+}
+function lt(e, t) {
+  return t < 0 || t >= e.current.length;
+}
+function Nt(e, t) {
+  return xe(e, { disabledIndices: t });
+}
+function tn(e, t) {
+  return xe(e, { decrement: !0, startingIndex: e.current.length, disabledIndices: t });
+}
+function xe(
+  e,
+  { startingIndex: t = -1, decrement: n = !1, disabledIndices: r, amount: u = 1 } = {}
+) {
+  let o = t;
+  do o += n ? -u : u;
+  while (o >= 0 && o <= e.current.length - 1 && at(e, o, r));
+  return o;
+}
+function Cr(
+  e,
+  {
+    event: t,
+    orientation: n,
+    loopFocus: r,
+    rtl: u,
+    cols: o,
+    disabledIndices: d,
+    minIndex: l,
+    maxIndex: f,
+    prevIndex: p,
+    stopEvent: x = !1,
+  }
+) {
+  let i = p;
+  const b = [],
+    M = {};
+  let I = !1;
+  {
+    let a = null,
+      h = -1;
+    e.current.forEach((g, c) => {
+      if (g == null) return;
+      const m = g.closest('[role="row"]');
+      m && (I = !0),
+        (m !== a || h === -1) && ((a = m), (h += 1), (b[h] = [])),
+        b[h].push(c),
+        (M[c] = h);
+    });
+  }
+  const R = I && b.length > 0 && b.some((a) => a.length !== o);
+  function S(a) {
+    if (!R || p === -1) return;
+    const h = M[p];
+    if (h == null) return;
+    const g = b[h].indexOf(p);
+    let c = a === 'up' ? h - 1 : h + 1;
+    r && (c < 0 ? (c = b.length - 1) : c >= b.length && (c = 0));
+    const m = new Set();
+    while (c >= 0 && c < b.length && !m.has(c)) {
+      m.add(c);
+      const j = b[c];
+      if (j.length === 0) {
+        c = a === 'up' ? c - 1 : c + 1;
+        continue;
+      }
+      const U = Math.min(g, j.length - 1);
+      for (let F = U; F >= 0; F -= 1) {
+        const Z = j[F];
+        if (!at(e, Z, d)) return Z;
+      }
+      (c = a === 'up' ? c - 1 : c + 1),
+        r && (c < 0 ? (c = b.length - 1) : c >= b.length && (c = 0));
+    }
+  }
+  if (t.key === zt) {
+    const a = S('up');
+    if (a !== void 0) x && Me(t), (i = a);
+    else {
+      if ((x && Me(t), p === -1)) i = f;
+      else if (
+        ((i = xe(e, { startingIndex: i, amount: o, decrement: !0, disabledIndices: d })),
+        r && (p - o < l || i < 0))
+      ) {
+        const h = p % o,
+          g = f % o,
+          c = f - (g - h);
+        g === h ? (i = f) : (i = g > h ? c : c - o);
+      }
+      lt(e, i) && (i = p);
+    }
+  }
+  if (t.key === ft) {
+    const a = S('down');
+    a !== void 0
+      ? (x && Me(t), (i = a))
+      : (x && Me(t),
+        p === -1
+          ? (i = l)
+          : ((i = xe(e, { startingIndex: p, amount: o, disabledIndices: d })),
+            r &&
+              p + o > f &&
+              (i = xe(e, { startingIndex: (p % o) - o, amount: o, disabledIndices: d }))),
+        lt(e, i) && (i = p));
+  }
+  if (n === 'both') {
+    const a = Gt(p / o);
+    t.key === (u ? Ke : We) &&
+      (x && Me(t),
+      p % o !== o - 1
+        ? ((i = xe(e, { startingIndex: p, disabledIndices: d })),
+          r && bt(i, o, a) && (i = xe(e, { startingIndex: p - (p % o) - 1, disabledIndices: d })))
+        : r && (i = xe(e, { startingIndex: p - (p % o) - 1, disabledIndices: d })),
+      bt(i, o, a) && (i = p)),
+      t.key === (u ? We : Ke) &&
+        (x && Me(t),
+        p % o !== 0
+          ? ((i = xe(e, { startingIndex: p, decrement: !0, disabledIndices: d })),
+            r &&
+              bt(i, o, a) &&
+              (i = xe(e, { startingIndex: p + (o - (p % o)), decrement: !0, disabledIndices: d })))
+          : r &&
+            (i = xe(e, { startingIndex: p + (o - (p % o)), decrement: !0, disabledIndices: d })),
+        bt(i, o, a) && (i = p));
+    const h = Gt(f / o) === a;
+    lt(e, i) &&
+      (r && h
+        ? (i =
+            t.key === (u ? We : Ke)
+              ? f
+              : xe(e, { startingIndex: p - (p % o) - 1, disabledIndices: d }))
+        : (i = p));
+  }
+  return i;
+}
+function Ar(e, t, n) {
+  const r = [];
+  let u = 0;
+  return (
+    e.forEach(({ width: o, height: d }, l) => {
+      let f = !1;
+      while (!f) {
+        const p = [];
+        for (let x = 0; x < o; x += 1) for (let i = 0; i < d; i += 1) p.push(u + x + i * t);
+        (u % t) + o <= t && p.every((x) => r[x] == null)
+          ? (p.forEach((x) => {
+              r[x] = l;
+            }),
+            (f = !0))
+          : (u += 1);
+      }
+    }),
+    [...r]
+  );
+}
+function Pr(e, t, n, r, u) {
+  if (e === -1) return -1;
+  const o = n.indexOf(e),
+    d = t[e];
+  switch (u) {
+    case 'tl':
+      return o;
+    case 'tr':
+      return d ? o + d.width - 1 : o;
+    case 'bl':
+      return d ? o + (d.height - 1) * r : o;
+    case 'br':
+      return n.lastIndexOf(e);
+    default:
+      return -1;
+  }
+}
+function Or(e, t) {
+  return t.flatMap((n, r) => (e.includes(n) ? [r] : []));
+}
+function at(e, t, n) {
+  if (typeof n == 'function') return n(t);
+  if (n) return n.includes(t);
+  const r = e.current[t];
+  return r ? r.hasAttribute('disabled') || r.getAttribute('aria-disabled') === 'true' : !1;
+}
+const Nr = s.forwardRef((t, n) => {
+    const {
+        render: r,
+        className: u,
+        id: o,
+        name: d,
+        value: l,
+        disabled: f = !1,
+        onValueChange: p,
+        defaultValue: x,
+        autoFocus: i = !1,
+        ...b
+      } = t,
+      {
+        state: M,
+        name: I,
+        disabled: R,
+        setTouched: S,
+        setDirty: a,
+        validityData: h,
+        setFocused: g,
+        setFilled: c,
+        validationMode: m,
+        validation: j,
+      } = _t(),
+      U = R || f,
+      F = I ?? d,
+      Z = { ...M, disabled: U },
+      { labelId: ae } = yn(),
+      X = Kt({ id: o });
+    ee(() => {
+      var W;
+      const y = l != null;
+      ((W = j.inputRef.current) != null && W.value) || (y && l !== '')
+        ? c(!0)
+        : y && l === '' && c(!1);
+    }, [j.inputRef, c, l]);
+    const z = s.useRef(null);
+    ee(() => {
+      i && z.current === Vt(ut(z.current)) && g(!0);
+    }, [i, g]);
+    const [q] = Lt({ controlled: l, default: x, name: 'FieldControl', state: 'value' }),
+      E = l !== void 0,
+      te = E ? q : void 0;
+    return (
+      Rn({
+        id: X,
+        name: F,
+        commit: j.commit,
+        value: te,
+        getValue: () => {
+          var y;
+          return (y = j.inputRef.current) == null ? void 0 : y.value;
+        },
+        controlRef: j.inputRef,
+      }),
+      Ve('input', t, {
+        ref: [n, z],
+        state: Z,
+        props: [
+          {
+            id: X,
+            disabled: U,
+            name: F,
+            ref: j.inputRef,
+            'aria-labelledby': ae,
+            autoFocus: i,
+            ...(E ? { value: te } : { defaultValue: x }),
+            onChange(y) {
+              const W = y.currentTarget.value;
+              p == null || p(W, he(wt, y.nativeEvent)), a(W !== h.initialValue), c(W !== '');
+            },
+            onFocus() {
+              g(!0);
+            },
+            onBlur(y) {
+              S(!0), g(!1), m === 'onBlur' && j.commit(y.currentTarget.value);
+            },
+            onKeyDown(y) {
+              y.currentTarget.tagName === 'INPUT' &&
+                y.key === 'Enter' &&
+                (S(!0), j.commit(y.currentTarget.value));
+            },
+          },
+          j.getInputValidationProps(),
+          b,
+        ],
+        stateAttributesMapping: vn,
+      })
+    );
+  }),
+  kr = s.forwardRef((t, n) => H.jsx(Nr, { ref: n, ...t }));
+function Oo({ className: e, type: t, ...n }) {
+  return H.jsx(kr, {
+    type: t,
+    'data-slot': 'input',
+    className: ke(
+      'dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 aria-invalid:ring-3 md:text-sm file:text-foreground placeholder:text-muted-foreground w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50',
+      e
+    ),
+    ...n,
+  });
+}
+function Vr(e, t = {}) {
+  const n = 'rootStore' in e ? e.rootStore : e,
+    r = n.context.dataRef,
+    {
+      enabled: u = !0,
+      event: o = 'click',
+      toggle: d = !0,
+      ignoreMouse: l = !1,
+      stickIfOpen: f = !0,
+      touchOpenDelay: p = 0,
+      reason: x = zn,
+    } = t,
+    i = s.useRef(void 0),
+    b = cn(),
+    M = je(),
+    I = s.useMemo(
+      () => ({
+        onPointerDown(R) {
+          i.current = R.pointerType;
+        },
+        onMouseDown(R) {
+          const S = i.current,
+            a = R.nativeEvent,
+            h = n.select('open');
+          if (R.button !== 0 || o === 'click' || (Xt(S, !0) && l)) return;
+          const g = r.current.openEvent,
+            c = g == null ? void 0 : g.type,
+            m = n.select('domReferenceElement') !== R.currentTarget,
+            j = (h && m) || !(h && d && (!(g && f) || c === 'click' || c === 'mousedown'));
+          if (_n(a.target)) {
+            const F = he(x, a, a.target);
+            j && S === 'touch' && p > 0
+              ? M.start(p, () => {
+                  n.setOpen(!0, F);
+                })
+              : n.setOpen(j, F);
+            return;
+          }
+          const U = R.currentTarget;
+          b.request(() => {
+            const F = he(x, a, U);
+            j && S === 'touch' && p > 0
+              ? M.start(p, () => {
+                  n.setOpen(!0, F);
+                })
+              : n.setOpen(j, F);
+          });
+        },
+        onClick(R) {
+          if (o === 'mousedown-only') return;
+          const S = i.current;
+          if (o === 'mousedown' && S) {
+            i.current = void 0;
+            return;
+          }
+          if (Xt(S, !0) && l) return;
+          const a = n.select('open'),
+            h = r.current.openEvent,
+            g = n.select('domReferenceElement') !== R.currentTarget,
+            c = (a && g) || !(a && d && (!(h && f) || Bn(h))),
+            m = he(x, R.nativeEvent, R.currentTarget);
+          c && S === 'touch' && p > 0
+            ? M.start(p, () => {
+                n.setOpen(!0, m);
+              })
+            : n.setOpen(c, m);
+        },
+        onKeyDown() {
+          i.current = void 0;
+        },
+      }),
+      [r, o, l, n, f, d, b, M, p, x]
+    );
+  return s.useMemo(() => (u ? { reference: I } : un), [u, I]);
+}
+const Lr = 'Escape';
+function Tt(e, t, n) {
+  switch (e) {
+    case 'vertical':
+      return t;
+    case 'horizontal':
+      return n;
+    default:
+      return t || n;
+  }
+}
+function xt(e, t) {
+  return Tt(t, e === zt || e === ft, e === Ke || e === We);
+}
+function kt(e, t, n) {
+  return Tt(t, e === ft, n ? e === Ke : e === We) || e === 'Enter' || e === ' ' || e === '';
+}
+function Dr(e, t, n) {
+  return Tt(t, n ? e === Ke : e === We, e === ft);
+}
+function Fr(e, t, n, r) {
+  const u = n ? e === We : e === Ke,
+    o = e === zt;
+  return t === 'both' || (t === 'horizontal' && r && r > 1) ? e === Lr : Tt(t, u, o);
+}
+function Hr(e, t) {
+  const n = 'rootStore' in e ? e.rootStore : e,
+    r = n.useState('open'),
+    u = n.useState('floatingElement'),
+    o = n.useState('domReferenceElement'),
+    d = n.context.dataRef,
+    {
+      listRef: l,
+      activeIndex: f,
+      onNavigate: p = () => {},
+      enabled: x = !0,
+      selectedIndex: i = null,
+      allowEscape: b = !1,
+      loopFocus: M = !1,
+      nested: I = !1,
+      rtl: R = !1,
+      virtual: S = !1,
+      focusItemOnOpen: a = 'auto',
+      focusItemOnHover: h = !0,
+      openOnArrowKeyDown: g = !0,
+      disabledIndices: c = void 0,
+      orientation: m = 'vertical',
+      parentOrientation: j,
+      cols: U = 1,
+      id: F,
+      resetOnPointerLeave: Z = !0,
+      externalTree: ae,
+    } = t,
+    X = fn(u),
+    z = Be(X),
+    q = Kn(),
+    E = Wn(ae);
+  ee(() => {
+    d.current.orientation = m;
+  }, [d, m]);
+  const te = qn(o),
+    Y = s.useRef(a),
+    y = s.useRef(i ?? -1),
+    W = s.useRef(null),
+    v = s.useRef(!0),
+    P = ge((T) => {
+      p(y.current === -1 ? null : y.current, T);
+    }),
+    J = s.useRef(P),
+    C = s.useRef(!!u),
+    me = s.useRef(r),
+    A = s.useRef(!1),
+    ne = s.useRef(!1),
+    O = Be(c),
+    $ = Be(r),
+    se = Be(i),
+    Ee = Be(Z),
+    Pe = ge(() => {
+      function T(_) {
+        S
+          ? E == null || E.events.emit('virtualfocus', _)
+          : Jt(_, { sync: A.current, preventScroll: !0 });
+      }
+      const N = l.current[y.current],
+        w = ne.current;
+      N && T(N),
+        (A.current ? (_) => _() : requestAnimationFrame)(() => {
+          var ue;
+          const _ = l.current[y.current] || N;
+          if (!_) return;
+          N || T(_),
+            G &&
+              (w || !v.current) &&
+              ((ue = _.scrollIntoView) == null ||
+                ue.call(_, { block: 'nearest', inline: 'nearest' }));
+        });
+    });
+  ee(() => {
+    x &&
+      (r && u
+        ? ((y.current = i ?? -1), Y.current && i != null && ((ne.current = !0), P()))
+        : C.current && ((y.current = -1), J.current()));
+  }, [x, r, u, i, P]),
+    ee(() => {
+      if (x) {
+        if (!r) {
+          A.current = !1;
+          return;
+        }
+        if (u)
+          if (f == null) {
+            if (((A.current = !1), se.current != null)) return;
+            if (
+              (C.current && ((y.current = -1), Pe()),
+              (!me.current || !C.current) &&
+                Y.current &&
+                (W.current != null || (Y.current === !0 && W.current == null)))
+            ) {
+              let T = 0;
+              const N = () => {
+                l.current[0] == null
+                  ? (T < 2 && (T ? requestAnimationFrame : queueMicrotask)(N), (T += 1))
+                  : ((y.current = W.current == null || kt(W.current, m, R) || I ? Nt(l) : tn(l)),
+                    (W.current = null),
+                    P());
+              };
+              N();
+            }
+          } else lt(l, f) || ((y.current = f), Pe(), (ne.current = !1));
+      }
+    }, [x, r, u, f, se, I, l, m, R, P, Pe, O]),
+    ee(() => {
+      var _, V;
+      if (!x || u || !E || S || !C.current) return;
+      const T = E.nodesRef.current,
+        N =
+          (V = (_ = T.find((ue) => ue.id === q)) == null ? void 0 : _.context) == null
+            ? void 0
+            : V.elements.floating,
+        w = Vt(ut(u)),
+        D = T.some((ue) => ue.context && Ge(ue.context.elements.floating, w));
+      N && !D && v.current && N.focus({ preventScroll: !0 });
+    }, [x, u, E, q, S]),
+    ee(() => {
+      (J.current = P), (me.current = r), (C.current = !!u);
+    }),
+    ee(() => {
+      r || ((W.current = null), (Y.current = a));
+    }, [r, a]);
+  const B = f != null,
+    G = s.useMemo(() => {
+      function T(w) {
+        if (!$.current) return;
+        const D = l.current.indexOf(w.currentTarget);
+        D !== -1 && y.current !== D && ((y.current = D), P(w));
+      }
+      return {
+        onFocus(w) {
+          (A.current = !0), T(w);
+        },
+        onClick: ({ currentTarget: w }) => w.focus({ preventScroll: !0 }),
+        onMouseMove(w) {
+          (A.current = !0), (ne.current = !1), h && T(w);
+        },
+        onPointerLeave(w) {
+          var _;
+          if (!$.current || !v.current || w.pointerType === 'touch') return;
+          A.current = !0;
+          const D = w.relatedTarget;
+          !h ||
+            l.current.includes(D) ||
+            (Ee.current &&
+              (Jt(null, { sync: !0 }),
+              (y.current = -1),
+              P(w),
+              S || (_ = z.current) == null || _.focus({ preventScroll: !0 })));
+        },
+      };
+    }, [$, z, h, l, P, Ee, S]),
+    de = s.useCallback(() => {
+      var T, N, w;
+      return (
+        j ??
+        ((w =
+          (N =
+            (T = E == null ? void 0 : E.nodesRef.current.find((D) => D.id === q)) == null
+              ? void 0
+              : T.context) == null
+            ? void 0
+            : N.dataRef) == null
+          ? void 0
+          : w.current.orientation)
+      );
+    }, [q, E, j]),
+    ce = ge((T) => {
+      if (
+        ((v.current = !1),
+        (A.current = !0),
+        T.which === 229 || (!$.current && T.currentTarget === z.current))
+      )
+        return;
+      if (I && Fr(T.key, m, R, U)) {
+        xt(T.key, de()) || Me(T),
+          n.setOpen(!1, he(At, T.nativeEvent)),
+          Zt(o) && (S ? E == null || E.events.emit('virtualfocus', o) : o.focus());
+        return;
+      }
+      const N = y.current,
+        w = Nt(l, c),
+        D = tn(l, c);
+      if (
+        (te ||
+          (T.key === 'Home' && (Me(T), (y.current = w), P(T)),
+          T.key === 'End' && (Me(T), (y.current = D), P(T))),
+        U > 1)
+      ) {
+        const _ = Array.from({ length: l.current.length }, () => ({ width: 1, height: 1 })),
+          V = Ar(_, U),
+          ue = V.findIndex((Re) => Re != null && !at(l, Re, c)),
+          ye = V.reduce((Re, re, ve) => (re != null && !at(l, re, c) ? ve : Re), -1),
+          Ce =
+            V[
+              Cr(
+                { current: V.map((Re) => (Re != null ? l.current[Re] : null)) },
+                {
+                  event: T,
+                  orientation: m,
+                  loopFocus: M,
+                  rtl: R,
+                  cols: U,
+                  disabledIndices: Or(
+                    [
+                      ...((typeof c != 'function' ? c : null) ||
+                        l.current.map((Re, re) => (at(l, re, c) ? re : void 0))),
+                      void 0,
+                    ],
+                    V
+                  ),
+                  minIndex: ue,
+                  maxIndex: ye,
+                  prevIndex: Pr(
+                    y.current > D ? w : y.current,
+                    _,
+                    V,
+                    U,
+                    T.key === ft ? 'bl' : T.key === (R ? Ke : We) ? 'tr' : 'tl'
+                  ),
+                  stopEvent: !0,
+                }
+              )
+            ];
+        if ((Ce != null && ((y.current = Ce), P(T)), m === 'both')) return;
+      }
+      if (xt(T.key, m)) {
+        if ((Me(T), r && !S && Vt(T.currentTarget.ownerDocument) === T.currentTarget)) {
+          (y.current = kt(T.key, m, R) ? w : D), P(T);
+          return;
+        }
+        kt(T.key, m, R)
+          ? M
+            ? N >= D
+              ? b && N !== l.current.length
+                ? (y.current = -1)
+                : ((A.current = !1), (y.current = w))
+              : (y.current = xe(l, { startingIndex: N, disabledIndices: c }))
+            : (y.current = Math.min(D, xe(l, { startingIndex: N, disabledIndices: c })))
+          : M
+            ? N <= w
+              ? b && N !== -1
+                ? (y.current = l.current.length)
+                : ((A.current = !1), (y.current = D))
+              : (y.current = xe(l, { startingIndex: N, decrement: !0, disabledIndices: c }))
+            : (y.current = Math.max(
+                w,
+                xe(l, { startingIndex: N, decrement: !0, disabledIndices: c })
+              )),
+          lt(l, y.current) && (y.current = -1),
+          P(T);
+      }
+    }),
+    fe = s.useMemo(() => S && r && B && { 'aria-activedescendant': `${F}-${f}` }, [S, r, B, F, f]),
+    be = s.useMemo(
+      () => ({
+        'aria-orientation': m === 'both' ? void 0 : m,
+        ...(te ? {} : fe),
+        onKeyDown(T) {
+          if (T.key === 'Tab' && T.shiftKey && r && !S) {
+            const N = Yn(T.nativeEvent);
+            if (N && !Ge(z.current, N)) return;
+            Me(T), n.setOpen(!1, he(dn, T.nativeEvent)), Zt(o) && o.focus();
+            return;
+          }
+          ce(T);
+        },
+        onPointerMove() {
+          v.current = !0;
+        },
+      }),
+      [fe, ce, z, m, te, n, r, S, o]
+    ),
+    ie = s.useMemo(() => {
+      function T(w) {
+        a === 'auto' && $n(w.nativeEvent) && (Y.current = !S);
+      }
+      function N(w) {
+        (Y.current = a), a === 'auto' && Gn(w.nativeEvent) && (Y.current = !0);
+      }
+      return {
+        onKeyDown(w) {
+          const D = n.select('open');
+          v.current = !1;
+          const _ = w.key.startsWith('Arrow'),
+            V = Dr(w.key, de(), R),
+            ue = xt(w.key, m),
+            ye = (I ? V : ue) || w.key === 'Enter' || w.key.trim() === '';
+          if (S && D) return ce(w);
+          if (!(!D && !g && _)) {
+            if (ye) {
+              const Ce = xt(w.key, de());
+              W.current = I && Ce ? null : w.key;
+            }
+            if (I) {
+              V &&
+                (Me(w),
+                D
+                  ? ((y.current = Nt(l, O.current)), P(w))
+                  : n.setOpen(!0, he(At, w.nativeEvent, w.currentTarget)));
+              return;
+            }
+            ue &&
+              (se.current != null && (y.current = se.current),
+              Me(w),
+              !D && g ? n.setOpen(!0, he(At, w.nativeEvent, w.currentTarget)) : ce(w),
+              D && P(w));
+          }
+        },
+        onFocus(w) {
+          n.select('open') && !S && ((y.current = -1), P(w));
+        },
+        onPointerDown: N,
+        onPointerEnter: N,
+        onMouseDown: T,
+        onClick: T,
+      };
+    }, [ce, O, a, l, I, P, n, g, m, de, R, se, S]),
+    pe = s.useMemo(() => ({ ...fe, ...ie }), [fe, ie]);
+  return s.useMemo(
+    () => (x ? { reference: pe, floating: be, item: G, trigger: ie } : {}),
+    [x, pe, be, ie, G]
+  );
+}
+function jr(e, t) {
+  const n = 'rootStore' in e ? e.rootStore : e,
+    r = n.context.dataRef,
+    u = n.useState('open'),
+    {
+      listRef: o,
+      activeIndex: d,
+      onMatch: l,
+      onTypingChange: f,
+      enabled: p = !0,
+      resetMs: x = 750,
+      selectedIndex: i = null,
+    } = t,
+    b = je(),
+    M = s.useRef(''),
+    I = s.useRef(i ?? d ?? -1),
+    R = s.useRef(null);
+  ee(() => {
+    (!u && i !== null) || (b.clear(), (R.current = null), M.current !== '' && (M.current = ''));
+  }, [u, i, b]),
+    ee(() => {
+      u && M.current === '' && (I.current = i ?? d ?? -1);
+    }, [u, i, d]);
+  const S = ge((m) => {
+      m
+        ? r.current.typing || ((r.current.typing = m), f == null || f(m))
+        : r.current.typing && ((r.current.typing = m), f == null || f(m));
+    }),
+    a = ge((m) => {
+      function j(z, q, E) {
+        const te = q.find(
+          (Y) => (Y == null ? void 0 : Y.toLocaleLowerCase().indexOf(E.toLocaleLowerCase())) === 0
+        );
+        return te ? z.indexOf(te) : -1;
+      }
+      const U = o.current;
+      if (
+        (M.current.length > 0 &&
+          M.current[0] !== ' ' &&
+          (j(U, U, M.current) === -1 ? S(!1) : m.key === ' ' && Me(m)),
+        U == null || m.key.length !== 1 || m.ctrlKey || m.metaKey || m.altKey)
+      )
+        return;
+      u && m.key !== ' ' && (Me(m), S(!0));
+      const F = M.current === '';
+      F && (I.current = i ?? d ?? -1),
+        U.every((z) => {
+          var q, E;
+          return z
+            ? ((q = z[0]) == null ? void 0 : q.toLocaleLowerCase()) !==
+                ((E = z[1]) == null ? void 0 : E.toLocaleLowerCase())
+            : !0;
+        }) &&
+          M.current === m.key &&
+          ((M.current = ''), (I.current = R.current)),
+        (M.current += m.key),
+        b.start(x, () => {
+          (M.current = ''), (I.current = R.current), S(!1);
+        });
+      const ae = F ? (i ?? d ?? -1) : I.current,
+        X = j(U, [...U.slice((ae || 0) + 1), ...U.slice(0, (ae || 0) + 1)], M.current);
+      X !== -1 ? (l == null || l(X), (R.current = X)) : m.key !== ' ' && ((M.current = ''), S(!1));
+    }),
+    h = ge((m) => {
+      const j = m.relatedTarget,
+        U = n.select('domReferenceElement'),
+        F = n.select('floatingElement'),
+        Z = Ge(U, j),
+        ae = Ge(F, j);
+      Z || ae || (b.clear(), (M.current = ''), (I.current = R.current), S(!1));
+    }),
+    g = s.useMemo(() => ({ onKeyDown: a, onBlur: h }), [a, h]),
+    c = s.useMemo(
+      () => ({
+        onKeyDown: a,
+        onKeyUp(m) {
+          m.key === ' ' && S(!1);
+        },
+        onBlur: h,
+      }),
+      [a, h, S]
+    );
+  return s.useMemo(() => (p ? { reference: g, floating: c } : {}), [p, g, c]);
+}
+function No({ className: e, size: t = 'default', ...n }) {
+  return H.jsx('div', {
+    'data-slot': 'card',
+    'data-size': t,
+    className: ke(
+      'ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-xl py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl group/card flex flex-col',
+      e
+    ),
+    ...n,
+  });
+}
+function ko({ className: e, ...t }) {
+  return H.jsx('div', {
+    'data-slot': 'card-header',
+    className: ke(
+      'gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]',
+      e
+    ),
+    ...t,
+  });
+}
+function Vo({ className: e, ...t }) {
+  return H.jsx('div', {
+    'data-slot': 'card-title',
+    className: ke('text-base leading-snug font-medium group-data-[size=sm]/card:text-sm', e),
+    ...t,
+  });
+}
+function Lo({ className: e, ...t }) {
+  return H.jsx('div', {
+    'data-slot': 'card-description',
+    className: ke('text-muted-foreground text-sm', e),
+    ...t,
+  });
+}
+function Do({ className: e, ...t }) {
+  return H.jsx('div', {
+    'data-slot': 'card-content',
+    className: ke('px-4 group-data-[size=sm]/card:px-3', e),
+    ...t,
+  });
+}
+const Sn = s.createContext(null),
+  Mn = s.createContext(null);
+function De() {
+  const e = s.useContext(Sn);
+  if (e === null) throw new Error(St(60));
+  return e;
+}
+function Tn() {
+  const e = s.useContext(Mn);
+  if (e === null) throw new Error(St(61));
+  return e;
+}
+const Ur = (e, t) => Object.is(e, t);
+function et(e, t, n) {
+  return e == null || t == null ? Object.is(e, t) : n(e, t);
+}
+function zr(e, t, n) {
+  return !e || e.length === 0 ? !1 : e.some((r) => (r === void 0 ? !1 : et(t, r, n)));
+}
+function ct(e, t, n) {
+  return !e || e.length === 0 ? -1 : e.findIndex((r) => (r === void 0 ? !1 : et(r, t, n)));
+}
+function Br(e, t, n) {
+  return e.filter((r) => !et(t, r, n));
+}
+function jt(e) {
+  if (e == null) return '';
+  if (typeof e == 'string') return e;
+  try {
+    return JSON.stringify(e);
+  } catch {
+    return String(e);
+  }
+}
+function In(e) {
+  return e != null && e.length > 0 && typeof e[0] == 'object' && e[0] != null && 'items' in e[0];
+}
+function _r(e) {
+  if (!Array.isArray(e)) return e != null && !('null' in e);
+  if (In(e)) {
+    for (const t of e)
+      for (const n of t.items) if (n && n.value == null && n.label != null) return !0;
+    return !1;
+  }
+  for (const t of e) if (t && t.value == null && t.label != null) return !0;
+  return !1;
+}
+function Kr(e, t) {
+  if (t && e != null) return t(e) ?? '';
+  if (e && typeof e == 'object') {
+    if ('label' in e && e.label != null) return String(e.label);
+    if ('value' in e) return String(e.value);
+  }
+  return jt(e);
+}
+function Qe(e, t) {
+  return t && e != null
+    ? (t(e) ?? '')
+    : e && typeof e == 'object' && 'value' in e && 'label' in e
+      ? jt(e.value)
+      : jt(e);
+}
+function En(e, t, n) {
+  function r() {
+    return Kr(e, n);
+  }
+  if (n && e != null) return n(e);
+  if (e && typeof e == 'object' && 'label' in e && e.label != null) return e.label;
+  if (t && !Array.isArray(t)) return t[e] ?? r();
+  if (Array.isArray(t)) {
+    const u = In(t) ? t.flatMap((o) => o.items) : t;
+    if (e == null || typeof e != 'object') {
+      const o = u.find((d) => d.value === e);
+      return o && o.label != null ? o.label : r();
+    }
+    if ('value' in e) {
+      const o = u.find((d) => d && d.value === e.value);
+      if (o && o.label != null) return o.label;
+    }
+  }
+  return r();
+}
+function Wr(e, t, n) {
+  return e.reduce(
+    (r, u, o) => (
+      o > 0 && r.push(', '), r.push(H.jsx(s.Fragment, { children: En(u, t, n) }, o)), r
+    ),
+    []
+  );
+}
+const k = {
+  id: Q((e) => e.id),
+  modal: Q((e) => e.modal),
+  multiple: Q((e) => e.multiple),
+  items: Q((e) => e.items),
+  itemToStringLabel: Q((e) => e.itemToStringLabel),
+  itemToStringValue: Q((e) => e.itemToStringValue),
+  isItemEqualToValue: Q((e) => e.isItemEqualToValue),
+  value: Q((e) => e.value),
+  hasSelectedValue: Q((e) => {
+    const { value: t, multiple: n, itemToStringValue: r } = e;
+    return t == null ? !1 : n && Array.isArray(t) ? t.length > 0 : Qe(t, r) !== '';
+  }),
+  hasNullItemLabel: Q((e, t) => (t ? _r(e.items) : !1)),
+  open: Q((e) => e.open),
+  mounted: Q((e) => e.mounted),
+  forceMount: Q((e) => e.forceMount),
+  transitionStatus: Q((e) => e.transitionStatus),
+  openMethod: Q((e) => e.openMethod),
+  activeIndex: Q((e) => e.activeIndex),
+  selectedIndex: Q((e) => e.selectedIndex),
+  isActive: Q((e, t) => e.activeIndex === t),
+  isSelected: Q((e, t, n) => {
+    const r = e.isItemEqualToValue,
+      u = e.value;
+    return e.multiple
+      ? Array.isArray(u) && u.some((o) => et(n, o, r))
+      : e.selectedIndex === t && e.selectedIndex !== null
+        ? !0
+        : et(n, u, r);
+  }),
+  isSelectedByFocus: Q((e, t) => e.selectedIndex === t),
+  popupProps: Q((e) => e.popupProps),
+  triggerProps: Q((e) => e.triggerProps),
+  triggerElement: Q((e) => e.triggerElement),
+  positionerElement: Q((e) => e.positionerElement),
+  listElement: Q((e) => e.listElement),
+  scrollUpArrowVisible: Q((e) => e.scrollUpArrowVisible),
+  scrollDownArrowVisible: Q((e) => e.scrollDownArrowVisible),
+  hasScrollArrows: Q((e) => e.hasScrollArrows),
+};
+function qr(e) {
+  const {
+      id: t,
+      value: n,
+      defaultValue: r = null,
+      onValueChange: u,
+      open: o,
+      defaultOpen: d = !1,
+      onOpenChange: l,
+      name: f,
+      autoComplete: p,
+      disabled: x = !1,
+      readOnly: i = !1,
+      required: b = !1,
+      modal: M = !0,
+      actionsRef: I,
+      inputRef: R,
+      onOpenChangeComplete: S,
+      items: a,
+      multiple: h = !1,
+      itemToStringLabel: g,
+      itemToStringValue: c,
+      isItemEqualToValue: m = Ur,
+      highlightItemOnHover: j = !0,
+      children: U,
+    } = e,
+    { clearErrors: F } = Rr(),
+    {
+      setDirty: Z,
+      setTouched: ae,
+      setFocused: X,
+      shouldValidateOnChange: z,
+      validityData: q,
+      setFilled: E,
+      name: te,
+      disabled: Y,
+      validation: y,
+      validationMode: W,
+    } = _t(),
+    v = Kt({ id: t }),
+    P = Y || x,
+    J = te ?? f,
+    [C, me] = Lt({ controlled: n, default: h ? (r ?? Qt) : r, name: 'Select', state: 'value' }),
+    [A, ne] = Lt({ controlled: o, default: d, name: 'Select', state: 'open' }),
+    O = s.useRef([]),
+    $ = s.useRef([]),
+    se = s.useRef(null),
+    Ee = s.useRef(null),
+    Pe = s.useRef(0),
+    B = s.useRef(null),
+    G = s.useRef([]),
+    de = s.useRef(!1),
+    ce = s.useRef(!1),
+    fe = s.useRef(null),
+    be = s.useRef({ allowSelectedMouseUp: !1, allowUnselectedMouseUp: !1 }),
+    ie = s.useRef(!1),
+    { mounted: pe, setMounted: T, transitionStatus: N } = Bt(A),
+    { openMethod: w, triggerProps: D, reset: _ } = Xn(A),
+    V = Dt(
+      () =>
+        new rr({
+          id: v,
+          modal: M,
+          multiple: h,
+          itemToStringLabel: g,
+          itemToStringValue: c,
+          isItemEqualToValue: m,
+          value: C,
+          open: A,
+          mounted: pe,
+          transitionStatus: N,
+          items: a,
+          forceMount: !1,
+          openMethod: null,
+          activeIndex: null,
+          selectedIndex: null,
+          popupProps: {},
+          triggerProps: {},
+          triggerElement: null,
+          positionerElement: null,
+          listElement: null,
+          scrollUpArrowVisible: !1,
+          scrollDownArrowVisible: !1,
+          hasScrollArrows: !1,
+        })
+    ).current,
+    ue = L(V, k.activeIndex),
+    ye = L(V, k.selectedIndex),
+    Ce = L(V, k.triggerElement),
+    Re = L(V, k.positionerElement),
+    re = s.useMemo(() => (h && Array.isArray(C) && C.length === 0 ? '' : Qe(C, c)), [h, C, c]),
+    ve = s.useMemo(() => (h && Array.isArray(C) ? C.map((K) => Qe(K, c)) : Qe(C, c)), [h, C, c]),
+    Te = Be(V.state.triggerElement);
+  Rn({ id: v, commit: y.commit, value: C, controlRef: Te, name: J, getValue: () => ve });
+  const Oe = s.useRef(C);
+  ee(() => {
+    C !== Oe.current && V.set('forceMount', !0);
+  }, [V, C]),
+    ee(() => {
+      E(h ? Array.isArray(C) && C.length > 0 : C != null);
+    }, [h, C, E]),
+    ee(() => {
+      if (A) return;
+      const oe = G.current;
+      if (h) {
+        const Ne = Array.isArray(C) ? C : [];
+        if (Ne.length === 0) {
+          V.set('selectedIndex', null);
+          return;
+        }
+        const Ae = Ne[Ne.length - 1],
+          ze = ct(oe, Ae, m);
+        V.set('selectedIndex', ze === -1 ? null : ze);
+        return;
+      }
+      const Se = ct(oe, C, m);
+      V.set('selectedIndex', Se === -1 ? null : Se);
+    }, [h, A, C, G, m, V]),
+    vr(C, () => {
+      F(J), Z(C !== q.initialValue), z() ? y.commit(C) : y.commit(C, !0);
+    });
+  const tt = ge((K, oe) => {
+      if (
+        (l == null || l(K, oe),
+        !oe.isCanceled &&
+          (ne(K),
+          !K &&
+            (oe.reason === dn || oe.reason === or) &&
+            (ae(!0), X(!1), W === 'onBlur' && y.commit(C)),
+          !K && V.state.activeIndex !== null))
+      ) {
+        const Se = O.current[V.state.activeIndex];
+        queueMicrotask(() => {
+          Se == null || Se.setAttribute('tabindex', '-1');
+        });
+      }
+    }),
+    nt = ge(() => {
+      T(!1), V.set('activeIndex', null), _(), S == null || S(!1);
+    });
+  Mt({
+    enabled: !I,
+    open: A,
+    ref: se,
+    onComplete() {
+      A || nt();
+    },
+  }),
+    s.useImperativeHandle(I, () => ({ unmount: nt }), [nt]);
+  const qe = ge((K, oe) => {
+      u == null || u(K, oe), !oe.isCanceled && me(K);
+    }),
+    rt = ge(() => {
+      const K = V.state.listElement || se.current;
+      if (!K) return;
+      const oe = K.scrollTop,
+        Se = K.scrollTop + K.clientHeight,
+        Ne = oe > 1,
+        Ae = Se < K.scrollHeight - 1;
+      V.state.scrollUpArrowVisible !== Ne && V.set('scrollUpArrowVisible', Ne),
+        V.state.scrollDownArrowVisible !== Ae && V.set('scrollDownArrowVisible', Ae);
+    }),
+    we = Jn({ open: A, onOpenChange: tt, elements: { reference: Ce, floating: Re } }),
+    dt = Vr(we, { enabled: !i && !P, event: 'mousedown' }),
+    pt = Zn(we, { bubbles: !1 }),
+    ot = Hr(we, {
+      enabled: !i && !P,
+      listRef: O,
+      activeIndex: ue,
+      selectedIndex: ye,
+      disabledIndices: Qt,
+      onNavigate(K) {
+        (K === null && !A) || V.set('activeIndex', K);
+      },
+      focusItemOnHover: !1,
+    }),
+    Le = jr(we, {
+      enabled: !i && !P && (A || !h),
+      listRef: $,
+      activeIndex: ue,
+      selectedIndex: ye,
+      onMatch(K) {
+        A ? V.set('activeIndex', K) : qe(G.current[K], he('none'));
+      },
+      onTypingChange(K) {
+        de.current = K;
+      },
+    }),
+    { getReferenceProps: gt, getFloatingProps: Ye, getItemProps: st } = Qn([dt, pt, ot, Le]),
+    it = s.useMemo(() => pn(gt(), D, v ? { id: v } : un), [gt, D, v]);
+  er(() => {
+    V.update({ popupProps: Ye(), triggerProps: it });
+  }),
+    ee(() => {
+      V.update({
+        id: v,
+        modal: M,
+        multiple: h,
+        value: C,
+        open: A,
+        mounted: pe,
+        transitionStatus: N,
+        popupProps: Ye(),
+        triggerProps: it,
+        items: a,
+        itemToStringLabel: g,
+        itemToStringValue: c,
+        isItemEqualToValue: m,
+        openMethod: w,
+      });
+    }, [V, v, M, h, C, A, pe, N, Ye, it, a, g, c, m, w]);
+  const It = s.useMemo(
+      () => ({
+        store: V,
+        name: J,
+        required: b,
+        disabled: P,
+        readOnly: i,
+        multiple: h,
+        itemToStringLabel: g,
+        itemToStringValue: c,
+        highlightItemOnHover: j,
+        setValue: qe,
+        setOpen: tt,
+        listRef: O,
+        popupRef: se,
+        scrollHandlerRef: Ee,
+        handleScrollArrowVisibility: rt,
+        scrollArrowsMountedCountRef: Pe,
+        getItemProps: st,
+        events: we.context.events,
+        valueRef: B,
+        valuesRef: G,
+        labelsRef: $,
+        typingRef: de,
+        selectionRef: be,
+        selectedItemTextRef: fe,
+        validation: y,
+        onOpenChangeComplete: S,
+        keyboardActiveRef: ce,
+        alignItemWithTriggerActiveRef: ie,
+        initialValueRef: Oe,
+      }),
+      [V, J, b, P, i, h, g, c, j, qe, tt, st, we.context.events, y, S, rt]
+    ),
+    mt = gn(R, y.inputRef),
+    ht = h && Array.isArray(C) && C.length > 0,
+    Et = s.useMemo(
+      () =>
+        !h || !Array.isArray(C) || !J
+          ? null
+          : C.map((K) => {
+              const oe = Qe(K, c);
+              return H.jsx('input', { type: 'hidden', name: J, value: oe }, oe);
+            }),
+      [h, C, J, c]
+    );
+  return H.jsx(Sn.Provider, {
+    value: It,
+    children: H.jsxs(Mn.Provider, {
+      value: we,
+      children: [
+        U,
+        H.jsx('input', {
+          ...y.getInputValidationProps({
+            onFocus() {
+              var K;
+              (K = V.state.triggerElement) == null || K.focus({ focusVisible: !0 });
+            },
+            onChange(K) {
+              if (K.nativeEvent.defaultPrevented) return;
+              const oe = K.target.value,
+                Se = he(wt, K.nativeEvent);
+              function Ne() {
+                if (h) return;
+                const Ae = G.current.find((ze) => Qe(ze, c).toLowerCase() === oe.toLowerCase());
+                Ae != null && (Z(Ae !== q.initialValue), qe(Ae, Se), z() && y.commit(Ae));
+              }
+              V.set('forceMount', !0), queueMicrotask(Ne);
+            },
+          }),
+          name: h ? void 0 : J,
+          autoComplete: p,
+          value: re,
+          disabled: P,
+          required: b && !ht,
+          readOnly: i,
+          ref: mt,
+          style: J ? tr : nr,
+          tabIndex: -1,
+          'aria-hidden': !0,
+        }),
+        Et,
+      ],
+    }),
+  });
+}
+function Yr(e) {
+  const t = e.getBoundingClientRect(),
+    n = window.getComputedStyle(e, '::before'),
+    r = window.getComputedStyle(e, '::after');
+  if (!(n.content !== 'none' || r.content !== 'none')) return t;
+  const o = Number.parseFloat(n.width) || 0,
+    d = Number.parseFloat(n.height) || 0,
+    l = Number.parseFloat(r.width) || 0,
+    f = Number.parseFloat(r.height) || 0,
+    p = Math.max(t.width, o, l),
+    x = Math.max(t.height, d, f),
+    i = p - t.width,
+    b = x - t.height;
+  return {
+    left: t.left - i / 2,
+    right: t.right + i / 2,
+    top: t.top - b / 2,
+    bottom: t.bottom + b / 2,
+  };
+}
+const yt = 2,
+  $r = 400,
+  nn = 200,
+  Gr = { ...sr, ...vn, value: () => null },
+  Xr = s.forwardRef((t, n) => {
+    const { render: r, className: u, id: o, disabled: d = !1, nativeButton: l = !0, ...f } = t,
+      { setTouched: p, setFocused: x, validationMode: i, state: b, disabled: M } = _t(),
+      { labelId: I } = yn(),
+      {
+        store: R,
+        setOpen: S,
+        selectionRef: a,
+        validation: h,
+        readOnly: g,
+        required: c,
+        alignItemWithTriggerActiveRef: m,
+        disabled: j,
+        keyboardActiveRef: U,
+      } = De(),
+      F = M || j || d,
+      Z = L(R, k.open),
+      ae = L(R, k.value),
+      X = L(R, k.triggerProps),
+      z = L(R, k.positionerElement),
+      q = L(R, k.listElement),
+      E = L(R, k.id),
+      te = L(R, k.hasSelectedValue),
+      Y = !te && Z,
+      y = L(R, k.hasNullItemLabel, Y),
+      W = o ?? E;
+    Kt({ id: W });
+    const v = Be(z),
+      P = s.useRef(null),
+      { getButtonProps: J, buttonRef: C } = mn({ disabled: F, native: l }),
+      me = ge((G) => {
+        R.set('triggerElement', G);
+      }),
+      A = gn(n, P, C, me),
+      ne = je(),
+      O = je(),
+      $ = je(),
+      se = je();
+    s.useEffect(() => {
+      if (Z)
+        return (
+          !(te || y)
+            ? $.start($r, () => {
+                (a.current.allowUnselectedMouseUp = !0), (a.current.allowSelectedMouseUp = !0);
+              })
+            : se.start(nn, () => {
+                (a.current.allowUnselectedMouseUp = !0),
+                  $.start(nn, () => {
+                    a.current.allowSelectedMouseUp = !0;
+                  });
+              }),
+          () => {
+            $.clear(), se.clear();
+          }
+        );
+      (a.current = { allowSelectedMouseUp: !1, allowUnselectedMouseUp: !1 }), O.clear();
+    }, [Z, te, y, a, O, $, se]);
+    const Ee = s.useMemo(() => {
+        var G;
+        return (q == null ? void 0 : q.id) ?? ((G = fn(z)) == null ? void 0 : G.id);
+      }, [q, z]),
+      Pe = pn(
+        X,
+        {
+          id: W,
+          role: 'combobox',
+          'aria-expanded': Z ? 'true' : 'false',
+          'aria-haspopup': 'listbox',
+          'aria-controls': Z ? Ee : void 0,
+          'aria-labelledby': I,
+          'aria-readonly': g || void 0,
+          'aria-required': c || void 0,
+          tabIndex: F ? -1 : 0,
+          ref: A,
+          onFocus(G) {
+            x(!0),
+              Z && m.current && S(!1, he(wt, G.nativeEvent)),
+              ne.start(0, () => {
+                R.set('forceMount', !0);
+              });
+          },
+          onBlur(G) {
+            Ge(z, G.relatedTarget) || (p(!0), x(!1), i === 'onBlur' && h.commit(ae));
+          },
+          onPointerMove() {
+            U.current = !1;
+          },
+          onKeyDown() {
+            U.current = !0;
+          },
+          onMouseDown(G) {
+            if (Z) return;
+            const de = ut(G.currentTarget);
+            function ce(fe) {
+              if (!P.current) return;
+              const be = fe.target;
+              if (Ge(P.current, be) || Ge(v.current, be) || be === P.current) return;
+              const ie = Yr(P.current);
+              (fe.clientX >= ie.left - yt &&
+                fe.clientX <= ie.right + yt &&
+                fe.clientY >= ie.top - yt &&
+                fe.clientY <= ie.bottom + yt) ||
+                S(!1, he(ir, fe));
+            }
+            O.start(0, () => {
+              de.addEventListener('mouseup', ce, { once: !0 });
+            });
+          },
+        },
+        h.getValidationProps,
+        f,
+        J
+      );
+    Pe.role = 'combobox';
+    const B = { ...b, open: Z, disabled: F, value: ae, readOnly: g, placeholder: !te };
+    return Ve('button', t, { ref: [n, P], state: B, stateAttributesMapping: Gr, props: Pe });
+  }),
+  Jr = { value: () => null },
+  Zr = s.forwardRef((t, n) => {
+    const { className: r, render: u, children: o, placeholder: d, ...l } = t,
+      { store: f, valueRef: p } = De(),
+      x = L(f, k.value),
+      i = L(f, k.items),
+      b = L(f, k.itemToStringLabel),
+      M = L(f, k.hasSelectedValue),
+      I = !M && d != null && o == null,
+      R = L(f, k.hasNullItemLabel, I),
+      S = { value: x, placeholder: !M };
+    let a = null;
+    return (
+      typeof o == 'function'
+        ? (a = o(x))
+        : o != null
+          ? (a = o)
+          : !M && d != null && !R
+            ? (a = d)
+            : Array.isArray(x)
+              ? (a = Wr(x, i, b))
+              : (a = En(x, i, b)),
+      Ve('span', t, {
+        state: S,
+        ref: [n, p],
+        props: [{ children: a }, l],
+        stateAttributesMapping: Jr,
+      })
+    );
+  }),
+  Qr = s.forwardRef((t, n) => {
+    const { className: r, render: u, ...o } = t,
+      { store: d } = De(),
+      f = { open: L(d, k.open) };
+    return Ve('span', t, {
+      state: f,
+      ref: n,
+      props: [{ 'aria-hidden': !0, children: '▼' }, o],
+      stateAttributesMapping: lr,
+    });
+  }),
+  eo = s.createContext(void 0),
+  to = s.forwardRef((t, n) => {
+    const { store: r } = De(),
+      u = L(r, k.mounted),
+      o = L(r, k.forceMount);
+    return u || o ? H.jsx(eo.Provider, { value: !0, children: H.jsx(ar, { ref: n, ...t }) }) : null;
+  }),
+  Cn = s.createContext({
+    register: () => {},
+    unregister: () => {},
+    subscribeMapChange: () => () => {},
+    elementsRef: { current: [] },
+    nextIndexRef: { current: 0 },
+  });
+function no() {
+  return s.useContext(Cn);
+}
+function ro(e) {
+  const { children: t, elementsRef: n, labelsRef: r, onMapChange: u } = e,
+    o = ge(u),
+    d = s.useRef(0),
+    l = Dt(so).current,
+    f = Dt(oo).current,
+    [p, x] = s.useState(0),
+    i = s.useRef(p),
+    b = ge((a, h) => {
+      f.set(a, h ?? null), (i.current += 1), x(i.current);
+    }),
+    M = ge((a) => {
+      f.delete(a), (i.current += 1), x(i.current);
+    }),
+    I = s.useMemo(() => {
+      const a = new Map();
+      return (
+        Array.from(f.keys())
+          .filter((g) => g.isConnected)
+          .sort(io)
+          .forEach((g, c) => {
+            const m = f.get(g) ?? {};
+            a.set(g, { ...m, index: c });
+          }),
+        a
+      );
+    }, [f, p]);
+  ee(() => {
+    if (typeof MutationObserver != 'function' || I.size === 0) return;
+    const a = new MutationObserver((h) => {
+      const g = new Set(),
+        c = (m) => (g.has(m) ? g.delete(m) : g.add(m));
+      h.forEach((m) => {
+        m.removedNodes.forEach(c), m.addedNodes.forEach(c);
+      }),
+        g.size === 0 && ((i.current += 1), x(i.current));
+    });
+    return (
+      I.forEach((h, g) => {
+        g.parentElement && a.observe(g.parentElement, { childList: !0 });
+      }),
+      () => {
+        a.disconnect();
+      }
+    );
+  }, [I]),
+    ee(() => {
+      i.current === p &&
+        (n.current.length !== I.size && (n.current.length = I.size),
+        r && r.current.length !== I.size && (r.current.length = I.size),
+        (d.current = I.size)),
+        o(I);
+    }, [o, I, n, r, p]),
+    ee(
+      () => () => {
+        n.current = [];
+      },
+      [n]
+    ),
+    ee(
+      () => () => {
+        r && (r.current = []);
+      },
+      [r]
+    );
+  const R = ge(
+    (a) => (
+      l.add(a),
+      () => {
+        l.delete(a);
+      }
+    )
+  );
+  ee(() => {
+    l.forEach((a) => a(I));
+  }, [l, I]);
+  const S = s.useMemo(
+    () => ({
+      register: b,
+      unregister: M,
+      subscribeMapChange: R,
+      elementsRef: n,
+      labelsRef: r,
+      nextIndexRef: d,
+    }),
+    [b, M, R, n, r, d]
+  );
+  return H.jsx(Cn.Provider, { value: S, children: t });
+}
+function oo() {
+  return new Map();
+}
+function so() {
+  return new Set();
+}
+function io(e, t) {
+  const n = e.compareDocumentPosition(t);
+  return n & Node.DOCUMENT_POSITION_FOLLOWING || n & Node.DOCUMENT_POSITION_CONTAINED_BY
+    ? -1
+    : n & Node.DOCUMENT_POSITION_PRECEDING || n & Node.DOCUMENT_POSITION_CONTAINS
+      ? 1
+      : 0;
+}
+const An = s.createContext(void 0);
+function Wt() {
+  const e = s.useContext(An);
+  if (!e) throw new Error(St(59));
+  return e;
+}
+function vt(e, t) {
+  e && Object.assign(e.style, t);
+}
+const Pn = { position: 'relative', maxHeight: '100%', overflowX: 'hidden', overflowY: 'auto' },
+  lo = { position: 'fixed' },
+  ao = s.forwardRef((t, n) => {
+    const {
+        anchor: r,
+        positionMethod: u = 'absolute',
+        className: o,
+        render: d,
+        side: l = 'bottom',
+        align: f = 'center',
+        sideOffset: p = 0,
+        alignOffset: x = 0,
+        collisionBoundary: i = 'clipping-ancestors',
+        collisionPadding: b,
+        arrowPadding: M = 5,
+        sticky: I = !1,
+        disableAnchorTracking: R,
+        alignItemWithTrigger: S = !0,
+        collisionAvoidance: a = cr,
+        ...h
+      } = t,
+      {
+        store: g,
+        listRef: c,
+        labelsRef: m,
+        alignItemWithTriggerActiveRef: j,
+        selectedItemTextRef: U,
+        valuesRef: F,
+        initialValueRef: Z,
+        popupRef: ae,
+        setValue: X,
+      } = De(),
+      z = Tn(),
+      q = L(g, k.open),
+      E = L(g, k.mounted),
+      te = L(g, k.modal),
+      Y = L(g, k.value),
+      y = L(g, k.openMethod),
+      W = L(g, k.positionerElement),
+      v = L(g, k.triggerElement),
+      P = L(g, k.isItemEqualToValue),
+      J = L(g, k.transitionStatus),
+      C = s.useRef(null),
+      me = s.useRef(null),
+      [A, ne] = s.useState(S),
+      O = E && A && y !== 'touch';
+    !E && A !== S && ne(S),
+      ee(() => {
+        E ||
+          (k.scrollUpArrowVisible(g.state) && g.set('scrollUpArrowVisible', !1),
+          k.scrollDownArrowVisible(g.state) && g.set('scrollDownArrowVisible', !1));
+      }, [g, E]),
+      s.useImperativeHandle(j, () => O),
+      ur((O || te) && q && y !== 'touch', v);
+    const $ = fr({
+        anchor: r,
+        floatingRootContext: z,
+        positionMethod: u,
+        mounted: E,
+        side: l,
+        sideOffset: p,
+        align: f,
+        alignOffset: x,
+        arrowPadding: M,
+        collisionBoundary: i,
+        collisionPadding: b,
+        sticky: I,
+        disableAnchorTracking: R ?? O,
+        collisionAvoidance: a,
+        keepMounted: !0,
+      }),
+      se = O ? 'none' : $.side,
+      Ee = O ? lo : $.positionerStyles,
+      Pe = s.useMemo(() => {
+        const ie = {};
+        return (
+          q || (ie.pointerEvents = 'none'),
+          { role: 'presentation', hidden: !E, style: { ...Ee, ...ie } }
+        );
+      }, [q, E, Ee]),
+      B = { open: q, side: se, align: $.align, anchorHidden: $.anchorHidden },
+      G = ge((ie) => {
+        g.set('positionerElement', ie);
+      }),
+      de = Ve('div', t, {
+        ref: [n, G],
+        state: B,
+        stateAttributesMapping: hn,
+        props: [Pe, bn(J), h],
+      }),
+      ce = s.useRef(0),
+      fe = ge((ie) => {
+        if ((ie.size === 0 && ce.current === 0) || F.current.length === 0) return;
+        const pe = ce.current;
+        if (((ce.current = ie.size), ie.size === pe)) return;
+        const T = he(wt);
+        if (pe !== 0 && !g.state.multiple && Y !== null && ct(F.current, Y, P) === -1) {
+          const w = Z.current,
+            _ = w != null && ct(F.current, w, P) !== -1 ? w : null;
+          X(_, T), _ === null && (g.set('selectedIndex', null), (U.current = null));
+        }
+        if (pe !== 0 && g.state.multiple && Array.isArray(Y)) {
+          const N = (D) => ct(F.current, D, P) !== -1,
+            w = Y.filter((D) => N(D));
+          (w.length !== Y.length || w.some((D) => !zr(Y, D, P))) &&
+            (X(w, T), w.length === 0 && (g.set('selectedIndex', null), (U.current = null)));
+        }
+        if (q && O) {
+          g.update({ scrollUpArrowVisible: !1, scrollDownArrowVisible: !1 });
+          const N = { height: '' };
+          vt(W, N), vt(ae.current, N);
+        }
+      }),
+      be = s.useMemo(
+        () => ({
+          ...$,
+          side: se,
+          alignItemWithTriggerActive: O,
+          setControlledAlignItemWithTrigger: ne,
+          scrollUpArrowRef: C,
+          scrollDownArrowRef: me,
+        }),
+        [$, se, O, ne]
+      );
+    return H.jsx(ro, {
+      elementsRef: c,
+      labelsRef: m,
+      onMapChange: fe,
+      children: H.jsxs(An.Provider, {
+        value: be,
+        children: [E && te && H.jsx(dr, { inert: pr(!q), cutout: v }), de],
+      }),
+    });
+  });
+function On(e) {
+  const t = e.currentTarget.getBoundingClientRect();
+  return (
+    t.top + 1 <= e.clientY &&
+    e.clientY <= t.bottom - 1 &&
+    t.left + 1 <= e.clientX &&
+    e.clientX <= t.right - 1
+  );
+}
+const co = s.createContext(void 0);
+function uo(e) {
+  return s.useContext(co);
+}
+const $e = 1,
+  fo = { ...hn, ...xn },
+  po = s.forwardRef((t, n) => {
+    const { render: r, className: u, finalFocus: o, ...d } = t,
+      {
+        store: l,
+        popupRef: f,
+        onOpenChangeComplete: p,
+        setOpen: x,
+        valueRef: i,
+        selectedItemTextRef: b,
+        keyboardActiveRef: M,
+        multiple: I,
+        handleScrollArrowVisibility: R,
+        scrollHandlerRef: S,
+        highlightItemOnHover: a,
+      } = De(),
+      {
+        side: h,
+        align: g,
+        alignItemWithTriggerActive: c,
+        setControlledAlignItemWithTrigger: m,
+        scrollDownArrowRef: j,
+        scrollUpArrowRef: U,
+      } = Wt(),
+      F = uo() != null,
+      Z = Tn(),
+      { nonce: ae, disableStyleElements: X } = gr(),
+      z = je(),
+      q = L(l, k.id),
+      E = L(l, k.open),
+      te = L(l, k.mounted),
+      Y = L(l, k.popupProps),
+      y = L(l, k.transitionStatus),
+      W = L(l, k.triggerElement),
+      v = L(l, k.positionerElement),
+      P = L(l, k.listElement),
+      J = s.useRef(0),
+      C = s.useRef(!1),
+      me = s.useRef(0),
+      A = s.useRef(!1),
+      ne = s.useRef({}),
+      O = cn(),
+      $ = ge((B) => {
+        if (!v || !f.current || !A.current) return;
+        if (C.current || !c) {
+          R();
+          return;
+        }
+        const G = v.style.top === '0px',
+          de = v.style.bottom === '0px',
+          ce = v.getBoundingClientRect().height,
+          fe = ut(v),
+          be = getComputedStyle(v),
+          ie = Number.parseFloat(be.marginTop),
+          pe = Number.parseFloat(be.marginBottom),
+          T = rn(getComputedStyle(f.current)),
+          N = Math.min(fe.documentElement.clientHeight - ie - pe, T),
+          w = B.scrollTop,
+          D = on(B);
+        let _ = 0,
+          V = null,
+          ue = !1,
+          ye = !1;
+        const Ce = (re) => {
+            v.style.height = `${re}px`;
+          },
+          Re = (re, ve) => {
+            const Te = Pt(re, 0, N - ce);
+            Te > 0 && Ce(ce + Te), (B.scrollTop = ve), N - (ce + Te) <= $e && (C.current = !0), R();
+          };
+        if (G) {
+          const re = D - w,
+            ve = ce + re,
+            Te = Math.min(ve, N);
+          if (((_ = Te), re <= $e)) {
+            Re(re, D);
+            return;
+          }
+          N - Te > $e ? (ye = !0) : (ue = !0);
+        } else if (de) {
+          const re = w,
+            ve = ce + re,
+            Te = Math.min(ve, N),
+            Oe = ve - N;
+          if (((_ = Te), re <= $e)) {
+            Re(re, 0);
+            return;
+          }
+          N - Te > $e ? (V = 0) : ((ue = !0), w < D && (V = w - (re - Oe)));
+        }
+        if (((_ = Math.ceil(_)), _ !== 0 && Ce(_), ye || V != null)) {
+          const re = on(B),
+            ve = ye ? re : Pt(V, 0, re);
+          Math.abs(B.scrollTop - ve) > $e && (B.scrollTop = ve);
+        }
+        (ue || _ >= N - $e) && (C.current = !0), R();
+      });
+    s.useImperativeHandle(S, () => $, [$]),
+      Mt({
+        open: E,
+        ref: f,
+        onComplete() {
+          E && (p == null || p(!0));
+        },
+      });
+    const se = { open: E, transitionStatus: y, side: h, align: g };
+    ee(() => {
+      !v ||
+        !f.current ||
+        Object.keys(ne.current).length ||
+        (ne.current = {
+          top: v.style.top || '0',
+          left: v.style.left || '0',
+          right: v.style.right,
+          height: v.style.height,
+          bottom: v.style.bottom,
+          minHeight: v.style.minHeight,
+          maxHeight: v.style.maxHeight,
+          marginTop: v.style.marginTop,
+          marginBottom: v.style.marginBottom,
+        });
+    }, [f, v]),
+      ee(() => {
+        E ||
+          c ||
+          ((A.current = !1),
+          (C.current = !1),
+          (J.current = 0),
+          (me.current = 0),
+          vt(v, ne.current));
+      }, [E, c, v, f]),
+      ee(() => {
+        const B = f.current;
+        if (!(!E || !W || !v || !B || l.state.transitionStatus === 'ending')) {
+          if (!c) {
+            (A.current = !0), O.request(R), B.style.removeProperty('--transform-origin');
+            return;
+          }
+          queueMicrotask(() => {
+            var de;
+            const G = go(B);
+            B.style.removeProperty('--transform-origin');
+            try {
+              const ce = getComputedStyle(v),
+                fe = getComputedStyle(B),
+                be = ut(W),
+                ie = en(v),
+                pe = W.getBoundingClientRect(),
+                T = v.getBoundingClientRect(),
+                N = pe.left,
+                w = pe.height,
+                D = P || B,
+                _ = D.scrollHeight,
+                V = Number.parseFloat(fe.borderBottomWidth),
+                ue = Number.parseFloat(ce.marginTop) || 10,
+                ye = Number.parseFloat(ce.marginBottom) || 10,
+                Ce = Number.parseFloat(ce.minHeight) || 100,
+                Re = rn(fe),
+                re = 5,
+                ve = 5,
+                Te = 20,
+                Oe = be.documentElement.clientHeight - ue - ye,
+                tt = be.documentElement.clientWidth,
+                nt = Oe - pe.bottom + w,
+                qe = b.current,
+                rt = i.current;
+              let we,
+                dt = 0,
+                pt = 0;
+              if (qe && rt) {
+                const oe = rt.getBoundingClientRect();
+                we = qe.getBoundingClientRect();
+                const Se = oe.left - N,
+                  Ne = we.left - T.left,
+                  Ae = oe.top - pe.top + oe.height / 2,
+                  ze = we.top - T.top + we.height / 2;
+                (dt = Se - Ne), (pt = ze - Ae);
+              }
+              const ot = nt + pt + ye + V;
+              let Le = Math.min(Oe, ot);
+              const gt = Oe - ue - ye,
+                Ye = ot - Le,
+                st = Math.max(re, N + dt),
+                it = tt - ve,
+                It = Math.max(0, st + T.width - it);
+              (v.style.left = `${st - It}px`),
+                (v.style.height = `${Le}px`),
+                (v.style.maxHeight = 'auto'),
+                (v.style.marginTop = `${ue}px`),
+                (v.style.marginBottom = `${ye}px`),
+                (B.style.height = '100%');
+              const mt = D.scrollHeight - D.clientHeight,
+                ht = Ye >= mt;
+              ht && (Le = Math.min(Oe, T.height) - (Ye - mt));
+              const Et = pe.top < Te || pe.bottom > Oe - Te || Le < Math.min(_, Ce),
+                K = (((de = ie.visualViewport) == null ? void 0 : de.scale) ?? 1) !== 1 && mr;
+              if (Et || K) {
+                (A.current = !0), vt(v, ne.current), hr.flushSync(() => m(!1));
+                return;
+              }
+              if (ht) {
+                const oe = Math.max(0, Oe - ot);
+                (v.style.top = T.height >= gt ? '0' : `${oe}px`),
+                  (v.style.height = `${Le}px`),
+                  (D.scrollTop = D.scrollHeight - D.clientHeight),
+                  (J.current = Math.max(Ce, Le));
+              } else (v.style.bottom = '0'), (J.current = Math.max(Ce, Le)), (D.scrollTop = Ye);
+              if (we) {
+                const oe = T.top,
+                  Se = T.height,
+                  Ne = we.top + we.height / 2,
+                  Ae = Se > 0 ? ((Ne - oe) / Se) * 100 : 50,
+                  ze = Pt(Ae, 0, 100);
+                B.style.setProperty('--transform-origin', `50% ${ze}%`);
+              }
+              (J.current === Oe || Le >= Re) && (C.current = !0),
+                R(),
+                setTimeout(() => {
+                  A.current = !0;
+                });
+            } finally {
+              G();
+            }
+          });
+        }
+      }, [l, E, v, W, i, b, f, R, c, m, O, j, U, P]),
+      s.useEffect(() => {
+        if (!c || !v || !E) return;
+        const B = en(v);
+        function G(de) {
+          x(!1, he(xr, de));
+        }
+        return (
+          B.addEventListener('resize', G),
+          () => {
+            B.removeEventListener('resize', G);
+          }
+        );
+      }, [x, c, v, E]);
+    const Ee = {
+        ...(P
+          ? { role: 'presentation', 'aria-orientation': void 0 }
+          : { role: 'listbox', 'aria-multiselectable': I || void 0, id: `${q}-list` }),
+        onKeyDown(B) {
+          (M.current = !0), F && yr.has(B.key) && B.stopPropagation();
+        },
+        onMouseMove() {
+          M.current = !1;
+        },
+        onPointerLeave(B) {
+          if (!a || On(B) || B.pointerType === 'touch') return;
+          const G = B.currentTarget;
+          z.start(0, () => {
+            l.set('activeIndex', null), G.focus({ preventScroll: !0 });
+          });
+        },
+        onScroll(B) {
+          P || $(B.currentTarget);
+        },
+        ...(c && { style: P ? { height: '100%' } : Pn }),
+      },
+      Pe = Ve('div', t, {
+        ref: [n, f],
+        state: se,
+        stateAttributesMapping: fo,
+        props: [Y, Ee, bn(y), { className: !P && c ? Ft.className : void 0 }, d],
+      });
+    return H.jsxs(s.Fragment, {
+      children: [
+        !X && Ft.getElement(ae),
+        H.jsx(br, {
+          context: Z,
+          modal: !1,
+          disabled: !te,
+          returnFocus: o,
+          restoreFocus: !0,
+          children: Pe,
+        }),
+      ],
+    });
+  });
+function rn(e) {
+  const t = e.maxHeight || '';
+  return (t.endsWith('px') && Number.parseFloat(t)) || 1 / 0;
+}
+function on(e) {
+  return Math.max(0, e.scrollHeight - e.clientHeight);
+}
+const sn = [
+  ['transform', 'none'],
+  ['scale', '1'],
+  ['translate', '0 0'],
+];
+function go(e) {
+  const { style: t } = e,
+    n = {};
+  for (const [r, u] of sn) (n[r] = t.getPropertyValue(r)), t.setProperty(r, u, 'important');
+  return () => {
+    for (const [r] of sn) {
+      const u = n[r];
+      u ? t.setProperty(r, u) : t.removeProperty(r);
+    }
+  };
+}
+const mo = s.forwardRef((t, n) => {
+  const { className: r, render: u, ...o } = t,
+    { store: d, scrollHandlerRef: l } = De(),
+    { alignItemWithTriggerActive: f } = Wt(),
+    p = L(d, k.hasScrollArrows),
+    x = L(d, k.openMethod),
+    i = L(d, k.multiple),
+    M = {
+      id: `${L(d, k.id)}-list`,
+      role: 'listbox',
+      'aria-multiselectable': i || void 0,
+      onScroll(R) {
+        var S;
+        (S = l.current) == null || S.call(l, R.currentTarget);
+      },
+      ...(f && { style: Pn }),
+      className: p && x !== 'touch' ? Ft.className : void 0,
+    },
+    I = ge((R) => {
+      d.set('listElement', R);
+    });
+  return Ve('div', t, { ref: [n, I], props: [M, o] });
+});
+const Nn = ((e) => ((e[(e.None = 0)] = 'None'), (e[(e.GuessFromOrder = 1)] = 'GuessFromOrder'), e))(
+  {}
+);
+function ho(e = {}) {
+  const { label: t, metadata: n, textRef: r, indexGuessBehavior: u, index: o } = e,
+    {
+      register: d,
+      unregister: l,
+      subscribeMapChange: f,
+      elementsRef: p,
+      labelsRef: x,
+      nextIndexRef: i,
+    } = no(),
+    b = s.useRef(-1),
+    [M, I] = s.useState(
+      o ??
+        (u === Nn.GuessFromOrder
+          ? () => {
+              if (b.current === -1) {
+                const a = i.current;
+                (i.current += 1), (b.current = a);
+              }
+              return b.current;
+            }
+          : -1)
+    ),
+    R = s.useRef(null),
+    S = s.useCallback(
+      (a) => {
+        var h;
+        if (((R.current = a), M !== -1 && a !== null && ((p.current[M] = a), x))) {
+          const g = t !== void 0;
+          x.current[M] = g
+            ? t
+            : (((h = r == null ? void 0 : r.current) == null ? void 0 : h.textContent) ??
+              a.textContent);
+        }
+      },
+      [M, p, x, t, r]
+    );
+  return (
+    ee(() => {
+      if (o != null) return;
+      const a = R.current;
+      if (a)
+        return (
+          d(a, n),
+          () => {
+            l(a);
+          }
+        );
+    }, [o, d, l, n]),
+    ee(() => {
+      if (o == null)
+        return f((a) => {
+          var g;
+          const h = R.current ? ((g = a.get(R.current)) == null ? void 0 : g.index) : null;
+          h != null && I(h);
+        });
+    }, [o, f, I]),
+    s.useMemo(() => ({ ref: S, index: M }), [M, S])
+  );
+}
+const kn = s.createContext(void 0);
+function qt() {
+  const e = s.useContext(kn);
+  if (!e) throw new Error(St(57));
+  return e;
+}
+const bo = s.memo(
+    s.forwardRef((t, n) => {
+      const {
+          render: r,
+          className: u,
+          value: o = null,
+          label: d,
+          disabled: l = !1,
+          nativeButton: f = !1,
+          ...p
+        } = t,
+        x = s.useRef(null),
+        i = ho({ label: d, textRef: x, indexGuessBehavior: Nn.GuessFromOrder }),
+        {
+          store: b,
+          getItemProps: M,
+          setOpen: I,
+          setValue: R,
+          selectionRef: S,
+          typingRef: a,
+          valuesRef: h,
+          keyboardActiveRef: g,
+          multiple: c,
+          highlightItemOnHover: m,
+        } = De(),
+        j = je(),
+        U = L(b, k.isActive, i.index),
+        F = L(b, k.isSelected, i.index, o),
+        Z = L(b, k.isSelectedByFocus, i.index),
+        ae = L(b, k.isItemEqualToValue),
+        X = i.index,
+        z = X !== -1,
+        q = s.useRef(null),
+        E = Be(X);
+      ee(() => {
+        if (!z) return;
+        const O = h.current;
+        return (
+          (O[X] = o),
+          () => {
+            delete O[X];
+          }
+        );
+      }, [z, X, o, h]),
+        ee(() => {
+          if (!z) return;
+          const O = b.state.value;
+          let $ = O;
+          c && Array.isArray(O) && O.length > 0 && ($ = O[O.length - 1]),
+            $ !== void 0 && et(o, $, ae) && b.set('selectedIndex', X);
+        }, [z, X, c, ae, b, o]);
+      const te = { disabled: l, selected: F, highlighted: U },
+        Y = M({ active: U, selected: F });
+      (Y.onFocus = void 0), (Y.id = void 0);
+      const y = s.useRef(null),
+        W = s.useRef('mouse'),
+        v = s.useRef(!1),
+        { getButtonProps: P, buttonRef: J } = mn({
+          disabled: l,
+          focusableWhenDisabled: !0,
+          native: f,
+        });
+      function C(O) {
+        const $ = b.state.value;
+        if (c) {
+          const se = Array.isArray($) ? $ : [],
+            Ee = F ? Br(se, o, ae) : [...se, o];
+          R(Ee, he(Ot, O));
+        } else R(o, he(Ot, O)), I(!1, he(Ot, O));
+      }
+      const me = {
+          role: 'option',
+          'aria-selected': F,
+          tabIndex: U ? 0 : -1,
+          onFocus() {
+            b.set('activeIndex', X);
+          },
+          onMouseEnter() {
+            !g.current && b.state.selectedIndex === null && m && b.set('activeIndex', X);
+          },
+          onMouseMove() {
+            m && b.set('activeIndex', X);
+          },
+          onMouseLeave(O) {
+            !m ||
+              g.current ||
+              On(O) ||
+              j.start(0, () => {
+                b.state.activeIndex === X && b.set('activeIndex', null);
+              });
+          },
+          onTouchStart() {
+            S.current = { allowSelectedMouseUp: !1, allowUnselectedMouseUp: !1 };
+          },
+          onKeyDown(O) {
+            (y.current = O.key), b.set('activeIndex', X);
+          },
+          onClick(O) {
+            (v.current = !1),
+              !(O.type === 'keydown' && y.current === null) &&
+                (l ||
+                  (y.current === ' ' && a.current) ||
+                  (W.current !== 'touch' && !U) ||
+                  ((y.current = null), C(O.nativeEvent)));
+          },
+          onPointerEnter(O) {
+            W.current = O.pointerType;
+          },
+          onPointerDown(O) {
+            (W.current = O.pointerType), (v.current = !0);
+          },
+          onMouseUp(O) {
+            if (l) return;
+            if (v.current) {
+              v.current = !1;
+              return;
+            }
+            const $ = !S.current.allowSelectedMouseUp && F,
+              se = !S.current.allowUnselectedMouseUp && !F;
+            $ || se || (W.current !== 'touch' && !U) || C(O.nativeEvent);
+          },
+        },
+        A = Ve('div', t, { ref: [J, n, i.ref, q], state: te, props: [Y, me, p, P] }),
+        ne = s.useMemo(
+          () => ({ selected: F, indexRef: E, textRef: x, selectedByFocus: Z, hasRegistered: z }),
+          [F, E, x, Z, z]
+        );
+      return H.jsx(kn.Provider, { value: ne, children: A });
+    })
+  ),
+  xo = s.forwardRef((t, n) => {
+    const r = t.keepMounted ?? !1,
+      { selected: u } = qt();
+    return r || u ? H.jsx(yo, { ...t, ref: n }) : null;
+  }),
+  yo = s.memo(
+    s.forwardRef((e, t) => {
+      const { render: n, className: r, keepMounted: u, ...o } = e,
+        { selected: d } = qt(),
+        l = s.useRef(null),
+        { transitionStatus: f, setMounted: p } = Bt(d),
+        i = Ve('span', e, {
+          ref: [t, l],
+          state: { selected: d, transitionStatus: f },
+          props: [{ 'aria-hidden': !0, children: '✔️' }, o],
+          stateAttributesMapping: xn,
+        });
+      return (
+        Mt({
+          open: d,
+          ref: l,
+          onComplete() {
+            d || p(!1);
+          },
+        }),
+        i
+      );
+    })
+  ),
+  Ro = s.memo(
+    s.forwardRef((t, n) => {
+      const { indexRef: r, textRef: u, selectedByFocus: o, hasRegistered: d } = qt(),
+        { selectedItemTextRef: l } = De(),
+        { className: f, render: p, ...x } = t,
+        i = s.useCallback(
+          (M) => {
+            if (!M || !d) return;
+            const I = l.current === null || !l.current.isConnected;
+            (o || (I && r.current === 0)) && (l.current = M);
+          },
+          [l, r, o, d]
+        );
+      return Ve('div', t, { ref: [i, n, u], props: x });
+    })
+  ),
+  Vn = s.forwardRef((t, n) => {
+    const { render: r, className: u, direction: o, keepMounted: d = !1, ...l } = t,
+      {
+        store: f,
+        popupRef: p,
+        listRef: x,
+        handleScrollArrowVisibility: i,
+        scrollArrowsMountedCountRef: b,
+      } = De(),
+      { side: M, scrollDownArrowRef: I, scrollUpArrowRef: R } = Wt(),
+      S = o === 'up' ? k.scrollUpArrowVisible : k.scrollDownArrowVisible,
+      a = L(f, S),
+      h = L(f, k.openMethod),
+      g = a && h !== 'touch',
+      c = je(),
+      m = o === 'up' ? R : I,
+      { transitionStatus: j, setMounted: U } = Bt(g);
+    ee(
+      () => (
+        (b.current += 1),
+        f.state.hasScrollArrows || f.set('hasScrollArrows', !0),
+        () => {
+          (b.current = Math.max(0, b.current - 1)),
+            b.current === 0 && f.state.hasScrollArrows && f.set('hasScrollArrows', !1);
+        }
+      ),
+      [f, b]
+    ),
+      Mt({
+        open: g,
+        ref: m,
+        onComplete() {
+          g || U(!1);
+        },
+      });
+    const ae = Ve('div', t, {
+      ref: [n, m],
+      state: { direction: o, visible: g, side: M, transitionStatus: j },
+      props: [
+        {
+          'aria-hidden': !0,
+          children: o === 'up' ? '▲' : '▼',
+          style: { position: 'absolute' },
+          onMouseMove(z) {
+            if ((z.movementX === 0 && z.movementY === 0) || c.isStarted()) return;
+            f.set('activeIndex', null);
+            function q() {
+              var W;
+              const E = f.state.listElement ?? p.current;
+              if (!E) return;
+              f.set('activeIndex', null), i();
+              const te = E.scrollTop === 0,
+                Y = Math.round(E.scrollTop + E.clientHeight) >= E.scrollHeight;
+              if (
+                (x.current.length === 0 &&
+                  (o === 'up'
+                    ? f.set('scrollUpArrowVisible', !te)
+                    : f.set('scrollDownArrowVisible', !Y)),
+                (o === 'up' && te) || (o === 'down' && Y))
+              ) {
+                c.clear();
+                return;
+              }
+              if ((f.state.listElement || p.current) && x.current && x.current.length > 0) {
+                const v = x.current,
+                  P = ((W = m.current) == null ? void 0 : W.offsetHeight) || 0;
+                if (o === 'up') {
+                  let J = 0;
+                  const C = E.scrollTop + P;
+                  for (let A = 0; A < v.length; A += 1) {
+                    const ne = v[A];
+                    if (ne && ne.offsetTop >= C) {
+                      J = A;
+                      break;
+                    }
+                  }
+                  const me = Math.max(0, J - 1);
+                  if (me < J) {
+                    const A = v[me];
+                    A && (E.scrollTop = Math.max(0, A.offsetTop - P));
+                  } else E.scrollTop = 0;
+                } else {
+                  let J = v.length - 1;
+                  const C = E.scrollTop + E.clientHeight - P;
+                  for (let A = 0; A < v.length; A += 1) {
+                    const ne = v[A];
+                    if (ne && ne.offsetTop + ne.offsetHeight > C) {
+                      J = Math.max(0, A - 1);
+                      break;
+                    }
+                  }
+                  const me = Math.min(v.length - 1, J + 1);
+                  if (me > J) {
+                    const A = v[me];
+                    A && (E.scrollTop = A.offsetTop + A.offsetHeight - E.clientHeight + P);
+                  } else E.scrollTop = E.scrollHeight - E.clientHeight;
+                }
+              }
+              c.start(40, q);
+            }
+            c.start(40, q);
+          },
+          onMouseLeave() {
+            c.clear();
+          },
+        },
+        l,
+      ],
+    });
+    return g || d ? ae : null;
+  }),
+  vo = s.forwardRef((t, n) => H.jsx(Vn, { ...t, ref: n, direction: 'down' })),
+  wo = s.forwardRef((t, n) => H.jsx(Vn, { ...t, ref: n, direction: 'up' })),
+  Fo = qr;
+function Ho({ className: e, ...t }) {
+  return H.jsx(Zr, {
+    'data-slot': 'select-value',
+    className: ke('flex flex-1 text-left', e),
+    ...t,
+  });
+}
+function jo({ className: e, size: t = 'default', children: n, ...r }) {
+  return H.jsxs(Xr, {
+    'data-slot': 'select-trigger',
+    'data-size': t,
+    className: ke(
+      "border-input data-placeholder:text-muted-foreground dark:bg-input/30 dark:hover:bg-input/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 gap-1.5 rounded-lg border bg-transparent py-2 pr-2 pl-2.5 text-sm transition-colors select-none focus-visible:ring-3 aria-invalid:ring-3 data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:gap-1.5 [&_svg:not([class*='size-'])]:size-4 flex w-fit items-center justify-between whitespace-nowrap outline-none disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center [&_svg]:pointer-events-none [&_svg]:shrink-0",
+      e
+    ),
+    ...r,
+    children: [
+      n,
+      H.jsx(Qr, {
+        render: H.jsx(wn, { className: 'text-muted-foreground size-4 pointer-events-none' }),
+      }),
+    ],
+  });
+}
+function Uo({
+  className: e,
+  children: t,
+  side: n = 'bottom',
+  sideOffset: r = 4,
+  align: u = 'center',
+  alignOffset: o = 0,
+  alignItemWithTrigger: d = !0,
+  ...l
+}) {
+  return H.jsx(to, {
+    children: H.jsx(ao, {
+      side: n,
+      sideOffset: r,
+      align: u,
+      alignOffset: o,
+      alignItemWithTrigger: d,
+      className: 'isolate z-50',
+      children: H.jsxs(po, {
+        'data-slot': 'select-content',
+        'data-align-trigger': d,
+        className: ke(
+          'bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 relative isolate z-50 max-h-(--available-height) w-(--anchor-width) origin-(--transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none',
+          e
+        ),
+        ...l,
+        children: [H.jsx(So, {}), H.jsx(mo, { children: t }), H.jsx(Mo, {})],
+      }),
+    }),
+  });
+}
+function zo({ className: e, children: t, ...n }) {
+  return H.jsxs(bo, {
+    'data-slot': 'select-item',
+    className: ke(
+      "focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2 relative flex w-full cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+      e
+    ),
+    ...n,
+    children: [
+      H.jsx(Ro, { className: 'flex flex-1 gap-2 shrink-0 whitespace-nowrap', children: t }),
+      H.jsx(xo, {
+        render: H.jsx('span', {
+          className: 'pointer-events-none absolute right-2 flex size-4 items-center justify-center',
+        }),
+        children: H.jsx(Mr, { className: 'pointer-events-none' }),
+      }),
+    ],
+  });
+}
+function So({ className: e, ...t }) {
+  return H.jsx(wo, {
+    'data-slot': 'select-scroll-up-button',
+    className: ke(
+      "bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*='size-'])]:size-4 top-0 w-full",
+      e
+    ),
+    ...t,
+    children: H.jsx(Er, {}),
+  });
+}
+function Mo({ className: e, ...t }) {
+  return H.jsx(vo, {
+    'data-slot': 'select-scroll-down-button',
+    className: ke(
+      "bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*='size-'])]:size-4 bottom-0 w-full",
+      e
+    ),
+    ...t,
+    children: H.jsx(wn, {}),
+  });
+}
+export {
+  No as C,
+  Oo as I,
+  Fo as S,
+  ko as a,
+  Vo as b,
+  Do as c,
+  jo as d,
+  Ho as e,
+  Uo as f,
+  zo as g,
+  ho as h,
+  uo as i,
+  ro as j,
+  Hr as k,
+  jr as l,
+  Yr as m,
+  Vr as n,
+  Lo as o,
+  Po as u,
+};
+//# sourceMappingURL=select-BNsiC9zT.js.map