{"version":3,"sources":["webpack:///./node_modules/vee-validate/dist/vee-validate.esm.js"],"names":["isCallable","fn","isNullOrUndefined","value","undefined","isObject","obj","Array","isArray","isIndex","Number","toNumber","n","parseFloat","isNaN","RULES","resolveRule","id","FormContextKey","Symbol","FieldContextKey","IS_ABSENT","isClient","window","isLocator","__locatorRef","isYupValidator","validate","hasCheckedAttr","type","isContainerValue","isEmptyContainer","length","Object","keys","isNotNestedPath","path","test","isNativeMultiSelect","el","isNativeSelect","multiple","tagName","isNativeMultiSelectNode","tag","attrs","hasTruthyBindingValue","includes","shouldHaveValueBinding","isFormSubmitEvent","evt","isEvent","target","Event","srcElement","isPropPresent","prop","isEqual","a","b","constructor","i","Map","size","entries","has","get","isFile","name","lastModified","Set","ArrayBuffer","isView","RegExp","source","flags","valueOf","prototype","toString","hasOwnProperty","call","key","File","set","val","klona","enumerable","configurable","writable","defineProperty","x","k","list","tmp","str","create","__proto__","forEach","add","Date","buffer","slice","getOwnPropertySymbols","getOwnPropertyDescriptor","getOwnPropertyNames","cleanupNonNestedPath","replace","getFromPath","object","fallback","resolvedValue","split","filter","Boolean","reduce","acc","propKey","setInPath","unset","splice","unsetPath","pathValues","map","_","idx","join","keysOf","record","injectWithSelf","symbol","def","vm","provides","warn","message","resolveNextCheckboxValue","currentValue","checkedValue","uncheckedValue","newVal","findIndex","v","push","throttle","func","limit","inThrottle","lastResult","args","context","this","setTimeout","apply","debounceAsync","inner","ms","timer","resolves","clearTimeout","result","r","Promise","resolve","applyModelModifiers","modifiers","number","withLatest","onDone","latestRun","async","pending","computedDeep","baseRef","newValue","deep","normalizeChildren","slotProps","slots","default","_a","_b","getBoundValue","hasValueBinding","_value","normalizeEventValue","input","files","from","options","opt","selected","disabled","selectedOption","find","normalizeRules","rules","_$$isNormalized","prev","curr","params","normalizeParams","buildParams","rule","parsedRule","parseRule","provided","mapValueToLocator","createLocator","locator","crossTable","extractLocators","DEFAULT_CONFIG","generateMessage","field","bails","validateOnBlur","validateOnChange","validateOnInput","validateOnModelUpdate","currentConfig","assign","getConfig","shouldBail","formData","values","_validate","errors","valid","validateFieldWithYup","ctx","form","pipeline","isValid","_generateFieldError","normalizedContext","rulesKeys","_test","error","validator","opts","abortEarly","then","catch","err","Error","fillTargetValues","fieldCtx","normalize","param","validateYupSchema","schema","errorObjects","results","messages","validateObjectSchema","paths","validations","_c","fieldResult","names","bailsMap","isAllValid","validationResults","all","ID_COUNTER","useFieldState","init","initialValue","setInitialValue","_useFieldValue","modelValue","errorMessage","setErrors","_useFieldErrors","meta","_useFieldMeta","MAX_SAFE_INTEGER","setState","state","touched","modelRef","resolveInitialValue","initialValues","stageInitialValue","setFieldValue","validated","dirty","immediate","flush","normalizeErrors","errorBag","setFieldErrorBag","API","sendInspectorState","INSPECTOR_ID","sendInspectorTree","useField","useCheckboxField","_useField","validateOnMount","label","validateOnValueUpdate","controlled","keepValueOnUnmount","modelPropName","syncVModel","controlForm","normalizeOptions","injectedForm","markedForRemoval","useVModel","handleChange","handleBlur","normalizedRules","rulesValue","extractRuleFromSchema","validateCurrentValue","mode","validateSchema","validateWithStateMutation","validateValidStateOnly","validate$1","e","shouldValidate","setTouched","isTouched","unwatchValue","lastWatchedValue","watchValue","oldVal","validateFn","resetField","setValue","handleReset","oldValue","register","unregister","dependencies","rulesVal","deps","dep","depAcc","depName","depValue","oldDeps","defaults","valueProp","standalone","fieldName","patchCheckboxApi","checked","checkedVal","handleCheckboxChange","propName","emitName","props","getCurrentModelValue","emit","propValue","modelModifiers","FieldImpl","inheritAttrs","as","String","required","Function","keepValue","validateField","onChangeHandler","handleInput","onInputHandler","fieldProps","resolveValidationTriggers","baseOnBlur","onBlur","baseOnInput","onInput","baseOnChange","onChange","resolveTag","expose","reset","children","_d","Field","FORM_COUNTER","useForm","formId","controlledModelPaths","RESET_LOCK","fieldsByPath","isSubmitting","submitCount","fieldArrays","formValues","setErrorBag","useErrorBag","initialErrors","bag","getFirstFieldAtPath","fieldOrGroup","fieldExists","fieldNames","fieldBailsMap","keepValuesOnUnmount","originalInitialValues","setInitialValues","useFormInitialValues","useFormMeta","controlledValues","validationSchema","debouncedSilentValidation","_validateSchema","debouncedValidation","formResult","fieldsById","formCtx","currentErrorsPaths","validation","setFieldError","applyFieldMutation","f","wasValidated","some","makeSubmissionFactory","onlyControlled","onValidationError","preventDefault","stopPropagation","setFieldTouched","setValues","resetForm","returnVal","handleSubmitImpl","handleSubmit","withControlled","registerField","unregisterField","unsetInitialValue","setFieldInitialValue","useFieldModel","isFieldGroup","mutation","mutateAllFields","fields","force","fieldInstance","clonedValue","createModel","insertFieldAtPath","rawField","fieldPath","fieldAtPath","removeFieldFromPath","newPath","oldPath","initialErrorMessage","isGroup","shouldKeepValue","currentGroupValue","isSameGroup","valueIdx","every","updateOriginal","schemaValue","submitForm","submit","initialTouched","currentValues","MERGE_STRATEGIES","isDirty","calculateFlags","flat","flag","mergeMethod","providedValues","updateFields","wasTouched","normalizeErrorItem","FormImpl","onSubmit","onInvalidSubmit","keepValues","handleFormReset","onReset","handleScopedSlotSubmit","onSuccess","formAttrs","novalidate","Form","useFieldArray","arrayPath","noOp","noOpApi","remove","swap","insert","update","prepend","move","alreadyExists","entryCounter","initFields","createEntry","updateEntryFlags","fieldsLength","entry","isFirst","isLast","pathName","pathValue","normalizedPathValue","indexA","indexB","newFields","temp","tempEntry","arr","unshift","oldIdx","newIdx","movedItem","movedValue","fieldArrayCtx","FieldArrayImpl","FieldArray","ErrorMessageImpl","role","ErrorMessage"],"mappings":"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","file":"js/chunk-2d0e1d50.1ffa8a24.js","sourcesContent":["/**\n  * vee-validate v4.7.2\n  * (c) 2022 Abdelrahman Awad\n  * @license MIT\n  */\nimport { getCurrentInstance, inject, warn as warn$1, ref, watch, unref, computed, reactive, onUnmounted, nextTick, onMounted, provide, isRef, onBeforeUnmount, defineComponent, toRef, resolveDynamicComponent, h, watchEffect, markRaw } from 'vue';\nimport { setupDevtoolsPlugin } from '@vue/devtools-api';\n\nfunction isCallable(fn) {\r\n    return typeof fn === 'function';\r\n}\r\nfunction isNullOrUndefined(value) {\r\n    return value === null || value === undefined;\r\n}\r\nconst isObject = (obj) => obj !== null && !!obj && typeof obj === 'object' && !Array.isArray(obj);\r\nfunction isIndex(value) {\r\n    return Number(value) >= 0;\r\n}\r\nfunction toNumber(value) {\r\n    const n = parseFloat(value);\r\n    return isNaN(n) ? value : n;\r\n}\n\nconst RULES = {};\r\n/**\r\n * Adds a custom validator to the list of validation rules.\r\n */\r\nfunction defineRule(id, validator) {\r\n    // makes sure new rules are properly formatted.\r\n    guardExtend(id, validator);\r\n    RULES[id] = validator;\r\n}\r\n/**\r\n * Gets an already defined rule\r\n */\r\nfunction resolveRule(id) {\r\n    return RULES[id];\r\n}\r\n/**\r\n * Guards from extension violations.\r\n */\r\nfunction guardExtend(id, validator) {\r\n    if (isCallable(validator)) {\r\n        return;\r\n    }\r\n    throw new Error(`Extension Error: The validator '${id}' must be a function.`);\r\n}\n\nconst FormContextKey = Symbol('vee-validate-form');\r\nconst FieldContextKey = Symbol('vee-validate-field-instance');\r\nconst IS_ABSENT = Symbol('Default empty value');\n\nconst isClient = typeof window !== 'undefined';\r\nfunction isLocator(value) {\r\n    return isCallable(value) && !!value.__locatorRef;\r\n}\r\nfunction isYupValidator(value) {\r\n    return !!value && isCallable(value.validate);\r\n}\r\nfunction hasCheckedAttr(type) {\r\n    return type === 'checkbox' || type === 'radio';\r\n}\r\nfunction isContainerValue(value) {\r\n    return isObject(value) || Array.isArray(value);\r\n}\r\n/**\r\n * True if the value is an empty object or array\r\n */\r\nfunction isEmptyContainer(value) {\r\n    if (Array.isArray(value)) {\r\n        return value.length === 0;\r\n    }\r\n    return isObject(value) && Object.keys(value).length === 0;\r\n}\r\n/**\r\n * Checks if the path opted out of nested fields using `[fieldName]` syntax\r\n */\r\nfunction isNotNestedPath(path) {\r\n    return /^\\[.+\\]$/i.test(path);\r\n}\r\n/**\r\n * Checks if an element is a native HTML5 multi-select input element\r\n */\r\nfunction isNativeMultiSelect(el) {\r\n    return isNativeSelect(el) && el.multiple;\r\n}\r\n/**\r\n * Checks if an element is a native HTML5 select input element\r\n */\r\nfunction isNativeSelect(el) {\r\n    return el.tagName === 'SELECT';\r\n}\r\n/**\r\n * Checks if a tag name with attrs object will render a native multi-select element\r\n */\r\nfunction isNativeMultiSelectNode(tag, attrs) {\r\n    // The falsy value array is the values that Vue won't add the `multiple` prop if it has one of these values\r\n    const hasTruthyBindingValue = ![false, null, undefined, 0].includes(attrs.multiple) && !Number.isNaN(attrs.multiple);\r\n    return tag === 'select' && 'multiple' in attrs && hasTruthyBindingValue;\r\n}\r\n/**\r\n * Checks if a node should have a `:value` binding or not\r\n *\r\n * These nodes should not have a value binding\r\n * For files, because they are not reactive\r\n * For multi-selects because the value binding will reset the value\r\n */\r\nfunction shouldHaveValueBinding(tag, attrs) {\r\n    return !isNativeMultiSelectNode(tag, attrs) && attrs.type !== 'file' && !hasCheckedAttr(attrs.type);\r\n}\r\nfunction isFormSubmitEvent(evt) {\r\n    return isEvent(evt) && evt.target && 'submit' in evt.target;\r\n}\r\nfunction isEvent(evt) {\r\n    if (!evt) {\r\n        return false;\r\n    }\r\n    if (typeof Event !== 'undefined' && isCallable(Event) && evt instanceof Event) {\r\n        return true;\r\n    }\r\n    // this is for IE and Cypress #3161\r\n    /* istanbul ignore next */\r\n    if (evt && evt.srcElement) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\nfunction isPropPresent(obj, prop) {\r\n    return prop in obj && obj[prop] !== IS_ABSENT;\r\n}\r\n/**\r\n * Compares if two values are the same borrowed from:\r\n * https://github.com/epoberezkin/fast-deep-equal\r\n * We added a case for file matching since `Object.keys` doesn't work with Files.\r\n * */\r\nfunction isEqual(a, b) {\r\n    if (a === b)\r\n        return true;\r\n    if (a && b && typeof a === 'object' && typeof b === 'object') {\r\n        if (a.constructor !== b.constructor)\r\n            return false;\r\n        // eslint-disable-next-line no-var\r\n        var length, i, keys;\r\n        if (Array.isArray(a)) {\r\n            length = a.length;\r\n            // eslint-disable-next-line eqeqeq\r\n            if (length != b.length)\r\n                return false;\r\n            for (i = length; i-- !== 0;)\r\n                if (!isEqual(a[i], b[i]))\r\n                    return false;\r\n            return true;\r\n        }\r\n        if (a instanceof Map && b instanceof Map) {\r\n            if (a.size !== b.size)\r\n                return false;\r\n            for (i of a.entries())\r\n                if (!b.has(i[0]))\r\n                    return false;\r\n            for (i of a.entries())\r\n                if (!isEqual(i[1], b.get(i[0])))\r\n                    return false;\r\n            return true;\r\n        }\r\n        // We added this part for file comparison, arguably a little naive but should work for most cases.\r\n        // #3911\r\n        if (isFile(a) && isFile(b)) {\r\n            if (a.size !== b.size)\r\n                return false;\r\n            if (a.name !== b.name)\r\n                return false;\r\n            if (a.lastModified !== b.lastModified)\r\n                return false;\r\n            if (a.type !== b.type)\r\n                return false;\r\n            return true;\r\n        }\r\n        if (a instanceof Set && b instanceof Set) {\r\n            if (a.size !== b.size)\r\n                return false;\r\n            for (i of a.entries())\r\n                if (!b.has(i[0]))\r\n                    return false;\r\n            return true;\r\n        }\r\n        if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\r\n            length = a.length;\r\n            // eslint-disable-next-line eqeqeq\r\n            if (length != b.length)\r\n                return false;\r\n            for (i = length; i-- !== 0;)\r\n                if (a[i] !== b[i])\r\n                    return false;\r\n            return true;\r\n        }\r\n        if (a.constructor === RegExp)\r\n            return a.source === b.source && a.flags === b.flags;\r\n        if (a.valueOf !== Object.prototype.valueOf)\r\n            return a.valueOf() === b.valueOf();\r\n        if (a.toString !== Object.prototype.toString)\r\n            return a.toString() === b.toString();\r\n        keys = Object.keys(a);\r\n        length = keys.length;\r\n        if (length !== Object.keys(b).length)\r\n            return false;\r\n        for (i = length; i-- !== 0;)\r\n            if (!Object.prototype.hasOwnProperty.call(b, keys[i]))\r\n                return false;\r\n        for (i = length; i-- !== 0;) {\r\n            // eslint-disable-next-line no-var\r\n            var key = keys[i];\r\n            if (!isEqual(a[key], b[key]))\r\n                return false;\r\n        }\r\n        return true;\r\n    }\r\n    // true if both NaN, false otherwise\r\n    // eslint-disable-next-line no-self-compare\r\n    return a !== a && b !== b;\r\n}\r\nfunction isFile(a) {\r\n    if (!isClient) {\r\n        return false;\r\n    }\r\n    return a instanceof File;\r\n}\n\nfunction set(obj, key, val) {\n\tif (typeof val.value === 'object') val.value = klona(val.value);\n\tif (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {\n\t\tObject.defineProperty(obj, key, val);\n\t} else obj[key] = val.value;\n}\n\nfunction klona(x) {\n\tif (typeof x !== 'object') return x;\n\n\tvar i=0, k, list, tmp, str=Object.prototype.toString.call(x);\n\n\tif (str === '[object Object]') {\n\t\ttmp = Object.create(x.__proto__ || null);\n\t} else if (str === '[object Array]') {\n\t\ttmp = Array(x.length);\n\t} else if (str === '[object Set]') {\n\t\ttmp = new Set;\n\t\tx.forEach(function (val) {\n\t\t\ttmp.add(klona(val));\n\t\t});\n\t} else if (str === '[object Map]') {\n\t\ttmp = new Map;\n\t\tx.forEach(function (val, key) {\n\t\t\ttmp.set(klona(key), klona(val));\n\t\t});\n\t} else if (str === '[object Date]') {\n\t\ttmp = new Date(+x);\n\t} else if (str === '[object RegExp]') {\n\t\ttmp = new RegExp(x.source, x.flags);\n\t} else if (str === '[object DataView]') {\n\t\ttmp = new x.constructor( klona(x.buffer) );\n\t} else if (str === '[object ArrayBuffer]') {\n\t\ttmp = x.slice(0);\n\t} else if (str.slice(-6) === 'Array]') {\n\t\t// ArrayBuffer.isView(x)\n\t\t// ~> `new` bcuz `Buffer.slice` => ref\n\t\ttmp = new x.constructor(x);\n\t}\n\n\tif (tmp) {\n\t\tfor (list=Object.getOwnPropertySymbols(x); i < list.length; i++) {\n\t\t\tset(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));\n\t\t}\n\n\t\tfor (i=0, list=Object.getOwnPropertyNames(x); i < list.length; i++) {\n\t\t\tif (Object.hasOwnProperty.call(tmp, k=list[i]) && tmp[k] === x[k]) continue;\n\t\t\tset(tmp, k, Object.getOwnPropertyDescriptor(x, k));\n\t\t}\n\t}\n\n\treturn tmp || x;\n}\n\nfunction cleanupNonNestedPath(path) {\r\n    if (isNotNestedPath(path)) {\r\n        return path.replace(/\\[|\\]/gi, '');\r\n    }\r\n    return path;\r\n}\r\nfunction getFromPath(object, path, fallback) {\r\n    if (!object) {\r\n        return fallback;\r\n    }\r\n    if (isNotNestedPath(path)) {\r\n        return object[cleanupNonNestedPath(path)];\r\n    }\r\n    const resolvedValue = (path || '')\r\n        .split(/\\.|\\[(\\d+)\\]/)\r\n        .filter(Boolean)\r\n        .reduce((acc, propKey) => {\r\n        if (isContainerValue(acc) && propKey in acc) {\r\n            return acc[propKey];\r\n        }\r\n        return fallback;\r\n    }, object);\r\n    return resolvedValue;\r\n}\r\n/**\r\n * Sets a nested property value in a path, creates the path properties if it doesn't exist\r\n */\r\nfunction setInPath(object, path, value) {\r\n    if (isNotNestedPath(path)) {\r\n        object[cleanupNonNestedPath(path)] = value;\r\n        return;\r\n    }\r\n    const keys = path.split(/\\.|\\[(\\d+)\\]/).filter(Boolean);\r\n    let acc = object;\r\n    for (let i = 0; i < keys.length; i++) {\r\n        // Last key, set it\r\n        if (i === keys.length - 1) {\r\n            acc[keys[i]] = value;\r\n            return;\r\n        }\r\n        // Key does not exist, create a container for it\r\n        if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {\r\n            // container can be either an object or an array depending on the next key if it exists\r\n            acc[keys[i]] = isIndex(keys[i + 1]) ? [] : {};\r\n        }\r\n        acc = acc[keys[i]];\r\n    }\r\n}\r\nfunction unset(object, key) {\r\n    if (Array.isArray(object) && isIndex(key)) {\r\n        object.splice(Number(key), 1);\r\n        return;\r\n    }\r\n    if (isObject(object)) {\r\n        delete object[key];\r\n    }\r\n}\r\n/**\r\n * Removes a nested property from object\r\n */\r\nfunction unsetPath(object, path) {\r\n    if (isNotNestedPath(path)) {\r\n        delete object[cleanupNonNestedPath(path)];\r\n        return;\r\n    }\r\n    const keys = path.split(/\\.|\\[(\\d+)\\]/).filter(Boolean);\r\n    let acc = object;\r\n    for (let i = 0; i < keys.length; i++) {\r\n        // Last key, unset it\r\n        if (i === keys.length - 1) {\r\n            unset(acc, keys[i]);\r\n            break;\r\n        }\r\n        // Key does not exist, exit\r\n        if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {\r\n            break;\r\n        }\r\n        acc = acc[keys[i]];\r\n    }\r\n    const pathValues = keys.map((_, idx) => {\r\n        return getFromPath(object, keys.slice(0, idx).join('.'));\r\n    });\r\n    for (let i = pathValues.length - 1; i >= 0; i--) {\r\n        if (!isEmptyContainer(pathValues[i])) {\r\n            continue;\r\n        }\r\n        if (i === 0) {\r\n            unset(object, keys[0]);\r\n            continue;\r\n        }\r\n        unset(pathValues[i - 1], keys[i - 1]);\r\n    }\r\n}\r\n/**\r\n * A typed version of Object.keys\r\n */\r\nfunction keysOf(record) {\r\n    return Object.keys(record);\r\n}\r\n// Uses same component provide as its own injections\r\n// Due to changes in https://github.com/vuejs/vue-next/pull/2424\r\nfunction injectWithSelf(symbol, def = undefined) {\r\n    const vm = getCurrentInstance();\r\n    return (vm === null || vm === void 0 ? void 0 : vm.provides[symbol]) || inject(symbol, def);\r\n}\r\nfunction warn(message) {\r\n    warn$1(`[vee-validate]: ${message}`);\r\n}\r\n/**\r\n * Ensures we deal with a singular field value\r\n */\r\nfunction normalizeField(field) {\r\n    if (Array.isArray(field)) {\r\n        return field[0];\r\n    }\r\n    return field;\r\n}\r\nfunction resolveNextCheckboxValue(currentValue, checkedValue, uncheckedValue) {\r\n    if (Array.isArray(currentValue)) {\r\n        const newVal = [...currentValue];\r\n        // Use isEqual since checked object values can possibly fail the equality check #3883\r\n        const idx = newVal.findIndex(v => isEqual(v, checkedValue));\r\n        idx >= 0 ? newVal.splice(idx, 1) : newVal.push(checkedValue);\r\n        return newVal;\r\n    }\r\n    return isEqual(currentValue, checkedValue) ? uncheckedValue : checkedValue;\r\n}\r\n/**\r\n * Creates a throttled function that only invokes the provided function (`func`) at most once per within a given number of milliseconds\r\n * (`limit`)\r\n */\r\nfunction throttle(func, limit) {\r\n    let inThrottle;\r\n    let lastResult;\r\n    return function (...args) {\r\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\r\n        const context = this;\r\n        if (!inThrottle) {\r\n            inThrottle = true;\r\n            setTimeout(() => (inThrottle = false), limit);\r\n            lastResult = func.apply(context, args);\r\n        }\r\n        return lastResult;\r\n    };\r\n}\r\nfunction debounceAsync(inner, ms = 0) {\r\n    let timer = null;\r\n    let resolves = [];\r\n    return function (...args) {\r\n        // Run the function after a certain amount of time\r\n        if (timer) {\r\n            window.clearTimeout(timer);\r\n        }\r\n        timer = window.setTimeout(() => {\r\n            // Get the result of the inner function, then apply it to the resolve function of\r\n            // each promise that has been created since the last time the inner function was run\r\n            const result = inner(...args);\r\n            resolves.forEach(r => r(result));\r\n            resolves = [];\r\n        }, ms);\r\n        return new Promise(resolve => resolves.push(resolve));\r\n    };\r\n}\r\nfunction applyModelModifiers(value, modifiers) {\r\n    if (!isObject(modifiers)) {\r\n        return value;\r\n    }\r\n    if (modifiers.number) {\r\n        return toNumber(value);\r\n    }\r\n    return value;\r\n}\r\nfunction withLatest(fn, onDone) {\r\n    let latestRun;\r\n    return async function runLatest(...args) {\r\n        const pending = fn(...args);\r\n        latestRun = pending;\r\n        const result = await pending;\r\n        if (pending !== latestRun) {\r\n            return result;\r\n        }\r\n        latestRun = undefined;\r\n        onDone(result, args);\r\n        return result;\r\n    };\r\n}\r\nfunction computedDeep({ get, set }) {\r\n    const baseRef = ref(klona(get()));\r\n    watch(get, newValue => {\r\n        if (isEqual(newValue, baseRef.value)) {\r\n            return;\r\n        }\r\n        baseRef.value = klona(newValue);\r\n    }, {\r\n        deep: true,\r\n    });\r\n    watch(baseRef, newValue => {\r\n        if (isEqual(newValue, get())) {\r\n            return;\r\n        }\r\n        set(klona(newValue));\r\n    }, {\r\n        deep: true,\r\n    });\r\n    return baseRef;\r\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nconst normalizeChildren = (tag, context, slotProps) => {\r\n    if (!context.slots.default) {\r\n        return context.slots.default;\r\n    }\r\n    if (typeof tag === 'string' || !tag) {\r\n        return context.slots.default(slotProps());\r\n    }\r\n    return {\r\n        default: () => { var _a, _b; return (_b = (_a = context.slots).default) === null || _b === void 0 ? void 0 : _b.call(_a, slotProps()); },\r\n    };\r\n};\r\n/**\r\n * Vue adds a `_value` prop at the moment on the input elements to store the REAL value on them, real values are different than the `value` attribute\r\n * as they do not get casted to strings unlike `el.value` which preserves user-code behavior\r\n */\r\nfunction getBoundValue(el) {\r\n    if (hasValueBinding(el)) {\r\n        return el._value;\r\n    }\r\n    return undefined;\r\n}\r\n/**\r\n * Vue adds a `_value` prop at the moment on the input elements to store the REAL value on them, real values are different than the `value` attribute\r\n * as they do not get casted to strings unlike `el.value` which preserves user-code behavior\r\n */\r\nfunction hasValueBinding(el) {\r\n    return '_value' in el;\r\n}\n\nfunction normalizeEventValue(value) {\r\n    if (!isEvent(value)) {\r\n        return value;\r\n    }\r\n    const input = value.target;\r\n    // Vue sets the current bound value on `_value` prop\r\n    // for checkboxes it it should fetch the value binding type as is (boolean instead of string)\r\n    if (hasCheckedAttr(input.type) && hasValueBinding(input)) {\r\n        return getBoundValue(input);\r\n    }\r\n    if (input.type === 'file' && input.files) {\r\n        const files = Array.from(input.files);\r\n        return input.multiple ? files : files[0];\r\n    }\r\n    if (isNativeMultiSelect(input)) {\r\n        return Array.from(input.options)\r\n            .filter(opt => opt.selected && !opt.disabled)\r\n            .map(getBoundValue);\r\n    }\r\n    // makes sure we get the actual `option` bound value\r\n    // #3440\r\n    if (isNativeSelect(input)) {\r\n        const selectedOption = Array.from(input.options).find(opt => opt.selected);\r\n        return selectedOption ? getBoundValue(selectedOption) : input.value;\r\n    }\r\n    return input.value;\r\n}\n\n/**\r\n * Normalizes the given rules expression.\r\n */\r\nfunction normalizeRules(rules) {\r\n    const acc = {};\r\n    Object.defineProperty(acc, '_$$isNormalized', {\r\n        value: true,\r\n        writable: false,\r\n        enumerable: false,\r\n        configurable: false,\r\n    });\r\n    if (!rules) {\r\n        return acc;\r\n    }\r\n    // Object is already normalized, skip.\r\n    if (isObject(rules) && rules._$$isNormalized) {\r\n        return rules;\r\n    }\r\n    if (isObject(rules)) {\r\n        return Object.keys(rules).reduce((prev, curr) => {\r\n            const params = normalizeParams(rules[curr]);\r\n            if (rules[curr] !== false) {\r\n                prev[curr] = buildParams(params);\r\n            }\r\n            return prev;\r\n        }, acc);\r\n    }\r\n    /* istanbul ignore if */\r\n    if (typeof rules !== 'string') {\r\n        return acc;\r\n    }\r\n    return rules.split('|').reduce((prev, rule) => {\r\n        const parsedRule = parseRule(rule);\r\n        if (!parsedRule.name) {\r\n            return prev;\r\n        }\r\n        prev[parsedRule.name] = buildParams(parsedRule.params);\r\n        return prev;\r\n    }, acc);\r\n}\r\n/**\r\n * Normalizes a rule param.\r\n */\r\nfunction normalizeParams(params) {\r\n    if (params === true) {\r\n        return [];\r\n    }\r\n    if (Array.isArray(params)) {\r\n        return params;\r\n    }\r\n    if (isObject(params)) {\r\n        return params;\r\n    }\r\n    return [params];\r\n}\r\nfunction buildParams(provided) {\r\n    const mapValueToLocator = (value) => {\r\n        // A target param using interpolation\r\n        if (typeof value === 'string' && value[0] === '@') {\r\n            return createLocator(value.slice(1));\r\n        }\r\n        return value;\r\n    };\r\n    if (Array.isArray(provided)) {\r\n        return provided.map(mapValueToLocator);\r\n    }\r\n    // #3073\r\n    if (provided instanceof RegExp) {\r\n        return [provided];\r\n    }\r\n    return Object.keys(provided).reduce((prev, key) => {\r\n        prev[key] = mapValueToLocator(provided[key]);\r\n        return prev;\r\n    }, {});\r\n}\r\n/**\r\n * Parses a rule string expression.\r\n */\r\nconst parseRule = (rule) => {\r\n    let params = [];\r\n    const name = rule.split(':')[0];\r\n    if (rule.includes(':')) {\r\n        params = rule.split(':').slice(1).join(':').split(',');\r\n    }\r\n    return { name, params };\r\n};\r\nfunction createLocator(value) {\r\n    const locator = (crossTable) => {\r\n        const val = getFromPath(crossTable, value) || crossTable[value];\r\n        return val;\r\n    };\r\n    locator.__locatorRef = value;\r\n    return locator;\r\n}\r\nfunction extractLocators(params) {\r\n    if (Array.isArray(params)) {\r\n        return params.filter(isLocator);\r\n    }\r\n    return keysOf(params)\r\n        .filter(key => isLocator(params[key]))\r\n        .map(key => params[key]);\r\n}\n\nconst DEFAULT_CONFIG = {\r\n    generateMessage: ({ field }) => `${field} is not valid.`,\r\n    bails: true,\r\n    validateOnBlur: true,\r\n    validateOnChange: true,\r\n    validateOnInput: false,\r\n    validateOnModelUpdate: true,\r\n};\r\nlet currentConfig = Object.assign({}, DEFAULT_CONFIG);\r\nconst getConfig = () => currentConfig;\r\nconst setConfig = (newConf) => {\r\n    currentConfig = Object.assign(Object.assign({}, currentConfig), newConf);\r\n};\r\nconst configure = setConfig;\n\n/**\r\n * Validates a value against the rules.\r\n */\r\nasync function validate(value, rules, options = {}) {\r\n    const shouldBail = options === null || options === void 0 ? void 0 : options.bails;\r\n    const field = {\r\n        name: (options === null || options === void 0 ? void 0 : options.name) || '{field}',\r\n        rules,\r\n        bails: shouldBail !== null && shouldBail !== void 0 ? shouldBail : true,\r\n        formData: (options === null || options === void 0 ? void 0 : options.values) || {},\r\n    };\r\n    const result = await _validate(field, value);\r\n    const errors = result.errors;\r\n    return {\r\n        errors,\r\n        valid: !errors.length,\r\n    };\r\n}\r\n/**\r\n * Starts the validation process.\r\n */\r\nasync function _validate(field, value) {\r\n    if (isYupValidator(field.rules)) {\r\n        return validateFieldWithYup(value, field.rules, { bails: field.bails });\r\n    }\r\n    // if a generic function or chain of generic functions\r\n    if (isCallable(field.rules) || Array.isArray(field.rules)) {\r\n        const ctx = {\r\n            field: field.name,\r\n            form: field.formData,\r\n            value: value,\r\n        };\r\n        // Normalize the pipeline\r\n        const pipeline = Array.isArray(field.rules) ? field.rules : [field.rules];\r\n        const length = pipeline.length;\r\n        const errors = [];\r\n        for (let i = 0; i < length; i++) {\r\n            const rule = pipeline[i];\r\n            const result = await rule(value, ctx);\r\n            const isValid = typeof result !== 'string' && result;\r\n            if (isValid) {\r\n                continue;\r\n            }\r\n            const message = typeof result === 'string' ? result : _generateFieldError(ctx);\r\n            errors.push(message);\r\n            if (field.bails) {\r\n                return {\r\n                    errors,\r\n                };\r\n            }\r\n        }\r\n        return {\r\n            errors,\r\n        };\r\n    }\r\n    const normalizedContext = Object.assign(Object.assign({}, field), { rules: normalizeRules(field.rules) });\r\n    const errors = [];\r\n    const rulesKeys = Object.keys(normalizedContext.rules);\r\n    const length = rulesKeys.length;\r\n    for (let i = 0; i < length; i++) {\r\n        const rule = rulesKeys[i];\r\n        const result = await _test(normalizedContext, value, {\r\n            name: rule,\r\n            params: normalizedContext.rules[rule],\r\n        });\r\n        if (result.error) {\r\n            errors.push(result.error);\r\n            if (field.bails) {\r\n                return {\r\n                    errors,\r\n                };\r\n            }\r\n        }\r\n    }\r\n    return {\r\n        errors,\r\n    };\r\n}\r\n/**\r\n * Handles yup validation\r\n */\r\nasync function validateFieldWithYup(value, validator, opts) {\r\n    var _a;\r\n    const errors = await validator\r\n        .validate(value, {\r\n        abortEarly: (_a = opts.bails) !== null && _a !== void 0 ? _a : true,\r\n    })\r\n        .then(() => [])\r\n        .catch((err) => {\r\n        // Yup errors have a name prop one them.\r\n        // https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string\r\n        if (err.name === 'ValidationError') {\r\n            return err.errors;\r\n        }\r\n        // re-throw the error so we don't hide it\r\n        throw err;\r\n    });\r\n    return {\r\n        errors,\r\n    };\r\n}\r\n/**\r\n * Tests a single input value against a rule.\r\n */\r\nasync function _test(field, value, rule) {\r\n    const validator = resolveRule(rule.name);\r\n    if (!validator) {\r\n        throw new Error(`No such validator '${rule.name}' exists.`);\r\n    }\r\n    const params = fillTargetValues(rule.params, field.formData);\r\n    const ctx = {\r\n        field: field.name,\r\n        value,\r\n        form: field.formData,\r\n        rule: Object.assign(Object.assign({}, rule), { params }),\r\n    };\r\n    const result = await validator(value, params, ctx);\r\n    if (typeof result === 'string') {\r\n        return {\r\n            error: result,\r\n        };\r\n    }\r\n    return {\r\n        error: result ? undefined : _generateFieldError(ctx),\r\n    };\r\n}\r\n/**\r\n * Generates error messages.\r\n */\r\nfunction _generateFieldError(fieldCtx) {\r\n    const message = getConfig().generateMessage;\r\n    if (!message) {\r\n        return 'Field is invalid';\r\n    }\r\n    return message(fieldCtx);\r\n}\r\nfunction fillTargetValues(params, crossTable) {\r\n    const normalize = (value) => {\r\n        if (isLocator(value)) {\r\n            return value(crossTable);\r\n        }\r\n        return value;\r\n    };\r\n    if (Array.isArray(params)) {\r\n        return params.map(normalize);\r\n    }\r\n    return Object.keys(params).reduce((acc, param) => {\r\n        acc[param] = normalize(params[param]);\r\n        return acc;\r\n    }, {});\r\n}\r\nasync function validateYupSchema(schema, values) {\r\n    const errorObjects = await schema\r\n        .validate(values, { abortEarly: false })\r\n        .then(() => [])\r\n        .catch((err) => {\r\n        // Yup errors have a name prop one them.\r\n        // https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string\r\n        if (err.name !== 'ValidationError') {\r\n            throw err;\r\n        }\r\n        // list of aggregated errors\r\n        return err.inner || [];\r\n    });\r\n    const results = {};\r\n    const errors = {};\r\n    for (const error of errorObjects) {\r\n        const messages = error.errors;\r\n        results[error.path] = { valid: !messages.length, errors: messages };\r\n        if (messages.length) {\r\n            errors[error.path] = messages[0];\r\n        }\r\n    }\r\n    return {\r\n        valid: !errorObjects.length,\r\n        results,\r\n        errors,\r\n    };\r\n}\r\nasync function validateObjectSchema(schema, values, opts) {\r\n    const paths = keysOf(schema);\r\n    const validations = paths.map(async (path) => {\r\n        var _a, _b, _c;\r\n        const fieldResult = await validate(getFromPath(values, path), schema[path], {\r\n            name: ((_a = opts === null || opts === void 0 ? void 0 : opts.names) === null || _a === void 0 ? void 0 : _a[path]) || path,\r\n            values: values,\r\n            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,\r\n        });\r\n        return Object.assign(Object.assign({}, fieldResult), { path });\r\n    });\r\n    let isAllValid = true;\r\n    const validationResults = await Promise.all(validations);\r\n    const results = {};\r\n    const errors = {};\r\n    for (const result of validationResults) {\r\n        results[result.path] = {\r\n            valid: result.valid,\r\n            errors: result.errors,\r\n        };\r\n        if (!result.valid) {\r\n            isAllValid = false;\r\n            errors[result.path] = result.errors[0];\r\n        }\r\n    }\r\n    return {\r\n        valid: isAllValid,\r\n        results,\r\n        errors,\r\n    };\r\n}\n\nlet ID_COUNTER = 0;\r\nfunction useFieldState(path, init) {\r\n    const { value, initialValue, setInitialValue } = _useFieldValue(path, init.modelValue, init.form);\r\n    const { errorMessage, errors, setErrors } = _useFieldErrors(path, init.form);\r\n    const meta = _useFieldMeta(value, initialValue, errors);\r\n    const id = ID_COUNTER >= Number.MAX_SAFE_INTEGER ? 0 : ++ID_COUNTER;\r\n    function setState(state) {\r\n        var _a;\r\n        if ('value' in state) {\r\n            value.value = state.value;\r\n        }\r\n        if ('errors' in state) {\r\n            setErrors(state.errors);\r\n        }\r\n        if ('touched' in state) {\r\n            meta.touched = (_a = state.touched) !== null && _a !== void 0 ? _a : meta.touched;\r\n        }\r\n        if ('initialValue' in state) {\r\n            setInitialValue(state.initialValue);\r\n        }\r\n    }\r\n    return {\r\n        id,\r\n        path,\r\n        value,\r\n        initialValue,\r\n        meta,\r\n        errors,\r\n        errorMessage,\r\n        setState,\r\n    };\r\n}\r\n/**\r\n * Creates the field value and resolves the initial value\r\n */\r\nfunction _useFieldValue(path, modelValue, form) {\r\n    const modelRef = ref(unref(modelValue));\r\n    function resolveInitialValue() {\r\n        if (!form) {\r\n            return unref(modelRef);\r\n        }\r\n        return getFromPath(form.meta.value.initialValues, unref(path), unref(modelRef));\r\n    }\r\n    function setInitialValue(value) {\r\n        if (!form) {\r\n            modelRef.value = value;\r\n            return;\r\n        }\r\n        form.stageInitialValue(unref(path), value, true);\r\n    }\r\n    const initialValue = computed(resolveInitialValue);\r\n    // if no form is associated, use a regular ref.\r\n    if (!form) {\r\n        const value = ref(resolveInitialValue());\r\n        return {\r\n            value,\r\n            initialValue,\r\n            setInitialValue,\r\n        };\r\n    }\r\n    // to set the initial value, first check if there is a current value, if there is then use it.\r\n    // otherwise use the configured initial value if it exists.\r\n    // prioritize model value over form values\r\n    // #3429\r\n    const currentValue = modelValue ? unref(modelValue) : getFromPath(form.values, unref(path), unref(initialValue));\r\n    form.stageInitialValue(unref(path), currentValue, true);\r\n    // otherwise use a computed setter that triggers the `setFieldValue`\r\n    const value = computed({\r\n        get() {\r\n            return getFromPath(form.values, unref(path));\r\n        },\r\n        set(newVal) {\r\n            form.setFieldValue(unref(path), newVal);\r\n        },\r\n    });\r\n    return {\r\n        value,\r\n        initialValue,\r\n        setInitialValue,\r\n    };\r\n}\r\n/**\r\n * Creates meta flags state and some associated effects with them\r\n */\r\nfunction _useFieldMeta(currentValue, initialValue, errors) {\r\n    const meta = reactive({\r\n        touched: false,\r\n        pending: false,\r\n        valid: true,\r\n        validated: !!unref(errors).length,\r\n        initialValue: computed(() => unref(initialValue)),\r\n        dirty: computed(() => {\r\n            return !isEqual(unref(currentValue), unref(initialValue));\r\n        }),\r\n    });\r\n    watch(errors, value => {\r\n        meta.valid = !value.length;\r\n    }, {\r\n        immediate: true,\r\n        flush: 'sync',\r\n    });\r\n    return meta;\r\n}\r\n/**\r\n * Creates the error message state for the field state\r\n */\r\nfunction _useFieldErrors(path, form) {\r\n    function normalizeErrors(messages) {\r\n        if (!messages) {\r\n            return [];\r\n        }\r\n        return Array.isArray(messages) ? messages : [messages];\r\n    }\r\n    if (!form) {\r\n        const errors = ref([]);\r\n        return {\r\n            errors,\r\n            errorMessage: computed(() => errors.value[0]),\r\n            setErrors: (messages) => {\r\n                errors.value = normalizeErrors(messages);\r\n            },\r\n        };\r\n    }\r\n    const errors = computed(() => form.errorBag.value[unref(path)] || []);\r\n    return {\r\n        errors,\r\n        errorMessage: computed(() => errors.value[0]),\r\n        setErrors: (messages) => {\r\n            form.setFieldErrorBag(unref(path), normalizeErrors(messages));\r\n        },\r\n    };\r\n}\n\nfunction installDevtoolsPlugin(app) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        setupDevtoolsPlugin({\r\n            id: 'vee-validate-devtools-plugin',\r\n            label: 'VeeValidate Plugin',\r\n            packageName: 'vee-validate',\r\n            homepage: 'https://vee-validate.logaretm.com/v4',\r\n            app,\r\n            logo: 'https://vee-validate.logaretm.com/v4/logo.png',\r\n        }, setupApiHooks);\r\n    }\r\n}\r\nconst DEVTOOLS_FORMS = {};\r\nconst DEVTOOLS_FIELDS = {};\r\nlet API;\r\nconst refreshInspector = throttle(() => {\r\n    setTimeout(async () => {\r\n        await nextTick();\r\n        API === null || API === void 0 ? void 0 : API.sendInspectorState(INSPECTOR_ID);\r\n        API === null || API === void 0 ? void 0 : API.sendInspectorTree(INSPECTOR_ID);\r\n    }, 100);\r\n}, 100);\r\nfunction registerFormWithDevTools(form) {\r\n    const vm = getCurrentInstance();\r\n    if (!API) {\r\n        const app = vm === null || vm === void 0 ? void 0 : vm.appContext.app;\r\n        if (!app) {\r\n            return;\r\n        }\r\n        installDevtoolsPlugin(app);\r\n    }\r\n    DEVTOOLS_FORMS[form.formId] = Object.assign({}, form);\r\n    DEVTOOLS_FORMS[form.formId]._vm = vm;\r\n    onUnmounted(() => {\r\n        delete DEVTOOLS_FORMS[form.formId];\r\n        refreshInspector();\r\n    });\r\n    refreshInspector();\r\n}\r\nfunction registerSingleFieldWithDevtools(field) {\r\n    const vm = getCurrentInstance();\r\n    if (!API) {\r\n        const app = vm === null || vm === void 0 ? void 0 : vm.appContext.app;\r\n        if (!app) {\r\n            return;\r\n        }\r\n        installDevtoolsPlugin(app);\r\n    }\r\n    DEVTOOLS_FIELDS[field.id] = Object.assign({}, field);\r\n    DEVTOOLS_FIELDS[field.id]._vm = vm;\r\n    onUnmounted(() => {\r\n        delete DEVTOOLS_FIELDS[field.id];\r\n        refreshInspector();\r\n    });\r\n    refreshInspector();\r\n}\r\nconst INSPECTOR_ID = 'vee-validate-inspector';\r\nconst COLORS = {\r\n    error: 0xbd4b4b,\r\n    success: 0x06d77b,\r\n    unknown: 0x54436b,\r\n    white: 0xffffff,\r\n    black: 0x000000,\r\n    blue: 0x035397,\r\n    purple: 0xb980f0,\r\n    orange: 0xf5a962,\r\n    gray: 0xbbbfca,\r\n};\r\nlet SELECTED_NODE = null;\r\nfunction setupApiHooks(api) {\r\n    API = api;\r\n    api.addInspector({\r\n        id: INSPECTOR_ID,\r\n        icon: 'rule',\r\n        label: 'vee-validate',\r\n        noSelectionText: 'Select a vee-validate node to inspect',\r\n        actions: [\r\n            {\r\n                icon: 'done_outline',\r\n                tooltip: 'Validate selected item',\r\n                action: async () => {\r\n                    if (!SELECTED_NODE) {\r\n                        console.error('There is not a valid selected vee-validate node or component');\r\n                        return;\r\n                    }\r\n                    const result = await SELECTED_NODE.validate();\r\n                    console.log(result);\r\n                },\r\n            },\r\n            {\r\n                icon: 'delete_sweep',\r\n                tooltip: 'Clear validation state of the selected item',\r\n                action: () => {\r\n                    if (!SELECTED_NODE) {\r\n                        console.error('There is not a valid selected vee-validate node or component');\r\n                        return;\r\n                    }\r\n                    if ('id' in SELECTED_NODE) {\r\n                        SELECTED_NODE.resetField();\r\n                        return;\r\n                    }\r\n                    SELECTED_NODE.resetForm();\r\n                },\r\n            },\r\n        ],\r\n    });\r\n    api.on.getInspectorTree(payload => {\r\n        if (payload.inspectorId !== INSPECTOR_ID) {\r\n            return;\r\n        }\r\n        const forms = Object.values(DEVTOOLS_FORMS);\r\n        const fields = Object.values(DEVTOOLS_FIELDS);\r\n        payload.rootNodes = [\r\n            ...forms.map(mapFormForDevtoolsInspector),\r\n            ...fields.map(field => mapFieldForDevtoolsInspector(field)),\r\n        ];\r\n    });\r\n    api.on.getInspectorState((payload, ctx) => {\r\n        if (payload.inspectorId !== INSPECTOR_ID || ctx.currentTab !== `custom-inspector:${INSPECTOR_ID}`) {\r\n            return;\r\n        }\r\n        const { form, field, type } = decodeNodeId(payload.nodeId);\r\n        if (form && type === 'form') {\r\n            payload.state = buildFormState(form);\r\n            SELECTED_NODE = form;\r\n            return;\r\n        }\r\n        if (field && type === 'field') {\r\n            payload.state = buildFieldState(field);\r\n            SELECTED_NODE = field;\r\n            return;\r\n        }\r\n        SELECTED_NODE = null;\r\n    });\r\n}\r\nfunction mapFormForDevtoolsInspector(form) {\r\n    const { textColor, bgColor } = getTagTheme(form);\r\n    const formTreeNodes = {};\r\n    Object.values(form.fieldsByPath.value).forEach(field => {\r\n        const fieldInstance = Array.isArray(field) ? field[0] : field;\r\n        if (!fieldInstance) {\r\n            return;\r\n        }\r\n        setInPath(formTreeNodes, unref(fieldInstance.name), mapFieldForDevtoolsInspector(fieldInstance, form));\r\n    });\r\n    function buildFormTree(tree, path = []) {\r\n        const key = [...path].pop();\r\n        if ('id' in tree) {\r\n            return Object.assign(Object.assign({}, tree), { label: key || tree.label });\r\n        }\r\n        if (isObject(tree)) {\r\n            return {\r\n                id: `${path.join('.')}`,\r\n                label: key || '',\r\n                children: Object.keys(tree).map(key => buildFormTree(tree[key], [...path, key])),\r\n            };\r\n        }\r\n        if (Array.isArray(tree)) {\r\n            return {\r\n                id: `${path.join('.')}`,\r\n                label: `${key}[]`,\r\n                children: tree.map((c, idx) => buildFormTree(c, [...path, String(idx)])),\r\n            };\r\n        }\r\n        return { id: '', label: '', children: [] };\r\n    }\r\n    const { children } = buildFormTree(formTreeNodes);\r\n    return {\r\n        id: encodeNodeId(form),\r\n        label: 'Form',\r\n        children,\r\n        tags: [\r\n            {\r\n                label: 'Form',\r\n                textColor,\r\n                backgroundColor: bgColor,\r\n            },\r\n            {\r\n                label: `${Object.keys(form.fieldsByPath.value).length} fields`,\r\n                textColor: COLORS.white,\r\n                backgroundColor: COLORS.unknown,\r\n            },\r\n        ],\r\n    };\r\n}\r\nfunction mapFieldForDevtoolsInspector(field, form) {\r\n    const fieldInstance = normalizeField(field);\r\n    const { textColor, bgColor } = getTagTheme(fieldInstance);\r\n    const isGroup = Array.isArray(field) && field.length > 1;\r\n    return {\r\n        id: encodeNodeId(form, fieldInstance, !isGroup),\r\n        label: unref(fieldInstance.name),\r\n        children: Array.isArray(field) ? field.map(fieldItem => mapFieldForDevtoolsInspector(fieldItem, form)) : undefined,\r\n        tags: [\r\n            isGroup\r\n                ? undefined\r\n                : {\r\n                    label: 'Field',\r\n                    textColor,\r\n                    backgroundColor: bgColor,\r\n                },\r\n            !form\r\n                ? {\r\n                    label: 'Standalone',\r\n                    textColor: COLORS.black,\r\n                    backgroundColor: COLORS.gray,\r\n                }\r\n                : undefined,\r\n            !isGroup && fieldInstance.type === 'checkbox'\r\n                ? {\r\n                    label: 'Checkbox',\r\n                    textColor: COLORS.white,\r\n                    backgroundColor: COLORS.blue,\r\n                }\r\n                : undefined,\r\n            !isGroup && fieldInstance.type === 'radio'\r\n                ? {\r\n                    label: 'Radio',\r\n                    textColor: COLORS.white,\r\n                    backgroundColor: COLORS.purple,\r\n                }\r\n                : undefined,\r\n            isGroup\r\n                ? {\r\n                    label: 'Group',\r\n                    textColor: COLORS.black,\r\n                    backgroundColor: COLORS.orange,\r\n                }\r\n                : undefined,\r\n        ].filter(Boolean),\r\n    };\r\n}\r\nfunction encodeNodeId(form, field, encodeIndex = true) {\r\n    const fieldPath = form ? unref(field === null || field === void 0 ? void 0 : field.name) : field === null || field === void 0 ? void 0 : field.id;\r\n    const fieldGroup = fieldPath ? form === null || form === void 0 ? void 0 : form.fieldsByPath.value[fieldPath] : undefined;\r\n    let idx;\r\n    if (encodeIndex && field && Array.isArray(fieldGroup)) {\r\n        idx = fieldGroup.indexOf(field);\r\n    }\r\n    const idObject = { f: form === null || form === void 0 ? void 0 : form.formId, ff: fieldPath, idx, type: field ? 'field' : 'form' };\r\n    return btoa(JSON.stringify(idObject));\r\n}\r\nfunction decodeNodeId(nodeId) {\r\n    try {\r\n        const idObject = JSON.parse(atob(nodeId));\r\n        const form = DEVTOOLS_FORMS[idObject.f];\r\n        if (!form && idObject.ff) {\r\n            const field = DEVTOOLS_FIELDS[idObject.ff];\r\n            if (!field) {\r\n                return {};\r\n            }\r\n            return {\r\n                type: idObject.type,\r\n                field,\r\n            };\r\n        }\r\n        if (!form) {\r\n            return {};\r\n        }\r\n        const fieldGroup = form.fieldsByPath.value[idObject.ff];\r\n        return {\r\n            type: idObject.type,\r\n            form,\r\n            field: Array.isArray(fieldGroup) ? fieldGroup[idObject.idx || 0] : fieldGroup,\r\n        };\r\n    }\r\n    catch (err) {\r\n        // console.error(`Devtools: [vee-validate] Failed to parse node id ${nodeId}`);\r\n    }\r\n    return {};\r\n}\r\nfunction buildFieldState(field) {\r\n    const { errors, meta, value } = field;\r\n    return {\r\n        'Field state': [\r\n            { key: 'errors', value: errors.value },\r\n            {\r\n                key: 'initialValue',\r\n                value: meta.initialValue,\r\n            },\r\n            {\r\n                key: 'currentValue',\r\n                value: value.value,\r\n            },\r\n            {\r\n                key: 'touched',\r\n                value: meta.touched,\r\n            },\r\n            {\r\n                key: 'dirty',\r\n                value: meta.dirty,\r\n            },\r\n            {\r\n                key: 'valid',\r\n                value: meta.valid,\r\n            },\r\n        ],\r\n    };\r\n}\r\nfunction buildFormState(form) {\r\n    const { errorBag, meta, values, isSubmitting, submitCount } = form;\r\n    return {\r\n        'Form state': [\r\n            {\r\n                key: 'submitCount',\r\n                value: submitCount.value,\r\n            },\r\n            {\r\n                key: 'isSubmitting',\r\n                value: isSubmitting.value,\r\n            },\r\n            {\r\n                key: 'touched',\r\n                value: meta.value.touched,\r\n            },\r\n            {\r\n                key: 'dirty',\r\n                value: meta.value.dirty,\r\n            },\r\n            {\r\n                key: 'valid',\r\n                value: meta.value.valid,\r\n            },\r\n            {\r\n                key: 'initialValues',\r\n                value: meta.value.initialValues,\r\n            },\r\n            {\r\n                key: 'currentValues',\r\n                value: values,\r\n            },\r\n            {\r\n                key: 'errors',\r\n                value: keysOf(errorBag.value).reduce((acc, key) => {\r\n                    var _a;\r\n                    const message = (_a = errorBag.value[key]) === null || _a === void 0 ? void 0 : _a[0];\r\n                    if (message) {\r\n                        acc[key] = message;\r\n                    }\r\n                    return acc;\r\n                }, {}),\r\n            },\r\n        ],\r\n    };\r\n}\r\n/**\r\n * Resolves the tag color based on the form state\r\n */\r\nfunction getTagTheme(fieldOrForm) {\r\n    // const fallbackColors = {\r\n    //   bgColor: COLORS.unknown,\r\n    //   textColor: COLORS.white,\r\n    // };\r\n    const isValid = 'id' in fieldOrForm ? fieldOrForm.meta.valid : fieldOrForm.meta.value.valid;\r\n    return {\r\n        bgColor: isValid ? COLORS.success : COLORS.error,\r\n        textColor: isValid ? COLORS.black : COLORS.white,\r\n    };\r\n}\n\n/**\r\n * Creates a field composite.\r\n */\r\nfunction useField(name, rules, opts) {\r\n    if (hasCheckedAttr(opts === null || opts === void 0 ? void 0 : opts.type)) {\r\n        return useCheckboxField(name, rules, opts);\r\n    }\r\n    return _useField(name, rules, opts);\r\n}\r\nfunction _useField(name, rules, opts) {\r\n    const { initialValue: modelValue, validateOnMount, bails, type, checkedValue, label, validateOnValueUpdate, uncheckedValue, controlled, keepValueOnUnmount, modelPropName, syncVModel, form: controlForm, } = normalizeOptions(unref(name), opts);\r\n    const injectedForm = controlled ? injectWithSelf(FormContextKey) : undefined;\r\n    const form = controlForm || injectedForm;\r\n    // a flag indicating if the field is about to be removed/unmounted.\r\n    let markedForRemoval = false;\r\n    const { id, value, initialValue, meta, setState, errors, errorMessage } = useFieldState(name, {\r\n        modelValue,\r\n        form,\r\n    });\r\n    if (syncVModel) {\r\n        useVModel({ value, prop: modelPropName, handleChange });\r\n    }\r\n    /**\r\n     * Handles common onBlur meta update\r\n     */\r\n    const handleBlur = () => {\r\n        meta.touched = true;\r\n    };\r\n    const normalizedRules = computed(() => {\r\n        let rulesValue = unref(rules);\r\n        const schema = unref(form === null || form === void 0 ? void 0 : form.schema);\r\n        if (schema && !isYupValidator(schema)) {\r\n            rulesValue = extractRuleFromSchema(schema, unref(name)) || rulesValue;\r\n        }\r\n        if (isYupValidator(rulesValue) || isCallable(rulesValue) || Array.isArray(rulesValue)) {\r\n            return rulesValue;\r\n        }\r\n        return normalizeRules(rulesValue);\r\n    });\r\n    async function validateCurrentValue(mode) {\r\n        var _a, _b;\r\n        if (form === null || form === void 0 ? void 0 : form.validateSchema) {\r\n            return (_a = (await form.validateSchema(mode)).results[unref(name)]) !== null && _a !== void 0 ? _a : { valid: true, errors: [] };\r\n        }\r\n        return validate(value.value, normalizedRules.value, {\r\n            name: unref(label) || unref(name),\r\n            values: (_b = form === null || form === void 0 ? void 0 : form.values) !== null && _b !== void 0 ? _b : {},\r\n            bails,\r\n        });\r\n    }\r\n    const validateWithStateMutation = withLatest(async () => {\r\n        meta.pending = true;\r\n        meta.validated = true;\r\n        return validateCurrentValue('validated-only');\r\n    }, result => {\r\n        if (markedForRemoval) {\r\n            result.valid = true;\r\n            result.errors = [];\r\n        }\r\n        setState({ errors: result.errors });\r\n        meta.pending = false;\r\n        return result;\r\n    });\r\n    const validateValidStateOnly = withLatest(async () => {\r\n        return validateCurrentValue('silent');\r\n    }, result => {\r\n        if (markedForRemoval) {\r\n            result.valid = true;\r\n        }\r\n        meta.valid = result.valid;\r\n        return result;\r\n    });\r\n    function validate$1(opts) {\r\n        if ((opts === null || opts === void 0 ? void 0 : opts.mode) === 'silent') {\r\n            return validateValidStateOnly();\r\n        }\r\n        return validateWithStateMutation();\r\n    }\r\n    // Common input/change event handler\r\n    function handleChange(e, shouldValidate = true) {\r\n        const newValue = normalizeEventValue(e);\r\n        value.value = newValue;\r\n        if (!validateOnValueUpdate && shouldValidate) {\r\n            validateWithStateMutation();\r\n        }\r\n    }\r\n    // Runs the initial validation\r\n    onMounted(() => {\r\n        if (validateOnMount) {\r\n            return validateWithStateMutation();\r\n        }\r\n        // validate self initially if no form was handling this\r\n        // forms should have their own initial silent validation run to make things more efficient\r\n        if (!form || !form.validateSchema) {\r\n            validateValidStateOnly();\r\n        }\r\n    });\r\n    function setTouched(isTouched) {\r\n        meta.touched = isTouched;\r\n    }\r\n    let unwatchValue;\r\n    let lastWatchedValue = klona(value.value);\r\n    function watchValue() {\r\n        unwatchValue = watch(value, (val, oldVal) => {\r\n            if (isEqual(val, oldVal) && isEqual(val, lastWatchedValue)) {\r\n                return;\r\n            }\r\n            const validateFn = validateOnValueUpdate ? validateWithStateMutation : validateValidStateOnly;\r\n            validateFn();\r\n            lastWatchedValue = klona(val);\r\n        }, {\r\n            deep: true,\r\n        });\r\n    }\r\n    watchValue();\r\n    function resetField(state) {\r\n        var _a;\r\n        unwatchValue === null || unwatchValue === void 0 ? void 0 : unwatchValue();\r\n        const newValue = state && 'value' in state ? state.value : initialValue.value;\r\n        setState({\r\n            value: klona(newValue),\r\n            initialValue: klona(newValue),\r\n            touched: (_a = state === null || state === void 0 ? void 0 : state.touched) !== null && _a !== void 0 ? _a : false,\r\n            errors: (state === null || state === void 0 ? void 0 : state.errors) || [],\r\n        });\r\n        meta.pending = false;\r\n        meta.validated = false;\r\n        validateValidStateOnly();\r\n        // need to watch at next tick to avoid triggering the value watcher\r\n        nextTick(() => {\r\n            watchValue();\r\n        });\r\n    }\r\n    function setValue(newValue) {\r\n        value.value = newValue;\r\n    }\r\n    function setErrors(errors) {\r\n        setState({ errors: Array.isArray(errors) ? errors : [errors] });\r\n    }\r\n    const field = {\r\n        id,\r\n        name,\r\n        label,\r\n        value,\r\n        meta,\r\n        errors,\r\n        errorMessage,\r\n        type,\r\n        checkedValue,\r\n        uncheckedValue,\r\n        bails,\r\n        keepValueOnUnmount,\r\n        resetField,\r\n        handleReset: () => resetField(),\r\n        validate: validate$1,\r\n        handleChange,\r\n        handleBlur,\r\n        setState,\r\n        setTouched,\r\n        setErrors,\r\n        setValue,\r\n    };\r\n    provide(FieldContextKey, field);\r\n    if (isRef(rules) && typeof unref(rules) !== 'function') {\r\n        watch(rules, (value, oldValue) => {\r\n            if (isEqual(value, oldValue)) {\r\n                return;\r\n            }\r\n            meta.validated ? validateWithStateMutation() : validateValidStateOnly();\r\n        }, {\r\n            deep: true,\r\n        });\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        field._vm = getCurrentInstance();\r\n        watch(() => (Object.assign(Object.assign({ errors: errors.value }, meta), { value: value.value })), refreshInspector, {\r\n            deep: true,\r\n        });\r\n        if (!form) {\r\n            registerSingleFieldWithDevtools(field);\r\n        }\r\n    }\r\n    // if no associated form return the field API immediately\r\n    if (!form) {\r\n        return field;\r\n    }\r\n    // associate the field with the given form\r\n    form.register(field);\r\n    onBeforeUnmount(() => {\r\n        markedForRemoval = true;\r\n        form.unregister(field);\r\n    });\r\n    // extract cross-field dependencies in a computed prop\r\n    const dependencies = computed(() => {\r\n        const rulesVal = normalizedRules.value;\r\n        // is falsy, a function schema or a yup schema\r\n        if (!rulesVal || isCallable(rulesVal) || isYupValidator(rulesVal) || Array.isArray(rulesVal)) {\r\n            return {};\r\n        }\r\n        return Object.keys(rulesVal).reduce((acc, rule) => {\r\n            const deps = extractLocators(rulesVal[rule])\r\n                .map((dep) => dep.__locatorRef)\r\n                .reduce((depAcc, depName) => {\r\n                const depValue = getFromPath(form.values, depName) || form.values[depName];\r\n                if (depValue !== undefined) {\r\n                    depAcc[depName] = depValue;\r\n                }\r\n                return depAcc;\r\n            }, {});\r\n            Object.assign(acc, deps);\r\n            return acc;\r\n        }, {});\r\n    });\r\n    // Adds a watcher that runs the validation whenever field dependencies change\r\n    watch(dependencies, (deps, oldDeps) => {\r\n        // Skip if no dependencies or if the field wasn't manipulated\r\n        if (!Object.keys(deps).length) {\r\n            return;\r\n        }\r\n        const shouldValidate = !isEqual(deps, oldDeps);\r\n        if (shouldValidate) {\r\n            meta.validated ? validateWithStateMutation() : validateValidStateOnly();\r\n        }\r\n    });\r\n    return field;\r\n}\r\n/**\r\n * Normalizes partial field options to include the full options\r\n */\r\nfunction normalizeOptions(name, opts) {\r\n    const defaults = () => ({\r\n        initialValue: undefined,\r\n        validateOnMount: false,\r\n        bails: true,\r\n        label: name,\r\n        validateOnValueUpdate: true,\r\n        keepValueOnUnmount: undefined,\r\n        modelPropName: 'modelValue',\r\n        syncVModel: true,\r\n        controlled: true,\r\n    });\r\n    if (!opts) {\r\n        return defaults();\r\n    }\r\n    // TODO: Deprecate this in next major release\r\n    const checkedValue = 'valueProp' in opts ? opts.valueProp : opts.checkedValue;\r\n    const controlled = 'standalone' in opts ? !opts.standalone : opts.controlled;\r\n    return Object.assign(Object.assign(Object.assign({}, defaults()), (opts || {})), { controlled: controlled !== null && controlled !== void 0 ? controlled : true, checkedValue });\r\n}\r\n/**\r\n * Extracts the validation rules from a schema\r\n */\r\nfunction extractRuleFromSchema(schema, fieldName) {\r\n    // no schema at all\r\n    if (!schema) {\r\n        return undefined;\r\n    }\r\n    // there is a key on the schema object for this field\r\n    return schema[fieldName];\r\n}\r\nfunction useCheckboxField(name, rules, opts) {\r\n    const form = !(opts === null || opts === void 0 ? void 0 : opts.standalone) ? injectWithSelf(FormContextKey) : undefined;\r\n    const checkedValue = opts === null || opts === void 0 ? void 0 : opts.checkedValue;\r\n    const uncheckedValue = opts === null || opts === void 0 ? void 0 : opts.uncheckedValue;\r\n    function patchCheckboxApi(field) {\r\n        const handleChange = field.handleChange;\r\n        const checked = computed(() => {\r\n            const currentValue = unref(field.value);\r\n            const checkedVal = unref(checkedValue);\r\n            return Array.isArray(currentValue)\r\n                ? currentValue.findIndex(v => isEqual(v, checkedVal)) >= 0\r\n                : isEqual(checkedVal, currentValue);\r\n        });\r\n        function handleCheckboxChange(e, shouldValidate = true) {\r\n            var _a;\r\n            if (checked.value === ((_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.checked)) {\r\n                if (shouldValidate) {\r\n                    field.validate();\r\n                }\r\n                return;\r\n            }\r\n            let newValue = normalizeEventValue(e);\r\n            // Single checkbox field without a form to toggle it's value\r\n            if (!form) {\r\n                newValue = resolveNextCheckboxValue(unref(field.value), unref(checkedValue), unref(uncheckedValue));\r\n            }\r\n            handleChange(newValue, shouldValidate);\r\n        }\r\n        return Object.assign(Object.assign({}, field), { checked,\r\n            checkedValue,\r\n            uncheckedValue, handleChange: handleCheckboxChange });\r\n    }\r\n    return patchCheckboxApi(_useField(name, rules, opts));\r\n}\r\nfunction useVModel({ prop, value, handleChange }) {\r\n    const vm = getCurrentInstance();\r\n    /* istanbul ignore next */\r\n    if (!vm) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn('Failed to setup model events because `useField` was not called in setup.');\r\n        }\r\n        return;\r\n    }\r\n    const propName = prop || 'modelValue';\r\n    const emitName = `update:${propName}`;\r\n    // Component doesn't have a model prop setup (must be defined on the props)\r\n    if (!(propName in vm.props)) {\r\n        return;\r\n    }\r\n    watch(value, newValue => {\r\n        if (isEqual(newValue, getCurrentModelValue(vm, propName))) {\r\n            return;\r\n        }\r\n        vm.emit(emitName, newValue);\r\n    });\r\n    watch(() => getCurrentModelValue(vm, propName), propValue => {\r\n        if (propValue === IS_ABSENT && value.value === undefined) {\r\n            return;\r\n        }\r\n        const newValue = propValue === IS_ABSENT ? undefined : propValue;\r\n        if (isEqual(newValue, applyModelModifiers(value.value, vm.props.modelModifiers))) {\r\n            return;\r\n        }\r\n        handleChange(newValue);\r\n    });\r\n}\r\nfunction getCurrentModelValue(vm, propName) {\r\n    return vm.props[propName];\r\n}\n\nconst FieldImpl = defineComponent({\r\n    name: 'Field',\r\n    inheritAttrs: false,\r\n    props: {\r\n        as: {\r\n            type: [String, Object],\r\n            default: undefined,\r\n        },\r\n        name: {\r\n            type: String,\r\n            required: true,\r\n        },\r\n        rules: {\r\n            type: [Object, String, Function],\r\n            default: undefined,\r\n        },\r\n        validateOnMount: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n        validateOnBlur: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        validateOnChange: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        validateOnInput: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        validateOnModelUpdate: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n        bails: {\r\n            type: Boolean,\r\n            default: () => getConfig().bails,\r\n        },\r\n        label: {\r\n            type: String,\r\n            default: undefined,\r\n        },\r\n        uncheckedValue: {\r\n            type: null,\r\n            default: undefined,\r\n        },\r\n        modelValue: {\r\n            type: null,\r\n            default: IS_ABSENT,\r\n        },\r\n        modelModifiers: {\r\n            type: null,\r\n            default: () => ({}),\r\n        },\r\n        'onUpdate:modelValue': {\r\n            type: null,\r\n            default: undefined,\r\n        },\r\n        standalone: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n        keepValue: {\r\n            type: Boolean,\r\n            default: undefined,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const rules = toRef(props, 'rules');\r\n        const name = toRef(props, 'name');\r\n        const label = toRef(props, 'label');\r\n        const uncheckedValue = toRef(props, 'uncheckedValue');\r\n        const keepValue = toRef(props, 'keepValue');\r\n        const { errors, value, errorMessage, validate: validateField, handleChange, handleBlur, setTouched, resetField, handleReset, meta, checked, setErrors, } = useField(name, rules, {\r\n            validateOnMount: props.validateOnMount,\r\n            bails: props.bails,\r\n            standalone: props.standalone,\r\n            type: ctx.attrs.type,\r\n            initialValue: resolveInitialValue(props, ctx),\r\n            // Only for checkboxes and radio buttons\r\n            checkedValue: ctx.attrs.value,\r\n            uncheckedValue,\r\n            label,\r\n            validateOnValueUpdate: false,\r\n            keepValueOnUnmount: keepValue,\r\n        });\r\n        // If there is a v-model applied on the component we need to emit the `update:modelValue` whenever the value binding changes\r\n        const onChangeHandler = function handleChangeWithModel(e, shouldValidate = true) {\r\n            handleChange(e, shouldValidate);\r\n            ctx.emit('update:modelValue', value.value);\r\n        };\r\n        const handleInput = (e) => {\r\n            if (!hasCheckedAttr(ctx.attrs.type)) {\r\n                value.value = normalizeEventValue(e);\r\n            }\r\n        };\r\n        const onInputHandler = function handleInputWithModel(e) {\r\n            handleInput(e);\r\n            ctx.emit('update:modelValue', value.value);\r\n        };\r\n        const fieldProps = computed(() => {\r\n            const { validateOnInput, validateOnChange, validateOnBlur, validateOnModelUpdate } = resolveValidationTriggers(props);\r\n            const baseOnBlur = [handleBlur, ctx.attrs.onBlur, validateOnBlur ? validateField : undefined].filter(Boolean);\r\n            const baseOnInput = [(e) => onChangeHandler(e, validateOnInput), ctx.attrs.onInput].filter(Boolean);\r\n            const baseOnChange = [(e) => onChangeHandler(e, validateOnChange), ctx.attrs.onChange].filter(Boolean);\r\n            const attrs = {\r\n                name: props.name,\r\n                onBlur: baseOnBlur,\r\n                onInput: baseOnInput,\r\n                onChange: baseOnChange,\r\n            };\r\n            attrs['onUpdate:modelValue'] = e => onChangeHandler(e, validateOnModelUpdate);\r\n            if (hasCheckedAttr(ctx.attrs.type) && checked) {\r\n                attrs.checked = checked.value;\r\n            }\r\n            const tag = resolveTag(props, ctx);\r\n            if (shouldHaveValueBinding(tag, ctx.attrs)) {\r\n                attrs.value = value.value;\r\n            }\r\n            return attrs;\r\n        });\r\n        function slotProps() {\r\n            return {\r\n                field: fieldProps.value,\r\n                value: value.value,\r\n                meta,\r\n                errors: errors.value,\r\n                errorMessage: errorMessage.value,\r\n                validate: validateField,\r\n                resetField,\r\n                handleChange: onChangeHandler,\r\n                handleInput: onInputHandler,\r\n                handleReset,\r\n                handleBlur,\r\n                setTouched,\r\n                setErrors,\r\n            };\r\n        }\r\n        ctx.expose({\r\n            setErrors,\r\n            setTouched,\r\n            reset: resetField,\r\n            validate: validateField,\r\n            handleChange,\r\n        });\r\n        return () => {\r\n            const tag = resolveDynamicComponent(resolveTag(props, ctx));\r\n            const children = normalizeChildren(tag, ctx, slotProps);\r\n            if (tag) {\r\n                return h(tag, Object.assign(Object.assign({}, ctx.attrs), fieldProps.value), children);\r\n            }\r\n            return children;\r\n        };\r\n    },\r\n});\r\nfunction resolveTag(props, ctx) {\r\n    let tag = props.as || '';\r\n    if (!props.as && !ctx.slots.default) {\r\n        tag = 'input';\r\n    }\r\n    return tag;\r\n}\r\nfunction resolveValidationTriggers(props) {\r\n    var _a, _b, _c, _d;\r\n    const { validateOnInput, validateOnChange, validateOnBlur, validateOnModelUpdate } = getConfig();\r\n    return {\r\n        validateOnInput: (_a = props.validateOnInput) !== null && _a !== void 0 ? _a : validateOnInput,\r\n        validateOnChange: (_b = props.validateOnChange) !== null && _b !== void 0 ? _b : validateOnChange,\r\n        validateOnBlur: (_c = props.validateOnBlur) !== null && _c !== void 0 ? _c : validateOnBlur,\r\n        validateOnModelUpdate: (_d = props.validateOnModelUpdate) !== null && _d !== void 0 ? _d : validateOnModelUpdate,\r\n    };\r\n}\r\nfunction resolveInitialValue(props, ctx) {\r\n    // Gets the initial value either from `value` prop/attr or `v-model` binding (modelValue)\r\n    // For checkboxes and radio buttons it will always be the model value not the `value` attribute\r\n    if (!hasCheckedAttr(ctx.attrs.type)) {\r\n        return isPropPresent(props, 'modelValue') ? props.modelValue : ctx.attrs.value;\r\n    }\r\n    return isPropPresent(props, 'modelValue') ? props.modelValue : undefined;\r\n}\r\nconst Field = FieldImpl;\n\nlet FORM_COUNTER = 0;\r\nfunction useForm(opts) {\r\n    var _a;\r\n    const formId = FORM_COUNTER++;\r\n    const controlledModelPaths = new Set();\r\n    // Prevents fields from double resetting their values, which causes checkboxes to toggle their initial value\r\n    // TODO: This won't be needed if we centralize all the state inside the `form` for form inputs\r\n    let RESET_LOCK = false;\r\n    // A lookup containing fields or field groups\r\n    const fieldsByPath = ref({});\r\n    // If the form is currently submitting\r\n    const isSubmitting = ref(false);\r\n    // The number of times the user tried to submit the form\r\n    const submitCount = ref(0);\r\n    // field arrays managed by this form\r\n    const fieldArrays = [];\r\n    // a private ref for all form values\r\n    const formValues = reactive(klona(unref(opts === null || opts === void 0 ? void 0 : opts.initialValues) || {}));\r\n    // the source of errors for the form fields\r\n    const { errorBag, setErrorBag, setFieldErrorBag } = useErrorBag(opts === null || opts === void 0 ? void 0 : opts.initialErrors);\r\n    // Gets the first error of each field\r\n    const errors = computed(() => {\r\n        return keysOf(errorBag.value).reduce((acc, key) => {\r\n            const bag = errorBag.value[key];\r\n            if (bag && bag.length) {\r\n                acc[key] = bag[0];\r\n            }\r\n            return acc;\r\n        }, {});\r\n    });\r\n    function getFirstFieldAtPath(path) {\r\n        const fieldOrGroup = fieldsByPath.value[path];\r\n        return Array.isArray(fieldOrGroup) ? fieldOrGroup[0] : fieldOrGroup;\r\n    }\r\n    function fieldExists(path) {\r\n        return !!fieldsByPath.value[path];\r\n    }\r\n    /**\r\n     * Holds a computed reference to all fields names and labels\r\n     */\r\n    const fieldNames = computed(() => {\r\n        return keysOf(fieldsByPath.value).reduce((names, path) => {\r\n            const field = getFirstFieldAtPath(path);\r\n            if (field) {\r\n                names[path] = unref(field.label || field.name) || '';\r\n            }\r\n            return names;\r\n        }, {});\r\n    });\r\n    const fieldBailsMap = computed(() => {\r\n        return keysOf(fieldsByPath.value).reduce((map, path) => {\r\n            var _a;\r\n            const field = getFirstFieldAtPath(path);\r\n            if (field) {\r\n                map[path] = (_a = field.bails) !== null && _a !== void 0 ? _a : true;\r\n            }\r\n            return map;\r\n        }, {});\r\n    });\r\n    // mutable non-reactive reference to initial errors\r\n    // we need this to process initial errors then unset them\r\n    const initialErrors = Object.assign({}, ((opts === null || opts === void 0 ? void 0 : opts.initialErrors) || {}));\r\n    const keepValuesOnUnmount = (_a = opts === null || opts === void 0 ? void 0 : opts.keepValuesOnUnmount) !== null && _a !== void 0 ? _a : false;\r\n    // initial form values\r\n    const { initialValues, originalInitialValues, setInitialValues } = useFormInitialValues(fieldsByPath, formValues, opts === null || opts === void 0 ? void 0 : opts.initialValues);\r\n    // form meta aggregations\r\n    const meta = useFormMeta(fieldsByPath, formValues, originalInitialValues, errors);\r\n    const controlledValues = computed(() => {\r\n        return [...controlledModelPaths, ...keysOf(fieldsByPath.value)].reduce((acc, path) => {\r\n            const value = getFromPath(formValues, path);\r\n            setInPath(acc, path, value);\r\n            return acc;\r\n        }, {});\r\n    });\r\n    const schema = opts === null || opts === void 0 ? void 0 : opts.validationSchema;\r\n    /**\r\n     * Batches validation runs in 5ms batches\r\n     * Must have two distinct batch queues to make sure they don't override each other settings #3783\r\n     */\r\n    const debouncedSilentValidation = debounceAsync(_validateSchema, 5);\r\n    const debouncedValidation = debounceAsync(_validateSchema, 5);\r\n    const validateSchema = withLatest(async (mode) => {\r\n        return (await mode) === 'silent' ? debouncedSilentValidation() : debouncedValidation();\r\n    }, (formResult, [mode]) => {\r\n        // fields by id lookup\r\n        const fieldsById = formCtx.fieldsByPath.value || {};\r\n        // errors fields names, we need it to also check if custom errors are updated\r\n        const currentErrorsPaths = keysOf(formCtx.errorBag.value);\r\n        // collect all the keys from the schema and all fields\r\n        // this ensures we have a complete keymap of all the fields\r\n        const paths = [\r\n            ...new Set([...keysOf(formResult.results), ...keysOf(fieldsById), ...currentErrorsPaths]),\r\n        ];\r\n        // aggregates the paths into a single result object while applying the results on the fields\r\n        return paths.reduce((validation, path) => {\r\n            const field = fieldsById[path];\r\n            const messages = (formResult.results[path] || { errors: [] }).errors;\r\n            const fieldResult = {\r\n                errors: messages,\r\n                valid: !messages.length,\r\n            };\r\n            validation.results[path] = fieldResult;\r\n            if (!fieldResult.valid) {\r\n                validation.errors[path] = fieldResult.errors[0];\r\n            }\r\n            // field not rendered\r\n            if (!field) {\r\n                setFieldError(path, messages);\r\n                return validation;\r\n            }\r\n            // always update the valid flag regardless of the mode\r\n            applyFieldMutation(field, f => (f.meta.valid = fieldResult.valid));\r\n            if (mode === 'silent') {\r\n                return validation;\r\n            }\r\n            const wasValidated = Array.isArray(field) ? field.some(f => f.meta.validated) : field.meta.validated;\r\n            if (mode === 'validated-only' && !wasValidated) {\r\n                return validation;\r\n            }\r\n            applyFieldMutation(field, f => f.setState({ errors: fieldResult.errors }));\r\n            return validation;\r\n        }, { valid: formResult.valid, results: {}, errors: {} });\r\n    });\r\n    function makeSubmissionFactory(onlyControlled) {\r\n        return function submitHandlerFactory(fn, onValidationError) {\r\n            return function submissionHandler(e) {\r\n                if (e instanceof Event) {\r\n                    e.preventDefault();\r\n                    e.stopPropagation();\r\n                }\r\n                // Touch all fields\r\n                setTouched(keysOf(fieldsByPath.value).reduce((acc, field) => {\r\n                    acc[field] = true;\r\n                    return acc;\r\n                }, {}));\r\n                isSubmitting.value = true;\r\n                submitCount.value++;\r\n                return validate()\r\n                    .then(result => {\r\n                    const values = klona(formValues);\r\n                    if (result.valid && typeof fn === 'function') {\r\n                        const controlled = klona(controlledValues.value);\r\n                        return fn(onlyControlled ? controlled : values, {\r\n                            evt: e,\r\n                            controlledValues: controlled,\r\n                            setErrors,\r\n                            setFieldError,\r\n                            setTouched,\r\n                            setFieldTouched,\r\n                            setValues,\r\n                            setFieldValue,\r\n                            resetForm,\r\n                        });\r\n                    }\r\n                    if (!result.valid && typeof onValidationError === 'function') {\r\n                        onValidationError({\r\n                            values,\r\n                            evt: e,\r\n                            errors: result.errors,\r\n                            results: result.results,\r\n                        });\r\n                    }\r\n                })\r\n                    .then(returnVal => {\r\n                    isSubmitting.value = false;\r\n                    return returnVal;\r\n                }, err => {\r\n                    isSubmitting.value = false;\r\n                    // re-throw the err so it doesn't go silent\r\n                    throw err;\r\n                });\r\n            };\r\n        };\r\n    }\r\n    const handleSubmitImpl = makeSubmissionFactory(false);\r\n    const handleSubmit = handleSubmitImpl;\r\n    handleSubmit.withControlled = makeSubmissionFactory(true);\r\n    const formCtx = {\r\n        formId,\r\n        fieldsByPath,\r\n        values: formValues,\r\n        controlledValues,\r\n        errorBag,\r\n        errors,\r\n        schema,\r\n        submitCount,\r\n        meta,\r\n        isSubmitting,\r\n        fieldArrays,\r\n        keepValuesOnUnmount,\r\n        validateSchema: unref(schema) ? validateSchema : undefined,\r\n        validate,\r\n        register: registerField,\r\n        unregister: unregisterField,\r\n        setFieldErrorBag,\r\n        validateField,\r\n        setFieldValue,\r\n        setValues,\r\n        setErrors,\r\n        setFieldError,\r\n        setFieldTouched,\r\n        setTouched,\r\n        resetForm,\r\n        handleSubmit,\r\n        stageInitialValue,\r\n        unsetInitialValue,\r\n        setFieldInitialValue,\r\n        useFieldModel,\r\n    };\r\n    function isFieldGroup(fieldOrGroup) {\r\n        return Array.isArray(fieldOrGroup);\r\n    }\r\n    function applyFieldMutation(fieldOrGroup, mutation) {\r\n        if (Array.isArray(fieldOrGroup)) {\r\n            return fieldOrGroup.forEach(mutation);\r\n        }\r\n        return mutation(fieldOrGroup);\r\n    }\r\n    function mutateAllFields(mutation) {\r\n        Object.values(fieldsByPath.value).forEach(field => {\r\n            if (!field) {\r\n                return;\r\n            }\r\n            // avoid resetting the field values, because they should've been reset already.\r\n            applyFieldMutation(field, mutation);\r\n        });\r\n    }\r\n    /**\r\n     * Manually sets an error message on a specific field\r\n     */\r\n    function setFieldError(field, message) {\r\n        setFieldErrorBag(field, message);\r\n    }\r\n    /**\r\n     * Sets errors for the fields specified in the object\r\n     */\r\n    function setErrors(fields) {\r\n        setErrorBag(fields);\r\n    }\r\n    /**\r\n     * Sets a single field value\r\n     */\r\n    function setFieldValue(field, value, { force } = { force: false }) {\r\n        var _a;\r\n        const fieldInstance = fieldsByPath.value[field];\r\n        const clonedValue = klona(value);\r\n        // field wasn't found, create a virtual field as a placeholder\r\n        if (!fieldInstance) {\r\n            setInPath(formValues, field, clonedValue);\r\n            return;\r\n        }\r\n        if (isFieldGroup(fieldInstance) && ((_a = fieldInstance[0]) === null || _a === void 0 ? void 0 : _a.type) === 'checkbox' && !Array.isArray(value)) {\r\n            // Multiple checkboxes, and only one of them got updated\r\n            const newValue = klona(resolveNextCheckboxValue(getFromPath(formValues, field) || [], value, undefined));\r\n            setInPath(formValues, field, newValue);\r\n            return;\r\n        }\r\n        let newValue = value;\r\n        // Single Checkbox: toggles the field value unless the field is being reset then force it\r\n        if (!isFieldGroup(fieldInstance) && fieldInstance.type === 'checkbox' && !force && !RESET_LOCK) {\r\n            newValue = klona(resolveNextCheckboxValue(getFromPath(formValues, field), value, unref(fieldInstance.uncheckedValue)));\r\n        }\r\n        setInPath(formValues, field, newValue);\r\n    }\r\n    /**\r\n     * Sets multiple fields values\r\n     */\r\n    function setValues(fields) {\r\n        // clean up old values\r\n        keysOf(formValues).forEach(key => {\r\n            delete formValues[key];\r\n        });\r\n        // set up new values\r\n        keysOf(fields).forEach(path => {\r\n            setFieldValue(path, fields[path]);\r\n        });\r\n        // regenerate the arrays when the form values change\r\n        fieldArrays.forEach(f => f && f.reset());\r\n    }\r\n    function createModel(path) {\r\n        const { value } = _useFieldValue(path, undefined, formCtx);\r\n        watch(value, () => {\r\n            if (!fieldExists(unref(path))) {\r\n                validate({ mode: 'validated-only' });\r\n            }\r\n        }, {\r\n            deep: true,\r\n        });\r\n        controlledModelPaths.add(unref(path));\r\n        return value;\r\n    }\r\n    function useFieldModel(path) {\r\n        if (!Array.isArray(path)) {\r\n            return createModel(path);\r\n        }\r\n        return path.map(createModel);\r\n    }\r\n    /**\r\n     * Sets the touched meta state on a field\r\n     */\r\n    function setFieldTouched(field, isTouched) {\r\n        const fieldInstance = fieldsByPath.value[field];\r\n        if (fieldInstance) {\r\n            applyFieldMutation(fieldInstance, f => f.setTouched(isTouched));\r\n        }\r\n    }\r\n    /**\r\n     * Sets the touched meta state on multiple fields\r\n     */\r\n    function setTouched(fields) {\r\n        keysOf(fields).forEach(field => {\r\n            setFieldTouched(field, !!fields[field]);\r\n        });\r\n    }\r\n    /**\r\n     * Resets all fields\r\n     */\r\n    function resetForm(state) {\r\n        RESET_LOCK = true;\r\n        // Reset all field states first\r\n        mutateAllFields(f => f.resetField());\r\n        // set initial values if provided\r\n        if (state === null || state === void 0 ? void 0 : state.values) {\r\n            setInitialValues(state.values);\r\n            setValues(state === null || state === void 0 ? void 0 : state.values);\r\n        }\r\n        else {\r\n            // clean up the initial values back to the original\r\n            setInitialValues(originalInitialValues.value);\r\n            // otherwise clean the current values\r\n            setValues(originalInitialValues.value);\r\n        }\r\n        if (state === null || state === void 0 ? void 0 : state.touched) {\r\n            setTouched(state.touched);\r\n        }\r\n        setErrors((state === null || state === void 0 ? void 0 : state.errors) || {});\r\n        submitCount.value = (state === null || state === void 0 ? void 0 : state.submitCount) || 0;\r\n        nextTick(() => {\r\n            RESET_LOCK = false;\r\n        });\r\n    }\r\n    function insertFieldAtPath(field, path) {\r\n        const rawField = markRaw(field);\r\n        const fieldPath = path;\r\n        // first field at that path\r\n        if (!fieldsByPath.value[fieldPath]) {\r\n            fieldsByPath.value[fieldPath] = rawField;\r\n            return;\r\n        }\r\n        const fieldAtPath = fieldsByPath.value[fieldPath];\r\n        if (fieldAtPath && !Array.isArray(fieldAtPath)) {\r\n            fieldsByPath.value[fieldPath] = [fieldAtPath];\r\n        }\r\n        // add the new array to that path\r\n        fieldsByPath.value[fieldPath] = [...fieldsByPath.value[fieldPath], rawField];\r\n    }\r\n    function removeFieldFromPath(field, path) {\r\n        const fieldPath = path;\r\n        const fieldAtPath = fieldsByPath.value[fieldPath];\r\n        if (!fieldAtPath) {\r\n            return;\r\n        }\r\n        // same field at path\r\n        if (!isFieldGroup(fieldAtPath) && field.id === fieldAtPath.id) {\r\n            delete fieldsByPath.value[fieldPath];\r\n            return;\r\n        }\r\n        if (isFieldGroup(fieldAtPath)) {\r\n            const idx = fieldAtPath.findIndex(f => f.id === field.id);\r\n            if (idx === -1) {\r\n                return;\r\n            }\r\n            fieldAtPath.splice(idx, 1);\r\n            if (!fieldAtPath.length) {\r\n                delete fieldsByPath.value[fieldPath];\r\n            }\r\n        }\r\n    }\r\n    function registerField(field) {\r\n        const fieldPath = unref(field.name);\r\n        insertFieldAtPath(field, fieldPath);\r\n        if (isRef(field.name)) {\r\n            // ensures when a field's name was already taken that it preserves its same value\r\n            // necessary for fields generated by loops\r\n            watch(field.name, async (newPath, oldPath) => {\r\n                // cache the value\r\n                await nextTick();\r\n                removeFieldFromPath(field, oldPath);\r\n                insertFieldAtPath(field, newPath);\r\n                // re-validate if either path had errors before\r\n                if (errors.value[oldPath] || errors.value[newPath]) {\r\n                    // clear up both paths errors\r\n                    setFieldError(oldPath, undefined);\r\n                    validateField(newPath);\r\n                }\r\n                // clean up the old path if no other field is sharing that name\r\n                // #3325\r\n                await nextTick();\r\n                if (!fieldExists(oldPath)) {\r\n                    unsetPath(formValues, oldPath);\r\n                }\r\n            });\r\n        }\r\n        // if field already had errors (initial errors) that's not user-set, validate it again to ensure state is correct\r\n        // the difference being that `initialErrors` will contain the error message while other errors (pre-validated schema) won't have them as initial errors\r\n        // #3342\r\n        const initialErrorMessage = unref(field.errorMessage);\r\n        if (initialErrorMessage && (initialErrors === null || initialErrors === void 0 ? void 0 : initialErrors[fieldPath]) !== initialErrorMessage) {\r\n            validateField(fieldPath);\r\n        }\r\n        // marks the initial error as \"consumed\" so it won't be matched later with same non-initial error\r\n        delete initialErrors[fieldPath];\r\n    }\r\n    function unregisterField(field) {\r\n        const fieldName = unref(field.name);\r\n        const fieldInstance = fieldsByPath.value[fieldName];\r\n        const isGroup = !!fieldInstance && isFieldGroup(fieldInstance);\r\n        removeFieldFromPath(field, fieldName);\r\n        // clears a field error on unmounted\r\n        // we wait till next tick to make sure if the field is completely removed and doesn't have any siblings like checkboxes\r\n        nextTick(() => {\r\n            var _a;\r\n            const shouldKeepValue = (_a = unref(field.keepValueOnUnmount)) !== null && _a !== void 0 ? _a : unref(keepValuesOnUnmount);\r\n            const currentGroupValue = getFromPath(formValues, fieldName);\r\n            // The boolean here is we check if the field still belongs to the same control group with that name\r\n            // if another group claimed the name, we should avoid handling it since it is no longer the same group\r\n            // this happens with `v-for` over some checkboxes and field arrays.\r\n            // also if the group no longer exist we can assume this group was the last one that controlled it\r\n            const isSameGroup = isGroup && (fieldInstance === fieldsByPath.value[fieldName] || !fieldsByPath.value[fieldName]);\r\n            // group field that still has a dangling value, the field may exist or not after it was removed.\r\n            // This used to be handled in the useField composable but the form has better context on when it should/not happen.\r\n            // if it does belong to it that means the group still exists\r\n            // #3844\r\n            if (isSameGroup && !shouldKeepValue) {\r\n                if (Array.isArray(currentGroupValue)) {\r\n                    const valueIdx = currentGroupValue.findIndex(i => isEqual(i, unref(field.checkedValue)));\r\n                    if (valueIdx > -1) {\r\n                        const newVal = [...currentGroupValue];\r\n                        newVal.splice(valueIdx, 1);\r\n                        setFieldValue(fieldName, newVal, { force: true });\r\n                    }\r\n                }\r\n                else if (currentGroupValue === unref(field.checkedValue)) {\r\n                    // Remove field if it is a group but does not have an array value, like for radio inputs #3963\r\n                    unsetPath(formValues, fieldName);\r\n                }\r\n            }\r\n            // Field was removed entirely, we should unset its path\r\n            // #3384\r\n            if (!fieldExists(fieldName)) {\r\n                setFieldError(fieldName, undefined);\r\n                // Checks if the field was configured to be unset during unmount or not\r\n                // Checks both the form-level config and field-level one\r\n                // Field has the priority if it is set, otherwise it goes to the form settings\r\n                if (shouldKeepValue) {\r\n                    return;\r\n                }\r\n                // Don't apply emptyContainer check unless the current group value is an array\r\n                if (isGroup && Array.isArray(currentGroupValue) && !isEmptyContainer(currentGroupValue)) {\r\n                    return;\r\n                }\r\n                unsetPath(formValues, fieldName);\r\n            }\r\n        });\r\n    }\r\n    async function validate(opts) {\r\n        const mode = (opts === null || opts === void 0 ? void 0 : opts.mode) || 'force';\r\n        if (mode === 'force') {\r\n            mutateAllFields(f => (f.meta.validated = true));\r\n        }\r\n        if (formCtx.validateSchema) {\r\n            return formCtx.validateSchema(mode);\r\n        }\r\n        // No schema, each field is responsible to validate itself\r\n        const validations = await Promise.all(Object.values(fieldsByPath.value).map(field => {\r\n            const fieldInstance = Array.isArray(field) ? field[0] : field;\r\n            if (!fieldInstance) {\r\n                return Promise.resolve({ key: '', valid: true, errors: [] });\r\n            }\r\n            return fieldInstance.validate(opts).then((result) => {\r\n                return {\r\n                    key: unref(fieldInstance.name),\r\n                    valid: result.valid,\r\n                    errors: result.errors,\r\n                };\r\n            });\r\n        }));\r\n        const results = {};\r\n        const errors = {};\r\n        for (const validation of validations) {\r\n            results[validation.key] = {\r\n                valid: validation.valid,\r\n                errors: validation.errors,\r\n            };\r\n            if (validation.errors.length) {\r\n                errors[validation.key] = validation.errors[0];\r\n            }\r\n        }\r\n        return {\r\n            valid: validations.every(r => r.valid),\r\n            results,\r\n            errors,\r\n        };\r\n    }\r\n    async function validateField(field) {\r\n        const fieldInstance = fieldsByPath.value[field];\r\n        if (!fieldInstance) {\r\n            warn$1(`field with name ${field} was not found`);\r\n            return Promise.resolve({ errors: [], valid: true });\r\n        }\r\n        if (Array.isArray(fieldInstance)) {\r\n            return fieldInstance.map(f => f.validate())[0];\r\n        }\r\n        return fieldInstance.validate();\r\n    }\r\n    function unsetInitialValue(path) {\r\n        unsetPath(initialValues.value, path);\r\n    }\r\n    /**\r\n     * Sneaky function to set initial field values\r\n     */\r\n    function stageInitialValue(path, value, updateOriginal = false) {\r\n        setInPath(formValues, path, value);\r\n        setFieldInitialValue(path, value);\r\n        if (updateOriginal && !(opts === null || opts === void 0 ? void 0 : opts.initialValues)) {\r\n            setInPath(originalInitialValues.value, path, klona(value));\r\n        }\r\n    }\r\n    function setFieldInitialValue(path, value) {\r\n        setInPath(initialValues.value, path, klona(value));\r\n    }\r\n    async function _validateSchema() {\r\n        const schemaValue = unref(schema);\r\n        if (!schemaValue) {\r\n            return { valid: true, results: {}, errors: {} };\r\n        }\r\n        const formResult = isYupValidator(schemaValue)\r\n            ? await validateYupSchema(schemaValue, formValues)\r\n            : await validateObjectSchema(schemaValue, formValues, {\r\n                names: fieldNames.value,\r\n                bailsMap: fieldBailsMap.value,\r\n            });\r\n        return formResult;\r\n    }\r\n    const submitForm = handleSubmit((_, { evt }) => {\r\n        if (isFormSubmitEvent(evt)) {\r\n            evt.target.submit();\r\n        }\r\n    });\r\n    // Trigger initial validation\r\n    onMounted(() => {\r\n        if (opts === null || opts === void 0 ? void 0 : opts.initialErrors) {\r\n            setErrors(opts.initialErrors);\r\n        }\r\n        if (opts === null || opts === void 0 ? void 0 : opts.initialTouched) {\r\n            setTouched(opts.initialTouched);\r\n        }\r\n        // if validate on mount was enabled\r\n        if (opts === null || opts === void 0 ? void 0 : opts.validateOnMount) {\r\n            validate();\r\n            return;\r\n        }\r\n        // otherwise run initial silent validation through schema if available\r\n        // the useField should skip their own silent validation if a yup schema is present\r\n        if (formCtx.validateSchema) {\r\n            formCtx.validateSchema('silent');\r\n        }\r\n    });\r\n    if (isRef(schema)) {\r\n        watch(schema, () => {\r\n            var _a;\r\n            (_a = formCtx.validateSchema) === null || _a === void 0 ? void 0 : _a.call(formCtx, 'validated-only');\r\n        });\r\n    }\r\n    // Provide injections\r\n    provide(FormContextKey, formCtx);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        registerFormWithDevTools(formCtx);\r\n        watch(() => (Object.assign(Object.assign({ errors: errorBag.value }, meta.value), { values: formValues, isSubmitting: isSubmitting.value, submitCount: submitCount.value })), refreshInspector, {\r\n            deep: true,\r\n        });\r\n    }\r\n    return Object.assign(Object.assign({}, formCtx), { handleReset: () => resetForm(), submitForm });\r\n}\r\n/**\r\n * Manages form meta aggregation\r\n */\r\nfunction useFormMeta(fieldsByPath, currentValues, initialValues, errors) {\r\n    const MERGE_STRATEGIES = {\r\n        touched: 'some',\r\n        pending: 'some',\r\n        valid: 'every',\r\n    };\r\n    const isDirty = computed(() => {\r\n        return !isEqual(currentValues, unref(initialValues));\r\n    });\r\n    function calculateFlags() {\r\n        const fields = Object.values(fieldsByPath.value).flat(1).filter(Boolean);\r\n        return keysOf(MERGE_STRATEGIES).reduce((acc, flag) => {\r\n            const mergeMethod = MERGE_STRATEGIES[flag];\r\n            acc[flag] = fields[mergeMethod](field => field.meta[flag]);\r\n            return acc;\r\n        }, {});\r\n    }\r\n    const flags = reactive(calculateFlags());\r\n    watchEffect(() => {\r\n        const value = calculateFlags();\r\n        flags.touched = value.touched;\r\n        flags.valid = value.valid;\r\n        flags.pending = value.pending;\r\n    });\r\n    return computed(() => {\r\n        return Object.assign(Object.assign({ initialValues: unref(initialValues) }, flags), { valid: flags.valid && !keysOf(errors.value).length, dirty: isDirty.value });\r\n    });\r\n}\r\n/**\r\n * Manages the initial values prop\r\n */\r\nfunction useFormInitialValues(fields, formValues, providedValues) {\r\n    // these are the mutable initial values as the fields are mounted/unmounted\r\n    const initialValues = ref(klona(unref(providedValues)) || {});\r\n    // these are the original initial value as provided by the user initially, they don't keep track of conditional fields\r\n    // this is important because some conditional fields will overwrite the initial values for other fields who had the same name\r\n    // like array fields, any push/insert operation will overwrite the initial values because they \"create new fields\"\r\n    // so these are the values that the reset function should use\r\n    // these only change when the user explicitly chanegs the initial values or when the user resets them with new values.\r\n    const originalInitialValues = ref(klona(unref(providedValues)) || {});\r\n    function setInitialValues(values, updateFields = false) {\r\n        initialValues.value = klona(values);\r\n        originalInitialValues.value = klona(values);\r\n        if (!updateFields) {\r\n            return;\r\n        }\r\n        // update the pristine non-touched fields\r\n        // those are excluded because it's unlikely you want to change the form values using initial values\r\n        // we mostly watch them for API population or newly inserted fields\r\n        // if the user API is taking too much time before user interaction they should consider disabling or hiding their inputs until the values are ready\r\n        keysOf(fields.value).forEach(fieldPath => {\r\n            const field = fields.value[fieldPath];\r\n            const wasTouched = Array.isArray(field) ? field.some(f => f.meta.touched) : field === null || field === void 0 ? void 0 : field.meta.touched;\r\n            if (!field || wasTouched) {\r\n                return;\r\n            }\r\n            const newValue = getFromPath(initialValues.value, fieldPath);\r\n            setInPath(formValues, fieldPath, klona(newValue));\r\n        });\r\n    }\r\n    if (isRef(providedValues)) {\r\n        watch(providedValues, value => {\r\n            setInitialValues(value, true);\r\n        }, {\r\n            deep: true,\r\n        });\r\n    }\r\n    return {\r\n        initialValues,\r\n        originalInitialValues,\r\n        setInitialValues,\r\n    };\r\n}\r\nfunction useErrorBag(initialErrors) {\r\n    const errorBag = ref({});\r\n    function normalizeErrorItem(message) {\r\n        return Array.isArray(message) ? message : message ? [message] : [];\r\n    }\r\n    /**\r\n     * Manually sets an error message on a specific field\r\n     */\r\n    function setFieldErrorBag(field, message) {\r\n        if (!message) {\r\n            delete errorBag.value[field];\r\n            return;\r\n        }\r\n        errorBag.value[field] = normalizeErrorItem(message);\r\n    }\r\n    /**\r\n     * Sets errors for the fields specified in the object\r\n     */\r\n    function setErrorBag(fields) {\r\n        errorBag.value = keysOf(fields).reduce((acc, key) => {\r\n            const message = fields[key];\r\n            if (message) {\r\n                acc[key] = normalizeErrorItem(message);\r\n            }\r\n            return acc;\r\n        }, {});\r\n    }\r\n    if (initialErrors) {\r\n        setErrorBag(initialErrors);\r\n    }\r\n    return {\r\n        errorBag,\r\n        setErrorBag,\r\n        setFieldErrorBag,\r\n    };\r\n}\n\nconst FormImpl = defineComponent({\r\n    name: 'Form',\r\n    inheritAttrs: false,\r\n    props: {\r\n        as: {\r\n            type: String,\r\n            default: 'form',\r\n        },\r\n        validationSchema: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        initialValues: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        initialErrors: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        initialTouched: {\r\n            type: Object,\r\n            default: undefined,\r\n        },\r\n        validateOnMount: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n        onSubmit: {\r\n            type: Function,\r\n            default: undefined,\r\n        },\r\n        onInvalidSubmit: {\r\n            type: Function,\r\n            default: undefined,\r\n        },\r\n        keepValues: {\r\n            type: Boolean,\r\n            default: false,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const initialValues = toRef(props, 'initialValues');\r\n        const validationSchema = toRef(props, 'validationSchema');\r\n        const keepValues = toRef(props, 'keepValues');\r\n        const { errors, values, meta, isSubmitting, submitCount, controlledValues, validate, validateField, handleReset, resetForm, handleSubmit, setErrors, setFieldError, setFieldValue, setValues, setFieldTouched, setTouched, } = useForm({\r\n            validationSchema: validationSchema.value ? validationSchema : undefined,\r\n            initialValues,\r\n            initialErrors: props.initialErrors,\r\n            initialTouched: props.initialTouched,\r\n            validateOnMount: props.validateOnMount,\r\n            keepValuesOnUnmount: keepValues,\r\n        });\r\n        const submitForm = handleSubmit((_, { evt }) => {\r\n            if (isFormSubmitEvent(evt)) {\r\n                evt.target.submit();\r\n            }\r\n        }, props.onInvalidSubmit);\r\n        const onSubmit = props.onSubmit ? handleSubmit(props.onSubmit, props.onInvalidSubmit) : submitForm;\r\n        function handleFormReset(e) {\r\n            if (isEvent(e)) {\r\n                // Prevent default form reset behavior\r\n                e.preventDefault();\r\n            }\r\n            handleReset();\r\n            if (typeof ctx.attrs.onReset === 'function') {\r\n                ctx.attrs.onReset();\r\n            }\r\n        }\r\n        function handleScopedSlotSubmit(evt, onSubmit) {\r\n            const onSuccess = typeof evt === 'function' && !onSubmit ? evt : onSubmit;\r\n            return handleSubmit(onSuccess, props.onInvalidSubmit)(evt);\r\n        }\r\n        function slotProps() {\r\n            return {\r\n                meta: meta.value,\r\n                errors: errors.value,\r\n                values: values,\r\n                isSubmitting: isSubmitting.value,\r\n                submitCount: submitCount.value,\r\n                controlledValues: controlledValues.value,\r\n                validate,\r\n                validateField,\r\n                handleSubmit: handleScopedSlotSubmit,\r\n                handleReset,\r\n                submitForm,\r\n                setErrors,\r\n                setFieldError,\r\n                setFieldValue,\r\n                setValues,\r\n                setFieldTouched,\r\n                setTouched,\r\n                resetForm,\r\n            };\r\n        }\r\n        // expose these functions and methods as part of public API\r\n        ctx.expose({\r\n            setFieldError,\r\n            setErrors,\r\n            setFieldValue,\r\n            setValues,\r\n            setFieldTouched,\r\n            setTouched,\r\n            resetForm,\r\n            validate,\r\n            validateField,\r\n        });\r\n        return function renderForm() {\r\n            // avoid resolving the form component as itself\r\n            const tag = props.as === 'form' ? props.as : resolveDynamicComponent(props.as);\r\n            const children = normalizeChildren(tag, ctx, slotProps);\r\n            if (!props.as) {\r\n                return children;\r\n            }\r\n            // Attributes to add on a native `form` tag\r\n            const formAttrs = props.as === 'form'\r\n                ? {\r\n                    // Disables native validation as vee-validate will handle it.\r\n                    novalidate: true,\r\n                }\r\n                : {};\r\n            return h(tag, Object.assign(Object.assign(Object.assign({}, formAttrs), ctx.attrs), { onSubmit, onReset: handleFormReset }), children);\r\n        };\r\n    },\r\n});\r\nconst Form = FormImpl;\n\nfunction useFieldArray(arrayPath) {\r\n    const form = injectWithSelf(FormContextKey, undefined);\r\n    const fields = ref([]);\r\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\r\n    const noOp = () => { };\r\n    const noOpApi = {\r\n        fields,\r\n        remove: noOp,\r\n        push: noOp,\r\n        swap: noOp,\r\n        insert: noOp,\r\n        update: noOp,\r\n        replace: noOp,\r\n        prepend: noOp,\r\n        move: noOp,\r\n    };\r\n    if (!form) {\r\n        warn('FieldArray requires being a child of `<Form/>` or `useForm` being called before it. Array fields may not work correctly');\r\n        return noOpApi;\r\n    }\r\n    if (!unref(arrayPath)) {\r\n        warn('FieldArray requires a field path to be provided, did you forget to pass the `name` prop?');\r\n        return noOpApi;\r\n    }\r\n    const alreadyExists = form.fieldArrays.find(a => unref(a.path) === unref(arrayPath));\r\n    if (alreadyExists) {\r\n        return alreadyExists;\r\n    }\r\n    let entryCounter = 0;\r\n    function initFields() {\r\n        const currentValues = getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(arrayPath), []) || [];\r\n        fields.value = currentValues.map(createEntry);\r\n        updateEntryFlags();\r\n    }\r\n    initFields();\r\n    function updateEntryFlags() {\r\n        const fieldsLength = fields.value.length;\r\n        for (let i = 0; i < fieldsLength; i++) {\r\n            const entry = fields.value[i];\r\n            entry.isFirst = i === 0;\r\n            entry.isLast = i === fieldsLength - 1;\r\n        }\r\n    }\r\n    function createEntry(value) {\r\n        const key = entryCounter++;\r\n        const entry = {\r\n            key,\r\n            value: computedDeep({\r\n                get() {\r\n                    const currentValues = getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(arrayPath), []) || [];\r\n                    const idx = fields.value.findIndex(e => e.key === key);\r\n                    return idx === -1 ? value : currentValues[idx];\r\n                },\r\n                set(value) {\r\n                    const idx = fields.value.findIndex(e => e.key === key);\r\n                    if (idx === -1) {\r\n                        warn(`Attempting to update a non-existent array item`);\r\n                        return;\r\n                    }\r\n                    update(idx, value);\r\n                },\r\n            }),\r\n            isFirst: false,\r\n            isLast: false,\r\n        };\r\n        return entry;\r\n    }\r\n    function remove(idx) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!pathValue || !Array.isArray(pathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [...pathValue];\r\n        newValue.splice(idx, 1);\r\n        form === null || form === void 0 ? void 0 : form.unsetInitialValue(pathName + `[${idx}]`);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value.splice(idx, 1);\r\n        updateEntryFlags();\r\n    }\r\n    function push(value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        const normalizedPathValue = isNullOrUndefined(pathValue) ? [] : pathValue;\r\n        if (!Array.isArray(normalizedPathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [...normalizedPathValue];\r\n        newValue.push(value);\r\n        form === null || form === void 0 ? void 0 : form.stageInitialValue(pathName + `[${newValue.length - 1}]`, value);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value.push(createEntry(value));\r\n        updateEntryFlags();\r\n    }\r\n    function swap(indexA, indexB) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!Array.isArray(pathValue) || !(indexA in pathValue) || !(indexB in pathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [...pathValue];\r\n        const newFields = [...fields.value];\r\n        // the old switcheroo\r\n        const temp = newValue[indexA];\r\n        newValue[indexA] = newValue[indexB];\r\n        newValue[indexB] = temp;\r\n        const tempEntry = newFields[indexA];\r\n        newFields[indexA] = newFields[indexB];\r\n        newFields[indexB] = tempEntry;\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value = newFields;\r\n        updateEntryFlags();\r\n    }\r\n    function insert(idx, value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!Array.isArray(pathValue) || pathValue.length < idx) {\r\n            return;\r\n        }\r\n        const newValue = [...pathValue];\r\n        const newFields = [...fields.value];\r\n        newValue.splice(idx, 0, value);\r\n        newFields.splice(idx, 0, createEntry(value));\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value = newFields;\r\n        updateEntryFlags();\r\n    }\r\n    function replace(arr) {\r\n        const pathName = unref(arrayPath);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, arr);\r\n        initFields();\r\n    }\r\n    function update(idx, value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        if (!Array.isArray(pathValue) || pathValue.length - 1 < idx) {\r\n            return;\r\n        }\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(`${pathName}[${idx}]`, value);\r\n        form === null || form === void 0 ? void 0 : form.validate({ mode: 'validated-only' });\r\n    }\r\n    function prepend(value) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        const normalizedPathValue = isNullOrUndefined(pathValue) ? [] : pathValue;\r\n        if (!Array.isArray(normalizedPathValue)) {\r\n            return;\r\n        }\r\n        const newValue = [value, ...normalizedPathValue];\r\n        form === null || form === void 0 ? void 0 : form.stageInitialValue(pathName + `[${newValue.length - 1}]`, value);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value.unshift(createEntry(value));\r\n        updateEntryFlags();\r\n    }\r\n    function move(oldIdx, newIdx) {\r\n        const pathName = unref(arrayPath);\r\n        const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);\r\n        const newValue = isNullOrUndefined(pathValue) ? [] : [...pathValue];\r\n        if (!Array.isArray(pathValue) || !(oldIdx in pathValue) || !(newIdx in pathValue)) {\r\n            return;\r\n        }\r\n        const newFields = [...fields.value];\r\n        const movedItem = newFields[oldIdx];\r\n        newFields.splice(oldIdx, 1);\r\n        newFields.splice(newIdx, 0, movedItem);\r\n        const movedValue = newValue[oldIdx];\r\n        newValue.splice(oldIdx, 1);\r\n        newValue.splice(newIdx, 0, movedValue);\r\n        form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);\r\n        fields.value = newFields;\r\n        updateEntryFlags();\r\n    }\r\n    const fieldArrayCtx = {\r\n        fields,\r\n        remove,\r\n        push,\r\n        swap,\r\n        insert,\r\n        update,\r\n        replace,\r\n        prepend,\r\n        move,\r\n    };\r\n    form.fieldArrays.push(Object.assign({ path: arrayPath, reset: initFields }, fieldArrayCtx));\r\n    onBeforeUnmount(() => {\r\n        const idx = form.fieldArrays.findIndex(i => unref(i.path) === unref(arrayPath));\r\n        if (idx >= 0) {\r\n            form.fieldArrays.splice(idx, 1);\r\n        }\r\n    });\r\n    return fieldArrayCtx;\r\n}\n\nconst FieldArrayImpl = defineComponent({\r\n    name: 'FieldArray',\r\n    inheritAttrs: false,\r\n    props: {\r\n        name: {\r\n            type: String,\r\n            required: true,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const { push, remove, swap, insert, replace, update, prepend, move, fields } = useFieldArray(toRef(props, 'name'));\r\n        function slotProps() {\r\n            return {\r\n                fields: fields.value,\r\n                push,\r\n                remove,\r\n                swap,\r\n                insert,\r\n                update,\r\n                replace,\r\n                prepend,\r\n                move,\r\n            };\r\n        }\r\n        ctx.expose({\r\n            push,\r\n            remove,\r\n            swap,\r\n            insert,\r\n            update,\r\n            replace,\r\n            prepend,\r\n            move,\r\n        });\r\n        return () => {\r\n            const children = normalizeChildren(undefined, ctx, slotProps);\r\n            return children;\r\n        };\r\n    },\r\n});\r\nconst FieldArray = FieldArrayImpl;\n\nconst ErrorMessageImpl = defineComponent({\r\n    name: 'ErrorMessage',\r\n    props: {\r\n        as: {\r\n            type: String,\r\n            default: undefined,\r\n        },\r\n        name: {\r\n            type: String,\r\n            required: true,\r\n        },\r\n    },\r\n    setup(props, ctx) {\r\n        const form = inject(FormContextKey, undefined);\r\n        const message = computed(() => {\r\n            return form === null || form === void 0 ? void 0 : form.errors.value[props.name];\r\n        });\r\n        function slotProps() {\r\n            return {\r\n                message: message.value,\r\n            };\r\n        }\r\n        return () => {\r\n            // Renders nothing if there are no messages\r\n            if (!message.value) {\r\n                return undefined;\r\n            }\r\n            const tag = (props.as ? resolveDynamicComponent(props.as) : props.as);\r\n            const children = normalizeChildren(tag, ctx, slotProps);\r\n            const attrs = Object.assign({ role: 'alert' }, ctx.attrs);\r\n            // If no tag was specified and there are children\r\n            // render the slot as is without wrapping it\r\n            if (!tag && (Array.isArray(children) || !children) && (children === null || children === void 0 ? void 0 : children.length)) {\r\n                return children;\r\n            }\r\n            // If no children in slot\r\n            // render whatever specified and fallback to a <span> with the message in it's contents\r\n            if ((Array.isArray(children) || !children) && !(children === null || children === void 0 ? void 0 : children.length)) {\r\n                return h(tag || 'span', attrs, message.value);\r\n            }\r\n            return h(tag, attrs, children);\r\n        };\r\n    },\r\n});\r\nconst ErrorMessage = ErrorMessageImpl;\n\nfunction useResetForm() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return function resetForm(state) {\r\n        if (!form) {\r\n            return;\r\n        }\r\n        return form.resetForm(state);\r\n    };\r\n}\n\n/**\r\n * If a field is dirty or not\r\n */\r\nfunction useIsFieldDirty(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return false;\r\n        }\r\n        return field.meta.dirty;\r\n    });\r\n}\n\n/**\r\n * If a field is touched or not\r\n */\r\nfunction useIsFieldTouched(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return false;\r\n        }\r\n        return field.meta.touched;\r\n    });\r\n}\n\n/**\r\n * If a field is validated and is valid\r\n */\r\nfunction useIsFieldValid(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return false;\r\n        }\r\n        return field.meta.valid;\r\n    });\r\n}\n\n/**\r\n * If the form is submitting or not\r\n */\r\nfunction useIsSubmitting() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.isSubmitting.value) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * Validates a single field\r\n */\r\nfunction useValidateField(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    let field = path ? undefined : inject(FieldContextKey);\r\n    return function validateField() {\r\n        if (path) {\r\n            field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);\r\n        }\r\n        if (!field) {\r\n            warn(`field with name ${unref(path)} was not found`);\r\n            return Promise.resolve({\r\n                errors: [],\r\n                valid: true,\r\n            });\r\n        }\r\n        return field.validate();\r\n    };\r\n}\n\n/**\r\n * If the form is dirty or not\r\n */\r\nfunction useIsFormDirty() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.meta.value.dirty) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * If the form is touched or not\r\n */\r\nfunction useIsFormTouched() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.meta.value.touched) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * If the form has been validated and is valid\r\n */\r\nfunction useIsFormValid() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.meta.value.valid) !== null && _a !== void 0 ? _a : false;\r\n    });\r\n}\n\n/**\r\n * Validate multiple fields\r\n */\r\nfunction useValidateForm() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return function validateField() {\r\n        if (!form) {\r\n            return Promise.resolve({ results: {}, errors: {}, valid: true });\r\n        }\r\n        return form.validate();\r\n    };\r\n}\n\n/**\r\n * The number of form's submission count\r\n */\r\nfunction useSubmitCount() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        var _a;\r\n        return (_a = form === null || form === void 0 ? void 0 : form.submitCount.value) !== null && _a !== void 0 ? _a : 0;\r\n    });\r\n}\n\n/**\r\n * Gives access to a field's current value\r\n */\r\nfunction useFieldValue(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    // We don't want to use self injected context as it doesn't make sense\r\n    const field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            return getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(path));\r\n        }\r\n        return unref(field === null || field === void 0 ? void 0 : field.value);\r\n    });\r\n}\n\n/**\r\n * Gives access to a form's values\r\n */\r\nfunction useFormValues() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        return (form === null || form === void 0 ? void 0 : form.values) || {};\r\n    });\r\n}\n\n/**\r\n * Gives access to all form errors\r\n */\r\nfunction useFormErrors() {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    return computed(() => {\r\n        return ((form === null || form === void 0 ? void 0 : form.errors.value) || {});\r\n    });\r\n}\n\n/**\r\n * Gives access to a single field error\r\n */\r\nfunction useFieldError(path) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    // We don't want to use self injected context as it doesn't make sense\r\n    const field = path ? undefined : inject(FieldContextKey);\r\n    return computed(() => {\r\n        if (path) {\r\n            return form === null || form === void 0 ? void 0 : form.errors.value[unref(path)];\r\n        }\r\n        return field === null || field === void 0 ? void 0 : field.errorMessage.value;\r\n    });\r\n}\n\nfunction useSubmitForm(cb) {\r\n    const form = injectWithSelf(FormContextKey);\r\n    if (!form) {\r\n        warn('No vee-validate <Form /> or `useForm` was detected in the component tree');\r\n    }\r\n    const onSubmit = form ? form.handleSubmit(cb) : undefined;\r\n    return function submitForm(e) {\r\n        if (!onSubmit) {\r\n            return;\r\n        }\r\n        return onSubmit(e);\r\n    };\r\n}\n\nexport { ErrorMessage, Field, FieldArray, FieldContextKey, Form, FormContextKey, IS_ABSENT, configure, defineRule, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate };\n"],"sourceRoot":""}