zudoku 0.39.5 → 0.40.0

package/lib/index.esm-D2ZUREQN.js

@@ -0,0 +1,1216 @@
+import v from "react";
+var ge = (e) => e.type === "checkbox", ue = (e) => e instanceof Date, j = (e) => e == null;
+const ft = (e) => typeof e == "object";
+var U = (e) => !j(e) && !Array.isArray(e) && ft(e) && !ue(e), yt = (e) => U(e) && e.target ? ge(e.target) ? e.target.checked : e.target.value : e, Mt = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, _t = (e, s) => e.has(Mt(s)), Nt = (e) => {
+  const s = e.constructor && e.constructor.prototype;
+  return U(s) && s.hasOwnProperty("isPrototypeOf");
+}, We = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function T(e) {
+  let s;
+  const t = Array.isArray(e), i = typeof FileList < "u" ? e instanceof FileList : !1;
+  if (e instanceof Date)
+    s = new Date(e);
+  else if (e instanceof Set)
+    s = new Set(e);
+  else if (!(We && (e instanceof Blob || i)) && (t || U(e)))
+    if (s = t ? [] : {}, !t && !Nt(e))
+      s = e;
+    else
+      for (const n in e)
+        e.hasOwnProperty(n) && (s[n] = T(e[n]));
+  else
+    return e;
+  return s;
+}
+var he = (e) => Array.isArray(e) ? e.filter(Boolean) : [], O = (e) => e === void 0, c = (e, s, t) => {
+  if (!s || !U(e))
+    return t;
+  const i = he(s.split(/[,[\].]+?/)).reduce((n, u) => j(n) ? n : n[u], e);
+  return O(i) || i === e ? O(e[s]) ? t : e[s] : i;
+}, Q = (e) => typeof e == "boolean", qe = (e) => /^\w*$/.test(e), gt = (e) => he(e.replace(/["|']|\]/g, "").split(/\.|\[/)), C = (e, s, t) => {
+  let i = -1;
+  const n = qe(s) ? [s] : gt(s), u = n.length, f = u - 1;
+  for (; ++i < u; ) {
+    const y = n[i];
+    let F = t;
+    if (i !== f) {
+      const x = e[y];
+      F = U(x) || Array.isArray(x) ? x : isNaN(+n[i + 1]) ? {} : [];
+    }
+    if (y === "__proto__" || y === "constructor" || y === "prototype")
+      return;
+    e[y] = F, e = e[y];
+  }
+};
+const me = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, ee = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, ie = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+}, ht = v.createContext(null), xe = () => v.useContext(ht), sr = (e) => {
+  const { children: s, ...t } = e;
+  return v.createElement(ht.Provider, { value: t }, s);
+};
+var vt = (e, s, t, i = !0) => {
+  const n = {
+    defaultValues: s._defaultValues
+  };
+  for (const u in e)
+    Object.defineProperty(n, u, {
+      get: () => {
+        const f = u;
+        return s._proxyFormState[f] !== ee.all && (s._proxyFormState[f] = !i || ee.all), t && (t[f] = !0), e[f];
+      }
+    });
+  return n;
+};
+function Bt(e) {
+  const s = xe(), { control: t = s.control, disabled: i, name: n, exact: u } = e || {}, [f, y] = v.useState(t._formState), F = v.useRef({
+    isDirty: !1,
+    isLoading: !1,
+    dirtyFields: !1,
+    touchedFields: !1,
+    validatingFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  }), x = v.useRef(n);
+  return x.current = n, v.useEffect(() => t._subscribe({
+    name: x.current,
+    formState: F.current,
+    exact: u,
+    callback: (w) => {
+      !i && y({
+        ...t._formState,
+        ...w
+      });
+    }
+  }), [t, i, u]), v.useEffect(() => {
+    F.current.isValid && t._setValid(!0);
+  }, [t]), v.useMemo(() => vt(f, t, F.current, !1), [f, t]);
+}
+var se = (e) => typeof e == "string", bt = (e, s, t, i, n) => se(e) ? (i && s.watch.add(e), c(t, e, n)) : Array.isArray(e) ? e.map((u) => (i && s.watch.add(u), c(t, u))) : (i && (s.watchAll = !0), t);
+function It(e) {
+  const s = xe(), { control: t = s.control, name: i, defaultValue: n, disabled: u, exact: f } = e || {}, y = v.useRef(i), F = v.useRef(n);
+  y.current = i, v.useEffect(() => t._subscribe({
+    name: y.current,
+    formState: {
+      values: !0
+    },
+    exact: f,
+    callback: (p) => !u && w(bt(y.current, t._names, p.values || t._formValues, !1, F.current))
+  }), [t, u, f]);
+  const [x, w] = v.useState(t._getWatch(i, n));
+  return v.useEffect(() => t._removeUnmounted()), x;
+}
+function Pt(e) {
+  const s = xe(), { name: t, disabled: i, control: n = s.control, shouldUnregister: u } = e, f = _t(n._names.array, t), y = It({
+    control: n,
+    name: t,
+    defaultValue: c(n._formValues, t, c(n._defaultValues, t, e.defaultValue)),
+    exact: !0
+  }), F = Bt({
+    control: n,
+    name: t,
+    exact: !0
+  }), x = v.useRef(e), w = v.useRef(n.register(t, {
+    ...e.rules,
+    value: y,
+    ...Q(e.disabled) ? { disabled: e.disabled } : {}
+  })), p = v.useMemo(() => Object.defineProperties({}, {
+    invalid: {
+      enumerable: !0,
+      get: () => !!c(F.errors, t)
+    },
+    isDirty: {
+      enumerable: !0,
+      get: () => !!c(F.dirtyFields, t)
+    },
+    isTouched: {
+      enumerable: !0,
+      get: () => !!c(F.touchedFields, t)
+    },
+    isValidating: {
+      enumerable: !0,
+      get: () => !!c(F.validatingFields, t)
+    },
+    error: {
+      enumerable: !0,
+      get: () => c(F.errors, t)
+    }
+  }), [F, t]), A = v.useCallback((P) => w.current.onChange({
+    target: {
+      value: yt(P),
+      name: t
+    },
+    type: me.CHANGE
+  }), [t]), R = v.useCallback(() => w.current.onBlur({
+    target: {
+      value: c(n._formValues, t),
+      name: t
+    },
+    type: me.BLUR
+  }), [t, n._formValues]), G = v.useCallback((P) => {
+    const W = c(n._fields, t);
+    W && P && (W._f.ref = {
+      focus: () => P.focus(),
+      select: () => P.select(),
+      setCustomValidity: (m) => P.setCustomValidity(m),
+      reportValidity: () => P.reportValidity()
+    });
+  }, [n._fields, t]), I = v.useMemo(() => ({
+    name: t,
+    value: y,
+    ...Q(i) || F.disabled ? { disabled: F.disabled || i } : {},
+    onChange: A,
+    onBlur: R,
+    ref: G
+  }), [t, i, F.disabled, A, R, G, y]);
+  return v.useEffect(() => {
+    const P = n._options.shouldUnregister || u;
+    n.register(t, {
+      ...x.current.rules,
+      ...Q(x.current.disabled) ? { disabled: x.current.disabled } : {}
+    });
+    const W = (m, Y) => {
+      const $ = c(n._fields, m);
+      $ && $._f && ($._f.mount = Y);
+    };
+    if (W(t, !0), P) {
+      const m = T(c(n._options.defaultValues, t));
+      C(n._defaultValues, t, m), O(c(n._formValues, t)) && C(n._formValues, t, m);
+    }
+    return !f && n.register(t), () => {
+      (f ? P && !n._state.action : P) ? n.unregister(t) : W(t, !1);
+    };
+  }, [t, n, f, u]), v.useEffect(() => {
+    n._setDisabledField({
+      disabled: i,
+      name: t
+    });
+  }, [i, t, n]), v.useMemo(() => ({
+    field: I,
+    formState: F,
+    fieldState: p
+  }), [I, F, p]);
+}
+const ir = (e) => e.render(Pt(e));
+var Wt = (e, s, t, i, n) => s ? {
+  ...t[e],
+  types: {
+    ...t[e] && t[e].types ? t[e].types : {},
+    [i]: n || !0
+  }
+} : {}, z = (e) => Array.isArray(e) ? e : [e], st = () => {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (n) => {
+      for (const u of e)
+        u.next && u.next(n);
+    },
+    subscribe: (n) => (e.push(n), {
+      unsubscribe: () => {
+        e = e.filter((u) => u !== n);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+}, Be = (e) => j(e) || !ft(e);
+function le(e, s) {
+  if (Be(e) || Be(s))
+    return e === s;
+  if (ue(e) && ue(s))
+    return e.getTime() === s.getTime();
+  const t = Object.keys(e), i = Object.keys(s);
+  if (t.length !== i.length)
+    return !1;
+  for (const n of t) {
+    const u = e[n];
+    if (!i.includes(n))
+      return !1;
+    if (n !== "ref") {
+      const f = s[n];
+      if (ue(u) && ue(f) || U(u) && U(f) || Array.isArray(u) && Array.isArray(f) ? !le(u, f) : u !== f)
+        return !1;
+    }
+  }
+  return !0;
+}
+var H = (e) => U(e) && !Object.keys(e).length, He = (e) => e.type === "file", te = (e) => typeof e == "function", Fe = (e) => {
+  if (!We)
+    return !1;
+  const s = e ? e.ownerDocument : 0;
+  return e instanceof (s && s.defaultView ? s.defaultView.HTMLElement : HTMLElement);
+}, mt = (e) => e.type === "select-multiple", $e = (e) => e.type === "radio", qt = (e) => $e(e) || ge(e), pe = (e) => Fe(e) && e.isConnected;
+function Ht(e, s) {
+  const t = s.slice(0, -1).length;
+  let i = 0;
+  for (; i < t; )
+    e = O(e) ? i++ : e[s[i++]];
+  return e;
+}
+function $t(e) {
+  for (const s in e)
+    if (e.hasOwnProperty(s) && !O(e[s]))
+      return !1;
+  return !0;
+}
+function B(e, s) {
+  const t = Array.isArray(s) ? s : qe(s) ? [s] : gt(s), i = t.length === 1 ? e : Ht(e, t), n = t.length - 1, u = t[n];
+  return i && delete i[u], n !== 0 && (U(i) && H(i) || Array.isArray(i) && $t(i)) && B(e, t.slice(0, -1)), e;
+}
+var Ft = (e) => {
+  for (const s in e)
+    if (te(e[s]))
+      return !0;
+  return !1;
+};
+function Ae(e, s = {}) {
+  const t = Array.isArray(e);
+  if (U(e) || t)
+    for (const i in e)
+      Array.isArray(e[i]) || U(e[i]) && !Ft(e[i]) ? (s[i] = Array.isArray(e[i]) ? [] : {}, Ae(e[i], s[i])) : j(e[i]) || (s[i] = !0);
+  return s;
+}
+function At(e, s, t) {
+  const i = Array.isArray(e);
+  if (U(e) || i)
+    for (const n in e)
+      Array.isArray(e[n]) || U(e[n]) && !Ft(e[n]) ? O(s) || Be(t[n]) ? t[n] = Array.isArray(e[n]) ? Ae(e[n], []) : { ...Ae(e[n]) } : At(e[n], j(s) ? {} : s[n], t[n]) : t[n] = !le(e[n], s[n]);
+  return t;
+}
+var ye = (e, s) => At(e, s, Ae(s));
+const it = {
+  value: !1,
+  isValid: !1
+}, at = { value: !0, isValid: !0 };
+var Vt = (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 && !O(e[0].attributes.value) ? O(e[0].value) || e[0].value === "" ? at : { value: e[0].value, isValid: !0 } : at
+    ) : it;
+  }
+  return it;
+}, xt = (e, { valueAsNumber: s, valueAsDate: t, setValueAs: i }) => O(e) ? e : s ? e === "" ? NaN : e && +e : t && se(e) ? new Date(e) : i ? i(e) : e;
+const nt = {
+  isValid: !1,
+  value: null
+};
+var St = (e) => Array.isArray(e) ? e.reduce((s, t) => t && t.checked && !t.disabled ? {
+  isValid: !0,
+  value: t.value
+} : s, nt) : nt;
+function lt(e) {
+  const s = e.ref;
+  return He(s) ? s.files : $e(s) ? St(e.refs).value : mt(s) ? [...s.selectedOptions].map(({ value: t }) => t) : ge(s) ? Vt(e.refs).value : xt(O(s.value) ? e.ref.value : s.value, e);
+}
+var jt = (e, s, t, i) => {
+  const n = {};
+  for (const u of e) {
+    const f = c(s, u);
+    f && C(n, u, f._f);
+  }
+  return {
+    criteriaMode: t,
+    names: [...e],
+    fields: n,
+    shouldUseNativeValidation: i
+  };
+}, Ve = (e) => e instanceof RegExp, _e = (e) => O(e) ? e : Ve(e) ? e.source : U(e) ? Ve(e.value) ? e.value.source : e.value : e, ce = (e) => ({
+  isOnSubmit: !e || e === ee.onSubmit,
+  isOnBlur: e === ee.onBlur,
+  isOnChange: e === ee.onChange,
+  isOnAll: e === ee.all,
+  isOnTouch: e === ee.onTouched
+});
+const ut = "AsyncFunction";
+var Kt = (e) => !!e && !!e.validate && !!(te(e.validate) && e.validate.constructor.name === ut || U(e.validate) && Object.values(e.validate).find((s) => s.constructor.name === ut)), zt = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate), Ie = (e, s, t) => !t && (s.watchAll || s.watch.has(e) || [...s.watch].some((i) => e.startsWith(i) && /^\.\w+/.test(e.slice(i.length))));
+const de = (e, s, t, i) => {
+  for (const n of t || Object.keys(e)) {
+    const u = c(e, n);
+    if (u) {
+      const { _f: f, ...y } = u;
+      if (f) {
+        if (f.refs && f.refs[0] && s(f.refs[0], n) && !i)
+          return !0;
+        if (f.ref && s(f.ref, f.name) && !i)
+          return !0;
+        if (de(y, s))
+          break;
+      } else if (U(y) && de(y, s))
+        break;
+    }
+  }
+};
+function ot(e, s, t) {
+  const i = c(e, t);
+  if (i || qe(t))
+    return {
+      error: i,
+      name: t
+    };
+  const n = t.split(".");
+  for (; n.length; ) {
+    const u = n.join("."), f = c(s, u), y = c(e, u);
+    if (f && !Array.isArray(f) && t !== u)
+      return { name: t };
+    if (y && y.type)
+      return {
+        name: u,
+        error: y
+      };
+    n.pop();
+  }
+  return {
+    name: t
+  };
+}
+var Gt = (e, s, t, i) => {
+  t(e);
+  const { name: n, ...u } = e;
+  return H(u) || Object.keys(u).length >= Object.keys(s).length || Object.keys(u).find((f) => s[f] === (!i || ee.all));
+}, Yt = (e, s, t) => !e || !s || e === s || z(e).some((i) => i && (t ? i === s : i.startsWith(s) || s.startsWith(i))), Jt = (e, s, t, i, n) => n.isOnAll ? !1 : !t && n.isOnTouch ? !(s || e) : (t ? i.isOnBlur : n.isOnBlur) ? !e : (t ? i.isOnChange : n.isOnChange) ? e : !0, Qt = (e, s) => !he(c(e, s)).length && B(e, s), wt = (e, s, t) => {
+  const i = z(c(e, t));
+  return C(i, "root", s[t]), C(e, t, i), e;
+}, be = (e) => se(e);
+function ct(e, s, t = "validate") {
+  if (be(e) || Array.isArray(e) && e.every(be) || Q(e) && !e)
+    return {
+      type: t,
+      message: be(e) ? e : "",
+      ref: s
+    };
+}
+var oe = (e) => U(e) && !Ve(e) ? e : {
+  value: e,
+  message: ""
+}, Pe = async (e, s, t, i, n, u) => {
+  const { ref: f, refs: y, required: F, maxLength: x, minLength: w, min: p, max: A, pattern: R, validate: G, name: I, valueAsNumber: P, mount: W } = e._f, m = c(t, I);
+  if (!W || s.has(I))
+    return {};
+  const Y = y ? y[0] : f, $ = (E) => {
+    n && Y.reportValidity && (Y.setCustomValidity(Q(E) ? "" : E || ""), Y.reportValidity());
+  }, M = {}, b = $e(f), h = ge(f), V = b || h, D = (P || He(f)) && O(f.value) && O(m) || Fe(f) && f.value === "" || m === "" || Array.isArray(m) && !m.length, J = Wt.bind(null, I, i, M), X = (E, S, L, K = ie.maxLength, Z = ie.minLength) => {
+    const re = E ? S : L;
+    M[I] = {
+      type: E ? K : Z,
+      message: re,
+      ref: f,
+      ...J(E ? K : Z, re)
+    };
+  };
+  if (u ? !Array.isArray(m) || !m.length : F && (!V && (D || j(m)) || Q(m) && !m || h && !Vt(y).isValid || b && !St(y).isValid)) {
+    const { value: E, message: S } = be(F) ? { value: !!F, message: F } : oe(F);
+    if (E && (M[I] = {
+      type: ie.required,
+      message: S,
+      ref: Y,
+      ...J(ie.required, S)
+    }, !i))
+      return $(S), M;
+  }
+  if (!D && (!j(p) || !j(A))) {
+    let E, S;
+    const L = oe(A), K = oe(p);
+    if (!j(m) && !isNaN(m)) {
+      const Z = f.valueAsNumber || m && +m;
+      j(L.value) || (E = Z > L.value), j(K.value) || (S = Z < K.value);
+    } else {
+      const Z = f.valueAsDate || new Date(m), re = (ve) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + ve), ae = f.type == "time", fe = f.type == "week";
+      se(L.value) && m && (E = ae ? re(m) > re(L.value) : fe ? m > L.value : Z > new Date(L.value)), se(K.value) && m && (S = ae ? re(m) < re(K.value) : fe ? m < K.value : Z < new Date(K.value));
+    }
+    if ((E || S) && (X(!!E, L.message, K.message, ie.max, ie.min), !i))
+      return $(M[I].message), M;
+  }
+  if ((x || w) && !D && (se(m) || u && Array.isArray(m))) {
+    const E = oe(x), S = oe(w), L = !j(E.value) && m.length > +E.value, K = !j(S.value) && m.length < +S.value;
+    if ((L || K) && (X(L, E.message, S.message), !i))
+      return $(M[I].message), M;
+  }
+  if (R && !D && se(m)) {
+    const { value: E, message: S } = oe(R);
+    if (Ve(E) && !m.match(E) && (M[I] = {
+      type: ie.pattern,
+      message: S,
+      ref: f,
+      ...J(ie.pattern, S)
+    }, !i))
+      return $(S), M;
+  }
+  if (G) {
+    if (te(G)) {
+      const E = await G(m, t), S = ct(E, Y);
+      if (S && (M[I] = {
+        ...S,
+        ...J(ie.validate, S.message)
+      }, !i))
+        return $(S.message), M;
+    } else if (U(G)) {
+      let E = {};
+      for (const S in G) {
+        if (!H(E) && !i)
+          break;
+        const L = ct(await G[S](m, t), Y, S);
+        L && (E = {
+          ...L,
+          ...J(S, L.message)
+        }, $(L.message), i && (M[I] = E));
+      }
+      if (!H(E) && (M[I] = {
+        ref: Y,
+        ...E
+      }, !i))
+        return M;
+    }
+  }
+  return $(!0), M;
+};
+const Xt = {
+  mode: ee.onSubmit,
+  reValidateMode: ee.onChange,
+  shouldFocusError: !0
+};
+function Zt(e = {}) {
+  let s = {
+    ...Xt,
+    ...e
+  }, t = {
+    submitCount: 0,
+    isDirty: !1,
+    isLoading: te(s.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: s.errors || {},
+    disabled: s.disabled || !1
+  };
+  const i = {};
+  let n = U(s.defaultValues) || U(s.values) ? T(s.values || s.defaultValues) || {} : {}, u = s.shouldUnregister ? {} : T(n), f = {
+    action: !1,
+    mount: !1,
+    watch: !1
+  }, y = {
+    mount: /* @__PURE__ */ new Set(),
+    disabled: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, F, x = 0;
+  const w = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  };
+  let p = {
+    ...w
+  };
+  const A = {
+    array: st(),
+    state: st()
+  }, R = ce(s.mode), G = ce(s.reValidateMode), I = s.criteriaMode === ee.all, P = (r) => (a) => {
+    clearTimeout(x), x = setTimeout(r, a);
+  }, W = async (r) => {
+    if (!s.disabled && (w.isValid || p.isValid || r)) {
+      const a = s.resolver ? H((await D()).errors) : await X(i, !0);
+      a !== t.isValid && A.state.next({
+        isValid: a
+      });
+    }
+  }, m = (r, a) => {
+    !s.disabled && (w.isValidating || w.validatingFields || p.isValidating || p.validatingFields) && ((r || Array.from(y.mount)).forEach((l) => {
+      l && (a ? C(t.validatingFields, l, a) : B(t.validatingFields, l));
+    }), A.state.next({
+      validatingFields: t.validatingFields,
+      isValidating: !H(t.validatingFields)
+    }));
+  }, Y = (r, a = [], l, _, d = !0, o = !0) => {
+    if (_ && l && !s.disabled) {
+      if (f.action = !0, o && Array.isArray(c(i, r))) {
+        const g = l(c(i, r), _.argA, _.argB);
+        d && C(i, r, g);
+      }
+      if (o && Array.isArray(c(t.errors, r))) {
+        const g = l(c(t.errors, r), _.argA, _.argB);
+        d && C(t.errors, r, g), Qt(t.errors, r);
+      }
+      if ((w.touchedFields || p.touchedFields) && o && Array.isArray(c(t.touchedFields, r))) {
+        const g = l(c(t.touchedFields, r), _.argA, _.argB);
+        d && C(t.touchedFields, r, g);
+      }
+      (w.dirtyFields || p.dirtyFields) && (t.dirtyFields = ye(n, u)), A.state.next({
+        name: r,
+        isDirty: S(r, a),
+        dirtyFields: t.dirtyFields,
+        errors: t.errors,
+        isValid: t.isValid
+      });
+    } else
+      C(u, r, a);
+  }, $ = (r, a) => {
+    C(t.errors, r, a), A.state.next({
+      errors: t.errors
+    });
+  }, M = (r) => {
+    t.errors = r, A.state.next({
+      errors: t.errors,
+      isValid: !1
+    });
+  }, b = (r, a, l, _) => {
+    const d = c(i, r);
+    if (d) {
+      const o = c(u, r, O(l) ? c(n, r) : l);
+      O(o) || _ && _.defaultChecked || a ? C(u, r, a ? o : lt(d._f)) : Z(r, o), f.mount && W();
+    }
+  }, h = (r, a, l, _, d) => {
+    let o = !1, g = !1;
+    const k = {
+      name: r
+    };
+    if (!s.disabled) {
+      if (!l || _) {
+        (w.isDirty || p.isDirty) && (g = t.isDirty, t.isDirty = k.isDirty = S(), o = g !== k.isDirty);
+        const N = le(c(n, r), a);
+        g = !!c(t.dirtyFields, r), N ? B(t.dirtyFields, r) : C(t.dirtyFields, r, !0), k.dirtyFields = t.dirtyFields, o = o || (w.dirtyFields || p.dirtyFields) && g !== !N;
+      }
+      if (l) {
+        const N = c(t.touchedFields, r);
+        N || (C(t.touchedFields, r, l), k.touchedFields = t.touchedFields, o = o || (w.touchedFields || p.touchedFields) && N !== l);
+      }
+      o && d && A.state.next(k);
+    }
+    return o ? k : {};
+  }, V = (r, a, l, _) => {
+    const d = c(t.errors, r), o = (w.isValid || p.isValid) && Q(a) && t.isValid !== a;
+    if (s.delayError && l ? (F = P(() => $(r, l)), F(s.delayError)) : (clearTimeout(x), F = null, l ? C(t.errors, r, l) : B(t.errors, r)), (l ? !le(d, l) : d) || !H(_) || o) {
+      const g = {
+        ..._,
+        ...o && Q(a) ? { isValid: a } : {},
+        errors: t.errors,
+        name: r
+      };
+      t = {
+        ...t,
+        ...g
+      }, A.state.next(g);
+    }
+  }, D = async (r) => {
+    m(r, !0);
+    const a = await s.resolver(u, s.context, jt(r || y.mount, i, s.criteriaMode, s.shouldUseNativeValidation));
+    return m(r), a;
+  }, J = async (r) => {
+    const { errors: a } = await D(r);
+    if (r)
+      for (const l of r) {
+        const _ = c(a, l);
+        _ ? C(t.errors, l, _) : B(t.errors, l);
+      }
+    else
+      t.errors = a;
+    return a;
+  }, X = async (r, a, l = {
+    valid: !0
+  }) => {
+    for (const _ in r) {
+      const d = r[_];
+      if (d) {
+        const { _f: o, ...g } = d;
+        if (o) {
+          const k = y.array.has(o.name), N = d._f && Kt(d._f);
+          N && w.validatingFields && m([_], !0);
+          const q = await Pe(d, y.disabled, u, I, s.shouldUseNativeValidation && !a, k);
+          if (N && w.validatingFields && m([_]), q[o.name] && (l.valid = !1, a))
+            break;
+          !a && (c(q, o.name) ? k ? wt(t.errors, q, o.name) : C(t.errors, o.name, q[o.name]) : B(t.errors, o.name));
+        }
+        !H(g) && await X(g, a, l);
+      }
+    }
+    return l.valid;
+  }, E = () => {
+    for (const r of y.unMount) {
+      const a = c(i, r);
+      a && (a._f.refs ? a._f.refs.every((l) => !pe(l)) : !pe(a._f.ref)) && we(r);
+    }
+    y.unMount = /* @__PURE__ */ new Set();
+  }, S = (r, a) => !s.disabled && (r && a && C(u, r, a), !le(je(), n)), L = (r, a, l) => bt(r, y, {
+    ...f.mount ? u : O(a) ? n : se(r) ? { [r]: a } : a
+  }, l, a), K = (r) => he(c(f.mount ? u : n, r, s.shouldUnregister ? c(n, r, []) : [])), Z = (r, a, l = {}) => {
+    const _ = c(i, r);
+    let d = a;
+    if (_) {
+      const o = _._f;
+      o && (!o.disabled && C(u, r, xt(a, o)), d = Fe(o.ref) && j(a) ? "" : a, mt(o.ref) ? [...o.ref.options].forEach((g) => g.selected = d.includes(g.value)) : o.refs ? ge(o.ref) ? o.refs.length > 1 ? o.refs.forEach((g) => (!g.defaultChecked || !g.disabled) && (g.checked = Array.isArray(d) ? !!d.find((k) => k === g.value) : d === g.value)) : o.refs[0] && (o.refs[0].checked = !!d) : o.refs.forEach((g) => g.checked = g.value === d) : He(o.ref) ? o.ref.value = "" : (o.ref.value = d, o.ref.type || A.state.next({
+        name: r,
+        values: T(u)
+      })));
+    }
+    (l.shouldDirty || l.shouldTouch) && h(r, d, l.shouldTouch, l.shouldDirty, !0), l.shouldValidate && Se(r);
+  }, re = (r, a, l) => {
+    for (const _ in a) {
+      const d = a[_], o = `${r}.${_}`, g = c(i, o);
+      (y.array.has(r) || U(d) || g && !g._f) && !ue(d) ? re(o, d, l) : Z(o, d, l);
+    }
+  }, ae = (r, a, l = {}) => {
+    const _ = c(i, r), d = y.array.has(r), o = T(a);
+    C(u, r, o), d ? (A.array.next({
+      name: r,
+      values: T(u)
+    }), (w.isDirty || w.dirtyFields || p.isDirty || p.dirtyFields) && l.shouldDirty && A.state.next({
+      name: r,
+      dirtyFields: ye(n, u),
+      isDirty: S(r, o)
+    })) : _ && !_._f && !j(o) ? re(r, o, l) : Z(r, o, l), Ie(r, y) && A.state.next({ ...t }), A.state.next({
+      name: f.mount ? r : void 0,
+      values: T(u)
+    });
+  }, fe = async (r) => {
+    f.mount = !0;
+    const a = r.target;
+    let l = a.name, _ = !0;
+    const d = c(i, l), o = (g) => {
+      _ = Number.isNaN(g) || ue(g) && isNaN(g.getTime()) || le(g, c(u, l, g));
+    };
+    if (d) {
+      let g, k;
+      const N = a.type ? lt(d._f) : yt(r), q = r.type === me.BLUR || r.type === me.FOCUS_OUT, Tt = !zt(d._f) && !s.resolver && !c(t.errors, l) && !d._f.deps || Jt(q, c(t.touchedFields, l), t.isSubmitted, G, R), De = Ie(l, y, q);
+      C(u, l, N), q ? (d._f.onBlur && d._f.onBlur(r), F && F(0)) : d._f.onChange && d._f.onChange(r);
+      const Ee = h(l, N, q), Lt = !H(Ee) || De;
+      if (!q && A.state.next({
+        name: l,
+        type: r.type,
+        values: T(u)
+      }), Tt)
+        return (w.isValid || p.isValid) && (s.mode === "onBlur" ? q && W() : q || W()), Lt && A.state.next({ name: l, ...De ? {} : Ee });
+      if (!q && De && A.state.next({ ...t }), s.resolver) {
+        const { errors: tt } = await D([l]);
+        if (o(N), _) {
+          const Ut = ot(t.errors, i, l), rt = ot(tt, i, Ut.name || l);
+          g = rt.error, l = rt.name, k = H(tt);
+        }
+      } else
+        m([l], !0), g = (await Pe(d, y.disabled, u, I, s.shouldUseNativeValidation))[l], m([l]), o(N), _ && (g ? k = !1 : (w.isValid || p.isValid) && (k = await X(i, !0)));
+      _ && (d._f.deps && Se(d._f.deps), V(l, k, g, Ee));
+    }
+  }, ve = (r, a) => {
+    if (c(t.errors, a) && r.focus)
+      return r.focus(), 1;
+  }, Se = async (r, a = {}) => {
+    let l, _;
+    const d = z(r);
+    if (s.resolver) {
+      const o = await J(O(r) ? r : d);
+      l = H(o), _ = r ? !d.some((g) => c(o, g)) : l;
+    } else r ? (_ = (await Promise.all(d.map(async (o) => {
+      const g = c(i, o);
+      return await X(g && g._f ? { [o]: g } : g);
+    }))).every(Boolean), !(!_ && !t.isValid) && W()) : _ = l = await X(i);
+    return A.state.next({
+      ...!se(r) || (w.isValid || p.isValid) && l !== t.isValid ? {} : { name: r },
+      ...s.resolver || !r ? { isValid: l } : {},
+      errors: t.errors
+    }), a.shouldFocus && !_ && de(i, ve, r ? d : y.mount), _;
+  }, je = (r) => {
+    const a = {
+      ...f.mount ? u : n
+    };
+    return O(r) ? a : se(r) ? c(a, r) : r.map((l) => c(a, l));
+  }, Ke = (r, a) => ({
+    invalid: !!c((a || t).errors, r),
+    isDirty: !!c((a || t).dirtyFields, r),
+    error: c((a || t).errors, r),
+    isValidating: !!c(t.validatingFields, r),
+    isTouched: !!c((a || t).touchedFields, r)
+  }), kt = (r) => {
+    r && z(r).forEach((a) => B(t.errors, a)), A.state.next({
+      errors: r ? t.errors : {}
+    });
+  }, ze = (r, a, l) => {
+    const _ = (c(i, r, { _f: {} })._f || {}).ref, d = c(t.errors, r) || {}, { ref: o, message: g, type: k, ...N } = d;
+    C(t.errors, r, {
+      ...N,
+      ...a,
+      ref: _
+    }), A.state.next({
+      name: r,
+      errors: t.errors,
+      isValid: !1
+    }), l && l.shouldFocus && _ && _.focus && _.focus();
+  }, Dt = (r, a) => te(r) ? A.state.subscribe({
+    next: (l) => r(L(void 0, a), l)
+  }) : L(r, a, !0), Ge = (r) => A.state.subscribe({
+    next: (a) => {
+      Yt(r.name, a.name, r.exact) && Gt(a, r.formState || w, Rt, r.reRenderRoot) && r.callback({
+        values: { ...u },
+        ...t,
+        ...a
+      });
+    }
+  }).unsubscribe, Et = (r) => (f.mount = !0, p = {
+    ...p,
+    ...r.formState
+  }, Ge({
+    ...r,
+    formState: p
+  })), we = (r, a = {}) => {
+    for (const l of r ? z(r) : y.mount)
+      y.mount.delete(l), y.array.delete(l), a.keepValue || (B(i, l), B(u, l)), !a.keepError && B(t.errors, l), !a.keepDirty && B(t.dirtyFields, l), !a.keepTouched && B(t.touchedFields, l), !a.keepIsValidating && B(t.validatingFields, l), !s.shouldUnregister && !a.keepDefaultValue && B(n, l);
+    A.state.next({
+      values: T(u)
+    }), A.state.next({
+      ...t,
+      ...a.keepDirty ? { isDirty: S() } : {}
+    }), !a.keepIsValid && W();
+  }, Ye = ({ disabled: r, name: a }) => {
+    (Q(r) && f.mount || r || y.disabled.has(a)) && (r ? y.disabled.add(a) : y.disabled.delete(a));
+  }, ke = (r, a = {}) => {
+    let l = c(i, r);
+    const _ = Q(a.disabled) || Q(s.disabled);
+    return C(i, r, {
+      ...l || {},
+      _f: {
+        ...l && l._f ? l._f : { ref: { name: r } },
+        name: r,
+        mount: !0,
+        ...a
+      }
+    }), y.mount.add(r), l ? Ye({
+      disabled: Q(a.disabled) ? a.disabled : s.disabled,
+      name: r
+    }) : b(r, !0, a.value), {
+      ..._ ? { disabled: a.disabled || s.disabled } : {},
+      ...s.progressive ? {
+        required: !!a.required,
+        min: _e(a.min),
+        max: _e(a.max),
+        minLength: _e(a.minLength),
+        maxLength: _e(a.maxLength),
+        pattern: _e(a.pattern)
+      } : {},
+      name: r,
+      onChange: fe,
+      onBlur: fe,
+      ref: (d) => {
+        if (d) {
+          ke(r, a), l = c(i, r);
+          const o = O(d.value) && d.querySelectorAll && d.querySelectorAll("input,select,textarea")[0] || d, g = qt(o), k = l._f.refs || [];
+          if (g ? k.find((N) => N === o) : o === l._f.ref)
+            return;
+          C(i, r, {
+            _f: {
+              ...l._f,
+              ...g ? {
+                refs: [
+                  ...k.filter(pe),
+                  o,
+                  ...Array.isArray(c(n, r)) ? [{}] : []
+                ],
+                ref: { type: o.type, name: r }
+              } : { ref: o }
+            }
+          }), b(r, !1, void 0, o);
+        } else
+          l = c(i, r, {}), l._f && (l._f.mount = !1), (s.shouldUnregister || a.shouldUnregister) && !(_t(y.array, r) && f.action) && y.unMount.add(r);
+      }
+    };
+  }, Je = () => s.shouldFocusError && de(i, ve, y.mount), pt = (r) => {
+    Q(r) && (A.state.next({ disabled: r }), de(i, (a, l) => {
+      const _ = c(i, l);
+      _ && (a.disabled = _._f.disabled || r, Array.isArray(_._f.refs) && _._f.refs.forEach((d) => {
+        d.disabled = _._f.disabled || r;
+      }));
+    }, 0, !1));
+  }, Qe = (r, a) => async (l) => {
+    let _;
+    l && (l.preventDefault && l.preventDefault(), l.persist && l.persist());
+    let d = T(u);
+    if (A.state.next({
+      isSubmitting: !0
+    }), s.resolver) {
+      const { errors: o, values: g } = await D();
+      t.errors = o, d = g;
+    } else
+      await X(i);
+    if (y.disabled.size)
+      for (const o of y.disabled)
+        C(d, o, void 0);
+    if (B(t.errors, "root"), H(t.errors)) {
+      A.state.next({
+        errors: {}
+      });
+      try {
+        await r(d, l);
+      } catch (o) {
+        _ = o;
+      }
+    } else
+      a && await a({ ...t.errors }, l), Je(), setTimeout(Je);
+    if (A.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: H(t.errors) && !_,
+      submitCount: t.submitCount + 1,
+      errors: t.errors
+    }), _)
+      throw _;
+  }, Ct = (r, a = {}) => {
+    c(i, r) && (O(a.defaultValue) ? ae(r, T(c(n, r))) : (ae(r, a.defaultValue), C(n, r, T(a.defaultValue))), a.keepTouched || B(t.touchedFields, r), a.keepDirty || (B(t.dirtyFields, r), t.isDirty = a.defaultValue ? S(r, T(c(n, r))) : S()), a.keepError || (B(t.errors, r), w.isValid && W()), A.state.next({ ...t }));
+  }, Xe = (r, a = {}) => {
+    const l = r ? T(r) : n, _ = T(l), d = H(r), o = d ? n : _;
+    if (a.keepDefaultValues || (n = l), !a.keepValues) {
+      if (a.keepDirtyValues) {
+        const g = /* @__PURE__ */ new Set([
+          ...y.mount,
+          ...Object.keys(ye(n, u))
+        ]);
+        for (const k of Array.from(g))
+          c(t.dirtyFields, k) ? C(o, k, c(u, k)) : ae(k, c(o, k));
+      } else {
+        if (We && O(r))
+          for (const g of y.mount) {
+            const k = c(i, g);
+            if (k && k._f) {
+              const N = Array.isArray(k._f.refs) ? k._f.refs[0] : k._f.ref;
+              if (Fe(N)) {
+                const q = N.closest("form");
+                if (q) {
+                  q.reset();
+                  break;
+                }
+              }
+            }
+          }
+        for (const g of y.mount)
+          ae(g, c(o, g));
+      }
+      u = T(o), A.array.next({
+        values: { ...o }
+      }), A.state.next({
+        values: { ...o }
+      });
+    }
+    y = {
+      mount: a.keepDirtyValues ? y.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      disabled: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, f.mount = !w.isValid || !!a.keepIsValid || !!a.keepDirtyValues, f.watch = !!s.shouldUnregister, A.state.next({
+      submitCount: a.keepSubmitCount ? t.submitCount : 0,
+      isDirty: d ? !1 : a.keepDirty ? t.isDirty : !!(a.keepDefaultValues && !le(r, n)),
+      isSubmitted: a.keepIsSubmitted ? t.isSubmitted : !1,
+      dirtyFields: d ? {} : a.keepDirtyValues ? a.keepDefaultValues && u ? ye(n, u) : t.dirtyFields : a.keepDefaultValues && r ? ye(n, r) : a.keepDirty ? t.dirtyFields : {},
+      touchedFields: a.keepTouched ? t.touchedFields : {},
+      errors: a.keepErrors ? t.errors : {},
+      isSubmitSuccessful: a.keepIsSubmitSuccessful ? t.isSubmitSuccessful : !1,
+      isSubmitting: !1
+    });
+  }, Ze = (r, a) => Xe(te(r) ? r(u) : r, a), Ot = (r, a = {}) => {
+    const l = c(i, r), _ = l && l._f;
+    if (_) {
+      const d = _.refs ? _.refs[0] : _.ref;
+      d.focus && (d.focus(), a.shouldSelect && te(d.select) && d.select());
+    }
+  }, Rt = (r) => {
+    t = {
+      ...t,
+      ...r
+    };
+  }, et = {
+    control: {
+      register: ke,
+      unregister: we,
+      getFieldState: Ke,
+      handleSubmit: Qe,
+      setError: ze,
+      _subscribe: Ge,
+      _runSchema: D,
+      _getWatch: L,
+      _getDirty: S,
+      _setValid: W,
+      _setFieldArray: Y,
+      _setDisabledField: Ye,
+      _setErrors: M,
+      _getFieldArray: K,
+      _reset: Xe,
+      _resetDefaultValues: () => te(s.defaultValues) && s.defaultValues().then((r) => {
+        Ze(r, s.resetOptions), A.state.next({
+          isLoading: !1
+        });
+      }),
+      _removeUnmounted: E,
+      _disableForm: pt,
+      _subjects: A,
+      _proxyFormState: w,
+      get _fields() {
+        return i;
+      },
+      get _formValues() {
+        return u;
+      },
+      get _state() {
+        return f;
+      },
+      set _state(r) {
+        f = r;
+      },
+      get _defaultValues() {
+        return n;
+      },
+      get _names() {
+        return y;
+      },
+      set _names(r) {
+        y = r;
+      },
+      get _formState() {
+        return t;
+      },
+      get _options() {
+        return s;
+      },
+      set _options(r) {
+        s = {
+          ...s,
+          ...r
+        };
+      }
+    },
+    subscribe: Et,
+    trigger: Se,
+    register: ke,
+    handleSubmit: Qe,
+    watch: Dt,
+    setValue: ae,
+    getValues: je,
+    reset: Ze,
+    resetField: Ct,
+    clearErrors: kt,
+    unregister: we,
+    setError: ze,
+    setFocus: Ot,
+    getFieldState: Ke
+  };
+  return {
+    ...et,
+    formControl: et
+  };
+}
+var ne = () => {
+  const e = typeof performance > "u" ? Date.now() : performance.now() * 1e3;
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (s) => {
+    const t = (Math.random() * 16 + e) % 16 | 0;
+    return (s == "x" ? t : t & 3 | 8).toString(16);
+  });
+}, Ce = (e, s, t = {}) => t.shouldFocus || O(t.shouldFocus) ? t.focusName || `${e}.${O(t.focusIndex) ? s : t.focusIndex}.` : "", Oe = (e, s) => [
+  ...e,
+  ...z(s)
+], Re = (e) => Array.isArray(e) ? e.map(() => {
+}) : void 0;
+function Te(e, s, t) {
+  return [
+    ...e.slice(0, s),
+    ...z(t),
+    ...e.slice(s)
+  ];
+}
+var Le = (e, s, t) => Array.isArray(e) ? (O(e[t]) && (e[t] = void 0), e.splice(t, 0, e.splice(s, 1)[0]), e) : [], Ue = (e, s) => [
+  ...z(s),
+  ...z(e)
+];
+function er(e, s) {
+  let t = 0;
+  const i = [...e];
+  for (const n of s)
+    i.splice(n - t, 1), t++;
+  return he(i).length ? i : [];
+}
+var Me = (e, s) => O(s) ? [] : er(e, z(s).sort((t, i) => t - i)), Ne = (e, s, t) => {
+  [e[s], e[t]] = [e[t], e[s]];
+}, dt = (e, s, t) => (e[s] = t, e);
+function ar(e) {
+  const s = xe(), { control: t = s.control, name: i, keyName: n = "id", shouldUnregister: u, rules: f } = e, [y, F] = v.useState(t._getFieldArray(i)), x = v.useRef(t._getFieldArray(i).map(ne)), w = v.useRef(y), p = v.useRef(i), A = v.useRef(!1);
+  p.current = i, w.current = y, t._names.array.add(i), f && t.register(i, f), v.useEffect(() => t._subjects.array.subscribe({
+    next: ({ values: b, name: h }) => {
+      if (h === p.current || !h) {
+        const V = c(b, p.current);
+        Array.isArray(V) && (F(V), x.current = V.map(ne));
+      }
+    }
+  }).unsubscribe, [t]);
+  const R = v.useCallback((b) => {
+    A.current = !0, t._setFieldArray(i, b);
+  }, [t, i]), G = (b, h) => {
+    const V = z(T(b)), D = Oe(t._getFieldArray(i), V);
+    t._names.focus = Ce(i, D.length - 1, h), x.current = Oe(x.current, V.map(ne)), R(D), F(D), t._setFieldArray(i, D, Oe, {
+      argA: Re(b)
+    });
+  }, I = (b, h) => {
+    const V = z(T(b)), D = Ue(t._getFieldArray(i), V);
+    t._names.focus = Ce(i, 0, h), x.current = Ue(x.current, V.map(ne)), R(D), F(D), t._setFieldArray(i, D, Ue, {
+      argA: Re(b)
+    });
+  }, P = (b) => {
+    const h = Me(t._getFieldArray(i), b);
+    x.current = Me(x.current, b), R(h), F(h), !Array.isArray(c(t._fields, i)) && C(t._fields, i, void 0), t._setFieldArray(i, h, Me, {
+      argA: b
+    });
+  }, W = (b, h, V) => {
+    const D = z(T(h)), J = Te(t._getFieldArray(i), b, D);
+    t._names.focus = Ce(i, b, V), x.current = Te(x.current, b, D.map(ne)), R(J), F(J), t._setFieldArray(i, J, Te, {
+      argA: b,
+      argB: Re(h)
+    });
+  }, m = (b, h) => {
+    const V = t._getFieldArray(i);
+    Ne(V, b, h), Ne(x.current, b, h), R(V), F(V), t._setFieldArray(i, V, Ne, {
+      argA: b,
+      argB: h
+    }, !1);
+  }, Y = (b, h) => {
+    const V = t._getFieldArray(i);
+    Le(V, b, h), Le(x.current, b, h), R(V), F(V), t._setFieldArray(i, V, Le, {
+      argA: b,
+      argB: h
+    }, !1);
+  }, $ = (b, h) => {
+    const V = T(h), D = dt(t._getFieldArray(i), b, V);
+    x.current = [...D].map((J, X) => !J || X === b ? ne() : x.current[X]), R(D), F([...D]), t._setFieldArray(i, D, dt, {
+      argA: b,
+      argB: V
+    }, !0, !1);
+  }, M = (b) => {
+    const h = z(T(b));
+    x.current = h.map(ne), R([...h]), F([...h]), t._setFieldArray(i, [...h], (V) => V, {}, !0, !1);
+  };
+  return v.useEffect(() => {
+    if (t._state.action = !1, Ie(i, t._names) && t._subjects.state.next({
+      ...t._formState
+    }), A.current && (!ce(t._options.mode).isOnSubmit || t._formState.isSubmitted) && !ce(t._options.reValidateMode).isOnSubmit)
+      if (t._options.resolver)
+        t._runSchema([i]).then((b) => {
+          const h = c(b.errors, i), V = c(t._formState.errors, i);
+          (V ? !h && V.type || h && (V.type !== h.type || V.message !== h.message) : h && h.type) && (h ? C(t._formState.errors, i, h) : B(t._formState.errors, i), t._subjects.state.next({
+            errors: t._formState.errors
+          }));
+        });
+      else {
+        const b = c(t._fields, i);
+        b && b._f && !(ce(t._options.reValidateMode).isOnSubmit && ce(t._options.mode).isOnSubmit) && Pe(b, t._names.disabled, t._formValues, t._options.criteriaMode === ee.all, t._options.shouldUseNativeValidation, !0).then((h) => !H(h) && t._subjects.state.next({
+          errors: wt(t._formState.errors, h, i)
+        }));
+      }
+    t._subjects.state.next({
+      name: i,
+      values: T(t._formValues)
+    }), t._names.focus && de(t._fields, (b, h) => {
+      if (t._names.focus && h.startsWith(t._names.focus) && b.focus)
+        return b.focus(), 1;
+    }), t._names.focus = "", t._setValid(), A.current = !1;
+  }, [y, i, t]), v.useEffect(() => (!c(t._formValues, i) && t._setFieldArray(i), () => {
+    const b = (h, V) => {
+      const D = c(t._fields, h);
+      D && D._f && (D._f.mount = V);
+    };
+    t._options.shouldUnregister || u ? t.unregister(i) : b(i, !1);
+  }), [i, t, n, u]), {
+    swap: v.useCallback(m, [R, i, t]),
+    move: v.useCallback(Y, [R, i, t]),
+    prepend: v.useCallback(I, [R, i, t]),
+    append: v.useCallback(G, [R, i, t]),
+    remove: v.useCallback(P, [R, i, t]),
+    insert: v.useCallback(W, [R, i, t]),
+    update: v.useCallback($, [R, i, t]),
+    replace: v.useCallback(M, [R, i, t]),
+    fields: v.useMemo(() => y.map((b, h) => ({
+      ...b,
+      [n]: x.current[h] || ne()
+    })), [y, n])
+  };
+}
+function nr(e = {}) {
+  const s = v.useRef(void 0), t = v.useRef(void 0), [i, n] = v.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: te(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1,
+    defaultValues: te(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  s.current || (s.current = {
+    ...e.formControl ? e.formControl : Zt(e),
+    formState: i
+  }, e.formControl && e.defaultValues && !te(e.defaultValues) && e.formControl.reset(e.defaultValues, e.resetOptions));
+  const u = s.current.control;
+  return u._options = e, v.useLayoutEffect(() => u._subscribe({
+    formState: u._proxyFormState,
+    callback: () => n({ ...u._formState }),
+    reRenderRoot: !0
+  }), [u]), v.useEffect(() => u._disableForm(e.disabled), [u, e.disabled]), v.useEffect(() => {
+    if (u._proxyFormState.isDirty) {
+      const f = u._getDirty();
+      f !== i.isDirty && u._subjects.state.next({
+        isDirty: f
+      });
+    }
+  }, [u, i.isDirty]), v.useEffect(() => {
+    e.values && !le(e.values, t.current) ? (u._reset(e.values, u._options.resetOptions), t.current = e.values, n((f) => ({ ...f }))) : u._resetDefaultValues();
+  }, [e.values, u]), v.useEffect(() => {
+    e.errors && !H(e.errors) && u._setErrors(e.errors);
+  }, [e.errors, u]), v.useEffect(() => {
+    u._state.mount || (u._setValid(), u._state.mount = !0), u._state.watch && (u._state.watch = !1, u._subjects.state.next({ ...u._formState })), u._removeUnmounted();
+  }), v.useEffect(() => {
+    e.shouldUnregister && u._subjects.state.next({
+      values: u._getWatch()
+    });
+  }, [e.shouldUnregister, u]), s.current.formState = vt(i, u), s.current;
+}
+export {
+  ir as C,
+  sr as F,
+  nr as a,
+  ar as b,
+  xe as u
+};
+//# sourceMappingURL=index.esm-D2ZUREQN.js.map