zudoku 0.7.2-dev.1 → 0.7.2-dev.11

package/lib/Input-BmwltPfA.js

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