{"version":3,"sources":["aspnet-validation.js"],"names":["root","factory","exports","module","window","define","amd","modules","./src/index.ts","__webpack_exports__","__webpack_require__","r","d","isValidatable","mode","ValidationService","__awaiter","thisArg","_arguments","P","generator","value","fulfilled","step","next","e","rejected","reject","result","done","resolve","then","apply","getDefault","__generator","body","f","y","t","_","label","getter","ops","g","verb","throw","return","Symbol","iterator","this","n","v","op","TypeError","call","trys","pop","length","undefined","push","nullLogger","_args","_i","arguments","class_1","warn","globalThis","console","element","HTMLInputElement","HTMLSelectElement","HTMLTextAreaElement","validatableSelector","selector","validatableElementTypes","map","concat","join","getRelativeFormElement","elementName","name","selectedName","substring","dotLocation","lastIndexOf","objectName","relativeElement","document","getElementsByName","form","querySelector","MvcValidationProviders","required","params","type","toLowerCase","elementType","Boolean","allElementsOfThisName_1","Array","from","querySelectorAll","element_1","checked","checkboxHiddenInput","stringLength","prototype","min","parseInt","max","compare","otherElement","other","range","isNaN","val","parseFloat","regex","pattern","RegExp","test","email","creditcard","cDigit","nCheck","nDigit","bEven","replace","charAt","url","lowerCaseValue","indexOf","phone","remote","fieldSelectors","additionalfields","split","fields","fieldSelectors_1","fieldSelector","fieldName","substr","fieldElement","encodedParams","encodeURIComponent","encodedParam","payload","Promise","ok","request","XMLHttpRequest","postData","FormData","append","open","setRequestHeader","send","onload","data","status","JSON","parse","responseText","statusText","onerror","addProvider","callback","providers","fieldUID","log","_this","addMvcProviders","mvc","preValidate","submitEvent","stopImmediatePropagation","handleValidated","scanMessages","remove","focusFirstInvalid","validationMessageElements_1","span","newEvent","submitValidForm","getElementById","dispatchEvent","pushValidationMessageSpan","forms","containingForm","HTMLFormElement","submitterInput","Element","closest","submit","_a","forms_1","_b","formUID","formInputUIDs","invalidFormInputUIDs","filter","removeValidationMessageSpan","formId","getElementUID","getAttribute","spans","messageFor","logger","isValid","prevalidate","validateForm","index","summary","splice","validateField","field","attributes","validationAtributes","cut","i","a","key","watch","addNoValidate","Object","keys","Q","directive","ValidationInputCssClassName","pcut","parameters","ValidationInputValidCssClassName","pkey","pvalue","directives","_loop_1","ValidationMessageValidCssClassName","ValidationSummaryCssClassName","ValidationSummaryValidCssClassName","random","c","toString","node","x","uid","guid4","elementByUID","getFormValidationTask","formInputs","validator","validators","inputUID","formValidators","all","tasks","every","getMessageFor","input","trackFormInput","validating","validationMessageElements_3","formEvents","error","cb","validate","shouldValidate","validationEvent","success","CustomEvent","detail","valid","parseDirectives","setTimeout","catch","finally","uids_1","classList","contains","innerHTML","renderSummary","untrackFormInput","indexToRemove","elementUIDs","debounceTimeoutID","createValidator","inputEvents","clearTimeout","debounce","valEvent","addEventListener","validateEvent","eventType","removeInput","scanInputs","inputs","addInput","createSummaryDOM","options","renderedMessages","ul","createElement","matchingElement","appendChild","li","summaryElements","stringify","sort","shadow","renderedSummaryJSON","listElements","j","hasChildNodes","swapClasses","addError","message","uids","ValidationMessageCssClassName","_c","resolution","_d","isHidden","provider","sent","removeError","offsetWidth","offsetHeight","getClientRects","addClass","removeClass","add","scan","assign","readyState","init","observer","MutationObserver","mutations","forEach","mutation","observed","observe","childList","subtree","oldValue","newValue","addedNodes","HTMLElement","removedNodes","target","attributeName","allowHiddenFields","formValidationEvent","fieldValidationEvent","SubmitEvent","submitter","name_1","firstInvalid","focus","isFieldValid","installedModules","m","o","defineProperty","enumerable","get","toStringTag","__esModule","ns","create","bind","hasOwnProperty","object","property","p","moduleId","l"],"mappings":"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","file":"../aspnet-validation.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n  if (typeof exports === 'object' && typeof module === 'object')\n    module.exports = factory();\n  else if (typeof define === 'function' && define.amd) define([], factory);\n  else if (typeof exports === 'object') exports['aspnetValidation'] = factory();\n  else root['aspnetValidation'] = factory();\n})(window, function () {\n  return /******/ (function (modules) {\n    // webpackBootstrap\n    /******/ // The module cache\n    /******/ var installedModules = {};\n    /******/\n    /******/ // The require function\n    /******/ function __webpack_require__(moduleId) {\n      /******/\n      /******/ // Check if module is in cache\n      /******/ if (installedModules[moduleId]) {\n        /******/ return installedModules[moduleId].exports;\n        /******/\n      }\n      /******/ // Create a new module (and put it into the cache)\n      /******/ var module = (installedModules[moduleId] = {\n        /******/ i: moduleId,\n        /******/ l: false,\n        /******/ exports: {},\n        /******/\n      });\n      /******/\n      /******/ // Execute the module function\n      /******/ modules[moduleId].call(\n        module.exports,\n        module,\n        module.exports,\n        __webpack_require__\n      );\n      /******/\n      /******/ // Flag the module as loaded\n      /******/ module.l = true;\n      /******/\n      /******/ // Return the exports of the module\n      /******/ return module.exports;\n      /******/\n    }\n    /******/\n    /******/\n    /******/ // expose the modules object (__webpack_modules__)\n    /******/ __webpack_require__.m = modules;\n    /******/\n    /******/ // expose the module cache\n    /******/ __webpack_require__.c = installedModules;\n    /******/\n    /******/ // define getter function for harmony exports\n    /******/ __webpack_require__.d = function (exports, name, getter) {\n      /******/ if (!__webpack_require__.o(exports, name)) {\n        /******/ Object.defineProperty(exports, name, {\n          enumerable: true,\n          get: getter,\n        });\n        /******/\n      }\n      /******/\n    };\n    /******/\n    /******/ // define __esModule on exports\n    /******/ __webpack_require__.r = function (exports) {\n      /******/ if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n        /******/ Object.defineProperty(exports, Symbol.toStringTag, {\n          value: 'Module',\n        });\n        /******/\n      }\n      /******/ Object.defineProperty(exports, '__esModule', { value: true });\n      /******/\n    };\n    /******/\n    /******/ // create a fake namespace object\n    /******/ // mode & 1: value is a module id, require it\n    /******/ // mode & 2: merge all properties of value into the ns\n    /******/ // mode & 4: return value when already ns object\n    /******/ // mode & 8|1: behave like require\n    /******/ __webpack_require__.t = function (value, mode) {\n      /******/ if (mode & 1) value = __webpack_require__(value);\n      /******/ if (mode & 8) return value;\n      /******/ if (\n        mode & 4 &&\n        typeof value === 'object' &&\n        value &&\n        value.__esModule\n      )\n        return value;\n      /******/ var ns = Object.create(null);\n      /******/ __webpack_require__.r(ns);\n      /******/ Object.defineProperty(ns, 'default', {\n        enumerable: true,\n        value: value,\n      });\n      /******/ if (mode & 2 && typeof value != 'string')\n        for (var key in value)\n          __webpack_require__.d(\n            ns,\n            key,\n            function (key) {\n              return value[key];\n            }.bind(null, key)\n          );\n      /******/ return ns;\n      /******/\n    };\n    /******/\n    /******/ // getDefaultExport function for compatibility with non-harmony modules\n    /******/ __webpack_require__.n = function (module) {\n      /******/ var getter =\n        module && module.__esModule\n          ? /******/ function getDefault() {\n              return module['default'];\n            }\n          : /******/ function getModuleExports() {\n              return module;\n            };\n      /******/ __webpack_require__.d(getter, 'a', getter);\n      /******/ return getter;\n      /******/\n    };\n    /******/\n    /******/ // Object.prototype.hasOwnProperty.call\n    /******/ __webpack_require__.o = function (object, property) {\n      return Object.prototype.hasOwnProperty.call(object, property);\n    };\n    /******/\n    /******/ // __webpack_public_path__\n    /******/ __webpack_require__.p = '';\n    /******/\n    /******/\n    /******/ // Load entry module and return exports\n    /******/ return __webpack_require__(\n      (__webpack_require__.s = './src/index.ts')\n    );\n    /******/\n  })(\n    /************************************************************************/\n    /******/ {\n      /***/ './src/index.ts':\n        /*!**********************!*\\\n  !*** ./src/index.ts ***!\n  \\**********************/\n        /*! exports provided: isValidatable, MvcValidationProviders, ValidationService */\n        /***/ function (module, __webpack_exports__, __webpack_require__) {\n          'use strict';\n          __webpack_require__.r(__webpack_exports__);\n          /* harmony export (binding) */ __webpack_require__.d(\n            __webpack_exports__,\n            'isValidatable',\n            function () {\n              return isValidatable;\n            }\n          );\n          /* harmony export (binding) */ __webpack_require__.d(\n            __webpack_exports__,\n            'MvcValidationProviders',\n            function () {\n              return MvcValidationProviders;\n            }\n          );\n          /* harmony export (binding) */ __webpack_require__.d(\n            __webpack_exports__,\n            'ValidationService',\n            function () {\n              return ValidationService;\n            }\n          );\n          var __awaiter =\n            (undefined && undefined.__awaiter) ||\n            function (thisArg, _arguments, P, generator) {\n              function adopt(value) {\n                return value instanceof P\n                  ? value\n                  : new P(function (resolve) {\n                      resolve(value);\n                    });\n              }\n              return new (P || (P = Promise))(function (resolve, reject) {\n                function fulfilled(value) {\n                  try {\n                    step(generator.next(value));\n                  } catch (e) {\n                    reject(e);\n                  }\n                }\n                function rejected(value) {\n                  try {\n                    step(generator['throw'](value));\n                  } catch (e) {\n                    reject(e);\n                  }\n                }\n                function step(result) {\n                  result.done\n                    ? resolve(result.value)\n                    : adopt(result.value).then(fulfilled, rejected);\n                }\n                step(\n                  (generator = generator.apply(\n                    thisArg,\n                    _arguments || []\n                  )).next()\n                );\n              });\n            };\n          var __generator =\n            (undefined && undefined.__generator) ||\n            function (thisArg, body) {\n              var _ = {\n                  label: 0,\n                  sent: function () {\n                    if (t[0] & 1) throw t[1];\n                    return t[1];\n                  },\n                  trys: [],\n                  ops: [],\n                },\n                f,\n                y,\n                t,\n                g;\n              return (\n                (g = { next: verb(0), throw: verb(1), return: verb(2) }),\n                typeof Symbol === 'function' &&\n                  (g[Symbol.iterator] = function () {\n                    return this;\n                  }),\n                g\n              );\n              function verb(n) {\n                return function (v) {\n                  return step([n, v]);\n                };\n              }\n              function step(op) {\n                if (f) throw new TypeError('Generator is already executing.');\n                while ((g && ((g = 0), op[0] && (_ = 0)), _))\n                  try {\n                    if (\n                      ((f = 1),\n                      y &&\n                        (t =\n                          op[0] & 2\n                            ? y['return']\n                            : op[0]\n                            ? y['throw'] || ((t = y['return']) && t.call(y), 0)\n                            : y.next) &&\n                        !(t = t.call(y, op[1])).done)\n                    )\n                      return t;\n                    if (((y = 0), t)) op = [op[0] & 2, t.value];\n                    switch (op[0]) {\n                      case 0:\n                      case 1:\n                        t = op;\n                        break;\n                      case 4:\n                        _.label++;\n                        return { value: op[1], done: false };\n                      case 5:\n                        _.label++;\n                        y = op[1];\n                        op = [0];\n                        continue;\n                      case 7:\n                        op = _.ops.pop();\n                        _.trys.pop();\n                        continue;\n                      default:\n                        if (\n                          !((t = _.trys),\n                          (t = t.length > 0 && t[t.length - 1])) &&\n                          (op[0] === 6 || op[0] === 2)\n                        ) {\n                          _ = 0;\n                          continue;\n                        }\n                        if (\n                          op[0] === 3 &&\n                          (!t || (op[1] > t[0] && op[1] < t[3]))\n                        ) {\n                          _.label = op[1];\n                          break;\n                        }\n                        if (op[0] === 6 && _.label < t[1]) {\n                          _.label = t[1];\n                          t = op;\n                          break;\n                        }\n                        if (t && _.label < t[2]) {\n                          _.label = t[2];\n                          _.ops.push(op);\n                          break;\n                        }\n                        if (t[2]) _.ops.pop();\n                        _.trys.pop();\n                        continue;\n                    }\n                    op = body.call(thisArg, _);\n                  } catch (e) {\n                    op = [6, e];\n                    y = 0;\n                  } finally {\n                    f = t = 0;\n                  }\n                if (op[0] & 5) throw op[1];\n                return { value: op[0] ? op[1] : void 0, done: true };\n              }\n            };\n          var nullLogger = new /** @class */ ((function () {\n            function class_1() {\n              this.warn = globalThis.console.warn;\n            }\n            class_1.prototype.log = function (_) {\n              var _args = [];\n              for (var _i = 1; _i < arguments.length; _i++) {\n                _args[_i - 1] = arguments[_i];\n              }\n            };\n            return class_1;\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           */\n          var isValidatable = function (element) {\n            return (\n              element instanceof HTMLInputElement ||\n              element instanceof HTMLSelectElement ||\n              element instanceof HTMLTextAreaElement\n            );\n          };\n          var validatableElementTypes = ['input', 'select', 'textarea'];\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           */\n          var validatableSelector = function (selector) {\n            return validatableElementTypes\n              .map(function (t) {\n                return ''.concat(t).concat(selector || '');\n              })\n              .join(',');\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           */\n          function getRelativeFormElement(element, selector) {\n            // example elementName: Form.PasswordConfirm, Form.Email\n            // example selector (dafuq): *.Password, *.__RequestVerificationToken\n            // example result element name: Form.Password, __RequestVerificationToken\n            var elementName = element.name;\n            var selectedName = selector.substring(2); // Password, __RequestVerificationToken\n            var objectName = '';\n            var dotLocation = elementName.lastIndexOf('.');\n            if (dotLocation > -1) {\n              // Form\n              objectName = elementName.substring(0, dotLocation);\n              // Form.Password\n              var relativeElementName = objectName + '.' + selectedName;\n              var relativeElement =\n                document.getElementsByName(relativeElementName)[0];\n              if (isValidatable(relativeElement)) {\n                return relativeElement;\n              }\n            }\n            // __RequestVerificationToken\n            return element.form.querySelector(\n              validatableSelector('[name='.concat(selectedName, ']'))\n            );\n          }\n          /**\n           * Contains default implementations for ASP.NET Core MVC validation attributes.\n           */\n          var MvcValidationProviders = /** @class */ (function () {\n            function MvcValidationProviders() {\n              /**\n               * Validates whether the input has a value.\n               */\n              this.required = function (value, element, params) {\n                // Handle single and multiple checkboxes/radio buttons.\n                var elementType = element.type.toLowerCase();\n                if (elementType === 'checkbox' || elementType === 'radio') {\n                  var allElementsOfThisName = Array.from(\n                    element.form.querySelectorAll(\n                      validatableSelector(\n                        \"[name='\"\n                          .concat(element.name, \"'][type='\")\n                          .concat(elementType, \"']\")\n                      )\n                    )\n                  );\n                  for (\n                    var _i = 0, allElementsOfThisName_1 = allElementsOfThisName;\n                    _i < allElementsOfThisName_1.length;\n                    _i++\n                  ) {\n                    var element_1 = allElementsOfThisName_1[_i];\n                    if (\n                      element_1 instanceof HTMLInputElement &&\n                      element_1.checked === true\n                    ) {\n                      return true;\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                    var checkboxHiddenInput = element.form.querySelector(\n                      \"input[name='\".concat(element.name, \"'][type='hidden']\")\n                    );\n                    if (\n                      checkboxHiddenInput instanceof HTMLInputElement &&\n                      checkboxHiddenInput.value === 'false'\n                    ) {\n                      return true;\n                    }\n                  }\n                  return false;\n                }\n                // Default behavior otherwise.\n                return Boolean(value);\n              };\n              /**\n               * Validates whether the input value satisfies the length contstraint.\n               */\n              this.stringLength = function (value, element, params) {\n                if (!value) {\n                  return true;\n                }\n                if (params.min) {\n                  var min = parseInt(params.min);\n                  if (value.length < min) {\n                    return false;\n                  }\n                }\n                if (params.max) {\n                  var max = parseInt(params.max);\n                  if (value.length > max) {\n                    return false;\n                  }\n                }\n                return true;\n              };\n              /**\n               * Validates whether the input value is equal to another input value.\n               */\n              this.compare = function (value, element, params) {\n                if (!params.other) {\n                  return true;\n                }\n                var otherElement = getRelativeFormElement(\n                  element,\n                  params.other\n                );\n                if (!otherElement) {\n                  return true;\n                }\n                return otherElement.value === value;\n              };\n              /**\n               * Validates whether the input value is a number within a given range.\n               */\n              this.range = function (value, element, params) {\n                if (!value) {\n                  return true;\n                }\n                var val = parseFloat(value);\n                if (isNaN(val)) {\n                  return false;\n                }\n                if (params.min) {\n                  var min = parseFloat(params.min);\n                  if (val < min) {\n                    return false;\n                  }\n                }\n                if (params.max) {\n                  var max = parseFloat(params.max);\n                  if (val > max) {\n                    return false;\n                  }\n                }\n                return true;\n              };\n              /**\n               * Validates whether the input value satisfies a regular expression pattern.\n               */\n              this.regex = function (value, element, params) {\n                if (!value || !params.pattern) {\n                  return true;\n                }\n                var r = new RegExp(params.pattern);\n                return r.test(value);\n              };\n              /**\n               * Validates whether the input value is an email in accordance to RFC822 specification, with a top level domain.\n               */\n              this.email = function (value, element, params) {\n                if (!value) {\n                  return true;\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                var r =\n                  /^([^\\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               * Validates whether the input value is a credit card number, with Luhn's Algorithm.\n               */\n              this.creditcard = function (value, element, params) {\n                if (!value) {\n                  return true;\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                // Accept only spaces, digits and dashes\n                if (/[^0-9 \\-]+/.test(value)) {\n                  return false;\n                }\n                var nCheck = 0,\n                  nDigit = 0,\n                  bEven = false,\n                  n,\n                  cDigit;\n                value = value.replace(/\\D/g, '');\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                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                  nCheck += nDigit;\n                  bEven = !bEven;\n                }\n                return nCheck % 10 === 0;\n              };\n              /**\n               * Validates whether the input value is a URL.\n               */\n              this.url = function (value, element, params) {\n                if (!value) {\n                  return true;\n                }\n                var lowerCaseValue = value.toLowerCase();\n                // Match the logic in `UrlAttribute`\n                return (\n                  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              this.phone = function (value, element, params) {\n                if (!value) {\n                  return true;\n                }\n                // Allows whitespace or dash as number separator because some people like to do that...\n                var consecutiveSeparator = /[\\+\\-\\s][\\-\\s]/g;\n                if (consecutiveSeparator.test(value)) {\n                  return false;\n                }\n                var r = /^\\+?[0-9\\-\\s]+$/;\n                return r.test(value);\n              };\n              /**\n               * Asynchronously validates the input value to a JSON GET API endpoint.\n               */\n              this.remote = function (value, element, params) {\n                if (!value) {\n                  return true;\n                }\n                // params.additionalfields: *.Email,*.Username\n                var fieldSelectors = params.additionalfields.split(',');\n                var fields = {};\n                for (\n                  var _i = 0, fieldSelectors_1 = fieldSelectors;\n                  _i < fieldSelectors_1.length;\n                  _i++\n                ) {\n                  var fieldSelector = fieldSelectors_1[_i];\n                  var fieldName = fieldSelector.substr(2);\n                  var fieldElement = getRelativeFormElement(\n                    element,\n                    fieldSelector\n                  );\n                  var hasValue = Boolean(fieldElement && fieldElement.value);\n                  if (!hasValue) {\n                    continue;\n                  }\n                  fields[fieldName] = fieldElement.value;\n                }\n                var url = params['url'];\n                var encodedParams = [];\n                for (var fieldName in fields) {\n                  var encodedParam =\n                    encodeURIComponent(fieldName) +\n                    '=' +\n                    encodeURIComponent(fields[fieldName]);\n                  encodedParams.push(encodedParam);\n                }\n                var payload = encodedParams.join('&');\n                return new Promise(function (ok, reject) {\n                  var request = new XMLHttpRequest();\n                  if (params.type === 'Post') {\n                    var postData = new FormData();\n                    for (var fieldName in fields) {\n                      postData.append(fieldName, fields[fieldName]);\n                    }\n                    request.open('post', url);\n                    request.setRequestHeader(\n                      'Content-Type',\n                      'application/x-www-form-urlencoded'\n                    );\n                    request.send(payload);\n                  } else {\n                    request.open('get', url + '?' + payload);\n                    request.send();\n                  }\n                  request.onload = function (e) {\n                    if (request.status >= 200 && request.status < 300) {\n                      var 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                  request.onerror = function (e) {\n                    reject({\n                      status: request.status,\n                      statusText: request.statusText,\n                      data: request.responseText,\n                    });\n                  };\n                });\n              };\n            }\n            return MvcValidationProviders;\n          })();\n\n          /**\n           * Responsible for managing the DOM elements and running the validation providers.\n           */\n          var ValidationService = /** @class */ (function () {\n            function ValidationService(logger) {\n              var _this = this;\n              /**\n               * A key-value collection of loaded validation plugins.\n               */\n              this.providers = {};\n              /**\n               * A key-value collection of <span> elements for displaying validation messages for an input (by DOM ID).\n               */\n              this.messageFor = {};\n              /**\n               * A list of managed elements, each having a randomly assigned unique identifier (UID).\n               */\n              this.elementUIDs = [];\n              /**\n               * A key-value collection of UID to Element for quick lookup.\n               */\n              this.elementByUID = {};\n              /**\n               * A key-value collection of input UIDs for a <form> UID.\n               */\n              this.formInputs = {};\n              /**\n               * A key-value map for input UID to its validator factory.\n               */\n              this.validators = {};\n              /**\n               * A key-value map for form UID to its trigger element (submit event for <form>).\n               */\n              this.formEvents = {};\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              this.inputEvents = {};\n              /**\n               * A key-value map of input UID to its validation error message.\n               */\n              this.summary = {};\n              /**\n               * In milliseconds, the rate of fire of the input validation.\n               */\n              this.debounce = 300;\n              /**\n               * Allow hidden fields validation\n               */\n              this.allowHiddenFields = false;\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              this.validateForm = function (form, callback) {\n                var formUID = _this.getElementUID(form);\n                var formValidationEvent = _this.formEvents[formUID];\n                if (formValidationEvent) {\n                  formValidationEvent(undefined, callback);\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              this.validateField = function (field, callback) {\n                var fieldUID = _this.getElementUID(field);\n                var fieldValidationEvent = _this.inputEvents[fieldUID];\n                if (fieldValidationEvent) {\n                  fieldValidationEvent(undefined, callback);\n                }\n              };\n              /**\n               * Called before validating form submit events.\n               * Default calls `preventDefault()` and `stopImmediatePropagation()`.\n               * @param submitEvent The `SubmitEvent`.\n               */\n              this.preValidate = function (submitEvent) {\n                submitEvent.preventDefault();\n                submitEvent.stopImmediatePropagation();\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              this.handleValidated = function (form, success, submitEvent) {\n                if (success) {\n                  if (submitEvent) {\n                    _this.submitValidForm(form, submitEvent);\n                  }\n                } else {\n                  _this.focusFirstInvalid(form);\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              this.submitValidForm = function (form, submitEvent) {\n                var 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                  var submitter = submitEvent.submitter;\n                  if (submitter) {\n                    var name_1 = submitter.getAttribute('name');\n                    // If name is null, a submit button is not submitted.\n                    if (name_1) {\n                      var submitterInput = document.createElement('input');\n                      submitterInput.type = 'hidden';\n                      submitterInput.name = name_1;\n                      submitterInput.value = submitter.getAttribute('value');\n                      form.appendChild(submitterInput);\n                    }\n                  }\n                  form.submit();\n                }\n              };\n              /**\n               * Focuses the first invalid element within the provided form\n               * @param form\n               */\n              this.focusFirstInvalid = function (form) {\n                var formUID = _this.getElementUID(form);\n                var formInputUIDs = _this.formInputs[formUID];\n                var invalidFormInputUIDs = formInputUIDs.filter(function (uid) {\n                  return _this.summary[uid];\n                });\n                if (invalidFormInputUIDs.length > 0) {\n                  var firstInvalid =\n                    _this.elementByUID[invalidFormInputUIDs[0]];\n                  if (firstInvalid) {\n                    firstInvalid.focus();\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              this.isValid = function (form, prevalidate, callback) {\n                if (prevalidate === void 0) {\n                  prevalidate = true;\n                }\n                if (prevalidate) {\n                  _this.validateForm(form, callback);\n                }\n                var formUID = _this.getElementUID(form);\n                var formInputUIDs = _this.formInputs[formUID];\n                var invalidFormInputUIDs = formInputUIDs.filter(function (uid) {\n                  return _this.summary[uid];\n                });\n                return invalidFormInputUIDs.length == 0;\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              this.isFieldValid = function (field, prevalidate, callback) {\n                if (prevalidate === void 0) {\n                  prevalidate = true;\n                }\n                if (prevalidate) {\n                  _this.validateField(field, callback);\n                }\n                var fieldUID = _this.getElementUID(field);\n                return _this.summary[fieldUID] === undefined;\n              };\n              /**\n               * Options for this instance of @type {ValidationService}.\n               */\n              this.options = {\n                root: document.body,\n                watch: false,\n                addNoValidate: true,\n              };\n              /**\n               * Override CSS class name for input validation error. Default: 'input-validation-error'\n               */\n              this.ValidationInputCssClassName = 'input-validation-error';\n              /**\n               * Override CSS class name for valid input validation. Default: 'input-validation-valid'\n               */\n              this.ValidationInputValidCssClassName = 'input-validation-valid';\n              /**\n               * Override CSS class name for field validation error. Default: 'field-validation-error'\n               */\n              this.ValidationMessageCssClassName = 'field-validation-error';\n              /**\n               * Override CSS class name for valid field validation. Default: 'field-validation-valid'\n               */\n              this.ValidationMessageValidCssClassName =\n                'field-validation-valid';\n              /**\n               * Override CSS class name for validation summary error. Default: 'validation-summary-errors'\n               */\n              this.ValidationSummaryCssClassName = 'validation-summary-errors';\n              /**\n               * Override CSS class name for valid validation summary. Default: 'field-validation-valid'\n               */\n              this.ValidationSummaryValidCssClassName =\n                'validation-summary-valid';\n              this.logger = logger || nullLogger;\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            ValidationService.prototype.addProvider = function (\n              name,\n              callback\n            ) {\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             * Registers the default providers for enabling ASP.NET Core MVC client-side validation.\n             */\n            ValidationService.prototype.addMvcProviders = function () {\n              var mvc = new MvcValidationProviders();\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             * Scans document for all validation message <span> generated by ASP.NET Core MVC, then tracks them.\n             */\n            ValidationService.prototype.scanMessages = function (root, remove) {\n              if (remove === void 0) {\n                remove = false;\n              }\n              /* If a validation span explicitly declares a form, we group the span with that form. */\n              var validationMessageElements = Array.from(\n                root.querySelectorAll('span[form]')\n              );\n              for (\n                var _i = 0,\n                  validationMessageElements_1 = validationMessageElements;\n                _i < validationMessageElements_1.length;\n                _i++\n              ) {\n                var span = validationMessageElements_1[_i];\n                var 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              // Otherwise if a validation message span is inside a form, we group the span with the form it's inside.\n              var forms = Array.from(root.querySelectorAll('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              var containingForm =\n                root instanceof Element ? root.closest('form') : null;\n              if (containingForm) {\n                forms.push(containingForm);\n              }\n              for (var _a = 0, forms_1 = forms; _a < forms_1.length; _a++) {\n                var form = forms_1[_a];\n                var validationMessageElements_3 = Array.from(\n                  form.querySelectorAll('[data-valmsg-for]')\n                );\n                for (\n                  var _b = 0,\n                    validationMessageElements_2 = validationMessageElements_3;\n                  _b < validationMessageElements_2.length;\n                  _b++\n                ) {\n                  var span = validationMessageElements_2[_b];\n                  if (remove) {\n                    this.removeValidationMessageSpan(form, span);\n                  } else {\n                    this.pushValidationMessageSpan(form, span);\n                  }\n                }\n              }\n            };\n            ValidationService.prototype.pushValidationMessageSpan = function (\n              form,\n              span\n            ) {\n              var formId = this.getElementUID(form);\n              var name = ''\n                .concat(formId, ':')\n                .concat(span.getAttribute('data-valmsg-for'));\n              var spans = this.messageFor[name] || (this.messageFor[name] = []);\n              if (spans.indexOf(span) < 0) {\n                spans.push(span);\n              } else {\n                this.logger.log(\n                  \"Validation element for '%s' is already tracked\",\n                  name,\n                  span\n                );\n              }\n            };\n            ValidationService.prototype.removeValidationMessageSpan = function (\n              form,\n              span\n            ) {\n              var formId = this.getElementUID(form);\n              var name = ''\n                .concat(formId, ':')\n                .concat(span.getAttribute('data-valmsg-for'));\n              var spans = this.messageFor[name];\n              if (!spans) {\n                return;\n              }\n              var index = spans.indexOf(span);\n              if (index >= 0) {\n                spans.splice(index, 1);\n              } else {\n                this.logger.log(\n                  \"Validation element for '%s' was already removed\",\n                  name,\n                  span\n                );\n              }\n            };\n            /**\n             * Given attribute map for an HTML input, returns the validation directives to be executed.\n             * @param attributes\n             */\n            ValidationService.prototype.parseDirectives = function (\n              attributes\n            ) {\n              var directives = {};\n              var validationAtributes = {};\n              var cut = 'data-val-'.length;\n              for (var i = 0; i < attributes.length; i++) {\n                var a = attributes[i];\n                if (a.name.indexOf('data-val-') === 0) {\n                  var key = a.name.substr(cut);\n                  validationAtributes[key] = a.value;\n                }\n              }\n              var _loop_1 = function (key) {\n                if (key.indexOf('-') === -1) {\n                  var parameters = Object.keys(validationAtributes).filter(\n                    function (Q) {\n                      return Q !== key && Q.indexOf(key) === 0;\n                    }\n                  );\n                  var directive = {\n                    error: validationAtributes[key],\n                    params: {},\n                  };\n                  var pcut = (key + '-').length;\n                  for (var i = 0; i < parameters.length; i++) {\n                    var pvalue = validationAtributes[parameters[i]];\n                    var pkey = parameters[i].substr(pcut);\n                    directive.params[pkey] = pvalue;\n                  }\n                  directives[key] = directive;\n                }\n              };\n              for (var key in validationAtributes) {\n                _loop_1(key);\n              }\n              return directives;\n            };\n            /**\n             *  Returns an RFC4122 version 4 compliant GUID.\n             */\n            ValidationService.prototype.guid4 = function () {\n              // (c) broofa, MIT Licensed\n              // https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript/2117523#2117523\n              return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(\n                /[xy]/g,\n                function (c) {\n                  var r = (Math.random() * 16) | 0,\n                    v = c == 'x' ? r : (r & 0x3) | 0x8;\n                  return v.toString(16);\n                }\n              );\n            };\n            /**\n             * Gets a UID for an DOM element.\n             * @param node\n             */\n            ValidationService.prototype.getElementUID = function (node) {\n              var x = this.elementUIDs.filter(function (e) {\n                return e.node === node;\n              })[0];\n              if (x) {\n                return x.uid;\n              }\n              var uid = this.guid4();\n              this.elementUIDs.push({\n                node: node,\n                uid: uid,\n              });\n              this.elementByUID[uid] = node;\n              return uid;\n            };\n            /**\n             * Returns a Promise that returns validation result for each and every inputs within the form.\n             * @param formUID\n             */\n            ValidationService.prototype.getFormValidationTask = function (\n              formUID\n            ) {\n              var formInputUIDs = this.formInputs[formUID];\n              if (!formInputUIDs || formInputUIDs.length === 0) {\n                return Promise.resolve(true);\n              }\n              var formValidators = [];\n              for (var i = 0; i < formInputUIDs.length; i++) {\n                var inputUID = formInputUIDs[i];\n                var validator = this.validators[inputUID];\n                if (validator) {\n                  formValidators.push(validator);\n                }\n              }\n              var tasks = formValidators.map(function (factory) {\n                return factory();\n              });\n              return Promise.all(tasks).then(function (result) {\n                return result.every(function (e) {\n                  return e;\n                });\n              });\n            };\n            // Retrieves the validation span for the input.\n            ValidationService.prototype.getMessageFor = function (input) {\n              if (!input.form) {\n                return [];\n              }\n              var formId = this.getElementUID(input.form);\n              var name = ''.concat(formId, ':').concat(input.name);\n              return this.messageFor[name];\n            };\n            /**\n             * Returns true if the event triggering the form submission indicates we should validate the form.\n             * @param e\n             */\n            ValidationService.prototype.shouldValidate = function (e) {\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             * 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            ValidationService.prototype.trackFormInput = function (\n              form,\n              inputUID\n            ) {\n              var _this = this;\n              var formUID = this.getElementUID(form);\n              if (!this.formInputs[formUID]) {\n                this.formInputs[formUID] = [];\n              }\n              var add = this.formInputs[formUID].indexOf(inputUID) === -1;\n              if (add) {\n                this.formInputs[formUID].push(inputUID);\n                if (this.options.addNoValidate) {\n                  this.logger.log('Setting novalidate on form', form);\n                  form.setAttribute('novalidate', 'novalidate');\n                } else {\n                  this.logger.log('Not setting novalidate on form', form);\n                }\n              } else {\n                this.logger.log(\n                  \"Form input for UID '%s' is already tracked\",\n                  inputUID\n                );\n              }\n              if (this.formEvents[formUID]) {\n                return;\n              }\n              var validating = false;\n              var cb = function (e, callback) {\n                // Prevent recursion\n                if (validating) {\n                  return;\n                }\n                if (!_this.shouldValidate(e)) {\n                  return;\n                }\n                var validate = _this.getFormValidationTask(formUID);\n                if (!validate) {\n                  return;\n                }\n                //`preValidate` typically prevents submit before validation\n                if (e) {\n                  _this.preValidate(e);\n                }\n                validating = true;\n                _this.logger.log('Validating', form);\n                validate\n                  .then(function (success) {\n                    return __awaiter(_this, void 0, void 0, function () {\n                      var validationEvent;\n                      return __generator(this, function (_a) {\n                        switch (_a.label) {\n                          case 0:\n                            this.logger.log(\n                              'Validated (success = %s)',\n                              success,\n                              form\n                            );\n                            if (callback) {\n                              callback(success);\n                              return [2 /*return*/];\n                            }\n                            validationEvent = new CustomEvent('validation', {\n                              detail: { valid: success },\n                            });\n                            form.dispatchEvent(validationEvent);\n                            // Firefox fix: redispatch 'submit' after finished handling this event\n                            return [\n                              4 /*yield*/,\n                              new Promise(function (resolve) {\n                                return setTimeout(resolve, 0);\n                              }),\n                            ];\n                          case 1:\n                            // Firefox fix: redispatch 'submit' after finished handling this event\n                            _a.sent();\n                            this.handleValidated(form, success, e);\n                            return [2 /*return*/];\n                        }\n                      });\n                    });\n                  })\n                  .catch(function (error) {\n                    _this.logger.log('Validation error', error);\n                  })\n                  .finally(function () {\n                    validating = false;\n                  });\n              };\n              form.addEventListener('submit', cb);\n              form.addEventListener('reset', function (e) {\n                var uids = _this.formInputs[formUID];\n                for (var _i = 0, uids_1 = uids; _i < uids_1.length; _i++) {\n                  var uid = uids_1[_i];\n                  var input = _this.elementByUID[uid];\n                  if (\n                    input.classList.contains(_this.ValidationInputCssClassName)\n                  ) {\n                    input.classList.remove(_this.ValidationInputCssClassName);\n                  }\n                  if (\n                    input.classList.contains(\n                      _this.ValidationInputValidCssClassName\n                    )\n                  ) {\n                    input.classList.remove(\n                      _this.ValidationInputValidCssClassName\n                    );\n                  }\n                  var spans = _this.getMessageFor(input);\n                  if (spans) {\n                    for (var i = 0; i < spans.length; i++) {\n                      spans[i].innerHTML = '';\n                    }\n                  }\n                  delete _this.summary[uid];\n                }\n                _this.renderSummary();\n              });\n              this.formEvents[formUID] = cb;\n            };\n            ValidationService.prototype.untrackFormInput = function (\n              form,\n              inputUID\n            ) {\n              var formUID = this.getElementUID(form);\n              if (!this.formInputs[formUID]) {\n                return;\n              }\n              var indexToRemove = this.formInputs[formUID].indexOf(inputUID);\n              if (indexToRemove >= 0) {\n                this.formInputs[formUID].splice(indexToRemove, 1);\n              } else {\n                this.logger.log(\n                  \"Form input for UID '%s' was already removed\",\n                  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            ValidationService.prototype.addInput = function (input) {\n              var _this = this;\n              var uid = this.getElementUID(input);\n              var directives = this.parseDirectives(input.attributes);\n              this.validators[uid] = this.createValidator(input, directives);\n              if (input.form) {\n                this.trackFormInput(input.form, uid);\n              }\n              if (this.inputEvents[uid]) {\n                return;\n              }\n              var debounceTimeoutID = 0;\n              var cb = function (e, callback) {\n                var validate = _this.validators[uid];\n                clearTimeout(debounceTimeoutID);\n                debounceTimeoutID = setTimeout(function () {\n                  validate()\n                    .then(callback)\n                    .catch(function (error) {\n                      _this.logger.log('Validation error', error);\n                    });\n                }, _this.debounce);\n              };\n              var validateEvent = input.dataset.valEvent;\n              if (validateEvent) {\n                input.addEventListener(validateEvent, cb);\n              } else {\n                var eventType =\n                  input instanceof HTMLSelectElement ? 'change' : 'input';\n                input.addEventListener(eventType, cb);\n              }\n              this.inputEvents[uid] = cb;\n            };\n            ValidationService.prototype.removeInput = function (input) {\n              var uid = this.getElementUID(input);\n              delete this.summary[uid];\n              delete this.inputEvents[uid];\n              delete this.validators[uid];\n              if (input.form) {\n                this.untrackFormInput(input.form, uid);\n              }\n            };\n            /**\n             * Scans the entire document for input elements to be validated.\n             */\n            ValidationService.prototype.scanInputs = function (root, remove) {\n              if (remove === void 0) {\n                remove = false;\n              }\n              var inputs = Array.from(\n                root.querySelectorAll(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 (\n                isValidatable(root) &&\n                root.getAttribute('data-val') === 'true'\n              ) {\n                inputs.push(root);\n              }\n              for (var i = 0; i < inputs.length; i++) {\n                var input = inputs[i];\n                if (remove) {\n                  this.removeInput(input);\n                } else {\n                  this.addInput(input);\n                }\n              }\n            };\n            /**\n             * Returns a <ul> element as a validation errors summary.\n             */\n            ValidationService.prototype.createSummaryDOM = function () {\n              if (!Object.keys(this.summary).length) {\n                return null;\n              }\n              var renderedMessages = [];\n              var ul = document.createElement('ul');\n              for (var 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                var matchingElement = this.elementByUID[key];\n                if (matchingElement instanceof HTMLInputElement) {\n                  if (\n                    matchingElement.type === 'checkbox' ||\n                    matchingElement.type === 'radio'\n                  ) {\n                    if (\n                      matchingElement.className ===\n                      this.ValidationInputValidCssClassName\n                    ) {\n                      continue;\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                var 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             * Displays validation summary to ASP.NET Core MVC designated elements, when it actually gets updated.\n             */\n            ValidationService.prototype.renderSummary = function () {\n              var summaryElements = document.querySelectorAll(\n                '[data-valmsg-summary=\"true\"]'\n              );\n              if (!summaryElements.length) {\n                return;\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              var shadow = JSON.stringify(\n                this.summary,\n                Object.keys(this.summary).sort()\n              );\n              if (shadow === this.renderedSummaryJSON) {\n                return;\n              }\n              // Prevents wasteful re-rendering of summary list element with identical items!\n              this.renderedSummaryJSON = shadow;\n              var ul = this.createSummaryDOM();\n              for (var i = 0; i < summaryElements.length; i++) {\n                var e = summaryElements[i];\n                // Remove existing list elements, but keep the summary's message.\n                var listElements = e.querySelectorAll('ul');\n                for (var j = 0; j < listElements.length; j++) {\n                  listElements[j].remove();\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(\n                    e,\n                    this.ValidationSummaryCssClassName,\n                    this.ValidationSummaryValidCssClassName\n                  );\n                  e.appendChild(ul.cloneNode(true));\n                } else {\n                  this.swapClasses(\n                    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            ValidationService.prototype.addError = function (input, message) {\n              var spans = this.getMessageFor(input);\n              if (spans) {\n                for (var i = 0; i < spans.length; i++) {\n                  var span = spans[i];\n                  spans[i].innerHTML = message;\n                  this.swapClasses(\n                    spans[i],\n                    this.ValidationMessageCssClassName,\n                    this.ValidationMessageValidCssClassName\n                  );\n                }\n              }\n              this.swapClasses(\n                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                var inputs = input.form.querySelectorAll(\n                  validatableSelector('[name=\"'.concat(input.name, '\"]'))\n                );\n                for (var i = 0; i < inputs.length; i++) {\n                  this.swapClasses(\n                    inputs[i],\n                    this.ValidationInputCssClassName,\n                    this.ValidationInputValidCssClassName\n                  );\n                  var uid = this.getElementUID(inputs[i]);\n                  this.summary[uid] = message;\n                }\n              }\n              this.renderSummary();\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            ValidationService.prototype.removeError = function (input) {\n              var spans = this.getMessageFor(input);\n              if (spans) {\n                for (var i = 0; i < spans.length; i++) {\n                  spans[i].innerHTML = '';\n                  this.swapClasses(\n                    spans[i],\n                    this.ValidationMessageValidCssClassName,\n                    this.ValidationMessageCssClassName\n                  );\n                }\n              }\n              this.swapClasses(\n                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                var inputs = input.form.querySelectorAll(\n                  validatableSelector('[name=\"'.concat(input.name, '\"]'))\n                );\n                for (var i = 0; i < inputs.length; i++) {\n                  this.swapClasses(\n                    inputs[i],\n                    this.ValidationInputValidCssClassName,\n                    this.ValidationInputCssClassName\n                  );\n                  var uid = this.getElementUID(inputs[i]);\n                  delete this.summary[uid];\n                }\n              }\n              this.renderSummary();\n            };\n            /**\n             * Returns a validation Promise factory for an input element, using given validation directives.\n             * @param input\n             * @param directives\n             */\n            ValidationService.prototype.createValidator = function (\n              input,\n              directives\n            ) {\n              var _this = this;\n              return function () {\n                return __awaiter(_this, void 0, void 0, function () {\n                  var _a,\n                    _b,\n                    _c,\n                    _i,\n                    key,\n                    directive,\n                    provider,\n                    result,\n                    valid,\n                    error,\n                    resolution;\n                  return __generator(this, function (_d) {\n                    switch (_d.label) {\n                      case 0:\n                        if (!!this.isHidden(input)) return [3 /*break*/, 7];\n                        _a = directives;\n                        _b = [];\n                        for (_c in _a) _b.push(_c);\n                        _i = 0;\n                        _d.label = 1;\n                      case 1:\n                        if (!(_i < _b.length)) return [3 /*break*/, 7];\n                        _c = _b[_i];\n                        if (!(_c in _a)) return [3 /*break*/, 6];\n                        key = _c;\n                        directive = directives[key];\n                        provider = this.providers[key];\n                        if (!provider) {\n                          this.logger.log(\n                            'aspnet-validation provider not implemented: %s',\n                            key\n                          );\n                          return [3 /*break*/, 6];\n                        }\n                        this.logger.log(\n                          'Running %s validator on element',\n                          key,\n                          input\n                        );\n                        result = provider(input.value, input, directive.params);\n                        valid = false;\n                        error = directive.error;\n                        if (!(typeof result === 'boolean'))\n                          return [3 /*break*/, 2];\n                        valid = result;\n                        return [3 /*break*/, 5];\n                      case 2:\n                        if (!(typeof result === 'string'))\n                          return [3 /*break*/, 3];\n                        valid = false;\n                        error = result;\n                        return [3 /*break*/, 5];\n                      case 3:\n                        return [4 /*yield*/, result];\n                      case 4:\n                        resolution = _d.sent();\n                        if (typeof resolution === 'boolean') {\n                          valid = resolution;\n                        } else {\n                          valid = false;\n                          error = resolution;\n                        }\n                        _d.label = 5;\n                      case 5:\n                        if (!valid) {\n                          this.addError(input, error);\n                          return [2 /*return*/, false];\n                        }\n                        _d.label = 6;\n                      case 6:\n                        _i++;\n                        return [3 /*break*/, 1];\n                      case 7:\n                        this.removeError(input);\n                        return [2 /*return*/, true];\n                    }\n                  });\n                });\n              };\n            };\n            /**\n             * Checks if the provided input is hidden from the browser\n             * @param input\n             * @returns\n             */\n            ValidationService.prototype.isHidden = function (input) {\n              return !(\n                this.allowHiddenFields ||\n                input.offsetWidth ||\n                input.offsetHeight ||\n                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            ValidationService.prototype.swapClasses = function (\n              element,\n              addClass,\n              removeClass\n            ) {\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             * 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            ValidationService.prototype.bootstrap = function (options) {\n              var _this = this;\n              Object.assign(this.options, options);\n              this.addMvcProviders();\n              var document = window.document;\n              var root = this.options.root;\n              var init = function () {\n                _this.scan(root);\n                // Watch for further mutations after initial scan\n                if (_this.options.watch) {\n                  _this.watch(root);\n                }\n              };\n              // If the document is done loading, scan it now.\n              if (\n                document.readyState === 'complete' ||\n                document.readyState === 'interactive'\n              ) {\n                init();\n              } else {\n                // Otherwise wait until the document is done loading.\n                document.addEventListener('DOMContentLoaded', init);\n              }\n            };\n            /**\n             * Scans the provided root element for any validation directives and attaches behavior to them.\n             */\n            ValidationService.prototype.scan = function (root) {\n              this.logger.log('Scanning', root);\n              this.scanMessages(root);\n              this.scanInputs(root);\n            };\n            /**\n             * Scans the provided root element for any validation directives and removes behavior from them.\n             */\n            ValidationService.prototype.remove = function (root) {\n              this.logger.log('Removing', root);\n              this.scanMessages(root, true);\n              this.scanInputs(root, true);\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            ValidationService.prototype.watch = function (root) {\n              var _this = this;\n              this.observer = new MutationObserver(function (mutations) {\n                mutations.forEach(function (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            ValidationService.prototype.observed = function (mutation) {\n              var _a, _b, _c;\n              if (mutation.type === 'childList') {\n                for (var i = 0; i < mutation.addedNodes.length; i++) {\n                  var node = mutation.addedNodes[i];\n                  this.logger.log('Added node', node);\n                  if (node instanceof HTMLElement) {\n                    this.scan(node);\n                  }\n                }\n                for (var i = 0; i < mutation.removedNodes.length; i++) {\n                  var 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                  var oldValue =\n                    (_a = mutation.oldValue) !== null && _a !== void 0\n                      ? _a\n                      : '';\n                  var newValue =\n                    (_c =\n                      (_b =\n                        mutation.target.attributes[mutation.attributeName]) ===\n                        null || _b === void 0\n                        ? void 0\n                        : _b.value) !== null && _c !== void 0\n                      ? _c\n                      : '';\n                  this.logger.log(\n                    \"Attribute '%s' changed from '%s' to '%s'\",\n                    mutation.attributeName,\n                    oldValue,\n                    newValue,\n                    mutation.target\n                  );\n                  if (oldValue !== newValue) {\n                    this.scan(mutation.target);\n                  }\n                }\n              }\n            };\n            return ValidationService;\n          })();\n\n          /***/\n        },\n\n      /******/\n    }\n  );\n});\n"]}