{"version":3,"sources":["webpack:///./src/Feature/WFFMCustomizations/platform/app/parsleyjs/parsleyjs.overrides.ts","webpack:///./src/Feature/WFFMCustomizations/platform/app/parsleyjs/index.ts","webpack:///./src/Feature/WFFMCustomizations/platform/app/compatibility-guide/utils/clear-select-options.ts","webpack:///./src/Feature/WFFMCustomizations/platform/app/compatibility-guide/index.ts","webpack:///./src/Feature/WFFMCustomizations/platform/app/compatibility-guide/compatibility-guide.ts","webpack:///./src/Feature/WFFMCustomizations/platform/app/country-selector/country-selector.ts","webpack:///./src/Feature/WFFMCustomizations/platform/app/country-selector/index.ts","webpack:///./node_modules/parsleyjs/dist/parsley.js","webpack:///./src/Feature/WFFMCustomizations/platform/app/defer.ts"],"names":["submitButtonSelector","buttonsLoadingCssClass","$","parsley","Parsley","on","this","$element","find","prop","removeClass","addClass","manufacturersFields","document","querySelectorAll","length","Array","prototype","forEach","call","manufacturersField","manufacturerSelect","querySelector","formElement","parentNode","manufacturerTypes","dataset","cgTypes","manufacturersUrl","productApiConfig","compatibilityGuideUrl","manufacturersXhr","XMLHttpRequest","open","send","onreadystatechange","readyState","status","JSON","parse","responseText","manufacturer","option","createElement","manufacturerId","id","appendChild","createTextNode","name","value","modelsElement","modelsSelect","addEventListener","selectedManufacturerOption","options","selectedIndex","select","start","i","clearSelectOptions","disabled","models","model","style","display","bootstrap","countrySelectorElements","each","index","countrySelectorElement","countryStatesElement","getElementById","getAttribute","lastSelectedCountry","lastSelectedCountryIndex","countryStates","innerHTML","countryStatesElementId","removeChild","$countrySelectorElement","selectedCountry","countryWithStates","filter","c","IsoCode","undefined","countryStatesElements","destroy","off","remove","states","States","statesSelectorHtml","replace","state","CountryStateName","after","$countryStatesElement","countryStatesElementValue","val","trigger","factory","_typeof","obj","Symbol","iterator","constructor","_extends","Object","assign","target","arguments","source","key","hasOwnProperty","apply","_slicedToArray","arr","isArray","_arrayWithHoles","_arr","_n","_d","_e","_s","_i","next","done","push","err","_iterableToArrayLimit","TypeError","_nonIterableRest","_toConsumableArray","arr2","_arrayWithoutHoles","iter","toString","from","_iterableToArray","_nonIterableSpread","globalID","pastWarnings","Utils","attr","element","namespace","attribute","attributes","regex","RegExp","specified","test","camelize","slice","deserializeValue","checkAttr","_checkAttr","hasAttribute","setAttr","setAttribute","dasherize","String","getType","generateID","num","isNaN","Number","e","str","match","chr","toUpperCase","toLowerCase","warn","_window$console","window","console","warnOnce","msg","_resetWarnings","trimString","string","date","parsed","_parsed$map2","map","x","parseInt","year","month","day","Date","getFullYear","getMonth","getDate","_string","integer","number","parseFloat","object","regexp","_regexp","flags","parseRequirement","requirementType","converter","converted","concat","namespaceEvents","events","split","evt","join","difference","array","result","_","elem","indexOf","all","promises","when","objectCreate","create","Error","_SubmitSelector","Defaults","inputs","excluded","priorityEnabled","multiple","group","uiEnabled","validationThreshold","focus","triggerAfterFailure","errorClass","successClass","classHandler","Field","errorsContainer","errorsWrapper","errorTemplate","Base","__id__","asyncSupport","_pipeAccordingToValidationResult","_this","pipe","r","Deferred","validationResult","reject","resolve","promise","actualizeOptions","domOptions","parent","_resetOptions","initOptions","_listeners","fn","subscribe","listenTo","queue","splice","unsubscribe","unsubscribeTo","extraArg","asyncIsValid","force","whenValid","_findRelated","Validator","spec","extend","validate","requirementFirstArg","validateMultiple","instance","validateDate","_isDateInput","validateNumber","validateString","parseRequirements","requirements","extraOptionReader","type","values","m","convertArrayRequirement","isPlainObject","requirementSpec","main","extra","convertExtraOptionRequirement","priority","ValidatorRegistry","validators","catalog","__class__","locale","init","typeTesters","email","digits","alphanum","url","range","decimalPlaces","Math","max","operatorToValidator","operator","_len","requirementsAndInput","_key","pop","args","parseArguments","comparisonOperator","addValidator","setLocale","addCatalog","messages","set","addMessage","message","addMessages","nameMessageObject","arg1","arg2","_setValidator","hasValidator","updateValidator","removeValidator","validator","getErrorMessage","constraint","formatMessage","defaultMessage","en","parameters","notblank","required","_ref","_ref$step","step","_ref$base","base","tester","nb","decimals","toInt","f","round","pow","pattern","minlength","requirement","maxlength","min","mincheck","maxcheck","check","equalto","refOrValue","$reference","euvatin","UI","diffResults","newResult","oldResult","deep","added","kept","found","j","assert","removed","Form","_actualizeTriggers","onSubmitValidate","onSubmitButton","_focusedField","fields","field","noFocus","_destroyUI","_reflowUI","_buildUI","_ui","diff","lastValidationResult","_manageStatusClass","_manageErrorsMessages","_failedOnce","getErrorsMessages","errorMessage","_getErrorMessage","addError","_ref$updateClass","updateClass","_addError","_errorClass","updateError","_ref2","_ref2$updateClass","_updateError","removeError","_ref3$updateClass","_removeError","hasConstraints","needsValidation","_successClass","_resetClass","errorsMessagesDisabled","_insertErrorWrapper","$errorsWrapper","append","html","_ref4","$errorClassHandler","errorsWrapperId","_ref5","removeAttr","customConstraintErrorMessage","_manageClassHandler","validationInformationVisible","$handlerFunction","$handler","jQuery","_inputHolder","nodeName","$errorsContainer","_this2","$toBind","_validateIfNeeded","event","_this3","getValue","debounce","clearTimeout","_debounced","setTimeout","_resetUI","children","statusMapping","pending","resolved","rejected","submitSource","_submitSource","_remoteCache","whenValidate","_trigger","stopImmediatePropagation","preventDefault","_submit","currentTarget","$synthetic","appendTo","Event","_arguments","_Utils$all$done$fail$","submitEvent","_refreshFields","_withoutReactualizingFormOptions","fail","always","isValid","_arguments2","refresh","reset","removeData","_bindFields","_this4","oldFields","fieldsMappedById","not","fieldInstance","Factory","uniqueId","oldActualizeOptions","eventName","Constraint","parsleyField","isDomConstraint","validatorSpec","_validatorRegistry","_parseRequirements","_this$validator","requirementList","parsleyFormInstance","constraints","constraintsByName","_bindConstraints","statusMapping$1","_this$whenValid$alway","_isInGroup","_refreshed","_isRequired","validateIfEmpty","inArray","_ref2$force","groupedConstraints","_getGroupedConstraints","_validateConstraint","_handleWhitespace","_refreshConstraints","refreshConstraints","addConstraint","removeConstraint","updateConstraint","_bindHtml5Constraints","trimValue","whitespace","p","sort","a","b","Multiple","addElement","$elements","fieldConstraints","has","data","_init","savedparsleyFormInstance","__version__","is","bind","isMultiple","handleMultiple","parsleyMultipleInstance","input","$previouslyRelated","get","doNotStore","parsleyInstance","ParsleyExtend","vernums","jquery","version","psly","instances","ParsleyConfig","ParsleyUtils","registry","i18n","ParsleyValidator","method","_window$Parsley","ParsleyUI","doNotUpdateClass","autoBind","o","deprecated","adapt","context","parsleyAdaptedCallback","unshift","eventPrefix","lastIndexOf","substr","listen","callback","unsubscribeAll","emit","_instance","instanceGiven","asyncValidators","xhr","reverse","addAsyncValidator","ajaxOptions","csr","encodeURIComponent","remoteOptions","param","ajax","handleXhr","then","globals","global","isNativeEvent","originalEvent","isTrusted","fakeInputEvent","misbehaves","behavesOk","selector","install","inputEventPatched","uninstall","module","exports","deferFn","raf","parser","DOMParser","deferredElements","deferredElement","innerHtml","trim","parsedDocument","parseFromString","head","getElementsByTagName","documentElement","childNodes","script","tagName","dtoScript","defer","async","insertBefore","firstChild","deferScripts","linkElement","textContent","insertAdjacentHTML","deferLinks","requestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","msRequestAnimationFrame"],"mappings":"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","file":"7.425cb26b63a284c97462.js","sourcesContent":["import { ParsleyJsFormEvent } from './enums/parsleyjs-form-event.enum';\r\n\r\ndeclare var Parsley: { on: (eventName: string, callback: () => void) => void; };\r\n\r\nconst submitButtonSelector = 'button[type=\"submit\"]';\r\nconst buttonsLoadingCssClass = 'jbr-btn--loading';\r\n\r\n/**\r\n * Overrides ParsleyJS standard behaviour,\r\n */\r\nexport function overrideParsleyJS() {\r\n  Parsley?.on(ParsleyJsFormEvent.Validate, function() {\r\n    this.$element\r\n      .find(submitButtonSelector)\r\n      .prop('disabled', true);\r\n  });\r\n\r\n  Parsley?.on(ParsleyJsFormEvent.Error, function() {\r\n    this.$element\r\n      .find(submitButtonSelector)\r\n      .prop('disabled', false)\r\n      .removeClass(buttonsLoadingCssClass);\r\n  });\r\n\r\n  Parsley?.on(ParsleyJsFormEvent.Success, function() {\r\n    this.$element\r\n      .find(submitButtonSelector)\r\n      .addClass(buttonsLoadingCssClass);\r\n  });\r\n}\r\n","import 'parsleyjs';\r\nimport { overrideParsleyJS } from './parsleyjs.overrides';\r\n\r\n(() => {\r\n  // Bind parsleyjs to necessary elements.\r\n  ($('[data-parsley-validate]') as any).parsley();\r\n  // Override default behaviour of parsleyjs.\r\n  overrideParsleyJS();\r\n})();\r\n","\r\n/**\r\n * Deletes select options from the element\r\n * @param select HTML select element to clear options for\r\n * @param start Index to start deleting of the options from\r\n */\r\nexport const clearSelectOptions = (select: HTMLSelectElement, start = 0) => {\r\n  const length = select.options.length;\r\n  for (let i = length - 1; i >= start; i--) {\r\n    select.options[i] = null;\r\n  }\r\n};\r\n","import { bootstrap } from './compatibility-guide';\r\n\r\n(() => {\r\n  const manufacturersFields: NodeListOf<HTMLElement> = document.querySelectorAll('.cg-manufacturers');\r\n  if (manufacturersFields.length === 0) {\r\n    return;\r\n  }\r\n\r\n  // Bootstrap compatibility guide dropdowns.\r\n  bootstrap(manufacturersFields);\r\n})();\r\n","import { CompatibilityGuideBootstrap } from './models/compatibility-guide-bootstrap';\r\nimport { clearSelectOptions } from './utils/clear-select-options';\r\n\r\ndeclare var productApiConfig: any;\r\n\r\nexport const bootstrap: CompatibilityGuideBootstrap = (manufacturersFields: NodeListOf<HTMLElement>) => {\r\n  Array.prototype.forEach.call(manufacturersFields, (manufacturersField: HTMLElement) => {\r\n    const manufacturerSelect: HTMLSelectElement = manufacturersField.querySelector('select');\r\n    const formElement = manufacturersField.parentNode.parentNode;\r\n\r\n    const manufacturerTypes = manufacturerSelect.dataset.cgTypes;\r\n    const manufacturersUrl = productApiConfig.compatibilityGuideUrl + 'api/manufacturer?types=' + manufacturerTypes;\r\n    const manufacturersXhr = new XMLHttpRequest();\r\n    manufacturersXhr.open('GET', manufacturersUrl, true);\r\n    manufacturersXhr.send();\r\n    manufacturersXhr.onreadystatechange = () => {\r\n      if (manufacturersXhr.readyState !== 4 || manufacturersXhr.status !== 200) {\r\n        return;\r\n      }\r\n\r\n      const manufacturers = JSON.parse(manufacturersXhr.responseText);\r\n      manufacturers.forEach((manufacturer: { id: string; name: string; }) => {\r\n        const option: HTMLOptionElement = document.createElement('option');\r\n        option.dataset.manufacturerId = manufacturer.id;\r\n        option.appendChild(document.createTextNode(manufacturer.name));\r\n        option.value = manufacturer.name;\r\n        manufacturerSelect.appendChild(option);\r\n      });\r\n    };\r\n\r\n    const modelsElement: HTMLElement | null = formElement.querySelector('.cg-models');\r\n    if (modelsElement === null) {\r\n      return;\r\n    }\r\n\r\n    const modelsSelect: HTMLSelectElement = modelsElement.querySelector('select');\r\n    manufacturerSelect.addEventListener('change', () => {\r\n      const selectedManufacturerOption = manufacturerSelect.options[manufacturerSelect.selectedIndex];\r\n      clearSelectOptions(modelsSelect, 1);\r\n\r\n      if (selectedManufacturerOption.value !== '') {\r\n        manufacturerSelect.disabled = true;\r\n        modelsSelect.disabled = true;\r\n        const modelsXhr = new XMLHttpRequest();\r\n        modelsXhr.open('GET', productApiConfig.compatibilityGuideUrl + 'api/manufacturer/' + selectedManufacturerOption.dataset.manufacturerId + '?types=' + manufacturerTypes);\r\n        modelsXhr.send();\r\n        modelsXhr.onreadystatechange = () => {\r\n          if (modelsXhr.readyState !== 4 || modelsXhr.status !== 200) {\r\n            return;\r\n          }\r\n\r\n          const models = JSON.parse(modelsXhr.responseText);\r\n          Array.prototype.forEach.call(models, (model: { name: string; }) => {\r\n            const option: HTMLOptionElement = document.createElement('option');\r\n            option.appendChild(document.createTextNode(model.name));\r\n            option.value = model.name;\r\n            modelsSelect.appendChild(option);\r\n          });\r\n\r\n          manufacturerSelect.disabled = false;\r\n          modelsSelect.disabled = false;\r\n          modelsElement.style.display = 'block';\r\n        };\r\n      } else {\r\n        modelsSelect.disabled = false;\r\n        modelsElement.style.display = 'none';\r\n      }\r\n    });\r\n  });\r\n};\r\n","import { CountrySelectorBootstrap } from './models/country-selector-bootstrap';\r\n\r\nexport const bootstrap: CountrySelectorBootstrap = (countrySelectorElements: JQuery) => {\r\n  countrySelectorElements.each((index: number, countrySelectorElement: HTMLSelectElement) => {\r\n    const countryStatesElement = document.getElementById(countrySelectorElement.getAttribute('states-json-id'));\r\n\r\n    if (countryStatesElement === null) {\r\n      return;\r\n    }\r\n\r\n    const countryStates: any[] = JSON.parse(countryStatesElement.innerHTML);\r\n    const countryStatesElementId = countrySelectorElement.getAttribute('states-list-id');\r\n    let lastSelectedCountry: string;\r\n    let lastSelectedCountryIndex: number;\r\n\r\n    countryStatesElement.parentNode.removeChild(countryStatesElement);\r\n    const $countrySelectorElement: JQuery = $(`#${countrySelectorElement.getAttribute('id')}`);\r\n    $countrySelectorElement.on('change', () => {\r\n      const selectedCountry = countrySelectorElement.value;\r\n      const countryWithStates = countryStates.filter((c: any) => c.IsoCode === selectedCountry)[0];\r\n\r\n      if (lastSelectedCountry !== undefined) {\r\n        countrySelectorElement.options[lastSelectedCountryIndex].value = lastSelectedCountry;\r\n      }\r\n\r\n      lastSelectedCountry = selectedCountry;\r\n      lastSelectedCountryIndex = countrySelectorElement.selectedIndex;\r\n      const countryStatesElements: JQuery = $(`#${countryStatesElementId}`);\r\n      if (countryStatesElements.length > 0 && (countryStatesElements as any).parsley) {\r\n        (countryStatesElements as any).parsley().destroy();\r\n      }\r\n\r\n      countryStatesElements.off().remove();\r\n      if (!countryWithStates) {\r\n        return;\r\n      }\r\n\r\n      const states = countryWithStates.States;\r\n      let statesSelectorHtml = '<select id=\"{0}\" {1} {2} class=\"jbr-form__input jbr-form__input--dropdown\" style=\"margin-top: 9px;\" name=\"{3}\">'\r\n        .replace(/\\{0\\}/gi, countryStatesElementId)\r\n        .replace(/\\{1\\}/gi, 'required')\r\n        .replace(/\\{2\\}/gi, 'data-parsley-error-message=\"' + countrySelectorElement.getAttribute('states-required-message') + '\"')\r\n        .replace(/\\{3\\}/gi, countrySelectorElement.getAttribute('name'));\r\n      statesSelectorHtml += '<option value>' + countrySelectorElement.getAttribute('states-list-empty-option') + '</option>';\r\n      for (const state of states) {\r\n        statesSelectorHtml += `<option value=\"${selectedCountry}-${state.IsoCode}\">${state.CountryStateName}</option>`;\r\n      }\r\n\r\n      statesSelectorHtml += '</select>';\r\n      $countrySelectorElement.after(statesSelectorHtml);\r\n\r\n      const $countryStatesElement = $(`#${countryStatesElementId}`);\r\n      $countryStatesElement.on('change', () => {\r\n        const countryStatesElementValue = $countryStatesElement.val() as string;\r\n        if (countryStatesElementValue === '') {\r\n          countrySelectorElement.options[countrySelectorElement.selectedIndex].value = selectedCountry;\r\n        } else {\r\n          countrySelectorElement.options[countrySelectorElement.selectedIndex].value = countryStatesElementValue;\r\n        }\r\n      });\r\n\r\n      if (($countryStatesElement as any).parsley) {\r\n        ($countryStatesElement as any).parsley();\r\n      }\r\n    });\r\n\r\n    // Trigger change event because country list could be pre-selected from Sitecore.\r\n    $countrySelectorElement.trigger('change');\r\n  });\r\n};\r\n","import { bootstrap } from './country-selector';\r\n\r\n(() => {\r\n  const countrySelectorElements: JQuery = $('[states-json-id]');\r\n  if (countrySelectorElements.length === 0) {\r\n    return;\r\n  }\r\n\r\n  // Bootstrap country selector dropdowns.\r\n  bootstrap(countrySelectorElements);\r\n})();\r\n","/*!\n* Parsley.js\n* Version 2.9.0 - built Wed, Apr 10th 2019, 4:18 pm\n* http://parsleyjs.org\n* Guillaume Potier - <guillaume@wisembly.com>\n* Marc-Andre Lafortune - <petroselinum@marc-andre.ca>\n* MIT Licensed\n*/\n\n// The source code below is generated by babel as\n// Parsley is written in ECMAScript 6\n//\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery')) :\n  typeof define === 'function' && define.amd ? define(['jquery'], factory) :\n  (global.parsley = factory(global.jQuery));\n}(this, (function ($) { 'use strict';\n\n  function _typeof(obj) {\n    if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n      _typeof = function (obj) {\n        return typeof obj;\n      };\n    } else {\n      _typeof = function (obj) {\n        return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n      };\n    }\n\n    return _typeof(obj);\n  }\n\n  function _extends() {\n    _extends = Object.assign || function (target) {\n      for (var i = 1; i < arguments.length; i++) {\n        var source = arguments[i];\n\n        for (var key in source) {\n          if (Object.prototype.hasOwnProperty.call(source, key)) {\n            target[key] = source[key];\n          }\n        }\n      }\n\n      return target;\n    };\n\n    return _extends.apply(this, arguments);\n  }\n\n  function _slicedToArray(arr, i) {\n    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n  }\n\n  function _toConsumableArray(arr) {\n    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n  }\n\n  function _arrayWithoutHoles(arr) {\n    if (Array.isArray(arr)) {\n      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n      return arr2;\n    }\n  }\n\n  function _arrayWithHoles(arr) {\n    if (Array.isArray(arr)) return arr;\n  }\n\n  function _iterableToArray(iter) {\n    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n  }\n\n  function _iterableToArrayLimit(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  function _nonIterableSpread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n  }\n\n  function _nonIterableRest() {\n    throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n  }\n\n  var globalID = 1;\n  var pastWarnings = {};\n  var Utils = {\n    // Parsley DOM-API\n    // returns object from dom attributes and values\n    attr: function attr(element, namespace, obj) {\n      var i;\n      var attribute;\n      var attributes;\n      var regex = new RegExp('^' + namespace, 'i');\n      if ('undefined' === typeof obj) obj = {};else {\n        // Clear all own properties. This won't affect prototype's values\n        for (i in obj) {\n          if (obj.hasOwnProperty(i)) delete obj[i];\n        }\n      }\n      if (!element) return obj;\n      attributes = element.attributes;\n\n      for (i = attributes.length; i--;) {\n        attribute = attributes[i];\n\n        if (attribute && attribute.specified && regex.test(attribute.name)) {\n          obj[this.camelize(attribute.name.slice(namespace.length))] = this.deserializeValue(attribute.value);\n        }\n      }\n\n      return obj;\n    },\n    checkAttr: function checkAttr(element, namespace, _checkAttr) {\n      return element.hasAttribute(namespace + _checkAttr);\n    },\n    setAttr: function setAttr(element, namespace, attr, value) {\n      element.setAttribute(this.dasherize(namespace + attr), String(value));\n    },\n    getType: function getType(element) {\n      return element.getAttribute('type') || 'text';\n    },\n    generateID: function generateID() {\n      return '' + globalID++;\n    },\n\n    /** Third party functions **/\n    deserializeValue: function deserializeValue(value) {\n      var num;\n\n      try {\n        return value ? value == \"true\" || (value == \"false\" ? false : value == \"null\" ? null : !isNaN(num = Number(value)) ? num : /^[\\[\\{]/.test(value) ? JSON.parse(value) : value) : value;\n      } catch (e) {\n        return value;\n      }\n    },\n    // Zepto camelize function\n    camelize: function camelize(str) {\n      return str.replace(/-+(.)?/g, function (match, chr) {\n        return chr ? chr.toUpperCase() : '';\n      });\n    },\n    // Zepto dasherize function\n    dasherize: function dasherize(str) {\n      return str.replace(/::/g, '/').replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2').replace(/([a-z\\d])([A-Z])/g, '$1_$2').replace(/_/g, '-').toLowerCase();\n    },\n    warn: function warn() {\n      var _window$console;\n\n      if (window.console && 'function' === typeof window.console.warn) (_window$console = window.console).warn.apply(_window$console, arguments);\n    },\n    warnOnce: function warnOnce(msg) {\n      if (!pastWarnings[msg]) {\n        pastWarnings[msg] = true;\n        this.warn.apply(this, arguments);\n      }\n    },\n    _resetWarnings: function _resetWarnings() {\n      pastWarnings = {};\n    },\n    trimString: function trimString(string) {\n      return string.replace(/^\\s+|\\s+$/g, '');\n    },\n    parse: {\n      date: function date(string) {\n        var parsed = string.match(/^(\\d{4,})-(\\d\\d)-(\\d\\d)$/);\n        if (!parsed) return null;\n\n        var _parsed$map = parsed.map(function (x) {\n          return parseInt(x, 10);\n        }),\n            _parsed$map2 = _slicedToArray(_parsed$map, 4),\n            _ = _parsed$map2[0],\n            year = _parsed$map2[1],\n            month = _parsed$map2[2],\n            day = _parsed$map2[3];\n\n        var date = new Date(year, month - 1, day);\n        if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) return null;\n        return date;\n      },\n      string: function string(_string) {\n        return _string;\n      },\n      integer: function integer(string) {\n        if (isNaN(string)) return null;\n        return parseInt(string, 10);\n      },\n      number: function number(string) {\n        if (isNaN(string)) throw null;\n        return parseFloat(string);\n      },\n      'boolean': function _boolean(string) {\n        return !/^\\s*false\\s*$/i.test(string);\n      },\n      object: function object(string) {\n        return Utils.deserializeValue(string);\n      },\n      regexp: function regexp(_regexp) {\n        var flags = ''; // Test if RegExp is literal, if not, nothing to be done, otherwise, we need to isolate flags and pattern\n\n        if (/^\\/.*\\/(?:[gimy]*)$/.test(_regexp)) {\n          // Replace the regexp literal string with the first match group: ([gimy]*)\n          // If no flag is present, this will be a blank string\n          flags = _regexp.replace(/.*\\/([gimy]*)$/, '$1'); // Again, replace the regexp literal string with the first match group:\n          // everything excluding the opening and closing slashes and the flags\n\n          _regexp = _regexp.replace(new RegExp('^/(.*?)/' + flags + '$'), '$1');\n        } else {\n          // Anchor regexp:\n          _regexp = '^' + _regexp + '$';\n        }\n\n        return new RegExp(_regexp, flags);\n      }\n    },\n    parseRequirement: function parseRequirement(requirementType, string) {\n      var converter = this.parse[requirementType || 'string'];\n      if (!converter) throw 'Unknown requirement specification: \"' + requirementType + '\"';\n      var converted = converter(string);\n      if (converted === null) throw \"Requirement is not a \".concat(requirementType, \": \\\"\").concat(string, \"\\\"\");\n      return converted;\n    },\n    namespaceEvents: function namespaceEvents(events, namespace) {\n      events = this.trimString(events || '').split(/\\s+/);\n      if (!events[0]) return '';\n      return $.map(events, function (evt) {\n        return \"\".concat(evt, \".\").concat(namespace);\n      }).join(' ');\n    },\n    difference: function difference(array, remove) {\n      // This is O(N^2), should be optimized\n      var result = [];\n      $.each(array, function (_, elem) {\n        if (remove.indexOf(elem) == -1) result.push(elem);\n      });\n      return result;\n    },\n    // Alter-ego to native Promise.all, but for jQuery\n    all: function all(promises) {\n      // jQuery treats $.when() and $.when(singlePromise) differently; let's avoid that and add spurious elements\n      return $.when.apply($, _toConsumableArray(promises).concat([42, 42]));\n    },\n    // Object.create polyfill, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create#Polyfill\n    objectCreate: Object.create || function () {\n      var Object = function Object() {};\n\n      return function (prototype) {\n        if (arguments.length > 1) {\n          throw Error('Second argument not supported');\n        }\n\n        if (_typeof(prototype) != 'object') {\n          throw TypeError('Argument must be an object');\n        }\n\n        Object.prototype = prototype;\n        var result = new Object();\n        Object.prototype = null;\n        return result;\n      };\n    }(),\n    _SubmitSelector: 'input[type=\"submit\"], button:submit'\n  };\n\n  // All these options could be overriden and specified directly in DOM using\n  // `data-parsley-` default DOM-API\n  // eg: `inputs` can be set in DOM using `data-parsley-inputs=\"input, textarea\"`\n  // eg: `data-parsley-stop-on-first-failing-constraint=\"false\"`\n  var Defaults = {\n    // ### General\n    // Default data-namespace for DOM API\n    namespace: 'data-parsley-',\n    // Supported inputs by default\n    inputs: 'input, textarea, select',\n    // Excluded inputs by default\n    excluded: 'input[type=button], input[type=submit], input[type=reset], input[type=hidden]',\n    // Stop validating field on highest priority failing constraint\n    priorityEnabled: true,\n    // ### Field only\n    // identifier used to group together inputs (e.g. radio buttons...)\n    multiple: null,\n    // identifier (or array of identifiers) used to validate only a select group of inputs\n    group: null,\n    // ### UI\n    // Enable\\Disable error messages\n    uiEnabled: true,\n    // Key events threshold before validation\n    validationThreshold: 3,\n    // Focused field on form validation error. 'first'|'last'|'none'\n    focus: 'first',\n    // event(s) that will trigger validation before first failure. eg: `input`...\n    trigger: false,\n    // event(s) that will trigger validation after first failure.\n    triggerAfterFailure: 'input',\n    // Class that would be added on every failing validation Parsley field\n    errorClass: 'parsley-error',\n    // Same for success validation\n    successClass: 'parsley-success',\n    // Return the `$element` that will receive these above success or error classes\n    // Could also be (and given directly from DOM) a valid selector like `'#div'`\n    classHandler: function classHandler(Field) {},\n    // Return the `$element` where errors will be appended\n    // Could also be (and given directly from DOM) a valid selector like `'#div'`\n    errorsContainer: function errorsContainer(Field) {},\n    // ul elem that would receive errors' list\n    errorsWrapper: '<ul class=\"parsley-errors-list\"></ul>',\n    // li elem that would receive error message\n    errorTemplate: '<li></li>'\n  };\n\n  var Base = function Base() {\n    this.__id__ = Utils.generateID();\n  };\n\n  Base.prototype = {\n    asyncSupport: true,\n    // Deprecated\n    _pipeAccordingToValidationResult: function _pipeAccordingToValidationResult() {\n      var _this = this;\n\n      var pipe = function pipe() {\n        var r = $.Deferred();\n        if (true !== _this.validationResult) r.reject();\n        return r.resolve().promise();\n      };\n\n      return [pipe, pipe];\n    },\n    actualizeOptions: function actualizeOptions() {\n      Utils.attr(this.element, this.options.namespace, this.domOptions);\n      if (this.parent && this.parent.actualizeOptions) this.parent.actualizeOptions();\n      return this;\n    },\n    _resetOptions: function _resetOptions(initOptions) {\n      this.domOptions = Utils.objectCreate(this.parent.options);\n      this.options = Utils.objectCreate(this.domOptions); // Shallow copy of ownProperties of initOptions:\n\n      for (var i in initOptions) {\n        if (initOptions.hasOwnProperty(i)) this.options[i] = initOptions[i];\n      }\n\n      this.actualizeOptions();\n    },\n    _listeners: null,\n    // Register a callback for the given event name\n    // Callback is called with context as the first argument and the `this`\n    // The context is the current parsley instance, or window.Parsley if global\n    // A return value of `false` will interrupt the calls\n    on: function on(name, fn) {\n      this._listeners = this._listeners || {};\n      var queue = this._listeners[name] = this._listeners[name] || [];\n      queue.push(fn);\n      return this;\n    },\n    // Deprecated. Use `on` instead\n    subscribe: function subscribe(name, fn) {\n      $.listenTo(this, name.toLowerCase(), fn);\n    },\n    // Unregister a callback (or all if none is given) for the given event name\n    off: function off(name, fn) {\n      var queue = this._listeners && this._listeners[name];\n\n      if (queue) {\n        if (!fn) {\n          delete this._listeners[name];\n        } else {\n          for (var i = queue.length; i--;) {\n            if (queue[i] === fn) queue.splice(i, 1);\n          }\n        }\n      }\n\n      return this;\n    },\n    // Deprecated. Use `off`\n    unsubscribe: function unsubscribe(name, fn) {\n      $.unsubscribeTo(this, name.toLowerCase());\n    },\n    // Trigger an event of the given name\n    // A return value of `false` interrupts the callback chain\n    // Returns false if execution was interrupted\n    trigger: function trigger(name, target, extraArg) {\n      target = target || this;\n      var queue = this._listeners && this._listeners[name];\n      var result;\n\n      if (queue) {\n        for (var i = queue.length; i--;) {\n          result = queue[i].call(target, target, extraArg);\n          if (result === false) return result;\n        }\n      }\n\n      if (this.parent) {\n        return this.parent.trigger(name, target, extraArg);\n      }\n\n      return true;\n    },\n    asyncIsValid: function asyncIsValid(group, force) {\n      Utils.warnOnce(\"asyncIsValid is deprecated; please use whenValid instead\");\n      return this.whenValid({\n        group: group,\n        force: force\n      });\n    },\n    _findRelated: function _findRelated() {\n      return this.options.multiple ? $(this.parent.element.querySelectorAll(\"[\".concat(this.options.namespace, \"multiple=\\\"\").concat(this.options.multiple, \"\\\"]\"))) : this.$element;\n    }\n  };\n\n  var convertArrayRequirement = function convertArrayRequirement(string, length) {\n    var m = string.match(/^\\s*\\[(.*)\\]\\s*$/);\n    if (!m) throw 'Requirement is not an array: \"' + string + '\"';\n    var values = m[1].split(',').map(Utils.trimString);\n    if (values.length !== length) throw 'Requirement has ' + values.length + ' values when ' + length + ' are needed';\n    return values;\n  };\n\n  var convertExtraOptionRequirement = function convertExtraOptionRequirement(requirementSpec, string, extraOptionReader) {\n    var main = null;\n    var extra = {};\n\n    for (var key in requirementSpec) {\n      if (key) {\n        var value = extraOptionReader(key);\n        if ('string' === typeof value) value = Utils.parseRequirement(requirementSpec[key], value);\n        extra[key] = value;\n      } else {\n        main = Utils.parseRequirement(requirementSpec[key], string);\n      }\n    }\n\n    return [main, extra];\n  }; // A Validator needs to implement the methods `validate` and `parseRequirements`\n\n\n  var Validator = function Validator(spec) {\n    $.extend(true, this, spec);\n  };\n\n  Validator.prototype = {\n    // Returns `true` iff the given `value` is valid according the given requirements.\n    validate: function validate(value, requirementFirstArg) {\n      if (this.fn) {\n        // Legacy style validator\n        if (arguments.length > 3) // If more args then value, requirement, instance...\n          requirementFirstArg = [].slice.call(arguments, 1, -1); // Skip first arg (value) and last (instance), combining the rest\n\n        return this.fn(value, requirementFirstArg);\n      }\n\n      if (Array.isArray(value)) {\n        if (!this.validateMultiple) throw 'Validator `' + this.name + '` does not handle multiple values';\n        return this.validateMultiple.apply(this, arguments);\n      } else {\n        var instance = arguments[arguments.length - 1];\n\n        if (this.validateDate && instance._isDateInput()) {\n          arguments[0] = Utils.parse.date(arguments[0]);\n          if (arguments[0] === null) return false;\n          return this.validateDate.apply(this, arguments);\n        }\n\n        if (this.validateNumber) {\n          if (isNaN(value)) return false;\n          arguments[0] = parseFloat(arguments[0]);\n          return this.validateNumber.apply(this, arguments);\n        }\n\n        if (this.validateString) {\n          return this.validateString.apply(this, arguments);\n        }\n\n        throw 'Validator `' + this.name + '` only handles multiple values';\n      }\n    },\n    // Parses `requirements` into an array of arguments,\n    // according to `this.requirementType`\n    parseRequirements: function parseRequirements(requirements, extraOptionReader) {\n      if ('string' !== typeof requirements) {\n        // Assume requirement already parsed\n        // but make sure we return an array\n        return Array.isArray(requirements) ? requirements : [requirements];\n      }\n\n      var type = this.requirementType;\n\n      if (Array.isArray(type)) {\n        var values = convertArrayRequirement(requirements, type.length);\n\n        for (var i = 0; i < values.length; i++) {\n          values[i] = Utils.parseRequirement(type[i], values[i]);\n        }\n\n        return values;\n      } else if ($.isPlainObject(type)) {\n        return convertExtraOptionRequirement(type, requirements, extraOptionReader);\n      } else {\n        return [Utils.parseRequirement(type, requirements)];\n      }\n    },\n    // Defaults:\n    requirementType: 'string',\n    priority: 2\n  };\n\n  var ValidatorRegistry = function ValidatorRegistry(validators, catalog) {\n    this.__class__ = 'ValidatorRegistry'; // Default Parsley locale is en\n\n    this.locale = 'en';\n    this.init(validators || {}, catalog || {});\n  };\n\n  var typeTesters = {\n    email: /^((([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+(\\.([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(\\\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-zA-Z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-zA-Z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-zA-Z]|\\d|-|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-zA-Z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))\\.)+(([a-zA-Z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-zA-Z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-zA-Z]|\\d|-|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-zA-Z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))$/,\n    // Follow https://www.w3.org/TR/html5/infrastructure.html#floating-point-numbers\n    number: /^-?(\\d*\\.)?\\d+(e[-+]?\\d+)?$/i,\n    integer: /^-?\\d+$/,\n    digits: /^\\d+$/,\n    alphanum: /^\\w+$/i,\n    date: {\n      test: function test(value) {\n        return Utils.parse.date(value) !== null;\n      }\n    },\n    url: new RegExp(\"^\" + // protocol identifier\n    \"(?:(?:https?|ftp)://)?\" + // ** mod: make scheme optional\n    // user:pass authentication\n    \"(?:\\\\S+(?::\\\\S*)?@)?\" + \"(?:\" + // IP address exclusion\n    // private & local networks\n    // \"(?!(?:10|127)(?:\\\\.\\\\d{1,3}){3})\" +   // ** mod: allow local networks\n    // \"(?!(?:169\\\\.254|192\\\\.168)(?:\\\\.\\\\d{1,3}){2})\" +  // ** mod: allow local networks\n    // \"(?!172\\\\.(?:1[6-9]|2\\\\d|3[0-1])(?:\\\\.\\\\d{1,3}){2})\" +  // ** mod: allow local networks\n    // IP address dotted notation octets\n    // excludes loopback network 0.0.0.0\n    // excludes reserved space >= 224.0.0.0\n    // excludes network & broacast addresses\n    // (first & last IP address of each class)\n    \"(?:[1-9]\\\\d?|1\\\\d\\\\d|2[01]\\\\d|22[0-3])\" + \"(?:\\\\.(?:1?\\\\d{1,2}|2[0-4]\\\\d|25[0-5])){2}\" + \"(?:\\\\.(?:[1-9]\\\\d?|1\\\\d\\\\d|2[0-4]\\\\d|25[0-4]))\" + \"|\" + // host name\n    \"(?:(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)\" + // domain name\n    \"(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)*\" + // TLD identifier\n    \"(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff]{2,}))\" + \")\" + // port number\n    \"(?::\\\\d{2,5})?\" + // resource path\n    \"(?:/\\\\S*)?\" + \"$\")\n  };\n  typeTesters.range = typeTesters.number; // See http://stackoverflow.com/a/10454560/8279\n\n  var decimalPlaces = function decimalPlaces(num) {\n    var match = ('' + num).match(/(?:\\.(\\d+))?(?:[eE]([+-]?\\d+))?$/);\n\n    if (!match) {\n      return 0;\n    }\n\n    return Math.max(0, // Number of digits right of decimal point.\n    (match[1] ? match[1].length : 0) - ( // Adjust for scientific notation.\n    match[2] ? +match[2] : 0));\n  }; // parseArguments('number', ['1', '2']) => [1, 2]\n\n\n  var parseArguments = function parseArguments(type, args) {\n    return args.map(Utils.parse[type]);\n  }; // operatorToValidator returns a validating function for an operator function, applied to the given type\n\n\n  var operatorToValidator = function operatorToValidator(type, operator) {\n    return function (value) {\n      for (var _len = arguments.length, requirementsAndInput = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        requirementsAndInput[_key - 1] = arguments[_key];\n      }\n\n      requirementsAndInput.pop(); // Get rid of `input` argument\n\n      if (!value) return true; // Builtin validators all accept empty strings, except `required` of course\n\n      return operator.apply(void 0, [value].concat(_toConsumableArray(parseArguments(type, requirementsAndInput))));\n    };\n  };\n\n  var comparisonOperator = function comparisonOperator(operator) {\n    return {\n      validateDate: operatorToValidator('date', operator),\n      validateNumber: operatorToValidator('number', operator),\n      requirementType: operator.length <= 2 ? 'string' : ['string', 'string'],\n      // Support operators with a 1 or 2 requirement(s)\n      priority: 30\n    };\n  };\n\n  ValidatorRegistry.prototype = {\n    init: function init(validators, catalog) {\n      this.catalog = catalog; // Copy prototype's validators:\n\n      this.validators = _extends({}, this.validators);\n\n      for (var name in validators) {\n        this.addValidator(name, validators[name].fn, validators[name].priority);\n      }\n\n      window.Parsley.trigger('parsley:validator:init');\n    },\n    // Set new messages locale if we have dictionary loaded in ParsleyConfig.i18n\n    setLocale: function setLocale(locale) {\n      if ('undefined' === typeof this.catalog[locale]) throw new Error(locale + ' is not available in the catalog');\n      this.locale = locale;\n      return this;\n    },\n    // Add a new messages catalog for a given locale. Set locale for this catalog if set === `true`\n    addCatalog: function addCatalog(locale, messages, set) {\n      if ('object' === _typeof(messages)) this.catalog[locale] = messages;\n      if (true === set) return this.setLocale(locale);\n      return this;\n    },\n    // Add a specific message for a given constraint in a given locale\n    addMessage: function addMessage(locale, name, message) {\n      if ('undefined' === typeof this.catalog[locale]) this.catalog[locale] = {};\n      this.catalog[locale][name] = message;\n      return this;\n    },\n    // Add messages for a given locale\n    addMessages: function addMessages(locale, nameMessageObject) {\n      for (var name in nameMessageObject) {\n        this.addMessage(locale, name, nameMessageObject[name]);\n      }\n\n      return this;\n    },\n    // Add a new validator\n    //\n    //    addValidator('custom', {\n    //        requirementType: ['integer', 'integer'],\n    //        validateString: function(value, from, to) {},\n    //        priority: 22,\n    //        messages: {\n    //          en: \"Hey, that's no good\",\n    //          fr: \"Aye aye, pas bon du tout\",\n    //        }\n    //    })\n    //\n    // Old API was addValidator(name, function, priority)\n    //\n    addValidator: function addValidator(name, arg1, arg2) {\n      if (this.validators[name]) Utils.warn('Validator \"' + name + '\" is already defined.');else if (Defaults.hasOwnProperty(name)) {\n        Utils.warn('\"' + name + '\" is a restricted keyword and is not a valid validator name.');\n        return;\n      }\n      return this._setValidator.apply(this, arguments);\n    },\n    hasValidator: function hasValidator(name) {\n      return !!this.validators[name];\n    },\n    updateValidator: function updateValidator(name, arg1, arg2) {\n      if (!this.validators[name]) {\n        Utils.warn('Validator \"' + name + '\" is not already defined.');\n        return this.addValidator.apply(this, arguments);\n      }\n\n      return this._setValidator.apply(this, arguments);\n    },\n    removeValidator: function removeValidator(name) {\n      if (!this.validators[name]) Utils.warn('Validator \"' + name + '\" is not defined.');\n      delete this.validators[name];\n      return this;\n    },\n    _setValidator: function _setValidator(name, validator, priority) {\n      if ('object' !== _typeof(validator)) {\n        // Old style validator, with `fn` and `priority`\n        validator = {\n          fn: validator,\n          priority: priority\n        };\n      }\n\n      if (!validator.validate) {\n        validator = new Validator(validator);\n      }\n\n      this.validators[name] = validator;\n\n      for (var locale in validator.messages || {}) {\n        this.addMessage(locale, name, validator.messages[locale]);\n      }\n\n      return this;\n    },\n    getErrorMessage: function getErrorMessage(constraint) {\n      var message; // Type constraints are a bit different, we have to match their requirements too to find right error message\n\n      if ('type' === constraint.name) {\n        var typeMessages = this.catalog[this.locale][constraint.name] || {};\n        message = typeMessages[constraint.requirements];\n      } else message = this.formatMessage(this.catalog[this.locale][constraint.name], constraint.requirements);\n\n      return message || this.catalog[this.locale].defaultMessage || this.catalog.en.defaultMessage;\n    },\n    // Kind of light `sprintf()` implementation\n    formatMessage: function formatMessage(string, parameters) {\n      if ('object' === _typeof(parameters)) {\n        for (var i in parameters) {\n          string = this.formatMessage(string, parameters[i]);\n        }\n\n        return string;\n      }\n\n      return 'string' === typeof string ? string.replace(/%s/i, parameters) : '';\n    },\n    // Here is the Parsley default validators list.\n    // A validator is an object with the following key values:\n    //  - priority: an integer\n    //  - requirement: 'string' (default), 'integer', 'number', 'regexp' or an Array of these\n    //  - validateString, validateMultiple, validateNumber: functions returning `true`, `false` or a promise\n    // Alternatively, a validator can be a function that returns such an object\n    //\n    validators: {\n      notblank: {\n        validateString: function validateString(value) {\n          return /\\S/.test(value);\n        },\n        priority: 2\n      },\n      required: {\n        validateMultiple: function validateMultiple(values) {\n          return values.length > 0;\n        },\n        validateString: function validateString(value) {\n          return /\\S/.test(value);\n        },\n        priority: 512\n      },\n      type: {\n        validateString: function validateString(value, type) {\n          var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n              _ref$step = _ref.step,\n              step = _ref$step === void 0 ? 'any' : _ref$step,\n              _ref$base = _ref.base,\n              base = _ref$base === void 0 ? 0 : _ref$base;\n\n          var tester = typeTesters[type];\n\n          if (!tester) {\n            throw new Error('validator type `' + type + '` is not supported');\n          }\n\n          if (!value) return true; // Builtin validators all accept empty strings, except `required` of course\n\n          if (!tester.test(value)) return false;\n\n          if ('number' === type) {\n            if (!/^any$/i.test(step || '')) {\n              var nb = Number(value);\n              var decimals = Math.max(decimalPlaces(step), decimalPlaces(base));\n              if (decimalPlaces(nb) > decimals) // Value can't have too many decimals\n                return false; // Be careful of rounding errors by using integers.\n\n              var toInt = function toInt(f) {\n                return Math.round(f * Math.pow(10, decimals));\n              };\n\n              if ((toInt(nb) - toInt(base)) % toInt(step) != 0) return false;\n            }\n          }\n\n          return true;\n        },\n        requirementType: {\n          '': 'string',\n          step: 'string',\n          base: 'number'\n        },\n        priority: 256\n      },\n      pattern: {\n        validateString: function validateString(value, regexp) {\n          if (!value) return true; // Builtin validators all accept empty strings, except `required` of course\n\n          return regexp.test(value);\n        },\n        requirementType: 'regexp',\n        priority: 64\n      },\n      minlength: {\n        validateString: function validateString(value, requirement) {\n          if (!value) return true; // Builtin validators all accept empty strings, except `required` of course\n\n          return value.length >= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      maxlength: {\n        validateString: function validateString(value, requirement) {\n          return value.length <= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      length: {\n        validateString: function validateString(value, min, max) {\n          if (!value) return true; // Builtin validators all accept empty strings, except `required` of course\n\n          return value.length >= min && value.length <= max;\n        },\n        requirementType: ['integer', 'integer'],\n        priority: 30\n      },\n      mincheck: {\n        validateMultiple: function validateMultiple(values, requirement) {\n          return values.length >= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      maxcheck: {\n        validateMultiple: function validateMultiple(values, requirement) {\n          return values.length <= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      check: {\n        validateMultiple: function validateMultiple(values, min, max) {\n          return values.length >= min && values.length <= max;\n        },\n        requirementType: ['integer', 'integer'],\n        priority: 30\n      },\n      min: comparisonOperator(function (value, requirement) {\n        return value >= requirement;\n      }),\n      max: comparisonOperator(function (value, requirement) {\n        return value <= requirement;\n      }),\n      range: comparisonOperator(function (value, min, max) {\n        return value >= min && value <= max;\n      }),\n      equalto: {\n        validateString: function validateString(value, refOrValue) {\n          if (!value) return true; // Builtin validators all accept empty strings, except `required` of course\n\n          var $reference = $(refOrValue);\n          if ($reference.length) return value === $reference.val();else return value === refOrValue;\n        },\n        priority: 256\n      },\n      euvatin: {\n        validateString: function validateString(value, refOrValue) {\n          if (!value) {\n            return true; // Builtin validators all accept empty strings, except `required` of course\n          }\n\n          var re = /^[A-Z][A-Z][A-Za-z0-9 -]{2,}$/;\n          return re.test(value);\n        },\n        priority: 30\n      }\n    }\n  };\n\n  var UI = {};\n\n  var diffResults = function diffResults(newResult, oldResult, deep) {\n    var added = [];\n    var kept = [];\n\n    for (var i = 0; i < newResult.length; i++) {\n      var found = false;\n\n      for (var j = 0; j < oldResult.length; j++) {\n        if (newResult[i].assert.name === oldResult[j].assert.name) {\n          found = true;\n          break;\n        }\n      }\n\n      if (found) kept.push(newResult[i]);else added.push(newResult[i]);\n    }\n\n    return {\n      kept: kept,\n      added: added,\n      removed: !deep ? diffResults(oldResult, newResult, true).added : []\n    };\n  };\n\n  UI.Form = {\n    _actualizeTriggers: function _actualizeTriggers() {\n      var _this = this;\n\n      this.$element.on('submit.Parsley', function (evt) {\n        _this.onSubmitValidate(evt);\n      });\n      this.$element.on('click.Parsley', Utils._SubmitSelector, function (evt) {\n        _this.onSubmitButton(evt);\n      }); // UI could be disabled\n\n      if (false === this.options.uiEnabled) return;\n      this.element.setAttribute('novalidate', '');\n    },\n    focus: function focus() {\n      this._focusedField = null;\n      if (true === this.validationResult || 'none' === this.options.focus) return null;\n\n      for (var i = 0; i < this.fields.length; i++) {\n        var field = this.fields[i];\n\n        if (true !== field.validationResult && field.validationResult.length > 0 && 'undefined' === typeof field.options.noFocus) {\n          this._focusedField = field.$element;\n          if ('first' === this.options.focus) break;\n        }\n      }\n\n      if (null === this._focusedField) return null;\n      return this._focusedField.focus();\n    },\n    _destroyUI: function _destroyUI() {\n      // Reset all event listeners\n      this.$element.off('.Parsley');\n    }\n  };\n  UI.Field = {\n    _reflowUI: function _reflowUI() {\n      this._buildUI(); // If this field doesn't have an active UI don't bother doing something\n\n\n      if (!this._ui) return; // Diff between two validation results\n\n      var diff = diffResults(this.validationResult, this._ui.lastValidationResult); // Then store current validation result for next reflow\n\n      this._ui.lastValidationResult = this.validationResult; // Handle valid / invalid / none field class\n\n      this._manageStatusClass(); // Add, remove, updated errors messages\n\n\n      this._manageErrorsMessages(diff); // Triggers impl\n\n\n      this._actualizeTriggers(); // If field is not valid for the first time, bind keyup trigger to ease UX and quickly inform user\n\n\n      if ((diff.kept.length || diff.added.length) && !this._failedOnce) {\n        this._failedOnce = true;\n\n        this._actualizeTriggers();\n      }\n    },\n    // Returns an array of field's error message(s)\n    getErrorsMessages: function getErrorsMessages() {\n      // No error message, field is valid\n      if (true === this.validationResult) return [];\n      var messages = [];\n\n      for (var i = 0; i < this.validationResult.length; i++) {\n        messages.push(this.validationResult[i].errorMessage || this._getErrorMessage(this.validationResult[i].assert));\n      }\n\n      return messages;\n    },\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    addError: function addError(name) {\n      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n          message = _ref.message,\n          assert = _ref.assert,\n          _ref$updateClass = _ref.updateClass,\n          updateClass = _ref$updateClass === void 0 ? true : _ref$updateClass;\n\n      this._buildUI();\n\n      this._addError(name, {\n        message: message,\n        assert: assert\n      });\n\n      if (updateClass) this._errorClass();\n    },\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    updateError: function updateError(name) {\n      var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n          message = _ref2.message,\n          assert = _ref2.assert,\n          _ref2$updateClass = _ref2.updateClass,\n          updateClass = _ref2$updateClass === void 0 ? true : _ref2$updateClass;\n\n      this._buildUI();\n\n      this._updateError(name, {\n        message: message,\n        assert: assert\n      });\n\n      if (updateClass) this._errorClass();\n    },\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    removeError: function removeError(name) {\n      var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n          _ref3$updateClass = _ref3.updateClass,\n          updateClass = _ref3$updateClass === void 0 ? true : _ref3$updateClass;\n\n      this._buildUI();\n\n      this._removeError(name); // edge case possible here: remove a standard Parsley error that is still failing in this.validationResult\n      // but highly improbable cuz' manually removing a well Parsley handled error makes no sense.\n\n\n      if (updateClass) this._manageStatusClass();\n    },\n    _manageStatusClass: function _manageStatusClass() {\n      if (this.hasConstraints() && this.needsValidation() && true === this.validationResult) this._successClass();else if (this.validationResult.length > 0) this._errorClass();else this._resetClass();\n    },\n    _manageErrorsMessages: function _manageErrorsMessages(diff) {\n      if ('undefined' !== typeof this.options.errorsMessagesDisabled) return; // Case where we have errorMessage option that configure an unique field error message, regardless failing validators\n\n      if ('undefined' !== typeof this.options.errorMessage) {\n        if (diff.added.length || diff.kept.length) {\n          this._insertErrorWrapper();\n\n          if (0 === this._ui.$errorsWrapper.find('.parsley-custom-error-message').length) this._ui.$errorsWrapper.append($(this.options.errorTemplate).addClass('parsley-custom-error-message'));\n          return this._ui.$errorsWrapper.addClass('filled').find('.parsley-custom-error-message').html(this.options.errorMessage);\n        }\n\n        return this._ui.$errorsWrapper.removeClass('filled').find('.parsley-custom-error-message').remove();\n      } // Show, hide, update failing constraints messages\n\n\n      for (var i = 0; i < diff.removed.length; i++) {\n        this._removeError(diff.removed[i].assert.name);\n      }\n\n      for (i = 0; i < diff.added.length; i++) {\n        this._addError(diff.added[i].assert.name, {\n          message: diff.added[i].errorMessage,\n          assert: diff.added[i].assert\n        });\n      }\n\n      for (i = 0; i < diff.kept.length; i++) {\n        this._updateError(diff.kept[i].assert.name, {\n          message: diff.kept[i].errorMessage,\n          assert: diff.kept[i].assert\n        });\n      }\n    },\n    _addError: function _addError(name, _ref4) {\n      var message = _ref4.message,\n          assert = _ref4.assert;\n\n      this._insertErrorWrapper();\n\n      this._ui.$errorClassHandler.attr('aria-describedby', this._ui.errorsWrapperId);\n\n      this._ui.$errorsWrapper.addClass('filled').append($(this.options.errorTemplate).addClass('parsley-' + name).html(message || this._getErrorMessage(assert)));\n    },\n    _updateError: function _updateError(name, _ref5) {\n      var message = _ref5.message,\n          assert = _ref5.assert;\n\n      this._ui.$errorsWrapper.addClass('filled').find('.parsley-' + name).html(message || this._getErrorMessage(assert));\n    },\n    _removeError: function _removeError(name) {\n      this._ui.$errorClassHandler.removeAttr('aria-describedby');\n\n      this._ui.$errorsWrapper.removeClass('filled').find('.parsley-' + name).remove();\n    },\n    _getErrorMessage: function _getErrorMessage(constraint) {\n      var customConstraintErrorMessage = constraint.name + 'Message';\n      if ('undefined' !== typeof this.options[customConstraintErrorMessage]) return window.Parsley.formatMessage(this.options[customConstraintErrorMessage], constraint.requirements);\n      return window.Parsley.getErrorMessage(constraint);\n    },\n    _buildUI: function _buildUI() {\n      // UI could be already built or disabled\n      if (this._ui || false === this.options.uiEnabled) return;\n      var _ui = {}; // Give field its Parsley id in DOM\n\n      this.element.setAttribute(this.options.namespace + 'id', this.__id__);\n      /** Generate important UI elements and store them in this **/\n      // $errorClassHandler is the $element that woul have parsley-error and parsley-success classes\n\n      _ui.$errorClassHandler = this._manageClassHandler(); // $errorsWrapper is a div that would contain the various field errors, it will be appended into $errorsContainer\n\n      _ui.errorsWrapperId = 'parsley-id-' + (this.options.multiple ? 'multiple-' + this.options.multiple : this.__id__);\n      _ui.$errorsWrapper = $(this.options.errorsWrapper).attr('id', _ui.errorsWrapperId); // ValidationResult UI storage to detect what have changed bwt two validations, and update DOM accordingly\n\n      _ui.lastValidationResult = [];\n      _ui.validationInformationVisible = false; // Store it in this for later\n\n      this._ui = _ui;\n    },\n    // Determine which element will have `parsley-error` and `parsley-success` classes\n    _manageClassHandler: function _manageClassHandler() {\n      // Class handled could also be determined by function given in Parsley options\n      if ('string' === typeof this.options.classHandler && $(this.options.classHandler).length) return $(this.options.classHandler); // Class handled could also be determined by function given in Parsley options\n\n      var $handlerFunction = this.options.classHandler; // It might also be the function name of a global function\n\n      if ('string' === typeof this.options.classHandler && 'function' === typeof window[this.options.classHandler]) $handlerFunction = window[this.options.classHandler];\n\n      if ('function' === typeof $handlerFunction) {\n        var $handler = $handlerFunction.call(this, this); // If this function returned a valid existing DOM element, go for it\n\n        if ('undefined' !== typeof $handler && $handler.length) return $handler;\n      } else if ('object' === _typeof($handlerFunction) && $handlerFunction instanceof jQuery && $handlerFunction.length) {\n        return $handlerFunction;\n      } else if ($handlerFunction) {\n        Utils.warn('The class handler `' + $handlerFunction + '` does not exist in DOM nor as a global JS function');\n      }\n\n      return this._inputHolder();\n    },\n    _inputHolder: function _inputHolder() {\n      // if simple element (input, texatrea, select...) it will perfectly host the classes and precede the error container\n      if (!this.options.multiple || this.element.nodeName === 'SELECT') return this.$element; // But if multiple element (radio, checkbox), that would be their parent\n\n      return this.$element.parent();\n    },\n    _insertErrorWrapper: function _insertErrorWrapper() {\n      var $errorsContainer = this.options.errorsContainer; // Nothing to do if already inserted\n\n      if (0 !== this._ui.$errorsWrapper.parent().length) return this._ui.$errorsWrapper.parent();\n\n      if ('string' === typeof $errorsContainer) {\n        if ($($errorsContainer).length) return $($errorsContainer).append(this._ui.$errorsWrapper);else if ('function' === typeof window[$errorsContainer]) $errorsContainer = window[$errorsContainer];else Utils.warn('The errors container `' + $errorsContainer + '` does not exist in DOM nor as a global JS function');\n      }\n\n      if ('function' === typeof $errorsContainer) $errorsContainer = $errorsContainer.call(this, this);\n      if ('object' === _typeof($errorsContainer) && $errorsContainer.length) return $errorsContainer.append(this._ui.$errorsWrapper);\n      return this._inputHolder().after(this._ui.$errorsWrapper);\n    },\n    _actualizeTriggers: function _actualizeTriggers() {\n      var _this2 = this;\n\n      var $toBind = this._findRelated();\n\n      var trigger; // Remove Parsley events already bound on this field\n\n      $toBind.off('.Parsley');\n      if (this._failedOnce) $toBind.on(Utils.namespaceEvents(this.options.triggerAfterFailure, 'Parsley'), function () {\n        _this2._validateIfNeeded();\n      });else if (trigger = Utils.namespaceEvents(this.options.trigger, 'Parsley')) {\n        $toBind.on(trigger, function (event) {\n          _this2._validateIfNeeded(event);\n        });\n      }\n    },\n    _validateIfNeeded: function _validateIfNeeded(event) {\n      var _this3 = this;\n\n      // For keyup, keypress, keydown, input... events that could be a little bit obstrusive\n      // do not validate if val length < min threshold on first validation. Once field have been validated once and info\n      // about success or failure have been displayed, always validate with this trigger to reflect every yalidation change.\n      if (event && /key|input/.test(event.type)) if (!(this._ui && this._ui.validationInformationVisible) && this.getValue().length <= this.options.validationThreshold) return;\n\n      if (this.options.debounce) {\n        window.clearTimeout(this._debounced);\n        this._debounced = window.setTimeout(function () {\n          return _this3.validate();\n        }, this.options.debounce);\n      } else this.validate();\n    },\n    _resetUI: function _resetUI() {\n      // Reset all event listeners\n      this._failedOnce = false;\n\n      this._actualizeTriggers(); // Nothing to do if UI never initialized for this field\n\n\n      if ('undefined' === typeof this._ui) return; // Reset all errors' li\n\n      this._ui.$errorsWrapper.removeClass('filled').children().remove(); // Reset validation class\n\n\n      this._resetClass(); // Reset validation flags and last validation result\n\n\n      this._ui.lastValidationResult = [];\n      this._ui.validationInformationVisible = false;\n    },\n    _destroyUI: function _destroyUI() {\n      this._resetUI();\n\n      if ('undefined' !== typeof this._ui) this._ui.$errorsWrapper.remove();\n      delete this._ui;\n    },\n    _successClass: function _successClass() {\n      this._ui.validationInformationVisible = true;\n\n      this._ui.$errorClassHandler.removeClass(this.options.errorClass).addClass(this.options.successClass);\n    },\n    _errorClass: function _errorClass() {\n      this._ui.validationInformationVisible = true;\n\n      this._ui.$errorClassHandler.removeClass(this.options.successClass).addClass(this.options.errorClass);\n    },\n    _resetClass: function _resetClass() {\n      this._ui.$errorClassHandler.removeClass(this.options.successClass).removeClass(this.options.errorClass);\n    }\n  };\n\n  var Form = function Form(element, domOptions, options) {\n    this.__class__ = 'Form';\n    this.element = element;\n    this.$element = $(element);\n    this.domOptions = domOptions;\n    this.options = options;\n    this.parent = window.Parsley;\n    this.fields = [];\n    this.validationResult = null;\n  };\n\n  var statusMapping = {\n    pending: null,\n    resolved: true,\n    rejected: false\n  };\n  Form.prototype = {\n    onSubmitValidate: function onSubmitValidate(event) {\n      var _this = this;\n\n      // This is a Parsley generated submit event, do not validate, do not prevent, simply exit and keep normal behavior\n      if (true === event.parsley) return; // If we didn't come here through a submit button, use the first one in the form\n\n      var submitSource = this._submitSource || this.$element.find(Utils._SubmitSelector)[0];\n      this._submitSource = null;\n      this.$element.find('.parsley-synthetic-submit-button').prop('disabled', true);\n      if (submitSource && null !== submitSource.getAttribute('formnovalidate')) return;\n      window.Parsley._remoteCache = {};\n      var promise = this.whenValidate({\n        event: event\n      });\n\n      if ('resolved' === promise.state() && false !== this._trigger('submit')) ; else {\n        // Rejected or pending: cancel this submit\n        event.stopImmediatePropagation();\n        event.preventDefault();\n        if ('pending' === promise.state()) promise.done(function () {\n          _this._submit(submitSource);\n        });\n      }\n    },\n    onSubmitButton: function onSubmitButton(event) {\n      this._submitSource = event.currentTarget;\n    },\n    // internal\n    // _submit submits the form, this time without going through the validations.\n    // Care must be taken to \"fake\" the actual submit button being clicked.\n    _submit: function _submit(submitSource) {\n      if (false === this._trigger('submit')) return; // Add submit button's data\n\n      if (submitSource) {\n        var $synthetic = this.$element.find('.parsley-synthetic-submit-button').prop('disabled', false);\n        if (0 === $synthetic.length) $synthetic = $('<input class=\"parsley-synthetic-submit-button\" type=\"hidden\">').appendTo(this.$element);\n        $synthetic.attr({\n          name: submitSource.getAttribute('name'),\n          value: submitSource.getAttribute('value')\n        });\n      }\n\n      this.$element.trigger(_extends($.Event('submit'), {\n        parsley: true\n      }));\n    },\n    // Performs validation on fields while triggering events.\n    // @returns `true` if all validations succeeds, `false`\n    // if a failure is immediately detected, or `null`\n    // if dependant on a promise.\n    // Consider using `whenValidate` instead.\n    validate: function validate(options) {\n      if (arguments.length >= 1 && !$.isPlainObject(options)) {\n        Utils.warnOnce('Calling validate on a parsley form without passing arguments as an object is deprecated.');\n\n        var _arguments = Array.prototype.slice.call(arguments),\n            group = _arguments[0],\n            force = _arguments[1],\n            event = _arguments[2];\n\n        options = {\n          group: group,\n          force: force,\n          event: event\n        };\n      }\n\n      return statusMapping[this.whenValidate(options).state()];\n    },\n    whenValidate: function whenValidate() {\n      var _this2 = this,\n          _Utils$all$done$fail$;\n\n      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          group = _ref.group,\n          force = _ref.force,\n          event = _ref.event;\n\n      this.submitEvent = event;\n\n      if (event) {\n        this.submitEvent = _extends({}, event, {\n          preventDefault: function preventDefault() {\n            Utils.warnOnce(\"Using `this.submitEvent.preventDefault()` is deprecated; instead, call `this.validationResult = false`\");\n            _this2.validationResult = false;\n          }\n        });\n      }\n\n      this.validationResult = true; // fire validate event to eventually modify things before every validation\n\n      this._trigger('validate'); // Refresh form DOM options and form's fields that could have changed\n\n\n      this._refreshFields();\n\n      var promises = this._withoutReactualizingFormOptions(function () {\n        return $.map(_this2.fields, function (field) {\n          return field.whenValidate({\n            force: force,\n            group: group\n          });\n        });\n      });\n\n      return (_Utils$all$done$fail$ = Utils.all(promises).done(function () {\n        _this2._trigger('success');\n      }).fail(function () {\n        _this2.validationResult = false;\n\n        _this2.focus();\n\n        _this2._trigger('error');\n      }).always(function () {\n        _this2._trigger('validated');\n      })).pipe.apply(_Utils$all$done$fail$, _toConsumableArray(this._pipeAccordingToValidationResult()));\n    },\n    // Iterate over refreshed fields, and stop on first failure.\n    // Returns `true` if all fields are valid, `false` if a failure is detected\n    // or `null` if the result depends on an unresolved promise.\n    // Prefer using `whenValid` instead.\n    isValid: function isValid(options) {\n      if (arguments.length >= 1 && !$.isPlainObject(options)) {\n        Utils.warnOnce('Calling isValid on a parsley form without passing arguments as an object is deprecated.');\n\n        var _arguments2 = Array.prototype.slice.call(arguments),\n            group = _arguments2[0],\n            force = _arguments2[1];\n\n        options = {\n          group: group,\n          force: force\n        };\n      }\n\n      return statusMapping[this.whenValid(options).state()];\n    },\n    // Iterate over refreshed fields and validate them.\n    // Returns a promise.\n    // A validation that immediately fails will interrupt the validations.\n    whenValid: function whenValid() {\n      var _this3 = this;\n\n      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          group = _ref2.group,\n          force = _ref2.force;\n\n      this._refreshFields();\n\n      var promises = this._withoutReactualizingFormOptions(function () {\n        return $.map(_this3.fields, function (field) {\n          return field.whenValid({\n            group: group,\n            force: force\n          });\n        });\n      });\n\n      return Utils.all(promises);\n    },\n    refresh: function refresh() {\n      this._refreshFields();\n\n      return this;\n    },\n    // Reset UI\n    reset: function reset() {\n      // Form case: emit a reset event for each field\n      for (var i = 0; i < this.fields.length; i++) {\n        this.fields[i].reset();\n      }\n\n      this._trigger('reset');\n    },\n    // Destroy Parsley instance (+ UI)\n    destroy: function destroy() {\n      // Field case: emit destroy event to clean UI and then destroy stored instance\n      this._destroyUI(); // Form case: destroy all its fields and then destroy stored instance\n\n\n      for (var i = 0; i < this.fields.length; i++) {\n        this.fields[i].destroy();\n      }\n\n      this.$element.removeData('Parsley');\n\n      this._trigger('destroy');\n    },\n    _refreshFields: function _refreshFields() {\n      return this.actualizeOptions()._bindFields();\n    },\n    _bindFields: function _bindFields() {\n      var _this4 = this;\n\n      var oldFields = this.fields;\n      this.fields = [];\n      this.fieldsMappedById = {};\n\n      this._withoutReactualizingFormOptions(function () {\n        _this4.$element.find(_this4.options.inputs).not(_this4.options.excluded).not(\"[\".concat(_this4.options.namespace, \"excluded=true]\")).each(function (_, element) {\n          var fieldInstance = new window.Parsley.Factory(element, {}, _this4); // Only add valid and not excluded `Field` and `FieldMultiple` children\n\n          if ('Field' === fieldInstance.__class__ || 'FieldMultiple' === fieldInstance.__class__) {\n            var uniqueId = fieldInstance.__class__ + '-' + fieldInstance.__id__;\n\n            if ('undefined' === typeof _this4.fieldsMappedById[uniqueId]) {\n              _this4.fieldsMappedById[uniqueId] = fieldInstance;\n\n              _this4.fields.push(fieldInstance);\n            }\n          }\n        });\n\n        $.each(Utils.difference(oldFields, _this4.fields), function (_, field) {\n          field.reset();\n        });\n      });\n\n      return this;\n    },\n    // Internal only.\n    // Looping on a form's fields to do validation or similar\n    // will trigger reactualizing options on all of them, which\n    // in turn will reactualize the form's options.\n    // To avoid calling actualizeOptions so many times on the form\n    // for nothing, _withoutReactualizingFormOptions temporarily disables\n    // the method actualizeOptions on this form while `fn` is called.\n    _withoutReactualizingFormOptions: function _withoutReactualizingFormOptions(fn) {\n      var oldActualizeOptions = this.actualizeOptions;\n\n      this.actualizeOptions = function () {\n        return this;\n      };\n\n      var result = fn();\n      this.actualizeOptions = oldActualizeOptions;\n      return result;\n    },\n    // Internal only.\n    // Shortcut to trigger an event\n    // Returns true iff event is not interrupted and default not prevented.\n    _trigger: function _trigger(eventName) {\n      return this.trigger('form:' + eventName);\n    }\n  };\n\n  var Constraint = function Constraint(parsleyField, name, requirements, priority, isDomConstraint) {\n    var validatorSpec = window.Parsley._validatorRegistry.validators[name];\n    var validator = new Validator(validatorSpec);\n    priority = priority || parsleyField.options[name + 'Priority'] || validator.priority;\n    isDomConstraint = true === isDomConstraint;\n\n    _extends(this, {\n      validator: validator,\n      name: name,\n      requirements: requirements,\n      priority: priority,\n      isDomConstraint: isDomConstraint\n    });\n\n    this._parseRequirements(parsleyField.options);\n  };\n\n  var capitalize = function capitalize(str) {\n    var cap = str[0].toUpperCase();\n    return cap + str.slice(1);\n  };\n\n  Constraint.prototype = {\n    validate: function validate(value, instance) {\n      var _this$validator;\n\n      return (_this$validator = this.validator).validate.apply(_this$validator, [value].concat(_toConsumableArray(this.requirementList), [instance]));\n    },\n    _parseRequirements: function _parseRequirements(options) {\n      var _this = this;\n\n      this.requirementList = this.validator.parseRequirements(this.requirements, function (key) {\n        return options[_this.name + capitalize(key)];\n      });\n    }\n  };\n\n  var Field = function Field(field, domOptions, options, parsleyFormInstance) {\n    this.__class__ = 'Field';\n    this.element = field;\n    this.$element = $(field); // Set parent if we have one\n\n    if ('undefined' !== typeof parsleyFormInstance) {\n      this.parent = parsleyFormInstance;\n    }\n\n    this.options = options;\n    this.domOptions = domOptions; // Initialize some properties\n\n    this.constraints = [];\n    this.constraintsByName = {};\n    this.validationResult = true; // Bind constraints\n\n    this._bindConstraints();\n  };\n\n  var statusMapping$1 = {\n    pending: null,\n    resolved: true,\n    rejected: false\n  };\n  Field.prototype = {\n    // # Public API\n    // Validate field and trigger some events for mainly `UI`\n    // @returns `true`, an array of the validators that failed, or\n    // `null` if validation is not finished. Prefer using whenValidate\n    validate: function validate(options) {\n      if (arguments.length >= 1 && !$.isPlainObject(options)) {\n        Utils.warnOnce('Calling validate on a parsley field without passing arguments as an object is deprecated.');\n        options = {\n          options: options\n        };\n      }\n\n      var promise = this.whenValidate(options);\n      if (!promise) // If excluded with `group` option\n        return true;\n\n      switch (promise.state()) {\n        case 'pending':\n          return null;\n\n        case 'resolved':\n          return true;\n\n        case 'rejected':\n          return this.validationResult;\n      }\n    },\n    // Validate field and trigger some events for mainly `UI`\n    // @returns a promise that succeeds only when all validations do\n    // or `undefined` if field is not in the given `group`.\n    whenValidate: function whenValidate() {\n      var _this$whenValid$alway,\n          _this = this;\n\n      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          force = _ref.force,\n          group = _ref.group;\n\n      // do not validate a field if not the same as given validation group\n      this.refresh();\n      if (group && !this._isInGroup(group)) return;\n      this.value = this.getValue(); // Field Validate event. `this.value` could be altered for custom needs\n\n      this._trigger('validate');\n\n      return (_this$whenValid$alway = this.whenValid({\n        force: force,\n        value: this.value,\n        _refreshed: true\n      }).always(function () {\n        _this._reflowUI();\n      }).done(function () {\n        _this._trigger('success');\n      }).fail(function () {\n        _this._trigger('error');\n      }).always(function () {\n        _this._trigger('validated');\n      })).pipe.apply(_this$whenValid$alway, _toConsumableArray(this._pipeAccordingToValidationResult()));\n    },\n    hasConstraints: function hasConstraints() {\n      return 0 !== this.constraints.length;\n    },\n    // An empty optional field does not need validation\n    needsValidation: function needsValidation(value) {\n      if ('undefined' === typeof value) value = this.getValue(); // If a field is empty and not required, it is valid\n      // Except if `data-parsley-validate-if-empty` explicitely added, useful for some custom validators\n\n      if (!value.length && !this._isRequired() && 'undefined' === typeof this.options.validateIfEmpty) return false;\n      return true;\n    },\n    _isInGroup: function _isInGroup(group) {\n      if (Array.isArray(this.options.group)) return -1 !== $.inArray(group, this.options.group);\n      return this.options.group === group;\n    },\n    // Just validate field. Do not trigger any event.\n    // Returns `true` iff all constraints pass, `false` if there are failures,\n    // or `null` if the result can not be determined yet (depends on a promise)\n    // See also `whenValid`.\n    isValid: function isValid(options) {\n      if (arguments.length >= 1 && !$.isPlainObject(options)) {\n        Utils.warnOnce('Calling isValid on a parsley field without passing arguments as an object is deprecated.');\n\n        var _arguments = Array.prototype.slice.call(arguments),\n            force = _arguments[0],\n            value = _arguments[1];\n\n        options = {\n          force: force,\n          value: value\n        };\n      }\n\n      var promise = this.whenValid(options);\n      if (!promise) // Excluded via `group`\n        return true;\n      return statusMapping$1[promise.state()];\n    },\n    // Just validate field. Do not trigger any event.\n    // @returns a promise that succeeds only when all validations do\n    // or `undefined` if the field is not in the given `group`.\n    // The argument `force` will force validation of empty fields.\n    // If a `value` is given, it will be validated instead of the value of the input.\n    whenValid: function whenValid() {\n      var _this2 = this;\n\n      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref2$force = _ref2.force,\n          force = _ref2$force === void 0 ? false : _ref2$force,\n          value = _ref2.value,\n          group = _ref2.group,\n          _refreshed = _ref2._refreshed;\n\n      // Recompute options and rebind constraints to have latest changes\n      if (!_refreshed) this.refresh(); // do not validate a field if not the same as given validation group\n\n      if (group && !this._isInGroup(group)) return;\n      this.validationResult = true; // A field without constraint is valid\n\n      if (!this.hasConstraints()) return $.when(); // Value could be passed as argument, needed to add more power to 'field:validate'\n\n      if ('undefined' === typeof value || null === value) value = this.getValue();\n      if (!this.needsValidation(value) && true !== force) return $.when();\n\n      var groupedConstraints = this._getGroupedConstraints();\n\n      var promises = [];\n      $.each(groupedConstraints, function (_, constraints) {\n        // Process one group of constraints at a time, we validate the constraints\n        // and combine the promises together.\n        var promise = Utils.all($.map(constraints, function (constraint) {\n          return _this2._validateConstraint(value, constraint);\n        }));\n        promises.push(promise);\n        if (promise.state() === 'rejected') return false; // Interrupt processing if a group has already failed\n      });\n      return Utils.all(promises);\n    },\n    // @returns a promise\n    _validateConstraint: function _validateConstraint(value, constraint) {\n      var _this3 = this;\n\n      var result = constraint.validate(value, this); // Map false to a failed promise\n\n      if (false === result) result = $.Deferred().reject(); // Make sure we return a promise and that we record failures\n\n      return Utils.all([result]).fail(function (errorMessage) {\n        if (!(_this3.validationResult instanceof Array)) _this3.validationResult = [];\n\n        _this3.validationResult.push({\n          assert: constraint,\n          errorMessage: 'string' === typeof errorMessage && errorMessage\n        });\n      });\n    },\n    // @returns Parsley field computed value that could be overrided or configured in DOM\n    getValue: function getValue() {\n      var value; // Value could be overriden in DOM or with explicit options\n\n      if ('function' === typeof this.options.value) value = this.options.value(this);else if ('undefined' !== typeof this.options.value) value = this.options.value;else value = this.$element.val(); // Handle wrong DOM or configurations\n\n      if ('undefined' === typeof value || null === value) return '';\n      return this._handleWhitespace(value);\n    },\n    // Reset UI\n    reset: function reset() {\n      this._resetUI();\n\n      return this._trigger('reset');\n    },\n    // Destroy Parsley instance (+ UI)\n    destroy: function destroy() {\n      // Field case: emit destroy event to clean UI and then destroy stored instance\n      this._destroyUI();\n\n      this.$element.removeData('Parsley');\n      this.$element.removeData('FieldMultiple');\n\n      this._trigger('destroy');\n    },\n    // Actualize options and rebind constraints\n    refresh: function refresh() {\n      this._refreshConstraints();\n\n      return this;\n    },\n    _refreshConstraints: function _refreshConstraints() {\n      return this.actualizeOptions()._bindConstraints();\n    },\n    refreshConstraints: function refreshConstraints() {\n      Utils.warnOnce(\"Parsley's refreshConstraints is deprecated. Please use refresh\");\n      return this.refresh();\n    },\n\n    /**\n    * Add a new constraint to a field\n    *\n    * @param {String}   name\n    * @param {Mixed}    requirements      optional\n    * @param {Number}   priority          optional\n    * @param {Boolean}  isDomConstraint   optional\n    */\n    addConstraint: function addConstraint(name, requirements, priority, isDomConstraint) {\n      if (window.Parsley._validatorRegistry.validators[name]) {\n        var constraint = new Constraint(this, name, requirements, priority, isDomConstraint); // if constraint already exist, delete it and push new version\n\n        if ('undefined' !== this.constraintsByName[constraint.name]) this.removeConstraint(constraint.name);\n        this.constraints.push(constraint);\n        this.constraintsByName[constraint.name] = constraint;\n      }\n\n      return this;\n    },\n    // Remove a constraint\n    removeConstraint: function removeConstraint(name) {\n      for (var i = 0; i < this.constraints.length; i++) {\n        if (name === this.constraints[i].name) {\n          this.constraints.splice(i, 1);\n          break;\n        }\n      }\n\n      delete this.constraintsByName[name];\n      return this;\n    },\n    // Update a constraint (Remove + re-add)\n    updateConstraint: function updateConstraint(name, parameters, priority) {\n      return this.removeConstraint(name).addConstraint(name, parameters, priority);\n    },\n    // # Internals\n    // Internal only.\n    // Bind constraints from config + options + DOM\n    _bindConstraints: function _bindConstraints() {\n      var constraints = [];\n      var constraintsByName = {}; // clean all existing DOM constraints to only keep javascript user constraints\n\n      for (var i = 0; i < this.constraints.length; i++) {\n        if (false === this.constraints[i].isDomConstraint) {\n          constraints.push(this.constraints[i]);\n          constraintsByName[this.constraints[i].name] = this.constraints[i];\n        }\n      }\n\n      this.constraints = constraints;\n      this.constraintsByName = constraintsByName; // then re-add Parsley DOM-API constraints\n\n      for (var name in this.options) {\n        this.addConstraint(name, this.options[name], undefined, true);\n      } // finally, bind special HTML5 constraints\n\n\n      return this._bindHtml5Constraints();\n    },\n    // Internal only.\n    // Bind specific HTML5 constraints to be HTML5 compliant\n    _bindHtml5Constraints: function _bindHtml5Constraints() {\n      // html5 required\n      if (null !== this.element.getAttribute('required')) this.addConstraint('required', true, undefined, true); // html5 pattern\n\n      if (null !== this.element.getAttribute('pattern')) this.addConstraint('pattern', this.element.getAttribute('pattern'), undefined, true); // range\n\n      var min = this.element.getAttribute('min');\n      var max = this.element.getAttribute('max');\n      if (null !== min && null !== max) this.addConstraint('range', [min, max], undefined, true); // HTML5 min\n      else if (null !== min) this.addConstraint('min', min, undefined, true); // HTML5 max\n        else if (null !== max) this.addConstraint('max', max, undefined, true); // length\n\n      if (null !== this.element.getAttribute('minlength') && null !== this.element.getAttribute('maxlength')) this.addConstraint('length', [this.element.getAttribute('minlength'), this.element.getAttribute('maxlength')], undefined, true); // HTML5 minlength\n      else if (null !== this.element.getAttribute('minlength')) this.addConstraint('minlength', this.element.getAttribute('minlength'), undefined, true); // HTML5 maxlength\n        else if (null !== this.element.getAttribute('maxlength')) this.addConstraint('maxlength', this.element.getAttribute('maxlength'), undefined, true); // html5 types\n\n      var type = Utils.getType(this.element); // Small special case here for HTML5 number: integer validator if step attribute is undefined or an integer value, number otherwise\n\n      if ('number' === type) {\n        return this.addConstraint('type', ['number', {\n          step: this.element.getAttribute('step') || '1',\n          base: min || this.element.getAttribute('value')\n        }], undefined, true); // Regular other HTML5 supported types\n      } else if (/^(email|url|range|date)$/i.test(type)) {\n        return this.addConstraint('type', type, undefined, true);\n      }\n\n      return this;\n    },\n    // Internal only.\n    // Field is required if have required constraint without `false` value\n    _isRequired: function _isRequired() {\n      if ('undefined' === typeof this.constraintsByName.required) return false;\n      return false !== this.constraintsByName.required.requirements;\n    },\n    // Internal only.\n    // Shortcut to trigger an event\n    _trigger: function _trigger(eventName) {\n      return this.trigger('field:' + eventName);\n    },\n    // Internal only\n    // Handles whitespace in a value\n    // Use `data-parsley-whitespace=\"squish\"` to auto squish input value\n    // Use `data-parsley-whitespace=\"trim\"` to auto trim input value\n    _handleWhitespace: function _handleWhitespace(value) {\n      if (true === this.options.trimValue) Utils.warnOnce('data-parsley-trim-value=\"true\" is deprecated, please use data-parsley-whitespace=\"trim\"');\n      if ('squish' === this.options.whitespace) value = value.replace(/\\s{2,}/g, ' ');\n      if ('trim' === this.options.whitespace || 'squish' === this.options.whitespace || true === this.options.trimValue) value = Utils.trimString(value);\n      return value;\n    },\n    _isDateInput: function _isDateInput() {\n      var c = this.constraintsByName.type;\n      return c && c.requirements === 'date';\n    },\n    // Internal only.\n    // Returns the constraints, grouped by descending priority.\n    // The result is thus an array of arrays of constraints.\n    _getGroupedConstraints: function _getGroupedConstraints() {\n      if (false === this.options.priorityEnabled) return [this.constraints];\n      var groupedConstraints = [];\n      var index = {}; // Create array unique of priorities\n\n      for (var i = 0; i < this.constraints.length; i++) {\n        var p = this.constraints[i].priority;\n        if (!index[p]) groupedConstraints.push(index[p] = []);\n        index[p].push(this.constraints[i]);\n      } // Sort them by priority DESC\n\n\n      groupedConstraints.sort(function (a, b) {\n        return b[0].priority - a[0].priority;\n      });\n      return groupedConstraints;\n    }\n  };\n\n  var Multiple = function Multiple() {\n    this.__class__ = 'FieldMultiple';\n  };\n\n  Multiple.prototype = {\n    // Add new `$element` sibling for multiple field\n    addElement: function addElement($element) {\n      this.$elements.push($element);\n      return this;\n    },\n    // See `Field._refreshConstraints()`\n    _refreshConstraints: function _refreshConstraints() {\n      var fieldConstraints;\n      this.constraints = []; // Select multiple special treatment\n\n      if (this.element.nodeName === 'SELECT') {\n        this.actualizeOptions()._bindConstraints();\n\n        return this;\n      } // Gather all constraints for each input in the multiple group\n\n\n      for (var i = 0; i < this.$elements.length; i++) {\n        // Check if element have not been dynamically removed since last binding\n        if (!$('html').has(this.$elements[i]).length) {\n          this.$elements.splice(i, 1);\n          continue;\n        }\n\n        fieldConstraints = this.$elements[i].data('FieldMultiple')._refreshConstraints().constraints;\n\n        for (var j = 0; j < fieldConstraints.length; j++) {\n          this.addConstraint(fieldConstraints[j].name, fieldConstraints[j].requirements, fieldConstraints[j].priority, fieldConstraints[j].isDomConstraint);\n        }\n      }\n\n      return this;\n    },\n    // See `Field.getValue()`\n    getValue: function getValue() {\n      // Value could be overriden in DOM\n      if ('function' === typeof this.options.value) return this.options.value(this);else if ('undefined' !== typeof this.options.value) return this.options.value; // Radio input case\n\n      if (this.element.nodeName === 'INPUT') {\n        var type = Utils.getType(this.element);\n        if (type === 'radio') return this._findRelated().filter(':checked').val() || ''; // checkbox input case\n\n        if (type === 'checkbox') {\n          var values = [];\n\n          this._findRelated().filter(':checked').each(function () {\n            values.push($(this).val());\n          });\n\n          return values;\n        }\n      } // Select multiple case\n\n\n      if (this.element.nodeName === 'SELECT' && null === this.$element.val()) return []; // Default case that should never happen\n\n      return this.$element.val();\n    },\n    _init: function _init() {\n      this.$elements = [this.$element];\n      return this;\n    }\n  };\n\n  var Factory = function Factory(element, options, parsleyFormInstance) {\n    this.element = element;\n    this.$element = $(element); // If the element has already been bound, returns its saved Parsley instance\n\n    var savedparsleyFormInstance = this.$element.data('Parsley');\n\n    if (savedparsleyFormInstance) {\n      // If the saved instance has been bound without a Form parent and there is one given in this call, add it\n      if ('undefined' !== typeof parsleyFormInstance && savedparsleyFormInstance.parent === window.Parsley) {\n        savedparsleyFormInstance.parent = parsleyFormInstance;\n\n        savedparsleyFormInstance._resetOptions(savedparsleyFormInstance.options);\n      }\n\n      if ('object' === _typeof(options)) {\n        _extends(savedparsleyFormInstance.options, options);\n      }\n\n      return savedparsleyFormInstance;\n    } // Parsley must be instantiated with a DOM element or jQuery $element\n\n\n    if (!this.$element.length) throw new Error('You must bind Parsley on an existing element.');\n    if ('undefined' !== typeof parsleyFormInstance && 'Form' !== parsleyFormInstance.__class__) throw new Error('Parent instance must be a Form instance');\n    this.parent = parsleyFormInstance || window.Parsley;\n    return this.init(options);\n  };\n\n  Factory.prototype = {\n    init: function init(options) {\n      this.__class__ = 'Parsley';\n      this.__version__ = '2.9.0';\n      this.__id__ = Utils.generateID(); // Pre-compute options\n\n      this._resetOptions(options); // A Form instance is obviously a `<form>` element but also every node that is not an input and has the `data-parsley-validate` attribute\n\n\n      if (this.element.nodeName === 'FORM' || Utils.checkAttr(this.element, this.options.namespace, 'validate') && !this.$element.is(this.options.inputs)) return this.bind('parsleyForm'); // Every other element is bound as a `Field` or `FieldMultiple`\n\n      return this.isMultiple() ? this.handleMultiple() : this.bind('parsleyField');\n    },\n    isMultiple: function isMultiple() {\n      var type = Utils.getType(this.element);\n      return type === 'radio' || type === 'checkbox' || this.element.nodeName === 'SELECT' && null !== this.element.getAttribute('multiple');\n    },\n    // Multiples fields are a real nightmare :(\n    // Maybe some refactoring would be appreciated here...\n    handleMultiple: function handleMultiple() {\n      var _this = this;\n\n      var name;\n      var parsleyMultipleInstance; // Handle multiple name\n\n      this.options.multiple = this.options.multiple || (name = this.element.getAttribute('name')) || this.element.getAttribute('id'); // Special select multiple input\n\n      if (this.element.nodeName === 'SELECT' && null !== this.element.getAttribute('multiple')) {\n        this.options.multiple = this.options.multiple || this.__id__;\n        return this.bind('parsleyFieldMultiple'); // Else for radio / checkboxes, we need a `name` or `data-parsley-multiple` to properly bind it\n      } else if (!this.options.multiple) {\n        Utils.warn('To be bound by Parsley, a radio, a checkbox and a multiple select input must have either a name or a multiple option.', this.$element);\n        return this;\n      } // Remove special chars\n\n\n      this.options.multiple = this.options.multiple.replace(/(:|\\.|\\[|\\]|\\{|\\}|\\$)/g, ''); // Add proper `data-parsley-multiple` to siblings if we have a valid multiple name\n\n      if (name) {\n        $('input[name=\"' + name + '\"]').each(function (i, input) {\n          var type = Utils.getType(input);\n          if (type === 'radio' || type === 'checkbox') input.setAttribute(_this.options.namespace + 'multiple', _this.options.multiple);\n        });\n      } // Check here if we don't already have a related multiple instance saved\n\n\n      var $previouslyRelated = this._findRelated();\n\n      for (var i = 0; i < $previouslyRelated.length; i++) {\n        parsleyMultipleInstance = $($previouslyRelated.get(i)).data('Parsley');\n\n        if ('undefined' !== typeof parsleyMultipleInstance) {\n          if (!this.$element.data('FieldMultiple')) {\n            parsleyMultipleInstance.addElement(this.$element);\n          }\n\n          break;\n        }\n      } // Create a secret Field instance for every multiple field. It will be stored in `data('FieldMultiple')`\n      // And will be useful later to access classic `Field` stuff while being in a `FieldMultiple` instance\n\n\n      this.bind('parsleyField', true);\n      return parsleyMultipleInstance || this.bind('parsleyFieldMultiple');\n    },\n    // Return proper `Form`, `Field` or `FieldMultiple`\n    bind: function bind(type, doNotStore) {\n      var parsleyInstance;\n\n      switch (type) {\n        case 'parsleyForm':\n          parsleyInstance = $.extend(new Form(this.element, this.domOptions, this.options), new Base(), window.ParsleyExtend)._bindFields();\n          break;\n\n        case 'parsleyField':\n          parsleyInstance = $.extend(new Field(this.element, this.domOptions, this.options, this.parent), new Base(), window.ParsleyExtend);\n          break;\n\n        case 'parsleyFieldMultiple':\n          parsleyInstance = $.extend(new Field(this.element, this.domOptions, this.options, this.parent), new Multiple(), new Base(), window.ParsleyExtend)._init();\n          break;\n\n        default:\n          throw new Error(type + 'is not a supported Parsley type');\n      }\n\n      if (this.options.multiple) Utils.setAttr(this.element, this.options.namespace, 'multiple', this.options.multiple);\n\n      if ('undefined' !== typeof doNotStore) {\n        this.$element.data('FieldMultiple', parsleyInstance);\n        return parsleyInstance;\n      } // Store the freshly bound instance in a DOM element for later access using jQuery `data()`\n\n\n      this.$element.data('Parsley', parsleyInstance); // Tell the world we have a new Form or Field instance!\n\n      parsleyInstance._actualizeTriggers();\n\n      parsleyInstance._trigger('init');\n\n      return parsleyInstance;\n    }\n  };\n\n  var vernums = $.fn.jquery.split('.');\n\n  if (parseInt(vernums[0]) <= 1 && parseInt(vernums[1]) < 8) {\n    throw \"The loaded version of jQuery is too old. Please upgrade to 1.8.x or better.\";\n  }\n\n  if (!vernums.forEach) {\n    Utils.warn('Parsley requires ES5 to run properly. Please include https://github.com/es-shims/es5-shim');\n  } // Inherit `on`, `off` & `trigger` to Parsley:\n\n\n  var Parsley = _extends(new Base(), {\n    element: document,\n    $element: $(document),\n    actualizeOptions: null,\n    _resetOptions: null,\n    Factory: Factory,\n    version: '2.9.0'\n  }); // Supplement Field and Form with Base\n  // This way, the constructors will have access to those methods\n\n\n  _extends(Field.prototype, UI.Field, Base.prototype);\n\n  _extends(Form.prototype, UI.Form, Base.prototype); // Inherit actualizeOptions and _resetOptions:\n\n\n  _extends(Factory.prototype, Base.prototype); // ### jQuery API\n  // `$('.elem').parsley(options)` or `$('.elem').psly(options)`\n\n\n  $.fn.parsley = $.fn.psly = function (options) {\n    if (this.length > 1) {\n      var instances = [];\n      this.each(function () {\n        instances.push($(this).parsley(options));\n      });\n      return instances;\n    } // Return undefined if applied to non existing DOM element\n\n\n    if (this.length == 0) {\n      return;\n    }\n\n    return new Factory(this[0], options);\n  }; // ### Field and Form extension\n  // Ensure the extension is now defined if it wasn't previously\n\n\n  if ('undefined' === typeof window.ParsleyExtend) window.ParsleyExtend = {}; // ### Parsley config\n  // Inherit from ParsleyDefault, and copy over any existing values\n\n  Parsley.options = _extends(Utils.objectCreate(Defaults), window.ParsleyConfig);\n  window.ParsleyConfig = Parsley.options; // Old way of accessing global options\n  // ### Globals\n\n  window.Parsley = window.psly = Parsley;\n  Parsley.Utils = Utils;\n  window.ParsleyUtils = {};\n  $.each(Utils, function (key, value) {\n    if ('function' === typeof value) {\n      window.ParsleyUtils[key] = function () {\n        Utils.warnOnce('Accessing `window.ParsleyUtils` is deprecated. Use `window.Parsley.Utils` instead.');\n        return Utils[key].apply(Utils, arguments);\n      };\n    }\n  }); // ### Define methods that forward to the registry, and deprecate all access except through window.Parsley\n\n  var registry = window.Parsley._validatorRegistry = new ValidatorRegistry(window.ParsleyConfig.validators, window.ParsleyConfig.i18n);\n  window.ParsleyValidator = {};\n  $.each('setLocale addCatalog addMessage addMessages getErrorMessage formatMessage addValidator updateValidator removeValidator hasValidator'.split(' '), function (i, method) {\n    window.Parsley[method] = function () {\n      return registry[method].apply(registry, arguments);\n    };\n\n    window.ParsleyValidator[method] = function () {\n      var _window$Parsley;\n\n      Utils.warnOnce(\"Accessing the method '\".concat(method, \"' through Validator is deprecated. Simply call 'window.Parsley.\").concat(method, \"(...)'\"));\n      return (_window$Parsley = window.Parsley)[method].apply(_window$Parsley, arguments);\n    };\n  }); // ### UI\n  // Deprecated global object\n\n  window.Parsley.UI = UI;\n  window.ParsleyUI = {\n    removeError: function removeError(instance, name, doNotUpdateClass) {\n      var updateClass = true !== doNotUpdateClass;\n      Utils.warnOnce(\"Accessing UI is deprecated. Call 'removeError' on the instance directly. Please comment in issue 1073 as to your need to call this method.\");\n      return instance.removeError(name, {\n        updateClass: updateClass\n      });\n    },\n    getErrorsMessages: function getErrorsMessages(instance) {\n      Utils.warnOnce(\"Accessing UI is deprecated. Call 'getErrorsMessages' on the instance directly.\");\n      return instance.getErrorsMessages();\n    }\n  };\n  $.each('addError updateError'.split(' '), function (i, method) {\n    window.ParsleyUI[method] = function (instance, name, message, assert, doNotUpdateClass) {\n      var updateClass = true !== doNotUpdateClass;\n      Utils.warnOnce(\"Accessing UI is deprecated. Call '\".concat(method, \"' on the instance directly. Please comment in issue 1073 as to your need to call this method.\"));\n      return instance[method](name, {\n        message: message,\n        assert: assert,\n        updateClass: updateClass\n      });\n    };\n  }); // ### PARSLEY auto-binding\n  // Prevent it by setting `ParsleyConfig.autoBind` to `false`\n\n  if (false !== window.ParsleyConfig.autoBind) {\n    $(function () {\n      // Works only on `data-parsley-validate`.\n      if ($('[data-parsley-validate]').length) $('[data-parsley-validate]').parsley();\n    });\n  }\n\n  var o = $({});\n\n  var deprecated = function deprecated() {\n    Utils.warnOnce(\"Parsley's pubsub module is deprecated; use the 'on' and 'off' methods on parsley instances or window.Parsley\");\n  }; // Returns an event handler that calls `fn` with the arguments it expects\n\n\n  function adapt(fn, context) {\n    // Store to allow unbinding\n    if (!fn.parsleyAdaptedCallback) {\n      fn.parsleyAdaptedCallback = function () {\n        var args = Array.prototype.slice.call(arguments, 0);\n        args.unshift(this);\n        fn.apply(context || o, args);\n      };\n    }\n\n    return fn.parsleyAdaptedCallback;\n  }\n\n  var eventPrefix = 'parsley:'; // Converts 'parsley:form:validate' into 'form:validate'\n\n  function eventName(name) {\n    if (name.lastIndexOf(eventPrefix, 0) === 0) return name.substr(eventPrefix.length);\n    return name;\n  } // $.listen is deprecated. Use Parsley.on instead.\n\n\n  $.listen = function (name, callback) {\n    var context;\n    deprecated();\n\n    if ('object' === _typeof(arguments[1]) && 'function' === typeof arguments[2]) {\n      context = arguments[1];\n      callback = arguments[2];\n    }\n\n    if ('function' !== typeof callback) throw new Error('Wrong parameters');\n    window.Parsley.on(eventName(name), adapt(callback, context));\n  };\n\n  $.listenTo = function (instance, name, fn) {\n    deprecated();\n    if (!(instance instanceof Field) && !(instance instanceof Form)) throw new Error('Must give Parsley instance');\n    if ('string' !== typeof name || 'function' !== typeof fn) throw new Error('Wrong parameters');\n    instance.on(eventName(name), adapt(fn));\n  };\n\n  $.unsubscribe = function (name, fn) {\n    deprecated();\n    if ('string' !== typeof name || 'function' !== typeof fn) throw new Error('Wrong arguments');\n    window.Parsley.off(eventName(name), fn.parsleyAdaptedCallback);\n  };\n\n  $.unsubscribeTo = function (instance, name) {\n    deprecated();\n    if (!(instance instanceof Field) && !(instance instanceof Form)) throw new Error('Must give Parsley instance');\n    instance.off(eventName(name));\n  };\n\n  $.unsubscribeAll = function (name) {\n    deprecated();\n    window.Parsley.off(eventName(name));\n    $('form,input,textarea,select').each(function () {\n      var instance = $(this).data('Parsley');\n\n      if (instance) {\n        instance.off(eventName(name));\n      }\n    });\n  }; // $.emit is deprecated. Use jQuery events instead.\n\n\n  $.emit = function (name, instance) {\n    var _instance;\n\n    deprecated();\n    var instanceGiven = instance instanceof Field || instance instanceof Form;\n    var args = Array.prototype.slice.call(arguments, instanceGiven ? 2 : 1);\n    args.unshift(eventName(name));\n\n    if (!instanceGiven) {\n      instance = window.Parsley;\n    }\n\n    (_instance = instance).trigger.apply(_instance, _toConsumableArray(args));\n  };\n\n  $.extend(true, Parsley, {\n    asyncValidators: {\n      'default': {\n        fn: function fn(xhr) {\n          // By default, only status 2xx are deemed successful.\n          // Note: we use status instead of state() because responses with status 200\n          // but invalid messages (e.g. an empty body for content type set to JSON) will\n          // result in state() === 'rejected'.\n          return xhr.status >= 200 && xhr.status < 300;\n        },\n        url: false\n      },\n      reverse: {\n        fn: function fn(xhr) {\n          // If reverse option is set, a failing ajax request is considered successful\n          return xhr.status < 200 || xhr.status >= 300;\n        },\n        url: false\n      }\n    },\n    addAsyncValidator: function addAsyncValidator(name, fn, url, options) {\n      Parsley.asyncValidators[name] = {\n        fn: fn,\n        url: url || false,\n        options: options || {}\n      };\n      return this;\n    }\n  });\n  Parsley.addValidator('remote', {\n    requirementType: {\n      '': 'string',\n      'validator': 'string',\n      'reverse': 'boolean',\n      'options': 'object'\n    },\n    validateString: function validateString(value, url, options, instance) {\n      var data = {};\n      var ajaxOptions;\n      var csr;\n      var validator = options.validator || (true === options.reverse ? 'reverse' : 'default');\n      if ('undefined' === typeof Parsley.asyncValidators[validator]) throw new Error('Calling an undefined async validator: `' + validator + '`');\n      url = Parsley.asyncValidators[validator].url || url; // Fill current value\n\n      if (url.indexOf('{value}') > -1) {\n        url = url.replace('{value}', encodeURIComponent(value));\n      } else {\n        data[instance.element.getAttribute('name') || instance.element.getAttribute('id')] = value;\n      } // Merge options passed in from the function with the ones in the attribute\n\n\n      var remoteOptions = $.extend(true, options.options || {}, Parsley.asyncValidators[validator].options); // All `$.ajax(options)` could be overridden or extended directly from DOM in `data-parsley-remote-options`\n\n      ajaxOptions = $.extend(true, {}, {\n        url: url,\n        data: data,\n        type: 'GET'\n      }, remoteOptions); // Generate store key based on ajax options\n\n      instance.trigger('field:ajaxoptions', instance, ajaxOptions);\n      csr = $.param(ajaxOptions); // Initialise querry cache\n\n      if ('undefined' === typeof Parsley._remoteCache) Parsley._remoteCache = {}; // Try to retrieve stored xhr\n\n      var xhr = Parsley._remoteCache[csr] = Parsley._remoteCache[csr] || $.ajax(ajaxOptions);\n\n      var handleXhr = function handleXhr() {\n        var result = Parsley.asyncValidators[validator].fn.call(instance, xhr, url, options);\n        if (!result) // Map falsy results to rejected promise\n          result = $.Deferred().reject();\n        return $.when(result);\n      };\n\n      return xhr.then(handleXhr, handleXhr);\n    },\n    priority: -1\n  });\n  Parsley.on('form:submit', function () {\n    Parsley._remoteCache = {};\n  });\n\n  Base.prototype.addAsyncValidator = function () {\n    Utils.warnOnce('Accessing the method `addAsyncValidator` through an instance is deprecated. Simply call `Parsley.addAsyncValidator(...)`');\n    return Parsley.addAsyncValidator.apply(Parsley, arguments);\n  };\n\n  // This is included with the Parsley library itself,\n  Parsley.addMessages('en', {\n    defaultMessage: \"This value seems to be invalid.\",\n    type: {\n      email: \"This value should be a valid email.\",\n      url: \"This value should be a valid url.\",\n      number: \"This value should be a valid number.\",\n      integer: \"This value should be a valid integer.\",\n      digits: \"This value should be digits.\",\n      alphanum: \"This value should be alphanumeric.\"\n    },\n    notblank: \"This value should not be blank.\",\n    required: \"This value is required.\",\n    pattern: \"This value seems to be invalid.\",\n    min: \"This value should be greater than or equal to %s.\",\n    max: \"This value should be lower than or equal to %s.\",\n    range: \"This value should be between %s and %s.\",\n    minlength: \"This value is too short. It should have %s characters or more.\",\n    maxlength: \"This value is too long. It should have %s characters or fewer.\",\n    length: \"This value length is invalid. It should be between %s and %s characters long.\",\n    mincheck: \"You must select at least %s choices.\",\n    maxcheck: \"You must select %s choices or fewer.\",\n    check: \"You must select between %s and %s choices.\",\n    equalto: \"This value should be the same.\",\n    euvatin: \"It's not a valid VAT Identification Number.\"\n  });\n  Parsley.setLocale('en');\n\n  function InputEvent() {\n    var _this = this;\n\n    var globals = window || global; // Slightly odd way construct our object. This way methods are force bound.\n    // Used to test for duplicate library.\n\n    _extends(this, {\n      // For browsers that do not support isTrusted, assumes event is native.\n      isNativeEvent: function isNativeEvent(evt) {\n        return evt.originalEvent && evt.originalEvent.isTrusted !== false;\n      },\n      fakeInputEvent: function fakeInputEvent(evt) {\n        if (_this.isNativeEvent(evt)) {\n          $(evt.target).trigger('input');\n        }\n      },\n      misbehaves: function misbehaves(evt) {\n        if (_this.isNativeEvent(evt)) {\n          _this.behavesOk(evt);\n\n          $(document).on('change.inputevent', evt.data.selector, _this.fakeInputEvent);\n\n          _this.fakeInputEvent(evt);\n        }\n      },\n      behavesOk: function behavesOk(evt) {\n        if (_this.isNativeEvent(evt)) {\n          $(document) // Simply unbinds the testing handler\n          .off('input.inputevent', evt.data.selector, _this.behavesOk).off('change.inputevent', evt.data.selector, _this.misbehaves);\n        }\n      },\n      // Bind the testing handlers\n      install: function install() {\n        if (globals.inputEventPatched) {\n          return;\n        }\n\n        globals.inputEventPatched = '0.0.3';\n        var _arr = ['select', 'input[type=\"checkbox\"]', 'input[type=\"radio\"]', 'input[type=\"file\"]'];\n\n        for (var _i = 0; _i < _arr.length; _i++) {\n          var selector = _arr[_i];\n          $(document).on('input.inputevent', selector, {\n            selector: selector\n          }, _this.behavesOk).on('change.inputevent', selector, {\n            selector: selector\n          }, _this.misbehaves);\n        }\n      },\n      uninstall: function uninstall() {\n        delete globals.inputEventPatched;\n        $(document).off('.inputevent');\n      }\n    });\n  }\n  var inputevent = new InputEvent();\n\n  inputevent.install();\n\n  return Parsley;\n\n})));\n//# sourceMappingURL=parsley.js.map\n","(() => {\r\n  const deferFn = () => {\r\n    const parser: DOMParser = new DOMParser();\r\n\r\n    const deferLinks = (parsedDocument: Document) => {\r\n      const linkElement: HTMLLinkElement = document.getElementsByTagName('link')[0];\r\n      let html: string = parsedDocument.documentElement.innerHTML || parsedDocument.documentElement.textContent;\r\n\r\n      if (html.indexOf('&lt;') > -1 || html.indexOf('&gt;') > -1) {\r\n        html = html.replace(/&lt;/gi, '<').replace(/&gt;/g, '>');\r\n      }\r\n\r\n      linkElement.insertAdjacentHTML('beforebegin', html);\r\n    };\r\n\r\n    const deferScripts = (parsedDocument: Document) => {\r\n      const head: HTMLHeadElement = document.getElementsByTagName('head')[0];\r\n      const nodes: HTMLScriptElement[] = [].slice.call(parsedDocument.documentElement.childNodes);\r\n\r\n      for (const script of nodes) {\r\n        if ((script.tagName || '').toLowerCase() !== 'script') {\r\n          continue;\r\n        }\r\n\r\n        const dtoScript: HTMLScriptElement = document.createElement('script');\r\n        dtoScript.type = 'text/javascript';\r\n        dtoScript.defer = true;\r\n        dtoScript.async = true;\r\n        dtoScript.setAttribute('src', script.getAttribute('src'));\r\n        head.insertBefore(dtoScript, head.firstChild);\r\n      }\r\n    };\r\n\r\n    const deferredElements: NodeListOf<HTMLElement> = document.querySelectorAll('noscript[defer]');\r\n    Array.prototype.forEach.call(deferredElements, (deferredElement: HTMLElement) => {\r\n      const innerHtml: string = (deferredElement.innerHTML || '').trim().replace('\\n', '');\r\n      const html: string = (deferredElement.innerHTML || '').trim().replace('\\n', '');\r\n\r\n      if (innerHtml === '') {\r\n        return;\r\n      }\r\n\r\n      const parsedDocument: Document = parser.parseFromString(html, 'text/html');\r\n      const deferType: string = (deferredElement.getAttribute('defer') || '').toLowerCase();\r\n\r\n      switch (deferType) {\r\n        case 'scripts':\r\n          deferScripts(parsedDocument);\r\n          break;\r\n\r\n        case 'links':\r\n        default:\r\n          deferLinks(parsedDocument);\r\n          break;\r\n      }\r\n\r\n      deferredElement.parentNode.removeChild(deferredElement);\r\n    });\r\n  };\r\n\r\n  const raf: (callback: FrameRequestCallback) => number =\r\n    requestAnimationFrame ||\r\n    (window as any).mozRequestAnimationFrame ||\r\n    webkitRequestAnimationFrame ||\r\n    (window as any).msRequestAnimationFrame;\r\n\r\n  if (raf) {\r\n    raf(deferFn);\r\n  } else {\r\n    window.addEventListener('load', deferFn);\r\n  }\r\n})();\r\n"],"sourceRoot":""}