bm-admin-ui 1.0.20-alpha → 1.0.21-alpha

package/index.js

@@ -127,7 +127,7 @@ var process = {
 
   (function (module) {
   function _extends() {
-    module.exports = _extends = Object.assign ? Object.assign.bind() : function (target) {
+    module.exports = _extends = Object.assign || function (target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i];
 
@@ -1504,8 +1504,8 @@ var process = {
     children.forEach(function (child) {
       if (Array.isArray(child)) {
         res.push.apply(res, (0, _toConsumableArray2.default)(child));
-      } else if (child.type === _vue.Fragment) {
-        res.push.apply(res, (0, _toConsumableArray2.default)(child.children));
+      } else if ((child === null || child === void 0 ? void 0 : child.type) === _vue.Fragment) {
+        res.push.apply(res, (0, _toConsumableArray2.default)(filterEmpty(child.children)));
       } else {
         res.push(child);
       }
@@ -3186,7 +3186,7 @@ var process = {
    */
   function convertToPercentage(n) {
       if (n <= 1) {
-          return "".concat(Number(n) * 100, "%");
+          return Number(n) * 100 + "%";
       }
       return n;
   }
@@ -3652,12 +3652,12 @@ var process = {
   // <http://www.w3.org/TR/css3-values/#number-value>
   var CSS_NUMBER = '[-\\+]?\\d*\\.\\d+%?';
   // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
-  var CSS_UNIT = "(?:".concat(CSS_NUMBER, ")|(?:").concat(CSS_INTEGER, ")");
+  var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
   // Actual matching.
   // Parentheses and commas are optional, but not required.
   // Whitespace can take the place of commas or opening paren
-  var PERMISSIVE_MATCH3 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
-  var PERMISSIVE_MATCH4 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
+  var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+  var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
   var matchers = {
       CSS_UNIT: new RegExp(CSS_UNIT),
       rgb: new RegExp('rgb' + PERMISSIVE_MATCH3),
@@ -3883,7 +3883,7 @@ var process = {
           var h = Math.round(hsv.h * 360);
           var s = Math.round(hsv.s * 100);
           var v = Math.round(hsv.v * 100);
-          return this.a === 1 ? "hsv(".concat(h, ", ").concat(s, "%, ").concat(v, "%)") : "hsva(".concat(h, ", ").concat(s, "%, ").concat(v, "%, ").concat(this.roundA, ")");
+          return this.a === 1 ? "hsv(" + h + ", " + s + "%, " + v + "%)" : "hsva(" + h + ", " + s + "%, " + v + "%, " + this.roundA + ")";
       };
       /**
        * Returns the object as a HSLA object.
@@ -3901,7 +3901,7 @@ var process = {
           var h = Math.round(hsl.h * 360);
           var s = Math.round(hsl.s * 100);
           var l = Math.round(hsl.l * 100);
-          return this.a === 1 ? "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)") : "hsla(".concat(h, ", ").concat(s, "%, ").concat(l, "%, ").concat(this.roundA, ")");
+          return this.a === 1 ? "hsl(" + h + ", " + s + "%, " + l + "%)" : "hsla(" + h + ", " + s + "%, " + l + "%, " + this.roundA + ")";
       };
       /**
        * Returns the hex value of the color.
@@ -3954,13 +3954,13 @@ var process = {
           var r = Math.round(this.r);
           var g = Math.round(this.g);
           var b = Math.round(this.b);
-          return this.a === 1 ? "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")") : "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(this.roundA, ")");
+          return this.a === 1 ? "rgb(" + r + ", " + g + ", " + b + ")" : "rgba(" + r + ", " + g + ", " + b + ", " + this.roundA + ")";
       };
       /**
        * Returns the object as a RGBA object.
        */
       TinyColor.prototype.toPercentageRgb = function () {
-          var fmt = function (x) { return "".concat(Math.round(bound01(x, 255) * 100), "%"); };
+          var fmt = function (x) { return Math.round(bound01(x, 255) * 100) + "%"; };
           return {
               r: fmt(this.r),
               g: fmt(this.g),
@@ -3974,8 +3974,8 @@ var process = {
       TinyColor.prototype.toPercentageRgbString = function () {
           var rnd = function (x) { return Math.round(bound01(x, 255) * 100); };
           return this.a === 1
-              ? "rgb(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%)")
-              : "rgba(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%, ").concat(this.roundA, ")");
+              ? "rgb(" + rnd(this.r) + "%, " + rnd(this.g) + "%, " + rnd(this.b) + "%)"
+              : "rgba(" + rnd(this.r) + "%, " + rnd(this.g) + "%, " + rnd(this.b) + "%, " + this.roundA + ")";
       };
       /**
        * The 'real' name of the color -if there is one.
@@ -4343,7 +4343,7 @@ var process = {
           var s = new TinyColor(secondColor);
           secondHex8String = '#' + rgbaToArgbHex(s.r, s.g, s.b, s.a);
       }
-      return "progid:DXImageTransform.Microsoft.gradient(".concat(gradientType, "startColorstr=").concat(hex8String, ",endColorstr=").concat(secondHex8String, ")");
+      return "progid:DXImageTransform.Microsoft.gradient(" + gradientType + "startColorstr=" + hex8String + ",endColorstr=" + secondHex8String + ")";
   }
 
   /**
@@ -5795,379 +5795,765 @@ var process = {
 
   var notification$1 = {};
 
-  var regeneratorRuntime$1 = {exports: {}};
+  var runtime = {exports: {}};
 
-  (function (module) {
-  var _typeof = _typeof$c.exports["default"];
+  /**
+   * 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.
+   */
 
-  function _regeneratorRuntime() {
-    /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+  (function (module) {
+  var runtime = (function (exports) {
 
-    module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
-      return exports;
-    }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-    var exports = {},
-        Op = Object.prototype,
-        hasOwn = Op.hasOwnProperty,
-        $Symbol = "function" == typeof Symbol ? Symbol : {},
-        iteratorSymbol = $Symbol.iterator || "@@iterator",
-        asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
-        toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+    var Op = Object.prototype;
+    var hasOwn = Op.hasOwnProperty;
+    var undefined$1; // 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) {
-      return Object.defineProperty(obj, key, {
+      Object.defineProperty(obj, key, {
         value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-      }), obj[key];
+        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 define(obj, key, value) {
+      define = function(obj, key, value) {
         return obj[key] = value;
       };
     }
 
     function wrap(innerFn, outerFn, self, tryLocsList) {
-      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
-          generator = Object.create(protoGenerator.prototype),
-          context = new Context(tryLocsList || []);
-      return generator._invoke = function (innerFn, self, context) {
-        var state = "suspendedStart";
-        return function (method, arg) {
-          if ("executing" === state) throw new Error("Generator is already running");
-
-          if ("completed" === state) {
-            if ("throw" === method) throw arg;
-            return doneResult();
-          }
-
-          for (context.method = method, context.arg = arg;;) {
-            var delegate = context.delegate;
-
-            if (delegate) {
-              var delegateResult = maybeInvokeDelegate(delegate, context);
+      // 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 || []);
 
-              if (delegateResult) {
-                if (delegateResult === ContinueSentinel) continue;
-                return delegateResult;
-              }
-            }
-
-            if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
-              if ("suspendedStart" === state) throw state = "completed", context.arg;
-              context.dispatchException(context.arg);
-            } else "return" === context.method && context.abrupt("return", context.arg);
-            state = "executing";
-            var record = tryCatch(innerFn, self, context);
-
-            if ("normal" === record.type) {
-              if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
-              return {
-                value: record.arg,
-                done: context.done
-              };
-            }
+      // The ._invoke method unifies the implementations of the .next,
+      // .throw, and .return methods.
+      generator._invoke = makeInvokeMethod(innerFn, self, context);
 
-            "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
-          }
-        };
-      }(innerFn, self, context), generator;
+      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)
-        };
+        return { type: "normal", arg: fn.call(obj, arg) };
       } catch (err) {
-        return {
-          type: "throw",
-          arg: err
-        };
+        return { type: "throw", arg: err };
       }
     }
 
-    exports.wrap = wrap;
+    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,
-        NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-    NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
-    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
 
+    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) {
+      ["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);
+            });
+          }
 
-        if ("throw" !== record.type) {
-          var result = record.arg,
-              value = result.value;
-          return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
-            invoke("next", value, resolve, reject);
-          }, function (err) {
-            invoke("throw", err, resolve, reject);
-          }) : PromiseImpl.resolve(value).then(function (unwrapped) {
-            result.value = unwrapped, resolve(result);
-          }, function (error) {
+          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);
           });
         }
-
-        reject(record.arg);
       }
 
       var previousPromise;
 
-      this._invoke = function (method, arg) {
+      function enqueue(method, arg) {
         function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function (resolve, reject) {
+          return new PromiseImpl(function(resolve, reject) {
             invoke(method, arg, resolve, reject);
           });
         }
 
-        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+        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$1) {
+        // 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$1;
+            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;
+            }
+          }
 
-      if (undefined === method) {
-        if (context.delegate = null, "throw" === context.method) {
-          if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
-          context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+          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 ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+
+      if (record.type === "throw") {
+        context.method = "throw";
+        context.arg = record.arg;
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+
       var info = record.arg;
-      return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+
+      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$1;
+        }
+
+      } 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]
-      };
-      1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+      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;
+      record.type = "normal";
+      delete record.arg;
+      entry.completion = record;
     }
 
     function Context(tryLocsList) {
-      this.tryEntries = [{
-        tryLoc: "root"
-      }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+      // 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 ("function" == typeof iterable.next) return iterable;
+        if (iteratorMethod) {
+          return iteratorMethod.call(iterable);
+        }
+
+        if (typeof iterable.next === "function") {
+          return iterable;
+        }
 
         if (!isNaN(iterable.length)) {
-          var i = -1,
-              next = function next() {
-            for (; ++i < iterable.length;) {
-              if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+          var i = -1, next = function next() {
+            while (++i < iterable.length) {
+              if (hasOwn.call(iterable, i)) {
+                next.value = iterable[i];
+                next.done = false;
+                return next;
+              }
             }
 
-            return next.value = undefined, next.done = !0, next;
+            next.value = undefined$1;
+            next.done = true;
+
+            return next;
           };
 
           return next.next = next;
         }
       }
 
-      return {
-        next: doneResult
-      };
+      // Return an iterator with no values.
+      return { next: doneResult };
     }
+    exports.values = values;
 
     function doneResult() {
-      return {
-        value: undefined,
-        done: !0
-      };
+      return { value: undefined$1, done: true };
     }
 
-    return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
-      var ctor = "function" == typeof genFun && genFun.constructor;
-      return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-    }, exports.mark = function (genFun) {
-      return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-    }, exports.awrap = function (arg) {
-      return {
-        __await: arg
-      };
-    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
-      return this;
-    }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-      void 0 === PromiseImpl && (PromiseImpl = Promise);
-      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
-        return result.done ? result.value : iter.next();
-      });
-    }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
-      return this;
-    }), define(Gp, "toString", function () {
-      return "[object Generator]";
-    }), exports.keys = function (object) {
-      var keys = [];
-
-      for (var key in object) {
-        keys.push(key);
-      }
+    Context.prototype = {
+      constructor: Context,
 
-      return keys.reverse(), function next() {
-        for (; keys.length;) {
-          var key = keys.pop();
-          if (key in object) return next.value = key, next.done = !1, next;
+      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$1;
+        this.done = false;
+        this.delegate = null;
+
+        this.method = "next";
+        this.arg = undefined$1;
+
+        this.tryEntries.forEach(resetTryEntry);
+
+        if (!skipTempReset) {
+          for (var name in this) {
+            // 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$1;
+            }
+          }
         }
+      },
 
-        return next.done = !0, next;
-      };
-    }, exports.values = values, Context.prototype = {
-      constructor: Context,
-      reset: function reset(skipTempReset) {
-        if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {
-          "t" === name.charAt(0) && 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;
         }
-      },
-      stop: function stop() {
-        this.done = !0;
-        var rootRecord = this.tryEntries[0].completion;
-        if ("throw" === rootRecord.type) throw rootRecord.arg;
+
         return this.rval;
       },
-      dispatchException: function dispatchException(exception) {
-        if (this.done) throw exception;
-        var context = this;
 
+      dispatchException: function(exception) {
+        if (this.done) {
+          throw exception;
+        }
+
+        var context = this;
         function handle(loc, caught) {
-          return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!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$1;
+          }
+
+          return !! caught;
         }
 
         for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i],
-              record = entry.completion;
-          if ("root" === entry.tryLoc) return handle("end");
+          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"),
-                hasFinally = hasOwn.call(entry, "finallyLoc");
+            var hasCatch = hasOwn.call(entry, "catchLoc");
+            var hasFinally = hasOwn.call(entry, "finallyLoc");
 
             if (hasCatch && hasFinally) {
-              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+              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, !0);
+              if (this.prev < entry.catchLoc) {
+                return handle(entry.catchLoc, true);
+              }
+
+            } else if (hasFinally) {
+              if (this.prev < entry.finallyLoc) {
+                return handle(entry.finallyLoc);
+              }
+
             } else {
-              if (!hasFinally) throw new Error("try statement without catch or finally");
-              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+              throw new Error("try statement without catch or finally");
             }
           }
         }
       },
