parsley-rails 1.2.4.0 → 2.0.0.0

data/vendor/assets/javascripts/parsley.i18n.pl.js

@@ -1,40 +1,33 @@
-window.ParsleyConfig = window.ParsleyConfig || {};
-
-(function ($) {
-  window.ParsleyConfig = $.extend( true, {}, window.ParsleyConfig, {
-    messages: {
-      // parsley ////////PL/by/Tymek.Cz////////////////
-        defaultMessage: "Wartość nieprawidłowa"
-      , type: {
-            email:      "Niepoprawny adres e-mail"
-          , url:        "Niepoprawny adres URL"
-          , urlstrict:  "Niepoprawny format adresu adres URL"
-          , number:     "Wpisz poprawną liczbę"
-          , digits:     "Dozwolone tylko cyfry"
-          , dateIso:    "Niepoprawny format  (użyj RRRR-MM-DD)"
-          , alphanum:   "Dozwolone tylko znaki alfanumeryczne"
-        }
-      , notnull:        "Wartość nie może być równa zero"
-      , notblank:       "Pole nie może pozostać puste"
-      , required:       "Pole wymagane"
-      , regexp:         "Niepoprawna wartość"
-      , min:            "Wpisz wartość większą od %s"
-      , max:            "Wpisz wartość mniejszą od %s"
-      , range:          "Wpisz wartość pomiędzy %s i %s"
-      , minlength:      "Wpisz %s lub więcej znaków"
-      , maxlength:      "Wpisz %s lub mniej znaków"
-      , rangelength:    "Wpisz od %s do %s znaków"
-      , mincheck:       "Wybierz %s lub więcej opcji"
-      , maxcheck:       "Wybierz %s lub mniej opcji"
-      , rangecheck:     "Wybierz od %s do %s opcji"
-      , equalto:        "Wartość nie jest identyczna"
-
-      // parsley.extend /PL/by/Tymek.Cz////////////////
-      , minwords:       "Wpisz więcej niż %s wyrazów"
-      , maxwords:       "Wpisz co najwyżej %s wyrazów"
-      , rangewords:     "Wpisz od %s do %s wyrazów"
-      , greaterthan:    "Podaj wartość większą od %s"
-      , lessthan:       "Podaj wartość mniejszą od %s"
-    }
-  });
-}(window.jQuery || window.Zepto));
+// ParsleyConfig definition if not already set
+window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
+
+// Define then the messages
+window.ParsleyConfig.i18n.pl = $.extend(window.ParsleyConfig.i18n.pl || {}, {
+  defaultMessage: "Wartość wygląda na nieprawidłową",
+  type: {
+    email:        "Wpisz poprawny adres e-mail.",
+    url:          "Wpisz poprawny adres URL.",
+    number:       "Wpisz poprawną liczbę.",
+    integer:      "Dozwolone jedynie liczby człkowite.",
+    digits:       "Dozwolone jedynie cyfry.",
+    alphanum:     "Dozwolone jedynie znaki alfanumeryczne."
+  },
+  notblank:       "Pole nie może zostać puste",
+  required:       "Pole jest wymagane.",
+  pattern:        "Wartość wygląda na nieprawidłową.",
+  min:            "Wartość powinna być większa od %s.",
+  max:            "Wartość powinna być mniejsza od %s.",
+  range:          "Wartość powinna być większa od %s i mniejsza od %s.",
+  minlength:      "Ilość znaków powinna wynosić %s lub więcej.",
+  maxlength:      "Ilość znaków powinna wynosić %s lub mniej.",
+  length:         "Ilość znaków powinna wynosić od %s do %s.",
+  mincheck:       "Musisz wybrać minimum %s opcji.",
+  maxcheck:       "Możesz wybrać maksymalnie %s opcji.",
+  check:          "Minimalnie możesz wybrać od %s do %s opcji",
+  equalto:        "Wartości nie są identyczne"
+});
+
+// If file is loaded after Parsley main file, auto-load locale
+if ('undefined' !== typeof window.ParsleyValidator)
+  window.ParsleyValidator.addCatalog('pl', window.ParsleyConfig.i18n.pl, true);

data/vendor/assets/javascripts/parsley.i18n.pt-br.js

@@ -0,0 +1,33 @@
+// ParsleyConfig definition if not already set
+window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
+
+// Define then the messages
+window.ParsleyConfig.i18n['pt-br'] = $.extend(window.ParsleyConfig.i18n['pt-br'] || {}, {
+  defaultMessage: "This value seems to be invalid.",
+  type: {
+    email:        "Esse campo deve ser um email válido.",
+    url:          "Esse campo deve ser uma url válida.",
+    number:       "Esse campo deve ser um número válido.",
+    integer:      "Esse campo deve ser um inteiro válido.",
+    digits:       "Esse campo deve conter apenas dígitos.",
+    alphanum:     "Esse campo deve ser alfa numérico."
+  },
+  notblank:       "Esse campo não pode ficar vazio.",
+  required:       "Esse campo é obrigatório.",
+  pattern:        "Esse campo parece estar inválido.",
+  min:            "Esse campo deve ser maior ou igual a %s.",
+  max:            "Esse campo deve ser menor ou igual a %s.",
+  range:          "Esse campo deve estar entre %s e %s.",
+  minlength:      "Esse campo é pequeno demais. Ele deveria ter %s characteres ou mais.",
+  maxlength:      "Esse campo grande demais. Ele deveri ter %s characteres ou menos.",
+  length:         "O tamanho desse campo é inválido. Ele deveria ter entre %s e %s characteres.",
+  mincheck:       "Você deve escolher pelo menos %s opções.",
+  maxcheck:       "Você deve escolher %s opções ou mais",
+  check:          "Você deve escolher entre %s e %s opções.",
+  equalto:        "Este valor deveria ser igual."
+});
+
+// If file is loaded after Parsley main file, auto-load locale
+if ('undefined' !== typeof window.ParsleyValidator)
+  window.ParsleyValidator.addCatalog('pt-br', window.ParsleyConfig.i18n['pt-br'], true);

data/vendor/assets/javascripts/parsley.i18n.ru.js

@@ -1,44 +1,38 @@
-window.ParsleyConfig = window.ParsleyConfig || {};
-
-(function ($) {
-  window.ParsleyConfig = $.extend( true, {}, window.ParsleyConfig, {
-    messages: {
-      // parsley //////////////////////////////////////
-        defaultMessage: "Поле заполнено некорректно."
-        , type: {
-            email:      "Поле должно быть адресом электронной почты."
-          , url:        "Поле должно быть ссылкой на сайт."
-          , urlstrict:  "Поле должно быть ссылкой на сайт."
-          , number:     "Поле должно быть числом."
-          , digits:     "Поле должно содержать только цифры."
-          , dateIso:    "Поле должно быть датой в формате (ГГГГ-ММ-ДД)."
-          , alphanum:   "Поле должно содержать только цифры и буквы."
-          , phone:      "Поле должно содержать корректный номер телефона."
-        }
-      , notnull:        "Поле должно быть не нулевым."
-      , notblank:       "Поле не должно быть пустым."
-      , required:       "Поле обязательно для заполнения."
-      , regexp:         "Поле заполнено некорректно."
-      , min:            "Значение поля должно быть больше %s."
-      , max:            "Значение поля должно быть меньше %s."
-      , range:          "Значение поля должно быть между %s и %s."
-      , minlength:      "В поле должно быть минимум %s символов(а)."
-      , maxlength:      "В поле должно быть не больше %s символов(а)."
-      , rangelength:    "В поле должно быть от %s до %s символов(а)."
-      , mincheck:       "Необходимо выбрать не менее %s пунктов(а)."
-      , maxcheck:       "Необходимо выбрать не более %s пунктов(а)."
-      , rangecheck:     "Необходимо выбрать от %s до %s пунктов."
-      , equalto:        "Значения полей должны быть одинаковыми."
-
-      // parsley.extend ///////////////////////////////
-      , minwords:       "В поле должно быть не менее %s слов."
-      , maxwords:       "В поле должно быть не более %s слов."
-      , rangewords:     "Количество слов в поле должно быть в диапазоне от %s до %s."
-      , greaterthan:    "Значение в поле должно быть более %s."
-      , lessthan:       "Значение в поле должно быть менее %s."
-      , beforedate:     "Дата должна быть до %s."
-      , afterdate:      "Дата должна быть после %s."
-      , americandate:   "В поле должна быть корректная дата в формате MM/DD/YYYY."
-    }
-  });
-}(window.jQuery || window.Zepto));
+//Parsley localization for Russian language
+//Evgeni Makarov
+//github.com/emakarov
+
+
+// ParsleyConfig definition if not already set
+window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
+
+// Define then the messages
+window.ParsleyConfig.i18n.ru = $.extend(window.ParsleyConfig.i18n.ru || {}, {
+  defaultMessage: "Некорректное значение.",
+  type: {
+    email:        "Введите адрес электронной почты.",
+    url:          "Введите URL адрес.",
+    number:       "Введите число.",
+    integer:      "Введите целое число.",
+    digits:       "Введите только цифры.",
+    alphanum:     "Введите буквенно-цифровое значение."
+  },
+  notblank:       "Это поле должно быть заполнено.",
+  required:       "Обязательное поле.",
+  pattern:        "Это значение некорректно.",
+  min:            "Это значение должно быть не менее чем %s.",
+  max:            "Это значение должно быть не более чем %s.",
+  range:          "Это значение должно быть в интервале от %s до %s.",
+  minlength:      "Введите не менее %s символов.",
+  maxlength:      "Введите не более %s символов.",
+  length:         "Длина строки должна быть от %s до %s символов.",
+  mincheck:       "Выберите не менее %s значений.",
+  maxcheck:       "Выберите не более %s значений.",
+  check:          "Выберите от %s до %s значений.",
+  equalto:        "Это значение должно совпадать."
+});
+
+// If file is loaded after Parsley main file, auto-load locale
+if ('undefined' !== typeof window.ParsleyValidator)
+  window.ParsleyValidator.addCatalog('ru', window.ParsleyConfig.i18n.ru, true);

data/vendor/assets/javascripts/parsley.i18n.sv.extra.js

@@ -0,0 +1,6 @@
+window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
+
+window.ParsleyConfig.i18n.sv = $.extend(window.ParsleyConfig.i18n.sv || {}, {
+  dateiso: "Ange ett giltigt datum (ÅÅÅÅ-MM-DD)."
+});

data/vendor/assets/javascripts/parsley.i18n.sv.js

@@ -1,45 +1,33 @@
-/**
-* Swedish i18n.
-*/
+// ParsleyConfig definition if not already set
 window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
 
-(function ($) {
-  window.ParsleyConfig = $.extend( true, {}, window.ParsleyConfig, {
-    messages: {
-      // parsley //////////////////////////////////////
-        defaultMessage: "Ogiltigt värde."
-        , type: {
-            email:      "Värdet måste vara en giltig e-postadress."
-          , url:        "Värdet måste vara en giltig URL."
-          , urlstrict:  "Värdet måste vara en giltig URL."
-          , number:     "Värdet måste vara ett giltigt nummer."
-          , digits:     "Värdet får enbart innehålla siffror."
-          , dateIso:    "Värdet måste vara ett giltigt datum (YYYY-MM-DD)."
-          , alphanum:   "Värdet får bara innehålla bokstäver och siffror."
-        }
-      , notnull:        "Värdet får inte vara null."
-      , notblank:       "Fältet får inte vara tomt."
-      , required:       "Måste fyllas i."
-      , regexp:         "Värdet verkar inte vara giltigt."
-      , min:            "Värdet måste vara större än %s."
-      , max:            "Värdet måste vara mindre än %s."
-      , range:          "Värdet måste vara mellan %s och %s."
-      , minlength:      "Värdet är för kort. Det måste innehålla minst %s tecken."
-      , maxlength:      "Värdet är för långt. Det får maximalt innehålla %s tecken."
-      , rangelength:    "Värdets längd är felaktig. Det måste innehålla mellan %s och %s tecken."
-      , mincheck:       "Minst %s värden måste väljas."
-      , maxcheck:       "Maximalt %s värden får väljas."
-      , rangecheck:     "Du måste göra minst %s och maximalt %s val."
-      , equalto:        "Värdet måste vara lika."
+// Define then the messages
+window.ParsleyConfig.i18n.sv = $.extend(window.ParsleyConfig.i18n.sv || {}, {
+  defaultMessage: "Ogiltigt värde.",
+  type: {
+    email:        "Ange en giltig e-postadress.",
+    url:          "Ange en giltig URL.",
+    number:       "Ange ett giltigt nummer.",
+    integer:      "Ange ett heltal.",
+    digits:       "Ange endast siffror.",
+    alphanum:     "Ange endast bokstäver och siffror."
+  },
+  notblank:       "Värdet får inte vara tomt.",
+  required:       "Måste fyllas i.",
+  pattern:        "Värdet är ej giltigt.",
+  min:            "Värdet måste vara större än eller lika med %s.",
+  max:            "Värdet måste vara mindre än eller lika med %s.",
+  range:          "Värdet måste vara mellan %s och %s.",
+  minlength:      "Värdet måste vara minst %s tecken.",
+  maxlength:      "Värdet får maximalt innehålla %s tecken.",
+  length:         "Värdet måste vara mellan %s och %s tecken.",
+  mincheck:       "Minst %s val måste göras.",
+  maxcheck:       "Maximalt %s val får göras.",
+  check:          "Mellan %s och %s val måste göras.",
+  equalto:        "Värdena måste vara lika."
+});
 
-      // parsley.extend ///////////////////////////////
-      , minwords:       "Fältet måste innehålla minst %s ord."
-      , maxwords:       "Fältet får maximalt innehålla %s ord."
-      , rangewords:     "Fältet ska innehålla mellan %s och %s ord."
-      , greaterthan:    "Värdet måste vara större än %s."
-      , lessthan:       "Värdet måste vara mindre än %s."
-      , beforedate:     "Datumet måste vara före %s."
-      , afterdate:      "Datumet måste vara efter %s."
-    }
-  });
-}(window.jQuery || window.Zepto));
+// If file is loaded after Parsley main file, auto-load locale
+if ('undefined' !== typeof window.ParsleyValidator)
+  window.ParsleyValidator.addCatalog('sv', window.ParsleyConfig.i18n.sv, true);

data/vendor/assets/javascripts/parsley.i18n.zh_cn.extra.js

@@ -0,0 +1,6 @@
+window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
+
+window.ParsleyConfig.i18n.zh_cn = $.extend(window.ParsleyConfig.i18n.zh_cn || {}, {
+  dateiso: "请输入正确格式的日期 (YYYY-MM-DD)."
+});

data/vendor/assets/javascripts/parsley.i18n.zh_cn.js

@@ -1,46 +1,33 @@
-/**
-* /!\ This file is just an example template to create/update your own language file /!\
-*/
-
+// ParsleyConfig definition if not already set
 window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
 
-(function ($) {
-  window.ParsleyConfig = $.extend( true, {}, window.ParsleyConfig, {
-    messages: {
-      // parsley //////////////////////////////////////
-        defaultMessage: "不正确的值"
-        , type: {
-            email:      "字段值应该是一个正确的电子邮件地址"
-          , url:        "字段值应该是一个正确的URL地址"
-          , urlstrict:  "字段值应该是一个正确的URL地址"
-          , number:     "字段值应该是一个合法的数字"
-          , digits:     "字段值应该是一个单独的数字"
-          , dateIso:    "字段值应该是一个正确的日期描述(YYYY-MM-DD)."
-          , alphanum:   "字段值应该是只包含字母和数字"
-        }
-      , notnull:        "字段值不可为null"
-      , notblank:       "字段值不可为空"
-      , required:       "字段值是必填的"
-      , regexp:         "字段值不合法"
-      , min:            "字段值应该大于 %s"
-      , max:            "字段值应该小于 %s."
-      , range:          "字段值应该大于 %s 并小于 %s."
-      , minlength:      "字段值太短了，长度应该大于等于 %s 个字符"
-      , maxlength:      "字段值太长了，长度应该小于等于 %s 个字符"
-      , rangelength:    "字段值长度错了，长度应该在 %s 和 %s 个字符之间"
-      , mincheck:       "你至少要选择 %s 个选项"
-      , maxcheck:       "你最多只能选择 %s 个选项"
-      , rangecheck:     "你只能选择 %s 到 %s 个选项"
-      , equalto:        "字段值应该和给定的值一样"
+// Define then the messages
+window.ParsleyConfig.i18n.zh_cn = $.extend(window.ParsleyConfig.i18n.zh_cn || {}, {
+  defaultMessage: "不正确的值",
+  type: {
+    email:        "请输入一个有效的电子邮箱地址",
+    url:          "请输入一个有效的链接",
+    number:       "请输入正确的数字",
+    integer:      "请输入正确的整数",
+    digits:       "请输入正确的号码",
+    alphanum:     "请输入字母或数字"
+  },
+  notblank:       "请输入值",
+  required:       "必填项",
+  pattern:        "格式不正确",
+  min:            "输入值请大于或等于 %s",
+  max:            "输入值请小于或等于 %s",
+  range:          "输入值应该在 %s 到 %s 之间",
+  minlength:      "请输入至少 %s 个字符",
+  maxlength:      "请输入至多 %s 个字符",
+  length:         "字符长度应该在 %s 到 %s 之间",
+  mincheck:       "请至少选择 %s 个选项",
+  maxcheck:       "请选择不超过 %s 个选项",
+  check:          "请选择 %s 到 %s 个选项",
+  equalto:        "输入值不同"
+});
 
-      // parsley.extend ///////////////////////////////
-      , minwords:       "字段值应该至少有 %s 个词"
-      , maxwords:       "字段值最多只能有 %s 个词"
-      , rangewords:     "字段值应该有 %s 到 %s 个词"
-      , greaterthan:    "字段值应该大于 %s"
-      , lessthan:       "字段值应该小于 %s"
-      , beforedate:     "字段值所表示的日期应该早于 %s."
-      , afterdate:      "字段值所表示的日期应该晚于 %s."
-    }
-  });
-}(window.jQuery || window.Zepto));
+// If file is loaded after Parsley main file, auto-load locale
+if ('undefined' !== typeof window.ParsleyValidator)
+  window.ParsleyValidator.addCatalog('zh_cn', window.ParsleyConfig.i18n.zh_cn, true);

data/vendor/assets/javascripts/parsley.js

@@ -1,1595 +1,2097 @@
-/*
- * Parsley.js allows you to verify your form inputs frontend side, without writing a line of javascript. Or so..
- *
- * Author: Guillaume Potier - @guillaumepotier
+/*!
+* Parsleyjs
+* Guillaume Potier - <guillaume@wisembly.com>
+* Version 2.0.0 - built Sat Apr 19 2014 17:29:18
+* MIT Licensed
+*
 */
