brd-ui-kit 0.1.84 → 0.1.86

package/dist/index.esm-CFsbc_Iq.js

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