bk-magic-vue 2.4.4 → 2.4.7

package/lib/upload.js

@@ -1,10 +1,11 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bk-magic-vue/lib/locale')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'bk-magic-vue/lib/locale'], factory) :
-  (global = global || self, factory(global.library = {}, global.locale));
-}(this, function (exports, locale) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bk-magic-vue/lib/locale'), require('spark-md5')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'bk-magic-vue/lib/locale', 'spark-md5'], factory) :
+  (global = global || self, factory(global.library = {}, global.locale, global.SparkMD5));
+}(this, function (exports, locale, SparkMD5) { 'use strict';
 
   var locale__default = 'default' in locale ? locale['default'] : locale;
+  SparkMD5 = SparkMD5 && SparkMD5.hasOwnProperty('default') ? SparkMD5['default'] : SparkMD5;
 
   var ceil = Math.ceil;
   var floor = Math.floor;
@@ -31,6 +32,8 @@
     };
   };
 
+  var _library = true;
+
   function createCommonjsModule(fn, module) {
   	return module = { exports: {} }, fn(module, module.exports), module.exports;
   }
@@ -537,6 +540,42 @@
     }, _typeof(obj);
   }
 
+  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+      var info = gen[key](arg);
+      var value = info.value;
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    if (info.done) {
+      resolve(value);
+    } else {
+      Promise.resolve(value).then(_next, _throw);
+    }
+  }
+
+  function _asyncToGenerator(fn) {
+    return function () {
+      var self = this,
+          args = arguments;
+      return new Promise(function (resolve, reject) {
+        var gen = fn.apply(self, args);
+
+        function _next(value) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+        }
+
+        function _throw(err) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+        }
+
+        _next(undefined);
+      });
+    };
+  }
+
   function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
@@ -614,6 +653,1054 @@
     return target;
   }
 