-
-!function ($) {
-
-  'use strict';
-
-  /**
-  * Validator class stores all constraints functions and associated messages.
-  * Provides public interface to add, remove or modify them
-  *
-  * @class Validator
-  * @constructor
-  */
-  var Validator = function ( options ) {
-    /**
-    * Error messages
-    *
-    * @property messages
-    * @type {Object}
-    */
-    this.messages = {
-        defaultMessage: "This value seems to be invalid."
-      , type: {
-            email:      "This value should be a valid email."
-          , url:        "This value should be a valid url."
-          , urlstrict:  "This value should be a valid url."
-          , number:     "This value should be a valid number."
-          , digits:     "This value should be digits."
-          , dateIso:    "This value should be a valid date (YYYY-MM-DD)."
-          , alphanum:   "This value should be alphanumeric."
-          , phone:      "This value should be a valid phone number."
+!(function($) {
+  var ParsleyUtils = {
+    // Parsley DOM-API
+    // returns object from dom attributes and values
+    // if attr is given, returns bool if attr present in DOM or not
+    attr: function ($element, namespace, checkAttr) {
+      var
+        attribute,
+        obj = {},
+        regex = new RegExp('^' + namespace, 'i');
+      if ('undefined' === typeof $element || 'undefined' === typeof $element[0])
+        return {};
+      for (var i in $element[0].attributes) {
+        attribute = $element[0].attributes[i];
+        if ('undefined' !== typeof attribute && null !== attribute && attribute.specified && regex.test(attribute.name)) {
+          if ('undefined' !== typeof checkAttr && new RegExp(checkAttr + '$', 'i').test(attribute.name))
+            return true;
+          obj[this.camelize(attribute.name.replace(namespace, ''))] = this.deserializeValue(attribute.value);
         }
-      , notnull:        "This value should not be null."
-      , notblank:       "This value should not be blank."
-      , required:       "This value is required."
-      , regexp:         "This value seems to be invalid."
-      , min:            "This value should be greater than or equal to %s."
-      , max:            "This value should be lower than or equal to %s."
-      , range:          "This value should be between %s and %s."
-      , minlength:      "This value is too short. It should have %s characters or more."
-      , maxlength:      "This value is too long. It should have %s characters or less."
-      , rangelength:    "This value length is invalid. It should be between %s and %s characters long."
-      , mincheck:       "You must select at least %s choices."
-      , maxcheck:       "You must select %s choices or less."
-      , rangecheck:     "You must select between %s and %s choices."
-      , equalto:        "This value should be the same."
+      }
+      return 'undefined' === typeof checkAttr ? obj : false;
     },
-
-    this.init( options );
+    setAttr: function ($element, namespace, attr, value) {
+      $element[0].setAttribute(this.dasherize(namespace + attr), String(value));
+    },
+    // Recursive object / array getter
+    get: function (obj, path) {
+      var
+        i = 0,
+        paths = (path || '').split('.');
+      while (this.isObject(obj) || this.isArray(obj)) {
+        obj = obj[paths[i++]];
+        if (i === paths.length)
+          return obj;
+      }
+      return undefined;
+    },
+    hash: function (length) {
+      return String(Math.random()).substring(2, length ? length + 2 : 9);
+    },
+    /** Third party functions **/
+    // Underscore isArray
+    isArray: function (mixed) {
+      return Object.prototype.toString.call(mixed) === '[object Array]';
+    },
+    // Underscore isObject
+    isObject: function (mixed) {
+      return mixed === Object(mixed);
+    },
+    // Zepto deserialize function
+    deserializeValue: function (value) {
+      var num;
+      try {
+        return value ?
+          value == "true" ||
+          (value == "false" ? false :
+          value == "null" ? null :
+          !isNaN(num = Number(value)) ? num :
+          /^[\[\{]/.test(value) ? $.parseJSON(value) :
+          value)
+          : value;
+      } catch (e) { return value; }
+    },
+    // Zepto camelize function
+    camelize: function (str) {
+      return str.replace(/-+(.)?/g, function(match, chr) {
+        return chr ? chr.toUpperCase() : '';
+      });
+    },
+    // Zepto dasherize function
+    dasherize: function (str) {
+      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();
+    }
+  };
+// All these options could be overriden and specified directly in DOM using
+// `data-parsley-` default DOM-API
+// eg: `inputs` can be set in DOM using `data-parsley-inputs="input, textarea"`
+// eg: `data-parsley-stop-on-first-failing-constraint="false"`
+  var ParsleyDefaults = {
+    // ### General
+    // Default data-namespace for DOM API
+    namespace: 'data-parsley-',
+    // Supported inputs by default
+    inputs: 'input, textarea, select',
+    // Excluded inputs by default
+    excluded: 'input[type=button], input[type=submit], input[type=reset], input[type=hidden]',
+    // Stop validating field on highest priority failing constraint
+    priorityEnabled: true,
+    // ### UI
+    // Enable\Disable error messages
+    uiEnabled: true,
+    // Key events threshold before validation
+    validationThreshold: 3,
+    // Focused field on form validation error. 'fist'|'last'|'none'
+    focus: 'first',
+    // `$.Event()` that will trigger validation. eg: `keyup`, `change`..
+    trigger: false,
+    // Class that would be added on every failing validation Parsley field
+    errorClass: 'parsley-error',
+    // Same for success validation
+    successClass: 'parsley-success',
+    // Return the `$element` that will receive these above success or error classes
+    // Could also be (and given directly from DOM) a valid selector like `'#div'`
+    classHandler: function (ParsleyField) {},
+    // Return the `$element` where errors will be appended
+    // Could also be (and given directly from DOM) a valid selector like `'#div'`
+    errorsContainer: function (ParsleyField) {},
+    // ul elem that would receive errors' list
+    errorsWrapper: '<ul class="parsley-errors-list"></ul>',
+    // li elem that would receive error message
+    errorTemplate: '<li></li>'
   };
 
-  Validator.prototype = {
-
-    constructor: Validator
-
-    /**
-    * Validator list. Built-in validators functions
-    *
-    * @property validators
-    * @type {Object}
-    */
-    , validators: {
-      notnull: function () {
-        return {
-          validate: function ( val ) {
-            return val.length > 0;
-          }
-          , priority: 2
-        }
-      }
-      , notblank: function () {
-        return {
-          validate: function ( val ) {
-            return 'string' === typeof val && '' !== val.replace( /^\s+/g, '' ).replace( /\s+$/g, '' );
-          }
-          , priority: 2
-        }
-      }
-      , required: function () {
-        var that = this;
-        return {
-          validate: function ( val ) {
-            // for checkboxes and select multiples. Check there is at least one required value
-            if ( 'object' === typeof val ) {
-              for ( var i in val ) {
-                if ( that.required().validate( val[ i ] ) ) {
-                  return true;
-                }
-              }
-
-              return false;
-            }
-
-            return that.notnull().validate( val ) && that.notblank().validate( val );
-          }
-          , priority: 512
-        }
-      }
-      , type: function () {
-        return {
-          validate: function ( val, type ) {
-            var regExp;
-
-            switch ( type ) {
-              case 'number':
-                regExp = /^-?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/;
-                break;
-              case 'digits':
-                regExp = /^\d+$/;
-                break;
-              case 'alphanum':
-                regExp = /^\w+$/;
-                break;
-              case 'email':
-                regExp = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-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-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))){2,6}$/i;
-                break;
-              case 'url':
-                val = new RegExp( '(https?|s?ftp|git)', 'i' ).test( val ) ? val : 'http://' + val;
-                /* falls through */
-              case 'urlstrict':
-                regExp = /^(https?|s?ftp|git):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i;
-                break;
-              case 'dateIso':
-                regExp = /^(\d{4})\D?(0[1-9]|1[0-2])\D?([12]\d|0[1-9]|3[01])$/;
-                break;
-              case 'phone':
-                regExp = /^((\+\d{1,3}(-| )?\(?\d\)?(-| )?\d{1,5})|(\(?\d{2,6}\)?))(-| )?(\d{3,4})(-| )?(\d{4})(( x| ext)\d{1,5}){0,1}$/;
-                break;
-              default:
-                return false;
-            }
-
-            // test regExp if not null
-            return '' !== val ? regExp.test( val ) : false;
-          }
-          , priority: 256
-        }
-      }
-      , regexp: function () {
-        return {
-          validate: function ( val, regExp, self ) {
-            return new RegExp( regExp, self.options.regexpFlag || '' ).test( val );
-          }
-          , priority: 64
-        }
-      }
-      , minlength: function () {
-        return {
-          validate: function ( val, min ) {
-            return val.length >= min;
-          }
-          , priority: 32
-        }
-      }
-      , maxlength: function () {
-        return {
-          validate: function ( val, max ) {
-            return val.length <= max;
-          }
-          , priority: 32
-        }
-      }
-      , rangelength: function () {
-        var that = this;
-        return {
-          validate: function ( val, arrayRange ) {
-            return that.minlength().validate( val, arrayRange[ 0 ] ) && that.maxlength().validate( val, arrayRange[ 1 ] );
-          }
-          , priority: 32
-        }
-      }
-      , min: function () {
-        return {
-          validate: function ( val, min ) {
-            return Number( val ) >= min;
-          }
-          , priority: 32
-        }
-      }
-      , max: function () {
-        return {
-          validate: function ( val, max ) {
-            return Number( val ) <= max;
-          }
-          , priority: 32
-        }
-      }
-      , range: function () {
-        var that = this;
-        return {
-          validate: function ( val, arrayRange ) {
-            return that.min().validate( val, arrayRange[ 0 ] ) && that.max().validate( val, arrayRange[ 1 ] );
-          }
-          , priority: 32
-        }
-      }
-      , equalto: function () {
-        return {
-          validate: function ( val, elem, self ) {
-            self.options.validateIfUnchanged = true;
-            return val === $( elem ).val();
-          }
-          , priority: 64
-        }
-      }
-      , remote: function () {
-        return {
-          validate: function ( val, url, self ) {
-            var result = null
-              , data = {}
-              , dataType = {};
-
-            data[ self.$element.attr( 'name' ) ] = val;
-
-            if ( 'undefined' !== typeof self.options.remoteDatatype )
-              dataType = { dataType: self.options.remoteDatatype };
-
-            var manage = function ( isConstraintValid, message ) {
-              // remove error message if we got a server message, different from previous message
-              if ( 'undefined' !== typeof message && 'undefined' !== typeof self.Validator.messages.remote && message !== self.Validator.messages.remote ) {
-                $( self.UI.ulError + ' .remote' ).remove();
-              }
-
-              if (false === isConstraintValid) {
-                  self.options.listeners.onFieldError( self.element, self.constraints, self );
-              } else if (true === isConstraintValid && false === self.options.listeners.onFieldSuccess( self.element, self.constraints, self )) {
-                  // if onFieldSuccess returns (bool) false, consider that field is invalid
-                  isConstraintValid = false;
-              }
-
-              self.updtConstraint( { name: 'remote', valid: isConstraintValid }, message );
-              self.manageValidationResult();
-            };
-
-            // transform string response into object
-            var handleResponse = function ( response ) {
-              if ( 'object' === typeof response ) {
-                return response;
-              }
-
-              try {
-                response = $.parseJSON( response );
-              } catch ( err ) {}
-
-              return response;
-            }
-
-            var manageErrorMessage = function ( response ) {
-              return 'object' === typeof response && null !== response ? ( 'undefined' !== typeof response.error ? response.error : ( 'undefined' !== typeof response.message ? response.message : null ) ) : null;
-            }
-
-            $.ajax( $.extend( {}, {
-                url: url
-              , data: data
-              , type: self.options.remoteMethod || 'GET'
-              , success: function ( response ) {
-                response = handleResponse( response );
-                manage( 1 === response || true === response || ( 'object' === typeof response && null !== response && 'undefined' !== typeof response.success ), manageErrorMessage( response )
-                );
-              }
-              , error: function ( response ) {
-                response = handleResponse( response );
-                manage( false, manageErrorMessage( response ) );
-              }
-            }, dataType ) );
-
-            return result;
-          }
-          , priority: 64
-        }
-      }
-
-      /**
-      * Aliases for checkboxes constraints
-      */
-      , mincheck: function () {
-        var that = this;
-        return {
-          validate: function ( obj, val ) { return that.minlength().validate( obj, val ) }
-          , priority: 32
-        }
-      }
-      , maxcheck: function () {
-        var that = this;
-        return {
-          validate: function ( obj, val ) { return that.maxlength().validate( obj, val ) }
-          , priority: 32
-        }
-      }
-      , rangecheck: function () {
-        var that = this;
-        return {
-          validate: function ( obj, arrayRange ) { return that.rangelength().validate( obj, arrayRange ) }
-          , priority: 32
-        }
+  var ParsleyAbstract = function() {};
+  ParsleyAbstract.prototype = {
+    asyncSupport: false,
+    actualizeOptions: function () {
+      this.options = this.OptionsFactory.get(this);
+      return this;
+    },
+    // ParsleyValidator validate proxy function . Could be replaced by third party scripts
+    validateThroughValidator: function (value, constraints, priority) {
+      return window.ParsleyValidator.validate.apply(window.ParsleyValidator, [value, constraints, priority]);
+    },
+    // Subscribe an event and a handler for a specific field or a specific form
+    // If on a ParsleyForm instance, it will be attached to form instance and also
+    // To every field instance for this form
+    subscribe: function (name, fn) {
+      $.listenTo(this, name.toLowerCase(), fn);
+      return this;
+    },
+    // Same as subscribe above. Unsubscribe an event for field, or form + its fields
+    unsubscribe: function (name) {
+      $.unsubscribeTo(this, name.toLowerCase());
+      return this;
+    },
+    // Reset UI
+    reset: function () {
+      // Field case: just emit a reset event for UI
+      if ('ParsleyForm' !== this.__class__)
+        return $.emit('parsley:field:reset', this);
+      // Form case: emit a reset event for each field
+      for (var i = 0; i < this.fields.length; i++)
+        $.emit('parsley:field:reset', this.fields[i]);
+      $.emit('parsley:form:reset', this);
+    },
+    // Destroy Parsley instance (+ UI)
+    destroy: function () {
+      // Field case: emit destroy event to clean UI and then destroy stored instance
+      if ('ParsleyForm' !== this.__class__) {
+        this.$element.removeData('Parsley');
+        this.$element.removeData('ParsleyFieldMultiple');
+        $.emit('parsley:field:destroy', this);
+        return;
       }
+      // Form case: destroy all its fields and then destroy stored instance
+      for (var i = 0; i < this.fields.length; i++)
+        this.fields[i].destroy();
+      this.$element.removeData('Parsley');
+      $.emit('parsley:form:destroy', this);
     }
-
+  };
+/*!
+* validator.js
+* Guillaume Potier - <guillaume@wisembly.com>
+* Version 0.5.8 - built Sun Mar 16 2014 17:18:21
+* MIT Licensed
+*
+*/
+( function ( exports ) {
+  /**
+  * Validator
+  */
+  var Validator = function ( options ) {
+    this.__class__ = 'Validator';
+    this.__version__ = '0.5.8';
+    this.options = options || {};
+    this.bindingKey = this.options.bindingKey || '_validatorjsConstraint';
+    return this;
+  };
+  Validator.prototype = {
+    constructor: Validator,
     /*
-    * Register custom validators and messages
+    * Validate string: validate( string, Assert, string ) || validate( string, [ Assert, Assert ], [ string, string ] )
+    * Validate object: validate( object, Constraint, string ) || validate( object, Constraint, [ string, string ] )
+    * Validate binded object: validate( object, string ) || validate( object, [ string, string ] )
     */
-    , init: function ( options ) {
-      var customValidators = options.validators
-        , customMessages = options.messages
-        , key;
-
-      for ( key in customValidators ) {
-        this.addValidator(key, customValidators[ key ]);
-      }
-
-      for ( key in customMessages ) {
-        this.addMessage(key, customMessages[ key ]);
-      }
+    validate: function ( objectOrString, AssertsOrConstraintOrGroup, group ) {
+      if ( 'string' !== typeof objectOrString && 'object' !== typeof objectOrString )
+        throw new Error( 'You must validate an object or a string' );
+      // string / array validation
+      if ( 'string' === typeof objectOrString || _isArray(objectOrString) )
+        return this._validateString( objectOrString, AssertsOrConstraintOrGroup, group );
+      // binded object validation
+      if ( this.isBinded( objectOrString ) )
+        return this._validateBindedObject( objectOrString, AssertsOrConstraintOrGroup );
+      // regular object validation
+      return this._validateObject( objectOrString, AssertsOrConstraintOrGroup, group );
+    },
+    bind: function ( object, constraint ) {
+      if ( 'object' !== typeof object )
+        throw new Error( 'Must bind a Constraint to an object' );
+      object[ this.bindingKey ] = new Constraint( constraint );
+      return this;
+    },
+    unbind: function ( object ) {
+      if ( 'undefined' === typeof object._validatorjsConstraint )
+        return this;
+      delete object[ this.bindingKey ];
+      return this;
+    },
+    isBinded: function ( object ) {
+      return 'undefined' !== typeof object[ this.bindingKey ];
+    },
+    getBinded: function ( object ) {
+      return this.isBinded( object ) ? object[ this.bindingKey ] : null;
+    },
+    _validateString: function ( string, assert, group ) {
+      var result, failures = [];
+      if ( !_isArray( assert ) )
+        assert = [ assert ];
+      for ( var i = 0; i < assert.length; i++ ) {
+        if ( ! ( assert[ i ] instanceof Assert) )
+          throw new Error( 'You must give an Assert or an Asserts array to validate a string' );
+        result = assert[ i ].check( string, group );
+        if ( result instanceof Violation )
+          failures.push( result );
+      }
+      return failures.length ? failures : true;
+    },
+    _validateObject: function ( object, constraint, group ) {
+      if ( 'object' !== typeof constraint )
+        throw new Error( 'You must give a constraint to validate an object' );
+      if ( constraint instanceof Constraint )
+        return constraint.check( object, group );
+      return new Constraint( constraint ).check( object, group );
+    },
+    _validateBindedObject: function ( object, group ) {
+      return object[ this.bindingKey ].check( object, group );
     }
-
-    /**
-    * Replace %s placeholders by values
-    *
-    * @method formatMesssage
-    * @param {String} message Message key
-    * @param {Mixed} args Args passed by validators functions. Could be string, number or object
-    * @return {String} Formatted string
-    */
-    , formatMesssage: function ( message, args ) {
-
-      if ( 'object' === typeof args ) {
-        for ( var i in args ) {
-          message = this.formatMesssage( message, args[ i ] );
-        }
-
-        return message;
+  };
+  Validator.errorCode = {
+    must_be_a_string: 'must_be_a_string',
+    must_be_an_array: 'must_be_an_array',
+    must_be_a_number: 'must_be_a_number',
+    must_be_a_string_or_array: 'must_be_a_string_or_array'
+  };
+  /**
+  * Constraint
+  */
+  var Constraint = function ( data, options ) {
+    this.__class__ = 'Constraint';
+    this.options = options || {};
+    this.nodes = {};
+    if ( data ) {
+      try {
+        this._bootstrap( data );
+      } catch ( err ) {
+        throw new Error( 'Should give a valid mapping object to Constraint', err, data );
       }
-
-      return 'string' === typeof message ? message.replace( new RegExp( '%s', 'i' ), args ) : '';
     }
-
-    /**
-    * Add / override a validator in validators list
-    *
-    * @method addValidator
-    * @param {String} name Validator name.
-    * @param {Function} fn Validator. Must return { validator: fn(), priority: int }
-    */
-    , addValidator: function ( name, fn ) {
-      if ('undefined' === typeof fn().validate) {
-        throw new Error( 'Validator `' + name + '` must have a validate method. See more here: http://parsleyjs.org/documentation.html#javascript-general' );
-      }
-
-      // add default prioirty if not given.
-      if ('undefined' === typeof fn().priority) {
-        fn = {
-            validate: fn().validate
-          , priority: 32
-        };
-
-        // Warn if possible
-        if (window.console && window.console.warn) {
-          window.console.warn( 'Validator `' + name + '` should have a priority. Default priority 32 given' );
+    return this;
+  };
+  Constraint.prototype = {
+    constructor: Constraint,
+    check: function ( object, group ) {
+      var result, failures = {};
+      // check all constraint nodes if strict validation enabled. Else, only object nodes that have a constraint
+      for ( var property in this.options.strict ? this.nodes : object ) {
+        if ( this.options.strict ? this.has( property, object ) : this.has( property ) ) {
+          result = this._check( property, object[ property ], group );
+          // check returned an array of Violations or an object mapping Violations
+          if ( ( _isArray( result ) && result.length > 0 ) || ( !_isArray( result ) && !_isEmptyObject( result ) ) )
+            failures[ property ] = result;
+        // in strict mode, get a violation for each constraint node not in object
+        } else if ( this.options.strict ) {
+          try {
+            // we trigger here a HaveProperty Assert violation to have uniform Violation object in the end
+            new Assert().HaveProperty( property ).validate( object );
+          } catch ( violation ) {
+            failures[ property ] = violation;
+          }
         }
       }
-
-      this.validators[ name ] = fn;
-    }
-
-    /**
-    * Add / override error message
-    *
-    * @method addMessage
-    * @param {String} name Message name. Will automatically be binded to validator with same name
-    * @param {String} message Message
-    */
-    , addMessage: function ( key, message, type ) {
-
-      if ( 'undefined' !== typeof type && true === type ) {
-        this.messages.type[ key ] = message;
-        return;
+      return _isEmptyObject(failures) ? true : failures;
+    },
+    add: function ( node, object ) {
+      if ( object instanceof Assert  || ( _isArray( object ) && object[ 0 ] instanceof Assert ) ) {
+        this.nodes[ node ] = object;
+        return this;
       }
-
-      // custom types messages are a bit tricky cuz' nested ;)
-      if ( 'type' === key ) {
-        for ( var i in message ) {
-          this.messages.type[ i ] = message[ i ];
-        }
-
-        return;
+      if ( 'object' === typeof object && !_isArray( object ) ) {
+        this.nodes[ node ] = object instanceof Constraint ? object : new Constraint( object );
+        return this;
       }
-
-      this.messages[ key ] = message;
+      throw new Error( 'Should give an Assert, an Asserts array, a Constraint', object );
+    },
+    has: function ( node, nodes ) {
+      nodes = 'undefined' !== typeof nodes ? nodes : this.nodes;
+      return 'undefined' !== typeof nodes[ node ];
+    },
+    get: function ( node, placeholder ) {
+      return this.has( node ) ? this.nodes[ node ] : placeholder || null;
+    },
+    remove: function ( node ) {
+      var _nodes = [];
+      for ( var i in this.nodes )
+        if ( i !== node )
+          _nodes[ i ] = this.nodes[ i ];
+      this.nodes = _nodes;
+      return this;
+    },
+    _bootstrap: function ( data ) {
+      if ( data instanceof Constraint )
+        return this.nodes = data.nodes;
+      for ( var node in data )
+        this.add( node, data[ node ] );
+    },
+    _check: function ( node, value, group ) {
+      // Assert
+      if ( this.nodes[ node ] instanceof Assert )
+        return this._checkAsserts( value, [ this.nodes[ node ] ], group );
+      // Asserts
+      if ( _isArray( this.nodes[ node ] ) )
+        return this._checkAsserts( value, this.nodes[ node ], group );
+      // Constraint -> check api
+      if ( this.nodes[ node ] instanceof Constraint )
+        return this.nodes[ node ].check( value, group );
+      throw new Error( 'Invalid node', this.nodes[ node ] );
+    },
+    _checkAsserts: function ( value, asserts, group ) {
+      var result, failures = [];
+      for ( var i = 0; i < asserts.length; i++ ) {
+        result = asserts[ i ].check( value, group );
+        if ( 'undefined' !== typeof result && true !== result )
+          failures.push( result );
+        // Some asserts (Collection for example) could return an object
+        // if ( result && ! ( result instanceof Violation ) )
+        //   return result;
+        //
+        // // Vast assert majority return Violation
+        // if ( result instanceof Violation )
+        //   failures.push( result );
+      }
+      return failures;
     }
   };
-
-  var ParsleyUI = function ( ParsleyInstance ) {
-    this.init( ParsleyInstance );
+  /**
+  * Violation
+  */
+  var Violation = function ( assert, value, violation ) {
+    this.__class__ = 'Violation';
+    if ( ! ( assert instanceof Assert ) )
+      throw new Error( 'Should give an assertion implementing the Assert interface' );
+    this.assert = assert;
+    this.value = value;
+    if ( 'undefined' !== typeof violation )
+      this.violation = violation;
   };
-
-  ParsleyUI.prototype = {
-
-    constructor: ParsleyUI
-
-    , init: function ( ParsleyInstance ) {
-      this.ParsleyInstance = ParsleyInstance;
-      this.hash = ParsleyInstance.hash;
-      this.options = this.ParsleyInstance.options;
-      this.errorClassHandler = this.options.errors.classHandler( this.ParsleyInstance.element, this.ParsleyInstance.isRadioOrCheckbox ) || this.ParsleyInstance.$element;
-      this.ulErrorManagement();
-    }
-
-    /**
-    * Manage ul error Container
-    *
-    * @private
-    * @method ulErrorManagement
-    */
-    , ulErrorManagement: function () {
-      this.ulError = '#' + this.hash;
-      this.ulTemplate = $( this.options.errors.errorsWrapper ).attr( 'id', this.hash ).addClass( 'parsley-error-list' );
-    }
-
-    /**
-    * Remove li / ul error
-    *
-    * @method removeError
-    * @param  {String} constraintName Method Name
-    * @return ParsleyUI
-    */
-    , removeError: function ( constraintName ) {
-      var liError = this.ulError + ' .' + constraintName
-        , that = this;
-
-      this.options.animate ? $( liError ).fadeOut( this.options.animateDuration, function () {
-        $( this ).remove();
-
-        if ( that.ulError && $( that.ulError ).children().length === 0 ) {
-          that.removeErrors();
-        } } ) : $( liError ).remove();
-
-        return this;
+  Violation.prototype = {
+    show: function () {
+      var show =  {
+        assert: this.assert.__class__,
+        value: this.value
+      };
+      if ( this.violation )
+        show.violation = this.violation;
+      return show;
+    },
+    __toString: function () {
+      if ( 'undefined' !== typeof this.violation )
+        this.violation = '", ' + this.getViolation().constraint + ' expected was ' + this.getViolation().expected;
+      return this.assert.__class__ + ' assert failed for "' + this.value + this.violation || '';
+    },
+    getViolation: function () {
+      var constraint, expected;
+      for ( constraint in this.violation )
+        expected = this.violation[ constraint ];
+      return { constraint: constraint, expected: expected };
     }
-
-    /**
-    * Add li error
-    *
-    * @method addError
-    * @param  {Object} { minlength: "error message for minlength constraint" }
-    * @return ParsleyUI
-    */
-    , addError: function ( error ) {
-      for ( var constraint in error ) {
-        var liTemplate = $( this.options.errors.errorElem ).addClass( constraint );
-
-        $( this.ulError ).append( this.options.animate ? $( liTemplate ).html( error[ constraint ] ).hide().fadeIn( this.options.animateDuration ) : $( liTemplate ).html( error[ constraint ] ) );
+  };
+  /**
+  * Assert
+  */
+  var Assert = function ( group ) {
+    this.__class__ = 'Assert';
+    this.__parentClass__ = this.__class__;
+    this.groups = [];
+    if ( 'undefined' !== typeof group )
+      this.addGroup( group );
+    return this;
+  };
+  Assert.prototype = {
+    construct: Assert,
+    check: function ( value, group ) {
+      if ( group && !this.hasGroup( group ) )
+        return;
+      if ( !group && this.hasGroups() )
+        return;
+      try {
+        return this.validate( value, group );
+      } catch ( violation ) {
+        return violation;
       }
-
+    },
+    hasGroup: function ( group ) {
+      if ( _isArray( group ) )
+        return this.hasOneOf( group );
+      // All Asserts respond to "Any" group
+      if ( 'Any' === group )
+        return true;
+      // Asserts with no group also respond to "Default" group. Else return false
+      if ( !this.hasGroups() )
+        return 'Default' === group;
+      return -1 !== this.groups.indexOf( group );
+    },
+    hasOneOf: function ( groups ) {
+      for ( var i = 0; i < groups.length; i++ )
+        if ( this.hasGroup( groups[ i ] ) )
+          return true;
+      return false;
+    },
+    hasGroups: function () {
+      return this.groups.length > 0;
+    },
+    addGroup: function ( group ) {
+      if ( _isArray( group ) )
+        return this.addGroups( group );
+      if ( !this.hasGroup( group ) )
+        this.groups.push( group );
       return this;
-    }
-
-    /**
-    * Update existing error if text has changed
-    *
-    * @method updateError
-    * @param  {Object} { minlength: "error message for minlength constraint" }
-    * @return ParsleyUI
-    */
-    , updateError: function ( error ) {
-      for ( var constraint in error ) {
-        if ( error[ constraint ] !==  $( this.ulError +  " > li." + constraint ).html() ) {
-          this.removeError( constraint ).addError( error );
-        }
-      }
-
+    },
+    removeGroup: function ( group ) {
+      var _groups = [];
+      for ( var i = 0; i < this.groups.length; i++ )
+        if ( group !== this.groups[ i ] )
+          _groups.push( this.groups[ i ] );
+      this.groups = _groups;
       return this;
-    }
-
-    /**
-    * Remove all ul / li errors
-    *
-    * @method removeErrors
-    * @return ParsleyUI
-    */
-    , removeErrors: function () {
-      this.options.animate ? $( this.ulError ).fadeOut( this.options.animateDuration, function () { $( this ).remove(); } ) : $( this.ulError ).remove();
-
+    },
+    addGroups: function ( groups ) {
+      for ( var i = 0; i < groups.length; i++ )
+        this.addGroup( groups[ i ] );
       return this;
-    }
-
+    },
     /**
-    * Remove ul errors and parsley error or success classes
-    *
-    * @method reset
-    * @return ParsleyUI
+    * Asserts definitions
     */
-    , reset: function () {
-      this.ParsleyInstance.valid = null;
-      this.removeErrors();
-      this.ParsleyInstance.validatedOnce = false;
-      this.errorClassHandler.removeClass( this.options.successClass ).removeClass( this.options.errorClass );
-
-      for ( var constraint in this.constraints ) {
-        this.constraints[ constraint ].valid = null;
-      }
-
+    HaveProperty: function ( node ) {
+      this.__class__ = 'HaveProperty';
+      this.node = node;
+      this.validate = function ( object ) {
+        if ( 'undefined' === typeof object[ this.node ] )
+          throw new Violation( this, object, { value: this.node } );
+        return true;
+      };
       return this;
-    }
-
-    /**
-    * Add li / ul errors messages
-    *
-    * @method manageError
-    * @param  {Object} constraint
-    * @return ParsleyUI
-    */
-    , manageError: function ( constraint ) {
-      // display ulError container if it has been removed previously (or never shown)
-      if ( !$( this.ulError ).length ) {
-        this.manageErrorContainer();
-      }
-
-      // TODO: refacto properly
-      // if required constraint but field is not null, do not display
-      if ( 'required' === constraint.name && null !== this.ParsleyInstance.getVal() && this.ParsleyInstance.getVal().length > 0 ) {
-        return this;
-
-      // if empty required field and non required constraint fails, do not display
-      } else if ( this.ParsleyInstance.isRequired && 'required' !== constraint.name && ( null === this.ParsleyInstance.getVal() || 0 === this.ParsleyInstance.getVal().length ) ) {
-        this.removeError( constraint.name );
-
-        return this;
-      }
-
-      // TODO: refacto error name w/ proper & readable function
-      var constraintName = constraint.name
-        , liClass = false !== this.options.errorMessage ? 'custom-error-message' : constraintName
-        , liError = {}
-        , message = false !== this.options.errorMessage ? this.options.errorMessage : ( constraint.name === 'type' ?
-            this.ParsleyInstance.Validator.messages[ constraintName ][ constraint.requirements ] : ( 'undefined' === typeof this.ParsleyInstance.Validator.messages[ constraintName ] ?
-              this.ParsleyInstance.Validator.messages.defaultMessage : this.ParsleyInstance.Validator.formatMesssage( this.ParsleyInstance.Validator.messages[ constraintName ], constraint.requirements ) ) );
-
-      liError[ liClass ] = message;
-
-      // add liError if not shown. update if already exist
-      !$( this.ulError + ' .' + liClass ).length ? this.addError( liError ) : this.updateError( liError );
-
+    },
+    Blank: function () {
+      this.__class__ = 'Blank';
+      this.validate = function ( value ) {
+        if ( 'string' !== typeof value )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_string } );
+        if ( '' !== value.replace( /^\s+/g, '' ).replace( /\s+$/g, '' ) )
+          throw new Violation( this, value );
+        return true;
+      };
       return this;
-    }
-
-    /**
-    * Create ul error container
-    *
-    * @method manageErrorContainer
-    * @return ParsleyUI
-    */
-    , manageErrorContainer: function () {
-      var errorContainer = this.options.errorContainer || this.options.errors.container( this.ParsleyInstance.element, this.ParsleyInstance.isRadioOrCheckbox )
-        , ulTemplate = this.options.animate ? this.ulTemplate.css('display', '') : this.ulTemplate;
-
-      if ( 'undefined' !== typeof errorContainer ) {
-        $( errorContainer ).append( ulTemplate );
-        return;
-      }
-
-      !this.ParsleyInstance.isRadioOrCheckbox ? this.ParsleyInstance.$element.after( ulTemplate ) : this.ParsleyInstance.$element.parent().after( ulTemplate );
-
+    },
+    Callback: function ( fn ) {
+      this.__class__ = 'Callback';
+      this.arguments = Array.prototype.slice.call( arguments );
+      if ( 1 === this.arguments.length )
+        this.arguments = [];
+      else
+        this.arguments.splice( 0, 1 );
+      if ( 'function' !== typeof fn )
+        throw new Error( 'Callback must be instanciated with a function' );
+      this.fn = fn;
+      this.validate = function ( value ) {
+        var result = this.fn.apply( this, [ value ].concat( this.arguments ) );
+        if ( true !== result )
+          throw new Violation( this, value, { result: result } );
+        return true;
+      };
       return this;
-    }
-  };
-
-  /**
-  * ParsleyField class manage each form field inside a validated Parsley form.
-  * Returns if field valid or not depending on its value and constraints
-  * Manage field error display and behavior, event triggers and more
-  *
-  * @class ParsleyField
-  * @constructor
-  */
-  var ParsleyField = function ( element, options, type ) {
-    this.options = options;
-
-    // if type is ParsleyFieldMultiple, just return this. used for clone
-    if ( type === 'ParsleyFieldMultiple' ) {
+    },
+    Choice: function ( list ) {
+      this.__class__ = 'Choice';
+      if ( !_isArray( list ) && 'function' !== typeof list )
+        throw new Error( 'Choice must be instanciated with an array or a function' );
+      this.list = list;
+      this.validate = function ( value ) {
+        var list = 'function' === typeof this.list ? this.list() : this.list;
+        for ( var i = 0; i < list.length; i++ )
+          if ( value === list[ i ] )
+            return true;
+        throw new Violation( this, value, { choices: list } );
+      };
       return this;
-    }
-
-    this.init( element, type || 'ParsleyField' );
-  };
-
-  ParsleyField.prototype = {
-
-    constructor: ParsleyField
-
-    /**
-    * Set some properties, bind constraint validators and validation events
-    *
-    * @method init
-    * @param {Object} element
-    * @param {Object} options
-    */
-    , init: function ( element, type ) {
-      this.type = type;
-      this.valid = true;
-      this.element = element;
-      this.validatedOnce = false;
-      this.$element = $( element );
-      this.val = this.$element.val();
-      this.Validator = new Validator( this.options );
-      this.isRequired = false;
-      this.constraints = {};
-
-      // overriden by ParsleyItemMultiple if radio or checkbox input
-      if ( 'undefined' === typeof this.isRadioOrCheckbox ) {
-        this.isRadioOrCheckbox = false;
-        this.hash = this.generateHash();
-      }
-
-      // error ul dom management done only once at init
-      this.UI = new ParsleyUI( this );
-
-      // bind some html5 properties
-      if ( this.options.useHtml5Constraints ) {
-        this.bindHtml5Constraints();
-      }
-
-      // bind validators to field
-      this.addConstraints();
-
-      // bind parsley events if validators have been registered
-      if ( this.hasConstraints() ) {
-        this.bindValidationEvents();
-      }
-    }
-
-    , setParent: function ( elem ) {
-      this.$parent = $( elem );
-    }
-
-    , getParent: function () {
-      return this.$parent;
-    }
-
-    /**
-    * Bind some extra html5 types / validators
-    *
-    * @private
-    * @method bindHtml5Constraints
-    */
-    , bindHtml5Constraints: function () {
-      // add html5 required support + class required support
-      if ( this.$element.hasClass( 'required' ) || this.$element.attr( 'required' ) ) {
-        this.options.required = true;
-      }
-
-      // add html5 supported types & options
-      var type = this.$element.attr( 'type' );
-      if ( 'undefined' !== typeof type && new RegExp( type, 'i' ).test( 'email url number range tel' ) ) {
-        this.options.type = 'tel' === type ? 'phone' : type;
-
-        // number and range types could have min and/or max values
-        if ( new RegExp( this.options.type, 'i' ).test( 'number range' ) ) {
-          this.options.type = 'number';
-
-          // double condition to support jQuery and Zepto.. :(
-          if ( 'undefined' !== typeof this.$element.attr( 'min' ) && this.$element.attr( 'min' ).length ) {
-            this.options.min = this.$element.attr( 'min' );
-          }
-
-          if ( 'undefined' !== typeof this.$element.attr( 'max' ) && this.$element.attr( 'max' ).length ) {
-            this.options.max = this.$element.attr( 'max' );
-          }
+    },
+    Collection: function ( constraint ) {
+      this.__class__ = 'Collection';
+      this.constraint = 'undefined' !== typeof constraint ? new Constraint( constraint ) : false;
+      this.validate = function ( collection, group ) {
+        var result, validator = new Validator(), count = 0, failures = {}, groups = this.groups.length ? this.groups : group;
+        if ( !_isArray( collection ) )
+          throw new Violation( this, array, { value: Validator.errorCode.must_be_an_array } );
+        for ( var i = 0; i < collection.length; i++ ) {
+          result = this.constraint ?
+            validator.validate( collection[ i ], this.constraint, groups ) :
+            validator.validate( collection[ i ], groups );
+          if ( !_isEmptyObject( result ) )
+            failures[ count ] = result;
+          count++;
         }
-      }
-
-      if ( 'string' === typeof this.$element.attr( 'pattern' ) && this.$element.attr( 'pattern' ).length ) {
-          this.options.regexp = this.$element.attr( 'pattern' );
-      }
-
-    }
-
-    /**
-    * Attach field validators functions passed through data-api
-    *
-    * @private
-    * @method addConstraints
-    */
-    , addConstraints: function () {
-      for ( var constraint in this.options ) {
-        var addConstraint = {};
-        addConstraint[ constraint ] = this.options[ constraint ];
-        this.addConstraint( addConstraint, true, false );
-      }
-    }
-
-    /**
-    * Dynamically add a new constraint to a field
-    *
-    * @method addConstraint
-    * @param {Object} constraint { name: requirements }
-    */
-    , addConstraint: function ( constraint, doNotUpdateValidationEvents, sort ) {
-        for ( var name in constraint ) {
-          name = name.toLowerCase();
-
-          if ( 'function' === typeof this.Validator.validators[ name ] ) {
-            this.constraints[ name ] = {
-                name: name
-              , requirements: constraint[ name ]
-              , valid: null
-            }
-
-            if ( name === 'required' ) {
-              this.isRequired = true;
-            }
-
-            this.addCustomConstraintMessage( name );
+        return !_isEmptyObject( failures ) ? failures : true;
+      };
+      return this;
+    },
+    Count: function ( count ) {
+      this.__class__ = 'Count';
+      this.count = count;
+      this.validate = function ( array ) {
+        if ( !_isArray( array ) )
+          throw new Violation( this, array, { value: Validator.errorCode.must_be_an_array } );
+        var count = 'function' === typeof this.count ? this.count( array ) : this.count;
+        if ( isNaN( Number( count ) ) )
+          throw new Error( 'Count must be a valid interger', count );
+        if ( count !== array.length )
+          throw new Violation( this, array, { count: count } );
+        return true;
+      };
+      return this;
+    },
+    Email: function () {
+      this.__class__ = 'Email';
+      this.validate = function ( value ) {
+        var regExp = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-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-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
+        if ( 'string' !== typeof value )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_string } );
+        if ( !regExp.test( value ) )
+          throw new Violation( this, value );
+        return true;
+      };
+      return this;
+    },
+    Eql: function ( eql ) {
+      this.__class__ = 'Eql';
+      if ( 'undefined' === typeof eql )
+        throw new Error( 'Equal must be instanciated with an Array or an Object' );
+      this.eql = eql;
+      this.validate = function ( value ) {
+        var eql = 'function' === typeof this.eql ? this.eql( value ) : this.eql;
+        if ( !expect.eql( eql, value ) )
+          throw new Violation( this, value, { eql: eql } );
+        return true;
+      };
+      return this;
+    },
+    EqualTo: function ( reference ) {
+      this.__class__ = 'EqualTo';
+      if ( 'undefined' === typeof reference )
+        throw new Error( 'EqualTo must be instanciated with a value or a function' );
+      this.reference = reference;
+      this.validate = function ( value ) {
+        var reference = 'function' === typeof this.reference ? this.reference( value ) : this.reference;
+        if ( reference !== value )
+          throw new Violation( this, value, { value: reference } );
+        return true;
+      };
+      return this;
+    },
+    GreaterThan: function ( threshold ) {
+      this.__class__ = 'GreaterThan';
+      if ( 'undefined' === typeof threshold )
+        throw new Error( 'Should give a threshold value' );
+      this.threshold = threshold;
+      this.validate = function ( value ) {
+        if ( '' === value || isNaN( Number( value ) ) )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_number } );
+        if ( this.threshold >= value )
+          throw new Violation( this, value, { threshold: this.threshold } );
+        return true;
+      };
+      return this;
+    },
+    GreaterThanOrEqual: function ( threshold ) {
+      this.__class__ = 'GreaterThanOrEqual';
+      if ( 'undefined' === typeof threshold )
+        throw new Error( 'Should give a threshold value' );
+      this.threshold = threshold;
+      this.validate = function ( value ) {
+        if ( '' === value || isNaN( Number( value ) ) )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_number } );
+        if ( this.threshold > value )
+          throw new Violation( this, value, { threshold: this.threshold } );
+        return true;
+      };
+      return this;
+    },
+    InstanceOf: function ( classRef ) {
+      this.__class__ = 'InstanceOf';
+      if ( 'undefined' === typeof classRef )
+        throw new Error( 'InstanceOf must be instanciated with a value' );
+      this.classRef = classRef;
+      this.validate = function ( value ) {
+        if ( true !== (value instanceof this.classRef) )
+          throw new Violation( this, value, { classRef: this.classRef } );
+        return true;
+      };
+      return this;
+    },
+    IPv4: function () {
+      this.__class__ = 'IPv4';
+      this.validate = function ( value ) {
+        var regExp = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+        if ( 'string' !== typeof value )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_string } );
+        if ( !regExp.test( value ) )
+          throw new Violation( this, value );
+        return true;
+      };
+      return this;
+    },
+    Length: function ( boundaries ) {
+      this.__class__ = 'Length';
+      if ( !boundaries.min && !boundaries.max )
+        throw new Error( 'Lenth assert must be instanciated with a { min: x, max: y } object' );
+      this.min = boundaries.min;
+      this.max = boundaries.max;
+      this.validate = function ( value ) {
+        if ( 'string' !== typeof value && !_isArray( value ) )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_string_or_array } );
+        if ( 'undefined' !== typeof this.min && this.min === this.max && value.length !== this.min )
+          throw new Violation( this, value, { min: this.min, max: this.max } );
+        if ( 'undefined' !== typeof this.max && value.length > this.max )
+          throw new Violation( this, value, { max: this.max } );
+        if ( 'undefined' !== typeof this.min && value.length < this.min )
+          throw new Violation( this, value, { min: this.min } );
+        return true;
+      };
+      return this;
+    },
+    LessThan: function ( threshold ) {
+      this.__class__ = 'LessThan';
+      if ( 'undefined' === typeof threshold )
+        throw new Error( 'Should give a threshold value' );
+      this.threshold = threshold;
+      this.validate = function ( value ) {
+        if ( '' === value || isNaN( Number( value ) ) )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_number } );
+        if ( this.threshold <= value )
+          throw new Violation( this, value, { threshold: this.threshold } );
+        return true;
+      };
+      return this;
+    },
+    LessThanOrEqual: function ( threshold ) {
+      this.__class__ = 'LessThanOrEqual';
+      if ( 'undefined' === typeof threshold )
+        throw new Error( 'Should give a threshold value' );
+      this.threshold = threshold;
+      this.validate = function ( value ) {
+        if ( '' === value || isNaN( Number( value ) ) )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_number } );
+        if ( this.threshold < value )
+          throw new Violation( this, value, { threshold: this.threshold } );
+        return true;
+      };
+      return this;
+    },
+    Mac: function () {
+      this.__class__ = 'Mac';
+      this.validate = function ( value ) {
+        var regExp = /^(?:[0-9A-F]{2}:){5}[0-9A-F]{2}$/i;
+        if ( 'string' !== typeof value )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_string } );
+        if ( !regExp.test( value ) )
+          throw new Violation( this, value );
+        return true;
+      };
+      return this;
+    },
+    NotNull: function () {
+      this.__class__ = 'NotNull';
+      this.validate = function ( value ) {
+        if ( null === value || 'undefined' === typeof value )
+          throw new Violation( this, value );
+        return true;
+      };
+      return this;
+    },
+    NotBlank: function () {
+      this.__class__ = 'NotBlank';
+      this.validate = function ( value ) {
+        if ( 'string' !== typeof value )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_string } );
+        if ( '' === value.replace( /^\s+/g, '' ).replace( /\s+$/g, '' ) )
+          throw new Violation( this, value );
+        return true;
+      };
+      return this;
+    },
+    Null: function () {
+      this.__class__ = 'Null';
+      this.validate = function ( value ) {
+        if ( null !== value )
+          throw new Violation( this, value );
+        return true;
+      };
+      return this;
+    },
+    Range: function ( min, max ) {
+      this.__class__ = 'Range';
+      if ( 'undefined' === typeof min || 'undefined' === typeof max )
+        throw new Error( 'Range assert expects min and max values' );
+      this.min = min;
+      this.max = max;
+      this.validate = function ( value ) {
+          try {
+            // validate strings and objects with their Length
+            if ( ( 'string' === typeof value && isNaN( Number( value ) ) ) || _isArray( value ) )
+              new Assert().Length( { min: this.min, max: this.max } ).validate( value );
+            // validate numbers with their value
+            else
+              new Assert().GreaterThanOrEqual( this.min ).validate( value ) && new Assert().LessThanOrEqual( this.max ).validate( value );
+            return true;
+          } catch ( violation ) {
+            throw new Violation( this, value, violation.violation );
           }
-        }
-
-        // force field validation next check and reset validation events
-        if ( 'undefined' === typeof doNotUpdateValidationEvents ) {
-          this.bindValidationEvents();
-        }
-    }
-
-    /**
-    * Dynamically update an existing constraint to a field.
-    * Simple API: { name: requirements }
-    *
-    * @method updtConstraint
-    * @param {Object} constraint
-    */
-    , updateConstraint: function ( constraint, message ) {
-      for ( var name in constraint ) {
-        this.updtConstraint( { name: name, requirements: constraint[ name ], valid: null }, message );
-      }
-    }
-
-    /**
-    * Dynamically update an existing constraint to a field.
-    * Complex API: { name: name, requirements: requirements, valid: boolean }
-    *
-    * @method updtConstraint
-    * @param {Object} constraint
-    */
-    , updtConstraint: function ( constraint, message ) {
-      this.constraints[ constraint.name ] = $.extend( true, this.constraints[ constraint.name ], constraint );
-
-      if ( 'string' === typeof message ) {
-        if ( constraint.name ===  'type' )
-          this.Validator.messages[ constraint.name ][ constraint.requirements ] = message ;
-        else
-          this.Validator.messages[ constraint.name ] = message ;
-      }
-
-      // force field validation next check and reset validation events
-      this.bindValidationEvents();
-    }
-
-    /**
-    * Dynamically remove an existing constraint to a field.
-    *
-    * @method removeConstraint
-    * @param {String} constraintName
-    */
-    , removeConstraint: function ( constraintName ) {
-      var constraintName = constraintName.toLowerCase();
-
-      delete this.constraints[ constraintName ];
-
-      if ( constraintName === 'required' ) {
-        this.isRequired = false;
-      }
-
-      // if there are no more constraint, reset errors and validation state
-      if ( !this.hasConstraints() ) {
-        this.UI.reset();
-        return;
-      }
-
-      this.bindValidationEvents();
-    }
-
-    /**
-    * Add custom constraint message, passed through data-API
-    *
-    * @private
-    * @method addCustomConstraintMessage
-    * @param constraint
-    */
-    , addCustomConstraintMessage: function ( constraint ) {
-      // custom message type data-type-email-message -> typeEmailMessage | data-minlength-error => minlengthMessage
-      var customMessage = constraint
-        + ( 'type' === constraint && 'undefined' !== typeof this.options[ constraint ] ? this.options[ constraint ].charAt( 0 ).toUpperCase() + this.options[ constraint ].substr( 1 ) : '' )
-        + 'Message';
-
-      if ( 'undefined' !== typeof this.options[ customMessage ] ) {
-        this.Validator.addMessage( 'type' === constraint ? this.options[ constraint ] : constraint, this.options[ customMessage ], 'type' === constraint );
-      }
-    }
-
-    /**
-    * Bind validation events on a field
-    *
-    * @private
-    * @method bindValidationEvents
-    */
-    , bindValidationEvents: function () {
-      // this field has validation events, that means it has to be validated
-      this.valid = null;
-      this.$element.addClass( 'parsley-validated' );
-
-      // remove eventually already binded events
-      this.$element.off( '.' + this.type );
-
-      // force add 'change' event if async remote validator here to have result before form submitting
-      if ( this.options.remote && !new RegExp( 'change', 'i' ).test( this.options.trigger ) ) {
-        this.options.trigger = !this.options.trigger ? 'change' : ' change';
-      }
-
-      // always bind keyup event, for better UX when a field is invalid
-      var triggers = ( !this.options.trigger ? '' : this.options.trigger )
-        + ( new RegExp( 'key', 'i' ).test( this.options.trigger ) ? '' : ' keyup' );
-
-      // always bind change event, for better UX when a select is invalid
-      if ( this.$element.is( 'select' ) ) {
-        triggers += new RegExp( 'change', 'i' ).test( triggers ) ? '' : ' change';
-      }
-
-      // trim triggers to bind them correctly with .on()
-      triggers = triggers.replace( /^\s+/g , '' ).replace( /\s+$/g , '' );
-
-      this.$element.on( ( triggers + ' ' ).split( ' ' ).join( '.' + this.type + ' ' ), false, $.proxy( this.eventValidation, this ) );
-    }
-
-    /**
-    * Hash management. Used for ul error
-    *
-    * @method generateHash
-    * @returns {String} 5 letters unique hash
-    */
-    , generateHash: function () {
-      return 'parsley-' + ( Math.random() + '' ).substring( 2 );
-    }
-
-    /**
-    * Public getHash accessor
-    *
-    * @method getHash
-    * @returns {String} hash
-    */
-    , getHash: function () {
-      return this.hash;
-    }
-
-    /**
-    * Returns field val needed for validation
-    * Special treatment for radio & checkboxes
-    *
-    * @method getVal
-    * @returns {String} val
-    */
-    , getVal: function () {
-      if ('undefined' !== typeof this.$element.domApi( this.options.namespace )[ 'value' ]) {
-        return this.$element.domApi( this.options.namespace )[ 'value' ];
-      }
-
-      return this.$element.val();
-    }
-
-    /**
-    * Called when validation is triggered by an event
-    * Do nothing if val.length < this.options.validationMinlength
-    *
-    * @method eventValidation
-    * @param {Object} event jQuery event
-    */
-    , eventValidation: function ( event ) {
-      var val = this.getVal();
-
-      // do nothing on keypress event if not explicitely passed as data-trigger and if field has not already been validated once
-      if ( event.type === 'keyup' && !/keyup/i.test( this.options.trigger ) && !this.validatedOnce ) {
         return true;
-      }
-
-      // do nothing on change event if not explicitely passed as data-trigger and if field has not already been validated once
-      if ( event.type === 'change' && !/change/i.test( this.options.trigger ) && !this.validatedOnce ) {
+      };
+      return this;
+    },
+    Regexp: function ( regexp, flag ) {
+      this.__class__ = 'Regexp';
+      if ( 'undefined' === typeof regexp )
+        throw new Error( 'You must give a regexp' );
+      this.regexp = regexp;
+      this.flag = flag || '';
+      this.validate = function ( value ) {
+        if ( 'string' !== typeof value )
+          throw new Violation( this, value, { value: Validator.errorCode.must_be_a_string } );
+        if ( !new RegExp( this.regexp, this.flag ).test( value ) )
+          throw new Violation( this, value, { regexp: this.regexp, flag: this.flag } );
         return true;
-      }
-
-      // start validation process only if field has enough chars and validation never started
-      if ( !this.isRadioOrCheckbox && this.getLength(val) < this.options.validationMinlength && !this.validatedOnce ) {
+      };
+      return this;
+    },
+    Required: function () {
+      this.__class__ = 'Required';
+      this.validate = function ( value ) {
+        if ( 'undefined' === typeof value )
+          throw new Violation( this, value );
+        try {
+          if ( 'string' === typeof value )
+            new Assert().NotNull().validate( value ) && new Assert().NotBlank().validate( value );
+          else if ( true === _isArray( value ) )
+            new Assert().Length( { min: 1 } ).validate( value );
+        } catch ( violation ) {
+          throw new Violation( this, value );
+        }
         return true;
-      }
-
-      this.validate();
-    }
-
-    /**
-     * Get the length of a given value
-     *
-     * @method getLength
-     * @return {int} The length of the value
-     */
-    , getLength: function ( val ) {
-      return !val || !val.hasOwnProperty( 'length' ) ? 0 : val.length;
-    }
-
-    /**
-    * Return if field verify its constraints
-    *
-    * @method isValid
-    * @return {Boolean} Is field valid or not
-    */
-    , isValid: function () {
-      return this.validate( false );
-    }
-
-    /**
-    * Return if field has constraints
-    *
-    * @method hasConstraints
-    * @return {Boolean} Is field has constraints or not
-    */
-    , hasConstraints: function () {
-      for ( var constraint in this.constraints ) {
+      };
+      return this;
+    },
+    // Unique() or Unique ( { key: foo } )
+    Unique: function ( object ) {
+      this.__class__ = 'Unique';
+      if ( 'object' === typeof object )
+        this.key = object.key;
+      this.validate = function ( array ) {
+        var value, store = [];
+        if ( !_isArray( array ) )
+          throw new Violation( this, array, { value: Validator.errorCode.must_be_an_array } );
+        for ( var i = 0; i < array.length; i++ ) {
+          value = 'object' === typeof array[ i ] ? array[ i ][ this.key ] : array[ i ];
+          if ( 'undefined' === typeof value )
+            continue;
+          if ( -1 !== store.indexOf( value ) )
+            throw new Violation( this, array, { value: value } );
+          store.push( value );
+        }
         return true;
-      }
-
-      return false;
-    }
-
-    /**
-    * Validate a field & display errors
-    *
-    * @method validate
-    * @param {Boolean} errorBubbling set to false if you just want valid boolean without error bubbling next to fields
-    * @return {Boolean} Is field valid or not
-    */
-    , validate: function ( errorBubbling ) {
-      var val = this.getVal()
-        , valid = null;
-
-      // do not even bother trying validating a field w/o constraints
-      if ( !this.hasConstraints() ) {
-        return null;
-      }
-
-      // do not validate excluded fields
-      if ( this.$element.is( this.options.excluded ) ) {
-        return null;
-      }
-
-      // reset Parsley validation if onFieldValidate returns true, or if field is empty and not required
-      if ( this.options.listeners.onFieldValidate( this.element, this ) || ( '' === val && !this.isRequired ) ) {
-        this.UI.reset();
-        return null;
-      }
-
-      // do not validate a field already validated and unchanged !
-      if ( !this.needsValidation( val ) ) {
-        return this.valid;
-      }
-
-      valid = this.applyValidators();
-
-      if ( 'undefined' !== typeof errorBubbling ? errorBubbling : this.options.showErrors ) {
-        this.manageValidationResult();
-      }
-
-      return valid;
-    }
-
-    /**
-    * Check if value has changed since previous validation
-    *
-    * @method needsValidation
-    * @param value
-    * @return {Boolean}
-    */
-    , needsValidation: function ( val ) {
-      if ( !this.options.validateIfUnchanged && this.valid !== null && this.val === val && this.validatedOnce ) {
-        return false;
-      }
-
-      this.val = val;
-      return this.validatedOnce = true;
+      };
+      return this;
     }
-
-    /**
-    * Loop through every fields validators
-    * Adds errors after unvalid fields
-    *
-    * @method applyValidators
-    * @return {Mixed} {Boolean} If field valid or not, null if not validated
-    */
-    , applyValidators: function () {
-      var valid = null;
-
-      for ( var constraint in this.constraints ) {
-        var result = this.Validator.validators[ this.constraints[ constraint ].name ]().validate( this.val, this.constraints[ constraint ].requirements, this );
-
-        if ( false === result ) {
-          valid = false;
-          this.constraints[ constraint ].valid = valid;
-        } else if ( true === result ) {
-          this.constraints[ constraint ].valid = true;
-          valid = false !== valid;
+  };
+  // expose to the world these awesome classes
+  exports.Assert = Assert;
+  exports.Validator = Validator;
+  exports.Violation = Violation;
+  exports.Constraint = Constraint;
+  /**
+  * Some useful object prototypes / functions here
+  */
+  // IE8<= compatibility
+  // https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf
+  if (!Array.prototype.indexOf)
+    Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
+        
+        if (this === null) {
+            throw new TypeError();
         }
-      }
-
-      // listeners' ballet
-      if (false === valid) {
-        this.options.listeners.onFieldError( this.element, this.constraints, this );
-      } else if (true === valid && false === this.options.listeners.onFieldSuccess( this.element, this.constraints, this )) {
-        // if onFieldSuccess returns (bool) false, consider that field si invalid
-        valid = false;
-      }
-
-      return valid;
-    }
-
-    /**
-    * Fired when all validators have be executed
-    * Returns true or false if field is valid or not
-    * Display errors messages below failed fields
-    * Adds parsley-success or parsley-error class on fields
-    *
-    * @method manageValidationResult
-    * @return {Boolean} Is field valid or not
-    */
-    , manageValidationResult: function () {
-      var valid = null
-        , errors = [];
-
-      for ( var constraint in this.constraints ) {
-        if ( false === this.constraints[ constraint ].valid ) {
-          errors.push( this.constraints[ constraint ]);
-          valid = false;
-        } else if ( true === this.constraints[ constraint ].valid ) {
-          this.UI.removeError( this.constraints[ constraint ].name );
-          valid = false !== valid;
+        var t = Object(this);
+        var len = t.length >>> 0;
+        if (len === 0) {
+            return -1;
         }
-      }
-
-      this.valid = valid;
-
-      if ( true === this.valid ) {
-        this.UI.removeErrors();
-        this.UI.errorClassHandler.removeClass( this.options.errorClass ).addClass( this.options.successClass );
-
-        return true;
-      } else if ( false === this.valid ) {
-        if ( true === this.options.priorityEnabled ) {
-          var maxPriority = 0, constraint, priority, error, errorArr = [];
-          for ( var i = 0; i < errors.length; i++ ) {
-            error = this.Validator.validators[ errors[ i ].name ]();
-            priority = error.priority;
-            errorArr.push(errors[ i ]);
-
-            if ( priority > maxPriority ) {
-              constraint = errors[ i ];
-              maxPriority = priority;
+        var n = 0;
+        if (arguments.length > 1) {
+            n = Number(arguments[1]);
+            if (n != n) { // shortcut for verifying if it's NaN
+                n = 0;
+            } else if (n !== 0 && n != Infinity && n != -Infinity) {
+                n = (n > 0 || -1) * Math.floor(Math.abs(n));
             }
-          }
-          for ( var i = 0; i < errorArr.length; i++ ) {
-            if ( constraint === errorArr[ i ] ) {
-              this.UI.manageError( constraint );
-            } else {
-              this.UI.removeError( errorArr[ i ].name );
+        }
+        if (n >= len) {
+            return -1;
+        }
+        var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+        for (; k < len; k++) {
+            if (k in t && t[k] === searchElement) {
+                return k;
             }
-          }
-        } else {
-          for ( var i = 0; i < errors.length; i++ )
-            this.UI.manageError( errors[ i ] );
         }
-
-        this.UI.errorClassHandler.removeClass( this.options.successClass ).addClass( this.options.errorClass );
-        return false;
-      }
-
-      // remove li error, and ul error if no more li inside
-      if ( this.UI.ulError && $( this.ulError ).children().length === 0 ) {
-        this.UI.removeErrors();
-      }
-
-      return valid;
-    }
-
-    /**
-    * Add custom listeners
-    *
-    * @param {Object} { listener: function () {} }, eg { onFormValidate: function ( valid, event, focus ) { ... } }
-    */
-    , addListener: function ( object ) {
-      for ( var listener in object ) {
-        this.options.listeners[ listener ] = object[ listener ];
-      }
-    }
-
-    /**
-    * Destroy parsley field instance
-    *
-    * @private
-    * @method destroy
-    */
-    , destroy: function () {
-      this.$element.removeClass( 'parsley-validated' );
-      this.UI.reset();
-      this.$element.off( '.' + this.type ).removeData( this.type );
-    }
+        return -1;
+    };
+  // Test if object is empty, useful for Constraint violations check
+  var _isEmptyObject = function ( obj ) {
+    for ( var property in obj )
+      return false;
+    return true;
   };
-
-  /**
-  * ParsleyFieldMultiple override ParsleyField for checkbox and radio inputs
-  * Pseudo-heritance to manage divergent behavior from ParsleyItem in dedicated methods
-  *
-  * @class ParsleyFieldMultiple
-  * @constructor
-  */
-  var ParsleyFieldMultiple = function ( element, options, type ) {
-    this.initMultiple( element, options );
-    this.inherit( element, options );
-    this.Validator = new Validator( options );
-
-    // call ParsleyField constructor
-    this.init( element, type || 'ParsleyFieldMultiple' );
+  var _isArray = function ( obj ) {
+    return Object.prototype.toString.call( obj ) === '[object Array]';
   };
-
-  ParsleyFieldMultiple.prototype = {
-
-    constructor: ParsleyFieldMultiple
-
-    /**
-    * Set some specific properties, call some extra methods to manage radio / checkbox
-    *
-    * @method init
-    * @param {Object} element
-    * @param {Object} options
-    */
-    , initMultiple: function ( element, options ) {
-      this.element = element;
-      this.$element = $( element );
-      this.group = options.group || false;
-      this.hash = this.getName();
-      this.siblings = this.group ? '[' + options.namespace + 'group="' + this.group + '"]' : 'input[name="' + this.$element.attr( 'name' ) + '"]';
-      this.isRadioOrCheckbox = true;
-      this.isRadio = this.$element.is( 'input[type=radio]' );
-      this.isCheckbox = this.$element.is( 'input[type=checkbox]' );
-      this.errorClassHandler = options.errors.classHandler( element, this.isRadioOrCheckbox ) || this.$element.parent();
-    }
-
-    /**
-    * Set specific constraints messages, do pseudo-heritance
-    *
-    * @private
-    * @method inherit
-    * @param {Object} element
-    * @param {Object} options
-    */
-    , inherit: function ( element, options ) {
-      var clone = new ParsleyField( element, options, 'ParsleyFieldMultiple' );
-
-      for ( var property in clone ) {
-        if ( 'undefined' === typeof this[ property ] ) {
-          this[ property ] = clone [ property ];
-        }
+  // https://github.com/LearnBoost/expect.js/blob/master/expect.js
+  var expect = {
+    eql: function ( actual, expected ) {
+      if ( actual === expected ) {
+        return true;
+      } else if ( 'undefined' !== typeof Buffer && Buffer.isBuffer( actual ) && Buffer.isBuffer( expected ) ) {
+        if ( actual.length !== expected.length ) return false;
+        for ( var i = 0; i < actual.length; i++ )
+          if ( actual[i] !== expected[i] ) return false;
+        return true;
+      } else if ( actual instanceof Date && expected instanceof Date ) {
+        return actual.getTime() === expected.getTime();
+      } else if ( typeof actual !== 'object' && typeof expected !== 'object' ) {
+        // loosy ==
+        return actual == expected;
+      } else {
+        return this.objEquiv(actual, expected);
       }
-    }
-
-    /**
-    * Set specific constraints messages, do pseudo-heritance
-    *
-    * @method getName
-    * @returns {String} radio / checkbox hash is cleaned 'name' or data-group property
-    */
-   , getName: function () {
-     if ( this.group ) {
-       return 'parsley-' + this.group;
-     }
-
-     if ( 'undefined' === typeof this.$element.attr( 'name' ) ) {
-       throw "A radio / checkbox input must have a parsley-group attribute or a name to be Parsley validated !";
-     }
-
-     return 'parsley-' + this.$element.attr( 'name' ).replace( /(:|\.|\[|\]|\$)/g, '' );
-   }
-
-   /**
-   * Special treatment for radio & checkboxes
-   * Returns checked radio or checkboxes values
-   *
-   * @method getVal
-   * @returns {String} val
-   */
-   , getVal: function () {
-      if ( this.isRadio ) {
-        return $( this.siblings + ':checked' ).val() || '';
+    },
+    isUndefinedOrNull: function ( value ) {
+      return value === null || typeof value === 'undefined';
+    },
+    isArguments: function ( object ) {
+      return Object.prototype.toString.call(object) == '[object Arguments]';
+    },
+    keys: function ( obj ) {
+      if ( Object.keys )
+        return Object.keys( obj );
+      var keys = [];
+      for ( var i in obj )
+        if ( Object.prototype.hasOwnProperty.call( obj, i ) )
+          keys.push(i);
+      return keys;
+    },
+    objEquiv: function ( a, b ) {
+      if ( this.isUndefinedOrNull( a ) || this.isUndefinedOrNull( b ) )
+        return false;
+      if ( a.prototype !== b.prototype ) return false;
+      if ( this.isArguments( a ) ) {
+        if ( !this.isArguments( b ) )
+          return false;
+        return eql( pSlice.call( a ) , pSlice.call( b ) );
       }
-
-      if ( this.isCheckbox ) {
-        var values = [];
-
-        $( this.siblings + ':checked' ).each( function () {
-          values.push( $( this ).val() );
-        } );
-
-        return values;
+      try {
+        var ka = this.keys( a ), kb = this.keys( b ), key, i;
+        if ( ka.length !== kb.length )
+          return false;
+        ka.sort();
+        kb.sort();
+        for ( i = ka.length - 1; i >= 0; i-- )
+          if ( ka[ i ] != kb[ i ] )
+            return false;
+        for ( i = ka.length - 1; i >= 0; i-- ) {
+          key = ka[i];
+          if ( !this.eql( a[ key ], b[ key ] ) )
+             return false;
+        }
+        return true;
+      } catch ( e ) {
+        return false;
       }
-   }
-
-   /**
-   * Bind validation events on a field
-   *
-   * @private
-   * @method bindValidationEvents
-   */
-   , bindValidationEvents: function () {
-     // this field has validation events, that means it has to be validated
-     this.valid = null;
-     this.$element.addClass( 'parsley-validated' );
-
-     // remove eventually already binded events
-     this.$element.off( '.' + this.type );
-
-      // always bind keyup event, for better UX when a field is invalid
-      var self = this
-        , triggers = ( !this.options.trigger ? '' : this.options.trigger )
-        + ( new RegExp( 'change', 'i' ).test( this.options.trigger ) ? '' : ' change' );
-
-      // trim triggers to bind them correctly with .on()
-      triggers = triggers.replace( /^\s+/g , '' ).replace( /\s+$/g ,'' );
-
-     // bind trigger event on every siblings
-     $( this.siblings ).each(function () {
-       $( this ).on( triggers.split( ' ' ).join( '.' + self.type + ' ' ) , false, $.proxy( self.eventValidation, self ) );
-     } )
-   }
+    }
   };
-
-  /**
-  * ParsleyForm class manage Parsley validated form.
-  * Manage its fields and global validation
-  *
-  * @class ParsleyForm
-  * @constructor
-  */
-  var ParsleyForm = function ( element, options, type ) {
-    this.init( element, options, type || 'parsleyForm' );
+  // AMD Compliance
+  if ( "function" === typeof define && define.amd ) {
+    define( 'validator', [],function() { return exports; } );
+  }
+} )( 'undefined' === typeof exports ? this[ 'undefined' !== typeof validatorjs_ns ? validatorjs_ns : 'Validator' ] = {} : exports );
+
+
+  var ParsleyValidator = function (validators, catalog) {
+    this.__class__ = 'ParsleyValidator';
+    this.Validator = Validator;
+    // Default Parsley locale is en
+    this.locale = 'en';
+    this.init(validators || {}, catalog || {});
   };
-
-  ParsleyForm.prototype = {
-
-    constructor: ParsleyForm
-
-    /* init data, bind jQuery on() actions */
-    , init: function ( element, options, type ) {
-      this.type = type;
-      this.items = [];
-      this.$element = $( element );
-      this.options = options;
-      var self = this;
-
-      this.$element.find( options.inputs ).each( function () {
-        self.addItem( this );
+  ParsleyValidator.prototype = {
+    init: function (validators, catalog) {
+      this.catalog = catalog;
+      for (var name in validators)
+        this.addValidator(name, validators[name].fn, validators[name].priority);
+      $.emit('parsley:validator:init');
+    },
+    // Set new messages locale if we have dictionary loaded in ParsleyConfig.i18n
+    setLocale: function (locale) {
+      if ('undefined' === typeof this.catalog[locale])
+        throw new Error(locale + ' is not available in the catalog');
+      this.locale = locale;
+      return this;
+    },
+    // Add a new messages catalog for a given locale. Set locale for this catalog if set === `true`
+    addCatalog: function (locale, messages, set) {
+      if ('object' === typeof messages)
+        this.catalog[locale] = messages;
+      if (true === set)
+        return this.setLocale(locale);
+      return this;
+    },
+    // Add a specific message for a given constraint in a given locale
+    addMessage: function (locale, name, message) {
+      if (undefined === typeof this.catalog[locale])
+        this.catalog[locale] = {};
+      this.catalog[locale][name.toLowerCase()] = message;
+      return this;
+    },
+    validate: function (value, constraints, priority) {
+      return new this.Validator.Validator().validate.apply(new Validator.Validator(), arguments);
+    },
+    // Add a new validator
+    addValidator: function (name, fn, priority) {
+      this.validators[name.toLowerCase()] = function (requirements) {
+        return $.extend(new Validator.Assert().Callback(fn, requirements), { priority: priority });
+      };
+      return this;
+    },
+    updateValidator: function (name, fn, priority) {
+      return addValidator(name, fn, priority);
+    },
+    removeValidator: function (name) {
+      delete this.validators[name];
+      return this;
+    },
+    getErrorMessage: function (constraint) {
+      var message;
+      // Type constraints are a bit different, we have to match their requirements too to find right error message
+      if ('type' === constraint.name)
+        message = this.catalog[this.locale][constraint.name][constraint.requirements];
+      else
+        message = this.formatMessage(this.catalog[this.locale][constraint.name], constraint.requirements);
+      return '' !== message ? message : this.catalog[this.locale].defaultMessage;
+    },
+    // Kind of light `sprintf()` implementation
+    formatMessage: function (string, parameters) {
+      if ('object' === typeof parameters) {
+        for (var i in parameters)
+          string = this.formatMessage(string, parameters[i]);
+        return string;
+      }
+      return 'string' === typeof string ? string.replace(new RegExp('%s', 'i'), parameters) : '';
+    },
+    // Here is the Parsley default validators list.
+    // This is basically Validatorjs validators, with different API for some of them
+    // and a Parsley priority set
+    validators: {
+      notblank: function () {
+        return $.extend(new Validator.Assert().NotBlank(), { priority: 2 });
+      },
+      required: function () {
+        return $.extend(new Validator.Assert().Required(), { priority: 512 });
+      },
+      type: function (type) {
+        var assert;
+        switch (type) {
+          case 'email':
+            assert = new Validator.Assert().Email();
+            break;
+          case 'number':
+            assert = new Validator.Assert().Regexp('^-?(?:\\d+|\\d{1,3}(?:,\\d{3})+)?(?:\\.\\d+)?$');
+            break;
+          case 'integer':
+            assert = new Validator.Assert().Regexp('^-?\\d+$');
+            break;
+          case 'digits':
+            assert = new Validator.Assert().Regexp('^\\d+$');
+            break;
+          case 'alphanum':
+            assert = new Validator.Assert().Regexp('^\\w+$', 'i');
+            break;
+          case 'url':
+            assert = new Validator.Assert().Regexp('(https?:\\/\\/)?(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{2,256}\\.[a-z]{2,4}\\b([-a-zA-Z0-9@:%_\\+.~#?&//=]*)', 'i');
+            break;
+          default:
+            throw new Error('validator type `' + type + '` is not supported');
+        }
+        return $.extend(assert, { priority: 256 });
+      },
+      pattern: function (regexp) {
+        var flags = '';
+        // Test if RegExp is literal, if not, nothing to be done, otherwise, we need to isolate flags and pattern
+        if (!!(/^\/.*\/(?:[gimy]*)$/.test(regexp))) {
+          // Replace the regexp literal string with the first match group: ([gimy]*)
+          // If no flag is present, this will be a blank string
+          flags = regexp.replace(/.*\/([gimy]*)$/, '$1');
+          // Again, replace the regexp literal string with the first match group:
+          // everything excluding the opening and closing slashes and the flags
+          regexp = regexp.replace(new RegExp('^/(.*?)/' + flags + '$'), '$1');
+        }
+        return $.extend(new Validator.Assert().Regexp(regexp, flags), { priority: 64 });
+      },
+      minlength: function (value) {
+        return $.extend(new Validator.Assert().Length({ min: value }), {
+          priority: 30,
+          requirementsTransformer: function () {
+            return 'string' === typeof value && !isNaN(value) ? parseInt(value, 10) : value;
+          }
+        });
+      },
+      maxlength: function (value) {
+        return $.extend(new Validator.Assert().Length({ max: value }), {
+        priority: 30,
+        requirementsTransformer: function () {
+            return 'string' === typeof value && !isNaN(value) ? parseInt(value, 10) : value;
+          }
       });
-
-      this.$element.on( 'submit.' + this.type , false, $.proxy( this.validate, this ) );
-    }
-
-    /**
-    * Add custom listeners
-    *
-    * @param {Object} { listener: function () {} }, eg { onFormValidate: function ( valid, event, focus ) { ... } }
-    */
-    , addListener: function ( object ) {
-      for ( var listener in object ) {
-        if ( new RegExp( 'Field' ).test( listener ) ) {
-          for ( var item = 0; item < this.items.length; item++ ) {
-            this.items[ item ].addListener( object );
+      },
+      length: function (array) {
+        return $.extend(new Validator.Assert().Length({ min: array[0], max: array[1] }), { priority: 32 });
+      },
+      mincheck: function (length) {
+        return this.minlength(length);
+      },
+      maxcheck: function (length) {
+        return this.maxlength(length);
+      },
+      check: function (array) {
+        return this.length(array);
+      },
+      min: function (value) {
+        return $.extend(new Validator.Assert().GreaterThanOrEqual(value), {
+          priority: 30,
+          requirementsTransformer: function () {
+            return 'string' === typeof value && !isNaN(value) ? parseInt(value, 10) : value;
           }
-        } else {
-          this.options.listeners[ listener ] = object[ listener ];
-        }
+        });
+      },
+      max: function (value) {
+        return $.extend(new Validator.Assert().LessThanOrEqual(value), {
+          priority: 30,
+          requirementsTransformer: function () {
+            return 'string' === typeof value && !isNaN(value) ? parseInt(value, 10) : value;
+          }
+        });
+      },
+      range: function (array) {
+        return $.extend(new Validator.Assert().Range(array[0], array[1]), {
+          priority: 32,
+          requirementsTransformer: function () {
+            for (var i = 0; i < array.length; i++)
+              array[i] = 'string' === typeof array[i] && !isNaN(array[i]) ? parseInt(array[i], 10) : array[i];
+            return array;
+          }
+        });
+      },
+      equalto: function (value) {
+        return $.extend(new Validator.Assert().EqualTo(value), {
+          priority: 256,
+          requirementsTransformer: function () {
+            return $(value).length ? $(value).val() : value;
+          }
+        });
       }
     }
+  };
 
-    /**
-    * Adds a new parsleyItem child to ParsleyForm
-    *
-    * @method addItem
-    * @param elem
-    */
-    , addItem: function ( elem ) {
-      var ParsleyField = $( elem ).parsley( this.options );
-      ParsleyField.setParent( this );
-
-      this.items.push( ParsleyField );
-    }
-
-    /**
-    * Removes a parsleyItem child from ParsleyForm
-    *
-    * @method removeItem
-    * @param elem
-    * @return {Boolean}
-    */
-    , removeItem: function ( elem ) {
-      var parsleyItem = $( elem ).parsley();
-
-      // identify & remove item if same Parsley hash
-      for ( var i = 0; i < this.items.length; i++ ) {
-        if ( this.items[ i ].hash === parsleyItem.hash ) {
-          this.items[ i ].destroy();
-          this.items.splice( i, 1 );
-          return true;
+  var ParsleyUI = function (options) {
+    this.__class__ = 'ParsleyUI';
+  };
+  ParsleyUI.prototype = {
+    listen: function () {
+      $.listen('parsley:form:init', this, this.setupForm);
+      $.listen('parsley:field:init', this, this.setupField);
+      $.listen('parsley:field:validated', this, this.reflow);
+      $.listen('parsley:form:validated', this, this.focus);
+      $.listen('parsley:field:reset', this, this.reset);
+      $.listen('parsley:form:destroy', this, this.destroy);
+      $.listen('parsley:field:destroy', this, this.destroy);
+      return this;
+    },
+    reflow: function (fieldInstance) {
+      // If this field has not an active UI (case for multiples) don't bother doing something
+      if ('undefined' === typeof fieldInstance._ui || false === fieldInstance._ui.active)
+        return;
+      // Diff between two validation results
+      var diff = this._diff(fieldInstance.validationResult, fieldInstance._ui.lastValidationResult);
+      // Then store current validation result for next reflow
+      fieldInstance._ui.lastValidationResult = fieldInstance.validationResult;
+      // Field have been validated at least once if here. Useful for binded key events..
+      fieldInstance._ui.validatedOnce = true;
+      // Handle valid / invalid / none field class
+      this.manageStatusClass(fieldInstance);
+      // Add, remove, updated errors messages
+      this.manageErrorsMessages(fieldInstance, diff);
+      // Triggers impl
+      this.actualizeTriggers(fieldInstance);
+      // If field is not valid for the first time, bind keyup trigger to ease UX and quickly inform user
+      if ((diff.kept.length || diff.added.length) && 'undefined' === typeof fieldInstance._ui.failedOnce)
+        this.manageFailingFieldTrigger(fieldInstance);
+    },
+    // Returns an array of field's error message(s)
+    getErrorsMessages: function (fieldInstance) {
+      // No error message, field is valid
+      if (true === fieldInstance.validationResult)
+        return [];
+      var messages = [];
+      for (var i = 0; i < fieldInstance.validationResult.length; i++)
+        messages.push(this._getErrorMessage(fieldInstance, fieldInstance.validationResult[i].assert));
+      return messages;
+    },
+    manageStatusClass: function (fieldInstance) {
+      if (true === fieldInstance.validationResult)
+        this._successClass(fieldInstance);
+      else if (fieldInstance.validationResult.length > 0)
+        this._errorClass(fieldInstance);
+      else
+        this._resetClass(fieldInstance);
+    },
+    manageErrorsMessages: function (fieldInstance, diff) {
+      if ('undefined' !== typeof fieldInstance.options.errorsMessagesDisabled)
+        return;
+      // Case where we have errorMessage option that configure an unique field error message, regardless failing validators
+      if ('undefined' !== typeof fieldInstance.options.errorMessage) {
+        if ((diff.added.length || diff.kept.length)) {
+          if (0 === fieldInstance._ui.$errorsWrapper.find('.parsley-custom-error-message').length)
+            fieldInstance._ui.$errorsWrapper
+              .append($(fieldInstance.options.errorTemplate)
+              .addClass('parsley-custom-error-message'));
+          return fieldInstance._ui.$errorsWrapper
+            .addClass('filled')
+            .find('.parsley-custom-error-message')
+            .html(fieldInstance.options.errorMessage);
         }
-      }
-
-      return false;
-    }
-
-    /**
-    * Process each form field validation
-    * Display errors, call custom onFormValidate() function
-    *
-    * @method validate
-    * @param {Object} event jQuery Event
-    * @return {Boolean} Is form valid or not
-    */
-    , validate: function ( event ) {
-      var valid = true;
-      this.focusedField = false;
-
-      for ( var item = 0; item < this.items.length; item++ ) {
-        if ( 'undefined' !== typeof this.items[ item ] && false === this.items[ item ].validate() ) {
-          valid = false;
-
-          if ( !this.focusedField && 'first' === this.options.focus || 'last' === this.options.focus ) {
-            this.focusedField = this.items[ item ].$element;
+        return fieldInstance._ui.$errorsWrapper
+          .removeClass('filled')
+          .find('.parsley-custom-error-message')
+          .remove();
+      }
+      // Show, hide, update failing constraints messages
+      for (var i = 0; i < diff.removed.length; i++)
+        this.removeError(fieldInstance, diff.removed[i].assert.name, true);
+      for (i = 0; i < diff.added.length; i++)
+        this.addError(fieldInstance, diff.added[i].assert.name, undefined, diff.added[i].assert, true);
+      for (i = 0; i < diff.kept.length; i++)
+        this.updateError(fieldInstance, diff.kept[i].assert.name, undefined, diff.kept[i].assert, true);
+    },
+    // TODO: strange API here, intuitive for manual usage with addError(pslyInstance, 'foo', 'bar')
+    // but a little bit complex for above internal usage, with forced undefined parametter..
+    addError: function (fieldInstance, name, message, assert, doNotUpdateClass) {
+      fieldInstance._ui.$errorsWrapper
+        .addClass('filled')
+        .append($(fieldInstance.options.errorTemplate)
+        .addClass('parsley-' + name)
+        .html(message || this._getErrorMessage(fieldInstance, assert)));
+      if (true !== doNotUpdateClass)
+        this._errorClass(fieldInstance);
+    },
+    // Same as above
+    updateError: function (fieldInstance, name, message, assert, doNotUpdateClass) {
+      fieldInstance._ui.$errorsWrapper
+        .addClass('filled')
+        .find('.parsley-' + name)
+        .html(message || this._getErrorMessage(fieldInstance, assert));
+      if (true !== doNotUpdateClass)
+        this._errorClass(fieldInstance);
+    },
+    // Same as above twice
+    removeError: function (fieldInstance, name, doNotUpdateClass) {
+      fieldInstance._ui.$errorsWrapper
+        .removeClass('filled')
+        .find('.parsley-' + name)
+        .remove();
+      // edge case possible here: remove a standard Parsley error that is still failing in fieldInstance.validationResult
+      // but highly improbable cuz' manually removing a well Parsley handled error makes no sense.
+      if (true !== doNotUpdateClass)
+        this.manageStatusClass(fieldInstance);
+    },
+    focus: function (formInstance) {
+      if (true === formInstance.validationResult || 'none' === formInstance.options.focus)
+        return formInstance._focusedField = null;
+      formInstance._focusedField = null;
+      for (var i = 0; i < formInstance.fields.length; i++)
+        if (true !== formInstance.fields[i].validationResult && formInstance.fields[i].validationResult.length > 0 && 'undefined' === typeof formInstance.fields[i].options.noFocus) {
+          if ('first' === formInstance.options.focus) {
+            formInstance._focusedField = formInstance.fields[i].$element;
+            return formInstance._focusedField.focus();
           }
+          formInstance._focusedField = formInstance.fields[i].$element;
         }
+      if (null === formInstance._focusedField)
+        return null;
+      return formInstance._focusedField.focus();
+    },
+    _getErrorMessage: function (fieldInstance, constraint) {
+      var customConstraintErrorMessage = constraint.name + 'Message';
+      if ('undefined' !== typeof fieldInstance.options[customConstraintErrorMessage])
+        return window.ParsleyValidator.formatMessage(fieldInstance.options[customConstraintErrorMessage], constraint.requirements);
+      return window.ParsleyValidator.getErrorMessage(constraint);
+    },
+    _diff: function (newResult, oldResult, deep) {
+      var
+        added = [],
+        kept = [];
+      for (var i = 0; i < newResult.length; i++) {
+        var found = false;
+        for (var j = 0; j < oldResult.length; j++)
+          if (newResult[i].assert.name === oldResult[j].assert.name) {
+            found = true;
+            break;
+          }
+        if (found)
+          kept.push(newResult[i]);
+        else
+          added.push(newResult[i]);
       }
+      return {
+        kept: kept,
+        added: added,
+        removed: !deep ? this._diff(oldResult, newResult, true).added : []
+      };
+    },
+    setupForm: function (formInstance) {
+      formInstance.$element.on('submit.Parsley', false, $.proxy(formInstance.onSubmitValidate, formInstance));
+      // UI could be disabled
+      if (false === formInstance.options.uiEnabled)
+        return;
+      formInstance.$element.attr('novalidate', '');
+    },
+    setupField: function (fieldInstance) {
+      var _ui = { active: false };
+      // UI could be disabled
+      if (false === fieldInstance.options.uiEnabled)
+        return;
+      _ui.active = true;
+      // Give field its Parsley id in DOM
+      fieldInstance.$element.attr(fieldInstance.options.namespace + 'id', fieldInstance.__id__);
+      /** Generate important UI elements and store them in fieldInstance **/
+      // $errorClassHandler is the $element that woul have parsley-error and parsley-success classes
+      _ui.$errorClassHandler = this._manageClassHandler(fieldInstance);
+      // $errorsWrapper is a div that would contain the various field errors, it will be appended into $errorsContainer
+      _ui.errorsWrapperId = 'parsley-id-' + ('undefined' !== typeof fieldInstance.options.multiple ? 'multiple-' + fieldInstance.options.multiple : fieldInstance.__id__);
+      _ui.$errorsWrapper = $(fieldInstance.options.errorsWrapper).attr('id', _ui.errorsWrapperId);
+      // ValidationResult UI storage to detect what have changed bwt two validations, and update DOM accordingly
+      _ui.lastValidationResult = [];
+      _ui.validatedOnce = false;
+      _ui.validationInformationVisible = false;
+      // Store it in fieldInstance for later
+      fieldInstance._ui = _ui;
+      /** Mess with DOM now **/
+      this._insertErrorWrapper(fieldInstance);
+      // Bind triggers first time
+      this.actualizeTriggers(fieldInstance);
+    },
+    // Determine which element will have `parsley-error` and `parsley-success` classes
+    _manageClassHandler: function (fieldInstance) {
+      // An element selector could be passed through DOM with `data-parsley-class-handler=#foo`
+      if ('string' === typeof fieldInstance.options.classHandler && $(fieldInstance.options.classHandler).length)
+        return $(fieldInstance.options.classHandler);
+      // Class handled could also be determined by function given in Parsley options
+      var $handler = fieldInstance.options.classHandler(fieldInstance);
+      // If this function returned a valid existing DOM element, go for it
+      if ('undefined' !== typeof $handler && $handler.length)
+        return $handler;
+      // Otherwise, if simple element (input, texatrea, select..) it will perfectly host the classes
+      if ('undefined' === typeof fieldInstance.options.multiple || fieldInstance.$element.is('select'))
+        return fieldInstance.$element;
+      // But if multiple element (radio, checkbox), that would be their parent
+      return fieldInstance.$element.parent();
+    },
+    _insertErrorWrapper: function (fieldInstance) {
+      var $errorsContainer;
+      if ('string' === typeof fieldInstance.options.errorsContainer )
+        if ($(fieldInstance.options.errorsContainer + '').length)
+          return $(fieldInstance.options.errorsContainer).append(fieldInstance._ui.$errorsWrapper);
+        else if (window.console && window.console.warn)
+          window.console.warn('The errors container `' + fieldInstance.options.errorsContainer + '` does not exist in DOM');
+
+      if ('function' === typeof fieldInstance.options.errorsContainer)
+        $errorsContainer = fieldInstance.options.errorsContainer(fieldInstance);
+      if ('undefined' !== typeof $errorsContainer && $errorsContainer.length)
+        return $errorsContainer.append(fieldInstance._ui.$errorsWrapper);
+      return 'undefined' === typeof fieldInstance.options.multiple ? fieldInstance.$element.after(fieldInstance._ui.$errorsWrapper) : fieldInstance.$element.parent().after(fieldInstance._ui.$errorsWrapper);
+    },
+    actualizeTriggers: function (fieldInstance) {
+      var that = this;
+      // Remove Parsley events already binded on this field
+      if (fieldInstance.options.multiple)
+        $('[' + fieldInstance.options.namespace + 'multiple="' + fieldInstance.options.multiple + '"]').each(function () {
+          $(this).off('.Parsley');
+        });
+      else
+        fieldInstance.$element.off('.Parsley');
+      // If no trigger is set, all good
+      if (false === fieldInstance.options.trigger)
+        return;
+      var triggers = fieldInstance.options.trigger.replace(/^\s+/g , '').replace(/\s+$/g , '');
+      if ('' === triggers)
+        return;
+      // Bind fieldInstance.eventValidate if exists (for parsley.ajax for example), ParsleyUI.eventValidate otherwise
+      if (fieldInstance.options.multiple)
+        $('[' + fieldInstance.options.namespace + 'multiple="' + fieldInstance.options.multiple + '"]').each(function () {
+          $(this).on(
+            triggers.split(' ').join('.Parsley ') + '.Parsley',
+            false,
+            $.proxy('function' === typeof fieldInstance.eventValidate ? fieldInstance.eventValidate : that.eventValidate, fieldInstance));
+        });
+      else
+        fieldInstance.$element
+          .on(
+            triggers.split(' ').join('.Parsley ') + '.Parsley',
+            false,
+            $.proxy('function' === typeof fieldInstance.eventValidate ? fieldInstance.eventValidate : this.eventValidate, fieldInstance));
+    },
+    // Called through $.proxy with fieldInstance. `this` context is ParsleyField
+    eventValidate: function(event) {
+      // For keyup, keypress, keydown.. events that could be a little bit obstrusive
+      // do not validate if val length < min threshold on first validation. Once field have been validated once and info
+      // about success or failure have been displayed, always validate with this trigger to reflect every yalidation change.
+      if (new RegExp('key').test(event.type))
+        if (!this._ui.validationInformationVisible && this.getValue().length <= this.options.validationThreshold)
+          return;
+      this._ui.validatedOnce = true;
+      this.validate();
+    },
+    manageFailingFieldTrigger: function (fieldInstance) {
+      fieldInstance._ui.failedOnce = true;
+      // Radio and checkboxes fields must bind every field multiple
+      if (fieldInstance.options.multiple)
+        $('[' + fieldInstance.options.namespace + 'multiple="' + fieldInstance.options.multiple + '"]').each(function () {
+          if (!new RegExp('change', 'i').test($(this).parsley().options.trigger || ''))
+            return $(this).on('change.ParsleyFailedOnce', false, $.proxy(fieldInstance.validate, fieldInstance));
+        });
+      // Select case
+      if (fieldInstance.$element.is('select'))
+        if (!new RegExp('change', 'i').test(fieldInstance.options.trigger || ''))
+          return fieldInstance.$element.on('change.ParsleyFailedOnce', false, $.proxy(fieldInstance.validate, fieldInstance));
+      // All other inputs fields
+      if (!new RegExp('keyup', 'i').test(fieldInstance.options.trigger || ''))
+        return fieldInstance.$element.on('keyup.ParsleyFailedOnce', false, $.proxy(fieldInstance.validate, fieldInstance));
+    },
+    reset: function (parsleyInstance) {
+      // Reset all event listeners
+      parsleyInstance.$element.off('.Parsley');
+      parsleyInstance.$element.off('.ParsleyFailedOnce');
+      // Nothing to do if UI never initialized for this field
+      if ('undefined' === typeof parsleyInstance._ui)
+        return;
+      if ('ParsleyForm' === parsleyInstance.__class__)
+        return;
+      // Reset all errors' li
+      parsleyInstance._ui.$errorsWrapper.children().each(function () {
+        $(this).remove();
+      });
+      // Reset validation class
+      this._resetClass(parsleyInstance);
+      // Reset validation flags and last validation result
+      parsleyInstance._ui.validatedOnce = false;
+      parsleyInstance._ui.lastValidationResult = [];
+      parsleyInstance._ui.validationInformationVisible = false;
+    },
+    destroy: function (parsleyInstance) {
+      this.reset(parsleyInstance);
+      if ('ParsleyForm' === parsleyInstance.__class__)
+        return;
+      parsleyInstance._ui.$errorsWrapper.remove();
+      delete parsleyInstance._ui;
+    },
+    _successClass: function (fieldInstance) {
+      fieldInstance._ui.validationInformationVisible = true;
+      fieldInstance._ui.$errorClassHandler.removeClass(fieldInstance.options.errorClass).addClass(fieldInstance.options.successClass);
+    },
+    _errorClass: function (fieldInstance) {
+      fieldInstance._ui.validationInformationVisible = true;
+      fieldInstance._ui.$errorClassHandler.removeClass(fieldInstance.options.successClass).addClass(fieldInstance.options.errorClass);
+    },
+    _resetClass: function (fieldInstance) {
+      fieldInstance._ui.$errorClassHandler.removeClass(fieldInstance.options.successClass).removeClass(fieldInstance.options.errorClass);
+    }
+  };
 
-      // form is invalid, focus an error field depending on focus policy
-      if ( this.focusedField && !valid ) {
-        // Scroll smoothly
-        if ( this.options.scrollDuration > 0 ) {
-          var that = this,
-              top = this.focusedField.offset().top - $( window ).height() / 2; // Center the window on the field
-
-          $( 'html, body' ).animate( {
-              scrollTop: top
-            },
-            this.options.scrollDuration,
-            function () {
-              that.focusedField.focus();
-            }
-          );
-        // Just focus on the field and let the browser do the rest
-        } else {
-          this.focusedField.focus();
-        }
-      }
-
-      // if onFormValidate returns (bool) false, form won't be submitted, even if valid
-      var onFormValidate = this.options.listeners.onFormValidate( valid, event, this );
-      if ('undefined' !== typeof onFormValidate) {
-        return onFormValidate;
+  var ParsleyOptionsFactory = function (defaultOptions, globalOptions, userOptions, namespace) {
+    this.__class__ = 'OptionsFactory';
+    this.__id__ = ParsleyUtils.hash(4);
+    this.formOptions = null;
+    this.fieldOptions = null;
+    this.staticOptions = $.extend(true, {}, defaultOptions, globalOptions, userOptions, { namespace: namespace });
+  };
+  ParsleyOptionsFactory.prototype = {
+    get: function (parsleyInstance) {
+      if ('undefined' === typeof parsleyInstance.__class__)
+        throw new Error('Parsley Instance expected');
+      switch (parsleyInstance.__class__) {
+        case 'Parsley':
+          return this.staticOptions;
+        case 'ParsleyForm':
+          return this.getFormOptions(parsleyInstance);
+        case 'ParsleyField':
+        case 'ParsleyFieldMultiple':
+          return this.getFieldOptions(parsleyInstance);
+        default:
+          throw new Error('Instance ' + parsleyInstance.__class__ + ' is not supported');
       }
-
-      return valid;
+    },
+    getFormOptions: function (formInstance) {
+      this.formOptions = ParsleyUtils.attr(formInstance.$element, this.staticOptions.namespace);
+      // not deep extend, since formOptions is a 1 level deep object
+      return $.extend({}, this.staticOptions, this.formOptions);
+    },
+    getFieldOptions: function (fieldInstance) {
+      this.fieldOptions = ParsleyUtils.attr(fieldInstance.$element, this.staticOptions.namespace);
+      if (null === this.formOptions && 'undefined' !== typeof fieldInstance.parent)
+        this.formOptions = this.getFormOptions(fieldInstance.parent);
+      // not deep extend, since formOptions and fieldOptions is a 1 level deep object
+      return $.extend({}, this.staticOptions, this.formOptions, this.fieldOptions);
     }
+  };
 
-    , isValid: function () {
-      for ( var item = 0; item < this.items.length; item++ ) {
-        if ( false === this.items[ item ].isValid() ) {
+  var ParsleyForm = function (element, OptionsFactory) {
+    this.__class__ = 'ParsleyForm';
+    this.__id__ = ParsleyUtils.hash(4);
+    if ('OptionsFactory' !== ParsleyUtils.get(OptionsFactory, '__class__'))
+      throw new Error('You must give an OptionsFactory instance');
+    this.OptionsFactory = OptionsFactory;
+    this.$element = $(element);
+    this.validationResult = null;
+    this.options = this.OptionsFactory.get(this);
+  };
+  ParsleyForm.prototype = {
+    onSubmitValidate: function (event) {
+      this.validate(undefined, undefined, event);
+      // prevent form submission if validation fails
+      if (false === this.validationResult && event instanceof $.Event) {
+        event.stopImmediatePropagation();
+        event.preventDefault();
+      }
+      return this;
+    },
+    // @returns boolean
+    validate: function (group, force, event) {
+      this.submitEvent = event;
+      this.validationResult = true;
+      var fieldValidationResult = [];
+      // Refresh form DOM options and form's fields that could have changed
+      this._refreshFields();
+      $.emit('parsley:form:validate', this);
+      // loop through fields to validate them one by one
+      for (var i = 0; i < this.fields.length; i++) {
+        // do not validate a field if not the same as given validation group
+        if (group && group !== this.fields[i].options.group)
+          continue;
+        fieldValidationResult = this.fields[i].validate(force);
+        if (true !== fieldValidationResult && fieldValidationResult.length > 0 && this.validationResult)
+          this.validationResult = false;
+      }
+      $.emit('parsley:form:validated', this);
+      return this.validationResult;
+    },
+    // Iterate over refreshed fields, and stop on first failure
+    isValid: function (group, force) {
+      this._refreshFields();
+      for (var i = 0; i < this.fields.length; i++) {
+        // do not validate a field if not the same as given validation group
+        if (group && group !== this.fields[i].options.group)
+          continue;
+        if (false === this.fields[i].isValid(force))
           return false;
-        }
       }
-
       return true;
+    },
+    _refreshFields: function () {
+      return this.actualizeOptions()._bindFields();
+    },
+    _bindFields: function () {
+      var self = this;
+      this.fields = [];
+      this.fieldsMappedById = {};
+      this.$element.find(this.options.inputs).each(function () {
+        var fieldInstance = new window.Parsley(this, {}, self);
+        // Only add valid and not excluded `ParsleyField` and `ParsleyFieldMultiple` children
+        if (('ParsleyField' === fieldInstance.__class__ || 'ParsleyFieldMultiple' === fieldInstance.__class__) && !fieldInstance.$element.is(fieldInstance.options.excluded))
+          if ('undefined' === typeof self.fieldsMappedById[fieldInstance.__class__ + '-' + fieldInstance.__id__]) {
+            self.fieldsMappedById[fieldInstance.__class__ + '-' + fieldInstance.__id__] = fieldInstance;
+            self.fields.push(fieldInstance);
+          }
+      });
+      return this;
     }
+  };
 
-    /**
-    * Remove all errors ul under invalid fields
-    *
-    * @method removeErrors
-    */
-    , removeErrors: function () {
-      for ( var item = 0; item < this.items.length; item++ ) {
-        this.items[ item ].parsley( 'reset' );
-      }
-    }
-
-    /**
-    * destroy Parsley binded on the form and its fields
-    *
-    * @method destroy
-    */
-    , destroy: function () {
-      for ( var item = 0; item < this.items.length; item++ ) {
-        this.items[ item ].destroy();
-      }
+  var ConstraintFactory = function (parsleyField, name, requirements, priority, isDomConstraint) {
+    if (!new RegExp('ParsleyField').test(ParsleyUtils.get(parsleyField, '__class__')))
+      throw new Error('ParsleyField or ParsleyFieldMultiple instance expected');
+    if ('function' !== typeof window.ParsleyValidator.validators[name] &&
+      'Assert' !== window.ParsleyValidator.validators[name](requirements).__parentClass__)
+      throw new Error('Valid validator expected');
+    var getPriority = function (parsleyField, name) {
+      if ('undefined' !== typeof parsleyField.options[name + 'Priority'])
+        return parsleyField.options[name + 'Priority'];
+      return ParsleyUtils.get(window.ParsleyValidator.validators[name](requirements), 'priority') || 2;
+    };
+    priority = priority || getPriority(parsleyField, name);
+    // If validator have a requirementsTransformer, execute it
+    if ('function' === typeof window.ParsleyValidator.validators[name](requirements).requirementsTransformer)
+      requirements = window.ParsleyValidator.validators[name](requirements).requirementsTransformer();
+    return $.extend(window.ParsleyValidator.validators[name](requirements), {
+      name: name,
+      requirements: requirements,
+      priority: priority,
+      groups: [priority],
+      isDomConstraint: isDomConstraint || ParsleyUtils.attr(parsleyField.$element, parsleyField.options.namespace, name)
+    });
+  };
 
-      this.$element.off( '.' + this.type ).removeData( this.type );
+  var ParsleyField = function (field, OptionsFactory, parsleyFormInstance) {
+    this.__class__ = 'ParsleyField';
+    this.__id__ = ParsleyUtils.hash(4);
+    this.$element = $(field);
+    // If we have a parent `ParsleyForm` instance given, use its `OptionsFactory`, and save parent
+    if ('undefined' !== typeof parsleyFormInstance) {
+      this.parent = parsleyFormInstance;
+      this.OptionsFactory = this.parent.OptionsFactory;
+      this.options = this.OptionsFactory.get(this);
+    // Else, take the `Parsley` one
+    } else {
+      this.OptionsFactory = OptionsFactory;
+      this.options = this.OptionsFactory.get(this);
     }
-
+    // Initialize some properties
+    this.constraints = [];
+    this.constraintsByName = {};
+    this.validationResult = [];
+    // Bind constraints
+    this._bindConstraints();
+  };
+  ParsleyField.prototype = {
+    // # Public API
+    // Validate field and $.emit some events for mainly `ParsleyUI`
+    // @returns validationResult:
+    //  - `true` if all constraint passes
+    //  - `[]` if not required field and empty (not validated)
+    //  - `[Violation, [Violation..]]` if there were validation errors
+    validate: function (force) {
+      this.value = this.getValue();
+      // Field Validate event. `this.value` could be altered for custom needs
+      $.emit('parsley:field:validate', this);
+      $.emit('parsley:field:' + (this.isValid(force, this.value) ? 'success' : 'error'), this);
+      // Field validated event. `this.validationResult` could be altered for custom needs too
+      $.emit('parsley:field:validated', this);
+      return this.validationResult;
+    },
+    // Just validate field. Do not trigger any event
+    // Same @return as `validate()`
+    isValid: function (force, value) {
+      // Recompute options and rebind constraints to have latest changes
+      this.refreshConstraints();
+      // Sort priorities to validate more important first
+      var priorities = this._getConstraintsSortedPriorities();
+      // Value could be passed as argument, needed to add more power to 'parsley:field:validate'
+      value = value || this.getValue();
+      // If a field is empty and not required, leave it alone, it's just fine
+      // Except if `data-parsley-validate-if-empty` explicitely added, useful for some custom validators
+      if (0 === value.length && !this._isRequired() && 'undefined' === typeof this.options.validateIfEmpty && true !== force)
+        return this.validationResult = [];
+      // If we want to validate field against all constraints, just call Validator and let it do the job
+      if (false === this.options.priorityEnabled)
+        return true === (this.validationResult = this.validateThroughValidator(value, this.constraints, 'Any'));
+      // Else, iterate over priorities one by one, and validate related asserts one by one
+      for (var i = 0; i < priorities.length; i++)
+        if (true !== (this.validationResult = this.validateThroughValidator(value, this.constraints, priorities[i])))
+          return false;
+      return true;
+    },
+    // @returns Parsley field computed value that could be overrided or configured in DOM
+    getValue: function () {
+      var value;
+      // Value could be overriden in DOM
+      if ('undefined' !== typeof this.options.value)
+        value = this.options.value;
+      else
+        value = this.$element.val();
+      // Handle wrong DOM or configurations
+      if ('undefined' === typeof value || null === value)
+        return '';
+      // Use `data-parsley-trim-value="true"` to auto trim inputs entry
+      if (true === this.options.trimValue)
+        return value.replace(/^\s+|\s+$/g, '');
+      return value;
+    },
+    // Actualize options that could have change since previous validation
+    // Re-bind accordingly constraints (could be some new, removed or updated)
+    refreshConstraints: function () {
+      return this.actualizeOptions()._bindConstraints();
+    },
     /**
-    * reset Parsley binded on the form and its fields
+    * Add a new constraint to a field
     *
-    * @method reset
+    * @method addConstraint
+    * @param {String}   name
+    * @param {Mixed}    requirements      optional
+    * @param {Number}   priority          optional
+    * @param {Boolean}  isDomConstraint   optional
     */
-    , reset: function () {
-      for ( var item = 0; item < this.items.length; item++ ) {
-        this.items[ item ].UI.reset();
+    addConstraint: function (name, requirements, priority, isDomConstraint) {
+      name = name.toLowerCase();
+      if ('function' === typeof window.ParsleyValidator.validators[name]) {
+        var constraint = new ConstraintFactory(this, name, requirements, priority, isDomConstraint);
+        // if constraint already exist, delete it and push new version
+        if ('undefined' !== this.constraintsByName[constraint.name])
+          this.removeConstraint(constraint.name);
+        this.constraints.push(constraint);
+        this.constraintsByName[constraint.name] = constraint;
       }
+      return this;
+    },
+    // Remove a constraint
+    removeConstraint: function (name) {
+      for (var i = 0; i < this.constraints.length; i++)
+        if (name === this.constraints[i].name) {
+          this.constraints.splice(i, 1);
+          break;
+        }
+      return this;
+    },
+    // Update a constraint (Remove + re-add)
+    updateConstraint: function (name, parameters, priority) {
+      return this.removeConstraint(name)
+        .addConstraint(name, parameters, priority);
+    },
+    // # Internals
+    // Internal only.
+    // Bind constraints from config + options + DOM
+    _bindConstraints: function () {
+      var constraints = [];
+      // clean all existing DOM constraints to only keep javascript user constraints
+      for (var i = 0; i < this.constraints.length; i++)
+        if (false === this.constraints[i].isDomConstraint)
+          constraints.push(this.constraints[i]);
+      this.constraints = constraints;
+      // then re-add Parsley DOM-API constraints
+      for (var name in this.options)
+        this.addConstraint(name, this.options[name]);
+      // finally, bind special HTML5 constraints
+      return this._bindHtml5Constraints();
+    },
+    // Internal only.
+    // Bind specific HTML5 constraints to be HTML5 compliant
+    _bindHtml5Constraints: function () {
+      // html5 required
+      if (this.$element.hasClass('required') || this.$element.attr('required'))
+        this.addConstraint('required', true, undefined, true);
+      // html5 pattern
+      if ('string' === typeof this.$element.attr('pattern'))
+        this.addConstraint('pattern', this.$element.attr('pattern'), undefined, true);
+      // range
+      if ('undefined' !== typeof this.$element.attr('min') && 'undefined' !== typeof this.$element.attr('max'))
+        this.addConstraint('range', [this.$element.attr('min'), this.$element.attr('max')], undefined, true);
+      // HTML5 min
+      else if ('undefined' !== typeof this.$element.attr('min'))
+        this.addConstraint('min', this.$element.attr('min'), undefined, true);
+      // HTML5 max
+      else if ('undefined' !== typeof this.$element.attr('max'))
+        this.addConstraint('max', this.$element.attr('max'), undefined, true);
+      // html5 types
+      var type = this.$element.attr('type');
+      if ('undefined' === typeof type)
+        return this;
+      // Small special case here for HTML5 number, that is in fact an integer validator
+      if ('number' === type)
+        return this.addConstraint('type', 'integer', undefined, true);
+      // Regular other HTML5 supported types
+      else if (new RegExp(type, 'i').test('email url range'))
+        return this.addConstraint('type', type, undefined, true);
+      return this;
+    },
+    // Internal only.
+    // Field is required if have required constraint without `false` value
+    _isRequired: function () {
+      if ('undefined' === typeof this.constraintsByName.required)
+        return false;
+      return false !== this.constraintsByName.required.requirements;
+    },
+    // Internal only.
+    // Sort constraints by priority DESC
+    _getConstraintsSortedPriorities: function () {
+      var priorities = [];
+      // Create array unique of priorities
+      for (var i = 0; i < this.constraints.length; i++)
+        if (-1 === priorities.indexOf(this.constraints[i].priority))
+          priorities.push(this.constraints[i].priority);
+      // Sort them by priority DESC
+      priorities.sort(function (a, b) { return b - a; });
+      return priorities;
     }
   };
 
-  /**
-  * Parsley plugin definition
-  * Provides an interface to access public Validator, ParsleyForm and ParsleyField functions
-  *
-  * @class Parsley
-  * @constructor
-  * @param {Mixed} Options. {Object} to configure Parsley or {String} method name to call a public class method
-  * @param {Function} Callback function
-  * @return {Mixed} public class method return
-  */
-  $.fn.parsley = function ( option, fn ) {
-    var namespace = { namespace: $( this ).data( 'parsleyNamespace' ) ? $( this ).data( 'parsleyNamespace' ) : ( 'undefined' !== typeof option && 'undefined' !== typeof option.namespace ? option.namespace : $.fn.parsley.defaults.namespace ) }
-      , options = $.extend( true, {}, $.fn.parsley.defaults, 'undefined' !== typeof window.ParsleyConfig ? window.ParsleyConfig : {}, option, this.domApi( namespace.namespace ) )
-      , newInstance = null
-      , args = Array.prototype.slice.call(arguments, 1);
-
-    function bind ( self, type ) {
-      var parsleyInstance = $( self ).data( type );
-
-      // if data never binded or we want to clone a build (for radio & checkboxes), bind it right now!
-      if ( !parsleyInstance ) {
-        switch ( type ) {
-          case 'parsleyForm':
-            parsleyInstance = new ParsleyForm( self, options, 'parsleyForm' );
-            break;
-          case 'parsleyField':
-            parsleyInstance = new ParsleyField( self, options, 'parsleyField' );
-            break;
-          case 'parsleyFieldMultiple':
-            parsleyInstance = new ParsleyFieldMultiple( self, options, 'parsleyFieldMultiple' );
-            break;
-          default:
-            return;
-        }
-
-        $( self ).data( type, parsleyInstance );
+  var ParsleyMultiple = function () {
+    this.__class__ = 'ParsleyFieldMultiple';
+  };
+  ParsleyMultiple.prototype = {
+    // Add new `$element` sibling for multiple field
+    addElement: function ($element) {
+      this.$elements.push($element);
+      return this;
+    },
+    // See `ParsleyField.refreshConstraints()`
+    refreshConstraints: function () {
+      var fieldConstraints;
+      this.constraints = [];
+      // Select multiple special treatment
+      if (this.$element.is('select')) {
+        this.actualizeOptions()._bindConstraints();
+        return this;
       }
-
-      // here is our parsley public function accessor
-      if ( 'string' === typeof option && 'function' === typeof parsleyInstance[ option ] ) {
-        var response = parsleyInstance[ option ].apply( parsleyInstance, args );
-
-        return 'undefined' !== typeof response ? response : $( self );
+      // Gather all constraints for each input in the multiple group
+      for (var i = 0; i < this.$elements.length; i++) {
+        fieldConstraints = this.$elements[i].data('ParsleyFieldMultiple').refreshConstraints().constraints;
+        for (var j = 0; j < fieldConstraints.length; j++)
+          this.addConstraint(fieldConstraints[j].name, fieldConstraints[j].requirements, fieldConstraints[j].priority, fieldConstraints[j].isDomConstraint);
       }
-
-      return parsleyInstance;
-    }
-
-    // if a form elem is given, bind all its input children
-    if ( $( this ).is( 'form' ) || 'undefined' !== typeof $( this ).domApi( namespace.namespace )[ 'bind' ] ) {
-      newInstance = bind ( $( this ), 'parsleyForm' );
-
-    // if it is a Parsley supported single element, bind it too, except inputs type hidden
-    // add here a return instance, cuz' we could call public methods on single elems with data[ option ]() above
-    } else if ( $( this ).is( options.inputs ) ) {
-      newInstance = bind( $( this ), !$( this ).is( 'input[type=radio], input[type=checkbox]' ) ? 'parsleyField' : 'parsleyFieldMultiple' );
+      return this;
+    },
+    // See `ParsleyField.getValue()`
+    getValue: function () {
+      // Value could be overriden in DOM
+      if ('undefined' !== typeof this.options.value)
+        return this.options.value;
+      // Radio input case
+      if (this.$element.is('input[type=radio]'))
+        return $('[' + this.options.namespace + 'multiple="' + this.options.multiple + '"]:checked').val() || '';
+      // checkbox input case
+      if (this.$element.is('input[type=checkbox]')) {
+        var values = [];
+        $('[' + this.options.namespace + 'multiple="' + this.options.multiple + '"]:checked').each(function () {
+          values.push($(this).val());
+        });
+        return values.length ? values : [];
+      }
+      // Select multiple case
+      if (this.$element.is('select') && null === this.$element.val())
+        return [];
+      // Default case that should never happen
+      return this.$element.val();
+    },
+    _init: function (multiple) {
+      this.$elements = [this.$element];
+      this.options.multiple = multiple;
+      return this;
     }
-
-    return 'function' === typeof fn ? fn() : newInstance;
   };
 
-  /* PARSLEY auto-binding
-  * =================================================== */
-  $( window ).on( 'load', function () {
-    $( '[parsley-validate], [data-parsley-validate]' ).each( function () {
-      $( this ).parsley();
-    } );
-  } );
-
-  /* PARSLEY DOM API
-  * =================================================== */
-  $.fn.domApi = function ( namespace ) {
-    var attribute,
-      obj = {}
-      , regex = new RegExp("^" + namespace, 'i');
-
-    if ( 'undefined' === typeof this[ 0 ] ) {
-      return {};
-    }
-
-    for ( var i in this[ 0 ].attributes ) {
-      attribute = this[ 0 ].attributes[ i ];
-
-      if ( 'undefined' !== typeof attribute && null !== attribute && attribute.specified && regex.test( attribute.name ) ) {
-        obj[ camelize( attribute.name.replace( namespace, '' ) ) ] = deserializeValue( attribute.value );
-      }
-    }
-
-    return obj;
+  var
+    o = $({}),
+    subscribed = {};
+  // $.listen(name, callback);
+  // $.listen(name, context, callback);
+  $.listen = function (name) {
+    if ('undefined' === typeof subscribed[name])
+      subscribed[name] = [];
+    if ('function' === typeof arguments[1])
+      return subscribed[name].push({ fn: arguments[1] });
+    if ('object' === typeof arguments[1] && 'function' === typeof arguments[2])
+      return subscribed[name].push({ fn: arguments[2], ctxt: arguments[1] });
+    throw new Error('Wrong parameters');
   };
-
-  // Zepto deserializeValue function
-  // "true"  => true
-  // "false" => false
-  // "null"  => null
-  // "42"    => 42
-  // "42.5"  => 42.5
-  // JSON    => parse if valid
-  // String  => self
-  var deserializeValue = function( value ) {
-    var num
-    try {
-      return value ?
-        value == "true" ||
-        ( value == "false" ? false :
-          value == "null" ? null :
-          !isNaN( num = Number( value ) ) ? num :
-          /^[\[\{]/.test( value ) ? $.parseJSON( value ) :
-          value )
-        : value;
-    } catch ( e ) {
-      return value;
-    }
+  $.listenTo = function (instance, name, fn) {
+    if ('undefined' === typeof subscribed[name])
+      subscribed[name] = [];
+    if (!(instance instanceof ParsleyField) && !(instance instanceof ParsleyForm))
+      throw new Error('Must give Parsley instance');
+    if ('string' !== typeof name || 'function' !== typeof fn)
+      throw new Error('Wrong parameters');
+    subscribed[name].push({ instance: instance, fn: fn });
   };
-
-  // Zepto camelize function
-  var camelize = function ( str ) {
-    return str.replace( /-+(.)?/g, function ( match, chr ) {
-      return chr ? chr.toUpperCase() : '';
-    } )
+  $.unsubscribe = function (name, fn) {
+    if ('undefined' === typeof subscribed[name])
+      return;
+    if ('string' !== typeof name || 'function' !== typeof fn)
+      throw new Error('Wrong arguments');
+    for (var i = 0; i < subscribed[name].length; i++)
+      if (subscribed[name][i].fn === fn)
+        return subscribed[name].splice(i, 1);
   };
-
-  // Zepto dasherize function
-  var dasherize = function ( str ) {
-    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()
+  $.unsubscribeTo = function (instance, name) {
+    if ('undefined' === typeof subscribed[name])
+      return;
+    if (!(instance instanceof ParsleyField) && !(instance instanceof ParsleyForm))
+      throw new Error('Must give Parsley instance');
+    for (var i = 0; i < subscribed[name].length; i++)
+      if ('undefined' !== typeof subscribed[name][i].instance && subscribed[name][i].instance.__id__ === instance.__id__)
+        return subscribed[name].splice(i, 1);
   };
-
-  /**
-  * Parsley plugin configuration
-  *
-  * @property $.fn.parsley.defaults
-  * @type {Object}
-  */
-  $.fn.parsley.defaults = {
-    // basic data-api overridable properties here..
-    namespace: 'parsley-'                       // DOM-API, default 'parsley-'. W3C valid would be 'data-parsley-' but quite ugly
-    , inputs: 'input, textarea, select'         // Default supported inputs.
-    , excluded: 'input[type=hidden], input[type=file], :disabled' // Do not validate input[type=hidden] & :disabled.
-    , priorityEnabled: true                     // Will display only one error at the time depending on validators priorities
-    , trigger: false                            // $.Event() that will trigger validation. eg: keyup, change..
-    , animate: true                             // fade in / fade out error messages
-    , animateDuration: 300                      // fadein/fadout ms time
-    , scrollDuration: 500                       // Duration in ms time of the window scroll when focusing on invalid field (0 = no scroll)
-    , focus: 'first'                            // 'fist'|'last'|'none' which error field would have focus first on form validation
-    , validationMinlength: 3                    // If trigger validation specified, only if value.length > validationMinlength
-    , successClass: 'parsley-success'           // Class name on each valid input
-    , errorClass: 'parsley-error'               // Class name on each invalid input
-    , errorMessage: false                       // Customize an unique error message showed if one constraint fails
-    , validators: {}                            // Add your custom validators functions
-    , showErrors: true                          // Set to false if you don't want Parsley to display error messages
-    , useHtml5Constraints: true                 // Set to false if you don't want Parsley to use html5 constraints
-    , messages: {}                              // Add your own error messages here
-
-    //some quite advanced configuration here..
-    , validateIfUnchanged: false                                          // false: validate once by field value change
-    , errors: {
-        classHandler: function ( elem, isRadioOrCheckbox ) {}             // specify where parsley error-success classes are set
-      , container: function ( elem, isRadioOrCheckbox ) {}                // specify an elem where errors will be **apened**
-      , errorsWrapper: '<ul></ul>'                                        // do not set an id for this elem, it would have an auto-generated id
-      , errorElem: '<li></li>'                                            // each field constraint fail in an li
+  $.unsubscribeAll = function (name) {
+    if ('undefined' === typeof subscribed[name])
+      return;
+    delete subscribed[name];
+  };
+  // $.emit(name [, arguments...]);
+  // $.emit(name, instance [, arguments..]);
+  $.emit = function (name, instance) {
+    if ('undefined' === typeof subscribed[name])
+      return;
+    // loop through registered callbacks for this event
+    for (var i = 0; i < subscribed[name].length; i++) {
+      // if instance is not registered, simple emit
+      if ('undefined' === typeof subscribed[name][i].instance) {
+        subscribed[name][i].fn.apply('undefined' !== typeof subscribed[name][i].ctxt ? subscribed[name][i].ctxt : o, Array.prototype.slice.call(arguments, 1));
+        continue;
+      }
+      // if instance registered but no instance given for the emit, continue
+      if (!(instance instanceof ParsleyField) && !(instance instanceof ParsleyForm))
+        continue;
+      // if instance is registered and same id, emit
+      if (subscribed[name][i].instance.__id__ === instance.__id__) {
+        subscribed[name][i].fn.apply(o, Array.prototype.slice.call(arguments, 1));
+        continue;
+      }
+      // if registered instance is a Form and fired one is a Field, loop over all its fields and emit if field found
+      if (subscribed[name][i].instance instanceof ParsleyForm && instance instanceof ParsleyField)
+        for (var j = 0; j < subscribed[name][i].instance.fields.length; j++)
+          if (subscribed[name][i].instance.fields[j].__id__ === instance.__id__) {
+            subscribed[name][i].fn.apply(o, Array.prototype.slice.call(arguments, 1));
+            continue;
+          }
+    }
+  };
+  $.subscribed = function () { return subscribed; };
+
+// ParsleyConfig definition if not already set
+window.ParsleyConfig = window.ParsleyConfig || {};
+window.ParsleyConfig.i18n = window.ParsleyConfig.i18n || {};
+// Define then the messages
+window.ParsleyConfig.i18n.en = $.extend(window.ParsleyConfig.i18n.en || {}, {
+  defaultMessage: "This value seems to be invalid.",
+  type: {
+    email:        "This value should be a valid email.",
+    url:          "This value should be a valid url.",
+    number:       "This value should be a valid number.",
+    integer:      "This value should be a valid integer.",
+    digits:       "This value should be digits.",
+    alphanum:     "This value should be alphanumeric."
+  },
+  notblank:       "This value should not be blank.",
+  required:       "This value is required.",
+  pattern:        "This value seems to be invalid.",
+  min:            "This value should be greater than or equal to %s.",
+  max:            "This value should be lower than or equal to %s.",
+  range:          "This value should be between %s and %s.",
+  minlength:      "This value is too short. It should have %s characters or more.",
+  maxlength:      "This value is too long. It should have %s characters or less.",
+  length:         "This value length is invalid. It should be between %s and %s characters long.",
+  mincheck:       "You must select at least %s choices.",
+  maxcheck:       "You must select %s choices or less.",
+  check:          "You must select between %s and %s choices.",
+  equalto:        "This value should be the same."
+});
+// If file is loaded after Parsley main file, auto-load locale
+if ('undefined' !== typeof window.ParsleyValidator)
+  window.ParsleyValidator.addCatalog('en', window.ParsleyConfig.i18n.en, true);
+
+//     Parsley.js 2.0.0
+//     http://parsleyjs.org
+//     (c) 20012-2014 Guillaume Potier, Wisembly
+//     Parsley may be freely distributed under the MIT license.
+
+  // ### Parsley factory
+  var Parsley = function (element, options, parsleyFormInstance) {
+    this.__class__ = 'Parsley';
+    this.__version__ = '2.0.0';
+    this.__id__ = ParsleyUtils.hash(4);
+    // Parsley must be instanciated with a DOM element or jQuery $element
+    if ('undefined' === typeof element)
+      throw new Error('You must give an element');
+    if ('undefined' !== typeof parsleyFormInstance && 'ParsleyForm' !== parsleyFormInstance.__class__)
+      throw new Error('Parent instance must be a ParsleyForm instance');
+    return this.init($(element), options, parsleyFormInstance);
+  };
+  Parsley.prototype = {
+    init: function ($element, options, parsleyFormInstance) {
+      if (!$element.length)
+        throw new Error('You must bind Parsley on an existing element.');
+      this.$element = $element;
+      // If element have already been binded, returns its saved Parsley instance
+      if (this.$element.data('Parsley')) {
+        var savedparsleyFormInstance = this.$element.data('Parsley');
+        // If saved instance have been binded without a ParsleyForm parent and there is one given in this call, add it
+        if ('undefined' !== typeof parsleyFormInstance)
+          savedparsleyFormInstance.parent = parsleyFormInstance;
+        return savedparsleyFormInstance;
+      }
+      // Handle 'static' options
+      this.OptionsFactory = new ParsleyOptionsFactory(ParsleyDefaults, ParsleyUtils.get(window, 'ParsleyConfig') || {}, options, this.getNamespace(options));
+      this.options = this.OptionsFactory.get(this);
+      // A ParsleyForm instance is obviously a `<form>` elem but also every node that is not an input and have `data-parsley-validate` attribute
+      if (this.$element.is('form') || (ParsleyUtils.attr(this.$element, this.options.namespace, 'validate') && !this.$element.is(this.options.inputs)))
+        return this.bind('parsleyForm');
+      // Every other supported element and not excluded element is binded as a `ParsleyField` or `ParsleyFieldMultiple`
+      else if (this.$element.is(this.options.inputs) && !this.$element.is(this.options.excluded))
+        return this.isMultiple() ? this.handleMultiple(parsleyFormInstance) : this.bind('parsleyField', parsleyFormInstance);
+      return this;
+    },
+    isMultiple: function () {
+      return (this.$element.is('input[type=radio], input[type=checkbox]') && 'undefined' === typeof this.options.multiple) || (this.$element.is('select') && 'undefined' !== typeof this.$element.attr('multiple'));
+    },
+    // Multiples fields are a real nightmare :(
+    // Maybe some refacto would be appreciated here..
+    handleMultiple: function (parsleyFormInstance) {
+      var
+        that = this,
+        name,
+        multiple,
+        parsleyMultipleInstance;
+      // Get parsleyFormInstance options if exist, mixed with element attributes
+      this.options = $.extend(this.options, parsleyFormInstance ? parsleyFormInstance.OptionsFactory.get(parsleyFormInstance) : {}, ParsleyUtils.attr(this.$element, this.options.namespace));
+      // Handle multiple name
+      if (this.options.multiple) {
+        multiple = this.options.multiple;
+      } else if ('undefined' !== typeof this.$element.attr('name') && this.$element.attr('name').length) {
+        multiple = name = this.$element.attr('name');
+      } else if ('undefined' !== typeof this.$element.attr('id') && this.$element.attr('id').length) {
+        multiple = this.$element.attr('id');
+      }
+      // Special select multiple input
+      if (this.$element.is('select') && 'undefined' !== typeof this.$element.attr('multiple')) {
+        return this.bind('parsleyFieldMultiple', parsleyFormInstance, multiple || this.__id__);
+      // Else for radio / checkboxes, we need a `name` or `data-parsley-multiple` to properly bind it
+      } else if ('undefined' === typeof multiple) {
+        if (window.console && window.console.warn)
+          window.console.warn('To be binded by Parsley, a radio, a checkbox and a multiple select input must have either a name or a multiple option.', this.$element);
+        return this;
+      }
+      // Remove special chars
+      multiple = multiple.replace(/(:|\.|\[|\]|\$)/g, '');
+      // Add proper `data-parsley-multiple` to siblings if we had a name
+      if ('undefined' !== typeof name)
+        $('input[name="' + name + '"]').each(function () {
+          if ($(this).is('input[type=radio], input[type=checkbox]'))
+            $(this).attr(that.options.namespace + 'multiple', multiple);
+        });
+      // Check here if we don't already have a related multiple instance saved
+      if ($('[' + this.options.namespace + 'multiple=' + multiple +']').length)
+        for (var i = 0; i < $('[' + this.options.namespace + 'multiple=' + multiple +']').length; i++)
+          if ('undefined' !== typeof $($('[' + this.options.namespace + 'multiple=' + multiple +']').get(i)).data('Parsley')) {
+            parsleyMultipleInstance = $($('[' + this.options.namespace + 'multiple=' + multiple +']').get(i)).data('Parsley');
+            if (!this.$element.data('ParsleyFieldMultiple')) {
+              parsleyMultipleInstance.addElement(this.$element);
+              this.$element.attr(this.options.namespace + 'id', parsleyMultipleInstance.__id__);
+            }
+            break;
+          }
+      // Create a secret ParsleyField instance for every multiple field. It would be stored in `data('ParsleyFieldMultiple')`
+      // And would be useful later to access classic `ParsleyField` stuff while being in a `ParsleyFieldMultiple` instance
+      this.bind('parsleyField', parsleyFormInstance, multiple, true);
+      return parsleyMultipleInstance || this.bind('parsleyFieldMultiple', parsleyFormInstance, multiple);
+    },
+    // Retrieve namespace used for DOM-API
+    getNamespace: function (options) {
+      // `data-parsley-namespace=<namespace>`
+      if ('undefined' !== typeof this.$element.data('parsleyNamespace'))
+        return this.$element.data('parsleyNamespace');
+      if ('undefined' !== typeof ParsleyUtils.get(options, 'namespace'))
+        return options.namespace;
+      if ('undefined' !== typeof ParsleyUtils.get(window, 'ParsleyConfig.namespace'))
+        return window.ParsleyConfig.namespace;
+      return ParsleyDefaults.namespace;
+    },
+    // Return proper `ParsleyForm`, `ParsleyField` or `ParsleyFieldMultiple`
+    bind: function (type, parentParsleyFormInstance, multiple, doNotStore) {
+      var parsleyInstance;
+      switch (type) {
+        case 'parsleyForm':
+          parsleyInstance = $.extend(
+            new ParsleyForm(this.$element, this.OptionsFactory),
+            new ParsleyAbstract(),
+            window.ParsleyExtend
+          )._bindFields();
+          break;
+        case 'parsleyField':
+          parsleyInstance = $.extend(
+            new ParsleyField(this.$element, this.OptionsFactory, parentParsleyFormInstance),
+            new ParsleyAbstract(),
+            window.ParsleyExtend
+          );
+          break;
+        case 'parsleyFieldMultiple':
+          parsleyInstance = $.extend(
+            new ParsleyField(this.$element, this.OptionsFactory, parentParsleyFormInstance),
+            new ParsleyAbstract(),
+            new ParsleyMultiple(),
+            window.ParsleyExtend
+          )._init(multiple);
+          break;
+        default:
+          throw new Error(type + 'is not a supported Parsley type');
+      }
+      if ('undefined' !== typeof multiple)
+        ParsleyUtils.setAttr(this.$element, this.options.namespace, 'multiple', multiple);
+      if ('undefined' !== typeof doNotStore) {
+        this.$element.data('ParsleyFieldMultiple', parsleyInstance);
+        return parsleyInstance;
+      }
+      // Store instance if `ParsleyForm`, `ParsleyField` or `ParsleyFieldMultiple`
+      if (new RegExp('ParsleyF', 'i').test(parsleyInstance.__class__)) {
+        // Store for later access the freshly binded instance in DOM element itself using jQuery `data()`
+        this.$element.data('Parsley', parsleyInstance);
+        // Tell the world we got a new ParsleyForm or ParsleyField instance!
+        $.emit('parsley:' + ('parsleyForm' === type ? 'form' : 'field') + ':init', parsleyInstance);
       }
-    , listeners: {
-        onFieldValidate: function ( elem, ParsleyField ) { return false; } // Executed on validation. Return true to ignore field validation
-      , onFormValidate: function ( isFormValid, event, ParsleyForm ) {}     // Executed once on form validation. Return (bool) false to block submit, even if valid
-      , onFieldError: function ( elem, constraints, ParsleyField ) {}     // Executed when a field is detected as invalid
-      , onFieldSuccess: function ( elem, constraints, ParsleyField ) {}   // Executed when a field passes validation
+      return parsleyInstance;
     }
   };
-
-// This plugin works with jQuery or Zepto (with data extension built for Zepto.)
-} ( window.jQuery || window.Zepto );
+  // ### jQuery API
+  // `$('.elem').parsley(options)` or `$('.elem').psly(options)`
+  $.fn.parsley = $.fn.psly = function (options) {
+    if (this.length > 1) {
+      var instances = [];
+      this.each(function () {
+        instances.push($(this).parsley(options));
+      });
+      return instances;
+    }
+    // Return undefined if applied to non existing DOM element
+    if (!$(this).length) {
+      if (window.console && window.console.warn)
+        window.console.warn('You must bind Parsley on an existing element.');
+      return;
+    }
+    return new Parsley(this, options);
+  };
+  // ### ParsleyUI
+  // UI is a class apart that only listen to some events and them modify DOM accordingly
+  // Could be overriden by defining a `window.ParsleyConfig.ParsleyUI` appropriate class (with `listen()` method basically)
+  window.ParsleyUI = 'function' === typeof ParsleyUtils.get(window, 'ParsleyConfig.ParsleyUI') ?
+    new window.ParsleyConfig.ParsleyUI().listen() : new ParsleyUI().listen();
+  // ### ParsleyField and ParsleyForm extension
+  // Ensure that defined if not already the case
+  if ('undefined' === typeof window.ParsleyExtend)
+    window.ParsleyExtend = {};
+  // ### ParsleyConfig
+  // Ensure that defined if not already the case
+  if ('undefined' === typeof window.ParsleyConfig)
+    window.ParsleyConfig = {};
+  // ### Globals
+  window.Parsley = window.psly = Parsley;
+  window.ParsleyUtils = ParsleyUtils;
+  window.ParsleyValidator = new ParsleyValidator(window.ParsleyConfig.validators, window.ParsleyConfig.i18n);
+  // ### PARSLEY auto-binding
+  // Prevent it by setting `ParsleyConfig.autoBind` to `false`
+  if (false !== ParsleyUtils.get(window, 'ParsleyConfig.autoBind'))
+    $(document).ready(function () {
+      // Works only on `data-parsley-validate`.
+      if ($('[data-parsley-validate]').length)
+        $('[data-parsley-validate]').parsley();
+    });
+
+// AMD Compliance
+if ('function' === typeof define && define.amd)
+  define('parsley', function() { return window.Parsley; } );
+})(window.jQuery);