zudoku 0.3.0-dev.3 → 0.3.0-dev.31

package/lib/Select-D-Jtx53Q.js

@@ -0,0 +1,4572 @@
+var sn = (e) => {
+  throw TypeError(e);
+};
+var cr = (e, r, t) => r.has(e) || sn("Cannot " + t);
+var te = (e, r, t) => (cr(e, r, "read from private field"), t ? t.call(e) : r.get(e)), it = (e, r, t) => r.has(e) ? sn("Cannot add the same private member more than once") : r instanceof WeakSet ? r.add(e) : r.set(e, t), at = (e, r, t, n) => (cr(e, r, "write to private field"), n ? n.call(e, t) : r.set(e, t), t), ct = (e, r, t) => (cr(e, r, "access private method"), t);
+import * as h from "react";
+import j, { useLayoutEffect as Rs, useEffect as Ps, useState as Ts } from "react";
+import { h as Os, S as Ht, c as Br, u as le, b as Je, P as oe, d as ce, i as Fs, g as be, e as Wr, a as an } from "./index-BaOOUFsA.js";
+import { S as Ns, w as Ds, i as cn, n as Ln, q as Ms, x as ks, y as Is } from "./DevPortalProvider-BMk-RCE0.js";
+import { j as P } from "./jsx-runtime-SV6hXQua.js";
+import { c as ke } from "./cn-DpqTslo9.js";
+import { c as jn, b as Vs, C as Ls } from "./index-CPvRaBBB.js";
+import * as Hr from "react-dom";
+import js from "react-dom";
+/**
+ * @license lucide-react v0.378.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Bn = jn("ChevronDown", [
+  ["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]
+]);
+/**
+ * @license lucide-react v0.378.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Bs = jn("ChevronUp", [["path", { d: "m18 15-6-6-6 6", key: "153udz" }]]);
+var Ue, $e, fe, De, Me, Vt, Pr, Vn, Ws = (Vn = class extends Ns {
+  constructor(t, n) {
+    super();
+    it(this, Me);
+    it(this, Ue);
+    it(this, $e);
+    it(this, fe);
+    it(this, De);
+    at(this, Ue, t), this.setOptions(n), this.bindMethods(), ct(this, Me, Vt).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(t) {
+    var o;
+    const n = this.options;
+    this.options = te(this, Ue).defaultMutationOptions(t), Ds(this.options, n) || te(this, Ue).getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: te(this, fe),
+      observer: this
+    }), n != null && n.mutationKey && this.options.mutationKey && cn(n.mutationKey) !== cn(this.options.mutationKey) ? this.reset() : ((o = te(this, fe)) == null ? void 0 : o.state.status) === "pending" && te(this, fe).setOptions(this.options);
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || (t = te(this, fe)) == null || t.removeObserver(this);
+  }
+  onMutationUpdate(t) {
+    ct(this, Me, Vt).call(this), ct(this, Me, Pr).call(this, t);
+  }
+  getCurrentResult() {
+    return te(this, $e);
+  }
+  reset() {
+    var t;
+    (t = te(this, fe)) == null || t.removeObserver(this), at(this, fe, void 0), ct(this, Me, Vt).call(this), ct(this, Me, Pr).call(this);
+  }
+  mutate(t, n) {
+    var o;
+    return at(this, De, n), (o = te(this, fe)) == null || o.removeObserver(this), at(this, fe, te(this, Ue).getMutationCache().build(te(this, Ue), this.options)), te(this, fe).addObserver(this), te(this, fe).execute(t);
+  }
+}, Ue = new WeakMap(), $e = new WeakMap(), fe = new WeakMap(), De = new WeakMap(), Me = new WeakSet(), Vt = function() {
+  var n;
+  const t = ((n = te(this, fe)) == null ? void 0 : n.state) ?? Os();
+  at(this, $e, {
+    ...t,
+    isPending: t.status === "pending",
+    isSuccess: t.status === "success",
+    isError: t.status === "error",
+    isIdle: t.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, Pr = function(t) {
+  Ln.batch(() => {
+    var n, o, s, i, a, c, u, f;
+    if (te(this, De) && this.hasListeners()) {
+      const d = te(this, $e).variables, g = te(this, $e).context;
+      (t == null ? void 0 : t.type) === "success" ? ((o = (n = te(this, De)).onSuccess) == null || o.call(n, t.data, d, g), (i = (s = te(this, De)).onSettled) == null || i.call(s, t.data, null, d, g)) : (t == null ? void 0 : t.type) === "error" && ((c = (a = te(this, De)).onError) == null || c.call(a, t.error, d, g), (f = (u = te(this, De)).onSettled) == null || f.call(
+        u,
+        void 0,
+        t.error,
+        d,
+        g
+      ));
+    }
+    this.listeners.forEach((d) => {
+      d(te(this, $e));
+    });
+  });
+}, Vn);
+function ol(e, r) {
+  const t = Ms(), [n] = h.useState(
+    () => new Ws(
+      t,
+      e
+    )
+  );
+  h.useEffect(() => {
+    n.setOptions(e);
+  }, [n, e]);
+  const o = h.useSyncExternalStore(
+    h.useCallback(
+      (i) => n.subscribe(Ln.batchCalls(i)),
+      [n]
+    ),
+    () => n.getCurrentResult(),
+    () => n.getCurrentResult()
+  ), s = h.useCallback(
+    (i, a) => {
+      n.mutate(i, a).catch(ks);
+    },
+    [n]
+  );
+  if (o.error && Is(n.options.throwOnError, [o.error]))
+    throw o.error;
+  return { ...o, mutate: s, mutateAsync: o.mutate };
+}
+const Hs = Vs(
+  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground shadow hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
+        outline: "border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-9 px-4 py-2",
+        sm: "h-8 rounded-md px-3 text-xs",
+        lg: "h-10 rounded-md px-8",
+        icon: "h-9 w-9"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+), Us = h.forwardRef(
+  ({ className: e, variant: r, size: t, asChild: n = !1, ...o }, s) => {
+    const i = n ? Ht : "button";
+    return /* @__PURE__ */ P.jsx(
+      i,
+      {
+        className: ke(Hs({ variant: r, size: t, className: e })),
+        ref: s,
+        ...o
+      }
+    );
+  }
+);
+Us.displayName = "Button";
+var Rt = (e) => e.type === "checkbox", ht = (e) => e instanceof Date, de = (e) => e == null;
+const Wn = (e) => typeof e == "object";
+var ae = (e) => !de(e) && !Array.isArray(e) && Wn(e) && !ht(e), Hn = (e) => ae(e) && e.target ? Rt(e.target) ? e.target.checked : e.target.value : e, $s = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, Un = (e, r) => e.has($s(r)), zs = (e) => {
+  const r = e.constructor && e.constructor.prototype;
+  return ae(r) && r.hasOwnProperty("isPrototypeOf");
+}, Ur = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function ie(e) {
+  let r;
+  const t = Array.isArray(e);
+  if (e instanceof Date)
+    r = new Date(e);
+  else if (e instanceof Set)
+    r = new Set(e);
+  else if (!(Ur && (e instanceof Blob || e instanceof FileList)) && (t || ae(e)))
+    if (r = t ? [] : {}, !t && !zs(e))
+      r = e;
+    else
+      for (const n in e)
+        e.hasOwnProperty(n) && (r[n] = ie(e[n]));
+  else
+    return e;
+  return r;
+}
+var Pt = (e) => Array.isArray(e) ? e.filter(Boolean) : [], Q = (e) => e === void 0, O = (e, r, t) => {
+  if (!r || !ae(e))
+    return t;
+  const n = Pt(r.split(/[,[\].]+?/)).reduce((o, s) => de(o) ? o : o[s], e);
+  return Q(n) || n === e ? Q(e[r]) ? t : e[r] : n;
+}, _e = (e) => typeof e == "boolean", $r = (e) => /^\w*$/.test(e), $n = (e) => Pt(e.replace(/["|']|\]/g, "").split(/\.|\[/)), G = (e, r, t) => {
+  let n = -1;
+  const o = $r(r) ? [r] : $n(r), s = o.length, i = s - 1;
+  for (; ++n < s; ) {
+    const a = o[n];
+    let c = t;
+    if (n !== i) {
+      const u = e[a];
+      c = ae(u) || Array.isArray(u) ? u : isNaN(+o[n + 1]) ? {} : [];
+    }
+    if (a === "__proto__")
+      return;
+    e[a] = c, e = e[a];
+  }
+  return e;
+};
+const Ut = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, xe = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, Fe = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+}, zn = j.createContext(null), Jt = () => j.useContext(zn), sl = (e) => {
+  const { children: r, ...t } = e;
+  return j.createElement(zn.Provider, { value: t }, r);
+};
+var Kn = (e, r, t, n = !0) => {
+  const o = {
+    defaultValues: r._defaultValues
+  };
+  for (const s in e)
+    Object.defineProperty(o, s, {
+      get: () => {
+        const i = s;
+        return r._proxyFormState[i] !== xe.all && (r._proxyFormState[i] = !n || xe.all), t && (t[i] = !0), e[i];
+      }
+    });
+  return o;
+}, he = (e) => ae(e) && !Object.keys(e).length, Yn = (e, r, t, n) => {
+  t(e);
+  const { name: o, ...s } = e;
+  return he(s) || Object.keys(s).length >= Object.keys(r).length || Object.keys(s).find((i) => r[i] === (!n || xe.all));
+}, pe = (e) => Array.isArray(e) ? e : [e], qn = (e, r, t) => !e || !r || e === r || pe(e).some((n) => n && (t ? n === r : n.startsWith(r) || r.startsWith(n)));
+function er(e) {
+  const r = j.useRef(e);
+  r.current = e, j.useEffect(() => {
+    const t = !e.disabled && r.current.subject && r.current.subject.subscribe({
+      next: r.current.next
+    });
+    return () => {
+      t && t.unsubscribe();
+    };
+  }, [e.disabled]);
+}
+function Ks(e) {
+  const r = Jt(), { control: t = r.control, disabled: n, name: o, exact: s } = e || {}, [i, a] = j.useState(t._formState), c = j.useRef(!0), u = j.useRef({
+    isDirty: !1,
+    isLoading: !1,
+    dirtyFields: !1,
+    touchedFields: !1,
+    validatingFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }), f = j.useRef(o);
+  return f.current = o, er({
+    disabled: n,
+    next: (d) => c.current && qn(f.current, d.name, s) && Yn(d, u.current, t._updateFormState) && a({
+      ...t._formState,
+      ...d
+    }),
+    subject: t._subjects.state
+  }), j.useEffect(() => (c.current = !0, u.current.isValid && t._updateValid(!0), () => {
+    c.current = !1;
+  }), [t]), Kn(i, t, u.current, !1);
+}
+var Pe = (e) => typeof e == "string", Xn = (e, r, t, n, o) => Pe(e) ? (n && r.watch.add(e), O(t, e, o)) : Array.isArray(e) ? e.map((s) => (n && r.watch.add(s), O(t, s))) : (n && (r.watchAll = !0), t);
+function Ys(e) {
+  const r = Jt(), { control: t = r.control, name: n, defaultValue: o, disabled: s, exact: i } = e || {}, a = j.useRef(n);
+  a.current = n, er({
+    disabled: s,
+    subject: t._subjects.values,
+    next: (f) => {
+      qn(a.current, f.name, i) && u(ie(Xn(a.current, t._names, f.values || t._formValues, !1, o)));
+    }
+  });
+  const [c, u] = j.useState(t._getWatch(n, o));
+  return j.useEffect(() => t._removeUnmounted()), c;
+}
+function qs(e) {
+  const r = Jt(), { name: t, disabled: n, control: o = r.control, shouldUnregister: s } = e, i = Un(o._names.array, t), a = Ys({
+    control: o,
+    name: t,
+    defaultValue: O(o._formValues, t, O(o._defaultValues, t, e.defaultValue)),
+    exact: !0
+  }), c = Ks({
+    control: o,
+    name: t
+  }), u = j.useRef(o.register(t, {
+    ...e.rules,
+    value: a,
+    ..._e(e.disabled) ? { disabled: e.disabled } : {}
+  }));
+  return j.useEffect(() => {
+    const f = o._options.shouldUnregister || s, d = (g, x) => {
+      const y = O(o._fields, g);
+      y && y._f && (y._f.mount = x);
+    };
+    if (d(t, !0), f) {
+      const g = ie(O(o._options.defaultValues, t));
+      G(o._defaultValues, t, g), Q(O(o._formValues, t)) && G(o._formValues, t, g);
+    }
+    return () => {
+      (i ? f && !o._state.action : f) ? o.unregister(t) : d(t, !1);
+    };
+  }, [t, o, i, s]), j.useEffect(() => {
+    O(o._fields, t) && o._updateDisabledField({
+      disabled: n,
+      fields: o._fields,
+      name: t,
+      value: O(o._fields, t)._f.value
+    });
+  }, [n, t, o]), {
+    field: {
+      name: t,
+      value: a,
+      ..._e(n) || c.disabled ? { disabled: c.disabled || n } : {},
+      onChange: j.useCallback((f) => u.current.onChange({
+        target: {
+          value: Hn(f),
+          name: t
+        },
+        type: Ut.CHANGE
+      }), [t]),
+      onBlur: j.useCallback(() => u.current.onBlur({
+        target: {
+          value: O(o._formValues, t),
+          name: t
+        },
+        type: Ut.BLUR
+      }), [t, o]),
+      ref: (f) => {
+        const d = O(o._fields, t);
+        d && f && (d._f.ref = {
+          focus: () => f.focus(),
+          select: () => f.select(),
+          setCustomValidity: (g) => f.setCustomValidity(g),
+          reportValidity: () => f.reportValidity()
+        });
+      }
+    },
+    formState: c,
+    fieldState: Object.defineProperties({}, {
+      invalid: {
+        enumerable: !0,
+        get: () => !!O(c.errors, t)
+      },
+      isDirty: {
+        enumerable: !0,
+        get: () => !!O(c.dirtyFields, t)
+      },
+      isTouched: {
+        enumerable: !0,
+        get: () => !!O(c.touchedFields, t)
+      },
+      isValidating: {
+        enumerable: !0,
+        get: () => !!O(c.validatingFields, t)
+      },
+      error: {
+        enumerable: !0,
+        get: () => O(c.errors, t)
+      }
+    })
+  };
+}
+const il = (e) => e.render(qs(e));
+var Xs = (e, r, t, n, o) => r ? {
+  ...t[e],
+  types: {
+    ...t[e] && t[e].types ? t[e].types : {},
+    [n]: o || !0
+  }
+} : {}, We = () => {
+  const e = typeof performance > "u" ? Date.now() : performance.now() * 1e3;
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (r) => {
+    const t = (Math.random() * 16 + e) % 16 | 0;
+    return (r == "x" ? t : t & 3 | 8).toString(16);
+  });
+}, lr = (e, r, t = {}) => t.shouldFocus || Q(t.shouldFocus) ? t.focusName || `${e}.${Q(t.focusIndex) ? r : t.focusIndex}.` : "", Ct = (e) => ({
+  isOnSubmit: !e || e === xe.onSubmit,
+  isOnBlur: e === xe.onBlur,
+  isOnChange: e === xe.onChange,
+  isOnAll: e === xe.all,
+  isOnTouch: e === xe.onTouched
+}), Tr = (e, r, t) => !t && (r.watchAll || r.watch.has(e) || [...r.watch].some((n) => e.startsWith(n) && /^\.\w+/.test(e.slice(n.length))));
+const pt = (e, r, t, n) => {
+  for (const o of t || Object.keys(e)) {
+    const s = O(e, o);
+    if (s) {
+      const { _f: i, ...a } = s;
+      if (i) {
+        if (i.refs && i.refs[0] && r(i.refs[0], o) && !n)
+          break;
+        if (i.ref && r(i.ref, i.name) && !n)
+          break;
+        pt(a, r);
+      } else ae(a) && pt(a, r);
+    }
+  }
+};
+var Gn = (e, r, t) => {
+  const n = pe(O(e, t));
+  return G(n, "root", r[t]), G(e, t, n), e;
+}, zr = (e) => e.type === "file", ze = (e) => typeof e == "function", $t = (e) => {
+  if (!Ur)
+    return !1;
+  const r = e ? e.ownerDocument : 0;
+  return e instanceof (r && r.defaultView ? r.defaultView.HTMLElement : HTMLElement);
+}, Lt = (e) => Pe(e), Kr = (e) => e.type === "radio", zt = (e) => e instanceof RegExp;
+const ln = {
+  value: !1,
+  isValid: !1
+}, un = { value: !0, isValid: !0 };
+var Zn = (e) => {
+  if (Array.isArray(e)) {
+    if (e.length > 1) {
+      const r = e.filter((t) => t && t.checked && !t.disabled).map((t) => t.value);
+      return { value: r, isValid: !!r.length };
+    }
+    return e[0].checked && !e[0].disabled ? (
+      // @ts-expect-error expected to work in the browser
+      e[0].attributes && !Q(e[0].attributes.value) ? Q(e[0].value) || e[0].value === "" ? un : { value: e[0].value, isValid: !0 } : un
+    ) : ln;
+  }
+  return ln;
+};
+const dn = {
+  isValid: !1,
+  value: null
+};
+var Qn = (e) => Array.isArray(e) ? e.reduce((r, t) => t && t.checked && !t.disabled ? {
+  isValid: !0,
+  value: t.value
+} : r, dn) : dn;
+function fn(e, r, t = "validate") {
+  if (Lt(e) || Array.isArray(e) && e.every(Lt) || _e(e) && !e)
+    return {
+      type: t,
+      message: Lt(e) ? e : "",
+      ref: r
+    };
+}
+var lt = (e) => ae(e) && !zt(e) ? e : {
+  value: e,
+  message: ""
+}, Or = async (e, r, t, n, o) => {
+  const { ref: s, refs: i, required: a, maxLength: c, minLength: u, min: f, max: d, pattern: g, validate: x, name: y, valueAsNumber: p, mount: S, disabled: b } = e._f, v = O(r, y);
+  if (!S || b)
+    return {};
+  const C = i ? i[0] : s, R = (D) => {
+    n && C.reportValidity && (C.setCustomValidity(_e(D) ? "" : D || ""), C.reportValidity());
+  }, w = {}, A = Kr(s), _ = Rt(s), M = A || _, H = (p || zr(s)) && Q(s.value) && Q(v) || $t(s) && s.value === "" || v === "" || Array.isArray(v) && !v.length, U = Xs.bind(null, y, t, w), J = (D, I, B, V = Fe.maxLength, $ = Fe.minLength) => {
+    const L = D ? I : B;
+    w[y] = {
+      type: D ? V : $,
+      message: L,
+      ref: s,
+      ...U(D ? V : $, L)
+    };
+  };
+  if (o ? !Array.isArray(v) || !v.length : a && (!M && (H || de(v)) || _e(v) && !v || _ && !Zn(i).isValid || A && !Qn(i).isValid)) {
+    const { value: D, message: I } = Lt(a) ? { value: !!a, message: a } : lt(a);
+    if (D && (w[y] = {
+      type: Fe.required,
+      message: I,
+      ref: C,
+      ...U(Fe.required, I)
+    }, !t))
+      return R(I), w;
+  }
+  if (!H && (!de(f) || !de(d))) {
+    let D, I;
+    const B = lt(d), V = lt(f);
+    if (!de(v) && !isNaN(v)) {
+      const $ = s.valueAsNumber || v && +v;
+      de(B.value) || (D = $ > B.value), de(V.value) || (I = $ < V.value);
+    } else {
+      const $ = s.valueAsDate || new Date(v), L = (Se) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + Se), Z = s.type == "time", ee = s.type == "week";
+      Pe(B.value) && v && (D = Z ? L(v) > L(B.value) : ee ? v > B.value : $ > new Date(B.value)), Pe(V.value) && v && (I = Z ? L(v) < L(V.value) : ee ? v < V.value : $ < new Date(V.value));
+    }
+    if ((D || I) && (J(!!D, B.message, V.message, Fe.max, Fe.min), !t))
+      return R(w[y].message), w;
+  }
+  if ((c || u) && !H && (Pe(v) || o && Array.isArray(v))) {
+    const D = lt(c), I = lt(u), B = !de(D.value) && v.length > +D.value, V = !de(I.value) && v.length < +I.value;
+    if ((B || V) && (J(B, D.message, I.message), !t))
+      return R(w[y].message), w;
+  }
+  if (g && !H && Pe(v)) {
+    const { value: D, message: I } = lt(g);
+    if (zt(D) && !v.match(D) && (w[y] = {
+      type: Fe.pattern,
+      message: I,
+      ref: s,
+      ...U(Fe.pattern, I)
+    }, !t))
+      return R(I), w;
+  }
+  if (x) {
+    if (ze(x)) {
+      const D = await x(v, r), I = fn(D, C);
+      if (I && (w[y] = {
+        ...I,
+        ...U(Fe.validate, I.message)
+      }, !t))
+        return R(I.message), w;
+    } else if (ae(x)) {
+      let D = {};
+      for (const I in x) {
+        if (!he(D) && !t)
+          break;
+        const B = fn(await x[I](v, r), C, I);
+        B && (D = {
+          ...B,
+          ...U(I, B.message)
+        }, R(B.message), t && (w[y] = D));
+      }
+      if (!he(D) && (w[y] = {
+        ref: C,
+        ...D
+      }, !t))
+        return w;
+    }
+  }
+  return R(!0), w;
+}, ur = (e, r) => [
+  ...e,
+  ...pe(r)
+], dr = (e) => Array.isArray(e) ? e.map(() => {
+}) : void 0;
+function fr(e, r, t) {
+  return [
+    ...e.slice(0, r),
+    ...pe(t),
+    ...e.slice(r)
+  ];
+}
+var hr = (e, r, t) => Array.isArray(e) ? (Q(e[t]) && (e[t] = void 0), e.splice(t, 0, e.splice(r, 1)[0]), e) : [], pr = (e, r) => [
+  ...pe(r),
+  ...pe(e)
+];
+function Gs(e, r) {
+  let t = 0;
+  const n = [...e];
+  for (const o of r)
+    n.splice(o - t, 1), t++;
+  return Pt(n).length ? n : [];
+}
+var mr = (e, r) => Q(r) ? [] : Gs(e, pe(r).sort((t, n) => t - n)), vr = (e, r, t) => {
+  [e[r], e[t]] = [e[t], e[r]];
+};
+function Zs(e, r) {
+  const t = r.slice(0, -1).length;
+  let n = 0;
+  for (; n < t; )
+    e = Q(e) ? n++ : e[r[n++]];
+  return e;
+}
+function Qs(e) {
+  for (const r in e)
+    if (e.hasOwnProperty(r) && !Q(e[r]))
+      return !1;
+  return !0;
+}
+function ne(e, r) {
+  const t = Array.isArray(r) ? r : $r(r) ? [r] : $n(r), n = t.length === 1 ? e : Zs(e, t), o = t.length - 1, s = t[o];
+  return n && delete n[s], o !== 0 && (ae(n) && he(n) || Array.isArray(n) && Qs(n)) && ne(e, t.slice(0, -1)), e;
+}
+var hn = (e, r, t) => (e[r] = t, e);
+function al(e) {
+  const r = Jt(), { control: t = r.control, name: n, keyName: o = "id", shouldUnregister: s } = e, [i, a] = j.useState(t._getFieldArray(n)), c = j.useRef(t._getFieldArray(n).map(We)), u = j.useRef(i), f = j.useRef(n), d = j.useRef(!1);
+  f.current = n, u.current = i, t._names.array.add(n), e.rules && t.register(n, e.rules), er({
+    next: ({ values: w, name: A }) => {
+      if (A === f.current || !A) {
+        const _ = O(w, f.current);
+        Array.isArray(_) && (a(_), c.current = _.map(We));
+      }
+    },
+    subject: t._subjects.array
+  });
+  const g = j.useCallback((w) => {
+    d.current = !0, t._updateFieldArray(n, w);
+  }, [t, n]), x = (w, A) => {
+    const _ = pe(ie(w)), M = ur(t._getFieldArray(n), _);
+    t._names.focus = lr(n, M.length - 1, A), c.current = ur(c.current, _.map(We)), g(M), a(M), t._updateFieldArray(n, M, ur, {
+      argA: dr(w)
+    });
+  }, y = (w, A) => {
+    const _ = pe(ie(w)), M = pr(t._getFieldArray(n), _);
+    t._names.focus = lr(n, 0, A), c.current = pr(c.current, _.map(We)), g(M), a(M), t._updateFieldArray(n, M, pr, {
+      argA: dr(w)
+    });
+  }, p = (w) => {
+    const A = mr(t._getFieldArray(n), w);
+    c.current = mr(c.current, w), g(A), a(A), t._updateFieldArray(n, A, mr, {
+      argA: w
+    });
+  }, S = (w, A, _) => {
+    const M = pe(ie(A)), H = fr(t._getFieldArray(n), w, M);
+    t._names.focus = lr(n, w, _), c.current = fr(c.current, w, M.map(We)), g(H), a(H), t._updateFieldArray(n, H, fr, {
+      argA: w,
+      argB: dr(A)
+    });
+  }, b = (w, A) => {
+    const _ = t._getFieldArray(n);
+    vr(_, w, A), vr(c.current, w, A), g(_), a(_), t._updateFieldArray(n, _, vr, {
+      argA: w,
+      argB: A
+    }, !1);
+  }, v = (w, A) => {
+    const _ = t._getFieldArray(n);
+    hr(_, w, A), hr(c.current, w, A), g(_), a(_), t._updateFieldArray(n, _, hr, {
+      argA: w,
+      argB: A
+    }, !1);
+  }, C = (w, A) => {
+    const _ = ie(A), M = hn(t._getFieldArray(n), w, _);
+    c.current = [...M].map((H, U) => !H || U === w ? We() : c.current[U]), g(M), a([...M]), t._updateFieldArray(n, M, hn, {
+      argA: w,
+      argB: _
+    }, !0, !1);
+  }, R = (w) => {
+    const A = pe(ie(w));
+    c.current = A.map(We), g([...A]), a([...A]), t._updateFieldArray(n, [...A], (_) => _, {}, !0, !1);
+  };
+  return j.useEffect(() => {
+    if (t._state.action = !1, Tr(n, t._names) && t._subjects.state.next({
+      ...t._formState
+    }), d.current && (!Ct(t._options.mode).isOnSubmit || t._formState.isSubmitted))
+      if (t._options.resolver)
+        t._executeSchema([n]).then((w) => {
+          const A = O(w.errors, n), _ = O(t._formState.errors, n);
+          (_ ? !A && _.type || A && (_.type !== A.type || _.message !== A.message) : A && A.type) && (A ? G(t._formState.errors, n, A) : ne(t._formState.errors, n), t._subjects.state.next({
+            errors: t._formState.errors
+          }));
+        });
+      else {
+        const w = O(t._fields, n);
+        w && w._f && !(Ct(t._options.reValidateMode).isOnSubmit && Ct(t._options.mode).isOnSubmit) && Or(w, t._formValues, t._options.criteriaMode === xe.all, t._options.shouldUseNativeValidation, !0).then((A) => !he(A) && t._subjects.state.next({
+          errors: Gn(t._formState.errors, A, n)
+        }));
+      }
+    t._subjects.values.next({
+      name: n,
+      values: { ...t._formValues }
+    }), t._names.focus && pt(t._fields, (w, A) => {
+      if (t._names.focus && A.startsWith(t._names.focus) && w.focus)
+        return w.focus(), 1;
+    }), t._names.focus = "", t._updateValid(), d.current = !1;
+  }, [i, n, t]), j.useEffect(() => (!O(t._formValues, n) && t._updateFieldArray(n), () => {
+    (t._options.shouldUnregister || s) && t.unregister(n);
+  }), [n, t, o, s]), {
+    swap: j.useCallback(b, [g, n, t]),
+    move: j.useCallback(v, [g, n, t]),
+    prepend: j.useCallback(y, [g, n, t]),
+    append: j.useCallback(x, [g, n, t]),
+    remove: j.useCallback(p, [g, n, t]),
+    insert: j.useCallback(S, [g, n, t]),
+    update: j.useCallback(C, [g, n, t]),
+    replace: j.useCallback(R, [g, n, t]),
+    fields: j.useMemo(() => i.map((w, A) => ({
+      ...w,
+      [o]: c.current[A] || We()
+    })), [i, o])
+  };
+}
+var gr = () => {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (o) => {
+      for (const s of e)
+        s.next && s.next(o);
+    },
+    subscribe: (o) => (e.push(o), {
+      unsubscribe: () => {
+        e = e.filter((s) => s !== o);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+}, Kt = (e) => de(e) || !Wn(e);
+function Qe(e, r) {
+  if (Kt(e) || Kt(r))
+    return e === r;
+  if (ht(e) && ht(r))
+    return e.getTime() === r.getTime();
+  const t = Object.keys(e), n = Object.keys(r);
+  if (t.length !== n.length)
+    return !1;
+  for (const o of t) {
+    const s = e[o];
+    if (!n.includes(o))
+      return !1;
+    if (o !== "ref") {
+      const i = r[o];
+      if (ht(s) && ht(i) || ae(s) && ae(i) || Array.isArray(s) && Array.isArray(i) ? !Qe(s, i) : s !== i)
+        return !1;
+    }
+  }
+  return !0;
+}
+var Jn = (e) => e.type === "select-multiple", Js = (e) => Kr(e) || Rt(e), yr = (e) => $t(e) && e.isConnected, eo = (e) => {
+  for (const r in e)
+    if (ze(e[r]))
+      return !0;
+  return !1;
+};
+function Yt(e, r = {}) {
+  const t = Array.isArray(e);
+  if (ae(e) || t)
+    for (const n in e)
+      Array.isArray(e[n]) || ae(e[n]) && !eo(e[n]) ? (r[n] = Array.isArray(e[n]) ? [] : {}, Yt(e[n], r[n])) : de(e[n]) || (r[n] = !0);
+  return r;
+}
+function to(e, r, t) {
+  const n = Array.isArray(e);
+  if (ae(e) || n)
+    for (const o in e)
+      Array.isArray(e[o]) || ae(e[o]) && !eo(e[o]) ? Q(r) || Kt(t[o]) ? t[o] = Array.isArray(e[o]) ? Yt(e[o], []) : { ...Yt(e[o]) } : to(e[o], de(r) ? {} : r[o], t[o]) : t[o] = !Qe(e[o], r[o]);
+  return t;
+}
+var Ft = (e, r) => to(e, r, Yt(r)), ro = (e, { valueAsNumber: r, valueAsDate: t, setValueAs: n }) => Q(e) ? e : r ? e === "" ? NaN : e && +e : t && Pe(e) ? new Date(e) : n ? n(e) : e;
+function wr(e) {
+  const r = e.ref;
+  if (!(e.refs ? e.refs.every((t) => t.disabled) : r.disabled))
+    return zr(r) ? r.files : Kr(r) ? Qn(e.refs).value : Jn(r) ? [...r.selectedOptions].map(({ value: t }) => t) : Rt(r) ? Zn(e.refs).value : ro(Q(r.value) ? e.ref.value : r.value, e);
+}
+var ei = (e, r, t, n) => {
+  const o = {};
+  for (const s of e) {
+    const i = O(r, s);
+    i && G(o, s, i._f);
+  }
+  return {
+    criteriaMode: t,
+    names: [...e],
+    fields: o,
+    shouldUseNativeValidation: n
+  };
+}, St = (e) => Q(e) ? e : zt(e) ? e.source : ae(e) ? zt(e.value) ? e.value.source : e.value : e, ti = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate);
+function pn(e, r, t) {
+  const n = O(e, t);
+  if (n || $r(t))
+    return {
+      error: n,
+      name: t
+    };
+  const o = t.split(".");
+  for (; o.length; ) {
+    const s = o.join("."), i = O(r, s), a = O(e, s);
+    if (i && !Array.isArray(i) && t !== s)
+      return { name: t };
+    if (a && a.type)
+      return {
+        name: s,
+        error: a
+      };
+    o.pop();
+  }
+  return {
+    name: t
+  };
+}
+var ri = (e, r, t, n, o) => o.isOnAll ? !1 : !t && o.isOnTouch ? !(r || e) : (t ? n.isOnBlur : o.isOnBlur) ? !e : (t ? n.isOnChange : o.isOnChange) ? e : !0, ni = (e, r) => !Pt(O(e, r)).length && ne(e, r);
+const oi = {
+  mode: xe.onSubmit,
+  reValidateMode: xe.onChange,
+  shouldFocusError: !0
+};
+function si(e = {}) {
+  let r = {
+    ...oi,
+    ...e
+  }, t = {
+    submitCount: 0,
+    isDirty: !1,
+    isLoading: ze(r.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: r.errors || {},
+    disabled: r.disabled || !1
+  }, n = {}, o = ae(r.defaultValues) || ae(r.values) ? ie(r.defaultValues || r.values) || {} : {}, s = r.shouldUnregister ? {} : ie(o), i = {
+    action: !1,
+    mount: !1,
+    watch: !1
+  }, a = {
+    mount: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, c, u = 0;
+  const f = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }, d = {
+    values: gr(),
+    array: gr(),
+    state: gr()
+  }, g = Ct(r.mode), x = Ct(r.reValidateMode), y = r.criteriaMode === xe.all, p = (l) => (m) => {
+    clearTimeout(u), u = setTimeout(l, m);
+  }, S = async (l) => {
+    if (f.isValid || l) {
+      const m = r.resolver ? he((await M()).errors) : await U(n, !0);
+      m !== t.isValid && d.state.next({
+        isValid: m
+      });
+    }
+  }, b = (l, m) => {
+    (f.isValidating || f.validatingFields) && ((l || Array.from(a.mount)).forEach((E) => {
+      E && (m ? G(t.validatingFields, E, m) : ne(t.validatingFields, E));
+    }), d.state.next({
+      validatingFields: t.validatingFields,
+      isValidating: !he(t.validatingFields)
+    }));
+  }, v = (l, m = [], E, N, F = !0, T = !0) => {
+    if (N && E) {
+      if (i.action = !0, T && Array.isArray(O(n, l))) {
+        const k = E(O(n, l), N.argA, N.argB);
+        F && G(n, l, k);
+      }
+      if (T && Array.isArray(O(t.errors, l))) {
+        const k = E(O(t.errors, l), N.argA, N.argB);
+        F && G(t.errors, l, k), ni(t.errors, l);
+      }
+      if (f.touchedFields && T && Array.isArray(O(t.touchedFields, l))) {
+        const k = E(O(t.touchedFields, l), N.argA, N.argB);
+        F && G(t.touchedFields, l, k);
+      }
+      f.dirtyFields && (t.dirtyFields = Ft(o, s)), d.state.next({
+        name: l,
+        isDirty: D(l, m),
+        dirtyFields: t.dirtyFields,
+        errors: t.errors,
+        isValid: t.isValid
+      });
+    } else
+      G(s, l, m);
+  }, C = (l, m) => {
+    G(t.errors, l, m), d.state.next({
+      errors: t.errors
+    });
+  }, R = (l) => {
+    t.errors = l, d.state.next({
+      errors: t.errors,
+      isValid: !1
+    });
+  }, w = (l, m, E, N) => {
+    const F = O(n, l);
+    if (F) {
+      const T = O(s, l, Q(E) ? O(o, l) : E);
+      Q(T) || N && N.defaultChecked || m ? G(s, l, m ? T : wr(F._f)) : V(l, T), i.mount && S();
+    }
+  }, A = (l, m, E, N, F) => {
+    let T = !1, k = !1;
+    const Y = {
+      name: l
+    }, re = !!(O(n, l) && O(n, l)._f && O(n, l)._f.disabled);
+    if (!E || N) {
+      f.isDirty && (k = t.isDirty, t.isDirty = Y.isDirty = D(), T = k !== Y.isDirty);
+      const ve = re || Qe(O(o, l), m);
+      k = !!(!re && O(t.dirtyFields, l)), ve || re ? ne(t.dirtyFields, l) : G(t.dirtyFields, l, !0), Y.dirtyFields = t.dirtyFields, T = T || f.dirtyFields && k !== !ve;
+    }
+    if (E) {
+      const ve = O(t.touchedFields, l);
+      ve || (G(t.touchedFields, l, E), Y.touchedFields = t.touchedFields, T = T || f.touchedFields && ve !== E);
+    }
+    return T && F && d.state.next(Y), T ? Y : {};
+  }, _ = (l, m, E, N) => {
+    const F = O(t.errors, l), T = f.isValid && _e(m) && t.isValid !== m;
+    if (e.delayError && E ? (c = p(() => C(l, E)), c(e.delayError)) : (clearTimeout(u), c = null, E ? G(t.errors, l, E) : ne(t.errors, l)), (E ? !Qe(F, E) : F) || !he(N) || T) {
+      const k = {
+        ...N,
+        ...T && _e(m) ? { isValid: m } : {},
+        errors: t.errors,
+        name: l
+      };
+      t = {
+        ...t,
+        ...k
+      }, d.state.next(k);
+    }
+  }, M = async (l) => {
+    b(l, !0);
+    const m = await r.resolver(s, r.context, ei(l || a.mount, n, r.criteriaMode, r.shouldUseNativeValidation));
+    return b(l), m;
+  }, H = async (l) => {
+    const { errors: m } = await M(l);
+    if (l)
+      for (const E of l) {
+        const N = O(m, E);
+        N ? G(t.errors, E, N) : ne(t.errors, E);
+      }
+    else
+      t.errors = m;
+    return m;
+  }, U = async (l, m, E = {
+    valid: !0
+  }) => {
+    for (const N in l) {
+      const F = l[N];
+      if (F) {
+        const { _f: T, ...k } = F;
+        if (T) {
+          const Y = a.array.has(T.name);
+          b([N], !0);
+          const re = await Or(F, s, y, r.shouldUseNativeValidation && !m, Y);
+          if (b([N]), re[T.name] && (E.valid = !1, m))
+            break;
+          !m && (O(re, T.name) ? Y ? Gn(t.errors, re, T.name) : G(t.errors, T.name, re[T.name]) : ne(t.errors, T.name));
+        }
+        k && await U(k, m, E);
+      }
+    }
+    return E.valid;
+  }, J = () => {
+    for (const l of a.unMount) {
+      const m = O(n, l);
+      m && (m._f.refs ? m._f.refs.every((E) => !yr(E)) : !yr(m._f.ref)) && Ce(l);
+    }
+    a.unMount = /* @__PURE__ */ new Set();
+  }, D = (l, m) => (l && m && G(s, l, m), !Qe(we(), o)), I = (l, m, E) => Xn(l, a, {
+    ...i.mount ? s : Q(m) ? o : Pe(l) ? { [l]: m } : m
+  }, E, m), B = (l) => Pt(O(i.mount ? s : o, l, e.shouldUnregister ? O(o, l, []) : [])), V = (l, m, E = {}) => {
+    const N = O(n, l);
+    let F = m;
+    if (N) {
+      const T = N._f;
+      T && (!T.disabled && G(s, l, ro(m, T)), F = $t(T.ref) && de(m) ? "" : m, Jn(T.ref) ? [...T.ref.options].forEach((k) => k.selected = F.includes(k.value)) : T.refs ? Rt(T.ref) ? T.refs.length > 1 ? T.refs.forEach((k) => (!k.defaultChecked || !k.disabled) && (k.checked = Array.isArray(F) ? !!F.find((Y) => Y === k.value) : F === k.value)) : T.refs[0] && (T.refs[0].checked = !!F) : T.refs.forEach((k) => k.checked = k.value === F) : zr(T.ref) ? T.ref.value = "" : (T.ref.value = F, T.ref.type || d.values.next({
+        name: l,
+        values: { ...s }
+      })));
+    }
+    (E.shouldDirty || E.shouldTouch) && A(l, F, E.shouldTouch, E.shouldDirty, !0), E.shouldValidate && Se(l);
+  }, $ = (l, m, E) => {
+    for (const N in m) {
+      const F = m[N], T = `${l}.${N}`, k = O(n, T);
+      (a.array.has(l) || !Kt(F) || k && !k._f) && !ht(F) ? $(T, F, E) : V(T, F, E);
+    }
+  }, L = (l, m, E = {}) => {
+    const N = O(n, l), F = a.array.has(l), T = ie(m);
+    G(s, l, T), F ? (d.array.next({
+      name: l,
+      values: { ...s }
+    }), (f.isDirty || f.dirtyFields) && E.shouldDirty && d.state.next({
+      name: l,
+      dirtyFields: Ft(o, s),
+      isDirty: D(l, T)
+    })) : N && !N._f && !de(T) ? $(l, T, E) : V(l, T, E), Tr(l, a) && d.state.next({ ...t }), d.values.next({
+      name: i.mount ? l : void 0,
+      values: { ...s }
+    });
+  }, Z = async (l) => {
+    i.mount = !0;
+    const m = l.target;
+    let E = m.name, N = !0;
+    const F = O(n, E), T = () => m.type ? wr(F._f) : Hn(l), k = (Y) => {
+      N = Number.isNaN(Y) || Y === O(s, E, Y);
+    };
+    if (F) {
+      let Y, re;
+      const ve = T(), st = l.type === Ut.BLUR || l.type === Ut.FOCUS_OUT, Cs = !ti(F._f) && !r.resolver && !O(t.errors, E) && !F._f.deps || ri(st, O(t.touchedFields, E), t.isSubmitted, x, g), ir = Tr(E, a, st);
+      G(s, E, ve), st ? (F._f.onBlur && F._f.onBlur(l), c && c(0)) : F._f.onChange && F._f.onChange(l);
+      const ar = A(E, ve, st, !1), As = !he(ar) || ir;
+      if (!st && d.values.next({
+        name: E,
+        type: l.type,
+        values: { ...s }
+      }), Cs)
+        return f.isValid && S(), As && d.state.next({ name: E, ...ir ? {} : ar });
+      if (!st && ir && d.state.next({ ...t }), r.resolver) {
+        const { errors: nn } = await M([E]);
+        if (k(ve), N) {
+          const _s = pn(t.errors, n, E), on = pn(nn, n, _s.name || E);
+          Y = on.error, E = on.name, re = he(nn);
+        }
+      } else
+        b([E], !0), Y = (await Or(F, s, y, r.shouldUseNativeValidation))[E], b([E]), k(ve), N && (Y ? re = !1 : f.isValid && (re = await U(n, !0)));
+      N && (F._f.deps && Se(F._f.deps), _(E, re, Y, ar));
+    }
+  }, ee = (l, m) => {
+    if (O(t.errors, m) && l.focus)
+      return l.focus(), 1;
+  }, Se = async (l, m = {}) => {
+    let E, N;
+    const F = pe(l);
+    if (r.resolver) {
+      const T = await H(Q(l) ? l : F);
+      E = he(T), N = l ? !F.some((k) => O(T, k)) : E;
+    } else l ? (N = (await Promise.all(F.map(async (T) => {
+      const k = O(n, T);
+      return await U(k && k._f ? { [T]: k } : k);
+    }))).every(Boolean), !(!N && !t.isValid) && S()) : N = E = await U(n);
+    return d.state.next({
+      ...!Pe(l) || f.isValid && E !== t.isValid ? {} : { name: l },
+      ...r.resolver || !l ? { isValid: E } : {},
+      errors: t.errors
+    }), m.shouldFocus && !N && pt(n, ee, l ? F : a.mount), N;
+  }, we = (l) => {
+    const m = {
+      ...i.mount ? s : o
+    };
+    return Q(l) ? m : Pe(l) ? O(m, l) : l.map((E) => O(m, E));
+  }, je = (l, m) => ({
+    invalid: !!O((m || t).errors, l),
+    isDirty: !!O((m || t).dirtyFields, l),
+    error: O((m || t).errors, l),
+    isValidating: !!O(t.validatingFields, l),
+    isTouched: !!O((m || t).touchedFields, l)
+  }), Ze = (l) => {
+    l && pe(l).forEach((m) => ne(t.errors, m)), d.state.next({
+      errors: l ? t.errors : {}
+    });
+  }, Ee = (l, m, E) => {
+    const N = (O(n, l, { _f: {} })._f || {}).ref, F = O(t.errors, l) || {}, { ref: T, message: k, type: Y, ...re } = F;
+    G(t.errors, l, {
+      ...re,
+      ...m,
+      ref: N
+    }), d.state.next({
+      name: l,
+      errors: t.errors,
+      isValid: !1
+    }), E && E.shouldFocus && N && N.focus && N.focus();
+  }, Be = (l, m) => ze(l) ? d.values.subscribe({
+    next: (E) => l(I(void 0, m), E)
+  }) : I(l, m, !0), Ce = (l, m = {}) => {
+    for (const E of l ? pe(l) : a.mount)
+      a.mount.delete(E), a.array.delete(E), m.keepValue || (ne(n, E), ne(s, E)), !m.keepError && ne(t.errors, E), !m.keepDirty && ne(t.dirtyFields, E), !m.keepTouched && ne(t.touchedFields, E), !m.keepIsValidating && ne(t.validatingFields, E), !r.shouldUnregister && !m.keepDefaultValue && ne(o, E);
+    d.values.next({
+      values: { ...s }
+    }), d.state.next({
+      ...t,
+      ...m.keepDirty ? { isDirty: D() } : {}
+    }), !m.keepIsValid && S();
+  }, W = ({ disabled: l, name: m, field: E, fields: N, value: F }) => {
+    if (_e(l) && i.mount || l) {
+      const T = l ? void 0 : Q(F) ? wr(E ? E._f : O(N, m)._f) : F;
+      G(s, m, T), A(m, T, !1, !1, !0);
+    }
+  }, q = (l, m = {}) => {
+    let E = O(n, l);
+    const N = _e(m.disabled);
+    return G(n, l, {
+      ...E || {},
+      _f: {
+        ...E && E._f ? E._f : { ref: { name: l } },
+        name: l,
+        mount: !0,
+        ...m
+      }
+    }), a.mount.add(l), E ? W({
+      field: E,
+      disabled: m.disabled,
+      name: l,
+      value: m.value
+    }) : w(l, !0, m.value), {
+      ...N ? { disabled: m.disabled } : {},
+      ...r.progressive ? {
+        required: !!m.required,
+        min: St(m.min),
+        max: St(m.max),
+        minLength: St(m.minLength),
+        maxLength: St(m.maxLength),
+        pattern: St(m.pattern)
+      } : {},
+      name: l,
+      onChange: Z,
+      onBlur: Z,
+      ref: (F) => {
+        if (F) {
+          q(l, m), E = O(n, l);
+          const T = Q(F.value) && F.querySelectorAll && F.querySelectorAll("input,select,textarea")[0] || F, k = Js(T), Y = E._f.refs || [];
+          if (k ? Y.find((re) => re === T) : T === E._f.ref)
+            return;
+          G(n, l, {
+            _f: {
+              ...E._f,
+              ...k ? {
+                refs: [
+                  ...Y.filter(yr),
+                  T,
+                  ...Array.isArray(O(o, l)) ? [{}] : []
+                ],
+                ref: { type: T.type, name: l }
+              } : { ref: T }
+            }
+          }), w(l, !1, void 0, T);
+        } else
+          E = O(n, l, {}), E._f && (E._f.mount = !1), (r.shouldUnregister || m.shouldUnregister) && !(Un(a.array, l) && i.action) && a.unMount.add(l);
+      }
+    };
+  }, se = () => r.shouldFocusError && pt(n, ee, a.mount), X = (l) => {
+    _e(l) && (d.state.next({ disabled: l }), pt(n, (m, E) => {
+      const N = O(n, E);
+      N && (m.disabled = N._f.disabled || l, Array.isArray(N._f.refs) && N._f.refs.forEach((F) => {
+        F.disabled = N._f.disabled || l;
+      }));
+    }, 0, !1));
+  }, z = (l, m) => async (E) => {
+    let N;
+    E && (E.preventDefault && E.preventDefault(), E.persist && E.persist());
+    let F = ie(s);
+    if (d.state.next({
+      isSubmitting: !0
+    }), r.resolver) {
+      const { errors: T, values: k } = await M();
+      t.errors = T, F = k;
+    } else
+      await U(n);
+    if (ne(t.errors, "root"), he(t.errors)) {
+      d.state.next({
+        errors: {}
+      });
+      try {
+        await l(F, E);
+      } catch (T) {
+        N = T;
+      }
+    } else
+      m && await m({ ...t.errors }, E), se(), setTimeout(se);
+    if (d.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: he(t.errors) && !N,
+      submitCount: t.submitCount + 1,
+      errors: t.errors
+    }), N)
+      throw N;
+  }, K = (l, m = {}) => {
+    O(n, l) && (Q(m.defaultValue) ? L(l, ie(O(o, l))) : (L(l, m.defaultValue), G(o, l, ie(m.defaultValue))), m.keepTouched || ne(t.touchedFields, l), m.keepDirty || (ne(t.dirtyFields, l), t.isDirty = m.defaultValue ? D(l, ie(O(o, l))) : D()), m.keepError || (ne(t.errors, l), f.isValid && S()), d.state.next({ ...t }));
+  }, ue = (l, m = {}) => {
+    const E = l ? ie(l) : o, N = ie(E), F = he(l), T = F ? o : N;
+    if (m.keepDefaultValues || (o = E), !m.keepValues) {
+      if (m.keepDirtyValues)
+        for (const k of a.mount)
+          O(t.dirtyFields, k) ? G(T, k, O(s, k)) : L(k, O(T, k));
+      else {
+        if (Ur && Q(l))
+          for (const k of a.mount) {
+            const Y = O(n, k);
+            if (Y && Y._f) {
+              const re = Array.isArray(Y._f.refs) ? Y._f.refs[0] : Y._f.ref;
+              if ($t(re)) {
+                const ve = re.closest("form");
+                if (ve) {
+                  ve.reset();
+                  break;
+                }
+              }
+            }
+          }
+        n = {};
+      }
+      s = e.shouldUnregister ? m.keepDefaultValues ? ie(o) : {} : ie(T), d.array.next({
+        values: { ...T }
+      }), d.values.next({
+        values: { ...T }
+      });
+    }
+    a = {
+      mount: m.keepDirtyValues ? a.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, i.mount = !f.isValid || !!m.keepIsValid || !!m.keepDirtyValues, i.watch = !!e.shouldUnregister, d.state.next({
+      submitCount: m.keepSubmitCount ? t.submitCount : 0,
+      isDirty: F ? !1 : m.keepDirty ? t.isDirty : !!(m.keepDefaultValues && !Qe(l, o)),
+      isSubmitted: m.keepIsSubmitted ? t.isSubmitted : !1,
+      dirtyFields: F ? {} : m.keepDirtyValues ? m.keepDefaultValues && s ? Ft(o, s) : t.dirtyFields : m.keepDefaultValues && l ? Ft(o, l) : m.keepDirty ? t.dirtyFields : {},
+      touchedFields: m.keepTouched ? t.touchedFields : {},
+      errors: m.keepErrors ? t.errors : {},
+      isSubmitSuccessful: m.keepIsSubmitSuccessful ? t.isSubmitSuccessful : !1,
+      isSubmitting: !1
+    });
+  }, me = (l, m) => ue(ze(l) ? l(s) : l, m);
+  return {
+    control: {
+      register: q,
+      unregister: Ce,
+      getFieldState: je,
+      handleSubmit: z,
+      setError: Ee,
+      _executeSchema: M,
+      _getWatch: I,
+      _getDirty: D,
+      _updateValid: S,
+      _removeUnmounted: J,
+      _updateFieldArray: v,
+      _updateDisabledField: W,
+      _getFieldArray: B,
+      _reset: ue,
+      _resetDefaultValues: () => ze(r.defaultValues) && r.defaultValues().then((l) => {
+        me(l, r.resetOptions), d.state.next({
+          isLoading: !1
+        });
+      }),
+      _updateFormState: (l) => {
+        t = {
+          ...t,
+          ...l
+        };
+      },
+      _disableForm: X,
+      _subjects: d,
+      _proxyFormState: f,
+      _setErrors: R,
+      get _fields() {
+        return n;
+      },
+      get _formValues() {
+        return s;
+      },
+      get _state() {
+        return i;
+      },
+      set _state(l) {
+        i = l;
+      },
+      get _defaultValues() {
+        return o;
+      },
+      get _names() {
+        return a;
+      },
+      set _names(l) {
+        a = l;
+      },
+      get _formState() {
+        return t;
+      },
+      set _formState(l) {
+        t = l;
+      },
+      get _options() {
+        return r;
+      },
+      set _options(l) {
+        r = {
+          ...r,
+          ...l
+        };
+      }
+    },
+    trigger: Se,
+    register: q,
+    handleSubmit: z,
+    watch: Be,
+    setValue: L,
+    getValues: we,
+    reset: me,
+    resetField: K,
+    clearErrors: Ze,
+    unregister: Ce,
+    setError: Ee,
+    setFocus: (l, m = {}) => {
+      const E = O(n, l), N = E && E._f;
+      if (N) {
+        const F = N.refs ? N.refs[0] : N.ref;
+        F.focus && (F.focus(), m.shouldSelect && F.select());
+      }
+    },
+    getFieldState: je
+  };
+}
+function cl(e = {}) {
+  const r = j.useRef(), t = j.useRef(), [n, o] = j.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: ze(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1,
+    defaultValues: ze(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  r.current || (r.current = {
+    ...si(e),
+    formState: n
+  });
+  const s = r.current.control;
+  return s._options = e, er({
+    subject: s._subjects.state,
+    next: (i) => {
+      Yn(i, s._proxyFormState, s._updateFormState, !0) && o({ ...s._formState });
+    }
+  }), j.useEffect(() => s._disableForm(e.disabled), [s, e.disabled]), j.useEffect(() => {
+    if (s._proxyFormState.isDirty) {
+      const i = s._getDirty();
+      i !== n.isDirty && s._subjects.state.next({
+        isDirty: i
+      });
+    }
+  }, [s, n.isDirty]), j.useEffect(() => {
+    e.values && !Qe(e.values, t.current) ? (s._reset(e.values, s._options.resetOptions), t.current = e.values, o((i) => ({ ...i }))) : s._resetDefaultValues();
+  }, [e.values, s]), j.useEffect(() => {
+    e.errors && s._setErrors(e.errors);
+  }, [e.errors, s]), j.useEffect(() => {
+    s._state.mount || (s._updateValid(), s._state.mount = !0), s._state.watch && (s._state.watch = !1, s._subjects.state.next({ ...s._formState })), s._removeUnmounted();
+  }), j.useEffect(() => {
+    e.shouldUnregister && s._subjects.values.next({
+      values: s._getWatch()
+    });
+  }, [e.shouldUnregister, s]), r.current.formState = Kn(n, s), r.current;
+}
+function mn(e, [r, t]) {
+  return Math.min(t, Math.max(r, e));
+}
+function ii(e) {
+  const r = e + "CollectionProvider", [t, n] = Br(r), [o, s] = t(
+    r,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  ), i = (x) => {
+    const { scope: y, children: p } = x, S = j.useRef(null), b = j.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ P.jsx(o, { scope: y, itemMap: b, collectionRef: S, children: p });
+  };
+  i.displayName = r;
+  const a = e + "CollectionSlot", c = j.forwardRef(
+    (x, y) => {
+      const { scope: p, children: S } = x, b = s(a, p), v = le(y, b.collectionRef);
+      return /* @__PURE__ */ P.jsx(Ht, { ref: v, children: S });
+    }
+  );
+  c.displayName = a;
+  const u = e + "CollectionItemSlot", f = "data-radix-collection-item", d = j.forwardRef(
+    (x, y) => {
+      const { scope: p, children: S, ...b } = x, v = j.useRef(null), C = le(y, v), R = s(u, p);
+      return j.useEffect(() => (R.itemMap.set(v, { ref: v, ...b }), () => void R.itemMap.delete(v))), /* @__PURE__ */ P.jsx(Ht, { [f]: "", ref: C, children: S });
+    }
+  );
+  d.displayName = u;
+  function g(x) {
+    const y = s(e + "CollectionConsumer", x);
+    return j.useCallback(() => {
+      const S = y.collectionRef.current;
+      if (!S) return [];
+      const b = Array.from(S.querySelectorAll(`[${f}]`));
+      return Array.from(y.itemMap.values()).sort(
+        (R, w) => b.indexOf(R.ref.current) - b.indexOf(w.ref.current)
+      );
+    }, [y.collectionRef, y.itemMap]);
+  }
+  return [
+    { Provider: i, Slot: c, ItemSlot: d },
+    g,
+    n
+  ];
+}
+var ai = h.createContext(void 0);
+function ci(e) {
+  const r = h.useContext(ai);
+  return e || r || "ltr";
+}
+function li(e, r = globalThis == null ? void 0 : globalThis.document) {
+  const t = Je(e);
+  h.useEffect(() => {
+    const n = (o) => {
+      o.key === "Escape" && t(o);
+    };
+    return r.addEventListener("keydown", n, { capture: !0 }), () => r.removeEventListener("keydown", n, { capture: !0 });
+  }, [t, r]);
+}
+var ui = "DismissableLayer", Fr = "dismissableLayer.update", di = "dismissableLayer.pointerDownOutside", fi = "dismissableLayer.focusOutside", vn, no = h.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), oo = h.forwardRef(
+  (e, r) => {
+    const {
+      disableOutsidePointerEvents: t = !1,
+      onEscapeKeyDown: n,
+      onPointerDownOutside: o,
+      onFocusOutside: s,
+      onInteractOutside: i,
+      onDismiss: a,
+      ...c
+    } = e, u = h.useContext(no), [f, d] = h.useState(null), g = (f == null ? void 0 : f.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document), [, x] = h.useState({}), y = le(r, (_) => d(_)), p = Array.from(u.layers), [S] = [...u.layersWithOutsidePointerEventsDisabled].slice(-1), b = p.indexOf(S), v = f ? p.indexOf(f) : -1, C = u.layersWithOutsidePointerEventsDisabled.size > 0, R = v >= b, w = mi((_) => {
+      const M = _.target, H = [...u.branches].some((U) => U.contains(M));
+      !R || H || (o == null || o(_), i == null || i(_), _.defaultPrevented || a == null || a());
+    }, g), A = vi((_) => {
+      const M = _.target;
+      [...u.branches].some((U) => U.contains(M)) || (s == null || s(_), i == null || i(_), _.defaultPrevented || a == null || a());
+    }, g);
+    return li((_) => {
+      v === u.layers.size - 1 && (n == null || n(_), !_.defaultPrevented && a && (_.preventDefault(), a()));
+    }, g), h.useEffect(() => {
+      if (f)
+        return t && (u.layersWithOutsidePointerEventsDisabled.size === 0 && (vn = g.body.style.pointerEvents, g.body.style.pointerEvents = "none"), u.layersWithOutsidePointerEventsDisabled.add(f)), u.layers.add(f), gn(), () => {
+          t && u.layersWithOutsidePointerEventsDisabled.size === 1 && (g.body.style.pointerEvents = vn);
+        };
+    }, [f, g, t, u]), h.useEffect(() => () => {
+      f && (u.layers.delete(f), u.layersWithOutsidePointerEventsDisabled.delete(f), gn());
+    }, [f, u]), h.useEffect(() => {
+      const _ = () => x({});
+      return document.addEventListener(Fr, _), () => document.removeEventListener(Fr, _);
+    }, []), /* @__PURE__ */ P.jsx(
+      oe.div,
+      {
+        ...c,
+        ref: y,
+        style: {
+          pointerEvents: C ? R ? "auto" : "none" : void 0,
+          ...e.style
+        },
+        onFocusCapture: ce(e.onFocusCapture, A.onFocusCapture),
+        onBlurCapture: ce(e.onBlurCapture, A.onBlurCapture),
+        onPointerDownCapture: ce(
+          e.onPointerDownCapture,
+          w.onPointerDownCapture
+        )
+      }
+    );
+  }
+);
+oo.displayName = ui;
+var hi = "DismissableLayerBranch", pi = h.forwardRef((e, r) => {
+  const t = h.useContext(no), n = h.useRef(null), o = le(r, n);
+  return h.useEffect(() => {
+    const s = n.current;
+    if (s)
+      return t.branches.add(s), () => {
+        t.branches.delete(s);
+      };
+  }, [t.branches]), /* @__PURE__ */ P.jsx(oe.div, { ...e, ref: o });
+});
+pi.displayName = hi;
+function mi(e, r = globalThis == null ? void 0 : globalThis.document) {
+  const t = Je(e), n = h.useRef(!1), o = h.useRef(() => {
+  });
+  return h.useEffect(() => {
+    const s = (a) => {
+      if (a.target && !n.current) {
+        let c = function() {
+          so(
+            di,
+            t,
+            u,
+            { discrete: !0 }
+          );
+        };
+        const u = { originalEvent: a };
+        a.pointerType === "touch" ? (r.removeEventListener("click", o.current), o.current = c, r.addEventListener("click", o.current, { once: !0 })) : c();
+      } else
+        r.removeEventListener("click", o.current);
+      n.current = !1;
+    }, i = window.setTimeout(() => {
+      r.addEventListener("pointerdown", s);
+    }, 0);
+    return () => {
+      window.clearTimeout(i), r.removeEventListener("pointerdown", s), r.removeEventListener("click", o.current);
+    };
+  }, [r, t]), {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => n.current = !0
+  };
+}
+function vi(e, r = globalThis == null ? void 0 : globalThis.document) {
+  const t = Je(e), n = h.useRef(!1);
+  return h.useEffect(() => {
+    const o = (s) => {
+      s.target && !n.current && so(fi, t, { originalEvent: s }, {
+        discrete: !1
+      });
+    };
+    return r.addEventListener("focusin", o), () => r.removeEventListener("focusin", o);
+  }, [r, t]), {
+    onFocusCapture: () => n.current = !0,
+    onBlurCapture: () => n.current = !1
+  };
+}
+function gn() {
+  const e = new CustomEvent(Fr);
+  document.dispatchEvent(e);
+}
+function so(e, r, t, { discrete: n }) {
+  const o = t.originalEvent.target, s = new CustomEvent(e, { bubbles: !1, cancelable: !0, detail: t });
+  r && o.addEventListener(e, r, { once: !0 }), n ? Fs(o, s) : o.dispatchEvent(s);
+}
+var xr = 0;
+function gi() {
+  h.useEffect(() => {
+    const e = document.querySelectorAll("[data-radix-focus-guard]");
+    return document.body.insertAdjacentElement("afterbegin", e[0] ?? yn()), document.body.insertAdjacentElement("beforeend", e[1] ?? yn()), xr++, () => {
+      xr === 1 && document.querySelectorAll("[data-radix-focus-guard]").forEach((r) => r.remove()), xr--;
+    };
+  }, []);
+}
+function yn() {
+  const e = document.createElement("span");
+  return e.setAttribute("data-radix-focus-guard", ""), e.tabIndex = 0, e.style.cssText = "outline: none; opacity: 0; position: fixed; pointer-events: none", e;
+}
+var br = "focusScope.autoFocusOnMount", Sr = "focusScope.autoFocusOnUnmount", wn = { bubbles: !1, cancelable: !0 }, yi = "FocusScope", io = h.forwardRef((e, r) => {
+  const {
+    loop: t = !1,
+    trapped: n = !1,
+    onMountAutoFocus: o,
+    onUnmountAutoFocus: s,
+    ...i
+  } = e, [a, c] = h.useState(null), u = Je(o), f = Je(s), d = h.useRef(null), g = le(r, (p) => c(p)), x = h.useRef({
+    paused: !1,
+    pause() {
+      this.paused = !0;
+    },
+    resume() {
+      this.paused = !1;
+    }
+  }).current;
+  h.useEffect(() => {
+    if (n) {
+      let p = function(C) {
+        if (x.paused || !a) return;
+        const R = C.target;
+        a.contains(R) ? d.current = R : He(d.current, { select: !0 });
+      }, S = function(C) {
+        if (x.paused || !a) return;
+        const R = C.relatedTarget;
+        R !== null && (a.contains(R) || He(d.current, { select: !0 }));
+      }, b = function(C) {
+        if (document.activeElement === document.body)
+          for (const w of C)
+            w.removedNodes.length > 0 && He(a);
+      };
+      document.addEventListener("focusin", p), document.addEventListener("focusout", S);
+      const v = new MutationObserver(b);
+      return a && v.observe(a, { childList: !0, subtree: !0 }), () => {
+        document.removeEventListener("focusin", p), document.removeEventListener("focusout", S), v.disconnect();
+      };
+    }
+  }, [n, a, x.paused]), h.useEffect(() => {
+    if (a) {
+      bn.add(x);
+      const p = document.activeElement;
+      if (!a.contains(p)) {
+        const b = new CustomEvent(br, wn);
+        a.addEventListener(br, u), a.dispatchEvent(b), b.defaultPrevented || (wi(Ci(ao(a)), { select: !0 }), document.activeElement === p && He(a));
+      }
+      return () => {
+        a.removeEventListener(br, u), setTimeout(() => {
+          const b = new CustomEvent(Sr, wn);
+          a.addEventListener(Sr, f), a.dispatchEvent(b), b.defaultPrevented || He(p ?? document.body, { select: !0 }), a.removeEventListener(Sr, f), bn.remove(x);
+        }, 0);
+      };
+    }
+  }, [a, u, f, x]);
+  const y = h.useCallback(
+    (p) => {
+      if (!t && !n || x.paused) return;
+      const S = p.key === "Tab" && !p.altKey && !p.ctrlKey && !p.metaKey, b = document.activeElement;
+      if (S && b) {
+        const v = p.currentTarget, [C, R] = xi(v);
+        C && R ? !p.shiftKey && b === R ? (p.preventDefault(), t && He(C, { select: !0 })) : p.shiftKey && b === C && (p.preventDefault(), t && He(R, { select: !0 })) : b === v && p.preventDefault();
+      }
+    },
+    [t, n, x.paused]
+  );
+  return /* @__PURE__ */ P.jsx(oe.div, { tabIndex: -1, ...i, ref: g, onKeyDown: y });
+});
+io.displayName = yi;
+function wi(e, { select: r = !1 } = {}) {
+  const t = document.activeElement;
+  for (const n of e)
+    if (He(n, { select: r }), document.activeElement !== t) return;
+}
+function xi(e) {
+  const r = ao(e), t = xn(r, e), n = xn(r.reverse(), e);
+  return [t, n];
+}
+function ao(e) {
+  const r = [], t = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (n) => {
+      const o = n.tagName === "INPUT" && n.type === "hidden";
+      return n.disabled || n.hidden || o ? NodeFilter.FILTER_SKIP : n.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  for (; t.nextNode(); ) r.push(t.currentNode);
+  return r;
+}
+function xn(e, r) {
+  for (const t of e)
+    if (!bi(t, { upTo: r })) return t;
+}
+function bi(e, { upTo: r }) {
+  if (getComputedStyle(e).visibility === "hidden") return !0;
+  for (; e; ) {
+    if (r !== void 0 && e === r) return !1;
+    if (getComputedStyle(e).display === "none") return !0;
+    e = e.parentElement;
+  }
+  return !1;
+}
+function Si(e) {
+  return e instanceof HTMLInputElement && "select" in e;
+}
+function He(e, { select: r = !1 } = {}) {
+  if (e && e.focus) {
+    const t = document.activeElement;
+    e.focus({ preventScroll: !0 }), e !== t && Si(e) && r && e.select();
+  }
+}
+var bn = Ei();
+function Ei() {
+  let e = [];
+  return {
+    add(r) {
+      const t = e[0];
+      r !== t && (t == null || t.pause()), e = Sn(e, r), e.unshift(r);
+    },
+    remove(r) {
+      var t;
+      e = Sn(e, r), (t = e[0]) == null || t.resume();
+    }
+  };
+}
+function Sn(e, r) {
+  const t = [...e], n = t.indexOf(r);
+  return n !== -1 && t.splice(n, 1), t;
+}
+function Ci(e) {
+  return e.filter((r) => r.tagName !== "A");
+}
+const Ai = ["top", "right", "bottom", "left"], Ke = Math.min, ge = Math.max, qt = Math.round, Nt = Math.floor, Ye = (e) => ({
+  x: e,
+  y: e
+}), _i = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Ri = {
+  start: "end",
+  end: "start"
+};
+function Nr(e, r, t) {
+  return ge(e, Ke(r, t));
+}
+function Ie(e, r) {
+  return typeof e == "function" ? e(r) : e;
+}
+function Ve(e) {
+  return e.split("-")[0];
+}
+function yt(e) {
+  return e.split("-")[1];
+}
+function Yr(e) {
+  return e === "x" ? "y" : "x";
+}
+function qr(e) {
+  return e === "y" ? "height" : "width";
+}
+function wt(e) {
+  return ["top", "bottom"].includes(Ve(e)) ? "y" : "x";
+}
+function Xr(e) {
+  return Yr(wt(e));
+}
+function Pi(e, r, t) {
+  t === void 0 && (t = !1);
+  const n = yt(e), o = Xr(e), s = qr(o);
+  let i = o === "x" ? n === (t ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return r.reference[s] > r.floating[s] && (i = Xt(i)), [i, Xt(i)];
+}
+function Ti(e) {
+  const r = Xt(e);
+  return [Dr(e), r, Dr(r)];
+}
+function Dr(e) {
+  return e.replace(/start|end/g, (r) => Ri[r]);
+}
+function Oi(e, r, t) {
+  const n = ["left", "right"], o = ["right", "left"], s = ["top", "bottom"], i = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return t ? r ? o : n : r ? n : o;
+    case "left":
+    case "right":
+      return r ? s : i;
+    default:
+      return [];
+  }
+}
+function Fi(e, r, t, n) {
+  const o = yt(e);
+  let s = Oi(Ve(e), t === "start", n);
+  return o && (s = s.map((i) => i + "-" + o), r && (s = s.concat(s.map(Dr)))), s;
+}
+function Xt(e) {
+  return e.replace(/left|right|bottom|top/g, (r) => _i[r]);
+}
+function Ni(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function co(e) {
+  return typeof e != "number" ? Ni(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Gt(e) {
+  const {
+    x: r,
+    y: t,
+    width: n,
+    height: o
+  } = e;
+  return {
+    width: n,
+    height: o,
+    top: t,
+    left: r,
+    right: r + n,
+    bottom: t + o,
+    x: r,
+    y: t
+  };
+}
+function En(e, r, t) {
+  let {
+    reference: n,
+    floating: o
+  } = e;
+  const s = wt(r), i = Xr(r), a = qr(i), c = Ve(r), u = s === "y", f = n.x + n.width / 2 - o.width / 2, d = n.y + n.height / 2 - o.height / 2, g = n[a] / 2 - o[a] / 2;
+  let x;
+  switch (c) {
+    case "top":
+      x = {
+        x: f,
+        y: n.y - o.height
+      };
+      break;
+    case "bottom":
+      x = {
+        x: f,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      x = {
+        x: n.x + n.width,
+        y: d
+      };
+      break;
+    case "left":
+      x = {
+        x: n.x - o.width,
+        y: d
+      };
+      break;
+    default:
+      x = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (yt(r)) {
+    case "start":
+      x[i] -= g * (t && u ? -1 : 1);
+      break;
+    case "end":
+      x[i] += g * (t && u ? -1 : 1);
+      break;
+  }
+  return x;
+}
+const Di = async (e, r, t) => {
+  const {
+    placement: n = "bottom",
+    strategy: o = "absolute",
+    middleware: s = [],
+    platform: i
+  } = t, a = s.filter(Boolean), c = await (i.isRTL == null ? void 0 : i.isRTL(r));
+  let u = await i.getElementRects({
+    reference: e,
+    floating: r,
+    strategy: o
+  }), {
+    x: f,
+    y: d
+  } = En(u, n, c), g = n, x = {}, y = 0;
+  for (let p = 0; p < a.length; p++) {
+    const {
+      name: S,
+      fn: b
+    } = a[p], {
+      x: v,
+      y: C,
+      data: R,
+      reset: w
+    } = await b({
+      x: f,
+      y: d,
+      initialPlacement: n,
+      placement: g,
+      strategy: o,
+      middlewareData: x,
+      rects: u,
+      platform: i,
+      elements: {
+        reference: e,
+        floating: r
+      }
+    });
+    f = v ?? f, d = C ?? d, x = {
+      ...x,
+      [S]: {
+        ...x[S],
+        ...R
+      }
+    }, w && y <= 50 && (y++, typeof w == "object" && (w.placement && (g = w.placement), w.rects && (u = w.rects === !0 ? await i.getElementRects({
+      reference: e,
+      floating: r,
+      strategy: o
+    }) : w.rects), {
+      x: f,
+      y: d
+    } = En(u, g, c)), p = -1);
+  }
+  return {
+    x: f,
+    y: d,
+    placement: g,
+    strategy: o,
+    middlewareData: x
+  };
+};
+async function At(e, r) {
+  var t;
+  r === void 0 && (r = {});
+  const {
+    x: n,
+    y: o,
+    platform: s,
+    rects: i,
+    elements: a,
+    strategy: c
+  } = e, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: d = "floating",
+    altBoundary: g = !1,
+    padding: x = 0
+  } = Ie(r, e), y = co(x), S = a[g ? d === "floating" ? "reference" : "floating" : d], b = Gt(await s.getClippingRect({
+    element: (t = await (s.isElement == null ? void 0 : s.isElement(S))) == null || t ? S : S.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(a.floating)),
+    boundary: u,
+    rootBoundary: f,
+    strategy: c
+  })), v = d === "floating" ? {
+    x: n,
+    y: o,
+    width: i.floating.width,
+    height: i.floating.height
+  } : i.reference, C = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(a.floating)), R = await (s.isElement == null ? void 0 : s.isElement(C)) ? await (s.getScale == null ? void 0 : s.getScale(C)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, w = Gt(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: v,
+    offsetParent: C,
+    strategy: c
+  }) : v);
+  return {
+    top: (b.top - w.top + y.top) / R.y,
+    bottom: (w.bottom - b.bottom + y.bottom) / R.y,
+    left: (b.left - w.left + y.left) / R.x,
+    right: (w.right - b.right + y.right) / R.x
+  };
+}
+const Mi = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(r) {
+    const {
+      x: t,
+      y: n,
+      placement: o,
+      rects: s,
+      platform: i,
+      elements: a,
+      middlewareData: c
+    } = r, {
+      element: u,
+      padding: f = 0
+    } = Ie(e, r) || {};
+    if (u == null)
+      return {};
+    const d = co(f), g = {
+      x: t,
+      y: n
+    }, x = Xr(o), y = qr(x), p = await i.getDimensions(u), S = x === "y", b = S ? "top" : "left", v = S ? "bottom" : "right", C = S ? "clientHeight" : "clientWidth", R = s.reference[y] + s.reference[x] - g[x] - s.floating[y], w = g[x] - s.reference[x], A = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(u));
+    let _ = A ? A[C] : 0;
+    (!_ || !await (i.isElement == null ? void 0 : i.isElement(A))) && (_ = a.floating[C] || s.floating[y]);
+    const M = R / 2 - w / 2, H = _ / 2 - p[y] / 2 - 1, U = Ke(d[b], H), J = Ke(d[v], H), D = U, I = _ - p[y] - J, B = _ / 2 - p[y] / 2 + M, V = Nr(D, B, I), $ = !c.arrow && yt(o) != null && B !== V && s.reference[y] / 2 - (B < D ? U : J) - p[y] / 2 < 0, L = $ ? B < D ? B - D : B - I : 0;
+    return {
+      [x]: g[x] + L,
+      data: {
+        [x]: V,
+        centerOffset: B - V - L,
+        ...$ && {
+          alignmentOffset: L
+        }
+      },
+      reset: $
+    };
+  }
+}), ki = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(r) {
+      var t, n;
+      const {
+        placement: o,
+        middlewareData: s,
+        rects: i,
+        initialPlacement: a,
+        platform: c,
+        elements: u
+      } = r, {
+        mainAxis: f = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: g,
+        fallbackStrategy: x = "bestFit",
+        fallbackAxisSideDirection: y = "none",
+        flipAlignment: p = !0,
+        ...S
+      } = Ie(e, r);
+      if ((t = s.arrow) != null && t.alignmentOffset)
+        return {};
+      const b = Ve(o), v = Ve(a) === a, C = await (c.isRTL == null ? void 0 : c.isRTL(u.floating)), R = g || (v || !p ? [Xt(a)] : Ti(a));
+      !g && y !== "none" && R.push(...Fi(a, p, y, C));
+      const w = [a, ...R], A = await At(r, S), _ = [];
+      let M = ((n = s.flip) == null ? void 0 : n.overflows) || [];
+      if (f && _.push(A[b]), d) {
+        const D = Pi(o, i, C);
+        _.push(A[D[0]], A[D[1]]);
+      }
+      if (M = [...M, {
+        placement: o,
+        overflows: _
+      }], !_.every((D) => D <= 0)) {
+        var H, U;
+        const D = (((H = s.flip) == null ? void 0 : H.index) || 0) + 1, I = w[D];
+        if (I)
+          return {
+            data: {
+              index: D,
+              overflows: M
+            },
+            reset: {
+              placement: I
+            }
+          };
+        let B = (U = M.filter((V) => V.overflows[0] <= 0).sort((V, $) => V.overflows[1] - $.overflows[1])[0]) == null ? void 0 : U.placement;
+        if (!B)
+          switch (x) {
+            case "bestFit": {
+              var J;
+              const V = (J = M.map(($) => [$.placement, $.overflows.filter((L) => L > 0).reduce((L, Z) => L + Z, 0)]).sort(($, L) => $[1] - L[1])[0]) == null ? void 0 : J[0];
+              V && (B = V);
+              break;
+            }
+            case "initialPlacement":
+              B = a;
+              break;
+          }
+        if (o !== B)
+          return {
+            reset: {
+              placement: B
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function Cn(e, r) {
+  return {
+    top: e.top - r.height,
+    right: e.right - r.width,
+    bottom: e.bottom - r.height,
+    left: e.left - r.width
+  };
+}
+function An(e) {
+  return Ai.some((r) => e[r] >= 0);
+}
+const Ii = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(r) {
+      const {
+        rects: t
+      } = r, {
+        strategy: n = "referenceHidden",
+        ...o
+      } = Ie(e, r);
+      switch (n) {
+        case "referenceHidden": {
+          const s = await At(r, {
+            ...o,
+            elementContext: "reference"
+          }), i = Cn(s, t.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: i,
+              referenceHidden: An(i)
+            }
+          };
+        }
+        case "escaped": {
+          const s = await At(r, {
+            ...o,
+            altBoundary: !0
+          }), i = Cn(s, t.floating);
+          return {
+            data: {
+              escapedOffsets: i,
+              escaped: An(i)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+async function Vi(e, r) {
+  const {
+    placement: t,
+    platform: n,
+    elements: o
+  } = e, s = await (n.isRTL == null ? void 0 : n.isRTL(o.floating)), i = Ve(t), a = yt(t), c = wt(t) === "y", u = ["left", "top"].includes(i) ? -1 : 1, f = s && c ? -1 : 1, d = Ie(r, e);
+  let {
+    mainAxis: g,
+    crossAxis: x,
+    alignmentAxis: y
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null,
+    ...d
+  };
+  return a && typeof y == "number" && (x = a === "end" ? y * -1 : y), c ? {
+    x: x * f,
+    y: g * u
+  } : {
+    x: g * u,
+    y: x * f
+  };
+}
+const Li = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(r) {
+      var t, n;
+      const {
+        x: o,
+        y: s,
+        placement: i,
+        middlewareData: a
+      } = r, c = await Vi(r, e);
+      return i === ((t = a.offset) == null ? void 0 : t.placement) && (n = a.arrow) != null && n.alignmentOffset ? {} : {
+        x: o + c.x,
+        y: s + c.y,
+        data: {
+          ...c,
+          placement: i
+        }
+      };
+    }
+  };
+}, ji = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(r) {
+      const {
+        x: t,
+        y: n,
+        placement: o
+      } = r, {
+        mainAxis: s = !0,
+        crossAxis: i = !1,
+        limiter: a = {
+          fn: (S) => {
+            let {
+              x: b,
+              y: v
+            } = S;
+            return {
+              x: b,
+              y: v
+            };
+          }
+        },
+        ...c
+      } = Ie(e, r), u = {
+        x: t,
+        y: n
+      }, f = await At(r, c), d = wt(Ve(o)), g = Yr(d);
+      let x = u[g], y = u[d];
+      if (s) {
+        const S = g === "y" ? "top" : "left", b = g === "y" ? "bottom" : "right", v = x + f[S], C = x - f[b];
+        x = Nr(v, x, C);
+      }
+      if (i) {
+        const S = d === "y" ? "top" : "left", b = d === "y" ? "bottom" : "right", v = y + f[S], C = y - f[b];
+        y = Nr(v, y, C);
+      }
+      const p = a.fn({
+        ...r,
+        [g]: x,
+        [d]: y
+      });
+      return {
+        ...p,
+        data: {
+          x: p.x - t,
+          y: p.y - n
+        }
+      };
+    }
+  };
+}, Bi = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(r) {
+      const {
+        x: t,
+        y: n,
+        placement: o,
+        rects: s,
+        middlewareData: i
+      } = r, {
+        offset: a = 0,
+        mainAxis: c = !0,
+        crossAxis: u = !0
+      } = Ie(e, r), f = {
+        x: t,
+        y: n
+      }, d = wt(o), g = Yr(d);
+      let x = f[g], y = f[d];
+      const p = Ie(a, r), S = typeof p == "number" ? {
+        mainAxis: p,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...p
+      };
+      if (c) {
+        const C = g === "y" ? "height" : "width", R = s.reference[g] - s.floating[C] + S.mainAxis, w = s.reference[g] + s.reference[C] - S.mainAxis;
+        x < R ? x = R : x > w && (x = w);
+      }
+      if (u) {
+        var b, v;
+        const C = g === "y" ? "width" : "height", R = ["top", "left"].includes(Ve(o)), w = s.reference[d] - s.floating[C] + (R && ((b = i.offset) == null ? void 0 : b[d]) || 0) + (R ? 0 : S.crossAxis), A = s.reference[d] + s.reference[C] + (R ? 0 : ((v = i.offset) == null ? void 0 : v[d]) || 0) - (R ? S.crossAxis : 0);
+        y < w ? y = w : y > A && (y = A);
+      }
+      return {
+        [g]: x,
+        [d]: y
+      };
+    }
+  };
+}, Wi = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(r) {
+      const {
+        placement: t,
+        rects: n,
+        platform: o,
+        elements: s
+      } = r, {
+        apply: i = () => {
+        },
+        ...a
+      } = Ie(e, r), c = await At(r, a), u = Ve(t), f = yt(t), d = wt(t) === "y", {
+        width: g,
+        height: x
+      } = n.floating;
+      let y, p;
+      u === "top" || u === "bottom" ? (y = u, p = f === (await (o.isRTL == null ? void 0 : o.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (p = u, y = f === "end" ? "top" : "bottom");
+      const S = x - c[y], b = g - c[p], v = !r.middlewareData.shift;
+      let C = S, R = b;
+      if (d) {
+        const A = g - c.left - c.right;
+        R = f || v ? Ke(b, A) : A;
+      } else {
+        const A = x - c.top - c.bottom;
+        C = f || v ? Ke(S, A) : A;
+      }
+      if (v && !f) {
+        const A = ge(c.left, 0), _ = ge(c.right, 0), M = ge(c.top, 0), H = ge(c.bottom, 0);
+        d ? R = g - 2 * (A !== 0 || _ !== 0 ? A + _ : ge(c.left, c.right)) : C = x - 2 * (M !== 0 || H !== 0 ? M + H : ge(c.top, c.bottom));
+      }
+      await i({
+        ...r,
+        availableWidth: R,
+        availableHeight: C
+      });
+      const w = await o.getDimensions(s.floating);
+      return g !== w.width || x !== w.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function xt(e) {
+  return lo(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function ye(e) {
+  var r;
+  return (e == null || (r = e.ownerDocument) == null ? void 0 : r.defaultView) || window;
+}
+function Le(e) {
+  var r;
+  return (r = (lo(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : r.documentElement;
+}
+function lo(e) {
+  return e instanceof Node || e instanceof ye(e).Node;
+}
+function Te(e) {
+  return e instanceof Element || e instanceof ye(e).Element;
+}
+function Oe(e) {
+  return e instanceof HTMLElement || e instanceof ye(e).HTMLElement;
+}
+function _n(e) {
+  return typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof ye(e).ShadowRoot;
+}
+function Tt(e) {
+  const {
+    overflow: r,
+    overflowX: t,
+    overflowY: n,
+    display: o
+  } = Ae(e);
+  return /auto|scroll|overlay|hidden|clip/.test(r + n + t) && !["inline", "contents"].includes(o);
+}
+function Hi(e) {
+  return ["table", "td", "th"].includes(xt(e));
+}
+function Gr(e) {
+  const r = Zr(), t = Ae(e);
+  return t.transform !== "none" || t.perspective !== "none" || (t.containerType ? t.containerType !== "normal" : !1) || !r && (t.backdropFilter ? t.backdropFilter !== "none" : !1) || !r && (t.filter ? t.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((n) => (t.willChange || "").includes(n)) || ["paint", "layout", "strict", "content"].some((n) => (t.contain || "").includes(n));
+}
+function Ui(e) {
+  let r = qe(e);
+  for (; Oe(r) && !gt(r); ) {
+    if (Gr(r))
+      return r;
+    r = qe(r);
+  }
+  return null;
+}
+function Zr() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function gt(e) {
+  return ["html", "body", "#document"].includes(xt(e));
+}
+function Ae(e) {
+  return ye(e).getComputedStyle(e);
+}
+function tr(e) {
+  return Te(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.pageXOffset,
+    scrollTop: e.pageYOffset
+  };
+}
+function qe(e) {
+  if (xt(e) === "html")
+    return e;
+  const r = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    _n(e) && e.host || // Fallback.
+    Le(e)
+  );
+  return _n(r) ? r.host : r;
+}
+function uo(e) {
+  const r = qe(e);
+  return gt(r) ? e.ownerDocument ? e.ownerDocument.body : e.body : Oe(r) && Tt(r) ? r : uo(r);
+}
+function _t(e, r, t) {
+  var n;
+  r === void 0 && (r = []), t === void 0 && (t = !0);
+  const o = uo(e), s = o === ((n = e.ownerDocument) == null ? void 0 : n.body), i = ye(o);
+  return s ? r.concat(i, i.visualViewport || [], Tt(o) ? o : [], i.frameElement && t ? _t(i.frameElement) : []) : r.concat(o, _t(o, [], t));
+}
+function fo(e) {
+  const r = Ae(e);
+  let t = parseFloat(r.width) || 0, n = parseFloat(r.height) || 0;
+  const o = Oe(e), s = o ? e.offsetWidth : t, i = o ? e.offsetHeight : n, a = qt(t) !== s || qt(n) !== i;
+  return a && (t = s, n = i), {
+    width: t,
+    height: n,
+    $: a
+  };
+}
+function Qr(e) {
+  return Te(e) ? e : e.contextElement;
+}
+function mt(e) {
+  const r = Qr(e);
+  if (!Oe(r))
+    return Ye(1);
+  const t = r.getBoundingClientRect(), {
+    width: n,
+    height: o,
+    $: s
+  } = fo(r);
+  let i = (s ? qt(t.width) : t.width) / n, a = (s ? qt(t.height) : t.height) / o;
+  return (!i || !Number.isFinite(i)) && (i = 1), (!a || !Number.isFinite(a)) && (a = 1), {
+    x: i,
+    y: a
+  };
+}
+const $i = /* @__PURE__ */ Ye(0);
+function ho(e) {
+  const r = ye(e);
+  return !Zr() || !r.visualViewport ? $i : {
+    x: r.visualViewport.offsetLeft,
+    y: r.visualViewport.offsetTop
+  };
+}
+function zi(e, r, t) {
+  return r === void 0 && (r = !1), !t || r && t !== ye(e) ? !1 : r;
+}
+function et(e, r, t, n) {
+  r === void 0 && (r = !1), t === void 0 && (t = !1);
+  const o = e.getBoundingClientRect(), s = Qr(e);
+  let i = Ye(1);
+  r && (n ? Te(n) && (i = mt(n)) : i = mt(e));
+  const a = zi(s, t, n) ? ho(s) : Ye(0);
+  let c = (o.left + a.x) / i.x, u = (o.top + a.y) / i.y, f = o.width / i.x, d = o.height / i.y;
+  if (s) {
+    const g = ye(s), x = n && Te(n) ? ye(n) : n;
+    let y = g, p = y.frameElement;
+    for (; p && n && x !== y; ) {
+      const S = mt(p), b = p.getBoundingClientRect(), v = Ae(p), C = b.left + (p.clientLeft + parseFloat(v.paddingLeft)) * S.x, R = b.top + (p.clientTop + parseFloat(v.paddingTop)) * S.y;
+      c *= S.x, u *= S.y, f *= S.x, d *= S.y, c += C, u += R, y = ye(p), p = y.frameElement;
+    }
+  }
+  return Gt({
+    width: f,
+    height: d,
+    x: c,
+    y: u
+  });
+}
+const Ki = [":popover-open", ":modal"];
+function Jr(e) {
+  return Ki.some((r) => {
+    try {
+      return e.matches(r);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Yi(e) {
+  let {
+    elements: r,
+    rect: t,
+    offsetParent: n,
+    strategy: o
+  } = e;
+  const s = o === "fixed", i = Le(n), a = r ? Jr(r.floating) : !1;
+  if (n === i || a && s)
+    return t;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = Ye(1);
+  const f = Ye(0), d = Oe(n);
+  if ((d || !d && !s) && ((xt(n) !== "body" || Tt(i)) && (c = tr(n)), Oe(n))) {
+    const g = et(n);
+    u = mt(n), f.x = g.x + n.clientLeft, f.y = g.y + n.clientTop;
+  }
+  return {
+    width: t.width * u.x,
+    height: t.height * u.y,
+    x: t.x * u.x - c.scrollLeft * u.x + f.x,
+    y: t.y * u.y - c.scrollTop * u.y + f.y
+  };
+}
+function qi(e) {
+  return Array.from(e.getClientRects());
+}
+function po(e) {
+  return et(Le(e)).left + tr(e).scrollLeft;
+}
+function Xi(e) {
+  const r = Le(e), t = tr(e), n = e.ownerDocument.body, o = ge(r.scrollWidth, r.clientWidth, n.scrollWidth, n.clientWidth), s = ge(r.scrollHeight, r.clientHeight, n.scrollHeight, n.clientHeight);
+  let i = -t.scrollLeft + po(e);
+  const a = -t.scrollTop;
+  return Ae(n).direction === "rtl" && (i += ge(r.clientWidth, n.clientWidth) - o), {
+    width: o,
+    height: s,
+    x: i,
+    y: a
+  };
+}
+function Gi(e, r) {
+  const t = ye(e), n = Le(e), o = t.visualViewport;
+  let s = n.clientWidth, i = n.clientHeight, a = 0, c = 0;
+  if (o) {
+    s = o.width, i = o.height;
+    const u = Zr();
+    (!u || u && r === "fixed") && (a = o.offsetLeft, c = o.offsetTop);
+  }
+  return {
+    width: s,
+    height: i,
+    x: a,
+    y: c
+  };
+}
+function Zi(e, r) {
+  const t = et(e, !0, r === "fixed"), n = t.top + e.clientTop, o = t.left + e.clientLeft, s = Oe(e) ? mt(e) : Ye(1), i = e.clientWidth * s.x, a = e.clientHeight * s.y, c = o * s.x, u = n * s.y;
+  return {
+    width: i,
+    height: a,
+    x: c,
+    y: u
+  };
+}
+function Rn(e, r, t) {
+  let n;
+  if (r === "viewport")
+    n = Gi(e, t);
+  else if (r === "document")
+    n = Xi(Le(e));
+  else if (Te(r))
+    n = Zi(r, t);
+  else {
+    const o = ho(e);
+    n = {
+      ...r,
+      x: r.x - o.x,
+      y: r.y - o.y
+    };
+  }
+  return Gt(n);
+}
+function mo(e, r) {
+  const t = qe(e);
+  return t === r || !Te(t) || gt(t) ? !1 : Ae(t).position === "fixed" || mo(t, r);
+}
+function Qi(e, r) {
+  const t = r.get(e);
+  if (t)
+    return t;
+  let n = _t(e, [], !1).filter((a) => Te(a) && xt(a) !== "body"), o = null;
+  const s = Ae(e).position === "fixed";
+  let i = s ? qe(e) : e;
+  for (; Te(i) && !gt(i); ) {
+    const a = Ae(i), c = Gr(i);
+    !c && a.position === "fixed" && (o = null), (s ? !c && !o : !c && a.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || Tt(i) && !c && mo(e, i)) ? n = n.filter((f) => f !== i) : o = a, i = qe(i);
+  }
+  return r.set(e, n), n;
+}
+function Ji(e) {
+  let {
+    element: r,
+    boundary: t,
+    rootBoundary: n,
+    strategy: o
+  } = e;
+  const i = [...t === "clippingAncestors" ? Jr(r) ? [] : Qi(r, this._c) : [].concat(t), n], a = i[0], c = i.reduce((u, f) => {
+    const d = Rn(r, f, o);
+    return u.top = ge(d.top, u.top), u.right = Ke(d.right, u.right), u.bottom = Ke(d.bottom, u.bottom), u.left = ge(d.left, u.left), u;
+  }, Rn(r, a, o));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function ea(e) {
+  const {
+    width: r,
+    height: t
+  } = fo(e);
+  return {
+    width: r,
+    height: t
+  };
+}
+function ta(e, r, t) {
+  const n = Oe(r), o = Le(r), s = t === "fixed", i = et(e, !0, s, r);
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = Ye(0);
+  if (n || !n && !s)
+    if ((xt(r) !== "body" || Tt(o)) && (a = tr(r)), n) {
+      const d = et(r, !0, s, r);
+      c.x = d.x + r.clientLeft, c.y = d.y + r.clientTop;
+    } else o && (c.x = po(o));
+  const u = i.left + a.scrollLeft - c.x, f = i.top + a.scrollTop - c.y;
+  return {
+    x: u,
+    y: f,
+    width: i.width,
+    height: i.height
+  };
+}
+function Er(e) {
+  return Ae(e).position === "static";
+}
+function Pn(e, r) {
+  return !Oe(e) || Ae(e).position === "fixed" ? null : r ? r(e) : e.offsetParent;
+}
+function vo(e, r) {
+  const t = ye(e);
+  if (Jr(e))
+    return t;
+  if (!Oe(e)) {
+    let o = qe(e);
+    for (; o && !gt(o); ) {
+      if (Te(o) && !Er(o))
+        return o;
+      o = qe(o);
+    }
+    return t;
+  }
+  let n = Pn(e, r);
+  for (; n && Hi(n) && Er(n); )
+    n = Pn(n, r);
+  return n && gt(n) && Er(n) && !Gr(n) ? t : n || Ui(e) || t;
+}
+const ra = async function(e) {
+  const r = this.getOffsetParent || vo, t = this.getDimensions, n = await t(e.floating);
+  return {
+    reference: ta(e.reference, await r(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function na(e) {
+  return Ae(e).direction === "rtl";
+}
+const oa = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Yi,
+  getDocumentElement: Le,
+  getClippingRect: Ji,
+  getOffsetParent: vo,
+  getElementRects: ra,
+  getClientRects: qi,
+  getDimensions: ea,
+  getScale: mt,
+  isElement: Te,
+  isRTL: na
+};
+function sa(e, r) {
+  let t = null, n;
+  const o = Le(e);
+  function s() {
+    var a;
+    clearTimeout(n), (a = t) == null || a.disconnect(), t = null;
+  }
+  function i(a, c) {
+    a === void 0 && (a = !1), c === void 0 && (c = 1), s();
+    const {
+      left: u,
+      top: f,
+      width: d,
+      height: g
+    } = e.getBoundingClientRect();
+    if (a || r(), !d || !g)
+      return;
+    const x = Nt(f), y = Nt(o.clientWidth - (u + d)), p = Nt(o.clientHeight - (f + g)), S = Nt(u), v = {
+      rootMargin: -x + "px " + -y + "px " + -p + "px " + -S + "px",
+      threshold: ge(0, Ke(1, c)) || 1
+    };
+    let C = !0;
+    function R(w) {
+      const A = w[0].intersectionRatio;
+      if (A !== c) {
+        if (!C)
+          return i();
+        A ? i(!1, A) : n = setTimeout(() => {
+          i(!1, 1e-7);
+        }, 1e3);
+      }
+      C = !1;
+    }
+    try {
+      t = new IntersectionObserver(R, {
+        ...v,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      t = new IntersectionObserver(R, v);
+    }
+    t.observe(e);
+  }
+  return i(!0), s;
+}
+function ia(e, r, t, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: s = !0,
+    elementResize: i = typeof ResizeObserver == "function",
+    layoutShift: a = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = n, u = Qr(e), f = o || s ? [...u ? _t(u) : [], ..._t(r)] : [];
+  f.forEach((b) => {
+    o && b.addEventListener("scroll", t, {
+      passive: !0
+    }), s && b.addEventListener("resize", t);
+  });
+  const d = u && a ? sa(u, t) : null;
+  let g = -1, x = null;
+  i && (x = new ResizeObserver((b) => {
+    let [v] = b;
+    v && v.target === u && x && (x.unobserve(r), cancelAnimationFrame(g), g = requestAnimationFrame(() => {
+      var C;
+      (C = x) == null || C.observe(r);
+    })), t();
+  }), u && !c && x.observe(u), x.observe(r));
+  let y, p = c ? et(e) : null;
+  c && S();
+  function S() {
+    const b = et(e);
+    p && (b.x !== p.x || b.y !== p.y || b.width !== p.width || b.height !== p.height) && t(), p = b, y = requestAnimationFrame(S);
+  }
+  return t(), () => {
+    var b;
+    f.forEach((v) => {
+      o && v.removeEventListener("scroll", t), s && v.removeEventListener("resize", t);
+    }), d == null || d(), (b = x) == null || b.disconnect(), x = null, c && cancelAnimationFrame(y);
+  };
+}
+const aa = Li, ca = ji, la = ki, ua = Wi, da = Ii, Tn = Mi, fa = Bi, ha = (e, r, t) => {
+  const n = /* @__PURE__ */ new Map(), o = {
+    platform: oa,
+    ...t
+  }, s = {
+    ...o.platform,
+    _c: n
+  };
+  return Di(e, r, {
+    ...o,
+    platform: s
+  });
+}, pa = (e) => {
+  function r(t) {
+    return {}.hasOwnProperty.call(t, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(t) {
+      const {
+        element: n,
+        padding: o
+      } = typeof e == "function" ? e(t) : e;
+      return n && r(n) ? n.current != null ? Tn({
+        element: n.current,
+        padding: o
+      }).fn(t) : {} : n ? Tn({
+        element: n,
+        padding: o
+      }).fn(t) : {};
+    }
+  };
+};
+var jt = typeof document < "u" ? Rs : Ps;
+function Zt(e, r) {
+  if (e === r)
+    return !0;
+  if (typeof e != typeof r)
+    return !1;
+  if (typeof e == "function" && e.toString() === r.toString())
+    return !0;
+  let t, n, o;
+  if (e && r && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (t = e.length, t !== r.length) return !1;
+      for (n = t; n-- !== 0; )
+        if (!Zt(e[n], r[n]))
+          return !1;
+      return !0;
+    }
+    if (o = Object.keys(e), t = o.length, t !== Object.keys(r).length)
+      return !1;
+    for (n = t; n-- !== 0; )
+      if (!{}.hasOwnProperty.call(r, o[n]))
+        return !1;
+    for (n = t; n-- !== 0; ) {
+      const s = o[n];
+      if (!(s === "_owner" && e.$$typeof) && !Zt(e[s], r[s]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && r !== r;
+}
+function go(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function On(e, r) {
+  const t = go(e);
+  return Math.round(r * t) / t;
+}
+function Fn(e) {
+  const r = h.useRef(e);
+  return jt(() => {
+    r.current = e;
+  }), r;
+}
+function ma(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: r = "bottom",
+    strategy: t = "absolute",
+    middleware: n = [],
+    platform: o,
+    elements: {
+      reference: s,
+      floating: i
+    } = {},
+    transform: a = !0,
+    whileElementsMounted: c,
+    open: u
+  } = e, [f, d] = h.useState({
+    x: 0,
+    y: 0,
+    strategy: t,
+    placement: r,
+    middlewareData: {},
+    isPositioned: !1
+  }), [g, x] = h.useState(n);
+  Zt(g, n) || x(n);
+  const [y, p] = h.useState(null), [S, b] = h.useState(null), v = h.useCallback((L) => {
+    L !== A.current && (A.current = L, p(L));
+  }, []), C = h.useCallback((L) => {
+    L !== _.current && (_.current = L, b(L));
+  }, []), R = s || y, w = i || S, A = h.useRef(null), _ = h.useRef(null), M = h.useRef(f), H = c != null, U = Fn(c), J = Fn(o), D = h.useCallback(() => {
+    if (!A.current || !_.current)
+      return;
+    const L = {
+      placement: r,
+      strategy: t,
+      middleware: g
+    };
+    J.current && (L.platform = J.current), ha(A.current, _.current, L).then((Z) => {
+      const ee = {
+        ...Z,
+        isPositioned: !0
+      };
+      I.current && !Zt(M.current, ee) && (M.current = ee, Hr.flushSync(() => {
+        d(ee);
+      }));
+    });
+  }, [g, r, t, J]);
+  jt(() => {
+    u === !1 && M.current.isPositioned && (M.current.isPositioned = !1, d((L) => ({
+      ...L,
+      isPositioned: !1
+    })));
+  }, [u]);
+  const I = h.useRef(!1);
+  jt(() => (I.current = !0, () => {
+    I.current = !1;
+  }), []), jt(() => {
+    if (R && (A.current = R), w && (_.current = w), R && w) {
+      if (U.current)
+        return U.current(R, w, D);
+      D();
+    }
+  }, [R, w, D, U, H]);
+  const B = h.useMemo(() => ({
+    reference: A,
+    floating: _,
+    setReference: v,
+    setFloating: C
+  }), [v, C]), V = h.useMemo(() => ({
+    reference: R,
+    floating: w
+  }), [R, w]), $ = h.useMemo(() => {
+    const L = {
+      position: t,
+      left: 0,
+      top: 0
+    };
+    if (!V.floating)
+      return L;
+    const Z = On(V.floating, f.x), ee = On(V.floating, f.y);
+    return a ? {
+      ...L,
+      transform: "translate(" + Z + "px, " + ee + "px)",
+      ...go(V.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: t,
+      left: Z,
+      top: ee
+    };
+  }, [t, a, V.floating, f.x, f.y]);
+  return h.useMemo(() => ({
+    ...f,
+    update: D,
+    refs: B,
+    elements: V,
+    floatingStyles: $
+  }), [f, D, B, V, $]);
+}
+var va = "Arrow", yo = h.forwardRef((e, r) => {
+  const { children: t, width: n = 10, height: o = 5, ...s } = e;
+  return /* @__PURE__ */ P.jsx(
+    oe.svg,
+    {
+      ...s,
+      ref: r,
+      width: n,
+      height: o,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: e.asChild ? t : /* @__PURE__ */ P.jsx("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+yo.displayName = va;
+var ga = yo;
+function ya(e) {
+  const [r, t] = h.useState(void 0);
+  return be(() => {
+    if (e) {
+      t({ width: e.offsetWidth, height: e.offsetHeight });
+      const n = new ResizeObserver((o) => {
+        if (!Array.isArray(o) || !o.length)
+          return;
+        const s = o[0];
+        let i, a;
+        if ("borderBoxSize" in s) {
+          const c = s.borderBoxSize, u = Array.isArray(c) ? c[0] : c;
+          i = u.inlineSize, a = u.blockSize;
+        } else
+          i = e.offsetWidth, a = e.offsetHeight;
+        t({ width: i, height: a });
+      });
+      return n.observe(e, { box: "border-box" }), () => n.unobserve(e);
+    } else
+      t(void 0);
+  }, [e]), r;
+}
+var en = "Popper", [wo, xo] = Br(en), [wa, bo] = wo(en), So = (e) => {
+  const { __scopePopper: r, children: t } = e, [n, o] = h.useState(null);
+  return /* @__PURE__ */ P.jsx(wa, { scope: r, anchor: n, onAnchorChange: o, children: t });
+};
+So.displayName = en;
+var Eo = "PopperAnchor", Co = h.forwardRef(
+  (e, r) => {
+    const { __scopePopper: t, virtualRef: n, ...o } = e, s = bo(Eo, t), i = h.useRef(null), a = le(r, i);
+    return h.useEffect(() => {
+      s.onAnchorChange((n == null ? void 0 : n.current) || i.current);
+    }), n ? null : /* @__PURE__ */ P.jsx(oe.div, { ...o, ref: a });
+  }
+);
+Co.displayName = Eo;
+var tn = "PopperContent", [xa, ba] = wo(tn), Ao = h.forwardRef(
+  (e, r) => {
+    var W, q, se, X, z, K;
+    const {
+      __scopePopper: t,
+      side: n = "bottom",
+      sideOffset: o = 0,
+      align: s = "center",
+      alignOffset: i = 0,
+      arrowPadding: a = 0,
+      avoidCollisions: c = !0,
+      collisionBoundary: u = [],
+      collisionPadding: f = 0,
+      sticky: d = "partial",
+      hideWhenDetached: g = !1,
+      updatePositionStrategy: x = "optimized",
+      onPlaced: y,
+      ...p
+    } = e, S = bo(tn, t), [b, v] = h.useState(null), C = le(r, (ue) => v(ue)), [R, w] = h.useState(null), A = ya(R), _ = (A == null ? void 0 : A.width) ?? 0, M = (A == null ? void 0 : A.height) ?? 0, H = n + (s !== "center" ? "-" + s : ""), U = typeof f == "number" ? f : { top: 0, right: 0, bottom: 0, left: 0, ...f }, J = Array.isArray(u) ? u : [u], D = J.length > 0, I = {
+      padding: U,
+      boundary: J.filter(Ea),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: D
+    }, { refs: B, floatingStyles: V, placement: $, isPositioned: L, middlewareData: Z } = ma({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: H,
+      whileElementsMounted: (...ue) => ia(...ue, {
+        animationFrame: x === "always"
+      }),
+      elements: {
+        reference: S.anchor
+      },
+      middleware: [
+        aa({ mainAxis: o + M, alignmentAxis: i }),
+        c && ca({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: d === "partial" ? fa() : void 0,
+          ...I
+        }),
+        c && la({ ...I }),
+        ua({
+          ...I,
+          apply: ({ elements: ue, rects: me, availableWidth: rt, availableHeight: nt }) => {
+            const { width: ot, height: l } = me.reference, m = ue.floating.style;
+            m.setProperty("--radix-popper-available-width", `${rt}px`), m.setProperty("--radix-popper-available-height", `${nt}px`), m.setProperty("--radix-popper-anchor-width", `${ot}px`), m.setProperty("--radix-popper-anchor-height", `${l}px`);
+          }
+        }),
+        R && pa({ element: R, padding: a }),
+        Ca({ arrowWidth: _, arrowHeight: M }),
+        g && da({ strategy: "referenceHidden", ...I })
+      ]
+    }), [ee, Se] = Po($), we = Je(y);
+    be(() => {
+      L && (we == null || we());
+    }, [L, we]);
+    const je = (W = Z.arrow) == null ? void 0 : W.x, Ze = (q = Z.arrow) == null ? void 0 : q.y, Ee = ((se = Z.arrow) == null ? void 0 : se.centerOffset) !== 0, [Be, Ce] = h.useState();
+    return be(() => {
+      b && Ce(window.getComputedStyle(b).zIndex);
+    }, [b]), /* @__PURE__ */ P.jsx(
+      "div",
+      {
+        ref: B.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...V,
+          transform: L ? V.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: Be,
+          "--radix-popper-transform-origin": [
+            (X = Z.transformOrigin) == null ? void 0 : X.x,
+            (z = Z.transformOrigin) == null ? void 0 : z.y
+          ].join(" "),
+          // hide the content if using the hide middleware and should be hidden
+          // set visibility to hidden and disable pointer events so the UI behaves
+          // as if the PopperContent isn't there at all
+          ...((K = Z.hide) == null ? void 0 : K.referenceHidden) && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        },
+        dir: e.dir,
+        children: /* @__PURE__ */ P.jsx(
+          xa,
+          {
+            scope: t,
+            placedSide: ee,
+            onArrowChange: w,
+            arrowX: je,
+            arrowY: Ze,
+            shouldHideArrow: Ee,
+            children: /* @__PURE__ */ P.jsx(
+              oe.div,
+              {
+                "data-side": ee,
+                "data-align": Se,
+                ...p,
+                ref: C,
+                style: {
+                  ...p.style,
+                  // if the PopperContent hasn't been placed yet (not all measurements done)
+                  // we prevent animations so that users's animation don't kick in too early referring wrong sides
+                  animation: L ? void 0 : "none"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Ao.displayName = tn;
+var _o = "PopperArrow", Sa = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, Ro = h.forwardRef(function(r, t) {
+  const { __scopePopper: n, ...o } = r, s = ba(_o, n), i = Sa[s.placedSide];
+  return (
+    // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)
+    // doesn't report size as we'd expect on SVG elements.
+    // it reports their bounding box which is effectively the largest path inside the SVG.
+    /* @__PURE__ */ P.jsx(
+      "span",
+      {
+        ref: s.onArrowChange,
+        style: {
+          position: "absolute",
+          left: s.arrowX,
+          top: s.arrowY,
+          [i]: 0,
+          transformOrigin: {
+            top: "",
+            right: "0 0",
+            bottom: "center 0",
+            left: "100% 0"
+          }[s.placedSide],
+          transform: {
+            top: "translateY(100%)",
+            right: "translateY(50%) rotate(90deg) translateX(-50%)",
+            bottom: "rotate(180deg)",
+            left: "translateY(50%) rotate(-90deg) translateX(50%)"
+          }[s.placedSide],
+          visibility: s.shouldHideArrow ? "hidden" : void 0
+        },
+        children: /* @__PURE__ */ P.jsx(
+          ga,
+          {
+            ...o,
+            ref: t,
+            style: {
+              ...o.style,
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            }
+          }
+        )
+      }
+    )
+  );
+});
+Ro.displayName = _o;
+function Ea(e) {
+  return e !== null;
+}
+var Ca = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(r) {
+    var S, b, v;
+    const { placement: t, rects: n, middlewareData: o } = r, i = ((S = o.arrow) == null ? void 0 : S.centerOffset) !== 0, a = i ? 0 : e.arrowWidth, c = i ? 0 : e.arrowHeight, [u, f] = Po(t), d = { start: "0%", center: "50%", end: "100%" }[f], g = (((b = o.arrow) == null ? void 0 : b.x) ?? 0) + a / 2, x = (((v = o.arrow) == null ? void 0 : v.y) ?? 0) + c / 2;
+    let y = "", p = "";
+    return u === "bottom" ? (y = i ? d : `${g}px`, p = `${-c}px`) : u === "top" ? (y = i ? d : `${g}px`, p = `${n.floating.height + c}px`) : u === "right" ? (y = `${-c}px`, p = i ? d : `${x}px`) : u === "left" && (y = `${n.floating.width + c}px`, p = i ? d : `${x}px`), { data: { x: y, y: p } };
+  }
+});
+function Po(e) {
+  const [r, t = "center"] = e.split("-");
+  return [r, t];
+}
+var Aa = So, _a = Co, Ra = Ao, Pa = Ro, Ta = "Portal", To = h.forwardRef((e, r) => {
+  var a;
+  const { container: t, ...n } = e, [o, s] = h.useState(!1);
+  be(() => s(!0), []);
+  const i = t || o && ((a = globalThis == null ? void 0 : globalThis.document) == null ? void 0 : a.body);
+  return i ? js.createPortal(/* @__PURE__ */ P.jsx(oe.div, { ...n, ref: r }), i) : null;
+});
+To.displayName = Ta;
+function Oa(e) {
+  const r = h.useRef({ value: e, previous: e });
+  return h.useMemo(() => (r.current.value !== e && (r.current.previous = r.current.value, r.current.value = e), r.current.previous), [e]);
+}
+var Fa = "VisuallyHidden", Oo = h.forwardRef(
+  (e, r) => /* @__PURE__ */ P.jsx(
+    oe.span,
+    {
+      ...e,
+      ref: r,
+      style: {
+        // See: https://github.com/twbs/bootstrap/blob/master/scss/mixins/_screen-reader.scss
+        position: "absolute",
+        border: 0,
+        width: 1,
+        height: 1,
+        padding: 0,
+        margin: -1,
+        overflow: "hidden",
+        clip: "rect(0, 0, 0, 0)",
+        whiteSpace: "nowrap",
+        wordWrap: "normal",
+        ...e.style
+      }
+    }
+  )
+);
+Oo.displayName = Fa;
+var Na = function(e) {
+  if (typeof document > "u")
+    return null;
+  var r = Array.isArray(e) ? e[0] : e;
+  return r.ownerDocument.body;
+}, ut = /* @__PURE__ */ new WeakMap(), Dt = /* @__PURE__ */ new WeakMap(), Mt = {}, Cr = 0, Fo = function(e) {
+  return e && (e.host || Fo(e.parentNode));
+}, Da = function(e, r) {
+  return r.map(function(t) {
+    if (e.contains(t))
+      return t;
+    var n = Fo(t);
+    return n && e.contains(n) ? n : (console.error("aria-hidden", t, "in not contained inside", e, ". Doing nothing"), null);
+  }).filter(function(t) {
+    return !!t;
+  });
+}, Ma = function(e, r, t, n) {
+  var o = Da(r, Array.isArray(e) ? e : [e]);
+  Mt[t] || (Mt[t] = /* @__PURE__ */ new WeakMap());
+  var s = Mt[t], i = [], a = /* @__PURE__ */ new Set(), c = new Set(o), u = function(d) {
+    !d || a.has(d) || (a.add(d), u(d.parentNode));
+  };
+  o.forEach(u);
+  var f = function(d) {
+    !d || c.has(d) || Array.prototype.forEach.call(d.children, function(g) {
+      if (a.has(g))
+        f(g);
+      else
+        try {
+          var x = g.getAttribute(n), y = x !== null && x !== "false", p = (ut.get(g) || 0) + 1, S = (s.get(g) || 0) + 1;
+          ut.set(g, p), s.set(g, S), i.push(g), p === 1 && y && Dt.set(g, !0), S === 1 && g.setAttribute(t, "true"), y || g.setAttribute(n, "true");
+        } catch (b) {
+          console.error("aria-hidden: cannot operate on ", g, b);
+        }
+    });
+  };
+  return f(r), a.clear(), Cr++, function() {
+    i.forEach(function(d) {
+      var g = ut.get(d) - 1, x = s.get(d) - 1;
+      ut.set(d, g), s.set(d, x), g || (Dt.has(d) || d.removeAttribute(n), Dt.delete(d)), x || d.removeAttribute(t);
+    }), Cr--, Cr || (ut = /* @__PURE__ */ new WeakMap(), ut = /* @__PURE__ */ new WeakMap(), Dt = /* @__PURE__ */ new WeakMap(), Mt = {});
+  };
+}, ka = function(e, r, t) {
+  t === void 0 && (t = "data-aria-hidden");
+  var n = Array.from(Array.isArray(e) ? e : [e]), o = Na(e);
+  return o ? (n.push.apply(n, Array.from(o.querySelectorAll("[aria-live]"))), Ma(n, o, t, "aria-hidden")) : function() {
+    return null;
+  };
+}, Re = function() {
+  return Re = Object.assign || function(r) {
+    for (var t, n = 1, o = arguments.length; n < o; n++) {
+      t = arguments[n];
+      for (var s in t) Object.prototype.hasOwnProperty.call(t, s) && (r[s] = t[s]);
+    }
+    return r;
+  }, Re.apply(this, arguments);
+};
+function No(e, r) {
+  var t = {};
+  for (var n in e) Object.prototype.hasOwnProperty.call(e, n) && r.indexOf(n) < 0 && (t[n] = e[n]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var o = 0, n = Object.getOwnPropertySymbols(e); o < n.length; o++)
+      r.indexOf(n[o]) < 0 && Object.prototype.propertyIsEnumerable.call(e, n[o]) && (t[n[o]] = e[n[o]]);
+  return t;
+}
+function Ia(e, r, t) {
+  if (t || arguments.length === 2) for (var n = 0, o = r.length, s; n < o; n++)
+    (s || !(n in r)) && (s || (s = Array.prototype.slice.call(r, 0, n)), s[n] = r[n]);
+  return e.concat(s || Array.prototype.slice.call(r));
+}
+var Bt = "right-scroll-bar-position", Wt = "width-before-scroll-bar", Va = "with-scroll-bars-hidden", La = "--removed-body-scroll-bar-size";
+function Ar(e, r) {
+  return typeof e == "function" ? e(r) : e && (e.current = r), e;
+}
+function ja(e, r) {
+  var t = Ts(function() {
+    return {
+      // value
+      value: e,
+      // last callback
+      callback: r,
+      // "memoized" public interface
+      facade: {
+        get current() {
+          return t.value;
+        },
+        set current(n) {
+          var o = t.value;
+          o !== n && (t.value = n, t.callback(n, o));
+        }
+      }
+    };
+  })[0];
+  return t.callback = r, t.facade;
+}
+var Ba = typeof window < "u" ? h.useLayoutEffect : h.useEffect, Nn = /* @__PURE__ */ new WeakMap();
+function Wa(e, r) {
+  var t = ja(null, function(n) {
+    return e.forEach(function(o) {
+      return Ar(o, n);
+    });
+  });
+  return Ba(function() {
+    var n = Nn.get(t);
+    if (n) {
+      var o = new Set(n), s = new Set(e), i = t.current;
+      o.forEach(function(a) {
+        s.has(a) || Ar(a, null);
+      }), s.forEach(function(a) {
+        o.has(a) || Ar(a, i);
+      });
+    }
+    Nn.set(t, e);
+  }, [e]), t;
+}
+function Ha(e) {
+  return e;
+}
+function Ua(e, r) {
+  r === void 0 && (r = Ha);
+  var t = [], n = !1, o = {
+    read: function() {
+      if (n)
+        throw new Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.");
+      return t.length ? t[t.length - 1] : e;
+    },
+    useMedium: function(s) {
+      var i = r(s, n);
+      return t.push(i), function() {
+        t = t.filter(function(a) {
+          return a !== i;
+        });
+      };
+    },
+    assignSyncMedium: function(s) {
+      for (n = !0; t.length; ) {
+        var i = t;
+        t = [], i.forEach(s);
+      }
+      t = {
+        push: function(a) {
+          return s(a);
+        },
+        filter: function() {
+          return t;
+        }
+      };
+    },
+    assignMedium: function(s) {
+      n = !0;
+      var i = [];
+      if (t.length) {
+        var a = t;
+        t = [], a.forEach(s), i = t;
+      }
+      var c = function() {
+        var f = i;
+        i = [], f.forEach(s);
+      }, u = function() {
+        return Promise.resolve().then(c);
+      };
+      u(), t = {
+        push: function(f) {
+          i.push(f), u();
+        },
+        filter: function(f) {
+          return i = i.filter(f), t;
+        }
+      };
+    }
+  };
+  return o;
+}
+function $a(e) {
+  e === void 0 && (e = {});
+  var r = Ua(null);
+  return r.options = Re({ async: !0, ssr: !1 }, e), r;
+}
+var Do = function(e) {
+  var r = e.sideCar, t = No(e, ["sideCar"]);
+  if (!r)
+    throw new Error("Sidecar: please provide `sideCar` property to import the right car");
+  var n = r.read();
+  if (!n)
+    throw new Error("Sidecar medium not found");
+  return h.createElement(n, Re({}, t));
+};
+Do.isSideCarExport = !0;
+function za(e, r) {
+  return e.useMedium(r), Do;
+}
+var Mo = $a(), _r = function() {
+}, rr = h.forwardRef(function(e, r) {
+  var t = h.useRef(null), n = h.useState({
+    onScrollCapture: _r,
+    onWheelCapture: _r,
+    onTouchMoveCapture: _r
+  }), o = n[0], s = n[1], i = e.forwardProps, a = e.children, c = e.className, u = e.removeScrollBar, f = e.enabled, d = e.shards, g = e.sideCar, x = e.noIsolation, y = e.inert, p = e.allowPinchZoom, S = e.as, b = S === void 0 ? "div" : S, v = e.gapMode, C = No(e, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]), R = g, w = Wa([t, r]), A = Re(Re({}, C), o);
+  return h.createElement(
+    h.Fragment,
+    null,
+    f && h.createElement(R, { sideCar: Mo, removeScrollBar: u, shards: d, noIsolation: x, inert: y, setCallbacks: s, allowPinchZoom: !!p, lockRef: t, gapMode: v }),
+    i ? h.cloneElement(h.Children.only(a), Re(Re({}, A), { ref: w })) : h.createElement(b, Re({}, A, { className: c, ref: w }), a)
+  );
+});
+rr.defaultProps = {
+  enabled: !0,
+  removeScrollBar: !0,
+  inert: !1
+};
+rr.classNames = {
+  fullWidth: Wt,
+  zeroRight: Bt
+};
+var Ka = function() {
+  if (typeof __webpack_nonce__ < "u")
+    return __webpack_nonce__;
+};
+function Ya() {
+  if (!document)
+    return null;
+  var e = document.createElement("style");
+  e.type = "text/css";
+  var r = Ka();
+  return r && e.setAttribute("nonce", r), e;
+}
+function qa(e, r) {
+  e.styleSheet ? e.styleSheet.cssText = r : e.appendChild(document.createTextNode(r));
+}
+function Xa(e) {
+  var r = document.head || document.getElementsByTagName("head")[0];
+  r.appendChild(e);
+}
+var Ga = function() {
+  var e = 0, r = null;
+  return {
+    add: function(t) {
+      e == 0 && (r = Ya()) && (qa(r, t), Xa(r)), e++;
+    },
+    remove: function() {
+      e--, !e && r && (r.parentNode && r.parentNode.removeChild(r), r = null);
+    }
+  };
+}, Za = function() {
+  var e = Ga();
+  return function(r, t) {
+    h.useEffect(function() {
+      return e.add(r), function() {
+        e.remove();
+      };
+    }, [r && t]);
+  };
+}, ko = function() {
+  var e = Za(), r = function(t) {
+    var n = t.styles, o = t.dynamic;
+    return e(n, o), null;
+  };
+  return r;
+}, Qa = {
+  left: 0,
+  top: 0,
+  right: 0,
+  gap: 0
+}, Rr = function(e) {
+  return parseInt(e || "", 10) || 0;
+}, Ja = function(e) {
+  var r = window.getComputedStyle(document.body), t = r[e === "padding" ? "paddingLeft" : "marginLeft"], n = r[e === "padding" ? "paddingTop" : "marginTop"], o = r[e === "padding" ? "paddingRight" : "marginRight"];
+  return [Rr(t), Rr(n), Rr(o)];
+}, ec = function(e) {
+  if (e === void 0 && (e = "margin"), typeof window > "u")
+    return Qa;
+  var r = Ja(e), t = document.documentElement.clientWidth, n = window.innerWidth;
+  return {
+    left: r[0],
+    top: r[1],
+    right: r[2],
+    gap: Math.max(0, n - t + r[2] - r[0])
+  };
+}, tc = ko(), vt = "data-scroll-locked", rc = function(e, r, t, n) {
+  var o = e.left, s = e.top, i = e.right, a = e.gap;
+  return t === void 0 && (t = "margin"), `
+  .`.concat(Va, ` {
+   overflow: hidden `).concat(n, `;
+   padding-right: `).concat(a, "px ").concat(n, `;
+  }
+  body[`).concat(vt, `] {
+    overflow: hidden `).concat(n, `;
+    overscroll-behavior: contain;
+    `).concat([
+    r && "position: relative ".concat(n, ";"),
+    t === "margin" && `
+    padding-left: `.concat(o, `px;
+    padding-top: `).concat(s, `px;
+    padding-right: `).concat(i, `px;
+    margin-left:0;
+    margin-top:0;
+    margin-right: `).concat(a, "px ").concat(n, `;
+    `),
+    t === "padding" && "padding-right: ".concat(a, "px ").concat(n, ";")
+  ].filter(Boolean).join(""), `
+  }
+  
+  .`).concat(Bt, ` {
+    right: `).concat(a, "px ").concat(n, `;
+  }
+  
+  .`).concat(Wt, ` {
+    margin-right: `).concat(a, "px ").concat(n, `;
+  }
+  
+  .`).concat(Bt, " .").concat(Bt, ` {
+    right: 0 `).concat(n, `;
+  }
+  
+  .`).concat(Wt, " .").concat(Wt, ` {
+    margin-right: 0 `).concat(n, `;
+  }
+  
+  body[`).concat(vt, `] {
+    `).concat(La, ": ").concat(a, `px;
+  }
+`);
+}, Dn = function() {
+  var e = parseInt(document.body.getAttribute(vt) || "0", 10);
+  return isFinite(e) ? e : 0;
+}, nc = function() {
+  h.useEffect(function() {
+    return document.body.setAttribute(vt, (Dn() + 1).toString()), function() {
+      var e = Dn() - 1;
+      e <= 0 ? document.body.removeAttribute(vt) : document.body.setAttribute(vt, e.toString());
+    };
+  }, []);
+}, oc = function(e) {
+  var r = e.noRelative, t = e.noImportant, n = e.gapMode, o = n === void 0 ? "margin" : n;
+  nc();
+  var s = h.useMemo(function() {
+    return ec(o);
+  }, [o]);
+  return h.createElement(tc, { styles: rc(s, !r, o, t ? "" : "!important") });
+}, Mr = !1;
+if (typeof window < "u")
+  try {
+    var kt = Object.defineProperty({}, "passive", {
+      get: function() {
+        return Mr = !0, !0;
+      }
+    });
+    window.addEventListener("test", kt, kt), window.removeEventListener("test", kt, kt);
+  } catch {
+    Mr = !1;
+  }
+var dt = Mr ? { passive: !1 } : !1, sc = function(e) {
+  return e.tagName === "TEXTAREA";
+}, Io = function(e, r) {
+  var t = window.getComputedStyle(e);
+  return (
+    // not-not-scrollable
+    t[r] !== "hidden" && // contains scroll inside self
+    !(t.overflowY === t.overflowX && !sc(e) && t[r] === "visible")
+  );
+}, ic = function(e) {
+  return Io(e, "overflowY");
+}, ac = function(e) {
+  return Io(e, "overflowX");
+}, Mn = function(e, r) {
+  var t = r.ownerDocument, n = r;
+  do {
+    typeof ShadowRoot < "u" && n instanceof ShadowRoot && (n = n.host);
+    var o = Vo(e, n);
+    if (o) {
+      var s = Lo(e, n), i = s[1], a = s[2];
+      if (i > a)
+        return !0;
+    }
+    n = n.parentNode;
+  } while (n && n !== t.body);
+  return !1;
+}, cc = function(e) {
+  var r = e.scrollTop, t = e.scrollHeight, n = e.clientHeight;
+  return [
+    r,
+    t,
+    n
+  ];
+}, lc = function(e) {
+  var r = e.scrollLeft, t = e.scrollWidth, n = e.clientWidth;
+  return [
+    r,
+    t,
+    n
+  ];
+}, Vo = function(e, r) {
+  return e === "v" ? ic(r) : ac(r);
+}, Lo = function(e, r) {
+  return e === "v" ? cc(r) : lc(r);
+}, uc = function(e, r) {
+  return e === "h" && r === "rtl" ? -1 : 1;
+}, dc = function(e, r, t, n, o) {
+  var s = uc(e, window.getComputedStyle(r).direction), i = s * n, a = t.target, c = r.contains(a), u = !1, f = i > 0, d = 0, g = 0;
+  do {
+    var x = Lo(e, a), y = x[0], p = x[1], S = x[2], b = p - S - s * y;
+    (y || b) && Vo(e, a) && (d += b, g += y), a instanceof ShadowRoot ? a = a.host : a = a.parentNode;
+  } while (
+    // portaled content
+    !c && a !== document.body || // self content
+    c && (r.contains(a) || r === a)
+  );
+  return (f && (Math.abs(d) < 1 || !o) || !f && (Math.abs(g) < 1 || !o)) && (u = !0), u;
+}, It = function(e) {
+  return "changedTouches" in e ? [e.changedTouches[0].clientX, e.changedTouches[0].clientY] : [0, 0];
+}, kn = function(e) {
+  return [e.deltaX, e.deltaY];
+}, In = function(e) {
+  return e && "current" in e ? e.current : e;
+}, fc = function(e, r) {
+  return e[0] === r[0] && e[1] === r[1];
+}, hc = function(e) {
+  return `
+  .block-interactivity-`.concat(e, ` {pointer-events: none;}
+  .allow-interactivity-`).concat(e, ` {pointer-events: all;}
+`);
+}, pc = 0, ft = [];
+function mc(e) {
+  var r = h.useRef([]), t = h.useRef([0, 0]), n = h.useRef(), o = h.useState(pc++)[0], s = h.useState(ko)[0], i = h.useRef(e);
+  h.useEffect(function() {
+    i.current = e;
+  }, [e]), h.useEffect(function() {
+    if (e.inert) {
+      document.body.classList.add("block-interactivity-".concat(o));
+      var p = Ia([e.lockRef.current], (e.shards || []).map(In), !0).filter(Boolean);
+      return p.forEach(function(S) {
+        return S.classList.add("allow-interactivity-".concat(o));
+      }), function() {
+        document.body.classList.remove("block-interactivity-".concat(o)), p.forEach(function(S) {
+          return S.classList.remove("allow-interactivity-".concat(o));
+        });
+      };
+    }
+  }, [e.inert, e.lockRef.current, e.shards]);
+  var a = h.useCallback(function(p, S) {
+    if ("touches" in p && p.touches.length === 2)
+      return !i.current.allowPinchZoom;
+    var b = It(p), v = t.current, C = "deltaX" in p ? p.deltaX : v[0] - b[0], R = "deltaY" in p ? p.deltaY : v[1] - b[1], w, A = p.target, _ = Math.abs(C) > Math.abs(R) ? "h" : "v";
+    if ("touches" in p && _ === "h" && A.type === "range")
+      return !1;
+    var M = Mn(_, A);
+    if (!M)
+      return !0;
+    if (M ? w = _ : (w = _ === "v" ? "h" : "v", M = Mn(_, A)), !M)
+      return !1;
+    if (!n.current && "changedTouches" in p && (C || R) && (n.current = w), !w)
+      return !0;
+    var H = n.current || w;
+    return dc(H, S, p, H === "h" ? C : R, !0);
+  }, []), c = h.useCallback(function(p) {
+    var S = p;
+    if (!(!ft.length || ft[ft.length - 1] !== s)) {
+      var b = "deltaY" in S ? kn(S) : It(S), v = r.current.filter(function(w) {
+        return w.name === S.type && (w.target === S.target || S.target === w.shadowParent) && fc(w.delta, b);
+      })[0];
+      if (v && v.should) {
+        S.cancelable && S.preventDefault();
+        return;
+      }
+      if (!v) {
+        var C = (i.current.shards || []).map(In).filter(Boolean).filter(function(w) {
+          return w.contains(S.target);
+        }), R = C.length > 0 ? a(S, C[0]) : !i.current.noIsolation;
+        R && S.cancelable && S.preventDefault();
+      }
+    }
+  }, []), u = h.useCallback(function(p, S, b, v) {
+    var C = { name: p, delta: S, target: b, should: v, shadowParent: vc(b) };
+    r.current.push(C), setTimeout(function() {
+      r.current = r.current.filter(function(R) {
+        return R !== C;
+      });
+    }, 1);
+  }, []), f = h.useCallback(function(p) {
+    t.current = It(p), n.current = void 0;
+  }, []), d = h.useCallback(function(p) {
+    u(p.type, kn(p), p.target, a(p, e.lockRef.current));
+  }, []), g = h.useCallback(function(p) {
+    u(p.type, It(p), p.target, a(p, e.lockRef.current));
+  }, []);
+  h.useEffect(function() {
+    return ft.push(s), e.setCallbacks({
+      onScrollCapture: d,
+      onWheelCapture: d,
+      onTouchMoveCapture: g
+    }), document.addEventListener("wheel", c, dt), document.addEventListener("touchmove", c, dt), document.addEventListener("touchstart", f, dt), function() {
+      ft = ft.filter(function(p) {
+        return p !== s;
+      }), document.removeEventListener("wheel", c, dt), document.removeEventListener("touchmove", c, dt), document.removeEventListener("touchstart", f, dt);
+    };
+  }, []);
+  var x = e.removeScrollBar, y = e.inert;
+  return h.createElement(
+    h.Fragment,
+    null,
+    y ? h.createElement(s, { styles: hc(o) }) : null,
+    x ? h.createElement(oc, { gapMode: e.gapMode }) : null
+  );
+}
+function vc(e) {
+  for (var r = null; e !== null; )
+    e instanceof ShadowRoot && (r = e.host, e = e.host), e = e.parentNode;
+  return r;
+}
+const gc = za(Mo, mc);
+var jo = h.forwardRef(function(e, r) {
+  return h.createElement(rr, Re({}, e, { ref: r, sideCar: gc }));
+});
+jo.classNames = rr.classNames;
+var yc = [" ", "Enter", "ArrowUp", "ArrowDown"], wc = [" ", "Enter"], Ot = "Select", [nr, or, xc] = ii(Ot), [bt, ll] = Br(Ot, [
+  xc,
+  xo
+]), sr = xo(), [bc, Xe] = bt(Ot), [Sc, Ec] = bt(Ot), Bo = (e) => {
+  const {
+    __scopeSelect: r,
+    children: t,
+    open: n,
+    defaultOpen: o,
+    onOpenChange: s,
+    value: i,
+    defaultValue: a,
+    onValueChange: c,
+    dir: u,
+    name: f,
+    autoComplete: d,
+    disabled: g,
+    required: x
+  } = e, y = sr(r), [p, S] = h.useState(null), [b, v] = h.useState(null), [C, R] = h.useState(!1), w = ci(u), [A = !1, _] = an({
+    prop: n,
+    defaultProp: o,
+    onChange: s
+  }), [M, H] = an({
+    prop: i,
+    defaultProp: a,
+    onChange: c
+  }), U = h.useRef(null), J = p ? !!p.closest("form") : !0, [D, I] = h.useState(/* @__PURE__ */ new Set()), B = Array.from(D).map((V) => V.props.value).join(";");
+  return /* @__PURE__ */ P.jsx(Aa, { ...y, children: /* @__PURE__ */ P.jsxs(
+    bc,
+    {
+      required: x,
+      scope: r,
+      trigger: p,
+      onTriggerChange: S,
+      valueNode: b,
+      onValueNodeChange: v,
+      valueNodeHasChildren: C,
+      onValueNodeHasChildrenChange: R,
+      contentId: Wr(),
+      value: M,
+      onValueChange: H,
+      open: A,
+      onOpenChange: _,
+      dir: w,
+      triggerPointerDownPosRef: U,
+      disabled: g,
+      children: [
+        /* @__PURE__ */ P.jsx(nr.Provider, { scope: r, children: /* @__PURE__ */ P.jsx(
+          Sc,
+          {
+            scope: e.__scopeSelect,
+            onNativeOptionAdd: h.useCallback((V) => {
+              I(($) => new Set($).add(V));
+            }, []),
+            onNativeOptionRemove: h.useCallback((V) => {
+              I(($) => {
+                const L = new Set($);
+                return L.delete(V), L;
+              });
+            }, []),
+            children: t
+          }
+        ) }),
+        J ? /* @__PURE__ */ P.jsxs(
+          fs,
+          {
+            "aria-hidden": !0,
+            required: x,
+            tabIndex: -1,
+            name: f,
+            autoComplete: d,
+            value: M,
+            onChange: (V) => H(V.target.value),
+            disabled: g,
+            children: [
+              M === void 0 ? /* @__PURE__ */ P.jsx("option", { value: "" }) : null,
+              Array.from(D)
+            ]
+          },
+          B
+        ) : null
+      ]
+    }
+  ) });
+};
+Bo.displayName = Ot;
+var Wo = "SelectTrigger", Ho = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, disabled: n = !1, ...o } = e, s = sr(t), i = Xe(Wo, t), a = i.disabled || n, c = le(r, i.onTriggerChange), u = or(t), [f, d, g] = hs((y) => {
+      const p = u().filter((v) => !v.disabled), S = p.find((v) => v.value === i.value), b = ps(p, y, S);
+      b !== void 0 && i.onValueChange(b.value);
+    }), x = () => {
+      a || (i.onOpenChange(!0), g());
+    };
+    return /* @__PURE__ */ P.jsx(_a, { asChild: !0, ...s, children: /* @__PURE__ */ P.jsx(
+      oe.button,
+      {
+        type: "button",
+        role: "combobox",
+        "aria-controls": i.contentId,
+        "aria-expanded": i.open,
+        "aria-required": i.required,
+        "aria-autocomplete": "none",
+        dir: i.dir,
+        "data-state": i.open ? "open" : "closed",
+        disabled: a,
+        "data-disabled": a ? "" : void 0,
+        "data-placeholder": ds(i.value) ? "" : void 0,
+        ...o,
+        ref: c,
+        onClick: ce(o.onClick, (y) => {
+          y.currentTarget.focus();
+        }),
+        onPointerDown: ce(o.onPointerDown, (y) => {
+          const p = y.target;
+          p.hasPointerCapture(y.pointerId) && p.releasePointerCapture(y.pointerId), y.button === 0 && y.ctrlKey === !1 && (x(), i.triggerPointerDownPosRef.current = {
+            x: Math.round(y.pageX),
+            y: Math.round(y.pageY)
+          }, y.preventDefault());
+        }),
+        onKeyDown: ce(o.onKeyDown, (y) => {
+          const p = f.current !== "";
+          !(y.ctrlKey || y.altKey || y.metaKey) && y.key.length === 1 && d(y.key), !(p && y.key === " ") && yc.includes(y.key) && (x(), y.preventDefault());
+        })
+      }
+    ) });
+  }
+);
+Ho.displayName = Wo;
+var Uo = "SelectValue", $o = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, className: n, style: o, children: s, placeholder: i = "", ...a } = e, c = Xe(Uo, t), { onValueNodeHasChildrenChange: u } = c, f = s !== void 0, d = le(r, c.onValueNodeChange);
+    return be(() => {
+      u(f);
+    }, [u, f]), /* @__PURE__ */ P.jsx(
+      oe.span,
+      {
+        ...a,
+        ref: d,
+        style: { pointerEvents: "none" },
+        children: ds(c.value) ? /* @__PURE__ */ P.jsx(P.Fragment, { children: i }) : s
+      }
+    );
+  }
+);
+$o.displayName = Uo;
+var Cc = "SelectIcon", zo = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, children: n, ...o } = e;
+    return /* @__PURE__ */ P.jsx(oe.span, { "aria-hidden": !0, ...o, ref: r, children: n || "▼" });
+  }
+);
+zo.displayName = Cc;
+var Ac = "SelectPortal", Ko = (e) => /* @__PURE__ */ P.jsx(To, { asChild: !0, ...e });
+Ko.displayName = Ac;
+var tt = "SelectContent", Yo = h.forwardRef(
+  (e, r) => {
+    const t = Xe(tt, e.__scopeSelect), [n, o] = h.useState();
+    if (be(() => {
+      o(new DocumentFragment());
+    }, []), !t.open) {
+      const s = n;
+      return s ? Hr.createPortal(
+        /* @__PURE__ */ P.jsx(qo, { scope: e.__scopeSelect, children: /* @__PURE__ */ P.jsx(nr.Slot, { scope: e.__scopeSelect, children: /* @__PURE__ */ P.jsx("div", { children: e.children }) }) }),
+        s
+      ) : null;
+    }
+    return /* @__PURE__ */ P.jsx(Xo, { ...e, ref: r });
+  }
+);
+Yo.displayName = tt;
+var Ne = 10, [qo, Ge] = bt(tt), _c = "SelectContentImpl", Xo = h.forwardRef(
+  (e, r) => {
+    const {
+      __scopeSelect: t,
+      position: n = "item-aligned",
+      onCloseAutoFocus: o,
+      onEscapeKeyDown: s,
+      onPointerDownOutside: i,
+      //
+      // PopperContent props
+      side: a,
+      sideOffset: c,
+      align: u,
+      alignOffset: f,
+      arrowPadding: d,
+      collisionBoundary: g,
+      collisionPadding: x,
+      sticky: y,
+      hideWhenDetached: p,
+      avoidCollisions: S,
+      //
+      ...b
+    } = e, v = Xe(tt, t), [C, R] = h.useState(null), [w, A] = h.useState(null), _ = le(r, (W) => R(W)), [M, H] = h.useState(null), [U, J] = h.useState(
+      null
+    ), D = or(t), [I, B] = h.useState(!1), V = h.useRef(!1);
+    h.useEffect(() => {
+      if (C) return ka(C);
+    }, [C]), gi();
+    const $ = h.useCallback(
+      (W) => {
+        const [q, ...se] = D().map((K) => K.ref.current), [X] = se.slice(-1), z = document.activeElement;
+        for (const K of W)
+          if (K === z || (K == null || K.scrollIntoView({ block: "nearest" }), K === q && w && (w.scrollTop = 0), K === X && w && (w.scrollTop = w.scrollHeight), K == null || K.focus(), document.activeElement !== z)) return;
+      },
+      [D, w]
+    ), L = h.useCallback(
+      () => $([M, C]),
+      [$, M, C]
+    );
+    h.useEffect(() => {
+      I && L();
+    }, [I, L]);
+    const { onOpenChange: Z, triggerPointerDownPosRef: ee } = v;
+    h.useEffect(() => {
+      if (C) {
+        let W = { x: 0, y: 0 };
+        const q = (X) => {
+          var z, K;
+          W = {
+            x: Math.abs(Math.round(X.pageX) - (((z = ee.current) == null ? void 0 : z.x) ?? 0)),
+            y: Math.abs(Math.round(X.pageY) - (((K = ee.current) == null ? void 0 : K.y) ?? 0))
+          };
+        }, se = (X) => {
+          W.x <= 10 && W.y <= 10 ? X.preventDefault() : C.contains(X.target) || Z(!1), document.removeEventListener("pointermove", q), ee.current = null;
+        };
+        return ee.current !== null && (document.addEventListener("pointermove", q), document.addEventListener("pointerup", se, { capture: !0, once: !0 })), () => {
+          document.removeEventListener("pointermove", q), document.removeEventListener("pointerup", se, { capture: !0 });
+        };
+      }
+    }, [C, Z, ee]), h.useEffect(() => {
+      const W = () => Z(!1);
+      return window.addEventListener("blur", W), window.addEventListener("resize", W), () => {
+        window.removeEventListener("blur", W), window.removeEventListener("resize", W);
+      };
+    }, [Z]);
+    const [Se, we] = hs((W) => {
+      const q = D().filter((z) => !z.disabled), se = q.find((z) => z.ref.current === document.activeElement), X = ps(q, W, se);
+      X && setTimeout(() => X.ref.current.focus());
+    }), je = h.useCallback(
+      (W, q, se) => {
+        const X = !V.current && !se;
+        (v.value !== void 0 && v.value === q || X) && (H(W), X && (V.current = !0));
+      },
+      [v.value]
+    ), Ze = h.useCallback(() => C == null ? void 0 : C.focus(), [C]), Ee = h.useCallback(
+      (W, q, se) => {
+        const X = !V.current && !se;
+        (v.value !== void 0 && v.value === q || X) && J(W);
+      },
+      [v.value]
+    ), Be = n === "popper" ? kr : Go, Ce = Be === kr ? {
+      side: a,
+      sideOffset: c,
+      align: u,
+      alignOffset: f,
+      arrowPadding: d,
+      collisionBoundary: g,
+      collisionPadding: x,
+      sticky: y,
+      hideWhenDetached: p,
+      avoidCollisions: S
+    } : {};
+    return /* @__PURE__ */ P.jsx(
+      qo,
+      {
+        scope: t,
+        content: C,
+        viewport: w,
+        onViewportChange: A,
+        itemRefCallback: je,
+        selectedItem: M,
+        onItemLeave: Ze,
+        itemTextRefCallback: Ee,
+        focusSelectedItem: L,
+        selectedItemText: U,
+        position: n,
+        isPositioned: I,
+        searchRef: Se,
+        children: /* @__PURE__ */ P.jsx(jo, { as: Ht, allowPinchZoom: !0, children: /* @__PURE__ */ P.jsx(
+          io,
+          {
+            asChild: !0,
+            trapped: v.open,
+            onMountAutoFocus: (W) => {
+              W.preventDefault();
+            },
+            onUnmountAutoFocus: ce(o, (W) => {
+              var q;
+              (q = v.trigger) == null || q.focus({ preventScroll: !0 }), W.preventDefault();
+            }),
+            children: /* @__PURE__ */ P.jsx(
+              oo,
+              {
+                asChild: !0,
+                disableOutsidePointerEvents: !0,
+                onEscapeKeyDown: s,
+                onPointerDownOutside: i,
+                onFocusOutside: (W) => W.preventDefault(),
+                onDismiss: () => v.onOpenChange(!1),
+                children: /* @__PURE__ */ P.jsx(
+                  Be,
+                  {
+                    role: "listbox",
+                    id: v.contentId,
+                    "data-state": v.open ? "open" : "closed",
+                    dir: v.dir,
+                    onContextMenu: (W) => W.preventDefault(),
+                    ...b,
+                    ...Ce,
+                    onPlaced: () => B(!0),
+                    ref: _,
+                    style: {
+                      // flex layout so we can place the scroll buttons properly
+                      display: "flex",
+                      flexDirection: "column",
+                      // reset the outline by default as the content MAY get focused
+                      outline: "none",
+                      ...b.style
+                    },
+                    onKeyDown: ce(b.onKeyDown, (W) => {
+                      const q = W.ctrlKey || W.altKey || W.metaKey;
+                      if (W.key === "Tab" && W.preventDefault(), !q && W.key.length === 1 && we(W.key), ["ArrowUp", "ArrowDown", "Home", "End"].includes(W.key)) {
+                        let X = D().filter((z) => !z.disabled).map((z) => z.ref.current);
+                        if (["ArrowUp", "End"].includes(W.key) && (X = X.slice().reverse()), ["ArrowUp", "ArrowDown"].includes(W.key)) {
+                          const z = W.target, K = X.indexOf(z);
+                          X = X.slice(K + 1);
+                        }
+                        setTimeout(() => $(X)), W.preventDefault();
+                      }
+                    })
+                  }
+                )
+              }
+            )
+          }
+        ) })
+      }
+    );
+  }
+);
+Xo.displayName = _c;
+var Rc = "SelectItemAlignedPosition", Go = h.forwardRef((e, r) => {
+  const { __scopeSelect: t, onPlaced: n, ...o } = e, s = Xe(tt, t), i = Ge(tt, t), [a, c] = h.useState(null), [u, f] = h.useState(null), d = le(r, (_) => f(_)), g = or(t), x = h.useRef(!1), y = h.useRef(!0), { viewport: p, selectedItem: S, selectedItemText: b, focusSelectedItem: v } = i, C = h.useCallback(() => {
+    if (s.trigger && s.valueNode && a && u && p && S && b) {
+      const _ = s.trigger.getBoundingClientRect(), M = u.getBoundingClientRect(), H = s.valueNode.getBoundingClientRect(), U = b.getBoundingClientRect();
+      if (s.dir !== "rtl") {
+        const z = U.left - M.left, K = H.left - z, ue = _.left - K, me = _.width + ue, rt = Math.max(me, M.width), nt = window.innerWidth - Ne, ot = mn(K, [Ne, nt - rt]);
+        a.style.minWidth = me + "px", a.style.left = ot + "px";
+      } else {
+        const z = M.right - U.right, K = window.innerWidth - H.right - z, ue = window.innerWidth - _.right - K, me = _.width + ue, rt = Math.max(me, M.width), nt = window.innerWidth - Ne, ot = mn(K, [Ne, nt - rt]);
+        a.style.minWidth = me + "px", a.style.right = ot + "px";
+      }
+      const J = g(), D = window.innerHeight - Ne * 2, I = p.scrollHeight, B = window.getComputedStyle(u), V = parseInt(B.borderTopWidth, 10), $ = parseInt(B.paddingTop, 10), L = parseInt(B.borderBottomWidth, 10), Z = parseInt(B.paddingBottom, 10), ee = V + $ + I + Z + L, Se = Math.min(S.offsetHeight * 5, ee), we = window.getComputedStyle(p), je = parseInt(we.paddingTop, 10), Ze = parseInt(we.paddingBottom, 10), Ee = _.top + _.height / 2 - Ne, Be = D - Ee, Ce = S.offsetHeight / 2, W = S.offsetTop + Ce, q = V + $ + W, se = ee - q;
+      if (q <= Ee) {
+        const z = S === J[J.length - 1].ref.current;
+        a.style.bottom = "0px";
+        const K = u.clientHeight - p.offsetTop - p.offsetHeight, ue = Math.max(
+          Be,
+          Ce + // viewport might have padding bottom, include it to avoid a scrollable viewport
+          (z ? Ze : 0) + K + L
+        ), me = q + ue;
+        a.style.height = me + "px";
+      } else {
+        const z = S === J[0].ref.current;
+        a.style.top = "0px";
+        const ue = Math.max(
+          Ee,
+          V + p.offsetTop + // viewport might have padding top, include it to avoid a scrollable viewport
+          (z ? je : 0) + Ce
+        ) + se;
+        a.style.height = ue + "px", p.scrollTop = q - Ee + p.offsetTop;
+      }
+      a.style.margin = `${Ne}px 0`, a.style.minHeight = Se + "px", a.style.maxHeight = D + "px", n == null || n(), requestAnimationFrame(() => x.current = !0);
+    }
+  }, [
+    g,
+    s.trigger,
+    s.valueNode,
+    a,
+    u,
+    p,
+    S,
+    b,
+    s.dir,
+    n
+  ]);
+  be(() => C(), [C]);
+  const [R, w] = h.useState();
+  be(() => {
+    u && w(window.getComputedStyle(u).zIndex);
+  }, [u]);
+  const A = h.useCallback(
+    (_) => {
+      _ && y.current === !0 && (C(), v == null || v(), y.current = !1);
+    },
+    [C, v]
+  );
+  return /* @__PURE__ */ P.jsx(
+    Tc,
+    {
+      scope: t,
+      contentWrapper: a,
+      shouldExpandOnScrollRef: x,
+      onScrollButtonChange: A,
+      children: /* @__PURE__ */ P.jsx(
+        "div",
+        {
+          ref: c,
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            position: "fixed",
+            zIndex: R
+          },
+          children: /* @__PURE__ */ P.jsx(
+            oe.div,
+            {
+              ...o,
+              ref: d,
+              style: {
+                // When we get the height of the content, it includes borders. If we were to set
+                // the height without having `boxSizing: 'border-box'` it would be too big.
+                boxSizing: "border-box",
+                // We need to ensure the content doesn't get taller than the wrapper
+                maxHeight: "100%",
+                ...o.style
+              }
+            }
+          )
+        }
+      )
+    }
+  );
+});
+Go.displayName = Rc;
+var Pc = "SelectPopperPosition", kr = h.forwardRef((e, r) => {
+  const {
+    __scopeSelect: t,
+    align: n = "start",
+    collisionPadding: o = Ne,
+    ...s
+  } = e, i = sr(t);
+  return /* @__PURE__ */ P.jsx(
+    Ra,
+    {
+      ...i,
+      ...s,
+      ref: r,
+      align: n,
+      collisionPadding: o,
+      style: {
+        // Ensure border-box for floating-ui calculations
+        boxSizing: "border-box",
+        ...s.style,
+        "--radix-select-content-transform-origin": "var(--radix-popper-transform-origin)",
+        "--radix-select-content-available-width": "var(--radix-popper-available-width)",
+        "--radix-select-content-available-height": "var(--radix-popper-available-height)",
+        "--radix-select-trigger-width": "var(--radix-popper-anchor-width)",
+        "--radix-select-trigger-height": "var(--radix-popper-anchor-height)"
+      }
+    }
+  );
+});
+kr.displayName = Pc;
+var [Tc, rn] = bt(tt, {}), Ir = "SelectViewport", Zo = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, nonce: n, ...o } = e, s = Ge(Ir, t), i = rn(Ir, t), a = le(r, s.onViewportChange), c = h.useRef(0);
+    return /* @__PURE__ */ P.jsxs(P.Fragment, { children: [
+      /* @__PURE__ */ P.jsx(
+        "style",
+        {
+          dangerouslySetInnerHTML: {
+            __html: "[data-radix-select-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-select-viewport]::-webkit-scrollbar{display:none}"
+          },
+          nonce: n
+        }
+      ),
+      /* @__PURE__ */ P.jsx(nr.Slot, { scope: t, children: /* @__PURE__ */ P.jsx(
+        oe.div,
+        {
+          "data-radix-select-viewport": "",
+          role: "presentation",
+          ...o,
+          ref: a,
+          style: {
+            // we use position: 'relative' here on the `viewport` so that when we call
+            // `selectedItem.offsetTop` in calculations, the offset is relative to the viewport
+            // (independent of the scrollUpButton).
+            position: "relative",
+            flex: 1,
+            overflow: "auto",
+            ...o.style
+          },
+          onScroll: ce(o.onScroll, (u) => {
+            const f = u.currentTarget, { contentWrapper: d, shouldExpandOnScrollRef: g } = i;
+            if (g != null && g.current && d) {
+              const x = Math.abs(c.current - f.scrollTop);
+              if (x > 0) {
+                const y = window.innerHeight - Ne * 2, p = parseFloat(d.style.minHeight), S = parseFloat(d.style.height), b = Math.max(p, S);
+                if (b < y) {
+                  const v = b + x, C = Math.min(y, v), R = v - C;
+                  d.style.height = C + "px", d.style.bottom === "0px" && (f.scrollTop = R > 0 ? R : 0, d.style.justifyContent = "flex-end");
+                }
+              }
+            }
+            c.current = f.scrollTop;
+          })
+        }
+      ) })
+    ] });
+  }
+);
+Zo.displayName = Ir;
+var Qo = "SelectGroup", [Oc, Fc] = bt(Qo), Jo = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e, o = Wr();
+    return /* @__PURE__ */ P.jsx(Oc, { scope: t, id: o, children: /* @__PURE__ */ P.jsx(oe.div, { role: "group", "aria-labelledby": o, ...n, ref: r }) });
+  }
+);
+Jo.displayName = Qo;
+var es = "SelectLabel", ts = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e, o = Fc(es, t);
+    return /* @__PURE__ */ P.jsx(oe.div, { id: o.id, ...n, ref: r });
+  }
+);
+ts.displayName = es;
+var Qt = "SelectItem", [Nc, rs] = bt(Qt), ns = h.forwardRef(
+  (e, r) => {
+    const {
+      __scopeSelect: t,
+      value: n,
+      disabled: o = !1,
+      textValue: s,
+      ...i
+    } = e, a = Xe(Qt, t), c = Ge(Qt, t), u = a.value === n, [f, d] = h.useState(s ?? ""), [g, x] = h.useState(!1), y = le(
+      r,
+      (b) => {
+        var v;
+        return (v = c.itemRefCallback) == null ? void 0 : v.call(c, b, n, o);
+      }
+    ), p = Wr(), S = () => {
+      o || (a.onValueChange(n), a.onOpenChange(!1));
+    };
+    if (n === "")
+      throw new Error(
+        "A <Select.Item /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder."
+      );
+    return /* @__PURE__ */ P.jsx(
+      Nc,
+      {
+        scope: t,
+        value: n,
+        disabled: o,
+        textId: p,
+        isSelected: u,
+        onItemTextChange: h.useCallback((b) => {
+          d((v) => v || ((b == null ? void 0 : b.textContent) ?? "").trim());
+        }, []),
+        children: /* @__PURE__ */ P.jsx(
+          nr.ItemSlot,
+          {
+            scope: t,
+            value: n,
+            disabled: o,
+            textValue: f,
+            children: /* @__PURE__ */ P.jsx(
+              oe.div,
+              {
+                role: "option",
+                "aria-labelledby": p,
+                "data-highlighted": g ? "" : void 0,
+                "aria-selected": u && g,
+                "data-state": u ? "checked" : "unchecked",
+                "aria-disabled": o || void 0,
+                "data-disabled": o ? "" : void 0,
+                tabIndex: o ? void 0 : -1,
+                ...i,
+                ref: y,
+                onFocus: ce(i.onFocus, () => x(!0)),
+                onBlur: ce(i.onBlur, () => x(!1)),
+                onPointerUp: ce(i.onPointerUp, S),
+                onPointerMove: ce(i.onPointerMove, (b) => {
+                  var v;
+                  o ? (v = c.onItemLeave) == null || v.call(c) : b.currentTarget.focus({ preventScroll: !0 });
+                }),
+                onPointerLeave: ce(i.onPointerLeave, (b) => {
+                  var v;
+                  b.currentTarget === document.activeElement && ((v = c.onItemLeave) == null || v.call(c));
+                }),
+                onKeyDown: ce(i.onKeyDown, (b) => {
+                  var C;
+                  ((C = c.searchRef) == null ? void 0 : C.current) !== "" && b.key === " " || (wc.includes(b.key) && S(), b.key === " " && b.preventDefault());
+                })
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+ns.displayName = Qt;
+var Et = "SelectItemText", os = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, className: n, style: o, ...s } = e, i = Xe(Et, t), a = Ge(Et, t), c = rs(Et, t), u = Ec(Et, t), [f, d] = h.useState(null), g = le(
+      r,
+      (b) => d(b),
+      c.onItemTextChange,
+      (b) => {
+        var v;
+        return (v = a.itemTextRefCallback) == null ? void 0 : v.call(a, b, c.value, c.disabled);
+      }
+    ), x = f == null ? void 0 : f.textContent, y = h.useMemo(
+      () => /* @__PURE__ */ P.jsx("option", { value: c.value, disabled: c.disabled, children: x }, c.value),
+      [c.disabled, c.value, x]
+    ), { onNativeOptionAdd: p, onNativeOptionRemove: S } = u;
+    return be(() => (p(y), () => S(y)), [p, S, y]), /* @__PURE__ */ P.jsxs(P.Fragment, { children: [
+      /* @__PURE__ */ P.jsx(oe.span, { id: c.textId, ...s, ref: g }),
+      c.isSelected && i.valueNode && !i.valueNodeHasChildren ? Hr.createPortal(s.children, i.valueNode) : null
+    ] });
+  }
+);
+os.displayName = Et;
+var ss = "SelectItemIndicator", is = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e;
+    return rs(ss, t).isSelected ? /* @__PURE__ */ P.jsx(oe.span, { "aria-hidden": !0, ...n, ref: r }) : null;
+  }
+);
+is.displayName = ss;
+var Vr = "SelectScrollUpButton", as = h.forwardRef((e, r) => {
+  const t = Ge(Vr, e.__scopeSelect), n = rn(Vr, e.__scopeSelect), [o, s] = h.useState(!1), i = le(r, n.onScrollButtonChange);
+  return be(() => {
+    if (t.viewport && t.isPositioned) {
+      let a = function() {
+        const u = c.scrollTop > 0;
+        s(u);
+      };
+      const c = t.viewport;
+      return a(), c.addEventListener("scroll", a), () => c.removeEventListener("scroll", a);
+    }
+  }, [t.viewport, t.isPositioned]), o ? /* @__PURE__ */ P.jsx(
+    ls,
+    {
+      ...e,
+      ref: i,
+      onAutoScroll: () => {
+        const { viewport: a, selectedItem: c } = t;
+        a && c && (a.scrollTop = a.scrollTop - c.offsetHeight);
+      }
+    }
+  ) : null;
+});
+as.displayName = Vr;
+var Lr = "SelectScrollDownButton", cs = h.forwardRef((e, r) => {
+  const t = Ge(Lr, e.__scopeSelect), n = rn(Lr, e.__scopeSelect), [o, s] = h.useState(!1), i = le(r, n.onScrollButtonChange);
+  return be(() => {
+    if (t.viewport && t.isPositioned) {
+      let a = function() {
+        const u = c.scrollHeight - c.clientHeight, f = Math.ceil(c.scrollTop) < u;
+        s(f);
+      };
+      const c = t.viewport;
+      return a(), c.addEventListener("scroll", a), () => c.removeEventListener("scroll", a);
+    }
+  }, [t.viewport, t.isPositioned]), o ? /* @__PURE__ */ P.jsx(
+    ls,
+    {
+      ...e,
+      ref: i,
+      onAutoScroll: () => {
+        const { viewport: a, selectedItem: c } = t;
+        a && c && (a.scrollTop = a.scrollTop + c.offsetHeight);
+      }
+    }
+  ) : null;
+});
+cs.displayName = Lr;
+var ls = h.forwardRef((e, r) => {
+  const { __scopeSelect: t, onAutoScroll: n, ...o } = e, s = Ge("SelectScrollButton", t), i = h.useRef(null), a = or(t), c = h.useCallback(() => {
+    i.current !== null && (window.clearInterval(i.current), i.current = null);
+  }, []);
+  return h.useEffect(() => () => c(), [c]), be(() => {
+    var f;
+    const u = a().find((d) => d.ref.current === document.activeElement);
+    (f = u == null ? void 0 : u.ref.current) == null || f.scrollIntoView({ block: "nearest" });
+  }, [a]), /* @__PURE__ */ P.jsx(
+    oe.div,
+    {
+      "aria-hidden": !0,
+      ...o,
+      ref: r,
+      style: { flexShrink: 0, ...o.style },
+      onPointerDown: ce(o.onPointerDown, () => {
+        i.current === null && (i.current = window.setInterval(n, 50));
+      }),
+      onPointerMove: ce(o.onPointerMove, () => {
+        var u;
+        (u = s.onItemLeave) == null || u.call(s), i.current === null && (i.current = window.setInterval(n, 50));
+      }),
+      onPointerLeave: ce(o.onPointerLeave, () => {
+        c();
+      })
+    }
+  );
+}), Dc = "SelectSeparator", us = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e;
+    return /* @__PURE__ */ P.jsx(oe.div, { "aria-hidden": !0, ...n, ref: r });
+  }
+);
+us.displayName = Dc;
+var jr = "SelectArrow", Mc = h.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e, o = sr(t), s = Xe(jr, t), i = Ge(jr, t);
+    return s.open && i.position === "popper" ? /* @__PURE__ */ P.jsx(Pa, { ...o, ...n, ref: r }) : null;
+  }
+);
+Mc.displayName = jr;
+function ds(e) {
+  return e === "" || e === void 0;
+}
+var fs = h.forwardRef(
+  (e, r) => {
+    const { value: t, ...n } = e, o = h.useRef(null), s = le(r, o), i = Oa(t);
+    return h.useEffect(() => {
+      const a = o.current, c = window.HTMLSelectElement.prototype, f = Object.getOwnPropertyDescriptor(
+        c,
+        "value"
+      ).set;
+      if (i !== t && f) {
+        const d = new Event("change", { bubbles: !0 });
+        f.call(a, t), a.dispatchEvent(d);
+      }
+    }, [i, t]), /* @__PURE__ */ P.jsx(Oo, { asChild: !0, children: /* @__PURE__ */ P.jsx("select", { ...n, ref: s, defaultValue: t }) });
+  }
+);
+fs.displayName = "BubbleSelect";
+function hs(e) {
+  const r = Je(e), t = h.useRef(""), n = h.useRef(0), o = h.useCallback(
+    (i) => {
+      const a = t.current + i;
+      r(a), function c(u) {
+        t.current = u, window.clearTimeout(n.current), u !== "" && (n.current = window.setTimeout(() => c(""), 1e3));
+      }(a);
+    },
+    [r]
+  ), s = h.useCallback(() => {
+    t.current = "", window.clearTimeout(n.current);
+  }, []);
+  return h.useEffect(() => () => window.clearTimeout(n.current), []), [t, o, s];
+}
+function ps(e, r, t) {
+  const o = r.length > 1 && Array.from(r).every((u) => u === r[0]) ? r[0] : r, s = t ? e.indexOf(t) : -1;
+  let i = kc(e, Math.max(s, 0));
+  o.length === 1 && (i = i.filter((u) => u !== t));
+  const c = i.find(
+    (u) => u.textValue.toLowerCase().startsWith(o.toLowerCase())
+  );
+  return c !== t ? c : void 0;
+}
+function kc(e, r) {
+  return e.map((t, n) => e[(r + n) % e.length]);
+}
+var Ic = Bo, ms = Ho, Vc = $o, Lc = zo, jc = Ko, vs = Yo, Bc = Zo, Wc = Jo, gs = ts, ys = ns, Hc = os, Uc = is, ws = as, xs = cs, bs = us;
+const ul = Ic, dl = Wc, fl = Vc, $c = h.forwardRef(({ className: e, children: r, ...t }, n) => /* @__PURE__ */ P.jsxs(
+  ms,
+  {
+    ref: n,
+    className: ke(
+      "flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+      e
+    ),
+    ...t,
+    children: [
+      /* @__PURE__ */ P.jsx("span", { className: "truncate", children: r }),
+      /* @__PURE__ */ P.jsx(Lc, { asChild: !0, children: /* @__PURE__ */ P.jsx(Bn, { className: "flex-shrink-0 h-4 w-4 opacity-50" }) })
+    ]
+  }
+));
+$c.displayName = ms.displayName;
+const Ss = h.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  ws,
+  {
+    ref: t,
+    className: ke(
+      "flex cursor-default items-center justify-center py-1",
+      e
+    ),
+    ...r,
+    children: /* @__PURE__ */ P.jsx(Bs, { className: "h-4 w-4" })
+  }
+));
+Ss.displayName = ws.displayName;
+const Es = h.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  xs,
+  {
+    ref: t,
+    className: ke(
+      "flex cursor-default items-center justify-center py-1",
+      e
+    ),
+    ...r,
+    children: /* @__PURE__ */ P.jsx(Bn, { className: "h-4 w-4" })
+  }
+));
+Es.displayName = xs.displayName;
+const zc = h.forwardRef(({ className: e, children: r, position: t = "popper", ...n }, o) => /* @__PURE__ */ P.jsx(jc, { children: /* @__PURE__ */ P.jsxs(
+  vs,
+  {
+    ref: o,
+    className: ke(
+      "relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=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",
+      t === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+      e
+    ),
+    position: t,
+    ...n,
+    children: [
+      /* @__PURE__ */ P.jsx(Ss, {}),
+      /* @__PURE__ */ P.jsx(
+        Bc,
+        {
+          className: ke(
+            "p-1",
+            t === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+          ),
+          children: r
+        }
+      ),
+      /* @__PURE__ */ P.jsx(Es, {})
+    ]
+  }
+) }));
+zc.displayName = vs.displayName;
+const Kc = h.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  gs,
+  {
+    ref: t,
+    className: ke("py-1.5 pl-8 pr-2 text-sm font-semibold", e),
+    ...r
+  }
+));
+Kc.displayName = gs.displayName;
+const Yc = h.forwardRef(({ className: e, children: r, ...t }, n) => /* @__PURE__ */ P.jsxs(
+  ys,
+  {
+    ref: n,
+    className: ke(
+      "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      e
+    ),
+    ...t,
+    children: [
+      /* @__PURE__ */ P.jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ P.jsx(Uc, { children: /* @__PURE__ */ P.jsx(Ls, { className: "h-4 w-4" }) }) }),
+      /* @__PURE__ */ P.jsx(Hc, { children: r })
+    ]
+  }
+));
+Yc.displayName = ys.displayName;
+const qc = h.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  bs,
+  {
+    ref: t,
+    className: ke("-mx-1 my-1 h-px bg-muted", e),
+    ...r
+  }
+));
+qc.displayName = bs.displayName;
+export {
+  Us as B,
+  il as C,
+  oo as D,
+  io as F,
+  To as P,
+  jo as R,
+  ul as S,
+  Oo as V,
+  ol as a,
+  $c as b,
+  fl as c,
+  zc as d,
+  dl as e,
+  Yc as f,
+  ii as g,
+  ci as h,
+  ka as i,
+  gi as j,
+  al as k,
+  Ys as l,
+  Jt as m,
+  sl as n,
+  cl as u
+};
+//# sourceMappingURL=Select-D-Jtx53Q.js.map