@orchidui/dashboard 1.8.1-93 → 1.8.1-96

package/dist/vee-validate-Cf8JDJ_k.js

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