{"version":3,"file":"js/40.34b07098.js","mappings":"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","sources":["webpack://familytoday-frontend/./src/composables/validators.composable.ts","webpack://familytoday-frontend/./node_modules/vee-validate/dist/vee-validate.esm.js"],"sourcesContent":["export default function useValidators() {\n    const isRequired = (value: string): boolean | string => {\n        return value && value.trim() ? true : 'This is required';\n    };\n\n    const isEmail = (value: string): boolean | string => {\n        return /^\\w+([.-]?\\w+)*@\\w+([.-]?\\w+)*(\\.\\w{2,3})+$/.test(value)\n            ? true\n            : 'This must be a valid email';\n    };\n\n    const isMinLen = (value: string, length: number): boolean | string => {\n        return value.length >= length\n            ? true\n            : `Must be at least ${length} characters`;\n    };\n\n    const isMaxLen = (value: string, length: number): boolean | string => {\n        return value.length <= length\n            ? true\n            : `Must be no more than ${length} characters`;\n    };\n\n    const isOneOf = (\n        value: string,\n        options: Array<string>\n    ): boolean | string => {\n        return options.includes(value)\n            ? true\n            : `Must be one of these options: { ${options.join(', ')} }`;\n    };\n\n    return {\n        isRequired,\n        isEmail,\n        isMinLen,\n        isMaxLen,\n        isOneOf,\n    };\n}\n","/**\n  * vee-validate v4.7.3\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 = clonedValue;\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        // reset values\r\n        const newValues = (state === null || state === void 0 ? void 0 : state.values) ? state.values : originalInitialValues.value;\r\n        setInitialValues(newValues);\r\n        setValues(newValues);\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"],"names":["useValidators","isRequired","value","trim","isEmail","test","isMinLen","length","isMaxLen","isOneOf","options","includes","join","isCallable","fn","isNullOrUndefined","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","Object","keys","isNotNestedPath","path","isNativeMultiSelect","el","isNativeSelect","multiple","tagName","isNativeMultiSelectNode","tag","attrs","hasTruthyBindingValue","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","keysOf","record","injectWithSelf","symbol","def","vm","getCurrentInstance","provides","inject","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","ref","watch","newValue","deep","normalizeChildren","slotProps","slots","default","_a","_b","getBoundValue","hasValueBinding","_value","normalizeEventValue","input","files","from","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","unref","resolveInitialValue","initialValues","stageInitialValue","computed","setFieldValue","reactive","validated","dirty","immediate","flush","normalizeErrors","errorBag","setFieldErrorBag","API","nextTick","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","onMounted","lastWatchedValue","watchValue","oldVal","validateFn","resetField","setValue","handleReset","provide","isRef","oldValue","register","onBeforeUnmount","unregister","dependencies","rulesVal","deps","dep","depAcc","depName","depValue","oldDeps","defaults","valueProp","standalone","fieldName","patchCheckboxApi","checked","checkedVal","handleCheckboxChange","propName","emitName","props","getCurrentModelValue","emit","propValue","modelModifiers","defineComponent","inheritAttrs","as","String","required","Function","keepValue","setup","toRef","validateField","onChangeHandler","handleInput","onInputHandler","fieldProps","resolveValidationTriggers","baseOnBlur","onBlur","baseOnInput","onInput","baseOnChange","onChange","resolveTag","expose","reset","resolveDynamicComponent","children","h","_d","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","newValues","insertFieldAtPath","rawField","markRaw","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","watchEffect","providedValues","updateFields","wasTouched","normalizeErrorItem","onSubmit","onInvalidSubmit","keepValues","handleFormReset","onReset","handleScopedSlotSubmit","onSuccess","formAttrs","novalidate","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","role"],"sourceRoot":""}