{"version":3,"sources":["webpack://aspnetValidation/webpack/universalModuleDefinition","webpack://aspnetValidation/webpack/bootstrap","webpack://aspnetValidation/./src/base.ts","webpack://aspnetValidation/./src/providers/checked.ts","webpack://aspnetValidation/./src/utility/functions.ts","webpack://aspnetValidation/./src/utility/composite-date.ts","webpack://aspnetValidation/./src/providers/composite-date.ts","webpack://aspnetValidation/./src/providers/composite-time.ts","webpack://aspnetValidation/./src/providers/conditional-regex.ts","webpack://aspnetValidation/./src/providers/email-cleanse.ts","webpack://aspnetValidation/./src/providers/index.ts","webpack://aspnetValidation/./src/providers/max-line-length.ts","webpack://aspnetValidation/./src/providers/max-lines.ts","webpack://aspnetValidation/./src/providers/regex-lines.ts","webpack://aspnetValidation/./src/index.ts"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","nullLogger","warn","globalThis","console","log","_","isValidatable","element","HTMLInputElement","HTMLSelectElement","HTMLTextAreaElement","validatableElementTypes","validatableSelector","selector","map","join","guid4","replace","Math","random","toString","getRelativeFormElement","elementName","selectedName","substring","dotLocation","lastIndexOf","relativeElementName","relativeElement","document","getElementsByName","form","querySelector","params","checkedValue","elementType","type","toLowerCase","allCheckedElementsOfThisName","Array","from","querySelectorAll","filter","input","checked","length","some","elementUIDs","elementByUID","getElementUID","node","x","e","uid","push","stateByUID","groupByUid","getCompositeDateValidationProvider","totalParts","missingMessageDatasetKey","parser","elementUid","uids","elements","el","getAllUids","activeElement","indexOf","every","values","v","required","dataset","parsedValues","parseInt","isNaN","date","valueOf","monthIndex","year","Date","y","getFullYear","getDate","getMonth","NaN","compositeTime","hours","minutes","getMinutes","getHours","isMatch","pattern","RegExp","test","service","promisesByValue","promisesByUid","getDefaultResult","timeout","Promise","resolve","setTimeout","sendCleanseRequestAsync","email","level","record","promise","reject","data8","emailvalidation","cleanse","option","response","Status","Success","result","valid","Result","SuggestedEmailAddress","suggestion","err","catch","other","otherElement","otherValue","endsWith","lowerValue","originalPromise","race","getCleanseResultAsync","Number","CustomEvent","detail","dispatchEvent","trim","max","split","regex","line","addInputValidationEventListener","handler","validateEvent","valEvent","addEventListener","eventType","checkboxHiddenInput","Boolean","stringLength","min","compare","range","val","parseFloat","creditcard","cDigit","nCheck","nDigit","bEven","charAt","url","lowerCaseValue","phone","remote","fieldSelectors","additionalfields","fields","fieldSelector","fieldName","substr","fieldElement","encodedParams","encodedParam","encodeURIComponent","payload","ok","request","XMLHttpRequest","postData","FormData","append","open","setRequestHeader","send","onload","status","data","JSON","parse","responseText","statusText","onerror","logger","providers","messageFor","formInputs","validators","formEvents","inputEvents","relatedInputEvents","summary","dependencies","debounce","allowHiddenFields","validateForm","callback","formUID","formValidationEvent","undefined","validateField","field","fieldUID","fieldValidationEvent","preValidate","submitEvent","preventDefault","stopImmediatePropagation","handleValidated","success","submitValidForm","focusFirstInvalid","newEvent","SubmitEvent","submitter","getAttribute","submitterInput","createElement","appendChild","submit","invalidFormInputUIDs","firstInvalid","focus","isValid","prevalidate","isFieldValid","options","body","watch","addNoValidate","ValidationInputCssClassName","ValidationInputValidCssClassName","ValidationMessageCssClassName","ValidationMessageValidCssClassName","ValidationSummaryCssClassName","ValidationSummaryValidCssClassName","this","addProvider","addMvcProviders","mvc","addCustomProviders","scanMessages","remove","span","getElementById","removeValidationMessageSpan","pushValidationMessageSpan","forms","HTMLFormElement","containingForm","Element","closest","formId","spans","index","splice","getDependencies","arr","parseDirectives","attributes","directives","validationAtributes","cut","a","parameters","keys","Q","directive","error","pcut","pvalue","pkey","getFormValidationTask","formInputUIDs","formValidators","inputUID","validator","tasks","all","then","getMessageFor","shouldValidate","trackFormInput","setAttribute","validating","cb","validate","validationEvent","finally","classList","contains","innerHTML","renderSummary","untrackFormInput","indexToRemove","addInput","createValidator","debounceTimeoutID","clearTimeout","addInputDependency","relatedUid","otherUids","otherUid","otherEl","otherType","removeError","removeInput","scanInputs","inputs","createSummaryDOM","renderedMessages","ul","matchingElement","className","li","summaryElements","shadow","stringify","sort","renderedSummaryJSON","listElements","j","hasChildNodes","swapClasses","cloneNode","addError","message","isHidden","provider","resolution","offsetWidth","offsetHeight","getClientRects","addClass","removeClass","add","bootstrap","assign","init","scan","readyState","observer","MutationObserver","mutations","forEach","mutation","observed","observe","childList","subtree","addedNodes","HTMLElement","removedNodes","target","oldValue","newValue","attributeName"],"mappings":"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","file":"aspnet-validation.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"aspnetValidation\"] = factory();\n\telse\n\t\troot[\"aspnetValidation\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n","/**\n * A simple IDictionary<string, string>\n */\nexport interface StringKeyValuePair {\n    [key: string]: string\n}\n\n/**\n * A duplex key-value pair for an element, by GUID or its DOM object reference.\n */\nexport interface ElementUID {\n    node: Element,\n    uid: string;\n}\n\n/**\n * A simple logging interface that mirrors the Console object.\n */\nexport interface Logger {\n    log(message: string, ...args: any[]): void;\n    warn(message: string, ...args: any[]): void;\n}\n\nexport const nullLogger = new (class implements Logger {\n    log(_: string, ..._args: any[]): void { }\n    warn = globalThis.console.warn;\n})();\n\n/**\n * An `HTMLElement` that can be validated (`input`, `select`, `textarea`).\n */\nexport type ValidatableElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;\n\n/**\n * Checks if `element` is validatable (`input`, `select`, `textarea`).\n * @param element The element to check.\n * @returns `true` if validatable, otherwise `false`.\n */\nexport const isValidatable = (element: Node): element is ValidatableElement =>\n    element instanceof HTMLInputElement\n    || element instanceof HTMLSelectElement\n    || element instanceof HTMLTextAreaElement;\n\nconst validatableElementTypes = ['input', 'select', 'textarea'];\n\n/**\n * Generates a selector to match validatable elements (`input`, `select`, `textarea`).\n * @param selector An optional selector to apply to the valid input types, e.g. `[data-val=\"true\"]`.\n * @returns The validatable elements.\n */\nexport const validatableSelector = (selector?: string) =>\n    validatableElementTypes.map(t => `${t}${selector || ''}`).join(',');\n\n/**\n * Parameters passed into validation providers from the element attributes.\n * error property is read from data-val-[Provider Name] attribute.\n * params property is populated from data-val-[Provider Name]-[Parameter Name] attributes.\n */\nexport interface ValidationDirectiveBindings {\n    error: string,\n    params: StringKeyValuePair\n}\n\n/**\n * A key-value pair describing what validations to enforce to an input element, with respective parameters.\n */\nexport type ValidationDirective = {\n    [key: string]: ValidationDirectiveBindings\n};\n\n/**\n * Validation plugin signature with multitype return.\n * Boolean return signifies the validation result, which uses the default validation error message read from the element attribute.\n * String return signifies failed validation, which then will be used as the validation error message.\n * Promise return signifies asynchronous plugin behavior, with same behavior as Boolean or String.\n */\nexport type ValidationProvider = (value: string, element: ValidatableElement, params: StringKeyValuePair) => boolean | string | Promise<boolean | string>;\n\n/**\n * Callback to receive the result of validating a form.\n */\nexport type ValidatedCallback = (success: boolean) => void;\n\n/**\n * Callback to receive the validation trigger event.\n */\nexport type ValidationEventHandler = (e?: Event, callback?: ValidatedCallback) => void;\n\n/**\n * A callback method signature that kickstarts a new validation task for an input element, as a Boolean Promise.\n */\nexport type Validator = () => Promise<boolean>;\n\n/**\n *  Returns an RFC4122 version 4 compliant GUID.\n */\nexport function guid4() {\n    // (c) broofa, MIT Licensed\n    // https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript/2117523#2117523\n\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);\n        return v.toString(16);\n    });\n}\n\n/**\n * Resolves and returns the element referred by original element using ASP.NET selector logic.\n * @param element - The input to validate\n * @param selector - Used to find the field. Ex. *.Password where * replaces whatever prefixes asp.net might add.\n */\nexport function getRelativeFormElement(element: ValidatableElement, selector: string): ValidatableElement {\n    // example elementName: Form.PasswordConfirm, Form.Email\n    // example selector (dafuq): *.Password, *.__RequestVerificationToken\n    // example result element name: Form.Password, __RequestVerificationToken\n\n    let elementName = element.name;\n    let selectedName = selector.substring(2); // Password, __RequestVerificationToken\n    let objectName = '';\n\n    let dotLocation = elementName.lastIndexOf('.');\n    if (dotLocation > -1) {\n        // Form\n        objectName = elementName.substring(0, dotLocation);\n\n        // Form.Password\n        let relativeElementName = objectName + '.' + selectedName;\n        let relativeElement = document.getElementsByName(relativeElementName)[0];\n        if (isValidatable(relativeElement)) {\n            return relativeElement;\n        }\n    }\n\n    // __RequestVerificationToken\n    return element.form.querySelector(validatableSelector(`[name=\"${selectedName}\"]`));\n}\n","import { validatableSelector, ValidationProvider } from \"../base\";\r\n\r\nconst checked: ValidationProvider = (value, element, params) => {\r\n    const checkedValue = params[\"value\"];\r\n    if (!checkedValue) {\r\n        return true;\r\n    }\r\n    const elementType = element.type.toLowerCase();\r\n    if (!(element instanceof HTMLInputElement)) {\r\n        return true;\r\n    }\r\n    if (elementType !== \"checkbox\" && elementType !== \"radio\") {\r\n        return true;\r\n    }\r\n    const allCheckedElementsOfThisName = Array.from(element.form.querySelectorAll(validatableSelector(`[name='${element.name}'][type='${elementType}']`)))\r\n        .filter(input => input instanceof HTMLInputElement && input.checked === true);\r\n    if (allCheckedElementsOfThisName.length === 0) {\r\n        return true;\r\n    }\r\n    const isChecked = allCheckedElementsOfThisName.some(input => input instanceof HTMLInputElement && input.value === checkedValue);\r\n    if (isChecked) {\r\n        return true;\r\n    }\r\n    return false;\r\n};\r\n\r\nexport default checked;\r\n","import { ValidatableElement, ElementUID, guid4 } from \"../base\";\n\nexport const elementUIDs: ElementUID[] = [];\nexport const elementByUID: { [uid: string]: ValidatableElement } = {};\n\nexport function getElementUID(node: ValidatableElement) {\n    let x = elementUIDs.filter(e => {\n        return e.node === node;\n    })[0];\n    if (x) {\n        return x.uid;\n    }\n    const uid = guid4();\n    elementUIDs.push({\n        node: node,\n        uid: uid\n    });\n    elementByUID[uid] = node;\n    return uid;\n}\n","import { ValidationProvider, ValidatableElement, validatableSelector, isValidatable } from \"../base\";\nimport { elementByUID, getElementUID } from \"./functions\";\n\n\nconst stateByUID: { [uid: string]: true } = {};\nconst groupByUid: { [uid: string]: string[] } = {};\n\ntype DateParser = (values: number[]) => Date;\n\nfunction getAllUids(element: ValidatableElement) {\n\n    const elementUid = getElementUID(element);\n\n    if (!groupByUid[elementUid]) {\n\n        const elements = element.form.querySelectorAll(validatableSelector(`[name=\"${element.name}\"]`));\n        const uids = Array.from(elements).map(el => isValidatable(el) ? getElementUID(el) : void 0).filter(uid => !!uid);\n\n        for (const uid of uids) {\n            if (!groupByUid[uid]) {\n                groupByUid[uid] = uids;\n            }\n        }\n    }\n\n    return groupByUid[elementUid];\n}\n\nexport function getCompositeDateValidationProvider(totalParts: number, missingMessageDatasetKey: string, parser: DateParser): ValidationProvider {\n    return (value, element, params) => {\n        const elementUid = getElementUID(element);\n\n        const uids: string[] = getAllUids(element);\n        if (uids.length !== totalParts) {\n            return true;\n        }\n\n        stateByUID[elementUid] = true;\n\n        const elements = uids.map(uid => elementByUID[uid]);\n        const isSubmit = isValidatable(document.activeElement) && elements.indexOf(document.activeElement) === -1;\n\n        if (!isSubmit) {\n            const areAllTouched = uids.every(uid => stateByUID[uid]);\n            if (!areAllTouched) {\n                // Not all touched\n                return true;\n            }\n        }\n\n        const values: string[] = uids.map(uid => uid === elementUid ? value : elementByUID[uid].value);\n        const areAllEmpty = values.every(v => !v);\n\n        if (areAllEmpty) {\n            const isRequired = \"required\" in params;\n            if (isRequired) {\n                return params.required || false;\n            }\n            else {\n                return true;\n            }\n        }\n\n        for (let i = 0; i < values.length; i++) {\n            if (!values[i]) {\n                // Missing value\n                return elementByUID[uids[i]].dataset[missingMessageDatasetKey] || false;\n            }\n        }\n\n        const parsedValues: number[] = values.map(v => parseInt(v));\n        if (parsedValues.some(v => isNaN(v))) {\n            // Invalid date\n            return false;\n        }\n\n        const date: Date = parser(parsedValues);\n\n        if (isNaN(date.valueOf())) {\n            // Invalid date\n            return false;\n        }\n\n        return true;\n    }\n}\n","import { getCompositeDateValidationProvider } from \"../utility/composite-date\";\n\nconst compositeDate = getCompositeDateValidationProvider(3, \"valCompositedateMissing\", values => {\n\n    const date = values[0];\n    const monthIndex = values[1] - 1;\n    const year = values[2];\n\n    const d = new Date(year, monthIndex, date);\n\n    if (isNaN(d.valueOf())) {\n        return d;\n    }\n\n    const y = d.getFullYear();\n\n    if (d.getDate() === date &&\n        d.getMonth() === monthIndex &&\n        y === year &&\n        1900 <= y &&\n        y < 2100) {\n        return d;\n    }\n\n    // Invalid date\n    return new Date(NaN);\n});\n\nexport default compositeDate;\n","import { getCompositeDateValidationProvider } from \"../utility/composite-date\";\n\nconst compositeTime = getCompositeDateValidationProvider(2, \"valCompositetimeMissing\", values => {\n\n    const hours = values[0];\n    const minutes = values[1];\n\n    const date = 1;\n    const monthIndex = 0;\n    const year = 2000;\n\n    const d = new Date(year, monthIndex, date, hours, minutes);\n\n    if (isNaN(d.valueOf())) {\n        return d;\n    }\n\n    if (d.getMinutes() === minutes &&\n        d.getHours() === hours &&\n        d.getDate() === date &&\n        d.getMonth() === monthIndex &&\n        d.getFullYear() === year) {\n        return d;\n    }\n\n    // Invalid date\n    return new Date(NaN);\n});\n\nexport default compositeTime;\n","import { ValidationProvider, getRelativeFormElement } from \"../base\";\n\nfunction isMatch(value: string, pattern?: string) {\n  if (pattern) {\n    const regex = new RegExp(pattern);\n    return regex.test(value);\n  }\n  return true;\n}\n\nfunction getResult(message?: string) {\n  if (message) {\n    return message;\n  }\n  else {\n    return false;\n  }\n}\n\nconst conditionalRegex: ValidationProvider = (value, element, params) => {\n  if (!value) {\n    return true;\n  }\n\n  if (!params.other) {\n    return true;\n  }\n\n  const otherElement = getRelativeFormElement(element, params.other);\n  if (!otherElement) {\n    return true;\n  }\n\n  const otherValue = otherElement.value;\n  if (otherValue) {\n    for (let key in params) {\n      if (key.endsWith(\"-value\") && params[key] === otherValue) {\n        if (isMatch(value, params[key.replace(/-value$/, \"-pattern\")])) {\n          return true;\n        }\n        return getResult(params[key.replace(/-value$/, \"-msg\")]);\n      }\n    }\n  }\n\n  return true;\n}\n\nexport default conditionalRegex;\n","import { ElementUID, guid4, ValidationProvider } from \"../base\";\n\n// https://www.data-8.co.uk/resources/api-reference/emailvalidation/cleanse/\n\ninterface Result {\n  valid: boolean;\n  suggestion?: string;\n}\n\nconst elementUIDs: ElementUID[] = [];\nconst elementByUID: { [uid: string]: Element } = {};\nfunction getElementUID(node: Element) {\n  let x = elementUIDs.filter(e => {\n    return e.node === node;\n  })[0];\n\n  if (x) {\n    return x.uid;\n  }\n\n  let uid = guid4();\n  elementUIDs.push({\n    node: node,\n    uid: uid\n  });\n  elementByUID[uid] = node;\n  return uid;\n}\n\nlet service;\nfunction getService() {\n  return service ?? (service = new data8.emailvalidation());\n}\n\nconst promisesByValue: Record<string, Promise<Result>> = {};\nconst promisesByUid: Record<string, Promise<Result>> = {};\n\nfunction getDefaultResult(timeout: number): Promise<Result> {\n  return new Promise(resolve => {\n    setTimeout(() => {\n      resolve(void 0);\n    }, timeout);\n  });\n}\n\nfunction sendCleanseRequestAsync(email, level?, record?): Promise<Result> {\n  const promise = promisesByValue[email] ?? (promisesByValue[email] = new Promise((resolve, reject) => {\n    try {\n      const service = getService();\n      service.cleanse(\n        email,\n        level,\n        record,\n        [\n          new data8.option('MissingMXRecordHandling', 'ServerCheck')\n        ],\n        response => {\n          if (response.Status.Success) {\n            const result: Result = {\n              valid: response.Result !== \"Invalid\",\n            };\n            if (response.SuggestedEmailAddress) {\n              result.suggestion = response.SuggestedEmailAddress;\n            }\n            resolve(result);\n          }\n          else {\n            reject(response);\n          }\n        },\n      );\n    }\n    catch (err) {\n      reject(err);\n    }\n  }));\n  promise.catch(() => {\n    if (promisesByValue[email] === promise) {\n      delete promisesByValue[email];\n    }\n  });\n  return promise;\n}\n\nasync function getCleanseResultAsync(value: string, timeout?: number): Promise<Result> {\n  try {\n    return await Promise.race([\n      sendCleanseRequestAsync(value, \"Address\"),\n      ...(typeof timeout === \"number\" ? [getDefaultResult(timeout)] : [])\n    ]);\n  }\n  catch {\n    return void 0;\n  }\n}\n\nconst validate: ValidationProvider = async (value, element, params) => {\n  if (!value) {\n    if (params[\"required\"]) {\n      // Required\n      return params[\"required\"];\n    }\n    return true;\n  }\n  if (params[\"regex\"]) {\n    const pattern = params[\"regex-pattern\"];\n    if (!(new RegExp(pattern).test(value))) {\n      // Invalid\n      return params[\"regex\"];\n    }\n  }\n  if (params[\"maxlength\"]) {\n    const max = parseInt(params[\"maxlength-max\"]);\n    if (max < value.length) {\n      // Too long\n      return params[\"maxlength\"];\n    }\n  }\n  const uid = getElementUID(element);\n  const lowerValue = value.toLowerCase();\n  let promise: Promise<Result>;\n  let result: Result;\n  const originalPromise = promisesByUid[uid] = getCleanseResultAsync(lowerValue, params.timeout ? Number(params.timeout) : void 0);\n  while (promise !== promisesByUid[uid]) {\n    promise = promisesByUid[uid];\n    result = await promise;\n  }\n  if (result) {\n    if (promise === originalPromise) {\n      const event = new CustomEvent(\"validation.emailcleanse\", { detail: { ...result, value } });\n      element.dispatchEvent(event);\n    }\n    return result.valid;\n  }\n  return true;\n};\n\nexport default validate;\n","import { ValidationProvider } from \"../base\";\r\n\r\nimport checked from \"./checked\";\r\nimport compositeDate from \"./composite-date\";\r\nimport compositeTime from \"./composite-time\";\r\nimport conditionalRegex from \"./conditional-regex\";\r\nimport emailcleanse from \"./email-cleanse\";\r\nimport maxLineLength from \"./max-line-length\";\r\nimport maxLines from \"./max-lines\";\r\nimport regexLines from \"./regex-lines\";\r\n\r\nconst map: Record<string, ValidationProvider> = {\r\n    \"checked\": checked,\r\n    \"compositedate\": compositeDate,\r\n    \"compositetime\": compositeTime,\r\n    \"conditionalregex\": conditionalRegex,\r\n    \"emailcleanse\": emailcleanse,\r\n    \"maxlinelength\": maxLineLength,\r\n    \"maxlines\": maxLines,\r\n    \"regexlines\": regexLines,\r\n}\r\n\r\nexport default map;\r\n","import { ValidationProvider } from \"../base\";\n\nconst maxLineLength: ValidationProvider = (value, element, params) => {\n    if (!value?.trim()) {\n        return true;\n    }\n\n    const max = parseInt(params[\"max\"]);\n    if (!max || isNaN(max)) {\n        return true;\n    }\n\n    const lines = value.replace(\"\\r\", \"\").split(\"\\n\").filter(v => !!v.trim());\n\n    for (const line of lines) {\n        if (max < line.trim().length) {\n            return false;\n        }\n    }\n\n    return true;\n};\n\nexport default maxLineLength;\n","import { ValidationProvider } from \"../base\";\n\nconst maxLines: ValidationProvider = (value, element, params) => {\n    if (!value?.trim()) {\n        return true;\n    }\n\n    const max = parseInt(params[\"max\"]);\n    if (!max || isNaN(max)) {\n        return true;\n    }\n\n    const lineCount = value.replace(\"\\r\", \"\").split(\"\\n\").filter(v => !!v.trim()).length;\n    if (max < lineCount) {\n        return false;\n    }\n\n    return true;\n};\n\nexport default maxLines;\n","import { ValidationProvider } from \"../base\";\n\nconst regexLines: ValidationProvider = (value, element, params) => {\n    if (!value || !params.pattern) {\n        return true;\n    }\n\n    const regex = new RegExp(params.pattern);\n    const lines = value.replace(\"\\r\", \"\").split(\"\\n\").filter(v => !!v.trim());\n\n    for (const line of lines) {\n        const v = line?.trim();\n        if (v && !regex.test(v)) {\n            return false;\n        }\n    }\n\n    return true;\n};\n\nexport default regexLines;\n","import {\n    ElementUID,\n    Logger,\n    StringKeyValuePair,\n    ValidatableElement,\n    validatableSelector,\n    ValidatedCallback,\n    ValidationDirective,\n    ValidationDirectiveBindings,\n    ValidationEventHandler,\n    ValidationProvider,\n    Validator,\n    getRelativeFormElement,\n    isValidatable,\n    nullLogger,\n    guid4,\n} from \"./base\";\n\nimport customProviders from \"./providers\";\n\n/**\n * Attaches the handler to the input on the configured validation event.\n * @param input\n * @param handler\n */\nfunction addInputValidationEventListener(input: ValidatableElement, handler: ValidationEventHandler) {\n    const validateEvent = input.dataset.valEvent;\n    if (validateEvent) {\n        input.addEventListener(validateEvent, handler);\n    }\n    else {\n        let eventType = input instanceof HTMLSelectElement ? 'change' : 'input';\n        input.addEventListener(eventType, handler);\n    }\n}\n\n/**\n * Contains default implementations for ASP.NET Core MVC validation attributes.\n */\nexport class MvcValidationProviders {\n    /**\n     * Validates whether the input has a value.\n     */\n    required: ValidationProvider = (value, element, params) => {\n        // Handle single and multiple checkboxes/radio buttons.\n        const elementType = element.type.toLowerCase();\n        if (elementType === \"checkbox\" || elementType === \"radio\") {\n            const allElementsOfThisName = Array.from(element.form.querySelectorAll(validatableSelector(`[name='${element.name}'][type='${elementType}']`)));\n            for (let element of allElementsOfThisName) {\n                if (element instanceof HTMLInputElement && element.checked === true) {\n                    return true;\n                }\n            }\n\n            // Checkboxes do not submit a value when unchecked. To work around this, platforms such as ASP.NET render a\n            // hidden input with the same name as the checkbox so that a value (\"false\") is still submitted even when\n            // the checkbox is not checked. We check this special case here.\n            if (elementType === \"checkbox\") {\n                const checkboxHiddenInput = element.form.querySelector(`input[name='${element.name}'][type='hidden']`);\n                if (checkboxHiddenInput instanceof HTMLInputElement && checkboxHiddenInput.value === \"false\") {\n                    return true;\n                }\n            }\n\n            return false;\n        }\n        // Default behavior otherwise.\n        return Boolean(value);\n    }\n\n    /**\n     * Validates whether the input value satisfies the length contstraint.\n     */\n    stringLength: ValidationProvider = (value, element, params) => {\n        if (!value) {\n            return true;\n        }\n\n        if (params.min) {\n            let min = parseInt(params.min);\n            if (value.length < min) {\n                return false;\n            }\n        }\n\n        if (params.max) {\n            let max = parseInt(params.max);\n            if (value.length > max) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    /**\n     * Validates whether the input value is equal to another input value.\n     */\n    compare: ValidationProvider = (value, element, params) => {\n        if (!params.other) {\n            return true;\n        }\n\n        let otherElement = getRelativeFormElement(element, params.other);\n        if (!otherElement) {\n            return true;\n        }\n\n        return (otherElement.value === value);\n    }\n\n    /**\n     * Validates whether the input value is a number within a given range.\n     */\n    range: ValidationProvider = (value, element, params) => {\n        if (!value) {\n            return true;\n        }\n\n        let val = parseFloat(value);\n        if (isNaN(val)) {\n            return false;\n        }\n\n        if (params.min) {\n            let min = parseFloat(params.min);\n            if (val < min) {\n                return false;\n            }\n        }\n\n        if (params.max) {\n            let max = parseFloat(params.max);\n            if (val > max) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    /**\n     * Validates whether the input value satisfies a regular expression pattern.\n     */\n    regex: ValidationProvider = (value, element, params) => {\n        if (!value || !params.pattern) {\n            return true;\n        }\n\n        let r = new RegExp(params.pattern);\n        return r.test(value);\n    }\n\n    /**\n     * Validates whether the input value is an email in accordance to RFC822 specification, with a top level domain.\n     */\n    email: ValidationProvider = (value, element, params) => {\n        if (!value) {\n            return true;\n        }\n\n        // RFC822 email address with .TLD validation\n        // (c) Richard Willis, Chris Ferdinandi, MIT Licensed\n        // https://gist.github.com/badsyntax/719800\n        // https://gist.github.com/cferdinandi/d04aad4ce064b8da3edf21e26f8944c4\n\n        let r = /^([^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x22([^\\x0d\\x22\\x5c\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x22)(\\x2e([^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x22([^\\x0d\\x22\\x5c\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x22))*\\x40([^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x5b([^\\x0d\\x5b-\\x5d\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x5d)(\\x2e([^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x5b([^\\x0d\\x5b-\\x5d\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x5d))*(\\.\\w{2,})+$/;\n        return r.test(value);\n    }\n\n    /**\n     * Validates whether the input value is a credit card number, with Luhn's Algorithm.\n     */\n    creditcard: ValidationProvider = (value, element, params) => {\n        if (!value) {\n            return true;\n        }\n\n        // (c) jquery-validation, MIT Licensed\n        // https://github.com/jquery-validation/jquery-validation/blob/master/src/additional/creditcard.js\n        // based on https://en.wikipedia.org/wiki/Luhn_algorithm\n\n        // Accept only spaces, digits and dashes\n        if (/[^0-9 \\-]+/.test(value)) {\n            return false;\n        }\n\n        var nCheck = 0,\n            nDigit = 0,\n            bEven = false,\n            n, cDigit;\n\n        value = value.replace(/\\D/g, \"\");\n\n        // Basing min and max length on https://developer.ean.com/general_info/Valid_Credit_Card_Types\n        if (value.length < 13 || value.length > 19) {\n            return false;\n        }\n\n        for (n = value.length - 1; n >= 0; n--) {\n            cDigit = value.charAt(n);\n            nDigit = parseInt(cDigit, 10);\n            if (bEven) {\n                if ((nDigit *= 2) > 9) {\n                    nDigit -= 9;\n                }\n            }\n\n            nCheck += nDigit;\n            bEven = !bEven;\n        }\n\n        return (nCheck % 10) === 0;\n    }\n\n    /**\n     * Validates whether the input value is a URL.\n     */\n    url: ValidationProvider = (value, element, params) => {\n        if (!value) {\n            return true;\n        }\n\n        let lowerCaseValue = value.toLowerCase();\n\n        // Match the logic in `UrlAttribute`\n        return lowerCaseValue.indexOf('http://') > -1\n            || lowerCaseValue.indexOf('https://') > -1\n            || lowerCaseValue.indexOf('ftp://') > -1;\n    }\n\n    /**\n     * Validates whether the input value is a phone number.\n     */\n    phone: ValidationProvider = (value, element, params) => {\n        if (!value) {\n            return true;\n        }\n\n        // Allows whitespace or dash as number separator because some people like to do that...\n        let consecutiveSeparator = /[\\+\\-\\s][\\-\\s]/g;\n        if (consecutiveSeparator.test(value)) {\n            return false;\n        }\n\n        let r = /^\\+?[0-9\\-\\s]+$/;\n        return r.test(value);\n    }\n\n    /**\n     * Asynchronously validates the input value to a JSON GET API endpoint.\n     */\n    remote: ValidationProvider = (value, element, params) => {\n        if (!value) {\n            return true;\n        }\n\n        // params.additionalfields: *.Email,*.Username\n        let fieldSelectors: string[] = (params.additionalfields as string).split(',');\n        let fields: StringKeyValuePair = {};\n\n        for (let fieldSelector of fieldSelectors) {\n            let fieldName = fieldSelector.substr(2);\n            let fieldElement = getRelativeFormElement(element, fieldSelector);\n\n            let hasValue = Boolean(fieldElement && fieldElement.value);\n            if (!hasValue) {\n                continue;\n            }\n\n            fields[fieldName] = fieldElement.value;\n        }\n\n        let url: string = params['url'];\n\n        let encodedParams: string[] = [];\n        for (let fieldName in fields) {\n            let encodedParam = encodeURIComponent(fieldName) + '=' + encodeURIComponent(fields[fieldName]);\n            encodedParams.push(encodedParam);\n        }\n        let payload = encodedParams.join('&');\n\n        return new Promise((ok, reject) => {\n            let request = new XMLHttpRequest();\n\n            if (params.type === 'Post') {\n                let postData = new FormData();\n                for (let fieldName in fields) {\n                    postData.append(fieldName, fields[fieldName]);\n                }\n                request.open('post', url);\n                request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n                request.send(payload);\n            } else {\n                request.open('get', url + '?' + payload);\n                request.send();\n            }\n\n            request.onload = e => {\n                if (request.status >= 200 && request.status < 300) {\n                    let data = JSON.parse(request.responseText);\n                    ok(data);\n                } else {\n                    reject({\n                        status: request.status,\n                        statusText: request.statusText,\n                        data: request.responseText\n                    });\n                }\n            };\n\n            request.onerror = e => {\n                reject({\n                    status: request.status,\n                    statusText: request.statusText,\n                    data: request.responseText\n                });\n            };\n        });\n    }\n}\n\n/**\n * Configuration for @type {ValidationService}.\n */\nexport interface ValidationServiceOptions {\n    watch: boolean;\n    root: ParentNode;\n    addNoValidate: boolean;\n}\n\n/**\n * Responsible for managing the DOM elements and running the validation providers.\n */\nexport class ValidationService {\n    /**\n     * A key-value collection of loaded validation plugins.\n     */\n    private providers: { [name: string]: ValidationProvider } = {};\n\n    /**\n     * A key-value collection of <span> elements for displaying validation messages for an input (by DOM ID).\n     */\n    private messageFor: { [id: string]: Element[] } = {};\n\n    /**\n     * A list of managed elements, each having a randomly assigned unique identifier (UID).\n     */\n    private elementUIDs: ElementUID[] = [];\n\n    /**\n     * A key-value collection of UID to Element for quick lookup.\n     */\n    private elementByUID: { [uid: string]: Element } = {};\n\n    /**\n     * A key-value collection of input UIDs for a <form> UID.\n     */\n    private formInputs: { [formUID: string]: string[] } = {};\n\n    /**\n     * A key-value map for input UID to its validator factory.\n     */\n    private validators: { [inputUID: string]: Validator } = {};\n\n    /**\n     * A key-value map for form UID to its trigger element (submit event for <form>).\n     */\n    private formEvents: { [id: string]: (e?: SubmitEvent, callback?: ValidatedCallback) => void } = {};\n\n    /**\n     * A key-value map for element UID to its trigger element (input event for <textarea> and <input>, change event for <select>).\n     */\n    private inputEvents: { [id: string]: ValidationEventHandler } = {};\n\n    /**\n     * A key-value map for element UID to its trigger element (input event for <textarea> and <input>, change event for <select>).\n     */\n    private relatedInputEvents: { [id: string]: (e?: Event) => void } = {};\n\n    /**\n     * A key-value map of input UID to its validation error message.\n     */\n    private summary: StringKeyValuePair = {};\n\n    /**\n     * A serialized representation of the validation error message summary rendered to the user.\n     */\n    private renderedSummaryJSON: string;\n\n    /**\n     * A key-value map of input UID to its dependent input UIDs.\n     */\n    private dependencies: Record<string, string[]> = {};\n\n    /**\n     * In milliseconds, the rate of fire of the input validation.\n     */\n    debounce = 300;\n\n    /**\n     * Allow hidden fields validation\n     */\n    allowHiddenFields = false;\n\n    private logger: Logger;\n    observer?: MutationObserver;\n\n    constructor(logger?: Logger) {\n        this.logger = logger || nullLogger;\n    }\n\n    /**\n     * Registers a new validation plugin of the given name, if not registered yet.\n     * Registered plugin validates inputs with data-val-[name] attribute, used as error message.\n     * @param name\n     * @param callback\n     */\n    addProvider(name: string, callback: ValidationProvider) {\n        if (this.providers[name]) {\n            // First-Come-First-Serve validation plugin design.\n            // Allows developers to override the default MVC Providers by adding custom providers BEFORE bootstrap() is called!\n            return;\n        }\n        this.logger.log(\"Registered provider: %s\", name);\n        this.providers[name] = callback;\n    }\n\n    /**\n     * Registers the default providers for enabling ASP.NET Core MVC client-side validation.\n     */\n    private addMvcProviders() {\n        let mvc = new MvcValidationProviders();\n\n        // [Required]\n        this.addProvider('required', mvc.required);\n        // [StringLength], [MinLength], [MaxLength]\n        this.addProvider('length', mvc.stringLength);\n        this.addProvider('maxlength', mvc.stringLength);\n        this.addProvider('minlength', mvc.stringLength);\n        // [Compare]\n        this.addProvider('equalto', mvc.compare);\n        // [Range]\n        this.addProvider('range', mvc.range);\n        // [RegularExpression]\n        this.addProvider('regex', mvc.regex);\n        // [CreditCard]\n        this.addProvider('creditcard', mvc.creditcard);\n        // [EmailAddress]\n        this.addProvider('email', mvc.email);\n        // [Url]\n        this.addProvider('url', mvc.url);\n        // [Phone]\n        this.addProvider('phone', mvc.phone);\n        // [Remote]\n        this.addProvider('remote', mvc.remote);\n    }\n\n    /**\n     * Registers the custom providers for enabling ASP.NET Core MVC client-side validation.\n     */\n    private addCustomProviders() {\n        for (let key in customProviders) {\n            this.addProvider(key, customProviders[key]);\n        }\n    }\n\n    /**\n     * Scans document for all validation message <span> generated by ASP.NET Core MVC, then tracks them.\n     */\n    private scanMessages(root: ParentNode, remove: boolean = false) {\n        /* If a validation span explicitly declares a form, we group the span with that form. */\n        let validationMessageElements = Array.from(root.querySelectorAll<HTMLElement>('span[form]'));\n        for (let span of validationMessageElements) {\n            let form = document.getElementById(span.getAttribute('form'));\n            if (form) {\n                if (remove) {\n                    this.removeValidationMessageSpan(form, span);\n                } else {\n                    this.pushValidationMessageSpan(form, span);\n                }\n            }\n        }\n\n        // Otherwise if a validation message span is inside a form, we group the span with the form it's inside.\n        let forms = Array.from(root.querySelectorAll<HTMLFormElement>('form'));\n        if (root instanceof HTMLFormElement) {\n            // querySelectorAll does not include the root element itself.\n            // we could use 'matches', but that's newer than querySelectorAll so we'll keep it simple and compatible.\n            forms.push(root);\n        }\n        // If root is the descendant of a form, we want to include that form too.\n        const containingForm = (root instanceof Element) ? root.closest('form') : null;\n        if (containingForm) {\n            forms.push(containingForm);\n        }\n\n        for (let form of forms) {\n            let validationMessageElements = Array.from(form.querySelectorAll<HTMLElement>('[data-valmsg-for]'));\n\n            for (let span of validationMessageElements) {\n                if (remove) {\n                    this.removeValidationMessageSpan(form, span);\n                } else {\n                    this.pushValidationMessageSpan(form, span);\n                }\n            }\n        }\n    }\n\n    private pushValidationMessageSpan(form: HTMLElement, span: HTMLElement) {\n        let formId = this.getElementUID(form);\n        let name = `${formId}:${span.getAttribute('data-valmsg-for')}`;\n        let spans = this.messageFor[name] || (this.messageFor[name] = []);\n        if (spans.indexOf(span) < 0) {\n            spans.push(span);\n        }\n        else {\n            this.logger.log(\"Validation element for '%s' is already tracked\", name, span);\n        }\n    }\n\n    private removeValidationMessageSpan(form: HTMLElement, span: HTMLElement) {\n        let formId = this.getElementUID(form);\n        let name = `${formId}:${span.getAttribute('data-valmsg-for')}`;\n        let spans = this.messageFor[name];\n        if (!spans) {\n            return;\n        }\n        let index = spans.indexOf(span);\n        if (index >= 0) {\n            spans.splice(index, 1);\n        }\n        else {\n            this.logger.log(\"Validation element for '%s' was already removed\", name, span);\n        }\n    }\n\n    /**\n     * Given an HTML input, returns the element dependencies.\n     * @param element\n     */\n    getDependencies(element: ValidatableElement): ValidatableElement[] {\n        const arr: ValidatableElement[] = [];\n        const v = element.getAttribute('data-dep-val');\n        if (v) {\n            const selectors = v.split(',');\n            for (let s of selectors) {\n                const el = getRelativeFormElement(element, s);\n                if (el) {\n                    arr.push(el);\n                }\n            }\n        }\n        return arr;\n    }\n\n    /**\n     * Given attribute map for an HTML input, returns the validation directives to be executed.\n     * @param attributes\n     */\n    parseDirectives(attributes: NamedNodeMap) {\n        let directives: ValidationDirective = {};\n        let validationAtributes: StringKeyValuePair = {};\n\n        let cut = 'data-val-'.length;\n        for (let i = 0; i < attributes.length; i++) {\n            let a = attributes[i];\n            if (a.name.indexOf('data-val-') === 0) {\n                let key = a.name.substr(cut);\n                validationAtributes[key] = a.value;\n            }\n        }\n\n        for (let key in validationAtributes) {\n            if (key.indexOf('-') === -1) {\n                let parameters = Object.keys(validationAtributes).filter(Q => {\n                    return (Q !== key) && (Q.indexOf(key) === 0);\n                });\n\n                let directive: ValidationDirectiveBindings = {\n                    error: validationAtributes[key],\n                    params: {}\n                };\n\n                let pcut = (key + '-').length;\n                for (let i = 0; i < parameters.length; i++) {\n                    let pvalue = validationAtributes[parameters[i]];\n                    let pkey = parameters[i].substr(pcut);\n\n                    directive.params[pkey] = pvalue;\n                }\n\n                directives[key] = directive;\n            }\n        }\n\n        return directives;\n    }\n\n    /**\n     * Gets a UID for an DOM element.\n     * @param node\n     */\n    private getElementUID(node: Element) {\n        let x = this.elementUIDs.filter(e => {\n            return e.node === node;\n        })[0];\n\n        if (x) {\n            return x.uid;\n        }\n\n        let uid = guid4();\n        this.elementUIDs.push({\n            node: node,\n            uid: uid\n        });\n        this.elementByUID[uid] = node;\n        return uid;\n    }\n\n    /**\n     * Returns a Promise that returns validation result for each and every inputs within the form.\n     * @param formUID\n     */\n    private getFormValidationTask(formUID: string) {\n        let formInputUIDs = this.formInputs[formUID];\n        if (!formInputUIDs || formInputUIDs.length === 0) {\n            return Promise.resolve(true);\n        }\n\n        let formValidators: Validator[] = [];\n\n        for (let i = 0; i < formInputUIDs.length; i++) {\n            let inputUID = formInputUIDs[i];\n            const validator = this.validators[inputUID];\n            if (validator) {\n                formValidators.push(validator);\n            }\n        }\n\n        let tasks = formValidators.map(factory => factory());\n        return Promise.all(tasks).then(result => result.every(e => e));\n    }\n\n    // Retrieves the validation span for the input.\n    private getMessageFor(input: ValidatableElement) {\n        if (!input.form) {\n            return [];\n        }\n        let formId = this.getElementUID(input.form);\n        let name = `${formId}:${input.name}`;\n        return this.messageFor[name];\n    }\n\n    /**\n     * Fires off validation for elements within the provided form and then calls the callback\n     * @param form The form to validate.\n     * @param callback Receives true or false indicating validity after all validation is complete.\n     */\n    validateForm = (form: HTMLFormElement, callback?: ValidatedCallback) => {\n        let formUID = this.getElementUID(form);\n        let formValidationEvent = this.formEvents[formUID];\n        if (formValidationEvent) {\n            formValidationEvent(undefined, callback);\n        }\n    }\n\n    /**\n     * Fires off validation for the provided element and then calls the callback\n     * @param field The element to validate.\n     * @param callback Receives true or false indicating validity after all validation is complete.\n     */\n    validateField = (field: ValidatableElement, callback?: ValidatedCallback) => {\n        let fieldUID = this.getElementUID(field);\n        let fieldValidationEvent = this.inputEvents[fieldUID];\n        if (fieldValidationEvent) {\n            fieldValidationEvent(undefined, callback);\n        }\n    }\n\n    /**\n     * Called before validating form submit events.\n     * Default calls `preventDefault()` and `stopImmediatePropagation()`.\n     * @param submitEvent The `SubmitEvent`.\n     */\n    preValidate = (submitEvent: SubmitEvent) => {\n        submitEvent.preventDefault();\n        submitEvent.stopImmediatePropagation();\n    }\n\n    /**\n     * Handler for validated form submit events.\n     * Default calls `submitValidForm(form, submitEvent)` on success\n     * and `focusFirstInvalid(form)` on failure.\n     * @param form The form that has been validated.\n     * @param success The validation result.\n     * @param submitEvent The `SubmitEvent`.\n     */\n    handleValidated = (form: HTMLFormElement, success: boolean, submitEvent?: SubmitEvent) => {\n        if (success) {\n            if (submitEvent) {\n                this.submitValidForm(form, submitEvent);\n            }\n        }\n        else {\n            this.focusFirstInvalid(form);\n        }\n    }\n\n    /**\n     * Dispatches a new `SubmitEvent` on the provided form,\n     * then calls `form.submit()` unless `submitEvent` is cancelable\n     * and `preventDefault()` was called by a handler that received the new event.\n     *\n     * This is equivalent to `form.requestSubmit()`, but more flexible.\n     * @param form The validated form to submit\n     * @param submitEvent The `SubmitEvent`.\n     */\n    submitValidForm = (form: HTMLFormElement, submitEvent: SubmitEvent) => {\n        const newEvent = new SubmitEvent('submit', submitEvent);\n        if (form.dispatchEvent(newEvent)) {\n            // Because the submitter is not propagated when calling\n            // form.submit(), we recreate it here.\n            const submitter = submitEvent.submitter;\n            if (submitter) {\n                const name = submitter.getAttribute('name');\n                // If name is null, a submit button is not submitted.\n                if (name) {\n                    const submitterInput = document.createElement('input');\n                    submitterInput.type = 'hidden';\n                    submitterInput.name = name;\n                    submitterInput.value = submitter.getAttribute('value');\n                    form.appendChild(submitterInput)\n                }\n            }\n\n            form.submit();\n        }\n    }\n\n    /**\n     * Focuses the first invalid element within the provided form\n     * @param form\n     */\n    focusFirstInvalid = (form: HTMLFormElement) => {\n        let formUID = this.getElementUID(form);\n        let formInputUIDs = this.formInputs[formUID];\n        let invalidFormInputUIDs = formInputUIDs.filter(uid => this.summary[uid]);\n\n        if (invalidFormInputUIDs.length > 0) {\n            var firstInvalid = this.elementByUID[invalidFormInputUIDs[0]] as HTMLElement;\n            if (firstInvalid) {\n                firstInvalid.focus();\n            }\n        }\n    }\n\n    /**\n     * Returns true if the provided form is currently valid.\n     * The form will be validated unless prevalidate is set to false.\n     * @param form The form to validate.\n     * @param prevalidate Whether the form should be validated before returning.\n     * @param callback A callback that receives true or false indicating validity after all validation is complete. Ignored if prevalidate is false.\n     * @returns The current state of the form. May be inaccurate if any validation is asynchronous (e.g. remote); consider using `callback` instead.\n     */\n    isValid = (form: HTMLFormElement, prevalidate: boolean = true, callback?: ValidatedCallback) => {\n        if (prevalidate) {\n            this.validateForm(form, callback);\n        }\n        let formUID = this.getElementUID(form);\n        let formInputUIDs = this.formInputs[formUID];\n        let invalidFormInputUIDs = formInputUIDs.filter(uid => this.summary[uid]);\n        return invalidFormInputUIDs.length == 0;\n    }\n\n    /**\n     * Returns true if the provided field is currently valid.\n     * The field will be validated unless prevalidate is set to false.\n     * @param field The field to validate.\n     * @param prevalidate Whether the field should be validated before returning.\n     * @param callback A callback that receives true or false indicating validity after all validation is complete. Ignored if prevalidate is false.\n     * @returns The current state of the field. May be inaccurate if any validation is asynchronous (e.g. remote); consider using `callback` instead.\n     */\n    isFieldValid = (field: ValidatableElement, prevalidate: boolean = true, callback?: ValidatedCallback) => {\n        if (prevalidate) {\n            this.validateField(field, callback);\n        }\n\n        let fieldUID = this.getElementUID(field);\n        return this.summary[fieldUID] === undefined;\n    }\n\n    /**\n     * Returns true if the event triggering the form submission indicates we should validate the form.\n     * @param e\n     */\n    private shouldValidate(e?: Event) {\n        // Skip client-side validation if the form has been submitted via a button that has the \"formnovalidate\" attribute.\n        return !(e && e['submitter'] && e['submitter']['formNoValidate']);\n    }\n\n    /**\n     * Tracks a <form> element as parent of an input UID. When the form is submitted, attempts to validate the said input asynchronously.\n     * @param form\n     * @param inputUID\n     */\n    private trackFormInput(form: HTMLFormElement, inputUID: string) {\n        let formUID = this.getElementUID(form);\n        if (!this.formInputs[formUID]) {\n            this.formInputs[formUID] = [];\n        }\n        let add = (this.formInputs[formUID].indexOf(inputUID) === -1);\n        if (add) {\n            this.formInputs[formUID].push(inputUID);\n\n            if (this.options.addNoValidate) {\n                this.logger.log('Setting novalidate on form', form);\n                form.setAttribute('novalidate', 'novalidate');\n            }\n            else {\n                this.logger.log('Not setting novalidate on form', form);\n            }\n        }\n        else {\n            this.logger.log(\"Form input for UID '%s' is already tracked\", inputUID);\n        }\n\n        if (this.formEvents[formUID]) {\n            return;\n        }\n\n        let validating = false;\n        let cb = (e?: SubmitEvent, callback?: ValidatedCallback) => {\n            // Prevent recursion\n            if (validating) {\n                return;\n            }\n\n            if (!this.shouldValidate(e)) {\n                return;\n            }\n\n            let validate = this.getFormValidationTask(formUID);\n            if (!validate) {\n                return;\n            }\n\n            //`preValidate` typically prevents submit before validation\n            if (e) {\n                this.preValidate(e);\n            }\n\n            validating = true;\n            this.logger.log('Validating', form);\n\n            validate.then(async success => {\n                this.logger.log('Validated (success = %s)', success, form);\n                if (callback) {\n                    callback(success);\n                    return;\n                }\n\n                const validationEvent = new CustomEvent('validation',\n                    {\n                        detail: { valid: success }\n                    });\n                form.dispatchEvent(validationEvent);\n\n                // Firefox fix: redispatch 'submit' after finished handling this event\n                await new Promise(resolve => setTimeout(resolve, 0));\n                this.handleValidated(form, success, e);\n            }).catch(error => {\n                this.logger.log('Validation error', error);\n            }).finally(() => {\n                validating = false;\n            });\n        };\n\n        form.addEventListener('submit', cb);\n        form.addEventListener('reset', e => {\n            let uids = this.formInputs[formUID];\n\n            for (let uid of uids) {\n                let input = this.elementByUID[uid] as ValidatableElement;\n                if (input.classList.contains(this.ValidationInputCssClassName)) {\n                    input.classList.remove(this.ValidationInputCssClassName);\n                }\n                if (input.classList.contains(this.ValidationInputValidCssClassName)) {\n                    input.classList.remove(this.ValidationInputValidCssClassName);\n                }\n\n                let spans = this.getMessageFor(input);\n                if (spans) {\n                    for (let i = 0; i < spans.length; i++) {\n                        spans[i].innerHTML = '';\n                    }\n                }\n\n                delete this.summary[uid];\n            }\n            this.renderSummary();\n        });\n        this.formEvents[formUID] = cb;\n    }\n\n    private untrackFormInput(form: HTMLFormElement, inputUID: string) {\n        let formUID = this.getElementUID(form);\n        if (!this.formInputs[formUID]) {\n            return;\n        }\n        let indexToRemove = this.formInputs[formUID].indexOf(inputUID);\n        if (indexToRemove >= 0) {\n            this.formInputs[formUID].splice(indexToRemove, 1);\n        }\n        else {\n            this.logger.log(\"Form input for UID '%s' was already removed\", inputUID);\n        }\n    }\n\n    /**\n     * Adds an input element to be managed and validated by the service.\n     * Triggers a debounced live validation when input value changes.\n     * @param input\n     */\n    addInput(input: ValidatableElement) {\n        let uid = this.getElementUID(input);\n\n        let directives = this.parseDirectives(input.attributes);\n        let dependencies = this.getDependencies(input);\n        this.validators[uid] = this.createValidator(input, directives);\n\n        if (input.form) {\n            this.trackFormInput(input.form, uid);\n        }\n\n        if (this.inputEvents[uid]) {\n            return;\n        }\n\n        let debounceTimeoutID = 0;\n        let cb = (e?: Event, callback?: ValidatedCallback) => {\n            let validate = this.validators[uid];\n            clearTimeout(debounceTimeoutID);\n            debounceTimeoutID = setTimeout(() => {\n                validate()\n                    .then(callback)\n                    .catch(error => {\n                        this.logger.log('Validation error', error);\n                    });\n            }, this.debounce);\n        };\n\n        for (let el of dependencies) {\n            this.addInputDependency(el, uid);\n        }\n\n        addInputValidationEventListener(input, cb);\n\n        this.inputEvents[uid] = cb;\n    }\n\n    /**\n     * Adds an input element to have its change events trigger validation on related elements.\n     * @param input\n     * @param relatedUid\n     */\n    addInputDependency(input: ValidatableElement, relatedUid: string) {\n\n        const uid = this.getElementUID(input);\n        (this.dependencies[uid] ?? (this.dependencies[uid] = [])).push(relatedUid);\n\n        if (!this.relatedInputEvents[uid]) {\n            addInputValidationEventListener(input, this.relatedInputEvents[uid] = () => {\n                const otherUids = this.dependencies[uid];\n                if (otherUids) {\n                    for (let otherUid of otherUids) {\n                        const otherEl = this.elementByUID[otherUid];\n                        if (otherEl && isValidatable(otherEl)) {\n                            const otherType = otherEl.type.toLowerCase();\n                            if (otherType === \"checkbox\" || otherType === \"radio\" || !otherEl.value) {\n                                if (!this.isFieldValid(otherEl, false)) {\n                                    this.removeError(otherEl);\n                                }\n                            }\n                            else {\n                                this.validateField(otherEl);\n                            }\n                        }\n                    }\n                }\n            });\n        }\n    }\n\n    removeInput(input: ValidatableElement) {\n        let uid = this.getElementUID(input);\n\n        delete this.summary[uid];\n        delete this.inputEvents[uid];\n        delete this.validators[uid];\n\n        if (input.form) {\n            this.untrackFormInput(input.form, uid);\n        }\n    }\n\n    /**\n     * Scans the entire document for input elements to be validated.\n     */\n    private scanInputs(root: ParentNode, remove: boolean = false) {\n        let inputs = Array.from(root.querySelectorAll<ValidatableElement>(validatableSelector('[data-val=\"true\"]')));\n\n        // querySelectorAll does not include the root element itself.\n        // we could use 'matches', but that's newer than querySelectorAll so we'll keep it simple and compatible.\n        if (isValidatable(root) && root.getAttribute(\"data-val\") === \"true\") {\n            inputs.push(root);\n        }\n\n        for (let i = 0; i < inputs.length; i++) {\n            let input = inputs[i];\n            if (remove) {\n                this.removeInput(input);\n            }\n            else {\n                this.addInput(input);\n            }\n        }\n    }\n\n    /**\n     * Returns a <ul> element as a validation errors summary.\n     */\n    createSummaryDOM() {\n        if (!Object.keys(this.summary).length) {\n            return null;\n        }\n\n        let renderedMessages = [];\n        let ul = document.createElement('ul');\n        for (let key in this.summary) {\n            // It could be that the message we are rendering belongs to one of a fieldset of multiple inputs that's not selected,\n            // even if another one in the fieldset is. In that case the fieldset is valid, and we shouldn't render the message.\n            const matchingElement = this.elementByUID[key];\n            if (matchingElement instanceof HTMLInputElement) {\n                if (matchingElement.type === \"checkbox\" || matchingElement.type === \"radio\") {\n                    if (matchingElement.className === this.ValidationInputValidCssClassName) {\n                        continue;\n                    }\n                }\n            }\n\n            // With required multiple inputs, such as a checkbox list, we'll have one message per input.\n            // It's one from the inputs that's required, not all, so we should only have one message displayed.\n            if (renderedMessages.indexOf(this.summary[key]) > -1) {\n                continue;\n            }\n\n            let li = document.createElement('li');\n            li.innerHTML = this.summary[key];\n            ul.appendChild(li);\n            renderedMessages.push(this.summary[key]);\n        }\n        return ul;\n    }\n\n    /**\n     * Displays validation summary to ASP.NET Core MVC designated elements, when it actually gets updated.\n     */\n    private renderSummary() {\n        let summaryElements = document.querySelectorAll('[data-valmsg-summary=\"true\"]');\n        if (!summaryElements.length) {\n            return;\n        }\n\n        // Prevents wasteful re-rendering of summary list element with identical items!\n        // Using JSON.stringify for quick and painless deep compare of simple KVP. You need to sort the keys first, tho...\n        let shadow = JSON.stringify(this.summary, Object.keys(this.summary).sort());\n        if (shadow === this.renderedSummaryJSON) {\n            return;\n        }\n\n        // Prevents wasteful re-rendering of summary list element with identical items!\n        this.renderedSummaryJSON = shadow;\n        let ul = this.createSummaryDOM();\n\n        for (let i = 0; i < summaryElements.length; i++) {\n            let e = summaryElements[i];\n\n            // Remove existing list elements, but keep the summary's message.\n            let listElements = e.querySelectorAll(\"ul\");\n            for (let j = 0; j < listElements.length; j++) {\n                listElements[j].remove();\n            }\n\n            // Style the summary element as valid/invalid depending on whether there are any messages to display.\n            if (ul && ul.hasChildNodes()) {\n                this.swapClasses(e,\n                    this.ValidationSummaryCssClassName,\n                    this.ValidationSummaryValidCssClassName)\n                e.appendChild(ul.cloneNode(true));\n            } else {\n                this.swapClasses(e,\n                    this.ValidationSummaryValidCssClassName,\n                    this.ValidationSummaryCssClassName)\n            }\n        }\n    }\n\n    /**\n     * Adds an error message to an input element, which also updates the validation message elements and validation summary elements.\n     * @param input\n     * @param message\n     */\n    addError(input: ValidatableElement, message: string) {\n        let spans = this.getMessageFor(input);\n        if (spans) {\n            for (let i = 0; i < spans.length; i++) {\n                const span = spans[i];\n                spans[i].innerHTML = message;\n                this.swapClasses(spans[i],\n                    this.ValidationMessageCssClassName,\n                    this.ValidationMessageValidCssClassName);\n            }\n        }\n\n        this.swapClasses(input,\n            this.ValidationInputCssClassName,\n            this.ValidationInputValidCssClassName);\n\n        if (input.form) {\n            // Adding an error to one input should also add it to others with the same name (i.e. for radio button and checkbox lists).\n            const inputs = input.form.querySelectorAll(validatableSelector(`[name=\"${input.name}\"]`));\n            for (let i = 0; i < inputs.length; i++) {\n                this.swapClasses(inputs[i],\n                    this.ValidationInputCssClassName,\n                    this.ValidationInputValidCssClassName);\n\n                let uid = this.getElementUID(inputs[i]);\n                this.summary[uid] = message;\n            }\n        }\n\n        this.renderSummary();\n    }\n\n    /**\n     * Removes an error message from an input element, which also updates the validation message elements and validation summary elements.\n     * @param input\n     */\n    removeError(input: ValidatableElement) {\n        let spans = this.getMessageFor(input);\n        if (spans) {\n            for (let i = 0; i < spans.length; i++) {\n                spans[i].innerHTML = '';\n                this.swapClasses(spans[i],\n                    this.ValidationMessageValidCssClassName,\n                    this.ValidationMessageCssClassName);\n            }\n        }\n\n        this.swapClasses(input,\n            this.ValidationInputValidCssClassName,\n            this.ValidationInputCssClassName);\n\n        // Removing an error from one input should also remove it from others with the same name (i.e. for radio button and checkbox lists).\n        if (input.form) {\n            const inputs = input.form.querySelectorAll(validatableSelector(`[name=\"${input.name}\"]`));\n            for (let i = 0; i < inputs.length; i++) {\n                this.swapClasses(inputs[i],\n                    this.ValidationInputValidCssClassName,\n                    this.ValidationInputCssClassName);\n\n                let uid = this.getElementUID(inputs[i]);\n                delete this.summary[uid];\n            }\n        }\n\n        this.renderSummary();\n    }\n\n    /**\n     * Returns a validation Promise factory for an input element, using given validation directives.\n     * @param input\n     * @param directives\n     */\n    createValidator(input: ValidatableElement, directives: ValidationDirective) {\n        return async () => {\n            // only validate visible fields\n            if (!this.isHidden(input)) {\n                for (let key in directives) {\n                    let directive = directives[key];\n                    let provider = this.providers[key];\n\n                    if (!provider) {\n                        this.logger.log('aspnet-validation provider not implemented: %s', key);\n                        continue;\n                    }\n                    this.logger.log(\"Running %s validator on element\", key, input);\n\n                    let result = provider(input.value, input, directive.params);\n                    let valid = false;\n                    let error = directive.error;\n\n                    if (typeof result === 'boolean') {\n                        valid = result;\n                    } else if (typeof result === 'string') {\n                        valid = false;\n                        error = result;\n                    } else {\n                        let resolution = await result;\n                        if (typeof resolution === 'boolean') {\n                            valid = resolution;\n                        } else {\n                            valid = false;\n                            error = resolution;\n                        }\n                    }\n\n                    if (!valid) {\n                        this.addError(input, error);\n                        return false;\n                    }\n                }\n            }\n\n            this.removeError(input);\n            return true;\n        };\n    }\n\n    /**\n     * Checks if the provided input is hidden from the browser\n     * @param input\n     * @returns\n     */\n    private isHidden(input: HTMLElement) {\n        return !(this.allowHiddenFields || input.offsetWidth || input.offsetHeight || input.getClientRects().length);\n    }\n\n    /**\n     * Adds addClass and removes removeClass\n     * @param element Element to modify\n     * @param addClass Class to add\n     * @param removeClass Class to remove\n     */\n    private swapClasses(element: Element, addClass: string, removeClass: string) {\n        if (addClass && !element.classList.contains(addClass)) {\n            element.classList.add(addClass);\n        }\n        if (element.classList.contains(removeClass)) {\n            element.classList.remove(removeClass);\n        }\n    }\n\n    /**\n     * Options for this instance of @type {ValidationService}.\n     */\n    private options: ValidationServiceOptions = {\n        root: document.body,\n        watch: false,\n        addNoValidate: true,\n    }\n\n    /**\n     * Load default validation providers and scans the entire document when ready.\n     * @param options.watch If set to true, a MutationObserver will be used to continuously watch for new elements that provide validation directives.\n     * @param options.addNoValidate If set to true (the default), a novalidate attribute will be added to the containing form in validate elemets.\n     */\n    bootstrap(options?: Partial<ValidationServiceOptions>) {\n        Object.assign(this.options, options);\n\n        this.addMvcProviders();\n        this.addCustomProviders();\n        let document = window.document;\n        const root = this.options.root;\n        const init = () => {\n            this.scan(root);\n\n            // Watch for further mutations after initial scan\n            if (this.options.watch) {\n                this.watch(root);\n            }\n        }\n\n        // If the document is done loading, scan it now.\n        if (document.readyState === 'complete' || document.readyState === 'interactive') {\n            init();\n        }\n        else {\n            // Otherwise wait until the document is done loading.\n            document.addEventListener('DOMContentLoaded', init);\n        }\n    }\n\n    /**\n     * Scans the provided root element for any validation directives and attaches behavior to them.\n     */\n    scan(root: ParentNode) {\n        this.logger.log('Scanning', root);\n        this.scanMessages(root);\n        this.scanInputs(root);\n    }\n\n    /**\n     * Scans the provided root element for any validation directives and removes behavior from them.\n     */\n    remove(root: ParentNode) {\n        this.logger.log('Removing', root);\n        this.scanMessages(root, true);\n        this.scanInputs(root, true);\n    }\n\n    /**\n     * Watches the provided root element for mutations, and scans for new validation directives to attach behavior.\n     * @param root The root element to use, defaults to the document.documentElement.\n     */\n    watch(root: ParentNode) {\n        this.observer = new MutationObserver(mutations => {\n            mutations.forEach(mutation => {\n                this.observed(mutation);\n            });\n        });\n        this.observer.observe(root, {\n            attributes: true,\n            childList: true,\n            subtree: true\n        });\n        this.logger.log(\"Watching for mutations\");\n    }\n\n    private observed(mutation: MutationRecord) {\n        if (mutation.type === 'childList') {\n            for (let i = 0; i < mutation.addedNodes.length; i++) {\n                let node = mutation.addedNodes[i];\n                this.logger.log('Added node', node);\n                if (node instanceof HTMLElement) {\n                    this.scan(node);\n                }\n            }\n            for (let i = 0; i < mutation.removedNodes.length; i++) {\n                let node = mutation.removedNodes[i];\n                this.logger.log('Removed node', node);\n                if (node instanceof HTMLElement) {\n                    this.remove(node);\n                }\n            }\n        } else if (mutation.type === 'attributes') {\n            if (mutation.target instanceof HTMLElement) {\n                const oldValue = mutation.oldValue ?? '';\n                const newValue = mutation.target.attributes[mutation.attributeName]?.value ?? '';\n                this.logger.log(\"Attribute '%s' changed from '%s' to '%s'\",\n                    mutation.attributeName,\n                    oldValue,\n                    newValue,\n                    mutation.target);\n                if (oldValue !== newValue) {\n                    this.scan(mutation.target);\n                }\n            }\n        }\n    }\n\n    /**\n     * Override CSS class name for input validation error. Default: 'input-validation-error'\n     */\n    ValidationInputCssClassName = \"input-validation-error\";\n\n    /**\n     * Override CSS class name for valid input validation. Default: 'input-validation-valid'\n     */\n    ValidationInputValidCssClassName = \"input-validation-valid\";\n\n    /**\n     * Override CSS class name for field validation error. Default: 'field-validation-error'\n     */\n    ValidationMessageCssClassName = \"field-validation-error\";\n\n    /**\n     * Override CSS class name for valid field validation. Default: 'field-validation-valid'\n     */\n    ValidationMessageValidCssClassName = \"field-validation-valid\";\n\n    /**\n     * Override CSS class name for validation summary error. Default: 'validation-summary-errors'\n     */\n    ValidationSummaryCssClassName = \"validation-summary-errors\";\n\n    /**\n     * Override CSS class name for valid validation summary. Default: 'field-validation-valid'\n     */\n    ValidationSummaryValidCssClassName = \"validation-summary-valid\";\n}\n"],"sourceRoot":""}