@arco-design/mobile-react 2.38.2 → 2.38.4

package/dist/index.js

@@ -1981,1582 +1981,1582 @@
       return targetMT;
     };
 
-    var __extends = undefined && undefined.__extends || function () {
-      var _extendStatics = function extendStatics(d, b) {
-        _extendStatics = Object.setPrototypeOf || {
-          __proto__: []
-        } instanceof Array && function (d, b) {
-          d.__proto__ = b;
-        } || function (d, b) {
-          for (var p in b) {
-            if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-          }
-        };
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-        return _extendStatics(d, b);
-      };
+    function createCommonjsModule(fn, basedir, module) {
+    	return module = {
+    		path: basedir,
+    		exports: {},
+    		require: function (path, base) {
+    			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+    		}
+    	}, fn(module, module.exports), module.exports;
+    }
 
-      return function (d, b) {
-        _extendStatics(d, b);
+    function commonjsRequire () {
+    	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+    }
 
-        function __() {
-          this.constructor = d;
-        }
+    var es6Promise$1 = createCommonjsModule(function (module, exports) {
+    /*!
+     * @overview es6-promise - a tiny implementation of Promises/A+.
+     * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
+     * @license   Licensed under MIT license
+     *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
+     * @version   v4.2.8+1e68dce6
+     */
 
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-      };
-    }();
+    (function (global, factory) {
+    	module.exports = factory() ;
+    }(commonjsGlobal, (function () {
+    function objectOrFunction(x) {
+      var type = typeof x;
+      return x !== null && (type === 'object' || type === 'function');
+    }
 
-    var __assign$1 = undefined && undefined.__assign || function () {
-      __assign$1 = Object.assign || function (t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
+    function isFunction(x) {
+      return typeof x === 'function';
+    }
 
-          for (var p in s) {
-            if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-          }
-        }
 
-        return t;
+
+    var _isArray = void 0;
+    if (Array.isArray) {
+      _isArray = Array.isArray;
+    } else {
+      _isArray = function (x) {
+        return Object.prototype.toString.call(x) === '[object Array]';
       };
+    }
 
-      return __assign$1.apply(this, arguments);
-    };
+    var isArray = _isArray;
 
-    var __rest = undefined && undefined.__rest || function (s, e) {
-      var t = {};
+    var len = 0;
+    var vertxNext = void 0;
+    var customSchedulerFn = void 0;
 
-      for (var p in s) {
-        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    var asap = function asap(callback, arg) {
+      queue[len] = callback;
+      queue[len + 1] = arg;
+      len += 2;
+      if (len === 2) {
+        // If len is 2, that means that we need to schedule an async flush.
+        // If additional callbacks are queued before the queue is flushed, they
+        // will be processed by this flush that we are scheduling.
+        if (customSchedulerFn) {
+          customSchedulerFn(flush);
+        } else {
+          scheduleFlush();
+        }
       }
+    };
 
-      if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-      }
-      return t;
-    }; // eslint-disable-next-line max-classes-per-file
+    function setScheduler(scheduleFn) {
+      customSchedulerFn = scheduleFn;
+    }
 
-    var BaseValidator =
-    /** @class */
-    function () {
-      function BaseValidator(value, rule, options) {
-        this.value = value;
+    function setAsap(asapFn) {
+      asap = asapFn;
+    }
 
-        var _a = rule.message,
-            message = _a === void 0 ? '' : _a,
-            rest = __rest(rule, ["message"]);
+    var browserWindow = typeof window !== 'undefined' ? window : undefined;
+    var browserGlobal = browserWindow || {};
+    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+    var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
 
-        this.message = message || '';
-        this.type = rule.type || ValidatorType.String;
-        this.error = {
-          value: value,
-          message: [],
-          errorTypes: []
+    // test for web worker but not in IE10
+    var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
+
+    // node
+    function useNextTick() {
+      // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+      // see https://github.com/cujojs/when/issues/410 for details
+      return function () {
+        return process.nextTick(flush);
+      };
+    }
+
+    // vertx
+    function useVertxTimer() {
+      if (typeof vertxNext !== 'undefined') {
+        return function () {
+          vertxNext(flush);
         };
-        this.field = options.field || '';
-        this.rule = rest;
-        this.validateRules = [];
-        this.curValidMsgTemplate = mergeMsgTemplate(messageTemplate, options.validateMessage);
       }
 
-      BaseValidator.prototype.isRequired = function () {
-        // 优先级最高
-        if (isEmptyValue(this.value) || isEmptyArray(this.value)) {
-          this.error.message = [this.message || getMsgTemplate(this.curValidMsgTemplate, 'required', [this.field])];
-          this.error.errorTypes = ['required'];
-          return false;
-        }
+      return useSetTimeout();
+    }
 
-        return true;
+    function useMutationObserver() {
+      var iterations = 0;
+      var observer = new BrowserMutationObserver(flush);
+      var node = document.createTextNode('');
+      observer.observe(node, { characterData: true });
+
+      return function () {
+        node.data = iterations = ++iterations % 2;
       };
+    }
 
-      BaseValidator.prototype.addError = function (errorType, message) {
-        var _a;
+    // web worker
+    function useMessageChannel() {
+      var channel = new MessageChannel();
+      channel.port1.onmessage = flush;
+      return function () {
+        return channel.port2.postMessage(0);
+      };
+    }
 
-        if (message) {
-          this.error.errorTypes.push(errorType);
-          (_a = this.error.message) === null || _a === void 0 ? void 0 : _a.push(message);
-        }
+    function useSetTimeout() {
+      // Store setTimeout reference so es6-promise will be unaffected by
+      // other code modifying setTimeout (like sinon.useFakeTimers())
+      var globalSetTimeout = setTimeout;
+      return function () {
+        return globalSetTimeout(flush, 1);
       };
+    }
 
-      BaseValidator.prototype.dealError = function (isError, _a) {
-        var _b;
+    var queue = new Array(1000);
+    function flush() {
+      for (var i = 0; i < len; i += 2) {
+        var callback = queue[i];
+        var arg = queue[i + 1];
 
-        var errTemplate = _a.errTemplate,
-            values = _a.values;
+        callback(arg);
 
-        if (isError) {
-          var theMessage = this.message || getMsgTemplate(this.curValidMsgTemplate, errTemplate, values);
-          this.error.errorTypes.push(errTemplate);
-          (_b = this.error.message) === null || _b === void 0 ? void 0 : _b.push(theMessage);
-          return theMessage;
-        }
+        queue[i] = undefined;
+        queue[i + 1] = undefined;
+      }
 
-        return '';
-      };
+      len = 0;
+    }
 
-      BaseValidator.prototype.getErrors = function () {
-        return this.error;
-      };
+    function attemptVertx() {
+      try {
+        var vertx = Function('return this')().require('vertx');
+        vertxNext = vertx.runOnLoop || vertx.runOnContext;
+        return useVertxTimer();
+      } catch (e) {
+        return useSetTimeout();
+      }
+    }
 
-      return BaseValidator;
-    }();
+    var scheduleFlush = void 0;
+    // Decide what async method to use to triggering processing of queued callbacks:
+    if (isNode) {
+      scheduleFlush = useNextTick();
+    } else if (BrowserMutationObserver) {
+      scheduleFlush = useMutationObserver();
+    } else if (isWorker) {
+      scheduleFlush = useMessageChannel();
+    } else if (browserWindow === undefined && typeof commonjsRequire === 'function') {
+      scheduleFlush = attemptVertx();
+    } else {
+      scheduleFlush = useSetTimeout();
+    }
 
-    var BooleanValidator =
-    /** @class */
-    function (_super) {
-      __extends(BooleanValidator, _super);
+    function then(onFulfillment, onRejection) {
+      var parent = this;
 
-      function BooleanValidator(value, rules, options) {
-        var _this = _super.call(this, value, rules, options) || this;
+      var child = new this.constructor(noop);
 
-        _this.validateRules = ['equal'];
-        return _this;
+      if (child[PROMISE_ID] === undefined) {
+        makePromise(child);
       }
 
-      BooleanValidator.prototype.equal = function (str) {
-        return this.dealError(!isEmptyValue(this.value) && this.value !== str, {
-          errTemplate: 'boolean.equal',
-          values: [this.field, "" + str]
-        });
-      };
+      var _state = parent._state;
 
-      return BooleanValidator;
-    }(BaseValidator);
 
-    var NumberValidator =
-    /** @class */
-    function (_super) {
-      __extends(NumberValidator, _super);
-
-      function NumberValidator(value, rules, options) {
-        var _this = _super.call(this, value, rules, options) || this;
-
-        _this.validateRules = ['min', 'max', 'equal', 'positive', 'negative'];
-        return _this;
+      if (_state) {
+        var callback = arguments[_state - 1];
+        asap(function () {
+          return invokeCallback(_state, child, callback, parent._result);
+        });
+      } else {
+        subscribe(parent, child, onFulfillment, onRejection);
       }
 
-      NumberValidator.prototype.min = function (num) {
-        this.dealError(!isEmptyValue(this.value) && this.value < num, {
-          errTemplate: 'number.min',
-          values: [this.field, "" + num]
-        });
-      };
+      return child;
+    }
 
-      NumberValidator.prototype.max = function (num) {
-        this.dealError(!isEmptyValue(this.value) && this.value > num, {
-          errTemplate: 'number.max',
-          values: [this.field, "" + num]
-        });
-      };
+    /**
+      `Promise.resolve` returns a promise that will become resolved with the
+      passed `value`. It is shorthand for the following:
 
-      NumberValidator.prototype.equal = function (num) {
-        return this.dealError(!isEmptyValue(this.value) && this.value !== num, {
-          errTemplate: 'number.equal',
-          values: [this.field, "" + num]
-        });
-      };
+      ```javascript
+      let promise = new Promise(function(resolve, reject){
+        resolve(1);
+      });
 
-      NumberValidator.prototype.positive = function () {
-        return this.dealError(!isEmptyValue(this.value) && this.value < 0, {
-          errTemplate: 'number.positive',
-          values: [this.field]
-        });
-      };
+      promise.then(function(value){
+        // value === 1
+      });
+      ```
 
-      NumberValidator.prototype.negative = function () {
-        return this.dealError(!isEmptyValue(this.value) && this.value > 0, {
-          errTemplate: 'number.negative',
-          values: [this.field]
-        });
-      };
+      Instead of writing the above, your code now simply becomes the following:
 
-      return NumberValidator;
-    }(BaseValidator);
+      ```javascript
+      let promise = Promise.resolve(1);
 
-    var StringValidator =
-    /** @class */
-    function (_super) {
-      __extends(StringValidator, _super);
+      promise.then(function(value){
+        // value === 1
+      });
+      ```
 
-      function StringValidator(value, rules, options) {
-        var _this = _super.call(this, value, rules, options) || this;
+      @method resolve
+      @static
+      @param {Any} value value that the returned promise will be resolved with
+      Useful for tooling.
+      @return {Promise} a promise that will become fulfilled with the given
+      `value`
+    */
+    function resolve$1(object) {
+      /*jshint validthis:true */
+      var Constructor = this;
 
-        _this.validateRules = ['min', 'max', 'len', 'equal', 'match', 'uppercase', 'lowercase', 'whitespace'];
-        return _this;
+      if (object && typeof object === 'object' && object.constructor === Constructor) {
+        return object;
       }
 
-      StringValidator.prototype.min = function (num) {
-        return this.dealError(!isEmptyValue(this.value) && this.value.length < num, {
-          errTemplate: 'string.min',
-          values: [this.field, "" + num]
-        });
-      };
+      var promise = new Constructor(noop);
+      resolve(promise, object);
+      return promise;
+    }
 
-      StringValidator.prototype.max = function (num) {
-        return this.dealError(!isEmptyValue(this.value) && this.value.length > num, {
-          errTemplate: 'string.max',
-          values: [this.field, "" + num]
-        });
-      };
+    var PROMISE_ID = Math.random().toString(36).substring(2);
 
-      StringValidator.prototype.len = function (num) {
-        return this.dealError(!isEmptyValue(this.value) && this.value.length !== num, {
-          errTemplate: 'string.len',
-          values: [this.field, "" + num]
-        });
-      };
+    function noop() {}
 
-      StringValidator.prototype.equal = function (str) {
-        return this.dealError(!isEmptyValue(this.value) && this.value !== str, {
-          errTemplate: 'string.equal',
-          values: [this.field, "" + str]
-        });
-      };
+    var PENDING = void 0;
+    var FULFILLED = 1;
+    var REJECTED = 2;
 
-      StringValidator.prototype.match = function (regStr) {
-        var reg = new RegExp(regStr);
-        return this.dealError(!isEmptyValue(this.value) && !reg.test(this.value), {
-          errTemplate: 'string.match',
-          values: [this.field, regStr]
-        });
-      };
+    function selfFulfillment() {
+      return new TypeError("You cannot resolve a promise with itself");
+    }
 
-      StringValidator.prototype.uppercase = function (isValue) {
-        var isUppercase = (this.value || '').toLocaleUpperCase() === this.value;
-        return this.dealError(!isEmptyValue(this.value) && isUppercase !== isValue, {
-          errTemplate: 'string.uppercase',
-          values: [this.field]
-        });
-      };
+    function cannotReturnOwn() {
+      return new TypeError('A promises callback cannot return that same promise.');
+    }
 
-      StringValidator.prototype.lowercase = function (isValue) {
-        var isLowercase = (this.value || '').toLocaleLowerCase() === this.value;
-        return this.dealError(!isEmptyValue(this.value) && isLowercase !== isValue, {
-          errTemplate: 'string.lowercase',
-          values: [this.field]
-        });
-      };
+    function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
+      try {
+        then$$1.call(value, fulfillmentHandler, rejectionHandler);
+      } catch (e) {
+        return e;
+      }
+    }
 
-      StringValidator.prototype.whitespace = function () {
-        return this.dealError(!isEmptyValue(this.value) && isEmptyValue(this.value.trim()), {
-          errTemplate: 'string.whitespace',
-          values: [this.field]
-        });
-      };
+    function handleForeignThenable(promise, thenable, then$$1) {
+      asap(function (promise) {
+        var sealed = false;
+        var error = tryThen(then$$1, thenable, function (value) {
+          if (sealed) {
+            return;
+          }
+          sealed = true;
+          if (thenable !== value) {
+            resolve(promise, value);
+          } else {
+            fulfill(promise, value);
+          }
+        }, function (reason) {
+          if (sealed) {
+            return;
+          }
+          sealed = true;
 
-      return StringValidator;
-    }(BaseValidator);
+          reject(promise, reason);
+        }, 'Settle: ' + (promise._label || ' unknown promise'));
 
-    var ArrayValidator =
-    /** @class */
-    function (_super) {
-      __extends(ArrayValidator, _super);
+        if (!sealed && error) {
+          sealed = true;
+          reject(promise, error);
+        }
+      }, promise);
+    }
 
-      function ArrayValidator(value, rules, options) {
-        var _this = _super.call(this, value, rules, options) || this;
+    function handleOwnThenable(promise, thenable) {
+      if (thenable._state === FULFILLED) {
+        fulfill(promise, thenable._result);
+      } else if (thenable._state === REJECTED) {
+        reject(promise, thenable._result);
+      } else {
+        subscribe(thenable, undefined, function (value) {
+          return resolve(promise, value);
+        }, function (reason) {
+          return reject(promise, reason);
+        });
+      }
+    }
 
-        _this.validateRules = ['min', 'max', 'deepEqual', 'includes'];
-        return _this;
+    function handleMaybeThenable(promise, maybeThenable, then$$1) {
+      if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
+        handleOwnThenable(promise, maybeThenable);
+      } else {
+        if (then$$1 === undefined) {
+          fulfill(promise, maybeThenable);
+        } else if (isFunction(then$$1)) {
+          handleForeignThenable(promise, maybeThenable, then$$1);
+        } else {
+          fulfill(promise, maybeThenable);
+        }
       }
+    }
 
-      ArrayValidator.prototype.min = function (num) {
-        return this.dealError(!isEmptyValue(this.value) && this.value.length < num, {
-          errTemplate: 'array.min',
-          values: [this.field, "" + num]
-        });
-      };
+    function resolve(promise, value) {
+      if (promise === value) {
+        reject(promise, selfFulfillment());
+      } else if (objectOrFunction(value)) {
+        var then$$1 = void 0;
+        try {
+          then$$1 = value.then;
+        } catch (error) {
+          reject(promise, error);
+          return;
+        }
+        handleMaybeThenable(promise, value, then$$1);
+      } else {
+        fulfill(promise, value);
+      }
+    }
 
-      ArrayValidator.prototype.max = function (num) {
-        return this.dealError(!isEmptyValue(this.value) && this.value.length > num, {
-          errTemplate: 'array.max',
-          values: [this.field, "" + num]
-        });
-      };
+    function publishRejection(promise) {
+      if (promise._onerror) {
+        promise._onerror(promise._result);
+      }
 
-      ArrayValidator.prototype.deepEqual = function (sub) {
-        return this.dealError(!isDeepEqual(this.value, sub), {
-          errTemplate: 'array.equal',
-          values: [this.field, "" + JSON.stringify(sub)]
-        });
-      };
-
-      ArrayValidator.prototype.includes = function (sub) {
-        var _this = this;
-
-        return this.dealError(sub.some(function (el) {
-          return !_this.value.includes(el);
-        }), {
-          errTemplate: 'array.includes',
-          values: [this.field, "" + JSON.stringify(sub)]
-        });
-      };
+      publish(promise);
+    }
 
-      return ArrayValidator;
-    }(BaseValidator);
+    function fulfill(promise, value) {
+      if (promise._state !== PENDING) {
+        return;
+      }
 
-    var ObjectValidator =
-    /** @class */
-    function (_super) {
-      __extends(ObjectValidator, _super);
+      promise._result = value;
+      promise._state = FULFILLED;
 
-      function ObjectValidator(value, rules, options) {
-        var _this = _super.call(this, value, rules, options) || this;
+      if (promise._subscribers.length !== 0) {
+        asap(publish, promise);
+      }
+    }
 
-        _this.validateRules = ['deepEqual', 'hasKeys'];
-        return _this;
+    function reject(promise, reason) {
+      if (promise._state !== PENDING) {
+        return;
       }
+      promise._state = REJECTED;
+      promise._result = reason;
 
-      ObjectValidator.prototype.deepEqual = function (sub) {
-        return this.dealError(!isDeepEqual(this.value, sub), {
-          errTemplate: 'object.deepEqual',
-          values: [this.field, "" + JSON.stringify(sub)]
-        });
-      };
+      asap(publishRejection, promise);
+    }
 
-      ObjectValidator.prototype.hasKeys = function (keys) {
-        var allKeys = isEmptyValue(this.value) ? [] : Object.keys(this.value);
-        return this.dealError(!isEmptyValue(this.value) && keys.some(function (theKey) {
-          return !allKeys.includes(theKey);
-        }), {
-          errTemplate: 'object.hasKeys',
-          values: [this.field, "" + JSON.stringify(keys)]
-        });
-      };
+    function subscribe(parent, child, onFulfillment, onRejection) {
+      var _subscribers = parent._subscribers;
+      var length = _subscribers.length;
 
-      return ObjectValidator;
-    }(BaseValidator);
 
-    var CustomValidator =
-    /** @class */
-    function (_super) {
-      __extends(CustomValidator, _super);
+      parent._onerror = null;
 
-      function CustomValidator(value, rules, options) {
-        return _super.call(this, value, rules, options) || this;
+      _subscribers[length] = child;
+      _subscribers[length + FULFILLED] = onFulfillment;
+      _subscribers[length + REJECTED] = onRejection;
+
+      if (length === 0 && parent._state) {
+        asap(publish, parent);
       }
+    }
 
-      CustomValidator.prototype.validator = function (validatorTool) {
-        var _this = this;
+    function publish(promise) {
+      var subscribers = promise._subscribers;
+      var settled = promise._state;
 
-        if (validatorTool) {
-          return new Promise(function (resolve) {
-            var validateLevel = _this.rule.validateLevel || 'error';
-            var ret = validatorTool(_this.value, function (message) {
-              if (message === void 0) {
-                message = '';
-              }
+      if (subscribers.length === 0) {
+        return;
+      }
 
-              return _this.addError('custom', message || '');
-            });
+      var child = void 0,
+          callback = void 0,
+          detail = promise._result;
 
-            if (ret && (ret === null || ret === void 0 ? void 0 : ret.then)) {
-              ret.then(function () {
-                return resolve(__assign$1(__assign$1({}, _this.getErrors()), {
-                  validateLevel: validateLevel
-                }));
-              });
-            } else {
-              resolve(__assign$1(__assign$1({}, _this.getErrors()), {
-                validateLevel: validateLevel
-              }));
-            }
-          });
+      for (var i = 0; i < subscribers.length; i += 3) {
+        child = subscribers[i];
+        callback = subscribers[i + settled];
+
+        if (child) {
+          invokeCallback(settled, child, callback, detail);
+        } else {
+          callback(detail);
         }
+      }
 
-        return null;
-      };
+      promise._subscribers.length = 0;
+    }
 
-      return CustomValidator;
-    }(BaseValidator);
+    function invokeCallback(settled, promise, callback, detail) {
+      var hasCallback = isFunction(callback),
+          value = void 0,
+          error = void 0,
+          succeeded = true;
 
-    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+      if (hasCallback) {
+        try {
+          value = callback(detail);
+        } catch (e) {
+          succeeded = false;
+          error = e;
+        }
 
-    function createCommonjsModule(fn, basedir, module) {
-    	return module = {
-    		path: basedir,
-    		exports: {},
-    		require: function (path, base) {
-    			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-    		}
-    	}, fn(module, module.exports), module.exports;
-    }
+        if (promise === value) {
+          reject(promise, cannotReturnOwn());
+          return;
+        }
+      } else {
+        value = detail;
+      }
 
-    function commonjsRequire () {
-    	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+      if (promise._state !== PENDING) ; else if (hasCallback && succeeded) {
+        resolve(promise, value);
+      } else if (succeeded === false) {
+        reject(promise, error);
+      } else if (settled === FULFILLED) {
+        fulfill(promise, value);
+      } else if (settled === REJECTED) {
+        reject(promise, value);
+      }
     }
 
-    var es6Promise$1 = createCommonjsModule(function (module, exports) {
-    /*!
-     * @overview es6-promise - a tiny implementation of Promises/A+.
-     * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
-     * @license   Licensed under MIT license
-     *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
-     * @version   v4.2.8+1e68dce6
-     */
+    function initializePromise(promise, resolver) {
+      try {
+        resolver(function resolvePromise(value) {
+          resolve(promise, value);
+        }, function rejectPromise(reason) {
+          reject(promise, reason);
+        });
+      } catch (e) {
+        reject(promise, e);
+      }
+    }
 
-    (function (global, factory) {
-    	module.exports = factory() ;
-    }(commonjsGlobal, (function () {
-    function objectOrFunction(x) {
-      var type = typeof x;
-      return x !== null && (type === 'object' || type === 'function');
+    var id = 0;
+    function nextId() {
+      return id++;
     }
 
-    function isFunction(x) {
-      return typeof x === 'function';
+    function makePromise(promise) {
+      promise[PROMISE_ID] = id++;
+      promise._state = undefined;
+      promise._result = undefined;
+      promise._subscribers = [];
     }
 
+    function validationError() {
+      return new Error('Array Methods must be provided an Array');
+    }
 
+    var Enumerator = function () {
+      function Enumerator(Constructor, input) {
+        this._instanceConstructor = Constructor;
+        this.promise = new Constructor(noop);
 
-    var _isArray = void 0;
-    if (Array.isArray) {
-      _isArray = Array.isArray;
-    } else {
-      _isArray = function (x) {
-        return Object.prototype.toString.call(x) === '[object Array]';
-      };
-    }
+        if (!this.promise[PROMISE_ID]) {
+          makePromise(this.promise);
+        }
 
-    var isArray = _isArray;
+        if (isArray(input)) {
+          this.length = input.length;
+          this._remaining = input.length;
 
-    var len = 0;
-    var vertxNext = void 0;
-    var customSchedulerFn = void 0;
+          this._result = new Array(this.length);
 
-    var asap = function asap(callback, arg) {
-      queue[len] = callback;
-      queue[len + 1] = arg;
-      len += 2;
-      if (len === 2) {
-        // If len is 2, that means that we need to schedule an async flush.
-        // If additional callbacks are queued before the queue is flushed, they
-        // will be processed by this flush that we are scheduling.
-        if (customSchedulerFn) {
-          customSchedulerFn(flush);
+          if (this.length === 0) {
+            fulfill(this.promise, this._result);
+          } else {
+            this.length = this.length || 0;
+            this._enumerate(input);
+            if (this._remaining === 0) {
+              fulfill(this.promise, this._result);
+            }
+          }
         } else {
-          scheduleFlush();
+          reject(this.promise, validationError());
         }
       }
-    };
 
-    function setScheduler(scheduleFn) {
-      customSchedulerFn = scheduleFn;
-    }
+      Enumerator.prototype._enumerate = function _enumerate(input) {
+        for (var i = 0; this._state === PENDING && i < input.length; i++) {
+          this._eachEntry(input[i], i);
+        }
+      };
 
-    function setAsap(asapFn) {
-      asap = asapFn;
-    }
+      Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
+        var c = this._instanceConstructor;
+        var resolve$$1 = c.resolve;
 
-    var browserWindow = typeof window !== 'undefined' ? window : undefined;
-    var browserGlobal = browserWindow || {};
-    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-    var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
 
-    // test for web worker but not in IE10
-    var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
+        if (resolve$$1 === resolve$1) {
+          var _then = void 0;
+          var error = void 0;
+          var didError = false;
+          try {
+            _then = entry.then;
+          } catch (e) {
+            didError = true;
+            error = e;
+          }
 
-    // node
-    function useNextTick() {
-      // node version 0.10.x displays a deprecation warning when nextTick is used recursively
-      // see https://github.com/cujojs/when/issues/410 for details
-      return function () {
-        return process.nextTick(flush);
+          if (_then === then && entry._state !== PENDING) {
+            this._settledAt(entry._state, i, entry._result);
+          } else if (typeof _then !== 'function') {
+            this._remaining--;
+            this._result[i] = entry;
+          } else if (c === Promise$1) {
+            var promise = new c(noop);
+            if (didError) {
+              reject(promise, error);
+            } else {
+              handleMaybeThenable(promise, entry, _then);
+            }
+            this._willSettleAt(promise, i);
+          } else {
+            this._willSettleAt(new c(function (resolve$$1) {
+              return resolve$$1(entry);
+            }), i);
+          }
+        } else {
+          this._willSettleAt(resolve$$1(entry), i);
+        }
       };
-    }
-
-    // vertx
-    function useVertxTimer() {
-      if (typeof vertxNext !== 'undefined') {
-        return function () {
-          vertxNext(flush);
-        };
-      }
 
-      return useSetTimeout();
-    }
+      Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
+        var promise = this.promise;
 
-    function useMutationObserver() {
-      var iterations = 0;
-      var observer = new BrowserMutationObserver(flush);
-      var node = document.createTextNode('');
-      observer.observe(node, { characterData: true });
 
-      return function () {
-        node.data = iterations = ++iterations % 2;
-      };
-    }
+        if (promise._state === PENDING) {
+          this._remaining--;
 
-    // web worker
-    function useMessageChannel() {
-      var channel = new MessageChannel();
-      channel.port1.onmessage = flush;
-      return function () {
-        return channel.port2.postMessage(0);
-      };
-    }
+          if (state === REJECTED) {
+            reject(promise, value);
+          } else {
+            this._result[i] = value;
+          }
+        }
 
-    function useSetTimeout() {
-      // Store setTimeout reference so es6-promise will be unaffected by
-      // other code modifying setTimeout (like sinon.useFakeTimers())
-      var globalSetTimeout = setTimeout;
-      return function () {
-        return globalSetTimeout(flush, 1);
+        if (this._remaining === 0) {
+          fulfill(promise, this._result);
+        }
       };
-    }
 
-    var queue = new Array(1000);
-    function flush() {
-      for (var i = 0; i < len; i += 2) {
-        var callback = queue[i];
-        var arg = queue[i + 1];
-
-        callback(arg);
+      Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
+        var enumerator = this;
 
-        queue[i] = undefined;
-        queue[i + 1] = undefined;
-      }
+        subscribe(promise, undefined, function (value) {
+          return enumerator._settledAt(FULFILLED, i, value);
+        }, function (reason) {
+          return enumerator._settledAt(REJECTED, i, reason);
+        });
+      };
 
-      len = 0;
-    }
+      return Enumerator;
+    }();
 
-    function attemptVertx() {
-      try {
-        var vertx = Function('return this')().require('vertx');
-        vertxNext = vertx.runOnLoop || vertx.runOnContext;
-        return useVertxTimer();
-      } catch (e) {
-        return useSetTimeout();
-      }
-    }
+    /**
+      `Promise.all` accepts an array of promises, and returns a new promise which
+      is fulfilled with an array of fulfillment values for the passed promises, or
+      rejected with the reason of the first passed promise to be rejected. It casts all
+      elements of the passed iterable to promises as it runs this algorithm.
 
-    var scheduleFlush = void 0;
-    // Decide what async method to use to triggering processing of queued callbacks:
-    if (isNode) {
-      scheduleFlush = useNextTick();
-    } else if (BrowserMutationObserver) {
-      scheduleFlush = useMutationObserver();
-    } else if (isWorker) {
-      scheduleFlush = useMessageChannel();
-    } else if (browserWindow === undefined && typeof commonjsRequire === 'function') {
-      scheduleFlush = attemptVertx();
-    } else {
-      scheduleFlush = useSetTimeout();
-    }
+      Example:
 
-    function then(onFulfillment, onRejection) {
-      var parent = this;
+      ```javascript
+      let promise1 = resolve(1);
+      let promise2 = resolve(2);
+      let promise3 = resolve(3);
+      let promises = [ promise1, promise2, promise3 ];
 
-      var child = new this.constructor(noop);
+      Promise.all(promises).then(function(array){
+        // The array here would be [ 1, 2, 3 ];
+      });
+      ```
 
-      if (child[PROMISE_ID] === undefined) {
-        makePromise(child);
-      }
+      If any of the `promises` given to `all` are rejected, the first promise
+      that is rejected will be given as an argument to the returned promises's
+      rejection handler. For example:
 
-      var _state = parent._state;
+      Example:
 
+      ```javascript
+      let promise1 = resolve(1);
+      let promise2 = reject(new Error("2"));
+      let promise3 = reject(new Error("3"));
+      let promises = [ promise1, promise2, promise3 ];
 
-      if (_state) {
-        var callback = arguments[_state - 1];
-        asap(function () {
-          return invokeCallback(_state, child, callback, parent._result);
-        });
-      } else {
-        subscribe(parent, child, onFulfillment, onRejection);
-      }
+      Promise.all(promises).then(function(array){
+        // Code here never runs because there are rejected promises!
+      }, function(error) {
+        // error.message === "2"
+      });
+      ```
 
-      return child;
+      @method all
+      @static
+      @param {Array} entries array of promises
+      @param {String} label optional string for labeling the promise.
+      Useful for tooling.
+      @return {Promise} promise that is fulfilled when all `promises` have been
+      fulfilled, or rejected if any of them become rejected.
+      @static
+    */
+    function all(entries) {
+      return new Enumerator(this, entries).promise;
     }
 
     /**
-      `Promise.resolve` returns a promise that will become resolved with the
-      passed `value`. It is shorthand for the following:
+      `Promise.race` returns a new promise which is settled in the same way as the
+      first passed promise to settle.
+
+      Example:
 
       ```javascript
-      let promise = new Promise(function(resolve, reject){
-        resolve(1);
+      let promise1 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 1');
+        }, 200);
       });
 
-      promise.then(function(value){
-        // value === 1
+      let promise2 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 2');
+        }, 100);
+      });
+
+      Promise.race([promise1, promise2]).then(function(result){
+        // result === 'promise 2' because it was resolved before promise1
+        // was resolved.
       });
       ```
 
-      Instead of writing the above, your code now simply becomes the following:
+      `Promise.race` is deterministic in that only the state of the first
+      settled promise matters. For example, even if other promises given to the
+      `promises` array argument are resolved, but the first settled promise has
+      become rejected before the other promises became fulfilled, the returned
+      promise will become rejected:
 
       ```javascript
-      let promise = Promise.resolve(1);
+      let promise1 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 1');
+        }, 200);
+      });
 
-      promise.then(function(value){
-        // value === 1
+      let promise2 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          reject(new Error('promise 2'));
+        }, 100);
+      });
+
+      Promise.race([promise1, promise2]).then(function(result){
+        // Code here never runs
+      }, function(reason){
+        // reason.message === 'promise 2' because promise 2 became rejected before
+        // promise 1 became fulfilled
       });
       ```
 
-      @method resolve
+      An example real-world use case is implementing timeouts:
+
+      ```javascript
+      Promise.race([ajax('foo.json'), timeout(5000)])
+      ```
+
+      @method race
       @static
-      @param {Any} value value that the returned promise will be resolved with
+      @param {Array} promises array of promises to observe
       Useful for tooling.
-      @return {Promise} a promise that will become fulfilled with the given
-      `value`
+      @return {Promise} a promise which settles in the same way as the first passed
+      promise to settle.
     */
-    function resolve$1(object) {
+    function race(entries) {
       /*jshint validthis:true */
       var Constructor = this;
 
-      if (object && typeof object === 'object' && object.constructor === Constructor) {
-        return object;
+      if (!isArray(entries)) {
+        return new Constructor(function (_, reject) {
+          return reject(new TypeError('You must pass an array to race.'));
+        });
+      } else {
+        return new Constructor(function (resolve, reject) {
+          var length = entries.length;
+          for (var i = 0; i < length; i++) {
+            Constructor.resolve(entries[i]).then(resolve, reject);
+          }
+        });
       }
-
-      var promise = new Constructor(noop);
-      resolve(promise, object);
-      return promise;
     }
 
-    var PROMISE_ID = Math.random().toString(36).substring(2);
-
-    function noop() {}
-
-    var PENDING = void 0;
-    var FULFILLED = 1;
-    var REJECTED = 2;
+    /**
+      `Promise.reject` returns a promise rejected with the passed `reason`.
+      It is shorthand for the following:
 
-    function selfFulfillment() {
-      return new TypeError("You cannot resolve a promise with itself");
-    }
+      ```javascript
+      let promise = new Promise(function(resolve, reject){
+        reject(new Error('WHOOPS'));
+      });
 
-    function cannotReturnOwn() {
-      return new TypeError('A promises callback cannot return that same promise.');
-    }
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
+      });
+      ```
 
-    function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
-      try {
-        then$$1.call(value, fulfillmentHandler, rejectionHandler);
-      } catch (e) {
-        return e;
-      }
-    }
+      Instead of writing the above, your code now simply becomes the following:
 
-    function handleForeignThenable(promise, thenable, then$$1) {
-      asap(function (promise) {
-        var sealed = false;
-        var error = tryThen(then$$1, thenable, function (value) {
-          if (sealed) {
-            return;
-          }
-          sealed = true;
-          if (thenable !== value) {
-            resolve(promise, value);
-          } else {
-            fulfill(promise, value);
-          }
-        }, function (reason) {
-          if (sealed) {
-            return;
-          }
-          sealed = true;
+      ```javascript
+      let promise = Promise.reject(new Error('WHOOPS'));
 
-          reject(promise, reason);
-        }, 'Settle: ' + (promise._label || ' unknown promise'));
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
+      });
+      ```
 
-        if (!sealed && error) {
-          sealed = true;
-          reject(promise, error);
-        }
-      }, promise);
+      @method reject
+      @static
+      @param {Any} reason value that the returned promise will be rejected with.
+      Useful for tooling.
+      @return {Promise} a promise rejected with the given `reason`.
+    */
+    function reject$1(reason) {
+      /*jshint validthis:true */
+      var Constructor = this;
+      var promise = new Constructor(noop);
+      reject(promise, reason);
+      return promise;
     }
 
-    function handleOwnThenable(promise, thenable) {
-      if (thenable._state === FULFILLED) {
-        fulfill(promise, thenable._result);
-      } else if (thenable._state === REJECTED) {
-        reject(promise, thenable._result);
-      } else {
-        subscribe(thenable, undefined, function (value) {
-          return resolve(promise, value);
-        }, function (reason) {
-          return reject(promise, reason);
-        });
-      }
+    function needsResolver() {
+      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
     }
 
-    function handleMaybeThenable(promise, maybeThenable, then$$1) {
-      if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
-        handleOwnThenable(promise, maybeThenable);
-      } else {
-        if (then$$1 === undefined) {
-          fulfill(promise, maybeThenable);
-        } else if (isFunction(then$$1)) {
-          handleForeignThenable(promise, maybeThenable, then$$1);
-        } else {
-          fulfill(promise, maybeThenable);
-        }
-      }
+    function needsNew() {
+      throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
     }
 
-    function resolve(promise, value) {
-      if (promise === value) {
-        reject(promise, selfFulfillment());
-      } else if (objectOrFunction(value)) {
-        var then$$1 = void 0;
-        try {
-          then$$1 = value.then;
-        } catch (error) {
-          reject(promise, error);
-          return;
-        }
-        handleMaybeThenable(promise, value, then$$1);
-      } else {
-        fulfill(promise, value);
-      }
-    }
+    /**
+      Promise objects represent the eventual result of an asynchronous operation. The
+      primary way of interacting with a promise is through its `then` method, which
+      registers callbacks to receive either a promise's eventual value or the reason
+      why the promise cannot be fulfilled.
 
-    function publishRejection(promise) {
-      if (promise._onerror) {
-        promise._onerror(promise._result);
-      }
+      Terminology
+      -----------
 
-      publish(promise);
-    }
+      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+      - `thenable` is an object or function that defines a `then` method.
+      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+      - `exception` is a value that is thrown using the throw statement.
+      - `reason` is a value that indicates why a promise was rejected.
+      - `settled` the final resting state of a promise, fulfilled or rejected.
 
-    function fulfill(promise, value) {
-      if (promise._state !== PENDING) {
-        return;
-      }
+      A promise can be in one of three states: pending, fulfilled, or rejected.
 
-      promise._result = value;
-      promise._state = FULFILLED;
+      Promises that are fulfilled have a fulfillment value and are in the fulfilled
+      state.  Promises that are rejected have a rejection reason and are in the
+      rejected state.  A fulfillment value is never a thenable.
 
-      if (promise._subscribers.length !== 0) {
-        asap(publish, promise);
-      }
-    }
+      Promises can also be said to *resolve* a value.  If this value is also a
+      promise, then the original promise's settled state will match the value's
+      settled state.  So a promise that *resolves* a promise that rejects will
+      itself reject, and a promise that *resolves* a promise that fulfills will
+      itself fulfill.
 
-    function reject(promise, reason) {
-      if (promise._state !== PENDING) {
-        return;
-      }
-      promise._state = REJECTED;
-      promise._result = reason;
 
-      asap(publishRejection, promise);
-    }
+      Basic Usage:
+      ------------
 
-    function subscribe(parent, child, onFulfillment, onRejection) {
-      var _subscribers = parent._subscribers;
-      var length = _subscribers.length;
+      ```js
+      let promise = new Promise(function(resolve, reject) {
+        // on success
+        resolve(value);
 
+        // on failure
+        reject(reason);
+      });
 
