@fewangsit/wangsvue 1.5.219-alpha.1 → 1.5.219-alpha.2

package/vendor/vee-validate/dist/vee-validate.esm.es.js

@@ -1,1309 +1,2042 @@
-import { ref as Y, reactive as Pe, computed as j, unref as w, onMounted as ft, isRef as Fe, watch as se, provide as vt, toValue as O, readonly as Mt, getCurrentInstance as Ne, onBeforeUnmount as Tt, watchEffect as kt, nextTick as ee, shallowRef as Rt, inject as Ut } from "vue";
+import { ref, reactive, computed, unref, onMounted, isRef, watch, provide, toValue, readonly, getCurrentInstance, onBeforeUnmount, watchEffect, nextTick, shallowRef, inject } from "vue";
 /**
   * vee-validate v4.13.2
   * (c) 2024 Abdelrahman Awad
   * @license MIT
   */
-function x(e) {
-  return typeof e == "function";
-}
-function ht(e) {
-  return e == null;
-}
-const ce = (e) => e !== null && !!e && typeof e == "object" && !Array.isArray(e);
-function Ye(e) {
-  return Number(e) >= 0;
-}
-function Bt(e) {
-  const t = parseFloat(e);
-  return isNaN(t) ? e : t;
-}
-function Dt(e) {
-  return typeof e == "object" && e !== null;
-}
-function zt(e) {
-  return e == null ? e === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(e);
-}
-function rt(e) {
-  if (!Dt(e) || zt(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 Oe(e, t) {
-  return Object.keys(t).forEach((n) => {
-    if (rt(t[n]) && rt(e[n])) {
-      e[n] || (e[n] = {}), Oe(e[n], t[n]);
+function isCallable(fn) {
+  return typeof fn === "function";
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+const isObject = (obj) => obj !== null && !!obj && typeof obj === "object" && !Array.isArray(obj);
+function isIndex(value) {
+  return Number(value) >= 0;
+}
+function toNumber(value) {
+  const n = parseFloat(value);
+  return isNaN(n) ? value : n;
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function getTag(value) {
+  if (value == null) {
+    return value === void 0 ? "[object Undefined]" : "[object Null]";
+  }
+  return Object.prototype.toString.call(value);
+}
+function isPlainObject(value) {
+  if (!isObjectLike(value) || getTag(value) !== "[object Object]") {
+    return false;
+  }
+  if (Object.getPrototypeOf(value) === null) {
+    return true;
+  }
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function merge(target, source) {
+  Object.keys(source).forEach((key) => {
+    if (isPlainObject(source[key]) && isPlainObject(target[key])) {
+      if (!target[key]) {
+        target[key] = {};
+      }
+      merge(target[key], source[key]);
       return;
     }
-    e[n] = t[n];
-  }), e;
+    target[key] = source[key];
+  });
+  return target;
 }
-function be(e) {
-  const t = e.split(".");
-  if (!t.length)
+function normalizeFormPath(path) {
+  const pathArr = path.split(".");
+  if (!pathArr.length) {
     return "";
-  let n = String(t[0]);
-  for (let l = 1; l < t.length; l++) {
-    if (Ye(t[l])) {
-      n += `[${t[l]}]`;
+  }
+  let fullPath = String(pathArr[0]);
+  for (let i = 1; i < pathArr.length; i++) {
+    if (isIndex(pathArr[i])) {
+      fullPath += `[${pathArr[i]}]`;
       continue;
     }
-    n += `.${t[l]}`;
-  }
-  return n;
-}
-const xt = {};
-function Lt(e) {
-  return xt[e];
-}
-function it(e, t, n) {
-  typeof n.value == "object" && (n.value = E(n.value)), !n.enumerable || n.get || n.set || !n.configurable || !n.writable || t === "__proto__" ? Object.defineProperty(e, t, n) : e[t] = n.value;
-}
-function E(e) {
-  if (typeof e != "object") return e;
-  var t = 0, n, l, u, a = Object.prototype.toString.call(e);
-  if (a === "[object Object]" ? u = Object.create(e.__proto__ || null) : a === "[object Array]" ? u = Array(e.length) : a === "[object Set]" ? (u = /* @__PURE__ */ new Set(), e.forEach(function(h) {
-    u.add(E(h));
-  })) : a === "[object Map]" ? (u = /* @__PURE__ */ new Map(), e.forEach(function(h, v) {
-    u.set(E(v), E(h));
-  })) : a === "[object Date]" ? u = /* @__PURE__ */ new Date(+e) : a === "[object RegExp]" ? u = new RegExp(e.source, e.flags) : a === "[object DataView]" ? u = new e.constructor(E(e.buffer)) : a === "[object ArrayBuffer]" ? u = e.slice(0) : a.slice(-6) === "Array]" && (u = new e.constructor(e)), u) {
-    for (l = Object.getOwnPropertySymbols(e); t < l.length; t++)
-      it(u, l[t], Object.getOwnPropertyDescriptor(e, l[t]));
-    for (t = 0, l = Object.getOwnPropertyNames(e); t < l.length; t++)
-      Object.hasOwnProperty.call(u, n = l[t]) && u[n] === e[n] || it(u, n, Object.getOwnPropertyDescriptor(e, n));
-  }
-  return u || e;
-}
-const Xe = Symbol("vee-validate-form"), $t = Symbol("vee-validate-field-instance"), lt = Symbol("Default empty value"), Wt = typeof window < "u";
-function qe(e) {
-  return x(e) && !!e.__locatorRef;
-}
-function X(e) {
-  return !!e && x(e.parse) && e.__type === "VVTypedSchema";
-}
-function Ie(e) {
-  return !!e && x(e.validate);
-}
-function mt(e) {
-  return e === "checkbox" || e === "radio";
-}
-function qt(e) {
-  return ce(e) || Array.isArray(e);
-}
-function Gt(e) {
-  return Array.isArray(e) ? e.length === 0 : ce(e) && Object.keys(e).length === 0;
-}
-function Me(e) {
-  return /^\[.+\]$/i.test(e);
-}
-function Ht(e) {
-  return yt(e) && e.multiple;
-}
-function yt(e) {
-  return e.tagName === "SELECT";
-}
-function Kt(e) {
-  return gt(e) && e.target && "submit" in e.target;
-}
-function gt(e) {
-  return e ? !!(typeof Event < "u" && x(Event) && e instanceof Event || e && e.srcElement) : !1;
-}
-function U(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, l, u;
-    if (Array.isArray(e)) {
-      if (n = e.length, n != t.length)
-        return !1;
-      for (l = n; l-- !== 0; )
-        if (!U(e[l], t[l]))
-          return !1;
-      return !0;
-    }
-    if (e instanceof Map && t instanceof Map) {
-      if (e.size !== t.size)
-        return !1;
-      for (l of e.entries())
-        if (!t.has(l[0]))
-          return !1;
-      for (l of e.entries())
-        if (!U(l[1], t.get(l[0])))
-          return !1;
-      return !0;
-    }
-    if (at(e) && at(t))
-      return !(e.size !== t.size || e.name !== t.name || e.lastModified !== t.lastModified || e.type !== t.type);
-    if (e instanceof Set && t instanceof Set) {
-      if (e.size !== t.size)
-        return !1;
-      for (l of e.entries())
-        if (!t.has(l[0]))
-          return !1;
-      return !0;
-    }
-    if (ArrayBuffer.isView(e) && ArrayBuffer.isView(t)) {
-      if (n = e.length, n != t.length)
-        return !1;
-      for (l = n; l-- !== 0; )
-        if (e[l] !== t[l])
-          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 (u = Object.keys(e), n = u.length, l = n; l-- !== 0; ) {
-      var a = u[l];
-      if (!U(e[a], t[a]))
-        return !1;
-    }
-    return !0;
-  }
-  return e !== e && t !== t;
-}
-function at(e) {
-  return Wt ? e instanceof File : !1;
-}
-function Je(e) {
-  return Me(e) ? e.replace(/\[|\]/gi, "") : e;
-}
-function L(e, t, n) {
-  return e ? Me(t) ? e[Je(t)] : (t || "").split(/\.|\[(\d+)\]/).filter(Boolean).reduce((u, a) => qt(u) && a in u ? u[a] : n, e) : n;
-}
-function re(e, t, n) {
-  if (Me(t)) {
-    e[Je(t)] = n;
+    fullPath += `.${pathArr[i]}`;
+  }
+  return fullPath;
+}
+const RULES = {};
+function resolveRule(id) {
+  return RULES[id];
+}
+function set(obj, key, val) {
+  if (typeof val.value === "object") val.value = klona(val.value);
+  if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") {
+    Object.defineProperty(obj, key, val);
+  } else obj[key] = val.value;
+}
+function klona(x) {
+  if (typeof x !== "object") return x;
+  var i = 0, k, list, tmp, str = Object.prototype.toString.call(x);
+  if (str === "[object Object]") {
+    tmp = Object.create(x.__proto__ || null);
+  } else if (str === "[object Array]") {
+    tmp = Array(x.length);
+  } else if (str === "[object Set]") {
+    tmp = /* @__PURE__ */ new Set();
+    x.forEach(function(val) {
+      tmp.add(klona(val));
+    });
+  } else if (str === "[object Map]") {
+    tmp = /* @__PURE__ */ new Map();
+    x.forEach(function(val, key) {
+      tmp.set(klona(key), klona(val));
+    });
+  } else if (str === "[object Date]") {
+    tmp = /* @__PURE__ */ new Date(+x);
+  } else if (str === "[object RegExp]") {
+    tmp = new RegExp(x.source, x.flags);
+  } else if (str === "[object DataView]") {
+    tmp = new x.constructor(klona(x.buffer));
+  } else if (str === "[object ArrayBuffer]") {
+    tmp = x.slice(0);
+  } else if (str.slice(-6) === "Array]") {
+    tmp = new x.constructor(x);
+  }
+  if (tmp) {
+    for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) {
+      set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
+    }
+    for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
+      if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k]) continue;
+      set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+    }
+  }
+  return tmp || x;
+}
+const FormContextKey = Symbol("vee-validate-form");
+const FieldContextKey = Symbol("vee-validate-field-instance");
+const IS_ABSENT = Symbol("Default empty value");
+const isClient = typeof window !== "undefined";
+function isLocator(value) {
+  return isCallable(value) && !!value.__locatorRef;
+}
+function isTypedSchema(value) {
+  return !!value && isCallable(value.parse) && value.__type === "VVTypedSchema";
+}
+function isYupValidator(value) {
+  return !!value && isCallable(value.validate);
+}
+function hasCheckedAttr(type) {
+  return type === "checkbox" || type === "radio";
+}
+function isContainerValue(value) {
+  return isObject(value) || Array.isArray(value);
+}
+function isEmptyContainer(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return isObject(value) && Object.keys(value).length === 0;
+}
+function isNotNestedPath(path) {
+  return /^\[.+\]$/i.test(path);
+}
+function isNativeMultiSelect(el) {
+  return isNativeSelect(el) && el.multiple;
+}
+function isNativeSelect(el) {
+  return el.tagName === "SELECT";
+}
+function isFormSubmitEvent(evt) {
+  return isEvent(evt) && evt.target && "submit" in evt.target;
+}
+function isEvent(evt) {
+  if (!evt) {
+    return false;
+  }
+  if (typeof Event !== "undefined" && isCallable(Event) && evt instanceof Event) {
+    return true;
+  }
+  if (evt && evt.srcElement) {
+    return true;
+  }
+  return false;
+}
+function isEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    if (a.constructor !== b.constructor)
+      return false;
+    var length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (!isEqual(a[i], b[i]))
+          return false;
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries())
+        if (!b.has(i[0]))
+          return false;
+      for (i of a.entries())
+        if (!isEqual(i[1], b.get(i[0])))
+          return false;
+      return true;
+    }
+    if (isFile(a) && isFile(b)) {
+      if (a.size !== b.size)
+        return false;
+      if (a.name !== b.name)
+        return false;
+      if (a.lastModified !== b.lastModified)
+        return false;
+      if (a.type !== b.type)
+        return false;
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries())
+        if (!b.has(i[0]))
+          return false;
+      return true;
+    }
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (a[i] !== b[i])
+          return false;
+      return true;
+    }
+    if (a.constructor === RegExp)
+      return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf)
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString)
+      return a.toString() === b.toString();
+    keys = Object.keys(a);
+    length = keys.length;
+    for (i = length; i-- !== 0; ) {
+      var key = keys[i];
+      if (!isEqual(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+function isFile(a) {
+  if (!isClient) {
+    return false;
+  }
+  return a instanceof File;
+}
+function cleanupNonNestedPath(path) {
+  if (isNotNestedPath(path)) {
+    return path.replace(/\[|\]/gi, "");
+  }
+  return path;
+}
+function getFromPath(object, path, fallback) {
+  if (!object) {
+    return fallback;
+  }
+  if (isNotNestedPath(path)) {
+    return object[cleanupNonNestedPath(path)];
+  }
+  const resolvedValue = (path || "").split(/\.|\[(\d+)\]/).filter(Boolean).reduce((acc, propKey) => {
+    if (isContainerValue(acc) && propKey in acc) {
+      return acc[propKey];
+    }
+    return fallback;
+  }, object);
+  return resolvedValue;
+}
+function setInPath(object, path, value) {
+  if (isNotNestedPath(path)) {
+    object[cleanupNonNestedPath(path)] = value;
     return;
   }
-  const l = t.split(/\.|\[(\d+)\]/).filter(Boolean);
-  let u = e;
-  for (let a = 0; a < l.length; a++) {
-    if (a === l.length - 1) {
-      u[l[a]] = n;
+  const keys = path.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let acc = object;
+  for (let i = 0; i < keys.length; i++) {
+    if (i === keys.length - 1) {
+      acc[keys[i]] = value;
       return;
     }
-    (!(l[a] in u) || ht(u[l[a]])) && (u[l[a]] = Ye(l[a + 1]) ? [] : {}), u = u[l[a]];
+    if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {
+      acc[keys[i]] = isIndex(keys[i + 1]) ? [] : {};
+    }
+    acc = acc[keys[i]];
   }
 }
-function $e(e, t) {
-  if (Array.isArray(e) && Ye(t)) {
-    e.splice(Number(t), 1);
+function unset(object, key) {
+  if (Array.isArray(object) && isIndex(key)) {
+    object.splice(Number(key), 1);
     return;
   }
-  ce(e) && delete e[t];
+  if (isObject(object)) {
+    delete object[key];
+  }
 }
-function ut(e, t) {
-  if (Me(t)) {
-    delete e[Je(t)];
+function unsetPath(object, path) {
+  if (isNotNestedPath(path)) {
+    delete object[cleanupNonNestedPath(path)];
     return;
   }
-  const n = t.split(/\.|\[(\d+)\]/).filter(Boolean);
-  let l = e;
-  for (let a = 0; a < n.length; a++) {
-    if (a === n.length - 1) {
-      $e(l, n[a]);
+  const keys = path.split(/\.|\[(\d+)\]/).filter(Boolean);
+  let acc = object;
+  for (let i = 0; i < keys.length; i++) {
+    if (i === keys.length - 1) {
+      unset(acc, keys[i]);
       break;
     }
-    if (!(n[a] in l) || ht(l[n[a]]))
+    if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {
       break;
-    l = l[n[a]];
+    }
+    acc = acc[keys[i]];
   }
-  const u = n.map((a, h) => L(e, n.slice(0, h).join(".")));
-  for (let a = u.length - 1; a >= 0; a--)
-    if (Gt(u[a])) {
-      if (a === 0) {
-        $e(e, n[0]);
-        continue;
-      }
-      $e(u[a - 1], n[a - 1]);
+  const pathValues = keys.map((_, idx) => {
+    return getFromPath(object, keys.slice(0, idx).join("."));
+  });
+  for (let i = pathValues.length - 1; i >= 0; i--) {
+    if (!isEmptyContainer(pathValues[i])) {
+      continue;
+    }
+    if (i === 0) {
+      unset(object, keys[0]);
+      continue;
     }
+    unset(pathValues[i - 1], keys[i - 1]);
+  }
 }
-function q(e) {
-  return Object.keys(e);
+function keysOf(record) {
+  return Object.keys(record);
 }
-function pt(e, t = void 0) {
-  const n = Ne();
-  return (n == null ? void 0 : n.provides[e]) || Ut(e, t);
+function injectWithSelf(symbol, def = void 0) {
+  const vm = getCurrentInstance();
+  return (vm === null || vm === void 0 ? void 0 : vm.provides[symbol]) || inject(symbol, def);
 }
-function ot(e, t, n) {
-  if (Array.isArray(e)) {
-    const l = [...e], u = l.findIndex((a) => U(a, t));
-    return u >= 0 ? l.splice(u, 1) : l.push(t), l;
+function resolveNextCheckboxValue(currentValue, checkedValue, uncheckedValue) {
+  if (Array.isArray(currentValue)) {
+    const newVal = [...currentValue];
+    const idx = newVal.findIndex((v) => isEqual(v, checkedValue));
+    idx >= 0 ? newVal.splice(idx, 1) : newVal.push(checkedValue);
+    return newVal;
   }
-  return U(e, t) ? n : t;
-}
-function st(e, t = 0) {
-  let n = null, l = [];
-  return function(...u) {
-    return n && clearTimeout(n), n = setTimeout(() => {
-      const a = e(...u);
-      l.forEach((h) => h(a)), l = [];
-    }, t), new Promise((a) => l.push(a));
+  return isEqual(currentValue, checkedValue) ? uncheckedValue : checkedValue;
+}
+function debounceAsync(inner, ms = 0) {
+  let timer = null;
+  let resolves = [];
+  return function(...args) {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      const result = inner(...args);
+      resolves.forEach((r) => r(result));
+      resolves = [];
+    }, ms);
+    return new Promise((resolve) => resolves.push(resolve));
   };
 }
-function Yt(e, t) {
-  return ce(t) && t.number ? Bt(e) : e;
-}
-function Ge(e, t) {
-  let n;
-  return async function(...u) {
-    const a = e(...u);
-    n = a;
-    const h = await a;
-    return a !== n ? h : (n = void 0, t(h, u));
+function applyModelModifiers(value, modifiers) {
+  if (!isObject(modifiers)) {
+    return value;
+  }
+  if (modifiers.number) {
+    return toNumber(value);
+  }
+  return value;
+}
+function withLatest(fn, onDone) {
+  let latestRun;
+  return async function runLatest(...args) {
+    const pending = fn(...args);
+    latestRun = pending;
+    const result = await pending;
+    if (pending !== latestRun) {
+      return result;
+    }
+    latestRun = void 0;
+    return onDone(result, args);
   };
 }
-function He(e) {
-  return Array.isArray(e) ? e : e ? [e] : [];
+function normalizeErrorItem(message) {
+  return Array.isArray(message) ? message : message ? [message] : [];
 }
-function Ee(e, t) {
-  const n = {};
-  for (const l in e)
-    t.includes(l) || (n[l] = e[l]);
-  return n;
-}
-function Xt(e) {
-  let t = null, n = [];
-  return function(...l) {
-    const u = ee(() => {
-      if (t !== u)
+function omit(obj, keys) {
+  const target = {};
+  for (const key in obj) {
+    if (!keys.includes(key)) {
+      target[key] = obj[key];
+    }
+  }
+  return target;
+}
+function debounceNextTick(inner) {
+  let lastTick = null;
+  let resolves = [];
+  return function(...args) {
+    const thisTick = nextTick(() => {
+      if (lastTick !== thisTick) {
         return;
-      const a = e(...l);
-      n.forEach((h) => h(a)), n = [], t = null;
+      }
+      const result = inner(...args);
+      resolves.forEach((r) => r(result));
+      resolves = [];
+      lastTick = null;
     });
-    return t = u, new Promise((a) => n.push(a));
+    lastTick = thisTick;
+    return new Promise((resolve) => resolves.push(resolve));
   };
 }
-function We(e) {
-  if (bt(e))
-    return e._value;
-}
-function bt(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 Ce(e) {
-  if (!gt(e))
-    return e;
-  const t = e.target;
-  if (mt(t.type) && bt(t))
-    return We(t);
-  if (t.type === "file" && t.files) {
-    const n = Array.from(t.files);
-    return t.multiple ? n : n[0];
-  }
-  if (Ht(t))
-    return Array.from(t.options).filter((n) => n.selected && !n.disabled).map(We);
-  if (yt(t)) {
-    const n = Array.from(t.options).find((l) => l.selected);
-    return n ? We(n) : t.value;
-  }
-  return Jt(t);
-}
-function Vt(e) {
-  const t = {};
-  return Object.defineProperty(t, "_$$isNormalized", {
-    value: !0,
-    writable: !1,
-    enumerable: !1,
-    configurable: !1
-  }), e ? ce(e) && e._$$isNormalized ? e : ce(e) ? Object.keys(e).reduce((n, l) => {
-    const u = Qt(e[l]);
-    return e[l] !== !1 && (n[l] = ct(u)), n;
-  }, t) : typeof e != "string" ? t : e.split("|").reduce((n, l) => {
-    const u = Zt(l);
-    return u.name && (n[u.name] = ct(u.params)), n;
-  }, t) : t;
-}
-function Qt(e) {
-  return e === !0 ? [] : Array.isArray(e) || ce(e) ? e : [e];
-}
-function ct(e) {
-  const t = (n) => typeof n == "string" && n[0] === "@" ? en(n.slice(1)) : n;
-  return Array.isArray(e) ? e.map(t) : e instanceof RegExp ? [e] : Object.keys(e).reduce((n, l) => (n[l] = t(e[l]), n), {});
-}
-const Zt = (e) => {
-  let t = [];
-  const n = e.split(":")[0];
-  return e.includes(":") && (t = e.split(":").slice(1).join(":").split(",")), { name: n, params: t };
+function getBoundValue(el) {
+  if (hasValueBinding(el)) {
+    return el._value;
+  }
+  return void 0;
+}
+function hasValueBinding(el) {
+  return "_value" in el;
+}
+function parseInputValue(el) {
+  if (el.type === "number") {
+    return Number.isNaN(el.valueAsNumber) ? el.value : el.valueAsNumber;
+  }
+  if (el.type === "range") {
+    return Number.isNaN(el.valueAsNumber) ? el.value : el.valueAsNumber;
+  }
+  return el.value;
+}
+function normalizeEventValue(value) {
+  if (!isEvent(value)) {
+    return value;
+  }
+  const input = value.target;
+  if (hasCheckedAttr(input.type) && hasValueBinding(input)) {
+    return getBoundValue(input);
+  }
+  if (input.type === "file" && input.files) {
+    const files = Array.from(input.files);
+    return input.multiple ? files : files[0];
+  }
+  if (isNativeMultiSelect(input)) {
+    return Array.from(input.options).filter((opt) => opt.selected && !opt.disabled).map(getBoundValue);
+  }
+  if (isNativeSelect(input)) {
+    const selectedOption = Array.from(input.options).find((opt) => opt.selected);
+    return selectedOption ? getBoundValue(selectedOption) : input.value;
+  }
+  return parseInputValue(input);
+}
+function normalizeRules(rules) {
+  const acc = {};
+  Object.defineProperty(acc, "_$$isNormalized", {
+    value: true,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  if (!rules) {
+    return acc;
+  }
+  if (isObject(rules) && rules._$$isNormalized) {
+    return rules;
+  }
+  if (isObject(rules)) {
+    return Object.keys(rules).reduce((prev, curr) => {
+      const params = normalizeParams(rules[curr]);
+      if (rules[curr] !== false) {
+        prev[curr] = buildParams(params);
+      }
+      return prev;
+    }, acc);
+  }
+  if (typeof rules !== "string") {
+    return acc;
+  }
+  return rules.split("|").reduce((prev, rule) => {
+    const parsedRule = parseRule(rule);
+    if (!parsedRule.name) {
+      return prev;
+    }
+    prev[parsedRule.name] = buildParams(parsedRule.params);
+    return prev;
+  }, acc);
+}
+function normalizeParams(params) {
+  if (params === true) {
+    return [];
+  }
+  if (Array.isArray(params)) {
+    return params;
+  }
+  if (isObject(params)) {
+    return params;
+  }
+  return [params];
+}
+function buildParams(provided) {
+  const mapValueToLocator = (value) => {
+    if (typeof value === "string" && value[0] === "@") {
+      return createLocator(value.slice(1));
+    }
+    return value;
+  };
+  if (Array.isArray(provided)) {
+    return provided.map(mapValueToLocator);
+  }
+  if (provided instanceof RegExp) {
+    return [provided];
+  }
+  return Object.keys(provided).reduce((prev, key) => {
+    prev[key] = mapValueToLocator(provided[key]);
+    return prev;
+  }, {});
+}
+const parseRule = (rule) => {
+  let params = [];
+  const name = rule.split(":")[0];
+  if (rule.includes(":")) {
+    params = rule.split(":").slice(1).join(":").split(",");
+  }
+  return { name, params };
 };
-function en(e) {
-  const t = (n) => L(n, e) || n[e];
-  return t.__locatorRef = e, t;
-}
-function tn(e) {
-  return Array.isArray(e) ? e.filter(qe) : q(e).filter((t) => qe(e[t])).map((t) => e[t]);
-}
-const nn = {
-  generateMessage: ({ field: e }) => `${e} is not valid.`,
-  bails: !0,
-  validateOnBlur: !0,
-  validateOnChange: !0,
-  validateOnInput: !1,
-  validateOnModelUpdate: !0
+function createLocator(value) {
+  const locator = (crossTable) => {
+    const val = getFromPath(crossTable, value) || crossTable[value];
+    return val;
+  };
+  locator.__locatorRef = value;
+  return locator;
+}
+function extractLocators(params) {
+  if (Array.isArray(params)) {
+    return params.filter(isLocator);
+  }
+  return keysOf(params).filter((key) => isLocator(params[key])).map((key) => params[key]);
+}
+const DEFAULT_CONFIG = {
+  generateMessage: ({ field }) => `${field} is not valid.`,
+  bails: true,
+  validateOnBlur: true,
+  validateOnChange: true,
+  validateOnInput: false,
+  validateOnModelUpdate: true
 };
-let rn = Object.assign({}, nn);
-const Ve = () => rn;
-async function Ot(e, t, n = {}) {
-  const l = n == null ? void 0 : n.bails, u = {
-    name: (n == null ? void 0 : n.name) || "{field}",
-    rules: t,
-    label: n == null ? void 0 : n.label,
-    bails: l ?? !0,
-    formData: (n == null ? void 0 : n.values) || {}
-  }, a = await ln(u, e);
-  return Object.assign(Object.assign({}, a), { valid: !a.errors.length });
-}
-async function ln(e, t) {
-  const n = e.rules;
-  if (X(n) || Ie(n))
-    return un(t, Object.assign(Object.assign({}, e), { rules: n }));
-  if (x(n) || Array.isArray(n)) {
-    const v = {
-      field: e.label || e.name,
-      name: e.name,
-      label: e.label,
-      form: e.formData,
-      value: t
-    }, c = Array.isArray(n) ? n : [n], s = c.length, S = [];
-    for (let b = 0; b < s; b++) {
-      const F = c[b], g = await F(t, v);
-      if (!(typeof g != "string" && !Array.isArray(g) && g)) {
-        if (Array.isArray(g))
-          S.push(...g);
-        else {
-          const J = typeof g == "string" ? g : St(v);
-          S.push(J);
-        }
-        if (e.bails)
-          return {
-            errors: S
-          };
+let currentConfig = Object.assign({}, DEFAULT_CONFIG);
+const getConfig = () => currentConfig;
+async function validate(value, rules, options = {}) {
+  const shouldBail = options === null || options === void 0 ? void 0 : options.bails;
+  const field = {
+    name: (options === null || options === void 0 ? void 0 : options.name) || "{field}",
+    rules,
+    label: options === null || options === void 0 ? void 0 : options.label,
+    bails: shouldBail !== null && shouldBail !== void 0 ? shouldBail : true,
+    formData: (options === null || options === void 0 ? void 0 : options.values) || {}
+  };
+  const result = await _validate(field, value);
+  return Object.assign(Object.assign({}, result), { valid: !result.errors.length });
+}
+async function _validate(field, value) {
+  const rules = field.rules;
+  if (isTypedSchema(rules) || isYupValidator(rules)) {
+    return validateFieldWithTypedSchema(value, Object.assign(Object.assign({}, field), { rules }));
+  }
+  if (isCallable(rules) || Array.isArray(rules)) {
+    const ctx = {
+      field: field.label || field.name,
+      name: field.name,
+      label: field.label,
+      form: field.formData,
+      value
+    };
+    const pipeline = Array.isArray(rules) ? rules : [rules];
+    const length2 = pipeline.length;
+    const errors2 = [];
+    for (let i = 0; i < length2; i++) {
+      const rule = pipeline[i];
+      const result = await rule(value, ctx);
+      const isValid = typeof result !== "string" && !Array.isArray(result) && result;
+      if (isValid) {
+        continue;
+      }
+      if (Array.isArray(result)) {
+        errors2.push(...result);
+      } else {
+        const message = typeof result === "string" ? result : _generateFieldError(ctx);
+        errors2.push(message);
+      }
+      if (field.bails) {
+        return {
+          errors: errors2
+        };
       }
     }
     return {
-      errors: S
+      errors: errors2
     };
   }
-  const l = Object.assign(Object.assign({}, e), { rules: Vt(n) }), u = [], a = Object.keys(l.rules), h = a.length;
-  for (let v = 0; v < h; v++) {
-    const c = a[v], s = await on(l, t, {
-      name: c,
-      params: l.rules[c]
+  const normalizedContext = Object.assign(Object.assign({}, field), { rules: normalizeRules(rules) });
+  const errors = [];
+  const rulesKeys = Object.keys(normalizedContext.rules);
+  const length = rulesKeys.length;
+  for (let i = 0; i < length; i++) {
+    const rule = rulesKeys[i];
+    const result = await _test(normalizedContext, value, {
+      name: rule,
+      params: normalizedContext.rules[rule]
     });
-    if (s.error && (u.push(s.error), e.bails))
-      return {
-        errors: u
-      };
+    if (result.error) {
+      errors.push(result.error);
+      if (field.bails) {
+        return {
+          errors
+        };
+      }
+    }
   }
   return {
-    errors: u
+    errors
   };
 }
-function an(e) {
-  return !!e && e.name === "ValidationError";
+function isYupError(err) {
+  return !!err && err.name === "ValidationError";
 }
-function _t(e) {
-  return {
+function yupToTypedSchema(yupSchema) {
+  const schema = {
     __type: "VVTypedSchema",
-    async parse(n, l) {
-      var u;
+    async parse(values, context) {
+      var _a;
       try {
+        const output = await yupSchema.validate(values, { abortEarly: false, context: (context === null || context === void 0 ? void 0 : context.formData) || {} });
         return {
-          output: await e.validate(n, { abortEarly: !1, context: (l == null ? void 0 : l.formData) || {} }),
+          output,
           errors: []
         };
-      } catch (a) {
-        if (!an(a))
-          throw a;
-        if (!(!((u = a.inner) === null || u === void 0) && u.length) && a.errors.length)
-          return { errors: [{ path: a.path, errors: a.errors }] };
-        const h = a.inner.reduce((v, c) => {
-          const s = c.path || "";
-          return v[s] || (v[s] = { errors: [], path: s }), v[s].errors.push(...c.errors), v;
+      } catch (err) {
+        if (!isYupError(err)) {
+          throw err;
+        }
+        if (!((_a = err.inner) === null || _a === void 0 ? void 0 : _a.length) && err.errors.length) {
+          return { errors: [{ path: err.path, errors: err.errors }] };
+        }
+        const errors = err.inner.reduce((acc, curr) => {
+          const path = curr.path || "";
+          if (!acc[path]) {
+            acc[path] = { errors: [], path };
+          }
+          acc[path].errors.push(...curr.errors);
+          return acc;
         }, {});
-        return { errors: Object.values(h) };
+        return { errors: Object.values(errors) };
       }
     }
   };
-}
-async function un(e, t) {
-  const l = await (X(t.rules) ? t.rules : _t(t.rules)).parse(e, { formData: t.formData }), u = [];
-  for (const a of l.errors)
-    a.errors.length && u.push(...a.errors);
+  return schema;
+}
+async function validateFieldWithTypedSchema(value, context) {
+  const typedSchema = isTypedSchema(context.rules) ? context.rules : yupToTypedSchema(context.rules);
+  const result = await typedSchema.parse(value, { formData: context.formData });
+  const messages = [];
+  for (const error of result.errors) {
+    if (error.errors.length) {
+      messages.push(...error.errors);
+    }
+  }
   return {
-    value: l.value,
-    errors: u
+    value: result.value,
+    errors: messages
   };
 }
-async function on(e, t, n) {
-  const l = Lt(n.name);
-  if (!l)
-    throw new Error(`No such validator '${n.name}' exists.`);
-  const u = sn(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: u })
-  }, h = await l(t, u, a);
-  return typeof h == "string" ? {
-    error: h
-  } : {
-    error: h ? void 0 : St(a)
+async function _test(field, value, rule) {
+  const validator = resolveRule(rule.name);
+  if (!validator) {
+    throw new Error(`No such validator '${rule.name}' exists.`);
+  }
+  const params = fillTargetValues(rule.params, field.formData);
+  const ctx = {
+    field: field.label || field.name,
+    name: field.name,
+    label: field.label,
+    value,
+    form: field.formData,
+    rule: Object.assign(Object.assign({}, rule), { params })
+  };
+  const result = await validator(value, params, ctx);
+  if (typeof result === "string") {
+    return {
+      error: result
+    };
+  }
+  return {
+    error: result ? void 0 : _generateFieldError(ctx)
   };
 }
-function St(e) {
-  const t = Ve().generateMessage;
-  return t ? t(e) : "Field is invalid";
-}
-function sn(e, t) {
-  const n = (l) => qe(l) ? l(t) : l;
-  return Array.isArray(e) ? e.map(n) : Object.keys(e).reduce((l, u) => (l[u] = n(e[u]), l), {});
+function _generateFieldError(fieldCtx) {
+  const message = getConfig().generateMessage;
+  if (!message) {
+    return "Field is invalid";
+  }
+  return message(fieldCtx);
 }
-async function cn(e, t) {
-  const l = await (X(e) ? e : _t(e)).parse(E(t)), u = {}, a = {};
-  for (const h of l.errors) {
-    const v = h.errors, c = (h.path || "").replace(/\["(\d+)"\]/g, (s, S) => `[${S}]`);
-    u[c] = { valid: !v.length, errors: v }, v.length && (a[c] = v[0]);
+function fillTargetValues(params, crossTable) {
+  const normalize = (value) => {
+    if (isLocator(value)) {
+      return value(crossTable);
+    }
+    return value;
+  };
+  if (Array.isArray(params)) {
+    return params.map(normalize);
+  }
+  return Object.keys(params).reduce((acc, param) => {
+    acc[param] = normalize(params[param]);
+    return acc;
+  }, {});
+}
+async function validateTypedSchema(schema, values) {
+  const typedSchema = isTypedSchema(schema) ? schema : yupToTypedSchema(schema);
+  const validationResult = await typedSchema.parse(klona(values));
+  const results = {};
+  const errors = {};
+  for (const error of validationResult.errors) {
+    const messages = error.errors;
+    const path = (error.path || "").replace(/\["(\d+)"\]/g, (_, m) => {
+      return `[${m}]`;
+    });
+    results[path] = { valid: !messages.length, errors: messages };
+    if (messages.length) {
+      errors[path] = messages[0];
+    }
   }
   return {
-    valid: !l.errors.length,
-    results: u,
-    errors: a,
-    values: l.value,
+    valid: !validationResult.errors.length,
+    results,
+    errors,
+    values: validationResult.value,
     source: "schema"
   };
 }
-async function dn(e, t, n) {
-  const u = q(e).map(async (s) => {
-    var S, b, F;
-    const g = (S = n == null ? void 0 : n.names) === null || S === void 0 ? void 0 : S[s], T = await Ot(L(t, s), e[s], {
-      name: (g == null ? void 0 : g.name) || s,
-      label: g == null ? void 0 : g.label,
-      values: t,
-      bails: (F = (b = n == null ? void 0 : n.bailsMap) === null || b === void 0 ? void 0 : b[s]) !== null && F !== void 0 ? F : !0
+async function validateObjectSchema(schema, values, opts) {
+  const paths = keysOf(schema);
+  const validations = paths.map(async (path) => {
+    var _a, _b, _c;
+    const strings = (_a = opts === null || opts === void 0 ? void 0 : opts.names) === null || _a === void 0 ? void 0 : _a[path];
+    const fieldResult = await validate(getFromPath(values, path), schema[path], {
+      name: (strings === null || strings === void 0 ? void 0 : strings.name) || path,
+      label: strings === null || strings === void 0 ? void 0 : strings.label,
+      values,
+      bails: (_c = (_b = opts === null || opts === void 0 ? void 0 : opts.bailsMap) === null || _b === void 0 ? void 0 : _b[path]) !== null && _c !== void 0 ? _c : true
     });
-    return Object.assign(Object.assign({}, T), { path: s });
+    return Object.assign(Object.assign({}, fieldResult), { path });
   });
-  let a = !0;
-  const h = await Promise.all(u), v = {}, c = {};
-  for (const s of h)
-    v[s.path] = {
-      valid: s.valid,
-      errors: s.errors
-    }, s.valid || (a = !1, c[s.path] = s.errors[0]);
+  let isAllValid = true;
+  const validationResults = await Promise.all(validations);
+  const results = {};
+  const errors = {};
+  for (const result of validationResults) {
+    results[result.path] = {
+      valid: result.valid,
+      errors: result.errors
+    };
+    if (!result.valid) {
+      isAllValid = false;
+      errors[result.path] = result.errors[0];
+    }
+  }
   return {
-    valid: a,
-    results: v,
-    errors: c,
+    valid: isAllValid,
+    results,
+    errors,
     source: "schema"
   };
 }
-let dt = 0;
-function fn(e, t) {
-  const { value: n, initialValue: l, setInitialValue: u } = vn(e, t.modelValue, t.form);
-  if (!t.form) {
-    let c = function(g) {
-      var T;
-      "value" in g && (n.value = g.value), "errors" in g && S(g.errors), "touched" in g && (F.touched = (T = g.touched) !== null && T !== void 0 ? T : F.touched), "initialValue" in g && u(g.initialValue);
+let ID_COUNTER = 0;
+function useFieldState(path, init) {
+  const { value, initialValue, setInitialValue } = _useFieldValue(path, init.modelValue, init.form);
+  if (!init.form) {
+    let setState2 = function(state2) {
+      var _a;
+      if ("value" in state2) {
+        value.value = state2.value;
+      }
+      if ("errors" in state2) {
+        setErrors(state2.errors);
+      }
+      if ("touched" in state2) {
+        meta.touched = (_a = state2.touched) !== null && _a !== void 0 ? _a : meta.touched;
+      }
+      if ("initialValue" in state2) {
+        setInitialValue(state2.initialValue);
+      }
     };
-    const { errors: s, setErrors: S } = yn(), b = dt >= Number.MAX_SAFE_INTEGER ? 0 : ++dt, F = mn(n, l, s, t.schema);
+    const { errors: errors2, setErrors } = createFieldErrors();
+    const id = ID_COUNTER >= Number.MAX_SAFE_INTEGER ? 0 : ++ID_COUNTER;
+    const meta = createFieldMeta(value, initialValue, errors2, init.schema);
     return {
-      id: b,
-      path: e,
-      value: n,
-      initialValue: l,
-      meta: F,
-      flags: { pendingUnmount: { [b]: !1 }, pendingReset: !1 },
-      errors: s,
-      setState: c
+      id,
+      path,
+      value,
+      initialValue,
+      meta,
+      flags: { pendingUnmount: { [id]: false }, pendingReset: false },
+      errors: errors2,
+      setState: setState2
     };
   }
-  const a = t.form.createPathState(e, {
-    bails: t.bails,
-    label: t.label,
-    type: t.type,
-    validate: t.validate,
-    schema: t.schema
-  }), h = j(() => a.errors);
-  function v(c) {
-    var s, S, b;
-    "value" in c && (n.value = c.value), "errors" in c && ((s = t.form) === null || s === void 0 || s.setFieldError(w(e), c.errors)), "touched" in c && ((S = t.form) === null || S === void 0 || S.setFieldTouched(w(e), (b = c.touched) !== null && b !== void 0 ? b : !1)), "initialValue" in c && u(c.initialValue);
+  const state = init.form.createPathState(path, {
+    bails: init.bails,
+    label: init.label,
+    type: init.type,
+    validate: init.validate,
+    schema: init.schema
+  });
+  const errors = computed(() => state.errors);
+  function setState(state2) {
+    var _a, _b, _c;
+    if ("value" in state2) {
+      value.value = state2.value;
+    }
+    if ("errors" in state2) {
+      (_a = init.form) === null || _a === void 0 ? void 0 : _a.setFieldError(unref(path), state2.errors);
+    }
+    if ("touched" in state2) {
+      (_b = init.form) === null || _b === void 0 ? void 0 : _b.setFieldTouched(unref(path), (_c = state2.touched) !== null && _c !== void 0 ? _c : false);
+    }
+    if ("initialValue" in state2) {
+      setInitialValue(state2.initialValue);
+    }
   }
   return {
-    id: Array.isArray(a.id) ? a.id[a.id.length - 1] : a.id,
-    path: e,
-    value: n,
-    errors: h,
-    meta: a,
-    initialValue: l,
-    flags: a.__flags,
-    setState: v
+    id: Array.isArray(state.id) ? state.id[state.id.length - 1] : state.id,
+    path,
+    value,
+    errors,
+    meta: state,
+    initialValue,
+    flags: state.__flags,
+    setState
   };
 }
-function vn(e, t, n) {
-  const l = Y(w(t));
-  function u() {
-    return n ? L(n.initialValues.value, w(e), w(l)) : w(l);
+function _useFieldValue(path, modelValue, form) {
+  const modelRef = ref(unref(modelValue));
+  function resolveInitialValue2() {
+    if (!form) {
+      return unref(modelRef);
+    }
+    return getFromPath(form.initialValues.value, unref(path), unref(modelRef));
   }
-  function a(s) {
-    if (!n) {
-      l.value = s;
+  function setInitialValue(value2) {
+    if (!form) {
+      modelRef.value = value2;
       return;
     }
-    n.setFieldInitialValue(w(e), s, !0);
+    form.setFieldInitialValue(unref(path), value2, true);
   }
-  const h = j(u);
-  if (!n)
+  const initialValue = computed(resolveInitialValue2);
+  if (!form) {
+    const value2 = ref(resolveInitialValue2());
     return {
-      value: Y(u()),
-      initialValue: h,
-      setInitialValue: a
+      value: value2,
+      initialValue,
+      setInitialValue
     };
-  const v = hn(t, n, h, e);
-  return n.stageInitialValue(w(e), v, !0), {
-    value: j({
-      get() {
-        return L(n.values, w(e));
-      },
-      set(s) {
-        n.setFieldValue(w(e), s, !1);
-      }
-    }),
-    initialValue: h,
-    setInitialValue: a
+  }
+  const currentValue = resolveModelValue(modelValue, form, initialValue, path);
+  form.stageInitialValue(unref(path), currentValue, true);
+  const value = computed({
+    get() {
+      return getFromPath(form.values, unref(path));
+    },
+    set(newVal) {
+      form.setFieldValue(unref(path), newVal, false);
+    }
+  });
+  return {
+    value,
+    initialValue,
+    setInitialValue
   };
 }
-function hn(e, t, n, l) {
-  return Fe(e) ? w(e) : e !== void 0 ? e : L(t.values, w(l), w(n));
-}
-function mn(e, t, n, l) {
-  const u = j(() => {
-    var h, v, c;
-    return (c = (v = (h = O(l)) === null || h === void 0 ? void 0 : h.describe) === null || v === void 0 ? void 0 : v.call(h).required) !== null && c !== void 0 ? c : !1;
-  }), a = Pe({
-    touched: !1,
-    pending: !1,
-    valid: !0,
-    required: u,
-    validated: !!w(n).length,
-    initialValue: j(() => w(t)),
-    dirty: j(() => !U(w(e), w(t)))
+function resolveModelValue(modelValue, form, initialValue, path) {
+  if (isRef(modelValue)) {
+    return unref(modelValue);
+  }
+  if (modelValue !== void 0) {
+    return modelValue;
+  }
+  return getFromPath(form.values, unref(path), unref(initialValue));
+}
+function createFieldMeta(currentValue, initialValue, errors, schema) {
+  const isRequired = computed(() => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = toValue(schema)) === null || _a === void 0 ? void 0 : _a.describe) === null || _b === void 0 ? void 0 : _b.call(_a).required) !== null && _c !== void 0 ? _c : false;
   });
-  return se(n, (h) => {
-    a.valid = !h.length;
+  const meta = reactive({
+    touched: false,
+    pending: false,
+    valid: true,
+    required: isRequired,
+    validated: !!unref(errors).length,
+    initialValue: computed(() => unref(initialValue)),
+    dirty: computed(() => {
+      return !isEqual(unref(currentValue), unref(initialValue));
+    })
+  });
+  watch(errors, (value) => {
+    meta.valid = !value.length;
   }, {
-    immediate: !0,
+    immediate: true,
     flush: "sync"
-  }), a;
+  });
+  return meta;
 }
-function yn() {
-  const e = Y([]);
+function createFieldErrors() {
+  const errors = ref([]);
   return {
-    errors: e,
-    setErrors: (t) => {
-      e.value = He(t);
+    errors,
+    setErrors: (messages) => {
+      errors.value = normalizeErrorItem(messages);
     }
   };
 }
-function jn(e, t, n) {
-  return mt(n == null ? void 0 : n.type) ? pn(e, t, n) : At(e, t, n);
-}
-function At(e, t, n) {
-  const { initialValue: l, validateOnMount: u, bails: a, type: h, checkedValue: v, label: c, validateOnValueUpdate: s, uncheckedValue: S, controlled: b, keepValueOnUnmount: F, syncVModel: g, form: T } = gn(n), J = b ? pt(Xe) : void 0, _ = T || J, Q = j(() => be(O(e))), $ = j(() => {
-    if (O(_ == null ? void 0 : _.schema))
-      return;
-    const V = w(t);
-    return Ie(V) || X(V) || x(V) || Array.isArray(V) ? V : Vt(V);
-  }), _e = !x($.value) && X(O(t)), { id: he, value: Z, initialValue: le, meta: B, setState: de, errors: me, flags: D } = fn(Q, {
-    modelValue: l,
-    form: _,
-    bails: a,
-    label: c,
-    type: h,
-    validate: $.value ? M : void 0,
-    schema: _e ? t : void 0
-  }), fe = j(() => me.value[0]);
-  g && bn({
-    value: Z,
-    prop: g,
-    handleChange: Ae,
-    shouldValidate: () => s && !D.pendingReset
+function useField(path, rules, opts) {
+  if (hasCheckedAttr(opts === null || opts === void 0 ? void 0 : opts.type)) {
+    return useFieldWithChecked(path, rules, opts);
+  }
+  return _useField(path, rules, opts);
+}
+function _useField(path, rules, opts) {
+  const { initialValue: modelValue, validateOnMount, bails, type, checkedValue, label, validateOnValueUpdate, uncheckedValue, controlled, keepValueOnUnmount, syncVModel, form: controlForm } = normalizeOptions(opts);
+  const injectedForm = controlled ? injectWithSelf(FormContextKey) : void 0;
+  const form = controlForm || injectedForm;
+  const name = computed(() => normalizeFormPath(toValue(path)));
+  const validator = computed(() => {
+    const schema = toValue(form === null || form === void 0 ? void 0 : form.schema);
+    if (schema) {
+      return void 0;
+    }
+    const rulesValue = unref(rules);
+    if (isYupValidator(rulesValue) || isTypedSchema(rulesValue) || isCallable(rulesValue) || Array.isArray(rulesValue)) {
+      return rulesValue;
+    }
+    return normalizeRules(rulesValue);
+  });
+  const isTyped = !isCallable(validator.value) && isTypedSchema(toValue(rules));
+  const { id, value, initialValue, meta, setState, errors, flags } = useFieldState(name, {
+    modelValue,
+    form,
+    bails,
+    label,
+    type,
+    validate: validator.value ? validate$1 : void 0,
+    schema: isTyped ? rules : void 0
   });
-  const Te = (f, V = !1) => {
-    B.touched = !0, V && ie();
+  const errorMessage = computed(() => errors.value[0]);
+  if (syncVModel) {
+    useVModel({
+      value,
+      prop: syncVModel,
+      handleChange,
+      shouldValidate: () => validateOnValueUpdate && !flags.pendingReset
+    });
+  }
+  const handleBlur = (evt, shouldValidate = false) => {
+    meta.touched = true;
+    if (shouldValidate) {
+      validateWithStateMutation();
+    }
   };
-  async function Se(f) {
-    var V, N;
-    if (_ != null && _.validateSchema) {
-      const { results: A } = await _.validateSchema(f);
-      return (V = A[O(Q)]) !== null && V !== void 0 ? V : { valid: !0, errors: [] };
-    }
-    return $.value ? Ot(Z.value, $.value, {
-      name: O(Q),
-      label: O(c),
-      values: (N = _ == null ? void 0 : _.values) !== null && N !== void 0 ? N : {},
-      bails: a
-    }) : { valid: !0, errors: [] };
-  }
-  const ie = Ge(async () => (B.pending = !0, B.validated = !0, Se("validated-only")), (f) => (D.pendingUnmount[W.id] || (de({ errors: f.errors }), B.pending = !1, B.valid = f.valid), f)), G = Ge(async () => Se("silent"), (f) => (B.valid = f.valid, f));
-  function M(f) {
-    return (f == null ? void 0 : f.mode) === "silent" ? G() : ie();
-  }
-  function Ae(f, V = !0) {
-    const N = Ce(f);
-    ve(N, V);
-  }
-  ft(() => {
-    if (u)
-      return ie();
-    (!_ || !_.validateSchema) && G();
+  async function validateCurrentValue(mode) {
+    var _a, _b;
+    if (form === null || form === void 0 ? void 0 : form.validateSchema) {
+      const { results } = await form.validateSchema(mode);
+      return (_a = results[toValue(name)]) !== null && _a !== void 0 ? _a : { valid: true, errors: [] };
+    }
+    if (validator.value) {
+      return validate(value.value, validator.value, {
+        name: toValue(name),
+        label: toValue(label),
+        values: (_b = form === null || form === void 0 ? void 0 : form.values) !== null && _b !== void 0 ? _b : {},
+        bails
+      });
+    }
+    return { valid: true, errors: [] };
+  }
+  const validateWithStateMutation = withLatest(async () => {
+    meta.pending = true;
+    meta.validated = true;
+    return validateCurrentValue("validated-only");
+  }, (result) => {
+    if (flags.pendingUnmount[field.id]) {
+      return result;
+    }
+    setState({ errors: result.errors });
+    meta.pending = false;
+    meta.valid = result.valid;
+    return result;
   });
-  function ae(f) {
-    B.touched = f;
-  }
-  function ue(f) {
-    var V;
-    const N = f && "value" in f ? f.value : le.value;
-    de({
-      value: E(N),
-      initialValue: E(N),
-      touched: (V = f == null ? void 0 : f.touched) !== null && V !== void 0 ? V : !1,
-      errors: (f == null ? void 0 : f.errors) || []
-    }), B.pending = !1, B.validated = !1, G();
-  }
-  const je = Ne();
-  function ve(f, V = !0) {
-    Z.value = je && g ? Yt(f, je.props.modelModifiers) : f, (V ? ie : G)();
-  }
-  function Qe(f) {
-    de({ errors: Array.isArray(f) ? f : [f] });
-  }
-  const ye = j({
+  const validateValidStateOnly = withLatest(async () => {
+    return validateCurrentValue("silent");
+  }, (result) => {
+    meta.valid = result.valid;
+    return result;
+  });
+  function validate$1(opts2) {
+    if ((opts2 === null || opts2 === void 0 ? void 0 : opts2.mode) === "silent") {
+      return validateValidStateOnly();
+    }
+    return validateWithStateMutation();
+  }
+  function handleChange(e, shouldValidate = true) {
+    const newValue = normalizeEventValue(e);
+    setValue(newValue, shouldValidate);
+  }
+  onMounted(() => {
+    if (validateOnMount) {
+      return validateWithStateMutation();
+    }
+    if (!form || !form.validateSchema) {
+      validateValidStateOnly();
+    }
+  });
+  function setTouched(isTouched) {
+    meta.touched = isTouched;
+  }
+  function resetField(state) {
+    var _a;
+    const newValue = state && "value" in state ? state.value : initialValue.value;
+    setState({
+      value: klona(newValue),
+      initialValue: klona(newValue),
+      touched: (_a = state === null || state === void 0 ? void 0 : state.touched) !== null && _a !== void 0 ? _a : false,
+      errors: (state === null || state === void 0 ? void 0 : state.errors) || []
+    });
+    meta.pending = false;
+    meta.validated = false;
+    validateValidStateOnly();
+  }
+  const vm = getCurrentInstance();
+  function setValue(newValue, shouldValidate = true) {
+    value.value = vm && syncVModel ? applyModelModifiers(newValue, vm.props.modelModifiers) : newValue;
+    const validateFn = shouldValidate ? validateWithStateMutation : validateValidStateOnly;
+    validateFn();
+  }
+  function setErrors(errors2) {
+    setState({ errors: Array.isArray(errors2) ? errors2 : [errors2] });
+  }
+  const valueProxy = computed({
     get() {
-      return Z.value;
+      return value.value;
     },
-    set(f) {
-      ve(f, s);
-    }
-  }), W = {
-    id: he,
-    name: Q,
-    label: c,
-    value: ye,
-    meta: B,
-    errors: me,
-    errorMessage: fe,
-    type: h,
-    checkedValue: v,
-    uncheckedValue: S,
-    bails: a,
-    keepValueOnUnmount: F,
-    resetField: ue,
-    handleReset: () => ue(),
-    validate: M,
-    handleChange: Ae,
-    handleBlur: Te,
-    setState: de,
-    setTouched: ae,
-    setErrors: Qe,
-    setValue: ve
+    set(newValue) {
+      setValue(newValue, validateOnValueUpdate);
+    }
+  });
+  const field = {
+    id,
+    name,
+    label,
+    value: valueProxy,
+    meta,
+    errors,
+    errorMessage,
+    type,
+    checkedValue,
+    uncheckedValue,
+    bails,
+    keepValueOnUnmount,
+    resetField,
+    handleReset: () => resetField(),
+    validate: validate$1,
+    handleChange,
+    handleBlur,
+    setState,
+    setTouched,
+    setErrors,
+    setValue
   };
-  if (vt($t, W), Fe(t) && typeof w(t) != "function" && se(t, (f, V) => {
-    U(f, V) || (B.validated ? ie() : G());
-  }, {
-    deep: !0
-  }), !_)
-    return W;
-  const ke = j(() => {
-    const f = $.value;
-    return !f || x(f) || Ie(f) || X(f) || Array.isArray(f) ? {} : Object.keys(f).reduce((V, N) => {
-      const A = tn(f[N]).map((te) => te.__locatorRef).reduce((te, K) => {
-        const ne = L(_.values, K) || _.values[K];
-        return ne !== void 0 && (te[K] = ne), te;
+  provide(FieldContextKey, field);
+  if (isRef(rules) && typeof unref(rules) !== "function") {
+    watch(rules, (value2, oldValue) => {
+      if (isEqual(value2, oldValue)) {
+        return;
+      }
+      meta.validated ? validateWithStateMutation() : validateValidStateOnly();
+    }, {
+      deep: true
+    });
+  }
+  if (!form) {
+    return field;
+  }
+  const dependencies = computed(() => {
+    const rulesVal = validator.value;
+    if (!rulesVal || isCallable(rulesVal) || isYupValidator(rulesVal) || isTypedSchema(rulesVal) || Array.isArray(rulesVal)) {
+      return {};
+    }
+    return Object.keys(rulesVal).reduce((acc, rule) => {
+      const deps = extractLocators(rulesVal[rule]).map((dep) => dep.__locatorRef).reduce((depAcc, depName) => {
+        const depValue = getFromPath(form.values, depName) || form.values[depName];
+        if (depValue !== void 0) {
+          depAcc[depName] = depValue;
+        }
+        return depAcc;
       }, {});
-      return Object.assign(V, A), V;
+      Object.assign(acc, deps);
+      return acc;
     }, {});
   });
-  return se(ke, (f, V) => {
-    if (!Object.keys(f).length)
+  watch(dependencies, (deps, oldDeps) => {
+    if (!Object.keys(deps).length) {
       return;
-    !U(f, V) && (B.validated ? ie() : G());
-  }), Tt(() => {
-    var f;
-    const V = (f = O(W.keepValueOnUnmount)) !== null && f !== void 0 ? f : O(_.keepValuesOnUnmount), N = O(Q);
-    if (V || !_ || D.pendingUnmount[W.id]) {
-      _ == null || _.removePathState(N, he);
+    }
+    const shouldValidate = !isEqual(deps, oldDeps);
+    if (shouldValidate) {
+      meta.validated ? validateWithStateMutation() : validateValidStateOnly();
+    }
+  });
+  onBeforeUnmount(() => {
+    var _a;
+    const shouldKeepValue = (_a = toValue(field.keepValueOnUnmount)) !== null && _a !== void 0 ? _a : toValue(form.keepValuesOnUnmount);
+    const path2 = toValue(name);
+    if (shouldKeepValue || !form || flags.pendingUnmount[field.id]) {
+      form === null || form === void 0 ? void 0 : form.removePathState(path2, id);
       return;
     }
-    D.pendingUnmount[W.id] = !0;
-    const A = _.getPathState(N);
-    if (Array.isArray(A == null ? void 0 : A.id) && (A != null && A.multiple) ? A != null && A.id.includes(W.id) : (A == null ? void 0 : A.id) === W.id) {
-      if (A != null && A.multiple && Array.isArray(A.value)) {
-        const K = A.value.findIndex((ne) => U(ne, O(W.checkedValue)));
-        if (K > -1) {
-          const ne = [...A.value];
-          ne.splice(K, 1), _.setFieldValue(N, ne);
-        }
-        Array.isArray(A.id) && A.id.splice(A.id.indexOf(W.id), 1);
-      } else
-        _.unsetPathValue(O(Q));
-      _.removePathState(N, he);
+    flags.pendingUnmount[field.id] = true;
+    const pathState = form.getPathState(path2);
+    const matchesId = Array.isArray(pathState === null || pathState === void 0 ? void 0 : pathState.id) && (pathState === null || pathState === void 0 ? void 0 : pathState.multiple) ? pathState === null || pathState === void 0 ? void 0 : pathState.id.includes(field.id) : (pathState === null || pathState === void 0 ? void 0 : pathState.id) === field.id;
+    if (!matchesId) {
+      return;
     }
-  }), W;
+    if ((pathState === null || pathState === void 0 ? void 0 : pathState.multiple) && Array.isArray(pathState.value)) {
+      const valueIdx = pathState.value.findIndex((i) => isEqual(i, toValue(field.checkedValue)));
+      if (valueIdx > -1) {
+        const newVal = [...pathState.value];
+        newVal.splice(valueIdx, 1);
+        form.setFieldValue(path2, newVal);
+      }
+      if (Array.isArray(pathState.id)) {
+        pathState.id.splice(pathState.id.indexOf(field.id), 1);
+      }
+    } else {
+      form.unsetPathValue(toValue(name));
+    }
+    form.removePathState(path2, id);
+  });
+  return field;
 }
-function gn(e) {
-  const t = () => ({
+function normalizeOptions(opts) {
+  const defaults = () => ({
     initialValue: void 0,
-    validateOnMount: !1,
-    bails: !0,
+    validateOnMount: false,
+    bails: true,
     label: void 0,
-    validateOnValueUpdate: !0,
+    validateOnValueUpdate: true,
     keepValueOnUnmount: void 0,
-    syncVModel: !1,
-    controlled: !0
-  }), n = !!(e != null && e.syncVModel), l = typeof (e == null ? void 0 : e.syncVModel) == "string" ? e.syncVModel : (e == null ? void 0 : e.modelPropName) || "modelValue", u = n && !("initialValue" in (e || {})) ? Ke(Ne(), l) : e == null ? void 0 : e.initialValue;
-  if (!e)
-    return Object.assign(Object.assign({}, t()), { initialValue: u });
-  const a = "valueProp" in e ? e.valueProp : e.checkedValue, h = "standalone" in e ? !e.standalone : e.controlled, v = (e == null ? void 0 : e.modelPropName) || (e == null ? void 0 : e.syncVModel) || !1;
-  return Object.assign(Object.assign(Object.assign({}, t()), e || {}), {
-    initialValue: u,
-    controlled: h ?? !0,
-    checkedValue: a,
-    syncVModel: v
+    syncVModel: false,
+    controlled: true
+  });
+  const isVModelSynced = !!(opts === null || opts === void 0 ? void 0 : opts.syncVModel);
+  const modelPropName = typeof (opts === null || opts === void 0 ? void 0 : opts.syncVModel) === "string" ? opts.syncVModel : (opts === null || opts === void 0 ? void 0 : opts.modelPropName) || "modelValue";
+  const initialValue = isVModelSynced && !("initialValue" in (opts || {})) ? getCurrentModelValue(getCurrentInstance(), modelPropName) : opts === null || opts === void 0 ? void 0 : opts.initialValue;
+  if (!opts) {
+    return Object.assign(Object.assign({}, defaults()), { initialValue });
+  }
+  const checkedValue = "valueProp" in opts ? opts.valueProp : opts.checkedValue;
+  const controlled = "standalone" in opts ? !opts.standalone : opts.controlled;
+  const syncVModel = (opts === null || opts === void 0 ? void 0 : opts.modelPropName) || (opts === null || opts === void 0 ? void 0 : opts.syncVModel) || false;
+  return Object.assign(Object.assign(Object.assign({}, defaults()), opts || {}), {
+    initialValue,
+    controlled: controlled !== null && controlled !== void 0 ? controlled : true,
+    checkedValue,
+    syncVModel
   });
 }
-function pn(e, t, n) {
-  const l = n != null && n.standalone ? void 0 : pt(Xe), u = n == null ? void 0 : n.checkedValue, a = n == null ? void 0 : n.uncheckedValue;
-  function h(v) {
-    const c = v.handleChange, s = j(() => {
-      const b = O(v.value), F = O(u);
-      return Array.isArray(b) ? b.findIndex((g) => U(g, F)) >= 0 : U(F, b);
+function useFieldWithChecked(name, rules, opts) {
+  const form = !(opts === null || opts === void 0 ? void 0 : opts.standalone) ? injectWithSelf(FormContextKey) : void 0;
+  const checkedValue = opts === null || opts === void 0 ? void 0 : opts.checkedValue;
+  const uncheckedValue = opts === null || opts === void 0 ? void 0 : opts.uncheckedValue;
+  function patchCheckedApi(field) {
+    const handleChange = field.handleChange;
+    const checked = computed(() => {
+      const currentValue = toValue(field.value);
+      const checkedVal = toValue(checkedValue);
+      return Array.isArray(currentValue) ? currentValue.findIndex((v) => isEqual(v, checkedVal)) >= 0 : isEqual(checkedVal, currentValue);
     });
-    function S(b, F = !0) {
-      var g, T;
-      if (s.value === ((g = b == null ? void 0 : b.target) === null || g === void 0 ? void 0 : g.checked)) {
-        F && v.validate();
+    function handleCheckboxChange(e, shouldValidate = true) {
+      var _a, _b;
+      if (checked.value === ((_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.checked)) {
+        if (shouldValidate) {
+          field.validate();
+        }
         return;
       }
-      const J = O(e), _ = l == null ? void 0 : l.getPathState(J), Q = Ce(b);
-      let $ = (T = O(u)) !== null && T !== void 0 ? T : Q;
-      l && (_ != null && _.multiple) && _.type === "checkbox" ? $ = ot(L(l.values, J) || [], $, void 0) : (n == null ? void 0 : n.type) === "checkbox" && ($ = ot(O(v.value), $, O(a))), c($, F);
-    }
-    return Object.assign(Object.assign({}, v), {
-      checked: s,
-      checkedValue: u,
-      uncheckedValue: a,
-      handleChange: S
+      const path = toValue(name);
+      const pathState = form === null || form === void 0 ? void 0 : form.getPathState(path);
+      const value = normalizeEventValue(e);
+      let newValue = (_b = toValue(checkedValue)) !== null && _b !== void 0 ? _b : value;
+      if (form && (pathState === null || pathState === void 0 ? void 0 : pathState.multiple) && pathState.type === "checkbox") {
+        newValue = resolveNextCheckboxValue(getFromPath(form.values, path) || [], newValue, void 0);
+      } else if ((opts === null || opts === void 0 ? void 0 : opts.type) === "checkbox") {
+        newValue = resolveNextCheckboxValue(toValue(field.value), newValue, toValue(uncheckedValue));
+      }
+      handleChange(newValue, shouldValidate);
+    }
+    return Object.assign(Object.assign({}, field), {
+      checked,
+      checkedValue,
+      uncheckedValue,
+      handleChange: handleCheckboxChange
     });
   }
-  return h(At(e, t, n));
+  return patchCheckedApi(_useField(name, rules, opts));
 }
-function bn({ prop: e, value: t, handleChange: n, shouldValidate: l }) {
-  const u = Ne();
-  if (!u || !e)
+function useVModel({ prop, value, handleChange, shouldValidate }) {
+  const vm = getCurrentInstance();
+  if (!vm || !prop) {
     return;
-  const a = typeof e == "string" ? e : "modelValue", h = `update:${a}`;
-  a in u.props && (se(t, (v) => {
-    U(v, Ke(u, a)) || u.emit(h, v);
-  }), se(() => Ke(u, a), (v) => {
-    if (v === lt && t.value === void 0)
+  }
+  const propName = typeof prop === "string" ? prop : "modelValue";
+  const emitName = `update:${propName}`;
+  if (!(propName in vm.props)) {
+    return;
+  }
+  watch(value, (newValue) => {
+    if (isEqual(newValue, getCurrentModelValue(vm, propName))) {
       return;
-    const c = v === lt ? void 0 : v;
-    U(c, t.value) || n(c, l());
-  }));
-}
-function Ke(e, t) {
-  if (e)
-    return e.props[t];
-}
-let Vn = 0;
-const we = ["bails", "fieldsCount", "id", "multiple", "type", "validate"];
-function jt(e) {
-  const n = Object.assign({}, O({})), l = w(void 0);
-  return l && X(l) && x(l.cast) ? E(l.cast(n) || {}) : E(n);
-}
-function En(e) {
-  var t;
-  const n = Vn++;
-  let l = 0;
-  const u = Y(!1), a = Y(!1), h = Y(0), v = [], c = Pe(jt()), s = Y([]), S = Y({}), b = Y({}), F = Xt(() => {
-    b.value = s.value.reduce((i, r) => (i[be(O(r.path))] = r, i), {});
+    }
+    vm.emit(emitName, newValue);
   });
-  function g(i, r) {
-    const o = M(i);
-    if (!o) {
-      typeof i == "string" && (S.value[be(i)] = He(r));
+  watch(() => getCurrentModelValue(vm, propName), (propValue) => {
+    if (propValue === IS_ABSENT && value.value === void 0) {
       return;
     }
-    if (typeof i == "string") {
-      const d = be(i);
-      S.value[d] && delete S.value[d];
+    const newValue = propValue === IS_ABSENT ? void 0 : propValue;
+    if (isEqual(newValue, value.value)) {
+      return;
     }
-    o.errors = He(r), o.valid = !o.errors.length;
+    handleChange(newValue, shouldValidate());
+  });
+}
+function getCurrentModelValue(vm, propName) {
+  if (!vm) {
+    return void 0;
+  }
+  return vm.props[propName];
+}
+let FORM_COUNTER = 0;
+const PRIVATE_PATH_STATE_KEYS = ["bails", "fieldsCount", "id", "multiple", "type", "validate"];
+function resolveInitialValues(opts) {
+  const givenInitial = {};
+  const providedValues = Object.assign({}, toValue(givenInitial));
+  const schema = unref(void 0);
+  if (schema && isTypedSchema(schema) && isCallable(schema.cast)) {
+    return klona(schema.cast(providedValues) || {});
   }
-  function T(i) {
-    q(i).forEach((r) => {
-      g(r, i[r]);
+  return klona(providedValues);
+}
+function useForm(opts) {
+  var _a;
+  const formId = FORM_COUNTER++;
+  let FIELD_ID_COUNTER = 0;
+  const isSubmitting = ref(false);
+  const isValidating = ref(false);
+  const submitCount = ref(0);
+  const fieldArrays = [];
+  const formValues = reactive(resolveInitialValues());
+  const pathStates = ref([]);
+  const extraErrorsBag = ref({});
+  const pathStateLookup = ref({});
+  const rebuildPathLookup = debounceNextTick(() => {
+    pathStateLookup.value = pathStates.value.reduce((names, state) => {
+      names[normalizeFormPath(toValue(state.path))] = state;
+      return names;
+    }, {});
+  });
+  function setFieldError(field, message) {
+    const state = findPathState(field);
+    if (!state) {
+      if (typeof field === "string") {
+        extraErrorsBag.value[normalizeFormPath(field)] = normalizeErrorItem(message);
+      }
+      return;
+    }
+    if (typeof field === "string") {
+      const normalizedPath = normalizeFormPath(field);
+      if (extraErrorsBag.value[normalizedPath]) {
+        delete extraErrorsBag.value[normalizedPath];
+      }
+    }
+    state.errors = normalizeErrorItem(message);
+    state.valid = !state.errors.length;
+  }
+  function setErrors(paths) {
+    keysOf(paths).forEach((path) => {
+      setFieldError(path, paths[path]);
     });
   }
-  const J = j(() => {
-    const i = s.value.reduce((r, o) => (o.errors.length && (r[o.path] = o.errors), r), {});
-    return Object.assign(Object.assign({}, S.value), i);
-  }), _ = j(() => q(J.value).reduce((i, r) => {
-    const o = J.value[r];
-    return o != null && o.length && (i[r] = o[0]), i;
-  }, {})), Q = j(() => s.value.reduce((i, r) => (i[r.path] = { name: r.path || "", label: r.label || "" }, i), {})), $ = j(() => s.value.reduce((i, r) => {
-    var o;
-    return i[r.path] = (o = r.bails) !== null && o !== void 0 ? o : !0, i;
-  }, {})), _e = Object.assign({}, {}), he = (t = void 0) !== null && t !== void 0 ? t : !1, { initialValues: Z, originalInitialValues: le, setInitialValues: B } = _n(s, c), de = On(s, c, le, _), me = j(() => s.value.reduce((i, r) => {
-    const o = L(c, r.path);
-    return re(i, r.path, o), i;
-  }, {})), D = void 0;
-  function fe(i, r) {
-    var o, d;
-    const y = j(() => L(Z.value, O(i))), p = b.value[O(i)], m = (r == null ? void 0 : r.type) === "checkbox" || (r == null ? void 0 : r.type) === "radio";
-    if (p && m) {
-      p.multiple = !0;
-      const H = l++;
-      return Array.isArray(p.id) ? p.id.push(H) : p.id = [p.id, H], p.fieldsCount++, p.__flags.pendingUnmount[H] = !1, p;
-    }
-    const I = j(() => L(c, O(i))), C = O(i), k = ae.findIndex((H) => H === C);
-    k !== -1 && ae.splice(k, 1);
-    const P = j(() => {
-      var H, pe, De, ze;
-      const xe = O(D);
-      if (X(xe))
-        return (pe = (H = xe.describe) === null || H === void 0 ? void 0 : H.call(xe, O(i)).required) !== null && pe !== void 0 ? pe : !1;
-      const Le = O(r == null ? void 0 : r.schema);
-      return X(Le) && (ze = (De = Le.describe) === null || De === void 0 ? void 0 : De.call(Le).required) !== null && ze !== void 0 ? ze : !1;
-    }), R = l++, z = Pe({
-      id: R,
-      path: i,
-      touched: !1,
-      pending: !1,
-      valid: !0,
-      validated: !!(!((o = _e[C]) === null || o === void 0) && o.length),
-      required: P,
-      initialValue: y,
-      errors: Rt([]),
-      bails: (d = r == null ? void 0 : r.bails) !== null && d !== void 0 ? d : !1,
-      label: r == null ? void 0 : r.label,
-      type: (r == null ? void 0 : r.type) || "default",
-      value: I,
-      multiple: !1,
+  const errorBag = computed(() => {
+    const pathErrors = pathStates.value.reduce((acc, state) => {
+      if (state.errors.length) {
+        acc[state.path] = state.errors;
+      }
+      return acc;
+    }, {});
+    return Object.assign(Object.assign({}, extraErrorsBag.value), pathErrors);
+  });
+  const errors = computed(() => {
+    return keysOf(errorBag.value).reduce((acc, key) => {
+      const errors2 = errorBag.value[key];
+      if (errors2 === null || errors2 === void 0 ? void 0 : errors2.length) {
+        acc[key] = errors2[0];
+      }
+      return acc;
+    }, {});
+  });
+  const fieldNames = computed(() => {
+    return pathStates.value.reduce((names, state) => {
+      names[state.path] = { name: state.path || "", label: state.label || "" };
+      return names;
+    }, {});
+  });
+  const fieldBailsMap = computed(() => {
+    return pathStates.value.reduce((map, state) => {
+      var _a2;
+      map[state.path] = (_a2 = state.bails) !== null && _a2 !== void 0 ? _a2 : true;
+      return map;
+    }, {});
+  });
+  const initialErrors = Object.assign({}, {});
+  const keepValuesOnUnmount = (_a = void 0) !== null && _a !== void 0 ? _a : false;
+  const { initialValues, originalInitialValues, setInitialValues } = useFormInitialValues(pathStates, formValues);
+  const meta = useFormMeta(pathStates, formValues, originalInitialValues, errors);
+  const controlledValues = computed(() => {
+    return pathStates.value.reduce((acc, state) => {
+      const value = getFromPath(formValues, state.path);
+      setInPath(acc, state.path, value);
+      return acc;
+    }, {});
+  });
+  const schema = void 0;
+  function createPathState(path, config) {
+    var _a2, _b;
+    const initialValue = computed(() => getFromPath(initialValues.value, toValue(path)));
+    const pathStateExists = pathStateLookup.value[toValue(path)];
+    const isCheckboxOrRadio = (config === null || config === void 0 ? void 0 : config.type) === "checkbox" || (config === null || config === void 0 ? void 0 : config.type) === "radio";
+    if (pathStateExists && isCheckboxOrRadio) {
+      pathStateExists.multiple = true;
+      const id2 = FIELD_ID_COUNTER++;
+      if (Array.isArray(pathStateExists.id)) {
+        pathStateExists.id.push(id2);
+      } else {
+        pathStateExists.id = [pathStateExists.id, id2];
+      }
+      pathStateExists.fieldsCount++;
+      pathStateExists.__flags.pendingUnmount[id2] = false;
+      return pathStateExists;
+    }
+    const currentValue = computed(() => getFromPath(formValues, toValue(path)));
+    const pathValue = toValue(path);
+    const unsetBatchIndex = UNSET_BATCH.findIndex((_path) => _path === pathValue);
+    if (unsetBatchIndex !== -1) {
+      UNSET_BATCH.splice(unsetBatchIndex, 1);
+    }
+    const isRequired = computed(() => {
+      var _a3, _b2, _c, _d;
+      const schemaValue = toValue(schema);
+      if (isTypedSchema(schemaValue)) {
+        return (_b2 = (_a3 = schemaValue.describe) === null || _a3 === void 0 ? void 0 : _a3.call(schemaValue, toValue(path)).required) !== null && _b2 !== void 0 ? _b2 : false;
+      }
+      const configSchemaValue = toValue(config === null || config === void 0 ? void 0 : config.schema);
+      if (isTypedSchema(configSchemaValue)) {
+        return (_d = (_c = configSchemaValue.describe) === null || _c === void 0 ? void 0 : _c.call(configSchemaValue).required) !== null && _d !== void 0 ? _d : false;
+      }
+      return false;
+    });
+    const id = FIELD_ID_COUNTER++;
+    const state = reactive({
+      id,
+      path,
+      touched: false,
+      pending: false,
+      valid: true,
+      validated: !!((_a2 = initialErrors[pathValue]) === null || _a2 === void 0 ? void 0 : _a2.length),
+      required: isRequired,
+      initialValue,
+      errors: shallowRef([]),
+      bails: (_b = config === null || config === void 0 ? void 0 : config.bails) !== null && _b !== void 0 ? _b : false,
+      label: config === null || config === void 0 ? void 0 : config.label,
+      type: (config === null || config === void 0 ? void 0 : config.type) || "default",
+      value: currentValue,
+      multiple: false,
       __flags: {
-        pendingUnmount: { [R]: !1 },
-        pendingReset: !1
+        pendingUnmount: { [id]: false },
+        pendingReset: false
       },
       fieldsCount: 1,
-      validate: r == null ? void 0 : r.validate,
-      dirty: j(() => !U(w(I), w(y)))
+      validate: config === null || config === void 0 ? void 0 : config.validate,
+      dirty: computed(() => {
+        return !isEqual(unref(currentValue), unref(initialValue));
+      })
     });
-    return s.value.push(z), b.value[C] = z, F(), _.value[C] && !_e[C] && ee(() => {
-      oe(C, { mode: "silent" });
-    }), Fe(i) && se(i, (H) => {
-      F();
-      const pe = E(I.value);
-      b.value[H] = z, ee(() => {
-        re(c, H, pe);
+    pathStates.value.push(state);
+    pathStateLookup.value[pathValue] = state;
+    rebuildPathLookup();
+    if (errors.value[pathValue] && !initialErrors[pathValue]) {
+      nextTick(() => {
+        validateField(pathValue, { mode: "silent" });
       });
-    }), z;
-  }
-  const Te = st(nt, 5), Se = st(nt, 5), ie = Ge(async (i) => await (i === "silent" ? Te() : Se()), (i, [r]) => {
-    const o = q(f.errorBag.value), y = [
-      .../* @__PURE__ */ new Set([...q(i.results), ...s.value.map((p) => p.path), ...o])
-    ].sort().reduce((p, m) => {
-      var I;
-      const C = m, k = M(C) || Ae(C), P = ((I = i.results[C]) === null || I === void 0 ? void 0 : I.errors) || [], R = O(k == null ? void 0 : k.path) || C, z = Sn({ errors: P, valid: !P.length }, p.results[R]);
-      return p.results[R] = z, z.valid || (p.errors[R] = z.errors[0]), k && S.value[R] && delete S.value[R], k ? (k.valid = z.valid, r === "silent" || r === "validated-only" && !k.validated || g(k, z.errors), p) : (g(R, P), p);
+    }
+    if (isRef(path)) {
+      watch(path, (newPath) => {
+        rebuildPathLookup();
+        const nextValue = klona(currentValue.value);
+        pathStateLookup.value[newPath] = state;
+        nextTick(() => {
+          setInPath(formValues, newPath, nextValue);
+        });
+      });
+    }
+    return state;
+  }
+  const debouncedSilentValidation = debounceAsync(_validateSchema, 5);
+  const debouncedValidation = debounceAsync(_validateSchema, 5);
+  const validateSchema = withLatest(async (mode) => {
+    return await (mode === "silent" ? debouncedSilentValidation() : debouncedValidation());
+  }, (formResult, [mode]) => {
+    const currentErrorsPaths = keysOf(formCtx.errorBag.value);
+    const paths = [
+      .../* @__PURE__ */ new Set([...keysOf(formResult.results), ...pathStates.value.map((p) => p.path), ...currentErrorsPaths])
+    ].sort();
+    const results = paths.reduce((validation, _path) => {
+      var _a2;
+      const expectedPath = _path;
+      const pathState = findPathState(expectedPath) || findHoistedPath(expectedPath);
+      const messages = ((_a2 = formResult.results[expectedPath]) === null || _a2 === void 0 ? void 0 : _a2.errors) || [];
+      const path = toValue(pathState === null || pathState === void 0 ? void 0 : pathState.path) || expectedPath;
+      const fieldResult = mergeValidationResults({ errors: messages, valid: !messages.length }, validation.results[path]);
+      validation.results[path] = fieldResult;
+      if (!fieldResult.valid) {
+        validation.errors[path] = fieldResult.errors[0];
+      }
+      if (pathState && extraErrorsBag.value[path]) {
+        delete extraErrorsBag.value[path];
+      }
+      if (!pathState) {
+        setFieldError(path, messages);
+        return validation;
+      }
+      pathState.valid = fieldResult.valid;
+      if (mode === "silent") {
+        return validation;
+      }
+      if (mode === "validated-only" && !pathState.validated) {
+        return validation;
+      }
+      setFieldError(pathState, fieldResult.errors);
+      return validation;
     }, {
-      valid: i.valid,
+      valid: formResult.valid,
       results: {},
       errors: {},
-      source: i.source
+      source: formResult.source
+    });
+    if (formResult.values) {
+      results.values = formResult.values;
+      results.source = formResult.source;
+    }
+    keysOf(results.results).forEach((path) => {
+      var _a2;
+      const pathState = findPathState(path);
+      if (!pathState) {
+        return;
+      }
+      if (mode === "silent") {
+        return;
+      }
+      if (mode === "validated-only" && !pathState.validated) {
+        return;
+      }
+      setFieldError(pathState, (_a2 = results.results[path]) === null || _a2 === void 0 ? void 0 : _a2.errors);
     });
-    return i.values && (y.values = i.values, y.source = i.source), q(y.results).forEach((p) => {
-      var m;
-      const I = M(p);
-      I && r !== "silent" && (r === "validated-only" && !I.validated || g(I, (m = y.results[p]) === null || m === void 0 ? void 0 : m.errors));
-    }), y;
+    return results;
   });
-  function G(i) {
-    s.value.forEach(i);
-  }
-  function M(i) {
-    const r = typeof i == "string" ? be(i) : i;
-    return typeof r == "string" ? b.value[r] : r;
-  }
-  function Ae(i) {
-    return s.value.filter((o) => i.startsWith(o.path)).reduce((o, d) => o ? d.path.length > o.path.length ? d : o : d, void 0);
-  }
-  let ae = [], ue;
-  function je(i) {
-    return ae.push(i), ue || (ue = ee(() => {
-      [...ae].sort().reverse().forEach((o) => {
-        ut(c, o);
-      }), ae = [], ue = null;
-    })), ue;
-  }
-  function ve(i) {
-    return function(o, d) {
-      return function(p) {
-        return p instanceof Event && (p.preventDefault(), p.stopPropagation()), G((m) => m.touched = !0), u.value = !0, h.value++, ge().then((m) => {
-          const I = E(c);
-          if (m.valid && typeof o == "function") {
-            const C = E(me.value);
-            let k = i ? C : I;
-            return m.values && (k = m.source === "schema" ? m.values : Object.assign({}, k, m.values)), o(k, {
-              evt: p,
-              controlledValues: C,
-              setErrors: T,
-              setFieldError: g,
-              setTouched: Ze,
-              setFieldTouched: K,
-              setValues: A,
-              setFieldValue: V,
-              resetForm: Re,
-              resetField: et
+  function mutateAllPathState(mutation) {
+    pathStates.value.forEach(mutation);
+  }
+  function findPathState(path) {
+    const normalizedPath = typeof path === "string" ? normalizeFormPath(path) : path;
+    const pathState = typeof normalizedPath === "string" ? pathStateLookup.value[normalizedPath] : normalizedPath;
+    return pathState;
+  }
+  function findHoistedPath(path) {
+    const candidates = pathStates.value.filter((state) => path.startsWith(state.path));
+    return candidates.reduce((bestCandidate, candidate) => {
+      if (!bestCandidate) {
+        return candidate;
+      }
+      return candidate.path.length > bestCandidate.path.length ? candidate : bestCandidate;
+    }, void 0);
+  }
+  let UNSET_BATCH = [];
+  let PENDING_UNSET;
+  function unsetPathValue(path) {
+    UNSET_BATCH.push(path);
+    if (!PENDING_UNSET) {
+      PENDING_UNSET = nextTick(() => {
+        const sortedPaths = [...UNSET_BATCH].sort().reverse();
+        sortedPaths.forEach((p) => {
+          unsetPath(formValues, p);
+        });
+        UNSET_BATCH = [];
+        PENDING_UNSET = null;
+      });
+    }
+    return PENDING_UNSET;
+  }
+  function makeSubmissionFactory(onlyControlled) {
+    return function submitHandlerFactory(fn, onValidationError) {
+      return function submissionHandler(e) {
+        if (e instanceof Event) {
+          e.preventDefault();
+          e.stopPropagation();
+        }
+        mutateAllPathState((s) => s.touched = true);
+        isSubmitting.value = true;
+        submitCount.value++;
+        return validate2().then((result) => {
+          const values = klona(formValues);
+          if (result.valid && typeof fn === "function") {
+            const controlled = klona(controlledValues.value);
+            let submittedValues = onlyControlled ? controlled : values;
+            if (result.values) {
+              submittedValues = result.source === "schema" ? result.values : Object.assign({}, submittedValues, result.values);
+            }
+            return fn(submittedValues, {
+              evt: e,
+              controlledValues: controlled,
+              setErrors,
+              setFieldError,
+              setTouched,
+              setFieldTouched,
+              setValues,
+              setFieldValue,
+              resetForm,
+              resetField
             });
           }
-          !m.valid && typeof d == "function" && d({
-            values: I,
-            evt: p,
-            errors: m.errors,
-            results: m.results
-          });
-        }).then((m) => (u.value = !1, m), (m) => {
-          throw u.value = !1, m;
+          if (!result.valid && typeof onValidationError === "function") {
+            onValidationError({
+              values,
+              evt: e,
+              errors: result.errors,
+              results: result.results
+            });
+          }
+        }).then((returnVal) => {
+          isSubmitting.value = false;
+          return returnVal;
+        }, (err) => {
+          isSubmitting.value = false;
+          throw err;
         });
       };
     };
   }
-  const ye = ve(!1);
-  ye.withControlled = ve(!0);
-  function W(i, r) {
-    const o = s.value.findIndex((y) => y.path === i && (Array.isArray(y.id) ? y.id.includes(r) : y.id === r)), d = s.value[o];
-    if (!(o === -1 || !d)) {
-      if (ee(() => {
-        oe(i, { mode: "silent", warn: !1 });
-      }), d.multiple && d.fieldsCount && d.fieldsCount--, Array.isArray(d.id)) {
-        const y = d.id.indexOf(r);
-        y >= 0 && d.id.splice(y, 1), delete d.__flags.pendingUnmount[r];
+  const handleSubmitImpl = makeSubmissionFactory(false);
+  const handleSubmit = handleSubmitImpl;
+  handleSubmit.withControlled = makeSubmissionFactory(true);
+  function removePathState(path, id) {
+    const idx = pathStates.value.findIndex((s) => {
+      return s.path === path && (Array.isArray(s.id) ? s.id.includes(id) : s.id === id);
+    });
+    const pathState = pathStates.value[idx];
+    if (idx === -1 || !pathState) {
+      return;
+    }
+    nextTick(() => {
+      validateField(path, { mode: "silent", warn: false });
+    });
+    if (pathState.multiple && pathState.fieldsCount) {
+      pathState.fieldsCount--;
+    }
+    if (Array.isArray(pathState.id)) {
+      const idIndex = pathState.id.indexOf(id);
+      if (idIndex >= 0) {
+        pathState.id.splice(idIndex, 1);
       }
-      (!d.multiple || d.fieldsCount <= 0) && (s.value.splice(o, 1), tt(i), F(), delete b.value[i]);
+      delete pathState.__flags.pendingUnmount[id];
+    }
+    if (!pathState.multiple || pathState.fieldsCount <= 0) {
+      pathStates.value.splice(idx, 1);
+      unsetInitialValue(path);
+      rebuildPathLookup();
+      delete pathStateLookup.value[path];
     }
   }
-  function ke(i) {
-    q(b.value).forEach((r) => {
-      r.startsWith(i) && delete b.value[r];
-    }), s.value = s.value.filter((r) => !r.path.startsWith(i)), ee(() => {
-      F();
+  function destroyPath(path) {
+    keysOf(pathStateLookup.value).forEach((key) => {
+      if (key.startsWith(path)) {
+        delete pathStateLookup.value[key];
+      }
+    });
+    pathStates.value = pathStates.value.filter((s) => !s.path.startsWith(path));
+    nextTick(() => {
+      rebuildPathLookup();
     });
   }
-  const f = {
-    formId: n,
-    values: c,
-    controlledValues: me,
-    errorBag: J,
-    errors: _,
-    schema: D,
-    submitCount: h,
-    meta: de,
-    isSubmitting: u,
-    isValidating: a,
-    fieldArrays: v,
-    keepValuesOnUnmount: he,
-    validateSchema: w(D) ? ie : void 0,
-    validate: ge,
-    setFieldError: g,
-    validateField: oe,
-    setFieldValue: V,
-    setValues: A,
-    setErrors: T,
-    setFieldTouched: K,
-    setTouched: Ze,
-    resetForm: Re,
-    resetField: et,
-    handleSubmit: ye,
-    useFieldModel: It,
-    defineInputBinds: Ct,
-    defineComponentBinds: Nt,
-    defineField: Be,
-    stageInitialValue: Pt,
-    unsetInitialValue: tt,
-    setFieldInitialValue: Ue,
-    createPathState: fe,
-    getPathState: M,
-    unsetPathValue: je,
-    removePathState: W,
-    initialValues: Z,
-    getAllPathStates: () => s.value,
-    destroyPath: ke,
-    isFieldTouched: ne,
-    isFieldDirty: Et,
-    isFieldValid: wt
+  const formCtx = {
+    formId,
+    values: formValues,
+    controlledValues,
+    errorBag,
+    errors,
+    schema,
+    submitCount,
+    meta,
+    isSubmitting,
+    isValidating,
+    fieldArrays,
+    keepValuesOnUnmount,
+    validateSchema: unref(schema) ? validateSchema : void 0,
+    validate: validate2,
+    setFieldError,
+    validateField,
+    setFieldValue,
+    setValues,
+    setErrors,
+    setFieldTouched,
+    setTouched,
+    resetForm,
+    resetField,
+    handleSubmit,
+    useFieldModel,
+    defineInputBinds,
+    defineComponentBinds,
+    defineField,
+    stageInitialValue,
+    unsetInitialValue,
+    setFieldInitialValue,
+    createPathState,
+    getPathState: findPathState,
+    unsetPathValue,
+    removePathState,
+    initialValues,
+    getAllPathStates: () => pathStates.value,
+    destroyPath,
+    isFieldTouched,
+    isFieldDirty,
+    isFieldValid
   };
-  function V(i, r, o = !0) {
-    const d = E(r), y = typeof i == "string" ? i : i.path;
-    M(y) || fe(y), re(c, y, d), o && oe(y);
-  }
-  function N(i, r = !0) {
-    q(c).forEach((o) => {
-      delete c[o];
-    }), q(i).forEach((o) => {
-      V(o, i[o], !1);
-    }), r && ge();
-  }
-  function A(i, r = !0) {
-    Oe(c, i), v.forEach((o) => o && o.reset()), r && ge();
-  }
-  function te(i, r) {
-    const o = M(O(i)) || fe(i);
-    return j({
+  function setFieldValue(field, value, shouldValidate = true) {
+    const clonedValue = klona(value);
+    const path = typeof field === "string" ? field : field.path;
+    const pathState = findPathState(path);
+    if (!pathState) {
+      createPathState(path);
+    }
+    setInPath(formValues, path, clonedValue);
+    if (shouldValidate) {
+      validateField(path);
+    }
+  }
+  function forceSetValues(fields, shouldValidate = true) {
+    keysOf(formValues).forEach((key) => {
+      delete formValues[key];
+    });
+    keysOf(fields).forEach((path) => {
+      setFieldValue(path, fields[path], false);
+    });
+    if (shouldValidate) {
+      validate2();
+    }
+  }
+  function setValues(fields, shouldValidate = true) {
+    merge(formValues, fields);
+    fieldArrays.forEach((f) => f && f.reset());
+    if (shouldValidate) {
+      validate2();
+    }
+  }
+  function createModel(path, shouldValidate) {
+    const pathState = findPathState(toValue(path)) || createPathState(path);
+    return computed({
       get() {
-        return o.value;
+        return pathState.value;
       },
-      set(d) {
-        var y;
-        const p = O(i);
-        V(p, d, (y = O(r)) !== null && y !== void 0 ? y : !1);
+      set(value) {
+        var _a2;
+        const pathValue = toValue(path);
+        setFieldValue(pathValue, value, (_a2 = toValue(shouldValidate)) !== null && _a2 !== void 0 ? _a2 : false);
       }
     });
   }
-  function K(i, r) {
-    const o = M(i);
-    o && (o.touched = r);
+  function setFieldTouched(field, isTouched) {
+    const pathState = findPathState(field);
+    if (pathState) {
+      pathState.touched = isTouched;
+    }
   }
-  function ne(i) {
-    const r = M(i);
-    return r ? r.touched : s.value.filter((o) => o.path.startsWith(i)).some((o) => o.touched);
+  function isFieldTouched(field) {
+    const pathState = findPathState(field);
+    if (pathState) {
+      return pathState.touched;
+    }
+    return pathStates.value.filter((s) => s.path.startsWith(field)).some((s) => s.touched);
   }
-  function Et(i) {
-    const r = M(i);
-    return r ? r.dirty : s.value.filter((o) => o.path.startsWith(i)).some((o) => o.dirty);
+  function isFieldDirty(field) {
+    const pathState = findPathState(field);
+    if (pathState) {
+      return pathState.dirty;
+    }
+    return pathStates.value.filter((s) => s.path.startsWith(field)).some((s) => s.dirty);
   }
-  function wt(i) {
-    const r = M(i);
-    return r ? r.valid : s.value.filter((o) => o.path.startsWith(i)).every((o) => o.valid);
+  function isFieldValid(field) {
+    const pathState = findPathState(field);
+    if (pathState) {
+      return pathState.valid;
+    }
+    return pathStates.value.filter((s) => s.path.startsWith(field)).every((s) => s.valid);
   }
-  function Ze(i) {
-    if (typeof i == "boolean") {
-      G((r) => {
-        r.touched = i;
+  function setTouched(fields) {
+    if (typeof fields === "boolean") {
+      mutateAllPathState((state) => {
+        state.touched = fields;
       });
       return;
     }
-    q(i).forEach((r) => {
-      K(r, !!i[r]);
+    keysOf(fields).forEach((field) => {
+      setFieldTouched(field, !!fields[field]);
     });
   }
-  function et(i, r) {
-    var o;
-    const d = r && "value" in r ? r.value : L(Z.value, i), y = M(i);
-    y && (y.__flags.pendingReset = !0), Ue(i, E(d), !0), V(i, d, !1), K(i, (o = r == null ? void 0 : r.touched) !== null && o !== void 0 ? o : !1), g(i, (r == null ? void 0 : r.errors) || []), ee(() => {
-      y && (y.__flags.pendingReset = !1);
+  function resetField(field, state) {
+    var _a2;
+    const newValue = state && "value" in state ? state.value : getFromPath(initialValues.value, field);
+    const pathState = findPathState(field);
+    if (pathState) {
+      pathState.__flags.pendingReset = true;
+    }
+    setFieldInitialValue(field, klona(newValue), true);
+    setFieldValue(field, newValue, false);
+    setFieldTouched(field, (_a2 = state === null || state === void 0 ? void 0 : state.touched) !== null && _a2 !== void 0 ? _a2 : false);
+    setFieldError(field, (state === null || state === void 0 ? void 0 : state.errors) || []);
+    nextTick(() => {
+      if (pathState) {
+        pathState.__flags.pendingReset = false;
+      }
     });
   }
-  function Re(i, r) {
-    let o = E(i != null && i.values ? i.values : le.value);
-    o = r != null && r.force ? o : Oe(le.value, o), o = X(D) && x(D.cast) ? D.cast(o) : o, B(o, { force: r == null ? void 0 : r.force }), G((d) => {
-      var y;
-      d.__flags.pendingReset = !0, d.validated = !1, d.touched = ((y = i == null ? void 0 : i.touched) === null || y === void 0 ? void 0 : y[d.path]) || !1, V(d.path, L(o, d.path), !1), g(d.path, void 0);
-    }), r != null && r.force ? N(o, !1) : A(o, !1), T((i == null ? void 0 : i.errors) || {}), h.value = (i == null ? void 0 : i.submitCount) || 0, ee(() => {
-      ge({ mode: "silent" }), G((d) => {
-        d.__flags.pendingReset = !1;
+  function resetForm(resetState, opts2) {
+    let newValues = klona((resetState === null || resetState === void 0 ? void 0 : resetState.values) ? resetState.values : originalInitialValues.value);
+    newValues = (opts2 === null || opts2 === void 0 ? void 0 : opts2.force) ? newValues : merge(originalInitialValues.value, newValues);
+    newValues = isTypedSchema(schema) && isCallable(schema.cast) ? schema.cast(newValues) : newValues;
+    setInitialValues(newValues, { force: opts2 === null || opts2 === void 0 ? void 0 : opts2.force });
+    mutateAllPathState((state) => {
+      var _a2;
+      state.__flags.pendingReset = true;
+      state.validated = false;
+      state.touched = ((_a2 = resetState === null || resetState === void 0 ? void 0 : resetState.touched) === null || _a2 === void 0 ? void 0 : _a2[state.path]) || false;
+      setFieldValue(state.path, getFromPath(newValues, state.path), false);
+      setFieldError(state.path, void 0);
+    });
+    (opts2 === null || opts2 === void 0 ? void 0 : opts2.force) ? forceSetValues(newValues, false) : setValues(newValues, false);
+    setErrors((resetState === null || resetState === void 0 ? void 0 : resetState.errors) || {});
+    submitCount.value = (resetState === null || resetState === void 0 ? void 0 : resetState.submitCount) || 0;
+    nextTick(() => {
+      validate2({ mode: "silent" });
+      mutateAllPathState((state) => {
+        state.__flags.pendingReset = false;
       });
     });
   }
-  async function ge(i) {
-    const r = (i == null ? void 0 : i.mode) || "force";
-    if (r === "force" && G((m) => m.validated = !0), f.validateSchema)
-      return f.validateSchema(r);
-    a.value = !0;
-    const o = await Promise.all(s.value.map((m) => m.validate ? m.validate(i).then((I) => ({
-      key: m.path,
-      valid: I.valid,
-      errors: I.errors,
-      value: I.value
-    })) : Promise.resolve({
-      key: m.path,
-      valid: !0,
-      errors: [],
-      value: void 0
-    })));
-    a.value = !1;
-    const d = {}, y = {}, p = {};
-    for (const m of o)
-      d[m.key] = {
-        valid: m.valid,
-        errors: m.errors
-      }, m.value && re(p, m.key, m.value), m.errors.length && (y[m.key] = m.errors[0]);
+  async function validate2(opts2) {
+    const mode = (opts2 === null || opts2 === void 0 ? void 0 : opts2.mode) || "force";
+    if (mode === "force") {
+      mutateAllPathState((f) => f.validated = true);
+    }
+    if (formCtx.validateSchema) {
+      return formCtx.validateSchema(mode);
+    }
+    isValidating.value = true;
+    const validations = await Promise.all(pathStates.value.map((state) => {
+      if (!state.validate) {
+        return Promise.resolve({
+          key: state.path,
+          valid: true,
+          errors: [],
+          value: void 0
+        });
+      }
+      return state.validate(opts2).then((result) => {
+        return {
+          key: state.path,
+          valid: result.valid,
+          errors: result.errors,
+          value: result.value
+        };
+      });
+    }));
+    isValidating.value = false;
+    const results = {};
+    const errors2 = {};
+    const values = {};
+    for (const validation of validations) {
+      results[validation.key] = {
+        valid: validation.valid,
+        errors: validation.errors
+      };
+      if (validation.value) {
+        setInPath(values, validation.key, validation.value);
+      }
+      if (validation.errors.length) {
+        errors2[validation.key] = validation.errors[0];
+      }
+    }
     return {
-      valid: o.every((m) => m.valid),
-      results: d,
-      errors: y,
-      values: p,
+      valid: validations.every((r) => r.valid),
+      results,
+      errors: errors2,
+      values,
       source: "fields"
     };
   }
-  async function oe(i, r) {
-    var o;
-    const d = M(i);
-    return d && (r == null ? void 0 : r.mode) !== "silent" && (d.validated = !0), d != null && d.validate ? d.validate(r) : (!d && (o = r == null ? void 0 : r.warn), Promise.resolve({ errors: [], valid: !0 }));
+  async function validateField(path, opts2) {
+    var _a2;
+    const state = findPathState(path);
+    if (state && (opts2 === null || opts2 === void 0 ? void 0 : opts2.mode) !== "silent") {
+      state.validated = true;
+    }
+    if (state === null || state === void 0 ? void 0 : state.validate) {
+      return state.validate(opts2);
+    }
+    !state && ((_a2 = opts2 === null || opts2 === void 0 ? void 0 : opts2.warn) !== null && _a2 !== void 0 ? _a2 : true);
+    return Promise.resolve({ errors: [], valid: true });
   }
-  function tt(i) {
-    ut(Z.value, i);
+  function unsetInitialValue(path) {
+    unsetPath(initialValues.value, path);
   }
-  function Pt(i, r, o = !1) {
-    Ue(i, r), re(c, i, r), o && re(le.value, i, E(r));
+  function stageInitialValue(path, value, updateOriginal = false) {
+    setFieldInitialValue(path, value);
+    setInPath(formValues, path, value);
+    if (updateOriginal && true) {
+      setInPath(originalInitialValues.value, path, klona(value));
+    }
   }
-  function Ue(i, r, o = !1) {
-    re(Z.value, i, E(r)), o && re(le.value, i, E(r));
+  function setFieldInitialValue(path, value, updateOriginal = false) {
+    setInPath(initialValues.value, path, klona(value));
+    if (updateOriginal) {
+      setInPath(originalInitialValues.value, path, klona(value));
+    }
   }
-  async function nt() {
-    const i = w(D);
-    if (!i)
-      return { valid: !0, results: {}, errors: {}, source: "none" };
-    a.value = !0;
-    const r = Ie(i) || X(i) ? await cn(i, c) : await dn(i, c, {
-      names: Q.value,
-      bailsMap: $.value
+  async function _validateSchema() {
+    const schemaValue = unref(schema);
+    if (!schemaValue) {
+      return { valid: true, results: {}, errors: {}, source: "none" };
+    }
+    isValidating.value = true;
+    const formResult = isYupValidator(schemaValue) || isTypedSchema(schemaValue) ? await validateTypedSchema(schemaValue, formValues) : await validateObjectSchema(schemaValue, formValues, {
+      names: fieldNames.value,
+      bailsMap: fieldBailsMap.value
     });
-    return a.value = !1, r;
+    isValidating.value = false;
+    return formResult;
   }
-  const Ft = ye((i, { evt: r }) => {
-    Kt(r) && r.target.submit();
+  const submitForm = handleSubmit((_, { evt }) => {
+    if (isFormSubmitEvent(evt)) {
+      evt.target.submit();
+    }
   });
-  ft(() => {
-    f.validateSchema && f.validateSchema("silent");
-  }), Fe(D) && se(D, () => {
-    var i;
-    (i = f.validateSchema) === null || i === void 0 || i.call(f, "validated-only");
-  }), vt(Xe, f);
-  function Be(i, r) {
-    const o = x(r) || r == null ? void 0 : r.label, d = M(O(i)) || fe(i, { label: o }), y = () => x(r) ? r(Ee(d, we)) : r || {};
-    function p() {
-      var P;
-      d.touched = !0, ((P = y().validateOnBlur) !== null && P !== void 0 ? P : Ve().validateOnBlur) && oe(d.path);
-    }
-    function m() {
-      var P;
-      ((P = y().validateOnInput) !== null && P !== void 0 ? P : Ve().validateOnInput) && ee(() => {
-        oe(d.path);
-      });
+  onMounted(() => {
+    if (formCtx.validateSchema) {
+      formCtx.validateSchema("silent");
     }
-    function I() {
-      var P;
-      ((P = y().validateOnChange) !== null && P !== void 0 ? P : Ve().validateOnChange) && ee(() => {
-        oe(d.path);
-      });
+  });
+  if (isRef(schema)) {
+    watch(schema, () => {
+      var _a2;
+      (_a2 = formCtx.validateSchema) === null || _a2 === void 0 ? void 0 : _a2.call(formCtx, "validated-only");
+    });
+  }
+  provide(FormContextKey, formCtx);
+  function defineField(path, config) {
+    const label = isCallable(config) ? void 0 : config === null || config === void 0 ? void 0 : config.label;
+    const pathState = findPathState(toValue(path)) || createPathState(path, { label });
+    const evalConfig = () => isCallable(config) ? config(omit(pathState, PRIVATE_PATH_STATE_KEYS)) : config || {};
+    function onBlur() {
+      var _a2;
+      pathState.touched = true;
+      const validateOnBlur = (_a2 = evalConfig().validateOnBlur) !== null && _a2 !== void 0 ? _a2 : getConfig().validateOnBlur;
+      if (validateOnBlur) {
+        validateField(pathState.path);
+      }
+    }
+    function onInput() {
+      var _a2;
+      const validateOnInput = (_a2 = evalConfig().validateOnInput) !== null && _a2 !== void 0 ? _a2 : getConfig().validateOnInput;
+      if (validateOnInput) {
+        nextTick(() => {
+          validateField(pathState.path);
+        });
+      }
     }
-    const C = j(() => {
-      const P = {
-        onChange: I,
-        onInput: m,
-        onBlur: p
+    function onChange() {
+      var _a2;
+      const validateOnChange = (_a2 = evalConfig().validateOnChange) !== null && _a2 !== void 0 ? _a2 : getConfig().validateOnChange;
+      if (validateOnChange) {
+        nextTick(() => {
+          validateField(pathState.path);
+        });
+      }
+    }
+    const props = computed(() => {
+      const base = {
+        onChange,
+        onInput,
+        onBlur
       };
-      return x(r) ? Object.assign(Object.assign({}, P), r(Ee(d, we)).props || {}) : r != null && r.props ? Object.assign(Object.assign({}, P), r.props(Ee(d, we))) : P;
+      if (isCallable(config)) {
+        return Object.assign(Object.assign({}, base), config(omit(pathState, PRIVATE_PATH_STATE_KEYS)).props || {});
+      }
+      if (config === null || config === void 0 ? void 0 : config.props) {
+        return Object.assign(Object.assign({}, base), config.props(omit(pathState, PRIVATE_PATH_STATE_KEYS)));
+      }
+      return base;
     });
-    return [te(i, () => {
-      var P, R, z;
-      return (z = (P = y().validateOnModelUpdate) !== null && P !== void 0 ? P : (R = Ve()) === null || R === void 0 ? void 0 : R.validateOnModelUpdate) !== null && z !== void 0 ? z : !0;
-    }), C];
-  }
-  function It(i) {
-    return Array.isArray(i) ? i.map((r) => te(r, !0)) : te(i);
-  }
-  function Ct(i, r) {
-    const [o, d] = Be(i, r);
-    function y() {
-      d.value.onBlur();
-    }
-    function p(I) {
-      const C = Ce(I);
-      V(O(i), C, !1), d.value.onInput();
-    }
-    function m(I) {
-      const C = Ce(I);
-      V(O(i), C, !1), d.value.onChange();
-    }
-    return j(() => Object.assign(Object.assign({}, d.value), {
-      onBlur: y,
-      onInput: p,
-      onChange: m,
-      value: o.value
-    }));
+    const model = createModel(path, () => {
+      var _a2, _b, _c;
+      return (_c = (_a2 = evalConfig().validateOnModelUpdate) !== null && _a2 !== void 0 ? _a2 : (_b = getConfig()) === null || _b === void 0 ? void 0 : _b.validateOnModelUpdate) !== null && _c !== void 0 ? _c : true;
+    });
+    return [model, props];
+  }
+  function useFieldModel(pathOrPaths) {
+    if (!Array.isArray(pathOrPaths)) {
+      return createModel(pathOrPaths);
+    }
+    return pathOrPaths.map((p) => createModel(p, true));
   }
-  function Nt(i, r) {
-    const [o, d] = Be(i, r), y = M(O(i));
-    function p(m) {
-      o.value = m;
+  function defineInputBinds(path, config) {
+    const [model, props] = defineField(path, config);
+    function onBlur() {
+      props.value.onBlur();
+    }
+    function onInput(e) {
+      const value = normalizeEventValue(e);
+      setFieldValue(toValue(path), value, false);
+      props.value.onInput();
+    }
+    function onChange(e) {
+      const value = normalizeEventValue(e);
+      setFieldValue(toValue(path), value, false);
+      props.value.onChange();
     }
-    return j(() => {
-      const m = x(r) ? r(Ee(y, we)) : r || {};
-      return Object.assign({ [m.model || "modelValue"]: o.value, [`onUpdate:${m.model || "modelValue"}`]: p }, d.value);
+    return computed(() => {
+      return Object.assign(Object.assign({}, props.value), {
+        onBlur,
+        onInput,
+        onChange,
+        value: model.value
+      });
     });
   }
-  return Object.assign(Object.assign({}, f), { values: Mt(c), handleReset: () => Re(), submitForm: Ft });
+  function defineComponentBinds(path, config) {
+    const [model, props] = defineField(path, config);
+    const pathState = findPathState(toValue(path));
+    function onUpdateModelValue(value) {
+      model.value = value;
+    }
+    return computed(() => {
+      const conf = isCallable(config) ? config(omit(pathState, PRIVATE_PATH_STATE_KEYS)) : config || {};
+      return Object.assign({ [conf.model || "modelValue"]: model.value, [`onUpdate:${conf.model || "modelValue"}`]: onUpdateModelValue }, props.value);
+    });
+  }
+  return Object.assign(Object.assign({}, formCtx), { values: readonly(formValues), handleReset: () => resetForm(), submitForm });
 }
-function On(e, t, n, l) {
-  const u = {
+function useFormMeta(pathsState, currentValues, initialValues, errors) {
+  const MERGE_STRATEGIES = {
     touched: "some",
     pending: "some",
     valid: "every"
-  }, a = j(() => !U(t, w(n)));
-  function h() {
-    const c = e.value;
-    return q(u).reduce((s, S) => {
-      const b = u[S];
-      return s[S] = c[b]((F) => F[S]), s;
+  };
+  const isDirty = computed(() => {
+    return !isEqual(currentValues, unref(initialValues));
+  });
+  function calculateFlags() {
+    const states = pathsState.value;
+    return keysOf(MERGE_STRATEGIES).reduce((acc, flag) => {
+      const mergeMethod = MERGE_STRATEGIES[flag];
+      acc[flag] = states[mergeMethod]((s) => s[flag]);
+      return acc;
     }, {});
   }
-  const v = Pe(h());
-  return kt(() => {
-    const c = h();
-    v.touched = c.touched, v.valid = c.valid, v.pending = c.pending;
-  }), j(() => Object.assign(Object.assign({ initialValues: w(n) }, v), { valid: v.valid && !q(l.value).length, dirty: a.value }));
-}
-function _n(e, t, n) {
-  const l = jt(), u = Y(l), a = Y(E(l));
-  function h(v, c) {
-    c != null && c.force ? (u.value = E(v), a.value = E(v)) : (u.value = Oe(E(u.value) || {}, E(v)), a.value = Oe(E(a.value) || {}, E(v))), c != null && c.updateFields && e.value.forEach((s) => {
-      if (s.touched)
+  const flags = reactive(calculateFlags());
+  watchEffect(() => {
+    const value = calculateFlags();
+    flags.touched = value.touched;
+    flags.valid = value.valid;
+    flags.pending = value.pending;
+  });
+  return computed(() => {
+    return Object.assign(Object.assign({ initialValues: unref(initialValues) }, flags), { valid: flags.valid && !keysOf(errors.value).length, dirty: isDirty.value });
+  });
+}
+function useFormInitialValues(pathsState, formValues, opts) {
+  const values = resolveInitialValues();
+  const initialValues = ref(values);
+  const originalInitialValues = ref(klona(values));
+  function setInitialValues(values2, opts2) {
+    if (opts2 === null || opts2 === void 0 ? void 0 : opts2.force) {
+      initialValues.value = klona(values2);
+      originalInitialValues.value = klona(values2);
+    } else {
+      initialValues.value = merge(klona(initialValues.value) || {}, klona(values2));
+      originalInitialValues.value = merge(klona(originalInitialValues.value) || {}, klona(values2));
+    }
+    if (!(opts2 === null || opts2 === void 0 ? void 0 : opts2.updateFields)) {
+      return;
+    }
+    pathsState.value.forEach((state) => {
+      const wasTouched = state.touched;
+      if (wasTouched) {
         return;
-      const b = L(u.value, s.path);
-      re(t, s.path, E(b));
+      }
+      const newValue = getFromPath(initialValues.value, state.path);
+      setInPath(formValues, state.path, klona(newValue));
     });
   }
   return {
-    initialValues: u,
-    originalInitialValues: a,
-    setInitialValues: h
+    initialValues,
+    originalInitialValues,
+    setInitialValues
   };
 }
-function Sn(e, t) {
-  return t ? {
-    valid: e.valid && t.valid,
-    errors: [...e.errors, ...t.errors]
-  } : e;
+function mergeValidationResults(a, b) {
+  if (!b) {
+    return a;
+  }
+  return {
+    valid: a.valid && b.valid,
+    errors: [...a.errors, ...b.errors]
+  };
 }
 export {
-  En as a,
-  jn as u
+  useForm as a,
+  useField as u
 };