-      abrupt: function abrupt(type, arg) {
+
+      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) {
+          if (entry.tryLoc <= this.prev &&
+              hasOwn.call(entry, "finallyLoc") &&
+              this.prev < entry.finallyLoc) {
             var finallyEntry = entry;
             break;
           }
         }
 
-        finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+        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 : {};
-        return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+        record.type = type;
+        record.arg = arg;
+
+        if (finallyEntry) {
+          this.method = "next";
+          this.next = finallyEntry.finallyLoc;
+          return ContinueSentinel;
+        }
+
+        return this.complete(record);
       },
-      complete: function complete(record, afterLoc) {
-        if ("throw" === record.type) throw record.arg;
-        return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+
+      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 finish(finallyLoc) {
+
+      finish: function(finallyLoc) {
         for (var i = this.tryEntries.length - 1; i >= 0; --i) {
           var entry = this.tryEntries[i];
-          if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+          if (entry.finallyLoc === finallyLoc) {
+            this.complete(entry.completion, entry.afterLoc);
+            resetTryEntry(entry);
+            return ContinueSentinel;
+          }
         }
       },
-      "catch": function _catch(tryLoc) {
+
+      "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 ("throw" === record.type) {
+            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 delegateYield(iterable, resultName, nextLoc) {
-        return this.delegate = {
+
+      delegateYield: function(iterable, resultName, nextLoc) {
+        this.delegate = {
           iterator: values(iterable),
           resultName: resultName,
           nextLoc: nextLoc
-        }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
-      }
-    }, exports;
-  }
+        };
+
+        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$1;
+        }
 
-  module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }(regeneratorRuntime$1));
+        return ContinueSentinel;
+      }
+    };
 