-      parent._onerror = null;
+      promise.then(function(value) {
+        // on fulfillment
+      }, function(reason) {
+        // on rejection
+      });
+      ```
 
-      _subscribers[length] = child;
-      _subscribers[length + FULFILLED] = onFulfillment;
-      _subscribers[length + REJECTED] = onRejection;
+      Advanced Usage:
+      ---------------
 
-      if (length === 0 && parent._state) {
-        asap(publish, parent);
-      }
-    }
+      Promises shine when abstracting away asynchronous interactions such as
+      `XMLHttpRequest`s.
 
-    function publish(promise) {
-      var subscribers = promise._subscribers;
-      var settled = promise._state;
+      ```js
+      function getJSON(url) {
+        return new Promise(function(resolve, reject){
+          let xhr = new XMLHttpRequest();
 
-      if (subscribers.length === 0) {
-        return;
+          xhr.open('GET', url);
+          xhr.onreadystatechange = handler;
+          xhr.responseType = 'json';
+          xhr.setRequestHeader('Accept', 'application/json');
+          xhr.send();
+
+          function handler() {
+            if (this.readyState === this.DONE) {
+              if (this.status === 200) {
+                resolve(this.response);
+              } else {
+                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+              }
+            }
+          };
+        });
       }
 
-      var child = void 0,
-          callback = void 0,
-          detail = promise._result;
+      getJSON('/posts.json').then(function(json) {
+        // on fulfillment
+      }, function(reason) {
+        // on rejection
+      });
+      ```
 
-      for (var i = 0; i < subscribers.length; i += 3) {
-        child = subscribers[i];
-        callback = subscribers[i + settled];
+      Unlike callbacks, promises are great composable primitives.
 
-        if (child) {
-          invokeCallback(settled, child, callback, detail);
-        } else {
-          callback(detail);
-        }
-      }
+      ```js
+      Promise.all([
+        getJSON('/posts'),
+        getJSON('/comments')
+      ]).then(function(values){
+        values[0] // => postsJSON
+        values[1] // => commentsJSON
 
-      promise._subscribers.length = 0;
-    }
+        return values;
+      });
+      ```
 
-    function invokeCallback(settled, promise, callback, detail) {
-      var hasCallback = isFunction(callback),
-          value = void 0,
-          error = void 0,
-          succeeded = true;
+      @class Promise
+      @param {Function} resolver
+      Useful for tooling.
+      @constructor
+    */
 
-      if (hasCallback) {
-        try {
-          value = callback(detail);
-        } catch (e) {
-          succeeded = false;
-          error = e;
-        }
+    var Promise$1 = function () {
+      function Promise(resolver) {
+        this[PROMISE_ID] = nextId();
+        this._result = this._state = undefined;
+        this._subscribers = [];
 
-        if (promise === value) {
-          reject(promise, cannotReturnOwn());
-          return;
+        if (noop !== resolver) {
+          typeof resolver !== 'function' && needsResolver();
+          this instanceof Promise ? initializePromise(this, resolver) : needsNew();
         }
-      } else {
-        value = detail;
       }
 
-      if (promise._state !== PENDING) ; else if (hasCallback && succeeded) {
-        resolve(promise, value);
-      } else if (succeeded === false) {
-        reject(promise, error);
-      } else if (settled === FULFILLED) {
-        fulfill(promise, value);
-      } else if (settled === REJECTED) {
-        reject(promise, value);
+      /**
+      The primary way of interacting with a promise is through its `then` method,
+      which registers callbacks to receive either a promise's eventual value or the
+      reason why the promise cannot be fulfilled.
+       ```js
+      findUser().then(function(user){
+        // user is available
+      }, function(reason){
+        // user is unavailable, and you are given the reason why
+      });
+      ```
+       Chaining
+      --------
+       The return value of `then` is itself a promise.  This second, 'downstream'
+      promise is resolved with the return value of the first promise's fulfillment
+      or rejection handler, or rejected if the handler throws an exception.
+       ```js
+      findUser().then(function (user) {
+        return user.name;
+      }, function (reason) {
+        return 'default name';
+      }).then(function (userName) {
+        // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+        // will be `'default name'`
+      });
+       findUser().then(function (user) {
+        throw new Error('Found user, but still unhappy');
+      }, function (reason) {
+        throw new Error('`findUser` rejected and we're unhappy');
+      }).then(function (value) {
+        // never reached
+      }, function (reason) {
+        // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+        // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
+      });
+      ```
+      If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+       ```js
+      findUser().then(function (user) {
+        throw new PedagogicalException('Upstream error');
+      }).then(function (value) {
+        // never reached
+      }).then(function (value) {
+        // never reached
+      }, function (reason) {
+        // The `PedgagocialException` is propagated all the way down to here
+      });
+      ```
+       Assimilation
+      ------------
+       Sometimes the value you want to propagate to a downstream promise can only be
+      retrieved asynchronously. This can be achieved by returning a promise in the
+      fulfillment or rejection handler. The downstream promise will then be pending
+      until the returned promise is settled. This is called *assimilation*.
+       ```js
+      findUser().then(function (user) {
+        return findCommentsByAuthor(user);
+      }).then(function (comments) {
+        // The user's comments are now available
+      });
+      ```
+       If the assimliated promise rejects, then the downstream promise will also reject.
+       ```js
+      findUser().then(function (user) {
+        return findCommentsByAuthor(user);
+      }).then(function (comments) {
+        // If `findCommentsByAuthor` fulfills, we'll have the value here
+      }, function (reason) {
+        // If `findCommentsByAuthor` rejects, we'll have the reason here
+      });
+      ```
+       Simple Example
+      --------------
+       Synchronous Example
+       ```javascript
+      let result;
+       try {
+        result = findResult();
+        // success
+      } catch(reason) {
+        // failure
       }
-    }
+      ```
+       Errback Example
+       ```js
+      findResult(function(result, err){
+        if (err) {
+          // failure
+        } else {
+          // success
+        }
+      });
+      ```
+       Promise Example;
+       ```javascript
+      findResult().then(function(result){
+        // success
+      }, function(reason){
+        // failure
+      });
+      ```
+       Advanced Example
+      --------------
+       Synchronous Example
+       ```javascript
+      let author, books;
+       try {
+        author = findAuthor();
+        books  = findBooksByAuthor(author);
+        // success
+      } catch(reason) {
+        // failure
+      }
+      ```
+       Errback Example
+       ```js
+       function foundBooks(books) {
+       }
+       function failure(reason) {
+       }
+       findAuthor(function(author, err){
+        if (err) {
+          failure(err);
+          // failure
+        } else {
+          try {
+            findBoooksByAuthor(author, function(books, err) {
+              if (err) {
+                failure(err);
+              } else {
+                try {
+                  foundBooks(books);
+                } catch(reason) {
+                  failure(reason);
+                }
+              }
+            });
+          } catch(error) {
+            failure(err);
+          }
+          // success
+        }
+      });
+      ```
+       Promise Example;
+       ```javascript
+      findAuthor().
+        then(findBooksByAuthor).
+        then(function(books){
+          // found books
+      }).catch(function(reason){
+        // something went wrong
+      });
+      ```
+       @method then
+      @param {Function} onFulfilled
+      @param {Function} onRejected
+      Useful for tooling.
+      @return {Promise}
+      */
 
-    function initializePromise(promise, resolver) {
+      /**
+      `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+      as the catch block of a try/catch statement.
+      ```js
+      function findAuthor(){
+      throw new Error('couldn't find that author');
+      }
+      // synchronous
       try {
-        resolver(function resolvePromise(value) {
-          resolve(promise, value);
-        }, function rejectPromise(reason) {
-          reject(promise, reason);
-        });
-      } catch (e) {
-        reject(promise, e);
+      findAuthor();
+      } catch(reason) {
+      // something went wrong
       }
-    }
+      // async with promises
+      findAuthor().catch(function(reason){
+      // something went wrong
+      });
+      ```
+      @method catch
+      @param {Function} onRejection
+      Useful for tooling.
+      @return {Promise}
+      */
 
