@soft-stech/bootsman-ui-shadcn 1.1.5 → 1.1.7

package/dist/useFormField-YDV6_Ldg.js

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