-  // TODO(Babel 8): Remove this file.
+    // 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;
 
-  var runtime = regeneratorRuntime$1.exports();
-  var regenerator = runtime;
+  }(
+    // 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.
+    module.exports 
+  ));
 
-  // Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
   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);
     }
   }
+  }(runtime));
+
+  var regenerator = runtime.exports;
 
   var CheckCircleOutlined$5 = {};
 
@@ -6912,7 +7298,7 @@ var process = {
       variables["".concat(type, "-color")] = formatColor(baseColor);
       variables["".concat(type, "-color-disabled")] = colorPalettes[1];
       variables["".concat(type, "-color-hover")] = colorPalettes[4];
-      variables["".concat(type, "-color-active")] = colorPalettes[7];
+      variables["".concat(type, "-color-active")] = colorPalettes[6];
       variables["".concat(type, "-color-outline")] = baseColor.clone().setAlpha(0.2).toRgbString();
       variables["".concat(type, "-color-deprecated-bg")] = colorPalettes[1];
       variables["".concat(type, "-color-deprecated-border")] = colorPalettes[3];
@@ -8357,7 +8743,7 @@ var process = {
   }
 
   function _extends$1() {
-    _extends$1 = Object.assign ? Object.assign.bind() : function (target) {
+    _extends$1 = Object.assign || function (target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i];
 
@@ -8370,6 +8756,7 @@ var process = {
 
       return target;
     };
+
     return _extends$1.apply(this, arguments);
   }
 
@@ -9514,8 +9901,8 @@ var process = {
     children.forEach(function (child) {
       if (Array.isArray(child)) {
         res.push.apply(res, _toConsumableArray$1(child));
-      } else if (child.type === require$$1$1.Fragment) {
-        res.push.apply(res, _toConsumableArray$1(child.children));
+      } else if ((child === null || child === void 0 ? void 0 : child.type) === require$$1$1.Fragment) {
+        res.push.apply(res, _toConsumableArray$1(filterEmpty(child.children)));
       } else {
         res.push(child);
       }
@@ -11729,7 +12116,7 @@ var process = {
       variables["".concat(type, "-color")] = formatColor(baseColor);
       variables["".concat(type, "-color-disabled")] = colorPalettes[1];
       variables["".concat(type, "-color-hover")] = colorPalettes[4];
-      variables["".concat(type, "-color-active")] = colorPalettes[7];
+      variables["".concat(type, "-color-active")] = colorPalettes[6];
       variables["".concat(type, "-color-outline")] = baseColor.clone().setAlpha(0.2).toRgbString();
       variables["".concat(type, "-color-deprecated-bg")] = colorPalettes[1];
       variables["".concat(type, "-color-deprecated-border")] = colorPalettes[3];
@@ -12384,8 +12771,8 @@ var process = {
     // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确
     // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin
 
-    x = Math.floor(box.left);
-    y = Math.floor(box.top); // In IE, most of the time, 2 extra pixels are added to the top and left
+    x = box.left;
+    y = box.top; // In IE, most of the time, 2 extra pixels are added to the top and left
     // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
     // IE6 standards mode, this border can be overridden by setting the
     // document element's border to zero -- thus, we cannot rely on the
@@ -12792,7 +13179,7 @@ var process = {
     }
 
     var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
-    var borderBoxValue = name === 'width' ? Math.floor(elem.getBoundingClientRect().width) : Math.floor(elem.getBoundingClientRect().height);
+    var borderBoxValue = name === 'width' ? elem.getBoundingClientRect().width : elem.getBoundingClientRect().height;
     var isBorderBox = isBorderBoxFn(elem);
     var cssBoxValue = 0;
 
@@ -15082,37 +15469,17 @@ var process = {
   var RightOutlined$1 = RightOutlined;
 
   // This icon file is generated automatically.
-  var DeleteOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M360 184h-8c4.4 0 8-3.6 8-8v8h304v-8c0 4.4 3.6 8 8 8h-8v72h72v-80c0-35.3-28.7-64-64-64H352c-35.3 0-64 28.7-64 64v80h72v-72zm504 72H160c-17.7 0-32 14.3-32 32v32c0 4.4 3.6 8 8 8h60.4l24.7 523c1.6 34.1 29.8 61 63.9 61h454c34.2 0 62.3-26.8 63.9-61l24.7-523H888c4.4 0 8-3.6 8-8v-32c0-17.7-14.3-32-32-32zM731.3 840H292.7l-24.2-512h487l-24.2 512z" } }] }, "name": "delete", "theme": "outlined" };
-  var DeleteOutlinedSvg = DeleteOutlined$2;
+  var PlusOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "defs", "attrs": {}, "children": [{ "tag": "style", "attrs": {} }] }, { "tag": "path", "attrs": { "d": "M482 152h60q8 0 8 8v704q0 8-8 8h-60q-8 0-8-8V160q0-8 8-8z" } }, { "tag": "path", "attrs": { "d": "M176 474h672q8 0 8 8v60q0 8-8 8H176q-8 0-8-8v-60q0-8 8-8z" } }] }, "name": "plus", "theme": "outlined" };
+  var PlusOutlinedSvg = PlusOutlined$2;
 
   function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$4(target, key, source[key]); }); } return target; }
 
   function _defineProperty$4(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; }
 