-    var id = 0;
-    function nextId() {
-      return id++;
-    }
 
-    function makePromise(promise) {
-      promise[PROMISE_ID] = id++;
-      promise._state = undefined;
-      promise._result = undefined;
-      promise._subscribers = [];
-    }
+      Promise.prototype.catch = function _catch(onRejection) {
+        return this.then(null, onRejection);
+      };
 
-    function validationError() {
-      return new Error('Array Methods must be provided an Array');
-    }
+      /**
+        `finally` will be invoked regardless of the promise's fate just as native
+        try/catch/finally behaves
+      
+        Synchronous example:
+      
+        ```js
+        findAuthor() {
+          if (Math.random() > 0.5) {
+            throw new Error();
+          }
+          return new Author();
+        }
+      
+        try {
+          return findAuthor(); // succeed or fail
+        } catch(error) {
+          return findOtherAuther();
+        } finally {
+          // always runs
+          // doesn't affect the return value
+        }
+        ```
+      
+        Asynchronous example:
+      
+        ```js
+        findAuthor().catch(function(reason){
+          return findOtherAuther();
+        }).finally(function(){
+          // author was either found, or not
+        });
+        ```
+      
+        @method finally
+        @param {Function} callback
+        @return {Promise}
+      */
 
-    var Enumerator = function () {
-      function Enumerator(Constructor, input) {
-        this._instanceConstructor = Constructor;
-        this.promise = new Constructor(noop);
 
-        if (!this.promise[PROMISE_ID]) {
-          makePromise(this.promise);
+      Promise.prototype.finally = function _finally(callback) {
+        var promise = this;
+        var constructor = promise.constructor;
+
+        if (isFunction(callback)) {
+          return promise.then(function (value) {
+            return constructor.resolve(callback()).then(function () {
+              return value;
+            });
+          }, function (reason) {
+            return constructor.resolve(callback()).then(function () {
+              throw reason;
+            });
+          });
         }
 
-        if (isArray(input)) {
-          this.length = input.length;
-          this._remaining = input.length;
+        return promise.then(callback, callback);
+      };
 
-          this._result = new Array(this.length);
+      return Promise;
+    }();
 
-          if (this.length === 0) {
-            fulfill(this.promise, this._result);
-          } else {
-            this.length = this.length || 0;
-            this._enumerate(input);
-            if (this._remaining === 0) {
-              fulfill(this.promise, this._result);
-            }
-          }
-        } else {
-          reject(this.promise, validationError());
+    Promise$1.prototype.then = then;
+    Promise$1.all = all;
+    Promise$1.race = race;
+    Promise$1.resolve = resolve$1;
+    Promise$1.reject = reject$1;
+    Promise$1._setScheduler = setScheduler;
+    Promise$1._setAsap = setAsap;
+    Promise$1._asap = asap;
+
+    /*global self*/
+    function polyfill() {
+      var local = void 0;
+
+      if (typeof commonjsGlobal !== 'undefined') {
+        local = commonjsGlobal;
+      } else if (typeof self !== 'undefined') {
+        local = self;
+      } else {
+        try {
+          local = Function('return this')();
+        } catch (e) {
+          throw new Error('polyfill failed because global object is unavailable in this environment');
         }
       }
 
-      Enumerator.prototype._enumerate = function _enumerate(input) {
-        for (var i = 0; this._state === PENDING && i < input.length; i++) {
-          this._eachEntry(input[i], i);
+      var P = local.Promise;
+
+      if (P) {
+        var promiseToString = null;
+        try {
+          promiseToString = Object.prototype.toString.call(P.resolve());
+        } catch (e) {
+          // silently ignored
         }
-      };
 
-      Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
-        var c = this._instanceConstructor;
-        var resolve$$1 = c.resolve;
+        if (promiseToString === '[object Promise]' && !P.cast) {
+          return;
+        }
+      }
+
+      local.Promise = Promise$1;
+    }
 
+    // Strange compat..
+    Promise$1.polyfill = polyfill;
+    Promise$1.Promise = Promise$1;
 
-        if (resolve$$1 === resolve$1) {
-          var _then = void 0;
-          var error = void 0;
-          var didError = false;
-          try {
-            _then = entry.then;
-          } catch (e) {
-            didError = true;
-            error = e;
-          }
+    return Promise$1;
 
-          if (_then === then && entry._state !== PENDING) {
-            this._settledAt(entry._state, i, entry._result);
-          } else if (typeof _then !== 'function') {
-            this._remaining--;
-            this._result[i] = entry;
-          } else if (c === Promise$1) {
-            var promise = new c(noop);
-            if (didError) {
-              reject(promise, error);
-            } else {
-              handleMaybeThenable(promise, entry, _then);
-            }
-            this._willSettleAt(promise, i);
-          } else {
-            this._willSettleAt(new c(function (resolve$$1) {
-              return resolve$$1(entry);
-            }), i);
-          }
-        } else {
-          this._willSettleAt(resolve$$1(entry), i);
-        }
-      };
+    })));
 
