zudoku 0.3.0-dev.52 → 0.3.0-dev.53

package/lib/Select-CcBbwJ2R.js

@@ -0,0 +1,3667 @@
+var Nr = (e) => {
+  throw TypeError(e);
+};
+var qt = (e, r, t) => r.has(e) || Nr("Cannot " + t);
+var te = (e, r, t) => (qt(e, r, "read from private field"), t ? t.call(e) : r.get(e)), nt = (e, r, t) => r.has(e) ? Nr("Cannot add the same private member more than once") : r instanceof WeakSet ? r.add(e) : r.set(e, t), st = (e, r, t, n) => (qt(e, r, "write to private field"), n ? n.call(e, t) : r.set(e, t), t), ot = (e, r, t) => (qt(e, r, "access private method"), t);
+import * as v from "react";
+import H, { useLayoutEffect as Os, useEffect as Fs } from "react";
+import { g as Ts } from "./mutation-DjbQSHzT.js";
+import { S as Vs, w as Ds, i as Ir, n as en, q as Ns, x as Is, y as ks } from "./DevPortalProvider-Do9oJqme.js";
+import { j as P } from "./jsx-runtime-CJZJivg2.js";
+import * as gr from "react-dom";
+import { P as ue, g as _e, c as tn, u as we, b as rn, d as ce, S as Ms, e as yr, a as kr } from "./index-ByHya67R.js";
+import { c as Ls, h as js, a as Bs, R as Hs, F as Ws, D as Us, V as $s, P as zs, u as Ks } from "./Combination-B0Iu6mhJ.js";
+import { c as nn, e as Ue, k as qs } from "./Markdown-aE_XoLNs.js";
+/**
+ * @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 sn = nn("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 Ys = nn("ChevronUp", [["path", { d: "m18 15-6-6-6 6", key: "153udz" }]]);
+var Be, He, fe, Ve, De, Et, ir, Jr, Gs = (Jr = class extends Vs {
+  constructor(r, t) {
+    super();
+    nt(this, De);
+    nt(this, Be);
+    nt(this, He);
+    nt(this, fe);
+    nt(this, Ve);
+    st(this, Be, r), this.setOptions(t), this.bindMethods(), ot(this, De, Et).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(r) {
+    var n;
+    const t = this.options;
+    this.options = te(this, Be).defaultMutationOptions(r), Ds(this.options, t) || te(this, Be).getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: te(this, fe),
+      observer: this
+    }), t != null && t.mutationKey && this.options.mutationKey && Ir(t.mutationKey) !== Ir(this.options.mutationKey) ? this.reset() : ((n = te(this, fe)) == null ? void 0 : n.state.status) === "pending" && te(this, fe).setOptions(this.options);
+  }
+  onUnsubscribe() {
+    var r;
+    this.hasListeners() || (r = te(this, fe)) == null || r.removeObserver(this);
+  }
+  onMutationUpdate(r) {
+    ot(this, De, Et).call(this), ot(this, De, ir).call(this, r);
+  }
+  getCurrentResult() {
+    return te(this, He);
+  }
+  reset() {
+    var r;
+    (r = te(this, fe)) == null || r.removeObserver(this), st(this, fe, void 0), ot(this, De, Et).call(this), ot(this, De, ir).call(this);
+  }
+  mutate(r, t) {
+    var n;
+    return st(this, Ve, t), (n = te(this, fe)) == null || n.removeObserver(this), st(this, fe, te(this, Be).getMutationCache().build(te(this, Be), this.options)), te(this, fe).addObserver(this), te(this, fe).execute(r);
+  }
+}, Be = new WeakMap(), He = new WeakMap(), fe = new WeakMap(), Ve = new WeakMap(), De = new WeakSet(), Et = function() {
+  var t;
+  const r = ((t = te(this, fe)) == null ? void 0 : t.state) ?? Ts();
+  st(this, He, {
+    ...r,
+    isPending: r.status === "pending",
+    isSuccess: r.status === "success",
+    isError: r.status === "error",
+    isIdle: r.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, ir = function(r) {
+  en.batch(() => {
+    var t, n, s, o, i, a, c, u;
+    if (te(this, Ve) && this.hasListeners()) {
+      const p = te(this, He).variables, d = te(this, He).context;
+      (r == null ? void 0 : r.type) === "success" ? ((n = (t = te(this, Ve)).onSuccess) == null || n.call(t, r.data, p, d), (o = (s = te(this, Ve)).onSettled) == null || o.call(s, r.data, null, p, d)) : (r == null ? void 0 : r.type) === "error" && ((a = (i = te(this, Ve)).onError) == null || a.call(i, r.error, p, d), (u = (c = te(this, Ve)).onSettled) == null || u.call(
+        c,
+        void 0,
+        r.error,
+        p,
+        d
+      ));
+    }
+    this.listeners.forEach((p) => {
+      p(te(this, He));
+    });
+  });
+}, Jr);
+function na(e, r) {
+  const t = Ns(), [n] = v.useState(
+    () => new Gs(
+      t,
+      e
+    )
+  );
+  v.useEffect(() => {
+    n.setOptions(e);
+  }, [n, e]);
+  const s = v.useSyncExternalStore(
+    v.useCallback(
+      (i) => n.subscribe(en.batchCalls(i)),
+      [n]
+    ),
+    () => n.getCurrentResult(),
+    () => n.getCurrentResult()
+  ), o = v.useCallback(
+    (i, a) => {
+      n.mutate(i, a).catch(Is);
+    },
+    [n]
+  );
+  if (s.error && ks(n.options.throwOnError, [s.error]))
+    throw s.error;
+  return { ...s, mutate: o, mutateAsync: s.mutate };
+}
+var wt = (e) => e.type === "checkbox", at = (e) => e instanceof Date, le = (e) => e == null;
+const on = (e) => typeof e == "object";
+var ie = (e) => !le(e) && !Array.isArray(e) && on(e) && !at(e), an = (e) => ie(e) && e.target ? wt(e.target) ? e.target.checked : e.target.value : e, Xs = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, ln = (e, r) => e.has(Xs(r)), Zs = (e) => {
+  const r = e.constructor && e.constructor.prototype;
+  return ie(r) && r.hasOwnProperty("isPrototypeOf");
+}, vr = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function oe(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 (!(vr && (e instanceof Blob || e instanceof FileList)) && (t || ie(e)))
+    if (r = t ? [] : {}, !t && !Zs(e))
+      r = e;
+    else
+      for (const n in e)
+        e.hasOwnProperty(n) && (r[n] = oe(e[n]));
+  else
+    return e;
+  return r;
+}
+var bt = (e) => Array.isArray(e) ? e.filter(Boolean) : [], Q = (e) => e === void 0, C = (e, r, t) => {
+  if (!r || !ie(e))
+    return t;
+  const n = bt(r.split(/[,[\].]+?/)).reduce((s, o) => le(s) ? s : s[o], e);
+  return Q(n) || n === e ? Q(e[r]) ? t : e[r] : n;
+}, Ee = (e) => typeof e == "boolean", xr = (e) => /^\w*$/.test(e), cn = (e) => bt(e.replace(/["|']|\]/g, "").split(/\.|\[/)), X = (e, r, t) => {
+  let n = -1;
+  const s = xr(r) ? [r] : cn(r), o = s.length, i = o - 1;
+  for (; ++n < o; ) {
+    const a = s[n];
+    let c = t;
+    if (n !== i) {
+      const u = e[a];
+      c = ie(u) || Array.isArray(u) ? u : isNaN(+s[n + 1]) ? {} : [];
+    }
+    if (a === "__proto__")
+      return;
+    e[a] = c, e = e[a];
+  }
+  return e;
+};
+const Ot = {
+  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"
+}, un = H.createContext(null), jt = () => H.useContext(un), sa = (e) => {
+  const { children: r, ...t } = e;
+  return H.createElement(un.Provider, { value: t }, r);
+};
+var fn = (e, r, t, n = !0) => {
+  const s = {
+    defaultValues: r._defaultValues
+  };
+  for (const o in e)
+    Object.defineProperty(s, o, {
+      get: () => {
+        const i = o;
+        return r._proxyFormState[i] !== xe.all && (r._proxyFormState[i] = !n || xe.all), t && (t[i] = !0), e[i];
+      }
+    });
+  return s;
+}, de = (e) => ie(e) && !Object.keys(e).length, dn = (e, r, t, n) => {
+  t(e);
+  const { name: s, ...o } = e;
+  return de(o) || Object.keys(o).length >= Object.keys(r).length || Object.keys(o).find((i) => r[i] === (!n || xe.all));
+}, pe = (e) => Array.isArray(e) ? e : [e], pn = (e, r, t) => !e || !r || e === r || pe(e).some((n) => n && (t ? n === r : n.startsWith(r) || r.startsWith(n)));
+function Bt(e) {
+  const r = H.useRef(e);
+  r.current = e, H.useEffect(() => {
+    const t = !e.disabled && r.current.subject && r.current.subject.subscribe({
+      next: r.current.next
+    });
+    return () => {
+      t && t.unsubscribe();
+    };
+  }, [e.disabled]);
+}
+function Qs(e) {
+  const r = jt(), { control: t = r.control, disabled: n, name: s, exact: o } = e || {}, [i, a] = H.useState(t._formState), c = H.useRef(!0), u = H.useRef({
+    isDirty: !1,
+    isLoading: !1,
+    dirtyFields: !1,
+    touchedFields: !1,
+    validatingFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }), p = H.useRef(s);
+  return p.current = s, Bt({
+    disabled: n,
+    next: (d) => c.current && pn(p.current, d.name, o) && dn(d, u.current, t._updateFormState) && a({
+      ...t._formState,
+      ...d
+    }),
+    subject: t._subjects.state
+  }), H.useEffect(() => (c.current = !0, u.current.isValid && t._updateValid(!0), () => {
+    c.current = !1;
+  }), [t]), fn(i, t, u.current, !1);
+}
+var Re = (e) => typeof e == "string", hn = (e, r, t, n, s) => Re(e) ? (n && r.watch.add(e), C(t, e, s)) : Array.isArray(e) ? e.map((o) => (n && r.watch.add(o), C(t, o))) : (n && (r.watchAll = !0), t);
+function Js(e) {
+  const r = jt(), { control: t = r.control, name: n, defaultValue: s, disabled: o, exact: i } = e || {}, a = H.useRef(n);
+  a.current = n, Bt({
+    disabled: o,
+    subject: t._subjects.values,
+    next: (p) => {
+      pn(a.current, p.name, i) && u(oe(hn(a.current, t._names, p.values || t._formValues, !1, s)));
+    }
+  });
+  const [c, u] = H.useState(t._getWatch(n, s));
+  return H.useEffect(() => t._removeUnmounted()), c;
+}
+function eo(e) {
+  const r = jt(), { name: t, disabled: n, control: s = r.control, shouldUnregister: o } = e, i = ln(s._names.array, t), a = Js({
+    control: s,
+    name: t,
+    defaultValue: C(s._formValues, t, C(s._defaultValues, t, e.defaultValue)),
+    exact: !0
+  }), c = Qs({
+    control: s,
+    name: t
+  }), u = H.useRef(s.register(t, {
+    ...e.rules,
+    value: a,
+    ...Ee(e.disabled) ? { disabled: e.disabled } : {}
+  }));
+  return H.useEffect(() => {
+    const p = s._options.shouldUnregister || o, d = (x, w) => {
+      const g = C(s._fields, x);
+      g && g._f && (g._f.mount = w);
+    };
+    if (d(t, !0), p) {
+      const x = oe(C(s._options.defaultValues, t));
+      X(s._defaultValues, t, x), Q(C(s._formValues, t)) && X(s._formValues, t, x);
+    }
+    return () => {
+      (i ? p && !s._state.action : p) ? s.unregister(t) : d(t, !1);
+    };
+  }, [t, s, i, o]), H.useEffect(() => {
+    C(s._fields, t) && s._updateDisabledField({
+      disabled: n,
+      fields: s._fields,
+      name: t,
+      value: C(s._fields, t)._f.value
+    });
+  }, [n, t, s]), {
+    field: {
+      name: t,
+      value: a,
+      ...Ee(n) || c.disabled ? { disabled: c.disabled || n } : {},
+      onChange: H.useCallback((p) => u.current.onChange({
+        target: {
+          value: an(p),
+          name: t
+        },
+        type: Ot.CHANGE
+      }), [t]),
+      onBlur: H.useCallback(() => u.current.onBlur({
+        target: {
+          value: C(s._formValues, t),
+          name: t
+        },
+        type: Ot.BLUR
+      }), [t, s]),
+      ref: (p) => {
+        const d = C(s._fields, t);
+        d && p && (d._f.ref = {
+          focus: () => p.focus(),
+          select: () => p.select(),
+          setCustomValidity: (x) => p.setCustomValidity(x),
+          reportValidity: () => p.reportValidity()
+        });
+      }
+    },
+    formState: c,
+    fieldState: Object.defineProperties({}, {
+      invalid: {
+        enumerable: !0,
+        get: () => !!C(c.errors, t)
+      },
+      isDirty: {
+        enumerable: !0,
+        get: () => !!C(c.dirtyFields, t)
+      },
+      isTouched: {
+        enumerable: !0,
+        get: () => !!C(c.touchedFields, t)
+      },
+      isValidating: {
+        enumerable: !0,
+        get: () => !!C(c.validatingFields, t)
+      },
+      error: {
+        enumerable: !0,
+        get: () => C(c.errors, t)
+      }
+    })
+  };
+}
+const oa = (e) => e.render(eo(e));
+var to = (e, r, t, n, s) => r ? {
+  ...t[e],
+  types: {
+    ...t[e] && t[e].types ? t[e].types : {},
+    [n]: s || !0
+  }
+} : {}, je = () => {
+  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);
+  });
+}, Yt = (e, r, t = {}) => t.shouldFocus || Q(t.shouldFocus) ? t.focusName || `${e}.${Q(t.focusIndex) ? r : t.focusIndex}.` : "", yt = (e) => ({
+  isOnSubmit: !e || e === xe.onSubmit,
+  isOnBlur: e === xe.onBlur,
+  isOnChange: e === xe.onChange,
+  isOnAll: e === xe.all,
+  isOnTouch: e === xe.onTouched
+}), ar = (e, r, t) => !t && (r.watchAll || r.watch.has(e) || [...r.watch].some((n) => e.startsWith(n) && /^\.\w+/.test(e.slice(n.length))));
+const lt = (e, r, t, n) => {
+  for (const s of t || Object.keys(e)) {
+    const o = C(e, s);
+    if (o) {
+      const { _f: i, ...a } = o;
+      if (i) {
+        if (i.refs && i.refs[0] && r(i.refs[0], s) && !n)
+          break;
+        if (i.ref && r(i.ref, i.name) && !n)
+          break;
+        lt(a, r);
+      } else ie(a) && lt(a, r);
+    }
+  }
+};
+var mn = (e, r, t) => {
+  const n = pe(C(e, t));
+  return X(n, "root", r[t]), X(e, t, n), e;
+}, wr = (e) => e.type === "file", We = (e) => typeof e == "function", Ft = (e) => {
+  if (!vr)
+    return !1;
+  const r = e ? e.ownerDocument : 0;
+  return e instanceof (r && r.defaultView ? r.defaultView.HTMLElement : HTMLElement);
+}, Rt = (e) => Re(e), br = (e) => e.type === "radio", Tt = (e) => e instanceof RegExp;
+const Mr = {
+  value: !1,
+  isValid: !1
+}, Lr = { value: !0, isValid: !0 };
+var gn = (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 === "" ? Lr : { value: e[0].value, isValid: !0 } : Lr
+    ) : Mr;
+  }
+  return Mr;
+};
+const jr = {
+  isValid: !1,
+  value: null
+};
+var yn = (e) => Array.isArray(e) ? e.reduce((r, t) => t && t.checked && !t.disabled ? {
+  isValid: !0,
+  value: t.value
+} : r, jr) : jr;
+function Br(e, r, t = "validate") {
+  if (Rt(e) || Array.isArray(e) && e.every(Rt) || Ee(e) && !e)
+    return {
+      type: t,
+      message: Rt(e) ? e : "",
+      ref: r
+    };
+}
+var it = (e) => ie(e) && !Tt(e) ? e : {
+  value: e,
+  message: ""
+}, lr = async (e, r, t, n, s) => {
+  const { ref: o, refs: i, required: a, maxLength: c, minLength: u, min: p, max: d, pattern: x, validate: w, name: g, valueAsNumber: A, mount: E, disabled: b } = e._f, m = C(r, g);
+  if (!E || b)
+    return {};
+  const R = i ? i[0] : o, D = (V) => {
+    n && R.reportValidity && (R.setCustomValidity(Ee(V) ? "" : V || ""), R.reportValidity());
+  }, y = {}, S = br(o), F = wt(o), N = S || F, $ = (A || wr(o)) && Q(o.value) && Q(m) || Ft(o) && o.value === "" || m === "" || Array.isArray(m) && !m.length, U = to.bind(null, g, t, y), J = (V, k, j, M = Fe.maxLength, W = Fe.minLength) => {
+    const L = V ? k : j;
+    y[g] = {
+      type: V ? M : W,
+      message: L,
+      ref: o,
+      ...U(V ? M : W, L)
+    };
+  };
+  if (s ? !Array.isArray(m) || !m.length : a && (!N && ($ || le(m)) || Ee(m) && !m || F && !gn(i).isValid || S && !yn(i).isValid)) {
+    const { value: V, message: k } = Rt(a) ? { value: !!a, message: a } : it(a);
+    if (V && (y[g] = {
+      type: Fe.required,
+      message: k,
+      ref: R,
+      ...U(Fe.required, k)
+    }, !t))
+      return D(k), y;
+  }
+  if (!$ && (!le(p) || !le(d))) {
+    let V, k;
+    const j = it(d), M = it(p);
+    if (!le(m) && !isNaN(m)) {
+      const W = o.valueAsNumber || m && +m;
+      le(j.value) || (V = W > j.value), le(M.value) || (k = W < M.value);
+    } else {
+      const W = o.valueAsDate || new Date(m), L = (be) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + be), Z = o.type == "time", ee = o.type == "week";
+      Re(j.value) && m && (V = Z ? L(m) > L(j.value) : ee ? m > j.value : W > new Date(j.value)), Re(M.value) && m && (k = Z ? L(m) < L(M.value) : ee ? m < M.value : W < new Date(M.value));
+    }
+    if ((V || k) && (J(!!V, j.message, M.message, Fe.max, Fe.min), !t))
+      return D(y[g].message), y;
+  }
+  if ((c || u) && !$ && (Re(m) || s && Array.isArray(m))) {
+    const V = it(c), k = it(u), j = !le(V.value) && m.length > +V.value, M = !le(k.value) && m.length < +k.value;
+    if ((j || M) && (J(j, V.message, k.message), !t))
+      return D(y[g].message), y;
+  }
+  if (x && !$ && Re(m)) {
+    const { value: V, message: k } = it(x);
+    if (Tt(V) && !m.match(V) && (y[g] = {
+      type: Fe.pattern,
+      message: k,
+      ref: o,
+      ...U(Fe.pattern, k)
+    }, !t))
+      return D(k), y;
+  }
+  if (w) {
+    if (We(w)) {
+      const V = await w(m, r), k = Br(V, R);
+      if (k && (y[g] = {
+        ...k,
+        ...U(Fe.validate, k.message)
+      }, !t))
+        return D(k.message), y;
+    } else if (ie(w)) {
+      let V = {};
+      for (const k in w) {
+        if (!de(V) && !t)
+          break;
+        const j = Br(await w[k](m, r), R, k);
+        j && (V = {
+          ...j,
+          ...U(k, j.message)
+        }, D(j.message), t && (y[g] = V));
+      }
+      if (!de(V) && (y[g] = {
+        ref: R,
+        ...V
+      }, !t))
+        return y;
+    }
+  }
+  return D(!0), y;
+}, Gt = (e, r) => [
+  ...e,
+  ...pe(r)
+], Xt = (e) => Array.isArray(e) ? e.map(() => {
+}) : void 0;
+function Zt(e, r, t) {
+  return [
+    ...e.slice(0, r),
+    ...pe(t),
+    ...e.slice(r)
+  ];
+}
+var Qt = (e, r, t) => Array.isArray(e) ? (Q(e[t]) && (e[t] = void 0), e.splice(t, 0, e.splice(r, 1)[0]), e) : [], Jt = (e, r) => [
+  ...pe(r),
+  ...pe(e)
+];
+function ro(e, r) {
+  let t = 0;
+  const n = [...e];
+  for (const s of r)
+    n.splice(s - t, 1), t++;
+  return bt(n).length ? n : [];
+}
+var er = (e, r) => Q(r) ? [] : ro(e, pe(r).sort((t, n) => t - n)), tr = (e, r, t) => {
+  [e[r], e[t]] = [e[t], e[r]];
+};
+function no(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 so(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 : xr(r) ? [r] : cn(r), n = t.length === 1 ? e : no(e, t), s = t.length - 1, o = t[s];
+  return n && delete n[o], s !== 0 && (ie(n) && de(n) || Array.isArray(n) && so(n)) && ne(e, t.slice(0, -1)), e;
+}
+var Hr = (e, r, t) => (e[r] = t, e);
+function ia(e) {
+  const r = jt(), { control: t = r.control, name: n, keyName: s = "id", shouldUnregister: o } = e, [i, a] = H.useState(t._getFieldArray(n)), c = H.useRef(t._getFieldArray(n).map(je)), u = H.useRef(i), p = H.useRef(n), d = H.useRef(!1);
+  p.current = n, u.current = i, t._names.array.add(n), e.rules && t.register(n, e.rules), Bt({
+    next: ({ values: y, name: S }) => {
+      if (S === p.current || !S) {
+        const F = C(y, p.current);
+        Array.isArray(F) && (a(F), c.current = F.map(je));
+      }
+    },
+    subject: t._subjects.array
+  });
+  const x = H.useCallback((y) => {
+    d.current = !0, t._updateFieldArray(n, y);
+  }, [t, n]), w = (y, S) => {
+    const F = pe(oe(y)), N = Gt(t._getFieldArray(n), F);
+    t._names.focus = Yt(n, N.length - 1, S), c.current = Gt(c.current, F.map(je)), x(N), a(N), t._updateFieldArray(n, N, Gt, {
+      argA: Xt(y)
+    });
+  }, g = (y, S) => {
+    const F = pe(oe(y)), N = Jt(t._getFieldArray(n), F);
+    t._names.focus = Yt(n, 0, S), c.current = Jt(c.current, F.map(je)), x(N), a(N), t._updateFieldArray(n, N, Jt, {
+      argA: Xt(y)
+    });
+  }, A = (y) => {
+    const S = er(t._getFieldArray(n), y);
+    c.current = er(c.current, y), x(S), a(S), t._updateFieldArray(n, S, er, {
+      argA: y
+    });
+  }, E = (y, S, F) => {
+    const N = pe(oe(S)), $ = Zt(t._getFieldArray(n), y, N);
+    t._names.focus = Yt(n, y, F), c.current = Zt(c.current, y, N.map(je)), x($), a($), t._updateFieldArray(n, $, Zt, {
+      argA: y,
+      argB: Xt(S)
+    });
+  }, b = (y, S) => {
+    const F = t._getFieldArray(n);
+    tr(F, y, S), tr(c.current, y, S), x(F), a(F), t._updateFieldArray(n, F, tr, {
+      argA: y,
+      argB: S
+    }, !1);
+  }, m = (y, S) => {
+    const F = t._getFieldArray(n);
+    Qt(F, y, S), Qt(c.current, y, S), x(F), a(F), t._updateFieldArray(n, F, Qt, {
+      argA: y,
+      argB: S
+    }, !1);
+  }, R = (y, S) => {
+    const F = oe(S), N = Hr(t._getFieldArray(n), y, F);
+    c.current = [...N].map(($, U) => !$ || U === y ? je() : c.current[U]), x(N), a([...N]), t._updateFieldArray(n, N, Hr, {
+      argA: y,
+      argB: F
+    }, !0, !1);
+  }, D = (y) => {
+    const S = pe(oe(y));
+    c.current = S.map(je), x([...S]), a([...S]), t._updateFieldArray(n, [...S], (F) => F, {}, !0, !1);
+  };
+  return H.useEffect(() => {
+    if (t._state.action = !1, ar(n, t._names) && t._subjects.state.next({
+      ...t._formState
+    }), d.current && (!yt(t._options.mode).isOnSubmit || t._formState.isSubmitted))
+      if (t._options.resolver)
+        t._executeSchema([n]).then((y) => {
+          const S = C(y.errors, n), F = C(t._formState.errors, n);
+          (F ? !S && F.type || S && (F.type !== S.type || F.message !== S.message) : S && S.type) && (S ? X(t._formState.errors, n, S) : ne(t._formState.errors, n), t._subjects.state.next({
+            errors: t._formState.errors
+          }));
+        });
+      else {
+        const y = C(t._fields, n);
+        y && y._f && !(yt(t._options.reValidateMode).isOnSubmit && yt(t._options.mode).isOnSubmit) && lr(y, t._formValues, t._options.criteriaMode === xe.all, t._options.shouldUseNativeValidation, !0).then((S) => !de(S) && t._subjects.state.next({
+          errors: mn(t._formState.errors, S, n)
+        }));
+      }
+    t._subjects.values.next({
+      name: n,
+      values: { ...t._formValues }
+    }), t._names.focus && lt(t._fields, (y, S) => {
+      if (t._names.focus && S.startsWith(t._names.focus) && y.focus)
+        return y.focus(), 1;
+    }), t._names.focus = "", t._updateValid(), d.current = !1;
+  }, [i, n, t]), H.useEffect(() => (!C(t._formValues, n) && t._updateFieldArray(n), () => {
+    (t._options.shouldUnregister || o) && t.unregister(n);
+  }), [n, t, s, o]), {
+    swap: H.useCallback(b, [x, n, t]),
+    move: H.useCallback(m, [x, n, t]),
+    prepend: H.useCallback(g, [x, n, t]),
+    append: H.useCallback(w, [x, n, t]),
+    remove: H.useCallback(A, [x, n, t]),
+    insert: H.useCallback(E, [x, n, t]),
+    update: H.useCallback(R, [x, n, t]),
+    replace: H.useCallback(D, [x, n, t]),
+    fields: H.useMemo(() => i.map((y, S) => ({
+      ...y,
+      [s]: c.current[S] || je()
+    })), [i, s])
+  };
+}
+var rr = () => {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (s) => {
+      for (const o of e)
+        o.next && o.next(s);
+    },
+    subscribe: (s) => (e.push(s), {
+      unsubscribe: () => {
+        e = e.filter((o) => o !== s);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+}, Vt = (e) => le(e) || !on(e);
+function Xe(e, r) {
+  if (Vt(e) || Vt(r))
+    return e === r;
+  if (at(e) && at(r))
+    return e.getTime() === r.getTime();
+  const t = Object.keys(e), n = Object.keys(r);
+  if (t.length !== n.length)
+    return !1;
+  for (const s of t) {
+    const o = e[s];
+    if (!n.includes(s))
+      return !1;
+    if (s !== "ref") {
+      const i = r[s];
+      if (at(o) && at(i) || ie(o) && ie(i) || Array.isArray(o) && Array.isArray(i) ? !Xe(o, i) : o !== i)
+        return !1;
+    }
+  }
+  return !0;
+}
+var vn = (e) => e.type === "select-multiple", oo = (e) => br(e) || wt(e), nr = (e) => Ft(e) && e.isConnected, xn = (e) => {
+  for (const r in e)
+    if (We(e[r]))
+      return !0;
+  return !1;
+};
+function Dt(e, r = {}) {
+  const t = Array.isArray(e);
+  if (ie(e) || t)
+    for (const n in e)
+      Array.isArray(e[n]) || ie(e[n]) && !xn(e[n]) ? (r[n] = Array.isArray(e[n]) ? [] : {}, Dt(e[n], r[n])) : le(e[n]) || (r[n] = !0);
+  return r;
+}
+function wn(e, r, t) {
+  const n = Array.isArray(e);
+  if (ie(e) || n)
+    for (const s in e)
+      Array.isArray(e[s]) || ie(e[s]) && !xn(e[s]) ? Q(r) || Vt(t[s]) ? t[s] = Array.isArray(e[s]) ? Dt(e[s], []) : { ...Dt(e[s]) } : wn(e[s], le(r) ? {} : r[s], t[s]) : t[s] = !Xe(e[s], r[s]);
+  return t;
+}
+var _t = (e, r) => wn(e, r, Dt(r)), bn = (e, { valueAsNumber: r, valueAsDate: t, setValueAs: n }) => Q(e) ? e : r ? e === "" ? NaN : e && +e : t && Re(e) ? new Date(e) : n ? n(e) : e;
+function sr(e) {
+  const r = e.ref;
+  if (!(e.refs ? e.refs.every((t) => t.disabled) : r.disabled))
+    return wr(r) ? r.files : br(r) ? yn(e.refs).value : vn(r) ? [...r.selectedOptions].map(({ value: t }) => t) : wt(r) ? gn(e.refs).value : bn(Q(r.value) ? e.ref.value : r.value, e);
+}
+var io = (e, r, t, n) => {
+  const s = {};
+  for (const o of e) {
+    const i = C(r, o);
+    i && X(s, o, i._f);
+  }
+  return {
+    criteriaMode: t,
+    names: [...e],
+    fields: s,
+    shouldUseNativeValidation: n
+  };
+}, mt = (e) => Q(e) ? e : Tt(e) ? e.source : ie(e) ? Tt(e.value) ? e.value.source : e.value : e, ao = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate);
+function Wr(e, r, t) {
+  const n = C(e, t);
+  if (n || xr(t))
+    return {
+      error: n,
+      name: t
+    };
+  const s = t.split(".");
+  for (; s.length; ) {
+    const o = s.join("."), i = C(r, o), a = C(e, o);
+    if (i && !Array.isArray(i) && t !== o)
+      return { name: t };
+    if (a && a.type)
+      return {
+        name: o,
+        error: a
+      };
+    s.pop();
+  }
+  return {
+    name: t
+  };
+}
+var lo = (e, r, t, n, s) => s.isOnAll ? !1 : !t && s.isOnTouch ? !(r || e) : (t ? n.isOnBlur : s.isOnBlur) ? !e : (t ? n.isOnChange : s.isOnChange) ? e : !0, co = (e, r) => !bt(C(e, r)).length && ne(e, r);
+const uo = {
+  mode: xe.onSubmit,
+  reValidateMode: xe.onChange,
+  shouldFocusError: !0
+};
+function fo(e = {}) {
+  let r = {
+    ...uo,
+    ...e
+  }, t = {
+    submitCount: 0,
+    isDirty: !1,
+    isLoading: We(r.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: r.errors || {},
+    disabled: r.disabled || !1
+  }, n = {}, s = ie(r.defaultValues) || ie(r.values) ? oe(r.defaultValues || r.values) || {} : {}, o = r.shouldUnregister ? {} : oe(s), 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 p = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }, d = {
+    values: rr(),
+    array: rr(),
+    state: rr()
+  }, x = yt(r.mode), w = yt(r.reValidateMode), g = r.criteriaMode === xe.all, A = (l) => (f) => {
+    clearTimeout(u), u = setTimeout(l, f);
+  }, E = async (l) => {
+    if (p.isValid || l) {
+      const f = r.resolver ? de((await N()).errors) : await U(n, !0);
+      f !== t.isValid && d.state.next({
+        isValid: f
+      });
+    }
+  }, b = (l, f) => {
+    (p.isValidating || p.validatingFields) && ((l || Array.from(a.mount)).forEach((h) => {
+      h && (f ? X(t.validatingFields, h, f) : ne(t.validatingFields, h));
+    }), d.state.next({
+      validatingFields: t.validatingFields,
+      isValidating: !de(t.validatingFields)
+    }));
+  }, m = (l, f = [], h, T, O = !0, _ = !0) => {
+    if (T && h) {
+      if (i.action = !0, _ && Array.isArray(C(n, l))) {
+        const I = h(C(n, l), T.argA, T.argB);
+        O && X(n, l, I);
+      }
+      if (_ && Array.isArray(C(t.errors, l))) {
+        const I = h(C(t.errors, l), T.argA, T.argB);
+        O && X(t.errors, l, I), co(t.errors, l);
+      }
+      if (p.touchedFields && _ && Array.isArray(C(t.touchedFields, l))) {
+        const I = h(C(t.touchedFields, l), T.argA, T.argB);
+        O && X(t.touchedFields, l, I);
+      }
+      p.dirtyFields && (t.dirtyFields = _t(s, o)), d.state.next({
+        name: l,
+        isDirty: V(l, f),
+        dirtyFields: t.dirtyFields,
+        errors: t.errors,
+        isValid: t.isValid
+      });
+    } else
+      X(o, l, f);
+  }, R = (l, f) => {
+    X(t.errors, l, f), d.state.next({
+      errors: t.errors
+    });
+  }, D = (l) => {
+    t.errors = l, d.state.next({
+      errors: t.errors,
+      isValid: !1
+    });
+  }, y = (l, f, h, T) => {
+    const O = C(n, l);
+    if (O) {
+      const _ = C(o, l, Q(h) ? C(s, l) : h);
+      Q(_) || T && T.defaultChecked || f ? X(o, l, f ? _ : sr(O._f)) : M(l, _), i.mount && E();
+    }
+  }, S = (l, f, h, T, O) => {
+    let _ = !1, I = !1;
+    const q = {
+      name: l
+    }, re = !!(C(n, l) && C(n, l)._f && C(n, l)._f.disabled);
+    if (!h || T) {
+      p.isDirty && (I = t.isDirty, t.isDirty = q.isDirty = V(), _ = I !== q.isDirty);
+      const me = re || Xe(C(s, l), f);
+      I = !!(!re && C(t.dirtyFields, l)), me || re ? ne(t.dirtyFields, l) : X(t.dirtyFields, l, !0), q.dirtyFields = t.dirtyFields, _ = _ || p.dirtyFields && I !== !me;
+    }
+    if (h) {
+      const me = C(t.touchedFields, l);
+      me || (X(t.touchedFields, l, h), q.touchedFields = t.touchedFields, _ = _ || p.touchedFields && me !== h);
+    }
+    return _ && O && d.state.next(q), _ ? q : {};
+  }, F = (l, f, h, T) => {
+    const O = C(t.errors, l), _ = p.isValid && Ee(f) && t.isValid !== f;
+    if (e.delayError && h ? (c = A(() => R(l, h)), c(e.delayError)) : (clearTimeout(u), c = null, h ? X(t.errors, l, h) : ne(t.errors, l)), (h ? !Xe(O, h) : O) || !de(T) || _) {
+      const I = {
+        ...T,
+        ..._ && Ee(f) ? { isValid: f } : {},
+        errors: t.errors,
+        name: l
+      };
+      t = {
+        ...t,
+        ...I
+      }, d.state.next(I);
+    }
+  }, N = async (l) => {
+    b(l, !0);
+    const f = await r.resolver(o, r.context, io(l || a.mount, n, r.criteriaMode, r.shouldUseNativeValidation));
+    return b(l), f;
+  }, $ = async (l) => {
+    const { errors: f } = await N(l);
+    if (l)
+      for (const h of l) {
+        const T = C(f, h);
+        T ? X(t.errors, h, T) : ne(t.errors, h);
+      }
+    else
+      t.errors = f;
+    return f;
+  }, U = async (l, f, h = {
+    valid: !0
+  }) => {
+    for (const T in l) {
+      const O = l[T];
+      if (O) {
+        const { _f: _, ...I } = O;
+        if (_) {
+          const q = a.array.has(_.name);
+          b([T], !0);
+          const re = await lr(O, o, g, r.shouldUseNativeValidation && !f, q);
+          if (b([T]), re[_.name] && (h.valid = !1, f))
+            break;
+          !f && (C(re, _.name) ? q ? mn(t.errors, re, _.name) : X(t.errors, _.name, re[_.name]) : ne(t.errors, _.name));
+        }
+        I && await U(I, f, h);
+      }
+    }
+    return h.valid;
+  }, J = () => {
+    for (const l of a.unMount) {
+      const f = C(n, l);
+      f && (f._f.refs ? f._f.refs.every((h) => !nr(h)) : !nr(f._f.ref)) && Ae(l);
+    }
+    a.unMount = /* @__PURE__ */ new Set();
+  }, V = (l, f) => (l && f && X(o, l, f), !Xe(ve(), s)), k = (l, f, h) => hn(l, a, {
+    ...i.mount ? o : Q(f) ? s : Re(l) ? { [l]: f } : f
+  }, h, f), j = (l) => bt(C(i.mount ? o : s, l, e.shouldUnregister ? C(s, l, []) : [])), M = (l, f, h = {}) => {
+    const T = C(n, l);
+    let O = f;
+    if (T) {
+      const _ = T._f;
+      _ && (!_.disabled && X(o, l, bn(f, _)), O = Ft(_.ref) && le(f) ? "" : f, vn(_.ref) ? [..._.ref.options].forEach((I) => I.selected = O.includes(I.value)) : _.refs ? wt(_.ref) ? _.refs.length > 1 ? _.refs.forEach((I) => (!I.defaultChecked || !I.disabled) && (I.checked = Array.isArray(O) ? !!O.find((q) => q === I.value) : O === I.value)) : _.refs[0] && (_.refs[0].checked = !!O) : _.refs.forEach((I) => I.checked = I.value === O) : wr(_.ref) ? _.ref.value = "" : (_.ref.value = O, _.ref.type || d.values.next({
+        name: l,
+        values: { ...o }
+      })));
+    }
+    (h.shouldDirty || h.shouldTouch) && S(l, O, h.shouldTouch, h.shouldDirty, !0), h.shouldValidate && be(l);
+  }, W = (l, f, h) => {
+    for (const T in f) {
+      const O = f[T], _ = `${l}.${T}`, I = C(n, _);
+      (a.array.has(l) || !Vt(O) || I && !I._f) && !at(O) ? W(_, O, h) : M(_, O, h);
+    }
+  }, L = (l, f, h = {}) => {
+    const T = C(n, l), O = a.array.has(l), _ = oe(f);
+    X(o, l, _), O ? (d.array.next({
+      name: l,
+      values: { ...o }
+    }), (p.isDirty || p.dirtyFields) && h.shouldDirty && d.state.next({
+      name: l,
+      dirtyFields: _t(s, o),
+      isDirty: V(l, _)
+    })) : T && !T._f && !le(_) ? W(l, _, h) : M(l, _, h), ar(l, a) && d.state.next({ ...t }), d.values.next({
+      name: i.mount ? l : void 0,
+      values: { ...o }
+    });
+  }, Z = async (l) => {
+    i.mount = !0;
+    const f = l.target;
+    let h = f.name, T = !0;
+    const O = C(n, h), _ = () => f.type ? sr(O._f) : an(l), I = (q) => {
+      T = Number.isNaN(q) || q === C(o, h, q);
+    };
+    if (O) {
+      let q, re;
+      const me = _(), rt = l.type === Ot.BLUR || l.type === Ot.FOCUS_OUT, Es = !ao(O._f) && !r.resolver && !C(t.errors, h) && !O._f.deps || lo(rt, C(t.touchedFields, h), t.isSubmitted, w, x), zt = ar(h, a, rt);
+      X(o, h, me), rt ? (O._f.onBlur && O._f.onBlur(l), c && c(0)) : O._f.onChange && O._f.onChange(l);
+      const Kt = S(h, me, rt, !1), Rs = !de(Kt) || zt;
+      if (!rt && d.values.next({
+        name: h,
+        type: l.type,
+        values: { ...o }
+      }), Es)
+        return p.isValid && E(), Rs && d.state.next({ name: h, ...zt ? {} : Kt });
+      if (!rt && zt && d.state.next({ ...t }), r.resolver) {
+        const { errors: Vr } = await N([h]);
+        if (I(me), T) {
+          const Ps = Wr(t.errors, n, h), Dr = Wr(Vr, n, Ps.name || h);
+          q = Dr.error, h = Dr.name, re = de(Vr);
+        }
+      } else
+        b([h], !0), q = (await lr(O, o, g, r.shouldUseNativeValidation))[h], b([h]), I(me), T && (q ? re = !1 : p.isValid && (re = await U(n, !0)));
+      T && (O._f.deps && be(O._f.deps), F(h, re, q, Kt));
+    }
+  }, ee = (l, f) => {
+    if (C(t.errors, f) && l.focus)
+      return l.focus(), 1;
+  }, be = async (l, f = {}) => {
+    let h, T;
+    const O = pe(l);
+    if (r.resolver) {
+      const _ = await $(Q(l) ? l : O);
+      h = de(_), T = l ? !O.some((I) => C(_, I)) : h;
+    } else l ? (T = (await Promise.all(O.map(async (_) => {
+      const I = C(n, _);
+      return await U(I && I._f ? { [_]: I } : I);
+    }))).every(Boolean), !(!T && !t.isValid) && E()) : T = h = await U(n);
+    return d.state.next({
+      ...!Re(l) || p.isValid && h !== t.isValid ? {} : { name: l },
+      ...r.resolver || !l ? { isValid: h } : {},
+      errors: t.errors
+    }), f.shouldFocus && !T && lt(n, ee, l ? O : a.mount), T;
+  }, ve = (l) => {
+    const f = {
+      ...i.mount ? o : s
+    };
+    return Q(l) ? f : Re(l) ? C(f, l) : l.map((h) => C(f, h));
+  }, Me = (l, f) => ({
+    invalid: !!C((f || t).errors, l),
+    isDirty: !!C((f || t).dirtyFields, l),
+    error: C((f || t).errors, l),
+    isValidating: !!C(t.validatingFields, l),
+    isTouched: !!C((f || t).touchedFields, l)
+  }), Ge = (l) => {
+    l && pe(l).forEach((f) => ne(t.errors, f)), d.state.next({
+      errors: l ? t.errors : {}
+    });
+  }, Se = (l, f, h) => {
+    const T = (C(n, l, { _f: {} })._f || {}).ref, O = C(t.errors, l) || {}, { ref: _, message: I, type: q, ...re } = O;
+    X(t.errors, l, {
+      ...re,
+      ...f,
+      ref: T
+    }), d.state.next({
+      name: l,
+      errors: t.errors,
+      isValid: !1
+    }), h && h.shouldFocus && T && T.focus && T.focus();
+  }, Le = (l, f) => We(l) ? d.values.subscribe({
+    next: (h) => l(k(void 0, f), h)
+  }) : k(l, f, !0), Ae = (l, f = {}) => {
+    for (const h of l ? pe(l) : a.mount)
+      a.mount.delete(h), a.array.delete(h), f.keepValue || (ne(n, h), ne(o, h)), !f.keepError && ne(t.errors, h), !f.keepDirty && ne(t.dirtyFields, h), !f.keepTouched && ne(t.touchedFields, h), !f.keepIsValidating && ne(t.validatingFields, h), !r.shouldUnregister && !f.keepDefaultValue && ne(s, h);
+    d.values.next({
+      values: { ...o }
+    }), d.state.next({
+      ...t,
+      ...f.keepDirty ? { isDirty: V() } : {}
+    }), !f.keepIsValid && E();
+  }, B = ({ disabled: l, name: f, field: h, fields: T, value: O }) => {
+    if (Ee(l) && i.mount || l) {
+      const _ = l ? void 0 : Q(O) ? sr(h ? h._f : C(T, f)._f) : O;
+      X(o, f, _), S(f, _, !1, !1, !0);
+    }
+  }, Y = (l, f = {}) => {
+    let h = C(n, l);
+    const T = Ee(f.disabled);
+    return X(n, l, {
+      ...h || {},
+      _f: {
+        ...h && h._f ? h._f : { ref: { name: l } },
+        name: l,
+        mount: !0,
+        ...f
+      }
+    }), a.mount.add(l), h ? B({
+      field: h,
+      disabled: f.disabled,
+      name: l,
+      value: f.value
+    }) : y(l, !0, f.value), {
+      ...T ? { disabled: f.disabled } : {},
+      ...r.progressive ? {
+        required: !!f.required,
+        min: mt(f.min),
+        max: mt(f.max),
+        minLength: mt(f.minLength),
+        maxLength: mt(f.maxLength),
+        pattern: mt(f.pattern)
+      } : {},
+      name: l,
+      onChange: Z,
+      onBlur: Z,
+      ref: (O) => {
+        if (O) {
+          Y(l, f), h = C(n, l);
+          const _ = Q(O.value) && O.querySelectorAll && O.querySelectorAll("input,select,textarea")[0] || O, I = oo(_), q = h._f.refs || [];
+          if (I ? q.find((re) => re === _) : _ === h._f.ref)
+            return;
+          X(n, l, {
+            _f: {
+              ...h._f,
+              ...I ? {
+                refs: [
+                  ...q.filter(nr),
+                  _,
+                  ...Array.isArray(C(s, l)) ? [{}] : []
+                ],
+                ref: { type: _.type, name: l }
+              } : { ref: _ }
+            }
+          }), y(l, !1, void 0, _);
+        } else
+          h = C(n, l, {}), h._f && (h._f.mount = !1), (r.shouldUnregister || f.shouldUnregister) && !(ln(a.array, l) && i.action) && a.unMount.add(l);
+      }
+    };
+  }, se = () => r.shouldFocusError && lt(n, ee, a.mount), G = (l) => {
+    Ee(l) && (d.state.next({ disabled: l }), lt(n, (f, h) => {
+      const T = C(n, h);
+      T && (f.disabled = T._f.disabled || l, Array.isArray(T._f.refs) && T._f.refs.forEach((O) => {
+        O.disabled = T._f.disabled || l;
+      }));
+    }, 0, !1));
+  }, z = (l, f) => async (h) => {
+    let T;
+    h && (h.preventDefault && h.preventDefault(), h.persist && h.persist());
+    let O = oe(o);
+    if (d.state.next({
+      isSubmitting: !0
+    }), r.resolver) {
+      const { errors: _, values: I } = await N();
+      t.errors = _, O = I;
+    } else
+      await U(n);
+    if (ne(t.errors, "root"), de(t.errors)) {
+      d.state.next({
+        errors: {}
+      });
+      try {
+        await l(O, h);
+      } catch (_) {
+        T = _;
+      }
+    } else
+      f && await f({ ...t.errors }, h), se(), setTimeout(se);
+    if (d.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: de(t.errors) && !T,
+      submitCount: t.submitCount + 1,
+      errors: t.errors
+    }), T)
+      throw T;
+  }, K = (l, f = {}) => {
+    C(n, l) && (Q(f.defaultValue) ? L(l, oe(C(s, l))) : (L(l, f.defaultValue), X(s, l, oe(f.defaultValue))), f.keepTouched || ne(t.touchedFields, l), f.keepDirty || (ne(t.dirtyFields, l), t.isDirty = f.defaultValue ? V(l, oe(C(s, l))) : V()), f.keepError || (ne(t.errors, l), p.isValid && E()), d.state.next({ ...t }));
+  }, ae = (l, f = {}) => {
+    const h = l ? oe(l) : s, T = oe(h), O = de(l), _ = O ? s : T;
+    if (f.keepDefaultValues || (s = h), !f.keepValues) {
+      if (f.keepDirtyValues)
+        for (const I of a.mount)
+          C(t.dirtyFields, I) ? X(_, I, C(o, I)) : L(I, C(_, I));
+      else {
+        if (vr && Q(l))
+          for (const I of a.mount) {
+            const q = C(n, I);
+            if (q && q._f) {
+              const re = Array.isArray(q._f.refs) ? q._f.refs[0] : q._f.ref;
+              if (Ft(re)) {
+                const me = re.closest("form");
+                if (me) {
+                  me.reset();
+                  break;
+                }
+              }
+            }
+          }
+        n = {};
+      }
+      o = e.shouldUnregister ? f.keepDefaultValues ? oe(s) : {} : oe(_), d.array.next({
+        values: { ..._ }
+      }), d.values.next({
+        values: { ..._ }
+      });
+    }
+    a = {
+      mount: f.keepDirtyValues ? a.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, i.mount = !p.isValid || !!f.keepIsValid || !!f.keepDirtyValues, i.watch = !!e.shouldUnregister, d.state.next({
+      submitCount: f.keepSubmitCount ? t.submitCount : 0,
+      isDirty: O ? !1 : f.keepDirty ? t.isDirty : !!(f.keepDefaultValues && !Xe(l, s)),
+      isSubmitted: f.keepIsSubmitted ? t.isSubmitted : !1,
+      dirtyFields: O ? {} : f.keepDirtyValues ? f.keepDefaultValues && o ? _t(s, o) : t.dirtyFields : f.keepDefaultValues && l ? _t(s, l) : f.keepDirty ? t.dirtyFields : {},
+      touchedFields: f.keepTouched ? t.touchedFields : {},
+      errors: f.keepErrors ? t.errors : {},
+      isSubmitSuccessful: f.keepIsSubmitSuccessful ? t.isSubmitSuccessful : !1,
+      isSubmitting: !1
+    });
+  }, he = (l, f) => ae(We(l) ? l(o) : l, f);
+  return {
+    control: {
+      register: Y,
+      unregister: Ae,
+      getFieldState: Me,
+      handleSubmit: z,
+      setError: Se,
+      _executeSchema: N,
+      _getWatch: k,
+      _getDirty: V,
+      _updateValid: E,
+      _removeUnmounted: J,
+      _updateFieldArray: m,
+      _updateDisabledField: B,
+      _getFieldArray: j,
+      _reset: ae,
+      _resetDefaultValues: () => We(r.defaultValues) && r.defaultValues().then((l) => {
+        he(l, r.resetOptions), d.state.next({
+          isLoading: !1
+        });
+      }),
+      _updateFormState: (l) => {
+        t = {
+          ...t,
+          ...l
+        };
+      },
+      _disableForm: G,
+      _subjects: d,
+      _proxyFormState: p,
+      _setErrors: D,
+      get _fields() {
+        return n;
+      },
+      get _formValues() {
+        return o;
+      },
+      get _state() {
+        return i;
+      },
+      set _state(l) {
+        i = l;
+      },
+      get _defaultValues() {
+        return s;
+      },
+      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: be,
+    register: Y,
+    handleSubmit: z,
+    watch: Le,
+    setValue: L,
+    getValues: ve,
+    reset: he,
+    resetField: K,
+    clearErrors: Ge,
+    unregister: Ae,
+    setError: Se,
+    setFocus: (l, f = {}) => {
+      const h = C(n, l), T = h && h._f;
+      if (T) {
+        const O = T.refs ? T.refs[0] : T.ref;
+        O.focus && (O.focus(), f.shouldSelect && O.select());
+      }
+    },
+    getFieldState: Me
+  };
+}
+function aa(e = {}) {
+  const r = H.useRef(), t = H.useRef(), [n, s] = H.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: We(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1,
+    defaultValues: We(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  r.current || (r.current = {
+    ...fo(e),
+    formState: n
+  });
+  const o = r.current.control;
+  return o._options = e, Bt({
+    subject: o._subjects.state,
+    next: (i) => {
+      dn(i, o._proxyFormState, o._updateFormState, !0) && s({ ...o._formState });
+    }
+  }), H.useEffect(() => o._disableForm(e.disabled), [o, e.disabled]), H.useEffect(() => {
+    if (o._proxyFormState.isDirty) {
+      const i = o._getDirty();
+      i !== n.isDirty && o._subjects.state.next({
+        isDirty: i
+      });
+    }
+  }, [o, n.isDirty]), H.useEffect(() => {
+    e.values && !Xe(e.values, t.current) ? (o._reset(e.values, o._options.resetOptions), t.current = e.values, s((i) => ({ ...i }))) : o._resetDefaultValues();
+  }, [e.values, o]), H.useEffect(() => {
+    e.errors && o._setErrors(e.errors);
+  }, [e.errors, o]), H.useEffect(() => {
+    o._state.mount || (o._updateValid(), o._state.mount = !0), o._state.watch && (o._state.watch = !1, o._subjects.state.next({ ...o._formState })), o._removeUnmounted();
+  }), H.useEffect(() => {
+    e.shouldUnregister && o._subjects.values.next({
+      values: o._getWatch()
+    });
+  }, [e.shouldUnregister, o]), r.current.formState = fn(n, o), r.current;
+}
+function Ur(e, [r, t]) {
+  return Math.min(t, Math.max(r, e));
+}
+const po = ["top", "right", "bottom", "left"], $e = Math.min, ge = Math.max, Nt = Math.round, Ct = Math.floor, ze = (e) => ({
+  x: e,
+  y: e
+}), ho = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, mo = {
+  start: "end",
+  end: "start"
+};
+function cr(e, r, t) {
+  return ge(e, $e(r, t));
+}
+function Ne(e, r) {
+  return typeof e == "function" ? e(r) : e;
+}
+function Ie(e) {
+  return e.split("-")[0];
+}
+function ft(e) {
+  return e.split("-")[1];
+}
+function Sr(e) {
+  return e === "x" ? "y" : "x";
+}
+function Ar(e) {
+  return e === "y" ? "height" : "width";
+}
+function dt(e) {
+  return ["top", "bottom"].includes(Ie(e)) ? "y" : "x";
+}
+function _r(e) {
+  return Sr(dt(e));
+}
+function go(e, r, t) {
+  t === void 0 && (t = !1);
+  const n = ft(e), s = _r(e), o = Ar(s);
+  let i = s === "x" ? n === (t ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return r.reference[o] > r.floating[o] && (i = It(i)), [i, It(i)];
+}
+function yo(e) {
+  const r = It(e);
+  return [ur(e), r, ur(r)];
+}
+function ur(e) {
+  return e.replace(/start|end/g, (r) => mo[r]);
+}
+function vo(e, r, t) {
+  const n = ["left", "right"], s = ["right", "left"], o = ["top", "bottom"], i = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return t ? r ? s : n : r ? n : s;
+    case "left":
+    case "right":
+      return r ? o : i;
+    default:
+      return [];
+  }
+}
+function xo(e, r, t, n) {
+  const s = ft(e);
+  let o = vo(Ie(e), t === "start", n);
+  return s && (o = o.map((i) => i + "-" + s), r && (o = o.concat(o.map(ur)))), o;
+}
+function It(e) {
+  return e.replace(/left|right|bottom|top/g, (r) => ho[r]);
+}
+function wo(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Sn(e) {
+  return typeof e != "number" ? wo(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function kt(e) {
+  const {
+    x: r,
+    y: t,
+    width: n,
+    height: s
+  } = e;
+  return {
+    width: n,
+    height: s,
+    top: t,
+    left: r,
+    right: r + n,
+    bottom: t + s,
+    x: r,
+    y: t
+  };
+}
+function $r(e, r, t) {
+  let {
+    reference: n,
+    floating: s
+  } = e;
+  const o = dt(r), i = _r(r), a = Ar(i), c = Ie(r), u = o === "y", p = n.x + n.width / 2 - s.width / 2, d = n.y + n.height / 2 - s.height / 2, x = n[a] / 2 - s[a] / 2;
+  let w;
+  switch (c) {
+    case "top":
+      w = {
+        x: p,
+        y: n.y - s.height
+      };
+      break;
+    case "bottom":
+      w = {
+        x: p,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      w = {
+        x: n.x + n.width,
+        y: d
+      };
+      break;
+    case "left":
+      w = {
+        x: n.x - s.width,
+        y: d
+      };
+      break;
+    default:
+      w = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (ft(r)) {
+    case "start":
+      w[i] -= x * (t && u ? -1 : 1);
+      break;
+    case "end":
+      w[i] += x * (t && u ? -1 : 1);
+      break;
+  }
+  return w;
+}
+const bo = async (e, r, t) => {
+  const {
+    placement: n = "bottom",
+    strategy: s = "absolute",
+    middleware: o = [],
+    platform: i
+  } = t, a = o.filter(Boolean), c = await (i.isRTL == null ? void 0 : i.isRTL(r));
+  let u = await i.getElementRects({
+    reference: e,
+    floating: r,
+    strategy: s
+  }), {
+    x: p,
+    y: d
+  } = $r(u, n, c), x = n, w = {}, g = 0;
+  for (let A = 0; A < a.length; A++) {
+    const {
+      name: E,
+      fn: b
+    } = a[A], {
+      x: m,
+      y: R,
+      data: D,
+      reset: y
+    } = await b({
+      x: p,
+      y: d,
+      initialPlacement: n,
+      placement: x,
+      strategy: s,
+      middlewareData: w,
+      rects: u,
+      platform: i,
+      elements: {
+        reference: e,
+        floating: r
+      }
+    });
+    p = m ?? p, d = R ?? d, w = {
+      ...w,
+      [E]: {
+        ...w[E],
+        ...D
+      }
+    }, y && g <= 50 && (g++, typeof y == "object" && (y.placement && (x = y.placement), y.rects && (u = y.rects === !0 ? await i.getElementRects({
+      reference: e,
+      floating: r,
+      strategy: s
+    }) : y.rects), {
+      x: p,
+      y: d
+    } = $r(u, x, c)), A = -1);
+  }
+  return {
+    x: p,
+    y: d,
+    placement: x,
+    strategy: s,
+    middlewareData: w
+  };
+};
+async function vt(e, r) {
+  var t;
+  r === void 0 && (r = {});
+  const {
+    x: n,
+    y: s,
+    platform: o,
+    rects: i,
+    elements: a,
+    strategy: c
+  } = e, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: p = "viewport",
+    elementContext: d = "floating",
+    altBoundary: x = !1,
+    padding: w = 0
+  } = Ne(r, e), g = Sn(w), E = a[x ? d === "floating" ? "reference" : "floating" : d], b = kt(await o.getClippingRect({
+    element: (t = await (o.isElement == null ? void 0 : o.isElement(E))) == null || t ? E : E.contextElement || await (o.getDocumentElement == null ? void 0 : o.getDocumentElement(a.floating)),
+    boundary: u,
+    rootBoundary: p,
+    strategy: c
+  })), m = d === "floating" ? {
+    x: n,
+    y: s,
+    width: i.floating.width,
+    height: i.floating.height
+  } : i.reference, R = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(a.floating)), D = await (o.isElement == null ? void 0 : o.isElement(R)) ? await (o.getScale == null ? void 0 : o.getScale(R)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, y = kt(o.convertOffsetParentRelativeRectToViewportRelativeRect ? await o.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: m,
+    offsetParent: R,
+    strategy: c
+  }) : m);
+  return {
+    top: (b.top - y.top + g.top) / D.y,
+    bottom: (y.bottom - b.bottom + g.bottom) / D.y,
+    left: (b.left - y.left + g.left) / D.x,
+    right: (y.right - b.right + g.right) / D.x
+  };
+}
+const So = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(r) {
+    const {
+      x: t,
+      y: n,
+      placement: s,
+      rects: o,
+      platform: i,
+      elements: a,
+      middlewareData: c
+    } = r, {
+      element: u,
+      padding: p = 0
+    } = Ne(e, r) || {};
+    if (u == null)
+      return {};
+    const d = Sn(p), x = {
+      x: t,
+      y: n
+    }, w = _r(s), g = Ar(w), A = await i.getDimensions(u), E = w === "y", b = E ? "top" : "left", m = E ? "bottom" : "right", R = E ? "clientHeight" : "clientWidth", D = o.reference[g] + o.reference[w] - x[w] - o.floating[g], y = x[w] - o.reference[w], S = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(u));
+    let F = S ? S[R] : 0;
+    (!F || !await (i.isElement == null ? void 0 : i.isElement(S))) && (F = a.floating[R] || o.floating[g]);
+    const N = D / 2 - y / 2, $ = F / 2 - A[g] / 2 - 1, U = $e(d[b], $), J = $e(d[m], $), V = U, k = F - A[g] - J, j = F / 2 - A[g] / 2 + N, M = cr(V, j, k), W = !c.arrow && ft(s) != null && j !== M && o.reference[g] / 2 - (j < V ? U : J) - A[g] / 2 < 0, L = W ? j < V ? j - V : j - k : 0;
+    return {
+      [w]: x[w] + L,
+      data: {
+        [w]: M,
+        centerOffset: j - M - L,
+        ...W && {
+          alignmentOffset: L
+        }
+      },
+      reset: W
+    };
+  }
+}), Ao = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(r) {
+      var t, n;
+      const {
+        placement: s,
+        middlewareData: o,
+        rects: i,
+        initialPlacement: a,
+        platform: c,
+        elements: u
+      } = r, {
+        mainAxis: p = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: x,
+        fallbackStrategy: w = "bestFit",
+        fallbackAxisSideDirection: g = "none",
+        flipAlignment: A = !0,
+        ...E
+      } = Ne(e, r);
+      if ((t = o.arrow) != null && t.alignmentOffset)
+        return {};
+      const b = Ie(s), m = Ie(a) === a, R = await (c.isRTL == null ? void 0 : c.isRTL(u.floating)), D = x || (m || !A ? [It(a)] : yo(a));
+      !x && g !== "none" && D.push(...xo(a, A, g, R));
+      const y = [a, ...D], S = await vt(r, E), F = [];
+      let N = ((n = o.flip) == null ? void 0 : n.overflows) || [];
+      if (p && F.push(S[b]), d) {
+        const V = go(s, i, R);
+        F.push(S[V[0]], S[V[1]]);
+      }
+      if (N = [...N, {
+        placement: s,
+        overflows: F
+      }], !F.every((V) => V <= 0)) {
+        var $, U;
+        const V = ((($ = o.flip) == null ? void 0 : $.index) || 0) + 1, k = y[V];
+        if (k)
+          return {
+            data: {
+              index: V,
+              overflows: N
+            },
+            reset: {
+              placement: k
+            }
+          };
+        let j = (U = N.filter((M) => M.overflows[0] <= 0).sort((M, W) => M.overflows[1] - W.overflows[1])[0]) == null ? void 0 : U.placement;
+        if (!j)
+          switch (w) {
+            case "bestFit": {
+              var J;
+              const M = (J = N.map((W) => [W.placement, W.overflows.filter((L) => L > 0).reduce((L, Z) => L + Z, 0)]).sort((W, L) => W[1] - L[1])[0]) == null ? void 0 : J[0];
+              M && (j = M);
+              break;
+            }
+            case "initialPlacement":
+              j = a;
+              break;
+          }
+        if (s !== j)
+          return {
+            reset: {
+              placement: j
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function zr(e, r) {
+  return {
+    top: e.top - r.height,
+    right: e.right - r.width,
+    bottom: e.bottom - r.height,
+    left: e.left - r.width
+  };
+}
+function Kr(e) {
+  return po.some((r) => e[r] >= 0);
+}
+const _o = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(r) {
+      const {
+        rects: t
+      } = r, {
+        strategy: n = "referenceHidden",
+        ...s
+      } = Ne(e, r);
+      switch (n) {
+        case "referenceHidden": {
+          const o = await vt(r, {
+            ...s,
+            elementContext: "reference"
+          }), i = zr(o, t.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: i,
+              referenceHidden: Kr(i)
+            }
+          };
+        }
+        case "escaped": {
+          const o = await vt(r, {
+            ...s,
+            altBoundary: !0
+          }), i = zr(o, t.floating);
+          return {
+            data: {
+              escapedOffsets: i,
+              escaped: Kr(i)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+async function Co(e, r) {
+  const {
+    placement: t,
+    platform: n,
+    elements: s
+  } = e, o = await (n.isRTL == null ? void 0 : n.isRTL(s.floating)), i = Ie(t), a = ft(t), c = dt(t) === "y", u = ["left", "top"].includes(i) ? -1 : 1, p = o && c ? -1 : 1, d = Ne(r, e);
+  let {
+    mainAxis: x,
+    crossAxis: w,
+    alignmentAxis: g
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null,
+    ...d
+  };
+  return a && typeof g == "number" && (w = a === "end" ? g * -1 : g), c ? {
+    x: w * p,
+    y: x * u
+  } : {
+    x: x * u,
+    y: w * p
+  };
+}
+const Eo = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(r) {
+      var t, n;
+      const {
+        x: s,
+        y: o,
+        placement: i,
+        middlewareData: a
+      } = r, c = await Co(r, e);
+      return i === ((t = a.offset) == null ? void 0 : t.placement) && (n = a.arrow) != null && n.alignmentOffset ? {} : {
+        x: s + c.x,
+        y: o + c.y,
+        data: {
+          ...c,
+          placement: i
+        }
+      };
+    }
+  };
+}, Ro = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(r) {
+      const {
+        x: t,
+        y: n,
+        placement: s
+      } = r, {
+        mainAxis: o = !0,
+        crossAxis: i = !1,
+        limiter: a = {
+          fn: (E) => {
+            let {
+              x: b,
+              y: m
+            } = E;
+            return {
+              x: b,
+              y: m
+            };
+          }
+        },
+        ...c
+      } = Ne(e, r), u = {
+        x: t,
+        y: n
+      }, p = await vt(r, c), d = dt(Ie(s)), x = Sr(d);
+      let w = u[x], g = u[d];
+      if (o) {
+        const E = x === "y" ? "top" : "left", b = x === "y" ? "bottom" : "right", m = w + p[E], R = w - p[b];
+        w = cr(m, w, R);
+      }
+      if (i) {
+        const E = d === "y" ? "top" : "left", b = d === "y" ? "bottom" : "right", m = g + p[E], R = g - p[b];
+        g = cr(m, g, R);
+      }
+      const A = a.fn({
+        ...r,
+        [x]: w,
+        [d]: g
+      });
+      return {
+        ...A,
+        data: {
+          x: A.x - t,
+          y: A.y - n
+        }
+      };
+    }
+  };
+}, Po = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(r) {
+      const {
+        x: t,
+        y: n,
+        placement: s,
+        rects: o,
+        middlewareData: i
+      } = r, {
+        offset: a = 0,
+        mainAxis: c = !0,
+        crossAxis: u = !0
+      } = Ne(e, r), p = {
+        x: t,
+        y: n
+      }, d = dt(s), x = Sr(d);
+      let w = p[x], g = p[d];
+      const A = Ne(a, r), E = typeof A == "number" ? {
+        mainAxis: A,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...A
+      };
+      if (c) {
+        const R = x === "y" ? "height" : "width", D = o.reference[x] - o.floating[R] + E.mainAxis, y = o.reference[x] + o.reference[R] - E.mainAxis;
+        w < D ? w = D : w > y && (w = y);
+      }
+      if (u) {
+        var b, m;
+        const R = x === "y" ? "width" : "height", D = ["top", "left"].includes(Ie(s)), y = o.reference[d] - o.floating[R] + (D && ((b = i.offset) == null ? void 0 : b[d]) || 0) + (D ? 0 : E.crossAxis), S = o.reference[d] + o.reference[R] + (D ? 0 : ((m = i.offset) == null ? void 0 : m[d]) || 0) - (D ? E.crossAxis : 0);
+        g < y ? g = y : g > S && (g = S);
+      }
+      return {
+        [x]: w,
+        [d]: g
+      };
+    }
+  };
+}, Oo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(r) {
+      const {
+        placement: t,
+        rects: n,
+        platform: s,
+        elements: o
+      } = r, {
+        apply: i = () => {
+        },
+        ...a
+      } = Ne(e, r), c = await vt(r, a), u = Ie(t), p = ft(t), d = dt(t) === "y", {
+        width: x,
+        height: w
+      } = n.floating;
+      let g, A;
+      u === "top" || u === "bottom" ? (g = u, A = p === (await (s.isRTL == null ? void 0 : s.isRTL(o.floating)) ? "start" : "end") ? "left" : "right") : (A = u, g = p === "end" ? "top" : "bottom");
+      const E = w - c[g], b = x - c[A], m = !r.middlewareData.shift;
+      let R = E, D = b;
+      if (d) {
+        const S = x - c.left - c.right;
+        D = p || m ? $e(b, S) : S;
+      } else {
+        const S = w - c.top - c.bottom;
+        R = p || m ? $e(E, S) : S;
+      }
+      if (m && !p) {
+        const S = ge(c.left, 0), F = ge(c.right, 0), N = ge(c.top, 0), $ = ge(c.bottom, 0);
+        d ? D = x - 2 * (S !== 0 || F !== 0 ? S + F : ge(c.left, c.right)) : R = w - 2 * (N !== 0 || $ !== 0 ? N + $ : ge(c.top, c.bottom));
+      }
+      await i({
+        ...r,
+        availableWidth: D,
+        availableHeight: R
+      });
+      const y = await s.getDimensions(o.floating);
+      return x !== y.width || w !== y.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function pt(e) {
+  return An(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function ye(e) {
+  var r;
+  return (e == null || (r = e.ownerDocument) == null ? void 0 : r.defaultView) || window;
+}
+function ke(e) {
+  var r;
+  return (r = (An(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : r.documentElement;
+}
+function An(e) {
+  return e instanceof Node || e instanceof ye(e).Node;
+}
+function Pe(e) {
+  return e instanceof Element || e instanceof ye(e).Element;
+}
+function Oe(e) {
+  return e instanceof HTMLElement || e instanceof ye(e).HTMLElement;
+}
+function qr(e) {
+  return typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof ye(e).ShadowRoot;
+}
+function St(e) {
+  const {
+    overflow: r,
+    overflowX: t,
+    overflowY: n,
+    display: s
+  } = Ce(e);
+  return /auto|scroll|overlay|hidden|clip/.test(r + n + t) && !["inline", "contents"].includes(s);
+}
+function Fo(e) {
+  return ["table", "td", "th"].includes(pt(e));
+}
+function Cr(e) {
+  const r = Er(), t = Ce(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 To(e) {
+  let r = Ke(e);
+  for (; Oe(r) && !ut(r); ) {
+    if (Cr(r))
+      return r;
+    r = Ke(r);
+  }
+  return null;
+}
+function Er() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function ut(e) {
+  return ["html", "body", "#document"].includes(pt(e));
+}
+function Ce(e) {
+  return ye(e).getComputedStyle(e);
+}
+function Ht(e) {
+  return Pe(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.pageXOffset,
+    scrollTop: e.pageYOffset
+  };
+}
+function Ke(e) {
+  if (pt(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.
+    qr(e) && e.host || // Fallback.
+    ke(e)
+  );
+  return qr(r) ? r.host : r;
+}
+function _n(e) {
+  const r = Ke(e);
+  return ut(r) ? e.ownerDocument ? e.ownerDocument.body : e.body : Oe(r) && St(r) ? r : _n(r);
+}
+function xt(e, r, t) {
+  var n;
+  r === void 0 && (r = []), t === void 0 && (t = !0);
+  const s = _n(e), o = s === ((n = e.ownerDocument) == null ? void 0 : n.body), i = ye(s);
+  return o ? r.concat(i, i.visualViewport || [], St(s) ? s : [], i.frameElement && t ? xt(i.frameElement) : []) : r.concat(s, xt(s, [], t));
+}
+function Cn(e) {
+  const r = Ce(e);
+  let t = parseFloat(r.width) || 0, n = parseFloat(r.height) || 0;
+  const s = Oe(e), o = s ? e.offsetWidth : t, i = s ? e.offsetHeight : n, a = Nt(t) !== o || Nt(n) !== i;
+  return a && (t = o, n = i), {
+    width: t,
+    height: n,
+    $: a
+  };
+}
+function Rr(e) {
+  return Pe(e) ? e : e.contextElement;
+}
+function ct(e) {
+  const r = Rr(e);
+  if (!Oe(r))
+    return ze(1);
+  const t = r.getBoundingClientRect(), {
+    width: n,
+    height: s,
+    $: o
+  } = Cn(r);
+  let i = (o ? Nt(t.width) : t.width) / n, a = (o ? Nt(t.height) : t.height) / s;
+  return (!i || !Number.isFinite(i)) && (i = 1), (!a || !Number.isFinite(a)) && (a = 1), {
+    x: i,
+    y: a
+  };
+}
+const Vo = /* @__PURE__ */ ze(0);
+function En(e) {
+  const r = ye(e);
+  return !Er() || !r.visualViewport ? Vo : {
+    x: r.visualViewport.offsetLeft,
+    y: r.visualViewport.offsetTop
+  };
+}
+function Do(e, r, t) {
+  return r === void 0 && (r = !1), !t || r && t !== ye(e) ? !1 : r;
+}
+function Ze(e, r, t, n) {
+  r === void 0 && (r = !1), t === void 0 && (t = !1);
+  const s = e.getBoundingClientRect(), o = Rr(e);
+  let i = ze(1);
+  r && (n ? Pe(n) && (i = ct(n)) : i = ct(e));
+  const a = Do(o, t, n) ? En(o) : ze(0);
+  let c = (s.left + a.x) / i.x, u = (s.top + a.y) / i.y, p = s.width / i.x, d = s.height / i.y;
+  if (o) {
+    const x = ye(o), w = n && Pe(n) ? ye(n) : n;
+    let g = x, A = g.frameElement;
+    for (; A && n && w !== g; ) {
+      const E = ct(A), b = A.getBoundingClientRect(), m = Ce(A), R = b.left + (A.clientLeft + parseFloat(m.paddingLeft)) * E.x, D = b.top + (A.clientTop + parseFloat(m.paddingTop)) * E.y;
+      c *= E.x, u *= E.y, p *= E.x, d *= E.y, c += R, u += D, g = ye(A), A = g.frameElement;
+    }
+  }
+  return kt({
+    width: p,
+    height: d,
+    x: c,
+    y: u
+  });
+}
+const No = [":popover-open", ":modal"];
+function Pr(e) {
+  return No.some((r) => {
+    try {
+      return e.matches(r);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Io(e) {
+  let {
+    elements: r,
+    rect: t,
+    offsetParent: n,
+    strategy: s
+  } = e;
+  const o = s === "fixed", i = ke(n), a = r ? Pr(r.floating) : !1;
+  if (n === i || a && o)
+    return t;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = ze(1);
+  const p = ze(0), d = Oe(n);
+  if ((d || !d && !o) && ((pt(n) !== "body" || St(i)) && (c = Ht(n)), Oe(n))) {
+    const x = Ze(n);
+    u = ct(n), p.x = x.x + n.clientLeft, p.y = x.y + n.clientTop;
+  }
+  return {
+    width: t.width * u.x,
+    height: t.height * u.y,
+    x: t.x * u.x - c.scrollLeft * u.x + p.x,
+    y: t.y * u.y - c.scrollTop * u.y + p.y
+  };
+}
+function ko(e) {
+  return Array.from(e.getClientRects());
+}
+function Rn(e) {
+  return Ze(ke(e)).left + Ht(e).scrollLeft;
+}
+function Mo(e) {
+  const r = ke(e), t = Ht(e), n = e.ownerDocument.body, s = ge(r.scrollWidth, r.clientWidth, n.scrollWidth, n.clientWidth), o = ge(r.scrollHeight, r.clientHeight, n.scrollHeight, n.clientHeight);
+  let i = -t.scrollLeft + Rn(e);
+  const a = -t.scrollTop;
+  return Ce(n).direction === "rtl" && (i += ge(r.clientWidth, n.clientWidth) - s), {
+    width: s,
+    height: o,
+    x: i,
+    y: a
+  };
+}
+function Lo(e, r) {
+  const t = ye(e), n = ke(e), s = t.visualViewport;
+  let o = n.clientWidth, i = n.clientHeight, a = 0, c = 0;
+  if (s) {
+    o = s.width, i = s.height;
+    const u = Er();
+    (!u || u && r === "fixed") && (a = s.offsetLeft, c = s.offsetTop);
+  }
+  return {
+    width: o,
+    height: i,
+    x: a,
+    y: c
+  };
+}
+function jo(e, r) {
+  const t = Ze(e, !0, r === "fixed"), n = t.top + e.clientTop, s = t.left + e.clientLeft, o = Oe(e) ? ct(e) : ze(1), i = e.clientWidth * o.x, a = e.clientHeight * o.y, c = s * o.x, u = n * o.y;
+  return {
+    width: i,
+    height: a,
+    x: c,
+    y: u
+  };
+}
+function Yr(e, r, t) {
+  let n;
+  if (r === "viewport")
+    n = Lo(e, t);
+  else if (r === "document")
+    n = Mo(ke(e));
+  else if (Pe(r))
+    n = jo(r, t);
+  else {
+    const s = En(e);
+    n = {
+      ...r,
+      x: r.x - s.x,
+      y: r.y - s.y
+    };
+  }
+  return kt(n);
+}
+function Pn(e, r) {
+  const t = Ke(e);
+  return t === r || !Pe(t) || ut(t) ? !1 : Ce(t).position === "fixed" || Pn(t, r);
+}
+function Bo(e, r) {
+  const t = r.get(e);
+  if (t)
+    return t;
+  let n = xt(e, [], !1).filter((a) => Pe(a) && pt(a) !== "body"), s = null;
+  const o = Ce(e).position === "fixed";
+  let i = o ? Ke(e) : e;
+  for (; Pe(i) && !ut(i); ) {
+    const a = Ce(i), c = Cr(i);
+    !c && a.position === "fixed" && (s = null), (o ? !c && !s : !c && a.position === "static" && !!s && ["absolute", "fixed"].includes(s.position) || St(i) && !c && Pn(e, i)) ? n = n.filter((p) => p !== i) : s = a, i = Ke(i);
+  }
+  return r.set(e, n), n;
+}
+function Ho(e) {
+  let {
+    element: r,
+    boundary: t,
+    rootBoundary: n,
+    strategy: s
+  } = e;
+  const i = [...t === "clippingAncestors" ? Pr(r) ? [] : Bo(r, this._c) : [].concat(t), n], a = i[0], c = i.reduce((u, p) => {
+    const d = Yr(r, p, s);
+    return u.top = ge(d.top, u.top), u.right = $e(d.right, u.right), u.bottom = $e(d.bottom, u.bottom), u.left = ge(d.left, u.left), u;
+  }, Yr(r, a, s));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function Wo(e) {
+  const {
+    width: r,
+    height: t
+  } = Cn(e);
+  return {
+    width: r,
+    height: t
+  };
+}
+function Uo(e, r, t) {
+  const n = Oe(r), s = ke(r), o = t === "fixed", i = Ze(e, !0, o, r);
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = ze(0);
+  if (n || !n && !o)
+    if ((pt(r) !== "body" || St(s)) && (a = Ht(r)), n) {
+      const d = Ze(r, !0, o, r);
+      c.x = d.x + r.clientLeft, c.y = d.y + r.clientTop;
+    } else s && (c.x = Rn(s));
+  const u = i.left + a.scrollLeft - c.x, p = i.top + a.scrollTop - c.y;
+  return {
+    x: u,
+    y: p,
+    width: i.width,
+    height: i.height
+  };
+}
+function or(e) {
+  return Ce(e).position === "static";
+}
+function Gr(e, r) {
+  return !Oe(e) || Ce(e).position === "fixed" ? null : r ? r(e) : e.offsetParent;
+}
+function On(e, r) {
+  const t = ye(e);
+  if (Pr(e))
+    return t;
+  if (!Oe(e)) {
+    let s = Ke(e);
+    for (; s && !ut(s); ) {
+      if (Pe(s) && !or(s))
+        return s;
+      s = Ke(s);
+    }
+    return t;
+  }
+  let n = Gr(e, r);
+  for (; n && Fo(n) && or(n); )
+    n = Gr(n, r);
+  return n && ut(n) && or(n) && !Cr(n) ? t : n || To(e) || t;
+}
+const $o = async function(e) {
+  const r = this.getOffsetParent || On, t = this.getDimensions, n = await t(e.floating);
+  return {
+    reference: Uo(e.reference, await r(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function zo(e) {
+  return Ce(e).direction === "rtl";
+}
+const Ko = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Io,
+  getDocumentElement: ke,
+  getClippingRect: Ho,
+  getOffsetParent: On,
+  getElementRects: $o,
+  getClientRects: ko,
+  getDimensions: Wo,
+  getScale: ct,
+  isElement: Pe,
+  isRTL: zo
+};
+function qo(e, r) {
+  let t = null, n;
+  const s = ke(e);
+  function o() {
+    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), o();
+    const {
+      left: u,
+      top: p,
+      width: d,
+      height: x
+    } = e.getBoundingClientRect();
+    if (a || r(), !d || !x)
+      return;
+    const w = Ct(p), g = Ct(s.clientWidth - (u + d)), A = Ct(s.clientHeight - (p + x)), E = Ct(u), m = {
+      rootMargin: -w + "px " + -g + "px " + -A + "px " + -E + "px",
+      threshold: ge(0, $e(1, c)) || 1
+    };
+    let R = !0;
+    function D(y) {
+      const S = y[0].intersectionRatio;
+      if (S !== c) {
+        if (!R)
+          return i();
+        S ? i(!1, S) : n = setTimeout(() => {
+          i(!1, 1e-7);
+        }, 1e3);
+      }
+      R = !1;
+    }
+    try {
+      t = new IntersectionObserver(D, {
+        ...m,
+        // Handle <iframe>s
+        root: s.ownerDocument
+      });
+    } catch {
+      t = new IntersectionObserver(D, m);
+    }
+    t.observe(e);
+  }
+  return i(!0), o;
+}
+function Yo(e, r, t, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: s = !0,
+    ancestorResize: o = !0,
+    elementResize: i = typeof ResizeObserver == "function",
+    layoutShift: a = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = n, u = Rr(e), p = s || o ? [...u ? xt(u) : [], ...xt(r)] : [];
+  p.forEach((b) => {
+    s && b.addEventListener("scroll", t, {
+      passive: !0
+    }), o && b.addEventListener("resize", t);
+  });
+  const d = u && a ? qo(u, t) : null;
+  let x = -1, w = null;
+  i && (w = new ResizeObserver((b) => {
+    let [m] = b;
+    m && m.target === u && w && (w.unobserve(r), cancelAnimationFrame(x), x = requestAnimationFrame(() => {
+      var R;
+      (R = w) == null || R.observe(r);
+    })), t();
+  }), u && !c && w.observe(u), w.observe(r));
+  let g, A = c ? Ze(e) : null;
+  c && E();
+  function E() {
+    const b = Ze(e);
+    A && (b.x !== A.x || b.y !== A.y || b.width !== A.width || b.height !== A.height) && t(), A = b, g = requestAnimationFrame(E);
+  }
+  return t(), () => {
+    var b;
+    p.forEach((m) => {
+      s && m.removeEventListener("scroll", t), o && m.removeEventListener("resize", t);
+    }), d == null || d(), (b = w) == null || b.disconnect(), w = null, c && cancelAnimationFrame(g);
+  };
+}
+const Go = Eo, Xo = Ro, Zo = Ao, Qo = Oo, Jo = _o, Xr = So, ei = Po, ti = (e, r, t) => {
+  const n = /* @__PURE__ */ new Map(), s = {
+    platform: Ko,
+    ...t
+  }, o = {
+    ...s.platform,
+    _c: n
+  };
+  return bo(e, r, {
+    ...s,
+    platform: o
+  });
+}, ri = (e) => {
+  function r(t) {
+    return {}.hasOwnProperty.call(t, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(t) {
+      const {
+        element: n,
+        padding: s
+      } = typeof e == "function" ? e(t) : e;
+      return n && r(n) ? n.current != null ? Xr({
+        element: n.current,
+        padding: s
+      }).fn(t) : {} : n ? Xr({
+        element: n,
+        padding: s
+      }).fn(t) : {};
+    }
+  };
+};
+var Pt = typeof document < "u" ? Os : Fs;
+function Mt(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, s;
+  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 (!Mt(e[n], r[n]))
+          return !1;
+      return !0;
+    }
+    if (s = Object.keys(e), t = s.length, t !== Object.keys(r).length)
+      return !1;
+    for (n = t; n-- !== 0; )
+      if (!{}.hasOwnProperty.call(r, s[n]))
+        return !1;
+    for (n = t; n-- !== 0; ) {
+      const o = s[n];
+      if (!(o === "_owner" && e.$$typeof) && !Mt(e[o], r[o]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && r !== r;
+}
+function Fn(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function Zr(e, r) {
+  const t = Fn(e);
+  return Math.round(r * t) / t;
+}
+function Qr(e) {
+  const r = v.useRef(e);
+  return Pt(() => {
+    r.current = e;
+  }), r;
+}
+function ni(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: r = "bottom",
+    strategy: t = "absolute",
+    middleware: n = [],
+    platform: s,
+    elements: {
+      reference: o,
+      floating: i
+    } = {},
+    transform: a = !0,
+    whileElementsMounted: c,
+    open: u
+  } = e, [p, d] = v.useState({
+    x: 0,
+    y: 0,
+    strategy: t,
+    placement: r,
+    middlewareData: {},
+    isPositioned: !1
+  }), [x, w] = v.useState(n);
+  Mt(x, n) || w(n);
+  const [g, A] = v.useState(null), [E, b] = v.useState(null), m = v.useCallback((L) => {
+    L !== S.current && (S.current = L, A(L));
+  }, []), R = v.useCallback((L) => {
+    L !== F.current && (F.current = L, b(L));
+  }, []), D = o || g, y = i || E, S = v.useRef(null), F = v.useRef(null), N = v.useRef(p), $ = c != null, U = Qr(c), J = Qr(s), V = v.useCallback(() => {
+    if (!S.current || !F.current)
+      return;
+    const L = {
+      placement: r,
+      strategy: t,
+      middleware: x
+    };
+    J.current && (L.platform = J.current), ti(S.current, F.current, L).then((Z) => {
+      const ee = {
+        ...Z,
+        isPositioned: !0
+      };
+      k.current && !Mt(N.current, ee) && (N.current = ee, gr.flushSync(() => {
+        d(ee);
+      }));
+    });
+  }, [x, r, t, J]);
+  Pt(() => {
+    u === !1 && N.current.isPositioned && (N.current.isPositioned = !1, d((L) => ({
+      ...L,
+      isPositioned: !1
+    })));
+  }, [u]);
+  const k = v.useRef(!1);
+  Pt(() => (k.current = !0, () => {
+    k.current = !1;
+  }), []), Pt(() => {
+    if (D && (S.current = D), y && (F.current = y), D && y) {
+      if (U.current)
+        return U.current(D, y, V);
+      V();
+    }
+  }, [D, y, V, U, $]);
+  const j = v.useMemo(() => ({
+    reference: S,
+    floating: F,
+    setReference: m,
+    setFloating: R
+  }), [m, R]), M = v.useMemo(() => ({
+    reference: D,
+    floating: y
+  }), [D, y]), W = v.useMemo(() => {
+    const L = {
+      position: t,
+      left: 0,
+      top: 0
+    };
+    if (!M.floating)
+      return L;
+    const Z = Zr(M.floating, p.x), ee = Zr(M.floating, p.y);
+    return a ? {
+      ...L,
+      transform: "translate(" + Z + "px, " + ee + "px)",
+      ...Fn(M.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: t,
+      left: Z,
+      top: ee
+    };
+  }, [t, a, M.floating, p.x, p.y]);
+  return v.useMemo(() => ({
+    ...p,
+    update: V,
+    refs: j,
+    elements: M,
+    floatingStyles: W
+  }), [p, V, j, M, W]);
+}
+var si = "Arrow", Tn = v.forwardRef((e, r) => {
+  const { children: t, width: n = 10, height: s = 5, ...o } = e;
+  return /* @__PURE__ */ P.jsx(
+    ue.svg,
+    {
+      ...o,
+      ref: r,
+      width: n,
+      height: s,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: e.asChild ? t : /* @__PURE__ */ P.jsx("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+Tn.displayName = si;
+var oi = Tn;
+function ii(e) {
+  const [r, t] = v.useState(void 0);
+  return _e(() => {
+    if (e) {
+      t({ width: e.offsetWidth, height: e.offsetHeight });
+      const n = new ResizeObserver((s) => {
+        if (!Array.isArray(s) || !s.length)
+          return;
+        const o = s[0];
+        let i, a;
+        if ("borderBoxSize" in o) {
+          const c = o.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 Or = "Popper", [Vn, Dn] = tn(Or), [ai, Nn] = Vn(Or), In = (e) => {
+  const { __scopePopper: r, children: t } = e, [n, s] = v.useState(null);
+  return /* @__PURE__ */ P.jsx(ai, { scope: r, anchor: n, onAnchorChange: s, children: t });
+};
+In.displayName = Or;
+var kn = "PopperAnchor", Mn = v.forwardRef(
+  (e, r) => {
+    const { __scopePopper: t, virtualRef: n, ...s } = e, o = Nn(kn, t), i = v.useRef(null), a = we(r, i);
+    return v.useEffect(() => {
+      o.onAnchorChange((n == null ? void 0 : n.current) || i.current);
+    }), n ? null : /* @__PURE__ */ P.jsx(ue.div, { ...s, ref: a });
+  }
+);
+Mn.displayName = kn;
+var Fr = "PopperContent", [li, ci] = Vn(Fr), Ln = v.forwardRef(
+  (e, r) => {
+    var B, Y, se, G, z, K;
+    const {
+      __scopePopper: t,
+      side: n = "bottom",
+      sideOffset: s = 0,
+      align: o = "center",
+      alignOffset: i = 0,
+      arrowPadding: a = 0,
+      avoidCollisions: c = !0,
+      collisionBoundary: u = [],
+      collisionPadding: p = 0,
+      sticky: d = "partial",
+      hideWhenDetached: x = !1,
+      updatePositionStrategy: w = "optimized",
+      onPlaced: g,
+      ...A
+    } = e, E = Nn(Fr, t), [b, m] = v.useState(null), R = we(r, (ae) => m(ae)), [D, y] = v.useState(null), S = ii(D), F = (S == null ? void 0 : S.width) ?? 0, N = (S == null ? void 0 : S.height) ?? 0, $ = n + (o !== "center" ? "-" + o : ""), U = typeof p == "number" ? p : { top: 0, right: 0, bottom: 0, left: 0, ...p }, J = Array.isArray(u) ? u : [u], V = J.length > 0, k = {
+      padding: U,
+      boundary: J.filter(fi),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: V
+    }, { refs: j, floatingStyles: M, placement: W, isPositioned: L, middlewareData: Z } = ni({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: $,
+      whileElementsMounted: (...ae) => Yo(...ae, {
+        animationFrame: w === "always"
+      }),
+      elements: {
+        reference: E.anchor
+      },
+      middleware: [
+        Go({ mainAxis: s + N, alignmentAxis: i }),
+        c && Xo({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: d === "partial" ? ei() : void 0,
+          ...k
+        }),
+        c && Zo({ ...k }),
+        Qo({
+          ...k,
+          apply: ({ elements: ae, rects: he, availableWidth: Je, availableHeight: et }) => {
+            const { width: tt, height: l } = he.reference, f = ae.floating.style;
+            f.setProperty("--radix-popper-available-width", `${Je}px`), f.setProperty("--radix-popper-available-height", `${et}px`), f.setProperty("--radix-popper-anchor-width", `${tt}px`), f.setProperty("--radix-popper-anchor-height", `${l}px`);
+          }
+        }),
+        D && ri({ element: D, padding: a }),
+        di({ arrowWidth: F, arrowHeight: N }),
+        x && Jo({ strategy: "referenceHidden", ...k })
+      ]
+    }), [ee, be] = Hn(W), ve = rn(g);
+    _e(() => {
+      L && (ve == null || ve());
+    }, [L, ve]);
+    const Me = (B = Z.arrow) == null ? void 0 : B.x, Ge = (Y = Z.arrow) == null ? void 0 : Y.y, Se = ((se = Z.arrow) == null ? void 0 : se.centerOffset) !== 0, [Le, Ae] = v.useState();
+    return _e(() => {
+      b && Ae(window.getComputedStyle(b).zIndex);
+    }, [b]), /* @__PURE__ */ P.jsx(
+      "div",
+      {
+        ref: j.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...M,
+          transform: L ? M.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: Le,
+          "--radix-popper-transform-origin": [
+            (G = Z.transformOrigin) == null ? void 0 : G.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(
+          li,
+          {
+            scope: t,
+            placedSide: ee,
+            onArrowChange: y,
+            arrowX: Me,
+            arrowY: Ge,
+            shouldHideArrow: Se,
+            children: /* @__PURE__ */ P.jsx(
+              ue.div,
+              {
+                "data-side": ee,
+                "data-align": be,
+                ...A,
+                ref: R,
+                style: {
+                  ...A.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"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Ln.displayName = Fr;
+var jn = "PopperArrow", ui = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, Bn = v.forwardRef(function(r, t) {
+  const { __scopePopper: n, ...s } = r, o = ci(jn, n), i = ui[o.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: o.onArrowChange,
+        style: {
+          position: "absolute",
+          left: o.arrowX,
+          top: o.arrowY,
+          [i]: 0,
+          transformOrigin: {
+            top: "",
+            right: "0 0",
+            bottom: "center 0",
+            left: "100% 0"
+          }[o.placedSide],
+          transform: {
+            top: "translateY(100%)",
+            right: "translateY(50%) rotate(90deg) translateX(-50%)",
+            bottom: "rotate(180deg)",
+            left: "translateY(50%) rotate(-90deg) translateX(50%)"
+          }[o.placedSide],
+          visibility: o.shouldHideArrow ? "hidden" : void 0
+        },
+        children: /* @__PURE__ */ P.jsx(
+          oi,
+          {
+            ...s,
+            ref: t,
+            style: {
+              ...s.style,
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            }
+          }
+        )
+      }
+    )
+  );
+});
+Bn.displayName = jn;
+function fi(e) {
+  return e !== null;
+}
+var di = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(r) {
+    var E, b, m;
+    const { placement: t, rects: n, middlewareData: s } = r, i = ((E = s.arrow) == null ? void 0 : E.centerOffset) !== 0, a = i ? 0 : e.arrowWidth, c = i ? 0 : e.arrowHeight, [u, p] = Hn(t), d = { start: "0%", center: "50%", end: "100%" }[p], x = (((b = s.arrow) == null ? void 0 : b.x) ?? 0) + a / 2, w = (((m = s.arrow) == null ? void 0 : m.y) ?? 0) + c / 2;
+    let g = "", A = "";
+    return u === "bottom" ? (g = i ? d : `${x}px`, A = `${-c}px`) : u === "top" ? (g = i ? d : `${x}px`, A = `${n.floating.height + c}px`) : u === "right" ? (g = `${-c}px`, A = i ? d : `${w}px`) : u === "left" && (g = `${n.floating.width + c}px`, A = i ? d : `${w}px`), { data: { x: g, y: A } };
+  }
+});
+function Hn(e) {
+  const [r, t = "center"] = e.split("-");
+  return [r, t];
+}
+var pi = In, hi = Mn, mi = Ln, gi = Bn;
+function yi(e) {
+  const r = v.useRef({ value: e, previous: e });
+  return v.useMemo(() => (r.current.value !== e && (r.current.previous = r.current.value, r.current.value = e), r.current.previous), [e]);
+}
+var vi = [" ", "Enter", "ArrowUp", "ArrowDown"], xi = [" ", "Enter"], At = "Select", [Wt, Ut, wi] = Ls(At), [ht, la] = tn(At, [
+  wi,
+  Dn
+]), $t = Dn(), [bi, qe] = ht(At), [Si, Ai] = ht(At), Wn = (e) => {
+  const {
+    __scopeSelect: r,
+    children: t,
+    open: n,
+    defaultOpen: s,
+    onOpenChange: o,
+    value: i,
+    defaultValue: a,
+    onValueChange: c,
+    dir: u,
+    name: p,
+    autoComplete: d,
+    disabled: x,
+    required: w
+  } = e, g = $t(r), [A, E] = v.useState(null), [b, m] = v.useState(null), [R, D] = v.useState(!1), y = Ks(u), [S = !1, F] = kr({
+    prop: n,
+    defaultProp: s,
+    onChange: o
+  }), [N, $] = kr({
+    prop: i,
+    defaultProp: a,
+    onChange: c
+  }), U = v.useRef(null), J = A ? !!A.closest("form") : !0, [V, k] = v.useState(/* @__PURE__ */ new Set()), j = Array.from(V).map((M) => M.props.value).join(";");
+  return /* @__PURE__ */ P.jsx(pi, { ...g, children: /* @__PURE__ */ P.jsxs(
+    bi,
+    {
+      required: w,
+      scope: r,
+      trigger: A,
+      onTriggerChange: E,
+      valueNode: b,
+      onValueNodeChange: m,
+      valueNodeHasChildren: R,
+      onValueNodeHasChildrenChange: D,
+      contentId: yr(),
+      value: N,
+      onValueChange: $,
+      open: S,
+      onOpenChange: F,
+      dir: y,
+      triggerPointerDownPosRef: U,
+      disabled: x,
+      children: [
+        /* @__PURE__ */ P.jsx(Wt.Provider, { scope: r, children: /* @__PURE__ */ P.jsx(
+          Si,
+          {
+            scope: e.__scopeSelect,
+            onNativeOptionAdd: v.useCallback((M) => {
+              k((W) => new Set(W).add(M));
+            }, []),
+            onNativeOptionRemove: v.useCallback((M) => {
+              k((W) => {
+                const L = new Set(W);
+                return L.delete(M), L;
+              });
+            }, []),
+            children: t
+          }
+        ) }),
+        J ? /* @__PURE__ */ P.jsxs(
+          hs,
+          {
+            "aria-hidden": !0,
+            required: w,
+            tabIndex: -1,
+            name: p,
+            autoComplete: d,
+            value: N,
+            onChange: (M) => $(M.target.value),
+            disabled: x,
+            children: [
+              N === void 0 ? /* @__PURE__ */ P.jsx("option", { value: "" }) : null,
+              Array.from(V)
+            ]
+          },
+          j
+        ) : null
+      ]
+    }
+  ) });
+};
+Wn.displayName = At;
+var Un = "SelectTrigger", $n = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, disabled: n = !1, ...s } = e, o = $t(t), i = qe(Un, t), a = i.disabled || n, c = we(r, i.onTriggerChange), u = Ut(t), [p, d, x] = ms((g) => {
+      const A = u().filter((m) => !m.disabled), E = A.find((m) => m.value === i.value), b = gs(A, g, E);
+      b !== void 0 && i.onValueChange(b.value);
+    }), w = () => {
+      a || (i.onOpenChange(!0), x());
+    };
+    return /* @__PURE__ */ P.jsx(hi, { asChild: !0, ...o, children: /* @__PURE__ */ P.jsx(
+      ue.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": ps(i.value) ? "" : void 0,
+        ...s,
+        ref: c,
+        onClick: ce(s.onClick, (g) => {
+          g.currentTarget.focus();
+        }),
+        onPointerDown: ce(s.onPointerDown, (g) => {
+          const A = g.target;
+          A.hasPointerCapture(g.pointerId) && A.releasePointerCapture(g.pointerId), g.button === 0 && g.ctrlKey === !1 && (w(), i.triggerPointerDownPosRef.current = {
+            x: Math.round(g.pageX),
+            y: Math.round(g.pageY)
+          }, g.preventDefault());
+        }),
+        onKeyDown: ce(s.onKeyDown, (g) => {
+          const A = p.current !== "";
+          !(g.ctrlKey || g.altKey || g.metaKey) && g.key.length === 1 && d(g.key), !(A && g.key === " ") && vi.includes(g.key) && (w(), g.preventDefault());
+        })
+      }
+    ) });
+  }
+);
+$n.displayName = Un;
+var zn = "SelectValue", Kn = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, className: n, style: s, children: o, placeholder: i = "", ...a } = e, c = qe(zn, t), { onValueNodeHasChildrenChange: u } = c, p = o !== void 0, d = we(r, c.onValueNodeChange);
+    return _e(() => {
+      u(p);
+    }, [u, p]), /* @__PURE__ */ P.jsx(
+      ue.span,
+      {
+        ...a,
+        ref: d,
+        style: { pointerEvents: "none" },
+        children: ps(c.value) ? /* @__PURE__ */ P.jsx(P.Fragment, { children: i }) : o
+      }
+    );
+  }
+);
+Kn.displayName = zn;
+var _i = "SelectIcon", qn = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, children: n, ...s } = e;
+    return /* @__PURE__ */ P.jsx(ue.span, { "aria-hidden": !0, ...s, ref: r, children: n || "▼" });
+  }
+);
+qn.displayName = _i;
+var Ci = "SelectPortal", Yn = (e) => /* @__PURE__ */ P.jsx(zs, { asChild: !0, ...e });
+Yn.displayName = Ci;
+var Qe = "SelectContent", Gn = v.forwardRef(
+  (e, r) => {
+    const t = qe(Qe, e.__scopeSelect), [n, s] = v.useState();
+    if (_e(() => {
+      s(new DocumentFragment());
+    }, []), !t.open) {
+      const o = n;
+      return o ? gr.createPortal(
+        /* @__PURE__ */ P.jsx(Xn, { scope: e.__scopeSelect, children: /* @__PURE__ */ P.jsx(Wt.Slot, { scope: e.__scopeSelect, children: /* @__PURE__ */ P.jsx("div", { children: e.children }) }) }),
+        o
+      ) : null;
+    }
+    return /* @__PURE__ */ P.jsx(Zn, { ...e, ref: r });
+  }
+);
+Gn.displayName = Qe;
+var Te = 10, [Xn, Ye] = ht(Qe), Ei = "SelectContentImpl", Zn = v.forwardRef(
+  (e, r) => {
+    const {
+      __scopeSelect: t,
+      position: n = "item-aligned",
+      onCloseAutoFocus: s,
+      onEscapeKeyDown: o,
+      onPointerDownOutside: i,
+      //
+      // PopperContent props
+      side: a,
+      sideOffset: c,
+      align: u,
+      alignOffset: p,
+      arrowPadding: d,
+      collisionBoundary: x,
+      collisionPadding: w,
+      sticky: g,
+      hideWhenDetached: A,
+      avoidCollisions: E,
+      //
+      ...b
+    } = e, m = qe(Qe, t), [R, D] = v.useState(null), [y, S] = v.useState(null), F = we(r, (B) => D(B)), [N, $] = v.useState(null), [U, J] = v.useState(
+      null
+    ), V = Ut(t), [k, j] = v.useState(!1), M = v.useRef(!1);
+    v.useEffect(() => {
+      if (R) return js(R);
+    }, [R]), Bs();
+    const W = v.useCallback(
+      (B) => {
+        const [Y, ...se] = V().map((K) => K.ref.current), [G] = se.slice(-1), z = document.activeElement;
+        for (const K of B)
+          if (K === z || (K == null || K.scrollIntoView({ block: "nearest" }), K === Y && y && (y.scrollTop = 0), K === G && y && (y.scrollTop = y.scrollHeight), K == null || K.focus(), document.activeElement !== z)) return;
+      },
+      [V, y]
+    ), L = v.useCallback(
+      () => W([N, R]),
+      [W, N, R]
+    );
+    v.useEffect(() => {
+      k && L();
+    }, [k, L]);
+    const { onOpenChange: Z, triggerPointerDownPosRef: ee } = m;
+    v.useEffect(() => {
+      if (R) {
+        let B = { x: 0, y: 0 };
+        const Y = (G) => {
+          var z, K;
+          B = {
+            x: Math.abs(Math.round(G.pageX) - (((z = ee.current) == null ? void 0 : z.x) ?? 0)),
+            y: Math.abs(Math.round(G.pageY) - (((K = ee.current) == null ? void 0 : K.y) ?? 0))
+          };
+        }, se = (G) => {
+          B.x <= 10 && B.y <= 10 ? G.preventDefault() : R.contains(G.target) || Z(!1), document.removeEventListener("pointermove", Y), ee.current = null;
+        };
+        return ee.current !== null && (document.addEventListener("pointermove", Y), document.addEventListener("pointerup", se, { capture: !0, once: !0 })), () => {
+          document.removeEventListener("pointermove", Y), document.removeEventListener("pointerup", se, { capture: !0 });
+        };
+      }
+    }, [R, Z, ee]), v.useEffect(() => {
+      const B = () => Z(!1);
+      return window.addEventListener("blur", B), window.addEventListener("resize", B), () => {
+        window.removeEventListener("blur", B), window.removeEventListener("resize", B);
+      };
+    }, [Z]);
+    const [be, ve] = ms((B) => {
+      const Y = V().filter((z) => !z.disabled), se = Y.find((z) => z.ref.current === document.activeElement), G = gs(Y, B, se);
+      G && setTimeout(() => G.ref.current.focus());
+    }), Me = v.useCallback(
+      (B, Y, se) => {
+        const G = !M.current && !se;
+        (m.value !== void 0 && m.value === Y || G) && ($(B), G && (M.current = !0));
+      },
+      [m.value]
+    ), Ge = v.useCallback(() => R == null ? void 0 : R.focus(), [R]), Se = v.useCallback(
+      (B, Y, se) => {
+        const G = !M.current && !se;
+        (m.value !== void 0 && m.value === Y || G) && J(B);
+      },
+      [m.value]
+    ), Le = n === "popper" ? fr : Qn, Ae = Le === fr ? {
+      side: a,
+      sideOffset: c,
+      align: u,
+      alignOffset: p,
+      arrowPadding: d,
+      collisionBoundary: x,
+      collisionPadding: w,
+      sticky: g,
+      hideWhenDetached: A,
+      avoidCollisions: E
+    } : {};
+    return /* @__PURE__ */ P.jsx(
+      Xn,
+      {
+        scope: t,
+        content: R,
+        viewport: y,
+        onViewportChange: S,
+        itemRefCallback: Me,
+        selectedItem: N,
+        onItemLeave: Ge,
+        itemTextRefCallback: Se,
+        focusSelectedItem: L,
+        selectedItemText: U,
+        position: n,
+        isPositioned: k,
+        searchRef: be,
+        children: /* @__PURE__ */ P.jsx(Hs, { as: Ms, allowPinchZoom: !0, children: /* @__PURE__ */ P.jsx(
+          Ws,
+          {
+            asChild: !0,
+            trapped: m.open,
+            onMountAutoFocus: (B) => {
+              B.preventDefault();
+            },
+            onUnmountAutoFocus: ce(s, (B) => {
+              var Y;
+              (Y = m.trigger) == null || Y.focus({ preventScroll: !0 }), B.preventDefault();
+            }),
+            children: /* @__PURE__ */ P.jsx(
+              Us,
+              {
+                asChild: !0,
+                disableOutsidePointerEvents: !0,
+                onEscapeKeyDown: o,
+                onPointerDownOutside: i,
+                onFocusOutside: (B) => B.preventDefault(),
+                onDismiss: () => m.onOpenChange(!1),
+                children: /* @__PURE__ */ P.jsx(
+                  Le,
+                  {
+                    role: "listbox",
+                    id: m.contentId,
+                    "data-state": m.open ? "open" : "closed",
+                    dir: m.dir,
+                    onContextMenu: (B) => B.preventDefault(),
+                    ...b,
+                    ...Ae,
+                    onPlaced: () => j(!0),
+                    ref: F,
+                    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, (B) => {
+                      const Y = B.ctrlKey || B.altKey || B.metaKey;
+                      if (B.key === "Tab" && B.preventDefault(), !Y && B.key.length === 1 && ve(B.key), ["ArrowUp", "ArrowDown", "Home", "End"].includes(B.key)) {
+                        let G = V().filter((z) => !z.disabled).map((z) => z.ref.current);
+                        if (["ArrowUp", "End"].includes(B.key) && (G = G.slice().reverse()), ["ArrowUp", "ArrowDown"].includes(B.key)) {
+                          const z = B.target, K = G.indexOf(z);
+                          G = G.slice(K + 1);
+                        }
+                        setTimeout(() => W(G)), B.preventDefault();
+                      }
+                    })
+                  }
+                )
+              }
+            )
+          }
+        ) })
+      }
+    );
+  }
+);
+Zn.displayName = Ei;
+var Ri = "SelectItemAlignedPosition", Qn = v.forwardRef((e, r) => {
+  const { __scopeSelect: t, onPlaced: n, ...s } = e, o = qe(Qe, t), i = Ye(Qe, t), [a, c] = v.useState(null), [u, p] = v.useState(null), d = we(r, (F) => p(F)), x = Ut(t), w = v.useRef(!1), g = v.useRef(!0), { viewport: A, selectedItem: E, selectedItemText: b, focusSelectedItem: m } = i, R = v.useCallback(() => {
+    if (o.trigger && o.valueNode && a && u && A && E && b) {
+      const F = o.trigger.getBoundingClientRect(), N = u.getBoundingClientRect(), $ = o.valueNode.getBoundingClientRect(), U = b.getBoundingClientRect();
+      if (o.dir !== "rtl") {
+        const z = U.left - N.left, K = $.left - z, ae = F.left - K, he = F.width + ae, Je = Math.max(he, N.width), et = window.innerWidth - Te, tt = Ur(K, [Te, et - Je]);
+        a.style.minWidth = he + "px", a.style.left = tt + "px";
+      } else {
+        const z = N.right - U.right, K = window.innerWidth - $.right - z, ae = window.innerWidth - F.right - K, he = F.width + ae, Je = Math.max(he, N.width), et = window.innerWidth - Te, tt = Ur(K, [Te, et - Je]);
+        a.style.minWidth = he + "px", a.style.right = tt + "px";
+      }
+      const J = x(), V = window.innerHeight - Te * 2, k = A.scrollHeight, j = window.getComputedStyle(u), M = parseInt(j.borderTopWidth, 10), W = parseInt(j.paddingTop, 10), L = parseInt(j.borderBottomWidth, 10), Z = parseInt(j.paddingBottom, 10), ee = M + W + k + Z + L, be = Math.min(E.offsetHeight * 5, ee), ve = window.getComputedStyle(A), Me = parseInt(ve.paddingTop, 10), Ge = parseInt(ve.paddingBottom, 10), Se = F.top + F.height / 2 - Te, Le = V - Se, Ae = E.offsetHeight / 2, B = E.offsetTop + Ae, Y = M + W + B, se = ee - Y;
+      if (Y <= Se) {
+        const z = E === J[J.length - 1].ref.current;
+        a.style.bottom = "0px";
+        const K = u.clientHeight - A.offsetTop - A.offsetHeight, ae = Math.max(
+          Le,
+          Ae + // viewport might have padding bottom, include it to avoid a scrollable viewport
+          (z ? Ge : 0) + K + L
+        ), he = Y + ae;
+        a.style.height = he + "px";
+      } else {
+        const z = E === J[0].ref.current;
+        a.style.top = "0px";
+        const ae = Math.max(
+          Se,
+          M + A.offsetTop + // viewport might have padding top, include it to avoid a scrollable viewport
+          (z ? Me : 0) + Ae
+        ) + se;
+        a.style.height = ae + "px", A.scrollTop = Y - Se + A.offsetTop;
+      }
+      a.style.margin = `${Te}px 0`, a.style.minHeight = be + "px", a.style.maxHeight = V + "px", n == null || n(), requestAnimationFrame(() => w.current = !0);
+    }
+  }, [
+    x,
+    o.trigger,
+    o.valueNode,
+    a,
+    u,
+    A,
+    E,
+    b,
+    o.dir,
+    n
+  ]);
+  _e(() => R(), [R]);
+  const [D, y] = v.useState();
+  _e(() => {
+    u && y(window.getComputedStyle(u).zIndex);
+  }, [u]);
+  const S = v.useCallback(
+    (F) => {
+      F && g.current === !0 && (R(), m == null || m(), g.current = !1);
+    },
+    [R, m]
+  );
+  return /* @__PURE__ */ P.jsx(
+    Oi,
+    {
+      scope: t,
+      contentWrapper: a,
+      shouldExpandOnScrollRef: w,
+      onScrollButtonChange: S,
+      children: /* @__PURE__ */ P.jsx(
+        "div",
+        {
+          ref: c,
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            position: "fixed",
+            zIndex: D
+          },
+          children: /* @__PURE__ */ P.jsx(
+            ue.div,
+            {
+              ...s,
+              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%",
+                ...s.style
+              }
+            }
+          )
+        }
+      )
+    }
+  );
+});
+Qn.displayName = Ri;
+var Pi = "SelectPopperPosition", fr = v.forwardRef((e, r) => {
+  const {
+    __scopeSelect: t,
+    align: n = "start",
+    collisionPadding: s = Te,
+    ...o
+  } = e, i = $t(t);
+  return /* @__PURE__ */ P.jsx(
+    mi,
+    {
+      ...i,
+      ...o,
+      ref: r,
+      align: n,
+      collisionPadding: s,
+      style: {
+        // Ensure border-box for floating-ui calculations
+        boxSizing: "border-box",
+        ...o.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)"
+      }
+    }
+  );
+});
+fr.displayName = Pi;
+var [Oi, Tr] = ht(Qe, {}), dr = "SelectViewport", Jn = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, nonce: n, ...s } = e, o = Ye(dr, t), i = Tr(dr, t), a = we(r, o.onViewportChange), c = v.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(Wt.Slot, { scope: t, children: /* @__PURE__ */ P.jsx(
+        ue.div,
+        {
+          "data-radix-select-viewport": "",
+          role: "presentation",
+          ...s,
+          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",
+            ...s.style
+          },
+          onScroll: ce(s.onScroll, (u) => {
+            const p = u.currentTarget, { contentWrapper: d, shouldExpandOnScrollRef: x } = i;
+            if (x != null && x.current && d) {
+              const w = Math.abs(c.current - p.scrollTop);
+              if (w > 0) {
+                const g = window.innerHeight - Te * 2, A = parseFloat(d.style.minHeight), E = parseFloat(d.style.height), b = Math.max(A, E);
+                if (b < g) {
+                  const m = b + w, R = Math.min(g, m), D = m - R;
+                  d.style.height = R + "px", d.style.bottom === "0px" && (p.scrollTop = D > 0 ? D : 0, d.style.justifyContent = "flex-end");
+                }
+              }
+            }
+            c.current = p.scrollTop;
+          })
+        }
+      ) })
+    ] });
+  }
+);
+Jn.displayName = dr;
+var es = "SelectGroup", [Fi, Ti] = ht(es), ts = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e, s = yr();
+    return /* @__PURE__ */ P.jsx(Fi, { scope: t, id: s, children: /* @__PURE__ */ P.jsx(ue.div, { role: "group", "aria-labelledby": s, ...n, ref: r }) });
+  }
+);
+ts.displayName = es;
+var rs = "SelectLabel", ns = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e, s = Ti(rs, t);
+    return /* @__PURE__ */ P.jsx(ue.div, { id: s.id, ...n, ref: r });
+  }
+);
+ns.displayName = rs;
+var Lt = "SelectItem", [Vi, ss] = ht(Lt), os = v.forwardRef(
+  (e, r) => {
+    const {
+      __scopeSelect: t,
+      value: n,
+      disabled: s = !1,
+      textValue: o,
+      ...i
+    } = e, a = qe(Lt, t), c = Ye(Lt, t), u = a.value === n, [p, d] = v.useState(o ?? ""), [x, w] = v.useState(!1), g = we(
+      r,
+      (b) => {
+        var m;
+        return (m = c.itemRefCallback) == null ? void 0 : m.call(c, b, n, s);
+      }
+    ), A = yr(), E = () => {
+      s || (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(
+      Vi,
+      {
+        scope: t,
+        value: n,
+        disabled: s,
+        textId: A,
+        isSelected: u,
+        onItemTextChange: v.useCallback((b) => {
+          d((m) => m || ((b == null ? void 0 : b.textContent) ?? "").trim());
+        }, []),
+        children: /* @__PURE__ */ P.jsx(
+          Wt.ItemSlot,
+          {
+            scope: t,
+            value: n,
+            disabled: s,
+            textValue: p,
+            children: /* @__PURE__ */ P.jsx(
+              ue.div,
+              {
+                role: "option",
+                "aria-labelledby": A,
+                "data-highlighted": x ? "" : void 0,
+                "aria-selected": u && x,
+                "data-state": u ? "checked" : "unchecked",
+                "aria-disabled": s || void 0,
+                "data-disabled": s ? "" : void 0,
+                tabIndex: s ? void 0 : -1,
+                ...i,
+                ref: g,
+                onFocus: ce(i.onFocus, () => w(!0)),
+                onBlur: ce(i.onBlur, () => w(!1)),
+                onPointerUp: ce(i.onPointerUp, E),
+                onPointerMove: ce(i.onPointerMove, (b) => {
+                  var m;
+                  s ? (m = c.onItemLeave) == null || m.call(c) : b.currentTarget.focus({ preventScroll: !0 });
+                }),
+                onPointerLeave: ce(i.onPointerLeave, (b) => {
+                  var m;
+                  b.currentTarget === document.activeElement && ((m = c.onItemLeave) == null || m.call(c));
+                }),
+                onKeyDown: ce(i.onKeyDown, (b) => {
+                  var R;
+                  ((R = c.searchRef) == null ? void 0 : R.current) !== "" && b.key === " " || (xi.includes(b.key) && E(), b.key === " " && b.preventDefault());
+                })
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+os.displayName = Lt;
+var gt = "SelectItemText", is = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, className: n, style: s, ...o } = e, i = qe(gt, t), a = Ye(gt, t), c = ss(gt, t), u = Ai(gt, t), [p, d] = v.useState(null), x = we(
+      r,
+      (b) => d(b),
+      c.onItemTextChange,
+      (b) => {
+        var m;
+        return (m = a.itemTextRefCallback) == null ? void 0 : m.call(a, b, c.value, c.disabled);
+      }
+    ), w = p == null ? void 0 : p.textContent, g = v.useMemo(
+      () => /* @__PURE__ */ P.jsx("option", { value: c.value, disabled: c.disabled, children: w }, c.value),
+      [c.disabled, c.value, w]
+    ), { onNativeOptionAdd: A, onNativeOptionRemove: E } = u;
+    return _e(() => (A(g), () => E(g)), [A, E, g]), /* @__PURE__ */ P.jsxs(P.Fragment, { children: [
+      /* @__PURE__ */ P.jsx(ue.span, { id: c.textId, ...o, ref: x }),
+      c.isSelected && i.valueNode && !i.valueNodeHasChildren ? gr.createPortal(o.children, i.valueNode) : null
+    ] });
+  }
+);
+is.displayName = gt;
+var as = "SelectItemIndicator", ls = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e;
+    return ss(as, t).isSelected ? /* @__PURE__ */ P.jsx(ue.span, { "aria-hidden": !0, ...n, ref: r }) : null;
+  }
+);
+ls.displayName = as;
+var pr = "SelectScrollUpButton", cs = v.forwardRef((e, r) => {
+  const t = Ye(pr, e.__scopeSelect), n = Tr(pr, e.__scopeSelect), [s, o] = v.useState(!1), i = we(r, n.onScrollButtonChange);
+  return _e(() => {
+    if (t.viewport && t.isPositioned) {
+      let a = function() {
+        const u = c.scrollTop > 0;
+        o(u);
+      };
+      const c = t.viewport;
+      return a(), c.addEventListener("scroll", a), () => c.removeEventListener("scroll", a);
+    }
+  }, [t.viewport, t.isPositioned]), s ? /* @__PURE__ */ P.jsx(
+    fs,
+    {
+      ...e,
+      ref: i,
+      onAutoScroll: () => {
+        const { viewport: a, selectedItem: c } = t;
+        a && c && (a.scrollTop = a.scrollTop - c.offsetHeight);
+      }
+    }
+  ) : null;
+});
+cs.displayName = pr;
+var hr = "SelectScrollDownButton", us = v.forwardRef((e, r) => {
+  const t = Ye(hr, e.__scopeSelect), n = Tr(hr, e.__scopeSelect), [s, o] = v.useState(!1), i = we(r, n.onScrollButtonChange);
+  return _e(() => {
+    if (t.viewport && t.isPositioned) {
+      let a = function() {
+        const u = c.scrollHeight - c.clientHeight, p = Math.ceil(c.scrollTop) < u;
+        o(p);
+      };
+      const c = t.viewport;
+      return a(), c.addEventListener("scroll", a), () => c.removeEventListener("scroll", a);
+    }
+  }, [t.viewport, t.isPositioned]), s ? /* @__PURE__ */ P.jsx(
+    fs,
+    {
+      ...e,
+      ref: i,
+      onAutoScroll: () => {
+        const { viewport: a, selectedItem: c } = t;
+        a && c && (a.scrollTop = a.scrollTop + c.offsetHeight);
+      }
+    }
+  ) : null;
+});
+us.displayName = hr;
+var fs = v.forwardRef((e, r) => {
+  const { __scopeSelect: t, onAutoScroll: n, ...s } = e, o = Ye("SelectScrollButton", t), i = v.useRef(null), a = Ut(t), c = v.useCallback(() => {
+    i.current !== null && (window.clearInterval(i.current), i.current = null);
+  }, []);
+  return v.useEffect(() => () => c(), [c]), _e(() => {
+    var p;
+    const u = a().find((d) => d.ref.current === document.activeElement);
+    (p = u == null ? void 0 : u.ref.current) == null || p.scrollIntoView({ block: "nearest" });
+  }, [a]), /* @__PURE__ */ P.jsx(
+    ue.div,
+    {
+      "aria-hidden": !0,
+      ...s,
+      ref: r,
+      style: { flexShrink: 0, ...s.style },
+      onPointerDown: ce(s.onPointerDown, () => {
+        i.current === null && (i.current = window.setInterval(n, 50));
+      }),
+      onPointerMove: ce(s.onPointerMove, () => {
+        var u;
+        (u = o.onItemLeave) == null || u.call(o), i.current === null && (i.current = window.setInterval(n, 50));
+      }),
+      onPointerLeave: ce(s.onPointerLeave, () => {
+        c();
+      })
+    }
+  );
+}), Di = "SelectSeparator", ds = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e;
+    return /* @__PURE__ */ P.jsx(ue.div, { "aria-hidden": !0, ...n, ref: r });
+  }
+);
+ds.displayName = Di;
+var mr = "SelectArrow", Ni = v.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...n } = e, s = $t(t), o = qe(mr, t), i = Ye(mr, t);
+    return o.open && i.position === "popper" ? /* @__PURE__ */ P.jsx(gi, { ...s, ...n, ref: r }) : null;
+  }
+);
+Ni.displayName = mr;
+function ps(e) {
+  return e === "" || e === void 0;
+}
+var hs = v.forwardRef(
+  (e, r) => {
+    const { value: t, ...n } = e, s = v.useRef(null), o = we(r, s), i = yi(t);
+    return v.useEffect(() => {
+      const a = s.current, c = window.HTMLSelectElement.prototype, p = Object.getOwnPropertyDescriptor(
+        c,
+        "value"
+      ).set;
+      if (i !== t && p) {
+        const d = new Event("change", { bubbles: !0 });
+        p.call(a, t), a.dispatchEvent(d);
+      }
+    }, [i, t]), /* @__PURE__ */ P.jsx($s, { asChild: !0, children: /* @__PURE__ */ P.jsx("select", { ...n, ref: o, defaultValue: t }) });
+  }
+);
+hs.displayName = "BubbleSelect";
+function ms(e) {
+  const r = rn(e), t = v.useRef(""), n = v.useRef(0), s = v.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]
+  ), o = v.useCallback(() => {
+    t.current = "", window.clearTimeout(n.current);
+  }, []);
+  return v.useEffect(() => () => window.clearTimeout(n.current), []), [t, s, o];
+}
+function gs(e, r, t) {
+  const s = r.length > 1 && Array.from(r).every((u) => u === r[0]) ? r[0] : r, o = t ? e.indexOf(t) : -1;
+  let i = Ii(e, Math.max(o, 0));
+  s.length === 1 && (i = i.filter((u) => u !== t));
+  const c = i.find(
+    (u) => u.textValue.toLowerCase().startsWith(s.toLowerCase())
+  );
+  return c !== t ? c : void 0;
+}
+function Ii(e, r) {
+  return e.map((t, n) => e[(r + n) % e.length]);
+}
+var ki = Wn, ys = $n, Mi = Kn, Li = qn, ji = Yn, vs = Gn, Bi = Jn, Hi = ts, xs = ns, ws = os, Wi = is, Ui = ls, bs = cs, Ss = us, As = ds;
+const ca = ki, ua = Hi, fa = Mi, $i = v.forwardRef(({ className: e, children: r, ...t }, n) => /* @__PURE__ */ P.jsxs(
+  ys,
+  {
+    ref: n,
+    className: Ue(
+      "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(Li, { asChild: !0, children: /* @__PURE__ */ P.jsx(sn, { className: "flex-shrink-0 h-4 w-4 opacity-50" }) })
+    ]
+  }
+));
+$i.displayName = ys.displayName;
+const _s = v.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  bs,
+  {
+    ref: t,
+    className: Ue(
+      "flex cursor-default items-center justify-center py-1",
+      e
+    ),
+    ...r,
+    children: /* @__PURE__ */ P.jsx(Ys, { className: "h-4 w-4" })
+  }
+));
+_s.displayName = bs.displayName;
+const Cs = v.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  Ss,
+  {
+    ref: t,
+    className: Ue(
+      "flex cursor-default items-center justify-center py-1",
+      e
+    ),
+    ...r,
+    children: /* @__PURE__ */ P.jsx(sn, { className: "h-4 w-4" })
+  }
+));
+Cs.displayName = Ss.displayName;
+const zi = v.forwardRef(({ className: e, children: r, position: t = "popper", ...n }, s) => /* @__PURE__ */ P.jsx(ji, { children: /* @__PURE__ */ P.jsxs(
+  vs,
+  {
+    ref: s,
+    className: Ue(
+      "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(_s, {}),
+      /* @__PURE__ */ P.jsx(
+        Bi,
+        {
+          className: Ue(
+            "p-1",
+            t === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+          ),
+          children: r
+        }
+      ),
+      /* @__PURE__ */ P.jsx(Cs, {})
+    ]
+  }
+) }));
+zi.displayName = vs.displayName;
+const Ki = v.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  xs,
+  {
+    ref: t,
+    className: Ue("py-1.5 pl-8 pr-2 text-sm font-semibold", e),
+    ...r
+  }
+));
+Ki.displayName = xs.displayName;
+const qi = v.forwardRef(({ className: e, children: r, ...t }, n) => /* @__PURE__ */ P.jsxs(
+  ws,
+  {
+    ref: n,
+    className: Ue(
+      "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(Ui, { children: /* @__PURE__ */ P.jsx(qs, { className: "h-4 w-4" }) }) }),
+      /* @__PURE__ */ P.jsx(Wi, { children: r })
+    ]
+  }
+));
+qi.displayName = ws.displayName;
+const Yi = v.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ P.jsx(
+  As,
+  {
+    ref: t,
+    className: Ue("-mx-1 my-1 h-px bg-muted", e),
+    ...r
+  }
+));
+Yi.displayName = As.displayName;
+export {
+  oa as C,
+  sa as F,
+  ca as S,
+  na as a,
+  $i as b,
+  fa as c,
+  zi as d,
+  ua as e,
+  qi as f,
+  ia as g,
+  Js as h,
+  jt as i,
+  aa as u
+};
+//# sourceMappingURL=Select-CcBbwJ2R.js.map