cross-country 1.2.21 → 1.2.22

package/dist/index.esm-DGm91C_6.js

@@ -0,0 +1,944 @@
+import B from "react";
+var fe = (e) => e.type === "checkbox", ee = (e) => e instanceof Date, L = (e) => e == null;
+const Ze = (e) => typeof e == "object";
+var D = (e) => !L(e) && !Array.isArray(e) && Ze(e) && !ee(e), gr = (e) => D(e) && e.target ? fe(e.target) ? e.target.checked : e.target.value : e, hr = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, vr = (e, s) => e.has(hr(s)), _r = (e) => {
+  const s = e.constructor && e.constructor.prototype;
+  return D(s) && s.hasOwnProperty("isPrototypeOf");
+}, Te = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function M(e) {
+  let s;
+  const t = Array.isArray(e);
+  if (e instanceof Date)
+    s = new Date(e);
+  else if (e instanceof Set)
+    s = new Set(e);
+  else if (!(Te && (e instanceof Blob || e instanceof FileList)) && (t || D(e)))
+    if (s = t ? [] : {}, !t && !_r(e))
+      s = e;
+    else
+      for (const u in e)
+        e.hasOwnProperty(u) && (s[u] = M(e[u]));
+  else
+    return e;
+  return s;
+}
+var Fe = (e) => Array.isArray(e) ? e.filter(Boolean) : [], w = (e) => e === void 0, d = (e, s, t) => {
+  if (!s || !D(e))
+    return t;
+  const u = Fe(s.split(/[,[\].]+?/)).reduce((n, l) => L(n) ? n : n[l], e);
+  return w(u) || u === e ? w(e[s]) ? t : e[s] : u;
+}, W = (e) => typeof e == "boolean", Oe = (e) => /^\w*$/.test(e), er = (e) => Fe(e.replace(/["|']|\]/g, "").split(/\.|\[/)), V = (e, s, t) => {
+  let u = -1;
+  const n = Oe(s) ? [s] : er(s), l = n.length, y = l - 1;
+  for (; ++u < l; ) {
+    const h = n[u];
+    let P = t;
+    if (u !== y) {
+      const q = e[h];
+      P = D(q) || Array.isArray(q) ? q : isNaN(+n[u + 1]) ? {} : [];
+    }
+    if (h === "__proto__")
+      return;
+    e[h] = P, e = e[h];
+  }
+  return e;
+};
+const He = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, I = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, z = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+};
+B.createContext(null);
+var br = (e, s, t, u = !0) => {
+  const n = {
+    defaultValues: s._defaultValues
+  };
+  for (const l in e)
+    Object.defineProperty(n, l, {
+      get: () => {
+        const y = l;
+        return s._proxyFormState[y] !== I.all && (s._proxyFormState[y] = !u || I.all), e[y];
+      }
+    });
+  return n;
+}, C = (e) => D(e) && !Object.keys(e).length, Fr = (e, s, t, u) => {
+  t(e);
+  const { name: n, ...l } = e;
+  return C(l) || Object.keys(l).length >= Object.keys(s).length || Object.keys(l).find((y) => s[y] === I.all);
+}, ge = (e) => Array.isArray(e) ? e : [e];
+function Ar(e) {
+  const s = B.useRef(e);
+  s.current = e, B.useEffect(() => {
+    const t = !e.disabled && s.current.subject && s.current.subject.subscribe({
+      next: s.current.next
+    });
+    return () => {
+      t && t.unsubscribe();
+    };
+  }, [e.disabled]);
+}
+var $ = (e) => typeof e == "string", Vr = (e, s, t, u, n) => $(e) ? (u && s.watch.add(e), d(t, e, n)) : Array.isArray(e) ? e.map((l) => (u && s.watch.add(l), d(t, l))) : (u && (s.watchAll = !0), t), xr = (e, s, t, u, n) => s ? {
+  ...t[e],
+  types: {
+    ...t[e] && t[e].types ? t[e].types : {},
+    [u]: n || !0
+  }
+} : {}, $e = (e) => ({
+  isOnSubmit: !e || e === I.onSubmit,
+  isOnBlur: e === I.onBlur,
+  isOnChange: e === I.onChange,
+  isOnAll: e === I.all,
+  isOnTouch: e === I.onTouched
+}), je = (e, s, t) => !t && (s.watchAll || s.watch.has(e) || [...s.watch].some((u) => e.startsWith(u) && /^\.\w+/.test(e.slice(u.length))));
+const oe = (e, s, t, u) => {
+  for (const n of t || Object.keys(e)) {
+    const l = d(e, n);
+    if (l) {
+      const { _f: y, ...h } = l;
+      if (y) {
+        if (y.refs && y.refs[0] && s(y.refs[0], n) && !u)
+          return !0;
+        if (y.ref && s(y.ref, y.name) && !u)
+          return !0;
+        if (oe(h, s))
+          break;
+      } else if (D(h) && oe(h, s))
+        break;
+    }
+  }
+};
+var wr = (e, s, t) => {
+  const u = ge(d(e, t));
+  return V(u, "root", s[t]), V(e, t, u), e;
+}, Le = (e) => e.type === "file", H = (e) => typeof e == "function", ve = (e) => {
+  if (!Te)
+    return !1;
+  const s = e ? e.ownerDocument : 0;
+  return e instanceof (s && s.defaultView ? s.defaultView.HTMLElement : HTMLElement);
+}, he = (e) => $(e), Ce = (e) => e.type === "radio", _e = (e) => e instanceof RegExp;
+const Ke = {
+  value: !1,
+  isValid: !1
+}, Ye = { value: !0, isValid: !0 };
+var rr = (e) => {
+  if (Array.isArray(e)) {
+    if (e.length > 1) {
+      const s = e.filter((t) => t && t.checked && !t.disabled).map((t) => t.value);
+      return { value: s, isValid: !!s.length };
+    }
+    return e[0].checked && !e[0].disabled ? (
+      // @ts-expect-error expected to work in the browser
+      e[0].attributes && !w(e[0].attributes.value) ? w(e[0].value) || e[0].value === "" ? Ye : { value: e[0].value, isValid: !0 } : Ye
+    ) : Ke;
+  }
+  return Ke;
+};
+const ze = {
+  isValid: !1,
+  value: null
+};
+var tr = (e) => Array.isArray(e) ? e.reduce((s, t) => t && t.checked && !t.disabled ? {
+  isValid: !0,
+  value: t.value
+} : s, ze) : ze;
+function Ge(e, s, t = "validate") {
+  if (he(e) || Array.isArray(e) && e.every(he) || W(e) && !e)
+    return {
+      type: t,
+      message: he(e) ? e : "",
+      ref: s
+    };
+}
+var se = (e) => D(e) && !_e(e) ? e : {
+  value: e,
+  message: ""
+}, Je = async (e, s, t, u, n) => {
+  const { ref: l, refs: y, required: h, maxLength: P, minLength: q, min: x, max: b, pattern: ce, validate: G, name: N, valueAsNumber: Ae, mount: j, disabled: J } = e._f, F = d(s, N);
+  if (!j || J)
+    return {};
+  const K = y ? y[0] : l, Y = (_) => {
+    u && K.reportValidity && (K.setCustomValidity(W(_) ? "" : _ || ""), K.reportValidity());
+  }, m = {}, re = Ce(l), de = fe(l), X = re || de, te = (Ae || Le(l)) && w(l.value) && w(F) || ve(l) && l.value === "" || F === "" || Array.isArray(F) && !F.length, U = xr.bind(null, N, t, m), ye = (_, A, k, O = z.maxLength, p = z.minLength) => {
+    const R = _ ? A : k;
+    m[N] = {
+      type: _ ? O : p,
+      message: R,
+      ref: l,
+      ...U(_ ? O : p, R)
+    };
+  };
+  if (n ? !Array.isArray(F) || !F.length : h && (!X && (te || L(F)) || W(F) && !F || de && !rr(y).isValid || re && !tr(y).isValid)) {
+    const { value: _, message: A } = he(h) ? { value: !!h, message: h } : se(h);
+    if (_ && (m[N] = {
+      type: z.required,
+      message: A,
+      ref: K,
+      ...U(z.required, A)
+    }, !t))
+      return Y(A), m;
+  }
+  if (!te && (!L(x) || !L(b))) {
+    let _, A;
+    const k = se(b), O = se(x);
+    if (!L(F) && !isNaN(F)) {
+      const p = l.valueAsNumber || F && +F;
+      L(k.value) || (_ = p > k.value), L(O.value) || (A = p < O.value);
+    } else {
+      const p = l.valueAsDate || new Date(F), R = (le) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + le), ie = l.type == "time", ae = l.type == "week";
+      $(k.value) && F && (_ = ie ? R(F) > R(k.value) : ae ? F > k.value : p > new Date(k.value)), $(O.value) && F && (A = ie ? R(F) < R(O.value) : ae ? F < O.value : p < new Date(O.value));
+    }
+    if ((_ || A) && (ye(!!_, k.message, O.message, z.max, z.min), !t))
+      return Y(m[N].message), m;
+  }
+  if ((P || q) && !te && ($(F) || n && Array.isArray(F))) {
+    const _ = se(P), A = se(q), k = !L(_.value) && F.length > +_.value, O = !L(A.value) && F.length < +A.value;
+    if ((k || O) && (ye(k, _.message, A.message), !t))
+      return Y(m[N].message), m;
+  }
+  if (ce && !te && $(F)) {
+    const { value: _, message: A } = se(ce);
+    if (_e(_) && !F.match(_) && (m[N] = {
+      type: z.pattern,
+      message: A,
+      ref: l,
+      ...U(z.pattern, A)
+    }, !t))
+      return Y(A), m;
+  }
+  if (G) {
+    if (H(G)) {
+      const _ = await G(F, s), A = Ge(_, K);
+      if (A && (m[N] = {
+        ...A,
+        ...U(z.validate, A.message)
+      }, !t))
+        return Y(A.message), m;
+    } else if (D(G)) {
+      let _ = {};
+      for (const A in G) {
+        if (!C(_) && !t)
+          break;
+        const k = Ge(await G[A](F, s), K, A);
+        k && (_ = {
+          ...k,
+          ...U(A, k.message)
+        }, Y(k.message), t && (m[N] = _));
+      }
+      if (!C(_) && (m[N] = {
+        ref: K,
+        ..._
+      }, !t))
+        return m;
+    }
+  }
+  return Y(!0), m;
+};
+function Dr(e, s) {
+  const t = s.slice(0, -1).length;
+  let u = 0;
+  for (; u < t; )
+    e = w(e) ? u++ : e[s[u++]];
+  return e;
+}
+function mr(e) {
+  for (const s in e)
+    if (e.hasOwnProperty(s) && !w(e[s]))
+      return !1;
+  return !0;
+}
+function E(e, s) {
+  const t = Array.isArray(s) ? s : Oe(s) ? [s] : er(s), u = t.length === 1 ? e : Dr(e, t), n = t.length - 1, l = t[n];
+  return u && delete u[l], n !== 0 && (D(u) && C(u) || Array.isArray(u) && mr(u)) && E(e, t.slice(0, -1)), e;
+}
+var me = () => {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (n) => {
+      for (const l of e)
+        l.next && l.next(n);
+    },
+    subscribe: (n) => (e.push(n), {
+      unsubscribe: () => {
+        e = e.filter((l) => l !== n);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+}, Se = (e) => L(e) || !Ze(e);
+function Q(e, s) {
+  if (Se(e) || Se(s))
+    return e === s;
+  if (ee(e) && ee(s))
+    return e.getTime() === s.getTime();
+  const t = Object.keys(e), u = Object.keys(s);
+  if (t.length !== u.length)
+    return !1;
+  for (const n of t) {
+    const l = e[n];
+    if (!u.includes(n))
+      return !1;
+    if (n !== "ref") {
+      const y = s[n];
+      if (ee(l) && ee(y) || D(l) && D(y) || Array.isArray(l) && Array.isArray(y) ? !Q(l, y) : l !== y)
+        return !1;
+    }
+  }
+  return !0;
+}
+var sr = (e) => e.type === "select-multiple", kr = (e) => Ce(e) || fe(e), ke = (e) => ve(e) && e.isConnected, ir = (e) => {
+  for (const s in e)
+    if (H(e[s]))
+      return !0;
+  return !1;
+};
+function be(e, s = {}) {
+  const t = Array.isArray(e);
+  if (D(e) || t)
+    for (const u in e)
+      Array.isArray(e[u]) || D(e[u]) && !ir(e[u]) ? (s[u] = Array.isArray(e[u]) ? [] : {}, be(e[u], s[u])) : L(e[u]) || (s[u] = !0);
+  return s;
+}
+function ar(e, s, t) {
+  const u = Array.isArray(e);
+  if (D(e) || u)
+    for (const n in e)
+      Array.isArray(e[n]) || D(e[n]) && !ir(e[n]) ? w(s) || Se(t[n]) ? t[n] = Array.isArray(e[n]) ? be(e[n], []) : { ...be(e[n]) } : ar(e[n], L(s) ? {} : s[n], t[n]) : t[n] = !Q(e[n], s[n]);
+  return t;
+}
+var ue = (e, s) => ar(e, s, be(s)), lr = (e, { valueAsNumber: s, valueAsDate: t, setValueAs: u }) => w(e) ? e : s ? e === "" ? NaN : e && +e : t && $(e) ? new Date(e) : u ? u(e) : e;
+function Ee(e) {
+  const s = e.ref;
+  if (!(e.refs ? e.refs.every((t) => t.disabled) : s.disabled))
+    return Le(s) ? s.files : Ce(s) ? tr(e.refs).value : sr(s) ? [...s.selectedOptions].map(({ value: t }) => t) : fe(s) ? rr(e.refs).value : lr(w(s.value) ? e.ref.value : s.value, e);
+}
+var Er = (e, s, t, u) => {
+  const n = {};
+  for (const l of e) {
+    const y = d(s, l);
+    y && V(n, l, y._f);
+  }
+  return {
+    criteriaMode: t,
+    names: [...e],
+    fields: n,
+    shouldUseNativeValidation: u
+  };
+}, ne = (e) => w(e) ? e : _e(e) ? e.source : D(e) ? _e(e.value) ? e.value.source : e.value : e;
+const Qe = "AsyncFunction";
+var Sr = (e) => (!e || !e.validate) && !!(H(e.validate) && e.validate.constructor.name === Qe || D(e.validate) && Object.values(e.validate).find((s) => s.constructor.name === Qe)), Tr = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate);
+function Xe(e, s, t) {
+  const u = d(e, t);
+  if (u || Oe(t))
+    return {
+      error: u,
+      name: t
+    };
+  const n = t.split(".");
+  for (; n.length; ) {
+    const l = n.join("."), y = d(s, l), h = d(e, l);
+    if (y && !Array.isArray(y) && t !== l)
+      return { name: t };
+    if (h && h.type)
+      return {
+        name: l,
+        error: h
+      };
+    n.pop();
+  }
+  return {
+    name: t
+  };
+}
+var Or = (e, s, t, u, n) => n.isOnAll ? !1 : !t && n.isOnTouch ? !(s || e) : (t ? u.isOnBlur : n.isOnBlur) ? !e : (t ? u.isOnChange : n.isOnChange) ? e : !0, Lr = (e, s) => !Fe(d(e, s)).length && E(e, s);
+const Cr = {
+  mode: I.onSubmit,
+  reValidateMode: I.onChange,
+  shouldFocusError: !0
+};
+function Nr(e = {}) {
+  let s = {
+    ...Cr,
+    ...e
+  }, t = {
+    submitCount: 0,
+    isDirty: !1,
+    isLoading: H(s.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: s.errors || {},
+    disabled: s.disabled || !1
+  }, u = {}, n = D(s.defaultValues) || D(s.values) ? M(s.defaultValues || s.values) || {} : {}, l = s.shouldUnregister ? {} : M(n), y = {
+    action: !1,
+    mount: !1,
+    watch: !1
+  }, h = {
+    mount: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, P, q = 0;
+  const x = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }, b = {
+    values: me(),
+    array: me(),
+    state: me()
+  }, ce = $e(s.mode), G = $e(s.reValidateMode), N = s.criteriaMode === I.all, Ae = (r) => (i) => {
+    clearTimeout(q), q = setTimeout(r, i);
+  }, j = async (r) => {
+    if (!s.disabled && (x.isValid || r)) {
+      const i = s.resolver ? C((await X()).errors) : await U(u, !0);
+      i !== t.isValid && b.state.next({
+        isValid: i
+      });
+    }
+  }, J = (r, i) => {
+    !s.disabled && (x.isValidating || x.validatingFields) && ((r || Array.from(h.mount)).forEach((a) => {
+      a && (i ? V(t.validatingFields, a, i) : E(t.validatingFields, a));
+    }), b.state.next({
+      validatingFields: t.validatingFields,
+      isValidating: !C(t.validatingFields)
+    }));
+  }, F = (r, i = [], a, c, f = !0, o = !0) => {
+    if (c && a && !s.disabled) {
+      if (y.action = !0, o && Array.isArray(d(u, r))) {
+        const g = a(d(u, r), c.argA, c.argB);
+        f && V(u, r, g);
+      }
+      if (o && Array.isArray(d(t.errors, r))) {
+        const g = a(d(t.errors, r), c.argA, c.argB);
+        f && V(t.errors, r, g), Lr(t.errors, r);
+      }
+      if (x.touchedFields && o && Array.isArray(d(t.touchedFields, r))) {
+        const g = a(d(t.touchedFields, r), c.argA, c.argB);
+        f && V(t.touchedFields, r, g);
+      }
+      x.dirtyFields && (t.dirtyFields = ue(n, l)), b.state.next({
+        name: r,
+        isDirty: _(r, i),
+        dirtyFields: t.dirtyFields,
+        errors: t.errors,
+        isValid: t.isValid
+      });
+    } else
+      V(l, r, i);
+  }, K = (r, i) => {
+    V(t.errors, r, i), b.state.next({
+      errors: t.errors
+    });
+  }, Y = (r) => {
+    t.errors = r, b.state.next({
+      errors: t.errors,
+      isValid: !1
+    });
+  }, m = (r, i, a, c) => {
+    const f = d(u, r);
+    if (f) {
+      const o = d(l, r, w(a) ? d(n, r) : a);
+      w(o) || c && c.defaultChecked || i ? V(l, r, i ? o : Ee(f._f)) : O(r, o), y.mount && j();
+    }
+  }, re = (r, i, a, c, f) => {
+    let o = !1, g = !1;
+    const v = {
+      name: r
+    };
+    if (!s.disabled) {
+      const S = !!(d(u, r) && d(u, r)._f && d(u, r)._f.disabled);
+      if (!a || c) {
+        x.isDirty && (g = t.isDirty, t.isDirty = v.isDirty = _(), o = g !== v.isDirty);
+        const T = S || Q(d(n, r), i);
+        g = !!(!S && d(t.dirtyFields, r)), T || S ? E(t.dirtyFields, r) : V(t.dirtyFields, r, !0), v.dirtyFields = t.dirtyFields, o = o || x.dirtyFields && g !== !T;
+      }
+      if (a) {
+        const T = d(t.touchedFields, r);
+        T || (V(t.touchedFields, r, a), v.touchedFields = t.touchedFields, o = o || x.touchedFields && T !== a);
+      }
+      o && f && b.state.next(v);
+    }
+    return o ? v : {};
+  }, de = (r, i, a, c) => {
+    const f = d(t.errors, r), o = x.isValid && W(i) && t.isValid !== i;
+    if (e.delayError && a ? (P = Ae(() => K(r, a)), P(e.delayError)) : (clearTimeout(q), P = null, a ? V(t.errors, r, a) : E(t.errors, r)), (a ? !Q(f, a) : f) || !C(c) || o) {
+      const g = {
+        ...c,
+        ...o && W(i) ? { isValid: i } : {},
+        errors: t.errors,
+        name: r
+      };
+      t = {
+        ...t,
+        ...g
+      }, b.state.next(g);
+    }
+  }, X = async (r) => {
+    J(r, !0);
+    const i = await s.resolver(l, s.context, Er(r || h.mount, u, s.criteriaMode, s.shouldUseNativeValidation));
+    return J(r), i;
+  }, te = async (r) => {
+    const { errors: i } = await X(r);
+    if (r)
+      for (const a of r) {
+        const c = d(i, a);
+        c ? V(t.errors, a, c) : E(t.errors, a);
+      }
+    else
+      t.errors = i;
+    return i;
+  }, U = async (r, i, a = {
+    valid: !0
+  }) => {
+    for (const c in r) {
+      const f = r[c];
+      if (f) {
+        const { _f: o, ...g } = f;
+        if (o) {
+          const v = h.array.has(o.name), S = f._f && Sr(f._f);
+          S && x.validatingFields && J([c], !0);
+          const T = await Je(f, l, N, s.shouldUseNativeValidation && !i, v);
+          if (S && x.validatingFields && J([c]), T[o.name] && (a.valid = !1, i))
+            break;
+          !i && (d(T, o.name) ? v ? wr(t.errors, T, o.name) : V(t.errors, o.name, T[o.name]) : E(t.errors, o.name));
+        }
+        !C(g) && await U(g, i, a);
+      }
+    }
+    return a.valid;
+  }, ye = () => {
+    for (const r of h.unMount) {
+      const i = d(u, r);
+      i && (i._f.refs ? i._f.refs.every((a) => !ke(a)) : !ke(i._f.ref)) && Ve(r);
+    }
+    h.unMount = /* @__PURE__ */ new Set();
+  }, _ = (r, i) => !s.disabled && (r && i && V(l, r, i), !Q(Ne(), n)), A = (r, i, a) => Vr(r, h, {
+    ...y.mount ? l : w(i) ? n : $(r) ? { [r]: i } : i
+  }, a, i), k = (r) => Fe(d(y.mount ? l : n, r, e.shouldUnregister ? d(n, r, []) : [])), O = (r, i, a = {}) => {
+    const c = d(u, r);
+    let f = i;
+    if (c) {
+      const o = c._f;
+      o && (!o.disabled && V(l, r, lr(i, o)), f = ve(o.ref) && L(i) ? "" : i, sr(o.ref) ? [...o.ref.options].forEach((g) => g.selected = f.includes(g.value)) : o.refs ? fe(o.ref) ? o.refs.length > 1 ? o.refs.forEach((g) => (!g.defaultChecked || !g.disabled) && (g.checked = Array.isArray(f) ? !!f.find((v) => v === g.value) : f === g.value)) : o.refs[0] && (o.refs[0].checked = !!f) : o.refs.forEach((g) => g.checked = g.value === f) : Le(o.ref) ? o.ref.value = "" : (o.ref.value = f, o.ref.type || b.values.next({
+        name: r,
+        values: { ...l }
+      })));
+    }
+    (a.shouldDirty || a.shouldTouch) && re(r, f, a.shouldTouch, a.shouldDirty, !0), a.shouldValidate && le(r);
+  }, p = (r, i, a) => {
+    for (const c in i) {
+      const f = i[c], o = `${r}.${c}`, g = d(u, o);
+      (h.array.has(r) || D(f) || g && !g._f) && !ee(f) ? p(o, f, a) : O(o, f, a);
+    }
+  }, R = (r, i, a = {}) => {
+    const c = d(u, r), f = h.array.has(r), o = M(i);
+    V(l, r, o), f ? (b.array.next({
+      name: r,
+      values: { ...l }
+    }), (x.isDirty || x.dirtyFields) && a.shouldDirty && b.state.next({
+      name: r,
+      dirtyFields: ue(n, l),
+      isDirty: _(r, o)
+    })) : c && !c._f && !L(o) ? p(r, o, a) : O(r, o, a), je(r, h) && b.state.next({ ...t }), b.values.next({
+      name: y.mount ? r : void 0,
+      values: { ...l }
+    });
+  }, ie = async (r) => {
+    y.mount = !0;
+    const i = r.target;
+    let a = i.name, c = !0;
+    const f = d(u, a), o = () => i.type ? Ee(f._f) : gr(r), g = (v) => {
+      c = Number.isNaN(v) || ee(v) && isNaN(v.getTime()) || Q(v, d(l, a, v));
+    };
+    if (f) {
+      let v, S;
+      const T = o(), Z = r.type === He.BLUR || r.type === He.FOCUS_OUT, cr = !Tr(f._f) && !s.resolver && !d(t.errors, a) && !f._f.deps || Or(Z, d(t.touchedFields, a), t.isSubmitted, G, ce), we = je(a, h, Z);
+      V(l, a, T), Z ? (f._f.onBlur && f._f.onBlur(r), P && P(0)) : f._f.onChange && f._f.onChange(r);
+      const De = re(a, T, Z, !1), dr = !C(De) || we;
+      if (!Z && b.values.next({
+        name: a,
+        type: r.type,
+        values: { ...l }
+      }), cr)
+        return x.isValid && (e.mode === "onBlur" ? Z && j() : j()), dr && b.state.next({ name: a, ...we ? {} : De });
+      if (!Z && we && b.state.next({ ...t }), s.resolver) {
+        const { errors: qe } = await X([a]);
+        if (g(T), c) {
+          const yr = Xe(t.errors, u, a), We = Xe(qe, u, yr.name || a);
+          v = We.error, a = We.name, S = C(qe);
+        }
+      } else
+        J([a], !0), v = (await Je(f, l, N, s.shouldUseNativeValidation))[a], J([a]), g(T), c && (v ? S = !1 : x.isValid && (S = await U(u, !0)));
+      c && (f._f.deps && le(f._f.deps), de(a, S, v, De));
+    }
+  }, ae = (r, i) => {
+    if (d(t.errors, i) && r.focus)
+      return r.focus(), 1;
+  }, le = async (r, i = {}) => {
+    let a, c;
+    const f = ge(r);
+    if (s.resolver) {
+      const o = await te(w(r) ? r : f);
+      a = C(o), c = r ? !f.some((g) => d(o, g)) : a;
+    } else r ? (c = (await Promise.all(f.map(async (o) => {
+      const g = d(u, o);
+      return await U(g && g._f ? { [o]: g } : g);
+    }))).every(Boolean), !(!c && !t.isValid) && j()) : c = a = await U(u);
+    return b.state.next({
+      ...!$(r) || x.isValid && a !== t.isValid ? {} : { name: r },
+      ...s.resolver || !r ? { isValid: a } : {},
+      errors: t.errors
+    }), i.shouldFocus && !c && oe(u, ae, r ? f : h.mount), c;
+  }, Ne = (r) => {
+    const i = {
+      ...y.mount ? l : n
+    };
+    return w(r) ? i : $(r) ? d(i, r) : r.map((a) => d(i, a));
+  }, Ue = (r, i) => ({
+    invalid: !!d((i || t).errors, r),
+    isDirty: !!d((i || t).dirtyFields, r),
+    error: d((i || t).errors, r),
+    isValidating: !!d(t.validatingFields, r),
+    isTouched: !!d((i || t).touchedFields, r)
+  }), ur = (r) => {
+    r && ge(r).forEach((i) => E(t.errors, i)), b.state.next({
+      errors: r ? t.errors : {}
+    });
+  }, Re = (r, i, a) => {
+    const c = (d(u, r, { _f: {} })._f || {}).ref, f = d(t.errors, r) || {}, { ref: o, message: g, type: v, ...S } = f;
+    V(t.errors, r, {
+      ...S,
+      ...i,
+      ref: c
+    }), b.state.next({
+      name: r,
+      errors: t.errors,
+      isValid: !1
+    }), a && a.shouldFocus && c && c.focus && c.focus();
+  }, nr = (r, i) => H(r) ? b.values.subscribe({
+    next: (a) => r(A(void 0, i), a)
+  }) : A(r, i, !0), Ve = (r, i = {}) => {
+    for (const a of r ? ge(r) : h.mount)
+      h.mount.delete(a), h.array.delete(a), i.keepValue || (E(u, a), E(l, a)), !i.keepError && E(t.errors, a), !i.keepDirty && E(t.dirtyFields, a), !i.keepTouched && E(t.touchedFields, a), !i.keepIsValidating && E(t.validatingFields, a), !s.shouldUnregister && !i.keepDefaultValue && E(n, a);
+    b.values.next({
+      values: { ...l }
+    }), b.state.next({
+      ...t,
+      ...i.keepDirty ? { isDirty: _() } : {}
+    }), !i.keepIsValid && j();
+  }, Me = ({ disabled: r, name: i, field: a, fields: c, value: f }) => {
+    if (W(r) && y.mount || r) {
+      const o = r ? void 0 : w(f) ? Ee(a ? a._f : d(c, i)._f) : f;
+      V(l, i, o), re(i, o, !1, !1, !0);
+    }
+  }, xe = (r, i = {}) => {
+    let a = d(u, r);
+    const c = W(i.disabled) || W(s.disabled);
+    return V(u, r, {
+      ...a || {},
+      _f: {
+        ...a && a._f ? a._f : { ref: { name: r } },
+        name: r,
+        mount: !0,
+        ...i
+      }
+    }), h.mount.add(r), a ? Me({
+      field: a,
+      disabled: W(i.disabled) ? i.disabled : s.disabled,
+      name: r,
+      value: i.value
+    }) : m(r, !0, i.value), {
+      ...c ? { disabled: i.disabled || s.disabled } : {},
+      ...s.progressive ? {
+        required: !!i.required,
+        min: ne(i.min),
+        max: ne(i.max),
+        minLength: ne(i.minLength),
+        maxLength: ne(i.maxLength),
+        pattern: ne(i.pattern)
+      } : {},
+      name: r,
+      onChange: ie,
+      onBlur: ie,
+      ref: (f) => {
+        if (f) {
+          xe(r, i), a = d(u, r);
+          const o = w(f.value) && f.querySelectorAll && f.querySelectorAll("input,select,textarea")[0] || f, g = kr(o), v = a._f.refs || [];
+          if (g ? v.find((S) => S === o) : o === a._f.ref)
+            return;
+          V(u, r, {
+            _f: {
+              ...a._f,
+              ...g ? {
+                refs: [
+                  ...v.filter(ke),
+                  o,
+                  ...Array.isArray(d(n, r)) ? [{}] : []
+                ],
+                ref: { type: o.type, name: r }
+              } : { ref: o }
+            }
+          }), m(r, !1, void 0, o);
+        } else
+          a = d(u, r, {}), a._f && (a._f.mount = !1), (s.shouldUnregister || i.shouldUnregister) && !(vr(h.array, r) && y.action) && h.unMount.add(r);
+      }
+    };
+  }, Be = () => s.shouldFocusError && oe(u, ae, h.mount), or = (r) => {
+    W(r) && (b.state.next({ disabled: r }), oe(u, (i, a) => {
+      const c = d(u, a);
+      c && (i.disabled = c._f.disabled || r, Array.isArray(c._f.refs) && c._f.refs.forEach((f) => {
+        f.disabled = c._f.disabled || r;
+      }));
+    }, 0, !1));
+  }, Pe = (r, i) => async (a) => {
+    let c;
+    if (a && (a.preventDefault && a.preventDefault(), a.persist && a.persist()), s.disabled) {
+      i && await i({ ...t.errors }, a);
+      return;
+    }
+    let f = M(l);
+    if (b.state.next({
+      isSubmitting: !0
+    }), s.resolver) {
+      const { errors: o, values: g } = await X();
+      t.errors = o, f = g;
+    } else
+      await U(u);
+    if (E(t.errors, "root"), C(t.errors)) {
+      b.state.next({
+        errors: {}
+      });
+      try {
+        await r(f, a);
+      } catch (o) {
+        c = o;
+      }
+    } else
+      i && await i({ ...t.errors }, a), Be(), setTimeout(Be);
+    if (b.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: C(t.errors) && !c,
+      submitCount: t.submitCount + 1,
+      errors: t.errors
+    }), c)
+      throw c;
+  }, fr = (r, i = {}) => {
+    d(u, r) && (w(i.defaultValue) ? R(r, M(d(n, r))) : (R(r, i.defaultValue), V(n, r, M(i.defaultValue))), i.keepTouched || E(t.touchedFields, r), i.keepDirty || (E(t.dirtyFields, r), t.isDirty = i.defaultValue ? _(r, M(d(n, r))) : _()), i.keepError || (E(t.errors, r), x.isValid && j()), b.state.next({ ...t }));
+  }, pe = (r, i = {}) => {
+    const a = r ? M(r) : n, c = M(a), f = C(r), o = f ? n : c;
+    if (i.keepDefaultValues || (n = a), !i.keepValues) {
+      if (i.keepDirtyValues) {
+        const g = /* @__PURE__ */ new Set([
+          ...h.mount,
+          ...Object.keys(ue(n, l))
+        ]);
+        for (const v of Array.from(g))
+          d(t.dirtyFields, v) ? V(o, v, d(l, v)) : R(v, d(o, v));
+      } else {
+        if (Te && w(r))
+          for (const g of h.mount) {
+            const v = d(u, g);
+            if (v && v._f) {
+              const S = Array.isArray(v._f.refs) ? v._f.refs[0] : v._f.ref;
+              if (ve(S)) {
+                const T = S.closest("form");
+                if (T) {
+                  T.reset();
+                  break;
+                }
+              }
+            }
+          }
+        u = {};
+      }
+      l = e.shouldUnregister ? i.keepDefaultValues ? M(n) : {} : M(o), b.array.next({
+        values: { ...o }
+      }), b.values.next({
+        values: { ...o }
+      });
+    }
+    h = {
+      mount: i.keepDirtyValues ? h.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, y.mount = !x.isValid || !!i.keepIsValid || !!i.keepDirtyValues, y.watch = !!e.shouldUnregister, b.state.next({
+      submitCount: i.keepSubmitCount ? t.submitCount : 0,
+      isDirty: f ? !1 : i.keepDirty ? t.isDirty : !!(i.keepDefaultValues && !Q(r, n)),
+      isSubmitted: i.keepIsSubmitted ? t.isSubmitted : !1,
+      dirtyFields: f ? {} : i.keepDirtyValues ? i.keepDefaultValues && l ? ue(n, l) : t.dirtyFields : i.keepDefaultValues && r ? ue(n, r) : i.keepDirty ? t.dirtyFields : {},
+      touchedFields: i.keepTouched ? t.touchedFields : {},
+      errors: i.keepErrors ? t.errors : {},
+      isSubmitSuccessful: i.keepIsSubmitSuccessful ? t.isSubmitSuccessful : !1,
+      isSubmitting: !1
+    });
+  }, Ie = (r, i) => pe(H(r) ? r(l) : r, i);
+  return {
+    control: {
+      register: xe,
+      unregister: Ve,
+      getFieldState: Ue,
+      handleSubmit: Pe,
+      setError: Re,
+      _executeSchema: X,
+      _getWatch: A,
+      _getDirty: _,
+      _updateValid: j,
+      _removeUnmounted: ye,
+      _updateFieldArray: F,
+      _updateDisabledField: Me,
+      _getFieldArray: k,
+      _reset: pe,
+      _resetDefaultValues: () => H(s.defaultValues) && s.defaultValues().then((r) => {
+        Ie(r, s.resetOptions), b.state.next({
+          isLoading: !1
+        });
+      }),
+      _updateFormState: (r) => {
+        t = {
+          ...t,
+          ...r
+        };
+      },
+      _disableForm: or,
+      _subjects: b,
+      _proxyFormState: x,
+      _setErrors: Y,
+      get _fields() {
+        return u;
+      },
+      get _formValues() {
+        return l;
+      },
+      get _state() {
+        return y;
+      },
+      set _state(r) {
+        y = r;
+      },
+      get _defaultValues() {
+        return n;
+      },
+      get _names() {
+        return h;
+      },
+      set _names(r) {
+        h = r;
+      },
+      get _formState() {
+        return t;
+      },
+      set _formState(r) {
+        t = r;
+      },
+      get _options() {
+        return s;
+      },
+      set _options(r) {
+        s = {
+          ...s,
+          ...r
+        };
+      }
+    },
+    trigger: le,
+    register: xe,
+    handleSubmit: Pe,
+    watch: nr,
+    setValue: R,
+    getValues: Ne,
+    reset: Ie,
+    resetField: fr,
+    clearErrors: ur,
+    unregister: Ve,
+    setError: Re,
+    setFocus: (r, i = {}) => {
+      const a = d(u, r), c = a && a._f;
+      if (c) {
+        const f = c.refs ? c.refs[0] : c.ref;
+        f.focus && (f.focus(), i.shouldSelect && H(f.select) && f.select());
+      }
+    },
+    getFieldState: Ue
+  };
+}
+function Pr(e = {}) {
+  const s = B.useRef(), t = B.useRef(), [u, n] = B.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: H(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1,
+    defaultValues: H(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  s.current || (s.current = {
+    ...Nr(e),
+    formState: u
+  });
+  const l = s.current.control;
+  return l._options = e, Ar({
+    subject: l._subjects.state,
+    next: (y) => {
+      Fr(y, l._proxyFormState, l._updateFormState) && n({ ...l._formState });
+    }
+  }), B.useEffect(() => l._disableForm(e.disabled), [l, e.disabled]), B.useEffect(() => {
+    if (l._proxyFormState.isDirty) {
+      const y = l._getDirty();
+      y !== u.isDirty && l._subjects.state.next({
+        isDirty: y
+      });
+    }
+  }, [l, u.isDirty]), B.useEffect(() => {
+    e.values && !Q(e.values, t.current) ? (l._reset(e.values, l._options.resetOptions), t.current = e.values, n((y) => ({ ...y }))) : l._resetDefaultValues();
+  }, [e.values, l]), B.useEffect(() => {
+    e.errors && l._setErrors(e.errors);
+  }, [e.errors, l]), B.useEffect(() => {
+    l._state.mount || (l._updateValid(), l._state.mount = !0), l._state.watch && (l._state.watch = !1, l._subjects.state.next({ ...l._formState })), l._removeUnmounted();
+  }), B.useEffect(() => {
+    e.shouldUnregister && l._subjects.values.next({
+      values: l._getWatch()
+    });
+  }, [e.shouldUnregister, l]), s.current.formState = br(u, l), s.current;
+}
+export {
+  Pr as u
+};