{"version":3,"file":"index.esm-680607de.js","sources":["../../../node_modules/vue-demi/lib/index.mjs","../../../node_modules/@vuelidate/core/dist/index.esm.js","../../../node_modules/@vuelidate/validators/dist/index.esm.js"],"sourcesContent":["import Vue from 'vue'\n\nvar isVue2 = true\nvar isVue3 = false\nvar Vue2 = Vue\nvar warn = Vue.util.warn\n\nfunction install() {}\n\n// createApp polyfill\nexport function createApp(rootComponent, rootProps) {\n var vm\n var provide = {}\n var app = {\n config: Vue.config,\n use: Vue.use.bind(Vue),\n mixin: Vue.mixin.bind(Vue),\n component: Vue.component.bind(Vue),\n provide: function (key, value) {\n provide[key] = value\n return this\n },\n directive: function (name, dir) {\n if (dir) {\n Vue.directive(name, dir)\n return app\n } else {\n return Vue.directive(name)\n }\n },\n mount: function (el, hydrating) {\n if (!vm) {\n vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))\n vm.$mount(el, hydrating)\n return vm\n } else {\n return vm\n }\n },\n unmount: function () {\n if (vm) {\n vm.$destroy()\n vm = undefined\n }\n },\n }\n return app\n}\n\nexport { Vue, Vue2, isVue2, isVue3, install, warn }\nexport * from 'vue'\n","import { isReactive, isReadonly, computed, unref, ref, watch, reactive, isRef, nextTick, inject, provide, getCurrentInstance, onBeforeMount, onBeforeUnmount } from 'vue-demi';\n\nfunction unwrapObj(obj) {\n let ignoreKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n return Object.keys(obj).reduce((o, k) => {\n if (ignoreKeys.includes(k)) return o;\n o[k] = unref(obj[k]);\n return o;\n }, {});\n}\nfunction isFunction(val) {\n return typeof val === 'function';\n}\nfunction isProxy(value) {\n return isReactive(value) || isReadonly(value);\n}\nfunction get(obj, stringPath, def) {\n // Cache the current object\n let current = obj;\n const path = stringPath.split('.'); // For each item in the path, dig into the object\n\n for (let i = 0; i < path.length; i++) {\n // If the item isn't found, return the default (or null)\n if (!current[path[i]]) return def; // Otherwise, update the current value\n\n current = current[path[i]];\n }\n\n return current;\n}\nfunction gatherBooleanGroupProperties(group, nestedResults, property) {\n return computed(() => {\n return group.some(path => {\n return get(nestedResults, path, {\n [property]: false\n })[property];\n });\n });\n}\nfunction gatherArrayGroupProperties(group, nestedResults, property) {\n return computed(() => {\n return group.reduce((all, path) => {\n const fetchedProperty = get(nestedResults, path, {\n [property]: false\n })[property] || [];\n return all.concat(fetchedProperty);\n }, []);\n });\n}\n\n/**\n * Response form a raw Validator function.\n * Should return a Boolean or an object with $invalid property.\n * @typedef {Boolean | { $valid: Boolean }} ValidatorResponse\n */\n\n/**\n * Calls a validation rule by unwrapping its value first from a ref.\n * @param {Validator} rule\n * @param {Ref} value\n * @param {VueInstance} instance\n * @param {Object} siblingState\n * @return {Promise<ValidatorResponse> | ValidatorResponse}\n */\n\nfunction callRule(rule, value, siblingState, instance) {\n return rule.call(instance, unref(value), unref(siblingState), instance);\n}\n/**\n * Normalizes the validator result\n * Allows passing a boolean of an object like `{ $valid: Boolean }`\n * @param {ValidatorResponse} result - Validator result\n * @return {boolean}\n */\n\n\nfunction normalizeValidatorResponse(result) {\n return result.$valid !== undefined ? !result.$valid : !result;\n}\n/**\n * Returns the result of an async validator.\n * @param {Validator} rule\n * @param {Ref<*>} model\n * @param {Ref<Boolean>} $pending\n * @param {Ref<Boolean>} $dirty\n * @param {GlobalConfig} config\n * @param {boolean} config.$lazy\n * @param {Ref<*>} $response\n * @param {VueInstance} instance\n * @param {Ref<*>[]} watchTargets\n * @param {Object} siblingState\n * @param {Ref<Boolean>} $lastInvalidState\n * @param {Ref<Number>} $lastCommittedOn\n * @return {{ $invalid: Ref<Boolean>, $unwatch: WatchStopHandle }}\n */\n\n\nfunction createAsyncResult(rule, model, $pending, $dirty, _ref, $response, instance) {\n let {\n $lazy,\n $rewardEarly\n } = _ref;\n let watchTargets = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : [];\n let siblingState = arguments.length > 8 ? arguments[8] : undefined;\n let $lastInvalidState = arguments.length > 9 ? arguments[9] : undefined;\n let $lastCommittedOn = arguments.length > 10 ? arguments[10] : undefined;\n const $invalid = ref(!!$dirty.value);\n const $pendingCounter = ref(0);\n $pending.value = false;\n const $unwatch = watch([model, $dirty].concat(watchTargets, $lastCommittedOn), () => {\n if ( // if $lazy and not dirty, return\n $lazy && !$dirty.value || // if in $rewardEarly mode and no previous errors, nothing pending, return\n $rewardEarly && !$lastInvalidState.value && !$pending.value) {\n return;\n }\n\n let ruleResult; // make sure we dont break if a validator throws\n\n try {\n ruleResult = callRule(rule, model, siblingState, instance);\n } catch (err) {\n // convert to a promise, so we can handle it async\n ruleResult = Promise.reject(err);\n }\n\n $pendingCounter.value++;\n $pending.value = !!$pendingCounter.value; // ensure $invalid is false, while validator is resolving\n\n $invalid.value = false;\n Promise.resolve(ruleResult).then(data => {\n $pendingCounter.value--;\n $pending.value = !!$pendingCounter.value;\n $response.value = data;\n $invalid.value = normalizeValidatorResponse(data);\n }).catch(error => {\n $pendingCounter.value--;\n $pending.value = !!$pendingCounter.value;\n $response.value = error;\n $invalid.value = true;\n });\n }, {\n immediate: true,\n deep: typeof model === 'object'\n });\n return {\n $invalid,\n $unwatch\n };\n}\n/**\n * Returns the result of a sync validator\n * @param {Validator} rule\n * @param {Ref<*>} model\n * @param {Ref<Boolean>} $dirty\n * @param {GlobalConfig} config\n * @param {Boolean} config.$lazy\n * @param {Ref<*>} $response\n * @param {VueInstance} instance\n * @param {Object} siblingState\n * @param {Ref<Boolean>} $lastInvalidState\n * @return {{$unwatch: (function(): {}), $invalid: ComputedRef<boolean>}}\n */\n\n\nfunction createSyncResult(rule, model, $dirty, _ref2, $response, instance, siblingState, $lastInvalidState) {\n let {\n $lazy,\n $rewardEarly\n } = _ref2;\n\n const $unwatch = () => ({});\n\n const $invalid = computed(() => {\n if ( // return early if $lazy mode and not touched\n $lazy && !$dirty.value || // If $rewardEarly mode is ON and last invalid was false (no error), return it.\n // If we want to invalidate, we just flip the last state to true, causing the computed to run again\n $rewardEarly && !$lastInvalidState.value) {\n return false;\n }\n\n let returnValue = true;\n\n try {\n const result = callRule(rule, model, siblingState, instance);\n $response.value = result;\n returnValue = normalizeValidatorResponse(result);\n } catch (err) {\n $response.value = err;\n }\n\n return returnValue;\n });\n return {\n $unwatch,\n $invalid\n };\n}\n/**\n * Returns the validation result.\n * Detects async and sync validators.\n * @param {NormalizedValidator} rule\n * @param {Ref<*>} model\n * @param {Ref<boolean>} $dirty\n * @param {GlobalConfig} config - Vuelidate config\n * @param {VueInstance} instance - component instance\n * @param {string} validatorName - name of the current validator\n * @param {string} propertyKey - the current property we are validating\n * @param {string} propertyPath - the deep path to the validated property\n * @param {Object} siblingState\n * @param {Ref<Boolean>} $lastInvalidState - the last invalid state\n * @param {Ref<Number>} $lastCommittedOn - the last time $commit was called\n * @return {{ $params: *, $message: Ref<String>, $pending: Ref<Boolean>, $invalid: Ref<Boolean>, $response: Ref<*>, $unwatch: WatchStopHandle }}\n */\n\n\nfunction createValidatorResult(rule, model, $dirty, config, instance, validatorName, propertyKey, propertyPath, siblingState, $lastInvalidState, $lastCommittedOn) {\n const $pending = ref(false);\n const $params = rule.$params || {};\n const $response = ref(null);\n let $invalid;\n let $unwatch;\n\n if (rule.$async) {\n ({\n $invalid,\n $unwatch\n } = createAsyncResult(rule.$validator, model, $pending, $dirty, config, $response, instance, rule.$watchTargets, siblingState, $lastInvalidState, $lastCommittedOn));\n } else {\n ({\n $invalid,\n $unwatch\n } = createSyncResult(rule.$validator, model, $dirty, config, $response, instance, siblingState, $lastInvalidState));\n }\n\n const message = rule.$message;\n const $message = isFunction(message) ? computed(() => message(unwrapObj({\n $pending,\n $invalid,\n $params: unwrapObj($params),\n // $params can hold refs, so we unwrap them for easy access\n $model: model,\n $response,\n $validator: validatorName,\n $propertyPath: propertyPath,\n $property: propertyKey\n }))) : message || '';\n return {\n $message,\n $params,\n $pending,\n $invalid,\n $response,\n $unwatch\n };\n}\n\n/**\n * Sorts a validation definition into rules, configs and nested validators.\n * @param {Object<NormalizedValidator|Function>} validationsRaw\n * @return {{ rules: Object<NormalizedValidator>, nestedValidators: Object, config: GlobalConfig }}\n */\n\nfunction sortValidations() {\n let validationsRaw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n const validations = unref(validationsRaw);\n const validationKeys = Object.keys(validations);\n const rules = {};\n const nestedValidators = {};\n const config = {};\n let validationGroups = null;\n validationKeys.forEach(key => {\n const v = validations[key];\n\n switch (true) {\n // If it is already normalized, use it\n case isFunction(v.$validator):\n rules[key] = v;\n break;\n // If it is just a function, normalize it first\n // into { $validator: <Fun> }\n\n case isFunction(v):\n rules[key] = {\n $validator: v\n };\n break;\n\n case key === '$validationGroups':\n validationGroups = v;\n break;\n // Catch $-prefixed properties as config\n\n case key.startsWith('$'):\n config[key] = v;\n break;\n // If it doesn’t match any of the above,\n // treat as nestedValidators state property\n\n default:\n nestedValidators[key] = v;\n }\n });\n return {\n rules,\n nestedValidators,\n config,\n validationGroups\n };\n}\n\nfunction _empty() {}\n\nconst ROOT_PATH = '__root';\n/** @typedef {import('vue-demi').ComponentPublicInstance} VueInstance */\n\n/** @typedef {import('vue-demi').ComputedRef} ComputedRef */\n\n/** @typedef {import('vue-demi').UnwrapRef} UnwrapRef */\n\n/** @typedef {import('vue-demi').WatchStopHandle} WatchStopHandle */\n\n/** @typedef {import('vue-demi').WritableComputedRef} WritableComputedRef */\n\n/** @typedef {import('vue-demi').UnwrapNestedRefs} UnwrapNestedRefs */\n\n/**\n * @typedef NormalizedValidator\n * @property {Validator} $validator\n * @property {String | Ref<String> | function(*): string} [$message]\n * @property {Object | Ref<Object>} [$params]\n * @property {Object | Ref<Object>} [$async]\n * @property {Ref<*>[]} [$watchTargets]\n */\n\n/**\n * Raw validator function, before being normalized\n * Can return a Promise or a {@see ValidatorResponse}\n * @typedef {function(*): ((Promise<ValidatorResponse> | ValidatorResponse))} Validator\n */\n\n/**\n * @typedef ErrorObject\n * @property {Ref<String>} $message - Reactive error message\n * @property {Ref<Object>} $params - Params passed from withParams\n * @property {Ref<Boolean>} $pending - If validation is pending\n * @property {String} $property - State key\n * @property {String} $propertyPath - Dot notation path to state\n * @property {String} $validator - Validator name\n * @property {String} $uid - Unique identifier\n */\n\n/**\n * @typedef ValidationResult\n * @property {Ref<Boolean>} $pending\n * @property {Ref<Boolean>} $dirty\n * @property {Ref<Boolean>} $invalid\n * @property {Ref<Boolean>} $error\n * @property {Ref<String>} $path\n * @property {Function} $touch\n * @property {Function} $reset\n * @property {ComputedRef<ErrorObject[]>} $errors\n * @property {ComputedRef<ErrorObject[]>} $silentErrors\n * @property {Function} $commit\n */\n\n/**\n * Creates the main Validation Results object for a state tree\n * Walks the tree's top level branches\n * @param {Object<NormalizedValidator>} rules - Rules for the current state tree\n * @param {Object} model - Current state value\n * @param {String} key - Key for the current state tree\n * @param {ResultsStorage} [resultsCache] - A cache map of all the validators\n * @param {String} [path] - the current property path\n * @param {GlobalConfig} [config] - the config object\n * @param {VueInstance} instance\n * @param {ComputedRef<Object>} externalResults\n * @param {Object} siblingState\n * @return {ValidationResult | {}}\n */\n\nfunction _call(body, then, direct) {\n if (direct) {\n return then ? then(body()) : body();\n }\n\n try {\n var result = Promise.resolve(body());\n return then ? result.then(then) : result;\n } catch (e) {\n return Promise.reject(e);\n }\n}\n/**\n * Collects the validation results of all nested state properties\n * @param {Object<NormalizedValidator|Function>} validations - The validation\n * @param {Object} nestedState - Current state\n * @param {String} path - Path to current property\n * @param {ResultsStorage} resultsCache - Validations cache map\n * @param {GlobalConfig} config - The config object\n * @param {VueInstance} instance - The current Vue instance\n * @param {ComputedRef<object>} nestedExternalResults - The external results for this nested collection\n * @return {Object<string, VuelidateState>}\n */\n\n\nfunction _callIgnored(body, direct) {\n return _call(body, _empty, direct);\n}\n\nfunction _invoke(body, then) {\n var result = body();\n\n if (result && result.then) {\n return result.then(then);\n }\n\n return then(result);\n}\n\nfunction _async(f) {\n return function () {\n for (var args = [], i = 0; i < arguments.length; i++) {\n args[i] = arguments[i];\n }\n\n try {\n return Promise.resolve(f.apply(this, args));\n } catch (e) {\n return Promise.reject(e);\n }\n };\n}\n\nfunction createValidationResults(rules, model, key, resultsCache, path, config, instance, externalResults, siblingState) {\n // collect the property keys\n const ruleKeys = Object.keys(rules);\n const cachedResult = resultsCache.get(path, rules);\n const $dirty = ref(false); // state for the $rewardEarly option\n\n /** The last invalid state of this property */\n\n const $lastInvalidState = ref(false);\n /** The last time $commit was called. Used to re-trigger async calls */\n\n const $lastCommittedOn = ref(0);\n\n if (cachedResult) {\n // if the rules are the same as before, use the cached results\n if (!cachedResult.$partial) return cachedResult; // remove old watchers\n\n cachedResult.$unwatch(); // use the `$dirty.value`, so we dont save references by accident\n\n $dirty.value = cachedResult.$dirty.value;\n }\n\n const result = {\n // restore $dirty from cache\n $dirty,\n $path: path,\n $touch: () => {\n if (!$dirty.value) $dirty.value = true;\n },\n $reset: () => {\n if ($dirty.value) $dirty.value = false;\n },\n $commit: () => {}\n };\n /**\n * If there are no validation rules, it is most likely\n * a top level state, aka root\n */\n\n if (!ruleKeys.length) {\n // if there are cached results, we should overwrite them with the new ones\n cachedResult && resultsCache.set(path, rules, result);\n return result;\n }\n\n ruleKeys.forEach(ruleKey => {\n result[ruleKey] = createValidatorResult(rules[ruleKey], model, result.$dirty, config, instance, ruleKey, key, path, siblingState, $lastInvalidState, $lastCommittedOn);\n });\n result.$externalResults = computed(() => {\n if (!externalResults.value) return [];\n return [].concat(externalResults.value).map((stringError, index) => ({\n $propertyPath: path,\n $property: key,\n $validator: '$externalResults',\n $uid: `${path}-externalResult-${index}`,\n $message: stringError,\n $params: {},\n $response: null,\n $pending: false\n }));\n });\n result.$invalid = computed(() => {\n const r = ruleKeys.some(ruleKey => unref(result[ruleKey].$invalid)); // cache the last invalid state\n\n $lastInvalidState.value = r;\n return !!result.$externalResults.value.length || r;\n });\n result.$pending = computed(() => ruleKeys.some(ruleKey => unref(result[ruleKey].$pending)));\n result.$error = computed(() => result.$dirty.value ? result.$pending.value || result.$invalid.value : false);\n result.$silentErrors = computed(() => ruleKeys.filter(ruleKey => unref(result[ruleKey].$invalid)).map(ruleKey => {\n const res = result[ruleKey];\n return reactive({\n $propertyPath: path,\n $property: key,\n $validator: ruleKey,\n $uid: `${path}-${ruleKey}`,\n $message: res.$message,\n $params: res.$params,\n $response: res.$response,\n $pending: res.$pending\n });\n }).concat(result.$externalResults.value));\n result.$errors = computed(() => result.$dirty.value ? result.$silentErrors.value : []);\n\n result.$unwatch = () => ruleKeys.forEach(ruleKey => {\n result[ruleKey].$unwatch();\n });\n\n result.$commit = () => {\n $lastInvalidState.value = true;\n $lastCommittedOn.value = Date.now();\n };\n\n resultsCache.set(path, rules, result);\n return result;\n}\n\nfunction collectNestedValidationResults(validations, nestedState, path, resultsCache, config, instance, nestedExternalResults) {\n const nestedValidationKeys = Object.keys(validations); // if we have no state, return empty object\n\n if (!nestedValidationKeys.length) return {};\n return nestedValidationKeys.reduce((results, nestedKey) => {\n // build validation results for nested state\n results[nestedKey] = setValidations({\n validations: validations[nestedKey],\n state: nestedState,\n key: nestedKey,\n parentKey: path,\n resultsCache,\n globalConfig: config,\n instance,\n externalResults: nestedExternalResults\n });\n return results;\n }, {});\n}\n/**\n * Generates the Meta fields from the results\n * @param {ValidationResult|{}} results\n * @param {Object.<string, VuelidateState>} nestedResults\n * @param {Object.<string, ValidationResult>} childResults\n * @return {{$anyDirty: Ref<Boolean>, $error: Ref<Boolean>, $invalid: Ref<Boolean>, $errors: Ref<ErrorObject[]>, $dirty: Ref<Boolean>, $touch: Function, $reset: Function }}\n */\n\n\nfunction createMetaFields(results, nestedResults, childResults) {\n const allResults = computed(() => [nestedResults, childResults].filter(res => res).reduce((allRes, res) => {\n return allRes.concat(Object.values(unref(res)));\n }, [])); // returns `$dirty` as true, if all children are dirty\n\n const $dirty = computed({\n get() {\n return results.$dirty.value || (allResults.value.length ? allResults.value.every(r => r.$dirty) : false);\n },\n\n set(v) {\n results.$dirty.value = v;\n }\n\n });\n const $silentErrors = computed(() => {\n // current state level errors, fallback to empty array if root\n const modelErrors = unref(results.$silentErrors) || []; // collect all nested and child $silentErrors\n\n const nestedErrors = allResults.value.filter(result => (unref(result).$silentErrors || []).length).reduce((errors, result) => {\n return errors.concat(...result.$silentErrors);\n }, []); // merge the $silentErrors\n\n return modelErrors.concat(nestedErrors);\n });\n const $errors = computed(() => {\n // current state level errors, fallback to empty array if root\n const modelErrors = unref(results.$errors) || []; // collect all nested and child $errors\n\n const nestedErrors = allResults.value.filter(result => (unref(result).$errors || []).length).reduce((errors, result) => {\n return errors.concat(...result.$errors);\n }, []); // merge the $errors\n\n return modelErrors.concat(nestedErrors);\n });\n const $invalid = computed(() => // if any of the nested values is invalid\n allResults.value.some(r => r.$invalid) || // or if the current state is invalid\n unref(results.$invalid) || // fallback to false if is root\n false);\n const $pending = computed(() => // if any of the nested values is pending\n allResults.value.some(r => unref(r.$pending)) || // if any of the current state validators is pending\n unref(results.$pending) || // fallback to false if is root\n false);\n const $anyDirty = computed(() => allResults.value.some(r => r.$dirty) || allResults.value.some(r => r.$anyDirty) || $dirty.value);\n const $error = computed(() => $dirty.value ? $pending.value || $invalid.value : false);\n\n const $touch = () => {\n // call the root $touch\n results.$touch(); // call all nested level $touch\n\n allResults.value.forEach(result => {\n result.$touch();\n });\n };\n\n const $commit = () => {\n // call the root $touch\n results.$commit(); // call all nested level $touch\n\n allResults.value.forEach(result => {\n result.$commit();\n });\n };\n\n const $reset = () => {\n // reset the root $dirty state\n results.$reset(); // reset all the children $dirty states\n\n allResults.value.forEach(result => {\n result.$reset();\n });\n }; // Ensure that if all child and nested results are $dirty, this also becomes $dirty\n\n\n if (allResults.value.length && allResults.value.every(nr => nr.$dirty)) $touch();\n return {\n $dirty,\n $errors,\n $invalid,\n $anyDirty,\n $error,\n $pending,\n $touch,\n $reset,\n $silentErrors,\n $commit\n };\n}\n/**\n * @typedef VuelidateState\n * @property {WritableComputedRef<any>} $model\n * @property {ComputedRef<Boolean>} $dirty\n * @property {ComputedRef<Boolean>} $error\n * @property {ComputedRef<ErrorObject[]>} $errors\n * @property {ComputedRef<Boolean>} $invalid\n * @property {ComputedRef<Boolean>} $anyDirty\n * @property {ComputedRef<Boolean>} $pending\n * @property {Function} $touch\n * @property {Function} $reset\n * @property {String} $path\n * @property {ComputedRef<ErrorObject[]>} $silentErrors\n * @property {Function} [$validate]\n * @property {Function} [$getResultsForChild]\n * @property {Object.<string, VuelidateState>}\n */\n\n/**\n * Main Vuelidate bootstrap function.\n * Used both for Composition API in `setup` and for Global App usage.\n * Used to collect validation state, when walking recursively down the state tree\n * @param {Object} params\n * @param {Object<NormalizedValidator|Function>} params.validations\n * @param {Object} params.state\n * @param {String} [params.key] - Current state property key. Used when being called on nested items\n * @param {String} [params.parentKey] - Parent state property key. Used when being called recursively\n * @param {Object<string, ValidationResult>} [params.childResults] - Used to collect child results.\n * @param {ResultsStorage} params.resultsCache - The cached validation results\n * @param {VueInstance} params.instance - The current Vue instance\n * @param {GlobalConfig} params.globalConfig - The validation config, passed to this setValidations instance.\n * @param {UnwrapNestedRefs<object> | Ref<Object>} params.externalResults - External validation results\n * @return {UnwrapNestedRefs<VuelidateState>}\n */\n\n\nfunction setValidations(_ref) {\n /**\n * Executes the validators and returns the result.\n * @return {Promise<boolean>}\n */\n const $validate = _async(function () {\n $touch();\n return _invoke(function () {\n if (mergedConfig.$rewardEarly) {\n $commit(); // await the watchers\n\n return _callIgnored(nextTick);\n }\n }, function () {\n // await the watchers\n return _call(nextTick, function () {\n return new Promise(resolve => {\n // return whether it is valid or not\n if (!$pending.value) return resolve(!$invalid.value);\n const unwatch = watch($pending, () => {\n resolve(!$invalid.value);\n unwatch();\n });\n });\n });\n });\n });\n /**\n * Returns a child component's results, based on registration name\n * @param {string} key\n * @return {VuelidateState}\n */\n\n\n let {\n validations,\n state,\n key,\n parentKey,\n childResults,\n resultsCache,\n globalConfig = {},\n instance,\n externalResults\n } = _ref;\n const path = parentKey ? `${parentKey}.${key}` : key; // Sort out the validation object into:\n // – rules = validators for current state tree fragment\n // — nestedValidators = nested state fragments keys that might contain more validators\n // – config = configuration properties that affect this state fragment\n\n const {\n rules,\n nestedValidators,\n config,\n validationGroups\n } = sortValidations(validations);\n const mergedConfig = Object.assign({}, globalConfig, config); // create protected state for cases when the state branch does not exist yet.\n // This protects when using the OptionsAPI as the data is bound after the setup method\n\n const nestedState = key ? computed(() => {\n const s = unref(state);\n return s ? unref(s[key]) : undefined;\n }) : state; // cache the external results, so we can revert back to them\n\n const cachedExternalResults = Object.assign({}, unref(externalResults) || {});\n const nestedExternalResults = computed(() => {\n const results = unref(externalResults);\n if (!key) return results;\n return results ? unref(results[key]) : undefined;\n }); // Use rules for the current state fragment and validate it\n\n const results = createValidationResults(rules, nestedState, key, resultsCache, path, mergedConfig, instance, nestedExternalResults, state); // Use nested keys to repeat the process\n // *WARN*: This is recursive\n\n const nestedResults = collectNestedValidationResults(nestedValidators, nestedState, path, resultsCache, mergedConfig, instance, nestedExternalResults);\n const $validationGroups = {};\n\n if (validationGroups) {\n Object.entries(validationGroups).forEach(_ref2 => {\n let [key, group] = _ref2;\n $validationGroups[key] = {\n $invalid: gatherBooleanGroupProperties(group, nestedResults, '$invalid'),\n $error: gatherBooleanGroupProperties(group, nestedResults, '$error'),\n $pending: gatherBooleanGroupProperties(group, nestedResults, '$pending'),\n $errors: gatherArrayGroupProperties(group, nestedResults, '$errors'),\n $silentErrors: gatherArrayGroupProperties(group, nestedResults, '$silentErrors')\n };\n });\n } // Collect and merge this level validation results\n // with all nested validation results\n\n\n const {\n $dirty,\n $errors,\n $invalid,\n $anyDirty,\n $error,\n $pending,\n $touch,\n $reset,\n $silentErrors,\n $commit\n } = createMetaFields(results, nestedResults, childResults);\n /**\n * If we have no `key`, this is the top level state\n * We dont need `$model` there.\n */\n\n const $model = key ? computed({\n get: () => unref(nestedState),\n set: val => {\n $dirty.value = true;\n const s = unref(state);\n const external = unref(externalResults);\n\n if (external) {\n external[key] = cachedExternalResults[key];\n }\n\n if (isRef(s[key])) {\n s[key].value = val;\n } else {\n s[key] = val;\n }\n }\n }) : null;\n\n if (key && mergedConfig.$autoDirty) {\n watch(nestedState, () => {\n if (!$dirty.value) $touch();\n const external = unref(externalResults);\n\n if (external) {\n external[key] = cachedExternalResults[key];\n }\n }, {\n flush: 'sync'\n });\n }\n\n function $getResultsForChild(key) {\n return (childResults.value || {})[key];\n }\n\n function $clearExternalResults() {\n if (isRef(externalResults)) {\n externalResults.value = cachedExternalResults;\n } else {\n // if the external results state was empty, we need to delete every property, one by one\n if (Object.keys(cachedExternalResults).length === 0) {\n Object.keys(externalResults).forEach(k => {\n delete externalResults[k];\n });\n } else {\n // state was not empty, so we just assign it back into the current state\n Object.assign(externalResults, cachedExternalResults);\n }\n }\n }\n\n return reactive(Object.assign({}, results, {\n // NOTE: The order here is very important, since we want to override\n // some of the *results* meta fields with the collective version of it\n // that includes the results of nested state validation results\n $model,\n $dirty,\n $error,\n $errors,\n $invalid,\n $anyDirty,\n $pending,\n $touch,\n $reset,\n $path: path || ROOT_PATH,\n $silentErrors,\n $validate,\n $commit\n }, childResults && {\n $getResultsForChild,\n $clearExternalResults,\n $validationGroups\n }, nestedResults));\n}\n\nclass ResultsStorage {\n constructor() {\n this.storage = new Map();\n }\n /**\n * Stores a validation result, and its rules by its path\n * @param {String} path\n * @param {Object<NormalizedValidator>} rules\n * @param {ValidationResult} result\n */\n\n\n set(path, rules, result) {\n this.storage.set(path, {\n rules,\n result\n });\n }\n /**\n * Check if the stored `results` for the provided `path` have the same `rules` compared to 'storedRules'\n * @param {String} path\n * @param {Object<NormalizedValidator>} rules\n * @param {Object<NormalizedValidator>} storedRules\n * @return {Boolean}\n */\n\n\n checkRulesValidity(path, rules, storedRules) {\n const storedRulesKeys = Object.keys(storedRules);\n const newRulesKeys = Object.keys(rules);\n if (newRulesKeys.length !== storedRulesKeys.length) return false;\n const hasAllValidators = newRulesKeys.every(ruleKey => storedRulesKeys.includes(ruleKey));\n if (!hasAllValidators) return false;\n return newRulesKeys.every(ruleKey => {\n if (!rules[ruleKey].$params) return true;\n return Object.keys(rules[ruleKey].$params).every(paramKey => {\n // make sure to unwrap before comparing\n return unref(storedRules[ruleKey].$params[paramKey]) === unref(rules[ruleKey].$params[paramKey]);\n });\n });\n }\n /**\n * Returns the matched result if catche is valid\n * @param {String} path\n * @param {Object<NormalizedValidator>} rules\n * @return {{$partial: boolean, $dirty: Ref<Boolean>, $unwatch: function}|undefined|ValidationResult}\n */\n\n\n get(path, rules) {\n const storedRuleResultPair = this.storage.get(path);\n if (!storedRuleResultPair) return undefined;\n const {\n rules: storedRules,\n result\n } = storedRuleResultPair;\n const isValidCache = this.checkRulesValidity(path, rules, storedRules);\n const $unwatch = result.$unwatch ? result.$unwatch : () => ({});\n if (!isValidCache) return {\n $dirty: result.$dirty,\n $partial: true,\n $unwatch\n };\n return result;\n }\n\n}\n\nconst CollectFlag = {\n COLLECT_ALL: true,\n COLLECT_NONE: false\n};\nconst VuelidateInjectChildResults = Symbol('vuelidate#injectChildResults');\nconst VuelidateRemoveChildResults = Symbol('vuelidate#removeChildResults');\n/**\n * Create helpers to collect validation state from child components\n * @param {Object} params\n * @param {String | Number | Boolean} params.$scope - Parent component scope\n * @return {{sendValidationResultsToParent: function[], childResults: ComputedRef<Object>, removeValidationResultsFromParent: function[]}}\n */\n\nfunction nestedValidations(_ref) {\n let {\n $scope,\n instance\n } = _ref;\n const childResultsRaw = {};\n const childResultsKeys = ref([]);\n const childResults = computed(() => childResultsKeys.value.reduce((results, key) => {\n results[key] = unref(childResultsRaw[key]);\n return results;\n }, {}));\n /**\n * Allows children to send validation data up to their parent.\n * @param {Object} results - the results\n * @param {Object} args\n * @param {String} args.$registerAs - the $registeredAs key\n * @param {String | Number | Boolean} args.$scope - the $scope key\n */\n\n function injectChildResultsIntoParent(results, _ref2) {\n let {\n $registerAs: key,\n $scope: childScope,\n $stopPropagation\n } = _ref2;\n if ($stopPropagation || $scope === CollectFlag.COLLECT_NONE || childScope === CollectFlag.COLLECT_NONE || $scope !== CollectFlag.COLLECT_ALL && $scope !== childScope) return;\n childResultsRaw[key] = results;\n childResultsKeys.value.push(key);\n } // combine with other `injectChildResultsIntoParent` from vuelidate instances in this Vue component instance\n\n\n instance.__vuelidateInjectInstances = [].concat(instance.__vuelidateInjectInstances || [], injectChildResultsIntoParent);\n /**\n * Allows children to remove the validation data from their parent, before getting destroyed.\n * @param {String} key - the registeredAs key\n */\n\n function removeChildResultsFromParent(key) {\n // remove the key\n childResultsKeys.value = childResultsKeys.value.filter(childKey => childKey !== key); // remove the stored data for the key\n\n delete childResultsRaw[key];\n } // combine with other `removeChildResultsFromParent` from vuelidate instances in this Vue component instance\n\n\n instance.__vuelidateRemoveInstances = [].concat(instance.__vuelidateRemoveInstances || [], removeChildResultsFromParent); // inject the `injectChildResultsIntoParent` method, into the current scope\n\n const sendValidationResultsToParent = inject(VuelidateInjectChildResults, []); // provide to all of its children the send results to parent function\n\n provide(VuelidateInjectChildResults, instance.__vuelidateInjectInstances);\n const removeValidationResultsFromParent = inject(VuelidateRemoveChildResults, []); // provide to all of its children the remove results function\n\n provide(VuelidateRemoveChildResults, instance.__vuelidateRemoveInstances);\n return {\n childResults,\n sendValidationResultsToParent,\n removeValidationResultsFromParent\n };\n}\n\n/**\n * Helper proxy for instance property access. It makes every reference\n * reactive for the validation function\n * @param target\n * @return {*|ComputedRef<*>}\n */\n\nfunction ComputedProxyFactory(target) {\n return new Proxy(target, {\n get(target, prop) {\n return typeof target[prop] === 'object' ? ComputedProxyFactory(target[prop]) : computed(() => target[prop]);\n }\n\n });\n}\n\n/**\n * @typedef GlobalConfig\n * @property {String} [$registerAs] - Config Object\n * @property {String | Number | Symbol} [$scope] - A scope to limit child component registration\n * @property {Boolean} [$stopPropagation] - Tells a Vue component to stop sending its results up to the parent\n * @property {Ref<Object>} [$externalResults] - External error messages, like from server validation.\n * @property {Boolean} [$autoDirty] - Should the form watch for state changed, and automatically set `$dirty` to true.\n * @property {Boolean} [$lazy] - Should the validations be lazy, and run only after they are dirty\n * @property {Boolean} [$rewardEarly] - Once valid, re-runs property validators only on manual calls of $commit\n */\n\n/**\n * Composition API compatible Vuelidate\n * Use inside the `setup` lifecycle hook\n * @param {Object | GlobalConfig} [validations] - Validations Object or the globalConfig.\n * @param {Object} [state] - State object - required if `validations` is a validation object.\n * @param {GlobalConfig} [globalConfig] - Config Object\n * @return {ComputedRef<*>}\n */\n\nlet uid = 0;\nfunction useVuelidate(validations, state) {\n var _getCurrentInstance;\n\n let globalConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n // if we pass only one argument, its most probably the globalConfig.\n // This use case is so parents can just collect results of child forms.\n if (arguments.length === 1) {\n globalConfig = validations;\n validations = undefined;\n state = undefined;\n }\n\n let {\n $registerAs,\n $scope = CollectFlag.COLLECT_ALL,\n $stopPropagation,\n $externalResults,\n currentVueInstance\n } = globalConfig;\n const instance = currentVueInstance || ((_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy);\n const componentOptions = instance ? instance.$options : {}; // if there is no registration name, add one.\n\n if (!$registerAs) {\n uid += 1;\n $registerAs = `_vuelidate_${uid}`;\n }\n\n const validationResults = ref({});\n const resultsCache = new ResultsStorage();\n const {\n childResults,\n sendValidationResultsToParent,\n removeValidationResultsFromParent\n } = instance ? nestedValidations({\n $scope,\n instance\n }) : {\n childResults: ref({})\n }; // Options API\n\n if (!validations && componentOptions.validations) {\n const rules = componentOptions.validations;\n state = ref({});\n onBeforeMount(() => {\n // Delay binding state to validations defined with the Options API until mounting, when the data\n // has been attached to the component instance. From that point on it will be reactive.\n state.value = instance;\n watch(() => isFunction(rules) ? rules.call(state.value, new ComputedProxyFactory(state.value)) : rules, validations => {\n validationResults.value = setValidations({\n validations,\n state,\n childResults,\n resultsCache,\n globalConfig,\n instance,\n externalResults: $externalResults || instance.vuelidateExternalResults\n });\n }, {\n immediate: true\n });\n });\n globalConfig = componentOptions.validationsConfig || globalConfig;\n } else {\n const validationsWatchTarget = isRef(validations) || isProxy(validations) ? validations // wrap plain objects in a reactive, so we can track changes if they have computed in them.\n : reactive(validations || {});\n watch(validationsWatchTarget, newValidationRules => {\n validationResults.value = setValidations({\n validations: newValidationRules,\n state,\n childResults,\n resultsCache,\n globalConfig,\n instance: instance !== null && instance !== void 0 ? instance : {},\n externalResults: $externalResults\n });\n }, {\n immediate: true\n });\n }\n\n if (instance) {\n // send all the data to the parent when the function is invoked inside setup.\n sendValidationResultsToParent.forEach(f => f(validationResults, {\n $registerAs,\n $scope,\n $stopPropagation\n })); // before this component is destroyed, remove all the data from the parent.\n\n onBeforeUnmount(() => removeValidationResultsFromParent.forEach(f => f($registerAs)));\n }\n\n return computed(() => {\n return Object.assign({}, unref(validationResults.value), childResults.value);\n });\n}\n\nexport { CollectFlag, useVuelidate as default, useVuelidate };\n","import { unref } from 'vue-demi';\n\nfunction isFunction(val) {\n return typeof val === 'function';\n}\nfunction isObject(o) {\n return o !== null && typeof o === 'object' && !Array.isArray(o);\n}\n/**\n * Returns a standard ValidatorObject\n * Wraps a plain function into a ValidatorObject\n * @param {NormalizedValidator|Function} validator\n * @return {NormalizedValidator}\n */\n\nfunction normalizeValidatorObject(validator) {\n return isFunction(validator.$validator) ? Object.assign({}, validator) : {\n $validator: validator\n };\n}\nfunction isPromise(object) {\n return isObject(object) && isFunction(object.then);\n}\n/**\n * Unwraps a ValidatorResponse object, into a boolean.\n * @param {ValidatorResponse} result\n * @return {boolean}\n */\n\nfunction unwrapValidatorResponse(result) {\n if (typeof result === 'object') return result.$valid;\n return result;\n}\n/**\n * Unwraps a `NormalizedValidator` object, returning its validator function.\n * @param {NormalizedValidator | Function} validator\n * @return {function}\n */\n\nfunction unwrapNormalizedValidator(validator) {\n return validator.$validator || validator;\n}\n\n/**\n * Allows attaching parameters to a validator\n * @param {Object} $params\n * @param {NormalizedValidator|Function} $validator\n * @return {NormalizedValidator}\n */\n\nfunction withParams($params, $validator) {\n if (!isObject($params)) throw new Error(`[@vuelidate/validators]: First parameter to \"withParams\" should be an object, provided ${typeof $params}`);\n if (!isObject($validator) && !isFunction($validator)) throw new Error(`[@vuelidate/validators]: Validator must be a function or object with $validator parameter`);\n const validatorObj = normalizeValidatorObject($validator);\n validatorObj.$params = Object.assign({}, validatorObj.$params || {}, $params);\n return validatorObj;\n}\n\n/**\n * @callback MessageCallback\n * @param {Object} params\n * @return String\n */\n\n/**\n * Attaches a message to a validator\n * @param {MessageCallback | String} $message\n * @param {NormalizedValidator|Function} $validator\n * @return {NormalizedValidator}\n */\n\nfunction withMessage($message, $validator) {\n if (!isFunction($message) && typeof unref($message) !== 'string') throw new Error(`[@vuelidate/validators]: First parameter to \"withMessage\" should be string or a function returning a string, provided ${typeof $message}`);\n if (!isObject($validator) && !isFunction($validator)) throw new Error(`[@vuelidate/validators]: Validator must be a function or object with $validator parameter`);\n const validatorObj = normalizeValidatorObject($validator);\n validatorObj.$message = $message;\n return validatorObj;\n}\n\n/**\n * @typedef {function(*): Promise<boolean|ValidatorResponse>} asyncValidator\n */\n\n/**\n * @typedef {Ref<*>[]|function(*): *} watchTargets\n */\n\n/**\n * Wraps validators that returns a Promise.\n * @param {asyncValidator} $validator\n * @param {watchTargets} $watchTargets\n * @return {{$async: boolean, $validator: asyncValidator, $watchTargets: watchTargets}}\n */\n\nfunction withAsync($validator) {\n let $watchTargets = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n const validatorObj = normalizeValidatorObject($validator);\n return Object.assign({}, validatorObj, {\n $async: true,\n $watchTargets\n });\n}\n\nfunction forEach(validators) {\n return {\n $validator(collection) {\n for (var _len = arguments.length, others = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n others[_key - 1] = arguments[_key];\n }\n\n // go over the collection. It can be a ref as well.\n return unref(collection).reduce((previous, collectionItem, index) => {\n // go over each property\n const collectionEntryResult = Object.entries(collectionItem).reduce((all, _ref) => {\n let [property, $model] = _ref;\n // get the validators for this property\n const innerValidators = validators[property] || {}; // go over each validator and run it\n\n const propertyResult = Object.entries(innerValidators).reduce((all, _ref2) => {\n let [validatorName, currentValidator] = _ref2;\n // extract the validator. Supports simple and extended validators.\n const validatorFunction = unwrapNormalizedValidator(currentValidator); // Call the validator, passing the VM as this, the value, current iterated object and the rest.\n\n const $response = validatorFunction.call(this, $model, collectionItem, index, ...others); // extract the valid from the result\n\n const $valid = unwrapValidatorResponse($response); // store the entire response for later\n\n all.$data[validatorName] = $response;\n all.$data.$invalid = !$valid || !!all.$data.$invalid;\n all.$data.$error = all.$data.$invalid; // if not valid, get the $message\n\n if (!$valid) {\n let $message = currentValidator.$message || '';\n const $params = currentValidator.$params || {}; // If $message is a function, we call it with the appropriate parameters\n\n if (typeof $message === 'function') {\n $message = $message({\n $pending: false,\n $invalid: !$valid,\n $params,\n $model,\n $response\n });\n } // save the error object\n\n\n all.$errors.push({\n $property: property,\n $message,\n $params,\n $response,\n $model,\n $pending: false,\n $validator: validatorName\n });\n }\n\n return {\n $valid: all.$valid && $valid,\n $data: all.$data,\n $errors: all.$errors\n };\n }, {\n $valid: true,\n $data: {},\n $errors: []\n });\n all.$data[property] = propertyResult.$data;\n all.$errors[property] = propertyResult.$errors;\n return {\n $valid: all.$valid && propertyResult.$valid,\n $data: all.$data,\n $errors: all.$errors\n };\n }, {\n $valid: true,\n $data: {},\n $errors: {}\n });\n return {\n $valid: previous.$valid && collectionEntryResult.$valid,\n $data: previous.$data.concat(collectionEntryResult.$data),\n $errors: previous.$errors.concat(collectionEntryResult.$errors)\n };\n }, {\n $valid: true,\n $data: [],\n $errors: []\n });\n },\n\n // collect all the validation errors into a 2 dimensional array, for each entry in the collection, you have an array of error messages.\n $message: _ref3 => {\n let {\n $response\n } = _ref3;\n return $response ? $response.$errors.map(context => {\n return Object.values(context).map(errors => errors.map(error => error.$message)).reduce((a, b) => a.concat(b), []);\n }) : [];\n }\n };\n}\n\n// \"required\" core, used in almost every validator to allow empty values\nconst req = value => {\n value = unref(value);\n if (Array.isArray(value)) return !!value.length;\n\n if (value === undefined || value === null) {\n return false;\n }\n\n if (value === false) {\n return true;\n }\n\n if (value instanceof Date) {\n // invalid date won't pass\n return !isNaN(value.getTime());\n }\n\n if (typeof value === 'object') {\n for (let _ in value) return true;\n\n return false;\n }\n\n return !!String(value).length;\n};\n/**\n * Returns the length of an arbitrary value\n * @param {Array|Object|String} value\n * @return {number}\n */\n\nconst len = value => {\n value = unref(value);\n if (Array.isArray(value)) return value.length;\n\n if (typeof value === 'object') {\n return Object.keys(value).length;\n }\n\n return String(value).length;\n};\n/**\n * Regex based validator template\n * @param {RegExp} expr\n * @return {function(*=): boolean}\n */\n\nfunction regex() {\n for (var _len = arguments.length, expr = new Array(_len), _key = 0; _key < _len; _key++) {\n expr[_key] = arguments[_key];\n }\n\n return value => {\n value = unref(value);\n return !req(value) || expr.every(reg => reg.test(value));\n };\n}\n\nvar common = /*#__PURE__*/Object.freeze({\n __proto__: null,\n withParams: withParams,\n withMessage: withMessage,\n withAsync: withAsync,\n forEach: forEach,\n req: req,\n len: len,\n regex: regex,\n unwrap: unref,\n unwrapNormalizedValidator: unwrapNormalizedValidator,\n unwrapValidatorResponse: unwrapValidatorResponse,\n normalizeValidatorObject: normalizeValidatorObject\n});\n\nvar alpha$1 = regex(/^[a-zA-Z]*$/);\n\n/**\n * Validate if value is alphabetical string.\n * @type {NormalizedValidator}\n */\n\nvar alpha = {\n $validator: alpha$1,\n $message: 'The value is not alphabetical',\n $params: {\n type: 'alpha'\n }\n};\n\nvar alphaNum$1 = regex(/^[a-zA-Z0-9]*$/);\n\n/**\n * Validate if value is alpha-numeric string.\n * @type {NormalizedValidator}\n */\n\nvar alphaNum = {\n $validator: alphaNum$1,\n $message: 'The value must be alpha-numeric',\n $params: {\n type: 'alphaNum'\n }\n};\n\nvar numeric$1 = regex(/^\\d*(\\.\\d+)?$/);\n\n/**\n * Check whether a value is numeric.\n * @type NormalizedValidator\n */\n\nvar numeric = {\n $validator: numeric$1,\n $message: 'Value must be numeric',\n $params: {\n type: 'numeric'\n }\n};\n\n/**\n * Check if a numeric value is between two values.\n * @param {Ref<Number> | Number} min\n * @param {Ref<Number> | Number} max\n * @return {function(*=): boolean}\n */\n\nfunction between$1 (min, max) {\n return value => !req(value) || (!/\\s/.test(value) || value instanceof Date) && +unref(min) <= +value && +unref(max) >= +value;\n}\n\n/**\n * Checks if a value is between two values.\n * @param {Ref<Number> | Number} min\n * @param {Ref<Number> | Number} max\n * @return {NormalizedValidator}\n */\n\nfunction between (min, max) {\n return {\n $validator: between$1(min, max),\n $message: _ref => {\n let {\n $params\n } = _ref;\n return `The value must be between ${$params.min} and ${$params.max}`;\n },\n $params: {\n min,\n max,\n type: 'between'\n }\n };\n}\n\nconst emailRegex = /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])$/i;\nvar email$1 = regex(emailRegex);\n\n/**\n * Validate if value is an email.\n * @type {NormalizedValidator}\n */\n\nvar email = {\n $validator: email$1,\n $message: 'Value is not a valid email address',\n $params: {\n type: 'email'\n }\n};\n\n/**\n * Check if a string is an IP Address\n * @param {String} value\n * @returns {boolean}\n */\n\nfunction ipAddress$1 (value) {\n if (!req(value)) {\n return true;\n }\n\n if (typeof value !== 'string') {\n return false;\n }\n\n const nibbles = value.split('.');\n return nibbles.length === 4 && nibbles.every(nibbleValid);\n}\n\nconst nibbleValid = nibble => {\n if (nibble.length > 3 || nibble.length === 0) {\n return false;\n }\n\n if (nibble[0] === '0' && nibble !== '0') {\n return false;\n }\n\n if (!nibble.match(/^\\d+$/)) {\n return false;\n }\n\n const numeric = +nibble | 0;\n return numeric >= 0 && numeric <= 255;\n};\n\n/**\n * Validate if value is an ipAddress string.\n * @type {NormalizedValidator}\n */\n\nvar ipAddress = {\n $validator: ipAddress$1,\n $message: 'The value is not a valid IP address',\n $params: {\n type: 'ipAddress'\n }\n};\n\n/**\n * Check if value is a properly formatted Mac Address.\n * @param {String | Ref<String>} [separator]\n * @returns {function(*): boolean}\n */\n\nfunction macAddress$1 () {\n let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ':';\n return value => {\n separator = unref(separator);\n\n if (!req(value)) {\n return true;\n }\n\n if (typeof value !== 'string') {\n return false;\n }\n\n const parts = typeof separator === 'string' && separator !== '' ? value.split(separator) : value.length === 12 || value.length === 16 ? value.match(/.{2}/g) : null;\n return parts !== null && (parts.length === 6 || parts.length === 8) && parts.every(hexValid);\n };\n}\n\nconst hexValid = hex => hex.toLowerCase().match(/^[0-9a-f]{2}$/);\n\n/**\n * Validate if value is a valid Mac Address string.\n * @returns {NormalizedValidator}\n */\n\nfunction macAddress (separator) {\n return {\n $validator: macAddress$1(separator),\n $message: 'The value is not a valid MAC Address',\n $params: {\n type: 'macAddress'\n }\n };\n}\n\n/**\n * Check if provided value has a maximum length\n * @param {Number | Ref<Number>} length\n * @returns {function(Array|Object|String): boolean}\n */\n\nfunction maxLength$1 (length) {\n return value => !req(value) || len(value) <= unref(length);\n}\n\n/**\n * Validate the max length of a string.\n * @param {Number} max\n * @return {NormalizedValidator}\n */\n\nfunction maxLength (max) {\n return {\n $validator: maxLength$1(max),\n $message: _ref => {\n let {\n $params\n } = _ref;\n return `The maximum length allowed is ${$params.max}`;\n },\n $params: {\n max,\n type: 'maxLength'\n }\n };\n}\n\n/**\n * Check if value is above a threshold.\n * @param {Number | Ref<Number>} length\n * @returns {function(Array|Object|String): boolean}\n */\n\nfunction minLength$1 (length) {\n return value => !req(value) || len(value) >= unref(length);\n}\n\n/**\n * Check if value is above a threshold.\n * @param {Number | Ref<Number>} min\n * @returns {NormalizedValidator}\n */\n\nfunction minLength (min) {\n return {\n $validator: minLength$1(min),\n $message: _ref => {\n let {\n $params\n } = _ref;\n return `This field should be at least ${$params.min} characters long`;\n },\n $params: {\n min,\n type: 'minLength'\n }\n };\n}\n\n/**\n * Validates if a value is empty.\n * @param {String | Array | Date | Object} value\n * @returns {boolean}\n */\n\nfunction required$1 (value) {\n if (typeof value === 'string') {\n value = value.trim();\n }\n\n return req(value);\n}\n\n/**\n * Check if a value is empty or not.\n * @type {NormalizedValidator}\n */\n\nvar required = {\n $validator: required$1,\n $message: 'Value is required',\n $params: {\n type: 'required'\n }\n};\n\nconst validate$1 = (prop, val) => prop ? req(typeof val === 'string' ? val.trim() : val) : true;\n/**\n * Returns required if the passed property is truthy\n * @param {Boolean | String | function(any): Boolean | Ref<string | boolean>} propOrFunction\n * @return {function(value: *, parentVM: object): Boolean}\n */\n\n\nfunction requiredIf$1(propOrFunction) {\n return function (value, parentVM) {\n if (typeof propOrFunction !== 'function') {\n return validate$1(unref(propOrFunction), value);\n }\n\n const result = propOrFunction.call(this, value, parentVM);\n return validate$1(result, value);\n };\n}\n\n/**\n * Returns required if the passed property is truthy\n * @param {Boolean | String | function(): (Boolean | Promise<boolean>)} prop\n * @return {NormalizedValidator}\n */\n\nfunction requiredIf (prop) {\n return {\n $validator: requiredIf$1(prop),\n $message: 'The value is required',\n $params: {\n type: 'requiredIf',\n prop\n }\n };\n}\n\nconst validate = (prop, val) => !prop ? req(typeof val === 'string' ? val.trim() : val) : true;\n/**\n * Returns required if the passed property is falsy.\n * @param {Boolean | String | function(any): Boolean | Ref<string | boolean>} propOrFunction\n * @return {function(value: *, parentVM: object): Boolean}\n */\n\n\nfunction requiredUnless$1(propOrFunction) {\n return function (value, parentVM) {\n if (typeof propOrFunction !== 'function') {\n return validate(unref(propOrFunction), value);\n }\n\n const result = propOrFunction.call(this, value, parentVM);\n return validate(result, value);\n };\n}\n\n/**\n * Returns required unless the passed property is truthy\n * @param {Boolean | String | function(): (Boolean | Promise<boolean>)} prop\n * @return {NormalizedValidator}\n */\n\nfunction requiredUnless (prop) {\n return {\n $validator: requiredUnless$1(prop),\n $message: 'The value is required',\n $params: {\n type: 'requiredUnless',\n prop\n }\n };\n}\n\n/**\n * Check if two values are identical.\n * @param {*} equalTo\n * @return {function(*=): boolean}\n */\n\nfunction sameAs$1 (equalTo) {\n return value => unref(value) === unref(equalTo);\n}\n\n/**\n * Check if two values are identical\n * @param {*} equalTo\n * @param {String} [otherName]\n * @return {NormalizedValidator}\n */\n\nfunction sameAs (equalTo) {\n let otherName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'other';\n return {\n $validator: sameAs$1(equalTo),\n $message: _ref => {\n return `The value must be equal to the ${otherName} value`;\n },\n $params: {\n equalTo,\n otherName,\n type: 'sameAs'\n }\n };\n}\n\n/**\n * Regex taken from {@link https://gist.github.com/dperini/729294}\n */\n\nconst urlRegex = /^(?:(?:(?:https?|ftp):)?\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:[a-z\\u00a1-\\uffff]{2,}\\.?))(?::\\d{2,5})?(?:[/?#]\\S*)?$/i;\nvar url$1 = regex(urlRegex);\n\n/**\n * Check if a value is a url\n * @type {NormalizedValidator}\n */\n\nvar url = {\n $validator: url$1,\n $message: 'The value is not a valid URL address',\n $params: {\n type: 'url'\n }\n};\n\nfunction _await$1(value, then, direct) {\n if (direct) {\n return then ? then(value) : value;\n }\n\n if (!value || !value.then) {\n value = Promise.resolve(value);\n }\n\n return then ? value.then(then) : value;\n}\n\nfunction syncOr(validators) {\n return function () {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return validators.reduce((valid, fn) => {\n if (unwrapValidatorResponse(valid)) return valid;\n return unwrapNormalizedValidator(fn).apply(this, args);\n }, false);\n };\n}\n\nfunction asyncOr(validators) {\n return function () {\n const _this = this;\n\n for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n args[_key2] = arguments[_key2];\n }\n\n return validators.reduce(function (valid, fn) {\n return _await$1(valid, function (r) {\n return unwrapValidatorResponse(r) ? r : unwrapNormalizedValidator(fn).apply(_this, args);\n });\n }, Promise.resolve(false));\n };\n}\n/**\n * Returns true when one of the provided functions returns true.\n * @param {...(NormalizedValidator|Function)} validators\n * @return {{$validator: function(...[*]=): (boolean | Promise<boolean>), $async: boolean, $watchTargets: any[]}}\n */\n\n\nfunction or$1() {\n for (var _len3 = arguments.length, validators = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n validators[_key3] = arguments[_key3];\n }\n\n const $async = validators.some(v => v.$async);\n const $watchTargets = validators.reduce((all, v) => {\n if (!v.$watchTargets) return all;\n return all.concat(v.$watchTargets);\n }, []);\n\n let $validator = () => false;\n\n if (validators.length) $validator = $async ? asyncOr(validators) : syncOr(validators);\n return {\n $async,\n $validator,\n $watchTargets\n };\n}\n\n/**\n * Returns true when one of the provided functions returns true.\n * @param {...(NormalizedValidator|Function)} validators\n * @return {NormalizedValidator}\n */\n\nfunction or () {\n return withParams({\n type: 'or'\n }, withMessage('The value does not match any of the provided validators', or$1(...arguments)));\n}\n\nfunction _await(value, then, direct) {\n if (direct) {\n return then ? then(value) : value;\n }\n\n if (!value || !value.then) {\n value = Promise.resolve(value);\n }\n\n return then ? value.then(then) : value;\n}\n/**\n *\n * @param validators\n * @return {function(...[*]=): Promise<boolean>}\n */\n\n\nfunction syncAnd(validators) {\n return function () {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return validators.reduce((valid, fn) => {\n if (!unwrapValidatorResponse(valid)) return valid;\n return unwrapNormalizedValidator(fn).apply(this, args);\n }, true);\n };\n}\n\nfunction asyncAnd(validators) {\n return function () {\n const _this = this;\n\n for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n args[_key2] = arguments[_key2];\n }\n\n return validators.reduce(function (valid, fn) {\n return _await(valid, function (r) {\n return unwrapValidatorResponse(r) ? unwrapNormalizedValidator(fn).apply(_this, args) : r;\n });\n }, Promise.resolve(true));\n };\n}\n/**\n * Returns true when all validators are truthy\n * @param {...(NormalizedValidator | Function)} validators\n * @return {{$validator: function(...[*]=): (boolean | Promise<boolean>), $async: boolean, $watchTargets: any[]}}\n */\n\n\nfunction and$1() {\n for (var _len3 = arguments.length, validators = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n validators[_key3] = arguments[_key3];\n }\n\n const $async = validators.some(v => v.$async);\n const $watchTargets = validators.reduce((all, v) => {\n if (!v.$watchTargets) return all;\n return all.concat(v.$watchTargets);\n }, []);\n\n let $validator = () => false;\n\n if (validators.length) $validator = $async ? asyncAnd(validators) : syncAnd(validators);\n return {\n $async,\n $validator,\n $watchTargets\n };\n}\n\n/**\n * Validate if all validators match.\n * @param {...*} validators\n * @returns {NormalizedValidator}\n */\n\nfunction and () {\n return withParams({\n type: 'and'\n }, withMessage('The value does not match all of the provided validators', and$1(...arguments)));\n}\n\n/**\n * Swaps the result of a value\n * @param {NormalizedValidator|Function} validator\n * @returns {function(*=, *=): boolean}\n */\n\nfunction not$1 (validator) {\n return function (value, vm) {\n if (!req(value)) return true;\n const response = unwrapNormalizedValidator(validator).call(this, value, vm);\n if (!isPromise(response)) return !unwrapValidatorResponse(response);\n return response.then(r => !unwrapValidatorResponse(r));\n };\n}\n\n/**\n * Swaps the result of a value\n * @param {NormalizedValidator|Function} validator\n * @returns {NormalizedValidator}\n */\n\nfunction not (validator) {\n return {\n $validator: not$1(validator),\n $message: `The value does not match the provided validator`,\n $params: {\n type: 'not'\n }\n };\n}\n\n/**\n * Check if a value is above a threshold.\n * @param {String | Number | Ref<Number> | Ref<String>} min\n * @returns {function(*=): boolean}\n */\n\nfunction minValue$1 (min) {\n return value => !req(value) || (!/\\s/.test(value) || value instanceof Date) && +value >= +unref(min);\n}\n\n/**\n * Check if a value is above a threshold.\n * @param {String | Number | Ref<Number> | Ref<String>} min\n * @returns {NormalizedValidator}\n */\n\nfunction minValue (min) {\n return {\n $validator: minValue$1(min),\n $message: _ref => {\n let {\n $params\n } = _ref;\n return `The minimum value allowed is ${$params.min}`;\n },\n $params: {\n min,\n type: 'minValue'\n }\n };\n}\n\n/**\n * Check if value is below a threshold.\n * @param {Number | Ref<Number> | Ref<String>} max\n * @returns {function(*=): boolean}\n */\n\nfunction maxValue$1 (max) {\n return value => !req(value) || (!/\\s/.test(value) || value instanceof Date) && +value <= +unref(max);\n}\n\n/**\n * Check if value is below a threshold.\n * @param {Number | Ref<Number> | Ref<String>} max\n * @return {NormalizedValidator}\n */\n\nvar maxValue = (max => ({\n $validator: maxValue$1(max),\n $message: _ref => {\n let {\n $params\n } = _ref;\n return `The maximum value allowed is ${$params.max}`;\n },\n $params: {\n max,\n type: 'maxValue'\n }\n}));\n\n// ^-[0-9]+$ - only for negative integer (minus sign without at least 1 digit is not a number)\n\nvar integer$1 = regex(/(^[0-9]*$)|(^-[0-9]+$)/);\n\n/**\n * Validate if value is integer.\n * @type {NormalizedValidator}\n */\n\nvar integer = {\n $validator: integer$1,\n $message: 'Value is not an integer',\n $params: {\n type: 'integer'\n }\n};\n\nvar decimal$1 = regex(/^[-]?\\d*(\\.\\d+)?$/);\n\n/**\n * Validate if value is decimal number.\n * @type {NormalizedValidator}\n */\n\nvar decimal = {\n $validator: decimal$1,\n $message: 'Value must be decimal',\n $params: {\n type: 'decimal'\n }\n};\n\n/**\n * Creates a translatable version of `withMessage` helper.\n * @param {function} t - the translation function of your choice\n * @param {function} [messagePath] - a function to generate the message path, passed to `t` for each message. By default it is `validations.${$validator}`\n * @param {function} [messageParams] - a function to augment the params, passed to `t` for each message.\n */\n\nfunction createI18nMessage(_ref) {\n let {\n t,\n messagePath = _ref2 => {\n let {\n $validator\n } = _ref2;\n return `validations.${$validator}`;\n },\n messageParams = params => params\n } = _ref;\n return function withI18nMessage(validator) {\n let {\n withArguments = false,\n messagePath: localMessagePath = messagePath,\n messageParams: localMessageParams = messageParams\n } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n function message(props) {\n return t(localMessagePath(props), localMessageParams(Object.assign({\n model: props.$model,\n property: props.$property,\n pending: props.$pending,\n invalid: props.$invalid,\n response: props.$response,\n validator: props.$validator,\n propertyPath: props.$propertyPath\n }, props.$params)));\n }\n\n if (withArguments && typeof validator === 'function') {\n return function () {\n return withMessage(message, validator(...arguments));\n };\n }\n\n return withMessage(message, validator);\n };\n}\n\nexport { alpha, alphaNum, and, between, createI18nMessage, decimal, email, common as helpers, integer, ipAddress, macAddress, maxLength, maxValue, minLength, minValue, not, numeric, or, required, requiredIf, requiredUnless, sameAs, url };\n"],"names":["Vue","unwrapObj","obj","ignoreKeys","o","k","unref","isFunction","val","isProxy","value","isReactive","isReadonly","get","stringPath","def","current","path","gatherBooleanGroupProperties","group","nestedResults","property","computed","gatherArrayGroupProperties","all","fetchedProperty","callRule","rule","siblingState","instance","normalizeValidatorResponse","result","createAsyncResult","model","$pending","$dirty","_ref","$response","$lazy","$rewardEarly","watchTargets","$lastInvalidState","$lastCommittedOn","$invalid","ref","$pendingCounter","$unwatch","watch","ruleResult","err","data","error","createSyncResult","_ref2","returnValue","createValidatorResult","config","validatorName","propertyKey","propertyPath","$params","message","sortValidations","validationsRaw","validations","validationKeys","rules","nestedValidators","validationGroups","key","v","_empty","ROOT_PATH","_call","body","then","direct","e","_callIgnored","_invoke","_async","f","args","i","createValidationResults","resultsCache","externalResults","ruleKeys","cachedResult","ruleKey","stringError","index","r","res","reactive","collectNestedValidationResults","nestedState","nestedExternalResults","nestedValidationKeys","results","nestedKey","setValidations","createMetaFields","childResults","allResults","allRes","$silentErrors","modelErrors","nestedErrors","errors","$errors","$anyDirty","$error","$touch","$commit","$reset","nr","$validate","mergedConfig","nextTick","resolve","unwatch","state","parentKey","globalConfig","s","cachedExternalResults","$validationGroups","$model","external","isRef","$getResultsForChild","$clearExternalResults","ResultsStorage","storedRules","storedRulesKeys","newRulesKeys","paramKey","storedRuleResultPair","isValidCache","CollectFlag","VuelidateInjectChildResults","VuelidateRemoveChildResults","nestedValidations","$scope","childResultsRaw","childResultsKeys","injectChildResultsIntoParent","childScope","$stopPropagation","removeChildResultsFromParent","childKey","sendValidationResultsToParent","inject","provide","removeValidationResultsFromParent","ComputedProxyFactory","target","prop","uid","useVuelidate","_getCurrentInstance","$registerAs","$externalResults","currentVueInstance","getCurrentInstance","componentOptions","validationResults","onBeforeMount","validationsWatchTarget","newValidationRules","onBeforeUnmount","isObject","normalizeValidatorObject","validator","unwrapValidatorResponse","unwrapNormalizedValidator","withParams","$validator","validatorObj","withMessage","$message","withAsync","$watchTargets","forEach","validators","collection","_len","others","_key","previous","collectionItem","collectionEntryResult","innerValidators","propertyResult","currentValidator","$valid","_ref3","context","b","req","_","len","regex","expr","reg","common","emailRegex","email$1","email","maxLength$1","length","maxLength","max","required$1","required","urlRegex"],"mappings":"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","x_google_ignoreList":[0,1,2]}