solid-hook-form 1.4.1 → 1.5.0

package/dist/main.js

@@ -1,141 +1,1407 @@
-import { createSignal as d, createContext as H, createComponent as T, useContext as q } from "solid-js";
-const S = (e) => {
-  const n = e.target;
-  return n instanceof HTMLSelectElement ? n.value : n instanceof HTMLInputElement && n.type === "checkbox" ? n.checked : n instanceof HTMLInputElement && n.type === "file" ? [...n.files || []] : n.value;
-}, y = (e, n) => {
-  if (e instanceof HTMLSelectElement) {
-    e.value = n;
+import { createSignal as _e, createContext as Qe, createComponent as Ke, useContext as Xe } from "solid-js";
+const Ze = (n) => {
+  const s = n.target;
+  return s instanceof HTMLSelectElement ? s.value : s instanceof HTMLInputElement && s.type === "checkbox" ? s.checked : s instanceof HTMLInputElement && s.type === "file" ? [...s.files || []] : s.value;
+}, ge = (n, s) => {
+  if (n instanceof HTMLSelectElement) {
+    n.value = s;
     return;
   }
-  if (e instanceof HTMLInputElement && e.type === "checkbox") {
-    e.checked = n;
+  if (n instanceof HTMLInputElement && n.type === "checkbox") {
+    n.checked = s;
     return;
   }
-  e instanceof HTMLInputElement && e.type === "file" || (e.value = n);
-}, p = (e) => e instanceof RegExp || typeof e == "string" || typeof e == "number" ? e : e.value, g = (e) => typeof e == "string" ? e : typeof e.message == "string" ? e.message : "", N = (e, n, r = {}) => {
-  const i = e[n];
-  if (r.required && !i)
-    return { type: "required", message: g(r.required) };
-  if (r.min && Number(i) < Number(p(r.min)))
-    return { type: "min", message: g(r.min) };
-  if (r.max && Number(i) > Number(p(r.max)))
-    return { type: "max", message: g(r.max) };
-  if (r.minLength && i.length < p(r.minLength))
-    return { type: "minLength", message: g(r.minLength) };
-  if (r.maxLength && i.length > p(r.maxLength))
-    return { type: "maxLength", message: g(r.maxLength) };
-  if (r.pattern && !p(r.pattern).test(i))
-    return { type: "pattern", message: g(r.pattern) };
-  if (r.validate) {
-    const c = r.validate(i, e);
-    if (c === !1)
+  n instanceof HTMLInputElement && n.type === "file" || (n.value = s);
+};
+function Je(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var ye = { exports: {} }, l = {};
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Me;
+function et() {
+  if (Me) return l;
+  Me = 1;
+  var n = Symbol.for("react.transitional.element"), s = Symbol.for("react.portal"), _ = Symbol.for("react.fragment"), E = Symbol.for("react.strict_mode"), w = Symbol.for("react.profiler"), N = Symbol.for("react.consumer"), M = Symbol.for("react.context"), P = Symbol.for("react.forward_ref"), j = Symbol.for("react.suspense"), L = Symbol.for("react.memo"), U = Symbol.for("react.lazy"), G = Symbol.iterator;
+  function Z(t) {
+    return t === null || typeof t != "object" ? null : (t = G && t[G] || t["@@iterator"], typeof t == "function" ? t : null);
+  }
+  var B = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, V = Object.assign, Q = {};
+  function H(t, o, f) {
+    this.props = t, this.context = o, this.refs = Q, this.updater = f || B;
+  }
+  H.prototype.isReactComponent = {}, H.prototype.setState = function(t, o) {
+    if (typeof t != "object" && typeof t != "function" && t != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, t, o, "setState");
+  }, H.prototype.forceUpdate = function(t) {
+    this.updater.enqueueForceUpdate(this, t, "forceUpdate");
+  };
+  function W() {
+  }
+  W.prototype = H.prototype;
+  function K(t, o, f) {
+    this.props = t, this.context = o, this.refs = Q, this.updater = f || B;
+  }
+  var I = K.prototype = new W();
+  I.constructor = K, V(I, H.prototype), I.isPureReactComponent = !0;
+  var J = Array.isArray, R = { H: null, A: null, T: null, S: null, V: null }, z = Object.prototype.hasOwnProperty;
+  function X(t, o, f, c, g, S) {
+    return f = S.ref, {
+      $$typeof: n,
+      type: t,
+      key: o,
+      ref: f !== void 0 ? f : null,
+      props: S
+    };
+  }
+  function Y(t, o) {
+    return X(
+      t.type,
+      o,
+      void 0,
+      void 0,
+      void 0,
+      t.props
+    );
+  }
+  function F(t) {
+    return typeof t == "object" && t !== null && t.$$typeof === n;
+  }
+  function ae(t) {
+    var o = { "=": "=0", ":": "=2" };
+    return "$" + t.replace(/[=:]/g, function(f) {
+      return o[f];
+    });
+  }
+  var C = /\/+/g;
+  function p(t, o) {
+    return typeof t == "object" && t !== null && t.key != null ? ae("" + t.key) : o.toString(36);
+  }
+  function O() {
+  }
+  function T(t) {
+    switch (t.status) {
+      case "fulfilled":
+        return t.value;
+      case "rejected":
+        throw t.reason;
+      default:
+        switch (typeof t.status == "string" ? t.then(O, O) : (t.status = "pending", t.then(
+          function(o) {
+            t.status === "pending" && (t.status = "fulfilled", t.value = o);
+          },
+          function(o) {
+            t.status === "pending" && (t.status = "rejected", t.reason = o);
+          }
+        )), t.status) {
+          case "fulfilled":
+            return t.value;
+          case "rejected":
+            throw t.reason;
+        }
+    }
+    throw t;
+  }
+  function k(t, o, f, c, g) {
+    var S = typeof t;
+    (S === "undefined" || S === "boolean") && (t = null);
+    var m = !1;
+    if (t === null) m = !0;
+    else
+      switch (S) {
+        case "bigint":
+        case "string":
+        case "number":
+          m = !0;
+          break;
+        case "object":
+          switch (t.$$typeof) {
+            case n:
+            case s:
+              m = !0;
+              break;
+            case U:
+              return m = t._init, k(
+                m(t._payload),
+                o,
+                f,
+                c,
+                g
+              );
+          }
+      }
+    if (m)
+      return g = g(t), m = c === "" ? "." + p(t, 0) : c, J(g) ? (f = "", m != null && (f = m.replace(C, "$&/") + "/"), k(g, o, f, "", function(te) {
+        return te;
+      })) : g != null && (F(g) && (g = Y(
+        g,
+        f + (g.key == null || t && t.key === g.key ? "" : ("" + g.key).replace(
+          C,
+          "$&/"
+        ) + "/") + m
+      )), o.push(g)), 1;
+    m = 0;
+    var q = c === "" ? "." : c + ":";
+    if (J(t))
+      for (var A = 0; A < t.length; A++)
+        c = t[A], S = q + p(c, A), m += k(
+          c,
+          o,
+          f,
+          S,
+          g
+        );
+    else if (A = Z(t), typeof A == "function")
+      for (t = A.call(t), A = 0; !(c = t.next()).done; )
+        c = c.value, S = q + p(c, A++), m += k(
+          c,
+          o,
+          f,
+          S,
+          g
+        );
+    else if (S === "object") {
+      if (typeof t.then == "function")
+        return k(
+          T(t),
+          o,
+          f,
+          c,
+          g
+        );
+      throw o = String(t), Error(
+        "Objects are not valid as a React child (found: " + (o === "[object Object]" ? "object with keys {" + Object.keys(t).join(", ") + "}" : o) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return m;
+  }
+  function $(t, o, f) {
+    if (t == null) return t;
+    var c = [], g = 0;
+    return k(t, c, "", "", function(S) {
+      return o.call(f, S, g++);
+    }), c;
+  }
+  function oe(t) {
+    if (t._status === -1) {
+      var o = t._result;
+      o = o(), o.then(
+        function(f) {
+          (t._status === 0 || t._status === -1) && (t._status = 1, t._result = f);
+        },
+        function(f) {
+          (t._status === 0 || t._status === -1) && (t._status = 2, t._result = f);
+        }
+      ), t._status === -1 && (t._status = 0, t._result = o);
+    }
+    if (t._status === 1) return t._result.default;
+    throw t._result;
+  }
+  var ee = typeof reportError == "function" ? reportError : function(t) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var o = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof t == "object" && t !== null && typeof t.message == "string" ? String(t.message) : String(t),
+        error: t
+      });
+      if (!window.dispatchEvent(o)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", t);
+      return;
+    }
+    console.error(t);
+  };
+  function ce() {
+  }
+  return l.Children = {
+    map: $,
+    forEach: function(t, o, f) {
+      $(
+        t,
+        function() {
+          o.apply(this, arguments);
+        },
+        f
+      );
+    },
+    count: function(t) {
+      var o = 0;
+      return $(t, function() {
+        o++;
+      }), o;
+    },
+    toArray: function(t) {
+      return $(t, function(o) {
+        return o;
+      }) || [];
+    },
+    only: function(t) {
+      if (!F(t))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return t;
+    }
+  }, l.Component = H, l.Fragment = _, l.Profiler = w, l.PureComponent = K, l.StrictMode = E, l.Suspense = j, l.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = R, l.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(t) {
+      return R.H.useMemoCache(t);
+    }
+  }, l.cache = function(t) {
+    return function() {
+      return t.apply(null, arguments);
+    };
+  }, l.cloneElement = function(t, o, f) {
+    if (t == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + t + "."
+      );
+    var c = V({}, t.props), g = t.key, S = void 0;
+    if (o != null)
+      for (m in o.ref !== void 0 && (S = void 0), o.key !== void 0 && (g = "" + o.key), o)
+        !z.call(o, m) || m === "key" || m === "__self" || m === "__source" || m === "ref" && o.ref === void 0 || (c[m] = o[m]);
+    var m = arguments.length - 2;
+    if (m === 1) c.children = f;
+    else if (1 < m) {
+      for (var q = Array(m), A = 0; A < m; A++)
+        q[A] = arguments[A + 2];
+      c.children = q;
+    }
+    return X(t.type, g, void 0, void 0, S, c);
+  }, l.createContext = function(t) {
+    return t = {
+      $$typeof: M,
+      _currentValue: t,
+      _currentValue2: t,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, t.Provider = t, t.Consumer = {
+      $$typeof: N,
+      _context: t
+    }, t;
+  }, l.createElement = function(t, o, f) {
+    var c, g = {}, S = null;
+    if (o != null)
+      for (c in o.key !== void 0 && (S = "" + o.key), o)
+        z.call(o, c) && c !== "key" && c !== "__self" && c !== "__source" && (g[c] = o[c]);
+    var m = arguments.length - 2;
+    if (m === 1) g.children = f;
+    else if (1 < m) {
+      for (var q = Array(m), A = 0; A < m; A++)
+        q[A] = arguments[A + 2];
+      g.children = q;
+    }
+    if (t && t.defaultProps)
+      for (c in m = t.defaultProps, m)
+        g[c] === void 0 && (g[c] = m[c]);
+    return X(t, S, void 0, void 0, null, g);
+  }, l.createRef = function() {
+    return { current: null };
+  }, l.forwardRef = function(t) {
+    return { $$typeof: P, render: t };
+  }, l.isValidElement = F, l.lazy = function(t) {
+    return {
+      $$typeof: U,
+      _payload: { _status: -1, _result: t },
+      _init: oe
+    };
+  }, l.memo = function(t, o) {
+    return {
+      $$typeof: L,
+      type: t,
+      compare: o === void 0 ? null : o
+    };
+  }, l.startTransition = function(t) {
+    var o = R.T, f = {};
+    R.T = f;
+    try {
+      var c = t(), g = R.S;
+      g !== null && g(f, c), typeof c == "object" && c !== null && typeof c.then == "function" && c.then(ce, ee);
+    } catch (S) {
+      ee(S);
+    } finally {
+      R.T = o;
+    }
+  }, l.unstable_useCacheRefresh = function() {
+    return R.H.useCacheRefresh();
+  }, l.use = function(t) {
+    return R.H.use(t);
+  }, l.useActionState = function(t, o, f) {
+    return R.H.useActionState(t, o, f);
+  }, l.useCallback = function(t, o) {
+    return R.H.useCallback(t, o);
+  }, l.useContext = function(t) {
+    return R.H.useContext(t);
+  }, l.useDebugValue = function() {
+  }, l.useDeferredValue = function(t, o) {
+    return R.H.useDeferredValue(t, o);
+  }, l.useEffect = function(t, o, f) {
+    var c = R.H;
+    if (typeof f == "function")
+      throw Error(
+        "useEffect CRUD overload is not enabled in this build of React."
+      );
+    return c.useEffect(t, o);
+  }, l.useId = function() {
+    return R.H.useId();
+  }, l.useImperativeHandle = function(t, o, f) {
+    return R.H.useImperativeHandle(t, o, f);
+  }, l.useInsertionEffect = function(t, o) {
+    return R.H.useInsertionEffect(t, o);
+  }, l.useLayoutEffect = function(t, o) {
+    return R.H.useLayoutEffect(t, o);
+  }, l.useMemo = function(t, o) {
+    return R.H.useMemo(t, o);
+  }, l.useOptimistic = function(t, o) {
+    return R.H.useOptimistic(t, o);
+  }, l.useReducer = function(t, o, f) {
+    return R.H.useReducer(t, o, f);
+  }, l.useRef = function(t) {
+    return R.H.useRef(t);
+  }, l.useState = function(t) {
+    return R.H.useState(t);
+  }, l.useSyncExternalStore = function(t, o, f) {
+    return R.H.useSyncExternalStore(
+      t,
+      o,
+      f
+    );
+  }, l.useTransition = function() {
+    return R.H.useTransition();
+  }, l.version = "19.1.0", l;
+}
+var se = { exports: {} };
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+se.exports;
+var $e;
+function tt() {
+  return $e || ($e = 1, function(n, s) {
+    process.env.NODE_ENV !== "production" && function() {
+      function _(e, r) {
+        Object.defineProperty(N.prototype, e, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              r[0],
+              r[1]
+            );
+          }
+        });
+      }
+      function E(e) {
+        return e === null || typeof e != "object" ? null : (e = Ee && e[Ee] || e["@@iterator"], typeof e == "function" ? e : null);
+      }
+      function w(e, r) {
+        e = (e = e.constructor) && (e.displayName || e.name) || "ReactClass";
+        var u = e + "." + r;
+        we[u] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          r,
+          e
+        ), we[u] = !0);
+      }
+      function N(e, r, u) {
+        this.props = e, this.context = r, this.refs = he, this.updater = u || Re;
+      }
+      function M() {
+      }
+      function P(e, r, u) {
+        this.props = e, this.context = r, this.refs = he, this.updater = u || Re;
+      }
+      function j(e) {
+        return "" + e;
+      }
+      function L(e) {
+        try {
+          j(e);
+          var r = !1;
+        } catch {
+          r = !0;
+        }
+        if (r) {
+          r = console;
+          var u = r.error, i = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return u.call(
+            r,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            i
+          ), j(e);
+        }
+      }
+      function U(e) {
+        if (e == null) return null;
+        if (typeof e == "function")
+          return e.$$typeof === ze ? null : e.displayName || e.name || null;
+        if (typeof e == "string") return e;
+        switch (e) {
+          case t:
+            return "Fragment";
+          case f:
+            return "Profiler";
+          case o:
+            return "StrictMode";
+          case m:
+            return "Suspense";
+          case q:
+            return "SuspenseList";
+          case We:
+            return "Activity";
+        }
+        if (typeof e == "object")
+          switch (typeof e.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), e.$$typeof) {
+            case ce:
+              return "Portal";
+            case g:
+              return (e.displayName || "Context") + ".Provider";
+            case c:
+              return (e._context.displayName || "Context") + ".Consumer";
+            case S:
+              var r = e.render;
+              return e = e.displayName, e || (e = r.displayName || r.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+            case A:
+              return r = e.displayName || null, r !== null ? r : U(e.type) || "Memo";
+            case te:
+              r = e._payload, e = e._init;
+              try {
+                return U(e(r));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function G(e) {
+        if (e === t) return "<>";
+        if (typeof e == "object" && e !== null && e.$$typeof === te)
+          return "<...>";
+        try {
+          var r = U(e);
+          return r ? "<" + r + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function Z() {
+        var e = h.A;
+        return e === null ? null : e.getOwner();
+      }
+      function B() {
+        return Error("react-stack-top-frame");
+      }
+      function V(e) {
+        if (le.call(e, "key")) {
+          var r = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (r && r.isReactWarning) return !1;
+        }
+        return e.key !== void 0;
+      }
+      function Q(e, r) {
+        function u() {
+          Ce || (Ce = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            r
+          ));
+        }
+        u.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: u,
+          configurable: !0
+        });
+      }
+      function H() {
+        var e = U(this.type);
+        return Ae[e] || (Ae[e] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), e = this.props.ref, e !== void 0 ? e : null;
+      }
+      function W(e, r, u, i, a, v, d, b) {
+        return u = v.ref, e = {
+          $$typeof: ee,
+          type: e,
+          key: r,
+          props: v,
+          _owner: a
+        }, (u !== void 0 ? u : null) !== null ? Object.defineProperty(e, "ref", {
+          enumerable: !1,
+          get: H
+        }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(e, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(e, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: d
+        }), Object.defineProperty(e, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: b
+        }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+      }
+      function K(e, r) {
+        return r = W(
+          e.type,
+          r,
+          void 0,
+          void 0,
+          e._owner,
+          e.props,
+          e._debugStack,
+          e._debugTask
+        ), e._store && (r._store.validated = e._store.validated), r;
+      }
+      function I(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === ee;
+      }
+      function J(e) {
+        var r = { "=": "=0", ":": "=2" };
+        return "$" + e.replace(/[=:]/g, function(u) {
+          return r[u];
+        });
+      }
+      function R(e, r) {
+        return typeof e == "object" && e !== null && e.key != null ? (L(e.key), J("" + e.key)) : r.toString(36);
+      }
+      function z() {
+      }
+      function X(e) {
+        switch (e.status) {
+          case "fulfilled":
+            return e.value;
+          case "rejected":
+            throw e.reason;
+          default:
+            switch (typeof e.status == "string" ? e.then(z, z) : (e.status = "pending", e.then(
+              function(r) {
+                e.status === "pending" && (e.status = "fulfilled", e.value = r);
+              },
+              function(r) {
+                e.status === "pending" && (e.status = "rejected", e.reason = r);
+              }
+            )), e.status) {
+              case "fulfilled":
+                return e.value;
+              case "rejected":
+                throw e.reason;
+            }
+        }
+        throw e;
+      }
+      function Y(e, r, u, i, a) {
+        var v = typeof e;
+        (v === "undefined" || v === "boolean") && (e = null);
+        var d = !1;
+        if (e === null) d = !0;
+        else
+          switch (v) {
+            case "bigint":
+            case "string":
+            case "number":
+              d = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case ee:
+                case ce:
+                  d = !0;
+                  break;
+                case te:
+                  return d = e._init, Y(
+                    d(e._payload),
+                    r,
+                    u,
+                    i,
+                    a
+                  );
+              }
+          }
+        if (d) {
+          d = e, a = a(d);
+          var b = i === "" ? "." + R(d, 0) : i;
+          return be(a) ? (u = "", b != null && (u = b.replace(Pe, "$&/") + "/"), Y(a, r, u, "", function(x) {
+            return x;
+          })) : a != null && (I(a) && (a.key != null && (d && d.key === a.key || L(a.key)), u = K(
+            a,
+            u + (a.key == null || d && d.key === a.key ? "" : ("" + a.key).replace(
+              Pe,
+              "$&/"
+            ) + "/") + b
+          ), i !== "" && d != null && I(d) && d.key == null && d._store && !d._store.validated && (u._store.validated = 2), a = u), r.push(a)), 1;
+        }
+        if (d = 0, b = i === "" ? "." : i + ":", be(e))
+          for (var y = 0; y < e.length; y++)
+            i = e[y], v = b + R(i, y), d += Y(
+              i,
+              r,
+              u,
+              v,
+              a
+            );
+        else if (y = E(e), typeof y == "function")
+          for (y === e.entries && (ke || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), ke = !0), e = y.call(e), y = 0; !(i = e.next()).done; )
+            i = i.value, v = b + R(i, y++), d += Y(
+              i,
+              r,
+              u,
+              v,
+              a
+            );
+        else if (v === "object") {
+          if (typeof e.then == "function")
+            return Y(
+              X(e),
+              r,
+              u,
+              i,
+              a
+            );
+          throw r = String(e), Error(
+            "Objects are not valid as a React child (found: " + (r === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : r) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return d;
+      }
+      function F(e, r, u) {
+        if (e == null) return e;
+        var i = [], a = 0;
+        return Y(e, i, "", "", function(v) {
+          return r.call(u, v, a++);
+        }), i;
+      }
+      function ae(e) {
+        if (e._status === -1) {
+          var r = e._result;
+          r = r(), r.then(
+            function(u) {
+              (e._status === 0 || e._status === -1) && (e._status = 1, e._result = u);
+            },
+            function(u) {
+              (e._status === 0 || e._status === -1) && (e._status = 2, e._result = u);
+            }
+          ), e._status === -1 && (e._status = 0, e._result = r);
+        }
+        if (e._status === 1)
+          return r = e._result, r === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            r
+          ), "default" in r || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            r
+          ), r.default;
+        throw e._result;
+      }
+      function C() {
+        var e = h.H;
+        return e === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), e;
+      }
+      function p() {
+      }
+      function O(e) {
+        if (pe === null)
+          try {
+            var r = ("require" + Math.random()).slice(0, 7);
+            pe = (n && n[r]).call(
+              n,
+              "timers"
+            ).setImmediate;
+          } catch {
+            pe = function(i) {
+              Ne === !1 && (Ne = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var a = new MessageChannel();
+              a.port1.onmessage = i, a.port2.postMessage(void 0);
+            };
+          }
+        return pe(e);
+      }
+      function T(e) {
+        return 1 < e.length && typeof AggregateError == "function" ? new AggregateError(e) : e[0];
+      }
+      function k(e, r) {
+        r !== de - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), de = r;
+      }
+      function $(e, r, u) {
+        var i = h.actQueue;
+        if (i !== null)
+          if (i.length !== 0)
+            try {
+              oe(i), O(function() {
+                return $(e, r, u);
+              });
+              return;
+            } catch (a) {
+              h.thrownErrors.push(a);
+            }
+          else h.actQueue = null;
+        0 < h.thrownErrors.length ? (i = T(h.thrownErrors), h.thrownErrors.length = 0, u(i)) : r(e);
+      }
+      function oe(e) {
+        if (!ve) {
+          ve = !0;
+          var r = 0;
+          try {
+            for (; r < e.length; r++) {
+              var u = e[r];
+              do {
+                h.didUsePromise = !1;
+                var i = u(!1);
+                if (i !== null) {
+                  if (h.didUsePromise) {
+                    e[r] = u, e.splice(0, r);
+                    return;
+                  }
+                  u = i;
+                } else break;
+              } while (!0);
+            }
+            e.length = 0;
+          } catch (a) {
+            e.splice(0, r + 1), h.thrownErrors.push(a);
+          } finally {
+            ve = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var ee = Symbol.for("react.transitional.element"), ce = Symbol.for("react.portal"), t = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), c = Symbol.for("react.consumer"), g = Symbol.for("react.context"), S = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), q = Symbol.for("react.suspense_list"), A = Symbol.for("react.memo"), te = Symbol.for("react.lazy"), We = Symbol.for("react.activity"), Ee = Symbol.iterator, we = {}, Re = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(e) {
+          w(e, "forceUpdate");
+        },
+        enqueueReplaceState: function(e) {
+          w(e, "replaceState");
+        },
+        enqueueSetState: function(e) {
+          w(e, "setState");
+        }
+      }, Te = Object.assign, he = {};
+      Object.freeze(he), N.prototype.isReactComponent = {}, N.prototype.setState = function(e, r) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, e, r, "setState");
+      }, N.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      var D = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      }, fe;
+      for (fe in D)
+        D.hasOwnProperty(fe) && _(fe, D[fe]);
+      M.prototype = N.prototype, D = P.prototype = new M(), D.constructor = P, Te(D, N.prototype), D.isPureReactComponent = !0;
+      var be = Array.isArray, ze = Symbol.for("react.client.reference"), h = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        V: null,
+        actQueue: null,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, le = Object.prototype.hasOwnProperty, Oe = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      D = {
+        "react-stack-bottom-frame": function(e) {
+          return e();
+        }
+      };
+      var Ce, Se, Ae = {}, xe = D["react-stack-bottom-frame"].bind(D, B)(), Ge = Oe(G(B)), ke = !1, Pe = /\/+/g, je = typeof reportError == "function" ? reportError : function(e) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var r = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof e == "object" && e !== null && typeof e.message == "string" ? String(e.message) : String(e),
+            error: e
+          });
+          if (!window.dispatchEvent(r)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", e);
+          return;
+        }
+        console.error(e);
+      }, Ne = !1, pe = null, de = 0, me = !1, ve = !1, Le = typeof queueMicrotask == "function" ? function(e) {
+        queueMicrotask(function() {
+          return queueMicrotask(e);
+        });
+      } : O;
+      D = Object.freeze({
+        __proto__: null,
+        c: function(e) {
+          return C().useMemoCache(e);
+        }
+      }), s.Children = {
+        map: F,
+        forEach: function(e, r, u) {
+          F(
+            e,
+            function() {
+              r.apply(this, arguments);
+            },
+            u
+          );
+        },
+        count: function(e) {
+          var r = 0;
+          return F(e, function() {
+            r++;
+          }), r;
+        },
+        toArray: function(e) {
+          return F(e, function(r) {
+            return r;
+          }) || [];
+        },
+        only: function(e) {
+          if (!I(e))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return e;
+        }
+      }, s.Component = N, s.Fragment = t, s.Profiler = f, s.PureComponent = P, s.StrictMode = o, s.Suspense = m, s.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = h, s.__COMPILER_RUNTIME = D, s.act = function(e) {
+        var r = h.actQueue, u = de;
+        de++;
+        var i = h.actQueue = r !== null ? r : [], a = !1;
+        try {
+          var v = e();
+        } catch (y) {
+          h.thrownErrors.push(y);
+        }
+        if (0 < h.thrownErrors.length)
+          throw k(r, u), e = T(h.thrownErrors), h.thrownErrors.length = 0, e;
+        if (v !== null && typeof v == "object" && typeof v.then == "function") {
+          var d = v;
+          return Le(function() {
+            a || me || (me = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(y, x) {
+              a = !0, d.then(
+                function(re) {
+                  if (k(r, u), u === 0) {
+                    try {
+                      oe(i), O(function() {
+                        return $(
+                          re,
+                          y,
+                          x
+                        );
+                      });
+                    } catch (Ve) {
+                      h.thrownErrors.push(Ve);
+                    }
+                    if (0 < h.thrownErrors.length) {
+                      var Be = T(
+                        h.thrownErrors
+                      );
+                      h.thrownErrors.length = 0, x(Be);
+                    }
+                  } else y(re);
+                },
+                function(re) {
+                  k(r, u), 0 < h.thrownErrors.length && (re = T(
+                    h.thrownErrors
+                  ), h.thrownErrors.length = 0), x(re);
+                }
+              );
+            }
+          };
+        }
+        var b = v;
+        if (k(r, u), u === 0 && (oe(i), i.length !== 0 && Le(function() {
+          a || me || (me = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), h.actQueue = null), 0 < h.thrownErrors.length)
+          throw e = T(h.thrownErrors), h.thrownErrors.length = 0, e;
+        return {
+          then: function(y, x) {
+            a = !0, u === 0 ? (h.actQueue = i, O(function() {
+              return $(
+                b,
+                y,
+                x
+              );
+            })) : y(b);
+          }
+        };
+      }, s.cache = function(e) {
+        return function() {
+          return e.apply(null, arguments);
+        };
+      }, s.captureOwnerStack = function() {
+        var e = h.getCurrentStack;
+        return e === null ? null : e();
+      }, s.cloneElement = function(e, r, u) {
+        if (e == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + e + "."
+          );
+        var i = Te({}, e.props), a = e.key, v = e._owner;
+        if (r != null) {
+          var d;
+          e: {
+            if (le.call(r, "ref") && (d = Object.getOwnPropertyDescriptor(
+              r,
+              "ref"
+            ).get) && d.isReactWarning) {
+              d = !1;
+              break e;
+            }
+            d = r.ref !== void 0;
+          }
+          d && (v = Z()), V(r) && (L(r.key), a = "" + r.key);
+          for (b in r)
+            !le.call(r, b) || b === "key" || b === "__self" || b === "__source" || b === "ref" && r.ref === void 0 || (i[b] = r[b]);
+        }
+        var b = arguments.length - 2;
+        if (b === 1) i.children = u;
+        else if (1 < b) {
+          d = Array(b);
+          for (var y = 0; y < b; y++)
+            d[y] = arguments[y + 2];
+          i.children = d;
+        }
+        for (i = W(
+          e.type,
+          a,
+          void 0,
+          void 0,
+          v,
+          i,
+          e._debugStack,
+          e._debugTask
+        ), a = 2; a < arguments.length; a++)
+          v = arguments[a], I(v) && v._store && (v._store.validated = 1);
+        return i;
+      }, s.createContext = function(e) {
+        return e = {
+          $$typeof: g,
+          _currentValue: e,
+          _currentValue2: e,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, e.Provider = e, e.Consumer = {
+          $$typeof: c,
+          _context: e
+        }, e._currentRenderer = null, e._currentRenderer2 = null, e;
+      }, s.createElement = function(e, r, u) {
+        for (var i = 2; i < arguments.length; i++) {
+          var a = arguments[i];
+          I(a) && a._store && (a._store.validated = 1);
+        }
+        if (i = {}, a = null, r != null)
+          for (y in Se || !("__self" in r) || "key" in r || (Se = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), V(r) && (L(r.key), a = "" + r.key), r)
+            le.call(r, y) && y !== "key" && y !== "__self" && y !== "__source" && (i[y] = r[y]);
+        var v = arguments.length - 2;
+        if (v === 1) i.children = u;
+        else if (1 < v) {
+          for (var d = Array(v), b = 0; b < v; b++)
+            d[b] = arguments[b + 2];
+          Object.freeze && Object.freeze(d), i.children = d;
+        }
+        if (e && e.defaultProps)
+          for (y in v = e.defaultProps, v)
+            i[y] === void 0 && (i[y] = v[y]);
+        a && Q(
+          i,
+          typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+        );
+        var y = 1e4 > h.recentlyCreatedOwnerStacks++;
+        return W(
+          e,
+          a,
+          void 0,
+          void 0,
+          Z(),
+          i,
+          y ? Error("react-stack-top-frame") : xe,
+          y ? Oe(G(e)) : Ge
+        );
+      }, s.createRef = function() {
+        var e = { current: null };
+        return Object.seal(e), e;
+      }, s.forwardRef = function(e) {
+        e != null && e.$$typeof === A ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof e != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          e === null ? "null" : typeof e
+        ) : e.length !== 0 && e.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), e != null && e.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var r = { $$typeof: S, render: e }, u;
+        return Object.defineProperty(r, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return u;
+          },
+          set: function(i) {
+            u = i, e.name || e.displayName || (Object.defineProperty(e, "name", { value: i }), e.displayName = i);
+          }
+        }), r;
+      }, s.isValidElement = I, s.lazy = function(e) {
+        return {
+          $$typeof: te,
+          _payload: { _status: -1, _result: e },
+          _init: ae
+        };
+      }, s.memo = function(e, r) {
+        e == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          e === null ? "null" : typeof e
+        ), r = {
+          $$typeof: A,
+          type: e,
+          compare: r === void 0 ? null : r
+        };
+        var u;
+        return Object.defineProperty(r, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return u;
+          },
+          set: function(i) {
+            u = i, e.name || e.displayName || (Object.defineProperty(e, "name", { value: i }), e.displayName = i);
+          }
+        }), r;
+      }, s.startTransition = function(e) {
+        var r = h.T, u = {};
+        h.T = u, u._updatedFibers = /* @__PURE__ */ new Set();
+        try {
+          var i = e(), a = h.S;
+          a !== null && a(u, i), typeof i == "object" && i !== null && typeof i.then == "function" && i.then(p, je);
+        } catch (v) {
+          je(v);
+        } finally {
+          r === null && u._updatedFibers && (e = u._updatedFibers.size, u._updatedFibers.clear(), 10 < e && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), h.T = r;
+        }
+      }, s.unstable_useCacheRefresh = function() {
+        return C().useCacheRefresh();
+      }, s.use = function(e) {
+        return C().use(e);
+      }, s.useActionState = function(e, r, u) {
+        return C().useActionState(
+          e,
+          r,
+          u
+        );
+      }, s.useCallback = function(e, r) {
+        return C().useCallback(e, r);
+      }, s.useContext = function(e) {
+        var r = C();
+        return e.$$typeof === c && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), r.useContext(e);
+      }, s.useDebugValue = function(e, r) {
+        return C().useDebugValue(e, r);
+      }, s.useDeferredValue = function(e, r) {
+        return C().useDeferredValue(e, r);
+      }, s.useEffect = function(e, r, u) {
+        e == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        var i = C();
+        if (typeof u == "function")
+          throw Error(
+            "useEffect CRUD overload is not enabled in this build of React."
+          );
+        return i.useEffect(e, r);
+      }, s.useId = function() {
+        return C().useId();
+      }, s.useImperativeHandle = function(e, r, u) {
+        return C().useImperativeHandle(e, r, u);
+      }, s.useInsertionEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), C().useInsertionEffect(e, r);
+      }, s.useLayoutEffect = function(e, r) {
+        return e == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), C().useLayoutEffect(e, r);
+      }, s.useMemo = function(e, r) {
+        return C().useMemo(e, r);
+      }, s.useOptimistic = function(e, r) {
+        return C().useOptimistic(e, r);
+      }, s.useReducer = function(e, r, u) {
+        return C().useReducer(e, r, u);
+      }, s.useRef = function(e) {
+        return C().useRef(e);
+      }, s.useState = function(e) {
+        return C().useState(e);
+      }, s.useSyncExternalStore = function(e, r, u) {
+        return C().useSyncExternalStore(
+          e,
+          r,
+          u
+        );
+      }, s.useTransition = function() {
+        return C().useTransition();
+      }, s.version = "19.1.0", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+  }(se, se.exports)), se.exports;
+}
+var Ie;
+function rt() {
+  return Ie || (Ie = 1, process.env.NODE_ENV === "production" ? ye.exports = et() : ye.exports = tt()), ye.exports;
+}
+var nt = rt();
+const ot = /* @__PURE__ */ Je(nt);
+var ut = (n) => n instanceof Date, Ye = (n) => n == null;
+const st = (n) => typeof n == "object";
+var Ue = (n) => !Ye(n) && !Array.isArray(n) && st(n) && !ut(n), qe = (n) => Array.isArray(n) ? n.filter(Boolean) : [], De = (n) => n === void 0, ie = (n, s, _) => {
+  if (!s || !Ue(n))
+    return _;
+  const E = qe(s.split(/[,[\].]+?/)).reduce((w, N) => Ye(w) ? w : w[N], n);
+  return De(E) || E === n ? De(n[s]) ? _ : n[s] : E;
+}, it = (n) => /^\w*$/.test(n), at = (n) => qe(n.replace(/["|']|\]/g, "").split(/\.|\[/)), He = (n, s, _) => {
+  let E = -1;
+  const w = it(s) ? [s] : at(s), N = w.length, M = N - 1;
+  for (; ++E < N; ) {
+    const P = w[E];
+    let j = _;
+    if (E !== M) {
+      const L = n[P];
+      j = Ue(L) || Array.isArray(L) ? L : isNaN(+w[E + 1]) ? {} : [];
+    }
+    if (P === "__proto__" || P === "constructor" || P === "prototype")
+      return;
+    n[P] = j, n = n[P];
+  }
+};
+ot.createContext(null);
+const ue = (n) => n instanceof RegExp || typeof n == "string" || typeof n == "number" ? n : n.value, ne = (n) => typeof n == "string" ? n : typeof n.message == "string" ? n.message : "", ct = (n, s, _ = {}) => {
+  const E = ie(n, s);
+  if (_.required && !E)
+    return { type: "required", message: ne(_.required) };
+  if (_.min && Number(E) < Number(ue(_.min)))
+    return { type: "min", message: ne(_.min) };
+  if (_.max && Number(E) > Number(ue(_.max)))
+    return { type: "max", message: ne(_.max) };
+  if (_.minLength && E.length < ue(_.minLength))
+    return { type: "minLength", message: ne(_.minLength) };
+  if (_.maxLength && E.length > ue(_.maxLength))
+    return { type: "maxLength", message: ne(_.maxLength) };
+  if (_.pattern && !ue(_.pattern).test(E))
+    return { type: "pattern", message: ne(_.pattern) };
+  if (_.validate) {
+    const w = _.validate(E, n);
+    if (w === !1)
       return { type: "validate" };
-    if (typeof c == "string")
-      return { type: "validate", message: c };
+    if (typeof w == "string")
+      return { type: "validate", message: w };
   }
-}, j = () => {
-  const [e, n] = d({});
+}, ft = () => {
+  const [n, s] = _e({});
   return {
-    errors: e,
-    appendError: (a, f) => {
-      n((m) => ({ ...m, [a]: f }));
+    errors: n,
+    appendError: (M, P) => {
+      s((j) => ({ ...j, [M]: P }));
     },
-    removeError: (a) => {
-      n((f) => {
-        const m = { ...f };
-        return delete m[a], m;
+    removeError: (M) => {
+      s((P) => {
+        const j = { ...P };
+        return delete j[M], j;
       });
     },
     resetErrors: () => {
-      n({});
+      s({});
+    },
+    getError: (M) => ie(n(), M)
+  };
+}, lt = () => {
+  const n = {};
+  return { rules: n, addRule: (E, w) => {
+    n[E] = {
+      required: w.required,
+      min: w.min,
+      max: w.max,
+      minLength: w.minLength,
+      maxLength: w.maxLength,
+      pattern: w.pattern,
+      validate: w.validate
+    };
+  }, getRule: (E) => n[E] };
+}, pt = () => {
+  const n = {};
+  return {
+    fields: n,
+    getField: (E) => n[E],
+    setField: (E, w) => {
+      n[E] = w;
     }
   };
-}, A = ({
-  defaultValues: e,
-  mode: n = "onInput"
+}, mt = ({
+  defaultValues: n,
+  mode: s = "onInput"
 }) => {
-  const r = {}, i = {}, [c, a] = d(e), { errors: f, appendError: m, removeError: F, resetErrors: b } = j(), [l, h] = d(!0), C = (t, o) => {
-    const s = r[t];
-    s && (o.ref = s), m(t, o);
-  }, I = (t) => {
-    F(t);
-  }, E = (t) => {
-    const o = i[t], s = N(c(), t, o);
-    s ? C(t, s) : I(t), h(!Object.keys(f()).length);
-  }, k = () => {
-    Object.keys(c()).forEach((t) => {
-      E(t);
+  const { fields: _, getField: E, setField: w } = pt(), { rules: N, addRule: M, getRule: P } = lt(), [j, L] = _e(n), { errors: U, appendError: G, removeError: Z, resetErrors: B, getError: V } = ft(), [Q, H] = _e(!0), W = (p, O) => {
+    const T = E(p);
+    T && (O.ref = T), G(p, O);
+  }, K = (p) => {
+    Z(p);
+  }, I = (p) => {
+    const O = P(p), T = ct(j(), p, O);
+    T ? W(p, T) : K(p), H(!Object.keys(U()).length);
+  }, J = () => {
+    Object.keys(N).forEach((p) => {
+      I(p);
     });
-  }, V = () => {
-    var o;
-    const t = Object.keys(r);
-    for (const s of t) {
-      const u = f()[s];
-      if (u) {
-        (o = u.ref) == null || o.focus();
+  }, R = () => {
+    var O;
+    const p = Object.keys(_);
+    for (const T of p) {
+      const k = V(T);
+      if (k) {
+        (O = k.ref) == null || O.focus();
         break;
       }
     }
-  }, v = (t, o) => {
-    const s = S(t);
-    a((u) => ({ ...u, [o]: s })), E(o);
-  }, M = (t, o = {}) => (i[t] = {
-    required: o.required,
-    min: o.min,
-    max: o.max,
-    minLength: o.minLength,
-    maxLength: o.maxLength,
-    pattern: o.pattern,
-    validate: o.validate
-  }, {
-    name: t,
-    // value: values()[name],
-    onInput(s) {
-      n === "onInput" && v(s, t);
+  }, z = (p, O) => {
+    const T = Ze(p);
+    L((k) => {
+      const $ = { ...k };
+      return He($, O, T), $;
+    }), I(O);
+  }, X = (p, O = {}) => (M(p, O), {
+    name: p,
+    // value: get(values(), name),
+    onInput(T) {
+      s === "onInput" && z(T, p);
     },
-    onChange(s) {
-      (n === "onChange" || n === "onInput") && v(s, t);
+    onChange(T) {
+      (s === "onChange" || s === "onInput") && z(T, p);
     },
-    ref(s) {
-      r[t] || (r[t] = s, s && y(s, c()[t]));
+    ref(T) {
+      E(p) || (w(p, T), T && ge(T, ie(j(), p)));
     }
-  }), x = (t) => t ? c()[t] : c();
+  }), Y = (p) => p ? ie(j(), p) : j();
   return {
-    values: c,
-    errors: f,
-    isValid: l,
-    register: M,
-    getValues: x,
-    setValue: (t, o) => {
-      a((u) => ({ ...u, [t]: o }));
-      const s = r[t];
-      s && y(s, o);
+    values: j,
+    errors: U,
+    isValid: Q,
+    register: X,
+    getValues: Y,
+    setValue: (p, O) => {
+      L((k) => {
+        const $ = { ...k };
+        return He($, p, O), $;
+      });
+      const T = E(p);
+      T && ge(T, O);
     },
-    onSubmit: (t) => (o) => {
-      o.preventDefault(), k(), l() && t(x()), V();
+    onSubmit: (p) => (O) => {
+      O.preventDefault(), J(), Q() && p(Y()), R();
     },
-    reset: (t = {}) => {
-      a(() => ({
-        ...e,
-        ...t
-      })), b(), h(!0);
+    reset: (p = {}) => {
+      const O = {
+        ...structuredClone(n),
+        ...p
+      };
+      L(() => O), B(), H(!0), Object.entries(_).forEach(([T, k]) => {
+        k && ge(k, ie(O, T));
+      });
     }
   };
-}, L = H(), D = (e) => T(L.Provider, {
+}, Fe = Qe(), yt = (n) => Ke(Fe.Provider, {
   get value() {
-    return e.form;
+    return n.form;
   },
   get children() {
-    return e.children;
+    return n.children;
   }
-}), z = () => {
-  const e = q(L);
-  if (!e)
+}), ht = () => {
+  const n = Xe(Fe);
+  if (!n)
     throw new Error("useFormContext: cannot find a FormProvider");
-  return e;
+  return n;
 };
 export {
-  D as FormProvider,
-  A as useForm,
-  z as useFormContext
+  yt as FormProvider,
+  mt as useForm,
+  ht as useFormContext
 };