-      Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
-        var promise = this.promise;
 
 
-        if (promise._state === PENDING) {
-          this._remaining--;
 
-          if (state === REJECTED) {
-            reject(promise, value);
-          } else {
-            this._result[i] = value;
+    });
+
+    var __extends = undefined && undefined.__extends || function () {
+      var _extendStatics = function extendStatics(d, b) {
+        _extendStatics = Object.setPrototypeOf || {
+          __proto__: []
+        } instanceof Array && function (d, b) {
+          d.__proto__ = b;
+        } || function (d, b) {
+          for (var p in b) {
+            if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
           }
-        }
+        };
 
-        if (this._remaining === 0) {
-          fulfill(promise, this._result);
-        }
+        return _extendStatics(d, b);
       };
 
-      Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
-        var enumerator = this;
+      return function (d, b) {
+        _extendStatics(d, b);
 
-        subscribe(promise, undefined, function (value) {
-          return enumerator._settledAt(FULFILLED, i, value);
-        }, function (reason) {
-          return enumerator._settledAt(REJECTED, i, reason);
-        });
-      };
+        function __() {
+          this.constructor = d;
+        }
 
-      return Enumerator;
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
     }();
 
-    /**
-      `Promise.all` accepts an array of promises, and returns a new promise which
-      is fulfilled with an array of fulfillment values for the passed promises, or
-      rejected with the reason of the first passed promise to be rejected. It casts all
-      elements of the passed iterable to promises as it runs this algorithm.
+    var __assign$1 = undefined && undefined.__assign || function () {
+      __assign$1 = Object.assign || function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
 
-      Example:
+          for (var p in s) {
+            if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+          }
+        }
 
-      ```javascript
-      let promise1 = resolve(1);
-      let promise2 = resolve(2);
-      let promise3 = resolve(3);
-      let promises = [ promise1, promise2, promise3 ];
+        return t;
+      };
 
-      Promise.all(promises).then(function(array){
-        // The array here would be [ 1, 2, 3 ];
-      });
-      ```
+      return __assign$1.apply(this, arguments);
+    };
 
-      If any of the `promises` given to `all` are rejected, the first promise
-      that is rejected will be given as an argument to the returned promises's
-      rejection handler. For example:
+    var __rest = undefined && undefined.__rest || function (s, e) {
+      var t = {};
 
-      Example:
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+      }
 
-      ```javascript
-      let promise1 = resolve(1);
-      let promise2 = reject(new Error("2"));
-      let promise3 = reject(new Error("3"));
-      let promises = [ promise1, promise2, promise3 ];
+      if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+      }
+      return t;
+    }; // eslint-disable-next-line max-classes-per-file
 
-      Promise.all(promises).then(function(array){
-        // Code here never runs because there are rejected promises!
-      }, function(error) {
-        // error.message === "2"
-      });
-      ```
+    var BaseValidator =
+    /** @class */
+    function () {
+      function BaseValidator(value, rule, options) {
+        this.value = value;
 
-      @method all
-      @static
-      @param {Array} entries array of promises
-      @param {String} label optional string for labeling the promise.
-      Useful for tooling.
-      @return {Promise} promise that is fulfilled when all `promises` have been
-      fulfilled, or rejected if any of them become rejected.
-      @static
-    */
-    function all(entries) {
-      return new Enumerator(this, entries).promise;
-    }
+        var _a = rule.message,
+            message = _a === void 0 ? '' : _a,
+            rest = __rest(rule, ["message"]);
 
-    /**
-      `Promise.race` returns a new promise which is settled in the same way as the
-      first passed promise to settle.
+        this.message = message || '';
+        this.type = rule.type || ValidatorType.String;
+        this.error = {
+          value: value,
+          message: [],
+          errorTypes: []
+        };
+        this.field = options.field || '';
+        this.rule = rest;
+        this.validateRules = [];
+        this.curValidMsgTemplate = mergeMsgTemplate(messageTemplate, options.validateMessage);
+      }
 
-      Example:
+      BaseValidator.prototype.isRequired = function () {
+        // 优先级最高
+        if (isEmptyValue(this.value) || isEmptyArray(this.value)) {
+          this.error.message = [this.message || getMsgTemplate(this.curValidMsgTemplate, 'required', [this.field])];
+          this.error.errorTypes = ['required'];
+          return false;
+        }
 
-      ```javascript
-      let promise1 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          resolve('promise 1');
-        }, 200);
-      });
+        return true;
+      };
 
-      let promise2 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          resolve('promise 2');
-        }, 100);
-      });
+      BaseValidator.prototype.addError = function (errorType, message) {
+        var _a;
 
-      Promise.race([promise1, promise2]).then(function(result){
-        // result === 'promise 2' because it was resolved before promise1
-        // was resolved.
-      });
-      ```
+        if (message) {
+          this.error.errorTypes.push(errorType);
+          (_a = this.error.message) === null || _a === void 0 ? void 0 : _a.push(message);
+        }
+      };
 
-      `Promise.race` is deterministic in that only the state of the first
-      settled promise matters. For example, even if other promises given to the
-      `promises` array argument are resolved, but the first settled promise has
-      become rejected before the other promises became fulfilled, the returned
-      promise will become rejected:
+      BaseValidator.prototype.dealError = function (isError, _a) {
+        var _b;
 
-      ```javascript
-      let promise1 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          resolve('promise 1');
-        }, 200);
-      });
+        var errTemplate = _a.errTemplate,
+            values = _a.values;
 
-      let promise2 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          reject(new Error('promise 2'));
-        }, 100);
-      });
+        if (isError) {
+          var theMessage = this.message || getMsgTemplate(this.curValidMsgTemplate, errTemplate, values);
+          this.error.errorTypes.push(errTemplate);
+          (_b = this.error.message) === null || _b === void 0 ? void 0 : _b.push(theMessage);
+          return theMessage;
+        }
 
-      Promise.race([promise1, promise2]).then(function(result){
-        // Code here never runs
-      }, function(reason){
-        // reason.message === 'promise 2' because promise 2 became rejected before
-        // promise 1 became fulfilled
-      });
-      ```
+        return '';
+      };
 
-      An example real-world use case is implementing timeouts:
+      BaseValidator.prototype.getErrors = function () {
+        return this.error;
+      };
 
-      ```javascript
-      Promise.race([ajax('foo.json'), timeout(5000)])
-      ```
+      return BaseValidator;
+    }();
 
-      @method race
-      @static
-      @param {Array} promises array of promises to observe
-      Useful for tooling.
-      @return {Promise} a promise which settles in the same way as the first passed
-      promise to settle.
-    */
-    function race(entries) {
-      /*jshint validthis:true */
-      var Constructor = this;
+    var BooleanValidator =
+    /** @class */
+    function (_super) {
+      __extends(BooleanValidator, _super);
 
-      if (!isArray(entries)) {
-        return new Constructor(function (_, reject) {
-          return reject(new TypeError('You must pass an array to race.'));
-        });
-      } else {
-        return new Constructor(function (resolve, reject) {
-          var length = entries.length;
-          for (var i = 0; i < length; i++) {
-            Constructor.resolve(entries[i]).then(resolve, reject);
-          }
-        });
-      }
-    }
+      function BooleanValidator(value, rules, options) {
+        var _this = _super.call(this, value, rules, options) || this;
 
-    /**
-      `Promise.reject` returns a promise rejected with the passed `reason`.
-      It is shorthand for the following:
+        _this.validateRules = ['equal'];
+        return _this;
+      }
 
-      ```javascript
-      let promise = new Promise(function(resolve, reject){
-        reject(new Error('WHOOPS'));
-      });
+      BooleanValidator.prototype.equal = function (str) {
+        return this.dealError(!isEmptyValue(this.value) && this.value !== str, {
+          errTemplate: 'boolean.equal',
+          values: [this.field, "" + str]
+        });
+      };
 
-      promise.then(function(value){
-        // Code here doesn't run because the promise is rejected!
-      }, function(reason){
-        // reason.message === 'WHOOPS'
-      });
-      ```
+      return BooleanValidator;
+    }(BaseValidator);
 
-      Instead of writing the above, your code now simply becomes the following:
+    var NumberValidator =
+    /** @class */
+    function (_super) {
+      __extends(NumberValidator, _super);
 
-      ```javascript
-      let promise = Promise.reject(new Error('WHOOPS'));
+      function NumberValidator(value, rules, options) {
+        var _this = _super.call(this, value, rules, options) || this;
 
-      promise.then(function(value){
-        // Code here doesn't run because the promise is rejected!
-      }, function(reason){
-        // reason.message === 'WHOOPS'
-      });
-      ```
+        _this.validateRules = ['min', 'max', 'equal', 'positive', 'negative'];
+        return _this;
+      }
 
-      @method reject
-      @static
-      @param {Any} reason value that the returned promise will be rejected with.
-      Useful for tooling.
-      @return {Promise} a promise rejected with the given `reason`.
-    */
-    function reject$1(reason) {
-      /*jshint validthis:true */
-      var Constructor = this;
-      var promise = new Constructor(noop);
-      reject(promise, reason);
-      return promise;
-    }
+      NumberValidator.prototype.min = function (num) {
+        this.dealError(!isEmptyValue(this.value) && this.value < num, {
+          errTemplate: 'number.min',
+          values: [this.field, "" + num]
+        });
+      };
 
-    function needsResolver() {
-      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
-    }
+      NumberValidator.prototype.max = function (num) {
+        this.dealError(!isEmptyValue(this.value) && this.value > num, {
+          errTemplate: 'number.max',
+          values: [this.field, "" + num]
+        });
+      };
 
-    function needsNew() {
-      throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
-    }
+      NumberValidator.prototype.equal = function (num) {
+        return this.dealError(!isEmptyValue(this.value) && this.value !== num, {
+          errTemplate: 'number.equal',
+          values: [this.field, "" + num]
+        });
+      };
 
-    /**
-      Promise objects represent the eventual result of an asynchronous operation. The
-      primary way of interacting with a promise is through its `then` method, which
-      registers callbacks to receive either a promise's eventual value or the reason
-      why the promise cannot be fulfilled.
+      NumberValidator.prototype.positive = function () {
+        return this.dealError(!isEmptyValue(this.value) && this.value < 0, {
+          errTemplate: 'number.positive',
+          values: [this.field]
+        });
+      };
 
-      Terminology
-      -----------
+      NumberValidator.prototype.negative = function () {
+        return this.dealError(!isEmptyValue(this.value) && this.value > 0, {
+          errTemplate: 'number.negative',
+          values: [this.field]
+        });
+      };
 
-      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
-      - `thenable` is an object or function that defines a `then` method.
-      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
-      - `exception` is a value that is thrown using the throw statement.
-      - `reason` is a value that indicates why a promise was rejected.
-      - `settled` the final resting state of a promise, fulfilled or rejected.
+      return NumberValidator;
+    }(BaseValidator);
 
-      A promise can be in one of three states: pending, fulfilled, or rejected.
+    var StringValidator =
+    /** @class */
+    function (_super) {
+      __extends(StringValidator, _super);
 
-      Promises that are fulfilled have a fulfillment value and are in the fulfilled
-      state.  Promises that are rejected have a rejection reason and are in the
-      rejected state.  A fulfillment value is never a thenable.
-
-      Promises can also be said to *resolve* a value.  If this value is also a
-      promise, then the original promise's settled state will match the value's
-      settled state.  So a promise that *resolves* a promise that rejects will
-      itself reject, and a promise that *resolves* a promise that fulfills will
-      itself fulfill.
-
-
-      Basic Usage:
-      ------------
-
-      ```js
-      let promise = new Promise(function(resolve, reject) {
-        // on success
-        resolve(value);
-
-        // on failure
-        reject(reason);
-      });
-
-      promise.then(function(value) {
-        // on fulfillment
-      }, function(reason) {
-        // on rejection
-      });
-      ```
-
-      Advanced Usage:
-      ---------------
-
-      Promises shine when abstracting away asynchronous interactions such as
-      `XMLHttpRequest`s.
-
-      ```js
-      function getJSON(url) {
-        return new Promise(function(resolve, reject){
-          let xhr = new XMLHttpRequest();
-
-          xhr.open('GET', url);
-          xhr.onreadystatechange = handler;
-          xhr.responseType = 'json';
-          xhr.setRequestHeader('Accept', 'application/json');
-          xhr.send();
+      function StringValidator(value, rules, options) {
+        var _this = _super.call(this, value, rules, options) || this;
 
-          function handler() {
-            if (this.readyState === this.DONE) {
-              if (this.status === 200) {
-                resolve(this.response);
-              } else {
-                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
-              }
-            }
-          };
-        });
+        _this.validateRules = ['min', 'max', 'len', 'equal', 'match', 'uppercase', 'lowercase', 'whitespace'];
+        return _this;
       }
 
-      getJSON('/posts.json').then(function(json) {
-        // on fulfillment
-      }, function(reason) {
-        // on rejection
-      });
-      ```
-
-      Unlike callbacks, promises are great composable primitives.
-
-      ```js
-      Promise.all([
-        getJSON('/posts'),
-        getJSON('/comments')
-      ]).then(function(values){
-        values[0] // => postsJSON
-        values[1] // => commentsJSON
-
-        return values;
-      });
-      ```
-
-      @class Promise
-      @param {Function} resolver
-      Useful for tooling.
-      @constructor
-    */
-
-    var Promise$1 = function () {
-      function Promise(resolver) {
-        this[PROMISE_ID] = nextId();
-        this._result = this._state = undefined;
-        this._subscribers = [];
+      StringValidator.prototype.min = function (num) {
+        return this.dealError(!isEmptyValue(this.value) && this.value.length < num, {
+          errTemplate: 'string.min',
+          values: [this.field, "" + num]
+        });
+      };
 
-        if (noop !== resolver) {
-          typeof resolver !== 'function' && needsResolver();
-          this instanceof Promise ? initializePromise(this, resolver) : needsNew();
-        }
-      }
+      StringValidator.prototype.max = function (num) {
+        return this.dealError(!isEmptyValue(this.value) && this.value.length > num, {
+          errTemplate: 'string.max',
+          values: [this.field, "" + num]
+        });
+      };
 
-      /**
-      The primary way of interacting with a promise is through its `then` method,
-      which registers callbacks to receive either a promise's eventual value or the
-      reason why the promise cannot be fulfilled.
-       ```js
-      findUser().then(function(user){
-        // user is available
-      }, function(reason){
-        // user is unavailable, and you are given the reason why
-      });
-      ```
-       Chaining
-      --------
-       The return value of `then` is itself a promise.  This second, 'downstream'
-      promise is resolved with the return value of the first promise's fulfillment
-      or rejection handler, or rejected if the handler throws an exception.
-       ```js
-      findUser().then(function (user) {
-        return user.name;
-      }, function (reason) {
-        return 'default name';
-      }).then(function (userName) {
-        // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
-        // will be `'default name'`
-      });
-       findUser().then(function (user) {
-        throw new Error('Found user, but still unhappy');
-      }, function (reason) {
-        throw new Error('`findUser` rejected and we're unhappy');
-      }).then(function (value) {
-        // never reached
-      }, function (reason) {
-        // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
-        // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
-      });
-      ```
-      If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
-       ```js
-      findUser().then(function (user) {
-        throw new PedagogicalException('Upstream error');
-      }).then(function (value) {
-        // never reached
-      }).then(function (value) {
-        // never reached
-      }, function (reason) {
-        // The `PedgagocialException` is propagated all the way down to here
-      });
-      ```
-       Assimilation
-      ------------
-       Sometimes the value you want to propagate to a downstream promise can only be
-      retrieved asynchronously. This can be achieved by returning a promise in the
-      fulfillment or rejection handler. The downstream promise will then be pending
-      until the returned promise is settled. This is called *assimilation*.
-       ```js
-      findUser().then(function (user) {
-        return findCommentsByAuthor(user);
-      }).then(function (comments) {
-        // The user's comments are now available
-      });
-      ```
-       If the assimliated promise rejects, then the downstream promise will also reject.
-       ```js
-      findUser().then(function (user) {
-        return findCommentsByAuthor(user);
-      }).then(function (comments) {
-        // If `findCommentsByAuthor` fulfills, we'll have the value here
-      }, function (reason) {
-        // If `findCommentsByAuthor` rejects, we'll have the reason here
-      });
-      ```
-       Simple Example
-      --------------
-       Synchronous Example
-       ```javascript
-      let result;
-       try {
-        result = findResult();
-        // success
-      } catch(reason) {
-        // failure
-      }
-      ```
-       Errback Example
-       ```js
-      findResult(function(result, err){
-        if (err) {
-          // failure
-        } else {
-          // success
-        }
-      });
-      ```
-       Promise Example;
-       ```javascript
-      findResult().then(function(result){
-        // success
-      }, function(reason){
-        // failure
-      });
-      ```
-       Advanced Example
-      --------------
-       Synchronous Example
-       ```javascript
-      let author, books;
-       try {
-        author = findAuthor();
-        books  = findBooksByAuthor(author);
-        // success
-      } catch(reason) {
-        // failure
-      }
-      ```
-       Errback Example
-       ```js
-       function foundBooks(books) {
-       }
-       function failure(reason) {
-       }
-       findAuthor(function(author, err){
-        if (err) {
-          failure(err);
-          // failure
-        } else {
-          try {
-            findBoooksByAuthor(author, function(books, err) {
-              if (err) {
-                failure(err);
-              } else {
-                try {
-                  foundBooks(books);
-                } catch(reason) {
-                  failure(reason);
-                }
-              }
-            });
-          } catch(error) {
-            failure(err);
-          }
-          // success
-        }
-      });
-      ```
-       Promise Example;
-       ```javascript
-      findAuthor().
-        then(findBooksByAuthor).
-        then(function(books){
-          // found books
-      }).catch(function(reason){
-        // something went wrong
-      });
-      ```
-       @method then
-      @param {Function} onFulfilled
-      @param {Function} onRejected
-      Useful for tooling.
-      @return {Promise}
-      */
+      StringValidator.prototype.len = function (num) {
+        return this.dealError(!isEmptyValue(this.value) && this.value.length !== num, {
+          errTemplate: 'string.len',
+          values: [this.field, "" + num]
+        });
+      };
 
-      /**
-      `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
-      as the catch block of a try/catch statement.
-      ```js
-      function findAuthor(){
-      throw new Error('couldn't find that author');
-      }
-      // synchronous
-      try {
-      findAuthor();
-      } catch(reason) {
-      // something went wrong
-      }
-      // async with promises
-      findAuthor().catch(function(reason){
-      // something went wrong
-      });
-      ```
-      @method catch
-      @param {Function} onRejection
-      Useful for tooling.
-      @return {Promise}
-      */
+      StringValidator.prototype.equal = function (str) {
+        return this.dealError(!isEmptyValue(this.value) && this.value !== str, {
+          errTemplate: 'string.equal',
+          values: [this.field, "" + str]
+        });
+      };
 
+      StringValidator.prototype.match = function (regStr) {
+        var reg = new RegExp(regStr);
+        return this.dealError(!isEmptyValue(this.value) && !reg.test(this.value), {
+          errTemplate: 'string.match',
+          values: [this.field, regStr]
+        });
+      };
 
-      Promise.prototype.catch = function _catch(onRejection) {
-        return this.then(null, onRejection);
+      StringValidator.prototype.uppercase = function (isValue) {
+        var isUppercase = (this.value || '').toLocaleUpperCase() === this.value;
+        return this.dealError(!isEmptyValue(this.value) && isUppercase !== isValue, {
+          errTemplate: 'string.uppercase',
+          values: [this.field]
+        });
       };
 
-      /**
-        `finally` will be invoked regardless of the promise's fate just as native
-        try/catch/finally behaves
-      
-        Synchronous example:
-      
-        ```js
-        findAuthor() {
-          if (Math.random() > 0.5) {
-            throw new Error();
-          }
-          return new Author();
-        }
-      
-        try {
-          return findAuthor(); // succeed or fail
-        } catch(error) {
-          return findOtherAuther();
-        } finally {
-          // always runs
-          // doesn't affect the return value
-        }
-        ```
-      
-        Asynchronous example:
-      
-        ```js
-        findAuthor().catch(function(reason){
-          return findOtherAuther();
-        }).finally(function(){
-          // author was either found, or not
+      StringValidator.prototype.lowercase = function (isValue) {
+        var isLowercase = (this.value || '').toLocaleLowerCase() === this.value;
+        return this.dealError(!isEmptyValue(this.value) && isLowercase !== isValue, {
+          errTemplate: 'string.lowercase',
+          values: [this.field]
         });
-        ```
-      
-        @method finally
-        @param {Function} callback
-        @return {Promise}
-      */
+      };
+
+      StringValidator.prototype.whitespace = function () {
+        return this.dealError(!isEmptyValue(this.value) && isEmptyValue(this.value.trim()), {
+          errTemplate: 'string.whitespace',
+          values: [this.field]
+        });
+      };
 
+      return StringValidator;
+    }(BaseValidator);
 
-      Promise.prototype.finally = function _finally(callback) {
-        var promise = this;
-        var constructor = promise.constructor;
+    var ArrayValidator =
+    /** @class */
+    function (_super) {
+      __extends(ArrayValidator, _super);
 
-        if (isFunction(callback)) {
-          return promise.then(function (value) {
-            return constructor.resolve(callback()).then(function () {
-              return value;
-            });
-          }, function (reason) {
-            return constructor.resolve(callback()).then(function () {
-              throw reason;
-            });
-          });
-        }
+      function ArrayValidator(value, rules, options) {
+        var _this = _super.call(this, value, rules, options) || this;
 
-        return promise.then(callback, callback);
+        _this.validateRules = ['min', 'max', 'deepEqual', 'includes'];
+        return _this;
+      }
+
+      ArrayValidator.prototype.min = function (num) {
+        return this.dealError(!isEmptyValue(this.value) && this.value.length < num, {
+          errTemplate: 'array.min',
+          values: [this.field, "" + num]
+        });
       };
 
-      return Promise;
-    }();
+      ArrayValidator.prototype.max = function (num) {
+        return this.dealError(!isEmptyValue(this.value) && this.value.length > num, {
+          errTemplate: 'array.max',
+          values: [this.field, "" + num]
+        });
+      };
 
-    Promise$1.prototype.then = then;
-    Promise$1.all = all;
-    Promise$1.race = race;
-    Promise$1.resolve = resolve$1;
-    Promise$1.reject = reject$1;
-    Promise$1._setScheduler = setScheduler;
-    Promise$1._setAsap = setAsap;
-    Promise$1._asap = asap;
+      ArrayValidator.prototype.deepEqual = function (sub) {
+        return this.dealError(!isDeepEqual(this.value, sub), {
+          errTemplate: 'array.equal',
+          values: [this.field, "" + JSON.stringify(sub)]
+        });
+      };
 
-    /*global self*/
-    function polyfill() {
-      var local = void 0;
+      ArrayValidator.prototype.includes = function (sub) {
+        var _this = this;
 
-      if (typeof commonjsGlobal !== 'undefined') {
-        local = commonjsGlobal;
-      } else if (typeof self !== 'undefined') {
-        local = self;
-      } else {
-        try {
-          local = Function('return this')();
-        } catch (e) {
-          throw new Error('polyfill failed because global object is unavailable in this environment');
-        }
-      }
+        return this.dealError(sub.some(function (el) {
+          return !_this.value.includes(el);
+        }), {
+          errTemplate: 'array.includes',
+          values: [this.field, "" + JSON.stringify(sub)]
+        });
+      };
 
-      var P = local.Promise;
+      return ArrayValidator;
+    }(BaseValidator);
 
-      if (P) {
-        var promiseToString = null;
-        try {
-          promiseToString = Object.prototype.toString.call(P.resolve());
-        } catch (e) {
-          // silently ignored
-        }
+    var ObjectValidator =
+    /** @class */
+    function (_super) {
+      __extends(ObjectValidator, _super);
 
-        if (promiseToString === '[object Promise]' && !P.cast) {
-          return;
-        }
+      function ObjectValidator(value, rules, options) {
+        var _this = _super.call(this, value, rules, options) || this;
+
+        _this.validateRules = ['deepEqual', 'hasKeys'];
+        return _this;
       }
 
-      local.Promise = Promise$1;
-    }
+      ObjectValidator.prototype.deepEqual = function (sub) {
+        return this.dealError(!isDeepEqual(this.value, sub), {
+          errTemplate: 'object.deepEqual',
+          values: [this.field, "" + JSON.stringify(sub)]
+        });
+      };
 
-    // Strange compat..
-    Promise$1.polyfill = polyfill;
-    Promise$1.Promise = Promise$1;
+      ObjectValidator.prototype.hasKeys = function (keys) {
+        var allKeys = isEmptyValue(this.value) ? [] : Object.keys(this.value);
+        return this.dealError(!isEmptyValue(this.value) && keys.some(function (theKey) {
+          return !allKeys.includes(theKey);
+        }), {
+          errTemplate: 'object.hasKeys',
+          values: [this.field, "" + JSON.stringify(keys)]
+        });
+      };
 
-    return Promise$1;
+      return ObjectValidator;
+    }(BaseValidator);
 
-    })));
+    var CustomValidator =
+    /** @class */
+    function (_super) {
+      __extends(CustomValidator, _super);
 
+      function CustomValidator(value, rules, options) {
+        return _super.call(this, value, rules, options) || this;
+      }
 
+      CustomValidator.prototype.validator = function (validatorTool) {
+        var _this = this;
 
+        if (validatorTool) {
+          return new es6Promise$1.Promise(function (resolve) {
+            var validateLevel = _this.rule.validateLevel || 'error';
+            var ret = validatorTool(_this.value, function (message) {
+              if (message === void 0) {
+                message = '';
+              }
 
-    });
+              return _this.addError('custom', message || '');
+            });
+
+            if (ret && (ret === null || ret === void 0 ? void 0 : ret.then)) {
+              ret.then(function () {
+                return resolve(__assign$1(__assign$1({}, _this.getErrors()), {
+                  validateLevel: validateLevel
+                }));
+              });
+            } else {
+              resolve(__assign$1(__assign$1({}, _this.getErrors()), {
+                validateLevel: validateLevel
+              }));
+            }
+          });
+        }
+
+        return null;
+      };
+
+      return CustomValidator;
+    }(BaseValidator);
 
     var __assign = undefined && undefined.__assign || function () {
       __assign = Object.assign || function (t) {
@@ -9220,8 +9220,11 @@
           otherProps = __rest$1(props, ["className", "items", "cancelText", "close", "title", "subTitle", "needBottomOffset"]);
 
       var popupRef = React.useRef(null);
+      var listRef = React.useRef(null);
       React.useImperativeHandle(ref, function () {
-        return popupRef.current;
+        return __assign$3(__assign$3({}, popupRef.current), {
+          actionList: listRef.current
+        });
       });
 
       function handleItemClick(e, item) {
@@ -9258,7 +9261,8 @@
         }, title) : null, subTitle ? /*#__PURE__*/React__default["default"].createElement("div", {
           className: prefixCls + "-action-sheet-sub-title"
         }, subTitle) : null) : null, /*#__PURE__*/React__default["default"].createElement("div", {
-          className: prefixCls + "-action-sheet-list"
+          className: prefixCls + "-action-sheet-list",
+          ref: listRef
         }, (items || []).map(function (item, index) {
           return item.content ? /*#__PURE__*/React__default["default"].createElement("div", {
             className: cls(prefixCls + "-action-sheet-item", item.className, item.status || 'normal'),
@@ -11466,28 +11470,57 @@
           append = props.append,
           _b = props.bordered,
           bordered = _b === void 0 ? true : _b,
-          _onClick = props.onClick;
+          onClick = props.onClick,
+          _c = props.clickable,
+          clickable = _c === void 0 ? false : _c;
       var domRef = React.useRef(null);
+
+      var _d = React.useState(false),
+          isPressed = _d[0],
+          setIsPressed = _d[1];
+
       React.useImperativeHandle(ref, function () {
         return {
           dom: domRef.current
         };
       });
+
+      var handleTouchStart = function handleTouchStart() {
+        if (clickable) {
+          setIsPressed(true);
+        }
+      };
+
+      var handleTouchEnd = function handleTouchEnd() {
+        if (clickable) {
+          setIsPressed(false);
+        }
+      };
+
+      var handleClick = function handleClick(e) {
+        if (onClick) {
+          onClick(e);
+        }
+      };
+
       return /*#__PURE__*/React__default["default"].createElement(ContextLayout, null, function (_a) {
         var prefixCls = _a.prefixCls;
         return /*#__PURE__*/React__default["default"].createElement(GroupContext.Consumer, null, function (_a) {
+          var _b, _c, _d;
+
           var isFromGroup = _a.isFromGroup;
           return /*#__PURE__*/React__default["default"].createElement("div", {
             className: cls(prefixCls + "-cell", 'all-border-box', {
-              'without-group': !isFromGroup
-            }, {
               bordered: bordered
-            }, className),
+            }, {
+              'without-group': !isFromGroup
+            }, (_b = {}, _b[prefixCls + "-cell-without-group"] = !isFromGroup, _b), (_c = {}, _c[prefixCls + "-cell-clickable"] = clickable, _c), (_d = {}, _d[prefixCls + "-cell-pressed"] = isPressed, _d), className),
             style: style,
             ref: domRef,
-            onClick: function onClick(e) {
-              return _onClick && _onClick(e);
-            }
+            onClick: handleClick,
+            onTouchStart: handleTouchStart,
+            onTouchEnd: handleTouchEnd,
+            onTouchCancel: handleTouchEnd
           }, prepend, /*#__PURE__*/React__default["default"].createElement("div", {
             className: cls(prefixCls + "-cell-inner", {
               'has-desc': desc
@@ -14254,6 +14287,9 @@
       React.useEffect(function () {
         _updateRangeValue(currentTs);
       }, [currentTs]);
+      React.useEffect(function () {
+        setCurrentTs(isRange ? Math.min(maxTs, Math.max(minTs, userSetCurrentTs[0])) : Math.min(maxTs, Math.max(minTs, userSetCurrentTs)));
+      }, [userSetCurrentTs, maxTs, minTs, isRange]);
       React.useEffect(function () {
         if (visible) {
           // 初始化当前时间
@@ -20964,7 +21000,7 @@
                   warnings: warnings,
                   errorTypes: errorTypes
                 });
-                return resolve({
+                resolve({
                   errors: _this._errors,
                   warnings: warnings,
                   value: value,
@@ -28950,7 +28986,7 @@
       }, [disabled, ifShouldHandle]);
 
       var refresh = function refresh() {
-        return new Promise(function (resolve) {
+        return new es6Promise.Promise(function (resolve) {
           if (domRef.current) {
             domRef.current.style.overflow = 'hidden';
             var animationKey_1 = new Date().getTime();