-  var DeleteOutlined = function DeleteOutlined(props, context) {
+  var PlusOutlined = function PlusOutlined(props, context) {
     var p = _objectSpread$3({}, props, context.attrs);
 
     return require$$1$1.createVNode(AntdIcon, _objectSpread$3({}, p, {
-      "icon": DeleteOutlinedSvg
-    }), null);
-  };
-
-  DeleteOutlined.displayName = 'DeleteOutlined';
-  DeleteOutlined.inheritAttrs = false;
-  var DeleteOutlined$1 = DeleteOutlined;
-
-  // This icon file is generated automatically.
-  var PlusOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "defs", "attrs": {}, "children": [{ "tag": "style", "attrs": {} }] }, { "tag": "path", "attrs": { "d": "M482 152h60q8 0 8 8v704q0 8-8 8h-60q-8 0-8-8V160q0-8 8-8z" } }, { "tag": "path", "attrs": { "d": "M176 474h672q8 0 8 8v60q0 8-8 8H176q-8 0-8-8v-60q0-8 8-8z" } }] }, "name": "plus", "theme": "outlined" };
-  var PlusOutlinedSvg = PlusOutlined$2;
-
-  function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$3(target, key, source[key]); }); } return target; }
-
-  function _defineProperty$3(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; }
-
-  var PlusOutlined = function PlusOutlined(props, context) {
-    var p = _objectSpread$2({}, props, context.attrs);
-
-    return require$$1$1.createVNode(AntdIcon, _objectSpread$2({}, p, {
       "icon": PlusOutlinedSvg
     }), null);
   };
