@soft-stech/bootsman-ui-shadcn 1.0.5-beta.0 → 1.0.5-beta.2

package/dist/bootsman-ui-shadcn141.js

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