+  var runtime_1 = createCommonjsModule(function (module) {
+  var runtime = (function (exports) {
+    var Op = Object.prototype;
+    var hasOwn = Op.hasOwnProperty;
+    var undefined$1;
+    var $Symbol = typeof Symbol === "function" ? Symbol : {};
+    var iteratorSymbol = $Symbol.iterator || "@@iterator";
+    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+    function define(obj, key, value) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+      return obj[key];
+    }
+    try {
+      define({}, "");
+    } catch (err) {
+      define = function(obj, key, value) {
+        return obj[key] = value;
+      };
+    }
+    function wrap(innerFn, outerFn, self, tryLocsList) {
+      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+      var generator = Object.create(protoGenerator.prototype);
+      var context = new Context(tryLocsList || []);
+      generator._invoke = makeInvokeMethod(innerFn, self, context);
+      return generator;
+    }
+    exports.wrap = wrap;
+    function tryCatch(fn, obj, arg) {
+      try {
+        return { type: "normal", arg: fn.call(obj, arg) };
+      } catch (err) {
+        return { type: "throw", arg: err };
+      }
+    }
+    var GenStateSuspendedStart = "suspendedStart";
+    var GenStateSuspendedYield = "suspendedYield";
+    var GenStateExecuting = "executing";
+    var GenStateCompleted = "completed";
+    var ContinueSentinel = {};
+    function Generator() {}
+    function GeneratorFunction() {}
+    function GeneratorFunctionPrototype() {}
+    var IteratorPrototype = {};
+    define(IteratorPrototype, iteratorSymbol, function () {
+      return this;
+    });
+    var getProto = Object.getPrototypeOf;
+    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+    if (NativeIteratorPrototype &&
+        NativeIteratorPrototype !== Op &&
+        hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+      IteratorPrototype = NativeIteratorPrototype;
+    }
+    var Gp = GeneratorFunctionPrototype.prototype =
+      Generator.prototype = Object.create(IteratorPrototype);
+    GeneratorFunction.prototype = GeneratorFunctionPrototype;
+    define(Gp, "constructor", GeneratorFunctionPrototype);
+    define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
+    GeneratorFunction.displayName = define(
+      GeneratorFunctionPrototype,
+      toStringTagSymbol,
+      "GeneratorFunction"
+    );
+    function defineIteratorMethods(prototype) {
+      ["next", "throw", "return"].forEach(function(method) {
+        define(prototype, method, function(arg) {
+          return this._invoke(method, arg);
+        });
+      });
+    }
+    exports.isGeneratorFunction = function(genFun) {
+      var ctor = typeof genFun === "function" && genFun.constructor;
+      return ctor
+        ? ctor === GeneratorFunction ||
+          (ctor.displayName || ctor.name) === "GeneratorFunction"
+        : false;
+    };
+    exports.mark = function(genFun) {
+      if (Object.setPrototypeOf) {
+        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+      } else {
+        genFun.__proto__ = GeneratorFunctionPrototype;
+        define(genFun, toStringTagSymbol, "GeneratorFunction");
+      }
+      genFun.prototype = Object.create(Gp);
+      return genFun;
+    };
+    exports.awrap = function(arg) {
+      return { __await: arg };
+    };
+    function AsyncIterator(generator, PromiseImpl) {
+      function invoke(method, arg, resolve, reject) {
+        var record = tryCatch(generator[method], generator, arg);
+        if (record.type === "throw") {
+          reject(record.arg);
+        } else {
+          var result = record.arg;
+          var value = result.value;
+          if (value &&
+              typeof value === "object" &&
+              hasOwn.call(value, "__await")) {
+            return PromiseImpl.resolve(value.__await).then(function(value) {
+              invoke("next", value, resolve, reject);
+            }, function(err) {
+              invoke("throw", err, resolve, reject);
+            });
+          }
+          return PromiseImpl.resolve(value).then(function(unwrapped) {
+            result.value = unwrapped;
+            resolve(result);
+          }, function(error) {
+            return invoke("throw", error, resolve, reject);
+          });
+        }
+      }
+      var previousPromise;
+      function enqueue(method, arg) {
+        function callInvokeWithMethodAndArg() {
+          return new PromiseImpl(function(resolve, reject) {
+            invoke(method, arg, resolve, reject);
+          });
+        }
+        return previousPromise =
+          previousPromise ? previousPromise.then(
+            callInvokeWithMethodAndArg,
+            callInvokeWithMethodAndArg
+          ) : callInvokeWithMethodAndArg();
+      }
+      this._invoke = enqueue;
+    }
+    defineIteratorMethods(AsyncIterator.prototype);
+    define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+      return this;
+    });
+    exports.AsyncIterator = AsyncIterator;
+    exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+      if (PromiseImpl === void 0) PromiseImpl = Promise;
+      var iter = new AsyncIterator(
+        wrap(innerFn, outerFn, self, tryLocsList),
+        PromiseImpl
+      );
+      return exports.isGeneratorFunction(outerFn)
+        ? iter
+        : iter.next().then(function(result) {
+            return result.done ? result.value : iter.next();
+          });
+    };
+    function makeInvokeMethod(innerFn, self, context) {
+      var state = GenStateSuspendedStart;
+      return function invoke(method, arg) {
+        if (state === GenStateExecuting) {
+          throw new Error("Generator is already running");
+        }
+        if (state === GenStateCompleted) {
+          if (method === "throw") {
+            throw arg;
+          }
+          return doneResult();
+        }
+        context.method = method;
+        context.arg = arg;
+        while (true) {
+          var delegate = context.delegate;
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+          if (context.method === "next") {
+            context.sent = context._sent = context.arg;
+          } else if (context.method === "throw") {
+            if (state === GenStateSuspendedStart) {
+              state = GenStateCompleted;
+              throw context.arg;
+            }
+            context.dispatchException(context.arg);
+          } else if (context.method === "return") {
+            context.abrupt("return", context.arg);
+          }
+          state = GenStateExecuting;
+          var record = tryCatch(innerFn, self, context);
+          if (record.type === "normal") {
+            state = context.done
+              ? GenStateCompleted
+              : GenStateSuspendedYield;
+            if (record.arg === ContinueSentinel) {
+              continue;
+            }
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          } else if (record.type === "throw") {
+            state = GenStateCompleted;
+            context.method = "throw";
+            context.arg = record.arg;
+          }
+        }
+      };
+    }
+    function maybeInvokeDelegate(delegate, context) {
+      var method = delegate.iterator[context.method];
+      if (method === undefined$1) {
+        context.delegate = null;
+        if (context.method === "throw") {
+          if (delegate.iterator["return"]) {
+            context.method = "return";
+            context.arg = undefined$1;
+            maybeInvokeDelegate(delegate, context);
+            if (context.method === "throw") {
+              return ContinueSentinel;
+            }
+          }
+          context.method = "throw";
+          context.arg = new TypeError(
+            "The iterator does not provide a 'throw' method");
+        }
+        return ContinueSentinel;
+      }
+      var record = tryCatch(method, delegate.iterator, context.arg);
+      if (record.type === "throw") {
+        context.method = "throw";
+        context.arg = record.arg;
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+      var info = record.arg;
+      if (! info) {
+        context.method = "throw";
+        context.arg = new TypeError("iterator result is not an object");
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+      if (info.done) {
+        context[delegate.resultName] = info.value;
+        context.next = delegate.nextLoc;
+        if (context.method !== "return") {
+          context.method = "next";
+          context.arg = undefined$1;
+        }
+      } else {
+        return info;
+      }
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+    defineIteratorMethods(Gp);
+    define(Gp, toStringTagSymbol, "Generator");
+    define(Gp, iteratorSymbol, function() {
+      return this;
+    });
+    define(Gp, "toString", function() {
+      return "[object Generator]";
+    });
+    function pushTryEntry(locs) {
+      var entry = { tryLoc: locs[0] };
+      if (1 in locs) {
+        entry.catchLoc = locs[1];
+      }
+      if (2 in locs) {
+        entry.finallyLoc = locs[2];
+        entry.afterLoc = locs[3];
+      }
+      this.tryEntries.push(entry);
+    }
+    function resetTryEntry(entry) {
+      var record = entry.completion || {};
+      record.type = "normal";
+      delete record.arg;
+      entry.completion = record;
+    }
+    function Context(tryLocsList) {
+      this.tryEntries = [{ tryLoc: "root" }];
+      tryLocsList.forEach(pushTryEntry, this);
+      this.reset(true);
+    }
+    exports.keys = function(object) {
+      var keys = [];
+      for (var key in object) {
+        keys.push(key);
+      }
+      keys.reverse();
+      return function next() {
+        while (keys.length) {
+          var key = keys.pop();
+          if (key in object) {
+            next.value = key;
+            next.done = false;
+            return next;
+          }
+        }
+        next.done = true;
+        return next;
+      };
+    };
+    function values(iterable) {
+      if (iterable) {
+        var iteratorMethod = iterable[iteratorSymbol];
+        if (iteratorMethod) {
+          return iteratorMethod.call(iterable);
+        }
+        if (typeof iterable.next === "function") {
+          return iterable;
+        }
+        if (!isNaN(iterable.length)) {
+          var i = -1, next = function next() {
+            while (++i < iterable.length) {
+              if (hasOwn.call(iterable, i)) {
+                next.value = iterable[i];
+                next.done = false;
+                return next;
+              }
+            }
+            next.value = undefined$1;
+            next.done = true;
+            return next;
+          };
+          return next.next = next;
+        }
+      }
+      return { next: doneResult };
+    }
+    exports.values = values;
+    function doneResult() {
+      return { value: undefined$1, done: true };
+    }
+    Context.prototype = {
+      constructor: Context,
+      reset: function(skipTempReset) {
+        this.prev = 0;
+        this.next = 0;
+        this.sent = this._sent = undefined$1;
+        this.done = false;
+        this.delegate = null;
+        this.method = "next";
+        this.arg = undefined$1;
+        this.tryEntries.forEach(resetTryEntry);
+        if (!skipTempReset) {
+          for (var name in this) {
+            if (name.charAt(0) === "t" &&
+                hasOwn.call(this, name) &&
+                !isNaN(+name.slice(1))) {
+              this[name] = undefined$1;
+            }
+          }
+        }
+      },
+      stop: function() {
+        this.done = true;
+        var rootEntry = this.tryEntries[0];
+        var rootRecord = rootEntry.completion;
+        if (rootRecord.type === "throw") {
+          throw rootRecord.arg;
+        }
+        return this.rval;
+      },
+      dispatchException: function(exception) {
+        if (this.done) {
+          throw exception;
+        }
+        var context = this;
+        function handle(loc, caught) {
+          record.type = "throw";
+          record.arg = exception;
+          context.next = loc;
+          if (caught) {
+            context.method = "next";
+            context.arg = undefined$1;
+          }
+          return !! caught;
+        }
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          var record = entry.completion;
+          if (entry.tryLoc === "root") {
+            return handle("end");
+          }
+          if (entry.tryLoc <= this.prev) {
+            var hasCatch = hasOwn.call(entry, "catchLoc");
+            var hasFinally = hasOwn.call(entry, "finallyLoc");
+            if (hasCatch && hasFinally) {
+              if (this.prev < entry.catchLoc) {
+                return handle(entry.catchLoc, true);
+              } else if (this.prev < entry.finallyLoc) {
+                return handle(entry.finallyLoc);
+              }
+            } else if (hasCatch) {
+              if (this.prev < entry.catchLoc) {
+                return handle(entry.catchLoc, true);
+              }
+            } else if (hasFinally) {
+              if (this.prev < entry.finallyLoc) {
+                return handle(entry.finallyLoc);
+              }
+            } else {
+              throw new Error("try statement without catch or finally");
+            }
+          }
+        }
+      },
+      abrupt: function(type, arg) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc <= this.prev &&
+              hasOwn.call(entry, "finallyLoc") &&
+              this.prev < entry.finallyLoc) {
+            var finallyEntry = entry;
+            break;
+          }
+        }
+        if (finallyEntry &&
+            (type === "break" ||
+             type === "continue") &&
+            finallyEntry.tryLoc <= arg &&
+            arg <= finallyEntry.finallyLoc) {
+          finallyEntry = null;
+        }
+        var record = finallyEntry ? finallyEntry.completion : {};
+        record.type = type;
+        record.arg = arg;
+        if (finallyEntry) {
+          this.method = "next";
+          this.next = finallyEntry.finallyLoc;
+          return ContinueSentinel;
+        }
+        return this.complete(record);
+      },
+      complete: function(record, afterLoc) {
+        if (record.type === "throw") {
+          throw record.arg;
+        }
+        if (record.type === "break" ||
+            record.type === "continue") {
+          this.next = record.arg;
+        } else if (record.type === "return") {
+          this.rval = this.arg = record.arg;
+          this.method = "return";
+          this.next = "end";
+        } else if (record.type === "normal" && afterLoc) {
+          this.next = afterLoc;
+        }
+        return ContinueSentinel;
+      },
+      finish: function(finallyLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.finallyLoc === finallyLoc) {
+            this.complete(entry.completion, entry.afterLoc);
+            resetTryEntry(entry);
+            return ContinueSentinel;
+          }
+        }
+      },
+      "catch": function(tryLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc === tryLoc) {
+            var record = entry.completion;
+            if (record.type === "throw") {
+              var thrown = record.arg;
+              resetTryEntry(entry);
+            }
+            return thrown;
+          }
+        }
+        throw new Error("illegal catch attempt");
+      },
+      delegateYield: function(iterable, resultName, nextLoc) {
+        this.delegate = {
+          iterator: values(iterable),
+          resultName: resultName,
+          nextLoc: nextLoc
+        };
+        if (this.method === "next") {
+          this.arg = undefined$1;
+        }
+        return ContinueSentinel;
+      }
+    };
+    return exports;
+  }(
+     module.exports 
+  ));
+  try {
+    regeneratorRuntime = runtime;
+  } catch (accidentalStrictMode) {
+    if (typeof globalThis === "object") {
+      globalThis.regeneratorRuntime = runtime;
+    } else {
+      Function("r", "regeneratorRuntime = r")(runtime);
+    }
+  }
+  });
+
+  var regenerator = runtime_1;
+
+  var $JSON = _core.JSON || (_core.JSON = { stringify: JSON.stringify });
+  var stringify = function stringify(it) {
+    return $JSON.stringify.apply($JSON, arguments);
+  };
+
+  var stringify$1 = stringify;
+
+  var _iterStep = function (done, value) {
+    return { value: value, done: !!done };
+  };
+
+  var es6_array_iterator = _iterDefine(Array, 'Array', function (iterated, kind) {
+    this._t = _toIobject(iterated);
+    this._i = 0;
+    this._k = kind;
+  }, function () {
+    var O = this._t;
+    var kind = this._k;
+    var index = this._i++;
+    if (!O || index >= O.length) {
+      this._t = undefined;
+      return _iterStep(1);
+    }
+    if (kind == 'keys') return _iterStep(0, index);
+    if (kind == 'values') return _iterStep(0, O[index]);
+    return _iterStep(0, [index, O[index]]);
+  }, 'values');
+  _iterators.Arguments = _iterators.Array;
+
+  var TO_STRING_TAG = _wks('toStringTag');
+  var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
+    'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
+    'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
+    'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
+    'TextTrackList,TouchList').split(',');
+  for (var i = 0; i < DOMIterables.length; i++) {
+    var NAME = DOMIterables[i];
+    var Collection = _global[NAME];
+    var proto = Collection && Collection.prototype;
+    if (proto && !proto[TO_STRING_TAG]) _hide(proto, TO_STRING_TAG, NAME);
+    _iterators[NAME] = _iterators.Array;
+  }
+
+  var _anInstance = function (it, Constructor, name, forbiddenField) {
+    if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
+      throw TypeError(name + ': incorrect invocation!');
+    } return it;
+  };
+
+  var _forOf = createCommonjsModule(function (module) {
+  var BREAK = {};
+  var RETURN = {};
+  var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
+    var iterFn = ITERATOR ? function () { return iterable; } : core_getIteratorMethod(iterable);
+    var f = _ctx(fn, that, entries ? 2 : 1);
+    var index = 0;
+    var length, step, iterator, result;
+    if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
+    if (_isArrayIter(iterFn)) for (length = _toLength(iterable.length); length > index; index++) {
+      result = entries ? f(_anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
+      if (result === BREAK || result === RETURN) return result;
+    } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
+      result = _iterCall(iterator, f, step.value, entries);
+      if (result === BREAK || result === RETURN) return result;
+    }
+  };
+  exports.BREAK = BREAK;
+  exports.RETURN = RETURN;
+  });
+
+  var SPECIES = _wks('species');
+  var _speciesConstructor = function (O, D) {
+    var C = _anObject(O).constructor;
+    var S;
+    return C === undefined || (S = _anObject(C)[SPECIES]) == undefined ? D : _aFunction(S);
+  };
+
+  var _invoke = function (fn, args, that) {
+    var un = that === undefined;
+    switch (args.length) {
+      case 0: return un ? fn()
+                        : fn.call(that);
+      case 1: return un ? fn(args[0])
+                        : fn.call(that, args[0]);
+      case 2: return un ? fn(args[0], args[1])
+                        : fn.call(that, args[0], args[1]);
+      case 3: return un ? fn(args[0], args[1], args[2])
+                        : fn.call(that, args[0], args[1], args[2]);
+      case 4: return un ? fn(args[0], args[1], args[2], args[3])
+                        : fn.call(that, args[0], args[1], args[2], args[3]);
+    } return fn.apply(that, args);
+  };
+
+  var process = _global.process;
+  var setTask = _global.setImmediate;
+  var clearTask = _global.clearImmediate;
+  var MessageChannel = _global.MessageChannel;
+  var Dispatch = _global.Dispatch;
+  var counter = 0;
+  var queue = {};
+  var ONREADYSTATECHANGE = 'onreadystatechange';
+  var defer, channel, port;
+  var run = function () {
+    var id = +this;
+    if (queue.hasOwnProperty(id)) {
+      var fn = queue[id];
+      delete queue[id];
+      fn();
+    }
+  };
+  var listener = function (event) {
+    run.call(event.data);
+  };
+  if (!setTask || !clearTask) {
+    setTask = function setImmediate(fn) {
+      var args = [];
+      var i = 1;
+      while (arguments.length > i) args.push(arguments[i++]);
+      queue[++counter] = function () {
+        _invoke(typeof fn == 'function' ? fn : Function(fn), args);
+      };
+      defer(counter);
+      return counter;
+    };
+    clearTask = function clearImmediate(id) {
+      delete queue[id];
+    };
+    if (_cof(process) == 'process') {
+      defer = function (id) {
+        process.nextTick(_ctx(run, id, 1));
+      };
+    } else if (Dispatch && Dispatch.now) {
+      defer = function (id) {
+        Dispatch.now(_ctx(run, id, 1));
+      };
+    } else if (MessageChannel) {
+      channel = new MessageChannel();
+      port = channel.port2;
+      channel.port1.onmessage = listener;
+      defer = _ctx(port.postMessage, port, 1);
+    } else if (_global.addEventListener && typeof postMessage == 'function' && !_global.importScripts) {
+      defer = function (id) {
+        _global.postMessage(id + '', '*');
+      };
+      _global.addEventListener('message', listener, false);
+    } else if (ONREADYSTATECHANGE in _domCreate('script')) {
+      defer = function (id) {
+        _html.appendChild(_domCreate('script'))[ONREADYSTATECHANGE] = function () {
+          _html.removeChild(this);
+          run.call(id);
+        };
+      };
+    } else {
+      defer = function (id) {
+        setTimeout(_ctx(run, id, 1), 0);
+      };
+    }
+  }
+  var _task = {
+    set: setTask,
+    clear: clearTask
+  };
+
+  var macrotask = _task.set;
+  var Observer = _global.MutationObserver || _global.WebKitMutationObserver;
+  var process$1 = _global.process;
+  var Promise$1 = _global.Promise;
+  var isNode = _cof(process$1) == 'process';
+  var _microtask = function () {
+    var head, last, notify;
+    var flush = function () {
+      var parent, fn;
+      if (isNode && (parent = process$1.domain)) parent.exit();
+      while (head) {
+        fn = head.fn;
+        head = head.next;
+        try {
+          fn();
+        } catch (e) {
+          if (head) notify();
+          else last = undefined;
+          throw e;
+        }
+      } last = undefined;
+      if (parent) parent.enter();
+    };
+    if (isNode) {
+      notify = function () {
+        process$1.nextTick(flush);
+      };
+    } else if (Observer && !(_global.navigator && _global.navigator.standalone)) {
+      var toggle = true;
+      var node = document.createTextNode('');
+      new Observer(flush).observe(node, { characterData: true });
+      notify = function () {
+        node.data = toggle = !toggle;
+      };
+    } else if (Promise$1 && Promise$1.resolve) {
+      var promise = Promise$1.resolve(undefined);
+      notify = function () {
+        promise.then(flush);
+      };
+    } else {
+      notify = function () {
+        macrotask.call(_global, flush);
+      };
+    }
+    return function (fn) {
+      var task = { fn: fn, next: undefined };
+      if (last) last.next = task;
+      if (!head) {
+        head = task;
+        notify();
+      } last = task;
+    };
+  };
+
+  function PromiseCapability(C) {
+    var resolve, reject;
+    this.promise = new C(function ($$resolve, $$reject) {
+      if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+      resolve = $$resolve;
+      reject = $$reject;
+    });
+    this.resolve = _aFunction(resolve);
+    this.reject = _aFunction(reject);
+  }
+  var f$1 = function (C) {
+    return new PromiseCapability(C);
+  };
+  var _newPromiseCapability = {
+  	f: f$1
+  };
+
+  var _perform = function (exec) {
+    try {
+      return { e: false, v: exec() };
+    } catch (e) {
+      return { e: true, v: e };
+    }
+  };
+
+  var navigator$1 = _global.navigator;
+  var _userAgent = navigator$1 && navigator$1.userAgent || '';
+
+  var _promiseResolve = function (C, x) {
+    _anObject(C);
+    if (_isObject(x) && x.constructor === C) return x;
+    var promiseCapability = _newPromiseCapability.f(C);
+    var resolve = promiseCapability.resolve;
+    resolve(x);
+    return promiseCapability.promise;
+  };
+
+  var _redefineAll = function (target, src, safe) {
+    for (var key in src) {
+      if (safe && target[key]) target[key] = src[key];
+      else _hide(target, key, src[key]);
+    } return target;
+  };
+
+  var SPECIES$1 = _wks('species');
+  var _setSpecies = function (KEY) {
+    var C = typeof _core[KEY] == 'function' ? _core[KEY] : _global[KEY];
+    if (_descriptors && C && !C[SPECIES$1]) _objectDp.f(C, SPECIES$1, {
+      configurable: true,
+      get: function () { return this; }
+    });
+  };
+
+  var task = _task.set;
+  var microtask = _microtask();
+  var PROMISE = 'Promise';
+  var TypeError$1 = _global.TypeError;
+  var process$2 = _global.process;
+  var versions = process$2 && process$2.versions;
+  var v8 = versions && versions.v8 || '';
+  var $Promise = _global[PROMISE];
+  var isNode$1 = _classof(process$2) == 'process';
+  var empty = function () {  };
+  var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
+  var newPromiseCapability = newGenericPromiseCapability = _newPromiseCapability.f;
+  var USE_NATIVE = !!function () {
+    try {
+      var promise = $Promise.resolve(1);
+      var FakePromise = (promise.constructor = {})[_wks('species')] = function (exec) {
+        exec(empty, empty);
+      };
+      return (isNode$1 || typeof PromiseRejectionEvent == 'function')
+        && promise.then(empty) instanceof FakePromise
+        && v8.indexOf('6.6') !== 0
+        && _userAgent.indexOf('Chrome/66') === -1;
+    } catch (e) {  }
+  }();
+  var isThenable = function (it) {
+    var then;
+    return _isObject(it) && typeof (then = it.then) == 'function' ? then : false;
+  };
+  var notify = function (promise, isReject) {
+    if (promise._n) return;
+    promise._n = true;
+    var chain = promise._c;
+    microtask(function () {
+      var value = promise._v;
+      var ok = promise._s == 1;
+      var i = 0;
+      var run = function (reaction) {
+        var handler = ok ? reaction.ok : reaction.fail;
+        var resolve = reaction.resolve;
+        var reject = reaction.reject;
+        var domain = reaction.domain;
+        var result, then, exited;
+        try {
+          if (handler) {
+            if (!ok) {
+              if (promise._h == 2) onHandleUnhandled(promise);
+              promise._h = 1;
+            }
+            if (handler === true) result = value;
+            else {
+              if (domain) domain.enter();
+              result = handler(value);
+              if (domain) {
+                domain.exit();
+                exited = true;
+              }
+            }
+            if (result === reaction.promise) {
+              reject(TypeError$1('Promise-chain cycle'));
+            } else if (then = isThenable(result)) {
+              then.call(result, resolve, reject);
+            } else resolve(result);
+          } else reject(value);
+        } catch (e) {
+          if (domain && !exited) domain.exit();
+          reject(e);
+        }
+      };
+      while (chain.length > i) run(chain[i++]);
+      promise._c = [];
+      promise._n = false;
+      if (isReject && !promise._h) onUnhandled(promise);
+    });
+  };
+  var onUnhandled = function (promise) {
+    task.call(_global, function () {
+      var value = promise._v;
+      var unhandled = isUnhandled(promise);
+      var result, handler, console;
+      if (unhandled) {
+        result = _perform(function () {
+          if (isNode$1) {
+            process$2.emit('unhandledRejection', value, promise);
+          } else if (handler = _global.onunhandledrejection) {
+            handler({ promise: promise, reason: value });
+          } else if ((console = _global.console) && console.error) {
+            console.error('Unhandled promise rejection', value);
+          }
+        });
+        promise._h = isNode$1 || isUnhandled(promise) ? 2 : 1;
+      } promise._a = undefined;
+      if (unhandled && result.e) throw result.v;
+    });
+  };
+  var isUnhandled = function (promise) {
+    return promise._h !== 1 && (promise._a || promise._c).length === 0;
+  };
+  var onHandleUnhandled = function (promise) {
+    task.call(_global, function () {
+      var handler;
+      if (isNode$1) {
+        process$2.emit('rejectionHandled', promise);
+      } else if (handler = _global.onrejectionhandled) {
+        handler({ promise: promise, reason: promise._v });
+      }
+    });
+  };
+  var $reject = function (value) {
+    var promise = this;
+    if (promise._d) return;
+    promise._d = true;
+    promise = promise._w || promise;
+    promise._v = value;
+    promise._s = 2;
+    if (!promise._a) promise._a = promise._c.slice();
+    notify(promise, true);
+  };
+  var $resolve = function (value) {
+    var promise = this;
+    var then;
+    if (promise._d) return;
+    promise._d = true;
+    promise = promise._w || promise;
+    try {
+      if (promise === value) throw TypeError$1("Promise can't be resolved itself");
+      if (then = isThenable(value)) {
+        microtask(function () {
+          var wrapper = { _w: promise, _d: false };
+          try {
+            then.call(value, _ctx($resolve, wrapper, 1), _ctx($reject, wrapper, 1));
+          } catch (e) {
+            $reject.call(wrapper, e);
+          }
+        });
+      } else {
+        promise._v = value;
+        promise._s = 1;
+        notify(promise, false);
+      }
+    } catch (e) {
+      $reject.call({ _w: promise, _d: false }, e);
+    }
+  };
+  if (!USE_NATIVE) {
+    $Promise = function Promise(executor) {
+      _anInstance(this, $Promise, PROMISE, '_h');
+      _aFunction(executor);
+      Internal.call(this);
+      try {
+        executor(_ctx($resolve, this, 1), _ctx($reject, this, 1));
+      } catch (err) {
+        $reject.call(this, err);
+      }
+    };
+    Internal = function Promise(executor) {
+      this._c = [];
+      this._a = undefined;
+      this._s = 0;
+      this._d = false;
+      this._v = undefined;
+      this._h = 0;
+      this._n = false;
+    };
+    Internal.prototype = _redefineAll($Promise.prototype, {
+      then: function then(onFulfilled, onRejected) {
+        var reaction = newPromiseCapability(_speciesConstructor(this, $Promise));
+        reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+        reaction.fail = typeof onRejected == 'function' && onRejected;
+        reaction.domain = isNode$1 ? process$2.domain : undefined;
+        this._c.push(reaction);
+        if (this._a) this._a.push(reaction);
+        if (this._s) notify(this, false);
+        return reaction.promise;
+      },
+      'catch': function (onRejected) {
+        return this.then(undefined, onRejected);
+      }
+    });
+    OwnPromiseCapability = function () {
+      var promise = new Internal();
+      this.promise = promise;
+      this.resolve = _ctx($resolve, promise, 1);
+      this.reject = _ctx($reject, promise, 1);
+    };
+    _newPromiseCapability.f = newPromiseCapability = function (C) {
+      return C === $Promise || C === Wrapper
+        ? new OwnPromiseCapability(C)
+        : newGenericPromiseCapability(C);
+    };
+  }
+  _export(_export.G + _export.W + _export.F * !USE_NATIVE, { Promise: $Promise });
+  _setToStringTag($Promise, PROMISE);
+  _setSpecies(PROMISE);
+  Wrapper = _core[PROMISE];
+  _export(_export.S + _export.F * !USE_NATIVE, PROMISE, {
+    reject: function reject(r) {
+      var capability = newPromiseCapability(this);
+      var $$reject = capability.reject;
+      $$reject(r);
+      return capability.promise;
+    }
+  });
+  _export(_export.S + _export.F * (_library ), PROMISE, {
+    resolve: function resolve(x) {
+      return _promiseResolve( this === Wrapper ? $Promise : this, x);
+    }
+  });
+  _export(_export.S + _export.F * !(USE_NATIVE && _iterDetect(function (iter) {
+    $Promise.all(iter)['catch'](empty);
+  })), PROMISE, {
+    all: function all(iterable) {
+      var C = this;
+      var capability = newPromiseCapability(C);
+      var resolve = capability.resolve;
+      var reject = capability.reject;
+      var result = _perform(function () {
+        var values = [];
+        var index = 0;
+        var remaining = 1;
+        _forOf(iterable, false, function (promise) {
+          var $index = index++;
+          var alreadyCalled = false;
+          values.push(undefined);
+          remaining++;
+          C.resolve(promise).then(function (value) {
+            if (alreadyCalled) return;
+            alreadyCalled = true;
+            values[$index] = value;
+            --remaining || resolve(values);
+          }, reject);
+        });
+        --remaining || resolve(values);
+      });
+      if (result.e) reject(result.v);
+      return capability.promise;
+    },
+    race: function race(iterable) {
+      var C = this;
+      var capability = newPromiseCapability(C);
+      var reject = capability.reject;
+      var result = _perform(function () {
+        _forOf(iterable, false, function (promise) {
+          C.resolve(promise).then(capability.resolve, reject);
+        });
+      });
+      if (result.e) reject(result.v);
+      return capability.promise;
+    }
+  });
+
+  _export(_export.P + _export.R, 'Promise', { 'finally': function (onFinally) {
+    var C = _speciesConstructor(this, _core.Promise || _global.Promise);
+    var isFunction = typeof onFinally == 'function';
+    return this.then(
+      isFunction ? function (x) {
+        return _promiseResolve(C, onFinally()).then(function () { return x; });
+      } : onFinally,
+      isFunction ? function (e) {
+        return _promiseResolve(C, onFinally()).then(function () { throw e; });
+      } : onFinally
+    );
+  } });
+
+  _export(_export.S, 'Promise', { 'try': function (callbackfn) {
+    var promiseCapability = _newPromiseCapability.f(this);
+    var result = _perform(callbackfn);
+    (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
+    return promiseCapability.promise;
+  } });
+
+  var promise = _core.Promise;
+
+  var promise$1 = promise;
+
   var _isArray = Array.isArray || function isArray(arg) {
     return _cof(arg) == 'Array';
   };
@@ -624,6 +1711,7 @@
 
   var isArray$1 = isArray;
 
+  var _this = undefined;
   var parseResponse = function parseResponse(response) {
     if (!response) {
       return response || {};
@@ -634,7 +1722,7 @@
       return response || {};
     }
   };
-  function upload(options) {
+  var defaultRequest = function defaultRequest(options) {
     var xhr = new XMLHttpRequest();
     options.fileObj.xhr = xhr;
     var formData = new FormData();
@@ -677,7 +1765,166 @@
         xhr.abort();
       }
     };
-  }
+  };
+  var blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
+  var sliceRequest = function () {
+    var _ref = _asyncToGenerator( regenerator.mark(function _callee(options) {
+      var chunkSize, file, blockCount, hash, progressList;
+      return regenerator.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              chunkSize = options.chunkSize * 1024 * 1024;
+              file = options.fileObj.origin;
+              if (file) {
+                _context.next = 5;
+                break;
+              }
+              _this.$bkMessage({
+                theme: 'warning',
+                message: '没有获取到文件',
+                offsetY: 80
+              });
+              return _context.abrupt("return");
+            case 5:
+              blockCount = Math.ceil(file.size / chunkSize);
+              _context.next = 8;
+              return hashFile(file, chunkSize);
+            case 8:
+              hash = _context.sent;
+              progressList = [];
+              sliceUpload(options, file, blockCount, hash, progressList, chunkSize);
+              _context.next = 13;
+              return promise$1.all(progressList).then(function () {
+                var data = {
+                  size: file.size,
+                  name: file.name,
+                  total: blockCount,
+                  hash: hash
+                };
+                var req = new XMLHttpRequest();
+                req.open(options.method, options.mergeUrl, true);
+                req.onreadystatechange = function () {
+                  if (req.readyState === 4) {
+                    var reponseText = parseResponse(req.responseText || req.response);
+                    if (req.status < 200 || req.status >= 300) {
+                      options.fileObj.progress = 100 + '%';
+                      options.fileObj.errorMsg = reponseText.message || locale.t('bk.uploadFile.uploadFailed');
+                      options.onError(options.fileObj, options.fileList, req.response);
+                    } else {
+                      options.onSuccess(reponseText, options.fileObj);
+                    }
+                    options.onDone(options.fileObj);
+                  }
+                };
+                req.setRequestHeader('Content-type', 'application/JSON');
+                req.send(stringify$1(data));
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+    return function sliceRequest(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var sliceUpload = function sliceUpload(options, file, blockCount, hash, progressList, chunkSize) {
+    var _loop = function _loop(i) {
+      var pooltask = new promise$1(function (resolve, reject) {
+        var start = i * chunkSize;
+        var end = Math.min(file.size, start + chunkSize);
+        var formData = new FormData();
+        options.data.forEach(function (item) {
+          formData.append(item.name, item.value);
+        });
+        formData.append('file', blobSlice.call(file, start, end));
+        formData.append('name', file.name);
+        formData.append('total', blockCount);
+        formData.append('index', i);
+        formData.append('size', file.size);
+        formData.append('hash', hash);
+        var xhr = new XMLHttpRequest();
+        options.fileObj.xhr = xhr;
+        xhr.onreadystatechange = function () {
+          if (xhr.readyState === 4) {
+            var reponseText = parseResponse(xhr.responseText || xhr.response);
+            if (xhr.status < 200 || xhr.status >= 300) {
+              reject(xhr.response);
+              options.fileObj.progress = 100 + '%';
+              options.fileObj.errorMsg = reponseText.message || locale.t('bk.uploadFile.uploadFailed');
+              options.onError(options.fileObj, options.fileList, xhr.response);
+            } else {
+              resolve('reponseText');
+            }
+            options.onDone(options.fileObj);
+          }
+        };
+        xhr.upload.addEventListener('progress', function (e) {
+          return options.onProgress(e, i);
+        }, false);
+        xhr.withCredentials = options.withCredentials;
+        xhr.open(options.method, options.sliceUrl, true);
+        if (options.header) {
+          if (isArray$1(options.header)) {
+            options.header.forEach(function (head) {
+              var headerKey = head.name;
+              var headerVal = head.value;
+              xhr.setRequestHeader(headerKey, headerVal);
+            });
+          } else {
+            var headerKey = options.header.name;
+            var headerVal = options.header.value;
+            xhr.setRequestHeader(headerKey, headerVal);
+          }
+        }
+        xhr.send(formData);
+      });
+      progressList.push(pooltask);
+    };
+    for (var i = 0; i < blockCount; i++) {
+      _loop(i);
+    }
+  };
+  var hashFile = function hashFile(file, chunkSize) {
+    return new promise$1(function (resolve, reject) {
+      var chunks = Math.ceil(file.size / chunkSize);
+      var currentChunk = 0;
+      var spark = new SparkMD5.ArrayBuffer();
+      var fileReader = new FileReader();
+      function loadNext() {
+        var start = currentChunk * chunkSize;
+        var end = start + chunkSize >= file.size ? file.size : start + chunkSize;
+        fileReader.readAsArrayBuffer(blobSlice.call(file, start, end));
+      }
+      fileReader.onload = function (e) {
+        spark.append(e.target.result);
+        currentChunk += 1;
+        if (currentChunk < chunks) {
+          loadNext();
+        } else {
+          var result = spark.end();
+          var sparkMd5 = new SparkMD5();
+          sparkMd5.append(result);
+          sparkMd5.append(file.name);
+          var hexHash = sparkMd5.end();
+          resolve(hexHash);
+        }
+      };
+      fileReader.onerror = function () {
+        _this.$bkMessage({
+          theme: 'warning',
+          message: '文件分片失败',
+          offsetY: 80
+        });
+      };
+      loadNext();
+    }).catch(function (err) {
+      console.log(err);
+    });
+  };
 
   var _stringWs = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
     '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
@@ -791,14 +2038,14 @@
 
   var keys$1 = keys;
 
-  var f$1 = Object.getOwnPropertySymbols;
+  var f$2 = Object.getOwnPropertySymbols;
   var _objectGops = {
-  	f: f$1
+  	f: f$2
   };
 
-  var f$2 = {}.propertyIsEnumerable;
+  var f$3 = {}.propertyIsEnumerable;
   var _objectPie = {
-  	f: f$2
+  	f: f$3
   };
 
   var $assign = Object.assign;
@@ -838,8 +2085,8 @@
   var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
   var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
   var timeoutDuration = 0;
-  for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
-    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
+  for (var i$1 = 0; i$1 < longerTimeoutBrowsers.length; i$1 += 1) {
+    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i$1]) >= 0) {
       timeoutDuration = 1;
       break;
     }
@@ -3405,7 +4652,7 @@
         default: 0
       },
       url: {
-        required: true,
+        required: false,
         type: String
       },
       size: {
@@ -3449,7 +4696,23 @@
         type: String,
         default: ''
       },
-      customRequest: Function
+      customRequest: Function,
+      sliceUpload: {
+        type: Boolean,
+        default: false
+      },
+      sliceUrl: {
+        type: String,
+        default: ''
+      },
+      mergeUrl: {
+        type: String,
+        default: ''
+      },
+      chunkSize: {
+        type: Number,
+        default: 10
+      }
     },
     data: function data() {
       return {
@@ -3596,6 +4859,9 @@
             fileHeader: '',
             origin: file,
             url: '',
+            sliceUrl: '',
+            mergeUrl: '',
+            chunkSize: 10,
             base64: '',
             status: '',
             done: false,
@@ -3662,9 +4928,10 @@
           this.$emit('on-error', fileObj, this.fileList);
           return;
         }
-        var uploadProgress = function uploadProgress(e) {
-          if (e.lengthComputable) {
-            var percentComplete = Math.round(e.loaded * 100 / e.total);
+        var progressList = [];
+        var uploadProgress = function uploadProgress(e, val) {
+          if (e.lengthComputable && !_this5.sliceUpload) {
+            var percentComplete = val || Math.round(e.loaded * 100 / e.total);
             var kb = Math.round(e.loaded / 1000);
             fileObj.progress = percentComplete + '%';
             _this5.speed = kb - _this5.total;
@@ -3676,6 +4943,24 @@
             }
             _this5.$emit('on-progress', e, fileObj, _this5.fileList);
           }
+          if (e.lengthComputable && _this5.sliceUpload) {
+            progressList[val] = e.loaded;
+            var complete = progressList.reduce(function (p, c) {
+              return p + c;
+            });
+            var _kb = Math.round(complete / 1000);
+            _this5.speed = _kb - _this5.total;
+            _this5.total = _kb;
+            _this5.unit = 'kb/s';
+            if (_this5.speed > 1000) {
+              _this5.speed = Math.round(_this5.speed / 1000);
+              _this5.unit = 'mb/s';
+            }
+            fileObj.progress = Math.round(complete * 100 / fileObj.origin.size) + '%';
+            if (fileObj.progress === 100 + '%') {
+              _this5.$emit('on-progress', e, fileObj, _this5.fileList);
+            }
+          }
           fileObj.status = 'running';
         };
         var options = {
@@ -3687,8 +4972,11 @@
           method: 'POST',
           header: this.header,
           url: this.url,
-          onProgress: function onProgress(event) {
-            uploadProgress(event);
+          sliceUrl: this.sliceUrl,
+          mergeUrl: this.mergeUrl,
+          chunkSize: this.chunkSize,
+          onProgress: function onProgress(event, val) {
+            uploadProgress(event, val);
           },
           onSuccess: function onSuccess(reponseText, fileObj) {
             _this5.handleSuccess(reponseText, fileObj);
@@ -3701,7 +4989,7 @@
           }
         };
         this.isdrag = false;
-        var request = this.customRequest || upload;
+        var request = this.customRequest ? this.customRequest : this.sliceUpload ? sliceRequest : defaultRequest;
         request(options);
       },
       handleSuccess: function handleSuccess(response, file) {