@oneclick.dev/cms-core-modules 0.0.123 → 0.0.125

package/dist/vee-validate-zod-D0WaDgDZ.mjs

@@ -0,0 +1,1780 @@
+import { ref as Q, reactive as De, computed as A, toValue as m, unref as C, onMounted as Ct, isRef as Re, watch as oe, provide as et, readonly as un, inject as wt, watchEffect as sn, nextTick as X, shallowRef as cn, warn as dn, getCurrentInstance as Ve, onUnmounted as It, onBeforeUnmount as fn } from "vue";
+import { Z as ft, g as vn, h as Pt } from "./types-B5MifmeF.mjs";
+function W(e) {
+  return typeof e == "function";
+}
+function Ft(e) {
+  return e == null;
+}
+const ce = (e) => e !== null && !!e && typeof e == "object" && !Array.isArray(e);
+function it(e) {
+  return Number(e) >= 0;
+}
+function hn(e) {
+  const t = parseFloat(e);
+  return isNaN(t) ? e : t;
+}
+function mn(e) {
+  return typeof e == "object" && e !== null;
+}
+function pn(e) {
+  return e == null ? e === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(e);
+}
+function vt(e) {
+  if (!mn(e) || pn(e) !== "[object Object]")
+    return !1;
+  if (Object.getPrototypeOf(e) === null)
+    return !0;
+  let t = e;
+  for (; Object.getPrototypeOf(t) !== null; )
+    t = Object.getPrototypeOf(t);
+  return Object.getPrototypeOf(e) === t;
+}
+function Pe(e, t) {
+  return Object.keys(t).forEach((n) => {
+    if (vt(t[n]) && vt(e[n])) {
+      e[n] || (e[n] = {}), Pe(e[n], t[n]);
+      return;
+    }
+    e[n] = t[n];
+  }), e;
+}
+function Ee(e) {
+  const t = e.split(".");
+  if (!t.length)
+    return "";
+  let n = String(t[0]);
+  for (let r = 1; r < t.length; r++) {
+    if (it(t[r])) {
+      n += `[${t[r]}]`;
+      continue;
+    }
+    n += `.${t[r]}`;
+  }
+  return n;
+}
+const yn = {};
+function gn(e) {
+  return yn[e];
+}
+function ht(e, t, n) {
+  typeof n.value == "object" && (n.value = j(n.value)), !n.enumerable || n.get || n.set || !n.configurable || !n.writable || t === "__proto__" ? Object.defineProperty(e, t, n) : e[t] = n.value;
+}
+function j(e) {
+  if (typeof e != "object") return e;
+  var t = 0, n, r, o, a = Object.prototype.toString.call(e);
+  if (a === "[object Object]" ? o = Object.create(e.__proto__ || null) : a === "[object Array]" ? o = Array(e.length) : a === "[object Set]" ? (o = /* @__PURE__ */ new Set(), e.forEach(function(s) {
+    o.add(j(s));
+  })) : a === "[object Map]" ? (o = /* @__PURE__ */ new Map(), e.forEach(function(s, d) {
+    o.set(j(d), j(s));
+  })) : a === "[object Date]" ? o = /* @__PURE__ */ new Date(+e) : a === "[object RegExp]" ? o = new RegExp(e.source, e.flags) : a === "[object DataView]" ? o = new e.constructor(j(e.buffer)) : a === "[object ArrayBuffer]" ? o = e.slice(0) : a.slice(-6) === "Array]" && (o = new e.constructor(e)), o) {
+    for (r = Object.getOwnPropertySymbols(e); t < r.length; t++)
+      ht(o, r[t], Object.getOwnPropertyDescriptor(e, r[t]));
+    for (t = 0, r = Object.getOwnPropertyNames(e); t < r.length; t++)
+      Object.hasOwnProperty.call(o, n = r[t]) && o[n] === e[n] || ht(o, n, Object.getOwnPropertyDescriptor(e, n));
+  }
+  return o || e;
+}
+const lt = /* @__PURE__ */ Symbol("vee-validate-form"), Nt = /* @__PURE__ */ Symbol("vee-validate-form-context"), bn = /* @__PURE__ */ Symbol("vee-validate-field-instance"), mt = /* @__PURE__ */ Symbol("Default empty value"), Tt = typeof window < "u";
+function tt(e) {
+  return W(e) && !!e.__locatorRef;
+}
+function ee(e) {
+  return !!e && W(e.parse) && e.__type === "VVTypedSchema";
+}
+function Me(e) {
+  return !!e && W(e.validate);
+}
+function kt(e) {
+  return e === "checkbox" || e === "radio";
+}
+function On(e) {
+  return ce(e) || Array.isArray(e);
+}
+function Vn(e) {
+  return Array.isArray(e) ? e.length === 0 : ce(e) && Object.keys(e).length === 0;
+}
+function Fe(e) {
+  return /^\[.+\]$/i.test(e);
+}
+function _n(e) {
+  return xt(e) && e.multiple;
+}
+function xt(e) {
+  return e.tagName === "SELECT";
+}
+function Sn(e) {
+  return Dt(e) && e.target && "submit" in e.target;
+}
+function Dt(e) {
+  return e ? !!(typeof Event < "u" && W(Event) && e instanceof Event || e && e.srcElement) : !1;
+}
+function B(e, t) {
+  if (e === t)
+    return !0;
+  if (e && t && typeof e == "object" && typeof t == "object") {
+    if (e.constructor !== t.constructor)
+      return !1;
+    var n, r, o;
+    if (Array.isArray(e)) {
+      if (n = e.length, n != t.length)
+        return !1;
+      for (r = n; r-- !== 0; )
+        if (!B(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (e instanceof Map && t instanceof Map) {
+      if (e.size !== t.size)
+        return !1;
+      for (r of e.entries())
+        if (!t.has(r[0]))
+          return !1;
+      for (r of e.entries())
+        if (!B(r[1], t.get(r[0])))
+          return !1;
+      return !0;
+    }
+    if (yt(e) && yt(t))
+      return !(e.size !== t.size || e.name !== t.name || e.lastModified !== t.lastModified || e.type !== t.type);
+    if (e instanceof Set && t instanceof Set) {
+      if (e.size !== t.size)
+        return !1;
+      for (r of e.entries())
+        if (!t.has(r[0]))
+          return !1;
+      return !0;
+    }
+    if (ArrayBuffer.isView(e) && ArrayBuffer.isView(t)) {
+      if (n = e.length, n != t.length)
+        return !1;
+      for (r = n; r-- !== 0; )
+        if (e[r] !== t[r])
+          return !1;
+      return !0;
+    }
+    if (e.constructor === RegExp)
+      return e.source === t.source && e.flags === t.flags;
+    if (e.valueOf !== Object.prototype.valueOf)
+      return e.valueOf() === t.valueOf();
+    if (e.toString !== Object.prototype.toString)
+      return e.toString() === t.toString();
+    if (e = pt(e), t = pt(t), o = Object.keys(e), n = o.length, n !== Object.keys(t).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(t, o[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      var a = o[r];
+      if (!B(e[a], t[a]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function pt(e) {
+  return Object.fromEntries(Object.entries(e).filter(([, t]) => t !== void 0));
+}
+function yt(e) {
+  return Tt ? e instanceof File : !1;
+}
+function Be(e) {
+  return Fe(e) ? e.replace(/\[|\]/gi, "") : e;
+}
+function q(e, t, n) {
+  return e ? Fe(t) ? e[Be(t)] : (t || "").split(/\.|\[(\d+)\]/).filter(Boolean).reduce((o, a) => On(o) && a in o ? o[a] : n, e) : n;
+}
+function ne(e, t, n) {
+  if (Fe(t)) {
+    e[Be(t)] = n;
+    return;
+  }
+  const r = t.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let o = e;
+  for (let a = 0; a < r.length; a++) {
+    if (a === r.length - 1) {
+      o[r[a]] = n;
+      return;
+    }
+    (!(r[a] in o) || Ft(o[r[a]])) && (o[r[a]] = it(r[a + 1]) ? [] : {}), o = o[r[a]];
+  }
+}
+function Xe(e, t) {
+  if (Array.isArray(e) && it(t)) {
+    e.splice(Number(t), 1);
+    return;
+  }
+  ce(e) && delete e[t];
+}
+function gt(e, t) {
+  if (Fe(t)) {
+    delete e[Be(t)];
+    return;
+  }
+  const n = t.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let r = e;
+  for (let a = 0; a < n.length; a++) {
+    if (a === n.length - 1) {
+      Xe(r, n[a]);
+      break;
+    }
+    if (!(n[a] in r) || Ft(r[n[a]]))
+      break;
+    r = r[n[a]];
+  }
+  const o = n.map((a, s) => q(e, n.slice(0, s).join(".")));
+  for (let a = o.length - 1; a >= 0; a--)
+    if (Vn(o[a])) {
+      if (a === 0) {
+        Xe(e, n[0]);
+        continue;
+      }
+      Xe(o[a - 1], n[a - 1]);
+    }
+}
+function L(e) {
+  return Object.keys(e);
+}
+function Rt(e, t = void 0) {
+  const n = Ve();
+  return n?.provides[e] || wt(e, t);
+}
+function jn(e, t, n) {
+  if (Array.isArray(e)) {
+    const r = [...e], o = r.findIndex((a) => B(a, t));
+    return o >= 0 ? r.splice(o, 1) : r.push(t), r;
+  }
+  return B(e, t) ? n : t;
+}
+function En(e, t) {
+  let n, r;
+  return function(...o) {
+    const a = this;
+    return n || (n = !0, setTimeout(() => n = !1, t), r = e.apply(a, o)), r;
+  };
+}
+function bt(e, t = 0) {
+  let n = null, r = [];
+  return function(...o) {
+    return n && clearTimeout(n), n = setTimeout(() => {
+      const a = e(...o);
+      r.forEach((s) => s(a)), r = [];
+    }, t), new Promise((a) => r.push(a));
+  };
+}
+function An(e, t) {
+  return ce(t) && t.number ? hn(e) : e;
+}
+function nt(e, t) {
+  let n;
+  return async function(...o) {
+    const a = e(...o);
+    n = a;
+    const s = await a;
+    return a !== n ? s : (n = void 0, t(s, o));
+  };
+}
+function rt(e) {
+  return Array.isArray(e) ? e : e ? [e] : [];
+}
+function ke(e, t) {
+  const n = {};
+  for (const r in e)
+    t.includes(r) || (n[r] = e[r]);
+  return n;
+}
+function Cn(e) {
+  let t = null, n = [];
+  return function(...r) {
+    const o = X(() => {
+      if (t !== o)
+        return;
+      const a = e(...r);
+      n.forEach((s) => s(a)), n = [], t = null;
+    });
+    return t = o, new Promise((a) => n.push(a));
+  };
+}
+function Qe(e) {
+  if (Mt(e))
+    return e._value;
+}
+function Mt(e) {
+  return "_value" in e;
+}
+function wn(e) {
+  return e.type === "number" || e.type === "range" ? Number.isNaN(e.valueAsNumber) ? e.value : e.valueAsNumber : e.value;
+}
+function Ue(e) {
+  if (!Dt(e))
+    return e;
+  const t = e.target;
+  if (kt(t.type) && Mt(t))
+    return Qe(t);
+  if (t.type === "file" && t.files) {
+    const n = Array.from(t.files);
+    return t.multiple ? n : n[0];
+  }
+  if (_n(t))
+    return Array.from(t.options).filter((n) => n.selected && !n.disabled).map(Qe);
+  if (xt(t)) {
+    const n = Array.from(t.options).find((r) => r.selected);
+    return n ? Qe(n) : t.value;
+  }
+  return wn(t);
+}
+function Ut(e) {
+  const t = {};
+  return Object.defineProperty(t, "_$$isNormalized", {
+    value: !0,
+    writable: !1,
+    enumerable: !1,
+    configurable: !1
+  }), e ? ce(e) && e._$$isNormalized ? e : ce(e) ? Object.keys(e).reduce((n, r) => {
+    const o = In(e[r]);
+    return e[r] !== !1 && (n[r] = Ot(o)), n;
+  }, t) : typeof e != "string" ? t : e.split("|").reduce((n, r) => {
+    const o = Pn(r);
+    return o.name && (n[o.name] = Ot(o.params)), n;
+  }, t) : t;
+}
+function In(e) {
+  return e === !0 ? [] : Array.isArray(e) || ce(e) ? e : [e];
+}
+function Ot(e) {
+  const t = (n) => typeof n == "string" && n[0] === "@" ? Fn(n.slice(1)) : n;
+  return Array.isArray(e) ? e.map(t) : e instanceof RegExp ? [e] : Object.keys(e).reduce((n, r) => (n[r] = t(e[r]), n), {});
+}
+const Pn = (e) => {
+  let t = [];
+  const n = e.split(":")[0];
+  return e.includes(":") && (t = e.split(":").slice(1).join(":").split(",")), { name: n, params: t };
+};
+function Fn(e) {
+  const t = (n) => {
+    var r;
+    return (r = q(n, e)) !== null && r !== void 0 ? r : n[e];
+  };
+  return t.__locatorRef = e, t;
+}
+function Nn(e) {
+  return Array.isArray(e) ? e.filter(tt) : L(e).filter((t) => tt(e[t])).map((t) => e[t]);
+}
+const Tn = {
+  generateMessage: ({ field: e }) => `${e} is not valid.`,
+  bails: !0,
+  validateOnBlur: !0,
+  validateOnChange: !0,
+  validateOnInput: !1,
+  validateOnModelUpdate: !0
+};
+let kn = Object.assign({}, Tn);
+const Ae = () => kn;
+async function Bt(e, t, n = {}) {
+  const r = n?.bails, o = {
+    name: n?.name || "{field}",
+    rules: t,
+    label: n?.label,
+    bails: r ?? !0,
+    formData: n?.values || {}
+  }, a = await xn(o, e);
+  return Object.assign(Object.assign({}, a), { valid: !a.errors.length });
+}
+async function xn(e, t) {
+  const n = e.rules;
+  if (ee(n) || Me(n))
+    return Rn(t, Object.assign(Object.assign({}, e), { rules: n }));
+  if (W(n) || Array.isArray(n)) {
+    const d = {
+      field: e.label || e.name,
+      name: e.name,
+      label: e.label,
+      form: e.formData,
+      value: t
+    }, v = Array.isArray(n) ? n : [n], c = v.length, p = [];
+    for (let _ = 0; _ < c; _++) {
+      const w = v[_], V = await w(t, d);
+      if (!(typeof V != "string" && !Array.isArray(V) && V)) {
+        if (Array.isArray(V))
+          p.push(...V);
+        else {
+          const K = typeof V == "string" ? V : Lt(d);
+          p.push(K);
+        }
+        if (e.bails)
+          return {
+            errors: p
+          };
+      }
+    }
+    return {
+      errors: p
+    };
+  }
+  const r = Object.assign(Object.assign({}, e), { rules: Ut(n) }), o = [], a = Object.keys(r.rules), s = a.length;
+  for (let d = 0; d < s; d++) {
+    const v = a[d], c = await Mn(r, t, {
+      name: v,
+      params: r.rules[v]
+    });
+    if (c.error && (o.push(c.error), e.bails))
+      return {
+        errors: o
+      };
+  }
+  return {
+    errors: o
+  };
+}
+function Dn(e) {
+  return !!e && e.name === "ValidationError";
+}
+function $t(e) {
+  return {
+    __type: "VVTypedSchema",
+    async parse(n, r) {
+      var o;
+      try {
+        return {
+          output: await e.validate(n, { abortEarly: !1, context: r?.formData || {} }),
+          errors: []
+        };
+      } catch (a) {
+        if (!Dn(a))
+          throw a;
+        if (!(!((o = a.inner) === null || o === void 0) && o.length) && a.errors.length)
+          return { errors: [{ path: a.path, errors: a.errors }] };
+        const s = a.inner.reduce((d, v) => {
+          const c = v.path || "";
+          return d[c] || (d[c] = { errors: [], path: c }), d[c].errors.push(...v.errors), d;
+        }, {});
+        return { errors: Object.values(s) };
+      }
+    }
+  };
+}
+async function Rn(e, t) {
+  const r = await (ee(t.rules) ? t.rules : $t(t.rules)).parse(e, { formData: t.formData }), o = [];
+  for (const a of r.errors)
+    a.errors.length && o.push(...a.errors);
+  return {
+    value: r.value,
+    errors: o
+  };
+}
+async function Mn(e, t, n) {
+  const r = gn(n.name);
+  if (!r)
+    throw new Error(`No such validator '${n.name}' exists.`);
+  const o = Un(n.params, e.formData), a = {
+    field: e.label || e.name,
+    name: e.name,
+    label: e.label,
+    value: t,
+    form: e.formData,
+    rule: Object.assign(Object.assign({}, n), { params: o })
+  }, s = await r(t, o, a);
+  return typeof s == "string" ? {
+    error: s
+  } : {
+    error: s ? void 0 : Lt(a)
+  };
+}
+function Lt(e) {
+  const t = Ae().generateMessage;
+  return t ? t(e) : "Field is invalid";
+}
+function Un(e, t) {
+  const n = (r) => tt(r) ? r(t) : r;
+  return Array.isArray(e) ? e.map(n) : Object.keys(e).reduce((r, o) => (r[o] = n(e[o]), r), {});
+}
+async function Bn(e, t) {
+  const r = await (ee(e) ? e : $t(e)).parse(j(t), { formData: j(t) }), o = {}, a = {};
+  for (const s of r.errors) {
+    const d = s.errors, v = (s.path || "").replace(/\["(\d+)"\]/g, (c, p) => `[${p}]`);
+    o[v] = { valid: !d.length, errors: d }, d.length && (a[v] = d[0]);
+  }
+  return {
+    valid: !r.errors.length,
+    results: o,
+    errors: a,
+    values: r.value,
+    source: "schema"
+  };
+}
+async function $n(e, t, n) {
+  const o = L(e).map(async (c) => {
+    var p, _, w;
+    const V = (p = n?.names) === null || p === void 0 ? void 0 : p[c], N = await Bt(q(t, c), e[c], {
+      name: V?.name || c,
+      label: V?.label,
+      values: t,
+      bails: (w = (_ = n?.bailsMap) === null || _ === void 0 ? void 0 : _[c]) !== null && w !== void 0 ? w : !0
+    });
+    return Object.assign(Object.assign({}, N), { path: c });
+  });
+  let a = !0;
+  const s = await Promise.all(o), d = {}, v = {};
+  for (const c of s)
+    d[c.path] = {
+      valid: c.valid,
+      errors: c.errors
+    }, c.valid || (a = !1, v[c.path] = c.errors[0]);
+  return {
+    valid: a,
+    results: d,
+    errors: v,
+    source: "schema"
+  };
+}
+let Vt = 0;
+function Ln(e, t) {
+  const { value: n, initialValue: r, setInitialValue: o } = zn(e, t.modelValue, t.form);
+  if (!t.form) {
+    let w = function(V) {
+      var N;
+      "value" in V && (n.value = V.value), "errors" in V && c(V.errors), "touched" in V && (_.touched = (N = V.touched) !== null && N !== void 0 ? N : _.touched), "initialValue" in V && o(V.initialValue);
+    };
+    const { errors: v, setErrors: c } = Kn(), p = Vt >= Number.MAX_SAFE_INTEGER ? 0 : ++Vt, _ = qn(n, r, v, t.schema);
+    return {
+      id: p,
+      path: e,
+      value: n,
+      initialValue: r,
+      meta: _,
+      flags: { pendingUnmount: { [p]: !1 }, pendingReset: !1 },
+      errors: v,
+      setState: w
+    };
+  }
+  const a = t.form.createPathState(e, {
+    bails: t.bails,
+    label: t.label,
+    type: t.type,
+    validate: t.validate,
+    schema: t.schema
+  }), s = A(() => a.errors);
+  function d(v) {
+    var c, p, _;
+    "value" in v && (n.value = v.value), "errors" in v && ((c = t.form) === null || c === void 0 || c.setFieldError(C(e), v.errors)), "touched" in v && ((p = t.form) === null || p === void 0 || p.setFieldTouched(C(e), (_ = v.touched) !== null && _ !== void 0 ? _ : !1)), "initialValue" in v && o(v.initialValue);
+  }
+  return {
+    id: Array.isArray(a.id) ? a.id[a.id.length - 1] : a.id,
+    path: e,
+    value: n,
+    errors: s,
+    meta: a,
+    initialValue: r,
+    flags: a.__flags,
+    setState: d
+  };
+}
+function zn(e, t, n) {
+  const r = Q(C(t));
+  function o() {
+    return n ? q(n.initialValues.value, C(e), C(r)) : C(r);
+  }
+  function a(c) {
+    if (!n) {
+      r.value = c;
+      return;
+    }
+    n.setFieldInitialValue(C(e), c, !0);
+  }
+  const s = A(o);
+  if (!n)
+    return {
+      value: Q(o()),
+      initialValue: s,
+      setInitialValue: a
+    };
+  const d = Wn(t, n, s, e);
+  return n.stageInitialValue(C(e), d, !0), {
+    value: A({
+      get() {
+        return q(n.values, C(e));
+      },
+      set(c) {
+        n.setFieldValue(C(e), c, !1);
+      }
+    }),
+    initialValue: s,
+    setInitialValue: a
+  };
+}
+function Wn(e, t, n, r) {
+  return Re(e) ? C(e) : e !== void 0 ? e : q(t.values, C(r), C(n));
+}
+function qn(e, t, n, r) {
+  const o = A(() => {
+    var s, d, v;
+    return (v = (d = (s = m(r)) === null || s === void 0 ? void 0 : s.describe) === null || d === void 0 ? void 0 : d.call(s).required) !== null && v !== void 0 ? v : !1;
+  }), a = De({
+    touched: !1,
+    pending: !1,
+    valid: !0,
+    required: o,
+    validated: !!C(n).length,
+    initialValue: A(() => C(t)),
+    dirty: A(() => !B(C(e), C(t)))
+  });
+  return oe(n, (s) => {
+    a.valid = !s.length;
+  }, {
+    immediate: !0,
+    flush: "sync"
+  }), a;
+}
+function Kn() {
+  const e = Q([]);
+  return {
+    errors: e,
+    setErrors: (t) => {
+      e.value = rt(t);
+    }
+  };
+}
+const Ce = {}, we = {}, Ie = "vee-validate-inspector", z = {
+  error: 12405579,
+  success: 448379,
+  unknown: 5522283,
+  white: 16777215,
+  black: 0,
+  blue: 218007,
+  purple: 12157168,
+  orange: 16099682,
+  gray: 12304330
+};
+let k = null, le;
+async function zt(e) {
+  if (process.env.NODE_ENV !== "production") {
+    if (!Tt)
+      return;
+    (await import("./index-DE8rdSjd.mjs")).setupDevtoolsPlugin({
+      id: "vee-validate-devtools-plugin",
+      label: "VeeValidate Plugin",
+      packageName: "vee-validate",
+      homepage: "https://vee-validate.logaretm.com/v4",
+      app: e,
+      logo: "https://vee-validate.logaretm.com/v4/logo.png"
+    }, (n) => {
+      le = n, n.addInspector({
+        id: Ie,
+        icon: "rule",
+        label: "vee-validate",
+        noSelectionText: "Select a vee-validate node to inspect",
+        actions: [
+          {
+            icon: "done_outline",
+            tooltip: "Validate selected item",
+            action: async () => {
+              if (!k) {
+                console.error("There is not a valid selected vee-validate node or component");
+                return;
+              }
+              if (k.type === "field") {
+                await k.field.validate();
+                return;
+              }
+              if (k.type === "form") {
+                await k.form.validate();
+                return;
+              }
+              k.type === "pathState" && await k.form.validateField(k.state.path);
+            }
+          },
+          {
+            icon: "delete_sweep",
+            tooltip: "Clear validation state of the selected item",
+            action: () => {
+              if (!k) {
+                console.error("There is not a valid selected vee-validate node or component");
+                return;
+              }
+              if (k.type === "field") {
+                k.field.resetField();
+                return;
+              }
+              k.type === "form" && k.form.resetForm(), k.type === "pathState" && k.form.resetField(k.state.path);
+            }
+          }
+        ]
+      }), n.on.getInspectorTree((r) => {
+        if (r.inspectorId !== Ie)
+          return;
+        const o = Object.values(Ce), a = Object.values(we);
+        r.rootNodes = [
+          ...o.map(Hn),
+          ...a.map((s) => Jn(s))
+        ];
+      }), n.on.getInspectorState((r) => {
+        if (r.inspectorId !== Ie)
+          return;
+        const { form: o, field: a, state: s, type: d } = Xn(r.nodeId);
+        if (n.unhighlightElement(), o && d === "form") {
+          r.state = Qn(o), k = { type: "form", form: o }, n.highlightElement(o._vm);
+          return;
+        }
+        if (s && d === "pathState" && o) {
+          r.state = _t(s), k = { type: "pathState", state: s, form: o };
+          return;
+        }
+        if (a && d === "field") {
+          r.state = _t({
+            errors: a.errors.value,
+            dirty: a.meta.dirty,
+            valid: a.meta.valid,
+            touched: a.meta.touched,
+            value: a.value.value,
+            initialValue: a.meta.initialValue
+          }), k = { field: a, type: "field" }, n.highlightElement(a._vm);
+          return;
+        }
+        k = null, n.unhighlightElement();
+      });
+    });
+  }
+}
+const _e = En(() => {
+  setTimeout(async () => {
+    await X(), le?.sendInspectorState(Ie), le?.sendInspectorTree(Ie);
+  }, 100);
+}, 100);
+function Zn(e) {
+  const t = Ve();
+  if (!le) {
+    const n = t?.appContext.app;
+    if (!n)
+      return;
+    zt(n);
+  }
+  Ce[e.formId] = Object.assign({}, e), Ce[e.formId]._vm = t, It(() => {
+    delete Ce[e.formId], _e();
+  }), _e();
+}
+function Gn(e) {
+  const t = Ve();
+  if (!le) {
+    const n = t?.appContext.app;
+    if (!n)
+      return;
+    zt(n);
+  }
+  we[e.id] = Object.assign({}, e), we[e.id]._vm = t, It(() => {
+    delete we[e.id], _e();
+  }), _e();
+}
+function Hn(e) {
+  const { textColor: t, bgColor: n } = qt(e.meta.value.valid), r = {};
+  Object.values(e.getAllPathStates()).forEach((s) => {
+    ne(r, m(s.path), Yn(s, e));
+  });
+  function o(s, d = []) {
+    const v = [...d].pop();
+    return "id" in s ? Object.assign(Object.assign({}, s), { label: v || s.label }) : ce(s) ? {
+      id: `${d.join(".")}`,
+      label: v || "",
+      children: Object.keys(s).map((c) => o(s[c], [...d, c]))
+    } : Array.isArray(s) ? {
+      id: `${d.join(".")}`,
+      label: `${v}[]`,
+      children: s.map((c, p) => o(c, [...d, String(p)]))
+    } : { id: "", label: "", children: [] };
+  }
+  const { children: a } = o(r);
+  return {
+    id: ot(e),
+    label: e.name,
+    children: a,
+    tags: [
+      {
+        label: "Form",
+        textColor: t,
+        backgroundColor: n
+      },
+      {
+        label: `${e.getAllPathStates().length} fields`,
+        textColor: z.white,
+        backgroundColor: z.unknown
+      }
+    ]
+  };
+}
+function Yn(e, t) {
+  return {
+    id: ot(t, e),
+    label: m(e.path),
+    tags: Wt(e.multiple, e.fieldsCount, e.type, e.valid, t)
+  };
+}
+function Jn(e, t) {
+  return {
+    id: ot(t, e),
+    label: C(e.name),
+    tags: Wt(!1, 1, e.type, e.meta.valid, t)
+  };
+}
+function Wt(e, t, n, r, o) {
+  const { textColor: a, bgColor: s } = qt(r);
+  return [
+    e ? void 0 : {
+      label: "Field",
+      textColor: a,
+      backgroundColor: s
+    },
+    o ? void 0 : {
+      label: "Standalone",
+      textColor: z.black,
+      backgroundColor: z.gray
+    },
+    n === "checkbox" ? {
+      label: "Checkbox",
+      textColor: z.white,
+      backgroundColor: z.blue
+    } : void 0,
+    n === "radio" ? {
+      label: "Radio",
+      textColor: z.white,
+      backgroundColor: z.purple
+    } : void 0,
+    e ? {
+      label: "Multiple",
+      textColor: z.black,
+      backgroundColor: z.orange
+    } : void 0
+  ].filter(Boolean);
+}
+function ot(e, t) {
+  const n = t ? "path" in t ? "pathState" : "field" : "form", r = t ? "path" in t ? t?.path : m(t?.name) : "", o = { f: e?.formId, ff: t?.id || r, type: n };
+  return btoa(encodeURIComponent(JSON.stringify(o)));
+}
+function Xn(e) {
+  try {
+    const t = JSON.parse(decodeURIComponent(atob(e))), n = Ce[t.f];
+    if (!n && t.ff) {
+      const o = we[t.ff];
+      return o ? {
+        type: t.type,
+        field: o
+      } : {};
+    }
+    if (!n)
+      return {};
+    const r = n.getPathState(t.ff);
+    return {
+      type: t.type,
+      form: n,
+      state: r
+    };
+  } catch {
+  }
+  return {};
+}
+function _t(e) {
+  return {
+    "Field state": [
+      { key: "errors", value: e.errors },
+      {
+        key: "initialValue",
+        value: e.initialValue
+      },
+      {
+        key: "currentValue",
+        value: e.value
+      },
+      {
+        key: "touched",
+        value: e.touched
+      },
+      {
+        key: "dirty",
+        value: e.dirty
+      },
+      {
+        key: "valid",
+        value: e.valid
+      }
+    ]
+  };
+}
+function Qn(e) {
+  const { errorBag: t, meta: n, values: r, isSubmitting: o, isValidating: a, submitCount: s } = e;
+  return {
+    "Form state": [
+      {
+        key: "submitCount",
+        value: s.value
+      },
+      {
+        key: "isSubmitting",
+        value: o.value
+      },
+      {
+        key: "isValidating",
+        value: a.value
+      },
+      {
+        key: "touched",
+        value: n.value.touched
+      },
+      {
+        key: "dirty",
+        value: n.value.dirty
+      },
+      {
+        key: "valid",
+        value: n.value.valid
+      },
+      {
+        key: "initialValues",
+        value: n.value.initialValues
+      },
+      {
+        key: "currentValues",
+        value: r
+      },
+      {
+        key: "errors",
+        value: L(t.value).reduce((d, v) => {
+          var c;
+          const p = (c = t.value[v]) === null || c === void 0 ? void 0 : c[0];
+          return p && (d[v] = p), d;
+        }, {})
+      }
+    ]
+  };
+}
+function qt(e) {
+  return {
+    bgColor: e ? z.success : z.error,
+    textColor: e ? z.black : z.white
+  };
+}
+function hr(e, t, n) {
+  return kt(void 0) ? tr(e, t) : Kt(e, t);
+}
+function Kt(e, t, n) {
+  const { initialValue: r, validateOnMount: o, bails: a, type: s, checkedValue: d, label: v, validateOnValueUpdate: c, uncheckedValue: p, controlled: _, keepValueOnUnmount: w, syncVModel: V, form: N } = er(), K = _ ? Rt(lt) : void 0, S = N || K, Z = A(() => Ee(m(e))), J = A(() => {
+    if (m(S?.schema))
+      return;
+    const O = C(t);
+    return Me(O) || ee(O) || W(O) || Array.isArray(O) ? O : Ut(O);
+  }), $e = !W(J.value) && ee(m(t)), { id: pe, value: de, initialValue: fe, meta: x, setState: ye, errors: ge, flags: ve } = Ln(Z, {
+    modelValue: r,
+    form: S,
+    bails: a,
+    label: v,
+    type: s,
+    validate: J.value ? ue : void 0,
+    schema: $e ? t : void 0
+  }), G = A(() => ge.value[0]);
+  V && nr({
+    value: de,
+    prop: V,
+    handleChange: D,
+    shouldValidate: () => c && !ve.pendingReset
+  });
+  const be = (h, O = !1) => {
+    x.touched = !0, O && ae();
+  };
+  async function Ne(h) {
+    var O, I;
+    if (S?.validateSchema) {
+      const { results: E } = await S.validateSchema(h);
+      return (O = E[m(Z)]) !== null && O !== void 0 ? O : { valid: !0, errors: [] };
+    }
+    return J.value ? Bt(de.value, J.value, {
+      name: m(Z),
+      label: m(v),
+      values: (I = S?.values) !== null && I !== void 0 ? I : {},
+      bails: a
+    }) : { valid: !0, errors: [] };
+  }
+  const ae = nt(async () => (x.pending = !0, x.validated = !0, Ne("validated-only")), (h) => (ve.pendingUnmount[R.id] || (ye({ errors: h.errors }), x.pending = !1, x.valid = h.valid), h)), re = nt(async () => Ne("silent"), (h) => (x.valid = h.valid, h));
+  function ue(h) {
+    return h?.mode === "silent" ? re() : ae();
+  }
+  function D(h, O = !0) {
+    const I = Ue(h);
+    Se(I, O);
+  }
+  Ct(() => {
+    if (o)
+      return ae();
+    (!S || !S.validateSchema) && re();
+  });
+  function Le(h) {
+    x.touched = h;
+  }
+  function se(h) {
+    var O;
+    const I = h && "value" in h ? h.value : fe.value;
+    ye({
+      value: j(I),
+      initialValue: j(I),
+      touched: (O = h?.touched) !== null && O !== void 0 ? O : !1,
+      errors: h?.errors || []
+    }), x.pending = !1, x.validated = !1, re();
+  }
+  const he = Ve();
+  function Se(h, O = !0) {
+    de.value = he && V ? An(h, he.props.modelModifiers) : h, (O ? ae : re)();
+  }
+  function Te(h) {
+    ye({ errors: Array.isArray(h) ? h : [h] });
+  }
+  const at = A({
+    get() {
+      return de.value;
+    },
+    set(h) {
+      Se(h, c);
+    }
+  }), R = {
+    id: pe,
+    name: Z,
+    label: v,
+    value: at,
+    meta: x,
+    errors: ge,
+    errorMessage: G,
+    type: s,
+    checkedValue: d,
+    uncheckedValue: p,
+    bails: a,
+    keepValueOnUnmount: w,
+    resetField: se,
+    handleReset: () => se(),
+    validate: ue,
+    handleChange: D,
+    handleBlur: be,
+    setState: ye,
+    setTouched: Le,
+    setErrors: Te,
+    setValue: Se
+  };
+  if (et(bn, R), Re(t) && typeof C(t) != "function" && oe(t, (h, O) => {
+    B(h, O) || (x.validated ? ae() : re());
+  }, {
+    deep: !0
+  }), process.env.NODE_ENV !== "production" && (R._vm = Ve(), oe(() => Object.assign(Object.assign({ errors: ge.value }, x), { value: de.value }), _e, {
+    deep: !0
+  }), S || Gn(R)), !S)
+    return R;
+  const ze = A(() => {
+    const h = J.value;
+    return !h || W(h) || Me(h) || ee(h) || Array.isArray(h) ? {} : Object.keys(h).reduce((O, I) => {
+      const E = Nn(h[I]).map((ie) => ie.__locatorRef).reduce((ie, te) => {
+        const H = q(S.values, te) || S.values[te];
+        return H !== void 0 && (ie[te] = H), ie;
+      }, {});
+      return Object.assign(O, E), O;
+    }, {});
+  });
+  return oe(ze, (h, O) => {
+    if (!Object.keys(h).length)
+      return;
+    !B(h, O) && (x.validated ? ae() : re());
+  }), fn(() => {
+    var h;
+    const O = (h = m(R.keepValueOnUnmount)) !== null && h !== void 0 ? h : m(S.keepValuesOnUnmount), I = m(Z);
+    if (O || !S || ve.pendingUnmount[R.id]) {
+      S?.removePathState(I, pe);
+      return;
+    }
+    ve.pendingUnmount[R.id] = !0;
+    const E = S.getPathState(I);
+    if (Array.isArray(E?.id) && E?.multiple ? E?.id.includes(R.id) : E?.id === R.id) {
+      if (E?.multiple && Array.isArray(E.value)) {
+        const te = E.value.findIndex((H) => B(H, m(R.checkedValue)));
+        if (te > -1) {
+          const H = [...E.value];
+          H.splice(te, 1), S.setFieldValue(I, H);
+        }
+        Array.isArray(E.id) && E.id.splice(E.id.indexOf(R.id), 1);
+      } else
+        S.unsetPathValue(m(Z));
+      S.removePathState(I, pe);
+    }
+  }), R;
+}
+function er(e) {
+  return Object.assign(Object.assign({}, {
+    initialValue: void 0,
+    validateOnMount: !1,
+    bails: !0,
+    label: void 0,
+    validateOnValueUpdate: !0,
+    keepValueOnUnmount: void 0,
+    syncVModel: !1,
+    controlled: !0
+  }), { initialValue: void 0 });
+}
+function tr(e, t, n) {
+  const r = Rt(lt), o = void 0, a = void 0;
+  function s(d) {
+    const v = d.handleChange, c = A(() => {
+      const _ = m(d.value), w = m(o);
+      return Array.isArray(_) ? _.findIndex((V) => B(V, w)) >= 0 : B(w, _);
+    });
+    function p(_, w = !0) {
+      var V, N;
+      if (c.value === ((V = _?.target) === null || V === void 0 ? void 0 : V.checked)) {
+        w && d.validate();
+        return;
+      }
+      const K = m(e), S = r?.getPathState(K), Z = Ue(_);
+      let J = (N = m(o)) !== null && N !== void 0 ? N : Z;
+      r && S?.multiple && S.type === "checkbox" && (J = jn(q(r.values, K) || [], J, void 0)), v(J, w);
+    }
+    return Object.assign(Object.assign({}, d), {
+      checked: c,
+      checkedValue: o,
+      uncheckedValue: a,
+      handleChange: p
+    });
+  }
+  return s(Kt(e, t));
+}
+function nr({ prop: e, value: t, handleChange: n, shouldValidate: r }) {
+  const o = Ve();
+  if (!o || !e) {
+    process.env.NODE_ENV !== "production" && console.warn("Failed to setup model events because `useField` was not called in setup.");
+    return;
+  }
+  const a = typeof e == "string" ? e : "modelValue", s = `update:${a}`;
+  a in o.props && (oe(t, (d) => {
+    B(d, St(o, a)) || o.emit(s, d);
+  }), oe(() => St(o, a), (d) => {
+    if (d === mt && t.value === void 0)
+      return;
+    const v = d === mt ? void 0 : d;
+    B(v, t.value) || n(v, r());
+  }));
+}
+function St(e, t) {
+  if (e)
+    return e.props[t];
+}
+let rr = 0;
+const xe = ["bails", "fieldsCount", "id", "multiple", "type", "validate"];
+function Zt(e) {
+  const t = e?.initialValues || {}, n = Object.assign({}, m(t)), r = C(e?.validationSchema);
+  return r && ee(r) && W(r.cast) ? j(r.cast(n) || {}) : j(n);
+}
+function mr(e) {
+  var t;
+  const n = rr++, r = e?.name || "Form";
+  let o = 0;
+  const a = Q(!1), s = Q(!1), d = Q(0), v = [], c = De(Zt(e)), p = Q([]), _ = Q({}), w = Q({}), V = Cn(() => {
+    w.value = p.value.reduce((l, i) => (l[Ee(m(i.path))] = i, l), {});
+  });
+  function N(l, i) {
+    const u = D(l);
+    if (!u) {
+      typeof l == "string" && (_.value[Ee(l)] = rt(i));
+      return;
+    }
+    if (typeof l == "string") {
+      const f = Ee(l);
+      _.value[f] && delete _.value[f];
+    }
+    u.errors = rt(i), u.valid = !u.errors.length;
+  }
+  function K(l) {
+    L(l).forEach((i) => {
+      N(i, l[i]);
+    });
+  }
+  e?.initialErrors && K(e.initialErrors);
+  const S = A(() => {
+    const l = p.value.reduce((i, u) => (u.errors.length && (i[m(u.path)] = u.errors), i), {});
+    return Object.assign(Object.assign({}, _.value), l);
+  }), Z = A(() => L(S.value).reduce((l, i) => {
+    const u = S.value[i];
+    return u?.length && (l[i] = u[0]), l;
+  }, {})), J = A(() => p.value.reduce((l, i) => (l[m(i.path)] = { name: m(i.path) || "", label: i.label || "" }, l), {})), $e = A(() => p.value.reduce((l, i) => {
+    var u;
+    return l[m(i.path)] = (u = i.bails) !== null && u !== void 0 ? u : !0, l;
+  }, {})), pe = Object.assign({}, e?.initialErrors || {}), de = (t = e?.keepValuesOnUnmount) !== null && t !== void 0 ? t : !1, { initialValues: fe, originalInitialValues: x, setInitialValues: ye } = lr(p, c, e), ge = ir(p, c, x, Z), ve = A(() => p.value.reduce((l, i) => {
+    const u = q(c, m(i.path));
+    return ne(l, m(i.path), u), l;
+  }, {})), G = e?.validationSchema;
+  function be(l, i) {
+    var u, f;
+    const g = A(() => q(fe.value, m(l))), b = w.value[m(l)], y = i?.type === "checkbox" || i?.type === "radio";
+    if (b && y) {
+      b.multiple = !0;
+      const Y = o++;
+      return Array.isArray(b.id) ? b.id.push(Y) : b.id = [b.id, Y], b.fieldsCount++, b.__flags.pendingUnmount[Y] = !1, b;
+    }
+    const F = A(() => q(c, m(l))), T = m(l), M = se.findIndex((Y) => Y === T);
+    M !== -1 && se.splice(M, 1);
+    const P = A(() => {
+      var Y, je, Ge, He;
+      const Ye = m(G);
+      if (ee(Ye))
+        return (je = (Y = Ye.describe) === null || Y === void 0 ? void 0 : Y.call(Ye, m(l)).required) !== null && je !== void 0 ? je : !1;
+      const Je = m(i?.schema);
+      return ee(Je) && (He = (Ge = Je.describe) === null || Ge === void 0 ? void 0 : Ge.call(Je).required) !== null && He !== void 0 ? He : !1;
+    }), U = o++, $ = De({
+      id: U,
+      path: l,
+      touched: !1,
+      pending: !1,
+      valid: !0,
+      validated: !!(!((u = pe[T]) === null || u === void 0) && u.length),
+      required: P,
+      initialValue: g,
+      errors: cn([]),
+      bails: (f = i?.bails) !== null && f !== void 0 ? f : !1,
+      label: i?.label,
+      type: i?.type || "default",
+      value: F,
+      multiple: !1,
+      __flags: {
+        pendingUnmount: { [U]: !1 },
+        pendingReset: !1
+      },
+      fieldsCount: 1,
+      validate: i?.validate,
+      dirty: A(() => !B(C(F), C(g)))
+    });
+    return p.value.push($), w.value[T] = $, V(), Z.value[T] && !pe[T] && X(() => {
+      me(T, { mode: "silent" });
+    }), Re(l) && oe(l, (Y) => {
+      V();
+      const je = j(F.value);
+      w.value[Y] = $, X(() => {
+        ne(c, Y, je);
+      });
+    }), $;
+  }
+  const Ne = bt(ct, 5), ae = bt(ct, 5), re = nt(async (l) => await (l === "silent" ? Ne() : ae()), (l, [i]) => {
+    const u = L(O.errorBag.value), g = [
+      .../* @__PURE__ */ new Set([...L(l.results), ...p.value.map((b) => b.path), ...u])
+    ].sort().reduce((b, y) => {
+      var F;
+      const T = y, M = D(T) || Le(T), P = ((F = l.results[T]) === null || F === void 0 ? void 0 : F.errors) || [], U = m(M?.path) || T, $ = or({ errors: P, valid: !P.length }, b.results[U]);
+      return b.results[U] = $, $.valid || (b.errors[U] = $.errors[0]), M && _.value[U] && delete _.value[U], M ? (M.valid = $.valid, i === "silent" || i === "validated-only" && !M.validated || N(M, $.errors), b) : (N(U, P), b);
+    }, {
+      valid: l.valid,
+      results: {},
+      errors: {},
+      source: l.source
+    });
+    return l.values && (g.values = l.values, g.source = l.source), L(g.results).forEach((b) => {
+      var y;
+      const F = D(b);
+      F && i !== "silent" && (i === "validated-only" && !F.validated || N(F, (y = g.results[b]) === null || y === void 0 ? void 0 : y.errors));
+    }), g;
+  });
+  function ue(l) {
+    p.value.forEach(l);
+  }
+  function D(l) {
+    const i = typeof l == "string" ? Ee(l) : l;
+    return typeof i == "string" ? w.value[i] : i;
+  }
+  function Le(l) {
+    return p.value.filter((u) => l.startsWith(m(u.path))).reduce((u, f) => u ? f.path.length > u.path.length ? f : u : f, void 0);
+  }
+  let se = [], he;
+  function Se(l) {
+    return se.push(l), he || (he = X(() => {
+      [...se].sort().reverse().forEach((u) => {
+        gt(c, u);
+      }), se = [], he = null;
+    })), he;
+  }
+  function Te(l) {
+    return function(u, f) {
+      return function(b) {
+        return b instanceof Event && (b.preventDefault(), b.stopPropagation()), ue((y) => y.touched = !0), a.value = !0, d.value++, Oe().then((y) => {
+          const F = j(c);
+          if (y.valid && typeof u == "function") {
+            const T = j(ve.value);
+            let M = l ? T : F;
+            return y.values && (M = y.source === "schema" ? y.values : Object.assign({}, M, y.values)), u(M, {
+              evt: b,
+              controlledValues: T,
+              setErrors: K,
+              setFieldError: N,
+              setTouched: We,
+              setFieldTouched: H,
+              setValues: ie,
+              setFieldValue: I,
+              resetForm: qe,
+              resetField: ut
+            });
+          }
+          !y.valid && typeof f == "function" && f({
+            values: F,
+            evt: b,
+            errors: y.errors,
+            results: y.results
+          });
+        }).then((y) => (a.value = !1, y), (y) => {
+          throw a.value = !1, y;
+        });
+      };
+    };
+  }
+  const R = Te(!1);
+  R.withControlled = Te(!0);
+  function ze(l, i) {
+    const u = p.value.findIndex((g) => g.path === l && (Array.isArray(g.id) ? g.id.includes(i) : g.id === i)), f = p.value[u];
+    if (!(u === -1 || !f)) {
+      if (X(() => {
+        me(l, { mode: "silent", warn: !1 });
+      }), f.multiple && f.fieldsCount && f.fieldsCount--, Array.isArray(f.id)) {
+        const g = f.id.indexOf(i);
+        g >= 0 && f.id.splice(g, 1), delete f.__flags.pendingUnmount[i];
+      }
+      (!f.multiple || f.fieldsCount <= 0) && (p.value.splice(u, 1), st(l), V(), delete w.value[l]);
+    }
+  }
+  function h(l) {
+    L(w.value).forEach((i) => {
+      i.startsWith(l) && delete w.value[i];
+    }), p.value = p.value.filter((i) => !i.path.startsWith(l)), X(() => {
+      V();
+    });
+  }
+  const O = {
+    name: r,
+    formId: n,
+    values: c,
+    controlledValues: ve,
+    errorBag: S,
+    errors: Z,
+    schema: G,
+    submitCount: d,
+    meta: ge,
+    isSubmitting: a,
+    isValidating: s,
+    fieldArrays: v,
+    keepValuesOnUnmount: de,
+    validateSchema: C(G) ? re : void 0,
+    validate: Oe,
+    setFieldError: N,
+    validateField: me,
+    setFieldValue: I,
+    setValues: ie,
+    setErrors: K,
+    setFieldTouched: H,
+    setTouched: We,
+    resetForm: qe,
+    resetField: ut,
+    handleSubmit: R,
+    useFieldModel: ln,
+    defineInputBinds: on,
+    defineComponentBinds: an,
+    defineField: Ze,
+    stageInitialValue: nn,
+    unsetInitialValue: st,
+    setFieldInitialValue: Ke,
+    createPathState: be,
+    getPathState: D,
+    unsetPathValue: Se,
+    removePathState: ze,
+    initialValues: fe,
+    getAllPathStates: () => p.value,
+    destroyPath: h,
+    isFieldTouched: Qt,
+    isFieldDirty: en,
+    isFieldValid: tn
+  };
+  function I(l, i, u = !0) {
+    const f = j(i), g = typeof l == "string" ? l : l.path;
+    D(g) || be(g), ne(c, g, f), u && me(g);
+  }
+  function E(l, i = !0) {
+    L(c).forEach((u) => {
+      delete c[u];
+    }), L(l).forEach((u) => {
+      I(u, l[u], !1);
+    }), i && Oe();
+  }
+  function ie(l, i = !0) {
+    Pe(c, l), v.forEach((u) => u && u.reset()), i && Oe();
+  }
+  function te(l, i) {
+    const u = D(m(l)) || be(l);
+    return A({
+      get() {
+        return u.value;
+      },
+      set(f) {
+        var g;
+        const b = m(l);
+        I(b, f, (g = m(i)) !== null && g !== void 0 ? g : !1);
+      }
+    });
+  }
+  function H(l, i) {
+    const u = D(l);
+    u && (u.touched = i);
+  }
+  function Qt(l) {
+    const i = D(l);
+    return i ? i.touched : p.value.filter((u) => u.path.startsWith(l)).some((u) => u.touched);
+  }
+  function en(l) {
+    const i = D(l);
+    return i ? i.dirty : p.value.filter((u) => u.path.startsWith(l)).some((u) => u.dirty);
+  }
+  function tn(l) {
+    const i = D(l);
+    return i ? i.valid : p.value.filter((u) => u.path.startsWith(l)).every((u) => u.valid);
+  }
+  function We(l) {
+    if (typeof l == "boolean") {
+      ue((i) => {
+        i.touched = l;
+      });
+      return;
+    }
+    L(l).forEach((i) => {
+      H(i, !!l[i]);
+    });
+  }
+  function ut(l, i) {
+    var u;
+    const f = i && "value" in i ? i.value : q(fe.value, l), g = D(l);
+    g && (g.__flags.pendingReset = !0), Ke(l, j(f), !0), I(l, f, !1), H(l, (u = i?.touched) !== null && u !== void 0 ? u : !1), N(l, i?.errors || []), X(() => {
+      g && (g.__flags.pendingReset = !1);
+    });
+  }
+  function qe(l, i) {
+    let u = j(l?.values ? l.values : x.value);
+    u = i?.force ? u : Pe(x.value, u), u = ee(G) && W(G.cast) ? G.cast(u) : u, ye(u, { force: i?.force }), ue((f) => {
+      var g;
+      f.__flags.pendingReset = !0, f.validated = !1, f.touched = ((g = l?.touched) === null || g === void 0 ? void 0 : g[m(f.path)]) || !1, I(m(f.path), q(u, m(f.path)), !1), N(m(f.path), void 0);
+    }), i?.force ? E(u, !1) : ie(u, !1), K(l?.errors || {}), d.value = l?.submitCount || 0, X(() => {
+      Oe({ mode: "silent" }), ue((f) => {
+        f.__flags.pendingReset = !1;
+      });
+    });
+  }
+  async function Oe(l) {
+    const i = l?.mode || "force";
+    if (i === "force" && ue((y) => y.validated = !0), O.validateSchema)
+      return O.validateSchema(i);
+    s.value = !0;
+    const u = await Promise.all(p.value.map((y) => y.validate ? y.validate(l).then((F) => ({
+      key: m(y.path),
+      valid: F.valid,
+      errors: F.errors,
+      value: F.value
+    })) : Promise.resolve({
+      key: m(y.path),
+      valid: !0,
+      errors: [],
+      value: void 0
+    })));
+    s.value = !1;
+    const f = {}, g = {}, b = {};
+    for (const y of u)
+      f[y.key] = {
+        valid: y.valid,
+        errors: y.errors
+      }, y.value && ne(b, y.key, y.value), y.errors.length && (g[y.key] = y.errors[0]);
+    return {
+      valid: u.every((y) => y.valid),
+      results: f,
+      errors: g,
+      values: b,
+      source: "fields"
+    };
+  }
+  async function me(l, i) {
+    var u;
+    const f = D(l);
+    if (f && i?.mode !== "silent" && (f.validated = !0), G) {
+      const { results: b } = await re(i?.mode || "validated-only");
+      return b[l] || { errors: [], valid: !0 };
+    }
+    return f?.validate ? f.validate(i) : (!f && (!((u = i?.warn) !== null && u !== void 0) || u) && process.env.NODE_ENV !== "production" && dn(`field with path ${l} was not found`), Promise.resolve({ errors: [], valid: !0 }));
+  }
+  function st(l) {
+    gt(fe.value, l);
+  }
+  function nn(l, i, u = !1) {
+    Ke(l, i), ne(c, l, i), u && !e?.initialValues && ne(x.value, l, j(i));
+  }
+  function Ke(l, i, u = !1) {
+    ne(fe.value, l, j(i)), u && ne(x.value, l, j(i));
+  }
+  async function ct() {
+    const l = C(G);
+    if (!l)
+      return { valid: !0, results: {}, errors: {}, source: "none" };
+    s.value = !0;
+    const i = Me(l) || ee(l) ? await Bn(l, c) : await $n(l, c, {
+      names: J.value,
+      bailsMap: $e.value
+    });
+    return s.value = !1, i;
+  }
+  const rn = R((l, { evt: i }) => {
+    Sn(i) && i.target.submit();
+  });
+  Ct(() => {
+    if (e?.initialErrors && K(e.initialErrors), e?.initialTouched && We(e.initialTouched), e?.validateOnMount) {
+      Oe();
+      return;
+    }
+    O.validateSchema && O.validateSchema("silent");
+  }), Re(G) && oe(G, () => {
+    var l;
+    (l = O.validateSchema) === null || l === void 0 || l.call(O, "validated-only");
+  }), et(lt, O), process.env.NODE_ENV !== "production" && (Zn(O), oe(() => Object.assign(Object.assign({ errors: S.value }, ge.value), { values: c, isSubmitting: a.value, isValidating: s.value, submitCount: d.value }), _e, {
+    deep: !0
+  }));
+  function Ze(l, i) {
+    const u = W(i) ? void 0 : i?.label, f = D(m(l)) || be(l, { label: u }), g = () => W(i) ? i(ke(f, xe)) : i || {};
+    function b() {
+      var P;
+      f.touched = !0, ((P = g().validateOnBlur) !== null && P !== void 0 ? P : Ae().validateOnBlur) && me(m(f.path));
+    }
+    function y() {
+      var P;
+      ((P = g().validateOnInput) !== null && P !== void 0 ? P : Ae().validateOnInput) && X(() => {
+        me(m(f.path));
+      });
+    }
+    function F() {
+      var P;
+      ((P = g().validateOnChange) !== null && P !== void 0 ? P : Ae().validateOnChange) && X(() => {
+        me(m(f.path));
+      });
+    }
+    const T = A(() => {
+      const P = {
+        onChange: F,
+        onInput: y,
+        onBlur: b
+      };
+      return W(i) ? Object.assign(Object.assign({}, P), i(ke(f, xe)).props || {}) : i?.props ? Object.assign(Object.assign({}, P), i.props(ke(f, xe))) : P;
+    });
+    return [te(l, () => {
+      var P, U, $;
+      return ($ = (P = g().validateOnModelUpdate) !== null && P !== void 0 ? P : (U = Ae()) === null || U === void 0 ? void 0 : U.validateOnModelUpdate) !== null && $ !== void 0 ? $ : !0;
+    }), T];
+  }
+  function ln(l) {
+    return Array.isArray(l) ? l.map((i) => te(i, !0)) : te(l);
+  }
+  function on(l, i) {
+    const [u, f] = Ze(l, i);
+    function g() {
+      f.value.onBlur();
+    }
+    function b(F) {
+      const T = Ue(F);
+      I(m(l), T, !1), f.value.onInput();
+    }
+    function y(F) {
+      const T = Ue(F);
+      I(m(l), T, !1), f.value.onChange();
+    }
+    return A(() => Object.assign(Object.assign({}, f.value), {
+      onBlur: g,
+      onInput: b,
+      onChange: y,
+      value: u.value
+    }));
+  }
+  function an(l, i) {
+    const [u, f] = Ze(l, i), g = D(m(l));
+    function b(y) {
+      u.value = y;
+    }
+    return A(() => {
+      const y = W(i) ? i(ke(g, xe)) : i || {};
+      return Object.assign({ [y.model || "modelValue"]: u.value, [`onUpdate:${y.model || "modelValue"}`]: b }, f.value);
+    });
+  }
+  const dt = Object.assign(Object.assign({}, O), { values: un(c), handleReset: () => qe(), submitForm: rn });
+  return et(Nt, dt), dt;
+}
+function ir(e, t, n, r) {
+  const o = {
+    touched: "some",
+    pending: "some",
+    valid: "every"
+  }, a = A(() => !B(t, C(n)));
+  function s() {
+    const v = e.value;
+    return L(o).reduce((c, p) => {
+      const _ = o[p];
+      return c[p] = v[_]((w) => w[p]), c;
+    }, {});
+  }
+  const d = De(s());
+  return sn(() => {
+    const v = s();
+    d.touched = v.touched, d.valid = v.valid, d.pending = v.pending;
+  }), A(() => Object.assign(Object.assign({ initialValues: C(n) }, d), { valid: d.valid && !L(r.value).length, dirty: a.value }));
+}
+function lr(e, t, n) {
+  const r = Zt(n), o = Q(r), a = Q(j(r));
+  function s(d, v) {
+    v?.force ? (o.value = j(d), a.value = j(d)) : (o.value = Pe(j(o.value) || {}, j(d)), a.value = Pe(j(a.value) || {}, j(d))), v?.updateFields && e.value.forEach((c) => {
+      if (c.touched)
+        return;
+      const _ = q(o.value, m(c.path));
+      ne(t, m(c.path), j(_));
+    });
+  }
+  return {
+    initialValues: o,
+    originalInitialValues: a,
+    setInitialValues: s
+  };
+}
+function or(e, t) {
+  return t ? {
+    valid: e.valid && t.valid,
+    errors: [...e.errors, ...t.errors]
+  } : e;
+}
+function pr() {
+  return wt(Nt);
+}
+const jt = (e) => e !== null && !!e && typeof e == "object" && !Array.isArray(e);
+function Gt(e) {
+  return Number(e) >= 0;
+}
+function ar(e) {
+  return typeof e == "object" && e !== null;
+}
+function ur(e) {
+  return e == null ? e === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(e);
+}
+function Et(e) {
+  if (!ar(e) || ur(e) !== "[object Object]")
+    return !1;
+  if (Object.getPrototypeOf(e) === null)
+    return !0;
+  let t = e;
+  for (; Object.getPrototypeOf(t) !== null; )
+    t = Object.getPrototypeOf(t);
+  return Object.getPrototypeOf(e) === t;
+}
+function Ht(e, t) {
+  return Object.keys(t).forEach((n) => {
+    if (Et(t[n]) && Et(e[n])) {
+      e[n] || (e[n] = {}), Ht(e[n], t[n]);
+      return;
+    }
+    e[n] = t[n];
+  }), e;
+}
+function sr(e) {
+  const t = e.split(".");
+  if (!t.length)
+    return "";
+  let n = String(t[0]);
+  for (let r = 1; r < t.length; r++) {
+    if (Gt(t[r])) {
+      n += `[${t[r]}]`;
+      continue;
+    }
+    n += `.${t[r]}`;
+  }
+  return n;
+}
+function yr(e, t) {
+  return {
+    __type: "VVTypedSchema",
+    async parse(r) {
+      const o = await e.safeParseAsync(r, t);
+      if (o.success)
+        return {
+          value: o.data,
+          errors: []
+        };
+      const a = {};
+      return Yt(o.error.issues, a), {
+        errors: Object.values(a)
+      };
+    },
+    cast(r) {
+      try {
+        return e.parse(r);
+      } catch {
+        const a = Jt(e);
+        return jt(a) && jt(r) ? Ht(a, r) : r;
+      }
+    },
+    describe(r) {
+      try {
+        if (!r)
+          return {
+            required: !e.isOptional(),
+            exists: !0
+          };
+        const o = cr(r, e);
+        return o ? {
+          required: !o.isOptional(),
+          exists: !0
+        } : {
+          required: !1,
+          exists: !1
+        };
+      } catch {
+        return process.env.NODE_ENV !== "production" && console.warn(`Failed to describe path ${r} on the schema, returning a default description.`), {
+          required: !1,
+          exists: !1
+        };
+      }
+    }
+  };
+}
+function Yt(e, t) {
+  e.forEach((n) => {
+    const r = sr(n.path.join("."));
+    n.code === "invalid_union" && (Yt(n.unionErrors.flatMap((o) => o.issues), t), !r) || (t[r] || (t[r] = { errors: [], path: r }), t[r].errors.push(n.message));
+  });
+}
+function Jt(e) {
+  if (e instanceof ft)
+    return Object.fromEntries(Object.entries(e.shape).map(([t, n]) => n instanceof vn ? [t, n._def.defaultValue()] : n instanceof ft ? [t, Jt(n)] : [t, void 0]));
+}
+function cr(e, t) {
+  if (!At(t))
+    return null;
+  if (Fe(e))
+    return t.shape[Be(e)];
+  const n = (e || "").split(/\.|\[(\d+)\]/).filter(Boolean);
+  let r = t;
+  for (let o = 0; o <= n.length; o++) {
+    const a = n[o];
+    if (!a || !r)
+      return r;
+    if (At(r)) {
+      r = r.shape[a] || null;
+      continue;
+    }
+    Gt(a) && dr(r) && (r = r._def.type);
+  }
+  return null;
+}
+function Xt(e) {
+  return e._def.typeName;
+}
+function dr(e) {
+  return Xt(e) === Pt.ZodArray;
+}
+function At(e) {
+  return Xt(e) === Pt.ZodObject;
+}
+export {
+  hr as a,
+  mr as b,
+  yr as t,
+  pr as u
+};