@@ -15121,46 +15488,6 @@ var process = {
   PlusOutlined.inheritAttrs = false;
   var PlusOutlined$1 = PlusOutlined;
 
-  // This icon file is generated automatically.
-  var UpOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 00140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z" } }] }, "name": "up", "theme": "outlined" };
-  var UpOutlinedSvg = UpOutlined$2;
-
-  function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } return target; }
-
-  function _defineProperty$2(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; }
-
-  var UpOutlined = function UpOutlined(props, context) {
-    var p = _objectSpread$1({}, props, context.attrs);
-
-    return require$$1$1.createVNode(AntdIcon, _objectSpread$1({}, p, {
-      "icon": UpOutlinedSvg
-    }), null);
-  };
-
-  UpOutlined.displayName = 'UpOutlined';
-  UpOutlined.inheritAttrs = false;
-  var UpOutlined$1 = UpOutlined;
-
-  // This icon file is generated automatically.
-  var UploadOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M400 317.7h73.9V656c0 4.4 3.6 8 8 8h60c4.4 0 8-3.6 8-8V317.7H624c6.7 0 10.4-7.7 6.3-12.9L518.3 163a8 8 0 00-12.6 0l-112 141.7c-4.1 5.3-.4 13 6.3 13zM878 626h-60c-4.4 0-8 3.6-8 8v154H214V634c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v198c0 17.7 14.3 32 32 32h684c17.7 0 32-14.3 32-32V634c0-4.4-3.6-8-8-8z" } }] }, "name": "upload", "theme": "outlined" };
-  var UploadOutlinedSvg = UploadOutlined$2;
-
-  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } return target; }
-
-  function _defineProperty$1(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; }
-
-  var UploadOutlined = function UploadOutlined(props, context) {
-    var p = _objectSpread({}, props, context.attrs);
-
-    return require$$1$1.createVNode(AntdIcon, _objectSpread({}, p, {
-      "icon": UploadOutlinedSvg
-    }), null);
-  };
-
-  UploadOutlined.displayName = 'UploadOutlined';
-  UploadOutlined.inheritAttrs = false;
-  var UploadOutlined$1 = UploadOutlined;
-
   var canUseDocElement$1 = function canUseDocElement() {
     return canUseDom() && window.document.documentElement;
   };
