{"version":3,"sources":["parsley.min.js","parsley.js","src/parsley/pubsub.js","src/vendor/inputevent.js","src/parsley/utils.js","src/parsley/defaults.js","src/parsley/base.js","src/parsley/validator.js","src/parsley/validator_registry.js","src/parsley/ui.js","src/parsley/form.js","src/parsley/constraint.js","src/parsley/field.js","src/parsley/multiple.js","src/parsley/factory.js","src/parsley/main.js","src/parsley/remote.js","src/i18n/en.js","src/parsley.js"],"names":["_toConsumableArray","arr","Array","isArray","i","arr2","length","from","_slice","prototype","slice","_slicedToArray","sliceIterator","_arr","_n","_d","_e","undefined","_s","_i","Symbol","iterator","next","done","push","value","err","Object","TypeError","_extends","assign","target","arguments","source","key","hasOwnProperty","call","global","factory","exports","module","require","define","amd","parsley","jQuery","this","$","adapt","fn","context","parsleyAdaptedCallback","args","unshift","apply","o","eventName","name","lastIndexOf","eventPrefix","substr","InputEvent","_this14","globals","window","isNativeEvent","evt","originalEvent","isTrusted","fakeInputEvent","trigger","misbehaves","behavesOk","document","on","data","selector","off","install","inputEventPatched","uninstall","globalID","pastWarnings","Utils","attr","element","namespace","obj","attribute","attributes","regex","RegExp","specified","test","camelize","deserializeValue","checkAttr","_checkAttr","hasAttribute","setAttr","setAttribute","dasherize","String","getType","getAttribute","generateID","num","isNaN","Number","JSON","parse","e","str","replace","match","chr","toUpperCase","toLowerCase","warn","_window$console","console","warnOnce","msg","_resetWarnings","trimString","string","date","parsed","_parsed$map","map","x","parseInt","_parsed$map2","year","month","day","Date","getFullYear","getMonth","getDate","_string","integer","number","parseFloat","boolean","object","regexp","_regexp","flags","parseRequirement","requirementType","converter","converted","namespaceEvents","events","split","join","difference","array","remove","result","each","_","elem","indexOf","all","promises","when","concat","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","options","domOptions","parent","_resetOptions","initOptions","_listeners","queue","subscribe","listenTo","splice","unsubscribe","unsubscribeTo","extraArg","asyncIsValid","force","whenValid","_findRelated","querySelectorAll","$element","convertArrayRequirement","m","values","convertExtraOptionRequirement","requirementSpec","extraOptionReader","main","extra","Validator","spec","extend","validate","requirementFirstArg","validateMultiple","instance","validateDate","_isDateInput","validateNumber","validateString","parseRequirements","requirements","type","isPlainObject","priority","ValidatorRegistry","validators","catalog","__class__","locale","init","typeTesters","email","digits","alphanum","url","range","decimalPlaces","Math","max","ValidatorRegistry__parseArguments","ValidatorRegistry__operatorToValidator","operator","_len","requirementsAndInput","_key","pop","ValidatorRegistry__comparisonOperator","addValidator","Parsley","setLocale","addCatalog","messages","set","addMessage","message","addMessages","nameMessageObject","arg1","arg2","_setValidator","hasValidator","updateValidator","removeValidator","validator","getErrorMessage","constraint","typeMessages","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","val","UI","diffResults","newResult","oldResult","deep","added","kept","found","j","assert","removed","Form","_actualizeTriggers","_this2","onSubmitValidate","onSubmitButton","_focusedField","fields","field","noFocus","_destroyUI","_reflowUI","_buildUI","_ui","diff","lastValidationResult","_manageStatusClass","_manageErrorsMessages","_failedOnce","getErrorsMessages","errorMessage","_getErrorMessage","addError","_ref2","_ref2$updateClass","updateClass","_addError","_errorClass","updateError","_ref3","_ref3$updateClass","_updateError","removeError","_ref4","_ref4$updateClass","_removeError","hasConstraints","needsValidation","_successClass","_resetClass","errorsMessagesDisabled","_insertErrorWrapper","$errorsWrapper","find","append","addClass","html","removeClass","_ref5","$errorClassHandler","errorsWrapperId","_ref6","removeAttr","customConstraintErrorMessage","_manageClassHandler","validationInformationVisible","$handlerFunction","$handler","_inputHolder","nodeName","$errorsContainer","after","_this3","$toBind","_validateIfNeeded","event","_this4","getValue","debounce","clearTimeout","_debounced","setTimeout","_resetUI","children","Form__statusMapping","pending","resolved","rejected","_this5","submitSource","_submitSource","prop","_remoteCache","whenValidate","state","_trigger","stopImmediatePropagation","preventDefault","_submit","currentTarget","$synthetic","appendTo","Event","_arguments","_Utils$all$done$fail$always","_this6","_ref7","submitEvent","_refreshFields","_withoutReactualizingFormOptions","fail","always","isValid","_arguments2","_this7","_ref8","refresh","reset","destroy","removeData","_bindFields","_this8","oldFields","fieldsMappedById","not","fieldInstance","Factory","uniqueId","oldActualizeOptions","Constraint","parsleyField","isDomConstraint","validatorSpec","_validatorRegistry","_parseRequirements","capitalize","cap","_validator","requirementList","_this9","parsleyFormInstance","constraints","constraintsByName","_bindConstraints","parsley_field__statusMapping","_whenValid$always$done$fail$always","_this10","_ref9","_isInGroup","_refreshed","_isRequired","validateIfEmpty","inArray","_arguments3","_this11","_ref10","_ref10$force","groupedConstraints","_getGroupedConstraints","_validateConstraint","_this12","_handleWhitespace","_refreshConstraints","refreshConstraints","addConstraint","removeConstraint","updateConstraint","_bindHtml5Constraints","trimValue","whitespace","c","index","p","sort","a","b","parsley_field","Multiple","addElement","$elements","fieldConstraints","has","filter","_init","savedparsleyFormInstance","__version__","is","bind","isMultiple","handleMultiple","parsleyMultipleInstance","_this13","input","$previouslyRelated","get","doNotStore","parsleyInstance","ParsleyExtend","vernums","jquery","forEach","version","psly","instances","ParsleyConfig","ParsleyUtils","registry","i18n","ParsleyValidator","method","_window$Parsley","ParsleyUI","doNotUpdateClass","autoBind","deprecated","listen","callback","unsubscribeAll","emit","_instance","instanceGiven","asyncValidators","default","xhr","status","reverse","addAsyncValidator","ajaxOptions","csr","encodeURIComponent","remoteOptions","param","ajax","handleXhr","then","inputevent"],"mappings":"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","file":"parsley.min.js","sourcesContent":["/*!\n* Parsley.js\n* Version 2.8.1 - built Sat, Feb 3rd 2018, 2:27 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//\nvar _slice = Array.prototype.slice;\n\nvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery')) : typeof define === 'function' && define.amd ? define(['jquery'], factory) : global.parsley = factory(global.jQuery);\n})(this, function ($) {\n  'use strict';\n\n  var globalID = 1;\n  var pastWarnings = {};\n\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\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\n      if (!element) return obj;\n\n      attributes = element.attributes;\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\n    checkAttr: function checkAttr(element, namespace, _checkAttr) {\n      return element.hasAttribute(namespace + _checkAttr);\n    },\n\n    setAttr: function setAttr(element, namespace, attr, value) {\n      element.setAttribute(this.dasherize(namespace + attr), String(value));\n    },\n\n    getType: function getType(element) {\n      return element.getAttribute('type') || 'text';\n    },\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\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\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\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\n    warnOnce: function warnOnce(msg) {\n      if (!pastWarnings[msg]) {\n        pastWarnings[msg] = true;\n        this.warn.apply(this, arguments);\n      }\n    },\n\n    _resetWarnings: function _resetWarnings() {\n      pastWarnings = {};\n    },\n\n    trimString: function trimString(string) {\n      return string.replace(/^\\s+|\\s+$/g, '');\n    },\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\n        var _parsed$map2 = _slicedToArray(_parsed$map, 4);\n\n        var _ = _parsed$map2[0];\n        var year = _parsed$map2[1];\n        var month = _parsed$map2[2];\n        var 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 = '';\n\n        // Test if RegExp is literal, if not, nothing to be done, otherwise, we need to isolate flags and pattern\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');\n          // Again, replace the regexp literal string with the first match group:\n          // everything excluding the opening and closing slashes and the flags\n          _regexp = _regexp.replace(new RegExp('^/(.*?)/' + flags + '$'), '$1');\n        } else {\n          // Anchor regexp:\n          _regexp = '^' + _regexp + '$';\n        }\n        return new RegExp(_regexp, flags);\n      }\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 ' + requirementType + ': \"' + string + '\"';\n      return converted;\n    },\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 evt + '.' + namespace;\n      }).join(' ');\n    },\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\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\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      return function (prototype) {\n        if (arguments.length > 1) {\n          throw Error('Second argument not supported');\n        }\n        if (typeof prototype != 'object') {\n          throw TypeError('Argument must be an object');\n        }\n        Object.prototype = prototype;\n        var result = new Object();\n        Object.prototype = null;\n        return result;\n      };\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\n  var Defaults = {\n    // ### General\n\n    // Default data-namespace for DOM API\n    namespace: 'data-parsley-',\n\n    // Supported inputs by default\n    inputs: 'input, textarea, select',\n\n    // Excluded inputs by default\n    excluded: 'input[type=button], input[type=submit], input[type=reset], input[type=hidden]',\n\n    // Stop validating field on highest priority failing constraint\n    priorityEnabled: true,\n\n    // ### Field only\n\n    // identifier used to group together inputs (e.g. radio buttons...)\n    multiple: null,\n\n    // identifier (or array of identifiers) used to validate only a select group of inputs\n    group: null,\n\n    // ### UI\n    // Enable\\Disable error messages\n    uiEnabled: true,\n\n    // Key events threshold before validation\n    validationThreshold: 3,\n\n    // Focused field on form validation error. 'first'|'last'|'none'\n    focus: 'first',\n\n    // event(s) that will trigger validation before first failure. eg: `input`...\n    trigger: false,\n\n    // event(s) that will trigger validation after first failure.\n    triggerAfterFailure: 'input',\n\n    // Class that would be added on every failing validation Parsley field\n    errorClass: 'parsley-error',\n\n    // Same for success validation\n    successClass: 'parsley-success',\n\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\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\n    // ul elem that would receive errors' list\n    errorsWrapper: '<ul class=\"parsley-errors-list\"></ul>',\n\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, // Deprecated\n\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      return [pipe, pipe];\n    },\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\n    _resetOptions: function _resetOptions(initOptions) {\n      this.domOptions = Utils.objectCreate(this.parent.options);\n      this.options = Utils.objectCreate(this.domOptions);\n      // Shallow copy of ownProperties of initOptions:\n      for (var i in initOptions) {\n        if (initOptions.hasOwnProperty(i)) this.options[i] = initOptions[i];\n      }\n      this.actualizeOptions();\n    },\n\n    _listeners: null,\n\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\n      return this;\n    },\n\n    // Deprecated. Use `on` instead\n    subscribe: function subscribe(name, fn) {\n      $.listenTo(this, name.toLowerCase(), fn);\n    },\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      if (queue) {\n        if (!fn) {\n          delete this._listeners[name];\n        } else {\n          for (var i = queue.length; i--;) if (queue[i] === fn) queue.splice(i, 1);\n        }\n      }\n      return this;\n    },\n\n    // Deprecated. Use `off`\n    unsubscribe: function unsubscribe(name, fn) {\n      $.unsubscribeTo(this, name.toLowerCase());\n    },\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      var parentResult;\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      if (this.parent) {\n        return this.parent.trigger(name, target, extraArg);\n      }\n      return true;\n    },\n\n    asyncIsValid: function asyncIsValid(group, force) {\n      Utils.warnOnce(\"asyncIsValid is deprecated; please use whenValid instead\");\n      return this.whenValid({ group: group, force: force });\n    },\n\n    _findRelated: function _findRelated() {\n      return this.options.multiple ? $(this.parent.element.querySelectorAll('[' + this.options.namespace + 'multiple=\"' + 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    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    return [main, extra];\n  };\n\n  // A Validator needs to implement the methods `validate` and `parseRequirements`\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\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        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        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        if (this.validateNumber) {\n          if (isNaN(value)) return false;\n          arguments[0] = parseFloat(arguments[0]);\n          return this.validateNumber.apply(this, arguments);\n        }\n        if (this.validateString) {\n          return this.validateString.apply(this, arguments);\n        }\n        throw 'Validator `' + this.name + '` only handles multiple values';\n      }\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      var type = this.requirementType;\n      if (Array.isArray(type)) {\n        var values = convertArrayRequirement(requirements, type.length);\n        for (var i = 0; i < values.length; i++) values[i] = Utils.parseRequirement(type[i], values[i]);\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\n    priority: 2\n\n  };\n\n  var ValidatorRegistry = function ValidatorRegistry(validators, catalog) {\n    this.__class__ = 'ValidatorRegistry';\n\n    // Default Parsley locale is en\n    this.locale = 'en';\n\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\n    // Follow https://www.w3.org/TR/html5/infrastructure.html#floating-point-numbers\n    number: /^-?(\\d*\\.)?\\d+(e[-+]?\\d+)?$/i,\n\n    integer: /^-?\\d+$/,\n\n    digits: /^\\d+$/,\n\n    alphanum: /^\\w+$/i,\n\n    date: {\n      test: function test(value) {\n        return Utils.parse.date(value) !== null;\n      }\n    },\n\n    url: new RegExp(\"^\" +\n    // protocol identifier\n    \"(?:(?:https?|ftp)://)?\" + // ** mod: make scheme optional\n    // user:pass authentication\n    \"(?:\\\\S+(?::\\\\S*)?@)?\" + \"(?:\" +\n    // 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]))\" + \"|\" +\n    // host name\n    '(?:(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)' +\n    // domain name\n    '(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)*' +\n    // TLD identifier\n    '(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff]{2,}))' + \")\" +\n    // port number\n    \"(?::\\\\d{2,5})?\" +\n    // resource path\n    \"(?:/\\\\S*)?\" + \"$\")\n  };\n  typeTesters.range = typeTesters.number;\n\n  // See http://stackoverflow.com/a/10454560/8279\n  var decimalPlaces = function decimalPlaces(num) {\n    var match = ('' + num).match(/(?:\\.(\\d+))?(?:[eE]([+-]?\\d+))?$/);\n    if (!match) {\n      return 0;\n    }\n    return Math.max(0,\n    // Number of digits right of decimal point.\n    (match[1] ? match[1].length : 0) - (\n    // Adjust for scientific notation.\n    match[2] ? +match[2] : 0));\n  };\n\n  // parseArguments('number', ['1', '2']) => [1, 2]\n  var ValidatorRegistry__parseArguments = function ValidatorRegistry__parseArguments(type, args) {\n    return args.map(Utils.parse[type]);\n  };\n  // operatorToValidator returns a validating function for an operator function, applied to the given type\n  var ValidatorRegistry__operatorToValidator = function ValidatorRegistry__operatorToValidator(type, operator) {\n    return function (value) {\n      for (var _len = arguments.length, requirementsAndInput = 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      return operator.apply(undefined, [value].concat(_toConsumableArray(ValidatorRegistry__parseArguments(type, requirementsAndInput))));\n    };\n  };\n\n  var ValidatorRegistry__comparisonOperator = function ValidatorRegistry__comparisonOperator(operator) {\n    return {\n      validateDate: ValidatorRegistry__operatorToValidator('date', operator),\n      validateNumber: ValidatorRegistry__operatorToValidator('number', operator),\n      requirementType: operator.length <= 2 ? 'string' : ['string', 'string'], // 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;\n      // Copy prototype's validators:\n      this.validators = _extends({}, this.validators);\n\n      for (var name in validators) this.addValidator(name, validators[name].fn, validators[name].priority);\n\n      window.Parsley.trigger('parsley:validator:init');\n    },\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\n      this.locale = locale;\n\n      return this;\n    },\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\n      if (true === set) return this.setLocale(locale);\n\n      return this;\n    },\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\n      this.catalog[locale][name] = message;\n\n      return this;\n    },\n\n    // Add messages for a given locale\n    addMessages: function addMessages(locale, nameMessageObject) {\n      for (var name in nameMessageObject) this.addMessage(locale, name, nameMessageObject[name]);\n\n      return this;\n    },\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\n    hasValidator: function hasValidator(name) {\n      return !!this.validators[name];\n    },\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      return this._setValidator.apply(this, arguments);\n    },\n\n    removeValidator: function removeValidator(name) {\n      if (!this.validators[name]) Utils.warn('Validator \"' + name + '\" is not defined.');\n\n      delete this.validators[name];\n\n      return this;\n    },\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      if (!validator.validate) {\n        validator = new Validator(validator);\n      }\n      this.validators[name] = validator;\n\n      for (var locale in validator.messages || {}) this.addMessage(locale, name, validator.messages[locale]);\n\n      return this;\n    },\n\n    getErrorMessage: function getErrorMessage(constraint) {\n      var message;\n\n      // Type constraints are a bit different, we have to match their requirements too to find right error message\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\n    // Kind of light `sprintf()` implementation\n    formatMessage: function formatMessage(string, parameters) {\n      if ('object' === typeof parameters) {\n        for (var i in parameters) string = this.formatMessage(string, parameters[i]);\n\n        return string;\n      }\n\n      return 'string' === typeof string ? string.replace(/%s/i, parameters) : '';\n    },\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        },\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        },\n        priority: 512\n      },\n      type: {\n        validateString: function validateString(value, type) {\n          var _ref = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];\n\n          var _ref$step = _ref.step;\n          var step = _ref$step === undefined ? 'any' : _ref$step;\n          var _ref$base = _ref.base;\n          var base = _ref$base === undefined ? 0 : _ref$base;\n\n          var tester = typeTesters[type];\n          if (!tester) {\n            throw new Error('validator type `' + type + '` is not supported');\n          }\n          if (!tester.test(value)) return false;\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;\n              // Be careful of rounding errors by using integers.\n              var toInt = function toInt(f) {\n                return Math.round(f * Math.pow(10, decimals));\n              };\n              if ((toInt(nb) - toInt(base)) % toInt(step) != 0) return false;\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          return regexp.test(value);\n        },\n        requirementType: 'regexp',\n        priority: 64\n      },\n      minlength: {\n        validateString: function validateString(value, requirement) {\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          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: ValidatorRegistry__comparisonOperator(function (value, requirement) {\n        return value >= requirement;\n      }),\n      max: ValidatorRegistry__comparisonOperator(function (value, requirement) {\n        return value <= requirement;\n      }),\n      range: ValidatorRegistry__comparisonOperator(function (value, min, max) {\n        return value >= min && value <= max;\n      }),\n      equalto: {\n        validateString: function validateString(value, refOrValue) {\n          var $reference = $(refOrValue);\n          if ($reference.length) return value === $reference.val();else return value === refOrValue;\n        },\n        priority: 256\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++) if (newResult[i].assert.name === oldResult[j].assert.name) {\n        found = true;\n        break;\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\n    _actualizeTriggers: function _actualizeTriggers() {\n      var _this2 = this;\n\n      this.$element.on('submit.Parsley', function (evt) {\n        _this2.onSubmitValidate(evt);\n      });\n      this.$element.on('click.Parsley', Utils._SubmitSelector, function (evt) {\n        _this2.onSubmitButton(evt);\n      });\n\n      // UI could be disabled\n      if (false === this.options.uiEnabled) return;\n\n      this.element.setAttribute('novalidate', '');\n    },\n\n    focus: function focus() {\n      this._focusedField = null;\n\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        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\n      return this._focusedField.focus();\n    },\n\n    _destroyUI: function _destroyUI() {\n      // Reset all event listeners\n      this.$element.off('.Parsley');\n    }\n\n  };\n\n  UI.Field = {\n\n    _reflowUI: function _reflowUI() {\n      this._buildUI();\n\n      // If this field doesn't have an active UI don't bother doing something\n      if (!this._ui) return;\n\n      // Diff between two validation results\n      var diff = diffResults(this.validationResult, this._ui.lastValidationResult);\n\n      // Then store current validation result for next reflow\n      this._ui.lastValidationResult = this.validationResult;\n\n      // Handle valid / invalid / none field class\n      this._manageStatusClass();\n\n      // Add, remove, updated errors messages\n      this._manageErrorsMessages(diff);\n\n      // Triggers impl\n      this._actualizeTriggers();\n\n      // If field is not valid for the first time, bind keyup trigger to ease UX and quickly inform user\n      if ((diff.kept.length || diff.added.length) && !this._failedOnce) {\n        this._failedOnce = true;\n        this._actualizeTriggers();\n      }\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\n      var messages = [];\n\n      for (var i = 0; i < this.validationResult.length; i++) messages.push(this.validationResult[i].errorMessage || this._getErrorMessage(this.validationResult[i].assert));\n\n      return messages;\n    },\n\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    addError: function addError(name) {\n      var _ref2 = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n      var message = _ref2.message;\n      var assert = _ref2.assert;\n      var _ref2$updateClass = _ref2.updateClass;\n      var updateClass = _ref2$updateClass === undefined ? true : _ref2$updateClass;\n\n      this._buildUI();\n      this._addError(name, { message: message, assert: assert });\n\n      if (updateClass) this._errorClass();\n    },\n\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    updateError: function updateError(name) {\n      var _ref3 = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n      var message = _ref3.message;\n      var assert = _ref3.assert;\n      var _ref3$updateClass = _ref3.updateClass;\n      var updateClass = _ref3$updateClass === undefined ? true : _ref3$updateClass;\n\n      this._buildUI();\n      this._updateError(name, { message: message, assert: assert });\n\n      if (updateClass) this._errorClass();\n    },\n\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    removeError: function removeError(name) {\n      var _ref4 = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n      var _ref4$updateClass = _ref4.updateClass;\n      var updateClass = _ref4$updateClass === undefined ? true : _ref4$updateClass;\n\n      this._buildUI();\n      this._removeError(name);\n\n      // 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      if (updateClass) this._manageStatusClass();\n    },\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\n    _manageErrorsMessages: function _manageErrorsMessages(diff) {\n      if ('undefined' !== typeof this.options.errorsMessagesDisabled) return;\n\n      // Case where we have errorMessage option that configure an unique field error message, regardless failing validators\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\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      }\n\n      // Show, hide, update failing constraints messages\n      for (var i = 0; i < diff.removed.length; i++) this._removeError(diff.removed[i].assert.name);\n\n      for (i = 0; i < diff.added.length; i++) this._addError(diff.added[i].assert.name, { message: diff.added[i].errorMessage, assert: diff.added[i].assert });\n\n      for (i = 0; i < diff.kept.length; i++) this._updateError(diff.kept[i].assert.name, { message: diff.kept[i].errorMessage, assert: diff.kept[i].assert });\n    },\n\n    _addError: function _addError(name, _ref5) {\n      var message = _ref5.message;\n      var assert = _ref5.assert;\n\n      this._insertErrorWrapper();\n      this._ui.$errorClassHandler.attr('aria-describedby', this._ui.errorsWrapperId);\n      this._ui.$errorsWrapper.addClass('filled').append($(this.options.errorTemplate).addClass('parsley-' + name).html(message || this._getErrorMessage(assert)));\n    },\n\n    _updateError: function _updateError(name, _ref6) {\n      var message = _ref6.message;\n      var assert = _ref6.assert;\n\n      this._ui.$errorsWrapper.addClass('filled').find('.parsley-' + name).html(message || this._getErrorMessage(assert));\n    },\n\n    _removeError: function _removeError(name) {\n      this._ui.$errorClassHandler.removeAttr('aria-describedby');\n      this._ui.$errorsWrapper.removeClass('filled').find('.parsley-' + name).remove();\n    },\n\n    _getErrorMessage: function _getErrorMessage(constraint) {\n      var customConstraintErrorMessage = constraint.name + 'Message';\n\n      if ('undefined' !== typeof this.options[customConstraintErrorMessage]) return window.Parsley.formatMessage(this.options[customConstraintErrorMessage], constraint.requirements);\n\n      return window.Parsley.getErrorMessage(constraint);\n    },\n\n    _buildUI: function _buildUI() {\n      // UI could be already built or disabled\n      if (this._ui || false === this.options.uiEnabled) return;\n\n      var _ui = {};\n\n      // Give field its Parsley id in DOM\n      this.element.setAttribute(this.options.namespace + 'id', this.__id__);\n\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      _ui.$errorClassHandler = this._manageClassHandler();\n\n      // $errorsWrapper is a div that would contain the various field errors, it will be appended into $errorsContainer\n      _ui.errorsWrapperId = 'parsley-id-' + (this.options.multiple ? 'multiple-' + this.options.multiple : this.__id__);\n      _ui.$errorsWrapper = $(this.options.errorsWrapper).attr('id', _ui.errorsWrapperId);\n\n      // ValidationResult UI storage to detect what have changed bwt two validations, and update DOM accordingly\n      _ui.lastValidationResult = [];\n      _ui.validationInformationVisible = false;\n\n      // Store it in this for later\n      this._ui = _ui;\n    },\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);\n\n      // Class handled could also be determined by function given in Parsley options\n      var $handlerFunction = this.options.classHandler;\n\n      // It might also be the function name of a global function\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);\n\n        // If this function returned a valid existing DOM element, go for it\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\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;\n\n      // But if multiple element (radio, checkbox), that would be their parent\n      return this.$element.parent();\n    },\n\n    _insertErrorWrapper: function _insertErrorWrapper() {\n      var $errorsContainer = this.options.errorsContainer;\n\n      // Nothing to do if already inserted\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\n      if ('object' === typeof $errorsContainer && $errorsContainer.length) return $errorsContainer.append(this._ui.$errorsWrapper);\n\n      return this._inputHolder().after(this._ui.$errorsWrapper);\n    },\n\n    _actualizeTriggers: function _actualizeTriggers() {\n      var _this3 = this;\n\n      var $toBind = this._findRelated();\n      var trigger;\n\n      // Remove Parsley events already bound on this field\n      $toBind.off('.Parsley');\n      if (this._failedOnce) $toBind.on(Utils.namespaceEvents(this.options.triggerAfterFailure, 'Parsley'), function () {\n        _this3._validateIfNeeded();\n      });else if (trigger = Utils.namespaceEvents(this.options.trigger, 'Parsley')) {\n        $toBind.on(trigger, function (event) {\n          _this3._validateIfNeeded(event);\n        });\n      }\n    },\n\n    _validateIfNeeded: function _validateIfNeeded(event) {\n      var _this4 = 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 _this4.validate();\n        }, this.options.debounce);\n      } else this.validate();\n    },\n\n    _resetUI: function _resetUI() {\n      // Reset all event listeners\n      this._failedOnce = false;\n      this._actualizeTriggers();\n\n      // Nothing to do if UI never initialized for this field\n      if ('undefined' === typeof this._ui) return;\n\n      // Reset all errors' li\n      this._ui.$errorsWrapper.removeClass('filled').children().remove();\n\n      // Reset validation class\n      this._resetClass();\n\n      // Reset validation flags and last validation result\n      this._ui.lastValidationResult = [];\n      this._ui.validationInformationVisible = false;\n    },\n\n    _destroyUI: function _destroyUI() {\n      this._resetUI();\n\n      if ('undefined' !== typeof this._ui) this._ui.$errorsWrapper.remove();\n\n      delete this._ui;\n    },\n\n    _successClass: function _successClass() {\n      this._ui.validationInformationVisible = true;\n      this._ui.$errorClassHandler.removeClass(this.options.errorClass).addClass(this.options.successClass);\n    },\n    _errorClass: function _errorClass() {\n      this._ui.validationInformationVisible = true;\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\n    this.element = element;\n    this.$element = $(element);\n    this.domOptions = domOptions;\n    this.options = options;\n    this.parent = window.Parsley;\n\n    this.fields = [];\n    this.validationResult = null;\n  };\n\n  var Form__statusMapping = { pending: null, resolved: true, rejected: false };\n\n  Form.prototype = {\n    onSubmitValidate: function onSubmitValidate(event) {\n      var _this5 = 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;\n\n      // If we didn't come here through a submit button, use the first one in the form\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\n      window.Parsley._remoteCache = {};\n\n      var promise = this.whenValidate({ event: event });\n\n      if ('resolved' === promise.state() && false !== this._trigger('submit')) {\n        // All good, let event go through. We make this distinction because browsers\n        // differ in their handling of `submit` being called from inside a submit event [#1047]\n      } else {\n          // Rejected or pending: cancel this submit\n          event.stopImmediatePropagation();\n          event.preventDefault();\n          if ('pending' === promise.state()) promise.done(function () {\n            _this5._submit(submitSource);\n          });\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;\n      // Add submit button's data\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'), { 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 = _slice.call(arguments);\n\n        var group = _arguments[0];\n        var force = _arguments[1];\n        var event = _arguments[2];\n\n        options = { group: group, force: force, event: event };\n      }\n      return Form__statusMapping[this.whenValidate(options).state()];\n    },\n\n    whenValidate: function whenValidate() {\n      var _Utils$all$done$fail$always,\n          _this6 = this;\n\n      var _ref7 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n      var group = _ref7.group;\n      var force = _ref7.force;\n      var event = _ref7.event;\n\n      this.submitEvent = event;\n      if (event) {\n        this.submitEvent = _extends({}, event, { preventDefault: function preventDefault() {\n            Utils.warnOnce(\"Using `this.submitEvent.preventDefault()` is deprecated; instead, call `this.validationResult = false`\");\n            _this6.validationResult = false;\n          } });\n      }\n      this.validationResult = true;\n\n      // fire validate event to eventually modify things before every validation\n      this._trigger('validate');\n\n      // Refresh form DOM options and form's fields that could have changed\n      this._refreshFields();\n\n      var promises = this._withoutReactualizingFormOptions(function () {\n        return $.map(_this6.fields, function (field) {\n          return field.whenValidate({ force: force, group: group });\n        });\n      });\n\n      return (_Utils$all$done$fail$always = Utils.all(promises).done(function () {\n        _this6._trigger('success');\n      }).fail(function () {\n        _this6.validationResult = false;\n        _this6.focus();\n        _this6._trigger('error');\n      }).always(function () {\n        _this6._trigger('validated');\n      })).pipe.apply(_Utils$all$done$fail$always, _toConsumableArray(this._pipeAccordingToValidationResult()));\n    },\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 = _slice.call(arguments);\n\n        var group = _arguments2[0];\n        var force = _arguments2[1];\n\n        options = { group: group, force: force };\n      }\n      return Form__statusMapping[this.whenValid(options).state()];\n    },\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 _this7 = this;\n\n      var _ref8 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n      var group = _ref8.group;\n      var force = _ref8.force;\n\n      this._refreshFields();\n\n      var promises = this._withoutReactualizingFormOptions(function () {\n        return $.map(_this7.fields, function (field) {\n          return field.whenValid({ group: group, force: force });\n        });\n      });\n      return Utils.all(promises);\n    },\n\n    refresh: function refresh() {\n      this._refreshFields();\n      return this;\n    },\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++) this.fields[i].reset();\n\n      this._trigger('reset');\n    },\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      // Form case: destroy all its fields and then destroy stored instance\n      for (var i = 0; i < this.fields.length; i++) this.fields[i].destroy();\n\n      this.$element.removeData('Parsley');\n      this._trigger('destroy');\n    },\n\n    _refreshFields: function _refreshFields() {\n      return this.actualizeOptions()._bindFields();\n    },\n\n    _bindFields: function _bindFields() {\n      var _this8 = this;\n\n      var oldFields = this.fields;\n\n      this.fields = [];\n      this.fieldsMappedById = {};\n\n      this._withoutReactualizingFormOptions(function () {\n        _this8.$element.find(_this8.options.inputs).not(_this8.options.excluded).each(function (_, element) {\n          var fieldInstance = new window.Parsley.Factory(element, {}, _this8);\n\n          // Only add valid and not excluded `Field` and `FieldMultiple` children\n          if (('Field' === fieldInstance.__class__ || 'FieldMultiple' === fieldInstance.__class__) && true !== fieldInstance.options.excluded) {\n            var uniqueId = fieldInstance.__class__ + '-' + fieldInstance.__id__;\n            if ('undefined' === typeof _this8.fieldsMappedById[uniqueId]) {\n              _this8.fieldsMappedById[uniqueId] = fieldInstance;\n              _this8.fields.push(fieldInstance);\n            }\n          }\n        });\n\n        $.each(Utils.difference(oldFields, _this8.fields), function (_, field) {\n          field.reset();\n        });\n      });\n      return this;\n    },\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      this.actualizeOptions = function () {\n        return this;\n      };\n      var result = fn();\n      this.actualizeOptions = oldActualizeOptions;\n      return result;\n    },\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\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    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 _validator;\n\n      return (_validator = this.validator).validate.apply(_validator, [value].concat(_toConsumableArray(this.requirementList), [instance]));\n    },\n\n    _parseRequirements: function _parseRequirements(options) {\n      var _this9 = this;\n\n      this.requirementList = this.validator.parseRequirements(this.requirements, function (key) {\n        return options[_this9.name + capitalize(key)];\n      });\n    }\n  };\n\n  var Field = function Field(field, domOptions, options, parsleyFormInstance) {\n    this.__class__ = 'Field';\n\n    this.element = field;\n    this.$element = $(field);\n\n    // Set parent if we have one\n    if ('undefined' !== typeof parsleyFormInstance) {\n      this.parent = parsleyFormInstance;\n    }\n\n    this.options = options;\n    this.domOptions = domOptions;\n\n    // Initialize some properties\n    this.constraints = [];\n    this.constraintsByName = {};\n    this.validationResult = true;\n\n    // Bind constraints\n    this._bindConstraints();\n  };\n\n  var parsley_field__statusMapping = { pending: null, resolved: true, 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 = { options: options };\n      }\n      var promise = this.whenValidate(options);\n      if (!promise) // If excluded with `group` option\n        return true;\n      switch (promise.state()) {\n        case 'pending':\n          return null;\n        case 'resolved':\n          return true;\n        case 'rejected':\n          return this.validationResult;\n      }\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 _whenValid$always$done$fail$always,\n          _this10 = this;\n\n      var _ref9 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n      var force = _ref9.force;\n      var group = _ref9.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\n      this.value = this.getValue();\n\n      // Field Validate event. `this.value` could be altered for custom needs\n      this._trigger('validate');\n\n      return (_whenValid$always$done$fail$always = this.whenValid({ force: force, value: this.value, _refreshed: true }).always(function () {\n        _this10._reflowUI();\n      }).done(function () {\n        _this10._trigger('success');\n      }).fail(function () {\n        _this10._trigger('error');\n      }).always(function () {\n        _this10._trigger('validated');\n      })).pipe.apply(_whenValid$always$done$fail$always, _toConsumableArray(this._pipeAccordingToValidationResult()));\n    },\n\n    hasConstraints: function hasConstraints() {\n      return 0 !== this.constraints.length;\n    },\n\n    // An empty optional field does not need validation\n    needsValidation: function needsValidation(value) {\n      if ('undefined' === typeof value) value = this.getValue();\n\n      // 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      if (!value.length && !this._isRequired() && 'undefined' === typeof this.options.validateIfEmpty) return false;\n\n      return true;\n    },\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\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 _arguments3 = _slice.call(arguments);\n\n        var force = _arguments3[0];\n        var value = _arguments3[1];\n\n        options = { force: force, value: value };\n      }\n      var promise = this.whenValid(options);\n      if (!promise) // Excluded via `group`\n        return true;\n      return parsley_field__statusMapping[promise.state()];\n    },\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 _this11 = this;\n\n      var _ref10 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n      var _ref10$force = _ref10.force;\n      var force = _ref10$force === undefined ? false : _ref10$force;\n      var value = _ref10.value;\n      var group = _ref10.group;\n      var _refreshed = _ref10._refreshed;\n\n      // Recompute options and rebind constraints to have latest changes\n      if (!_refreshed) this.refresh();\n      // do not validate a field if not the same as given validation group\n      if (group && !this._isInGroup(group)) return;\n\n      this.validationResult = true;\n\n      // A field without constraint is valid\n      if (!this.hasConstraints()) return $.when();\n\n      // Value could be passed as argument, needed to add more power to 'field:validate'\n      if ('undefined' === typeof value || null === value) value = this.getValue();\n\n      if (!this.needsValidation(value) && true !== force) return $.when();\n\n      var groupedConstraints = this._getGroupedConstraints();\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 _this11._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\n    // @returns a promise\n    _validateConstraint: function _validateConstraint(value, constraint) {\n      var _this12 = this;\n\n      var result = constraint.validate(value, this);\n      // Map false to a failed promise\n      if (false === result) result = $.Deferred().reject();\n      // Make sure we return a promise and that we record failures\n      return Utils.all([result]).fail(function (errorMessage) {\n        if (!(_this12.validationResult instanceof Array)) _this12.validationResult = [];\n        _this12.validationResult.push({\n          assert: constraint,\n          errorMessage: 'string' === typeof errorMessage && errorMessage\n        });\n      });\n    },\n\n    // @returns Parsley field computed value that could be overrided or configured in DOM\n    getValue: function getValue() {\n      var value;\n\n      // Value could be overriden in DOM or with explicit options\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();\n\n      // Handle wrong DOM or configurations\n      if ('undefined' === typeof value || null === value) return '';\n\n      return this._handleWhitespace(value);\n    },\n\n    // Reset UI\n    reset: function reset() {\n      this._resetUI();\n      return this._trigger('reset');\n    },\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      this.$element.removeData('Parsley');\n      this.$element.removeData('FieldMultiple');\n      this._trigger('destroy');\n    },\n\n    // Actualize options and rebind constraints\n    refresh: function refresh() {\n      this._refreshConstraints();\n      return this;\n    },\n\n    _refreshConstraints: function _refreshConstraints() {\n      return this.actualizeOptions()._bindConstraints();\n    },\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\n      if (window.Parsley._validatorRegistry.validators[name]) {\n        var constraint = new Constraint(this, name, requirements, priority, isDomConstraint);\n\n        // if constraint already exist, delete it and push new version\n        if ('undefined' !== this.constraintsByName[constraint.name]) this.removeConstraint(constraint.name);\n\n        this.constraints.push(constraint);\n        this.constraintsByName[constraint.name] = constraint;\n      }\n\n      return this;\n    },\n\n    // Remove a constraint\n    removeConstraint: function removeConstraint(name) {\n      for (var i = 0; i < this.constraints.length; i++) if (name === this.constraints[i].name) {\n        this.constraints.splice(i, 1);\n        break;\n      }\n      delete this.constraintsByName[name];\n      return this;\n    },\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\n    // # Internals\n\n    // Internal only.\n    // Bind constraints from config + options + DOM\n    _bindConstraints: function _bindConstraints() {\n      var constraints = [];\n      var constraintsByName = {};\n\n      // clean all existing DOM constraints to only keep javascript user constraints\n      for (var i = 0; i < this.constraints.length; i++) if (false === this.constraints[i].isDomConstraint) {\n        constraints.push(this.constraints[i]);\n        constraintsByName[this.constraints[i].name] = this.constraints[i];\n      }\n\n      this.constraints = constraints;\n      this.constraintsByName = constraintsByName;\n\n      // then re-add Parsley DOM-API constraints\n      for (var name in this.options) this.addConstraint(name, this.options[name], undefined, true);\n\n      // finally, bind special HTML5 constraints\n      return this._bindHtml5Constraints();\n    },\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);\n\n      // html5 pattern\n      if (null !== this.element.getAttribute('pattern')) this.addConstraint('pattern', this.element.getAttribute('pattern'), undefined, true);\n\n      // range\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);\n\n      // HTML5 min\n      else if (null !== min) this.addConstraint('min', min, undefined, true);\n\n        // HTML5 max\n        else if (null !== max) this.addConstraint('max', max, undefined, true);\n\n      // length\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);\n\n      // HTML5 minlength\n      else if (null !== this.element.getAttribute('minlength')) this.addConstraint('minlength', this.element.getAttribute('minlength'), undefined, true);\n\n        // HTML5 maxlength\n        else if (null !== this.element.getAttribute('maxlength')) this.addConstraint('maxlength', this.element.getAttribute('maxlength'), undefined, true);\n\n      // html5 types\n      var type = Utils.getType(this.element);\n\n      // Small special case here for HTML5 number: integer validator if step attribute is undefined or an integer value, number otherwise\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);\n        // 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      return this;\n    },\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\n      return false !== this.constraintsByName.required.requirements;\n    },\n\n    // Internal only.\n    // Shortcut to trigger an event\n    _trigger: function _trigger(eventName) {\n      return this.trigger('field:' + eventName);\n    },\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\n      if ('squish' === this.options.whitespace) value = value.replace(/\\s{2,}/g, ' ');\n\n      if ('trim' === this.options.whitespace || 'squish' === this.options.whitespace || true === this.options.trimValue) value = Utils.trimString(value);\n\n      return value;\n    },\n\n    _isDateInput: function _isDateInput() {\n      var c = this.constraintsByName.type;\n      return c && c.requirements === 'date';\n    },\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\n      var groupedConstraints = [];\n      var index = {};\n\n      // Create array unique of priorities\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      }\n      // Sort them by priority DESC\n      groupedConstraints.sort(function (a, b) {\n        return b[0].priority - a[0].priority;\n      });\n\n      return groupedConstraints;\n    }\n\n  };\n\n  var parsley_field = Field;\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\n      return this;\n    },\n\n    // See `Field._refreshConstraints()`\n    _refreshConstraints: function _refreshConstraints() {\n      var fieldConstraints;\n\n      this.constraints = [];\n\n      // Select multiple special treatment\n      if (this.element.nodeName === 'SELECT') {\n        this.actualizeOptions()._bindConstraints();\n\n        return this;\n      }\n\n      // Gather all constraints for each input in the multiple group\n      for (var i = 0; i < this.$elements.length; i++) {\n\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++) this.addConstraint(fieldConstraints[j].name, fieldConstraints[j].requirements, fieldConstraints[j].priority, fieldConstraints[j].isDomConstraint);\n      }\n\n      return this;\n    },\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;\n\n      // Radio input case\n      if (this.element.nodeName === 'INPUT') {\n        var type = Utils.getType(this.element);\n        if (type === 'radio') return this._findRelated().filter(':checked').val() || '';\n\n        // checkbox input case\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      }\n\n      // Select multiple case\n      if (this.element.nodeName === 'SELECT' && null === this.$element.val()) return [];\n\n      // Default case that should never happen\n      return this.$element.val();\n    },\n\n    _init: function _init() {\n      this.$elements = [this.$element];\n\n      return this;\n    }\n  };\n\n  var Factory = function Factory(element, options, parsleyFormInstance) {\n    this.element = element;\n    this.$element = $(element);\n\n    // If the element has already been bound, returns its saved Parsley instance\n    var savedparsleyFormInstance = this.$element.data('Parsley');\n    if (savedparsleyFormInstance) {\n\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        savedparsleyFormInstance._resetOptions(savedparsleyFormInstance.options);\n      }\n\n      if ('object' === typeof options) {\n        _extends(savedparsleyFormInstance.options, options);\n      }\n\n      return savedparsleyFormInstance;\n    }\n\n    // Parsley must be instantiated with a DOM element or jQuery $element\n    if (!this.$element.length) throw new Error('You must bind Parsley on an existing element.');\n\n    if ('undefined' !== typeof parsleyFormInstance && 'Form' !== parsleyFormInstance.__class__) throw new Error('Parent instance must be a Form instance');\n\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.8.1';\n      this.__id__ = Utils.generateID();\n\n      // Pre-compute options\n      this._resetOptions(options);\n\n      // 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      if (this.element.nodeName === 'FORM' || Utils.checkAttr(this.element, this.options.namespace, 'validate') && !this.$element.is(this.options.inputs)) return this.bind('parsleyForm');\n\n      // Every other element is bound as a `Field` or `FieldMultiple`\n      return this.isMultiple() ? this.handleMultiple() : this.bind('parsleyField');\n    },\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\n    // Multiples fields are a real nightmare :(\n    // Maybe some refactoring would be appreciated here...\n    handleMultiple: function handleMultiple() {\n      var _this13 = this;\n\n      var name;\n      var multiple;\n      var parsleyMultipleInstance;\n\n      // Handle multiple name\n      this.options.multiple = this.options.multiple || (name = this.element.getAttribute('name')) || this.element.getAttribute('id');\n\n      // Special select multiple input\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');\n\n        // 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        }\n\n      // Remove special chars\n      this.options.multiple = this.options.multiple.replace(/(:|\\.|\\[|\\]|\\{|\\}|\\$)/g, '');\n\n      // Add proper `data-parsley-multiple` to siblings if we have a valid multiple name\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(_this13.options.namespace + 'multiple', _this13.options.multiple);\n        });\n      }\n\n      // Check here if we don't already have a related multiple instance saved\n      var $previouslyRelated = this._findRelated();\n      for (var i = 0; i < $previouslyRelated.length; i++) {\n        parsleyMultipleInstance = $($previouslyRelated.get(i)).data('Parsley');\n        if ('undefined' !== typeof parsleyMultipleInstance) {\n\n          if (!this.$element.data('FieldMultiple')) {\n            parsleyMultipleInstance.addElement(this.$element);\n          }\n\n          break;\n        }\n      }\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      this.bind('parsleyField', true);\n\n      return parsleyMultipleInstance || this.bind('parsleyFieldMultiple');\n    },\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        case 'parsleyField':\n          parsleyInstance = $.extend(new parsley_field(this.element, this.domOptions, this.options, this.parent), new Base(), window.ParsleyExtend);\n          break;\n        case 'parsleyFieldMultiple':\n          parsleyInstance = $.extend(new parsley_field(this.element, this.domOptions, this.options, this.parent), new Multiple(), new Base(), window.ParsleyExtend)._init();\n          break;\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\n        return parsleyInstance;\n      }\n\n      // Store the freshly bound instance in a DOM element for later access using jQuery `data()`\n      this.$element.data('Parsley', parsleyInstance);\n\n      // Tell the world we have a new Form or Field instance!\n      parsleyInstance._actualizeTriggers();\n      parsleyInstance._trigger('init');\n\n      return parsleyInstance;\n    }\n  };\n\n  var vernums = $.fn.jquery.split('.');\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  if (!vernums.forEach) {\n    Utils.warn('Parsley requires ES5 to run properly. Please include https://github.com/es-shims/es5-shim');\n  }\n  // Inherit `on`, `off` & `trigger` to Parsley:\n  var Parsley = _extends(new Base(), {\n    element: document,\n    $element: $(document),\n    actualizeOptions: null,\n    _resetOptions: null,\n    Factory: Factory,\n    version: '2.8.1'\n  });\n\n  // Supplement Field and Form with Base\n  // This way, the constructors will have access to those methods\n  _extends(parsley_field.prototype, UI.Field, Base.prototype);\n  _extends(Form.prototype, UI.Form, Base.prototype);\n  // Inherit actualizeOptions and _resetOptions:\n  _extends(Factory.prototype, Base.prototype);\n\n  // ### jQuery API\n  // `$('.elem').parsley(options)` or `$('.elem').psly(options)`\n  $.fn.parsley = $.fn.psly = function (options) {\n    if (this.length > 1) {\n      var instances = [];\n\n      this.each(function () {\n        instances.push($(this).parsley(options));\n      });\n\n      return instances;\n    }\n\n    // Return undefined if applied to non existing DOM element\n    if (this.length == 0) {\n      return;\n    }\n\n    return new Factory(this[0], options);\n  };\n\n  // ### Field and Form extension\n  // Ensure the extension is now defined if it wasn't previously\n  if ('undefined' === typeof window.ParsleyExtend) window.ParsleyExtend = {};\n\n  // ### Parsley config\n  // Inherit from ParsleyDefault, and copy over any existing values\n  Parsley.options = _extends(Utils.objectCreate(Defaults), window.ParsleyConfig);\n  window.ParsleyConfig = Parsley.options; // Old way of accessing global options\n\n  // ### Globals\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  });\n\n  // ### Define methods that forward to the registry, and deprecate all access except through window.Parsley\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    window.ParsleyValidator[method] = function () {\n      var _window$Parsley;\n\n      Utils.warnOnce('Accessing the method \\'' + method + '\\' through Validator is deprecated. Simply call \\'window.Parsley.' + method + '(...)\\'');\n      return (_window$Parsley = window.Parsley)[method].apply(_window$Parsley, arguments);\n    };\n  });\n\n  // ### UI\n  // Deprecated global object\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, { updateClass: updateClass });\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 \\'' + method + '\\' on the instance directly. Please comment in issue 1073 as to your need to call this method.');\n      return instance[method](name, { message: message, assert: assert, updateClass: updateClass });\n    };\n  });\n\n  // ### PARSLEY auto-binding\n  // Prevent it by setting `ParsleyConfig.autoBind` to `false`\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  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  };\n\n  // Returns an event handler that calls `fn` with the arguments it expects\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    return fn.parsleyAdaptedCallback;\n  }\n\n  var eventPrefix = 'parsley:';\n  // Converts 'parsley:form:validate' into 'form:validate'\n  function eventName(name) {\n    if (name.lastIndexOf(eventPrefix, 0) === 0) return name.substr(eventPrefix.length);\n    return name;\n  }\n\n  // $.listen is deprecated. Use Parsley.on instead.\n  $.listen = function (name, callback) {\n    var context;\n    deprecated();\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\n    window.Parsley.on(eventName(name), adapt(callback, context));\n  };\n\n  $.listenTo = function (instance, name, fn) {\n    deprecated();\n    if (!(instance instanceof parsley_field) && !(instance instanceof Form)) throw new Error('Must give Parsley instance');\n\n    if ('string' !== typeof name || 'function' !== typeof fn) throw new Error('Wrong parameters');\n\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 parsley_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      if (instance) {\n        instance.off(eventName(name));\n      }\n    });\n  };\n\n  // $.emit is deprecated. Use jQuery events instead.\n  $.emit = function (name, instance) {\n    var _instance;\n\n    deprecated();\n    var instanceGiven = instance instanceof parsley_field || instance instanceof Form;\n    var args = Array.prototype.slice.call(arguments, instanceGiven ? 2 : 1);\n    args.unshift(eventName(name));\n    if (!instanceGiven) {\n      instance = window.Parsley;\n    }\n    (_instance = instance).trigger.apply(_instance, _toConsumableArray(args));\n  };\n\n  var pubsub = {};\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\n    addAsyncValidator: function addAsyncValidator(name, fn, url, options) {\n      Parsley.asyncValidators[name] = {\n        fn: fn,\n        url: url || false,\n        options: options || {}\n      };\n\n      return this;\n    }\n\n  });\n\n  Parsley.addValidator('remote', {\n    requirementType: {\n      '': 'string',\n      'validator': 'string',\n      'reverse': 'boolean',\n      'options': 'object'\n    },\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\n      if ('undefined' === typeof Parsley.asyncValidators[validator]) throw new Error('Calling an undefined async validator: `' + validator + '`');\n\n      url = Parsley.asyncValidators[validator].url || url;\n\n      // Fill current value\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      }\n\n      // Merge options passed in from the function with the ones in the attribute\n      var remoteOptions = $.extend(true, options.options || {}, Parsley.asyncValidators[validator].options);\n\n      // All `$.ajax(options)` could be overridden or extended directly from DOM in `data-parsley-remote-options`\n      ajaxOptions = $.extend(true, {}, {\n        url: url,\n        data: data,\n        type: 'GET'\n      }, remoteOptions);\n\n      // Generate store key based on ajax options\n      instance.trigger('field:ajaxoptions', instance, ajaxOptions);\n\n      csr = $.param(ajaxOptions);\n\n      // Initialise querry cache\n      if ('undefined' === typeof Parsley._remoteCache) Parsley._remoteCache = {};\n\n      // Try to retrieve stored xhr\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\n    priority: -1\n  });\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  // thus there is no use in adding it to your project.\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  });\n\n  Parsley.setLocale('en');\n\n  /**\n   * inputevent - Alleviate browser bugs for input events\n   * https://github.com/marcandre/inputevent\n   * @version v0.0.3 - (built Thu, Apr 14th 2016, 5:58 pm)\n   * @author Marc-Andre Lafortune <github@marc-andre.ca>\n   * @license MIT\n   */\n\n  function InputEvent() {\n    var _this14 = this;\n\n    var globals = window || global;\n\n    // Slightly odd way construct our object. This way methods are force bound.\n    // Used to test for duplicate library.\n    _extends(this, {\n\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\n      fakeInputEvent: function fakeInputEvent(evt) {\n        if (_this14.isNativeEvent(evt)) {\n          $(evt.target).trigger('input');\n        }\n      },\n\n      misbehaves: function misbehaves(evt) {\n        if (_this14.isNativeEvent(evt)) {\n          _this14.behavesOk(evt);\n          $(document).on('change.inputevent', evt.data.selector, _this14.fakeInputEvent);\n          _this14.fakeInputEvent(evt);\n        }\n      },\n\n      behavesOk: function behavesOk(evt) {\n        if (_this14.isNativeEvent(evt)) {\n          $(document) // Simply unbinds the testing handler\n          .off('input.inputevent', evt.data.selector, _this14.behavesOk).off('change.inputevent', evt.data.selector, _this14.misbehaves);\n        }\n      },\n\n      // Bind the testing handlers\n      install: function install() {\n        if (globals.inputEventPatched) {\n          return;\n        }\n        globals.inputEventPatched = '0.0.3';\n        var _arr = ['select', 'input[type=\"checkbox\"]', 'input[type=\"radio\"]', 'input[type=\"file\"]'];\n        for (var _i = 0; _i < _arr.length; _i++) {\n          var selector = _arr[_i];\n          $(document).on('input.inputevent', selector, { selector: selector }, _this14.behavesOk).on('change.inputevent', selector, { selector: selector }, _this14.misbehaves);\n        }\n      },\n\n      uninstall: function uninstall() {\n        delete globals.inputEventPatched;\n        $(document).off('.inputevent');\n      }\n\n    });\n  };\n\n  var inputevent = new InputEvent();\n\n  inputevent.install();\n\n  var parsley = Parsley;\n\n  return parsley;\n});\n//# sourceMappingURL=parsley.js.map\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.$)\n}(this, function ($) { 'use strict';\n\n  var globalID = 1;\n  var pastWarnings = {};\n\n  var Utils = {\n    // Parsley DOM-API\n    // returns object from dom attributes and values\n    attr: function (element, namespace, obj) {\n      var i;\n      var attribute;\n      var attributes;\n      var regex = new RegExp('^' + namespace, 'i');\n\n      if ('undefined' === typeof obj)\n        obj = {};\n      else {\n        // Clear all own properties. This won't affect prototype's values\n        for (i in obj) {\n          if (obj.hasOwnProperty(i))\n            delete obj[i];\n        }\n      }\n\n      if (!element)\n        return obj;\n\n      attributes = element.attributes;\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\n    checkAttr: function (element, namespace, checkAttr) {\n      return element.hasAttribute(namespace + checkAttr);\n    },\n\n    setAttr: function (element, namespace, attr, value) {\n      element.setAttribute(this.dasherize(namespace + attr), String(value));\n    },\n\n    getType: function(element) {\n      return element.getAttribute('type') || 'text';\n    },\n\n    generateID: function () {\n      return '' + globalID++;\n    },\n\n    /** Third party functions **/\n    deserializeValue: function (value) {\n      var num;\n\n      try {\n        return value ?\n          value == \"true\" ||\n          (value == \"false\" ? false :\n          value == \"null\" ? null :\n          !isNaN(num = Number(value)) ? num :\n          /^[\\[\\{]/.test(value) ? JSON.parse(value) :\n          value)\n          : value;\n      } catch (e) { return value; }\n    },\n\n    // Zepto camelize function\n    camelize: function (str) {\n      return str.replace(/-+(.)?/g, function (match, chr) {\n        return chr ? chr.toUpperCase() : '';\n      });\n    },\n\n    // Zepto dasherize function\n    dasherize: function (str) {\n      return str.replace(/::/g, '/')\n        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')\n        .replace(/([a-z\\d])([A-Z])/g, '$1_$2')\n        .replace(/_/g, '-')\n        .toLowerCase();\n    },\n\n    warn: function () {\n      if (window.console && 'function' === typeof window.console.warn)\n        window.console.warn(...arguments);\n    },\n\n    warnOnce: function(msg) {\n      if (!pastWarnings[msg]) {\n        pastWarnings[msg] = true;\n        this.warn(...arguments);\n      }\n    },\n\n    _resetWarnings: function () {\n      pastWarnings = {};\n    },\n\n    trimString: function(string) {\n      return string.replace(/^\\s+|\\s+$/g, '');\n    },\n\n    parse: {\n      date: function(string) {\n        let parsed = string.match(/^(\\d{4,})-(\\d\\d)-(\\d\\d)$/);\n        if (!parsed)\n          return null;\n        let [_, year, month, day] = parsed.map(x => parseInt(x, 10));\n        let date = new Date(year, month - 1, day);\n        if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day)\n          return null;\n        return date;\n      },\n      string: function(string) {\n        return string;\n      },\n      integer: function(string) {\n        if (isNaN(string))\n          return null;\n        return parseInt(string, 10);\n      },\n      number: function(string) {\n        if (isNaN(string))\n          throw null;\n        return parseFloat(string);\n      },\n      'boolean': function _boolean(string) {\n        return !(/^\\s*false\\s*$/i.test(string));\n      },\n      object: function(string) {\n        return Utils.deserializeValue(string);\n      },\n      regexp: function(regexp) {\n        var flags = '';\n\n        // Test if RegExp is literal, if not, nothing to be done, otherwise, we need to isolate flags and pattern\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');\n          // Again, replace the regexp literal string with the first match group:\n          // everything excluding the opening and closing slashes and the flags\n          regexp = regexp.replace(new RegExp('^/(.*?)/' + flags + '$'), '$1');\n        } else {\n          // Anchor regexp:\n          regexp = '^' + regexp + '$';\n        }\n        return new RegExp(regexp, flags);\n      }\n    },\n\n    parseRequirement: function(requirementType, string) {\n      var converter = this.parse[requirementType || 'string'];\n      if (!converter)\n        throw 'Unknown requirement specification: \"' + requirementType + '\"';\n      let converted = converter(string);\n      if (converted === null)\n        throw `Requirement is not a ${requirementType}: \"${string}\"`;\n      return converted;\n    },\n\n    namespaceEvents: function(events, namespace) {\n      events = this.trimString(events || '').split(/\\s+/);\n      if (!events[0])\n        return '';\n      return $.map(events, evt => `${evt}.${namespace}`).join(' ');\n    },\n\n    difference: function(array, remove) {\n      // This is O(N^2), should be optimized\n      let result = [];\n      $.each(array, (_, elem) => {\n        if (remove.indexOf(elem) == -1)\n          result.push(elem);\n      });\n      return result;\n    },\n\n    // Alter-ego to native Promise.all, but for jQuery\n    all: function(promises) {\n      // jQuery treats $.when() and $.when(singlePromise) differently; let's avoid that and add spurious elements\n      return $.when(...promises, 42, 42);\n    },\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 () {};\n      return function (prototype) {\n        if (arguments.length > 1) {\n          throw Error('Second argument not supported');\n        }\n        if (typeof prototype != 'object') {\n          throw TypeError('Argument must be an object');\n        }\n        Object.prototype = prototype;\n        var result = new Object();\n        Object.prototype = null;\n        return result;\n      };\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\n  var Defaults = {\n    // ### General\n\n    // Default data-namespace for DOM API\n    namespace: 'data-parsley-',\n\n    // Supported inputs by default\n    inputs: 'input, textarea, select',\n\n    // Excluded inputs by default\n    excluded: 'input[type=button], input[type=submit], input[type=reset], input[type=hidden]',\n\n    // Stop validating field on highest priority failing constraint\n    priorityEnabled: true,\n\n    // ### Field only\n\n    // identifier used to group together inputs (e.g. radio buttons...)\n    multiple: null,\n\n    // identifier (or array of identifiers) used to validate only a select group of inputs\n    group: null,\n\n    // ### UI\n    // Enable\\Disable error messages\n    uiEnabled: true,\n\n    // Key events threshold before validation\n    validationThreshold: 3,\n\n    // Focused field on form validation error. 'first'|'last'|'none'\n    focus: 'first',\n\n    // event(s) that will trigger validation before first failure. eg: `input`...\n    trigger: false,\n\n    // event(s) that will trigger validation after first failure.\n    triggerAfterFailure: 'input',\n\n    // Class that would be added on every failing validation Parsley field\n    errorClass: 'parsley-error',\n\n    // Same for success validation\n    successClass: 'parsley-success',\n\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 (Field) {},\n\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 (Field) {},\n\n    // ul elem that would receive errors' list\n    errorsWrapper: '<ul class=\"parsley-errors-list\"></ul>',\n\n    // li elem that would receive error message\n    errorTemplate: '<li></li>'\n  };\n\n  var Base = function () {\n    this.__id__ = Utils.generateID();\n  };\n\n  Base.prototype = {\n    asyncSupport: true, // Deprecated\n\n    _pipeAccordingToValidationResult: function () {\n      var pipe = () => {\n        var r = $.Deferred();\n        if (true !== this.validationResult)\n          r.reject();\n        return r.resolve().promise();\n      };\n      return [pipe, pipe];\n    },\n\n    actualizeOptions: function () {\n      Utils.attr(this.element, this.options.namespace, this.domOptions);\n      if (this.parent && this.parent.actualizeOptions)\n        this.parent.actualizeOptions();\n      return this;\n    },\n\n    _resetOptions: function (initOptions) {\n      this.domOptions = Utils.objectCreate(this.parent.options);\n      this.options = Utils.objectCreate(this.domOptions);\n      // Shallow copy of ownProperties of initOptions:\n      for (var i in initOptions) {\n        if (initOptions.hasOwnProperty(i))\n          this.options[i] = initOptions[i];\n      }\n      this.actualizeOptions();\n    },\n\n    _listeners: null,\n\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 (name, fn) {\n      this._listeners = this._listeners || {};\n      var queue = this._listeners[name] = this._listeners[name] || [];\n      queue.push(fn);\n\n      return this;\n    },\n\n    // Deprecated. Use `on` instead\n    subscribe: function(name, fn) {\n      $.listenTo(this, name.toLowerCase(), fn);\n    },\n\n    // Unregister a callback (or all if none is given) for the given event name\n    off: function (name, fn) {\n      var queue = this._listeners && this._listeners[name];\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)\n              queue.splice(i, 1);\n        }\n      }\n      return this;\n    },\n\n    // Deprecated. Use `off`\n    unsubscribe: function(name, fn) {\n      $.unsubscribeTo(this, name.toLowerCase());\n    },\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 (name, target, extraArg) {\n      target = target || this;\n      var queue = this._listeners && this._listeners[name];\n      var result;\n      var parentResult;\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      if (this.parent) {\n        return this.parent.trigger(name, target, extraArg);\n      }\n      return true;\n    },\n\n    asyncIsValid: function (group, force) {\n      Utils.warnOnce(\"asyncIsValid is deprecated; please use whenValid instead\");\n      return this.whenValid({group, force});\n    },\n\n    _findRelated: function () {\n      return this.options.multiple ?\n        $(this.parent.element.querySelectorAll(`[${this.options.namespace}multiple=\"${this.options.multiple}\"]`))\n      : this.$element;\n    }\n  };\n\n  var convertArrayRequirement = function(string, length) {\n    var m = string.match(/^\\s*\\[(.*)\\]\\s*$/);\n    if (!m)\n      throw 'Requirement is not an array: \"' + string + '\"';\n    var values = m[1].split(',').map(Utils.trimString);\n    if (values.length !== length)\n      throw 'Requirement has ' + values.length + ' values when ' + length + ' are needed';\n    return values;\n  };\n\n  var convertExtraOptionRequirement = function(requirementSpec, string, extraOptionReader) {\n    var main = null;\n    var extra = {};\n    for (var key in requirementSpec) {\n      if (key) {\n        var value = extraOptionReader(key);\n        if ('string' === typeof value)\n          value = Utils.parseRequirement(requirementSpec[key], value);\n        extra[key] = value;\n      } else {\n        main = Utils.parseRequirement(requirementSpec[key], string);\n      }\n    }\n    return [main, extra];\n  };\n\n  // A Validator needs to implement the methods `validate` and `parseRequirements`\n\n  var Validator = function(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(value, requirementFirstArg) {\n      if (this.fn) { // Legacy style validator\n\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        return this.fn(value, requirementFirstArg);\n      }\n\n      if (Array.isArray(value)) {\n        if (!this.validateMultiple)\n          throw 'Validator `' + this.name + '` does not handle multiple values';\n        return this.validateMultiple(...arguments);\n      } else {\n        let instance = arguments[arguments.length - 1];\n        if (this.validateDate && instance._isDateInput()) {\n          arguments[0] = Utils.parse.date(arguments[0]);\n          if (arguments[0] === null)\n            return false;\n          return this.validateDate(...arguments);\n        }\n        if (this.validateNumber) {\n          if (isNaN(value))\n            return false;\n          arguments[0] = parseFloat(arguments[0]);\n          return this.validateNumber(...arguments);\n        }\n        if (this.validateString) {\n          return this.validateString(...arguments);\n        }\n        throw 'Validator `' + this.name + '` only handles multiple values';\n      }\n    },\n\n    // Parses `requirements` into an array of arguments,\n    // according to `this.requirementType`\n    parseRequirements: function(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      var type = this.requirementType;\n      if (Array.isArray(type)) {\n        var values = convertArrayRequirement(requirements, type.length);\n        for (var i = 0; i < values.length; i++)\n          values[i] = Utils.parseRequirement(type[i], values[i]);\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\n    priority: 2\n\n  };\n\n  var ValidatorRegistry = function (validators, catalog) {\n    this.__class__ = 'ValidatorRegistry';\n\n    // Default Parsley locale is en\n    this.locale = 'en';\n\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\n    // Follow https://www.w3.org/TR/html5/infrastructure.html#floating-point-numbers\n    number: /^-?(\\d*\\.)?\\d+(e[-+]?\\d+)?$/i,\n\n    integer: /^-?\\d+$/,\n\n    digits: /^\\d+$/,\n\n    alphanum: /^\\w+$/i,\n\n    date: {\n      test: value => Utils.parse.date(value) !== null\n    },\n\n    url: new RegExp(\n        \"^\" +\n          // protocol identifier\n          \"(?:(?:https?|ftp)://)?\" + // ** mod: make scheme optional\n          // user:pass authentication\n          \"(?:\\\\S+(?::\\\\S*)?@)?\" +\n          \"(?:\" +\n            // 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])\" +\n            \"(?:\\\\.(?:1?\\\\d{1,2}|2[0-4]\\\\d|25[0-5])){2}\" +\n            \"(?:\\\\.(?:[1-9]\\\\d?|1\\\\d\\\\d|2[0-4]\\\\d|25[0-4]))\" +\n          \"|\" +\n            // host name\n            \"(?:(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)\" +\n            // domain name\n            \"(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)*\" +\n            // TLD identifier\n            \"(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff]{2,}))\" +\n          \")\" +\n          // port number\n          \"(?::\\\\d{2,5})?\" +\n          // resource path\n          \"(?:/\\\\S*)?\" +\n        \"$\"\n      )\n  };\n  typeTesters.range = typeTesters.number;\n\n  // See http://stackoverflow.com/a/10454560/8279\n  var decimalPlaces = num => {\n    var match = ('' + num).match(/(?:\\.(\\d+))?(?:[eE]([+-]?\\d+))?$/);\n    if (!match) { return 0; }\n    return Math.max(\n         0,\n         // Number of digits right of decimal point.\n         (match[1] ? match[1].length : 0) -\n         // Adjust for scientific notation.\n         (match[2] ? +match[2] : 0));\n  };\n\n  // parseArguments('number', ['1', '2']) => [1, 2]\n  let ValidatorRegistry__parseArguments = (type, args) => args.map(Utils.parse[type]);\n  // operatorToValidator returns a validating function for an operator function, applied to the given type\n  let ValidatorRegistry__operatorToValidator = (type, operator) => {\n    return (value, ...requirementsAndInput) => {\n      requirementsAndInput.pop(); // Get rid of `input` argument\n      return operator(value, ...ValidatorRegistry__parseArguments(type, requirementsAndInput));\n    };\n  };\n\n  let ValidatorRegistry__comparisonOperator = operator => ({\n    validateDate: ValidatorRegistry__operatorToValidator('date', operator),\n    validateNumber: ValidatorRegistry__operatorToValidator('number', operator),\n    requirementType: operator.length <= 2 ? 'string' : ['string', 'string'], // Support operators with a 1 or 2 requirement(s)\n    priority: 30\n  });\n\n  ValidatorRegistry.prototype = {\n    init: function (validators, catalog) {\n      this.catalog = catalog;\n      // Copy prototype's validators:\n      this.validators = Object.assign({}, this.validators);\n\n      for (var name in validators)\n        this.addValidator(name, validators[name].fn, validators[name].priority);\n\n      window.Parsley.trigger('parsley:validator:init');\n    },\n\n    // Set new messages locale if we have dictionary loaded in ParsleyConfig.i18n\n    setLocale: function (locale) {\n      if ('undefined' === typeof this.catalog[locale])\n        throw new Error(locale + ' is not available in the catalog');\n\n      this.locale = locale;\n\n      return this;\n    },\n\n    // Add a new messages catalog for a given locale. Set locale for this catalog if set === `true`\n    addCatalog: function (locale, messages, set) {\n      if ('object' === typeof messages)\n        this.catalog[locale] = messages;\n\n      if (true === set)\n        return this.setLocale(locale);\n\n      return this;\n    },\n\n    // Add a specific message for a given constraint in a given locale\n    addMessage: function (locale, name, message) {\n      if ('undefined' === typeof this.catalog[locale])\n        this.catalog[locale] = {};\n\n      this.catalog[locale][name] = message;\n\n      return this;\n    },\n\n    // Add messages for a given locale\n    addMessages: function (locale, nameMessageObject) {\n      for (var name in nameMessageObject)\n        this.addMessage(locale, name, nameMessageObject[name]);\n\n      return this;\n    },\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 (name, arg1, arg2) {\n      if (this.validators[name])\n        Utils.warn('Validator \"' + name + '\" is already defined.');\n      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(...arguments);\n    },\n\n    hasValidator: function (name) {\n      return !!this.validators[name];\n    },\n\n    updateValidator: function (name, arg1, arg2) {\n      if (!this.validators[name]) {\n        Utils.warn('Validator \"' + name + '\" is not already defined.');\n        return this.addValidator(...arguments);\n      }\n      return this._setValidator(...arguments);\n    },\n\n    removeValidator: function (name) {\n      if (!this.validators[name])\n        Utils.warn('Validator \"' + name + '\" is not defined.');\n\n      delete this.validators[name];\n\n      return this;\n    },\n\n    _setValidator: function (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      if (!validator.validate) {\n        validator = new Validator(validator);\n      }\n      this.validators[name] = validator;\n\n      for (var locale in validator.messages || {})\n        this.addMessage(locale, name, validator.messages[locale]);\n\n      return this;\n    },\n\n    getErrorMessage: function (constraint) {\n      var message;\n\n      // Type constraints are a bit different, we have to match their requirements too to find right error message\n      if ('type' === constraint.name) {\n        var typeMessages = this.catalog[this.locale][constraint.name] || {};\n        message = typeMessages[constraint.requirements];\n      } else\n        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\n    // Kind of light `sprintf()` implementation\n    formatMessage: function (string, parameters) {\n      if ('object' === typeof parameters) {\n        for (var i in parameters)\n          string = this.formatMessage(string, parameters[i]);\n\n        return string;\n      }\n\n      return 'string' === typeof string ? string.replace(/%s/i, parameters) : '';\n    },\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(value) {\n          return /\\S/.test(value);\n        },\n        priority: 2\n      },\n      required: {\n        validateMultiple: function(values) {\n          return values.length > 0;\n        },\n        validateString: function(value) {\n          return /\\S/.test(value);\n        },\n        priority: 512\n      },\n      type: {\n        validateString: function(value, type, {step = 'any', base = 0} = {}) {\n          var tester = typeTesters[type];\n          if (!tester) {\n            throw new Error('validator type `' + type + '` is not supported');\n          }\n          if (!tester.test(value))\n            return false;\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;\n              // Be careful of rounding errors by using integers.\n              var toInt = f => Math.round(f * Math.pow(10, decimals));\n              if ((toInt(nb) - toInt(base)) % toInt(step) != 0)\n                return false;\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(value, regexp) {\n          return regexp.test(value);\n        },\n        requirementType: 'regexp',\n        priority: 64\n      },\n      minlength: {\n        validateString: function (value, requirement) {\n          return value.length >= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      maxlength: {\n        validateString: function (value, requirement) {\n          return value.length <= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      length: {\n        validateString: function (value, min, max) {\n          return value.length >= min && value.length <= max;\n        },\n        requirementType: ['integer', 'integer'],\n        priority: 30\n      },\n      mincheck: {\n        validateMultiple: function (values, requirement) {\n          return values.length >= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      maxcheck: {\n        validateMultiple: function (values, requirement) {\n          return values.length <= requirement;\n        },\n        requirementType: 'integer',\n        priority: 30\n      },\n      check: {\n        validateMultiple: function (values, min, max) {\n          return values.length >= min && values.length <= max;\n        },\n        requirementType: ['integer', 'integer'],\n        priority: 30\n      },\n      min: ValidatorRegistry__comparisonOperator((value, requirement) => value >= requirement),\n      max: ValidatorRegistry__comparisonOperator((value, requirement) => value <= requirement),\n      range: ValidatorRegistry__comparisonOperator((value, min, max) => value >= min && value <= max),\n      equalto: {\n        validateString: function (value, refOrValue) {\n          var $reference = $(refOrValue);\n          if ($reference.length)\n            return value === $reference.val();\n          else\n            return value === refOrValue;\n        },\n        priority: 256\n      }\n    }\n  };\n\n  var UI = {};\n\n  var diffResults = function (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      if (found)\n        kept.push(newResult[i]);\n      else\n        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\n    _actualizeTriggers: function () {\n      this.$element.on('submit.Parsley', evt => { this.onSubmitValidate(evt); });\n      this.$element.on('click.Parsley', Utils._SubmitSelector, evt => { this.onSubmitButton(evt); });\n\n      // UI could be disabled\n      if (false === this.options.uiEnabled)\n        return;\n\n      this.element.setAttribute('novalidate', '');\n    },\n\n    focus: function () {\n      this._focusedField = null;\n\n      if (true === this.validationResult || 'none' === this.options.focus)\n        return null;\n\n      for (var i = 0; i < this.fields.length; i++) {\n        var field = this.fields[i];\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)\n            break;\n        }\n      }\n\n      if (null === this._focusedField)\n        return null;\n\n      return this._focusedField.focus();\n    },\n\n    _destroyUI: function () {\n      // Reset all event listeners\n      this.$element.off('.Parsley');\n    }\n\n  };\n\n  UI.Field = {\n\n    _reflowUI: function () {\n      this._buildUI();\n\n      // If this field doesn't have an active UI don't bother doing something\n      if (!this._ui)\n        return;\n\n      // Diff between two validation results\n      var diff = diffResults(this.validationResult, this._ui.lastValidationResult);\n\n      // Then store current validation result for next reflow\n      this._ui.lastValidationResult = this.validationResult;\n\n      // Handle valid / invalid / none field class\n      this._manageStatusClass();\n\n      // Add, remove, updated errors messages\n      this._manageErrorsMessages(diff);\n\n      // Triggers impl\n      this._actualizeTriggers();\n\n      // If field is not valid for the first time, bind keyup trigger to ease UX and quickly inform user\n      if ((diff.kept.length || diff.added.length) && !this._failedOnce) {\n        this._failedOnce = true;\n        this._actualizeTriggers();\n      }\n    },\n\n    // Returns an array of field's error message(s)\n    getErrorsMessages: function () {\n      // No error message, field is valid\n      if (true === this.validationResult)\n        return [];\n\n      var messages = [];\n\n      for (var i = 0; i < this.validationResult.length; i++)\n        messages.push(this.validationResult[i].errorMessage ||\n         this._getErrorMessage(this.validationResult[i].assert));\n\n      return messages;\n    },\n\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    addError: function (name, {message, assert, updateClass = true} = {}) {\n      this._buildUI();\n      this._addError(name, {message, assert});\n\n      if (updateClass)\n        this._errorClass();\n    },\n\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    updateError: function (name, {message, assert, updateClass = true} = {}) {\n      this._buildUI();\n      this._updateError(name, {message, assert});\n\n      if (updateClass)\n        this._errorClass();\n    },\n\n    // It's a goal of Parsley that this method is no longer required [#1073]\n    removeError: function (name, {updateClass = true} = {}) {\n      this._buildUI();\n      this._removeError(name);\n\n      // 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      if (updateClass)\n        this._manageStatusClass();\n    },\n\n    _manageStatusClass: function () {\n      if (this.hasConstraints() && this.needsValidation() && true === this.validationResult)\n        this._successClass();\n      else if (this.validationResult.length > 0)\n        this._errorClass();\n      else\n        this._resetClass();\n    },\n\n    _manageErrorsMessages: function (diff) {\n      if ('undefined' !== typeof this.options.errorsMessagesDisabled)\n        return;\n\n      // Case where we have errorMessage option that configure an unique field error message, regardless failing validators\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)\n            this._ui.$errorsWrapper\n              .append(\n                $(this.options.errorTemplate)\n                .addClass('parsley-custom-error-message')\n              );\n\n          return this._ui.$errorsWrapper\n            .addClass('filled')\n            .find('.parsley-custom-error-message')\n            .html(this.options.errorMessage);\n        }\n\n        return this._ui.$errorsWrapper\n          .removeClass('filled')\n          .find('.parsley-custom-error-message')\n          .remove();\n      }\n\n      // Show, hide, update failing constraints messages\n      for (var i = 0; i < diff.removed.length; i++)\n        this._removeError(diff.removed[i].assert.name);\n\n      for (i = 0; i < diff.added.length; i++)\n        this._addError(diff.added[i].assert.name, {message: diff.added[i].errorMessage, assert: diff.added[i].assert});\n\n      for (i = 0; i < diff.kept.length; i++)\n        this._updateError(diff.kept[i].assert.name, {message: diff.kept[i].errorMessage, assert: diff.kept[i].assert});\n    },\n\n\n    _addError: function (name, {message, assert}) {\n      this._insertErrorWrapper();\n      this._ui.$errorClassHandler\n        .attr('aria-describedby', this._ui.errorsWrapperId);\n      this._ui.$errorsWrapper\n        .addClass('filled')\n        .append(\n          $(this.options.errorTemplate)\n          .addClass('parsley-' + name)\n          .html(message || this._getErrorMessage(assert))\n        );\n    },\n\n    _updateError: function (name, {message, assert}) {\n      this._ui.$errorsWrapper\n        .addClass('filled')\n        .find('.parsley-' + name)\n        .html(message || this._getErrorMessage(assert));\n    },\n\n    _removeError: function (name) {\n      this._ui.$errorClassHandler\n        .removeAttr('aria-describedby');\n      this._ui.$errorsWrapper\n        .removeClass('filled')\n        .find('.parsley-' + name)\n        .remove();\n    },\n\n    _getErrorMessage: function (constraint) {\n      var customConstraintErrorMessage = constraint.name + 'Message';\n\n      if ('undefined' !== typeof this.options[customConstraintErrorMessage])\n        return window.Parsley.formatMessage(this.options[customConstraintErrorMessage], constraint.requirements);\n\n      return window.Parsley.getErrorMessage(constraint);\n    },\n\n    _buildUI: function () {\n      // UI could be already built or disabled\n      if (this._ui || false === this.options.uiEnabled)\n        return;\n\n      var _ui = {};\n\n      // Give field its Parsley id in DOM\n      this.element.setAttribute(this.options.namespace + 'id', this.__id__);\n\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      _ui.$errorClassHandler = this._manageClassHandler();\n\n      // $errorsWrapper is a div that would contain the various field errors, it will be appended into $errorsContainer\n      _ui.errorsWrapperId = 'parsley-id-' + (this.options.multiple ? 'multiple-' + this.options.multiple : this.__id__);\n      _ui.$errorsWrapper = $(this.options.errorsWrapper).attr('id', _ui.errorsWrapperId);\n\n      // ValidationResult UI storage to detect what have changed bwt two validations, and update DOM accordingly\n      _ui.lastValidationResult = [];\n      _ui.validationInformationVisible = false;\n\n      // Store it in this for later\n      this._ui = _ui;\n    },\n\n    // Determine which element will have `parsley-error` and `parsley-success` classes\n    _manageClassHandler: function () {\n      // Class handled could also be determined by function given in Parsley options\n      if ('string' === typeof this.options.classHandler && $(this.options.classHandler).length)\n        return $(this.options.classHandler);\n\n      // Class handled could also be determined by function given in Parsley options\n      var $handlerFunction = this.options.classHandler;\n\n      // It might also be the function name of a global function\n      if ('string' === typeof this.options.classHandler && 'function' === typeof window[this.options.classHandler])\n        $handlerFunction = window[this.options.classHandler];\n\n      if ('function' === typeof $handlerFunction) {\n        var $handler = $handlerFunction.call(this, this);\n\n        // If this function returned a valid existing DOM element, go for it\n        if ('undefined' !== typeof $handler && $handler.length)\n          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\n    _inputHolder: function() {\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')\n        return this.$element;\n\n      // But if multiple element (radio, checkbox), that would be their parent\n      return this.$element.parent();\n    },\n\n    _insertErrorWrapper: function () {\n      var $errorsContainer = this.options.errorsContainer;\n\n      // Nothing to do if already inserted\n      if (0 !== this._ui.$errorsWrapper.parent().length)\n        return this._ui.$errorsWrapper.parent();\n\n      if ('string' === typeof $errorsContainer) {\n        if ($($errorsContainer).length)\n          return $($errorsContainer).append(this._ui.$errorsWrapper);\n        else if ('function' === typeof window[$errorsContainer])\n          $errorsContainer = window[$errorsContainer];\n        else\n          Utils.warn('The errors container `' + $errorsContainer + '` does not exist in DOM nor as a global JS function');\n      }\n\n      if ('function' === typeof $errorsContainer)\n        $errorsContainer = $errorsContainer.call(this, this);\n\n      if ('object' === typeof $errorsContainer && $errorsContainer.length)\n        return $errorsContainer.append(this._ui.$errorsWrapper);\n\n      return this._inputHolder().after(this._ui.$errorsWrapper);\n    },\n\n    _actualizeTriggers: function () {\n      var $toBind = this._findRelated();\n      var trigger;\n\n      // Remove Parsley events already bound on this field\n      $toBind.off('.Parsley');\n      if (this._failedOnce)\n        $toBind.on(Utils.namespaceEvents(this.options.triggerAfterFailure, 'Parsley'), () => {\n          this._validateIfNeeded();\n        });\n      else if (trigger = Utils.namespaceEvents(this.options.trigger, 'Parsley')) {\n        $toBind.on(trigger, event => {\n          this._validateIfNeeded(event);\n        });\n      }\n    },\n\n    _validateIfNeeded: function (event) {\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))\n        if (!(this._ui && this._ui.validationInformationVisible) && this.getValue().length <= this.options.validationThreshold)\n          return;\n\n      if (this.options.debounce) {\n        window.clearTimeout(this._debounced);\n        this._debounced = window.setTimeout(() => this.validate(), this.options.debounce);\n      } else\n        this.validate();\n    },\n\n    _resetUI: function () {\n      // Reset all event listeners\n      this._failedOnce = false;\n      this._actualizeTriggers();\n\n      // Nothing to do if UI never initialized for this field\n      if ('undefined' === typeof this._ui)\n        return;\n\n      // Reset all errors' li\n      this._ui.$errorsWrapper\n        .removeClass('filled')\n        .children()\n        .remove();\n\n      // Reset validation class\n      this._resetClass();\n\n      // Reset validation flags and last validation result\n      this._ui.lastValidationResult = [];\n      this._ui.validationInformationVisible = false;\n    },\n\n    _destroyUI: function () {\n      this._resetUI();\n\n      if ('undefined' !== typeof this._ui)\n        this._ui.$errorsWrapper.remove();\n\n      delete this._ui;\n    },\n\n    _successClass: function () {\n      this._ui.validationInformationVisible = true;\n      this._ui.$errorClassHandler.removeClass(this.options.errorClass).addClass(this.options.successClass);\n    },\n    _errorClass: function () {\n      this._ui.validationInformationVisible = true;\n      this._ui.$errorClassHandler.removeClass(this.options.successClass).addClass(this.options.errorClass);\n    },\n    _resetClass: function () {\n      this._ui.$errorClassHandler.removeClass(this.options.successClass).removeClass(this.options.errorClass);\n    }\n  };\n\n  var Form = function (element, domOptions, options) {\n    this.__class__ = 'Form';\n\n    this.element = element;\n    this.$element = $(element);\n    this.domOptions = domOptions;\n    this.options = options;\n    this.parent = window.Parsley;\n\n    this.fields = [];\n    this.validationResult = null;\n  };\n\n  var Form__statusMapping = {pending: null, resolved: true, rejected: false};\n\n  Form.prototype = {\n    onSubmitValidate: function (event) {\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)\n        return;\n\n      // If we didn't come here through a submit button, use the first one in the form\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'))\n        return;\n\n      window.Parsley._remoteCache = {};\n\n      var promise = this.whenValidate({event});\n\n      if ('resolved' === promise.state() && false !== this._trigger('submit')) {\n        // All good, let event go through. We make this distinction because browsers\n        // differ in their handling of `submit` being called from inside a submit event [#1047]\n      } else {\n        // Rejected or pending: cancel this submit\n        event.stopImmediatePropagation();\n        event.preventDefault();\n        if ('pending' === promise.state())\n          promise.done(() => { this._submit(submitSource); });\n      }\n    },\n\n    onSubmitButton: function(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 (submitSource) {\n      if (false === this._trigger('submit'))\n        return;\n      // Add submit button's data\n      if (submitSource) {\n        var $synthetic = this.$element.find('.parsley-synthetic-submit-button').prop('disabled', false);\n        if (0 === $synthetic.length)\n          $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(Object.assign($.Event('submit'), {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 (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        var [group, force, event] = arguments;\n        options = {group, force, event};\n      }\n      return Form__statusMapping[ this.whenValidate(options).state() ];\n    },\n\n    whenValidate: function ({group, force, event} = {}) {\n      this.submitEvent = event;\n      if (event) {\n        this.submitEvent = Object.assign({}, event, {preventDefault: () => {\n          Utils.warnOnce(\"Using `this.submitEvent.preventDefault()` is deprecated; instead, call `this.validationResult = false`\");\n          this.validationResult = false;\n        }});\n      }\n      this.validationResult = true;\n\n      // fire validate event to eventually modify things before every validation\n      this._trigger('validate');\n\n      // Refresh form DOM options and form's fields that could have changed\n      this._refreshFields();\n\n      var promises = this._withoutReactualizingFormOptions(() => {\n        return $.map(this.fields, field => field.whenValidate({force, group}));\n      });\n\n      return Utils.all(promises)\n        .done(  () => { this._trigger('success'); })\n        .fail(  () => {\n          this.validationResult = false;\n          this.focus();\n          this._trigger('error');\n        })\n        .always(() => { this._trigger('validated'); })\n        .pipe(...this._pipeAccordingToValidationResult());\n    },\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 (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        var [group, force] = arguments;\n        options = {group, force};\n      }\n      return Form__statusMapping[ this.whenValid(options).state() ];\n    },\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 ({group, force} = {}) {\n      this._refreshFields();\n\n      var promises = this._withoutReactualizingFormOptions(() => {\n        return $.map(this.fields, field => field.whenValid({group, force}));\n      });\n      return Utils.all(promises);\n    },\n\n    refresh: function() {\n      this._refreshFields();\n      return this;\n    },\n\n    // Reset UI\n    reset: function () {\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      this._trigger('reset');\n    },\n\n    // Destroy Parsley instance (+ UI)\n    destroy: function () {\n      // Field case: emit destroy event to clean UI and then destroy stored instance\n      this._destroyUI();\n\n      // Form case: destroy all its fields and then destroy stored instance\n      for (var i = 0; i < this.fields.length; i++)\n        this.fields[i].destroy();\n\n      this.$element.removeData('Parsley');\n      this._trigger('destroy');\n    },\n\n    _refreshFields: function () {\n      return this.actualizeOptions()._bindFields();\n    },\n\n    _bindFields: function () {\n      var oldFields = this.fields;\n\n      this.fields = [];\n      this.fieldsMappedById = {};\n\n      this._withoutReactualizingFormOptions(() => {\n        this.$element\n        .find(this.options.inputs)\n        .not(this.options.excluded)\n        .each((_, element) => {\n          var fieldInstance = new window.Parsley.Factory(element, {}, this);\n\n          // Only add valid and not excluded `Field` and `FieldMultiple` children\n          if (('Field' === fieldInstance.__class__ || 'FieldMultiple' === fieldInstance.__class__) && (true !== fieldInstance.options.excluded)) {\n            let uniqueId = fieldInstance.__class__ + '-' + fieldInstance.__id__;\n            if ('undefined' === typeof this.fieldsMappedById[uniqueId]) {\n              this.fieldsMappedById[uniqueId] = fieldInstance;\n              this.fields.push(fieldInstance);\n            }\n          }\n        });\n\n        $.each(Utils.difference(oldFields, this.fields), (_, field) => {\n          field.reset();\n        });\n      });\n      return this;\n    },\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 (fn) {\n      var oldActualizeOptions = this.actualizeOptions;\n      this.actualizeOptions = function () { return this; };\n      var result = fn();\n      this.actualizeOptions = oldActualizeOptions;\n      return result;\n    },\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 (eventName) {\n      return this.trigger('form:' + eventName);\n    }\n\n  };\n\n  const Constraint = function(parsleyField, name, requirements, priority, isDomConstraint) {\n    const validatorSpec = window.Parsley._validatorRegistry.validators[name];\n    const validator = new Validator(validatorSpec);\n    priority = priority || parsleyField.options[name + 'Priority'] || validator.priority;\n    isDomConstraint = (true === isDomConstraint);\n\n    Object.assign(this, {\n      validator,\n      name,\n      requirements,\n      priority,\n      isDomConstraint\n    });\n    this._parseRequirements(parsleyField.options);\n  };\n\n  const capitalize = function(str) {\n    const cap = str[0].toUpperCase();\n    return cap + str.slice(1);\n  };\n\n  Constraint.prototype = {\n    validate: function(value, instance) {\n      return this.validator.validate(value, ...this.requirementList, instance);\n    },\n\n    _parseRequirements: function(options) {\n      this.requirementList = this.validator.parseRequirements(this.requirements,\n        key => options[this.name + capitalize(key)]\n      );\n    }\n  };\n\n  var Field = function (field, domOptions, options, parsleyFormInstance) {\n    this.__class__ = 'Field';\n\n    this.element = field;\n    this.$element = $(field);\n\n    // Set parent if we have one\n    if ('undefined' !== typeof parsleyFormInstance) {\n      this.parent = parsleyFormInstance;\n    }\n\n    this.options = options;\n    this.domOptions = domOptions;\n\n    // Initialize some properties\n    this.constraints = [];\n    this.constraintsByName = {};\n    this.validationResult = true;\n\n    // Bind constraints\n    this._bindConstraints();\n  };\n\n  var parsley_field__statusMapping = {pending: null, resolved: true, 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 (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 = {options};\n      }\n      var promise = this.whenValidate(options);\n      if (!promise)  // If excluded with `group` option\n        return true;\n      switch (promise.state()) {\n        case 'pending': return null;\n        case 'resolved': return true;\n        case 'rejected': return this.validationResult;\n      }\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 ({force, group} =  {}) {\n      // do not validate a field if not the same as given validation group\n      this.refresh();\n      if (group && !this._isInGroup(group))\n        return;\n\n      this.value = this.getValue();\n\n      // Field Validate event. `this.value` could be altered for custom needs\n      this._trigger('validate');\n\n      return this.whenValid({force, value: this.value, _refreshed: true})\n        .always(() => { this._reflowUI(); })\n        .done(() =>   { this._trigger('success'); })\n        .fail(() =>   { this._trigger('error'); })\n        .always(() => { this._trigger('validated'); })\n        .pipe(...this._pipeAccordingToValidationResult());\n    },\n\n    hasConstraints: function () {\n      return 0 !== this.constraints.length;\n    },\n\n    // An empty optional field does not need validation\n    needsValidation: function (value) {\n      if ('undefined' === typeof value)\n        value = this.getValue();\n\n      // 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      if (!value.length && !this._isRequired() && 'undefined' === typeof this.options.validateIfEmpty)\n        return false;\n\n      return true;\n    },\n\n    _isInGroup: function (group) {\n      if (Array.isArray(this.options.group))\n        return -1 !== $.inArray(group, this.options.group);\n      return this.options.group === group;\n    },\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 (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        var [force, value] = arguments;\n        options = {force, value};\n      }\n      var promise = this.whenValid(options);\n      if (!promise) // Excluded via `group`\n        return true;\n      return parsley_field__statusMapping[promise.state()];\n    },\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 ({force = false, value, group, _refreshed} = {}) {\n      // Recompute options and rebind constraints to have latest changes\n      if (!_refreshed)\n        this.refresh();\n      // do not validate a field if not the same as given validation group\n      if (group && !this._isInGroup(group))\n        return;\n\n      this.validationResult = true;\n\n      // A field without constraint is valid\n      if (!this.hasConstraints())\n        return $.when();\n\n      // Value could be passed as argument, needed to add more power to 'field:validate'\n      if ('undefined' === typeof value || null === value)\n        value = this.getValue();\n\n      if (!this.needsValidation(value) && true !== force)\n        return $.when();\n\n      var groupedConstraints = this._getGroupedConstraints();\n      var promises = [];\n      $.each(groupedConstraints, (_, 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(\n          $.map(constraints, constraint => this._validateConstraint(value, constraint))\n        );\n        promises.push(promise);\n        if (promise.state() === 'rejected')\n          return false; // Interrupt processing if a group has already failed\n      });\n      return Utils.all(promises);\n    },\n\n    // @returns a promise\n    _validateConstraint: function(value, constraint) {\n      var result = constraint.validate(value, this);\n      // Map false to a failed promise\n      if (false === result)\n        result = $.Deferred().reject();\n      // Make sure we return a promise and that we record failures\n      return Utils.all([result]).fail(errorMessage => {\n        if (!(this.validationResult instanceof Array))\n          this.validationResult = [];\n        this.validationResult.push({\n          assert: constraint,\n          errorMessage: 'string' === typeof errorMessage && errorMessage\n        });\n      });\n    },\n\n    // @returns Parsley field computed value that could be overrided or configured in DOM\n    getValue: function () {\n      var value;\n\n      // Value could be overriden in DOM or with explicit options\n      if ('function' === typeof this.options.value)\n        value = this.options.value(this);\n      else if ('undefined' !== typeof this.options.value)\n        value = this.options.value;\n      else\n        value = this.$element.val();\n\n      // Handle wrong DOM or configurations\n      if ('undefined' === typeof value || null === value)\n        return '';\n\n      return this._handleWhitespace(value);\n    },\n\n    // Reset UI\n    reset: function () {\n      this._resetUI();\n      return this._trigger('reset');\n    },\n\n    // Destroy Parsley instance (+ UI)\n    destroy: function () {\n      // Field case: emit destroy event to clean UI and then destroy stored instance\n      this._destroyUI();\n      this.$element.removeData('Parsley');\n      this.$element.removeData('FieldMultiple');\n      this._trigger('destroy');\n    },\n\n    // Actualize options and rebind constraints\n    refresh: function () {\n      this._refreshConstraints();\n      return this;\n    },\n\n    _refreshConstraints: function () {\n      return this.actualizeOptions()._bindConstraints();\n    },\n\n    refreshConstraints: function() {\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 (name, requirements, priority, isDomConstraint) {\n\n      if (window.Parsley._validatorRegistry.validators[name]) {\n        var constraint = new Constraint(this, name, requirements, priority, isDomConstraint);\n\n        // if constraint already exist, delete it and push new version\n        if ('undefined' !== this.constraintsByName[constraint.name])\n          this.removeConstraint(constraint.name);\n\n        this.constraints.push(constraint);\n        this.constraintsByName[constraint.name] = constraint;\n      }\n\n      return this;\n    },\n\n    // Remove a constraint\n    removeConstraint: function (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      delete this.constraintsByName[name];\n      return this;\n    },\n\n    // Update a constraint (Remove + re-add)\n    updateConstraint: function (name, parameters, priority) {\n      return this.removeConstraint(name)\n        .addConstraint(name, parameters, priority);\n    },\n\n    // # Internals\n\n    // Internal only.\n    // Bind constraints from config + options + DOM\n    _bindConstraints: function () {\n      var constraints = [];\n      var constraintsByName = {};\n\n      // clean all existing DOM constraints to only keep javascript user constraints\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      this.constraints = constraints;\n      this.constraintsByName = constraintsByName;\n\n      // then re-add Parsley DOM-API constraints\n      for (var name in this.options)\n        this.addConstraint(name, this.options[name], undefined, true);\n\n      // finally, bind special HTML5 constraints\n      return this._bindHtml5Constraints();\n    },\n\n    // Internal only.\n    // Bind specific HTML5 constraints to be HTML5 compliant\n    _bindHtml5Constraints: function () {\n      // html5 required\n      if (null !== this.element.getAttribute('required'))\n        this.addConstraint('required', true, undefined, true);\n\n      // html5 pattern\n      if (null !== this.element.getAttribute('pattern'))\n        this.addConstraint('pattern', this.element.getAttribute('pattern'), undefined, true);\n\n      // range\n      let min = this.element.getAttribute('min');\n      let max = this.element.getAttribute('max');\n      if (null !== min && null !== max)\n        this.addConstraint('range', [min, max], undefined, true);\n\n      // HTML5 min\n      else if (null !== min)\n        this.addConstraint('min', min, undefined, true);\n\n      // HTML5 max\n      else if (null !== max)\n        this.addConstraint('max', max, undefined, true);\n\n\n      // length\n      if (null !== this.element.getAttribute('minlength') && null !== this.element.getAttribute('maxlength'))\n        this.addConstraint('length', [this.element.getAttribute('minlength'), this.element.getAttribute('maxlength')], undefined, true);\n\n      // HTML5 minlength\n      else if (null !== this.element.getAttribute('minlength'))\n        this.addConstraint('minlength', this.element.getAttribute('minlength'), undefined, true);\n\n      // HTML5 maxlength\n      else if (null !== this.element.getAttribute('maxlength'))\n        this.addConstraint('maxlength', this.element.getAttribute('maxlength'), undefined, true);\n\n\n      // html5 types\n      var type = Utils.getType(this.element);\n\n      // Small special case here for HTML5 number: integer validator if step attribute is undefined or an integer value, number otherwise\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);\n      // 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      return this;\n    },\n\n    // Internal only.\n    // Field is required if have required constraint without `false` value\n    _isRequired: function () {\n      if ('undefined' === typeof this.constraintsByName.required)\n        return false;\n\n      return false !== this.constraintsByName.required.requirements;\n    },\n\n    // Internal only.\n    // Shortcut to trigger an event\n    _trigger: function (eventName) {\n      return this.trigger('field:' + eventName);\n    },\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 (value) {\n      if (true === this.options.trimValue)\n        Utils.warnOnce('data-parsley-trim-value=\"true\" is deprecated, please use data-parsley-whitespace=\"trim\"');\n\n      if ('squish' === this.options.whitespace)\n        value = value.replace(/\\s{2,}/g, ' ');\n\n      if (('trim' === this.options.whitespace) || ('squish' === this.options.whitespace) || (true === this.options.trimValue))\n        value = Utils.trimString(value);\n\n      return value;\n    },\n\n    _isDateInput: function() {\n      var c = this.constraintsByName.type;\n      return c && c.requirements === 'date';\n    },\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 () {\n      if (false === this.options.priorityEnabled)\n        return [this.constraints];\n\n      var groupedConstraints = [];\n      var index = {};\n\n      // Create array unique of priorities\n      for (var i = 0; i < this.constraints.length; i++) {\n        var p = this.constraints[i].priority;\n        if (!index[p])\n          groupedConstraints.push(index[p] = []);\n        index[p].push(this.constraints[i]);\n      }\n      // Sort them by priority DESC\n      groupedConstraints.sort(function (a, b) { return b[0].priority - a[0].priority; });\n\n      return groupedConstraints;\n    }\n\n  };\n\n  var parsley_field = Field;\n\n  var Multiple = function () {\n    this.__class__ = 'FieldMultiple';\n  };\n\n  Multiple.prototype = {\n    // Add new `$element` sibling for multiple field\n    addElement: function ($element) {\n      this.$elements.push($element);\n\n      return this;\n    },\n\n    // See `Field._refreshConstraints()`\n    _refreshConstraints: function () {\n      var fieldConstraints;\n\n      this.constraints = [];\n\n      // Select multiple special treatment\n      if (this.element.nodeName === 'SELECT') {\n        this.actualizeOptions()._bindConstraints();\n\n        return this;\n      }\n\n      // Gather all constraints for each input in the multiple group\n      for (var i = 0; i < this.$elements.length; i++) {\n\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      return this;\n    },\n\n    // See `Field.getValue()`\n    getValue: function () {\n      // Value could be overriden in DOM\n      if ('function' === typeof this.options.value)\n        return this.options.value(this);\n      else if ('undefined' !== typeof this.options.value)\n        return this.options.value;\n\n      // Radio input case\n      if (this.element.nodeName === 'INPUT') {\n        var type = Utils.getType(this.element);\n        if (type === 'radio')\n          return this._findRelated().filter(':checked').val() || '';\n\n        // checkbox input case\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      }\n\n      // Select multiple case\n      if (this.element.nodeName === 'SELECT' && null === this.$element.val())\n        return [];\n\n      // Default case that should never happen\n      return this.$element.val();\n    },\n\n    _init: function () {\n      this.$elements = [this.$element];\n\n      return this;\n    }\n  };\n\n  var Factory = function (element, options, parsleyFormInstance) {\n    this.element = element;\n    this.$element = $(element);\n\n    // If the element has already been bound, returns its saved Parsley instance\n    var savedparsleyFormInstance = this.$element.data('Parsley');\n    if (savedparsleyFormInstance) {\n\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        savedparsleyFormInstance._resetOptions(savedparsleyFormInstance.options);\n      }\n\n      if ('object' === typeof options) {\n        Object.assign(savedparsleyFormInstance.options, options);\n      }\n\n      return savedparsleyFormInstance;\n    }\n\n    // Parsley must be instantiated with a DOM element or jQuery $element\n    if (!this.$element.length)\n      throw new Error('You must bind Parsley on an existing element.');\n\n    if ('undefined' !== typeof parsleyFormInstance && 'Form' !== parsleyFormInstance.__class__)\n      throw new Error('Parent instance must be a Form instance');\n\n    this.parent = parsleyFormInstance || window.Parsley;\n    return this.init(options);\n  };\n\n  Factory.prototype = {\n    init: function (options) {\n      this.__class__ = 'Parsley';\n      this.__version__ = '2.8.1';\n      this.__id__ = Utils.generateID();\n\n      // Pre-compute options\n      this._resetOptions(options);\n\n      // 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      if (this.element.nodeName === 'FORM' || (Utils.checkAttr(this.element, this.options.namespace, 'validate') && !this.$element.is(this.options.inputs)))\n        return this.bind('parsleyForm');\n\n      // Every other element is bound as a `Field` or `FieldMultiple`\n      return this.isMultiple() ? this.handleMultiple() : this.bind('parsleyField');\n    },\n\n    isMultiple: function () {\n      var type = Utils.getType(this.element);\n      return ((type === 'radio' || type === 'checkbox') ||\n        (this.element.nodeName === 'SELECT' && null !== this.element.getAttribute('multiple')));\n    },\n\n    // Multiples fields are a real nightmare :(\n    // Maybe some refactoring would be appreciated here...\n    handleMultiple: function () {\n      var name;\n      var multiple;\n      var parsleyMultipleInstance;\n\n      // Handle multiple name\n      this.options.multiple = this.options.multiple ||\n        (name = this.element.getAttribute('name')) ||\n        this.element.getAttribute('id');\n\n      // Special select multiple input\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');\n\n      // 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      }\n\n      // Remove special chars\n      this.options.multiple = this.options.multiple.replace(/(:|\\.|\\[|\\]|\\{|\\}|\\$)/g, '');\n\n      // Add proper `data-parsley-multiple` to siblings if we have a valid multiple name\n      if (name) {\n        $('input[name=\"' + name + '\"]').each((i, input) => {\n          var type = Utils.getType(input);\n          if ((type === 'radio' || type === 'checkbox'))\n            input.setAttribute(this.options.namespace + 'multiple', this.options.multiple);\n        });\n      }\n\n      // Check here if we don't already have a related multiple instance saved\n      var $previouslyRelated = this._findRelated();\n      for (var i = 0; i < $previouslyRelated.length; i++) {\n        parsleyMultipleInstance = $($previouslyRelated.get(i)).data('Parsley');\n        if ('undefined' !== typeof parsleyMultipleInstance) {\n\n          if (!this.$element.data('FieldMultiple')) {\n            parsleyMultipleInstance.addElement(this.$element);\n          }\n\n          break;\n        }\n      }\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      this.bind('parsleyField', true);\n\n      return parsleyMultipleInstance || this.bind('parsleyFieldMultiple');\n    },\n\n    // Return proper `Form`, `Field` or `FieldMultiple`\n    bind: function (type, doNotStore) {\n      var parsleyInstance;\n\n      switch (type) {\n        case 'parsleyForm':\n          parsleyInstance = $.extend(\n            new Form(this.element, this.domOptions, this.options),\n            new Base(),\n            window.ParsleyExtend\n          )._bindFields();\n          break;\n        case 'parsleyField':\n          parsleyInstance = $.extend(\n            new parsley_field(this.element, this.domOptions, this.options, this.parent),\n            new Base(),\n            window.ParsleyExtend\n          );\n          break;\n        case 'parsleyFieldMultiple':\n          parsleyInstance = $.extend(\n            new parsley_field(this.element, this.domOptions, this.options, this.parent),\n            new Multiple(),\n            new Base(),\n            window.ParsleyExtend\n          )._init();\n          break;\n        default:\n          throw new Error(type + 'is not a supported Parsley type');\n      }\n\n      if (this.options.multiple)\n        Utils.setAttr(this.element, this.options.namespace, 'multiple', this.options.multiple);\n\n      if ('undefined' !== typeof doNotStore) {\n        this.$element.data('FieldMultiple', parsleyInstance);\n\n        return parsleyInstance;\n      }\n\n      // Store the freshly bound instance in a DOM element for later access using jQuery `data()`\n      this.$element.data('Parsley', parsleyInstance);\n\n      // Tell the world we have a new Form or Field instance!\n      parsleyInstance._actualizeTriggers();\n      parsleyInstance._trigger('init');\n\n      return parsleyInstance;\n    }\n  };\n\n  var vernums = $.fn.jquery.split('.');\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  if (!vernums.forEach) {\n    Utils.warn('Parsley requires ES5 to run properly. Please include https://github.com/es-shims/es5-shim');\n  }\n  // Inherit `on`, `off` & `trigger` to Parsley:\n  var Parsley = Object.assign(new Base(), {\n      element: document,\n      $element: $(document),\n      actualizeOptions: null,\n      _resetOptions: null,\n      Factory: Factory,\n      version: '2.8.1'\n    });\n\n  // Supplement Field and Form with Base\n  // This way, the constructors will have access to those methods\n  Object.assign(parsley_field.prototype, UI.Field, Base.prototype);\n  Object.assign(Form.prototype, UI.Form, Base.prototype);\n  // Inherit actualizeOptions and _resetOptions:\n  Object.assign(Factory.prototype, Base.prototype);\n\n  // ### jQuery API\n  // `$('.elem').parsley(options)` or `$('.elem').psly(options)`\n  $.fn.parsley = $.fn.psly = function (options) {\n    if (this.length > 1) {\n      var instances = [];\n\n      this.each(function () {\n        instances.push($(this).parsley(options));\n      });\n\n      return instances;\n    }\n\n    // Return undefined if applied to non existing DOM element\n    if (this.length == 0) {\n      return;\n    }\n\n    return new Factory(this[0], options);\n  };\n\n  // ### Field and Form extension\n  // Ensure the extension is now defined if it wasn't previously\n  if ('undefined' === typeof window.ParsleyExtend)\n    window.ParsleyExtend = {};\n\n  // ### Parsley config\n  // Inherit from ParsleyDefault, and copy over any existing values\n  Parsley.options = Object.assign(Utils.objectCreate(Defaults), window.ParsleyConfig);\n  window.ParsleyConfig = Parsley.options; // Old way of accessing global options\n\n  // ### Globals\n  window.Parsley = window.psly = Parsley;\n  Parsley.Utils = Utils;\n  window.ParsleyUtils = {};\n  $.each(Utils, (key, value) => {\n    if ('function' === typeof value) {\n      window.ParsleyUtils[key] = (...args) => {\n        Utils.warnOnce('Accessing `window.ParsleyUtils` is deprecated. Use `window.Parsley.Utils` instead.');\n        return Utils[key](...args);\n      };\n    }\n  });\n\n  // ### Define methods that forward to the registry, and deprecate all access except through window.Parsley\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] = (...args) => registry[method](...args);\n    window.ParsleyValidator[method] = function () {\n      Utils.warnOnce(`Accessing the method '${method}' through Validator is deprecated. Simply call 'window.Parsley.${method}(...)'`);\n      return window.Parsley[method](...arguments);\n    };\n  });\n\n  // ### UI\n  // Deprecated global object\n  window.Parsley.UI = UI;\n  window.ParsleyUI = {\n    removeError: function (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, {updateClass});\n    },\n    getErrorsMessages: function (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 '${method}' on the instance directly. Please comment in issue 1073 as to your need to call this method.`);\n      return instance[method](name, {message, assert, updateClass});\n    };\n  });\n\n  // ### PARSLEY auto-binding\n  // Prevent it by setting `ParsleyConfig.autoBind` to `false`\n  if (false !== window.ParsleyConfig.autoBind) {\n    $(function () {\n      // Works only on `data-parsley-validate`.\n      if ($('[data-parsley-validate]').length)\n        $('[data-parsley-validate]').parsley();\n    });\n  }\n\n  var o = $({});\n  var deprecated = function () {\n    Utils.warnOnce(\"Parsley's pubsub module is deprecated; use the 'on' and 'off' methods on parsley instances or window.Parsley\");\n  };\n\n  // Returns an event handler that calls `fn` with the arguments it expects\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    return fn.parsleyAdaptedCallback;\n  }\n\n  var eventPrefix = 'parsley:';\n  // Converts 'parsley:form:validate' into 'form:validate'\n  function eventName(name) {\n    if (name.lastIndexOf(eventPrefix, 0) === 0)\n      return name.substr(eventPrefix.length);\n    return name;\n  }\n\n  // $.listen is deprecated. Use Parsley.on instead.\n  $.listen = function (name, callback) {\n    var context;\n    deprecated();\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)\n      throw new Error('Wrong parameters');\n\n    window.Parsley.on(eventName(name), adapt(callback, context));\n  };\n\n  $.listenTo = function (instance, name, fn) {\n    deprecated();\n    if (!(instance instanceof parsley_field) && !(instance instanceof Form))\n      throw new Error('Must give Parsley instance');\n\n    if ('string' !== typeof name || 'function' !== typeof fn)\n      throw new Error('Wrong parameters');\n\n    instance.on(eventName(name), adapt(fn));\n  };\n\n  $.unsubscribe = function (name, fn) {\n    deprecated();\n    if ('string' !== typeof name || 'function' !== typeof fn)\n      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 parsley_field) && !(instance instanceof Form))\n      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      if (instance) {\n        instance.off(eventName(name));\n      }\n    });\n  };\n\n  // $.emit is deprecated. Use jQuery events instead.\n  $.emit = function (name, instance) {\n    deprecated();\n    var instanceGiven = (instance instanceof parsley_field) || (instance instanceof Form);\n    var args = Array.prototype.slice.call(arguments, instanceGiven ? 2 : 1);\n    args.unshift(eventName(name));\n    if (!instanceGiven) {\n      instance = window.Parsley;\n    }\n    instance.trigger(...args);\n  };\n\n  var pubsub = {};\n\n  $.extend(true, Parsley, {\n    asyncValidators: {\n      'default': {\n        fn: function (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 (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\n    addAsyncValidator: function (name, fn, url, options) {\n      Parsley.asyncValidators[name] = {\n        fn: fn,\n        url: url || false,\n        options: options || {}\n      };\n\n      return this;\n    }\n\n  });\n\n  Parsley.addValidator('remote', {\n    requirementType: {\n      '': 'string',\n      'validator': 'string',\n      'reverse': 'boolean',\n      'options': 'object'\n    },\n\n    validateString: function (value, url, options, instance) {\n      var data = {};\n      var ajaxOptions;\n      var csr;\n      var validator = options.validator || (true === options.reverse ? 'reverse' : 'default');\n\n      if ('undefined' === typeof Parsley.asyncValidators[validator])\n        throw new Error('Calling an undefined async validator: `' + validator + '`');\n\n      url = Parsley.asyncValidators[validator].url || url;\n\n      // Fill current value\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      }\n\n      // Merge options passed in from the function with the ones in the attribute\n      var remoteOptions = $.extend(true, options.options || {} , Parsley.asyncValidators[validator].options);\n\n      // All `$.ajax(options)` could be overridden or extended directly from DOM in `data-parsley-remote-options`\n      ajaxOptions = $.extend(true, {}, {\n        url: url,\n        data: data,\n        type: 'GET'\n      }, remoteOptions);\n\n      // Generate store key based on ajax options\n      instance.trigger('field:ajaxoptions', instance, ajaxOptions);\n\n      csr = $.param(ajaxOptions);\n\n      // Initialise querry cache\n      if ('undefined' === typeof Parsley._remoteCache)\n        Parsley._remoteCache = {};\n\n      // Try to retrieve stored xhr\n      var xhr = Parsley._remoteCache[csr] = Parsley._remoteCache[csr] || $.ajax(ajaxOptions);\n\n      var handleXhr = function () {\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\n    priority: -1\n  });\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(...arguments);\n  };\n\n  // This is included with the Parsley library itself,\n  // thus there is no use in adding it to your project.\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  });\n\n  Parsley.setLocale('en');\n\n  /**\n   * inputevent - Alleviate browser bugs for input events\n   * https://github.com/marcandre/inputevent\n   * @version v0.0.3 - (built Thu, Apr 14th 2016, 5:58 pm)\n   * @author Marc-Andre Lafortune <github@marc-andre.ca>\n   * @license MIT\n   */\n\n  function InputEvent() {\n    let globals = window || global;\n\n    // Slightly odd way construct our object. This way methods are force bound.\n    // Used to test for duplicate library.\n    Object.assign(this, {\n\n      // For browsers that do not support isTrusted, assumes event is native.\n      isNativeEvent: evt => {\n        return evt.originalEvent && evt.originalEvent.isTrusted !== false;\n      },\n\n      fakeInputEvent: evt => {\n        if (this.isNativeEvent(evt)) {\n          $(evt.target).trigger('input');\n        }\n      },\n\n      misbehaves: evt => {\n        if (this.isNativeEvent(evt)) {\n          this.behavesOk(evt);\n          $(document)\n            .on('change.inputevent', evt.data.selector, this.fakeInputEvent);\n          this.fakeInputEvent(evt);\n        }\n      },\n\n      behavesOk: evt => {\n        if (this.isNativeEvent(evt)) {\n          $(document) // Simply unbinds the testing handler\n            .off('input.inputevent', evt.data.selector, this.behavesOk)\n            .off('change.inputevent', evt.data.selector, this.misbehaves);\n        }\n      },\n\n      // Bind the testing handlers\n      install: () => {\n        if (globals.inputEventPatched) {\n          return;\n        }\n        globals.inputEventPatched = '0.0.3';\n        for (let selector of ['select', 'input[type=\"checkbox\"]', 'input[type=\"radio\"]', 'input[type=\"file\"]']) {\n          $(document)\n            .on('input.inputevent', selector, {selector}, this.behavesOk)\n            .on('change.inputevent', selector, {selector}, this.misbehaves);\n        }\n      },\n\n      uninstall: () => {\n        delete globals.inputEventPatched;\n        $(document).off('.inputevent');\n      }\n\n    });\n  };\n\n  var inputevent = new InputEvent();\n\n  inputevent.install();\n\n  var parsley = Parsley;\n\n  return parsley;\n\n}));\n","import $ from 'jquery';\nimport Field from './field';\nimport Form from './form';\nimport Utils from './utils';\n\nvar o = $({});\nvar deprecated = function () {\n  Utils.warnOnce(\"Parsley's pubsub module is deprecated; use the 'on' and 'off' methods on parsley instances or window.Parsley\");\n};\n\n// Returns an event handler that calls `fn` with the arguments it expects\nfunction 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  return fn.parsleyAdaptedCallback;\n}\n\nvar eventPrefix = 'parsley:';\n// Converts 'parsley:form:validate' into 'form:validate'\nfunction eventName(name) {\n  if (name.lastIndexOf(eventPrefix, 0) === 0)\n    return name.substr(eventPrefix.length);\n  return name;\n}\n\n// $.listen is deprecated. Use Parsley.on instead.\n$.listen = function (name, callback) {\n  var context;\n  deprecated();\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)\n    throw new Error('Wrong parameters');\n\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))\n    throw new Error('Must give Parsley instance');\n\n  if ('string' !== typeof name || 'function' !== typeof fn)\n    throw new Error('Wrong parameters');\n\n  instance.on(eventName(name), adapt(fn));\n};\n\n$.unsubscribe = function (name, fn) {\n  deprecated();\n  if ('string' !== typeof name || 'function' !== typeof fn)\n    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))\n    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    if (instance) {\n      instance.off(eventName(name));\n    }\n  });\n};\n\n// $.emit is deprecated. Use jQuery events instead.\n$.emit = function (name, instance) {\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  if (!instanceGiven) {\n    instance = window.Parsley;\n  }\n  instance.trigger(...args);\n};\n\nexport default {};\n","/**\n * inputevent - Alleviate browser bugs for input events\n * https://github.com/marcandre/inputevent\n * @version v0.0.3 - (built Thu, Apr 14th 2016, 5:58 pm)\n * @author Marc-Andre Lafortune <github@marc-andre.ca>\n * @license MIT\n */\n\nimport $ from 'jquery';\n\nfunction InputEvent() {\n  let globals = window || global;\n\n  // Slightly odd way construct our object. This way methods are force bound.\n  // Used to test for duplicate library.\n  Object.assign(this, {\n\n    // For browsers that do not support isTrusted, assumes event is native.\n    isNativeEvent: evt => {\n      return evt.originalEvent && evt.originalEvent.isTrusted !== false;\n    },\n\n    fakeInputEvent: evt => {\n      if (this.isNativeEvent(evt)) {\n        $(evt.target).trigger('input');\n      }\n    },\n\n    misbehaves: evt => {\n      if (this.isNativeEvent(evt)) {\n        this.behavesOk(evt);\n        $(document)\n          .on('change.inputevent', evt.data.selector, this.fakeInputEvent);\n        this.fakeInputEvent(evt);\n      }\n    },\n\n    behavesOk: evt => {\n      if (this.isNativeEvent(evt)) {\n        $(document) // Simply unbinds the testing handler\n          .off('input.inputevent', evt.data.selector, this.behavesOk)\n          .off('change.inputevent', evt.data.selector, this.misbehaves);\n      }\n    },\n\n    // Bind the testing handlers\n    install: () => {\n      if (globals.inputEventPatched) {\n        return;\n      }\n      globals.inputEventPatched = '0.0.3';\n      for (let selector of ['select', 'input[type=\"checkbox\"]', 'input[type=\"radio\"]', 'input[type=\"file\"]']) {\n        $(document)\n          .on('input.inputevent', selector, {selector}, this.behavesOk)\n          .on('change.inputevent', selector, {selector}, this.misbehaves);\n      }\n    },\n\n    uninstall: () => {\n      delete globals.inputEventPatched;\n      $(document).off('.inputevent');\n    }\n\n  });\n};\n\nexport default new InputEvent();\n","import $ from 'jquery';\n\nvar globalID = 1;\nvar pastWarnings = {};\n\nvar Utils = {\n  // Parsley DOM-API\n  // returns object from dom attributes and values\n  attr: function (element, namespace, obj) {\n    var i;\n    var attribute;\n    var attributes;\n    var regex = new RegExp('^' + namespace, 'i');\n\n    if ('undefined' === typeof obj)\n      obj = {};\n    else {\n      // Clear all own properties. This won't affect prototype's values\n      for (i in obj) {\n        if (obj.hasOwnProperty(i))\n          delete obj[i];\n      }\n    }\n\n    if (!element)\n      return obj;\n\n    attributes = element.attributes;\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\n  checkAttr: function (element, namespace, checkAttr) {\n    return element.hasAttribute(namespace + checkAttr);\n  },\n\n  setAttr: function (element, namespace, attr, value) {\n    element.setAttribute(this.dasherize(namespace + attr), String(value));\n  },\n\n  getType: function(element) {\n    return element.getAttribute('type') || 'text';\n  },\n\n  generateID: function () {\n    return '' + globalID++;\n  },\n\n  /** Third party functions **/\n  deserializeValue: function (value) {\n    var num;\n\n    try {\n      return value ?\n        value == \"true\" ||\n        (value == \"false\" ? false :\n        value == \"null\" ? null :\n        !isNaN(num = Number(value)) ? num :\n        /^[\\[\\{]/.test(value) ? JSON.parse(value) :\n        value)\n        : value;\n    } catch (e) { return value; }\n  },\n\n  // Zepto camelize function\n  camelize: function (str) {\n    return str.replace(/-+(.)?/g, function (match, chr) {\n      return chr ? chr.toUpperCase() : '';\n    });\n  },\n\n  // Zepto dasherize function\n  dasherize: function (str) {\n    return str.replace(/::/g, '/')\n      .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')\n      .replace(/([a-z\\d])([A-Z])/g, '$1_$2')\n      .replace(/_/g, '-')\n      .toLowerCase();\n  },\n\n  warn: function () {\n    if (window.console && 'function' === typeof window.console.warn)\n      window.console.warn(...arguments);\n  },\n\n  warnOnce: function(msg) {\n    if (!pastWarnings[msg]) {\n      pastWarnings[msg] = true;\n      this.warn(...arguments);\n    }\n  },\n\n  _resetWarnings: function () {\n    pastWarnings = {};\n  },\n\n  trimString: function(string) {\n    return string.replace(/^\\s+|\\s+$/g, '');\n  },\n\n  parse: {\n    date: function(string) {\n      let parsed = string.match(/^(\\d{4,})-(\\d\\d)-(\\d\\d)$/);\n      if (!parsed)\n        return null;\n      let [_, year, month, day] = parsed.map(x => parseInt(x, 10));\n      let date = new Date(year, month - 1, day);\n      if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day)\n        return null;\n      return date;\n    },\n    string: function(string) {\n      return string;\n    },\n    integer: function(string) {\n      if (isNaN(string))\n        return null;\n      return parseInt(string, 10);\n    },\n    number: function(string) {\n      if (isNaN(string))\n        throw null;\n      return parseFloat(string);\n    },\n    'boolean': function _boolean(string) {\n      return !(/^\\s*false\\s*$/i.test(string));\n    },\n    object: function(string) {\n      return Utils.deserializeValue(string);\n    },\n    regexp: function(regexp) {\n      var flags = '';\n\n      // Test if RegExp is literal, if not, nothing to be done, otherwise, we need to isolate flags and pattern\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');\n        // Again, replace the regexp literal string with the first match group:\n        // everything excluding the opening and closing slashes and the flags\n        regexp = regexp.replace(new RegExp('^/(.*?)/' + flags + '$'), '$1');\n      } else {\n        // Anchor regexp:\n        regexp = '^' + regexp + '$';\n      }\n      return new RegExp(regexp, flags);\n    }\n  },\n\n  parseRequirement: function(requirementType, string) {\n    var converter = this.parse[requirementType || 'string'];\n    if (!converter)\n      throw 'Unknown requirement specification: \"' + requirementType + '\"';\n    let converted = converter(string);\n    if (converted === null)\n      throw `Requirement is not a ${requirementType}: \"${string}\"`;\n    return converted;\n  },\n\n  namespaceEvents: function(events, namespace) {\n    events = this.trimString(events || '').split(/\\s+/);\n    if (!events[0])\n      return '';\n    return $.map(events, evt => `${evt}.${namespace}`).join(' ');\n  },\n\n  difference: function(array, remove) {\n    // This is O(N^2), should be optimized\n    let result = [];\n    $.each(array, (_, elem) => {\n      if (remove.indexOf(elem) == -1)\n        result.push(elem);\n    });\n    return result;\n  },\n\n  // Alter-ego to native Promise.all, but for jQuery\n  all: function(promises) {\n    // jQuery treats $.when() and $.when(singlePromise) differently; let's avoid that and add spurious elements\n    return $.when(...promises, 42, 42);\n  },\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 () {};\n    return function (prototype) {\n      if (arguments.length > 1) {\n        throw Error('Second argument not supported');\n      }\n      if (typeof prototype != 'object') {\n        throw TypeError('Argument must be an object');\n      }\n      Object.prototype = prototype;\n      var result = new Object();\n      Object.prototype = null;\n      return result;\n    };\n  })(),\n\n  _SubmitSelector: 'input[type=\"submit\"], button:submit'\n};\n\nexport default Utils;\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\nvar Defaults = {\n  // ### General\n\n  // Default data-namespace for DOM API\n  namespace: 'data-parsley-',\n\n  // Supported inputs by default\n  inputs: 'input, textarea, select',\n\n  // Excluded inputs by default\n  excluded: 'input[type=button], input[type=submit], input[type=reset], input[type=hidden]',\n\n  // Stop validating field on highest priority failing constraint\n  priorityEnabled: true,\n\n  // ### Field only\n\n  // identifier used to group together inputs (e.g. radio buttons...)\n  multiple: null,\n\n  // identifier (or array of identifiers) used to validate only a select group of inputs\n  group: null,\n\n  // ### UI\n  // Enable\\Disable error messages\n  uiEnabled: true,\n\n  // Key events threshold before validation\n  validationThreshold: 3,\n\n  // Focused field on form validation error. 'first'|'last'|'none'\n  focus: 'first',\n\n  // event(s) that will trigger validation before first failure. eg: `input`...\n  trigger: false,\n\n  // event(s) that will trigger validation after first failure.\n  triggerAfterFailure: 'input',\n\n  // Class that would be added on every failing validation Parsley field\n  errorClass: 'parsley-error',\n\n  // Same for success validation\n  successClass: 'parsley-success',\n\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 (Field) {},\n\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 (Field) {},\n\n  // ul elem that would receive errors' list\n  errorsWrapper: '<ul class=\"parsley-errors-list\"></ul>',\n\n  // li elem that would receive error message\n  errorTemplate: '<li></li>'\n};\n\nexport default Defaults;\n","import $ from 'jquery';\nimport Utils from './utils';\n\nvar Base = function () {\n  this.__id__ = Utils.generateID();\n};\n\nBase.prototype = {\n  asyncSupport: true, // Deprecated\n\n  _pipeAccordingToValidationResult: function () {\n    var pipe = () => {\n      var r = $.Deferred();\n      if (true !== this.validationResult)\n        r.reject();\n      return r.resolve().promise();\n    };\n    return [pipe, pipe];\n  },\n\n  actualizeOptions: function () {\n    Utils.attr(this.element, this.options.namespace, this.domOptions);\n    if (this.parent && this.parent.actualizeOptions)\n      this.parent.actualizeOptions();\n    return this;\n  },\n\n  _resetOptions: function (initOptions) {\n    this.domOptions = Utils.objectCreate(this.parent.options);\n    this.options = Utils.objectCreate(this.domOptions);\n    // Shallow copy of ownProperties of initOptions:\n    for (var i in initOptions) {\n      if (initOptions.hasOwnProperty(i))\n        this.options[i] = initOptions[i];\n    }\n    this.actualizeOptions();\n  },\n\n  _listeners: null,\n\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 (name, fn) {\n    this._listeners = this._listeners || {};\n    var queue = this._listeners[name] = this._listeners[name] || [];\n    queue.push(fn);\n\n    return this;\n  },\n\n  // Deprecated. Use `on` instead\n  subscribe: function(name, fn) {\n    $.listenTo(this, name.toLowerCase(), fn);\n  },\n\n  // Unregister a callback (or all if none is given) for the given event name\n  off: function (name, fn) {\n    var queue = this._listeners && this._listeners[name];\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)\n            queue.splice(i, 1);\n      }\n    }\n    return this;\n  },\n\n  // Deprecated. Use `off`\n  unsubscribe: function(name, fn) {\n    $.unsubscribeTo(this, name.toLowerCase());\n  },\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 (name, target, extraArg) {\n    target = target || this;\n    var queue = this._listeners && this._listeners[name];\n    var result;\n    var parentResult;\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    if (this.parent) {\n      return this.parent.trigger(name, target, extraArg);\n    }\n    return true;\n  },\n\n  asyncIsValid: function (group, force) {\n    Utils.warnOnce(\"asyncIsValid is deprecated; please use whenValid instead\");\n    return this.whenValid({group, force});\n  },\n\n  _findRelated: function () {\n    return this.options.multiple ?\n      $(this.parent.element.querySelectorAll(`[${this.options.namespace}multiple=\"${this.options.multiple}\"]`))\n    : this.$element;\n  }\n};\n\nexport default Base;\n","import $ from 'jquery';\nimport Utils from './utils';\n\nvar convertArrayRequirement = function(string, length) {\n  var m = string.match(/^\\s*\\[(.*)\\]\\s*$/);\n  if (!m)\n    throw 'Requirement is not an array: \"' + string + '\"';\n  var values = m[1].split(',').map(Utils.trimString);\n  if (values.length !== length)\n    throw 'Requirement has ' + values.length + ' values when ' + length + ' are needed';\n  return values;\n};\n\nvar convertExtraOptionRequirement = function(requirementSpec, string, extraOptionReader) {\n  var main = null;\n  var extra = {};\n  for (var key in requirementSpec) {\n    if (key) {\n      var value = extraOptionReader(key);\n      if ('string' === typeof value)\n        value = Utils.parseRequirement(requirementSpec[key], value);\n      extra[key] = value;\n    } else {\n      main = Utils.parseRequirement(requirementSpec[key], string);\n    }\n  }\n  return [main, extra];\n};\n\n// A Validator needs to implement the methods `validate` and `parseRequirements`\n\nvar Validator = function(spec) {\n  $.extend(true, this, spec);\n};\n\nValidator.prototype = {\n  // Returns `true` iff the given `value` is valid according the given requirements.\n  validate: function(value, requirementFirstArg) {\n    if (this.fn) { // Legacy style validator\n\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      return this.fn(value, requirementFirstArg);\n    }\n\n    if (Array.isArray(value)) {\n      if (!this.validateMultiple)\n        throw 'Validator `' + this.name + '` does not handle multiple values';\n      return this.validateMultiple(...arguments);\n    } else {\n      let instance = arguments[arguments.length - 1];\n      if (this.validateDate && instance._isDateInput()) {\n        arguments[0] = Utils.parse.date(arguments[0]);\n        if (arguments[0] === null)\n          return false;\n        return this.validateDate(...arguments);\n      }\n      if (this.validateNumber) {\n        if (isNaN(value))\n          return false;\n        arguments[0] = parseFloat(arguments[0]);\n        return this.validateNumber(...arguments);\n      }\n      if (this.validateString) {\n        return this.validateString(...arguments);\n      }\n      throw 'Validator `' + this.name + '` only handles multiple values';\n    }\n  },\n\n  // Parses `requirements` into an array of arguments,\n  // according to `this.requirementType`\n  parseRequirements: function(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    var type = this.requirementType;\n    if (Array.isArray(type)) {\n      var values = convertArrayRequirement(requirements, type.length);\n      for (var i = 0; i < values.length; i++)\n        values[i] = Utils.parseRequirement(type[i], values[i]);\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\n  priority: 2\n\n};\n\nexport default Validator;\n","import $ from 'jquery';\nimport Utils from './utils';\nimport Defaults from './defaults';\nimport Validator from './validator';\n\nvar ValidatorRegistry = function (validators, catalog) {\n  this.__class__ = 'ValidatorRegistry';\n\n  // Default Parsley locale is en\n  this.locale = 'en';\n\n  this.init(validators || {}, catalog || {});\n};\n\nvar 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\n  // Follow https://www.w3.org/TR/html5/infrastructure.html#floating-point-numbers\n  number: /^-?(\\d*\\.)?\\d+(e[-+]?\\d+)?$/i,\n\n  integer: /^-?\\d+$/,\n\n  digits: /^\\d+$/,\n\n  alphanum: /^\\w+$/i,\n\n  date: {\n    test: value => Utils.parse.date(value) !== null\n  },\n\n  url: new RegExp(\n      \"^\" +\n        // protocol identifier\n        \"(?:(?:https?|ftp)://)?\" + // ** mod: make scheme optional\n        // user:pass authentication\n        \"(?:\\\\S+(?::\\\\S*)?@)?\" +\n        \"(?:\" +\n          // 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])\" +\n          \"(?:\\\\.(?:1?\\\\d{1,2}|2[0-4]\\\\d|25[0-5])){2}\" +\n          \"(?:\\\\.(?:[1-9]\\\\d?|1\\\\d\\\\d|2[0-4]\\\\d|25[0-4]))\" +\n        \"|\" +\n          // host name\n          \"(?:(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)\" +\n          // domain name\n          \"(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff0-9]-*)*[a-zA-Z\\\\u00a1-\\\\uffff0-9]+)*\" +\n          // TLD identifier\n          \"(?:\\\\.(?:[a-zA-Z\\\\u00a1-\\\\uffff]{2,}))\" +\n        \")\" +\n        // port number\n        \"(?::\\\\d{2,5})?\" +\n        // resource path\n        \"(?:/\\\\S*)?\" +\n      \"$\"\n    )\n};\ntypeTesters.range = typeTesters.number;\n\n// See http://stackoverflow.com/a/10454560/8279\nvar decimalPlaces = num => {\n  var match = ('' + num).match(/(?:\\.(\\d+))?(?:[eE]([+-]?\\d+))?$/);\n  if (!match) { return 0; }\n  return Math.max(\n       0,\n       // Number of digits right of decimal point.\n       (match[1] ? match[1].length : 0) -\n       // Adjust for scientific notation.\n       (match[2] ? +match[2] : 0));\n};\n\n// parseArguments('number', ['1', '2']) => [1, 2]\nlet parseArguments = (type, args) => args.map(Utils.parse[type]);\n// operatorToValidator returns a validating function for an operator function, applied to the given type\nlet operatorToValidator = (type, operator) => {\n  return (value, ...requirementsAndInput) => {\n    requirementsAndInput.pop(); // Get rid of `input` argument\n    return operator(value, ...parseArguments(type, requirementsAndInput));\n  };\n};\n\nlet comparisonOperator = operator => ({\n  validateDate: operatorToValidator('date', operator),\n  validateNumber: operatorToValidator('number', operator),\n  requirementType: operator.length <= 2 ? 'string' : ['string', 'string'], // Support operators with a 1 or 2 requirement(s)\n  priority: 30\n});\n\nValidatorRegistry.prototype = {\n  init: function (validators, catalog) {\n    this.catalog = catalog;\n    // Copy prototype's validators:\n    this.validators = Object.assign({}, this.validators);\n\n    for (var name in validators)\n      this.addValidator(name, validators[name].fn, validators[name].priority);\n\n    window.Parsley.trigger('parsley:validator:init');\n  },\n\n  // Set new messages locale if we have dictionary loaded in ParsleyConfig.i18n\n  setLocale: function (locale) {\n    if ('undefined' === typeof this.catalog[locale])\n      throw new Error(locale + ' is not available in the catalog');\n\n    this.locale = locale;\n\n    return this;\n  },\n\n  // Add a new messages catalog for a given locale. Set locale for this catalog if set === `true`\n  addCatalog: function (locale, messages, set) {\n    if ('object' === typeof messages)\n      this.catalog[locale] = messages;\n\n    if (true === set)\n      return this.setLocale(locale);\n\n    return this;\n  },\n\n  // Add a specific message for a given constraint in a given locale\n  addMessage: function (locale, name, message) {\n    if ('undefined' === typeof this.catalog[locale])\n      this.catalog[locale] = {};\n\n    this.catalog[locale][name] = message;\n\n    return this;\n  },\n\n  // Add messages for a given locale\n  addMessages: function (locale, nameMessageObject) {\n    for (var name in nameMessageObject)\n      this.addMessage(locale, name, nameMessageObject[name]);\n\n    return this;\n  },\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 (name, arg1, arg2) {\n    if (this.validators[name])\n      Utils.warn('Validator \"' + name + '\" is already defined.');\n    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(...arguments);\n  },\n\n  hasValidator: function (name) {\n    return !!this.validators[name];\n  },\n\n  updateValidator: function (name, arg1, arg2) {\n    if (!this.validators[name]) {\n      Utils.warn('Validator \"' + name + '\" is not already defined.');\n      return this.addValidator(...arguments);\n    }\n    return this._setValidator(...arguments);\n  },\n\n  removeValidator: function (name) {\n    if (!this.validators[name])\n      Utils.warn('Validator \"' + name + '\" is not defined.');\n\n    delete this.validators[name];\n\n    return this;\n  },\n\n  _setValidator: function (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    if (!validator.validate) {\n      validator = new Validator(validator);\n    }\n    this.validators[name] = validator;\n\n    for (var locale in validator.messages || {})\n      this.addMessage(locale, name, validator.messages[locale]);\n\n    return this;\n  },\n\n  getErrorMessage: function (constraint) {\n    var message;\n\n    // Type constraints are a bit different, we have to match their requirements too to find right error message\n    if ('type' === constraint.name) {\n      var typeMessages = this.catalog[this.locale][constraint.name] || {};\n      message = typeMessages[constraint.requirements];\n    } else\n      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\n  // Kind of light `sprintf()` implementation\n  formatMessage: function (string, parameters) {\n    if ('object' === typeof parameters) {\n      for (var i in parameters)\n        string = this.formatMessage(string, parameters[i]);\n\n      return string;\n    }\n\n    return 'string' === typeof string ? string.replace(/%s/i, parameters) : '';\n  },\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(value) {\n        return /\\S/.test(value);\n      },\n      priority: 2\n    },\n    required: {\n      validateMultiple: function(values) {\n        return values.length > 0;\n      },\n      validateString: function(value) {\n        return /\\S/.test(value);\n      },\n      priority: 512\n    },\n    type: {\n      validateString: function(value, type, {step = 'any', base = 0} = {}) {\n        var tester = typeTesters[type];\n        if (!tester) {\n          throw new Error('validator type `' + type + '` is not supported');\n        }\n        if (!tester.test(value))\n          return false;\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;\n            // Be careful of rounding errors by using integers.\n            var toInt = f => Math.round(f * Math.pow(10, decimals));\n            if ((toInt(nb) - toInt(base)) % toInt(step) != 0)\n              return false;\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(value, regexp) {\n        return regexp.test(value);\n      },\n      requirementType: 'regexp',\n      priority: 64\n    },\n    minlength: {\n      validateString: function (value, requirement) {\n        return value.length >= requirement;\n      },\n      requirementType: 'integer',\n      priority: 30\n    },\n    maxlength: {\n      validateString: function (value, requirement) {\n        return value.length <= requirement;\n      },\n      requirementType: 'integer',\n      priority: 30\n    },\n    length: {\n      validateString: function (value, min, max) {\n        return value.length >= min && value.length <= max;\n      },\n      requirementType: ['integer', 'integer'],\n      priority: 30\n    },\n    mincheck: {\n      validateMultiple: function (values, requirement) {\n        return values.length >= requirement;\n      },\n      requirementType: 'integer',\n      priority: 30\n    },\n    maxcheck: {\n      validateMultiple: function (values, requirement) {\n        return values.length <= requirement;\n      },\n      requirementType: 'integer',\n      priority: 30\n    },\n    check: {\n      validateMultiple: function (values, min, max) {\n        return values.length >= min && values.length <= max;\n      },\n      requirementType: ['integer', 'integer'],\n      priority: 30\n    },\n    min: comparisonOperator((value, requirement) => value >= requirement),\n    max: comparisonOperator((value, requirement) => value <= requirement),\n    range: comparisonOperator((value, min, max) => value >= min && value <= max),\n    equalto: {\n      validateString: function (value, refOrValue) {\n        var $reference = $(refOrValue);\n        if ($reference.length)\n          return value === $reference.val();\n        else\n          return value === refOrValue;\n      },\n      priority: 256\n    }\n  }\n};\n\nexport default ValidatorRegistry;\n","import $ from 'jquery';\nimport Utils from './utils';\n\nvar UI = {};\n\nvar diffResults = function (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    if (found)\n      kept.push(newResult[i]);\n    else\n      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\nUI.Form = {\n\n  _actualizeTriggers: function () {\n    this.$element.on('submit.Parsley', evt => { this.onSubmitValidate(evt); });\n    this.$element.on('click.Parsley', Utils._SubmitSelector, evt => { this.onSubmitButton(evt); });\n\n    // UI could be disabled\n    if (false === this.options.uiEnabled)\n      return;\n\n    this.element.setAttribute('novalidate', '');\n  },\n\n  focus: function () {\n    this._focusedField = null;\n\n    if (true === this.validationResult || 'none' === this.options.focus)\n      return null;\n\n    for (var i = 0; i < this.fields.length; i++) {\n      var field = this.fields[i];\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)\n          break;\n      }\n    }\n\n    if (null === this._focusedField)\n      return null;\n\n    return this._focusedField.focus();\n  },\n\n  _destroyUI: function () {\n    // Reset all event listeners\n    this.$element.off('.Parsley');\n  }\n\n};\n\nUI.Field = {\n\n  _reflowUI: function () {\n    this._buildUI();\n\n    // If this field doesn't have an active UI don't bother doing something\n    if (!this._ui)\n      return;\n\n    // Diff between two validation results\n    var diff = diffResults(this.validationResult, this._ui.lastValidationResult);\n\n    // Then store current validation result for next reflow\n    this._ui.lastValidationResult = this.validationResult;\n\n    // Handle valid / invalid / none field class\n    this._manageStatusClass();\n\n    // Add, remove, updated errors messages\n    this._manageErrorsMessages(diff);\n\n    // Triggers impl\n    this._actualizeTriggers();\n\n    // If field is not valid for the first time, bind keyup trigger to ease UX and quickly inform user\n    if ((diff.kept.length || diff.added.length) && !this._failedOnce) {\n      this._failedOnce = true;\n      this._actualizeTriggers();\n    }\n  },\n\n  // Returns an array of field's error message(s)\n  getErrorsMessages: function () {\n    // No error message, field is valid\n    if (true === this.validationResult)\n      return [];\n\n    var messages = [];\n\n    for (var i = 0; i < this.validationResult.length; i++)\n      messages.push(this.validationResult[i].errorMessage ||\n       this._getErrorMessage(this.validationResult[i].assert));\n\n    return messages;\n  },\n\n  // It's a goal of Parsley that this method is no longer required [#1073]\n  addError: function (name, {message, assert, updateClass = true} = {}) {\n    this._buildUI();\n    this._addError(name, {message, assert});\n\n    if (updateClass)\n      this._errorClass();\n  },\n\n  // It's a goal of Parsley that this method is no longer required [#1073]\n  updateError: function (name, {message, assert, updateClass = true} = {}) {\n    this._buildUI();\n    this._updateError(name, {message, assert});\n\n    if (updateClass)\n      this._errorClass();\n  },\n\n  // It's a goal of Parsley that this method is no longer required [#1073]\n  removeError: function (name, {updateClass = true} = {}) {\n    this._buildUI();\n    this._removeError(name);\n\n    // 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    if (updateClass)\n      this._manageStatusClass();\n  },\n\n  _manageStatusClass: function () {\n    if (this.hasConstraints() && this.needsValidation() && true === this.validationResult)\n      this._successClass();\n    else if (this.validationResult.length > 0)\n      this._errorClass();\n    else\n      this._resetClass();\n  },\n\n  _manageErrorsMessages: function (diff) {\n    if ('undefined' !== typeof this.options.errorsMessagesDisabled)\n      return;\n\n    // Case where we have errorMessage option that configure an unique field error message, regardless failing validators\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)\n          this._ui.$errorsWrapper\n            .append(\n              $(this.options.errorTemplate)\n              .addClass('parsley-custom-error-message')\n            );\n\n        return this._ui.$errorsWrapper\n          .addClass('filled')\n          .find('.parsley-custom-error-message')\n          .html(this.options.errorMessage);\n      }\n\n      return this._ui.$errorsWrapper\n        .removeClass('filled')\n        .find('.parsley-custom-error-message')\n        .remove();\n    }\n\n    // Show, hide, update failing constraints messages\n    for (var i = 0; i < diff.removed.length; i++)\n      this._removeError(diff.removed[i].assert.name);\n\n    for (i = 0; i < diff.added.length; i++)\n      this._addError(diff.added[i].assert.name, {message: diff.added[i].errorMessage, assert: diff.added[i].assert});\n\n    for (i = 0; i < diff.kept.length; i++)\n      this._updateError(diff.kept[i].assert.name, {message: diff.kept[i].errorMessage, assert: diff.kept[i].assert});\n  },\n\n\n  _addError: function (name, {message, assert}) {\n    this._insertErrorWrapper();\n    this._ui.$errorClassHandler\n      .attr('aria-describedby', this._ui.errorsWrapperId);\n    this._ui.$errorsWrapper\n      .addClass('filled')\n      .append(\n        $(this.options.errorTemplate)\n        .addClass('parsley-' + name)\n        .html(message || this._getErrorMessage(assert))\n      );\n  },\n\n  _updateError: function (name, {message, assert}) {\n    this._ui.$errorsWrapper\n      .addClass('filled')\n      .find('.parsley-' + name)\n      .html(message || this._getErrorMessage(assert));\n  },\n\n  _removeError: function (name) {\n    this._ui.$errorClassHandler\n      .removeAttr('aria-describedby');\n    this._ui.$errorsWrapper\n      .removeClass('filled')\n      .find('.parsley-' + name)\n      .remove();\n  },\n\n  _getErrorMessage: function (constraint) {\n    var customConstraintErrorMessage = constraint.name + 'Message';\n\n    if ('undefined' !== typeof this.options[customConstraintErrorMessage])\n      return window.Parsley.formatMessage(this.options[customConstraintErrorMessage], constraint.requirements);\n\n    return window.Parsley.getErrorMessage(constraint);\n  },\n\n  _buildUI: function () {\n    // UI could be already built or disabled\n    if (this._ui || false === this.options.uiEnabled)\n      return;\n\n    var _ui = {};\n\n    // Give field its Parsley id in DOM\n    this.element.setAttribute(this.options.namespace + 'id', this.__id__);\n\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    _ui.$errorClassHandler = this._manageClassHandler();\n\n    // $errorsWrapper is a div that would contain the various field errors, it will be appended into $errorsContainer\n    _ui.errorsWrapperId = 'parsley-id-' + (this.options.multiple ? 'multiple-' + this.options.multiple : this.__id__);\n    _ui.$errorsWrapper = $(this.options.errorsWrapper).attr('id', _ui.errorsWrapperId);\n\n    // ValidationResult UI storage to detect what have changed bwt two validations, and update DOM accordingly\n    _ui.lastValidationResult = [];\n    _ui.validationInformationVisible = false;\n\n    // Store it in this for later\n    this._ui = _ui;\n  },\n\n  // Determine which element will have `parsley-error` and `parsley-success` classes\n  _manageClassHandler: function () {\n    // Class handled could also be determined by function given in Parsley options\n    if ('string' === typeof this.options.classHandler && $(this.options.classHandler).length)\n      return $(this.options.classHandler);\n\n    // Class handled could also be determined by function given in Parsley options\n    var $handlerFunction = this.options.classHandler;\n\n    // It might also be the function name of a global function\n    if ('string' === typeof this.options.classHandler && 'function' === typeof window[this.options.classHandler])\n      $handlerFunction = window[this.options.classHandler];\n\n    if ('function' === typeof $handlerFunction) {\n      var $handler = $handlerFunction.call(this, this);\n\n      // If this function returned a valid existing DOM element, go for it\n      if ('undefined' !== typeof $handler && $handler.length)\n        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\n  _inputHolder: function() {\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')\n      return this.$element;\n\n    // But if multiple element (radio, checkbox), that would be their parent\n    return this.$element.parent();\n  },\n\n  _insertErrorWrapper: function () {\n    var $errorsContainer = this.options.errorsContainer;\n\n    // Nothing to do if already inserted\n    if (0 !== this._ui.$errorsWrapper.parent().length)\n      return this._ui.$errorsWrapper.parent();\n\n    if ('string' === typeof $errorsContainer) {\n      if ($($errorsContainer).length)\n        return $($errorsContainer).append(this._ui.$errorsWrapper);\n      else if ('function' === typeof window[$errorsContainer])\n        $errorsContainer = window[$errorsContainer];\n      else\n        Utils.warn('The errors container `' + $errorsContainer + '` does not exist in DOM nor as a global JS function');\n    }\n\n    if ('function' === typeof $errorsContainer)\n      $errorsContainer = $errorsContainer.call(this, this);\n\n    if ('object' === typeof $errorsContainer && $errorsContainer.length)\n      return $errorsContainer.append(this._ui.$errorsWrapper);\n\n    return this._inputHolder().after(this._ui.$errorsWrapper);\n  },\n\n  _actualizeTriggers: function () {\n    var $toBind = this._findRelated();\n    var trigger;\n\n    // Remove Parsley events already bound on this field\n    $toBind.off('.Parsley');\n    if (this._failedOnce)\n      $toBind.on(Utils.namespaceEvents(this.options.triggerAfterFailure, 'Parsley'), () => {\n        this._validateIfNeeded();\n      });\n    else if (trigger = Utils.namespaceEvents(this.options.trigger, 'Parsley')) {\n      $toBind.on(trigger, event => {\n        this._validateIfNeeded(event);\n      });\n    }\n  },\n\n  _validateIfNeeded: function (event) {\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))\n      if (!(this._ui && this._ui.validationInformationVisible) && this.getValue().length <= this.options.validationThreshold)\n        return;\n\n    if (this.options.debounce) {\n      window.clearTimeout(this._debounced);\n      this._debounced = window.setTimeout(() => this.validate(), this.options.debounce);\n    } else\n      this.validate();\n  },\n\n  _resetUI: function () {\n    // Reset all event listeners\n    this._failedOnce = false;\n    this._actualizeTriggers();\n\n    // Nothing to do if UI never initialized for this field\n    if ('undefined' === typeof this._ui)\n      return;\n\n    // Reset all errors' li\n    this._ui.$errorsWrapper\n      .removeClass('filled')\n      .children()\n      .remove();\n\n    // Reset validation class\n    this._resetClass();\n\n    // Reset validation flags and last validation result\n    this._ui.lastValidationResult = [];\n    this._ui.validationInformationVisible = false;\n  },\n\n  _destroyUI: function () {\n    this._resetUI();\n\n    if ('undefined' !== typeof this._ui)\n      this._ui.$errorsWrapper.remove();\n\n    delete this._ui;\n  },\n\n  _successClass: function () {\n    this._ui.validationInformationVisible = true;\n    this._ui.$errorClassHandler.removeClass(this.options.errorClass).addClass(this.options.successClass);\n  },\n  _errorClass: function () {\n    this._ui.validationInformationVisible = true;\n    this._ui.$errorClassHandler.removeClass(this.options.successClass).addClass(this.options.errorClass);\n  },\n  _resetClass: function () {\n    this._ui.$errorClassHandler.removeClass(this.options.successClass).removeClass(this.options.errorClass);\n  }\n};\n\nexport default UI;\n","import $ from 'jquery';\nimport Base from './base';\nimport Utils from './utils';\n\nvar Form = function (element, domOptions, options) {\n  this.__class__ = 'Form';\n\n  this.element = element;\n  this.$element = $(element);\n  this.domOptions = domOptions;\n  this.options = options;\n  this.parent = window.Parsley;\n\n  this.fields = [];\n  this.validationResult = null;\n};\n\nvar statusMapping = {pending: null, resolved: true, rejected: false};\n\nForm.prototype = {\n  onSubmitValidate: function (event) {\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)\n      return;\n\n    // If we didn't come here through a submit button, use the first one in the form\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'))\n      return;\n\n    window.Parsley._remoteCache = {};\n\n    var promise = this.whenValidate({event});\n\n    if ('resolved' === promise.state() && false !== this._trigger('submit')) {\n      // All good, let event go through. We make this distinction because browsers\n      // differ in their handling of `submit` being called from inside a submit event [#1047]\n    } else {\n      // Rejected or pending: cancel this submit\n      event.stopImmediatePropagation();\n      event.preventDefault();\n      if ('pending' === promise.state())\n        promise.done(() => { this._submit(submitSource); });\n    }\n  },\n\n  onSubmitButton: function(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 (submitSource) {\n    if (false === this._trigger('submit'))\n      return;\n    // Add submit button's data\n    if (submitSource) {\n      var $synthetic = this.$element.find('.parsley-synthetic-submit-button').prop('disabled', false);\n      if (0 === $synthetic.length)\n        $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(Object.assign($.Event('submit'), {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 (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      var [group, force, event] = arguments;\n      options = {group, force, event};\n    }\n    return statusMapping[ this.whenValidate(options).state() ];\n  },\n\n  whenValidate: function ({group, force, event} = {}) {\n    this.submitEvent = event;\n    if (event) {\n      this.submitEvent = Object.assign({}, event, {preventDefault: () => {\n        Utils.warnOnce(\"Using `this.submitEvent.preventDefault()` is deprecated; instead, call `this.validationResult = false`\");\n        this.validationResult = false;\n      }});\n    }\n    this.validationResult = true;\n\n    // fire validate event to eventually modify things before every validation\n    this._trigger('validate');\n\n    // Refresh form DOM options and form's fields that could have changed\n    this._refreshFields();\n\n    var promises = this._withoutReactualizingFormOptions(() => {\n      return $.map(this.fields, field => field.whenValidate({force, group}));\n    });\n\n    return Utils.all(promises)\n      .done(  () => { this._trigger('success'); })\n      .fail(  () => {\n        this.validationResult = false;\n        this.focus();\n        this._trigger('error');\n      })\n      .always(() => { this._trigger('validated'); })\n      .pipe(...this._pipeAccordingToValidationResult());\n  },\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 (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      var [group, force] = arguments;\n      options = {group, force};\n    }\n    return statusMapping[ this.whenValid(options).state() ];\n  },\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 ({group, force} = {}) {\n    this._refreshFields();\n\n    var promises = this._withoutReactualizingFormOptions(() => {\n      return $.map(this.fields, field => field.whenValid({group, force}));\n    });\n    return Utils.all(promises);\n  },\n\n  refresh: function() {\n    this._refreshFields();\n    return this;\n  },\n\n  // Reset UI\n  reset: function () {\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    this._trigger('reset');\n  },\n\n  // Destroy Parsley instance (+ UI)\n  destroy: function () {\n    // Field case: emit destroy event to clean UI and then destroy stored instance\n    this._destroyUI();\n\n    // Form case: destroy all its fields and then destroy stored instance\n    for (var i = 0; i < this.fields.length; i++)\n      this.fields[i].destroy();\n\n    this.$element.removeData('Parsley');\n    this._trigger('destroy');\n  },\n\n  _refreshFields: function () {\n    return this.actualizeOptions()._bindFields();\n  },\n\n  _bindFields: function () {\n    var oldFields = this.fields;\n\n    this.fields = [];\n    this.fieldsMappedById = {};\n\n    this._withoutReactualizingFormOptions(() => {\n      this.$element\n      .find(this.options.inputs)\n      .not(this.options.excluded)\n      .each((_, element) => {\n        var fieldInstance = new window.Parsley.Factory(element, {}, this);\n\n        // Only add valid and not excluded `Field` and `FieldMultiple` children\n        if (('Field' === fieldInstance.__class__ || 'FieldMultiple' === fieldInstance.__class__) && (true !== fieldInstance.options.excluded)) {\n          let uniqueId = fieldInstance.__class__ + '-' + fieldInstance.__id__;\n          if ('undefined' === typeof this.fieldsMappedById[uniqueId]) {\n            this.fieldsMappedById[uniqueId] = fieldInstance;\n            this.fields.push(fieldInstance);\n          }\n        }\n      });\n\n      $.each(Utils.difference(oldFields, this.fields), (_, field) => {\n        field.reset();\n      });\n    });\n    return this;\n  },\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 (fn) {\n    var oldActualizeOptions = this.actualizeOptions;\n    this.actualizeOptions = function () { return this; };\n    var result = fn();\n    this.actualizeOptions = oldActualizeOptions;\n    return result;\n  },\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 (eventName) {\n    return this.trigger('form:' + eventName);\n  }\n\n};\n\nexport default Form;\n","import Utils from './utils';\nimport Validator from './validator';\n\nconst Constraint = function(parsleyField, name, requirements, priority, isDomConstraint) {\n  const validatorSpec = window.Parsley._validatorRegistry.validators[name];\n  const validator = new Validator(validatorSpec);\n  priority = priority || parsleyField.options[name + 'Priority'] || validator.priority;\n  isDomConstraint = (true === isDomConstraint);\n\n  Object.assign(this, {\n    validator,\n    name,\n    requirements,\n    priority,\n    isDomConstraint\n  });\n  this._parseRequirements(parsleyField.options);\n};\n\nconst capitalize = function(str) {\n  const cap = str[0].toUpperCase();\n  return cap + str.slice(1);\n};\n\nConstraint.prototype = {\n  validate: function(value, instance) {\n    return this.validator.validate(value, ...this.requirementList, instance);\n  },\n\n  _parseRequirements: function(options) {\n    this.requirementList = this.validator.parseRequirements(this.requirements,\n      key => options[this.name + capitalize(key)]\n    );\n  }\n};\n\nexport default Constraint;\n","import $ from 'jquery';\nimport Constraint from './constraint';\nimport UI from './ui';\nimport Utils from './utils';\n\nvar Field = function (field, domOptions, options, parsleyFormInstance) {\n  this.__class__ = 'Field';\n\n  this.element = field;\n  this.$element = $(field);\n\n  // Set parent if we have one\n  if ('undefined' !== typeof parsleyFormInstance) {\n    this.parent = parsleyFormInstance;\n  }\n\n  this.options = options;\n  this.domOptions = domOptions;\n\n  // Initialize some properties\n  this.constraints = [];\n  this.constraintsByName = {};\n  this.validationResult = true;\n\n  // Bind constraints\n  this._bindConstraints();\n};\n\nvar statusMapping = {pending: null, resolved: true, rejected: false};\n\nField.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 (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 = {options};\n    }\n    var promise = this.whenValidate(options);\n    if (!promise)  // If excluded with `group` option\n      return true;\n    switch (promise.state()) {\n      case 'pending': return null;\n      case 'resolved': return true;\n      case 'rejected': return this.validationResult;\n    }\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 ({force, group} =  {}) {\n    // do not validate a field if not the same as given validation group\n    this.refresh();\n    if (group && !this._isInGroup(group))\n      return;\n\n    this.value = this.getValue();\n\n    // Field Validate event. `this.value` could be altered for custom needs\n    this._trigger('validate');\n\n    return this.whenValid({force, value: this.value, _refreshed: true})\n      .always(() => { this._reflowUI(); })\n      .done(() =>   { this._trigger('success'); })\n      .fail(() =>   { this._trigger('error'); })\n      .always(() => { this._trigger('validated'); })\n      .pipe(...this._pipeAccordingToValidationResult());\n  },\n\n  hasConstraints: function () {\n    return 0 !== this.constraints.length;\n  },\n\n  // An empty optional field does not need validation\n  needsValidation: function (value) {\n    if ('undefined' === typeof value)\n      value = this.getValue();\n\n    // 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    if (!value.length && !this._isRequired() && 'undefined' === typeof this.options.validateIfEmpty)\n      return false;\n\n    return true;\n  },\n\n  _isInGroup: function (group) {\n    if (Array.isArray(this.options.group))\n      return -1 !== $.inArray(group, this.options.group);\n    return this.options.group === group;\n  },\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 (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      var [force, value] = arguments;\n      options = {force, value};\n    }\n    var promise = this.whenValid(options);\n    if (!promise) // Excluded via `group`\n      return true;\n    return statusMapping[promise.state()];\n  },\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 ({force = false, value, group, _refreshed} = {}) {\n    // Recompute options and rebind constraints to have latest changes\n    if (!_refreshed)\n      this.refresh();\n    // do not validate a field if not the same as given validation group\n    if (group && !this._isInGroup(group))\n      return;\n\n    this.validationResult = true;\n\n    // A field without constraint is valid\n    if (!this.hasConstraints())\n      return $.when();\n\n    // Value could be passed as argument, needed to add more power to 'field:validate'\n    if ('undefined' === typeof value || null === value)\n      value = this.getValue();\n\n    if (!this.needsValidation(value) && true !== force)\n      return $.when();\n\n    var groupedConstraints = this._getGroupedConstraints();\n    var promises = [];\n    $.each(groupedConstraints, (_, 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(\n        $.map(constraints, constraint => this._validateConstraint(value, constraint))\n      );\n      promises.push(promise);\n      if (promise.state() === 'rejected')\n        return false; // Interrupt processing if a group has already failed\n    });\n    return Utils.all(promises);\n  },\n\n  // @returns a promise\n  _validateConstraint: function(value, constraint) {\n    var result = constraint.validate(value, this);\n    // Map false to a failed promise\n    if (false === result)\n      result = $.Deferred().reject();\n    // Make sure we return a promise and that we record failures\n    return Utils.all([result]).fail(errorMessage => {\n      if (!(this.validationResult instanceof Array))\n        this.validationResult = [];\n      this.validationResult.push({\n        assert: constraint,\n        errorMessage: 'string' === typeof errorMessage && errorMessage\n      });\n    });\n  },\n\n  // @returns Parsley field computed value that could be overrided or configured in DOM\n  getValue: function () {\n    var value;\n\n    // Value could be overriden in DOM or with explicit options\n    if ('function' === typeof this.options.value)\n      value = this.options.value(this);\n    else if ('undefined' !== typeof this.options.value)\n      value = this.options.value;\n    else\n      value = this.$element.val();\n\n    // Handle wrong DOM or configurations\n    if ('undefined' === typeof value || null === value)\n      return '';\n\n    return this._handleWhitespace(value);\n  },\n\n  // Reset UI\n  reset: function () {\n    this._resetUI();\n    return this._trigger('reset');\n  },\n\n  // Destroy Parsley instance (+ UI)\n  destroy: function () {\n    // Field case: emit destroy event to clean UI and then destroy stored instance\n    this._destroyUI();\n    this.$element.removeData('Parsley');\n    this.$element.removeData('FieldMultiple');\n    this._trigger('destroy');\n  },\n\n  // Actualize options and rebind constraints\n  refresh: function () {\n    this._refreshConstraints();\n    return this;\n  },\n\n  _refreshConstraints: function () {\n    return this.actualizeOptions()._bindConstraints();\n  },\n\n  refreshConstraints: function() {\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 (name, requirements, priority, isDomConstraint) {\n\n    if (window.Parsley._validatorRegistry.validators[name]) {\n      var constraint = new Constraint(this, name, requirements, priority, isDomConstraint);\n\n      // if constraint already exist, delete it and push new version\n      if ('undefined' !== this.constraintsByName[constraint.name])\n        this.removeConstraint(constraint.name);\n\n      this.constraints.push(constraint);\n      this.constraintsByName[constraint.name] = constraint;\n    }\n\n    return this;\n  },\n\n  // Remove a constraint\n  removeConstraint: function (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    delete this.constraintsByName[name];\n    return this;\n  },\n\n  // Update a constraint (Remove + re-add)\n  updateConstraint: function (name, parameters, priority) {\n    return this.removeConstraint(name)\n      .addConstraint(name, parameters, priority);\n  },\n\n  // # Internals\n\n  // Internal only.\n  // Bind constraints from config + options + DOM\n  _bindConstraints: function () {\n    var constraints = [];\n    var constraintsByName = {};\n\n    // clean all existing DOM constraints to only keep javascript user constraints\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    this.constraints = constraints;\n    this.constraintsByName = constraintsByName;\n\n    // then re-add Parsley DOM-API constraints\n    for (var name in this.options)\n      this.addConstraint(name, this.options[name], undefined, true);\n\n    // finally, bind special HTML5 constraints\n    return this._bindHtml5Constraints();\n  },\n\n  // Internal only.\n  // Bind specific HTML5 constraints to be HTML5 compliant\n  _bindHtml5Constraints: function () {\n    // html5 required\n    if (null !== this.element.getAttribute('required'))\n      this.addConstraint('required', true, undefined, true);\n\n    // html5 pattern\n    if (null !== this.element.getAttribute('pattern'))\n      this.addConstraint('pattern', this.element.getAttribute('pattern'), undefined, true);\n\n    // range\n    let min = this.element.getAttribute('min');\n    let max = this.element.getAttribute('max');\n    if (null !== min && null !== max)\n      this.addConstraint('range', [min, max], undefined, true);\n\n    // HTML5 min\n    else if (null !== min)\n      this.addConstraint('min', min, undefined, true);\n\n    // HTML5 max\n    else if (null !== max)\n      this.addConstraint('max', max, undefined, true);\n\n\n    // length\n    if (null !== this.element.getAttribute('minlength') && null !== this.element.getAttribute('maxlength'))\n      this.addConstraint('length', [this.element.getAttribute('minlength'), this.element.getAttribute('maxlength')], undefined, true);\n\n    // HTML5 minlength\n    else if (null !== this.element.getAttribute('minlength'))\n      this.addConstraint('minlength', this.element.getAttribute('minlength'), undefined, true);\n\n    // HTML5 maxlength\n    else if (null !== this.element.getAttribute('maxlength'))\n      this.addConstraint('maxlength', this.element.getAttribute('maxlength'), undefined, true);\n\n\n    // html5 types\n    var type = Utils.getType(this.element);\n\n    // Small special case here for HTML5 number: integer validator if step attribute is undefined or an integer value, number otherwise\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);\n    // 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    return this;\n  },\n\n  // Internal only.\n  // Field is required if have required constraint without `false` value\n  _isRequired: function () {\n    if ('undefined' === typeof this.constraintsByName.required)\n      return false;\n\n    return false !== this.constraintsByName.required.requirements;\n  },\n\n  // Internal only.\n  // Shortcut to trigger an event\n  _trigger: function (eventName) {\n    return this.trigger('field:' + eventName);\n  },\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 (value) {\n    if (true === this.options.trimValue)\n      Utils.warnOnce('data-parsley-trim-value=\"true\" is deprecated, please use data-parsley-whitespace=\"trim\"');\n\n    if ('squish' === this.options.whitespace)\n      value = value.replace(/\\s{2,}/g, ' ');\n\n    if (('trim' === this.options.whitespace) || ('squish' === this.options.whitespace) || (true === this.options.trimValue))\n      value = Utils.trimString(value);\n\n    return value;\n  },\n\n  _isDateInput: function() {\n    var c = this.constraintsByName.type;\n    return c && c.requirements === 'date';\n  },\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 () {\n    if (false === this.options.priorityEnabled)\n      return [this.constraints];\n\n    var groupedConstraints = [];\n    var index = {};\n\n    // Create array unique of priorities\n    for (var i = 0; i < this.constraints.length; i++) {\n      var p = this.constraints[i].priority;\n      if (!index[p])\n        groupedConstraints.push(index[p] = []);\n      index[p].push(this.constraints[i]);\n    }\n    // Sort them by priority DESC\n    groupedConstraints.sort(function (a, b) { return b[0].priority - a[0].priority; });\n\n    return groupedConstraints;\n  }\n\n};\n\nexport default Field;\n","import $ from 'jquery';\nimport Utils from './utils';\n\nvar Multiple = function () {\n  this.__class__ = 'FieldMultiple';\n};\n\nMultiple.prototype = {\n  // Add new `$element` sibling for multiple field\n  addElement: function ($element) {\n    this.$elements.push($element);\n\n    return this;\n  },\n\n  // See `Field._refreshConstraints()`\n  _refreshConstraints: function () {\n    var fieldConstraints;\n\n    this.constraints = [];\n\n    // Select multiple special treatment\n    if (this.element.nodeName === 'SELECT') {\n      this.actualizeOptions()._bindConstraints();\n\n      return this;\n    }\n\n    // Gather all constraints for each input in the multiple group\n    for (var i = 0; i < this.$elements.length; i++) {\n\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    return this;\n  },\n\n  // See `Field.getValue()`\n  getValue: function () {\n    // Value could be overriden in DOM\n    if ('function' === typeof this.options.value)\n      return this.options.value(this);\n    else if ('undefined' !== typeof this.options.value)\n      return this.options.value;\n\n    // Radio input case\n    if (this.element.nodeName === 'INPUT') {\n      var type = Utils.getType(this.element);\n      if (type === 'radio')\n        return this._findRelated().filter(':checked').val() || '';\n\n      // checkbox input case\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    }\n\n    // Select multiple case\n    if (this.element.nodeName === 'SELECT' && null === this.$element.val())\n      return [];\n\n    // Default case that should never happen\n    return this.$element.val();\n  },\n\n  _init: function () {\n    this.$elements = [this.$element];\n\n    return this;\n  }\n};\n\nexport default Multiple;\n","import $ from 'jquery';\nimport Utils from './utils';\nimport Base from './base';\nimport Form from './form';\nimport Field from './field';\nimport Multiple from './multiple';\n\nvar Factory = function (element, options, parsleyFormInstance) {\n  this.element = element;\n  this.$element = $(element);\n\n  // If the element has already been bound, returns its saved Parsley instance\n  var savedparsleyFormInstance = this.$element.data('Parsley');\n  if (savedparsleyFormInstance) {\n\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      savedparsleyFormInstance._resetOptions(savedparsleyFormInstance.options);\n    }\n\n    if ('object' === typeof options) {\n      Object.assign(savedparsleyFormInstance.options, options);\n    }\n\n    return savedparsleyFormInstance;\n  }\n\n  // Parsley must be instantiated with a DOM element or jQuery $element\n  if (!this.$element.length)\n    throw new Error('You must bind Parsley on an existing element.');\n\n  if ('undefined' !== typeof parsleyFormInstance && 'Form' !== parsleyFormInstance.__class__)\n    throw new Error('Parent instance must be a Form instance');\n\n  this.parent = parsleyFormInstance || window.Parsley;\n  return this.init(options);\n};\n\nFactory.prototype = {\n  init: function (options) {\n    this.__class__ = 'Parsley';\n    this.__version__ = '@@version';\n    this.__id__ = Utils.generateID();\n\n    // Pre-compute options\n    this._resetOptions(options);\n\n    // 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    if (this.element.nodeName === 'FORM' || (Utils.checkAttr(this.element, this.options.namespace, 'validate') && !this.$element.is(this.options.inputs)))\n      return this.bind('parsleyForm');\n\n    // Every other element is bound as a `Field` or `FieldMultiple`\n    return this.isMultiple() ? this.handleMultiple() : this.bind('parsleyField');\n  },\n\n  isMultiple: function () {\n    var type = Utils.getType(this.element);\n    return ((type === 'radio' || type === 'checkbox') ||\n      (this.element.nodeName === 'SELECT' && null !== this.element.getAttribute('multiple')));\n  },\n\n  // Multiples fields are a real nightmare :(\n  // Maybe some refactoring would be appreciated here...\n  handleMultiple: function () {\n    var name;\n    var multiple;\n    var parsleyMultipleInstance;\n\n    // Handle multiple name\n    this.options.multiple = this.options.multiple ||\n      (name = this.element.getAttribute('name')) ||\n      this.element.getAttribute('id');\n\n    // Special select multiple input\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');\n\n    // 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    }\n\n    // Remove special chars\n    this.options.multiple = this.options.multiple.replace(/(:|\\.|\\[|\\]|\\{|\\}|\\$)/g, '');\n\n    // Add proper `data-parsley-multiple` to siblings if we have a valid multiple name\n    if (name) {\n      $('input[name=\"' + name + '\"]').each((i, input) => {\n        var type = Utils.getType(input);\n        if ((type === 'radio' || type === 'checkbox'))\n          input.setAttribute(this.options.namespace + 'multiple', this.options.multiple);\n      });\n    }\n\n    // Check here if we don't already have a related multiple instance saved\n    var $previouslyRelated = this._findRelated();\n    for (var i = 0; i < $previouslyRelated.length; i++) {\n      parsleyMultipleInstance = $($previouslyRelated.get(i)).data('Parsley');\n      if ('undefined' !== typeof parsleyMultipleInstance) {\n\n        if (!this.$element.data('FieldMultiple')) {\n          parsleyMultipleInstance.addElement(this.$element);\n        }\n\n        break;\n      }\n    }\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    this.bind('parsleyField', true);\n\n    return parsleyMultipleInstance || this.bind('parsleyFieldMultiple');\n  },\n\n  // Return proper `Form`, `Field` or `FieldMultiple`\n  bind: function (type, doNotStore) {\n    var parsleyInstance;\n\n    switch (type) {\n      case 'parsleyForm':\n        parsleyInstance = $.extend(\n          new Form(this.element, this.domOptions, this.options),\n          new Base(),\n          window.ParsleyExtend\n        )._bindFields();\n        break;\n      case 'parsleyField':\n        parsleyInstance = $.extend(\n          new Field(this.element, this.domOptions, this.options, this.parent),\n          new Base(),\n          window.ParsleyExtend\n        );\n        break;\n      case 'parsleyFieldMultiple':\n        parsleyInstance = $.extend(\n          new Field(this.element, this.domOptions, this.options, this.parent),\n          new Multiple(),\n          new Base(),\n          window.ParsleyExtend\n        )._init();\n        break;\n      default:\n        throw new Error(type + 'is not a supported Parsley type');\n    }\n\n    if (this.options.multiple)\n      Utils.setAttr(this.element, this.options.namespace, 'multiple', this.options.multiple);\n\n    if ('undefined' !== typeof doNotStore) {\n      this.$element.data('FieldMultiple', parsleyInstance);\n\n      return parsleyInstance;\n    }\n\n    // Store the freshly bound instance in a DOM element for later access using jQuery `data()`\n    this.$element.data('Parsley', parsleyInstance);\n\n    // Tell the world we have a new Form or Field instance!\n    parsleyInstance._actualizeTriggers();\n    parsleyInstance._trigger('init');\n\n    return parsleyInstance;\n  }\n};\n\nexport default Factory;\n","import $ from 'jquery';\nimport Utils from './utils';\nimport Defaults from './defaults';\nimport Base from './base';\nimport ValidatorRegistry from './validator_registry';\nimport UI from './ui';\nimport Form from './form';\nimport Field from './field';\nimport Multiple from './multiple';\nimport Factory from './factory';\n\nvar vernums = $.fn.jquery.split('.');\nif (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}\nif (!vernums.forEach) {\n  Utils.warn('Parsley requires ES5 to run properly. Please include https://github.com/es-shims/es5-shim');\n}\n// Inherit `on`, `off` & `trigger` to Parsley:\nvar Parsley = Object.assign(new Base(), {\n    element: document,\n    $element: $(document),\n    actualizeOptions: null,\n    _resetOptions: null,\n    Factory: Factory,\n    version: '@@version'\n  });\n\n// Supplement Field and Form with Base\n// This way, the constructors will have access to those methods\nObject.assign(Field.prototype, UI.Field, Base.prototype);\nObject.assign(Form.prototype, UI.Form, Base.prototype);\n// Inherit actualizeOptions and _resetOptions:\nObject.assign(Factory.prototype, Base.prototype);\n\n// ### jQuery API\n// `$('.elem').parsley(options)` or `$('.elem').psly(options)`\n$.fn.parsley = $.fn.psly = function (options) {\n  if (this.length > 1) {\n    var instances = [];\n\n    this.each(function () {\n      instances.push($(this).parsley(options));\n    });\n\n    return instances;\n  }\n\n  // Return undefined if applied to non existing DOM element\n  if (this.length == 0) {\n    return;\n  }\n\n  return new Factory(this[0], options);\n};\n\n// ### Field and Form extension\n// Ensure the extension is now defined if it wasn't previously\nif ('undefined' === typeof window.ParsleyExtend)\n  window.ParsleyExtend = {};\n\n// ### Parsley config\n// Inherit from ParsleyDefault, and copy over any existing values\nParsley.options = Object.assign(Utils.objectCreate(Defaults), window.ParsleyConfig);\nwindow.ParsleyConfig = Parsley.options; // Old way of accessing global options\n\n// ### Globals\nwindow.Parsley = window.psly = Parsley;\nParsley.Utils = Utils;\nwindow.ParsleyUtils = {};\n$.each(Utils, (key, value) => {\n  if ('function' === typeof value) {\n    window.ParsleyUtils[key] = (...args) => {\n      Utils.warnOnce('Accessing `window.ParsleyUtils` is deprecated. Use `window.Parsley.Utils` instead.');\n      return Utils[key](...args);\n    };\n  }\n});\n\n// ### Define methods that forward to the registry, and deprecate all access except through window.Parsley\nvar registry = window.Parsley._validatorRegistry = new ValidatorRegistry(window.ParsleyConfig.validators, window.ParsleyConfig.i18n);\nwindow.ParsleyValidator = {};\n$.each('setLocale addCatalog addMessage addMessages getErrorMessage formatMessage addValidator updateValidator removeValidator hasValidator'.split(' '), function (i, method) {\n  window.Parsley[method] = (...args) => registry[method](...args);\n  window.ParsleyValidator[method] = function () {\n    Utils.warnOnce(`Accessing the method '${method}' through Validator is deprecated. Simply call 'window.Parsley.${method}(...)'`);\n    return window.Parsley[method](...arguments);\n  };\n});\n\n// ### UI\n// Deprecated global object\nwindow.Parsley.UI = UI;\nwindow.ParsleyUI = {\n  removeError: function (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, {updateClass});\n  },\n  getErrorsMessages: function (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 '${method}' on the instance directly. Please comment in issue 1073 as to your need to call this method.`);\n    return instance[method](name, {message, assert, updateClass});\n  };\n});\n\n// ### PARSLEY auto-binding\n// Prevent it by setting `ParsleyConfig.autoBind` to `false`\nif (false !== window.ParsleyConfig.autoBind) {\n  $(function () {\n    // Works only on `data-parsley-validate`.\n    if ($('[data-parsley-validate]').length)\n      $('[data-parsley-validate]').parsley();\n  });\n}\n\nexport default Parsley;\n","import $ from 'jquery';\nimport Utils from './utils';\nimport Base from './base';\n\nimport Parsley from './main';\n\n$.extend(true, Parsley, {\n  asyncValidators: {\n    'default': {\n      fn: function (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 (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\n  addAsyncValidator: function (name, fn, url, options) {\n    Parsley.asyncValidators[name] = {\n      fn: fn,\n      url: url || false,\n      options: options || {}\n    };\n\n    return this;\n  }\n\n});\n\nParsley.addValidator('remote', {\n  requirementType: {\n    '': 'string',\n    'validator': 'string',\n    'reverse': 'boolean',\n    'options': 'object'\n  },\n\n  validateString: function (value, url, options, instance) {\n    var data = {};\n    var ajaxOptions;\n    var csr;\n    var validator = options.validator || (true === options.reverse ? 'reverse' : 'default');\n\n    if ('undefined' === typeof Parsley.asyncValidators[validator])\n      throw new Error('Calling an undefined async validator: `' + validator + '`');\n\n    url = Parsley.asyncValidators[validator].url || url;\n\n    // Fill current value\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    }\n\n    // Merge options passed in from the function with the ones in the attribute\n    var remoteOptions = $.extend(true, options.options || {} , Parsley.asyncValidators[validator].options);\n\n    // All `$.ajax(options)` could be overridden or extended directly from DOM in `data-parsley-remote-options`\n    ajaxOptions = $.extend(true, {}, {\n      url: url,\n      data: data,\n      type: 'GET'\n    }, remoteOptions);\n\n    // Generate store key based on ajax options\n    instance.trigger('field:ajaxoptions', instance, ajaxOptions);\n\n    csr = $.param(ajaxOptions);\n\n    // Initialise querry cache\n    if ('undefined' === typeof Parsley._remoteCache)\n      Parsley._remoteCache = {};\n\n    // Try to retrieve stored xhr\n    var xhr = Parsley._remoteCache[csr] = Parsley._remoteCache[csr] || $.ajax(ajaxOptions);\n\n    var handleXhr = function () {\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\n  priority: -1\n});\n\nParsley.on('form:submit', function () {\n  Parsley._remoteCache = {};\n});\n\nBase.prototype.addAsyncValidator = function () {\n  Utils.warnOnce('Accessing the method `addAsyncValidator` through an instance is deprecated. Simply call `Parsley.addAsyncValidator(...)`');\n  return Parsley.addAsyncValidator(...arguments);\n};\n","// This is included with the Parsley library itself,\n// thus there is no use in adding it to your project.\nimport Parsley from '../parsley/main';\n\nParsley.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});\n\nParsley.setLocale('en');\n","import $ from 'jquery';\nimport Parsley from './parsley/main';\nimport './parsley/pubsub';\nimport './parsley/remote';\nimport './i18n/en';\nimport inputevent from './vendor/inputevent';\n\ninputevent.install();\n\nexport default Parsley;\n"]}