suprform 1.0.7 → 1.0.9

package/dist/suprform.es.js

@@ -1,2 +1,1467 @@
-
+import { jsx as ne, Fragment as jr, jsxs as cr } from "react/jsx-runtime";
+import F, { createContext as Qr, useContext as Gr, useMemo as We, useImperativeHandle as Fr, cloneElement as He, Children as zr, isValidElement as Kr } from "react";
+var ve = (e) => e.type === "checkbox", le = (e) => e instanceof Date, G = (e) => e == null;
+const br = (e) => typeof e == "object";
+var M = (e) => !G(e) && !Array.isArray(e) && br(e) && !le(e), Ar = (e) => M(e) && e.target ? ve(e.target) ? e.target.checked : e.target.value : e, Yr = (e) => e.substring(0, e.search(/\.\d+(\.|$)/)) || e, pr = (e, t) => e.has(Yr(t)), Jr = (e) => {
+  const t = e.constructor && e.constructor.prototype;
+  return M(t) && t.hasOwnProperty("isPrototypeOf");
+}, ze = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function U(e) {
+  let t;
+  const r = Array.isArray(e), s = typeof FileList < "u" ? e instanceof FileList : !1;
+  if (e instanceof Date)
+    t = new Date(e);
+  else if (!(ze && (e instanceof Blob || s)) && (r || M(e)))
+    if (t = r ? [] : Object.create(Object.getPrototypeOf(e)), !r && !Jr(e))
+      t = e;
+    else
+      for (const u in e)
+        e.hasOwnProperty(u) && (t[u] = U(e[u]));
+  else
+    return e;
+  return t;
+}
+var xe = (e) => /^\w*$/.test(e), T = (e) => e === void 0, Se = (e) => Array.isArray(e) ? e.filter(Boolean) : [], Ke = (e) => Se(e.replace(/["|']|\]/g, "").split(/\.|\[/)), m = (e, t, r) => {
+  if (!t || !M(e))
+    return r;
+  const s = (xe(t) ? [t] : Ke(t)).reduce((u, i) => G(u) ? u : u[i], e);
+  return T(s) || s === e ? T(e[t]) ? r : e[t] : s;
+}, K = (e) => typeof e == "boolean", R = (e, t, r) => {
+  let s = -1;
+  const u = xe(t) ? [t] : Ke(t), i = u.length, l = i - 1;
+  for (; ++s < i; ) {
+    const c = u[s];
+    let v = r;
+    if (s !== l) {
+      const p = e[c];
+      v = M(p) || Array.isArray(p) ? p : isNaN(+u[s + 1]) ? {} : [];
+    }
+    if (c === "__proto__" || c === "constructor" || c === "prototype")
+      return;
+    e[c] = v, e = e[c];
+  }
+};
+const be = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, X = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, ae = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+}, Ye = F.createContext(null);
+Ye.displayName = "HookFormContext";
+const _e = () => F.useContext(Ye), Xr = (e) => {
+  const { children: t, ...r } = e;
+  return F.createElement(Ye.Provider, { value: r }, t);
+};
+var xr = (e, t, r, s = !0) => {
+  const u = {
+    defaultValues: t._defaultValues
+  };
+  for (const i in e)
+    Object.defineProperty(u, i, {
+      get: () => {
+        const l = i;
+        return t._proxyFormState[l] !== X.all && (t._proxyFormState[l] = !s || X.all), r && (r[l] = !0), e[l];
+      }
+    });
+  return u;
+};
+const Ee = typeof window < "u" ? F.useLayoutEffect : F.useEffect;
+function Zr(e) {
+  const t = _e(), { control: r = t.control, disabled: s, name: u, exact: i } = e || {}, [l, c] = F.useState(r._formState), v = F.useRef({
+    isDirty: !1,
+    isLoading: !1,
+    dirtyFields: !1,
+    touchedFields: !1,
+    validatingFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  });
+  return Ee(() => r._subscribe({
+    name: u,
+    formState: v.current,
+    exact: i,
+    callback: (p) => {
+      !s && c({
+        ...r._formState,
+        ...p
+      });
+    }
+  }), [u, s, i]), F.useEffect(() => {
+    v.current.isValid && r._setValid(!0);
+  }, [r]), F.useMemo(() => xr(l, r, v.current, !1), [l, r]);
+}
+var Y = (e) => typeof e == "string", $e = (e, t, r, s, u) => Y(e) ? (s && t.watch.add(e), m(r, e, u)) : Array.isArray(e) ? e.map((i) => (s && t.watch.add(i), m(r, i))) : (s && (t.watchAll = !0), r), qe = (e) => G(e) || !br(e);
+function ee(e, t, r = /* @__PURE__ */ new WeakSet()) {
+  if (qe(e) || qe(t))
+    return Object.is(e, t);
+  if (le(e) && le(t))
+    return e.getTime() === t.getTime();
+  const s = Object.keys(e), u = Object.keys(t);
+  if (s.length !== u.length)
+    return !1;
+  if (r.has(e) || r.has(t))
+    return !0;
+  r.add(e), r.add(t);
+  for (const i of s) {
+    const l = e[i];
+    if (!u.includes(i))
+      return !1;
+    if (i !== "ref") {
+      const c = t[i];
+      if (le(l) && le(c) || M(l) && M(c) || Array.isArray(l) && Array.isArray(c) ? !ee(l, c, r) : !Object.is(l, c))
+        return !1;
+    }
+  }
+  return !0;
+}
+function Sr(e) {
+  const t = _e(), { control: r = t.control, name: s, defaultValue: u, disabled: i, exact: l, compute: c } = e || {}, v = F.useRef(u), p = F.useRef(c), V = F.useRef(void 0), g = F.useRef(r), b = F.useRef(s);
+  p.current = c;
+  const [H, I] = F.useState(() => {
+    const f = r._getWatch(s, v.current);
+    return p.current ? p.current(f) : f;
+  }), C = F.useCallback((f) => {
+    const y = $e(s, r._names, f || r._formValues, !1, v.current);
+    return p.current ? p.current(y) : y;
+  }, [r._formValues, r._names, s]), B = F.useCallback((f) => {
+    if (!i) {
+      const y = $e(s, r._names, f || r._formValues, !1, v.current);
+      if (p.current) {
+        const x = p.current(y);
+        ee(x, V.current) || (I(x), V.current = x);
+      } else
+        I(y);
+    }
+  }, [r._formValues, r._names, i, s]);
+  Ee(() => ((g.current !== r || !ee(b.current, s)) && (g.current = r, b.current = s, B()), r._subscribe({
+    name: s,
+    formState: {
+      values: !0
+    },
+    exact: l,
+    callback: (f) => {
+      B(f.values);
+    }
+  })), [r, l, s, B]), F.useEffect(() => r._removeUnmounted());
+  const j = g.current !== r, S = b.current, P = F.useMemo(() => {
+    if (i)
+      return null;
+    const f = !j && !ee(S, s);
+    return j || f ? C() : null;
+  }, [i, j, s, S, C]);
+  return P !== null ? P : H;
+}
+function et(e) {
+  const t = _e(), { name: r, disabled: s, control: u = t.control, shouldUnregister: i, defaultValue: l, exact: c = !0 } = e, v = pr(u._names.array, r), p = F.useMemo(() => m(u._formValues, r, m(u._defaultValues, r, l)), [u, r, l]), V = Sr({
+    control: u,
+    name: r,
+    defaultValue: p,
+    exact: c
+  }), g = Zr({
+    control: u,
+    name: r,
+    exact: c
+  }), b = F.useRef(e), H = F.useRef(void 0), I = F.useRef(u.register(r, {
+    ...e.rules,
+    value: V,
+    ...K(e.disabled) ? { disabled: e.disabled } : {}
+  }));
+  b.current = e;
+  const C = F.useMemo(() => Object.defineProperties({}, {
+    invalid: {
+      enumerable: !0,
+      get: () => !!m(g.errors, r)
+    },
+    isDirty: {
+      enumerable: !0,
+      get: () => !!m(g.dirtyFields, r)
+    },
+    isTouched: {
+      enumerable: !0,
+      get: () => !!m(g.touchedFields, r)
+    },
+    isValidating: {
+      enumerable: !0,
+      get: () => !!m(g.validatingFields, r)
+    },
+    error: {
+      enumerable: !0,
+      get: () => m(g.errors, r)
+    }
+  }), [g, r]), B = F.useCallback((f) => I.current.onChange({
+    target: {
+      value: Ar(f),
+      name: r
+    },
+    type: be.CHANGE
+  }), [r]), j = F.useCallback(() => I.current.onBlur({
+    target: {
+      value: m(u._formValues, r),
+      name: r
+    },
+    type: be.BLUR
+  }), [r, u._formValues]), S = F.useCallback((f) => {
+    const y = m(u._fields, r);
+    y && f && (y._f.ref = {
+      focus: () => f.focus && f.focus(),
+      select: () => f.select && f.select(),
+      setCustomValidity: (x) => f.setCustomValidity(x),
+      reportValidity: () => f.reportValidity()
+    });
+  }, [u._fields, r]), P = F.useMemo(() => ({
+    name: r,
+    value: V,
+    ...K(s) || g.disabled ? { disabled: g.disabled || s } : {},
+    onChange: B,
+    onBlur: j,
+    ref: S
+  }), [r, s, g.disabled, B, j, S, V]);
+  return F.useEffect(() => {
+    const f = u._options.shouldUnregister || i, y = H.current;
+    y && y !== r && !v && u.unregister(y), u.register(r, {
+      ...b.current.rules,
+      ...K(b.current.disabled) ? { disabled: b.current.disabled } : {}
+    });
+    const x = (E, Z) => {
+      const W = m(u._fields, E);
+      W && W._f && (W._f.mount = Z);
+    };
+    if (x(r, !0), f) {
+      const E = U(m(u._options.defaultValues, r, b.current.defaultValue));
+      R(u._defaultValues, r, E), T(m(u._formValues, r)) && R(u._formValues, r, E);
+    }
+    return !v && u.register(r), H.current = r, () => {
+      (v ? f && !u._state.action : f) ? u.unregister(r) : x(r, !1);
+    };
+  }, [r, u, v, i]), F.useEffect(() => {
+    u._setDisabledField({
+      disabled: s,
+      name: r
+    });
+  }, [s, r, u]), F.useMemo(() => ({
+    field: P,
+    formState: g,
+    fieldState: C
+  }), [P, g, C]);
+}
+const rt = (e) => e.render(et(e));
+var tt = (e, t, r, s, u) => t ? {
+  ...r[e],
+  types: {
+    ...r[e] && r[e].types ? r[e].types : {},
+    [s]: u || !0
+  }
+} : {}, z = (e) => Array.isArray(e) ? e : [e], dr = () => {
+  let e = [];
+  return {
+    get observers() {
+      return e;
+    },
+    next: (u) => {
+      for (const i of e)
+        i.next && i.next(u);
+    },
+    subscribe: (u) => (e.push(u), {
+      unsubscribe: () => {
+        e = e.filter((i) => i !== u);
+      }
+    }),
+    unsubscribe: () => {
+      e = [];
+    }
+  };
+};
+function Er(e, t) {
+  const r = {};
+  for (const s in e)
+    if (e.hasOwnProperty(s)) {
+      const u = e[s], i = t[s];
+      if (u && M(u) && i) {
+        const l = Er(u, i);
+        M(l) && (r[s] = l);
+      } else e[s] && (r[s] = i);
+    }
+  return r;
+}
+var $ = (e) => M(e) && !Object.keys(e).length, Je = (e) => e.type === "file", re = (e) => typeof e == "function", Ae = (e) => {
+  if (!ze)
+    return !1;
+  const t = e ? e.ownerDocument : 0;
+  return e instanceof (t && t.defaultView ? t.defaultView.HTMLElement : HTMLElement);
+}, wr = (e) => e.type === "select-multiple", Xe = (e) => e.type === "radio", st = (e) => Xe(e) || ve(e), Oe = (e) => Ae(e) && e.isConnected;
+function at(e, t) {
+  const r = t.slice(0, -1).length;
+  let s = 0;
+  for (; s < r; )
+    e = T(e) ? s++ : e[t[s++]];
+  return e;
+}
+function nt(e) {
+  for (const t in e)
+    if (e.hasOwnProperty(t) && !T(e[t]))
+      return !1;
+  return !0;
+}
+function L(e, t) {
+  const r = Array.isArray(t) ? t : xe(t) ? [t] : Ke(t), s = r.length === 1 ? e : at(e, r), u = r.length - 1, i = r[u];
+  return s && delete s[i], u !== 0 && (M(s) && $(s) || Array.isArray(s) && nt(s)) && L(e, r.slice(0, -1)), e;
+}
+var it = (e) => {
+  for (const t in e)
+    if (re(e[t]))
+      return !0;
+  return !1;
+};
+function Cr(e) {
+  return Array.isArray(e) || M(e) && !it(e);
+}
+function je(e, t = {}) {
+  for (const r in e) {
+    const s = e[r];
+    Cr(s) ? (t[r] = Array.isArray(s) ? [] : {}, je(s, t[r])) : T(s) || (t[r] = !0);
+  }
+  return t;
+}
+function fe(e, t, r) {
+  r || (r = je(t));
+  for (const s in e) {
+    const u = e[s];
+    if (Cr(u))
+      T(t) || qe(r[s]) ? r[s] = je(u, Array.isArray(u) ? [] : {}) : fe(u, G(t) ? {} : t[s], r[s]);
+    else {
+      const i = t[s];
+      r[s] = !ee(u, i);
+    }
+  }
+  return r;
+}
+const fr = {
+  value: !1,
+  isValid: !1
+}, yr = { value: !0, isValid: !0 };
+var kr = (e) => {
+  if (Array.isArray(e)) {
+    if (e.length > 1) {
+      const t = e.filter((r) => r && r.checked && !r.disabled).map((r) => r.value);
+      return { value: t, isValid: !!t.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 === "" ? yr : { value: e[0].value, isValid: !0 } : yr
+    ) : fr;
+  }
+  return fr;
+}, Dr = (e, { valueAsNumber: t, valueAsDate: r, setValueAs: s }) => T(e) ? e : t ? e === "" ? NaN : e && +e : r && Y(e) ? new Date(e) : s ? s(e) : e;
+const mr = {
+  isValid: !1,
+  value: null
+};
+var Rr = (e) => Array.isArray(e) ? e.reduce((t, r) => r && r.checked && !r.disabled ? {
+  isValid: !0,
+  value: r.value
+} : t, mr) : mr;
+function _r(e) {
+  const t = e.ref;
+  return Je(t) ? t.files : Xe(t) ? Rr(e.refs).value : wr(t) ? [...t.selectedOptions].map(({ value: r }) => r) : ve(t) ? kr(e.refs).value : Dr(T(t.value) ? e.ref.value : t.value, e);
+}
+var ut = (e, t, r, s) => {
+  const u = {};
+  for (const i of e) {
+    const l = m(t, i);
+    l && R(u, i, l._f);
+  }
+  return {
+    criteriaMode: r,
+    names: [...e],
+    fields: u,
+    shouldUseNativeValidation: s
+  };
+}, pe = (e) => e instanceof RegExp, he = (e) => T(e) ? e : pe(e) ? e.source : M(e) ? pe(e.value) ? e.value.source : e.value : e, ye = (e) => ({
+  isOnSubmit: !e || e === X.onSubmit,
+  isOnBlur: e === X.onBlur,
+  isOnChange: e === X.onChange,
+  isOnAll: e === X.all,
+  isOnTouch: e === X.onTouched
+});
+const gr = "AsyncFunction";
+var ot = (e) => !!e && !!e.validate && !!(re(e.validate) && e.validate.constructor.name === gr || M(e.validate) && Object.values(e.validate).find((t) => t.constructor.name === gr)), lt = (e) => e.mount && (e.required || e.min || e.max || e.maxLength || e.minLength || e.pattern || e.validate), Qe = (e, t, r) => !r && (t.watchAll || t.watch.has(e) || [...t.watch].some((s) => e.startsWith(s) && /^\.\w+/.test(e.slice(s.length))));
+const me = (e, t, r, s) => {
+  for (const u of r || Object.keys(e)) {
+    const i = m(e, u);
+    if (i) {
+      const { _f: l, ...c } = i;
+      if (l) {
+        if (l.refs && l.refs[0] && t(l.refs[0], u) && !s)
+          return !0;
+        if (l.ref && t(l.ref, l.name) && !s)
+          return !0;
+        if (me(c, t))
+          break;
+      } else if (M(c) && me(c, t))
+        break;
+    }
+  }
+};
+function hr(e, t, r) {
+  const s = m(e, r);
+  if (s || xe(r))
+    return {
+      error: s,
+      name: r
+    };
+  const u = r.split(".");
+  for (; u.length; ) {
+    const i = u.join("."), l = m(t, i), c = m(e, i);
+    if (l && !Array.isArray(l) && r !== i)
+      return { name: r };
+    if (c && c.type)
+      return {
+        name: i,
+        error: c
+      };
+    if (c && c.root && c.root.type)
+      return {
+        name: `${i}.root`,
+        error: c.root
+      };
+    u.pop();
+  }
+  return {
+    name: r
+  };
+}
+var ct = (e, t, r, s) => {
+  r(e);
+  const { name: u, ...i } = e;
+  return $(i) || Object.keys(i).length >= Object.keys(t).length || Object.keys(i).find((l) => t[l] === (!s || X.all));
+}, dt = (e, t, r) => !e || !t || e === t || z(e).some((s) => s && (r ? s === t : s.startsWith(t) || t.startsWith(s))), ft = (e, t, r, s, u) => u.isOnAll ? !1 : !r && u.isOnTouch ? !(t || e) : (r ? s.isOnBlur : u.isOnBlur) ? !e : (r ? s.isOnChange : u.isOnChange) ? e : !0, yt = (e, t) => !Se(m(e, t)).length && L(e, t), Or = (e, t, r) => {
+  const s = z(m(e, r));
+  return R(s, "root", t[r]), R(e, r, s), e;
+};
+function vr(e, t, r = "validate") {
+  if (Y(e) || Array.isArray(e) && e.every(Y) || K(e) && !e)
+    return {
+      type: r,
+      message: Y(e) ? e : "",
+      ref: t
+    };
+}
+var de = (e) => M(e) && !pe(e) ? e : {
+  value: e,
+  message: ""
+}, Ge = async (e, t, r, s, u, i) => {
+  const { ref: l, refs: c, required: v, maxLength: p, minLength: V, min: g, max: b, pattern: H, validate: I, name: C, valueAsNumber: B, mount: j } = e._f, S = m(r, C);
+  if (!j || t.has(C))
+    return {};
+  const P = c ? c[0] : l, f = (w) => {
+    u && P.reportValidity && (P.setCustomValidity(K(w) ? "" : w || ""), P.reportValidity());
+  }, y = {}, x = Xe(l), E = ve(l), Z = x || E, W = (B || Je(l)) && T(l.value) && T(S) || Ae(l) && l.value === "" || S === "" || Array.isArray(S) && !S.length, oe = tt.bind(null, C, s, y), te = (w, D, N, q = ae.maxLength, Q = ae.minLength) => {
+    const se = w ? D : N;
+    y[C] = {
+      type: w ? q : Q,
+      message: se,
+      ref: l,
+      ...oe(w ? q : Q, se)
+    };
+  };
+  if (i ? !Array.isArray(S) || !S.length : v && (!Z && (W || G(S)) || K(S) && !S || E && !kr(c).isValid || x && !Rr(c).isValid)) {
+    const { value: w, message: D } = Y(v) ? { value: !!v, message: v } : de(v);
+    if (w && (y[C] = {
+      type: ae.required,
+      message: D,
+      ref: P,
+      ...oe(ae.required, D)
+    }, !s))
+      return f(D), y;
+  }
+  if (!W && (!G(g) || !G(b))) {
+    let w, D;
+    const N = de(b), q = de(g);
+    if (!G(S) && !isNaN(S)) {
+      const Q = l.valueAsNumber || S && +S;
+      G(N.value) || (w = Q > N.value), G(q.value) || (D = Q < q.value);
+    } else {
+      const Q = l.valueAsDate || new Date(S), se = (Ve) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + Ve), ge = l.type == "time", ce = l.type == "week";
+      Y(N.value) && S && (w = ge ? se(S) > se(N.value) : ce ? S > N.value : Q > new Date(N.value)), Y(q.value) && S && (D = ge ? se(S) < se(q.value) : ce ? S < q.value : Q < new Date(q.value));
+    }
+    if ((w || D) && (te(!!w, N.message, q.message, ae.max, ae.min), !s))
+      return f(y[C].message), y;
+  }
+  if ((p || V) && !W && (Y(S) || i && Array.isArray(S))) {
+    const w = de(p), D = de(V), N = !G(w.value) && S.length > +w.value, q = !G(D.value) && S.length < +D.value;
+    if ((N || q) && (te(N, w.message, D.message), !s))
+      return f(y[C].message), y;
+  }
+  if (H && !W && Y(S)) {
+    const { value: w, message: D } = de(H);
+    if (pe(w) && !S.match(w) && (y[C] = {
+      type: ae.pattern,
+      message: D,
+      ref: l,
+      ...oe(ae.pattern, D)
+    }, !s))
+      return f(D), y;
+  }
+  if (I) {
+    if (re(I)) {
+      const w = await I(S, r), D = vr(w, P);
+      if (D && (y[C] = {
+        ...D,
+        ...oe(ae.validate, D.message)
+      }, !s))
+        return f(D.message), y;
+    } else if (M(I)) {
+      let w = {};
+      for (const D in I) {
+        if (!$(w) && !s)
+          break;
+        const N = vr(await I[D](S, r), P, D);
+        N && (w = {
+          ...N,
+          ...oe(D, N.message)
+        }, f(N.message), s && (y[C] = w));
+      }
+      if (!$(w) && (y[C] = {
+        ref: P,
+        ...w
+      }, !s))
+        return y;
+    }
+  }
+  return f(!0), y;
+};
+const mt = {
+  mode: X.onSubmit,
+  reValidateMode: X.onChange,
+  shouldFocusError: !0
+};
+function _t(e = {}) {
+  let t = {
+    ...mt,
+    ...e
+  }, r = {
+    submitCount: 0,
+    isDirty: !1,
+    isReady: !1,
+    isLoading: re(t.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: t.errors || {},
+    disabled: t.disabled || !1
+  }, s = {}, u = M(t.defaultValues) || M(t.values) ? U(t.defaultValues || t.values) || {} : {}, i = t.shouldUnregister ? {} : U(u), l = {
+    action: !1,
+    mount: !1,
+    watch: !1
+  }, c = {
+    mount: /* @__PURE__ */ new Set(),
+    disabled: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, v, p = 0;
+  const V = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  };
+  let g = {
+    ...V
+  };
+  const b = {
+    array: dr(),
+    state: dr()
+  }, H = t.criteriaMode === X.all, I = (a) => (n) => {
+    clearTimeout(p), p = setTimeout(a, n);
+  }, C = async (a) => {
+    if (!t.disabled && (V.isValid || g.isValid || a)) {
+      const n = t.resolver ? $((await E()).errors) : await W(s, !0);
+      n !== r.isValid && b.state.next({
+        isValid: n
+      });
+    }
+  }, B = (a, n) => {
+    !t.disabled && (V.isValidating || V.validatingFields || g.isValidating || g.validatingFields) && ((a || Array.from(c.mount)).forEach((o) => {
+      o && (n ? R(r.validatingFields, o, n) : L(r.validatingFields, o));
+    }), b.state.next({
+      validatingFields: r.validatingFields,
+      isValidating: !$(r.validatingFields)
+    }));
+  }, j = (a, n = [], o, h, _ = !0, d = !0) => {
+    if (h && o && !t.disabled) {
+      if (l.action = !0, d && Array.isArray(m(s, a))) {
+        const A = o(m(s, a), h.argA, h.argB);
+        _ && R(s, a, A);
+      }
+      if (d && Array.isArray(m(r.errors, a))) {
+        const A = o(m(r.errors, a), h.argA, h.argB);
+        _ && R(r.errors, a, A), yt(r.errors, a);
+      }
+      if ((V.touchedFields || g.touchedFields) && d && Array.isArray(m(r.touchedFields, a))) {
+        const A = o(m(r.touchedFields, a), h.argA, h.argB);
+        _ && R(r.touchedFields, a, A);
+      }
+      (V.dirtyFields || g.dirtyFields) && (r.dirtyFields = fe(u, i)), b.state.next({
+        name: a,
+        isDirty: te(a, n),
+        dirtyFields: r.dirtyFields,
+        errors: r.errors,
+        isValid: r.isValid
+      });
+    } else
+      R(i, a, n);
+  }, S = (a, n) => {
+    R(r.errors, a, n), b.state.next({
+      errors: r.errors
+    });
+  }, P = (a) => {
+    r.errors = a, b.state.next({
+      errors: r.errors,
+      isValid: !1
+    });
+  }, f = (a, n, o, h) => {
+    const _ = m(s, a);
+    if (_) {
+      const d = m(i, a, T(o) ? m(u, a) : o);
+      T(d) || h && h.defaultChecked || n ? R(i, a, n ? d : _r(_._f)) : N(a, d), l.mount && !l.action && C();
+    }
+  }, y = (a, n, o, h, _) => {
+    let d = !1, A = !1;
+    const k = {
+      name: a
+    };
+    if (!t.disabled) {
+      if (!o || h) {
+        (V.isDirty || g.isDirty) && (A = r.isDirty, r.isDirty = k.isDirty = te(), d = A !== k.isDirty);
+        const O = ee(m(u, a), n);
+        A = !!m(r.dirtyFields, a), O ? L(r.dirtyFields, a) : R(r.dirtyFields, a, !0), k.dirtyFields = r.dirtyFields, d = d || (V.dirtyFields || g.dirtyFields) && A !== !O;
+      }
+      if (o) {
+        const O = m(r.touchedFields, a);
+        O || (R(r.touchedFields, a, o), k.touchedFields = r.touchedFields, d = d || (V.touchedFields || g.touchedFields) && O !== o);
+      }
+      d && _ && b.state.next(k);
+    }
+    return d ? k : {};
+  }, x = (a, n, o, h) => {
+    const _ = m(r.errors, a), d = (V.isValid || g.isValid) && K(n) && r.isValid !== n;
+    if (t.delayError && o ? (v = I(() => S(a, o)), v(t.delayError)) : (clearTimeout(p), v = null, o ? R(r.errors, a, o) : L(r.errors, a)), (o ? !ee(_, o) : _) || !$(h) || d) {
+      const A = {
+        ...h,
+        ...d && K(n) ? { isValid: n } : {},
+        errors: r.errors,
+        name: a
+      };
+      r = {
+        ...r,
+        ...A
+      }, b.state.next(A);
+    }
+  }, E = async (a) => {
+    B(a, !0);
+    const n = await t.resolver(i, t.context, ut(a || c.mount, s, t.criteriaMode, t.shouldUseNativeValidation));
+    return B(a), n;
+  }, Z = async (a) => {
+    const { errors: n } = await E(a);
+    if (a)
+      for (const o of a) {
+        const h = m(n, o);
+        h ? R(r.errors, o, h) : L(r.errors, o);
+      }
+    else
+      r.errors = n;
+    return n;
+  }, W = async (a, n, o = {
+    valid: !0
+  }) => {
+    for (const h in a) {
+      const _ = a[h];
+      if (_) {
+        const { _f: d, ...A } = _;
+        if (d) {
+          const k = c.array.has(d.name), O = _._f && ot(_._f);
+          O && V.validatingFields && B([d.name], !0);
+          const J = await Ge(_, c.disabled, i, H, t.shouldUseNativeValidation && !n, k);
+          if (O && V.validatingFields && B([d.name]), J[d.name] && (o.valid = !1, n))
+            break;
+          !n && (m(J, d.name) ? k ? Or(r.errors, J, d.name) : R(r.errors, d.name, J[d.name]) : L(r.errors, d.name));
+        }
+        !$(A) && await W(A, n, o);
+      }
+    }
+    return o.valid;
+  }, oe = () => {
+    for (const a of c.unMount) {
+      const n = m(s, a);
+      n && (n._f.refs ? n._f.refs.every((o) => !Oe(o)) : !Oe(n._f.ref)) && we(a);
+    }
+    c.unMount = /* @__PURE__ */ new Set();
+  }, te = (a, n) => !t.disabled && (a && n && R(i, a, n), !ee(Ve(), u)), w = (a, n, o) => $e(a, c, {
+    ...l.mount ? i : T(n) ? u : Y(a) ? { [a]: n } : n
+  }, o, n), D = (a) => Se(m(l.mount ? i : u, a, t.shouldUnregister ? m(u, a, []) : [])), N = (a, n, o = {}) => {
+    const h = m(s, a);
+    let _ = n;
+    if (h) {
+      const d = h._f;
+      d && (!d.disabled && R(i, a, Dr(n, d)), _ = Ae(d.ref) && G(n) ? "" : n, wr(d.ref) ? [...d.ref.options].forEach((A) => A.selected = _.includes(A.value)) : d.refs ? ve(d.ref) ? d.refs.forEach((A) => {
+        (!A.defaultChecked || !A.disabled) && (Array.isArray(_) ? A.checked = !!_.find((k) => k === A.value) : A.checked = _ === A.value || !!_);
+      }) : d.refs.forEach((A) => A.checked = A.value === _) : Je(d.ref) ? d.ref.value = "" : (d.ref.value = _, d.ref.type || b.state.next({
+        name: a,
+        values: U(i)
+      })));
+    }
+    (o.shouldDirty || o.shouldTouch) && y(a, _, o.shouldTouch, o.shouldDirty, !0), o.shouldValidate && ce(a);
+  }, q = (a, n, o) => {
+    for (const h in n) {
+      if (!n.hasOwnProperty(h))
+        return;
+      const _ = n[h], d = a + "." + h, A = m(s, d);
+      (c.array.has(a) || M(_) || A && !A._f) && !le(_) ? q(d, _, o) : N(d, _, o);
+    }
+  }, Q = (a, n, o = {}) => {
+    const h = m(s, a), _ = c.array.has(a), d = U(n);
+    R(i, a, d), _ ? (b.array.next({
+      name: a,
+      values: U(i)
+    }), (V.isDirty || V.dirtyFields || g.isDirty || g.dirtyFields) && o.shouldDirty && b.state.next({
+      name: a,
+      dirtyFields: fe(u, i),
+      isDirty: te(a, d)
+    })) : h && !h._f && !G(d) ? q(a, d, o) : N(a, d, o), Qe(a, c) && b.state.next({ ...r, name: a }), b.state.next({
+      name: l.mount ? a : void 0,
+      values: U(i)
+    });
+  }, se = async (a) => {
+    l.mount = !0;
+    const n = a.target;
+    let o = n.name, h = !0;
+    const _ = m(s, o), d = (O) => {
+      h = Number.isNaN(O) || le(O) && isNaN(O.getTime()) || ee(O, m(i, o, O));
+    }, A = ye(t.mode), k = ye(t.reValidateMode);
+    if (_) {
+      let O, J;
+      const Fe = n.type ? _r(_._f) : Ar(a), ie = a.type === be.BLUR || a.type === be.FOCUS_OUT, Hr = !lt(_._f) && !t.resolver && !m(r.errors, o) && !_._f.deps || ft(ie, m(r.touchedFields, o), r.isSubmitted, k, A), De = Qe(o, c, ie);
+      R(i, o, Fe), ie ? (!n || !n.readOnly) && (_._f.onBlur && _._f.onBlur(a), v && v(0)) : _._f.onChange && _._f.onChange(a);
+      const Re = y(o, Fe, ie), $r = !$(Re) || De;
+      if (!ie && b.state.next({
+        name: o,
+        type: a.type,
+        values: U(i)
+      }), Hr)
+        return (V.isValid || g.isValid) && (t.mode === "onBlur" ? ie && C() : ie || C()), $r && b.state.next({ name: o, ...De ? {} : Re });
+      if (!ie && De && b.state.next({ ...r }), t.resolver) {
+        const { errors: or } = await E([o]);
+        if (d(Fe), h) {
+          const qr = hr(r.errors, s, o), lr = hr(or, s, qr.name || o);
+          O = lr.error, o = lr.name, J = $(or);
+        }
+      } else
+        B([o], !0), O = (await Ge(_, c.disabled, i, H, t.shouldUseNativeValidation))[o], B([o]), d(Fe), h && (O ? J = !1 : (V.isValid || g.isValid) && (J = await W(s, !0)));
+      h && (_._f.deps && (!Array.isArray(_._f.deps) || _._f.deps.length > 0) && ce(_._f.deps), x(o, J, O, Re));
+    }
+  }, ge = (a, n) => {
+    if (m(r.errors, n) && a.focus)
+      return a.focus(), 1;
+  }, ce = async (a, n = {}) => {
+    let o, h;
+    const _ = z(a);
+    if (t.resolver) {
+      const d = await Z(T(a) ? a : _);
+      o = $(d), h = a ? !_.some((A) => m(d, A)) : o;
+    } else a ? (h = (await Promise.all(_.map(async (d) => {
+      const A = m(s, d);
+      return await W(A && A._f ? { [d]: A } : A);
+    }))).every(Boolean), !(!h && !r.isValid) && C()) : h = o = await W(s);
+    return b.state.next({
+      ...!Y(a) || (V.isValid || g.isValid) && o !== r.isValid ? {} : { name: a },
+      ...t.resolver || !a ? { isValid: o } : {},
+      errors: r.errors
+    }), n.shouldFocus && !h && me(s, ge, a ? _ : c.mount), h;
+  }, Ve = (a, n) => {
+    let o = {
+      ...l.mount ? i : u
+    };
+    return n && (o = Er(n.dirtyFields ? r.dirtyFields : r.touchedFields, o)), T(a) ? o : Y(a) ? m(o, a) : a.map((h) => m(o, h));
+  }, er = (a, n) => ({
+    invalid: !!m((n || r).errors, a),
+    isDirty: !!m((n || r).dirtyFields, a),
+    error: m((n || r).errors, a),
+    isValidating: !!m(r.validatingFields, a),
+    isTouched: !!m((n || r).touchedFields, a)
+  }), Nr = (a) => {
+    a && z(a).forEach((n) => L(r.errors, n)), b.state.next({
+      errors: a ? r.errors : {}
+    });
+  }, rr = (a, n, o) => {
+    const h = (m(s, a, { _f: {} })._f || {}).ref, _ = m(r.errors, a) || {}, { ref: d, message: A, type: k, ...O } = _;
+    R(r.errors, a, {
+      ...O,
+      ...n,
+      ref: h
+    }), b.state.next({
+      name: a,
+      errors: r.errors,
+      isValid: !1
+    }), o && o.shouldFocus && h && h.focus && h.focus();
+  }, Lr = (a, n) => re(a) ? b.state.subscribe({
+    next: (o) => "values" in o && a(w(void 0, n), o)
+  }) : w(a, n, !0), tr = (a) => b.state.subscribe({
+    next: (n) => {
+      dt(a.name, n.name, a.exact) && ct(n, a.formState || V, Wr, a.reRenderRoot) && a.callback({
+        values: { ...i },
+        ...r,
+        ...n,
+        defaultValues: u
+      });
+    }
+  }).unsubscribe, Mr = (a) => (l.mount = !0, g = {
+    ...g,
+    ...a.formState
+  }, tr({
+    ...a,
+    formState: g
+  })), we = (a, n = {}) => {
+    for (const o of a ? z(a) : c.mount)
+      c.mount.delete(o), c.array.delete(o), n.keepValue || (L(s, o), L(i, o)), !n.keepError && L(r.errors, o), !n.keepDirty && L(r.dirtyFields, o), !n.keepTouched && L(r.touchedFields, o), !n.keepIsValidating && L(r.validatingFields, o), !t.shouldUnregister && !n.keepDefaultValue && L(u, o);
+    b.state.next({
+      values: U(i)
+    }), b.state.next({
+      ...r,
+      ...n.keepDirty ? { isDirty: te() } : {}
+    }), !n.keepIsValid && C();
+  }, sr = ({ disabled: a, name: n }) => {
+    (K(a) && l.mount || a || c.disabled.has(n)) && (a ? c.disabled.add(n) : c.disabled.delete(n));
+  }, Ce = (a, n = {}) => {
+    let o = m(s, a);
+    const h = K(n.disabled) || K(t.disabled);
+    return R(s, a, {
+      ...o || {},
+      _f: {
+        ...o && o._f ? o._f : { ref: { name: a } },
+        name: a,
+        mount: !0,
+        ...n
+      }
+    }), c.mount.add(a), o ? sr({
+      disabled: K(n.disabled) ? n.disabled : t.disabled,
+      name: a
+    }) : f(a, !0, n.value), {
+      ...h ? { disabled: n.disabled || t.disabled } : {},
+      ...t.progressive ? {
+        required: !!n.required,
+        min: he(n.min),
+        max: he(n.max),
+        minLength: he(n.minLength),
+        maxLength: he(n.maxLength),
+        pattern: he(n.pattern)
+      } : {},
+      name: a,
+      onChange: se,
+      onBlur: se,
+      ref: (_) => {
+        if (_) {
+          Ce(a, n), o = m(s, a);
+          const d = T(_.value) && _.querySelectorAll && _.querySelectorAll("input,select,textarea")[0] || _, A = st(d), k = o._f.refs || [];
+          if (A ? k.find((O) => O === d) : d === o._f.ref)
+            return;
+          R(s, a, {
+            _f: {
+              ...o._f,
+              ...A ? {
+                refs: [
+                  ...k.filter(Oe),
+                  d,
+                  ...Array.isArray(m(u, a)) ? [{}] : []
+                ],
+                ref: { type: d.type, name: a }
+              } : { ref: d }
+            }
+          }), f(a, !1, void 0, d);
+        } else
+          o = m(s, a, {}), o._f && (o._f.mount = !1), (t.shouldUnregister || n.shouldUnregister) && !(pr(c.array, a) && l.action) && c.unMount.add(a);
+      }
+    };
+  }, ke = () => t.shouldFocusError && me(s, ge, c.mount), Ir = (a) => {
+    K(a) && (b.state.next({ disabled: a }), me(s, (n, o) => {
+      const h = m(s, o);
+      h && (n.disabled = h._f.disabled || a, Array.isArray(h._f.refs) && h._f.refs.forEach((_) => {
+        _.disabled = h._f.disabled || a;
+      }));
+    }, 0, !1));
+  }, ar = (a, n) => async (o) => {
+    let h;
+    o && (o.preventDefault && o.preventDefault(), o.persist && o.persist());
+    let _ = U(i);
+    if (b.state.next({
+      isSubmitting: !0
+    }), t.resolver) {
+      const { errors: d, values: A } = await E();
+      r.errors = d, _ = U(A);
+    } else
+      await W(s);
+    if (c.disabled.size)
+      for (const d of c.disabled)
+        L(_, d);
+    if (L(r.errors, "root"), $(r.errors)) {
+      b.state.next({
+        errors: {}
+      });
+      try {
+        await a(_, o);
+      } catch (d) {
+        h = d;
+      }
+    } else
+      n && await n({ ...r.errors }, o), ke(), setTimeout(ke);
+    if (b.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: $(r.errors) && !h,
+      submitCount: r.submitCount + 1,
+      errors: r.errors
+    }), h)
+      throw h;
+  }, Br = (a, n = {}) => {
+    m(s, a) && (T(n.defaultValue) ? Q(a, U(m(u, a))) : (Q(a, n.defaultValue), R(u, a, U(n.defaultValue))), n.keepTouched || L(r.touchedFields, a), n.keepDirty || (L(r.dirtyFields, a), r.isDirty = n.defaultValue ? te(a, U(m(u, a))) : te()), n.keepError || (L(r.errors, a), V.isValid && C()), b.state.next({ ...r }));
+  }, nr = (a, n = {}) => {
+    const o = a ? U(a) : u, h = U(o), _ = $(a), d = _ ? u : h;
+    if (n.keepDefaultValues || (u = o), !n.keepValues) {
+      if (n.keepDirtyValues) {
+        const A = /* @__PURE__ */ new Set([
+          ...c.mount,
+          ...Object.keys(fe(u, i))
+        ]);
+        for (const k of Array.from(A))
+          m(r.dirtyFields, k) ? R(d, k, m(i, k)) : Q(k, m(d, k));
+      } else {
+        if (ze && T(a))
+          for (const A of c.mount) {
+            const k = m(s, A);
+            if (k && k._f) {
+              const O = Array.isArray(k._f.refs) ? k._f.refs[0] : k._f.ref;
+              if (Ae(O)) {
+                const J = O.closest("form");
+                if (J) {
+                  J.reset();
+                  break;
+                }
+              }
+            }
+          }
+        if (n.keepFieldsRef)
+          for (const A of c.mount)
+            Q(A, m(d, A));
+        else
+          s = {};
+      }
+      i = t.shouldUnregister ? n.keepDefaultValues ? U(u) : {} : U(d), b.array.next({
+        values: { ...d }
+      }), b.state.next({
+        values: { ...d }
+      });
+    }
+    c = {
+      mount: n.keepDirtyValues ? c.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      disabled: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, l.mount = !V.isValid || !!n.keepIsValid || !!n.keepDirtyValues || !t.shouldUnregister && !$(d), l.watch = !!t.shouldUnregister, l.action = !1, n.keepErrors || (r.errors = {}), b.state.next({
+      submitCount: n.keepSubmitCount ? r.submitCount : 0,
+      isDirty: _ ? !1 : n.keepDirty ? r.isDirty : !!(n.keepDefaultValues && !ee(a, u)),
+      isSubmitted: n.keepIsSubmitted ? r.isSubmitted : !1,
+      dirtyFields: _ ? {} : n.keepDirtyValues ? n.keepDefaultValues && i ? fe(u, i) : r.dirtyFields : n.keepDefaultValues && a ? fe(u, a) : n.keepDirty ? r.dirtyFields : {},
+      touchedFields: n.keepTouched ? r.touchedFields : {},
+      errors: n.keepErrors ? r.errors : {},
+      isSubmitSuccessful: n.keepIsSubmitSuccessful ? r.isSubmitSuccessful : !1,
+      isSubmitting: !1,
+      defaultValues: u
+    });
+  }, ir = (a, n) => nr(re(a) ? a(i) : a, n), Pr = (a, n = {}) => {
+    const o = m(s, a), h = o && o._f;
+    if (h) {
+      const _ = h.refs ? h.refs[0] : h.ref;
+      _.focus && (_.focus(), n.shouldSelect && re(_.select) && _.select());
+    }
+  }, Wr = (a) => {
+    r = {
+      ...r,
+      ...a
+    };
+  }, ur = {
+    control: {
+      register: Ce,
+      unregister: we,
+      getFieldState: er,
+      handleSubmit: ar,
+      setError: rr,
+      _subscribe: tr,
+      _runSchema: E,
+      _focusError: ke,
+      _getWatch: w,
+      _getDirty: te,
+      _setValid: C,
+      _setFieldArray: j,
+      _setDisabledField: sr,
+      _setErrors: P,
+      _getFieldArray: D,
+      _reset: nr,
+      _resetDefaultValues: () => re(t.defaultValues) && t.defaultValues().then((a) => {
+        ir(a, t.resetOptions), b.state.next({
+          isLoading: !1
+        });
+      }),
+      _removeUnmounted: oe,
+      _disableForm: Ir,
+      _subjects: b,
+      _proxyFormState: V,
+      get _fields() {
+        return s;
+      },
+      get _formValues() {
+        return i;
+      },
+      get _state() {
+        return l;
+      },
+      set _state(a) {
+        l = a;
+      },
+      get _defaultValues() {
+        return u;
+      },
+      get _names() {
+        return c;
+      },
+      set _names(a) {
+        c = a;
+      },
+      get _formState() {
+        return r;
+      },
+      get _options() {
+        return t;
+      },
+      set _options(a) {
+        t = {
+          ...t,
+          ...a
+        };
+      }
+    },
+    subscribe: Mr,
+    trigger: ce,
+    register: Ce,
+    handleSubmit: ar,
+    watch: Lr,
+    setValue: Q,
+    getValues: Ve,
+    reset: ir,
+    resetField: Br,
+    clearErrors: Nr,
+    unregister: we,
+    setError: rr,
+    setFocus: Pr,
+    getFieldState: er
+  };
+  return {
+    ...ur,
+    formControl: ur
+  };
+}
+var ue = () => {
+  if (typeof crypto < "u" && crypto.randomUUID)
+    return crypto.randomUUID();
+  const e = typeof performance > "u" ? Date.now() : performance.now() * 1e3;
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (t) => {
+    const r = (Math.random() * 16 + e) % 16 | 0;
+    return (t == "x" ? r : r & 3 | 8).toString(16);
+  });
+}, Te = (e, t, r = {}) => r.shouldFocus || T(r.shouldFocus) ? r.focusName || `${e}.${T(r.focusIndex) ? t : r.focusIndex}.` : "", Ue = (e, t) => [
+  ...e,
+  ...z(t)
+], Ne = (e) => Array.isArray(e) ? e.map(() => {
+}) : void 0;
+function Le(e, t, r) {
+  return [
+    ...e.slice(0, t),
+    ...z(r),
+    ...e.slice(t)
+  ];
+}
+var Me = (e, t, r) => Array.isArray(e) ? (T(e[r]) && (e[r] = void 0), e.splice(r, 0, e.splice(t, 1)[0]), e) : [], Ie = (e, t) => [
+  ...z(t),
+  ...z(e)
+];
+function gt(e, t) {
+  let r = 0;
+  const s = [...e];
+  for (const u of t)
+    s.splice(u - r, 1), r++;
+  return Se(s).length ? s : [];
+}
+var Be = (e, t) => T(t) ? [] : gt(e, z(t).sort((r, s) => r - s)), Pe = (e, t, r) => {
+  [e[t], e[r]] = [e[r], e[t]];
+}, Vr = (e, t, r) => (e[t] = r, e);
+function ht(e) {
+  const t = _e(), { control: r = t.control, name: s, keyName: u = "id", shouldUnregister: i, rules: l } = e, [c, v] = F.useState(r._getFieldArray(s)), p = F.useRef(r._getFieldArray(s).map(ue)), V = F.useRef(!1);
+  r._names.array.add(s), F.useMemo(() => l && c.length >= 0 && r.register(s, l), [r, s, c.length, l]), Ee(() => r._subjects.array.subscribe({
+    next: ({ values: f, name: y }) => {
+      if (y === s || !y) {
+        const x = m(f, s);
+        Array.isArray(x) && (v(x), p.current = x.map(ue));
+      }
+    }
+  }).unsubscribe, [r, s]);
+  const g = F.useCallback((f) => {
+    V.current = !0, r._setFieldArray(s, f);
+  }, [r, s]), b = (f, y) => {
+    const x = z(U(f)), E = Ue(r._getFieldArray(s), x);
+    r._names.focus = Te(s, E.length - 1, y), p.current = Ue(p.current, x.map(ue)), g(E), v(E), r._setFieldArray(s, E, Ue, {
+      argA: Ne(f)
+    });
+  }, H = (f, y) => {
+    const x = z(U(f)), E = Ie(r._getFieldArray(s), x);
+    r._names.focus = Te(s, 0, y), p.current = Ie(p.current, x.map(ue)), g(E), v(E), r._setFieldArray(s, E, Ie, {
+      argA: Ne(f)
+    });
+  }, I = (f) => {
+    const y = Be(r._getFieldArray(s), f);
+    p.current = Be(p.current, f), g(y), v(y), !Array.isArray(m(r._fields, s)) && R(r._fields, s, void 0), r._setFieldArray(s, y, Be, {
+      argA: f
+    });
+  }, C = (f, y, x) => {
+    const E = z(U(y)), Z = Le(r._getFieldArray(s), f, E);
+    r._names.focus = Te(s, f, x), p.current = Le(p.current, f, E.map(ue)), g(Z), v(Z), r._setFieldArray(s, Z, Le, {
+      argA: f,
+      argB: Ne(y)
+    });
+  }, B = (f, y) => {
+    const x = r._getFieldArray(s);
+    Pe(x, f, y), Pe(p.current, f, y), g(x), v(x), r._setFieldArray(s, x, Pe, {
+      argA: f,
+      argB: y
+    }, !1);
+  }, j = (f, y) => {
+    const x = r._getFieldArray(s);
+    Me(x, f, y), Me(p.current, f, y), g(x), v(x), r._setFieldArray(s, x, Me, {
+      argA: f,
+      argB: y
+    }, !1);
+  }, S = (f, y) => {
+    const x = U(y), E = Vr(r._getFieldArray(s), f, x);
+    p.current = [...E].map((Z, W) => !Z || W === f ? ue() : p.current[W]), g(E), v([...E]), r._setFieldArray(s, E, Vr, {
+      argA: f,
+      argB: x
+    }, !0, !1);
+  }, P = (f) => {
+    const y = z(U(f));
+    p.current = y.map(ue), g([...y]), v([...y]), r._setFieldArray(s, [...y], (x) => x, {}, !0, !1);
+  };
+  return F.useEffect(() => {
+    if (r._state.action = !1, Qe(s, r._names) && r._subjects.state.next({
+      ...r._formState
+    }), V.current && (!ye(r._options.mode).isOnSubmit || r._formState.isSubmitted) && !ye(r._options.reValidateMode).isOnSubmit)
+      if (r._options.resolver)
+        r._runSchema([s]).then((f) => {
+          const y = m(f.errors, s), x = m(r._formState.errors, s);
+          (x ? !y && x.type || y && (x.type !== y.type || x.message !== y.message) : y && y.type) && (y ? R(r._formState.errors, s, y) : L(r._formState.errors, s), r._subjects.state.next({
+            errors: r._formState.errors
+          }));
+        });
+      else {
+        const f = m(r._fields, s);
+        f && f._f && !(ye(r._options.reValidateMode).isOnSubmit && ye(r._options.mode).isOnSubmit) && Ge(f, r._names.disabled, r._formValues, r._options.criteriaMode === X.all, r._options.shouldUseNativeValidation, !0).then((y) => !$(y) && r._subjects.state.next({
+          errors: Or(r._formState.errors, y, s)
+        }));
+      }
+    r._subjects.state.next({
+      name: s,
+      values: U(r._formValues)
+    }), r._names.focus && me(r._fields, (f, y) => {
+      if (r._names.focus && y.startsWith(r._names.focus) && f.focus)
+        return f.focus(), 1;
+    }), r._names.focus = "", r._setValid(), V.current = !1;
+  }, [c, s, r]), F.useEffect(() => (!m(r._formValues, s) && r._setFieldArray(s), () => {
+    const f = (y, x) => {
+      const E = m(r._fields, y);
+      E && E._f && (E._f.mount = x);
+    };
+    r._options.shouldUnregister || i ? r.unregister(s) : f(s, !1);
+  }), [s, r, u, i]), {
+    swap: F.useCallback(B, [g, s, r]),
+    move: F.useCallback(j, [g, s, r]),
+    prepend: F.useCallback(H, [g, s, r]),
+    append: F.useCallback(b, [g, s, r]),
+    remove: F.useCallback(I, [g, s, r]),
+    insert: F.useCallback(C, [g, s, r]),
+    update: F.useCallback(S, [g, s, r]),
+    replace: F.useCallback(P, [g, s, r]),
+    fields: F.useMemo(() => c.map((f, y) => ({
+      ...f,
+      [u]: p.current[y] || ue()
+    })), [c, u])
+  };
+}
+function vt(e = {}) {
+  const t = F.useRef(void 0), r = F.useRef(void 0), [s, u] = F.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: re(e.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1,
+    isReady: !1,
+    defaultValues: re(e.defaultValues) ? void 0 : e.defaultValues
+  });
+  if (!t.current)
+    if (e.formControl)
+      t.current = {
+        ...e.formControl,
+        formState: s
+      }, e.defaultValues && !re(e.defaultValues) && e.formControl.reset(e.defaultValues, e.resetOptions);
+    else {
+      const { formControl: l, ...c } = _t(e);
+      t.current = {
+        ...c,
+        formState: s
+      };
+    }
+  const i = t.current.control;
+  return i._options = e, Ee(() => {
+    const l = i._subscribe({
+      formState: i._proxyFormState,
+      callback: () => u({ ...i._formState }),
+      reRenderRoot: !0
+    });
+    return u((c) => ({
+      ...c,
+      isReady: !0
+    })), i._formState.isReady = !0, l;
+  }, [i]), F.useEffect(() => i._disableForm(e.disabled), [i, e.disabled]), F.useEffect(() => {
+    e.mode && (i._options.mode = e.mode), e.reValidateMode && (i._options.reValidateMode = e.reValidateMode);
+  }, [i, e.mode, e.reValidateMode]), F.useEffect(() => {
+    e.errors && (i._setErrors(e.errors), i._focusError());
+  }, [i, e.errors]), F.useEffect(() => {
+    e.shouldUnregister && i._subjects.state.next({
+      values: i._getWatch()
+    });
+  }, [i, e.shouldUnregister]), F.useEffect(() => {
+    if (i._proxyFormState.isDirty) {
+      const l = i._getDirty();
+      l !== s.isDirty && i._subjects.state.next({
+        isDirty: l
+      });
+    }
+  }, [i, s.isDirty]), F.useEffect(() => {
+    var l;
+    e.values && !ee(e.values, r.current) ? (i._reset(e.values, {
+      keepFieldsRef: !0,
+      ...i._options.resetOptions
+    }), !((l = i._options.resetOptions) === null || l === void 0) && l.keepIsValid || i._setValid(), r.current = e.values, u((c) => ({ ...c }))) : i._resetDefaultValues();
+  }, [i, e.values]), F.useEffect(() => {
+    i._state.mount || (i._setValid(), i._state.mount = !0), i._state.watch && (i._state.watch = !1, i._subjects.state.next({ ...i._formState })), i._removeUnmounted();
+  }), t.current.formState = xr(s, i), t.current;
+}
+const Tr = Qr(void 0), Vt = ({ showAsterisk: e, children: t }) => /* @__PURE__ */ ne(Tr.Provider, { value: { showAsterisk: e }, children: t }), Ft = () => {
+  const e = Gr(Tr);
+  if (!e)
+    throw new Error("useSuprFormContext must be used within a SuprFormProvider");
+  return e;
+}, bt = ({
+  children: e,
+  visibility: t
+}) => {
+  const { getValues: r } = _e(), s = We(() => typeof t == "boolean" ? [] : (t == null ? void 0 : t.conditions.map((l) => l.name)) || [], [t]), u = Sr({ name: s });
+  return We(() => {
+    if (typeof t == "boolean") return t;
+    if (!t || (t == null ? void 0 : t.conditions.length) === 0) return !0;
+    const { conditions: l, operator: c } = t, v = s.reduce((V, g, b) => (V[g] = u[b], V), {}), p = l.map((V) => {
+      const g = v[V.name];
+      switch (V.operator) {
+        case "EQUALS":
+          return g === V.value;
+        case "NOT_EQUALS":
+          return g !== V.value;
+        case "GREATER_THAN":
+          return g > V.value;
+        case "LESS_THAN":
+          return g < V.value;
+        case "GREATER_THAN_OR_EQUAL":
+          return g >= V.value;
+        case "LESS_THAN_OR_EQUAL":
+          return g <= V.value;
+        case "STARTS_WITH":
+          return g.startsWith(V.value);
+        case "ENDS_WITH":
+          return g.endsWith(V.value);
+        case "INCLUDES":
+          return g.includes(V.value);
+        case "NOT_INCLUDES":
+          return !g.includes(V.value);
+        default:
+          return !1;
+      }
+    });
+    return c === "AND" ? p.every(Boolean) : p.some(Boolean);
+  }, [t, s, u, r]) ? e : null;
+}, Ur = ({
+  children: e,
+  onSubmit: t = () => {
+  },
+  onError: r = () => {
+  },
+  style: s = {},
+  className: u = "",
+  formOptions: i,
+  showAsterisk: l,
+  ref: c
+}) => {
+  const v = vt({
+    mode: "onSubmit",
+    reValidateMode: "onChange",
+    shouldFocusError: !0,
+    ...i
+  });
+  return Fr(
+    c,
+    () => ({
+      setValue: v.setValue,
+      setError: v.setError,
+      clearErrors: v.clearErrors,
+      getValues: v.getValues,
+      reset: v.reset,
+      setFocus: v.setFocus,
+      resetField: v.resetField,
+      trigger: v.trigger,
+      unregister: v.unregister,
+      watch: v.watch
+    }),
+    [v]
+  ), /* @__PURE__ */ ne(Vt, { showAsterisk: l, children: /* @__PURE__ */ ne(Xr, { ...v, children: /* @__PURE__ */ ne(
+    "form",
+    {
+      noValidate: !0,
+      onSubmit: v.handleSubmit(t, r),
+      style: s,
+      className: u,
+      children: e
+    }
+  ) }) });
+}, Ze = ({
+  children: e,
+  name: t,
+  rules: r,
+  className: s,
+  label: u,
+  id: i,
+  disabled: l,
+  shouldUnregister: c,
+  visibility: v
+}) => {
+  const { control: p } = _e(), V = e.props.value, { showAsterisk: g } = Ft(), b = e.props.onChange, H = e.props.onBlur, I = We(() => i || crypto.randomUUID(), []), C = /* @__PURE__ */ ne(
+    rt,
+    {
+      control: p,
+      name: t,
+      rules: r,
+      defaultValue: V,
+      disabled: l,
+      shouldUnregister: c,
+      render: ({ field: { name: B, onBlur: j, value: S, onChange: P, ref: f }, fieldState: { error: y } }) => /* @__PURE__ */ cr(
+        "div",
+        {
+          className: `controlled-field ${s}`,
+          style: { display: "flex", flexDirection: "column", gap: "5px" },
+          children: [
+            u && /* @__PURE__ */ cr("label", { htmlFor: I, className: "controlled-field-label", children: [
+              u,
+              g && !!r && /* @__PURE__ */ ne("span", { style: { color: "red" }, children: " *" })
+            ] }),
+            He(e, {
+              ...e.props,
+              id: I,
+              name: B,
+              disabled: l,
+              onChange: (...x) => {
+                P(...x), b == null || b(...x);
+              },
+              value: S,
+              onBlur: (...x) => {
+                j(), H == null || H(...x);
+              },
+              ref: f
+            }),
+            y && /* @__PURE__ */ ne("div", { style: { color: "red", fontSize: 13 }, className: "controlled-field-error", children: y.message })
+          ]
+        }
+      )
+    }
+  );
+  return v ? /* @__PURE__ */ ne(bt, { visibility: v, children: C }) : C;
+}, At = ({ name: e, rules: t, ref: r, children: s }) => {
+  const u = ht({
+    name: e,
+    rules: t
+  });
+  Fr(r, () => u, [u]);
+  const i = (l, c) => zr.map(l, (v) => {
+    if (!Kr(v))
+      return v;
+    const p = v.props, V = v.type;
+    if (((V == null ? void 0 : V.displayName) === "SuprFormControl" || V === Ze || p.name !== void 0 && typeof V != "string") && p.name !== void 0) {
+      const b = {
+        ...p,
+        name: `${c}${p.name}`
+      };
+      return p.id !== void 0 && (b.id = `${c}${p.id}`), He(v, b);
+    }
+    return p.children ? He(v, {
+      ...p,
+      children: i(p.children, c)
+    }) : v;
+  });
+  return /* @__PURE__ */ ne(jr, { children: u.fields.map((l, c) => {
+    const v = `${e}.${c}.`;
+    return i(s, v);
+  }) });
+};
+Ze.displayName = "SuprFormControl";
+Ur.Control = Ze;
+Ur.ControlArray = At;
+export {
+  Ur as SuprForm
+};
 //# sourceMappingURL=suprform.es.js.map