@@ -16219,6 +16546,26 @@ var process = {
   });
   var DialogWrap$3 = DialogWrap$2;
 
+  // This icon file is generated automatically.
+  var UpOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 00140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z" } }] }, "name": "up", "theme": "outlined" };
+  var UpOutlinedSvg = UpOutlined$2;
+
+  function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$3(target, key, source[key]); }); } return target; }
+
+  function _defineProperty$3(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; }
+
+  var UpOutlined = function UpOutlined(props, context) {
+    var p = _objectSpread$2({}, props, context.attrs);
+
+    return require$$1$1.createVNode(AntdIcon, _objectSpread$2({}, p, {
+      "icon": UpOutlinedSvg
+    }), null);
+  };
+
+  UpOutlined.displayName = 'UpOutlined';
+  UpOutlined.inheritAttrs = false;
+  var UpOutlined$1 = UpOutlined;
+
   var __rest$e = undefined && undefined.__rest || function (s, e) {
     var t = {};
 
@@ -16898,6 +17245,46 @@ var process = {
     return app;
   };
 
+  // This icon file is generated automatically.
+  var DeleteOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M360 184h-8c4.4 0 8-3.6 8-8v8h304v-8c0 4.4 3.6 8 8 8h-8v72h72v-80c0-35.3-28.7-64-64-64H352c-35.3 0-64 28.7-64 64v80h72v-72zm504 72H160c-17.7 0-32 14.3-32 32v32c0 4.4 3.6 8 8 8h60.4l24.7 523c1.6 34.1 29.8 61 63.9 61h454c34.2 0 62.3-26.8 63.9-61l24.7-523H888c4.4 0 8-3.6 8-8v-32c0-17.7-14.3-32-32-32zM731.3 840H292.7l-24.2-512h487l-24.2 512z" } }] }, "name": "delete", "theme": "outlined" };
+  var DeleteOutlinedSvg = DeleteOutlined$2;
+
+  function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } return target; }
+
+  function _defineProperty$2(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; }
+
+  var DeleteOutlined = function DeleteOutlined(props, context) {
+    var p = _objectSpread$1({}, props, context.attrs);
+
+    return require$$1$1.createVNode(AntdIcon, _objectSpread$1({}, p, {
+      "icon": DeleteOutlinedSvg
+    }), null);
+  };
+
+  DeleteOutlined.displayName = 'DeleteOutlined';
+  DeleteOutlined.inheritAttrs = false;
+  var DeleteOutlined$1 = DeleteOutlined;
+
+  // This icon file is generated automatically.
+  var UploadOutlined$2 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M400 317.7h73.9V656c0 4.4 3.6 8 8 8h60c4.4 0 8-3.6 8-8V317.7H624c6.7 0 10.4-7.7 6.3-12.9L518.3 163a8 8 0 00-12.6 0l-112 141.7c-4.1 5.3-.4 13 6.3 13zM878 626h-60c-4.4 0-8 3.6-8 8v154H214V634c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v198c0 17.7 14.3 32 32 32h684c17.7 0 32-14.3 32-32V634c0-4.4-3.6-8-8-8z" } }] }, "name": "upload", "theme": "outlined" };
+  var UploadOutlinedSvg = UploadOutlined$2;
+
+  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } return target; }
+
+  function _defineProperty$1(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; }
+
+  var UploadOutlined = function UploadOutlined(props, context) {
+    var p = _objectSpread({}, props, context.attrs);
+
+    return require$$1$1.createVNode(AntdIcon, _objectSpread({}, p, {
+      "icon": UploadOutlinedSvg
+    }), null);
+  };
+
+  UploadOutlined.displayName = 'UploadOutlined';
+  UploadOutlined.inheritAttrs = false;
+  var UploadOutlined$1 = UploadOutlined;
+
   var alert = {};
 
   var vnode = {};
