@soft-stech/bootsman-ui-shadcn 1.0.5-beta.4 → 1.1.0

package/dist/useFormField-ht86QnXS.js

@@ -0,0 +1,2097 @@
+import { defineComponent as ct, toRef as _e, computed as S, resolveDynamicComponent as ft, h as Le, inject as Ce, toValue as E, getCurrentInstance as Ee, unref as j, onMounted as Mt, provide as Bt, isRef as $e, watch as be, onBeforeUnmount as on, ref as de, reactive as ze, nextTick as se, warn as Rt, readonly as sn, watchEffect as dn, onUnmounted as Ut, shallowRef as cn } from "vue";
+import { F as fn } from "./BuiFormItem.vue_vue_type_script_setup_true_lang-H1naMqTM.js";
+function vn() {
+  return Dt().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+function Dt() {
+  return typeof navigator < "u" && typeof window < "u" ? window : typeof global < "u" ? global : {};
+}
+const hn = typeof Proxy == "function", mn = "devtools-plugin:setup", gn = "plugin:settings:set";
+let je, at;
+function yn() {
+  var e;
+  return je !== void 0 || (typeof window < "u" && window.performance ? (je = !0, at = window.performance) : typeof global < "u" && (!((e = global.perf_hooks) === null || e === void 0) && e.performance) ? (je = !0, at = global.perf_hooks.performance) : je = !1), je;
+}
+function bn() {
+  return yn() ? at.now() : Date.now();
+}
+class pn {
+  constructor(t, n) {
+    this.target = null, this.targetQueue = [], this.onQueue = [], this.plugin = t, this.hook = n;
+    const r = {};
+    if (t.settings)
+      for (const o in t.settings) {
+        const d = t.settings[o];
+        r[o] = d.defaultValue;
+      }
+    const i = `__vue-devtools-plugin-settings__${t.id}`;
+    let u = Object.assign({}, r);
+    try {
+      const o = localStorage.getItem(i), d = JSON.parse(o);
+      Object.assign(u, d);
+    } catch {
+    }
+    this.fallbacks = {
+      getSettings() {
+        return u;
+      },
+      setSettings(o) {
+        try {
+          localStorage.setItem(i, JSON.stringify(o));
+        } catch {
+        }
+        u = o;
+      },
+      now() {
+        return bn();
+      }
+    }, n && n.on(gn, (o, d) => {
+      o === this.plugin.id && this.fallbacks.setSettings(d);
+    }), this.proxiedOn = new Proxy({}, {
+      get: (o, d) => this.target ? this.target.on[d] : (...c) => {
+        this.onQueue.push({
+          method: d,
+          args: c
+        });
+      }
+    }), this.proxiedTarget = new Proxy({}, {
+      get: (o, d) => this.target ? this.target[d] : d === "on" ? this.proxiedOn : Object.keys(this.fallbacks).includes(d) ? (...c) => (this.targetQueue.push({
+        method: d,
+        args: c,
+        resolve: () => {
+        }
+      }), this.fallbacks[d](...c)) : (...c) => new Promise((f) => {
+        this.targetQueue.push({
+          method: d,
+          args: c,
+          resolve: f
+        });
+      })
+    });
+  }
+  async setRealTarget(t) {
+    this.target = t;
+    for (const n of this.onQueue)
+      this.target.on[n.method](...n.args);
+    for (const n of this.targetQueue)
+      n.resolve(await this.target[n.method](...n.args));
+  }
+}
+function On(e, t) {
+  const n = e, r = Dt(), i = vn(), u = hn && n.enableEarlyProxy;
+  if (i && (r.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !u))
+    i.emit(mn, e, t);
+  else {
+    const o = u ? new pn(n, i) : null;
+    (r.__VUE_DEVTOOLS_PLUGINS__ = r.__VUE_DEVTOOLS_PLUGINS__ || []).push({
+      pluginDescriptor: n,
+      setupFn: t,
+      proxy: o
+    }), o && t(o.proxiedTarget);
+  }
+}
+/**
+  * vee-validate v4.12.4
+  * (c) 2023 Abdelrahman Awad
+  * @license MIT
+  */
+function W(e) {
+  return typeof e == "function";
+}
+function xt(e) {
+  return e == null;
+}
+const Oe = (e) => e !== null && !!e && typeof e == "object" && !Array.isArray(e);
+function vt(e) {
+  return Number(e) >= 0;
+}
+function Vn(e) {
+  const t = parseFloat(e);
+  return isNaN(t) ? e : t;
+}
+function _n(e) {
+  return typeof e == "object" && e !== null;
+}
+function Sn(e) {
+  return e == null ? e === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(e);
+}
+function Et(e) {
+  if (!_n(e) || Sn(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 Be(e, t) {
+  return Object.keys(t).forEach((n) => {
+    if (Et(t[n]) && Et(e[n])) {
+      e[n] || (e[n] = {}), Be(e[n], t[n]);
+      return;
+    }
+    e[n] = t[n];
+  }), e;
+}
+function Te(e) {
+  const t = e.split(".");
+  if (!t.length)
+    return "";
+  let n = String(t[0]);
+  for (let r = 1; r < t.length; r++) {
+    if (vt(t[r])) {
+      n += `[${t[r]}]`;
+      continue;
+    }
+    n += `.${t[r]}`;
+  }
+  return n;
+}
+const En = {};
+function In(e) {
+  return En[e];
+}
+function It(e, t, n) {
+  typeof n.value == "object" && (n.value = C(n.value)), !n.enumerable || n.get || n.set || !n.configurable || !n.writable || t === "__proto__" ? Object.defineProperty(e, t, n) : e[t] = n.value;
+}
+function C(e) {
+  if (typeof e != "object")
+    return e;
+  var t = 0, n, r, i, u = Object.prototype.toString.call(e);
+  if (u === "[object Object]" ? i = Object.create(e.__proto__ || null) : u === "[object Array]" ? i = Array(e.length) : u === "[object Set]" ? (i = /* @__PURE__ */ new Set(), e.forEach(function(o) {
+    i.add(C(o));
+  })) : u === "[object Map]" ? (i = /* @__PURE__ */ new Map(), e.forEach(function(o, d) {
+    i.set(C(d), C(o));
+  })) : u === "[object Date]" ? i = /* @__PURE__ */ new Date(+e) : u === "[object RegExp]" ? i = new RegExp(e.source, e.flags) : u === "[object DataView]" ? i = new e.constructor(C(e.buffer)) : u === "[object ArrayBuffer]" ? i = e.slice(0) : u.slice(-6) === "Array]" && (i = new e.constructor(e)), i) {
+    for (r = Object.getOwnPropertySymbols(e); t < r.length; t++)
+      It(i, r[t], Object.getOwnPropertyDescriptor(e, r[t]));
+    for (t = 0, r = Object.getOwnPropertyNames(e); t < r.length; t++)
+      Object.hasOwnProperty.call(i, n = r[t]) && i[n] === e[n] || It(i, n, Object.getOwnPropertyDescriptor(e, n));
+  }
+  return i || e;
+}
+const Fe = Symbol("vee-validate-form"), qe = Symbol("vee-validate-field-instance"), We = Symbol("Default empty value"), jn = typeof window < "u";
+function ut(e) {
+  return W(e) && !!e.__locatorRef;
+}
+function ce(e) {
+  return !!e && W(e.parse) && e.__type === "VVTypedSchema";
+}
+function Ge(e) {
+  return !!e && W(e.validate);
+}
+function Re(e) {
+  return e === "checkbox" || e === "radio";
+}
+function An(e) {
+  return Oe(e) || Array.isArray(e);
+}
+function Cn(e) {
+  return Array.isArray(e) ? e.length === 0 : Oe(e) && Object.keys(e).length === 0;
+}
+function Ke(e) {
+  return /^\[.+\]$/i.test(e);
+}
+function wn(e) {
+  return Lt(e) && e.multiple;
+}
+function Lt(e) {
+  return e.tagName === "SELECT";
+}
+function Fn(e, t) {
+  const n = ![!1, null, void 0, 0].includes(t.multiple) && !Number.isNaN(t.multiple);
+  return e === "select" && "multiple" in t && n;
+}
+function Pn(e, t) {
+  return !Fn(e, t) && t.type !== "file" && !Re(t.type);
+}
+function $t(e) {
+  return ht(e) && e.target && "submit" in e.target;
+}
+function ht(e) {
+  return e ? !!(typeof Event < "u" && W(Event) && e instanceof Event || e && e.srcElement) : !1;
+}
+function jt(e, t) {
+  return t in e && e[t] !== We;
+}
+function q(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, i;
+    if (Array.isArray(e)) {
+      if (n = e.length, n != t.length)
+        return !1;
+      for (r = n; r-- !== 0; )
+        if (!q(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 (!q(r[1], t.get(r[0])))
+          return !1;
+      return !0;
+    }
+    if (At(e) && At(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();
+    for (i = Object.keys(e), n = i.length, r = n; r-- !== 0; ) {
+      var u = i[r];
+      if (!q(e[u], t[u]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function At(e) {
+  return jn ? e instanceof File : !1;
+}
+function mt(e) {
+  return Ke(e) ? e.replace(/\[|\]/gi, "") : e;
+}
+function ee(e, t, n) {
+  return e ? Ke(t) ? e[mt(t)] : (t || "").split(/\.|\[(\d+)\]/).filter(Boolean).reduce((i, u) => An(i) && u in i ? i[u] : n, e) : n;
+}
+function ge(e, t, n) {
+  if (Ke(t)) {
+    e[mt(t)] = n;
+    return;
+  }
+  const r = t.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let i = e;
+  for (let u = 0; u < r.length; u++) {
+    if (u === r.length - 1) {
+      i[r[u]] = n;
+      return;
+    }
+    (!(r[u] in i) || xt(i[r[u]])) && (i[r[u]] = vt(r[u + 1]) ? [] : {}), i = i[r[u]];
+  }
+}
+function it(e, t) {
+  if (Array.isArray(e) && vt(t)) {
+    e.splice(Number(t), 1);
+    return;
+  }
+  Oe(e) && delete e[t];
+}
+function Ct(e, t) {
+  if (Ke(t)) {
+    delete e[mt(t)];
+    return;
+  }
+  const n = t.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let r = e;
+  for (let u = 0; u < n.length; u++) {
+    if (u === n.length - 1) {
+      it(r, n[u]);
+      break;
+    }
+    if (!(n[u] in r) || xt(r[n[u]]))
+      break;
+    r = r[n[u]];
+  }
+  const i = n.map((u, o) => ee(e, n.slice(0, o).join(".")));
+  for (let u = i.length - 1; u >= 0; u--)
+    if (Cn(i[u])) {
+      if (u === 0) {
+        it(e, n[0]);
+        continue;
+      }
+      it(i[u - 1], n[u - 1]);
+    }
+}
+function ie(e) {
+  return Object.keys(e);
+}
+function Qe(e, t = void 0) {
+  const n = Ee();
+  return n?.provides[e] || Ce(e, t);
+}
+function kn(e) {
+  Rt(`[vee-validate]: ${e}`);
+}
+function wt(e, t, n) {
+  if (Array.isArray(e)) {
+    const r = [...e], i = r.findIndex((u) => q(u, t));
+    return i >= 0 ? r.splice(i, 1) : r.push(t), r;
+  }
+  return q(e, t) ? n : t;
+}
+function Tn(e, t) {
+  let n, r;
+  return function(...i) {
+    const u = this;
+    return n || (n = !0, setTimeout(() => n = !1, t), r = e.apply(u, i)), r;
+  };
+}
+function Ft(e, t = 0) {
+  let n = null, r = [];
+  return function(...i) {
+    return n && clearTimeout(n), n = setTimeout(() => {
+      const u = e(...i);
+      r.forEach((o) => o(u)), r = [];
+    }, t), new Promise((u) => r.push(u));
+  };
+}
+function Nn(e, t) {
+  return Oe(t) && t.number ? Vn(e) : e;
+}
+function ot(e, t) {
+  let n;
+  return async function(...i) {
+    const u = e(...i);
+    n = u;
+    const o = await u;
+    return u !== n ? o : (n = void 0, t(o, i));
+  };
+}
+function st(e) {
+  return Array.isArray(e) ? e : e ? [e] : [];
+}
+function gt(e) {
+  const t = Qe(Fe), n = e ? S(() => t?.getPathState(E(e))) : void 0, r = e ? void 0 : Ce(qe);
+  return !r && !n?.value && process.env.NODE_ENV !== "production" && kn(`field with name ${E(e)} was not found`), n || r;
+}
+function De(e, t) {
+  const n = {};
+  for (const r in e)
+    t.includes(r) || (n[r] = e[r]);
+  return n;
+}
+function Mn(e) {
+  let t = null, n = [];
+  return function(...r) {
+    const i = se(() => {
+      if (t !== i)
+        return;
+      const u = e(...r);
+      n.forEach((o) => o(u)), n = [], t = null;
+    });
+    return t = i, new Promise((u) => n.push(u));
+  };
+}
+function yt(e, t, n) {
+  return t.slots.default ? typeof e == "string" || !e ? t.slots.default(n()) : {
+    default: () => {
+      var r, i;
+      return (i = (r = t.slots).default) === null || i === void 0 ? void 0 : i.call(r, n());
+    }
+  } : t.slots.default;
+}
+function lt(e) {
+  if (zt(e))
+    return e._value;
+}
+function zt(e) {
+  return "_value" in e;
+}
+function Bn(e) {
+  return e.type === "number" || e.type === "range" ? Number.isNaN(e.valueAsNumber) ? e.value : e.valueAsNumber : e.value;
+}
+function He(e) {
+  if (!ht(e))
+    return e;
+  const t = e.target;
+  if (Re(t.type) && zt(t))
+    return lt(t);
+  if (t.type === "file" && t.files) {
+    const n = Array.from(t.files);
+    return t.multiple ? n : n[0];
+  }
+  if (wn(t))
+    return Array.from(t.options).filter((n) => n.selected && !n.disabled).map(lt);
+  if (Lt(t)) {
+    const n = Array.from(t.options).find((r) => r.selected);
+    return n ? lt(n) : t.value;
+  }
+  return Bn(t);
+}
+function Wt(e) {
+  const t = {};
+  return Object.defineProperty(t, "_$$isNormalized", {
+    value: !0,
+    writable: !1,
+    enumerable: !1,
+    configurable: !1
+  }), e ? Oe(e) && e._$$isNormalized ? e : Oe(e) ? Object.keys(e).reduce((n, r) => {
+    const i = Rn(e[r]);
+    return e[r] !== !1 && (n[r] = Pt(i)), n;
+  }, t) : typeof e != "string" ? t : e.split("|").reduce((n, r) => {
+    const i = Un(r);
+    return i.name && (n[i.name] = Pt(i.params)), n;
+  }, t) : t;
+}
+function Rn(e) {
+  return e === !0 ? [] : Array.isArray(e) || Oe(e) ? e : [e];
+}
+function Pt(e) {
+  const t = (n) => typeof n == "string" && n[0] === "@" ? Dn(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 Un = (e) => {
+  let t = [];
+  const n = e.split(":")[0];
+  return e.includes(":") && (t = e.split(":").slice(1).join(":").split(",")), { name: n, params: t };
+};
+function Dn(e) {
+  const t = (n) => ee(n, e) || n[e];
+  return t.__locatorRef = e, t;
+}
+function xn(e) {
+  return Array.isArray(e) ? e.filter(ut) : ie(e).filter((t) => ut(e[t])).map((t) => e[t]);
+}
+const Ln = {
+  generateMessage: ({ field: e }) => `${e} is not valid.`,
+  bails: !0,
+  validateOnBlur: !0,
+  validateOnChange: !0,
+  validateOnInput: !1,
+  validateOnModelUpdate: !0
+};
+let $n = Object.assign({}, Ln);
+const Se = () => $n;
+async function Gt(e, t, n = {}) {
+  const r = n?.bails, i = {
+    name: n?.name || "{field}",
+    rules: t,
+    label: n?.label,
+    bails: r ?? !0,
+    formData: n?.values || {}
+  }, o = (await zn(i, e)).errors;
+  return {
+    errors: o,
+    valid: !o.length
+  };
+}
+async function zn(e, t) {
+  if (ce(e.rules) || Ge(e.rules))
+    return Gn(t, e.rules);
+  if (W(e.rules) || Array.isArray(e.rules)) {
+    const o = {
+      field: e.label || e.name,
+      name: e.name,
+      label: e.label,
+      form: e.formData,
+      value: t
+    }, d = Array.isArray(e.rules) ? e.rules : [e.rules], c = d.length, f = [];
+    for (let g = 0; g < c; g++) {
+      const y = d[g], I = await y(t, o);
+      if (!(typeof I != "string" && !Array.isArray(I) && I)) {
+        if (Array.isArray(I))
+          f.push(...I);
+        else {
+          const P = typeof I == "string" ? I : qt(o);
+          f.push(P);
+        }
+        if (e.bails)
+          return {
+            errors: f
+          };
+      }
+    }
+    return {
+      errors: f
+    };
+  }
+  const n = Object.assign(Object.assign({}, e), { rules: Wt(e.rules) }), r = [], i = Object.keys(n.rules), u = i.length;
+  for (let o = 0; o < u; o++) {
+    const d = i[o], c = await Hn(n, t, {
+      name: d,
+      params: n.rules[d]
+    });
+    if (c.error && (r.push(c.error), e.bails))
+      return {
+        errors: r
+      };
+  }
+  return {
+    errors: r
+  };
+}
+function Wn(e) {
+  return !!e && e.name === "ValidationError";
+}
+function Ht(e) {
+  return {
+    __type: "VVTypedSchema",
+    async parse(n) {
+      var r;
+      try {
+        return {
+          output: await e.validate(n, { abortEarly: !1 }),
+          errors: []
+        };
+      } catch (i) {
+        if (!Wn(i))
+          throw i;
+        if (!(!((r = i.inner) === null || r === void 0) && r.length) && i.errors.length)
+          return { errors: [{ path: i.path, errors: i.errors }] };
+        const u = i.inner.reduce((o, d) => {
+          const c = d.path || "";
+          return o[c] || (o[c] = { errors: [], path: c }), o[c].errors.push(...d.errors), o;
+        }, {});
+        return { errors: Object.values(u) };
+      }
+    }
+  };
+}
+async function Gn(e, t) {
+  const r = await (ce(t) ? t : Ht(t)).parse(e), i = [];
+  for (const u of r.errors)
+    u.errors.length && i.push(...u.errors);
+  return {
+    errors: i
+  };
+}
+async function Hn(e, t, n) {
+  const r = In(n.name);
+  if (!r)
+    throw new Error(`No such validator '${n.name}' exists.`);
+  const i = qn(n.params, e.formData), u = {
+    field: e.label || e.name,
+    name: e.name,
+    label: e.label,
+    value: t,
+    form: e.formData,
+    rule: Object.assign(Object.assign({}, n), { params: i })
+  }, o = await r(t, i, u);
+  return typeof o == "string" ? {
+    error: o
+  } : {
+    error: o ? void 0 : qt(u)
+  };
+}
+function qt(e) {
+  const t = Se().generateMessage;
+  return t ? t(e) : "Field is invalid";
+}
+function qn(e, t) {
+  const n = (r) => ut(r) ? r(t) : r;
+  return Array.isArray(e) ? e.map(n) : Object.keys(e).reduce((r, i) => (r[i] = n(e[i]), r), {});
+}
+async function Kn(e, t) {
+  const r = await (ce(e) ? e : Ht(e)).parse(C(t)), i = {}, u = {};
+  for (const o of r.errors) {
+    const d = o.errors, c = (o.path || "").replace(/\["(\d+)"\]/g, (f, g) => `[${g}]`);
+    i[c] = { valid: !d.length, errors: d }, d.length && (u[c] = d[0]);
+  }
+  return {
+    valid: !r.errors.length,
+    results: i,
+    errors: u,
+    values: r.value
+  };
+}
+async function Qn(e, t, n) {
+  const i = ie(e).map(async (f) => {
+    var g, y, I;
+    const O = (g = n?.names) === null || g === void 0 ? void 0 : g[f], P = await Gt(ee(t, f), e[f], {
+      name: O?.name || f,
+      label: O?.label,
+      values: t,
+      bails: (I = (y = n?.bailsMap) === null || y === void 0 ? void 0 : y[f]) !== null && I !== void 0 ? I : !0
+    });
+    return Object.assign(Object.assign({}, P), { path: f });
+  });
+  let u = !0;
+  const o = await Promise.all(i), d = {}, c = {};
+  for (const f of o)
+    d[f.path] = {
+      valid: f.valid,
+      errors: f.errors
+    }, f.valid || (u = !1, c[f.path] = f.errors[0]);
+  return {
+    valid: u,
+    results: d,
+    errors: c
+  };
+}
+let kt = 0;
+function Jn(e, t) {
+  const { value: n, initialValue: r, setInitialValue: i } = Yn(e, t.modelValue, t.form);
+  if (!t.form) {
+    let I = function(O) {
+      var P;
+      "value" in O && (n.value = O.value), "errors" in O && f(O.errors), "touched" in O && (y.touched = (P = O.touched) !== null && P !== void 0 ? P : y.touched), "initialValue" in O && i(O.initialValue);
+    };
+    const { errors: c, setErrors: f } = er(), g = kt >= Number.MAX_SAFE_INTEGER ? 0 : ++kt, y = Zn(n, r, c, t.schema);
+    return {
+      id: g,
+      path: e,
+      value: n,
+      initialValue: r,
+      meta: y,
+      flags: { pendingUnmount: { [g]: !1 }, pendingReset: !1 },
+      errors: c,
+      setState: I
+    };
+  }
+  const u = t.form.createPathState(e, {
+    bails: t.bails,
+    label: t.label,
+    type: t.type,
+    validate: t.validate,
+    schema: t.schema
+  }), o = S(() => u.errors);
+  function d(c) {
+    var f, g, y;
+    "value" in c && (n.value = c.value), "errors" in c && ((f = t.form) === null || f === void 0 || f.setFieldError(j(e), c.errors)), "touched" in c && ((g = t.form) === null || g === void 0 || g.setFieldTouched(j(e), (y = c.touched) !== null && y !== void 0 ? y : !1)), "initialValue" in c && i(c.initialValue);
+  }
+  return {
+    id: Array.isArray(u.id) ? u.id[u.id.length - 1] : u.id,
+    path: e,
+    value: n,
+    errors: o,
+    meta: u,
+    initialValue: r,
+    flags: u.__flags,
+    setState: d
+  };
+}
+function Yn(e, t, n) {
+  const r = de(j(t));
+  function i() {
+    return n ? ee(n.initialValues.value, j(e), j(r)) : j(r);
+  }
+  function u(f) {
+    if (!n) {
+      r.value = f;
+      return;
+    }
+    n.setFieldInitialValue(j(e), f, !0);
+  }
+  const o = S(i);
+  if (!n)
+    return {
+      value: de(i()),
+      initialValue: o,
+      setInitialValue: u
+    };
+  const d = Xn(t, n, o, e);
+  return n.stageInitialValue(j(e), d, !0), {
+    value: S({
+      get() {
+        return ee(n.values, j(e));
+      },
+      set(f) {
+        n.setFieldValue(j(e), f, !1);
+      }
+    }),
+    initialValue: o,
+    setInitialValue: u
+  };
+}
+function Xn(e, t, n, r) {
+  return $e(e) ? j(e) : e !== void 0 ? e : ee(t.values, j(r), j(n));
+}
+function Zn(e, t, n, r) {
+  var i, u;
+  const o = (u = (i = r?.describe) === null || i === void 0 ? void 0 : i.call(r).required) !== null && u !== void 0 ? u : !1, d = ze({
+    touched: !1,
+    pending: !1,
+    valid: !0,
+    required: o,
+    validated: !!j(n).length,
+    initialValue: S(() => j(t)),
+    dirty: S(() => !q(j(e), j(t)))
+  });
+  return be(n, (c) => {
+    d.valid = !c.length;
+  }, {
+    immediate: !0,
+    flush: "sync"
+  }), d;
+}
+function er() {
+  const e = de([]);
+  return {
+    errors: e,
+    setErrors: (t) => {
+      e.value = st(t);
+    }
+  };
+}
+function Kt(e) {
+  process.env.NODE_ENV !== "production" && On({
+    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"
+  }, rr);
+}
+const Ne = {}, Me = {};
+let ye;
+const we = Tn(() => {
+  setTimeout(async () => {
+    await se(), ye?.sendInspectorState(Ae), ye?.sendInspectorTree(Ae);
+  }, 100);
+}, 100);
+function tr(e) {
+  const t = Ee();
+  if (!ye) {
+    const n = t?.appContext.app;
+    if (!n)
+      return;
+    Kt(n);
+  }
+  Ne[e.formId] = Object.assign({}, e), Ne[e.formId]._vm = t, Ut(() => {
+    delete Ne[e.formId], we();
+  }), we();
+}
+function nr(e) {
+  const t = Ee();
+  if (!ye) {
+    const n = t?.appContext.app;
+    if (!n)
+      return;
+    Kt(n);
+  }
+  Me[e.id] = Object.assign({}, e), Me[e.id]._vm = t, Ut(() => {
+    delete Me[e.id], we();
+  }), we();
+}
+const Ae = "vee-validate-inspector", Z = {
+  error: 12405579,
+  success: 448379,
+  unknown: 5522283,
+  white: 16777215,
+  black: 0,
+  blue: 218007,
+  purple: 12157168,
+  orange: 16099682,
+  gray: 12304330
+};
+let R = null;
+function rr(e) {
+  ye = e, e.addInspector({
+    id: Ae,
+    icon: "rule",
+    label: "vee-validate",
+    noSelectionText: "Select a vee-validate node to inspect",
+    actions: [
+      {
+        icon: "done_outline",
+        tooltip: "Validate selected item",
+        action: async () => {
+          if (!R) {
+            console.error("There is not a valid selected vee-validate node or component");
+            return;
+          }
+          if (R.type === "field") {
+            await R.field.validate();
+            return;
+          }
+          if (R.type === "form") {
+            await R.form.validate();
+            return;
+          }
+          R.type === "pathState" && await R.form.validateField(R.state.path);
+        }
+      },
+      {
+        icon: "delete_sweep",
+        tooltip: "Clear validation state of the selected item",
+        action: () => {
+          if (!R) {
+            console.error("There is not a valid selected vee-validate node or component");
+            return;
+          }
+          if (R.type === "field") {
+            R.field.resetField();
+            return;
+          }
+          R.type === "form" && R.form.resetForm(), R.type === "pathState" && R.form.resetField(R.state.path);
+        }
+      }
+    ]
+  }), e.on.getInspectorTree((t) => {
+    if (t.inspectorId !== Ae)
+      return;
+    const n = Object.values(Ne), r = Object.values(Me);
+    t.rootNodes = [
+      ...n.map(ir),
+      ...r.map((i) => ar(i))
+    ];
+  }), e.on.getInspectorState((t, n) => {
+    if (t.inspectorId !== Ae || n.currentTab !== `custom-inspector:${Ae}`)
+      return;
+    const { form: r, field: i, state: u, type: o } = ur(t.nodeId);
+    if (r && o === "form") {
+      t.state = or(r), R = { type: "form", form: r };
+      return;
+    }
+    if (u && o === "pathState" && r) {
+      t.state = Tt(u), R = { type: "pathState", state: u, form: r };
+      return;
+    }
+    if (i && o === "field") {
+      t.state = Tt({
+        errors: i.errors.value,
+        dirty: i.meta.dirty,
+        valid: i.meta.valid,
+        touched: i.meta.touched,
+        value: i.value.value,
+        initialValue: i.meta.initialValue
+      }), R = { field: i, type: "field" };
+      return;
+    }
+    R = null;
+  });
+}
+function ir(e) {
+  const { textColor: t, bgColor: n } = Jt(e.meta.value.valid), r = {};
+  Object.values(e.getAllPathStates()).forEach((o) => {
+    ge(r, j(o.path), lr(o, e));
+  });
+  function i(o, d = []) {
+    const c = [...d].pop();
+    return "id" in o ? Object.assign(Object.assign({}, o), { label: c || o.label }) : Oe(o) ? {
+      id: `${d.join(".")}`,
+      label: c || "",
+      children: Object.keys(o).map((f) => i(o[f], [...d, f]))
+    } : Array.isArray(o) ? {
+      id: `${d.join(".")}`,
+      label: `${c}[]`,
+      children: o.map((f, g) => i(f, [...d, String(g)]))
+    } : { id: "", label: "", children: [] };
+  }
+  const { children: u } = i(r);
+  return {
+    id: bt(e),
+    label: "Form",
+    children: u,
+    tags: [
+      {
+        label: "Form",
+        textColor: t,
+        backgroundColor: n
+      },
+      {
+        label: `${e.getAllPathStates().length} fields`,
+        textColor: Z.white,
+        backgroundColor: Z.unknown
+      }
+    ]
+  };
+}
+function lr(e, t) {
+  return {
+    id: bt(t, e),
+    label: j(e.path),
+    tags: Qt(e.multiple, e.fieldsCount, e.type, e.valid, t)
+  };
+}
+function ar(e, t) {
+  return {
+    id: bt(t, e),
+    label: j(e.name),
+    tags: Qt(!1, 1, e.type, e.meta.valid, t)
+  };
+}
+function Qt(e, t, n, r, i) {
+  const { textColor: u, bgColor: o } = Jt(r);
+  return [
+    e ? void 0 : {
+      label: "Field",
+      textColor: u,
+      backgroundColor: o
+    },
+    i ? 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 bt(e, t) {
+  const n = t ? "path" in t ? "pathState" : "field" : "form", r = t ? "path" in t ? t?.path : j(t?.name) : "", i = { f: e?.formId, ff: r, type: n };
+  return btoa(encodeURIComponent(JSON.stringify(i)));
+}
+function ur(e) {
+  try {
+    const t = JSON.parse(decodeURIComponent(atob(e))), n = Ne[t.f];
+    if (!n && t.ff) {
+      const i = Me[t.ff];
+      return i ? {
+        type: t.type,
+        field: i
+      } : {};
+    }
+    if (!n)
+      return {};
+    const r = n.getPathState(t.ff);
+    return {
+      type: t.type,
+      form: n,
+      state: r
+    };
+  } catch {
+  }
+  return {};
+}
+function Tt(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 or(e) {
+  const { errorBag: t, meta: n, values: r, isSubmitting: i, isValidating: u, submitCount: o } = e;
+  return {
+    "Form state": [
+      {
+        key: "submitCount",
+        value: o.value
+      },
+      {
+        key: "isSubmitting",
+        value: i.value
+      },
+      {
+        key: "isValidating",
+        value: u.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: ie(t.value).reduce((d, c) => {
+          var f;
+          const g = (f = t.value[c]) === null || f === void 0 ? void 0 : f[0];
+          return g && (d[c] = g), d;
+        }, {})
+      }
+    ]
+  };
+}
+function Jt(e) {
+  return {
+    bgColor: e ? Z.success : Z.error,
+    textColor: e ? Z.black : Z.white
+  };
+}
+function sr(e, t, n) {
+  return Re(n?.type) ? cr(e, t, n) : Yt(e, t, n);
+}
+function Yt(e, t, n) {
+  const { initialValue: r, validateOnMount: i, bails: u, type: o, checkedValue: d, label: c, validateOnValueUpdate: f, uncheckedValue: g, controlled: y, keepValueOnUnmount: I, syncVModel: O, form: P } = dr(n), K = y ? Qe(Fe) : void 0, b = P || K, $ = S(() => Te(E(e))), D = S(() => {
+    if (E(b?.schema))
+      return;
+    const V = j(t);
+    return Ge(V) || ce(V) || W(V) || Array.isArray(V) ? V : Wt(V);
+  }), { id: G, value: Q, initialValue: te, meta: T, setState: ue, errors: N, flags: x } = Jn($, {
+    modelValue: r,
+    form: b,
+    bails: u,
+    label: c,
+    type: o,
+    validate: D.value ? re : void 0,
+    schema: ce(t) ? t : void 0
+  }), U = S(() => N.value[0]);
+  O && fr({
+    value: Q,
+    prop: O,
+    handleChange: _,
+    shouldValidate: () => f && !x.pendingReset
+  });
+  const fe = (h, V = !1) => {
+    T.touched = !0, V && ne();
+  };
+  async function he(h) {
+    var V, F;
+    if (b?.validateSchema) {
+      const { results: w } = await b.validateSchema(h);
+      return (V = w[E($)]) !== null && V !== void 0 ? V : { valid: !0, errors: [] };
+    }
+    return D.value ? Gt(Q.value, D.value, {
+      name: E($),
+      label: E(c),
+      values: (F = b?.values) !== null && F !== void 0 ? F : {},
+      bails: u
+    }) : { valid: !0, errors: [] };
+  }
+  const ne = ot(async () => (T.pending = !0, T.validated = !0, he("validated-only")), (h) => (x.pendingUnmount[L.id] || (ue({ errors: h.errors }), T.pending = !1, T.valid = h.valid), h)), J = ot(async () => he("silent"), (h) => (T.valid = h.valid, h));
+  function re(h) {
+    return h?.mode === "silent" ? J() : ne();
+  }
+  function _(h, V = !0) {
+    const F = He(h);
+    Pe(F, V);
+  }
+  Mt(() => {
+    if (i)
+      return ne();
+    (!b || !b.validateSchema) && J();
+  });
+  function Y(h) {
+    T.touched = h;
+  }
+  function le(h) {
+    var V;
+    const F = h && "value" in h ? h.value : te.value;
+    ue({
+      value: C(F),
+      initialValue: C(F),
+      touched: (V = h?.touched) !== null && V !== void 0 ? V : !1,
+      errors: h?.errors || []
+    }), T.pending = !1, T.validated = !1, J();
+  }
+  const pe = Ee();
+  function Pe(h, V = !0) {
+    Q.value = pe && O ? Nn(h, pe.props.modelModifiers) : h, (V ? ne : J)();
+  }
+  function Ue(h) {
+    ue({ errors: Array.isArray(h) ? h : [h] });
+  }
+  const pt = S({
+    get() {
+      return Q.value;
+    },
+    set(h) {
+      Pe(h, f);
+    }
+  }), L = {
+    id: G,
+    name: $,
+    label: c,
+    value: pt,
+    meta: T,
+    errors: N,
+    errorMessage: U,
+    type: o,
+    checkedValue: d,
+    uncheckedValue: g,
+    bails: u,
+    keepValueOnUnmount: I,
+    resetField: le,
+    handleReset: () => le(),
+    validate: re,
+    handleChange: _,
+    handleBlur: fe,
+    setState: ue,
+    setTouched: Y,
+    setErrors: Ue,
+    setValue: Pe
+  };
+  if (Bt(qe, L), $e(t) && typeof j(t) != "function" && be(t, (h, V) => {
+    q(h, V) || (T.validated ? ne() : J());
+  }, {
+    deep: !0
+  }), process.env.NODE_ENV !== "production" && (L._vm = Ee(), be(() => Object.assign(Object.assign({ errors: N.value }, T), { value: Q.value }), we, {
+    deep: !0
+  }), b || nr(L)), !b)
+    return L;
+  const Je = S(() => {
+    const h = D.value;
+    return !h || W(h) || Ge(h) || ce(h) || Array.isArray(h) ? {} : Object.keys(h).reduce((V, F) => {
+      const w = xn(h[F]).map((me) => me.__locatorRef).reduce((me, ve) => {
+        const ae = ee(b.values, ve) || b.values[ve];
+        return ae !== void 0 && (me[ve] = ae), me;
+      }, {});
+      return Object.assign(V, w), V;
+    }, {});
+  });
+  return be(Je, (h, V) => {
+    if (!Object.keys(h).length)
+      return;
+    !q(h, V) && (T.validated ? ne() : J());
+  }), on(() => {
+    var h;
+    const V = (h = E(L.keepValueOnUnmount)) !== null && h !== void 0 ? h : E(b.keepValuesOnUnmount), F = E($);
+    if (V || !b || x.pendingUnmount[L.id]) {
+      b?.removePathState(F, G);
+      return;
+    }
+    x.pendingUnmount[L.id] = !0;
+    const w = b.getPathState(F);
+    if (Array.isArray(w?.id) && w?.multiple ? w?.id.includes(L.id) : w?.id === L.id) {
+      if (w?.multiple && Array.isArray(w.value)) {
+        const ve = w.value.findIndex((ae) => q(ae, E(L.checkedValue)));
+        if (ve > -1) {
+          const ae = [...w.value];
+          ae.splice(ve, 1), b.setFieldValue(F, ae);
+        }
+        Array.isArray(w.id) && w.id.splice(w.id.indexOf(L.id), 1);
+      } else
+        b.unsetPathValue(E($));
+      b.removePathState(F, G);
+    }
+  }), L;
+}
+function dr(e) {
+  const t = () => ({
+    initialValue: void 0,
+    validateOnMount: !1,
+    bails: !0,
+    label: void 0,
+    validateOnValueUpdate: !0,
+    keepValueOnUnmount: void 0,
+    syncVModel: !1,
+    controlled: !0
+  }), n = !!e?.syncVModel, r = typeof e?.syncVModel == "string" ? e.syncVModel : e?.modelPropName || "modelValue", i = n && !("initialValue" in (e || {})) ? dt(Ee(), r) : e?.initialValue;
+  if (!e)
+    return Object.assign(Object.assign({}, t()), { initialValue: i });
+  const u = "valueProp" in e ? e.valueProp : e.checkedValue, o = "standalone" in e ? !e.standalone : e.controlled, d = e?.modelPropName || e?.syncVModel || !1;
+  return Object.assign(Object.assign(Object.assign({}, t()), e || {}), {
+    initialValue: i,
+    controlled: o ?? !0,
+    checkedValue: u,
+    syncVModel: d
+  });
+}
+function cr(e, t, n) {
+  const r = n?.standalone ? void 0 : Qe(Fe), i = n?.checkedValue, u = n?.uncheckedValue;
+  function o(d) {
+    const c = d.handleChange, f = S(() => {
+      const y = E(d.value), I = E(i);
+      return Array.isArray(y) ? y.findIndex((O) => q(O, I)) >= 0 : q(I, y);
+    });
+    function g(y, I = !0) {
+      var O, P;
+      if (f.value === ((O = y?.target) === null || O === void 0 ? void 0 : O.checked)) {
+        I && d.validate();
+        return;
+      }
+      const K = E(e), b = r?.getPathState(K), $ = He(y);
+      let D = (P = E(i)) !== null && P !== void 0 ? P : $;
+      r && b?.multiple && b.type === "checkbox" ? D = wt(ee(r.values, K) || [], D, void 0) : n?.type === "checkbox" && (D = wt(E(d.value), D, E(u))), c(D, I);
+    }
+    return Object.assign(Object.assign({}, d), {
+      checked: f,
+      checkedValue: i,
+      uncheckedValue: u,
+      handleChange: g
+    });
+  }
+  return o(Yt(e, t, n));
+}
+function fr({ prop: e, value: t, handleChange: n, shouldValidate: r }) {
+  const i = Ee();
+  if (!i || !e) {
+    process.env.NODE_ENV !== "production" && console.warn("Failed to setup model events because `useField` was not called in setup.");
+    return;
+  }
+  const u = typeof e == "string" ? e : "modelValue", o = `update:${u}`;
+  u in i.props && (be(t, (d) => {
+    q(d, dt(i, u)) || i.emit(o, d);
+  }), be(() => dt(i, u), (d) => {
+    if (d === We && t.value === void 0)
+      return;
+    const c = d === We ? void 0 : d;
+    q(c, t.value) || n(c, r());
+  }));
+}
+function dt(e, t) {
+  if (e)
+    return e.props[t];
+}
+const vr = /* @__PURE__ */ ct({
+  name: "Field",
+  inheritAttrs: !1,
+  props: {
+    as: {
+      type: [String, Object],
+      default: void 0
+    },
+    name: {
+      type: String,
+      required: !0
+    },
+    rules: {
+      type: [Object, String, Function],
+      default: void 0
+    },
+    validateOnMount: {
+      type: Boolean,
+      default: !1
+    },
+    validateOnBlur: {
+      type: Boolean,
+      default: void 0
+    },
+    validateOnChange: {
+      type: Boolean,
+      default: void 0
+    },
+    validateOnInput: {
+      type: Boolean,
+      default: void 0
+    },
+    validateOnModelUpdate: {
+      type: Boolean,
+      default: void 0
+    },
+    bails: {
+      type: Boolean,
+      default: () => Se().bails
+    },
+    label: {
+      type: String,
+      default: void 0
+    },
+    uncheckedValue: {
+      type: null,
+      default: void 0
+    },
+    modelValue: {
+      type: null,
+      default: We
+    },
+    modelModifiers: {
+      type: null,
+      default: () => ({})
+    },
+    "onUpdate:modelValue": {
+      type: null,
+      default: void 0
+    },
+    standalone: {
+      type: Boolean,
+      default: !1
+    },
+    keepValue: {
+      type: Boolean,
+      default: void 0
+    }
+  },
+  setup(e, t) {
+    const n = _e(e, "rules"), r = _e(e, "name"), i = _e(e, "label"), u = _e(e, "uncheckedValue"), o = _e(e, "keepValue"), { errors: d, value: c, errorMessage: f, validate: g, handleChange: y, handleBlur: I, setTouched: O, resetField: P, handleReset: K, meta: b, checked: $, setErrors: D } = sr(r, n, {
+      validateOnMount: e.validateOnMount,
+      bails: e.bails,
+      standalone: e.standalone,
+      type: t.attrs.type,
+      initialValue: mr(e, t),
+      // Only for checkboxes and radio buttons
+      checkedValue: t.attrs.value,
+      uncheckedValue: u,
+      label: i,
+      validateOnValueUpdate: e.validateOnModelUpdate,
+      keepValueOnUnmount: o,
+      syncVModel: !0
+    }), G = function(x, U = !0) {
+      y(x, U);
+    }, Q = S(() => {
+      const { validateOnInput: N, validateOnChange: x, validateOnBlur: U, validateOnModelUpdate: fe } = hr(e);
+      function he(_) {
+        I(_, U), W(t.attrs.onBlur) && t.attrs.onBlur(_);
+      }
+      function ne(_) {
+        G(_, N), W(t.attrs.onInput) && t.attrs.onInput(_);
+      }
+      function J(_) {
+        G(_, x), W(t.attrs.onChange) && t.attrs.onChange(_);
+      }
+      const re = {
+        name: e.name,
+        onBlur: he,
+        onInput: ne,
+        onChange: J
+      };
+      return re["onUpdate:modelValue"] = (_) => G(_, fe), re;
+    }), te = S(() => {
+      const N = Object.assign({}, Q.value);
+      Re(t.attrs.type) && $ && (N.checked = $.value);
+      const x = Nt(e, t);
+      return Pn(x, t.attrs) && (N.value = c.value), N;
+    }), T = S(() => Object.assign(Object.assign({}, Q.value), { modelValue: c.value }));
+    function ue() {
+      return {
+        field: te.value,
+        componentField: T.value,
+        value: c.value,
+        meta: b,
+        errors: d.value,
+        errorMessage: f.value,
+        validate: g,
+        resetField: P,
+        handleChange: G,
+        handleInput: (N) => G(N, !1),
+        handleReset: K,
+        handleBlur: Q.value.onBlur,
+        setTouched: O,
+        setErrors: D
+      };
+    }
+    return t.expose({
+      value: c,
+      meta: b,
+      errors: d,
+      errorMessage: f,
+      setErrors: D,
+      setTouched: O,
+      reset: P,
+      validate: g,
+      handleChange: y
+    }), () => {
+      const N = ft(Nt(e, t)), x = yt(N, t, ue);
+      return N ? Le(N, Object.assign(Object.assign({}, t.attrs), te.value), x) : x;
+    };
+  }
+});
+function Nt(e, t) {
+  let n = e.as || "";
+  return !e.as && !t.slots.default && (n = "input"), n;
+}
+function hr(e) {
+  var t, n, r, i;
+  const { validateOnInput: u, validateOnChange: o, validateOnBlur: d, validateOnModelUpdate: c } = Se();
+  return {
+    validateOnInput: (t = e.validateOnInput) !== null && t !== void 0 ? t : u,
+    validateOnChange: (n = e.validateOnChange) !== null && n !== void 0 ? n : o,
+    validateOnBlur: (r = e.validateOnBlur) !== null && r !== void 0 ? r : d,
+    validateOnModelUpdate: (i = e.validateOnModelUpdate) !== null && i !== void 0 ? i : c
+  };
+}
+function mr(e, t) {
+  return Re(t.attrs.type) ? jt(e, "modelValue") ? e.modelValue : void 0 : jt(e, "modelValue") ? e.modelValue : t.attrs.value;
+}
+const wr = vr;
+let gr = 0;
+const xe = ["bails", "fieldsCount", "id", "multiple", "type", "validate"];
+function Xt(e) {
+  const t = Object.assign({}, E(e?.initialValues || {})), n = j(e?.validationSchema);
+  return n && ce(n) && W(n.cast) ? C(n.cast(t) || {}) : C(t);
+}
+function yr(e) {
+  var t;
+  const n = gr++;
+  let r = 0;
+  const i = de(!1), u = de(!1), o = de(0), d = [], c = ze(Xt(e)), f = de([]), g = de({}), y = de({}), I = Mn(() => {
+    y.value = f.value.reduce((a, l) => (a[Te(E(l.path))] = l, a), {});
+  });
+  function O(a, l) {
+    const s = _(a);
+    if (!s) {
+      typeof a == "string" && (g.value[Te(a)] = st(l));
+      return;
+    }
+    if (typeof a == "string") {
+      const v = Te(a);
+      g.value[v] && delete g.value[v];
+    }
+    s.errors = st(l), s.valid = !s.errors.length;
+  }
+  function P(a) {
+    ie(a).forEach((l) => {
+      O(l, a[l]);
+    });
+  }
+  e?.initialErrors && P(e.initialErrors);
+  const K = S(() => {
+    const a = f.value.reduce((l, s) => (s.errors.length && (l[s.path] = s.errors), l), {});
+    return Object.assign(Object.assign({}, g.value), a);
+  }), b = S(() => ie(K.value).reduce((a, l) => {
+    const s = K.value[l];
+    return s?.length && (a[l] = s[0]), a;
+  }, {})), $ = S(() => f.value.reduce((a, l) => (a[l.path] = { name: l.path || "", label: l.label || "" }, a), {})), D = S(() => f.value.reduce((a, l) => {
+    var s;
+    return a[l.path] = (s = l.bails) !== null && s !== void 0 ? s : !0, a;
+  }, {})), G = Object.assign({}, e?.initialErrors || {}), Q = (t = e?.keepValuesOnUnmount) !== null && t !== void 0 ? t : !1, { initialValues: te, originalInitialValues: T, setInitialValues: ue } = pr(f, c, e), N = br(f, c, T, b), x = S(() => f.value.reduce((a, l) => {
+    const s = ee(c, l.path);
+    return ge(a, l.path, s), a;
+  }, {})), U = e?.validationSchema;
+  function fe(a, l) {
+    var s, v;
+    const p = S(() => ee(te.value, E(a))), m = y.value[E(a)], A = l?.type === "checkbox" || l?.type === "radio";
+    if (m && A) {
+      m.multiple = !0;
+      const oe = r++;
+      return Array.isArray(m.id) ? m.id.push(oe) : m.id = [m.id, oe], m.fieldsCount++, m.__flags.pendingUnmount[oe] = !1, m;
+    }
+    const M = S(() => ee(c, E(a))), B = E(a), H = le.findIndex((oe) => oe === B);
+    H !== -1 && le.splice(H, 1);
+    const k = S(() => {
+      var oe, ke, tt, St, nt, rt;
+      return ce(U) ? (tt = (ke = (oe = U).describe) === null || ke === void 0 ? void 0 : ke.call(oe, E(a)).required) !== null && tt !== void 0 ? tt : !1 : ce(l?.schema) && (rt = (nt = (St = l?.schema).describe) === null || nt === void 0 ? void 0 : nt.call(St).required) !== null && rt !== void 0 ? rt : !1;
+    }), z = r++, X = ze({
+      id: z,
+      path: a,
+      touched: !1,
+      pending: !1,
+      valid: !0,
+      validated: !!(!((s = G[B]) === null || s === void 0) && s.length),
+      required: k,
+      initialValue: p,
+      errors: cn([]),
+      bails: (v = l?.bails) !== null && v !== void 0 ? v : !1,
+      label: l?.label,
+      type: l?.type || "default",
+      value: M,
+      multiple: !1,
+      __flags: {
+        pendingUnmount: { [z]: !1 },
+        pendingReset: !1
+      },
+      fieldsCount: 1,
+      validate: l?.validate,
+      dirty: S(() => !q(j(M), j(p)))
+    });
+    return f.value.push(X), y.value[B] = X, I(), b.value[B] && !G[B] && se(() => {
+      Ve(B, { mode: "silent" });
+    }), $e(a) && be(a, (oe) => {
+      I();
+      const ke = C(M.value);
+      y.value[oe] = X, se(() => {
+        ge(c, oe, ke);
+      });
+    }), X;
+  }
+  const he = Ft(_t, 5), ne = Ft(_t, 5), J = ot(async (a) => await (a === "silent" ? he() : ne()), (a, [l]) => {
+    const s = ie(V.errorBag.value), p = [
+      .../* @__PURE__ */ new Set([...ie(a.results), ...f.value.map((m) => m.path), ...s])
+    ].sort().reduce((m, A) => {
+      var M;
+      const B = A, H = _(B) || Y(B), k = ((M = a.results[B]) === null || M === void 0 ? void 0 : M.errors) || [], z = E(H?.path) || B, X = Or({ errors: k, valid: !k.length }, m.results[z]);
+      return m.results[z] = X, X.valid || (m.errors[z] = X.errors[0]), H && g.value[z] && delete g.value[z], H ? (H.valid = X.valid, l === "silent" || l === "validated-only" && !H.validated || O(H, X.errors), m) : (O(z, k), m);
+    }, { valid: a.valid, results: {}, errors: {} });
+    return a.values && (p.values = a.values), p;
+  });
+  function re(a) {
+    f.value.forEach(a);
+  }
+  function _(a) {
+    const l = typeof a == "string" ? Te(a) : a;
+    return typeof l == "string" ? y.value[l] : l;
+  }
+  function Y(a) {
+    return f.value.filter((s) => a.startsWith(s.path)).reduce((s, v) => s ? v.path.length > s.path.length ? v : s : v, void 0);
+  }
+  let le = [], pe;
+  function Pe(a) {
+    return le.push(a), pe || (pe = se(() => {
+      [...le].sort().reverse().forEach((s) => {
+        Ct(c, s);
+      }), le = [], pe = null;
+    })), pe;
+  }
+  function Ue(a) {
+    return function(s, v) {
+      return function(m) {
+        return m instanceof Event && (m.preventDefault(), m.stopPropagation()), re((A) => A.touched = !0), i.value = !0, o.value++, Ie().then((A) => {
+          const M = C(c);
+          if (A.valid && typeof s == "function") {
+            const B = C(x.value);
+            let H = a ? B : M;
+            return A.values && (H = A.values), s(H, {
+              evt: m,
+              controlledValues: B,
+              setErrors: P,
+              setFieldError: O,
+              setTouched: Ye,
+              setFieldTouched: ae,
+              setValues: me,
+              setFieldValue: F,
+              resetForm: Xe,
+              resetField: Ot
+            });
+          }
+          !A.valid && typeof v == "function" && v({
+            values: M,
+            evt: m,
+            errors: A.errors,
+            results: A.results
+          });
+        }).then((A) => (i.value = !1, A), (A) => {
+          throw i.value = !1, A;
+        });
+      };
+    };
+  }
+  const L = Ue(!1);
+  L.withControlled = Ue(!0);
+  function Je(a, l) {
+    const s = f.value.findIndex((p) => p.path === a), v = f.value[s];
+    if (!(s === -1 || !v)) {
+      if (se(() => {
+        Ve(a, { mode: "silent", warn: !1 });
+      }), v.multiple && v.fieldsCount && v.fieldsCount--, Array.isArray(v.id)) {
+        const p = v.id.indexOf(l);
+        p >= 0 && v.id.splice(p, 1), delete v.__flags.pendingUnmount[l];
+      }
+      (!v.multiple || v.fieldsCount <= 0) && (f.value.splice(s, 1), Vt(a), I(), delete y.value[a]);
+    }
+  }
+  function h(a) {
+    ie(y.value).forEach((l) => {
+      l.startsWith(a) && delete y.value[l];
+    }), f.value = f.value.filter((l) => !l.path.startsWith(a)), se(() => {
+      I();
+    });
+  }
+  const V = {
+    formId: n,
+    values: c,
+    controlledValues: x,
+    errorBag: K,
+    errors: b,
+    schema: U,
+    submitCount: o,
+    meta: N,
+    isSubmitting: i,
+    isValidating: u,
+    fieldArrays: d,
+    keepValuesOnUnmount: Q,
+    validateSchema: j(U) ? J : void 0,
+    validate: Ie,
+    setFieldError: O,
+    validateField: Ve,
+    setFieldValue: F,
+    setValues: me,
+    setErrors: P,
+    setFieldTouched: ae,
+    setTouched: Ye,
+    resetForm: Xe,
+    resetField: Ot,
+    handleSubmit: L,
+    useFieldModel: ln,
+    defineInputBinds: an,
+    defineComponentBinds: un,
+    defineField: et,
+    stageInitialValue: nn,
+    unsetInitialValue: Vt,
+    setFieldInitialValue: Ze,
+    createPathState: fe,
+    getPathState: _,
+    unsetPathValue: Pe,
+    removePathState: Je,
+    initialValues: te,
+    getAllPathStates: () => f.value,
+    destroyPath: h,
+    isFieldTouched: Zt,
+    isFieldDirty: en,
+    isFieldValid: tn
+  };
+  function F(a, l, s = !0) {
+    const v = C(l), p = typeof a == "string" ? a : a.path;
+    _(p) || fe(p), ge(c, p, v), s && Ve(p);
+  }
+  function w(a, l = !0) {
+    ie(c).forEach((s) => {
+      delete c[s];
+    }), ie(a).forEach((s) => {
+      F(s, a[s], !1);
+    }), l && Ie();
+  }
+  function me(a, l = !0) {
+    Be(c, a), d.forEach((s) => s && s.reset()), l && Ie();
+  }
+  function ve(a, l) {
+    const s = _(E(a)) || fe(a);
+    return S({
+      get() {
+        return s.value;
+      },
+      set(v) {
+        var p;
+        const m = E(a);
+        F(m, v, (p = E(l)) !== null && p !== void 0 ? p : !1);
+      }
+    });
+  }
+  function ae(a, l) {
+    const s = _(a);
+    s && (s.touched = l);
+  }
+  function Zt(a) {
+    const l = _(a);
+    return l ? l.touched : f.value.filter((s) => s.path.startsWith(a)).some((s) => s.touched);
+  }
+  function en(a) {
+    const l = _(a);
+    return l ? l.dirty : f.value.filter((s) => s.path.startsWith(a)).some((s) => s.dirty);
+  }
+  function tn(a) {
+    const l = _(a);
+    return l ? l.valid : f.value.filter((s) => s.path.startsWith(a)).every((s) => s.valid);
+  }
+  function Ye(a) {
+    if (typeof a == "boolean") {
+      re((l) => {
+        l.touched = a;
+      });
+      return;
+    }
+    ie(a).forEach((l) => {
+      ae(l, !!a[l]);
+    });
+  }
+  function Ot(a, l) {
+    var s;
+    const v = l && "value" in l ? l.value : ee(te.value, a), p = _(a);
+    p && (p.__flags.pendingReset = !0), Ze(a, C(v), !0), F(a, v, !1), ae(a, (s = l?.touched) !== null && s !== void 0 ? s : !1), O(a, l?.errors || []), se(() => {
+      p && (p.__flags.pendingReset = !1);
+    });
+  }
+  function Xe(a, l) {
+    let s = C(a?.values ? a.values : T.value);
+    s = l?.force ? s : Be(T.value, s), s = ce(U) && W(U.cast) ? U.cast(s) : s, ue(s), re((v) => {
+      var p;
+      v.__flags.pendingReset = !0, v.validated = !1, v.touched = ((p = a?.touched) === null || p === void 0 ? void 0 : p[v.path]) || !1, F(v.path, ee(s, v.path), !1), O(v.path, void 0);
+    }), l?.force ? w(s, !1) : me(s, !1), P(a?.errors || {}), o.value = a?.submitCount || 0, se(() => {
+      Ie({ mode: "silent" }), re((v) => {
+        v.__flags.pendingReset = !1;
+      });
+    });
+  }
+  async function Ie(a) {
+    const l = a?.mode || "force";
+    if (l === "force" && re((m) => m.validated = !0), V.validateSchema)
+      return V.validateSchema(l);
+    u.value = !0;
+    const s = await Promise.all(f.value.map((m) => m.validate ? m.validate(a).then((A) => ({
+      key: m.path,
+      valid: A.valid,
+      errors: A.errors
+    })) : Promise.resolve({
+      key: m.path,
+      valid: !0,
+      errors: []
+    })));
+    u.value = !1;
+    const v = {}, p = {};
+    for (const m of s)
+      v[m.key] = {
+        valid: m.valid,
+        errors: m.errors
+      }, m.errors.length && (p[m.key] = m.errors[0]);
+    return {
+      valid: s.every((m) => m.valid),
+      results: v,
+      errors: p
+    };
+  }
+  async function Ve(a, l) {
+    var s;
+    const v = _(a);
+    if (v && l?.mode !== "silent" && (v.validated = !0), U) {
+      const { results: m } = await J(l?.mode || "validated-only");
+      return m[a] || { errors: [], valid: !0 };
+    }
+    return v?.validate ? v.validate(l) : (!v && ((s = l?.warn) !== null && s !== void 0 ? s : !0) && process.env.NODE_ENV !== "production" && Rt(`field with path ${a} was not found`), Promise.resolve({ errors: [], valid: !0 }));
+  }
+  function Vt(a) {
+    Ct(te.value, a);
+  }
+  function nn(a, l, s = !1) {
+    Ze(a, l), ge(c, a, l), s && !e?.initialValues && ge(T.value, a, C(l));
+  }
+  function Ze(a, l, s = !1) {
+    ge(te.value, a, C(l)), s && ge(T.value, a, C(l));
+  }
+  async function _t() {
+    const a = j(U);
+    if (!a)
+      return { valid: !0, results: {}, errors: {} };
+    u.value = !0;
+    const l = Ge(a) || ce(a) ? await Kn(a, c) : await Qn(a, c, {
+      names: $.value,
+      bailsMap: D.value
+    });
+    return u.value = !1, l;
+  }
+  const rn = L((a, { evt: l }) => {
+    $t(l) && l.target.submit();
+  });
+  Mt(() => {
+    if (e?.initialErrors && P(e.initialErrors), e?.initialTouched && Ye(e.initialTouched), e?.validateOnMount) {
+      Ie();
+      return;
+    }
+    V.validateSchema && V.validateSchema("silent");
+  }), $e(U) && be(U, () => {
+    var a;
+    (a = V.validateSchema) === null || a === void 0 || a.call(V, "validated-only");
+  }), Bt(Fe, V), process.env.NODE_ENV !== "production" && (tr(V), be(() => Object.assign(Object.assign({ errors: K.value }, N.value), { values: c, isSubmitting: i.value, isValidating: u.value, submitCount: o.value }), we, {
+    deep: !0
+  }));
+  function et(a, l) {
+    const s = W(l) ? void 0 : l?.label, v = _(E(a)) || fe(a, { label: s }), p = () => W(l) ? l(De(v, xe)) : l || {};
+    function m() {
+      var k;
+      v.touched = !0, ((k = p().validateOnBlur) !== null && k !== void 0 ? k : Se().validateOnBlur) && Ve(v.path);
+    }
+    function A() {
+      var k;
+      ((k = p().validateOnInput) !== null && k !== void 0 ? k : Se().validateOnInput) && se(() => {
+        Ve(v.path);
+      });
+    }
+    function M() {
+      var k;
+      ((k = p().validateOnChange) !== null && k !== void 0 ? k : Se().validateOnChange) && se(() => {
+        Ve(v.path);
+      });
+    }
+    const B = S(() => {
+      const k = {
+        onChange: M,
+        onInput: A,
+        onBlur: m
+      };
+      return W(l) ? Object.assign(Object.assign({}, k), l(De(v, xe)).props || {}) : l?.props ? Object.assign(Object.assign({}, k), l.props(De(v, xe))) : k;
+    });
+    return [ve(a, () => {
+      var k, z, X;
+      return (X = (k = p().validateOnModelUpdate) !== null && k !== void 0 ? k : (z = Se()) === null || z === void 0 ? void 0 : z.validateOnModelUpdate) !== null && X !== void 0 ? X : !0;
+    }), B];
+  }
+  function ln(a) {
+    return Array.isArray(a) ? a.map((l) => ve(l, !0)) : ve(a);
+  }
+  function an(a, l) {
+    const [s, v] = et(a, l);
+    function p(M) {
+      v.value.onBlur(M);
+    }
+    function m(M) {
+      const B = He(M);
+      F(E(a), B, !1), v.value.onInput(M);
+    }
+    function A(M) {
+      const B = He(M);
+      F(E(a), B, !1), v.value.onChange(M);
+    }
+    return S(() => Object.assign(Object.assign({}, v.value), {
+      onBlur: p,
+      onInput: m,
+      onChange: A,
+      value: s.value
+    }));
+  }
+  function un(a, l) {
+    const [s, v] = et(a, l), p = _(E(a));
+    function m(A) {
+      s.value = A;
+    }
+    return S(() => {
+      const A = W(l) ? l(De(p, xe)) : l || {};
+      return Object.assign({ [A.model || "modelValue"]: s.value, [`onUpdate:${A.model || "modelValue"}`]: m }, v.value);
+    });
+  }
+  return Object.assign(Object.assign({}, V), { values: sn(c), handleReset: () => Xe(), submitForm: rn });
+}
+function br(e, t, n, r) {
+  const i = {
+    touched: "some",
+    pending: "some",
+    valid: "every"
+  }, u = S(() => !q(t, j(n)));
+  function o() {
+    const c = e.value;
+    return ie(i).reduce((f, g) => {
+      const y = i[g];
+      return f[g] = c[y]((I) => I[g]), f;
+    }, {});
+  }
+  const d = ze(o());
+  return dn(() => {
+    const c = o();
+    d.touched = c.touched, d.valid = c.valid, d.pending = c.pending;
+  }), S(() => Object.assign(Object.assign({ initialValues: j(n) }, d), { valid: d.valid && !ie(r.value).length, dirty: u.value }));
+}
+function pr(e, t, n) {
+  const r = Xt(n), i = de(r), u = de(C(r));
+  function o(d, c = !1) {
+    i.value = Be(C(i.value) || {}, C(d)), u.value = Be(C(u.value) || {}, C(d)), c && e.value.forEach((f) => {
+      if (f.touched)
+        return;
+      const y = ee(i.value, f.path);
+      ge(t, f.path, C(y));
+    });
+  }
+  return {
+    initialValues: i,
+    originalInitialValues: u,
+    setInitialValues: o
+  };
+}
+function Or(e, t) {
+  return t ? {
+    valid: e.valid && t.valid,
+    errors: [...e.errors, ...t.errors]
+  } : e;
+}
+const Vr = /* @__PURE__ */ ct({
+  name: "Form",
+  inheritAttrs: !1,
+  props: {
+    as: {
+      type: null,
+      default: "form"
+    },
+    validationSchema: {
+      type: Object,
+      default: void 0
+    },
+    initialValues: {
+      type: Object,
+      default: void 0
+    },
+    initialErrors: {
+      type: Object,
+      default: void 0
+    },
+    initialTouched: {
+      type: Object,
+      default: void 0
+    },
+    validateOnMount: {
+      type: Boolean,
+      default: !1
+    },
+    onSubmit: {
+      type: Function,
+      default: void 0
+    },
+    onInvalidSubmit: {
+      type: Function,
+      default: void 0
+    },
+    keepValues: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(e, t) {
+    const n = _e(e, "validationSchema"), r = _e(e, "keepValues"), { errors: i, errorBag: u, values: o, meta: d, isSubmitting: c, isValidating: f, submitCount: g, controlledValues: y, validate: I, validateField: O, handleReset: P, resetForm: K, handleSubmit: b, setErrors: $, setFieldError: D, setFieldValue: G, setValues: Q, setFieldTouched: te, setTouched: T, resetField: ue } = yr({
+      validationSchema: n.value ? n : void 0,
+      initialValues: e.initialValues,
+      initialErrors: e.initialErrors,
+      initialTouched: e.initialTouched,
+      validateOnMount: e.validateOnMount,
+      keepValuesOnUnmount: r
+    }), N = b((_, { evt: Y }) => {
+      $t(Y) && Y.target.submit();
+    }, e.onInvalidSubmit), x = e.onSubmit ? b(e.onSubmit, e.onInvalidSubmit) : N;
+    function U(_) {
+      ht(_) && _.preventDefault(), P(), typeof t.attrs.onReset == "function" && t.attrs.onReset();
+    }
+    function fe(_, Y) {
+      return b(typeof _ == "function" && !Y ? _ : Y, e.onInvalidSubmit)(_);
+    }
+    function he() {
+      return C(o);
+    }
+    function ne() {
+      return C(d.value);
+    }
+    function J() {
+      return C(i.value);
+    }
+    function re() {
+      return {
+        meta: d.value,
+        errors: i.value,
+        errorBag: u.value,
+        values: o,
+        isSubmitting: c.value,
+        isValidating: f.value,
+        submitCount: g.value,
+        controlledValues: y.value,
+        validate: I,
+        validateField: O,
+        handleSubmit: fe,
+        handleReset: P,
+        submitForm: N,
+        setErrors: $,
+        setFieldError: D,
+        setFieldValue: G,
+        setValues: Q,
+        setFieldTouched: te,
+        setTouched: T,
+        resetForm: K,
+        resetField: ue,
+        getValues: he,
+        getMeta: ne,
+        getErrors: J
+      };
+    }
+    return t.expose({
+      setFieldError: D,
+      setErrors: $,
+      setFieldValue: G,
+      setValues: Q,
+      setFieldTouched: te,
+      setTouched: T,
+      resetForm: K,
+      validate: I,
+      validateField: O,
+      resetField: ue,
+      getValues: he,
+      getMeta: ne,
+      getErrors: J,
+      values: o,
+      meta: d,
+      errors: i
+    }), function() {
+      const Y = e.as === "form" ? e.as : e.as ? ft(e.as) : null, le = yt(Y, t, re);
+      return Y ? Le(Y, Object.assign(Object.assign(Object.assign({}, Y === "form" ? {
+        // Disables native validation as vee-validate will handle it.
+        novalidate: !0
+      } : {}), t.attrs), { onSubmit: x, onReset: U }), le) : le;
+    };
+  }
+}), Fr = Vr, _r = /* @__PURE__ */ ct({
+  name: "ErrorMessage",
+  props: {
+    as: {
+      type: String,
+      default: void 0
+    },
+    name: {
+      type: String,
+      required: !0
+    }
+  },
+  setup(e, t) {
+    const n = Ce(Fe, void 0), r = S(() => n?.errors.value[e.name]);
+    function i() {
+      return {
+        message: r.value
+      };
+    }
+    return () => {
+      if (!r.value)
+        return;
+      const u = e.as ? ft(e.as) : e.as, o = yt(u, t, i), d = Object.assign({ role: "alert" }, t.attrs);
+      return !u && (Array.isArray(o) || !o) && o?.length ? o : (Array.isArray(o) || !o) && !o?.length ? Le(u || "span", d, r.value) : Le(u, d, o);
+    };
+  }
+}), Pr = _r;
+function Sr(e) {
+  const t = gt(e);
+  return S(() => {
+    var n, r;
+    return t && (r = "meta" in t ? t.meta.dirty : (n = t?.value) === null || n === void 0 ? void 0 : n.dirty) !== null && r !== void 0 ? r : !1;
+  });
+}
+function Er(e) {
+  const t = gt(e);
+  return S(() => {
+    var n, r;
+    return t && (r = "meta" in t ? t.meta.touched : (n = t?.value) === null || n === void 0 ? void 0 : n.touched) !== null && r !== void 0 ? r : !1;
+  });
+}
+function Ir(e) {
+  const t = gt(e);
+  return S(() => {
+    var n, r;
+    return t && (r = "meta" in t ? t.meta.valid : (n = t?.value) === null || n === void 0 ? void 0 : n.valid) !== null && r !== void 0 ? r : !1;
+  });
+}
+function jr(e) {
+  const t = Qe(Fe), n = e ? void 0 : Ce(qe);
+  return S(() => e ? t?.errors.value[E(e)] : n?.errorMessage.value);
+}
+function kr() {
+  const e = Ce(qe), t = Ce(fn), n = {
+    valid: Ir(),
+    isDirty: Sr(),
+    isTouched: Er(),
+    error: jr()
+  };
+  if (!e)
+    throw new Error("useFormField should be used within <FormField>");
+  const { name: r } = e, i = t;
+  return {
+    id: i,
+    name: r,
+    formItemId: `${i}-form-item`,
+    formDescriptionId: `${i}-form-item-description`,
+    formMessageId: `${i}-form-item-message`,
+    ...n
+  };
+}
+export {
+  Pr as E,
+  Fr as F,
+  wr as a,
+  kr as u
+};