{"version":3,"file":"index.iife.min.js","sources":["../src/utils/common.js","../src/utils/withParams.js","../src/utils/withMessage.js","../src/raw/core.js","../src/utils/withAsync.js","../src/utils/forEach.js","../src/withMessages/alpha.js","../src/raw/alpha.js","../src/withMessages/alphaNum.js","../src/raw/alphaNum.js","../src/withMessages/numeric.js","../src/raw/numeric.js","../src/raw/between.js","../src/withMessages/email.js","../src/raw/email.js","../src/raw/ipAddress.js","../src/withMessages/ipAddress.js","../src/raw/macAddress.js","../src/withMessages/required.js","../src/raw/required.js","../src/raw/requiredIf.js","../src/raw/requiredUnless.js","../src/raw/sameAs.js","../src/withMessages/url.js","../src/raw/url.js","../src/raw/or.js","../src/raw/and.js","../src/raw/not.js","../src/raw/minValue.js","../src/raw/maxValue.js","../src/withMessages/integer.js","../src/raw/integer.js","../src/withMessages/decimal.js","../src/raw/decimal.js","../src/withMessages/and.js","../src/withMessages/between.js","../src/utils/createI18nMessage.js","../src/withMessages/macAddress.js","../src/withMessages/maxLength.js","../src/raw/maxLength.js","../src/withMessages/maxValue.js","../src/withMessages/minLength.js","../src/raw/minLength.js","../src/withMessages/minValue.js","../src/withMessages/not.js","../src/withMessages/or.js","../src/withMessages/requiredIf.js","../src/withMessages/requiredUnless.js","../src/withMessages/sameAs.js"],"sourcesContent":["import { unref as unwrap } from 'vue-demi'\n\nexport { unwrap }\n\nexport function isFunction (val) {\n  return typeof val === 'function'\n}\n\nexport function isObject (o) {\n  return o !== null && typeof o === 'object' && !Array.isArray(o)\n}\n\n/**\n * Returns a standard ValidatorObject\n * Wraps a plain function into a ValidatorObject\n * @param {NormalizedValidator|Function} validator\n * @return {NormalizedValidator}\n */\nexport function normalizeValidatorObject (validator) {\n  return isFunction(validator.$validator)\n    ? { ...validator }\n    : {\n      $validator: validator\n    }\n}\n\n/**\n * Returns whether a value is truthy ot not.\n * @param {Function|*} prop\n * @return {boolean}\n */\nexport function isTruthy (prop) {\n  prop = unwrap(prop)\n  return Boolean(isFunction(prop) ? prop() : prop)\n}\n\nexport function isPromise (object) {\n  return isObject(object) && isFunction(object.then)\n}\n\n/**\n * Unwraps a ValidatorResponse object, into a boolean.\n * @param {ValidatorResponse} result\n * @return {boolean}\n */\nexport function unwrapValidatorResponse (result) {\n  if (typeof result === 'object') return result.$valid\n  return result\n}\n\n/**\n * Unwraps a `NormalizedValidator` object, returning its validator function.\n * @param {NormalizedValidator | Function} validator\n * @return {function}\n */\nexport function unwrapNormalizedValidator (validator) {\n  return validator.$validator || validator\n}\n","import { normalizeValidatorObject, isFunction, isObject } from './common'\n\n/**\n * Allows attaching parameters to a validator\n * @param {Object} $params\n * @param {NormalizedValidator|Function} $validator\n * @return {NormalizedValidator}\n */\nexport default function 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\n  const validatorObj = normalizeValidatorObject($validator)\n\n  validatorObj.$params = {\n    ...(validatorObj.$params || {}),\n    ...$params\n  }\n\n  return validatorObj\n}\n","import { normalizeValidatorObject, isFunction, isObject, unwrap } from './common'\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 */\nexport default function withMessage ($message, $validator) {\n  if (!isFunction($message) && typeof unwrap($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\n  const validatorObj = normalizeValidatorObject($validator)\n  validatorObj.$message = $message\n\n  return validatorObj\n}\n","// \"required\" core, used in almost every validator to allow empty values\n\nimport { unwrap } from '../utils/common'\n\nexport const req = (value) => {\n  value = unwrap(value)\n  if (Array.isArray(value)) return !!value.length\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    return false\n  }\n\n  return !!String(value).length\n}\n\n/**\n * Returns the length of an arbitrary value\n * @param {Array|Object|String} value\n * @return {number}\n */\nexport const len = (value) => {\n  value = unwrap(value)\n  if (Array.isArray(value)) return value.length\n  if (typeof value === 'object') {\n    return Object.keys(value).length\n  }\n  return String(value).length\n}\n\n/**\n * Regex based validator template\n * @param {RegExp} expr\n * @return {function(*=): boolean}\n */\nexport function regex (...expr) {\n  return (value) => {\n    value = unwrap(value)\n    return !req(value) || expr.every((reg) => reg.test(value))\n  }\n}\n","import { normalizeValidatorObject } from './common'\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 */\nexport default function withAsync ($validator, $watchTargets = []) {\n  const validatorObj = normalizeValidatorObject($validator)\n  return {\n    ...validatorObj,\n    $async: true,\n    $watchTargets\n  }\n}\n","import { unwrapNormalizedValidator, unwrapValidatorResponse, unwrap } from './common'\n\nexport default function forEach (validators) {\n  return {\n    $validator (collection, ...others) {\n      // go over the collection. It can be a ref as well.\n      return unwrap(collection).reduce((previous, collectionItem) => {\n        // go over each property\n        const collectionEntryResult = Object.entries(collectionItem).reduce((all, [property, $model]) => {\n          // get the validators for this property\n          const innerValidators = validators[property] || {}\n          // go over each validator and run it\n          const propertyResult = Object.entries(innerValidators).reduce((all, [validatorName, currentValidator]) => {\n            // extract the validator. Supports simple and extended validators.\n            const validatorFunction = unwrapNormalizedValidator(currentValidator)\n            // Call the validator, passing the VM as this, the value, current iterated object and the rest.\n            const $response = validatorFunction.call(this, $model, collectionItem, ...others)\n            // extract the valid from the result\n            const $valid = unwrapValidatorResponse($response)\n            // store the entire response for later\n            all.$data[validatorName] = $response\n            all.$data.$invalid = !$valid || !!all.$data.$invalid\n            all.$data.$error = all.$data.$invalid\n            // if not valid, get the $message\n            if (!$valid) {\n              let $message = currentValidator.$message || ''\n              const $params = currentValidator.$params || {}\n              // If $message is a function, we call it with the appropriate parameters\n              if (typeof $message === 'function') {\n                $message = $message({\n                  $pending: false,\n                  $invalid: !$valid,\n                  $params,\n                  $model,\n                  $response\n                })\n              }\n              // save the error object\n              all.$errors.push({\n                $property: property,\n                $message,\n                $params,\n                $response,\n                $model,\n                $pending: false,\n                $validator: validatorName\n              })\n            }\n            return {\n              $valid: all.$valid && $valid,\n              $data: all.$data,\n              $errors: all.$errors\n            }\n          }, { $valid: true, $data: {}, $errors: [] })\n\n          all.$data[property] = propertyResult.$data\n          all.$errors[property] = propertyResult.$errors\n\n          return {\n            $valid: all.$valid && propertyResult.$valid,\n            $data: all.$data,\n            $errors: all.$errors\n          }\n        }, { $valid: true, $data: {}, $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      }, { $valid: true, $data: [], $errors: [] })\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: ({ $response }) => ($response\n      ? $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","import alpha from '../raw/alpha'\n\n/**\n * Validate if value is alphabetical string.\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: alpha,\n  $message: 'The value is not alphabetical',\n  $params: {\n    type: 'alpha'\n  }\n}\n","import { regex } from '../common'\n\nexport default regex(/^[a-zA-Z]*$/)\n","import alphaNum from '../raw/alphaNum'\n\n/**\n * Validate if value is alpha-numeric string.\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: alphaNum,\n  $message: 'The value must be alpha-numeric',\n  $params: {\n    type: 'alphaNum'\n  }\n}\n","import { regex } from '../common'\n\nexport default regex(/^[a-zA-Z0-9]*$/)\n","import numeric from '../raw/numeric'\n\n/**\n * Check whether a value is numeric.\n * @type NormalizedValidator\n */\nexport default {\n  $validator: numeric,\n  $message: 'Value must be numeric',\n  $params: {\n    type: 'numeric'\n  }\n}\n","import { regex } from '../common'\n\nexport default regex(/^\\d*(\\.\\d+)?$/)\n","import { req } from './core'\nimport { unwrap } from '../utils/common'\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 */\nexport default function (min, max) {\n  return (value) =>\n    !req(value) ||\n    ((!/\\s/.test(value) || value instanceof Date) &&\n      +unwrap(min) <= +value &&\n      +unwrap(max) >= +value)\n}\n","import email from '../raw/email'\n\n/**\n * Validate if value is an email.\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: email,\n  $message: 'Value is not a valid email address',\n  $params: { type: 'email' }\n}\n","import { regex } from '../common'\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;\n\nexport default regex(emailRegex)\n","import { req } from '../common'\n\n/**\n * Check if a string is an IP Address\n * @param {String} value\n * @returns {boolean}\n */\nexport default function (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","import ipAddress from '../raw/ipAddress'\n\n/**\n * Validate if value is an ipAddress string.\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: ipAddress,\n  $message: 'The value is not a valid IP address',\n  $params: { type: 'ipAddress' }\n}\n","import { req } from './core'\nimport { unwrap } from '../utils/common'\n\n/**\n * Check if value is a properly formatted Mac Address.\n * @param {String | Ref<String>} [separator]\n * @returns {function(*): boolean}\n */\nexport default function (separator = ':') {\n  return value => {\n    separator = unwrap(separator)\n\n    if (!req(value)) {\n      return true\n    }\n\n    if (typeof value !== 'string') {\n      return false\n    }\n\n    const parts =\n      typeof separator === 'string' && separator !== ''\n        ? value.split(separator)\n        : value.length === 12 || value.length === 16\n          ? value.match(/.{2}/g)\n          : null\n\n    return (\n      parts !== null &&\n      (parts.length === 6 || parts.length === 8) &&\n      parts.every(hexValid)\n    )\n  }\n}\n\nconst hexValid = (hex) => hex.toLowerCase().match(/^[0-9a-f]{2}$/)\n","import required from '../raw/required'\n\n/**\n * Check if a value is empty or not.\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: required,\n  $message: 'Value is required',\n  $params: {\n    type: 'required'\n  }\n}\n","import { req } from '../common'\n\n/**\n * Validates if a value is empty.\n * @param {String | Array | Date | Object} value\n * @returns {boolean}\n */\nexport default function (value) {\n  if (typeof value === 'string') {\n    value = value.trim()\n  }\n  return req(value)\n}\n","import { req } from './core'\nimport { unwrap } from '../common'\n\nconst validate = (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 */\nexport default function requiredIf (propOrFunction) {\n  return function (value, parentVM) {\n    if (typeof propOrFunction !== 'function') {\n      return validate(unwrap(propOrFunction), value)\n    }\n    const result = propOrFunction.call(this, value, parentVM)\n    return validate(result, value)\n  }\n}\n","import { req } from './core'\nimport { unwrap } from '../common'\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 */\nexport default function requiredUnless (propOrFunction) {\n  return function (value, parentVM) {\n    if (typeof propOrFunction !== 'function') {\n      return validate(unwrap(propOrFunction), value)\n    }\n    const result = propOrFunction.call(this, value, parentVM)\n    return validate(result, value)\n  }\n}\n","import { unwrap } from '../utils/common'\n\n/**\n * Check if two values are identical.\n * @param {*} equalTo\n * @return {function(*=): boolean}\n */\nexport default function (equalTo) {\n  return value => unwrap(value) === unwrap(equalTo)\n}\n","import url from '../raw/url'\n\n/**\n * Check if a value is a url\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: url,\n  $message: 'The value is not a valid URL address',\n  $params: {\n    type: 'url'\n  }\n}\n","import { regex } from '../common'\n\n/**\n * Regex taken from {@link https://gist.github.com/dperini/729294}\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\n\nexport default regex(urlRegex)\n","import { unwrapNormalizedValidator, unwrapValidatorResponse } from '../utils/common'\n\nfunction syncOr (validators) {\n  return function (...args) {\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 (...args) {\n    return validators\n      .reduce(async (valid, fn) => {\n        const r = await valid\n        if (unwrapValidatorResponse(r)) return r\n        return unwrapNormalizedValidator(fn).apply(this, args)\n      }, Promise.resolve(false))\n  }\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 */\nexport default function or (...validators) {\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  let $validator = () => false\n  if (validators.length) $validator = $async ? asyncOr(validators) : syncOr(validators)\n  return {\n    $async,\n    $validator,\n    $watchTargets\n  }\n}\n","import { unwrapNormalizedValidator, unwrapValidatorResponse } from '../utils/common'\n\nfunction syncAnd (validators) {\n  return function (...args) {\n    return validators.reduce((valid, fn) => {\n      if (!unwrapValidatorResponse(valid)) return valid\n      return unwrapNormalizedValidator(fn).apply(this, args)\n    }, true)\n  }\n}\n\n/**\n *\n * @param validators\n * @return {function(...[*]=): Promise<boolean>}\n */\nfunction asyncAnd (validators) {\n  return function (...args) {\n    return validators.reduce(async (valid, fn) => {\n      const r = await valid\n      if (!unwrapValidatorResponse(r)) return r\n      return unwrapNormalizedValidator(fn).apply(this, args)\n    }, Promise.resolve(true))\n  }\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 */\nexport default function and (...validators) {\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  let $validator = () => false\n  if (validators.length) $validator = $async ? asyncAnd(validators) : syncAnd(validators)\n  return {\n    $async,\n    $validator,\n    $watchTargets\n  }\n}\n","import { req } from './core'\nimport { isPromise, unwrapNormalizedValidator, unwrapValidatorResponse } from '../utils/common'\n\n/**\n * Swaps the result of a value\n * @param {NormalizedValidator|Function} validator\n * @returns {function(*=, *=): boolean}\n */\nexport default function (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","import { req } from './core'\nimport { unwrap } from '../utils/common'\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 */\nexport default function (min) {\n  return (value) =>\n    !req(value) ||\n    ((!/\\s/.test(value) || value instanceof Date) && +value >= +unwrap(min))\n}\n","import { req } from '../common'\nimport { unwrap } from '../utils/common'\n\n/**\n * Check if value is below a threshold.\n * @param {Number | Ref<Number> | Ref<String>} max\n * @returns {function(*=): boolean}\n */\nexport default function (max) {\n  return value =>\n    !req(value) ||\n    ((!/\\s/.test(value) || value instanceof Date) && +value <= +unwrap(max))\n}\n","import integer from '../raw/integer'\n\n/**\n * Validate if value is integer.\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: integer,\n  $message: 'Value is not an integer',\n  $params: { type: 'integer' }\n}\n","import { regex } from '../common'\n// ^[0-9]*$ - for empty string and positive integer\n// ^-[0-9]+$ - only for negative integer (minus sign without at least 1 digit is not a number)\nexport default regex(/(^[0-9]*$)|(^-[0-9]+$)/)\n","import decimal from '../raw/decimal'\n\n/**\n * Validate if value is decimal number.\n * @type {NormalizedValidator}\n */\nexport default {\n  $validator: decimal,\n  $message: 'Value must be decimal',\n  $params: { type: 'decimal' }\n}\n","import { regex } from '../common'\n\nexport default regex(/^[-]?\\d*(\\.\\d+)?$/)\n","import and from '../raw/and'\nimport { withMessage, withParams } from '../common'\n\n/**\n * Validate if all validators match.\n * @param {...*} validators\n * @returns {NormalizedValidator}\n */\nexport default function (...validators) {\n  return withParams({ type: 'and' },\n    withMessage('The value does not match all of the provided validators',\n      and(...validators)\n    )\n  )\n}\n","import between from '../raw/between'\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 */\nexport default function (min, max) {\n  return {\n    $validator: between(min, max),\n    $message: ({ $params }) => `The value must be between ${$params.min} and ${$params.max}`,\n    $params: { min, max, type: 'between' }\n  }\n}\n","import withMessage from './withMessage'\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 */\nexport default function createI18nMessage ({\n  t,\n  messagePath = ({ $validator }) => `validations.${$validator}`,\n  messageParams = (params) => params\n}) {\n  return function withI18nMessage (\n    validator,\n    {\n      withArguments = false,\n      messagePath: localMessagePath = messagePath,\n      messageParams: localMessageParams = messageParams\n    } = {}\n  ) {\n    function message (props) {\n      return t(localMessagePath(props), localMessageParams({\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\n    if (withArguments && typeof validator === 'function') {\n      return (...args) => withMessage(message, validator(...args))\n    }\n\n    return withMessage(message, validator)\n  }\n}\n","import macAddress from '../raw/macAddress'\n\n/**\n * Validate if value is a valid Mac Address string.\n * @returns {NormalizedValidator}\n */\nexport default function (separator) {\n  return {\n    $validator: macAddress(separator),\n    $message: 'The value is not a valid MAC Address',\n    $params: { type: 'macAddress' }\n  }\n}\n","import maxLength from '../raw/maxLength'\n\n/**\n * Validate the max length of a string.\n * @param {Number} max\n * @return {NormalizedValidator}\n */\nexport default function (max) {\n  return {\n    $validator: maxLength(max),\n    $message: ({ $params }) => `The maximum length allowed is ${$params.max}`,\n    $params: { max, type: 'maxLength' }\n  }\n}\n","import { req, len } from '../common'\nimport { unwrap } from '../utils/common'\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 */\nexport default function (length) {\n  return (value) => !req(value) || len(value) <= unwrap(length)\n}\n","import maxValue from '../raw/maxValue'\n\n/**\n * Check if value is below a threshold.\n * @param {Number | Ref<Number> | Ref<String>} max\n * @return {NormalizedValidator}\n */\nexport default max => ({\n  $validator: maxValue(max),\n  $message: ({ $params }) => `The maximum value allowed is ${$params.max}`,\n  $params: { max, type: 'maxValue' }\n})\n","import minLength from '../raw/minLength'\n\n/**\n * Check if value is above a threshold.\n * @param {Number | Ref<Number>} min\n * @returns {NormalizedValidator}\n */\nexport default function (min) {\n  return {\n    $validator: minLength(min),\n    $message: ({ $params }) => `This field should be at least ${$params.min} characters long`,\n    $params: { min, type: 'minLength' }\n  }\n}\n","import { req, len } from './core'\nimport { unwrap } from '../utils/common'\n\n/**\n * Check if value is above a threshold.\n * @param {Number | Ref<Number>} length\n * @returns {function(Array|Object|String): boolean}\n */\nexport default function (length) {\n  return value => !req(value) || len(value) >= unwrap(length)\n}\n","import minValue from '../raw/minValue'\n\n/**\n * Check if a value is above a threshold.\n * @param {String | Number | Ref<Number> | Ref<String>} min\n * @returns {NormalizedValidator}\n */\nexport default function (min) {\n  return {\n    $validator: minValue(min),\n    $message: ({ $params }) => `The minimum value allowed is ${$params.min}`,\n    $params: { min, type: 'minValue' }\n  }\n}\n","import not from '../raw/not'\n\n/**\n * Swaps the result of a value\n * @param {NormalizedValidator|Function} validator\n * @returns {NormalizedValidator}\n */\nexport default function (validator) {\n  return {\n    $validator: not(validator),\n    $message: `The value does not match the provided validator`,\n    $params: {\n      type: 'not'\n    }\n  }\n}\n","import or from '../raw/or'\nimport { withMessage, withParams } from '../common'\n\n/**\n * Returns true when one of the provided functions returns true.\n * @param {...(NormalizedValidator|Function)} validators\n * @return {NormalizedValidator}\n */\nexport default function (...validators) {\n  return withParams({ type: 'or' },\n    withMessage('The value does not match any of the provided validators',\n      or(...validators))\n  )\n}\n","import requiredIf from '../raw/requiredIf'\n\n/**\n * Returns required if the passed property is truthy\n * @param {Boolean | String | function(): (Boolean | Promise<boolean>)} prop\n * @return {NormalizedValidator}\n */\nexport default function (prop) {\n  return {\n    $validator: requiredIf(prop),\n    $message: 'The value is required',\n    $params: { type: 'requiredIf', prop }\n  }\n}\n","import requiredUnless from '../raw/requiredUnless'\n\n/**\n * Returns required unless the passed property is truthy\n * @param {Boolean | String | function(): (Boolean | Promise<boolean>)} prop\n * @return {NormalizedValidator}\n */\nexport default function (prop) {\n  return {\n    $validator: requiredUnless(prop),\n    $message: 'The value is required',\n    $params: { type: 'requiredUnless', prop }\n  }\n}\n","import sameAs from '../raw/sameAs'\n\n/**\n * Check if two values are identical\n * @param {*} equalTo\n * @param {String} [otherName]\n * @return {NormalizedValidator}\n */\nexport default function (equalTo, otherName = 'other') {\n  return {\n    $validator: sameAs(equalTo),\n    $message: ({ $params }) => `The value must be equal to the ${otherName} value`,\n    $params: { equalTo, otherName, type: 'sameAs' }\n  }\n}\n"],"names":["isFunction","val","isObject","o","Array","isArray","normalizeValidatorObject","validator","$validator","unwrapValidatorResponse","result","$valid","unwrapNormalizedValidator","withParams","$params","Error","validatorObj","withMessage","$message","unwrap","req","value","length","Date","isNaN","getTime","_","String","len","Object","keys","regex","expr","every","reg","test","$watchTargets","$async","validators","collection","others","reduce","previous","collectionItem","collectionEntryResult","entries","all","property","$model","innerValidators","propertyResult","validatorName","currentValidator","$response","call","this","$data","$invalid","$error","$pending","$errors","push","$property","concat","_ref3","map","context","values","errors","error","a","b","type","min","max","nibbleValid","nibble","match","numeric","nibbles","split","separator","parts","hexValid","hex","toLowerCase","trim","validate","prop","equalTo","then","direct","Promise","resolve","syncOr","args","valid","fn","apply","asyncOr","r","or","some","v","syncAnd","asyncAnd","and","vm","response","object","between","_ref","t","messagePath","_ref2","messageParams","params","withArguments","localMessagePath","localMessageParams","message","props","model","pending","invalid","propertyPath","$propertyPath","macAddress","maxValue","minValue","not","propOrFunction","parentVM","otherName","sameAs"],"mappings":"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"}