bkui-vue 0.0.1-beta.39 → 0.0.1-beta.390

package/lib/upload/index.js

@@ -0,0 +1,3681 @@
+import * as __WEBPACK_EXTERNAL_MODULE__shared_65459f0a__ from "../shared";
+import * as __WEBPACK_EXTERNAL_MODULE_vue__ from "vue";
+import * as __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__ from "../icon";
+import * as __WEBPACK_EXTERNAL_MODULE__progress_ed4d3a99__ from "../progress";
+import * as __WEBPACK_EXTERNAL_MODULE__button_59c00871__ from "../button";
+/******/ var __webpack_modules__ = ({
+
+/***/ 7162:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(5047);
+
+
+/***/ }),
+
+/***/ 5047:
+/***/ ((module) => {
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var runtime = (function (exports) {
+  "use strict";
+
+  var Op = Object.prototype;
+  var hasOwn = Op.hasOwnProperty;
+  var undefined; // More compressible than void 0.
+  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 {
+    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
+    define({}, "");
+  } catch (err) {
+    define = function(obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+    var generator = Object.create(protoGenerator.prototype);
+    var context = new Context(tryLocsList || []);
+
+    // The ._invoke method unifies the implementations of the .next,
+    // .throw, and .return methods.
+    generator._invoke = makeInvokeMethod(innerFn, self, context);
+
+    return generator;
+  }
+  exports.wrap = wrap;
+
+  // Try/catch helper to minimize deoptimizations. Returns a completion
+  // record like context.tryEntries[i].completion. This interface could
+  // have been (and was previously) designed to take a closure to be
+  // invoked without arguments, but in all the cases we care about we
+  // already have an existing method we want to call, so there's no need
+  // to create a new function object. We can even get away with assuming
+  // the method takes exactly one argument, since that happens to be true
+  // in every case, so we don't have to touch the arguments object. The
+  // only additional allocation required is the completion record, which
+  // has a stable shape and so hopefully should be cheap to allocate.
+  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";
+
+  // Returning this object from the innerFn has the same effect as
+  // breaking out of the dispatch switch statement.
+  var ContinueSentinel = {};
+
+  // Dummy constructor functions that we use as the .constructor and
+  // .constructor.prototype properties for functions that return Generator
+  // objects. For full spec compliance, you may wish to configure your
+  // minifier not to mangle the names of these two functions.
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+
+  // This is a polyfill for %IteratorPrototype% for environments that
+  // don't natively support it.
+  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)) {
+    // This environment has a native %IteratorPrototype%; use it instead
+    // of the polyfill.
+    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"
+  );
+
+  // Helper for defining the .next, .throw, and .return methods of the
+  // Iterator interface in terms of a single ._invoke method.
+  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 ||
+        // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (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;
+  };
+
+  // Within the body of any async function, `await x` is transformed to
+  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+  // `hasOwn.call(value, "__await")` to determine if the yielded value is
+  // meant to be awaited.
+  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) {
+          // When a yielded Promise is resolved, its final value becomes
+          // the .value of the Promise<{value,done}> result for the
+          // current iteration.
+          result.value = unwrapped;
+          resolve(result);
+        }, function(error) {
+          // If a rejected Promise was yielded, throw the rejection back
+          // into the async generator function so it can be handled there.
+          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 =
+        // If enqueue has been called before, then we want to wait until
+        // all previous Promises have been resolved before calling invoke,
+        // so that results are always delivered in the correct order. If
+        // enqueue has not been called before, then it is important to
+        // call invoke immediately, without waiting on a callback to fire,
+        // so that the async generator function has the opportunity to do
+        // any necessary setup in a predictable way. This predictability
+        // is why the Promise constructor synchronously invokes its
+        // executor callback, and why async functions synchronously
+        // execute code before the first await. Since we implement simple
+        // async functions in terms of async generators, it is especially
+        // important to get this right, even though it requires care.
+        previousPromise ? previousPromise.then(
+          callInvokeWithMethodAndArg,
+          // Avoid propagating failures to Promises returned by later
+          // invocations of the iterator.
+          callInvokeWithMethodAndArg
+        ) : callInvokeWithMethodAndArg();
+    }
+
+    // Define the unified helper method that is used to implement .next,
+    // .throw, and .return (see defineIteratorMethods).
+    this._invoke = enqueue;
+  }
+
+  defineIteratorMethods(AsyncIterator.prototype);
+  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  });
+  exports.AsyncIterator = AsyncIterator;
+
+  // Note that simple async functions are implemented on top of
+  // AsyncIterator objects; they just return a Promise for the value of
+  // the final result produced by the iterator.
+  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 // If outerFn is a generator, return the full iterator.
+      : 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;
+        }
+
+        // Be forgiving, per 25.3.3.3.3 of the spec:
+        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+        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") {
+          // Setting context._sent for legacy support of Babel's
+          // function.sent implementation.
+          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") {
+          // If an exception is thrown from innerFn, we leave state ===
+          // GenStateExecuting and loop back for another invocation.
+          state = context.done
+            ? GenStateCompleted
+            : GenStateSuspendedYield;
+
+          if (record.arg === ContinueSentinel) {
+            continue;
+          }
+
+          return {
+            value: record.arg,
+            done: context.done
+          };
+
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+          // Dispatch the exception by looping back around to the
+          // context.dispatchException(context.arg) call above.
+          context.method = "throw";
+          context.arg = record.arg;
+        }
+      }
+    };
+  }
+
+  // Call delegate.iterator[context.method](context.arg) and handle the
+  // result, either by returning a { value, done } result from the
+  // delegate iterator, or by modifying context.method and context.arg,
+  // setting context.delegate to null, and returning the ContinueSentinel.
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+    if (method === undefined) {
+      // A .throw or .return when the delegate iterator has no .throw
+      // method always terminates the yield* loop.
+      context.delegate = null;
+
+      if (context.method === "throw") {
+        // Note: ["return"] must be used for ES3 parsing compatibility.
+        if (delegate.iterator["return"]) {
+          // If the delegate iterator has a return method, give it a
+          // chance to clean up.
+          context.method = "return";
+          context.arg = undefined;
+          maybeInvokeDelegate(delegate, context);
+
+          if (context.method === "throw") {
+            // If maybeInvokeDelegate(context) changed context.method from
+            // "return" to "throw", let that override the TypeError below.
+            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) {
+      // Assign the result of the finished delegate to the temporary
+      // variable specified by delegate.resultName (see delegateYield).
+      context[delegate.resultName] = info.value;
+
+      // Resume execution at the desired location (see delegateYield).
+      context.next = delegate.nextLoc;
+
+      // If context.method was "throw" but the delegate handled the
+      // exception, let the outer generator proceed normally. If
+      // context.method was "next", forget context.arg since it has been
+      // "consumed" by the delegate iterator. If context.method was
+      // "return", allow the original .return call to continue in the
+      // outer generator.
+      if (context.method !== "return") {
+        context.method = "next";
+        context.arg = undefined;
+      }
+
+    } else {
+      // Re-yield the result returned by the delegate method.
+      return info;
+    }
+
+    // The delegate iterator is finished, so forget it and continue with
+    // the outer generator.
+    context.delegate = null;
+    return ContinueSentinel;
+  }
+
+  // Define Generator.prototype.{next,throw,return} in terms of the
+  // unified ._invoke helper method.
+  defineIteratorMethods(Gp);
+
+  define(Gp, toStringTagSymbol, "Generator");
+
+  // A Generator should always return itself as the iterator object when the
+  // @@iterator function is called on it. Some browsers' implementations of the
+  // iterator prototype chain incorrectly implement this, causing the Generator
+  // object to not be returned from this call. This ensures that doesn't happen.
+  // See https://github.com/facebook/regenerator/issues/274 for more details.
+  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) {
+    // The root entry object (effectively a try statement without a catch
+    // or a finally block) gives us a place to store values thrown from
+    // locations where there is no enclosing try statement.
+    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();
+
+    // Rather than returning an object with a next method, we keep
+    // things simple and return the next function itself.
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      // To avoid creating an additional object, we just hang the .value
+      // and .done properties off the next function object itself. This
+      // also ensures that the minifier will not anonymize the function.
+      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;
+          next.done = true;
+
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    // Return an iterator with no values.
+    return { next: doneResult };
+  }
+  exports.values = values;
+
+  function doneResult() {
+    return { value: undefined, done: true };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+
+    reset: function(skipTempReset) {
+      this.prev = 0;
+      this.next = 0;
+      // Resetting context._sent for legacy support of Babel's
+      // function.sent implementation.
+      this.sent = this._sent = undefined;
+      this.done = false;
+      this.delegate = null;
+
+      this.method = "next";
+      this.arg = undefined;
+
+      this.tryEntries.forEach(resetTryEntry);
+
+      if (!skipTempReset) {
+        for (var name in this) {
+          // Not sure about the optimal order of these conditions:
+          if (name.charAt(0) === "t" &&
+              hasOwn.call(this, name) &&
+              !isNaN(+name.slice(1))) {
+            this[name] = undefined;
+          }
+        }
+      }
+    },
+
+    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) {
+          // If the dispatched exception was caught by a catch block,
+          // then let that catch block handle the exception normally.
+          context.method = "next";
+          context.arg = undefined;
+        }
+
+        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") {
+          // Exception thrown outside of any try block that could handle
+          // it, so set the completion value of the entire function to
+          // throw the exception.
+          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) {
+        // Ignore the finally entry if control is not jumping to a
+        // location outside the try/catch block.
+        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;
+        }
+      }
+
+      // The context.catch method must only be called with a location
+      // argument that corresponds to a known catch block.
+      throw new Error("illegal catch attempt");
+    },
+
+    delegateYield: function(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      if (this.method === "next") {
+        // Deliberately forget the last sent value so that we don't
+        // accidentally pass it on to the delegate.
+        this.arg = undefined;
+      }
+
+      return ContinueSentinel;
+    }
+  };
+
+  // Regardless of whether this script is executing as a CommonJS module
+  // or not, return the runtime object so that we can declare the variable
+  // regeneratorRuntime in the outer scope, which allows this module to be
+  // injected easily by `bin/regenerator --include-runtime script.js`.
+  return exports;
+
+}(
+  // If this script is executing as a CommonJS module, use module.exports
+  // as the regeneratorRuntime namespace. Otherwise create a new empty
+  // object. Either way, the resulting object will be used to initialize
+  // the regeneratorRuntime variable at the top of this file.
+   true ? module.exports : 0
+));
+
+try {
+  regeneratorRuntime = runtime;
+} catch (accidentalStrictMode) {
+  // This module should not be running in strict mode, so the above
+  // assignment should always work unless something is misconfigured. Just
+  // in case runtime.js accidentally runs in strict mode, in modern engines
+  // we can explicitly access globalThis. In older engines we can escape
+  // strict mode using a global Function call. This could conceivably fail
+  // if a Content Security Policy forbids using Function, but in that case
+  // the proper solution is to fix the accidental strict mode problem. If
+  // you've misconfigured your bundler to force strict mode and applied a
+  // CSP to forbid Function, and you're not willing to fix either of those
+  // problems, please detail your unique predicament in a GitHub issue.
+  if (typeof globalThis === "object") {
+    globalThis.regeneratorRuntime = runtime;
+  } else {
+    Function("r", "regeneratorRuntime = r")(runtime);
+  }
+}
+
+
+/***/ }),
+
+/***/ 4791:
+/***/ ((module) => {
+
+(function (factory) {
+    if (true) {
+        // Node/CommonJS
+        module.exports = factory();
+    } else { var glob; }
+}(function (undefined) {
+
+    'use strict';
+
+    /*
+     * Fastest md5 implementation around (JKM md5).
+     * Credits: Joseph Myers
+     *
+     * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+     * @see http://jsperf.com/md5-shootout/7
+     */
+
+    /* this function is much faster,
+      so if possible we use it. Some IEs
+      are the only ones I know of that
+      need the idiotic second function,
+      generated by an if clause.  */
+    var add32 = function (a, b) {
+        return (a + b) & 0xFFFFFFFF;
+    },
+        hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+
+
+    function cmn(q, a, b, x, s, t) {
+        a = add32(add32(a, q), add32(x, t));
+        return add32((a << s) | (a >>> (32 - s)), b);
+    }
+
+    function md5cycle(x, k) {
+        var a = x[0],
+            b = x[1],
+            c = x[2],
+            d = x[3];
+
+        a += (b & c | ~b & d) + k[0] - 680876936 | 0;
+        a  = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[1] - 389564586 | 0;
+        d  = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[2] + 606105819 | 0;
+        c  = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
+        b  = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[4] - 176418897 | 0;
+        a  = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
+        d  = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
+        c  = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[7] - 45705983 | 0;
+        b  = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
+        a  = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
+        d  = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[10] - 42063 | 0;
+        c  = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
+        b  = (b << 22 | b >>> 10) + c | 0;
+        a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
+        a  = (a << 7 | a >>> 25) + b | 0;
+        d += (a & b | ~a & c) + k[13] - 40341101 | 0;
+        d  = (d << 12 | d >>> 20) + a | 0;
+        c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
+        c  = (c << 17 | c >>> 15) + d | 0;
+        b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
+        b  = (b << 22 | b >>> 10) + c | 0;
+
+        a += (b & d | c & ~d) + k[1] - 165796510 | 0;
+        a  = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
+        d  = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[11] + 643717713 | 0;
+        c  = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[0] - 373897302 | 0;
+        b  = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[5] - 701558691 | 0;
+        a  = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[10] + 38016083 | 0;
+        d  = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[15] - 660478335 | 0;
+        c  = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[4] - 405537848 | 0;
+        b  = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[9] + 568446438 | 0;
+        a  = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
+        d  = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[3] - 187363961 | 0;
+        c  = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
+        b  = (b << 20 | b >>> 12) + c | 0;
+        a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
+        a  = (a << 5 | a >>> 27) + b | 0;
+        d += (a & c | b & ~c) + k[2] - 51403784 | 0;
+        d  = (d << 9 | d >>> 23) + a | 0;
+        c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
+        c  = (c << 14 | c >>> 18) + d | 0;
+        b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
+        b  = (b << 20 | b >>> 12) + c | 0;
+
+        a += (b ^ c ^ d) + k[5] - 378558 | 0;
+        a  = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
+        d  = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
+        c  = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[14] - 35309556 | 0;
+        b  = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
+        a  = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
+        d  = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[7] - 155497632 | 0;
+        c  = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
+        b  = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[13] + 681279174 | 0;
+        a  = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[0] - 358537222 | 0;
+        d  = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[3] - 722521979 | 0;
+        c  = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[6] + 76029189 | 0;
+        b  = (b << 23 | b >>> 9) + c | 0;
+        a += (b ^ c ^ d) + k[9] - 640364487 | 0;
+        a  = (a << 4 | a >>> 28) + b | 0;
+        d += (a ^ b ^ c) + k[12] - 421815835 | 0;
+        d  = (d << 11 | d >>> 21) + a | 0;
+        c += (d ^ a ^ b) + k[15] + 530742520 | 0;
+        c  = (c << 16 | c >>> 16) + d | 0;
+        b += (c ^ d ^ a) + k[2] - 995338651 | 0;
+        b  = (b << 23 | b >>> 9) + c | 0;
+
+        a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
+        a  = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
+        d  = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
+        c  = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
+        b  = (b << 21 |b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
+        a  = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
+        d  = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
+        c  = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
+        b  = (b << 21 |b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
+        a  = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
+        d  = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
+        c  = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
+        b  = (b << 21 |b >>> 11) + c | 0;
+        a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
+        a  = (a << 6 | a >>> 26) + b | 0;
+        d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
+        d  = (d << 10 | d >>> 22) + a | 0;
+        c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
+        c  = (c << 15 | c >>> 17) + d | 0;
+        b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
+        b  = (b << 21 | b >>> 11) + c | 0;
+
+        x[0] = a + x[0] | 0;
+        x[1] = b + x[1] | 0;
+        x[2] = c + x[2] | 0;
+        x[3] = d + x[3] | 0;
+    }
+
+    function md5blk(s) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+
+    function md5blk_array(a) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+        }
+        return md5blks;
+    }
+
+    function md51(s) {
+        var n = s.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        }
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+        return state;
+    }
+
+    function md51_array(a) {
+        var n = a.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+        }
+
+        // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+        // containing the last element of the parent array if the sub array specified starts
+        // beyond the length of the parent array - weird.
+        // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+        a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+        length = a.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= a[i] << ((i % 4) << 3);
+        }
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+
+        return state;
+    }
+
+    function rhex(n) {
+        var s = '',
+            j;
+        for (j = 0; j < 4; j += 1) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+        }
+        return s;
+    }
+
+    function hex(x) {
+        var i;
+        for (i = 0; i < x.length; i += 1) {
+            x[i] = rhex(x[i]);
+        }
+        return x.join('');
+    }
+
+    // In some cases the fast add32 function cannot be used..
+    if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') {
+        add32 = function (x, y) {
+            var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+                msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+            return (msw << 16) | (lsw & 0xFFFF);
+        };
+    }
+
+    // ---------------------------------------------------
+
+    /**
+     * ArrayBuffer slice polyfill.
+     *
+     * @see https://github.com/ttaubert/node-arraybuffer-slice
+     */
+
+    if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {
+        (function () {
+            function clamp(val, length) {
+                val = (val | 0) || 0;
+
+                if (val < 0) {
+                    return Math.max(val + length, 0);
+                }
+
+                return Math.min(val, length);
+            }
+
+            ArrayBuffer.prototype.slice = function (from, to) {
+                var length = this.byteLength,
+                    begin = clamp(from, length),
+                    end = length,
+                    num,
+                    target,
+                    targetArray,
+                    sourceArray;
+
+                if (to !== undefined) {
+                    end = clamp(to, length);
+                }
+
+                if (begin > end) {
+                    return new ArrayBuffer(0);
+                }
+
+                num = end - begin;
+                target = new ArrayBuffer(num);
+                targetArray = new Uint8Array(target);
+
+                sourceArray = new Uint8Array(this, begin, num);
+                targetArray.set(sourceArray);
+
+                return target;
+            };
+        })();
+    }
+
+    // ---------------------------------------------------
+
+    /**
+     * Helpers.
+     */
+
+    function toUtf8(str) {
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        return str;
+    }
+
+    function utf8Str2ArrayBuffer(str, returnUInt8Array) {
+        var length = str.length,
+           buff = new ArrayBuffer(length),
+           arr = new Uint8Array(buff),
+           i;
+
+        for (i = 0; i < length; i += 1) {
+            arr[i] = str.charCodeAt(i);
+        }
+
+        return returnUInt8Array ? arr : buff;
+    }
+
+    function arrayBuffer2Utf8Str(buff) {
+        return String.fromCharCode.apply(null, new Uint8Array(buff));
+    }
+
+    function concatenateArrayBuffers(first, second, returnUInt8Array) {
+        var result = new Uint8Array(first.byteLength + second.byteLength);
+
+        result.set(new Uint8Array(first));
+        result.set(new Uint8Array(second), first.byteLength);
+
+        return returnUInt8Array ? result : result.buffer;
+    }
+
+    function hexToBinaryString(hex) {
+        var bytes = [],
+            length = hex.length,
+            x;
+
+        for (x = 0; x < length - 1; x += 2) {
+            bytes.push(parseInt(hex.substr(x, 2), 16));
+        }
+
+        return String.fromCharCode.apply(String, bytes);
+    }
+
+    // ---------------------------------------------------
+
+    /**
+     * SparkMD5 OOP implementation.
+     *
+     * Use this class to perform an incremental md5, otherwise use the
+     * static methods instead.
+     */
+
+    function SparkMD5() {
+        // call reset to init the instance
+        this.reset();
+    }
+
+    /**
+     * Appends a string.
+     * A conversion will be applied if an utf8 string is detected.
+     *
+     * @param {String} str The string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.append = function (str) {
+        // Converts the string to utf8 bytes if necessary
+        // Then append as binary
+        this.appendBinary(toUtf8(str));
+
+        return this;
+    };
+
+    /**
+     * Appends a binary string.
+     *
+     * @param {String} contents The binary string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.appendBinary = function (contents) {
+        this._buff += contents;
+        this._length += contents.length;
+
+        var length = this._buff.length,
+            i;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
+        }
+
+        this._buff = this._buff.substring(i - 64);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     *
+     * @param {Boolean} raw True to get the raw string, false to get the hex string
+     *
+     * @return {String} The result
+     */
+    SparkMD5.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            i,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = hex(this._hash);
+
+        if (raw) {
+            ret = hexToBinaryString(ret);
+        }
+
+        this.reset();
+
+        return ret;
+    };
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.reset = function () {
+        this._buff = '';
+        this._length = 0;
+        this._hash = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Gets the internal state of the computation.
+     *
+     * @return {Object} The state
+     */
+    SparkMD5.prototype.getState = function () {
+        return {
+            buff: this._buff,
+            length: this._length,
+            hash: this._hash.slice()
+        };
+    };
+
+    /**
+     * Gets the internal state of the computation.
+     *
+     * @param {Object} state The state
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.setState = function (state) {
+        this._buff = state.buff;
+        this._length = state.length;
+        this._hash = state.hash;
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other additional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.prototype.destroy = function () {
+        delete this._hash;
+        delete this._buff;
+        delete this._length;
+    };
+
+    /**
+     * Finish the final calculation based on the tail.
+     *
+     * @param {Array}  tail   The tail (will be modified)
+     * @param {Number} length The length of the remaining buffer
+     */
+    SparkMD5.prototype._finish = function (tail, length) {
+        var i = length,
+            tmp,
+            lo,
+            hi;
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(this._hash, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Do the final computation based on the tail and length
+        // Beware that the final length may not fit in 32 bits so we take care of that
+        tmp = this._length * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(this._hash, tail);
+    };
+
+    /**
+     * Performs the md5 hash on a string.
+     * A conversion will be applied if utf8 string is detected.
+     *
+     * @param {String}  str The string
+     * @param {Boolean} [raw] True to get the raw string, false to get the hex string
+     *
+     * @return {String} The result
+     */
+    SparkMD5.hash = function (str, raw) {
+        // Converts the string to utf8 bytes if necessary
+        // Then compute it using the binary function
+        return SparkMD5.hashBinary(toUtf8(str), raw);
+    };
+
+    /**
+     * Performs the md5 hash on a binary string.
+     *
+     * @param {String}  content The binary string
+     * @param {Boolean} [raw]     True to get the raw string, false to get the hex string
+     *
+     * @return {String} The result
+     */
+    SparkMD5.hashBinary = function (content, raw) {
+        var hash = md51(content),
+            ret = hex(hash);
+
+        return raw ? hexToBinaryString(ret) : ret;
+    };
+
+    // ---------------------------------------------------
+
+    /**
+     * SparkMD5 OOP implementation for array buffers.
+     *
+     * Use this class to perform an incremental md5 ONLY for array buffers.
+     */
+    SparkMD5.ArrayBuffer = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+    /**
+     * Appends an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array to be appended
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+        var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),
+            length = buff.length,
+            i;
+
+        this._length += arr.byteLength;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
+        }
+
+        this._buff = (i - 64) < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     *
+     * @param {Boolean} raw True to get the raw string, false to get the hex string
+     *
+     * @return {String} The result
+     */
+    SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            i,
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = hex(this._hash);
+
+        if (raw) {
+            ret = hexToBinaryString(ret);
+        }
+
+        this.reset();
+
+        return ret;
+    };
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.reset = function () {
+        this._buff = new Uint8Array(0);
+        this._length = 0;
+        this._hash = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Gets the internal state of the computation.
+     *
+     * @return {Object} The state
+     */
+    SparkMD5.ArrayBuffer.prototype.getState = function () {
+        var state = SparkMD5.prototype.getState.call(this);
+
+        // Convert buffer to a string
+        state.buff = arrayBuffer2Utf8Str(state.buff);
+
+        return state;
+    };
+
+    /**
+     * Gets the internal state of the computation.
+     *
+     * @param {Object} state The state
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.setState = function (state) {
+        // Convert string to buffer
+        state.buff = utf8Str2ArrayBuffer(state.buff, true);
+
+        return SparkMD5.prototype.setState.call(this, state);
+    };
+
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+    /**
+     * Performs the md5 hash on an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array buffer
+     * @param {Boolean}     [raw] True to get the raw string, false to get the hex one
+     *
+     * @return {String} The result
+     */
+    SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+        var hash = md51_array(new Uint8Array(arr)),
+            ret = hex(hash);
+
+        return raw ? hexToBinaryString(ret) : ret;
+    };
+
+    return SparkMD5;
+}));
+
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/ 
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ 	// Check if module is in cache
+/******/ 	var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 	if (cachedModule !== undefined) {
+/******/ 		return cachedModule.exports;
+/******/ 	}
+/******/ 	// Create a new module (and put it into the cache)
+/******/ 	var module = __webpack_module_cache__[moduleId] = {
+/******/ 		// no module.id needed
+/******/ 		// no module.loaded needed
+/******/ 		exports: {}
+/******/ 	};
+/******/ 
+/******/ 	// Execute the module function
+/******/ 	__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 
+/******/ 	// Return the exports of the module
+/******/ 	return module.exports;
+/******/ }
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/compat get default export */
+/******/ (() => {
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = (module) => {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			() => (module['default']) :
+/******/ 			() => (module);
+/******/ 		__webpack_require__.d(getter, { a: getter });
+/******/ 		return getter;
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "Z": () => (/* binding */ src)
+});
+
+;// CONCATENATED MODULE: external "../shared"
+var x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var y = x => () => x
+const external_shared_namespaceObject = x({ ["classes"]: () => __WEBPACK_EXTERNAL_MODULE__shared_65459f0a__.classes, ["isNullOrUndef"]: () => __WEBPACK_EXTERNAL_MODULE__shared_65459f0a__.isNullOrUndef, ["withInstall"]: () => __WEBPACK_EXTERNAL_MODULE__shared_65459f0a__.withInstall });
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+;// CONCATENATED MODULE: external "vue"
+var external_vue_x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var external_vue_y = x => () => x
+const external_vue_namespaceObject = external_vue_x({ ["Fragment"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.Fragment, ["TransitionGroup"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.TransitionGroup, ["computed"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.computed, ["createTextVNode"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.createTextVNode, ["createVNode"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.createVNode, ["defineComponent"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.defineComponent, ["h"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.h, ["isVNode"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.isVNode, ["mergeProps"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.mergeProps, ["onBeforeUnmount"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.onBeforeUnmount, ["ref"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.ref, ["shallowRef"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.shallowRef, ["toRefs"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.toRefs, ["vShow"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.vShow, ["watch"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.watch, ["withDirectives"]: () => __WEBPACK_EXTERNAL_MODULE_vue__.withDirectives });
+// EXTERNAL MODULE: ../../node_modules/@babel/runtime/regenerator/index.js
+var regenerator = __webpack_require__(7162);
+var regenerator_default = /*#__PURE__*/__webpack_require__.n(regenerator);
+;// CONCATENATED MODULE: ../../node_modules/tslib/tslib.es6.js
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(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]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    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;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var __createBinding = Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+});
+
+function __exportStar(m, o) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+/** @deprecated */
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+var __setModuleDefault = Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+};
+
+function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+function __classPrivateFieldIn(state, receiver) {
+    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
+    return typeof state === "function" ? receiver === state : state.has(receiver);
+}
+
+;// CONCATENATED MODULE: ../../packages/upload/src/upload.type.ts
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+var CLASS_PREFIX = 'bk-upload';
+var EThemes;
+
+(function (EThemes) {
+  EThemes["BUTTON"] = "button";
+  EThemes["DRAGGABLE"] = "draggable";
+  EThemes["PICTURE"] = "picture";
+})(EThemes || (EThemes = {}));
+
+var EUploadStatus;
+
+(function (EUploadStatus) {
+  EUploadStatus["NEW"] = "new";
+  EUploadStatus["UPLOADING"] = "uploading";
+  EUploadStatus["SUCCESS"] = "success";
+  EUploadStatus["FAIL"] = "fail";
+})(EUploadStatus || (EUploadStatus = {}));
+
+;
+;
+;
+;// CONCATENATED MODULE: ../../packages/upload/src/props.ts
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+
+var themes = [EThemes.BUTTON, EThemes.DRAGGABLE, EThemes.PICTURE];
+/* harmony default export */ const props = ({
+  theme: {
+    type: String,
+    "default": 'draggable',
+    validator: function validator(val) {
+      if (!val || themes.includes(val)) {
+        return true;
+      }
+
+      console.error("invalid theme, ".concat(val, ", the theme must be one of \u3010").concat(themes.join(' | '), "\u3011"));
+      return false;
+    }
+  },
+  files: {
+    type: Array,
+    "default": function _default() {
+      return [];
+    }
+  },
+  name: {
+    type: String,
+    "default": 'upload_file'
+  },
+  multiple: {
+    type: Boolean,
+    "default": true
+  },
+  disabled: {
+    type: Boolean,
+    "default": false
+  },
+  autoUpload: {
+    type: Boolean,
+    "default": true
+  },
+  accept: {
+    type: String
+  },
+  delayTime: {
+    type: Number,
+    "default": 0
+  },
+  url: {
+    type: String,
+    required: false
+  },
+  method: {
+    type: String,
+    "default": 'post'
+  },
+  size: {
+    type: [Number, Object],
+    "default": function _default() {
+      return {
+        maxFileSize: 5,
+        maxImgSize: 1
+      };
+    }
+  },
+  handleResCode: {
+    type: Function,
+    "default": function _default(res) {
+      if (res && res.code === 0) {
+        return true;
+      }
+
+      return false;
+    }
+  },
+  headers: {
+    type: Object,
+    "default": function _default() {
+      return {};
+    }
+  },
+  header: {
+    type: [Array, Object],
+    "default": function _default() {
+      return [];
+    }
+  },
+  tip: {
+    type: String,
+    "default": ''
+  },
+  validateName: {
+    type: RegExp
+  },
+  withCredentials: {
+    type: Boolean,
+    "default": false
+  },
+  limit: Number,
+  data: {
+    type: [Array, Object],
+    "default": function _default() {
+      return [];
+    }
+  },
+  formDataAttributes: {
+    type: [Array, Object],
+    "default": function _default() {
+      return [];
+    }
+  },
+  extCls: {
+    type: String,
+    "default": ''
+  },
+  customRequest: Function,
+  beforeUpload: {
+    type: Function
+  },
+  beforeRemove: {
+    type: Function
+  },
+  sliceUpload: {
+    type: Boolean,
+    "default": false
+  },
+  sliceUrl: {
+    type: String,
+    "default": ''
+  },
+  mergeUrl: {
+    type: String,
+    "default": ''
+  },
+  chunkSize: {
+    type: Number,
+    "default": 10
+  }
+});
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/slicedToArray.js
+
+
+
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+;// CONCATENATED MODULE: external "../icon"
+var external_icon_x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var external_icon_y = x => () => x
+const external_icon_namespaceObject = external_icon_x({ ["ArchiveFill"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.ArchiveFill, ["AudioFill"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.AudioFill, ["Del"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.Del, ["Done"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.Done, ["ImageFill"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.ImageFill, ["Plus"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.Plus, ["RightTurnLine"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.RightTurnLine, ["TextFill"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.TextFill, ["Upload"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.Upload, ["VideoFill"]: () => __WEBPACK_EXTERNAL_MODULE__icon_85385c3e__.VideoFill });
+;// CONCATENATED MODULE: external "../progress"
+var external_progress_x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var external_progress_y = x => () => x
+const external_progress_namespaceObject = external_progress_x({ ["default"]: () => __WEBPACK_EXTERNAL_MODULE__progress_ed4d3a99__["default"] });
+;// CONCATENATED MODULE: ../../packages/upload/src/upload-list.tsx
+
+
+
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+
+
+
+
+
+
+
+function _isSlot(s) {
+  return typeof s === 'function' || Object.prototype.toString.call(s) === '[object Object]' && !(0,external_vue_namespaceObject.isVNode)(s);
+}
+
+/* harmony default export */ const upload_list = ((0,external_vue_namespaceObject.defineComponent)({
+  name: 'UploadList',
+  props: {
+    theme: props.theme,
+    disabled: props.disabled,
+    files: props.files,
+    multiple: props.multiple
+  },
+  emits: ['remove', 'retry'],
+  setup: function setup(props, _ref) {
+    var slots = _ref.slots,
+        emit = _ref.emit;
+
+    var _toRefs = (0,external_vue_namespaceObject.toRefs)(props),
+        theme = _toRefs.theme,
+        disabled = _toRefs.disabled,
+        multiple = _toRefs.multiple;
+
+    var classBlock = "".concat(CLASS_PREFIX, "-list");
+    var isPhotowall = (0,external_vue_namespaceObject.computed)(function () {
+      return theme.value === EThemes.PICTURE;
+    });
+    var isSinglePhoto = (0,external_vue_namespaceObject.computed)(function () {
+      return isPhotowall.value && !multiple.value;
+    });
+    var classNames = (0,external_vue_namespaceObject.computed)(function () {
+      var _classes;
+
+      return (0,external_shared_namespaceObject.classes)((_classes = {}, _defineProperty(_classes, classBlock, true), _defineProperty(_classes, "".concat(classBlock, "--").concat(theme.value), true), _defineProperty(_classes, "".concat(classBlock, "--disabled"), disabled.value), _classes));
+    });
+
+    function formatSize(value) {
+      var uints = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+      var index = Math.floor(Math.log(value) / Math.log(1024));
+      var size = value / Math.pow(1024, index);
+      return "".concat(size.toFixed(2)).concat(uints[index]);
+    }
+
+    function handleRemove(file, e) {
+      emit('remove', file, e);
+    }
+
+    function handleRetry(file, e) {
+      emit('retry', file, e);
+    }
+
+    var Photowall = function Photowall() {
+      var _slot;
+
+      return (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.TransitionGroup, {
+        "name": "".concat(classBlock, "__item")
+      }, _isSlot(_slot = props.files.map(function (file) {
+        var _classes2;
+
+        var classNames = (0,external_shared_namespaceObject.classes)((_classes2 = {}, _defineProperty(_classes2, "".concat(classBlock, "__item"), true), _defineProperty(_classes2, "".concat(classBlock, "__item-picture"), true), _defineProperty(_classes2, "".concat(classBlock, "__item--").concat(file.status), true), _classes2));
+        return (0,external_vue_namespaceObject.createVNode)("li", {
+          "key": file.uid,
+          "class": classNames
+        }, [(slots === null || slots === void 0 ? void 0 : slots.file) ? slots.file({
+          file: file
+        }) : PhotoItem(file)]);
+      })) ? _slot : {
+        "default": function _default() {
+          return [_slot];
+        }
+      });
+    };
+
+    var PhotoItem = function PhotoItem(file) {
+      return [(0,external_vue_namespaceObject.withDirectives)((0,external_vue_namespaceObject.createVNode)("img", {
+        "src": file.url,
+        "class": "".concat(classBlock, "__picture-item-thumbnail"),
+        "alt": ""
+      }, null), [[external_vue_namespaceObject.vShow, file.status !== 'uploading']]), (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [file.status === 'uploading' && (0,external_vue_namespaceObject.createVNode)(external_progress_namespaceObject["default"], {
+        "class": "".concat(classBlock, "__picture-item-progress"),
+        "type": "circle",
+        "color": "#3a84ff",
+        "bgColor": "#333",
+        "width": 50,
+        "titleStyle": {
+          color: '#fff'
+        },
+        "percent": file.percentage
+      }, null)]), (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [!disabled.value && (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__picture-item-actions")
+      }, [(0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.Del, {
+        "class": "action-icon",
+        "onClick": function onClick(e) {
+          return handleRemove(file, e);
+        }
+      }, null)])])];
+    };
+
+    var Normal = function Normal() {
+      var _slot2;
+
+      return (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.TransitionGroup, {
+        "name": "".concat(classBlock, "__item")
+      }, _isSlot(_slot2 = props.files.map(function (file) {
+        var _classes3;
+
+        var classNames = (0,external_shared_namespaceObject.classes)((_classes3 = {}, _defineProperty(_classes3, "".concat(classBlock, "__item"), true), _defineProperty(_classes3, "".concat(classBlock, "__item--").concat(file.status), true), _classes3));
+        return (0,external_vue_namespaceObject.createVNode)("li", {
+          "key": file.uid,
+          "class": classNames
+        }, [(slots === null || slots === void 0 ? void 0 : slots.file) ? slots.file({
+          file: file
+        }) : NormalItem(file)]);
+      })) ? _slot2 : {
+        "default": function _default() {
+          return [_slot2];
+        }
+      });
+    };
+
+    var FileIcon = function FileIcon(file) {
+      var _a;
+
+      var rawType = (_a = file === null || file === void 0 ? void 0 : file.raw) === null || _a === void 0 ? void 0 : _a.type;
+
+      var _ref2 = (rawType === null || rawType === void 0 ? void 0 : rawType.split('/')) || '',
+          _ref3 = _slicedToArray(_ref2, 1),
+          type = _ref3[0];
+
+      var iconMap = {
+        text: external_icon_namespaceObject.TextFill,
+        image: external_icon_namespaceObject.ImageFill,
+        application: external_icon_namespaceObject.TextFill,
+        video: external_icon_namespaceObject.VideoFill,
+        audio: external_icon_namespaceObject.AudioFill
+      };
+      var icon = iconMap[type] || external_icon_namespaceObject.TextFill;
+      var zipType = ['application/zip', 'application/rar', 'application/tar', 'application/gz', 'application/x-gzip'];
+
+      if (zipType.includes(rawType)) {
+        icon = external_icon_namespaceObject.ArchiveFill;
+      }
+
+      return (0,external_vue_namespaceObject.h)(icon, {
+        "class": "".concat(classBlock, "__item-file-icon")
+      });
+    };
+
+    var NormalItem = function NormalItem(file) {
+      return [(0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__item-icon")
+      }, [file.isPic ? (0,external_vue_namespaceObject.createVNode)("img", {
+        "src": file.url,
+        "class": "".concat(classBlock, "__item-thumbnail"),
+        "alt": ""
+      }, null) : FileIcon(file)]), (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__item-summary")
+      }, [(0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__item-name"),
+        "title": file.name
+      }, [file.name]), file.status !== 'uploading' && (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__item-message"),
+        "title": file.statusText
+      }, [file.status === 'success' && (0,external_vue_namespaceObject.createVNode)("span", null, [(0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.Done, {
+        "class": "".concat(classBlock, "__item-message-success-icon")
+      }, null), file.statusText || '上传成功']), file.status === 'fail' && (0,external_vue_namespaceObject.createVNode)("span", null, [file.statusText || '上传失败'])]), file.status === 'uploading' && (0,external_vue_namespaceObject.createVNode)(external_progress_namespaceObject["default"], {
+        "class": "".concat(classBlock, "__item-progress"),
+        "showText": false,
+        "percent": file.percentage,
+        "size": "small"
+      }, null), file.status !== 'fail' && (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__item-speed")
+      }, [(0,external_vue_namespaceObject.withDirectives)((0,external_vue_namespaceObject.createVNode)("span", {
+        "class": "".concat(classBlock, "__item-speed-size")
+      }, [formatSize(file.size)]), [[external_vue_namespaceObject.vShow, file.size]]), (0,external_vue_namespaceObject.withDirectives)((0,external_vue_namespaceObject.createVNode)("span", {
+        "class": "".concat(classBlock, "__item-speed-percentage")
+      }, [file.percentage, (0,external_vue_namespaceObject.createTextVNode)("%")]), [[external_vue_namespaceObject.vShow, file.status === 'uploading']])]), !disabled.value && (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__item-actions")
+      }, [file.status === 'fail' && (0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.RightTurnLine, {
+        "class": "".concat(classBlock, "__item-retry-icon"),
+        "onClick": function onClick(e) {
+          return handleRetry(file, e);
+        }
+      }, null), (0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.Del, {
+        "class": "".concat(classBlock, "__item-del-icon"),
+        "onClick": function onClick(e) {
+          return handleRemove(file, e);
+        }
+      }, null)])])];
+    };
+
+    return function () {
+      var _a;
+
+      return (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [isSinglePhoto.value ? (slots === null || slots === void 0 ? void 0 : slots.innerTrigger) && (slots === null || slots === void 0 ? void 0 : slots.innerTrigger((_a = props.files) === null || _a === void 0 ? void 0 : _a[0])) : (0,external_vue_namespaceObject.createVNode)("ul", {
+        "class": classNames.value
+      }, [isPhotowall.value ? Photowall() : Normal(), (slots === null || slots === void 0 ? void 0 : slots.innerTrigger) && (slots === null || slots === void 0 ? void 0 : slots.innerTrigger())])]);
+    };
+  }
+}));
+;// CONCATENATED MODULE: external "../button"
+var external_button_x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
+var external_button_y = x => () => x
+const external_button_namespaceObject = external_button_x({ ["default"]: () => __WEBPACK_EXTERNAL_MODULE__button_59c00871__["default"] });
+;// CONCATENATED MODULE: ../../packages/upload/src/upload-trigger.tsx
+
+
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+
+
+
+
+
+
+
+/* harmony default export */ const upload_trigger = ((0,external_vue_namespaceObject.defineComponent)({
+  name: 'UploadTrigger',
+  props: {
+    theme: props.theme,
+    disabled: props.disabled,
+    multiple: props.multiple,
+    accept: props.accept,
+    file: {
+      type: Object
+    }
+  },
+  emits: ['change', 'remove'],
+  setup: function setup(props, _ref) {
+    var slots = _ref.slots,
+        emit = _ref.emit;
+
+    var _toRefs = (0,external_vue_namespaceObject.toRefs)(props),
+        theme = _toRefs.theme,
+        disabled = _toRefs.disabled,
+        file = _toRefs.file,
+        multiple = _toRefs.multiple,
+        accept = _toRefs.accept;
+
+    var classBlock = "".concat(CLASS_PREFIX, "-trigger");
+    var isButton = (0,external_vue_namespaceObject.computed)(function () {
+      return theme.value === EThemes.BUTTON;
+    });
+    var isDrag = (0,external_vue_namespaceObject.computed)(function () {
+      return theme.value === EThemes.DRAGGABLE;
+    });
+    var isPicture = (0,external_vue_namespaceObject.computed)(function () {
+      return theme.value === EThemes.PICTURE;
+    });
+    var isSinglePicture = (0,external_vue_namespaceObject.computed)(function () {
+      return isPicture.value && !multiple.value;
+    });
+    var acceptTypes = (0,external_vue_namespaceObject.computed)(function () {
+      return isPicture.value && !accept.value ? 'image/png,image/jpeg,image/jpg' : accept.value;
+    });
+    var inputEl = (0,external_vue_namespaceObject.ref)(null);
+    var classNames = (0,external_vue_namespaceObject.computed)(function () {
+      var _classes;
+
+      var _a, _b, _c;
+
+      return (0,external_shared_namespaceObject.classes)((_classes = {}, _defineProperty(_classes, classBlock, true), _defineProperty(_classes, "".concat(classBlock, "--").concat(theme.value), true), _defineProperty(_classes, "".concat(classBlock, "--single-picture"), isSinglePicture.value), _defineProperty(_classes, "".concat(classBlock, "--has-file"), (_a = file.value) !== null && _a !== void 0 ? _a : false), _defineProperty(_classes, "".concat(classBlock, "--").concat((_b = file.value) === null || _b === void 0 ? void 0 : _b.status), (_c = file.value) !== null && _c !== void 0 ? _c : false), _defineProperty(_classes, "".concat(classBlock, "--dragover"), dragover.value), _defineProperty(_classes, "".concat(classBlock, "--disabled"), disabled.value), _classes));
+    });
+
+    var invoke = function invoke() {
+      inputEl.value.value = null;
+      inputEl.value.click();
+    };
+
+    var handleFileChange = function handleFileChange(e) {
+      var files = e.target.files;
+      emit('change', Array.from(files));
+    };
+
+    var handleClick = function handleClick() {
+      if (props.disabled) {
+        return;
+      }
+
+      invoke();
+    };
+
+    var handleKeydown = function handleKeydown(e) {
+      if (e.defaultPrevented || e.target !== e.currentTarget) {
+        return;
+      }
+
+      if (e.code === 'Enter' || e.code === 'Space') {
+        invoke();
+      }
+
+      e.preventDefault();
+    };
+
+    function handleRemove(file, e) {
+      emit('remove', file, e);
+      e.stopPropagation();
+      e.preventDefault();
+    }
+
+    var dragover = (0,external_vue_namespaceObject.ref)(false);
+
+    var Dragger = function Dragger() {
+      var handleDrop = function handleDrop(e) {
+        if (disabled.value) {
+          return;
+        }
+
+        e.preventDefault();
+        dragover.value = false;
+        var files = Array.from(e.dataTransfer.files);
+
+        if (!acceptTypes.value) {
+          emit('change', files);
+          return;
+        }
+
+        var filesFiltered = files.filter(function (file) {
+          var type = file.type,
+              name = file.name;
+          var extension = name.includes('.') ? ".".concat(name.split('.').pop()) : '';
+          var baseType = type.replace(/\/.*$/, '');
+          return acceptTypes.value.split(',').map(function (type) {
+            return type.trim();
+          }).filter(function (type) {
+            return type;
+          }).some(function (acceptedType) {
+            if (acceptedType.startsWith('.')) {
+              return extension === acceptedType;
+            }
+
+            if (/\/\*$/.test(acceptedType)) {
+              return baseType === acceptedType.replace(/\/\*$/, '');
+            }
+
+            if (/^[^/]+\/[^/]+$/.test(acceptedType)) {
+              return type === acceptedType;
+            }
+
+            return false;
+          });
+        });
+        emit('change', filesFiltered);
+      };
+
+      var handleDragover = function handleDragover(e) {
+        e.preventDefault();
+        dragover.value = true;
+      };
+
+      var handleDragleave = function handleDragleave() {
+        dragover.value = false;
+      };
+
+      var classNames = (0,external_shared_namespaceObject.classes)(_defineProperty({}, "".concat(classBlock, "__draggable"), true));
+      return (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": classNames,
+        "onDrop": handleDrop,
+        "onDragover": handleDragover,
+        "onDragleave": handleDragleave
+      }, [slots["default"] ? slots["default"]() : (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [(0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.Upload, {
+        "class": "".concat(classBlock, "__draggable-icon")
+      }, null), (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__draggable-text")
+      }, [(0,external_vue_namespaceObject.createTextVNode)("\u5C06\u6587\u4EF6\u62D6\u5230\u6B64\u5904\u6216"), (0,external_vue_namespaceObject.createVNode)("span", {
+        "class": "".concat(classBlock, "__draggable-upload-link")
+      }, [(0,external_vue_namespaceObject.createTextVNode)("\u70B9\u51FB\u4E0A\u4F20")])])])]);
+    };
+
+    var Picture = function Picture() {
+      return (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [isSinglePicture.value && props.file ? SinglePicture(props.file) : DefaultPicture()]);
+    };
+
+    var DefaultPicture = function DefaultPicture() {
+      return (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [slots["default"] ? slots["default"]() : (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__picture-inner")
+      }, [(0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.Plus, {
+        "class": "".concat(classBlock, "__picture-icon")
+      }, null), (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__picture-text")
+      }, [(0,external_vue_namespaceObject.createTextVNode)("\u70B9\u51FB\u4E0A\u4F20")])])]);
+    };
+
+    var SinglePicture = function SinglePicture(file) {
+      return [(0,external_vue_namespaceObject.withDirectives)((0,external_vue_namespaceObject.createVNode)("img", {
+        "src": file.url,
+        "class": "".concat(classBlock, "__picture-thumbnail"),
+        "alt": ""
+      }, null), [[external_vue_namespaceObject.vShow, file.status !== 'uploading']]), (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [file.status === 'uploading' && (0,external_vue_namespaceObject.createVNode)(external_progress_namespaceObject["default"], {
+        "class": "".concat(classBlock, "__picture-progress"),
+        "type": "circle",
+        "color": "#3a84ff",
+        "bgColor": "#333",
+        "width": 50,
+        "titleStyle": {
+          color: '#fff'
+        },
+        "percent": file.percentage
+      }, null)]), (0,external_vue_namespaceObject.createVNode)(external_vue_namespaceObject.Fragment, null, [!props.disabled && (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(classBlock, "__picture-actions")
+      }, [(0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.Del, {
+        "class": "action-icon",
+        "onClick": function onClick(e) {
+          return handleRemove(file, e);
+        }
+      }, null)])])];
+    };
+
+    var Button = function Button() {
+      return (0,external_vue_namespaceObject.createVNode)(external_button_namespaceObject["default"], {
+        "disabled": disabled.value
+      }, {
+        "default": function _default() {
+          return [(0,external_vue_namespaceObject.createVNode)(external_icon_namespaceObject.Upload, {
+            "class": "".concat(classBlock, "__button-icon")
+          }, null), (0,external_vue_namespaceObject.createVNode)("span", {
+            "class": "".concat(classBlock, "__button-text")
+          }, [(0,external_vue_namespaceObject.createTextVNode)("\u4E0A\u4F20\u6587\u4EF6")])];
+        }
+      });
+    };
+
+    var Trigger = function Trigger() {
+      if (isButton.value) return Button();
+      if (isDrag.value) return Dragger();
+      if (isPicture.value) return Picture();
+    };
+
+    return function () {
+      var _a;
+
+      return (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": classNames.value,
+        "tabindex": "0",
+        "onClick": handleClick,
+        "onKeydown": handleKeydown
+      }, [slots.trigger ? [slots.trigger(), (_a = slots === null || slots === void 0 ? void 0 : slots["default"]) === null || _a === void 0 ? void 0 : _a.call(slots)] : Trigger(), (0,external_vue_namespaceObject.createVNode)("input", {
+        "ref": inputEl,
+        "class": "".concat(classBlock, "__input-file"),
+        "tabindex": "-1",
+        "onChange": handleFileChange,
+        "accept": acceptTypes.value,
+        "multiple": multiple.value,
+        "disabled": disabled.value,
+        "type": "file"
+      }, null)]);
+    };
+  }
+}));
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/iterableToArray.js
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
+
+
+
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+// EXTERNAL MODULE: ../../node_modules/spark-md5/spark-md5.js
+var spark_md5 = __webpack_require__(4791);
+var spark_md5_default = /*#__PURE__*/__webpack_require__.n(spark_md5);
+;// CONCATENATED MODULE: ../../packages/upload/src/use-ajax-upload.ts
+
+
+
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+
+
+
+;
+
+function getRes(xhr) {
+  var res = xhr.responseText || xhr.response;
+
+  if (!res) {
+    return res;
+  }
+
+  try {
+    return JSON.parse(res);
+  } catch (_a) {
+    return res;
+  }
+}
+
+var ajaxUpload = function ajaxUpload(option) {
+  if (typeof XMLHttpRequest === 'undefined') {
+    throw new Error('XMLHttpRequest is undefined');
+  }
+
+  var xhr = new XMLHttpRequest();
+  var action = option.action;
+
+  if (xhr.upload) {
+    xhr.upload.addEventListener('progress', function (event) {
+      var progressEvent = event;
+      progressEvent.percent = event.total > 0 ? event.loaded / event.total * 100 : 0;
+      option.onProgress(progressEvent);
+    });
+  }
+
+  var formData = new FormData();
+
+  if (option.data) {
+    var appendData = option.data;
+
+    if (!Array.isArray(appendData)) {
+      appendData = [appendData];
+    }
+
+    appendData.forEach(function (data) {
+      for (var _i = 0, _Object$entries = Object.entries(data); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+            key = _Object$entries$_i[0],
+            value = _Object$entries$_i[1];
+
+        if (Array.isArray(value)) formData.append.apply(formData, [key].concat(_toConsumableArray(value)));else formData.append(key, value);
+      }
+    });
+  }
+
+  if (option.formDataAttributes) {
+    var _appendData = option.formDataAttributes;
+
+    if (!Array.isArray(_appendData)) {
+      _appendData = [_appendData];
+    }
+
+    _appendData.forEach(function (item) {
+      if (Array.isArray(item.value)) formData.append.apply(formData, [item.name].concat(_toConsumableArray(item.value)));else formData.append(item.name, item.value);
+    });
+  }
+
+  formData.append(option.filename, option.file, option.file.name);
+  xhr.addEventListener('error', function () {
+    option.onError(new Error('An error occurred during upload'));
+  });
+  xhr.addEventListener('load', function () {
+    if (xhr.status < 200 || xhr.status >= 300) {
+      return option.onError(new Error('An error occurred during upload'));
+    }
+
+    option.onSuccess(getRes(xhr));
+  });
+  xhr.addEventListener('loadend', function () {
+    option.onComplete();
+  });
+  xhr.open(option.method, action, true);
+
+  if (option.withCredentials && 'withCredentials' in xhr) {
+    xhr.withCredentials = true;
+  }
+
+  if (option.header) {
+    if (Array.isArray(option.header)) {
+      option.header.forEach(function (head) {
+        var headerKey = head.name;
+        var headerVal = head.value;
+        xhr.setRequestHeader(headerKey, headerVal);
+      });
+    } else {
+      var headerKey = option.header.name;
+      var headerVal = option.header.value;
+      xhr.setRequestHeader(headerKey, headerVal);
+    }
+  }
+
+  var headers = option.headers || {};
+
+  if (headers instanceof Headers) {
+    headers.forEach(function (value, key) {
+      return xhr.setRequestHeader(key, value);
+    });
+  } else {
+    for (var _i2 = 0, _Object$entries2 = Object.entries(headers); _i2 < _Object$entries2.length; _i2++) {
+      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          key = _Object$entries2$_i[0],
+          value = _Object$entries2$_i[1];
+
+      if ((0,external_shared_namespaceObject.isNullOrUndef)(value)) continue;
+      xhr.setRequestHeader(key, String(value));
+    }
+  }
+
+  xhr.send(formData);
+  return xhr;
+}; // 该方法用于在不同的浏览器使用不同的方式
+
+var blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
+var ajaxSliceUpload = function ajaxSliceUpload(option) {
+  return __awaiter(void 0, void 0, void 0, /*#__PURE__*/regenerator_default().mark(function _callee() {
+    var chunkSize, file, blockCount, hash, progressList;
+    return regenerator_default().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            chunkSize = option.chunkSize * 1024 * 1024;
+            file = option.file;
+
+            if (file) {
+              _context.next = 4;
+              break;
+            }
+
+            throw new Error('File not found');
+
+          case 4:
+            blockCount = Math.ceil(file.size / chunkSize);
+            _context.next = 7;
+            return hashFile(file, chunkSize);
+
+          case 7:
+            hash = _context.sent;
+            progressList = [];
+            sliceSend(option, file, blockCount, hash, progressList, chunkSize); // 所有分片上传后，请求合并分片文件
+
+            _context.next = 12;
+            return Promise.all(progressList).then(function () {
+              // 合并chunks
+              var data = {
+                size: file.size,
+                name: file.name,
+                total: blockCount,
+                hash: hash
+              };
+              var req = new XMLHttpRequest();
+              req.open(option.method, option.mergeUrl, true);
+
+              req.onreadystatechange = function () {
+                if (req.readyState === 4) {
+                  if (req.status < 200 || req.status >= 300) {
+                    return option.onError(new Error('An error occurred during upload'));
+                  }
+
+                  option.onSuccess(getRes(req));
+                }
+              };
+
+              req.onloadend = function () {
+                option.onComplete();
+              };
+
+              req.setRequestHeader('Content-type', 'application/JSON');
+              req.send(JSON.stringify(data));
+            });
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+}; // 请求分片上传，保存在progressList中
+
+var sliceSend = function sliceSend(option, file, blockCount, hash, progressList, chunkSize) {
+  var _loop = function _loop(i) {
+    // eslint-disable-next-line no-loop-func
+    var pooltask = new Promise(function (resolve, reject) {
+      var start = i * chunkSize;
+      var end = Math.min(file.size, start + chunkSize); // 构建表单
+
+      var formData = new FormData();
+
+      if (option.data) {
+        var appendData = option.data;
+
+        if (!Array.isArray(appendData)) {
+          appendData = [appendData];
+        }
+
+        appendData.forEach(function (data) {
+          for (var _i3 = 0, _Object$entries3 = Object.entries(data); _i3 < _Object$entries3.length; _i3++) {
+            var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+                key = _Object$entries3$_i[0],
+                value = _Object$entries3$_i[1];
+
+            if (Array.isArray(value)) formData.append.apply(formData, [key].concat(_toConsumableArray(value)));else formData.append(key, value);
+          }
+        });
+      }
+
+      if (option.formDataAttributes) {
+        var _appendData2 = option.formDataAttributes;
+
+        if (!Array.isArray(_appendData2)) {
+          _appendData2 = [_appendData2];
+        }
+
+        _appendData2.forEach(function (item) {
+          if (Array.isArray(item.value)) formData.append.apply(formData, [item.name].concat(_toConsumableArray(item.value)));else formData.append(item.name, item.value);
+        });
+      }
+
+      formData.append('file', blobSlice.call(file, start, end));
+      formData.append('name', file.name);
+      formData.append('total', blockCount.toString());
+      formData.append('index', i.toString());
+      formData.append('size', file.size.toString());
+      formData.append('hash', hash.toString());
+      var xhr = new XMLHttpRequest();
+
+      xhr.onreadystatechange = function () {
+        if (xhr.readyState === 4) {
+          var res = getRes(xhr);
+
+          if (xhr.status < 200 || xhr.status >= 300) {
+            reject(res);
+            option.onError(new Error('An error occurred during upload'));
+          } else {
+            resolve('reponseText');
+          }
+        }
+      };
+
+      xhr.upload.addEventListener('progress', function (event) {
+        var progressEvent = event;
+        option.onProgress(progressEvent, i);
+      }, false);
+
+      if (option.withCredentials && 'withCredentials' in xhr) {
+        xhr.withCredentials = true;
+      }
+
+      xhr.open(option.method, option.sliceUrl, true);
+
+      if (option.header) {
+        if (Array.isArray(option.header)) {
+          option.header.forEach(function (head) {
+            var headerKey = head.name;
+            var headerVal = head.value;
+            xhr.setRequestHeader(headerKey, headerVal);
+          });
+        } else {
+          var headerKey = option.header.name;
+          var headerVal = option.header.value;
+          xhr.setRequestHeader(headerKey, headerVal);
+        }
+      }
+
+      var headers = option.headers || {};
+
+      if (headers instanceof Headers) {
+        headers.forEach(function (value, key) {
+          return xhr.setRequestHeader(key, value);
+        });
+      } else {
+        for (var _i4 = 0, _Object$entries4 = Object.entries(headers); _i4 < _Object$entries4.length; _i4++) {
+          var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
+              key = _Object$entries4$_i[0],
+              value = _Object$entries4$_i[1];
+
+          if ((0,external_shared_namespaceObject.isNullOrUndef)(value)) continue;
+          xhr.setRequestHeader(key, String(value));
+        }
+      }
+
+      xhr.send(formData);
+    });
+    progressList.push(pooltask);
+  };
+
+  for (var i = 0; i < blockCount; i++) {
+    _loop(i);
+  }
+}; // SparkMD5分片文件
+
+
+var hashFile = function hashFile(file, chunkSize) {
+  return new Promise(function (resolve, reject) {
+    var chunks = Math.ceil(file.size / chunkSize);
+    var currentChunk = 0;
+    var spark = new (spark_md5_default()).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); // Append array buffer
+
+      currentChunk += 1;
+
+      if (currentChunk < chunks) {
+        loadNext();
+      } else {
+        var result = spark.end(); // 如果单纯的使用result 作为hash值的时候, 如果文件内容相同，而名称不同的时候
+        // 想保留两个文件无法保留。所以把文件名称加上。
+
+        var sparkMd5 = new (spark_md5_default())();
+        sparkMd5.append(result);
+        sparkMd5.append(file.name);
+        var hexHash = sparkMd5.end();
+        resolve(hexHash);
+      }
+    };
+
+    fileReader.onerror = function () {
+      reject(new Error('File slcie failed'));
+    };
+
+    loadNext();
+  })["catch"](function (err) {
+    console.log(err);
+  });
+};
+;// CONCATENATED MODULE: ../../packages/upload/src/use-file-handler.ts
+
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+
+
+
+
+function buildFileId(index) {
+  return Date.now() + index;
+}
+
+/* harmony default export */ const use_file_handler = (function (props, hooks) {
+  var maxImgSize = (0,external_vue_namespaceObject.computed)(function () {
+    var _a;
+
+    if (typeof props.size === 'number') {
+      return props.size;
+    }
+
+    return (_a = props === null || props === void 0 ? void 0 : props.size) === null || _a === void 0 ? void 0 : _a.maxImgSize;
+  });
+  var maxFileSize = (0,external_vue_namespaceObject.computed)(function () {
+    var _a;
+
+    if (typeof props.size === 'number') {
+      return props.size;
+    }
+
+    return (_a = props === null || props === void 0 ? void 0 : props.size) === null || _a === void 0 ? void 0 : _a.maxImgSize;
+  }); // 文件列表，包括选择的和已上传
+
+  var fileList = (0,external_vue_namespaceObject.ref)([]);
+
+  function findFile(rawFile) {
+    return fileList.value.find(function (item) {
+      return item.uid === rawFile.uid;
+    });
+  }
+
+  var activeIndex = 0;
+
+  function handlePreprocess(file) {
+    var _a;
+
+    activeIndex += 1;
+    file.uid = buildFileId(activeIndex);
+    var uploadFile = {
+      uid: file.uid,
+      name: file.name,
+      status: EUploadStatus.NEW,
+      size: file.size,
+      raw: file
+    };
+    var isImage = file.type.startsWith('image/');
+    var error = null; // 图片缩略图处理
+
+    if (isImage) {
+      try {
+        uploadFile.url = window.URL.createObjectURL(file);
+      } catch (err) {
+        console.error(err);
+      }
+
+      uploadFile.isPic = true;
+    } // 文件名称校验
+
+
+    if (props.validateName && !((_a = props.validateName) === null || _a === void 0 ? void 0 : _a.test(uploadFile.name))) {
+      uploadFile.status = EUploadStatus.FAIL;
+      uploadFile.statusText = 'invalid filename';
+      error = new Error(uploadFile.statusText);
+    }
+
+    if (isImage && file.size > maxImgSize.value * Math.pow(1024, 2)) {
+      uploadFile.status = EUploadStatus.FAIL;
+      uploadFile.statusText = 'invalid file size';
+      error = new Error(uploadFile.statusText);
+    }
+
+    if (!isImage && file.size > maxFileSize.value * Math.pow(1024, 2)) {
+      uploadFile.status = EUploadStatus.FAIL;
+      uploadFile.statusText = 'invalid file size';
+      error = new Error(uploadFile.statusText);
+    }
+
+    fileList.value.push(uploadFile);
+    return error;
+  }
+
+  function handleRemove(file) {
+    var _a;
+
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/regenerator_default().mark(function _callee() {
+      var uploadFile, remove, before;
+      return regenerator_default().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              uploadFile = file instanceof File ? findFile(file) : file;
+
+              remove = function remove(file) {
+                var _a;
+
+                hooks.onRemove(file, fileList.value);
+                fileList.value.splice(fileList.value.indexOf(uploadFile), 1);
+
+                if ((_a = file.url) === null || _a === void 0 ? void 0 : _a.startsWith('blob:')) {
+                  URL.revokeObjectURL(file.url);
+                }
+              };
+
+              if (!props.beforeRemove) {
+                _context.next = 9;
+                break;
+              }
+
+              _context.next = 5;
+              return (_a = props.beforeRemove) === null || _a === void 0 ? void 0 : _a.call(props, uploadFile, fileList.value);
+
+            case 5:
+              before = _context.sent;
+
+              if (before !== false) {
+                remove(uploadFile);
+              }
+
+              _context.next = 10;
+              break;
+
+            case 9:
+              remove(uploadFile);
+
+            case 10:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+  }
+
+  function handleError(err, rawFile, res) {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/regenerator_default().mark(function _callee2() {
+      var file;
+      return regenerator_default().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              file = findFile(rawFile);
+
+              if (file) {
+                _context2.next = 3;
+                break;
+              }
+
+              return _context2.abrupt("return");
+
+            case 3:
+              file.status = 'fail';
+              file.statusText = err.message;
+              file.response = res;
+
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+  }
+
+  function handleSuccess(res, rawFile) {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/regenerator_default().mark(function _callee3() {
+      var file;
+      return regenerator_default().wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              file = findFile(rawFile);
+
+              if (file) {
+                _context3.next = 3;
+                break;
+              }
+
+              return _context3.abrupt("return");
+
+            case 3:
+              file.status = 'success';
+              file.response = res;
+
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+  }
+
+  function handleProgress(event, rawFile) {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/regenerator_default().mark(function _callee4() {
+      var file;
+      return regenerator_default().wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              // TODO slideUpload progress
+              file = findFile(rawFile);
+
+              if (file) {
+                _context4.next = 3;
+                break;
+              }
+
+              return _context4.abrupt("return");
+
+            case 3:
+              file.status = 'uploading';
+              file.percentage = Math.round(event.percent);
+
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+  }
+
+  (0,external_vue_namespaceObject.watch)(function () {
+    return props.files;
+  }, function (files) {
+    fileList.value = files.map(function (file) {
+      var _a, _b;
+
+      activeIndex += 1;
+      return Object.assign(Object.assign({}, file), {
+        uid: (_a = file.uid) !== null && _a !== void 0 ? _a : buildFileId(activeIndex),
+        status: (_b = file.status) !== null && _b !== void 0 ? _b : EUploadStatus.SUCCESS
+      });
+    });
+  }, {
+    immediate: true,
+    deep: true
+  });
+  return {
+    fileList: fileList,
+    handlePreprocess: handlePreprocess,
+    handleRemove: handleRemove,
+    handleError: handleError,
+    handleSuccess: handleSuccess,
+    handleProgress: handleProgress
+  };
+});
+;// CONCATENATED MODULE: ../../packages/upload/src/upload.tsx
+
+
+
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = upload_unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function upload_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return upload_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return upload_arrayLikeToArray(o, minLen); }
+
+function upload_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+
+
+
+
+
+
+
+
+
+/* harmony default export */ const upload = ((0,external_vue_namespaceObject.defineComponent)({
+  name: 'Upload',
+  props: props,
+  emits: ['exceed', 'progress', 'success', 'error', 'delete', 'done'],
+  setup: function setup(props, _ref) {
+    var slots = _ref.slots,
+        emit = _ref.emit,
+        expose = _ref.expose;
+    var requests = (0,external_vue_namespaceObject.shallowRef)({});
+    var isPhotowall = (0,external_vue_namespaceObject.computed)(function () {
+      return props.theme === EThemes.PICTURE;
+    });
+    var isSinglePhoto = (0,external_vue_namespaceObject.computed)(function () {
+      return isPhotowall.value && !props.multiple;
+    });
+    var classNames = (0,external_vue_namespaceObject.computed)(function () {
+      var _classes;
+
+      var _a;
+
+      return (0,external_shared_namespaceObject.classes)((_classes = {}, _defineProperty(_classes, CLASS_PREFIX, true), _defineProperty(_classes, "".concat(CLASS_PREFIX, "--").concat(props.theme), true), _defineProperty(_classes, "".concat(CLASS_PREFIX, "--disabled"), props.disabled), _defineProperty(_classes, "".concat(CLASS_PREFIX, "--single-picture"), isSinglePhoto.value), _defineProperty(_classes, props.extCls, (_a = props.extCls) !== null && _a !== void 0 ? _a : false), _classes));
+    });
+    var triggerProps = (0,external_vue_namespaceObject.computed)(function () {
+      return {
+        theme: props.theme,
+        multiple: props.multiple,
+        disabled: props.disabled,
+        accept: props.accept
+      };
+    });
+
+    function onRemove(file, fileList) {
+      abort(file);
+      emit('delete', file, fileList);
+    }
+
+    var _useFileHandler = use_file_handler(props, {
+      onRemove: onRemove
+    }),
+        fileList = _useFileHandler.fileList,
+        handlePreprocess = _useFileHandler.handlePreprocess,
+        handleRemove = _useFileHandler.handleRemove,
+        handleProgress = _useFileHandler.handleProgress,
+        handleSuccess = _useFileHandler.handleSuccess,
+        handleError = _useFileHandler.handleError;
+
+    function handleFiles(files) {
+      if (!files.length) {
+        return;
+      } // limit检查
+
+
+      if (props.limit && fileList.value.length + files.length > props.limit) {
+        emit('exceed', files, fileList.value);
+        return;
+      }
+
+      var sendFiles = files;
+
+      if (!props.multiple || props.limit === 1) {
+        sendFiles = files.slice(0, 1);
+      }
+
+      var _iterator = _createForOfIteratorHelper(sendFiles),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var file = _step.value;
+          var rawFile = file;
+          var error = handlePreprocess(rawFile);
+
+          if (error) {
+            emit('error', rawFile, fileList.value, error);
+            return;
+          }
+
+          if (props.autoUpload) {
+            upload(rawFile, sendFiles);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    ;
+
+    function handleRetry(file) {
+      send(file.raw);
+    }
+
+    function upload(file, sendFiles) {
+      var _a;
+
+      return __awaiter(this, void 0, void 0, /*#__PURE__*/regenerator_default().mark(function _callee() {
+        var beforeResult;
+        return regenerator_default().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (props.beforeUpload) {
+                  _context.next = 2;
+                  break;
+                }
+
+                return _context.abrupt("return", send(file, sendFiles));
+
+              case 2:
+                _context.prev = 2;
+                _context.next = 5;
+                return (_a = props.beforeUpload) === null || _a === void 0 ? void 0 : _a.call(props, file);
+
+              case 5:
+                beforeResult = _context.sent;
+                _context.next = 11;
+                break;
+
+              case 8:
+                _context.prev = 8;
+                _context.t0 = _context["catch"](2);
+                beforeResult = false;
+
+              case 11:
+                if (!(beforeResult === false)) {
+                  _context.next = 14;
+                  break;
+                }
+
+                handleRemove(file);
+                return _context.abrupt("return");
+
+              case 14:
+                send(file, sendFiles);
+
+              case 15:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[2, 8]]);
+      }));
+    }
+
+    function send(file, sendFiles) {
+      var headers = props.headers,
+          header = props.header,
+          data = props.data,
+          formDataAttributes = props.formDataAttributes,
+          method = props.method,
+          withCredentials = props.withCredentials,
+          filename = props.name,
+          url = props.url,
+          sliceUrl = props.sliceUrl,
+          mergeUrl = props.mergeUrl,
+          chunkSize = props.chunkSize,
+          customRequest = props.customRequest;
+      var uid = file.uid;
+      var options = {
+        headers: headers,
+        header: header,
+        withCredentials: withCredentials,
+        file: file,
+        data: data,
+        formDataAttributes: formDataAttributes,
+        method: method,
+        filename: filename,
+        action: url,
+        sliceUrl: sliceUrl,
+        mergeUrl: mergeUrl,
+        chunkSize: chunkSize,
+        onProgress: function onProgress(event) {
+          handleProgress(event, file);
+          emit('progress', event, file, fileList.value);
+        },
+        onSuccess: function onSuccess(res) {
+          var _a;
+
+          var result = res;
+
+          if ((_a = props === null || props === void 0 ? void 0 : props.handleResCode) === null || _a === void 0 ? void 0 : _a.call(props, result)) {
+            handleSuccess(res, file);
+            emit('success', res, file, fileList.value);
+          } else {
+            var err = new Error((result === null || result === void 0 ? void 0 : result.message) || 'unknow error');
+            handleError(err, file, res);
+            emit('error', file, fileList.value, err);
+          }
+
+          delete requests.value[uid];
+        },
+        onError: function onError(err) {
+          handleError(err, file);
+          emit('error', file, fileList.value, err);
+          delete requests.value[uid];
+        },
+        onComplete: function onComplete() {
+          if (sendFiles && sendFiles.indexOf(file) === sendFiles.length - 1) {
+            emit('done', fileList.value);
+          }
+        }
+      };
+      var uploadFn = props.sliceUpload ? ajaxSliceUpload : ajaxUpload;
+
+      if (customRequest) {
+        uploadFn = customRequest;
+      }
+
+      var request = uploadFn(options);
+      requests.value[uid] = request;
+
+      if (request instanceof Promise) {
+        request.then(options.onSuccess, options.onError);
+      }
+    }
+
+    function abort(file) {
+      var reqs = requests.value;
+
+      if (file) {
+        reqs = _defineProperty({}, file.uid, requests.value[file.uid]);
+      }
+
+      Object.keys(reqs).forEach(function (uid) {
+        if (reqs[uid] instanceof XMLHttpRequest) {
+          var xhr = reqs[uid];
+          xhr === null || xhr === void 0 ? void 0 : xhr.abort();
+        }
+
+        delete requests.value[uid];
+      });
+    }
+
+    (0,external_vue_namespaceObject.onBeforeUnmount)(function () {
+      fileList.value.forEach(function (_ref2) {
+        var url = _ref2.url;
+        if (url === null || url === void 0 ? void 0 : url.startsWith('blob:')) URL.revokeObjectURL(url);
+      });
+    });
+    expose({
+      handleRemove: handleRemove,
+      handleRetry: handleRetry
+    });
+    return function () {
+      return (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": classNames.value
+      }, [!isPhotowall.value && (0,external_vue_namespaceObject.createVNode)(upload_trigger, (0,external_vue_namespaceObject.mergeProps)(triggerProps.value, {
+        "onChange": handleFiles
+      }), slots), slots.tip ? slots.tip() : props.tip && (0,external_vue_namespaceObject.createVNode)("div", {
+        "class": "".concat(CLASS_PREFIX, "__tip")
+      }, [props.tip]), (0,external_vue_namespaceObject.createVNode)(upload_list, {
+        "files": fileList.value,
+        "theme": props.theme,
+        "disabled": props.disabled,
+        "multiple": props.multiple,
+        "onRemove": handleRemove,
+        "onRetry": handleRetry
+      }, {
+        innerTrigger: function innerTrigger(file) {
+          return isPhotowall.value && (0,external_vue_namespaceObject.createVNode)(upload_trigger, (0,external_vue_namespaceObject.mergeProps)(triggerProps.value, {
+            "file": file,
+            "onChange": handleFiles,
+            "onRemove": handleRemove
+          }), slots);
+        },
+        file: slots.file
+      })]);
+    };
+  }
+}));
+;// CONCATENATED MODULE: ../../packages/upload/src/index.ts
+/*
+ * Tencent is pleased to support the open source community by making
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
+ *
+ * Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+ *
+ * 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) is licensed under the MIT License.
+ *
+ * License for 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition):
+ *
+ * ---------------------------------------------------
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+ * the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+ * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+*/
+
+
+var Upload = (0,external_shared_namespaceObject.withInstall)(upload);
+/* harmony default export */ const src = (Upload);
+})();
+
+var __webpack_exports__default = __webpack_exports__.Z;
+export { __webpack_exports__default as default };