vuejs 1.0.36 → 1.0.37

data/vendor/assets/javascripts/vue-validator3.js

@@ -0,0 +1,2054 @@
+/*!
+ * vue-validator v3.0.0-alpha.2 
+ * (c) 2016 kazuya kawaguchi
+ * Released under the MIT License.
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global.VueValidator = factory());
+}(this, (function () { 'use strict';
+
+/*  */
+
+function warn (msg, err) {
+  if (window.console) {
+    console.warn('[vue-validator] ' + msg);
+    if (err) {
+      console.warn(err.stack);
+    }
+  }
+}
+
+/*  */
+
+// validator configrations
+var validator = {
+  classes: {}
+};
+
+var Config = function (Vue) {
+  // define Vue.config.validator configration
+  // $FlowFixMe: https://github.com/facebook/flow/issues/285
+  Object.defineProperty(Vue.config, 'validator', {
+    enumerable: true,
+    configurable: true,
+    get: function () { return validator },
+    set: function (val) { validator = val; }
+  });
+};
+
+/*  */
+/**
+ * build-in validators
+ */
+
+/**
+ * required
+ * This function validate whether the value has been filled out.
+ */
+function required (val, arg) {
+  var isRequired = arg === undefined ? true : arg;
+  if (Array.isArray(val)) {
+    if (val.length !== 0) {
+      var valid = true;
+      for (var i = 0, l = val.length; i < l; i++) {
+        valid = required(val[i], isRequired);
+        if ((isRequired && !valid) || (!isRequired && valid)) {
+          break
+        }
+      }
+      return valid
+    } else {
+      return !isRequired
+    }
+  } else if (typeof val === 'number' || typeof val === 'function') {
+    return isRequired
+  } else if (typeof val === 'boolean') {
+    return val === isRequired
+  } else if (typeof val === 'string') {
+    return isRequired ? (val.length > 0) : (val.length <= 0)
+  } else if (val !== null && typeof val === 'object') {
+    return isRequired ? (Object.keys(val).length > 0) : (Object.keys(val).length <= 0)
+  } else if (val === null || val === undefined) {
+    return !isRequired
+  } else {
+    return !isRequired
+  }
+}
+
+/**
+ * pattern
+ * This function validate whether the value matches the regex pattern
+ */
+function pattern (val, pat) {
+  if (typeof pat !== 'string') { return false }
+
+  var match = pat.match(new RegExp('^/(.*?)/([gimy]*)$'));
+  if (!match) { return false }
+
+  return new RegExp(match[1], match[2]).test(val)
+}
+
+/**
+ * minlength
+ * This function validate whether the minimum length.
+ */
+function minlength (val, min) {
+  if (typeof val === 'string') {
+    return isInteger(min, 10) && val.length >= parseInt(min, 10)
+  } else if (Array.isArray(val)) {
+    return val.length >= parseInt(min, 10)
+  } else {
+    return false
+  }
+}
+
+/**
+ * maxlength
+ * This function validate whether the maximum length.
+ */
+function maxlength (val, max) {
+  if (typeof val === 'string') {
+    return isInteger(max, 10) && val.length <= parseInt(max, 10)
+  } else if (Array.isArray(val)) {
+    return val.length <= parseInt(max, 10)
+  } else {
+    return false
+  }
+}
+
+/**
+ * min
+ * This function validate whether the minimum value of the numberable value.
+ */
+function min (val, arg) {
+  return !isNaN(+(val)) && !isNaN(+(arg)) && (+(val) >= +(arg))
+}
+
+/**
+ * max
+ * This function validate whether the maximum value of the numberable value.
+ */
+function max (val, arg) {
+  return !isNaN(+(val)) && !isNaN(+(arg)) && (+(val) <= +(arg))
+}
+
+/**
+ * isInteger
+ * This function check whether the value of the string is integer.
+ */
+function isInteger (val) {
+  return /^(-?[1-9]\d*|0)$/.test(val)
+}
+
+
+var validators = Object.freeze({
+	required: required,
+	pattern: pattern,
+	minlength: minlength,
+	maxlength: maxlength,
+	min: min,
+	max: max
+});
+
+/*  */
+var Asset = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+
+  // set global validators asset
+  var assets = Object.create(null);
+  extend(assets, validators);
+  Vue.options.validators = assets;
+
+  // set option merge strategy
+  var strats = Vue.config.optionMergeStrategies;
+  if (strats) {
+    strats.validators = function (parent, child) {
+      if (!child) { return parent }
+      if (!parent) { return child }
+      var ret = Object.create(null);
+      extend(ret, parent);
+      var key;
+      for (key in child) {
+        ret[key] = child[key];
+      }
+      return ret
+    };
+  }
+
+  /**
+   * Register or retrieve a global validator definition.
+   */
+  function validator (
+    id,
+    def
+  ) {
+    if (def === undefined) {
+      return Vue.options['validators'][id]
+    } else {
+      Vue.options['validators'][id] = def;
+      if (def === null) {
+        delete Vue.options['validators']['id'];
+      }
+    }
+  }
+  Vue['validator'] = validator;
+};
+
+/*  */
+
+var Group = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+
+  return {
+    data: function data () {
+      return {
+        valid: true,
+        dirty: false,
+        touched: false,
+        modified: false,
+        results: {}
+      }
+    },
+    computed: {
+      invalid: function invalid () { return !this.valid },
+      pristine: function pristine () { return !this.dirty },
+      untouched: function untouched () { return !this.touched },
+      result: function result () {
+        var ret = {
+          valid: this.valid,
+          invalid: this.invalid,
+          dirty: this.dirty,
+          pristine: this.pristine,
+          touched: this.touched,
+          untouched: this.untouched,
+          modified: this.modified
+        };
+        var results = this.results;
+        this._validityKeys.forEach(function (key) {
+          ret[key] = results[key];
+          if (ret[key].errors) {
+            var errors = ret.errors || [];
+            ret[key].errors.forEach(function (error) {
+              errors.push(error);
+            });
+            ret.errors = errors;
+          }
+        });
+        return ret
+      }
+    },
+    watch: {
+      results: function results (val, old) {
+        var keys = this._validityKeys;
+        var results = this.results;
+        this.valid = this.checkResults(keys, results, 'valid', true);
+        this.dirty = this.checkResults(keys, results, 'dirty', false);
+        this.touched = this.checkResults(keys, results, 'touched', false);
+        this.modified = this.checkResults(keys, results, 'modified', false);
+      }
+    },
+    created: function created () {
+      this._validities = Object.create(null);
+      this._validityWatchers = Object.create(null);
+      this._validityKeys = [];
+      this._committing = false;
+    },
+    destroyed: function destroyed () {
+      var this$1 = this;
+
+      this._validityKeys.forEach(function (key) {
+        this$1._validityWatchers[key]();
+        delete this$1._validityWatchers[key];
+        delete this$1._validities[key];
+      });
+      delete this._validityWatchers;
+      delete this._validities;
+      delete this._validityKeys;
+    },
+    methods: {
+      register: function register (name, validity) {
+        var this$1 = this;
+
+        this._validities[name] = validity;
+        this._validityKeys = Object.keys(this._validities);
+        this.setResults(name, {});
+        this.withCommit(function () {
+          this$1._validityWatchers[name] = validity.$watch('result', function (val, old) {
+            this$1.setResults(name, val);
+          }, { deep: true, immediate: true });
+        });
+      },
+      unregister: function unregister (name) {
+        var this$1 = this;
+
+        this._validityWatchers[name]();
+        delete this._validityWatchers[name];
+        delete this._validities[name];
+        this._validityKeys = Object.keys(this._validities);
+        this.withCommit(function () {
+          this$1.resetResults(name);
+        });
+      },
+      validityCount: function validityCount () {
+        return this._validityKeys.length
+      },
+      isRegistered: function isRegistered (name) {
+        return name in this._validities
+      },
+      getValidityKeys: function getValidityKeys () {
+        return this._validityKeys
+      },
+      checkResults: function checkResults (
+        keys,
+        results,
+        prop,
+        checking
+      ) {
+        var ret = checking;
+        for (var i = 0; i < keys.length; i++) {
+          var result = results[keys[i]];
+          if (result[prop] !== checking) {
+            ret = !checking;
+            break
+          }
+        }
+        return ret
+      },
+      setResults: function setResults (name, val) {
+        var this$1 = this;
+
+        var newVal = {};
+        this._validityKeys.forEach(function (key) {
+          newVal[key] = extend({}, this$1.results[key]);
+        });
+        newVal[name] = extend({}, val);
+        this.results = newVal;
+      },
+      resetResults: function resetResults (ignore) {
+        var this$1 = this;
+
+        var newVal = {};
+        this._validityKeys.forEach(function (key) {
+          if (ignore && ignore !== key) {
+            newVal[key] = extend({}, this$1.results[key]);
+          }
+        });
+        this.results = newVal;
+      },
+      withCommit: function withCommit (fn) {
+        var committing = this._committing;
+        this._committing = true;
+        fn();
+        this._committing = committing;
+      }
+    }
+  }
+};
+
+/*  */
+var ValidationClass = function (Vue) {
+  var ValidityGroup = Group(Vue);
+
+  var Validation = function Validation (options) {
+    if ( options === void 0 ) options = {};
+
+    this._result = {};
+    this._host = options.host;
+    this._named = Object.create(null);
+    this._group = Object.create(null);
+    this._validities = Object.create(null);
+    this._beginDestroy = false;
+    Vue.util.defineReactive(this._host, '$validation', this._result);
+  };
+
+  Validation.prototype.register = function register (
+    field,
+    validity,
+    options
+  ) {
+      if ( options === void 0 ) options = {};
+
+    // NOTE: lazy setup (in constructor, occured callstack recursive errors ...)
+    if (!this._validityManager) {
+      this._validityManager = new Vue(ValidityGroup);
+      this._watchValidityResult();
+    }
+
+    if (this._validities[field]) {
+      // TODO: should be output console.error
+      return
+    }
+    this._validities[field] = validity;
+
+    var named = options.named;
+      var group = options.group;
+    var groupValidity = group
+      ? this._getValidityGroup('group', group) || this._registerValidityGroup('group', group)
+      : null;
+    var namedValidity = named
+      ? this._getValidityGroup('named', named) || this._registerValidityGroup('named', named)
+      : null;
+    if (named && group && namedValidity && groupValidity) {
+      groupValidity.register(field, validity);
+      !namedValidity.isRegistered(group) && namedValidity.register(group, groupValidity);
+      !this._validityManager.isRegistered(named) && this._validityManager.register(named, namedValidity);
+    } else if (namedValidity) {
+      namedValidity.register(field, validity);
+      !this._validityManager.isRegistered(named) && this._validityManager.register(named, namedValidity);
+    } else if (groupValidity) {
+      groupValidity.register(field, validity);
+      !this._validityManager.isRegistered(group) && this._validityManager.register(group, groupValidity);
+    } else {
+      this._validityManager.register(field, validity);
+    }
+  };
+
+  Validation.prototype.unregister = function unregister (
+    field,
+    options
+  ) {
+      if ( options === void 0 ) options = {};
+
+    if (!this._validityManager) {
+      // TODO: should be output error
+      return
+    }
+
+    if (!this._validities[field]) {
+      // TODO: should be output error
+      return
+    }
+    delete this._validities[field];
+
+    var named = options.named;
+      var group = options.group;
+    var groupValidity = group ? this._getValidityGroup('group', group) : null;
+    var namedValidity = named ? this._getValidityGroup('named', named) : null;
+    if (named && group && namedValidity && groupValidity) {
+      groupValidity.unregister(field);
+      if (groupValidity.validityCount() === 0) {
+        namedValidity.isRegistered(group) && namedValidity.unregister(group);
+        this._unregisterValidityGroup('group', group);
+      }
+      if (namedValidity.validityCount() === 0) {
+        this._validityManager.isRegistered(named) && this._validityManager.unregister(named);
+        this._unregisterValidityGroup('named', named);
+      }
+    } else if (named && namedValidity) {
+      namedValidity.unregister(field);
+      if (namedValidity.validityCount() === 0) {
+        this._validityManager.isRegistered(named) && this._validityManager.unregister(named);
+        this._unregisterValidityGroup('named', named);
+      }
+    } else if (group && groupValidity) {
+      groupValidity.unregister(field);
+      if (groupValidity.validityCount() === 0) {
+        this._validityManager.isRegistered(group) && this._validityManager.unregister(group);
+        this._unregisterValidityGroup('group', group);
+      }
+    } else {
+      this._validityManager.unregister(field);
+    }
+  };
+
+  Validation.prototype.destroy = function destroy () {
+      var this$1 = this;
+
+    var validityKeys = Object.keys(this._validities);
+    var namedKeys = Object.keys(this._named);
+    var groupKeys = Object.keys(this._group);
+
+    // unregister validity
+    validityKeys.forEach(function (validityKey) {
+      groupKeys.forEach(function (groupKey) {
+        var group = this$1._getValidityGroup('group', groupKey);
+        if (group && group.isRegistered(groupKey)) {
+          group.unregister(validityKey);
+        }
+      });
+      namedKeys.forEach(function (namedKey) {
+        var named = this$1._getValidityGroup('named', namedKey);
+        if (named && named.isRegistered(validityKey)) {
+          named.unregister(validityKey);
+        }
+      });
+      if (this$1._validityManager.isRegistered(validityKey)) {
+        this$1._validityManager.unregister(validityKey);
+      }
+      delete this$1._validities[validityKey];
+    });
+
+    // unregister grouped validity
+    groupKeys.forEach(function (groupKey) {
+      namedKeys.forEach(function (namedKey) {
+        var named = this$1._getValidityGroup('named', namedKey);
+        if (named && named.isRegistered(groupKey)) {
+          named.unregister(groupKey);
+        }
+      });
+      if (this$1._validityManager.isRegistered(groupKey)) {
+        this$1._validityManager.unregister(groupKey);
+      }
+      this$1._unregisterValidityGroup('group', groupKey);
+    });
+
+    // unregister named validity
+    namedKeys.forEach(function (namedKey) {
+      if (this$1._validityManager.isRegistered(namedKey)) {
+        this$1._validityManager.unregister(namedKey);
+      }
+      this$1._unregisterValidityGroup('named', namedKey);
+    });
+
+    this._beginDestroy = true;
+  };
+
+  Validation.prototype._getValidityGroup = function _getValidityGroup (type, name) {
+    return type === 'named' ? this._named[name] : this._group[name]
+  };
+
+  Validation.prototype._registerValidityGroup = function _registerValidityGroup (type, name) {
+    var groups = type === 'named' ? this._named : this._group;
+    groups[name] = new Vue(ValidityGroup);
+    return groups[name]
+  };
+
+  Validation.prototype._unregisterValidityGroup = function _unregisterValidityGroup (type, name) {
+    var groups = type === 'named' ? this._named : this._group;
+    if (!groups[name]) {
+      // TODO: should be warn
+      return
+    }
+
+    groups[name].$destroy();
+    delete groups[name];
+  };
+
+  Validation.prototype._watchValidityResult = function _watchValidityResult () {
+      var this$1 = this;
+
+    this._watcher = this._validityManager.$watch('results', function (val, old) {
+      Vue.set(this$1._host, '$validation', val);
+      if (this$1._beginDestroy) {
+        this$1._destroyValidityMananger();
+      }
+    }, { deep: true });
+  };
+
+  Validation.prototype._unwatchValidityResult = function _unwatchValidityResult () {
+    this._watcher();
+    delete this._watcher;
+  };
+
+  Validation.prototype._destroyValidityMananger = function _destroyValidityMananger () {
+    this._unwatchValidityResult();
+    this._validityManager.$destroy();
+    this._validityManager = null;
+  };
+
+  return Validation
+};
+
+/*  */
+
+var Mixin = function (Vue) {
+  var Validation = ValidationClass(Vue);
+
+  return {
+    beforeCreate: function beforeCreate () {
+      this._validation = new Validation({ host: this });
+    }
+  }
+};
+
+/*  */
+
+var baseProps = {
+  field: {
+    type: String,
+    required: true
+  },
+  validators: {
+    type: [String, Array, Object],
+    required: true
+  },
+  group: {
+    type: String
+  },
+  multiple: {
+    type: Boolean
+  },
+  autotouch: {
+    type: String,
+    default: function () {
+      return 'on'
+    }
+  },
+  classes: {
+    type: Object,
+    default: function () {
+      return {}
+    }
+  }
+};
+
+var DEFAULT_CLASSES = {
+  valid: 'valid',
+  invalid: 'invalid',
+  touched: 'touched',
+  untouched: 'untouched',
+  pristine: 'pristine',
+  dirty: 'dirty',
+  modified: 'modified'
+};
+
+/*  */
+var States = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+  var isPlainObject = ref.isPlainObject;
+
+  function initialStates (states, validators, init) {
+    if ( init === void 0 ) init = undefined;
+
+    if (Array.isArray(validators)) {
+      validators.forEach(function (validator) {
+        states[validator] = init;
+      });
+    } else {
+      Object.keys(validators).forEach(function (validator) {
+        var props = (validators[validator] &&
+          validators[validator]['props'] &&
+          isPlainObject(validators[validator]['props']))
+            ? validators[validator]['props']
+            : null;
+        if (props) {
+          Object.keys(props).forEach(function (prop) {
+            states[validator] = {};
+            states[validator][prop] = init;
+          });
+        } else {
+          states[validator] = init;
+        }
+      });
+    }
+  }
+
+  function getInitialResults (validators) {
+    var results = {};
+    initialStates(results, validators, undefined);
+    return results
+  }
+
+  function getInitialProgresses (validators) {
+    var progresses = {};
+    initialStates(progresses, validators, '');
+    return progresses
+  }
+
+  var props = extend({
+    child: {
+      type: Object,
+      required: true
+    },
+    value: {
+      type: Object
+    }
+  }, baseProps);
+
+  function data () {
+    var validators = nomalizeValidators(this.validators);
+    return {
+      results: getInitialResults(validators),
+      valid: true,
+      dirty: false,
+      touched: false,
+      modified: false,
+      progresses: getInitialProgresses(validators)
+    }
+  }
+
+  return {
+    props: props,
+    data: data
+  }
+};
+
+function nomalizeValidators (target) {
+  return typeof target === 'string' ? [target] : target
+}
+
+/*  */
+
+var Computed = function (Vue) {
+  var ref = Vue.util;
+  var isPlainObject = ref.isPlainObject;
+
+  function setError (
+    result,
+    field,
+    validator,
+    message,
+    prop
+  ) {
+    var error = { field: field, validator: validator };
+    if (message) {
+      error.message = message;
+    }
+    if (prop) {
+      error.prop = prop;
+    }
+    result.errors = result.errors || [];
+    result.errors.push(error);
+  }
+
+  function walkProgresses (keys, target) {
+    var progress = '';
+    for (var i = 0; i < keys.length; i++) {
+      var result = target[keys[i]];
+      if (typeof result === 'string' && result) {
+        progress = result;
+        break
+      }
+      if (isPlainObject(result)) {
+        var nestedKeys = Object.keys(result);
+        progress = walkProgresses(nestedKeys, result);
+        if (!progress) {
+          break
+        }
+      }
+    }
+    return progress
+  }
+
+  function invalid () {
+    return !this.valid
+  }
+
+  function pristine () {
+    return !this.dirty
+  }
+
+  function untouched () {
+    return !this.touched
+  }
+
+  function result () {
+    var this$1 = this;
+
+    var ret = {
+      valid: this.valid,
+      invalid: this.invalid,
+      dirty: this.dirty,
+      pristine: this.pristine,
+      touched: this.touched,
+      untouched: this.untouched,
+      modified: this.modified
+    };
+
+    var keys = this._keysCached(this._uid.toString(), this.results);
+    keys.forEach(function (validator) {
+      var result = this$1.results[validator];
+      if (typeof result === 'boolean') {
+        if (result) {
+          ret[validator] = false;
+        } else {
+          setError(ret, this$1.field, validator);
+          ret[validator] = !result;
+        }
+      } else if (typeof result === 'string') {
+        setError(ret, this$1.field, validator, result);
+        ret[validator] = result;
+      } else if (isPlainObject(result)) { // object
+        var props = Object.keys(result);
+        props.forEach(function (prop) {
+          var propRet = result[prop];
+          ret[prop] = ret[prop] || {};
+          if (typeof propRet === 'boolean') {
+            if (propRet) {
+              ret[prop][validator] = false;
+            } else {
+              setError(ret, this$1.field, validator, undefined, prop);
+              ret[prop][validator] = !propRet;
+            }
+          } else if (typeof propRet === 'string') {
+            setError(ret, this$1.field, validator, propRet, prop);
+            ret[prop][validator] = propRet;
+          } else {
+            ret[prop][validator] = false;
+          }
+        });
+      } else {
+        ret[validator] = false;
+      }
+    });
+
+    return ret
+  }
+
+  function progress () {
+    var ret = '';
+    ret = walkProgresses(
+      this._keysCached(this._uid.toString(), this.results),
+      this.progresses
+    );
+    return ret
+  }
+
+  return {
+    invalid: invalid,
+    pristine: pristine,
+    untouched: untouched,
+    result: result,
+    progress: progress
+  }
+};
+
+/*  */
+
+var Render = function (Vue) {
+  return {
+    render: function render (h) {
+      return this.child
+    }
+  }
+};
+
+/*  */
+
+var SingleElementClass = function (Vue) {
+  var ref = Vue.util;
+  var looseEqual = ref.looseEqual;
+
+  var SingleElement = function SingleElement (vm) {
+    this._vm = vm;
+    this.initValue = this.getValue();
+    this.attachValidity();
+  };
+
+  SingleElement.prototype.attachValidity = function attachValidity () {
+    this._vm.$el.$validity = this._vm;
+  };
+
+  SingleElement.prototype.getValue = function getValue () {
+    var el = this._vm.$el;
+    if (el.tagName === 'SELECT') {
+      return getSelectValue(el)
+    } else {
+      if (el.type === 'checkbox') {
+        return el.checked
+      } else {
+        return el.value
+      }
+    }
+  };
+
+  SingleElement.prototype.checkModified = function checkModified () {
+    var el = this._vm.$el;
+    if (el.tagName === 'SELECT') {
+      return !looseEqual(this.initValue, getSelectValue(el))
+    } else {
+      if (el.type === 'checkbox') {
+        return !looseEqual(this.initValue, el.checked)
+      } else {
+        return !looseEqual(this.initValue, el.value)
+      }
+    }
+  };
+
+  SingleElement.prototype.listenToucheableEvent = function listenToucheableEvent () {
+    this._vm.$el.addEventListener('focusout', this._vm.willUpdateTouched);
+  };
+
+  SingleElement.prototype.unlistenToucheableEvent = function unlistenToucheableEvent () {
+    this._vm.$el.removeEventListener('focusout', this._vm.willUpdateTouched);
+  };
+
+  SingleElement.prototype.listenInputableEvent = function listenInputableEvent () {
+    var vm = this._vm;
+    var el = vm.$el;
+    if (el.tagName === 'SELECT') {
+      el.addEventListener('change', vm.handleInputable);
+    } else {
+      if (el.type === 'checkbox') {
+        el.addEventListener('change', vm.handleInputable);
+      } else {
+        el.addEventListener('input', vm.handleInputable);
+      }
+    }
+  };
+
+  SingleElement.prototype.unlistenInputableEvent = function unlistenInputableEvent () {
+    var vm = this._vm;
+    var el = vm.$el;
+    if (el.tagName === 'SELECT') {
+      el.removeEventListener('change', vm.handleInputable);
+    } else {
+      if (el.type === 'checkbox') {
+        el.removeEventListener('change', vm.handleInputable);
+      } else {
+        el.removeEventListener('input', vm.handleInputable);
+      }
+    }
+  };
+
+  return SingleElement
+};
+
+function getSelectValue (el) {
+  var value = [];
+  for (var i = 0, l = el.options.length; i < l; i++) {
+    var option = el.options[i];
+    if (!option.disabled && option.selected) {
+      value.push(option.value);
+    }
+  }
+  return value
+}
+
+/*  */
+
+var MultiElementClass = function (Vue) {
+  var ref = Vue.util;
+  var looseEqual = ref.looseEqual;
+
+  var MultiElement = function MultiElement (vm) {
+    // TODO: should be checked whether included radio or checkbox
+    this._vm = vm;
+    this.initValue = this.getValue();
+    this.attachValidity();
+  };
+
+  MultiElement.prototype.attachValidity = function attachValidity () {
+      var this$1 = this;
+
+    this._vm.$el.$validity = this._vm;
+    this._eachItems(function (item) {
+      item.$validity = this$1._vm;
+    });
+  };
+
+  MultiElement.prototype.getValue = function getValue () {
+    return this._getCheckedValue()
+  };
+
+  MultiElement.prototype.checkModified = function checkModified () {
+    return !looseEqual(this.initValue, this._getCheckedValue())
+  };
+
+  MultiElement.prototype.listenToucheableEvent = function listenToucheableEvent () {
+      var this$1 = this;
+
+    this._eachItems(function (item) {
+      item.addEventListener('focusout', this$1._vm.willUpdateTouched);
+    });
+  };
+
+  MultiElement.prototype.unlistenToucheableEvent = function unlistenToucheableEvent () {
+      var this$1 = this;
+
+    this._eachItems(function (item) {
+      item.removeEventListener('focusout', this$1._vm.willUpdateTouched);
+    });
+  };
+
+  MultiElement.prototype.listenInputableEvent = function listenInputableEvent () {
+      var this$1 = this;
+
+    this._eachItems(function (item) {
+      item.addEventListener('change', this$1._vm.handleInputable);
+    });
+  };
+
+  MultiElement.prototype.unlistenInputableEvent = function unlistenInputableEvent () {
+      var this$1 = this;
+
+    this._eachItems(function (item) {
+      item.removeEventListener('change', this$1._vm.handleInputable);
+    });
+  };
+
+  MultiElement.prototype._getCheckedValue = function _getCheckedValue () {
+    var value = [];
+    this._eachItems(function (item) {
+      if (!item.disabled && item.checked) {
+        value.push(item.value);
+      }
+    });
+    return value
+  };
+
+  MultiElement.prototype._getItems = function _getItems () {
+    return this._vm.$el.querySelectorAll('input[type="checkbox"], input[type="radio"]')
+  };
+
+  MultiElement.prototype._eachItems = function _eachItems (cb) {
+    var items = this._getItems();
+    for (var i = 0; i < items.length; i++) {
+      cb(items[i]);
+    }
+  };
+
+  return MultiElement
+};
+
+/*  */
+
+var inBrowser =
+  typeof window !== 'undefined' &&
+  Object.prototype.toString.call(window) !== '[object Object]';
+var UA = inBrowser && window.navigator.userAgent.toLowerCase();
+var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+
+function getClass (el) {
+  var classname = el.className;
+  if (typeof classname === 'object') {
+    classname = classname.baseVal || '';
+  }
+  return classname
+}
+
+function setClass (el, cls) {
+  if (isIE9 && !/svg$/.test(el.namespaceURI)) {
+    el.className = cls;
+  } else {
+    el.setAttribute('class', cls);
+  }
+}
+
+function addClass (el, cls) {
+  if (el.classList) {
+    el.classList.add(cls);
+  } else {
+    var cur = ' ' + getClass(el) + ' ';
+    if (cur.indexOf(' ' + cls + ' ') < 0) {
+      setClass(el, (cur + cls).trim());
+    }
+  }
+}
+
+function removeClass (el, cls) {
+  if (el.classList) {
+    el.classList.remove(cls);
+  } else {
+    var cur = ' ' + getClass(el) + ' ';
+    var tar = ' ' + cls + ' ';
+    while (cur.indexOf(tar) >= 0) {
+      cur = cur.replace(tar, ' ');
+    }
+    setClass(el, cur.trim());
+  }
+  if (!el.className) {
+    el.removeAttribute('class');
+  }
+}
+
+function toggleClasses (el, key, fn) {
+  if (!el) { return }
+
+  key = key.trim();
+  if (key.indexOf(' ') === -1) {
+    fn(el, key);
+    return
+  }
+
+  var keys = key.split(/\s+/);
+  for (var i = 0, l = keys.length; i < l; i++) {
+    fn(el, keys[i]);
+  }
+}
+
+function memoize (fn) {
+  var cache = Object.create(null);
+  return function memoizeFn (id) {
+    var args = [], len = arguments.length - 1;
+    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
+
+    var hit = cache[id];
+    return hit || (cache[id] = fn.apply(void 0, args))
+  }
+}
+
+/*  */
+var ComponentElementClass = function (Vue) {
+  var ref = Vue.util;
+  var looseEqual = ref.looseEqual;
+  var isPlainObject = ref.isPlainObject;
+
+  function getValidatorProps (validators) {
+    var normalized = typeof validators === 'string' ? [validators] : validators;
+    var targets = [];
+    if (isPlainObject(normalized)) {
+      Object.keys(normalized).forEach(function (validator) {
+        var props = (normalized[validator] &&
+          normalized[validator]['props'] &&
+          isPlainObject(normalized[validator]['props']))
+            ? normalized[validator]['props']
+            : null;
+        if (props) {
+          Object.keys(props).forEach(function (prop) {
+            if (!~targets.indexOf(prop)) {
+              targets.push(prop);
+            }
+          });
+        }
+      });
+    }
+    return targets
+  }
+
+  var ComponentElement = function ComponentElement (vm, vnode, validatorProps) {
+    this._vm = vm;
+    this._vnode = vnode;
+    this._validatorProps = validatorProps || memoize(getValidatorProps);
+    this.initValue = this.getValue();
+    this._watchers = [];
+    this.attachValidity();
+  };
+
+  ComponentElement.prototype.attachValidity = function attachValidity () {
+    this._vm.$el.$validity = this._vm;
+  };
+
+  ComponentElement.prototype.getValidatorProps = function getValidatorProps$1 () {
+    var vm = this._vm;
+    return this._validatorProps(vm._uid.toString(), vm.validators)
+  };
+
+  ComponentElement.prototype.getValue = function getValue () {
+      var this$1 = this;
+
+    var value = {};
+    this.getValidatorProps().forEach(function (prop) {
+      value[prop] = this$1._vnode.child[prop];
+    });
+    return value
+  };
+
+  ComponentElement.prototype.checkModified = function checkModified () {
+    return !looseEqual(this.initValue, this.getValue())
+  };
+
+  ComponentElement.prototype.listenToucheableEvent = function listenToucheableEvent () {
+    this._vm.$el.addEventListener('focusout', this._vm.willUpdateTouched);
+  };
+
+  ComponentElement.prototype.unlistenToucheableEvent = function unlistenToucheableEvent () {
+    this._vm.$el.removeEventListener('focusout', this._vm.willUpdateTouched);
+  };
+
+  ComponentElement.prototype.listenInputableEvent = function listenInputableEvent () {
+      var this$1 = this;
+
+    this.getValidatorProps().forEach(function (prop) {
+      this$1._watchers.push(this$1._vnode.child.$watch(prop, this$1._vm.watchInputable));
+    });
+  };
+
+  ComponentElement.prototype.unlistenInputableEvent = function unlistenInputableEvent () {
+    this._watchers.forEach(function (watcher) { watcher(); });
+    this._watchers = [];
+  };
+
+  return ComponentElement
+};
+
+/*  */
+var Elements = function (Vue) {
+  var SingleElement = SingleElementClass(Vue);
+  var MultiElement = MultiElementClass(Vue);
+  var ComponentElement = ComponentElementClass(Vue);
+
+  return {
+    SingleElement: SingleElement,
+    MultiElement: MultiElement,
+    ComponentElement: ComponentElement
+  }
+};
+
+/*  */
+var Lifecycles = function (Vue) {
+  var ref = Elements(Vue);
+  var SingleElement = ref.SingleElement;
+  var MultiElement = ref.MultiElement;
+  var ComponentElement = ref.ComponentElement;
+
+  function createValidityElement (vm, vnode) {
+    return vm.multiple
+      ? new MultiElement(vm)
+      : checkBuiltInElement(vnode)
+        ? new SingleElement(vm)
+        : checkComponentElement(vnode)
+          ? new ComponentElement(vm, vnode)
+          : null
+  }
+
+  function watchModelable (val) {
+    this.$emit('input', {
+      result: this.result,
+      progress: this.progress,
+      progresses: this.progresses
+    });
+  }
+
+  function created () {
+    this._elementable = null;
+
+    this._keysCached = memoize(function (results) {
+      return Object.keys(results)
+    });
+
+    // for event control flags
+    this._modified = false;
+
+    // watch validation raw results
+    this._watchValidationRawResults();
+
+    var validation = this.$options.propsData ? this.$options.propsData.validation : null;
+    if (validation) {
+      var instance = validation.instance;
+      var name = validation.name;
+      var group = this.group;
+      instance.register(this.field, this, { named: name, group: group });
+    }
+  }
+
+  function destroyed () {
+    var validation = this.$options.propsData ? this.$options.propsData.validation : null;
+    if (validation) {
+      var instance = validation.instance;
+      var name = validation.name;
+      var group = this.group;
+      instance.unregister(this.field, { named: name, group: group });
+    }
+
+    if (this._unwatchResultProp) {
+      this._unwatchResultProp();
+      this._unwatchResultProp = null;
+    }
+
+    if (this._unwatchProgressProp) {
+      this._unwatchProgressProp();
+      this._unwatchProgressProp = null;
+    }
+
+    this._unwatchValidationRawResults();
+
+    this._elementable.unlistenInputableEvent();
+    if (this.autotouch === 'on') {
+      this._elementable.unlistenToucheableEvent();
+    }
+    this._elementable = null;
+  }
+
+  function mounted () {
+    this._elementable = createValidityElement(this, this._vnode);
+    if (this._elementable) {
+      if (this.autotouch === 'on') {
+        this._elementable.listenToucheableEvent();
+      }
+      this._elementable.listenInputableEvent();
+    } else {
+      // TODO: should be warn
+    }
+
+    if (hasModelDirective(this.$vnode)) {
+      this._unwatchResultProp = this.$watch('result', watchModelable);
+      this._unwatchProgressProp = this.$watch('progress', watchModelable);
+    }
+
+    toggleClasses(this.$el, this.classes.untouched, addClass);
+    toggleClasses(this.$el, this.classes.pristine, addClass);
+  }
+
+  return {
+    created: created,
+    destroyed: destroyed,
+    mounted: mounted
+  }
+};
+
+function checkComponentElement (vnode) {
+  return vnode.child &&
+    vnode.componentOptions &&
+    vnode.tag &&
+    vnode.tag.match(/vue-component/)
+}
+
+function checkBuiltInElement (vnode) {
+  return !vnode.child &&
+    !vnode.componentOptions &&
+    vnode.tag
+}
+
+function hasModelDirective (vnode) {
+  return ((vnode && vnode.data && vnode.data.directives) || []).find(function (dir) { return dir.name === 'model'; })
+}
+
+/*  */
+
+var Event = function (Vue) {
+  function _fireEvent (type) {
+    var args = [], len = arguments.length - 1;
+    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
+
+    (ref = this).$emit.apply(ref, [ type ].concat( args ));
+    var ref;
+  }
+
+  return {
+    _fireEvent: _fireEvent
+  }
+};
+
+/*  */
+var State = function (Vue) {
+  var ref = Vue.util;
+  var isPlainObject = ref.isPlainObject;
+
+  function getValue (options) {
+    return this._elementable.getValue()
+  }
+
+  function checkModified () {
+    return this._elementable.checkModified()
+  }
+
+  function willUpdateTouched (options) {
+    if (!this.touched) {
+      this.touched = true;
+      toggleClasses(this.$el, this.classes.touched, addClass);
+      toggleClasses(this.$el, this.classes.untouched, removeClass);
+      this._fireEvent('touched');
+    }
+  }
+
+  function willUpdateDirty () {
+    if (!this.dirty && this.checkModified()) {
+      this.dirty = true;
+      toggleClasses(this.$el, this.classes.dirty, addClass);
+      toggleClasses(this.$el, this.classes.pristine, removeClass);
+      this._fireEvent('dirty');
+    }
+  }
+
+  function willUpdateModified () {
+    var modified = this.modified = this.checkModified();
+    if (this._modified !== modified) {
+      this._modified = modified;
+      toggleClasses(this.$el, this.classes.modified, modified ? addClass : removeClass);
+      this._fireEvent('modified', modified);
+    }
+  }
+
+  function handleInputable (e) {
+    this.willUpdateDirty();
+    this.willUpdateModified();
+  }
+
+  function watchInputable (val) {
+    this.willUpdateDirty();
+    this.willUpdateModified();
+  }
+
+  function _initStates (keys, target, init) {
+    if ( init === void 0 ) init = undefined;
+
+    for (var i = 0; i < keys.length; i++) {
+      var result = target[keys[i]];
+      if (isPlainObject(result)) {
+        var nestedKeys = Object.keys(result);
+        _initStates(nestedKeys, result, init);
+      } else {
+        target[keys[i]] = init;
+      }
+    }
+  }
+
+  function reset () {
+    this._unwatchValidationRawResults();
+    var keys = this._keysCached(this._uid.toString(), this.results);
+    _initStates(keys, this.results, undefined);
+    _initStates(keys, this.progresses, '');
+    toggleClasses(this.$el, this.classes.valid, removeClass);
+    toggleClasses(this.$el, this.classes.invalid, removeClass);
+    toggleClasses(this.$el, this.classes.touched, removeClass);
+    toggleClasses(this.$el, this.classes.untouched, addClass);
+    toggleClasses(this.$el, this.classes.dirty, removeClass);
+    toggleClasses(this.$el, this.classes.pristine, addClass);
+    toggleClasses(this.$el, this.classes.modified, removeClass);
+    this.valid = true;
+    this.dirty = false;
+    this.touched = false;
+    this.modified = false;
+    this._modified = false;
+    this._watchValidationRawResults();
+  }
+
+  function _walkValid (keys, target) {
+    var valid = true;
+    for (var i = 0; i < keys.length; i++) {
+      var result = target[keys[i]];
+      if (typeof result === 'boolean' && !result) {
+        valid = false;
+        break
+      }
+      if (typeof result === 'string' && result) {
+        valid = false;
+        break
+      }
+      if (isPlainObject(result)) {
+        var nestedKeys = Object.keys(result);
+        valid = _walkValid(nestedKeys, result);
+        if (!valid) {
+          break
+        }
+      }
+    }
+    return valid
+  }
+
+  function _watchValidationRawResults () {
+    var this$1 = this;
+
+    this._unwatchResults = this.$watch('results', function (val) {
+      this$1.valid = _walkValid(
+        this$1._keysCached(this$1._uid.toString(), this$1.results),
+        this$1.results
+      );
+      if (this$1.valid) {
+        toggleClasses(this$1.$el, this$1.classes.valid, addClass);
+        toggleClasses(this$1.$el, this$1.classes.invalid, removeClass);
+      } else {
+        toggleClasses(this$1.$el, this$1.classes.valid, removeClass);
+        toggleClasses(this$1.$el, this$1.classes.invalid, addClass);
+      }
+
+      this$1._fireEvent(this$1.valid ? 'valid' : 'invalid');
+    }, { deep: true });
+  }
+
+  function _unwatchValidationRawResults () {
+    this._unwatchResults();
+    this._unwatchResults = undefined;
+    delete this._unwatchResults;
+  }
+
+  function touch () {
+    this.willUpdateTouched();
+  }
+
+  return {
+    getValue: getValue,
+    checkModified: checkModified,
+    willUpdateTouched: willUpdateTouched,
+    willUpdateDirty: willUpdateDirty,
+    willUpdateModified: willUpdateModified,
+    handleInputable: handleInputable,
+    watchInputable: watchInputable,
+    reset: reset,
+    _walkValid: _walkValid,
+    _watchValidationRawResults: _watchValidationRawResults,
+    _unwatchValidationRawResults: _unwatchValidationRawResults,
+    touch: touch
+  }
+};
+
+/*  */
+
+/**
+ * Forgiving check for a promise
+ */
+function isPromise (p) {
+  return p && typeof p.then === 'function'
+}
+
+var Validate = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+  var isPlainObject = ref.isPlainObject;
+  var resolveAsset = ref.resolveAsset;
+
+  function _resolveValidator (name) {
+    var options = (this.child && this.child.context)
+      ? this.child.context.$options
+      : this.$options;
+    return resolveAsset(options, 'validators', name)
+  }
+
+  function _getValidateRawDescriptor (
+    validator,
+    field,
+    value
+  ) {
+    var asset = this._resolveValidator(validator);
+    if (!asset) {
+      // TODO: should be warned
+      return null
+    }
+
+    var fn = null;
+    var rule = null;
+    var msg = null;
+    if (isPlainObject(asset)) {
+      if (asset.check && typeof asset.check === 'function') {
+        fn = asset.check;
+      }
+      if (asset.message) {
+        msg = asset.message;
+      }
+    } else if (typeof asset === 'function') {
+      fn = asset;
+    } else {
+      // TODO: should be warned
+      return null
+    }
+
+    if (!fn) {
+      // TODO: should be warned
+      return null
+    }
+
+    var props = null;
+    var validators = this.validators;
+    if (isPlainObject(validators)) {
+      if (isPlainObject(validators[validator])) {
+        if (validators[validator].props && isPlainObject(validators[validator].props)) {
+          props = validators[validator].props;
+        } else {
+          if (validators[validator].rule) {
+            rule = validators[validator].rule;
+          }
+          if (validators[validator].message) {
+            msg = validators[validator].message;
+          }
+        }
+      } else {
+        rule = validators[validator];
+      }
+    }
+
+    var descriptor = { fn: fn, value: value, field: field };
+    if (rule) {
+      descriptor.rule = rule;
+    }
+    if (msg) {
+      descriptor.msg = msg;
+    }
+    if (props) {
+      descriptor.props = props;
+    }
+
+    return descriptor
+  }
+
+  function _resolveMessage (
+    field,
+    msg,
+    override
+  ) {
+    if (override) { return override }
+    return msg
+      ? typeof msg === 'function'
+        ? msg(field)
+        : msg
+      : undefined
+  }
+
+  function _invokeValidator (
+    ref,
+    value,
+    cb
+  ) {
+    var this$1 = this;
+    var fn = ref.fn;
+    var field = ref.field;
+    var rule = ref.rule;
+    var msg = ref.msg;
+
+    var future = fn.call(this.child.context, value, rule);
+    if (typeof future === 'function') { // function
+      future(function () { // resolve
+        cb(true);
+      }, function (err) { // reject
+        cb(false, this$1._resolveMessage(field, msg, err));
+      });
+    } else if (isPromise(future)) { // promise
+      future.then(function () { // resolve
+        cb(true);
+      }, function (err) { // reject
+        cb(false, this$1._resolveMessage(field, msg, err));
+      }).catch(function (err) {
+        cb(false, this$1._resolveMessage(field, msg, err.message));
+      });
+    } else { // sync
+      cb(future, future === false ? this._resolveMessage(field, msg) : undefined);
+    }
+  }
+
+  function _getValidateDescriptors (
+    validator,
+    field,
+    value
+  ) {
+    var descriptors = [];
+
+    var rawDescriptor = this._getValidateRawDescriptor(validator, this.field, value);
+    if (!rawDescriptor) { return descriptors }
+
+    if (!rawDescriptor.props) {
+      var descriptor = { name: validator };
+      extend(descriptor, rawDescriptor);
+      descriptors.push(descriptor);
+    } else {
+      var propsKeys = Object.keys(!rawDescriptor.props);
+      propsKeys.forEach(function (prop) {
+        var descriptor = {
+          fn: rawDescriptor.fn,
+          name: validator,
+          value: rawDescriptor.value[prop],
+          field: rawDescriptor.field,
+          prop: prop
+        };
+        if (rawDescriptor.props[prop].rule) {
+          descriptor.rule = rawDescriptor.props[prop].rule;
+        }
+        if (rawDescriptor.props[prop].message) {
+          descriptor.msg = rawDescriptor.props[prop].message;
+        }
+        descriptors.push(descriptor);
+      });
+    }
+
+    return descriptors
+  }
+
+  function _syncValidates (field, cb) {
+    var this$1 = this;
+
+    var validators = this._keysCached(this._uid.toString(), this.results);
+    var value = this.getValue();
+    var descriptors = [];
+    validators.forEach(function (validator) {
+      this$1._getValidateDescriptors(validator, field, value).forEach(function (desc) {
+        descriptors.push(desc);
+      });
+    });
+
+    var count = 0;
+    var len = descriptors.length;
+    descriptors.forEach(function (desc) {
+      var validator = desc.name;
+      var prop = desc.prop;
+      if ((!prop && this$1.progresses[validator]) || (prop && this$1.progresses[validator][prop])) {
+        count++;
+        if (count === len) {
+          cb(this$1._walkValid(this$1._keysCached(this$1._uid.toString(), this$1.results), this$1.results));
+        }
+        return
+      }
+
+      if (!prop) {
+        this$1.progresses[validator] = 'running';
+      } else {
+        this$1.progresses[validator][prop] = 'running';
+      }
+
+      this$1.$nextTick(function () {
+        this$1._invokeValidator(desc, desc.value, function (ret, msg) {
+          if (!prop) {
+            this$1.progresses[validator] = '';
+            this$1.results[validator] = msg || ret;
+          } else {
+            this$1.progresses[validator][prop] = '';
+            this$1.results[validator][prop] = msg || ret;
+          }
+
+          count++;
+          if (count === len) {
+            cb(this$1._walkValid(this$1._keysCached(this$1._uid.toString(), this$1.results), this$1.results));
+          }
+        });
+      });
+    });
+  }
+
+  // TODO:should be refactor!!
+  function _validate (validator, value, cb) {
+    var this$1 = this;
+
+    var descriptor = this._getValidateRawDescriptor(validator, this.field, value);
+    if (descriptor && !descriptor.props) {
+      if (this.progresses[validator]) { return false }
+      this.progresses[validator] = 'running';
+      this.$nextTick(function () {
+        this$1._invokeValidator(descriptor, descriptor.value, function (ret, msg) {
+          this$1.progresses[validator] = '';
+          this$1.results[validator] = msg || ret;
+          if (cb) {
+            this$1.$nextTick(function () {
+              cb.call(this$1, null, ret, msg);
+            });
+          } else {
+            var e = { result: ret };
+            if (msg) {
+              e['msg'] = msg;
+            }
+            this$1._fireEvent('validate', validator, e);
+          }
+        });
+      });
+    } else if (descriptor && descriptor.props) {
+      var propsKeys = Object.keys(descriptor.props);
+      propsKeys.forEach(function (prop) {
+        if (this$1.progresses[validator][prop]) { return }
+        this$1.progresses[validator][prop] = 'running';
+        var values = descriptor.value;
+        var propDescriptor = {
+          fn: descriptor.fn,
+          value: values[prop],
+          field: descriptor.field
+        };
+        if (descriptor.props[prop].rule) {
+          propDescriptor.rule = descriptor.props[prop].rule;
+        }
+        if (descriptor.props[prop].message) {
+          propDescriptor.msg = descriptor.props[prop].message;
+        }
+        this$1.$nextTick(function () {
+          this$1._invokeValidator(propDescriptor, propDescriptor.value, function (result, msg) {
+            this$1.progresses[validator][prop] = '';
+            this$1.results[validator][prop] = msg || result;
+            var e = { prop: prop, result: result };
+            if (msg) {
+              e['msg'] = msg;
+            }
+            this$1._fireEvent('validate', validator, e);
+          });
+        });
+      });
+    } else {
+      // TODO:
+      var err = new Error();
+      cb ? cb.call(this, err) : this._fireEvent('validate', validator, err);
+    }
+    return true
+  }
+
+  // TODO: should be re-design of API
+  function validate () {
+    var this$1 = this;
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
+
+    var validators;
+    var value;
+    var cb;
+    var ret = true;
+
+    if (args.length === 3) {
+      validators = [args[0]];
+      value = args[1];
+      cb = args[2];
+    } else if (args.length === 2) {
+      if (isPlainObject(args[0])) {
+        validators = [args[0].validator];
+        value = args[0].value || this.getValue();
+        cb = args[1];
+      } else {
+        validators = this._keysCached(this._uid.toString(), this.results);
+        value = args[0];
+        cb = args[1];
+      }
+    } else if (args.length === 1) {
+      validators = this._keysCached(this._uid.toString(), this.results);
+      value = this.getValue();
+      cb = args[0];
+    } else {
+      validators = this._keysCached(this._uid.toString(), this.results);
+      value = this.getValue();
+      cb = null;
+    }
+
+    if (args.length === 3 || (args.length === 2 && isPlainObject(args[0]))) {
+      ret = this._validate(validators[0], value, cb);
+    } else {
+      validators.forEach(function (validator) {
+        ret = this$1._validate(validator, value, cb);
+      });
+    }
+
+    return ret
+  }
+
+  return {
+    _resolveValidator: _resolveValidator,
+    _getValidateRawDescriptor: _getValidateRawDescriptor,
+    _getValidateDescriptors: _getValidateDescriptors,
+    _resolveMessage: _resolveMessage,
+    _invokeValidator: _invokeValidator,
+    _validate: _validate,
+    _syncValidates: _syncValidates,
+    validate: validate
+  }
+};
+
+/*  */
+
+var Methods = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+
+  var methods = {};
+  extend(methods, Event(Vue));
+  extend(methods, State(Vue));
+  extend(methods, Validate(Vue));
+
+  return methods
+};
+
+/*  */
+
+var ValidityControl = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+
+  var ref$1 = States(Vue);
+  var props = ref$1.props;
+  var data = ref$1.data;
+  var computed = Computed(Vue);
+  var lifecycles = Lifecycles(Vue);
+  var ref$2 = Render(Vue);
+  var render = ref$2.render;
+  var methods = Methods(Vue);
+
+  var validity = {
+    props: props,
+    data: data,
+    render: render,
+    computed: computed,
+    methods: methods
+  };
+  extend(validity, lifecycles);
+
+  return validity
+};
+
+/*  */
+var Validity = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+
+  return {
+    functional: true,
+    props: baseProps,
+    render: function render (
+      h,
+      ref
+    ) {
+      var props = ref.props;
+      var data = ref.data;
+      var children = ref.children;
+
+      return children.map(function (child) {
+        if (!child.tag) { return child }
+        var newData = extend({}, data);
+        newData.props = extend({}, props);
+        // TODO: should be refactored
+        newData.props.classes = extend(extend(extend({}, DEFAULT_CLASSES), Vue.config.validator.classes), newData.props.classes);
+        newData.props.child = child;
+        return h('validity-control', newData)
+      })
+    }
+  }
+};
+
+/*  */
+var ValidityGroup = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+
+  var props = extend({
+    tag: {
+      type: String,
+      default: 'fieldset'
+    }
+  }, baseProps);
+
+  return {
+    functional: true,
+    props: props,
+    render: function render (
+      h,
+      ref
+    ) {
+      var props = ref.props;
+      var data = ref.data;
+      var children = ref.children;
+
+      var child = h(props.tag, children);
+      var newData = extend({}, data);
+      newData.props = extend({}, props);
+      // TODO: should be refactored
+      newData.props.classes = extend(extend(extend({}, DEFAULT_CLASSES), Vue.config.validator.classes), newData.props.classes);
+      newData.props.child = child;
+      newData.props.multiple = true;
+      return h('validity-control', newData)
+    }
+  }
+};
+
+/*  */
+
+var Validation = function (Vue) {
+  var ref = Vue.util;
+  var extend = ref.extend;
+
+  return {
+    functional: true,
+    props: {
+      name: {
+        type: String
+      },
+      tag: {
+        type: String,
+        default: 'form'
+      }
+    },
+    render: function render (
+      h,
+      ref
+    ) {
+      var props = ref.props;
+      var data = ref.data;
+      var parent = ref.parent;
+      var children = ref.children;
+      var slots = ref.slots;
+
+      if (!parent._validation) {
+        // TODO: should be warned
+        return children
+      }
+      var tag = props.tag || 'form';
+      walkChildren(parent._validation, props.name, children);
+      var newData = extend({ attrs: {}}, data);
+      if (tag === 'form') {
+        newData.attrs.novalidate = true;
+      }
+      return h(tag, newData, children)
+    }
+  }
+};
+
+function walkChildren (validation, name, children) {
+  children.forEach(function (child) {
+    if (child &&
+        child.componentOptions &&
+        child.componentOptions.propsData && child.componentOptions.tag === 'validity-control') {
+      child.componentOptions.propsData.validation = {
+        instance: validation,
+        name: name
+      };
+    }
+    child.children && walkChildren(validation, name, child.children);
+  });
+}
+
+/*  */
+var Component = function (Vue) {
+  return {
+    'validity-control': ValidityControl(Vue),
+    'validity': Validity(Vue),
+    'validity-group': ValidityGroup(Vue),
+    'validation': Validation(Vue)
+  }
+};
+
+/*  */
+// TODO: should be defined strict type
+function mapValidation (results) {
+  var res = {};
+
+  normalizeMap(results).forEach(function (ref) {
+    var key = ref.key;
+    var val = ref.val;
+
+    res[key] = function mappedValidation () {
+      var validation = this.$validation;
+      if (!this._isMounted) {
+        return null
+      }
+      var paths = val.split('.');
+      var first = paths.shift();
+      if (first !== '$validation') {
+        warn(("unknown validation result path: " + val));
+        return null
+      }
+      var path;
+      var value = validation;
+      do {
+        path = paths.shift();
+        value = value[path];
+      } while (paths.length > 0 && value !== undefined)
+      return value
+    };
+  });
+
+  return res
+}
+
+// TODO: should be defined strict type
+function normalizeMap (map) {
+  return Array.isArray(map)
+    ? map.map(function (key) { return ({ key: key, val: key }); })
+    : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })
+}
+
+/*  */
+var installed = false;
+
+function plugin (Vue, options) {
+  if ( options === void 0 ) options = {};
+
+  if (installed) {
+    warn('already installed.');
+    return
+  }
+
+  Config(Vue);
+  Asset(Vue);
+  installMixin(Vue);
+  installComponent(Vue);
+  installed = true;
+}
+
+function installMixin (Vue) {
+  Vue.mixin(Mixin(Vue));
+}
+
+function installComponent (Vue) {
+  var components = Component(Vue);
+  Object.keys(components).forEach(function (id) {
+    Vue.component(id, components[id]);
+  });
+}
+
+plugin.mapValidation = mapValidation; // for standalone
+plugin.version = '3.0.0-alpha.2';
+
+if (typeof window !== 'undefined' && window.Vue) {
+  window.Vue.use(plugin);
+}
+
+var index = {
+  install: plugin,
+  mapValidation: mapValidation
+};
+
+return index;
+
+})));