vueonrails 0.1.0 → 0.2.0

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

@@ -1,2054 +0,0 @@
-/*!
- * 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;
-
-})));