zudoku 0.6.2-dev.4 → 0.6.2-dev.6

package/lib/Input-BBlyeDuG.js

@@ -0,0 +1,2192 @@
+var zt = (e) => {
+  throw TypeError(e);
+};
+var St = (e, r, t) => r.has(e) || zt("Cannot " + t);
+var G = (e, r, t) => (St(e, r, "read from private field"), t ? t.call(e) : r.get(e)), Ue = (e, r, t) => r.has(e) ? zt("Cannot add the same private member more than once") : r instanceof WeakSet ? r.add(e) : r.set(e, t), He = (e, r, t, s) => (St(e, r, "write to private field"), s ? s.call(e, t) : r.set(e, t), t), We = (e, r, t) => (St(e, r, "access private method"), t);
+import * as f from "react";
+import I from "react";
+import { n as fs, f as ps, c as hs, o as or, d as xe, A as ms, P as he, b as oe, e as Ne, i as ys, j as gs, R as vs, S as xs, F as Ss, D as _s, C as bs, a as Bt, p as ws, V as As, h as Cs, l as Es, g as Vs, u as Yt, q as Fs } from "./index-BLvMkqjO.js";
+import { S as Ts, s as Rs, h as Xt, n as ar, a as Is, d as Ns, e as Ds } from "./ZudokuContext-JoyeA9dT.js";
+import * as ir from "react-dom";
+import { j as E } from "./jsx-runtime-lNnQYwFN.js";
+import { ChevronDown as lr, ChevronUp as Ps, Check as ks } from "lucide-react";
+import { a as Ve } from "./Markdown-CCNihH_N.js";
+var Te, Re, ie, Ce, Ee, ot, Nt, nr, Ms = (nr = class extends Ts {
+  constructor(r, t) {
+    super();
+    Ue(this, Ee);
+    Ue(this, Te);
+    Ue(this, Re);
+    Ue(this, ie);
+    Ue(this, Ce);
+    He(this, Te, r), this.setOptions(t), this.bindMethods(), We(this, Ee, ot).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(r) {
+    var s;
+    const t = this.options;
+    this.options = G(this, Te).defaultMutationOptions(r), Rs(this.options, t) || G(this, Te).getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: G(this, ie),
+      observer: this
+    }), t != null && t.mutationKey && this.options.mutationKey && Xt(t.mutationKey) !== Xt(this.options.mutationKey) ? this.reset() : ((s = G(this, ie)) == null ? void 0 : s.state.status) === "pending" && G(this, ie).setOptions(this.options);
+  }
+  onUnsubscribe() {
+    var r;
+    this.hasListeners() || (r = G(this, ie)) == null || r.removeObserver(this);
+  }
+  onMutationUpdate(r) {
+    We(this, Ee, ot).call(this), We(this, Ee, Nt).call(this, r);
+  }
+  getCurrentResult() {
+    return G(this, Re);
+  }
+  reset() {
+    var r;
+    (r = G(this, ie)) == null || r.removeObserver(this), He(this, ie, void 0), We(this, Ee, ot).call(this), We(this, Ee, Nt).call(this);
+  }
+  mutate(r, t) {
+    var s;
+    return He(this, Ce, t), (s = G(this, ie)) == null || s.removeObserver(this), He(this, ie, G(this, Te).getMutationCache().build(G(this, Te), this.options)), G(this, ie).addObserver(this), G(this, ie).execute(r);
+  }
+}, Te = new WeakMap(), Re = new WeakMap(), ie = new WeakMap(), Ce = new WeakMap(), Ee = new WeakSet(), ot = function() {
+  var t;
+  const r = ((t = G(this, ie)) == null ? void 0 : t.state) ?? fs();
+  He(this, Re, {
+    ...r,
+    isPending: r.status === "pending",
+    isSuccess: r.status === "success",
+    isError: r.status === "error",
+    isIdle: r.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, Nt = function(r) {
+  ar.batch(() => {
+    var t, s, o, a, l, c, d, S;
+    if (G(this, Ce) && this.hasListeners()) {
+      const m = G(this, Re).variables, y = G(this, Re).context;
+      (r == null ? void 0 : r.type) === "success" ? ((s = (t = G(this, Ce)).onSuccess) == null || s.call(t, r.data, m, y), (a = (o = G(this, Ce)).onSettled) == null || a.call(o, r.data, null, m, y)) : (r == null ? void 0 : r.type) === "error" && ((c = (l = G(this, Ce)).onError) == null || c.call(l, r.error, m, y), (S = (d = G(this, Ce)).onSettled) == null || S.call(
+        d,
+        void 0,
+        r.error,
+        m,
+        y
+      ));
+    }
+    this.listeners.forEach((m) => {
+      m(G(this, Re));
+    });
+  });
+}, nr);
+function Bn(e, r) {
+  const t = Is(), [s] = f.useState(
+    () => new Ms(
+      t,
+      e
+    )
+  );
+  f.useEffect(() => {
+    s.setOptions(e);
+  }, [s, e]);
+  const o = f.useSyncExternalStore(
+    f.useCallback(
+      (l) => s.subscribe(ar.batchCalls(l)),
+      [s]
+    ),
+    () => s.getCurrentResult(),
+    () => s.getCurrentResult()
+  ), a = f.useCallback(
+    (l, c) => {
+      s.mutate(l, c).catch(Ns);
+    },
+    [s]
+  );
+  if (o.error && Ds(s.options.throwOnError, [o.error]))
+    throw o.error;
+  return { ...o, mutate: a, mutateAsync: o.mutate };
+}
+var Qe = (e) => e.type === "checkbox", $e = (e) => e instanceof Date, ne = (e) => e == null;
+const cr = (e) => typeof e == "object";
+var re = (e) => !ne(e) && !Array.isArray(e) && cr(e) && !$e(e), ur = (e) => re(e) && e.target ? Qe(e.target) ? e.target.checked : e.target.value : e, Os = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, dr = (e, r) => e.has(Os(r)), Ls = (e) => {
+  const r = e.constructor && e.constructor.prototype;
+  return re(r) && r.hasOwnProperty("isPrototypeOf");
+}, Ut = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function te(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 (!(Ut && (e instanceof Blob || e instanceof FileList)) && (t || re(e)))
+    if (r = t ? [] : {}, !t && !Ls(e))
+      r = e;
+    else
+      for (const s in e)
+        e.hasOwnProperty(s) && (r[s] = te(e[s]));
+  else
+    return e;
+  return r;
+}
+var Je = (e) => Array.isArray(e) ? e.filter(Boolean) : [], $ = (e) => e === void 0, h = (e, r, t) => {
+  if (!r || !re(e))
+    return t;
+  const s = Je(r.split(/[,[\].]+?/)).reduce((o, a) => ne(o) ? o : o[a], e);
+  return $(s) || s === e ? $(e[r]) ? t : e[r] : s;
+}, ge = (e) => typeof e == "boolean", Ht = (e) => /^\w*$/.test(e), fr = (e) => Je(e.replace(/["|']|\]/g, "").split(/\.|\[/)), H = (e, r, t) => {
+  let s = -1;
+  const o = Ht(r) ? [r] : fr(r), a = o.length, l = a - 1;
+  for (; ++s < a; ) {
+    const c = o[s];
+    let d = t;
+    if (s !== l) {
+      const S = e[c];
+      d = re(S) || Array.isArray(S) ? S : isNaN(+o[s + 1]) ? {} : [];
+    }
+    if (c === "__proto__")
+      return;
+    e[c] = d, e = e[c];
+  }
+  return e;
+};
+const it = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, pe = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, we = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+}, pr = I.createContext(null), pt = () => I.useContext(pr), Un = (e) => {
+  const { children: r, ...t } = e;
+  return I.createElement(pr.Provider, { value: t }, r);
+};
+var hr = (e, r, t, s = !0) => {
+  const o = {
+    defaultValues: r._defaultValues
+  };
+  for (const a in e)
+    Object.defineProperty(o, a, {
+      get: () => {
+        const l = a;
+        return r._proxyFormState[l] !== pe.all && (r._proxyFormState[l] = !s || pe.all), t && (t[l] = !0), e[l];
+      }
+    });
+  return o;
+}, le = (e) => re(e) && !Object.keys(e).length, mr = (e, r, t, s) => {
+  t(e);
+  const { name: o, ...a } = e;
+  return le(a) || Object.keys(a).length >= Object.keys(r).length || Object.keys(a).find((l) => r[l] === (!s || pe.all));
+}, ce = (e) => Array.isArray(e) ? e : [e], yr = (e, r, t) => !e || !r || e === r || ce(e).some((s) => s && (t ? s === r : s.startsWith(r) || r.startsWith(s)));
+function ht(e) {
+  const r = I.useRef(e);
+  r.current = e, I.useEffect(() => {
+    const t = !e.disabled && r.current.subject && r.current.subject.subscribe({
+      next: r.current.next
+    });
+    return () => {
+      t && t.unsubscribe();
+    };
+  }, [e.disabled]);
+}
+function js(e) {
+  const r = pt(), { control: t = r.control, disabled: s, name: o, exact: a } = e || {}, [l, c] = I.useState(t._formState), d = I.useRef(!0), S = I.useRef({
+    isDirty: !1,
+    isLoading: !1,
+    dirtyFields: !1,
+    touchedFields: !1,
+    validatingFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }), m = I.useRef(o);
+  return m.current = o, ht({
+    disabled: s,
+    next: (y) => d.current && yr(m.current, y.name, a) && mr(y, S.current, t._updateFormState) && c({
+      ...t._formState,
+      ...y
+    }),
+    subject: t._subjects.state
+  }), I.useEffect(() => (d.current = !0, S.current.isValid && t._updateValid(!0), () => {
+    d.current = !1;
+  }), [t]), hr(l, t, S.current, !1);
+}
+var ve = (e) => typeof e == "string", gr = (e, r, t, s, o) => ve(e) ? (s && r.watch.add(e), h(t, e, o)) : Array.isArray(e) ? e.map((a) => (s && r.watch.add(a), h(t, a))) : (s && (r.watchAll = !0), t);
+function Bs(e) {
+  const r = pt(), { control: t = r.control, name: s, defaultValue: o, disabled: a, exact: l } = e || {}, c = I.useRef(s);
+  c.current = s, ht({
+    disabled: a,
+    subject: t._subjects.values,
+    next: (m) => {
+      yr(c.current, m.name, l) && S(te(gr(c.current, t._names, m.values || t._formValues, !1, o)));
+    }
+  });
+  const [d, S] = I.useState(t._getWatch(s, o));
+  return I.useEffect(() => t._removeUnmounted()), d;
+}
+function Us(e) {
+  const r = pt(), { name: t, disabled: s, control: o = r.control, shouldUnregister: a } = e, l = dr(o._names.array, t), c = Bs({
+    control: o,
+    name: t,
+    defaultValue: h(o._formValues, t, h(o._defaultValues, t, e.defaultValue)),
+    exact: !0
+  }), d = js({
+    control: o,
+    name: t
+  }), S = I.useRef(o.register(t, {
+    ...e.rules,
+    value: c,
+    ...ge(e.disabled) ? { disabled: e.disabled } : {}
+  }));
+  return I.useEffect(() => {
+    const m = o._options.shouldUnregister || a, y = (V, O) => {
+      const b = h(o._fields, V);
+      b && b._f && (b._f.mount = O);
+    };
+    if (y(t, !0), m) {
+      const V = te(h(o._options.defaultValues, t));
+      H(o._defaultValues, t, V), $(h(o._formValues, t)) && H(o._formValues, t, V);
+    }
+    return () => {
+      (l ? m && !o._state.action : m) ? o.unregister(t) : y(t, !1);
+    };
+  }, [t, o, l, a]), I.useEffect(() => {
+    h(o._fields, t) && o._updateDisabledField({
+      disabled: s,
+      fields: o._fields,
+      name: t,
+      value: h(o._fields, t)._f.value
+    });
+  }, [s, t, o]), {
+    field: {
+      name: t,
+      value: c,
+      ...ge(s) || d.disabled ? { disabled: d.disabled || s } : {},
+      onChange: I.useCallback((m) => S.current.onChange({
+        target: {
+          value: ur(m),
+          name: t
+        },
+        type: it.CHANGE
+      }), [t]),
+      onBlur: I.useCallback(() => S.current.onBlur({
+        target: {
+          value: h(o._formValues, t),
+          name: t
+        },
+        type: it.BLUR
+      }), [t, o]),
+      ref: (m) => {
+        const y = h(o._fields, t);
+        y && m && (y._f.ref = {
+          focus: () => m.focus(),
+          select: () => m.select(),
+          setCustomValidity: (V) => m.setCustomValidity(V),
+          reportValidity: () => m.reportValidity()
+        });
+      }
+    },
+    formState: d,
+    fieldState: Object.defineProperties({}, {
+      invalid: {
+        enumerable: !0,
+        get: () => !!h(d.errors, t)
+      },
+      isDirty: {
+        enumerable: !0,
+        get: () => !!h(d.dirtyFields, t)
+      },
+      isTouched: {
+        enumerable: !0,
+        get: () => !!h(d.touchedFields, t)
+      },
+      isValidating: {
+        enumerable: !0,
+        get: () => !!h(d.validatingFields, t)
+      },
+      error: {
+        enumerable: !0,
+        get: () => h(d.errors, t)
+      }
+    })
+  };
+}
+const Hn = (e) => e.render(Us(e));
+var Hs = (e, r, t, s, o) => r ? {
+  ...t[e],
+  types: {
+    ...t[e] && t[e].types ? t[e].types : {},
+    [s]: o || !0
+  }
+} : {}, Fe = () => {
+  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);
+  });
+}, _t = (e, r, t = {}) => t.shouldFocus || $(t.shouldFocus) ? t.focusName || `${e}.${$(t.focusIndex) ? r : t.focusIndex}.` : "", Ze = (e) => ({
+  isOnSubmit: !e || e === pe.onSubmit,
+  isOnBlur: e === pe.onBlur,
+  isOnChange: e === pe.onChange,
+  isOnAll: e === pe.all,
+  isOnTouch: e === pe.onTouched
+}), Dt = (e, r, t) => !t && (r.watchAll || r.watch.has(e) || [...r.watch].some((s) => e.startsWith(s) && /^\.\w+/.test(e.slice(s.length))));
+const qe = (e, r, t, s) => {
+  for (const o of t || Object.keys(e)) {
+    const a = h(e, o);
+    if (a) {
+      const { _f: l, ...c } = a;
+      if (l) {
+        if (l.refs && l.refs[0] && r(l.refs[0], o) && !s)
+          break;
+        if (l.ref && r(l.ref, l.name) && !s)
+          break;
+        qe(c, r);
+      } else re(c) && qe(c, r);
+    }
+  }
+};
+var vr = (e, r, t) => {
+  const s = ce(h(e, t));
+  return H(s, "root", r[t]), H(e, t, s), e;
+}, Wt = (e) => e.type === "file", Ie = (e) => typeof e == "function", lt = (e) => {
+  if (!Ut)
+    return !1;
+  const r = e ? e.ownerDocument : 0;
+  return e instanceof (r && r.defaultView ? r.defaultView.HTMLElement : HTMLElement);
+}, at = (e) => ve(e), Kt = (e) => e.type === "radio", ct = (e) => e instanceof RegExp;
+const Zt = {
+  value: !1,
+  isValid: !1
+}, Qt = { value: !0, isValid: !0 };
+var xr = (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 && !$(e[0].attributes.value) ? $(e[0].value) || e[0].value === "" ? Qt : { value: e[0].value, isValid: !0 } : Qt
+    ) : Zt;
+  }
+  return Zt;
+};
+const Jt = {
+  isValid: !1,
+  value: null
+};
+var Sr = (e) => Array.isArray(e) ? e.reduce((r, t) => t && t.checked && !t.disabled ? {
+  isValid: !0,
+  value: t.value
+} : r, Jt) : Jt;
+function er(e, r, t = "validate") {
+  if (at(e) || Array.isArray(e) && e.every(at) || ge(e) && !e)
+    return {
+      type: t,
+      message: at(e) ? e : "",
+      ref: r
+    };
+}
+var Ke = (e) => re(e) && !ct(e) ? e : {
+  value: e,
+  message: ""
+}, Pt = async (e, r, t, s, o) => {
+  const { ref: a, refs: l, required: c, maxLength: d, minLength: S, min: m, max: y, pattern: V, validate: O, name: b, valueAsNumber: P, mount: M, disabled: T } = e._f, g = h(r, b);
+  if (!M || T)
+    return {};
+  const D = l ? l[0] : a, Z = (F) => {
+    s && D.reportValidity && (D.setCustomValidity(ge(F) ? "" : F || ""), D.reportValidity());
+  }, v = {}, w = Kt(a), C = Qe(a), k = w || C, Q = (P || Wt(a)) && $(a.value) && $(g) || lt(a) && a.value === "" || g === "" || Array.isArray(g) && !g.length, z = Hs.bind(null, b, t, v), de = (F, N, B, L = we.maxLength, Y = we.minLength) => {
+    const X = F ? N : B;
+    v[b] = {
+      type: F ? L : Y,
+      message: X,
+      ref: a,
+      ...z(F ? L : Y, X)
+    };
+  };
+  if (o ? !Array.isArray(g) || !g.length : c && (!k && (Q || ne(g)) || ge(g) && !g || C && !xr(l).isValid || w && !Sr(l).isValid)) {
+    const { value: F, message: N } = at(c) ? { value: !!c, message: c } : Ke(c);
+    if (F && (v[b] = {
+      type: we.required,
+      message: N,
+      ref: D,
+      ...z(we.required, N)
+    }, !t))
+      return Z(N), v;
+  }
+  if (!Q && (!ne(m) || !ne(y))) {
+    let F, N;
+    const B = Ke(y), L = Ke(m);
+    if (!ne(g) && !isNaN(g)) {
+      const Y = a.valueAsNumber || g && +g;
+      ne(B.value) || (F = Y > B.value), ne(L.value) || (N = Y < L.value);
+    } else {
+      const Y = a.valueAsDate || new Date(g), X = (Se) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + Se), fe = a.type == "time", ae = a.type == "week";
+      ve(B.value) && g && (F = fe ? X(g) > X(B.value) : ae ? g > B.value : Y > new Date(B.value)), ve(L.value) && g && (N = fe ? X(g) < X(L.value) : ae ? g < L.value : Y < new Date(L.value));
+    }
+    if ((F || N) && (de(!!F, B.message, L.message, we.max, we.min), !t))
+      return Z(v[b].message), v;
+  }
+  if ((d || S) && !Q && (ve(g) || o && Array.isArray(g))) {
+    const F = Ke(d), N = Ke(S), B = !ne(F.value) && g.length > +F.value, L = !ne(N.value) && g.length < +N.value;
+    if ((B || L) && (de(B, F.message, N.message), !t))
+      return Z(v[b].message), v;
+  }
+  if (V && !Q && ve(g)) {
+    const { value: F, message: N } = Ke(V);
+    if (ct(F) && !g.match(F) && (v[b] = {
+      type: we.pattern,
+      message: N,
+      ref: a,
+      ...z(we.pattern, N)
+    }, !t))
+      return Z(N), v;
+  }
+  if (O) {
+    if (Ie(O)) {
+      const F = await O(g, r), N = er(F, D);
+      if (N && (v[b] = {
+        ...N,
+        ...z(we.validate, N.message)
+      }, !t))
+        return Z(N.message), v;
+    } else if (re(O)) {
+      let F = {};
+      for (const N in O) {
+        if (!le(F) && !t)
+          break;
+        const B = er(await O[N](g, r), D, N);
+        B && (F = {
+          ...B,
+          ...z(N, B.message)
+        }, Z(B.message), t && (v[b] = F));
+      }
+      if (!le(F) && (v[b] = {
+        ref: D,
+        ...F
+      }, !t))
+        return v;
+    }
+  }
+  return Z(!0), v;
+}, bt = (e, r) => [
+  ...e,
+  ...ce(r)
+], wt = (e) => Array.isArray(e) ? e.map(() => {
+}) : void 0;
+function At(e, r, t) {
+  return [
+    ...e.slice(0, r),
+    ...ce(t),
+    ...e.slice(r)
+  ];
+}
+var Ct = (e, r, t) => Array.isArray(e) ? ($(e[t]) && (e[t] = void 0), e.splice(t, 0, e.splice(r, 1)[0]), e) : [], Et = (e, r) => [
+  ...ce(r),
+  ...ce(e)
+];
+function Ws(e, r) {
+  let t = 0;
+  const s = [...e];
+  for (const o of r)
+    s.splice(o - t, 1), t++;
+  return Je(s).length ? s : [];
+}
+var Vt = (e, r) => $(r) ? [] : Ws(e, ce(r).sort((t, s) => t - s)), Ft = (e, r, t) => {
+  [e[r], e[t]] = [e[t], e[r]];
+};
+function Ks(e, r) {
+  const t = r.slice(0, -1).length;
+  let s = 0;
+  for (; s < t; )
+    e = $(e) ? s++ : e[r[s++]];
+  return e;
+}
+function $s(e) {
+  for (const r in e)
+    if (e.hasOwnProperty(r) && !$(e[r]))
+      return !1;
+  return !0;
+}
+function ee(e, r) {
+  const t = Array.isArray(r) ? r : Ht(r) ? [r] : fr(r), s = t.length === 1 ? e : Ks(e, t), o = t.length - 1, a = t[o];
+  return s && delete s[a], o !== 0 && (re(s) && le(s) || Array.isArray(s) && $s(s)) && ee(e, t.slice(0, -1)), e;
+}
+var tr = (e, r, t) => (e[r] = t, e);
+function Wn(e) {
+  const r = pt(), { control: t = r.control, name: s, keyName: o = "id", shouldUnregister: a } = e, [l, c] = I.useState(t._getFieldArray(s)), d = I.useRef(t._getFieldArray(s).map(Fe)), S = I.useRef(l), m = I.useRef(s), y = I.useRef(!1);
+  m.current = s, S.current = l, t._names.array.add(s), e.rules && t.register(s, e.rules), ht({
+    next: ({ values: v, name: w }) => {
+      if (w === m.current || !w) {
+        const C = h(v, m.current);
+        Array.isArray(C) && (c(C), d.current = C.map(Fe));
+      }
+    },
+    subject: t._subjects.array
+  });
+  const V = I.useCallback((v) => {
+    y.current = !0, t._updateFieldArray(s, v);
+  }, [t, s]), O = (v, w) => {
+    const C = ce(te(v)), k = bt(t._getFieldArray(s), C);
+    t._names.focus = _t(s, k.length - 1, w), d.current = bt(d.current, C.map(Fe)), V(k), c(k), t._updateFieldArray(s, k, bt, {
+      argA: wt(v)
+    });
+  }, b = (v, w) => {
+    const C = ce(te(v)), k = Et(t._getFieldArray(s), C);
+    t._names.focus = _t(s, 0, w), d.current = Et(d.current, C.map(Fe)), V(k), c(k), t._updateFieldArray(s, k, Et, {
+      argA: wt(v)
+    });
+  }, P = (v) => {
+    const w = Vt(t._getFieldArray(s), v);
+    d.current = Vt(d.current, v), V(w), c(w), t._updateFieldArray(s, w, Vt, {
+      argA: v
+    });
+  }, M = (v, w, C) => {
+    const k = ce(te(w)), Q = At(t._getFieldArray(s), v, k);
+    t._names.focus = _t(s, v, C), d.current = At(d.current, v, k.map(Fe)), V(Q), c(Q), t._updateFieldArray(s, Q, At, {
+      argA: v,
+      argB: wt(w)
+    });
+  }, T = (v, w) => {
+    const C = t._getFieldArray(s);
+    Ft(C, v, w), Ft(d.current, v, w), V(C), c(C), t._updateFieldArray(s, C, Ft, {
+      argA: v,
+      argB: w
+    }, !1);
+  }, g = (v, w) => {
+    const C = t._getFieldArray(s);
+    Ct(C, v, w), Ct(d.current, v, w), V(C), c(C), t._updateFieldArray(s, C, Ct, {
+      argA: v,
+      argB: w
+    }, !1);
+  }, D = (v, w) => {
+    const C = te(w), k = tr(t._getFieldArray(s), v, C);
+    d.current = [...k].map((Q, z) => !Q || z === v ? Fe() : d.current[z]), V(k), c([...k]), t._updateFieldArray(s, k, tr, {
+      argA: v,
+      argB: C
+    }, !0, !1);
+  }, Z = (v) => {
+    const w = ce(te(v));
+    d.current = w.map(Fe), V([...w]), c([...w]), t._updateFieldArray(s, [...w], (C) => C, {}, !0, !1);
+  };
+  return I.useEffect(() => {
+    if (t._state.action = !1, Dt(s, t._names) && t._subjects.state.next({
+      ...t._formState
+    }), y.current && (!Ze(t._options.mode).isOnSubmit || t._formState.isSubmitted))
+      if (t._options.resolver)
+        t._executeSchema([s]).then((v) => {
+          const w = h(v.errors, s), C = h(t._formState.errors, s);
+          (C ? !w && C.type || w && (C.type !== w.type || C.message !== w.message) : w && w.type) && (w ? H(t._formState.errors, s, w) : ee(t._formState.errors, s), t._subjects.state.next({
+            errors: t._formState.errors
+          }));
+        });
+      else {
+        const v = h(t._fields, s);
+        v && v._f && !(Ze(t._options.reValidateMode).isOnSubmit && Ze(t._options.mode).isOnSubmit) && Pt(v, t._formValues, t._options.criteriaMode === pe.all, t._options.shouldUseNativeValidation, !0).then((w) => !le(w) && t._subjects.state.next({
+          errors: vr(t._formState.errors, w, s)
+        }));
+      }
+    t._subjects.values.next({
+      name: s,
+      values: { ...t._formValues }
+    }), t._names.focus && qe(t._fields, (v, w) => {
+      if (t._names.focus && w.startsWith(t._names.focus) && v.focus)
+        return v.focus(), 1;
+    }), t._names.focus = "", t._updateValid(), y.current = !1;
+  }, [l, s, t]), I.useEffect(() => (!h(t._formValues, s) && t._updateFieldArray(s), () => {
+    (t._options.shouldUnregister || a) && t.unregister(s);
+  }), [s, t, o, a]), {
+    swap: I.useCallback(T, [V, s, t]),
+    move: I.useCallback(g, [V, s, t]),
+    prepend: I.useCallback(b, [V, s, t]),
+    append: I.useCallback(O, [V, s, t]),
+    remove: I.useCallback(P, [V, s, t]),
+    insert: I.useCallback(M, [V, s, t]),
+    update: I.useCallback(D, [V, s, t]),
+    replace: I.useCallback(Z, [V, s, t]),
+    fields: I.useMemo(() => l.map((v, w) => ({
+      ...v,
+      [o]: d.current[w] || Fe()
+    })), [l, o])
+  };
+}
+var Tt = () => {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (o) => {
+      for (const a of e)
+        a.next && a.next(o);
+    },
+    subscribe: (o) => (e.push(o), {
+      unsubscribe: () => {
+        e = e.filter((a) => a !== o);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+}, ut = (e) => ne(e) || !cr(e);
+function Me(e, r) {
+  if (ut(e) || ut(r))
+    return e === r;
+  if ($e(e) && $e(r))
+    return e.getTime() === r.getTime();
+  const t = Object.keys(e), s = Object.keys(r);
+  if (t.length !== s.length)
+    return !1;
+  for (const o of t) {
+    const a = e[o];
+    if (!s.includes(o))
+      return !1;
+    if (o !== "ref") {
+      const l = r[o];
+      if ($e(a) && $e(l) || re(a) && re(l) || Array.isArray(a) && Array.isArray(l) ? !Me(a, l) : a !== l)
+        return !1;
+    }
+  }
+  return !0;
+}
+var _r = (e) => e.type === "select-multiple", qs = (e) => Kt(e) || Qe(e), Rt = (e) => lt(e) && e.isConnected, br = (e) => {
+  for (const r in e)
+    if (Ie(e[r]))
+      return !0;
+  return !1;
+};
+function dt(e, r = {}) {
+  const t = Array.isArray(e);
+  if (re(e) || t)
+    for (const s in e)
+      Array.isArray(e[s]) || re(e[s]) && !br(e[s]) ? (r[s] = Array.isArray(e[s]) ? [] : {}, dt(e[s], r[s])) : ne(e[s]) || (r[s] = !0);
+  return r;
+}
+function wr(e, r, t) {
+  const s = Array.isArray(e);
+  if (re(e) || s)
+    for (const o in e)
+      Array.isArray(e[o]) || re(e[o]) && !br(e[o]) ? $(r) || ut(t[o]) ? t[o] = Array.isArray(e[o]) ? dt(e[o], []) : { ...dt(e[o]) } : wr(e[o], ne(r) ? {} : r[o], t[o]) : t[o] = !Me(e[o], r[o]);
+  return t;
+}
+var nt = (e, r) => wr(e, r, dt(r)), Ar = (e, { valueAsNumber: r, valueAsDate: t, setValueAs: s }) => $(e) ? e : r ? e === "" ? NaN : e && +e : t && ve(e) ? new Date(e) : s ? s(e) : e;
+function It(e) {
+  const r = e.ref;
+  if (!(e.refs ? e.refs.every((t) => t.disabled) : r.disabled))
+    return Wt(r) ? r.files : Kt(r) ? Sr(e.refs).value : _r(r) ? [...r.selectedOptions].map(({ value: t }) => t) : Qe(r) ? xr(e.refs).value : Ar($(r.value) ? e.ref.value : r.value, e);
+}
+var Gs = (e, r, t, s) => {
+  const o = {};
+  for (const a of e) {
+    const l = h(r, a);
+    l && H(o, a, l._f);
+  }
+  return {
+    criteriaMode: t,
+    names: [...e],
+    fields: o,
+    shouldUseNativeValidation: s
+  };
+}, Ye = (e) => $(e) ? e : ct(e) ? e.source : re(e) ? ct(e.value) ? e.value.source : e.value : e, zs = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate);
+function rr(e, r, t) {
+  const s = h(e, t);
+  if (s || Ht(t))
+    return {
+      error: s,
+      name: t
+    };
+  const o = t.split(".");
+  for (; o.length; ) {
+    const a = o.join("."), l = h(r, a), c = h(e, a);
+    if (l && !Array.isArray(l) && t !== a)
+      return { name: t };
+    if (c && c.type)
+      return {
+        name: a,
+        error: c
+      };
+    o.pop();
+  }
+  return {
+    name: t
+  };
+}
+var Ys = (e, r, t, s, o) => o.isOnAll ? !1 : !t && o.isOnTouch ? !(r || e) : (t ? s.isOnBlur : o.isOnBlur) ? !e : (t ? s.isOnChange : o.isOnChange) ? e : !0, Xs = (e, r) => !Je(h(e, r)).length && ee(e, r);
+const Zs = {
+  mode: pe.onSubmit,
+  reValidateMode: pe.onChange,
+  shouldFocusError: !0
+};
+function Qs(e = {}) {
+  let r = {
+    ...Zs,
+    ...e
+  }, t = {
+    submitCount: 0,
+    isDirty: !1,
+    isLoading: Ie(r.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: r.errors || {},
+    disabled: r.disabled || !1
+  }, s = {}, o = re(r.defaultValues) || re(r.values) ? te(r.defaultValues || r.values) || {} : {}, a = r.shouldUnregister ? {} : te(o), l = {
+    action: !1,
+    mount: !1,
+    watch: !1
+  }, c = {
+    mount: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, d, S = 0;
+  const m = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }, y = {
+    values: Tt(),
+    array: Tt(),
+    state: Tt()
+  }, V = Ze(r.mode), O = Ze(r.reValidateMode), b = r.criteriaMode === pe.all, P = (n) => (i) => {
+    clearTimeout(S), S = setTimeout(n, i);
+  }, M = async (n) => {
+    if (m.isValid || n) {
+      const i = r.resolver ? le((await k()).errors) : await z(s, !0);
+      i !== t.isValid && y.state.next({
+        isValid: i
+      });
+    }
+  }, T = (n, i) => {
+    (m.isValidating || m.validatingFields) && ((n || Array.from(c.mount)).forEach((u) => {
+      u && (i ? H(t.validatingFields, u, i) : ee(t.validatingFields, u));
+    }), y.state.next({
+      validatingFields: t.validatingFields,
+      isValidating: !le(t.validatingFields)
+    }));
+  }, g = (n, i = [], u, _, x = !0, p = !0) => {
+    if (_ && u) {
+      if (l.action = !0, p && Array.isArray(h(s, n))) {
+        const A = u(h(s, n), _.argA, _.argB);
+        x && H(s, n, A);
+      }
+      if (p && Array.isArray(h(t.errors, n))) {
+        const A = u(h(t.errors, n), _.argA, _.argB);
+        x && H(t.errors, n, A), Xs(t.errors, n);
+      }
+      if (m.touchedFields && p && Array.isArray(h(t.touchedFields, n))) {
+        const A = u(h(t.touchedFields, n), _.argA, _.argB);
+        x && H(t.touchedFields, n, A);
+      }
+      m.dirtyFields && (t.dirtyFields = nt(o, a)), y.state.next({
+        name: n,
+        isDirty: F(n, i),
+        dirtyFields: t.dirtyFields,
+        errors: t.errors,
+        isValid: t.isValid
+      });
+    } else
+      H(a, n, i);
+  }, D = (n, i) => {
+    H(t.errors, n, i), y.state.next({
+      errors: t.errors
+    });
+  }, Z = (n) => {
+    t.errors = n, y.state.next({
+      errors: t.errors,
+      isValid: !1
+    });
+  }, v = (n, i, u, _) => {
+    const x = h(s, n);
+    if (x) {
+      const p = h(a, n, $(u) ? h(o, n) : u);
+      $(p) || _ && _.defaultChecked || i ? H(a, n, i ? p : It(x._f)) : L(n, p), l.mount && M();
+    }
+  }, w = (n, i, u, _, x) => {
+    let p = !1, A = !1;
+    const j = {
+      name: n
+    }, J = !!(h(s, n) && h(s, n)._f && h(s, n)._f.disabled);
+    if (!u || _) {
+      m.isDirty && (A = t.isDirty, t.isDirty = j.isDirty = F(), p = A !== j.isDirty);
+      const ue = J || Me(h(o, n), i);
+      A = !!(!J && h(t.dirtyFields, n)), ue || J ? ee(t.dirtyFields, n) : H(t.dirtyFields, n, !0), j.dirtyFields = t.dirtyFields, p = p || m.dirtyFields && A !== !ue;
+    }
+    if (u) {
+      const ue = h(t.touchedFields, n);
+      ue || (H(t.touchedFields, n, u), j.touchedFields = t.touchedFields, p = p || m.touchedFields && ue !== u);
+    }
+    return p && x && y.state.next(j), p ? j : {};
+  }, C = (n, i, u, _) => {
+    const x = h(t.errors, n), p = m.isValid && ge(i) && t.isValid !== i;
+    if (e.delayError && u ? (d = P(() => D(n, u)), d(e.delayError)) : (clearTimeout(S), d = null, u ? H(t.errors, n, u) : ee(t.errors, n)), (u ? !Me(x, u) : x) || !le(_) || p) {
+      const A = {
+        ..._,
+        ...p && ge(i) ? { isValid: i } : {},
+        errors: t.errors,
+        name: n
+      };
+      t = {
+        ...t,
+        ...A
+      }, y.state.next(A);
+    }
+  }, k = async (n) => {
+    T(n, !0);
+    const i = await r.resolver(a, r.context, Gs(n || c.mount, s, r.criteriaMode, r.shouldUseNativeValidation));
+    return T(n), i;
+  }, Q = async (n) => {
+    const { errors: i } = await k(n);
+    if (n)
+      for (const u of n) {
+        const _ = h(i, u);
+        _ ? H(t.errors, u, _) : ee(t.errors, u);
+      }
+    else
+      t.errors = i;
+    return i;
+  }, z = async (n, i, u = {
+    valid: !0
+  }) => {
+    for (const _ in n) {
+      const x = n[_];
+      if (x) {
+        const { _f: p, ...A } = x;
+        if (p) {
+          const j = c.array.has(p.name);
+          T([_], !0);
+          const J = await Pt(x, a, b, r.shouldUseNativeValidation && !i, j);
+          if (T([_]), J[p.name] && (u.valid = !1, i))
+            break;
+          !i && (h(J, p.name) ? j ? vr(t.errors, J, p.name) : H(t.errors, p.name, J[p.name]) : ee(t.errors, p.name));
+        }
+        A && await z(A, i, u);
+      }
+    }
+    return u.valid;
+  }, de = () => {
+    for (const n of c.unMount) {
+      const i = h(s, n);
+      i && (i._f.refs ? i._f.refs.every((u) => !Rt(u)) : !Rt(i._f.ref)) && be(n);
+    }
+    c.unMount = /* @__PURE__ */ new Set();
+  }, F = (n, i) => (n && i && H(a, n, i), !Me(ke(), o)), N = (n, i, u) => gr(n, c, {
+    ...l.mount ? a : $(i) ? o : ve(n) ? { [n]: i } : i
+  }, u, i), B = (n) => Je(h(l.mount ? a : o, n, e.shouldUnregister ? h(o, n, []) : [])), L = (n, i, u = {}) => {
+    const _ = h(s, n);
+    let x = i;
+    if (_) {
+      const p = _._f;
+      p && (!p.disabled && H(a, n, Ar(i, p)), x = lt(p.ref) && ne(i) ? "" : i, _r(p.ref) ? [...p.ref.options].forEach((A) => A.selected = x.includes(A.value)) : p.refs ? Qe(p.ref) ? p.refs.length > 1 ? p.refs.forEach((A) => (!A.defaultChecked || !A.disabled) && (A.checked = Array.isArray(x) ? !!x.find((j) => j === A.value) : x === A.value)) : p.refs[0] && (p.refs[0].checked = !!x) : p.refs.forEach((A) => A.checked = A.value === x) : Wt(p.ref) ? p.ref.value = "" : (p.ref.value = x, p.ref.type || y.values.next({
+        name: n,
+        values: { ...a }
+      })));
+    }
+    (u.shouldDirty || u.shouldTouch) && w(n, x, u.shouldTouch, u.shouldDirty, !0), u.shouldValidate && Se(n);
+  }, Y = (n, i, u) => {
+    for (const _ in i) {
+      const x = i[_], p = `${n}.${_}`, A = h(s, p);
+      (c.array.has(n) || !ut(x) || A && !A._f) && !$e(x) ? Y(p, x, u) : L(p, x, u);
+    }
+  }, X = (n, i, u = {}) => {
+    const _ = h(s, n), x = c.array.has(n), p = te(i);
+    H(a, n, p), x ? (y.array.next({
+      name: n,
+      values: { ...a }
+    }), (m.isDirty || m.dirtyFields) && u.shouldDirty && y.state.next({
+      name: n,
+      dirtyFields: nt(o, a),
+      isDirty: F(n, p)
+    })) : _ && !_._f && !ne(p) ? Y(n, p, u) : L(n, p, u), Dt(n, c) && y.state.next({ ...t }), y.values.next({
+      name: l.mount ? n : void 0,
+      values: { ...a }
+    });
+  }, fe = async (n) => {
+    l.mount = !0;
+    const i = n.target;
+    let u = i.name, _ = !0;
+    const x = h(s, u), p = () => i.type ? It(x._f) : ur(n), A = (j) => {
+      _ = Number.isNaN(j) || j === h(a, u, j);
+    };
+    if (x) {
+      let j, J;
+      const ue = p(), Be = n.type === it.BLUR || n.type === it.FOCUS_OUT, cs = !zs(x._f) && !r.resolver && !h(t.errors, u) && !x._f.deps || Ys(Be, h(t.touchedFields, u), t.isSubmitted, O, V), vt = Dt(u, c, Be);
+      H(a, u, ue), Be ? (x._f.onBlur && x._f.onBlur(n), d && d(0)) : x._f.onChange && x._f.onChange(n);
+      const xt = w(u, ue, Be, !1), us = !le(xt) || vt;
+      if (!Be && y.values.next({
+        name: u,
+        type: n.type,
+        values: { ...a }
+      }), cs)
+        return m.isValid && M(), us && y.state.next({ name: u, ...vt ? {} : xt });
+      if (!Be && vt && y.state.next({ ...t }), r.resolver) {
+        const { errors: qt } = await k([u]);
+        if (A(ue), _) {
+          const ds = rr(t.errors, s, u), Gt = rr(qt, s, ds.name || u);
+          j = Gt.error, u = Gt.name, J = le(qt);
+        }
+      } else
+        T([u], !0), j = (await Pt(x, a, b, r.shouldUseNativeValidation))[u], T([u]), A(ue), _ && (j ? J = !1 : m.isValid && (J = await z(s, !0)));
+      _ && (x._f.deps && Se(x._f.deps), C(u, J, j, xt));
+    }
+  }, ae = (n, i) => {
+    if (h(t.errors, i) && n.focus)
+      return n.focus(), 1;
+  }, Se = async (n, i = {}) => {
+    let u, _;
+    const x = ce(n);
+    if (r.resolver) {
+      const p = await Q($(n) ? n : x);
+      u = le(p), _ = n ? !x.some((A) => h(p, A)) : u;
+    } else n ? (_ = (await Promise.all(x.map(async (p) => {
+      const A = h(s, p);
+      return await z(A && A._f ? { [p]: A } : A);
+    }))).every(Boolean), !(!_ && !t.isValid) && M()) : _ = u = await z(s);
+    return y.state.next({
+      ...!ve(n) || m.isValid && u !== t.isValid ? {} : { name: n },
+      ...r.resolver || !n ? { isValid: u } : {},
+      errors: t.errors
+    }), i.shouldFocus && !_ && qe(s, ae, n ? x : c.mount), _;
+  }, ke = (n) => {
+    const i = {
+      ...l.mount ? a : o
+    };
+    return $(n) ? i : ve(n) ? h(i, n) : n.map((u) => h(i, u));
+  }, Le = (n, i) => ({
+    invalid: !!h((i || t).errors, n),
+    isDirty: !!h((i || t).dirtyFields, n),
+    error: h((i || t).errors, n),
+    isValidating: !!h(t.validatingFields, n),
+    isTouched: !!h((i || t).touchedFields, n)
+  }), ze = (n) => {
+    n && ce(n).forEach((i) => ee(t.errors, i)), y.state.next({
+      errors: n ? t.errors : {}
+    });
+  }, _e = (n, i, u) => {
+    const _ = (h(s, n, { _f: {} })._f || {}).ref, x = h(t.errors, n) || {}, { ref: p, message: A, type: j, ...J } = x;
+    H(t.errors, n, {
+      ...J,
+      ...i,
+      ref: _
+    }), y.state.next({
+      name: n,
+      errors: t.errors,
+      isValid: !1
+    }), u && u.shouldFocus && _ && _.focus && _.focus();
+  }, je = (n, i) => Ie(n) ? y.values.subscribe({
+    next: (u) => n(N(void 0, i), u)
+  }) : N(n, i, !0), be = (n, i = {}) => {
+    for (const u of n ? ce(n) : c.mount)
+      c.mount.delete(u), c.array.delete(u), i.keepValue || (ee(s, u), ee(a, u)), !i.keepError && ee(t.errors, u), !i.keepDirty && ee(t.dirtyFields, u), !i.keepTouched && ee(t.touchedFields, u), !i.keepIsValidating && ee(t.validatingFields, u), !r.shouldUnregister && !i.keepDefaultValue && ee(o, u);
+    y.values.next({
+      values: { ...a }
+    }), y.state.next({
+      ...t,
+      ...i.keepDirty ? { isDirty: F() } : {}
+    }), !i.keepIsValid && M();
+  }, R = ({ disabled: n, name: i, field: u, fields: _, value: x }) => {
+    if (ge(n) && l.mount || n) {
+      const p = n ? void 0 : $(x) ? It(u ? u._f : h(_, i)._f) : x;
+      H(a, i, p), w(i, p, !1, !1, !0);
+    }
+  }, K = (n, i = {}) => {
+    let u = h(s, n);
+    const _ = ge(i.disabled);
+    return H(s, n, {
+      ...u || {},
+      _f: {
+        ...u && u._f ? u._f : { ref: { name: n } },
+        name: n,
+        mount: !0,
+        ...i
+      }
+    }), c.mount.add(n), u ? R({
+      field: u,
+      disabled: i.disabled,
+      name: n,
+      value: i.value
+    }) : v(n, !0, i.value), {
+      ..._ ? { disabled: i.disabled } : {},
+      ...r.progressive ? {
+        required: !!i.required,
+        min: Ye(i.min),
+        max: Ye(i.max),
+        minLength: Ye(i.minLength),
+        maxLength: Ye(i.maxLength),
+        pattern: Ye(i.pattern)
+      } : {},
+      name: n,
+      onChange: fe,
+      onBlur: fe,
+      ref: (x) => {
+        if (x) {
+          K(n, i), u = h(s, n);
+          const p = $(x.value) && x.querySelectorAll && x.querySelectorAll("input,select,textarea")[0] || x, A = qs(p), j = u._f.refs || [];
+          if (A ? j.find((J) => J === p) : p === u._f.ref)
+            return;
+          H(s, n, {
+            _f: {
+              ...u._f,
+              ...A ? {
+                refs: [
+                  ...j.filter(Rt),
+                  p,
+                  ...Array.isArray(h(o, n)) ? [{}] : []
+                ],
+                ref: { type: p.type, name: n }
+              } : { ref: p }
+            }
+          }), v(n, !1, void 0, p);
+        } else
+          u = h(s, n, {}), u._f && (u._f.mount = !1), (r.shouldUnregister || i.shouldUnregister) && !(dr(c.array, n) && l.action) && c.unMount.add(n);
+      }
+    };
+  }, se = () => r.shouldFocusError && qe(s, ae, c.mount), q = (n) => {
+    ge(n) && (y.state.next({ disabled: n }), qe(s, (i, u) => {
+      const _ = h(s, u);
+      _ && (i.disabled = _._f.disabled || n, Array.isArray(_._f.refs) && _._f.refs.forEach((x) => {
+        x.disabled = _._f.disabled || n;
+      }));
+    }, 0, !1));
+  }, U = (n, i) => async (u) => {
+    let _;
+    u && (u.preventDefault && u.preventDefault(), u.persist && u.persist());
+    let x = te(a);
+    if (y.state.next({
+      isSubmitting: !0
+    }), r.resolver) {
+      const { errors: p, values: A } = await k();
+      t.errors = p, x = A;
+    } else
+      await z(s);
+    if (ee(t.errors, "root"), le(t.errors)) {
+      y.state.next({
+        errors: {}
+      });
+      try {
+        await n(x, u);
+      } catch (p) {
+        _ = p;
+      }
+    } else
+      i && await i({ ...t.errors }, u), se(), setTimeout(se);
+    if (y.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: le(t.errors) && !_,
+      submitCount: t.submitCount + 1,
+      errors: t.errors
+    }), _)
+      throw _;
+  }, W = (n, i = {}) => {
+    h(s, n) && ($(i.defaultValue) ? X(n, te(h(o, n))) : (X(n, i.defaultValue), H(o, n, te(i.defaultValue))), i.keepTouched || ee(t.touchedFields, n), i.keepDirty || (ee(t.dirtyFields, n), t.isDirty = i.defaultValue ? F(n, te(h(o, n))) : F()), i.keepError || (ee(t.errors, n), m.isValid && M()), y.state.next({ ...t }));
+  }, me = (n, i = {}) => {
+    const u = n ? te(n) : o, _ = te(u), x = le(n), p = x ? o : _;
+    if (i.keepDefaultValues || (o = u), !i.keepValues) {
+      if (i.keepDirtyValues)
+        for (const A of c.mount)
+          h(t.dirtyFields, A) ? H(p, A, h(a, A)) : X(A, h(p, A));
+      else {
+        if (Ut && $(n))
+          for (const A of c.mount) {
+            const j = h(s, A);
+            if (j && j._f) {
+              const J = Array.isArray(j._f.refs) ? j._f.refs[0] : j._f.ref;
+              if (lt(J)) {
+                const ue = J.closest("form");
+                if (ue) {
+                  ue.reset();
+                  break;
+                }
+              }
+            }
+          }
+        s = {};
+      }
+      a = e.shouldUnregister ? i.keepDefaultValues ? te(o) : {} : te(p), y.array.next({
+        values: { ...p }
+      }), y.values.next({
+        values: { ...p }
+      });
+    }
+    c = {
+      mount: i.keepDirtyValues ? c.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, l.mount = !m.isValid || !!i.keepIsValid || !!i.keepDirtyValues, l.watch = !!e.shouldUnregister, y.state.next({
+      submitCount: i.keepSubmitCount ? t.submitCount : 0,
+      isDirty: x ? !1 : i.keepDirty ? t.isDirty : !!(i.keepDefaultValues && !Me(n, o)),
+      isSubmitted: i.keepIsSubmitted ? t.isSubmitted : !1,
+      dirtyFields: x ? {} : i.keepDirtyValues ? i.keepDefaultValues && a ? nt(o, a) : t.dirtyFields : i.keepDefaultValues && n ? nt(o, n) : i.keepDirty ? t.dirtyFields : {},
+      touchedFields: i.keepTouched ? t.touchedFields : {},
+      errors: i.keepErrors ? t.errors : {},
+      isSubmitSuccessful: i.keepIsSubmitSuccessful ? t.isSubmitSuccessful : !1,
+      isSubmitting: !1
+    });
+  }, ye = (n, i) => me(Ie(n) ? n(a) : n, i);
+  return {
+    control: {
+      register: K,
+      unregister: be,
+      getFieldState: Le,
+      handleSubmit: U,
+      setError: _e,
+      _executeSchema: k,
+      _getWatch: N,
+      _getDirty: F,
+      _updateValid: M,
+      _removeUnmounted: de,
+      _updateFieldArray: g,
+      _updateDisabledField: R,
+      _getFieldArray: B,
+      _reset: me,
+      _resetDefaultValues: () => Ie(r.defaultValues) && r.defaultValues().then((n) => {
+        ye(n, r.resetOptions), y.state.next({
+          isLoading: !1
+        });
+      }),
+      _updateFormState: (n) => {
+        t = {
+          ...t,
+          ...n
+        };
+      },
+      _disableForm: q,
+      _subjects: y,
+      _proxyFormState: m,
+      _setErrors: Z,
+      get _fields() {
+        return s;
+      },
+      get _formValues() {
+        return a;
+      },
+      get _state() {
+        return l;
+      },
+      set _state(n) {
+        l = n;
+      },
+      get _defaultValues() {
+        return o;
+      },
+      get _names() {
+        return c;
+      },
+      set _names(n) {
+        c = n;
+      },
+      get _formState() {
+        return t;
+      },
+      set _formState(n) {
+        t = n;
+      },
+      get _options() {
+        return r;
+      },
+      set _options(n) {
+        r = {
+          ...r,
+          ...n
+        };
+      }
+    },
+    trigger: Se,
+    register: K,
+    handleSubmit: U,
+    watch: je,
+    setValue: X,
+    getValues: ke,
+    reset: ye,
+    resetField: W,
+    clearErrors: ze,
+    unregister: be,
+    setError: _e,
+    setFocus: (n, i = {}) => {
+      const u = h(s, n), _ = u && u._f;
+      if (_) {
+        const x = _.refs ? _.refs[0] : _.ref;
+        x.focus && (x.focus(), i.shouldSelect && x.select());
+      }
+    },
+    getFieldState: Le
+  };
+}
+function Kn(e = {}) {
+  const r = I.useRef(), t = I.useRef(), [s, o] = I.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: Ie(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1,
+    defaultValues: Ie(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  r.current || (r.current = {
+    ...Qs(e),
+    formState: s
+  });
+  const a = r.current.control;
+  return a._options = e, ht({
+    subject: a._subjects.state,
+    next: (l) => {
+      mr(l, a._proxyFormState, a._updateFormState, !0) && o({ ...a._formState });
+    }
+  }), I.useEffect(() => a._disableForm(e.disabled), [a, e.disabled]), I.useEffect(() => {
+    if (a._proxyFormState.isDirty) {
+      const l = a._getDirty();
+      l !== s.isDirty && a._subjects.state.next({
+        isDirty: l
+      });
+    }
+  }, [a, s.isDirty]), I.useEffect(() => {
+    e.values && !Me(e.values, t.current) ? (a._reset(e.values, a._options.resetOptions), t.current = e.values, o((l) => ({ ...l }))) : a._resetDefaultValues();
+  }, [e.values, a]), I.useEffect(() => {
+    e.errors && a._setErrors(e.errors);
+  }, [e.errors, a]), I.useEffect(() => {
+    a._state.mount || (a._updateValid(), a._state.mount = !0), a._state.watch && (a._state.watch = !1, a._subjects.state.next({ ...a._formState })), a._removeUnmounted();
+  }), I.useEffect(() => {
+    e.shouldUnregister && a._subjects.values.next({
+      values: a._getWatch()
+    });
+  }, [e.shouldUnregister, a]), r.current.formState = hr(s, a), r.current;
+}
+function sr(e, [r, t]) {
+  return Math.min(t, Math.max(r, e));
+}
+function Js(e) {
+  const r = f.useRef({ value: e, previous: e });
+  return f.useMemo(() => (r.current.value !== e && (r.current.previous = r.current.value, r.current.value = e), r.current.previous), [e]);
+}
+var en = [" ", "Enter", "ArrowUp", "ArrowDown"], tn = [" ", "Enter"], et = "Select", [mt, yt, rn] = ps(et), [Ge, $n] = hs(et, [
+  rn,
+  or
+]), gt = or(), [sn, De] = Ge(et), [nn, on] = Ge(et), Cr = (e) => {
+  const {
+    __scopeSelect: r,
+    children: t,
+    open: s,
+    defaultOpen: o,
+    onOpenChange: a,
+    value: l,
+    defaultValue: c,
+    onValueChange: d,
+    dir: S,
+    name: m,
+    autoComplete: y,
+    disabled: V,
+    required: O
+  } = e, b = gt(r), [P, M] = f.useState(null), [T, g] = f.useState(null), [D, Z] = f.useState(!1), v = Vs(S), [w = !1, C] = Yt({
+    prop: s,
+    defaultProp: o,
+    onChange: a
+  }), [k, Q] = Yt({
+    prop: l,
+    defaultProp: c,
+    onChange: d
+  }), z = f.useRef(null), de = P ? !!P.closest("form") : !0, [F, N] = f.useState(/* @__PURE__ */ new Set()), B = Array.from(F).map((L) => L.props.value).join(";");
+  return /* @__PURE__ */ E.jsx(Fs, { ...b, children: /* @__PURE__ */ E.jsxs(
+    sn,
+    {
+      required: O,
+      scope: r,
+      trigger: P,
+      onTriggerChange: M,
+      valueNode: T,
+      onValueNodeChange: g,
+      valueNodeHasChildren: D,
+      onValueNodeHasChildrenChange: Z,
+      contentId: Bt(),
+      value: k,
+      onValueChange: Q,
+      open: w,
+      onOpenChange: C,
+      dir: v,
+      triggerPointerDownPosRef: z,
+      disabled: V,
+      children: [
+        /* @__PURE__ */ E.jsx(mt.Provider, { scope: r, children: /* @__PURE__ */ E.jsx(
+          nn,
+          {
+            scope: e.__scopeSelect,
+            onNativeOptionAdd: f.useCallback((L) => {
+              N((Y) => new Set(Y).add(L));
+            }, []),
+            onNativeOptionRemove: f.useCallback((L) => {
+              N((Y) => {
+                const X = new Set(Y);
+                return X.delete(L), X;
+              });
+            }, []),
+            children: t
+          }
+        ) }),
+        de ? /* @__PURE__ */ E.jsxs(
+          Zr,
+          {
+            "aria-hidden": !0,
+            required: O,
+            tabIndex: -1,
+            name: m,
+            autoComplete: y,
+            value: k,
+            onChange: (L) => Q(L.target.value),
+            disabled: V,
+            children: [
+              k === void 0 ? /* @__PURE__ */ E.jsx("option", { value: "" }) : null,
+              Array.from(F)
+            ]
+          },
+          B
+        ) : null
+      ]
+    }
+  ) });
+};
+Cr.displayName = et;
+var Er = "SelectTrigger", Vr = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, disabled: s = !1, ...o } = e, a = gt(t), l = De(Er, t), c = l.disabled || s, d = xe(r, l.onTriggerChange), S = yt(t), [m, y, V] = Qr((b) => {
+      const P = S().filter((g) => !g.disabled), M = P.find((g) => g.value === l.value), T = Jr(P, b, M);
+      T !== void 0 && l.onValueChange(T.value);
+    }), O = () => {
+      c || (l.onOpenChange(!0), V());
+    };
+    return /* @__PURE__ */ E.jsx(ms, { asChild: !0, ...a, children: /* @__PURE__ */ E.jsx(
+      he.button,
+      {
+        type: "button",
+        role: "combobox",
+        "aria-controls": l.contentId,
+        "aria-expanded": l.open,
+        "aria-required": l.required,
+        "aria-autocomplete": "none",
+        dir: l.dir,
+        "data-state": l.open ? "open" : "closed",
+        disabled: c,
+        "data-disabled": c ? "" : void 0,
+        "data-placeholder": Xr(l.value) ? "" : void 0,
+        ...o,
+        ref: d,
+        onClick: oe(o.onClick, (b) => {
+          b.currentTarget.focus();
+        }),
+        onPointerDown: oe(o.onPointerDown, (b) => {
+          const P = b.target;
+          P.hasPointerCapture(b.pointerId) && P.releasePointerCapture(b.pointerId), b.button === 0 && b.ctrlKey === !1 && (O(), l.triggerPointerDownPosRef.current = {
+            x: Math.round(b.pageX),
+            y: Math.round(b.pageY)
+          }, b.preventDefault());
+        }),
+        onKeyDown: oe(o.onKeyDown, (b) => {
+          const P = m.current !== "";
+          !(b.ctrlKey || b.altKey || b.metaKey) && b.key.length === 1 && y(b.key), !(P && b.key === " ") && en.includes(b.key) && (O(), b.preventDefault());
+        })
+      }
+    ) });
+  }
+);
+Vr.displayName = Er;
+var Fr = "SelectValue", Tr = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, className: s, style: o, children: a, placeholder: l = "", ...c } = e, d = De(Fr, t), { onValueNodeHasChildrenChange: S } = d, m = a !== void 0, y = xe(r, d.onValueNodeChange);
+    return Ne(() => {
+      S(m);
+    }, [S, m]), /* @__PURE__ */ E.jsx(
+      he.span,
+      {
+        ...c,
+        ref: y,
+        style: { pointerEvents: "none" },
+        children: Xr(d.value) ? /* @__PURE__ */ E.jsx(E.Fragment, { children: l }) : a
+      }
+    );
+  }
+);
+Tr.displayName = Fr;
+var an = "SelectIcon", Rr = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, children: s, ...o } = e;
+    return /* @__PURE__ */ E.jsx(he.span, { "aria-hidden": !0, ...o, ref: r, children: s || "▼" });
+  }
+);
+Rr.displayName = an;
+var ln = "SelectPortal", Ir = (e) => /* @__PURE__ */ E.jsx(Es, { asChild: !0, ...e });
+Ir.displayName = ln;
+var Oe = "SelectContent", Nr = f.forwardRef(
+  (e, r) => {
+    const t = De(Oe, e.__scopeSelect), [s, o] = f.useState();
+    if (Ne(() => {
+      o(new DocumentFragment());
+    }, []), !t.open) {
+      const a = s;
+      return a ? ir.createPortal(
+        /* @__PURE__ */ E.jsx(Dr, { scope: e.__scopeSelect, children: /* @__PURE__ */ E.jsx(mt.Slot, { scope: e.__scopeSelect, children: /* @__PURE__ */ E.jsx("div", { children: e.children }) }) }),
+        a
+      ) : null;
+    }
+    return /* @__PURE__ */ E.jsx(Pr, { ...e, ref: r });
+  }
+);
+Nr.displayName = Oe;
+var Ae = 10, [Dr, Pe] = Ge(Oe), cn = "SelectContentImpl", Pr = f.forwardRef(
+  (e, r) => {
+    const {
+      __scopeSelect: t,
+      position: s = "item-aligned",
+      onCloseAutoFocus: o,
+      onEscapeKeyDown: a,
+      onPointerDownOutside: l,
+      //
+      // PopperContent props
+      side: c,
+      sideOffset: d,
+      align: S,
+      alignOffset: m,
+      arrowPadding: y,
+      collisionBoundary: V,
+      collisionPadding: O,
+      sticky: b,
+      hideWhenDetached: P,
+      avoidCollisions: M,
+      //
+      ...T
+    } = e, g = De(Oe, t), [D, Z] = f.useState(null), [v, w] = f.useState(null), C = xe(r, (R) => Z(R)), [k, Q] = f.useState(null), [z, de] = f.useState(
+      null
+    ), F = yt(t), [N, B] = f.useState(!1), L = f.useRef(!1);
+    f.useEffect(() => {
+      if (D) return ys(D);
+    }, [D]), gs();
+    const Y = f.useCallback(
+      (R) => {
+        const [K, ...se] = F().map((W) => W.ref.current), [q] = se.slice(-1), U = document.activeElement;
+        for (const W of R)
+          if (W === U || (W == null || W.scrollIntoView({ block: "nearest" }), W === K && v && (v.scrollTop = 0), W === q && v && (v.scrollTop = v.scrollHeight), W == null || W.focus(), document.activeElement !== U)) return;
+      },
+      [F, v]
+    ), X = f.useCallback(
+      () => Y([k, D]),
+      [Y, k, D]
+    );
+    f.useEffect(() => {
+      N && X();
+    }, [N, X]);
+    const { onOpenChange: fe, triggerPointerDownPosRef: ae } = g;
+    f.useEffect(() => {
+      if (D) {
+        let R = { x: 0, y: 0 };
+        const K = (q) => {
+          var U, W;
+          R = {
+            x: Math.abs(Math.round(q.pageX) - (((U = ae.current) == null ? void 0 : U.x) ?? 0)),
+            y: Math.abs(Math.round(q.pageY) - (((W = ae.current) == null ? void 0 : W.y) ?? 0))
+          };
+        }, se = (q) => {
+          R.x <= 10 && R.y <= 10 ? q.preventDefault() : D.contains(q.target) || fe(!1), document.removeEventListener("pointermove", K), ae.current = null;
+        };
+        return ae.current !== null && (document.addEventListener("pointermove", K), document.addEventListener("pointerup", se, { capture: !0, once: !0 })), () => {
+          document.removeEventListener("pointermove", K), document.removeEventListener("pointerup", se, { capture: !0 });
+        };
+      }
+    }, [D, fe, ae]), f.useEffect(() => {
+      const R = () => fe(!1);
+      return window.addEventListener("blur", R), window.addEventListener("resize", R), () => {
+        window.removeEventListener("blur", R), window.removeEventListener("resize", R);
+      };
+    }, [fe]);
+    const [Se, ke] = Qr((R) => {
+      const K = F().filter((U) => !U.disabled), se = K.find((U) => U.ref.current === document.activeElement), q = Jr(K, R, se);
+      q && setTimeout(() => q.ref.current.focus());
+    }), Le = f.useCallback(
+      (R, K, se) => {
+        const q = !L.current && !se;
+        (g.value !== void 0 && g.value === K || q) && (Q(R), q && (L.current = !0));
+      },
+      [g.value]
+    ), ze = f.useCallback(() => D == null ? void 0 : D.focus(), [D]), _e = f.useCallback(
+      (R, K, se) => {
+        const q = !L.current && !se;
+        (g.value !== void 0 && g.value === K || q) && de(R);
+      },
+      [g.value]
+    ), je = s === "popper" ? kt : kr, be = je === kt ? {
+      side: c,
+      sideOffset: d,
+      align: S,
+      alignOffset: m,
+      arrowPadding: y,
+      collisionBoundary: V,
+      collisionPadding: O,
+      sticky: b,
+      hideWhenDetached: P,
+      avoidCollisions: M
+    } : {};
+    return /* @__PURE__ */ E.jsx(
+      Dr,
+      {
+        scope: t,
+        content: D,
+        viewport: v,
+        onViewportChange: w,
+        itemRefCallback: Le,
+        selectedItem: k,
+        onItemLeave: ze,
+        itemTextRefCallback: _e,
+        focusSelectedItem: X,
+        selectedItemText: z,
+        position: s,
+        isPositioned: N,
+        searchRef: Se,
+        children: /* @__PURE__ */ E.jsx(vs, { as: xs, allowPinchZoom: !0, children: /* @__PURE__ */ E.jsx(
+          Ss,
+          {
+            asChild: !0,
+            trapped: g.open,
+            onMountAutoFocus: (R) => {
+              R.preventDefault();
+            },
+            onUnmountAutoFocus: oe(o, (R) => {
+              var K;
+              (K = g.trigger) == null || K.focus({ preventScroll: !0 }), R.preventDefault();
+            }),
+            children: /* @__PURE__ */ E.jsx(
+              _s,
+              {
+                asChild: !0,
+                disableOutsidePointerEvents: !0,
+                onEscapeKeyDown: a,
+                onPointerDownOutside: l,
+                onFocusOutside: (R) => R.preventDefault(),
+                onDismiss: () => g.onOpenChange(!1),
+                children: /* @__PURE__ */ E.jsx(
+                  je,
+                  {
+                    role: "listbox",
+                    id: g.contentId,
+                    "data-state": g.open ? "open" : "closed",
+                    dir: g.dir,
+                    onContextMenu: (R) => R.preventDefault(),
+                    ...T,
+                    ...be,
+                    onPlaced: () => B(!0),
+                    ref: C,
+                    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",
+                      ...T.style
+                    },
+                    onKeyDown: oe(T.onKeyDown, (R) => {
+                      const K = R.ctrlKey || R.altKey || R.metaKey;
+                      if (R.key === "Tab" && R.preventDefault(), !K && R.key.length === 1 && ke(R.key), ["ArrowUp", "ArrowDown", "Home", "End"].includes(R.key)) {
+                        let q = F().filter((U) => !U.disabled).map((U) => U.ref.current);
+                        if (["ArrowUp", "End"].includes(R.key) && (q = q.slice().reverse()), ["ArrowUp", "ArrowDown"].includes(R.key)) {
+                          const U = R.target, W = q.indexOf(U);
+                          q = q.slice(W + 1);
+                        }
+                        setTimeout(() => Y(q)), R.preventDefault();
+                      }
+                    })
+                  }
+                )
+              }
+            )
+          }
+        ) })
+      }
+    );
+  }
+);
+Pr.displayName = cn;
+var un = "SelectItemAlignedPosition", kr = f.forwardRef((e, r) => {
+  const { __scopeSelect: t, onPlaced: s, ...o } = e, a = De(Oe, t), l = Pe(Oe, t), [c, d] = f.useState(null), [S, m] = f.useState(null), y = xe(r, (C) => m(C)), V = yt(t), O = f.useRef(!1), b = f.useRef(!0), { viewport: P, selectedItem: M, selectedItemText: T, focusSelectedItem: g } = l, D = f.useCallback(() => {
+    if (a.trigger && a.valueNode && c && S && P && M && T) {
+      const C = a.trigger.getBoundingClientRect(), k = S.getBoundingClientRect(), Q = a.valueNode.getBoundingClientRect(), z = T.getBoundingClientRect();
+      if (a.dir !== "rtl") {
+        const U = z.left - k.left, W = Q.left - U, me = C.left - W, ye = C.width + me, tt = Math.max(ye, k.width), rt = window.innerWidth - Ae, st = sr(W, [Ae, rt - tt]);
+        c.style.minWidth = ye + "px", c.style.left = st + "px";
+      } else {
+        const U = k.right - z.right, W = window.innerWidth - Q.right - U, me = window.innerWidth - C.right - W, ye = C.width + me, tt = Math.max(ye, k.width), rt = window.innerWidth - Ae, st = sr(W, [Ae, rt - tt]);
+        c.style.minWidth = ye + "px", c.style.right = st + "px";
+      }
+      const de = V(), F = window.innerHeight - Ae * 2, N = P.scrollHeight, B = window.getComputedStyle(S), L = parseInt(B.borderTopWidth, 10), Y = parseInt(B.paddingTop, 10), X = parseInt(B.borderBottomWidth, 10), fe = parseInt(B.paddingBottom, 10), ae = L + Y + N + fe + X, Se = Math.min(M.offsetHeight * 5, ae), ke = window.getComputedStyle(P), Le = parseInt(ke.paddingTop, 10), ze = parseInt(ke.paddingBottom, 10), _e = C.top + C.height / 2 - Ae, je = F - _e, be = M.offsetHeight / 2, R = M.offsetTop + be, K = L + Y + R, se = ae - K;
+      if (K <= _e) {
+        const U = M === de[de.length - 1].ref.current;
+        c.style.bottom = "0px";
+        const W = S.clientHeight - P.offsetTop - P.offsetHeight, me = Math.max(
+          je,
+          be + // viewport might have padding bottom, include it to avoid a scrollable viewport
+          (U ? ze : 0) + W + X
+        ), ye = K + me;
+        c.style.height = ye + "px";
+      } else {
+        const U = M === de[0].ref.current;
+        c.style.top = "0px";
+        const me = Math.max(
+          _e,
+          L + P.offsetTop + // viewport might have padding top, include it to avoid a scrollable viewport
+          (U ? Le : 0) + be
+        ) + se;
+        c.style.height = me + "px", P.scrollTop = K - _e + P.offsetTop;
+      }
+      c.style.margin = `${Ae}px 0`, c.style.minHeight = Se + "px", c.style.maxHeight = F + "px", s == null || s(), requestAnimationFrame(() => O.current = !0);
+    }
+  }, [
+    V,
+    a.trigger,
+    a.valueNode,
+    c,
+    S,
+    P,
+    M,
+    T,
+    a.dir,
+    s
+  ]);
+  Ne(() => D(), [D]);
+  const [Z, v] = f.useState();
+  Ne(() => {
+    S && v(window.getComputedStyle(S).zIndex);
+  }, [S]);
+  const w = f.useCallback(
+    (C) => {
+      C && b.current === !0 && (D(), g == null || g(), b.current = !1);
+    },
+    [D, g]
+  );
+  return /* @__PURE__ */ E.jsx(
+    fn,
+    {
+      scope: t,
+      contentWrapper: c,
+      shouldExpandOnScrollRef: O,
+      onScrollButtonChange: w,
+      children: /* @__PURE__ */ E.jsx(
+        "div",
+        {
+          ref: d,
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            position: "fixed",
+            zIndex: Z
+          },
+          children: /* @__PURE__ */ E.jsx(
+            he.div,
+            {
+              ...o,
+              ref: y,
+              style: {
+                // When we get the height of the content, it includes borders. If we were to set
+                // the height without having `boxSizing: 'border-box'` it would be too big.
+                boxSizing: "border-box",
+                // We need to ensure the content doesn't get taller than the wrapper
+                maxHeight: "100%",
+                ...o.style
+              }
+            }
+          )
+        }
+      )
+    }
+  );
+});
+kr.displayName = un;
+var dn = "SelectPopperPosition", kt = f.forwardRef((e, r) => {
+  const {
+    __scopeSelect: t,
+    align: s = "start",
+    collisionPadding: o = Ae,
+    ...a
+  } = e, l = gt(t);
+  return /* @__PURE__ */ E.jsx(
+    bs,
+    {
+      ...l,
+      ...a,
+      ref: r,
+      align: s,
+      collisionPadding: o,
+      style: {
+        // Ensure border-box for floating-ui calculations
+        boxSizing: "border-box",
+        ...a.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)"
+      }
+    }
+  );
+});
+kt.displayName = dn;
+var [fn, $t] = Ge(Oe, {}), Mt = "SelectViewport", Mr = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, nonce: s, ...o } = e, a = Pe(Mt, t), l = $t(Mt, t), c = xe(r, a.onViewportChange), d = f.useRef(0);
+    return /* @__PURE__ */ E.jsxs(E.Fragment, { children: [
+      /* @__PURE__ */ E.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: s
+        }
+      ),
+      /* @__PURE__ */ E.jsx(mt.Slot, { scope: t, children: /* @__PURE__ */ E.jsx(
+        he.div,
+        {
+          "data-radix-select-viewport": "",
+          role: "presentation",
+          ...o,
+          ref: c,
+          style: {
+            // we use position: 'relative' here on the `viewport` so that when we call
+            // `selectedItem.offsetTop` in calculations, the offset is relative to the viewport
+            // (independent of the scrollUpButton).
+            position: "relative",
+            flex: 1,
+            overflow: "auto",
+            ...o.style
+          },
+          onScroll: oe(o.onScroll, (S) => {
+            const m = S.currentTarget, { contentWrapper: y, shouldExpandOnScrollRef: V } = l;
+            if (V != null && V.current && y) {
+              const O = Math.abs(d.current - m.scrollTop);
+              if (O > 0) {
+                const b = window.innerHeight - Ae * 2, P = parseFloat(y.style.minHeight), M = parseFloat(y.style.height), T = Math.max(P, M);
+                if (T < b) {
+                  const g = T + O, D = Math.min(b, g), Z = g - D;
+                  y.style.height = D + "px", y.style.bottom === "0px" && (m.scrollTop = Z > 0 ? Z : 0, y.style.justifyContent = "flex-end");
+                }
+              }
+            }
+            d.current = m.scrollTop;
+          })
+        }
+      ) })
+    ] });
+  }
+);
+Mr.displayName = Mt;
+var Or = "SelectGroup", [pn, hn] = Ge(Or), Lr = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...s } = e, o = Bt();
+    return /* @__PURE__ */ E.jsx(pn, { scope: t, id: o, children: /* @__PURE__ */ E.jsx(he.div, { role: "group", "aria-labelledby": o, ...s, ref: r }) });
+  }
+);
+Lr.displayName = Or;
+var jr = "SelectLabel", Br = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...s } = e, o = hn(jr, t);
+    return /* @__PURE__ */ E.jsx(he.div, { id: o.id, ...s, ref: r });
+  }
+);
+Br.displayName = jr;
+var ft = "SelectItem", [mn, Ur] = Ge(ft), Hr = f.forwardRef(
+  (e, r) => {
+    const {
+      __scopeSelect: t,
+      value: s,
+      disabled: o = !1,
+      textValue: a,
+      ...l
+    } = e, c = De(ft, t), d = Pe(ft, t), S = c.value === s, [m, y] = f.useState(a ?? ""), [V, O] = f.useState(!1), b = xe(
+      r,
+      (T) => {
+        var g;
+        return (g = d.itemRefCallback) == null ? void 0 : g.call(d, T, s, o);
+      }
+    ), P = Bt(), M = () => {
+      o || (c.onValueChange(s), c.onOpenChange(!1));
+    };
+    if (s === "")
+      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__ */ E.jsx(
+      mn,
+      {
+        scope: t,
+        value: s,
+        disabled: o,
+        textId: P,
+        isSelected: S,
+        onItemTextChange: f.useCallback((T) => {
+          y((g) => g || ((T == null ? void 0 : T.textContent) ?? "").trim());
+        }, []),
+        children: /* @__PURE__ */ E.jsx(
+          mt.ItemSlot,
+          {
+            scope: t,
+            value: s,
+            disabled: o,
+            textValue: m,
+            children: /* @__PURE__ */ E.jsx(
+              he.div,
+              {
+                role: "option",
+                "aria-labelledby": P,
+                "data-highlighted": V ? "" : void 0,
+                "aria-selected": S && V,
+                "data-state": S ? "checked" : "unchecked",
+                "aria-disabled": o || void 0,
+                "data-disabled": o ? "" : void 0,
+                tabIndex: o ? void 0 : -1,
+                ...l,
+                ref: b,
+                onFocus: oe(l.onFocus, () => O(!0)),
+                onBlur: oe(l.onBlur, () => O(!1)),
+                onPointerUp: oe(l.onPointerUp, M),
+                onPointerMove: oe(l.onPointerMove, (T) => {
+                  var g;
+                  o ? (g = d.onItemLeave) == null || g.call(d) : T.currentTarget.focus({ preventScroll: !0 });
+                }),
+                onPointerLeave: oe(l.onPointerLeave, (T) => {
+                  var g;
+                  T.currentTarget === document.activeElement && ((g = d.onItemLeave) == null || g.call(d));
+                }),
+                onKeyDown: oe(l.onKeyDown, (T) => {
+                  var D;
+                  ((D = d.searchRef) == null ? void 0 : D.current) !== "" && T.key === " " || (tn.includes(T.key) && M(), T.key === " " && T.preventDefault());
+                })
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Hr.displayName = ft;
+var Xe = "SelectItemText", Wr = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, className: s, style: o, ...a } = e, l = De(Xe, t), c = Pe(Xe, t), d = Ur(Xe, t), S = on(Xe, t), [m, y] = f.useState(null), V = xe(
+      r,
+      (T) => y(T),
+      d.onItemTextChange,
+      (T) => {
+        var g;
+        return (g = c.itemTextRefCallback) == null ? void 0 : g.call(c, T, d.value, d.disabled);
+      }
+    ), O = m == null ? void 0 : m.textContent, b = f.useMemo(
+      () => /* @__PURE__ */ E.jsx("option", { value: d.value, disabled: d.disabled, children: O }, d.value),
+      [d.disabled, d.value, O]
+    ), { onNativeOptionAdd: P, onNativeOptionRemove: M } = S;
+    return Ne(() => (P(b), () => M(b)), [P, M, b]), /* @__PURE__ */ E.jsxs(E.Fragment, { children: [
+      /* @__PURE__ */ E.jsx(he.span, { id: d.textId, ...a, ref: V }),
+      d.isSelected && l.valueNode && !l.valueNodeHasChildren ? ir.createPortal(a.children, l.valueNode) : null
+    ] });
+  }
+);
+Wr.displayName = Xe;
+var Kr = "SelectItemIndicator", $r = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...s } = e;
+    return Ur(Kr, t).isSelected ? /* @__PURE__ */ E.jsx(he.span, { "aria-hidden": !0, ...s, ref: r }) : null;
+  }
+);
+$r.displayName = Kr;
+var Ot = "SelectScrollUpButton", qr = f.forwardRef((e, r) => {
+  const t = Pe(Ot, e.__scopeSelect), s = $t(Ot, e.__scopeSelect), [o, a] = f.useState(!1), l = xe(r, s.onScrollButtonChange);
+  return Ne(() => {
+    if (t.viewport && t.isPositioned) {
+      let c = function() {
+        const S = d.scrollTop > 0;
+        a(S);
+      };
+      const d = t.viewport;
+      return c(), d.addEventListener("scroll", c), () => d.removeEventListener("scroll", c);
+    }
+  }, [t.viewport, t.isPositioned]), o ? /* @__PURE__ */ E.jsx(
+    zr,
+    {
+      ...e,
+      ref: l,
+      onAutoScroll: () => {
+        const { viewport: c, selectedItem: d } = t;
+        c && d && (c.scrollTop = c.scrollTop - d.offsetHeight);
+      }
+    }
+  ) : null;
+});
+qr.displayName = Ot;
+var Lt = "SelectScrollDownButton", Gr = f.forwardRef((e, r) => {
+  const t = Pe(Lt, e.__scopeSelect), s = $t(Lt, e.__scopeSelect), [o, a] = f.useState(!1), l = xe(r, s.onScrollButtonChange);
+  return Ne(() => {
+    if (t.viewport && t.isPositioned) {
+      let c = function() {
+        const S = d.scrollHeight - d.clientHeight, m = Math.ceil(d.scrollTop) < S;
+        a(m);
+      };
+      const d = t.viewport;
+      return c(), d.addEventListener("scroll", c), () => d.removeEventListener("scroll", c);
+    }
+  }, [t.viewport, t.isPositioned]), o ? /* @__PURE__ */ E.jsx(
+    zr,
+    {
+      ...e,
+      ref: l,
+      onAutoScroll: () => {
+        const { viewport: c, selectedItem: d } = t;
+        c && d && (c.scrollTop = c.scrollTop + d.offsetHeight);
+      }
+    }
+  ) : null;
+});
+Gr.displayName = Lt;
+var zr = f.forwardRef((e, r) => {
+  const { __scopeSelect: t, onAutoScroll: s, ...o } = e, a = Pe("SelectScrollButton", t), l = f.useRef(null), c = yt(t), d = f.useCallback(() => {
+    l.current !== null && (window.clearInterval(l.current), l.current = null);
+  }, []);
+  return f.useEffect(() => () => d(), [d]), Ne(() => {
+    var m;
+    const S = c().find((y) => y.ref.current === document.activeElement);
+    (m = S == null ? void 0 : S.ref.current) == null || m.scrollIntoView({ block: "nearest" });
+  }, [c]), /* @__PURE__ */ E.jsx(
+    he.div,
+    {
+      "aria-hidden": !0,
+      ...o,
+      ref: r,
+      style: { flexShrink: 0, ...o.style },
+      onPointerDown: oe(o.onPointerDown, () => {
+        l.current === null && (l.current = window.setInterval(s, 50));
+      }),
+      onPointerMove: oe(o.onPointerMove, () => {
+        var S;
+        (S = a.onItemLeave) == null || S.call(a), l.current === null && (l.current = window.setInterval(s, 50));
+      }),
+      onPointerLeave: oe(o.onPointerLeave, () => {
+        d();
+      })
+    }
+  );
+}), yn = "SelectSeparator", Yr = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...s } = e;
+    return /* @__PURE__ */ E.jsx(he.div, { "aria-hidden": !0, ...s, ref: r });
+  }
+);
+Yr.displayName = yn;
+var jt = "SelectArrow", gn = f.forwardRef(
+  (e, r) => {
+    const { __scopeSelect: t, ...s } = e, o = gt(t), a = De(jt, t), l = Pe(jt, t);
+    return a.open && l.position === "popper" ? /* @__PURE__ */ E.jsx(ws, { ...o, ...s, ref: r }) : null;
+  }
+);
+gn.displayName = jt;
+function Xr(e) {
+  return e === "" || e === void 0;
+}
+var Zr = f.forwardRef(
+  (e, r) => {
+    const { value: t, ...s } = e, o = f.useRef(null), a = xe(r, o), l = Js(t);
+    return f.useEffect(() => {
+      const c = o.current, d = window.HTMLSelectElement.prototype, m = Object.getOwnPropertyDescriptor(
+        d,
+        "value"
+      ).set;
+      if (l !== t && m) {
+        const y = new Event("change", { bubbles: !0 });
+        m.call(c, t), c.dispatchEvent(y);
+      }
+    }, [l, t]), /* @__PURE__ */ E.jsx(As, { asChild: !0, children: /* @__PURE__ */ E.jsx("select", { ...s, ref: a, defaultValue: t }) });
+  }
+);
+Zr.displayName = "BubbleSelect";
+function Qr(e) {
+  const r = Cs(e), t = f.useRef(""), s = f.useRef(0), o = f.useCallback(
+    (l) => {
+      const c = t.current + l;
+      r(c), function d(S) {
+        t.current = S, window.clearTimeout(s.current), S !== "" && (s.current = window.setTimeout(() => d(""), 1e3));
+      }(c);
+    },
+    [r]
+  ), a = f.useCallback(() => {
+    t.current = "", window.clearTimeout(s.current);
+  }, []);
+  return f.useEffect(() => () => window.clearTimeout(s.current), []), [t, o, a];
+}
+function Jr(e, r, t) {
+  const o = r.length > 1 && Array.from(r).every((S) => S === r[0]) ? r[0] : r, a = t ? e.indexOf(t) : -1;
+  let l = vn(e, Math.max(a, 0));
+  o.length === 1 && (l = l.filter((S) => S !== t));
+  const d = l.find(
+    (S) => S.textValue.toLowerCase().startsWith(o.toLowerCase())
+  );
+  return d !== t ? d : void 0;
+}
+function vn(e, r) {
+  return e.map((t, s) => e[(r + s) % e.length]);
+}
+var xn = Cr, es = Vr, Sn = Tr, _n = Rr, bn = Ir, ts = Nr, wn = Mr, An = Lr, rs = Br, ss = Hr, Cn = Wr, En = $r, ns = qr, os = Gr, as = Yr;
+const qn = xn, Gn = An, zn = Sn, Vn = f.forwardRef(({ className: e, children: r, ...t }, s) => /* @__PURE__ */ f.createElement(
+  es,
+  {
+    ref: s,
+    className: Ve(
+      "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
+  },
+  /* @__PURE__ */ f.createElement("span", { className: "truncate" }, r),
+  /* @__PURE__ */ f.createElement(_n, { asChild: !0 }, /* @__PURE__ */ f.createElement(lr, { className: "flex-shrink-0 h-4 w-4 opacity-50" }))
+));
+Vn.displayName = es.displayName;
+const is = f.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ f.createElement(
+  ns,
+  {
+    ref: t,
+    className: Ve(
+      "flex cursor-default items-center justify-center py-1",
+      e
+    ),
+    ...r
+  },
+  /* @__PURE__ */ f.createElement(Ps, { className: "h-4 w-4" })
+));
+is.displayName = ns.displayName;
+const ls = f.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ f.createElement(
+  os,
+  {
+    ref: t,
+    className: Ve(
+      "flex cursor-default items-center justify-center py-1",
+      e
+    ),
+    ...r
+  },
+  /* @__PURE__ */ f.createElement(lr, { className: "h-4 w-4" })
+));
+ls.displayName = os.displayName;
+const Fn = f.forwardRef(({ className: e, children: r, position: t = "popper", ...s }, o) => /* @__PURE__ */ f.createElement(bn, null, /* @__PURE__ */ f.createElement(
+  ts,
+  {
+    ref: o,
+    className: Ve(
+      "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,
+    ...s
+  },
+  /* @__PURE__ */ f.createElement(is, null),
+  /* @__PURE__ */ f.createElement(
+    wn,
+    {
+      className: Ve(
+        "p-1",
+        t === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+      )
+    },
+    r
+  ),
+  /* @__PURE__ */ f.createElement(ls, null)
+)));
+Fn.displayName = ts.displayName;
+const Tn = f.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ f.createElement(
+  rs,
+  {
+    ref: t,
+    className: Ve("py-1.5 pl-8 pr-2 text-sm font-semibold", e),
+    ...r
+  }
+));
+Tn.displayName = rs.displayName;
+const Rn = f.forwardRef(({ className: e, children: r, ...t }, s) => /* @__PURE__ */ f.createElement(
+  ss,
+  {
+    ref: s,
+    className: Ve(
+      "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
+  },
+  /* @__PURE__ */ f.createElement("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center" }, /* @__PURE__ */ f.createElement(En, null, /* @__PURE__ */ f.createElement(ks, { className: "h-4 w-4" }))),
+  /* @__PURE__ */ f.createElement(Cn, null, r)
+));
+Rn.displayName = ss.displayName;
+const In = f.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ f.createElement(
+  as,
+  {
+    ref: t,
+    className: Ve("-mx-1 my-1 h-px bg-muted", e),
+    ...r
+  }
+));
+In.displayName = as.displayName;
+const Nn = f.forwardRef(
+  ({ className: e, type: r, ...t }, s) => /* @__PURE__ */ f.createElement(
+    "input",
+    {
+      type: r,
+      className: Ve(
+        "flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
+        e
+      ),
+      ref: s,
+      ...t
+    }
+  )
+);
+Nn.displayName = "Input";
+export {
+  Hn as C,
+  Un as F,
+  Nn as I,
+  qn as S,
+  Bn as a,
+  Vn as b,
+  zn as c,
+  Fn as d,
+  Gn as e,
+  Rn as f,
+  Wn as g,
+  pt as h,
+  Kn as u
+};
+//# sourceMappingURL=Input-BBlyeDuG.js.map