@soft-stech/bootsman-ui-shadcn 1.1.27 → 1.1.28

package/dist/useFormField-_ngdGlTO.js

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