@@ -27033,6 +27420,18 @@ var process = {
           type: Boolean,
           default: false,
       },
+      expandPlacement: {
+          type: String,
+          default: 'left',
+      },
+      expandText: {
+          type: String,
+          default: '展开',
+      },
+      collapseText: {
+          type: String,
+          default: '收起',
+      },
   };
   const searchFilterProps = Object.assign({ userRule: {
           type: Array,
@@ -27069,9 +27468,6 @@ var process = {
           default() {
               return [];
           },
-      }, expandPlacement: {
-          type: String,
-          default: 'left',
       } }, searchResetBtnProps);
 
   const _hoisted_1$a = { class: "bm-search-filter-btn" };
@@ -27079,6 +27475,7 @@ var process = {
   const _hoisted_3$7 = /* @__PURE__ */ require$$1$1.createTextVNode("\u91CD\u7F6E");
   const _hoisted_4$7 = /* @__PURE__ */ require$$1$1.createTextVNode("\u67E5\u8BE2");
   const _sfc_main$d = /* @__PURE__ */ require$$1$1.defineComponent({
+    name: "search-reset-btn",
     props: searchResetBtnProps,
     emits: ["submit", "reset", "expand"],
     setup(__props, { emit: emits }) {
@@ -27102,7 +27499,7 @@ var process = {
             class: "bm-search-filter-expand",
             onClick: handleExpandBtnChange
           }, [
-            require$$1$1.createTextVNode(require$$1$1.toDisplayString(isExpand.value ? "\u6536\u8D77" : "\u5C55\u5F00"), 1),
+            require$$1$1.createTextVNode(require$$1$1.toDisplayString(isExpand.value ? props.collapseText : props.expandText), 1),
             isExpand.value ? (require$$1$1.openBlock(), require$$1$1.createBlock(require$$1$1.unref(UpOutlined$1), { key: 0 })) : (require$$1$1.openBlock(), require$$1$1.createBlock(require$$1$1.unref(DownOutlined$1), { key: 1 }))
           ])) : require$$1$1.createCommentVNode("v-if", true),
           require$$1$1.createElementVNode("span", _hoisted_2$8, [
@@ -27768,7 +28165,7 @@ var process = {
             "onUpdate:api": _cache[0] || (_cache[0] = ($event) => fApi.value = $event),
             "model-value": props.value,
             rule: require$$1$1.unref(rule),
-            option: require$$1$1.unref(option),
+            option,
             onChange: handleChange
           }, null, 8, ["api", "model-value", "rule", "option"])
         ], 2);
@@ -28788,8 +29185,8 @@ var process = {
 
         return (0, _vue$K.createVNode)("span", {
           "class": cls.value,
-          "onMouseenter": props.onMouseEnter,
-          "onMouseleave": props.onMouseLeave,
+          "onMouseenter": props.onMouseenter,
+          "onMouseleave": props.onMouseleave,
           "onFocus": props.onFocus,
           "onBlur": props.onBlur
         }, [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)]);
@@ -39246,7 +39643,7 @@ var process = {
           });
         };
 
