ics-ui-kit 0.1.19 → 1.0.0-alpha.1

package/dist/FormStack-DfoaOry7.js

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