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

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

@@ -1,2042 +0,0 @@
-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 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;
-    }
-    target[key] = source[key];
-  });
-  return target;
-}
-function normalizeFormPath(path) {
-  const pathArr = path.split(".");
-  if (!pathArr.length) {
-    return "";
-  }
-  let fullPath = String(pathArr[0]);
-  for (let i = 1; i < pathArr.length; i++) {
-    if (isIndex(pathArr[i])) {
-      fullPath += `[${pathArr[i]}]`;
-      continue;
-    }
-    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 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;
-    }
-    if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {
-      acc[keys[i]] = isIndex(keys[i + 1]) ? [] : {};
-    }
-    acc = acc[keys[i]];
-  }
-}
-function unset(object, key) {
-  if (Array.isArray(object) && isIndex(key)) {
-    object.splice(Number(key), 1);
-    return;
-  }
-  if (isObject(object)) {
-    delete object[key];
-  }
-}
-function unsetPath(object, path) {
-  if (isNotNestedPath(path)) {
-    delete object[cleanupNonNestedPath(path)];
-    return;
-  }
-  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 (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {
-      break;
-    }
-    acc = acc[keys[i]];
-  }
-  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 keysOf(record) {
-  return Object.keys(record);
-}
-function injectWithSelf(symbol, def = void 0) {
-  const vm = getCurrentInstance();
-  return (vm === null || vm === void 0 ? void 0 : vm.provides[symbol]) || inject(symbol, def);
-}
-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 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 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 normalizeErrorItem(message) {
-  return Array.isArray(message) ? message : message ? [message] : [];
-}
-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 result = inner(...args);
-      resolves.forEach((r) => r(result));
-      resolves = [];
-      lastTick = null;
-    });
-    lastTick = thisTick;
-    return new Promise((resolve) => resolves.push(resolve));
-  };
-}
-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 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 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: errors2
-    };
-  }
-  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 (result.error) {
-      errors.push(result.error);
-      if (field.bails) {
-        return {
-          errors
-        };
-      }
-    }
-  }
-  return {
-    errors
-  };
-}
-function isYupError(err) {
-  return !!err && err.name === "ValidationError";
-}
-function yupToTypedSchema(yupSchema) {
-  const schema = {
-    __type: "VVTypedSchema",
-    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,
-          errors: []
-        };
-      } 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(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: result.value,
-    errors: messages
-  };
-}
-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 _generateFieldError(fieldCtx) {
-  const message = getConfig().generateMessage;
-  if (!message) {
-    return "Field is invalid";
-  }
-  return message(fieldCtx);
-}
-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: !validationResult.errors.length,
-    results,
-    errors,
-    values: validationResult.value,
-    source: "schema"
-  };
-}
-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({}, fieldResult), { path });
-  });
-  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: isAllValid,
-    results,
-    errors,
-    source: "schema"
-  };
-}
-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: errors2, setErrors } = createFieldErrors();
-    const id = ID_COUNTER >= Number.MAX_SAFE_INTEGER ? 0 : ++ID_COUNTER;
-    const meta = createFieldMeta(value, initialValue, errors2, init.schema);
-    return {
-      id,
-      path,
-      value,
-      initialValue,
-      meta,
-      flags: { pendingUnmount: { [id]: false }, pendingReset: false },
-      errors: errors2,
-      setState: setState2
-    };
-  }
-  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(state.id) ? state.id[state.id.length - 1] : state.id,
-    path,
-    value,
-    errors,
-    meta: state,
-    initialValue,
-    flags: state.__flags,
-    setState
-  };
-}
-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 setInitialValue(value2) {
-    if (!form) {
-      modelRef.value = value2;
-      return;
-    }
-    form.setFieldInitialValue(unref(path), value2, true);
-  }
-  const initialValue = computed(resolveInitialValue2);
-  if (!form) {
-    const value2 = ref(resolveInitialValue2());
-    return {
-      value: value2,
-      initialValue,
-      setInitialValue
-    };
-  }
-  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 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;
-  });
-  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: true,
-    flush: "sync"
-  });
-  return meta;
-}
-function createFieldErrors() {
-  const errors = ref([]);
-  return {
-    errors,
-    setErrors: (messages) => {
-      errors.value = normalizeErrorItem(messages);
-    }
-  };
-}
-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 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 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;
-  });
-  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 value.value;
-    },
-    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
-  };
-  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;
-      }, {});
-      Object.assign(acc, deps);
-      return acc;
-    }, {});
-  });
-  watch(dependencies, (deps, oldDeps) => {
-    if (!Object.keys(deps).length) {
-      return;
-    }
-    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;
-    }
-    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;
-    }
-    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 normalizeOptions(opts) {
-  const defaults = () => ({
-    initialValue: void 0,
-    validateOnMount: false,
-    bails: true,
-    label: void 0,
-    validateOnValueUpdate: true,
-    keepValueOnUnmount: void 0,
-    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 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 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 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 patchCheckedApi(_useField(name, rules, opts));
-}
-function useVModel({ prop, value, handleChange, shouldValidate }) {
-  const vm = getCurrentInstance();
-  if (!vm || !prop) {
-    return;
-  }
-  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;
-    }
-    vm.emit(emitName, newValue);
-  });
-  watch(() => getCurrentModelValue(vm, propName), (propValue) => {
-    if (propValue === IS_ABSENT && value.value === void 0) {
-      return;
-    }
-    const newValue = propValue === IS_ABSENT ? void 0 : propValue;
-    if (isEqual(newValue, value.value)) {
-      return;
-    }
-    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) || {});
-  }
-  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 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: { [id]: false },
-        pendingReset: false
-      },
-      fieldsCount: 1,
-      validate: config === null || config === void 0 ? void 0 : config.validate,
-      dirty: computed(() => {
-        return !isEqual(unref(currentValue), unref(initialValue));
-      })
-    });
-    pathStates.value.push(state);
-    pathStateLookup.value[pathValue] = state;
-    rebuildPathLookup();
-    if (errors.value[pathValue] && !initialErrors[pathValue]) {
-      nextTick(() => {
-        validateField(pathValue, { mode: "silent" });
-      });
-    }
-    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: formResult.valid,
-      results: {},
-      errors: {},
-      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 results;
-  });
-  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
-            });
-          }
-          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 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);
-      }
-      delete pathState.__flags.pendingUnmount[id];
-    }
-    if (!pathState.multiple || pathState.fieldsCount <= 0) {
-      pathStates.value.splice(idx, 1);
-      unsetInitialValue(path);
-      rebuildPathLookup();
-      delete pathStateLookup.value[path];
-    }
-  }
-  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 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 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 pathState.value;
-      },
-      set(value) {
-        var _a2;
-        const pathValue = toValue(path);
-        setFieldValue(pathValue, value, (_a2 = toValue(shouldValidate)) !== null && _a2 !== void 0 ? _a2 : false);
-      }
-    });
-  }
-  function setFieldTouched(field, isTouched) {
-    const pathState = findPathState(field);
-    if (pathState) {
-      pathState.touched = isTouched;
-    }
-  }
-  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 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 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 setTouched(fields) {
-    if (typeof fields === "boolean") {
-      mutateAllPathState((state) => {
-        state.touched = fields;
-      });
-      return;
-    }
-    keysOf(fields).forEach((field) => {
-      setFieldTouched(field, !!fields[field]);
-    });
-  }
-  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 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 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: validations.every((r) => r.valid),
-      results,
-      errors: errors2,
-      values,
-      source: "fields"
-    };
-  }
-  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 unsetInitialValue(path) {
-    unsetPath(initialValues.value, path);
-  }
-  function stageInitialValue(path, value, updateOriginal = false) {
-    setFieldInitialValue(path, value);
-    setInPath(formValues, path, value);
-    if (updateOriginal && true) {
-      setInPath(originalInitialValues.value, path, klona(value));
-    }
-  }
-  function setFieldInitialValue(path, value, updateOriginal = false) {
-    setInPath(initialValues.value, path, klona(value));
-    if (updateOriginal) {
-      setInPath(originalInitialValues.value, path, klona(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
-    });
-    isValidating.value = false;
-    return formResult;
-  }
-  const submitForm = handleSubmit((_, { evt }) => {
-    if (isFormSubmitEvent(evt)) {
-      evt.target.submit();
-    }
-  });
-  onMounted(() => {
-    if (formCtx.validateSchema) {
-      formCtx.validateSchema("silent");
-    }
-  });
-  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);
-        });
-      }
-    }
-    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
-      };
-      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;
-    });
-    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 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 computed(() => {
-      return Object.assign(Object.assign({}, props.value), {
-        onBlur,
-        onInput,
-        onChange,
-        value: model.value
-      });
-    });
-  }
-  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 useFormMeta(pathsState, currentValues, initialValues, errors) {
-  const MERGE_STRATEGIES = {
-    touched: "some",
-    pending: "some",
-    valid: "every"
-  };
-  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 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 newValue = getFromPath(initialValues.value, state.path);
-      setInPath(formValues, state.path, klona(newValue));
-    });
-  }
-  return {
-    initialValues,
-    originalInitialValues,
-    setInitialValues
-  };
-}
-function mergeValidationResults(a, b) {
-  if (!b) {
-    return a;
-  }
-  return {
-    valid: a.valid && b.valid,
-    errors: [...a.errors, ...b.errors]
-  };
-}
-export {
-  useForm as a,
-  useField as u
-};