@fluidattacks/design 8.1.0 → 8.2.0

package/dist/node_modules/react-hook-form/dist/index.esm.js

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