-        syncScroll(3);
+        syncScroll(5);
       }
     };
   }
@@ -44879,7 +45276,7 @@ var process = {
                 ]);
               }), 128))
             ])) : require$$1$1.createCommentVNode("v-if", true)
-          ], 2112))
+          ], 64))
         ])
       ]),
       require$$1$1.createElementVNode("div", _hoisted_14$1, [
@@ -45143,7 +45540,7 @@ var process = {
           showHeaderOverflow: true,
           align: null,
           columns: [],
-          tooltipConfig: { leaveDelay: 1e6 },
+          tooltipConfig: { leaveDelay: 10 },
           data: [],
           pagerConfig: {},
           emptyText: "\u6682\u65E0\u6570\u636E",
@@ -45834,10 +46231,12 @@ var process = {
           emit("update", state.uploadedList);
         },
         uploadError(error, file = {}) {
-          if (methods.fileIsDelete(file)) {
-            return;
+          if (file) {
+            if (methods.fileIsDelete(file)) {
+              return;
+            }
+            state.fileList[file.uid].status = "error";
           }
-          state.fileList[file.uid].status = "error";
           emit("error", error);
         },
         async deleteFile(uid) {
@@ -46165,7 +46564,7 @@ var process = {
               key: 1,
               file: item
             })
-          ], 2112)) : require$$1$1.createCommentVNode("v-if", true),
+          ], 64)) : require$$1$1.createCommentVNode("v-if", true),
           require$$1$1.createCommentVNode(" \u56FE\u7247\u9519\u8BEF\u5C55\u793A "),
           item.status === "error" ? (require$$1$1.openBlock(), require$$1$1.createElementBlock("div", {
             key: 2,
@@ -46211,7 +46610,7 @@ var process = {
               }, 8, ["class", "disabled"]),
               _ctx.extraConfigs.tips && _ctx.extraConfigs.showTips ? (require$$1$1.openBlock(), require$$1$1.createElementBlock("div", _hoisted_23, require$$1$1.toDisplayString(_ctx.extraConfigs.tips), 1)) : require$$1$1.createCommentVNode("v-if", true)
             ])) : require$$1$1.createCommentVNode("v-if", true)
-          ], 2112))
+          ], 64))
         ]),
         _: 3
       }, 16, ["class"])) : require$$1$1.createCommentVNode("v-if", true),
@@ -46505,7 +46904,7 @@ var process = {
         if (!props.list.length || props.alwaysInvoke)
           emit("addClick");
       }
-      const tooltipConfig = ref({
+      const tooltipConfig = require$$1$1.ref({
         align: void 0,
         arrowPointAtCenter: false,
         autoAdjustOverflow: true,
@@ -46520,7 +46919,7 @@ var process = {
         placement: props.placement,
         trigger: "hover"
       });
-      watch(() => props.toolTipProps, (tooltipprop) => {
+      require$$1$1.watch(() => props.toolTipProps, (tooltipprop) => {
         tooltipConfig.value = {
           ...tooltipConfig.value,
           ...tooltipprop