@scbt-ecom/ui 0.23.0 → 0.24.0

package/dist/useDebounce-DSBzpBLy.js

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