bk-magic-vue 2.3.2-beta.4 → 2.3.2-beta.6

package/lib/form-item.js

@@ -1042,173 +1042,115 @@
 
   var isArray$1 = isArray;
 
-  var runtime_1 = createCommonjsModule(function (module) {
-  var runtime = (function (exports) {
-    var Op = Object.prototype;
-    var hasOwn = Op.hasOwnProperty;
-    var undefined$1;
-    var $Symbol = typeof Symbol === "function" ? Symbol : {};
-    var iteratorSymbol = $Symbol.iterator || "@@iterator";
-    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
-    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+  function _regeneratorRuntime() {
+    _regeneratorRuntime = function () {
+      return exports;
+    };
+    var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      defineProperty = Object.defineProperty || function (obj, key, desc) {
+        obj[key] = desc.value;
+      },
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
     function define(obj, key, value) {
-      Object.defineProperty(obj, key, {
+      return Object.defineProperty(obj, key, {
         value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-      return obj[key];
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      }), obj[key];
     }
     try {
       define({}, "");
     } catch (err) {
-      define = function(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;
-      var generator = Object.create(protoGenerator.prototype);
-      var context = new Context(tryLocsList || []);
-      generator._invoke = makeInvokeMethod(innerFn, self, context);
-      return generator;
+      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+      return defineProperty(generator, "_invoke", {
+        value: makeInvokeMethod(innerFn, self, context)
+      }), generator;
     }
-    exports.wrap = wrap;
     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
+        };
       }
     }
-    var GenStateSuspendedStart = "suspendedStart";
-    var GenStateSuspendedYield = "suspendedYield";
-    var GenStateExecuting = "executing";
-    var GenStateCompleted = "completed";
+    exports.wrap = wrap;
     var ContinueSentinel = {};
     function Generator() {}
     function GeneratorFunction() {}
     function GeneratorFunctionPrototype() {}
     var IteratorPrototype = {};
-    IteratorPrototype[iteratorSymbol] = function () {
+    define(IteratorPrototype, iteratorSymbol, function () {
       return this;
-    };
-    var getProto = Object.getPrototypeOf;
-    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-    if (NativeIteratorPrototype &&
-        NativeIteratorPrototype !== Op &&
-        hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
-      IteratorPrototype = NativeIteratorPrototype;
-    }
-    var Gp = GeneratorFunctionPrototype.prototype =
-      Generator.prototype = Object.create(IteratorPrototype);
-    GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
-    GeneratorFunctionPrototype.constructor = GeneratorFunction;
-    GeneratorFunction.displayName = define(
-      GeneratorFunctionPrototype,
-      toStringTagSymbol,
-      "GeneratorFunction"
-    );
+    });
+    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);
     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 ||
-          (ctor.displayName || ctor.name) === "GeneratorFunction"
-        : false;
-    };
-    exports.mark = function(genFun) {
-      if (Object.setPrototypeOf) {
-        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-      } else {
-        genFun.__proto__ = GeneratorFunctionPrototype;
-        define(genFun, toStringTagSymbol, "GeneratorFunction");
-      }
-      genFun.prototype = Object.create(Gp);
-      return genFun;
-    };
-    exports.awrap = function(arg) {
-      return { __await: arg };
-    };
     function AsyncIterator(generator, PromiseImpl) {
       function invoke(method, arg, resolve, reject) {
         var record = tryCatch(generator[method], generator, arg);
-        if (record.type === "throw") {
-          reject(record.arg);
-        } else {
-          var result = record.arg;
-          var value = result.value;
-          if (value &&
-              typeof value === "object" &&
-              hasOwn.call(value, "__await")) {
-            return PromiseImpl.resolve(value.__await).then(function(value) {
-              invoke("next", value, resolve, reject);
-            }, function(err) {
-              invoke("throw", err, resolve, reject);
-            });
-          }
-          return PromiseImpl.resolve(value).then(function(unwrapped) {
-            result.value = unwrapped;
-            resolve(result);
-          }, function(error) {
+        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 invoke("throw", error, resolve, reject);
           });
         }
+        reject(record.arg);
       }
       var previousPromise;
-      function enqueue(method, arg) {
-        function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function(resolve, reject) {
-            invoke(method, arg, resolve, reject);
-          });
+      defineProperty(this, "_invoke", {
+        value: function (method, arg) {
+          function callInvokeWithMethodAndArg() {
+            return new PromiseImpl(function (resolve, reject) {
+              invoke(method, arg, resolve, reject);
+            });
+          }
+          return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
         }
-        return previousPromise =
-          previousPromise ? previousPromise.then(
-            callInvokeWithMethodAndArg,
-            callInvokeWithMethodAndArg
-          ) : callInvokeWithMethodAndArg();
-      }
-      this._invoke = enqueue;
+      });
     }
-    defineIteratorMethods(AsyncIterator.prototype);
-    AsyncIterator.prototype[asyncIteratorSymbol] = function () {
-      return this;
-    };
-    exports.AsyncIterator = AsyncIterator;
-    exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-      if (PromiseImpl === void 0) PromiseImpl = Promise;
-      var iter = new AsyncIterator(
-        wrap(innerFn, outerFn, self, tryLocsList),
-        PromiseImpl
-      );
-      return exports.isGeneratorFunction(outerFn)
-        ? iter
-        : iter.next().then(function(result) {
-            return result.done ? result.value : iter.next();
-          });
-    };
     function makeInvokeMethod(innerFn, self, context) {
-      var state = GenStateSuspendedStart;
-      return function invoke(method, arg) {
-        if (state === GenStateExecuting) {
-          throw new Error("Generator is already running");
-        }
-        if (state === GenStateCompleted) {
-          if (method === "throw") {
-            throw arg;
-          }
+      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();
         }
-        context.method = method;
-        context.arg = arg;
-        while (true) {
+        for (context.method = method, context.arg = arg;;) {
           var delegate = context.delegate;
           if (delegate) {
             var delegateResult = maybeInvokeDelegate(delegate, context);
@@ -1217,297 +1159,178 @@
               return delegateResult;
             }
           }
-          if (context.method === "next") {
-            context.sent = context._sent = context.arg;
-          } else if (context.method === "throw") {
-            if (state === GenStateSuspendedStart) {
-              state = GenStateCompleted;
-              throw context.arg;
-            }
+          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 if (context.method === "return") {
-            context.abrupt("return", context.arg);
-          }
-          state = GenStateExecuting;
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
           var record = tryCatch(innerFn, self, context);
-          if (record.type === "normal") {
-            state = context.done
-              ? GenStateCompleted
-              : GenStateSuspendedYield;
-            if (record.arg === ContinueSentinel) {
-              continue;
-            }
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
             return {
               value: record.arg,
               done: context.done
             };
-          } else if (record.type === "throw") {
-            state = GenStateCompleted;
-            context.method = "throw";
-            context.arg = record.arg;
           }
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
         }
       };
     }
     function maybeInvokeDelegate(delegate, context) {
       var method = delegate.iterator[context.method];
-      if (method === undefined$1) {
-        context.delegate = null;
-        if (context.method === "throw") {
-          if (delegate.iterator["return"]) {
-            context.method = "return";
-            context.arg = undefined$1;
-            maybeInvokeDelegate(delegate, context);
-            if (context.method === "throw") {
-              return ContinueSentinel;
-            }
-          }
-          context.method = "throw";
-          context.arg = new TypeError(
-            "The iterator does not provide a 'throw' method");
+      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");
         }
         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;
-      }
+      if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
       var info = record.arg;
-      if (! info) {
-        context.method = "throw";
-        context.arg = new TypeError("iterator result is not an object");
-        context.delegate = null;
-        return ContinueSentinel;
-      }
-      if (info.done) {
-        context[delegate.resultName] = info.value;
-        context.next = delegate.nextLoc;
-        if (context.method !== "return") {
-          context.method = "next";
-          context.arg = undefined$1;
-        }
-      } else {
-        return info;
-      }
-      context.delegate = null;
-      return ContinueSentinel;
+      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);
     }
-    defineIteratorMethods(Gp);
-    define(Gp, toStringTagSymbol, "Generator");
-    Gp[iteratorSymbol] = function() {
-      return this;
-    };
-    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);
+      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);
     }
     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(true);
-    }
-    exports.keys = function(object) {
-      var keys = [];
-      for (var key in object) {
-        keys.push(key);
-      }
-      keys.reverse();
-      return function next() {
-        while (keys.length) {
-          var key = keys.pop();
-          if (key in object) {
-            next.value = key;
-            next.done = false;
-            return next;
-          }
-        }
-        next.done = true;
-        return next;
-      };
-    };
+      this.tryEntries = [{
+        tryLoc: "root"
+      }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+    }
     function values(iterable) {
       if (iterable) {
         var iteratorMethod = iterable[iteratorSymbol];
-        if (iteratorMethod) {
-          return iteratorMethod.call(iterable);
-        }
-        if (typeof iterable.next === "function") {
-          return iterable;
-        }
+        if (iteratorMethod) return iteratorMethod.call(iterable);
+        if ("function" == typeof iterable.next) return iterable;
         if (!isNaN(iterable.length)) {
-          var i = -1, next = function next() {
-            while (++i < iterable.length) {
-              if (hasOwn.call(iterable, i)) {
-                next.value = iterable[i];
-                next.done = false;
-                return next;
-              }
-            }
-            next.value = undefined$1;
-            next.done = true;
-            return next;
-          };
+          var i = -1,
+            next = function next() {
+              for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+              return next.value = undefined, next.done = !0, next;
+            };
           return next.next = next;
         }
       }
-      return { next: doneResult };
+      return {
+        next: doneResult
+      };
     }
-    exports.values = values;
     function doneResult() {
-      return { value: undefined$1, done: true };
+      return {
+        value: undefined,
+        done: !0
+      };
     }
-    Context.prototype = {
-      constructor: Context,
-      reset: function(skipTempReset) {
-        this.prev = 0;
-        this.next = 0;
-        this.sent = this._sent = undefined$1;
-        this.done = false;
-        this.delegate = null;
-        this.method = "next";
-        this.arg = undefined$1;
-        this.tryEntries.forEach(resetTryEntry);
-        if (!skipTempReset) {
-          for (var name in this) {
-            if (name.charAt(0) === "t" &&
-                hasOwn.call(this, name) &&
-                !isNaN(+name.slice(1))) {
-              this[name] = undefined$1;
-            }
-          }
+    return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+      value: GeneratorFunctionPrototype,
+      configurable: !0
+    }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+      value: GeneratorFunction,
+      configurable: !0
+    }), 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 (val) {
+      var object = Object(val),
+        keys = [];
+      for (var key in object) keys.push(key);
+      return keys.reverse(), function next() {
+        for (; keys.length;) {
+          var key = keys.pop();
+          if (key in object) return next.value = key, next.done = !1, next;
         }
+        return next.done = !0, next;
+      };
+    }, exports.values = values, Context.prototype = {
+      constructor: Context,
+      reset: function (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 () {
+        this.done = !0;
+        var rootRecord = this.tryEntries[0].completion;
+        if ("throw" === rootRecord.type) throw rootRecord.arg;
         return this.rval;
       },
-      dispatchException: function(exception) {
-        if (this.done) {
-          throw exception;
-        }
+      dispatchException: function (exception) {
+        if (this.done) throw exception;
         var context = this;
         function handle(loc, caught) {
-          record.type = "throw";
-          record.arg = exception;
-          context.next = loc;
-          if (caught) {
-            context.method = "next";
-            context.arg = undefined$1;
-          }
-          return !! caught;
+          return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
         }
         for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          var record = entry.completion;
-          if (entry.tryLoc === "root") {
-            return handle("end");
-          }
+          var entry = this.tryEntries[i],
+            record = entry.completion;
+          if ("root" === entry.tryLoc) return handle("end");
           if (entry.tryLoc <= this.prev) {
-            var hasCatch = hasOwn.call(entry, "catchLoc");
-            var hasFinally = hasOwn.call(entry, "finallyLoc");
+            var hasCatch = hasOwn.call(entry, "catchLoc"),
+              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);
-              }
+              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+              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);
-              }
+              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
             } else {
-              throw new Error("try statement without catch or finally");
+              if (!hasFinally) throw new Error("try statement without catch or finally");
+              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
             }
           }
         }
       },
-      abrupt: function(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;
           }
         }
-        if (finallyEntry &&
-            (type === "break" ||
-             type === "continue") &&
-            finallyEntry.tryLoc <= arg &&
-            arg <= finallyEntry.finallyLoc) {
-          finallyEntry = null;
-        }
+        finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
         var record = finallyEntry ? finallyEntry.completion : {};
-        record.type = type;
-        record.arg = arg;
-        if (finallyEntry) {
-          this.method = "next";
-          this.next = finallyEntry.finallyLoc;
-          return ContinueSentinel;
-        }
-        return this.complete(record);
+        return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : 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;
+      complete: function (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;
       },
-      finish: function(finallyLoc) {
+      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;
-          }
+          if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
         }
       },
-      "catch": function(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 (record.type === "throw") {
+            if ("throw" === record.type) {
               var thrown = record.arg;
               resetTryEntry(entry);
             }
@@ -1516,47 +1339,24 @@
         }
         throw new Error("illegal catch attempt");
       },
-      delegateYield: function(iterable, resultName, nextLoc) {
-        this.delegate = {
+      delegateYield: function (iterable, resultName, nextLoc) {
+        return this.delegate = {
           iterator: values(iterable),
           resultName: resultName,
           nextLoc: nextLoc
-        };
-        if (this.method === "next") {
-          this.arg = undefined$1;
-        }
-        return ContinueSentinel;
+        }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
       }
-    };
-    return exports;
-  }(
-     module.exports 
-  ));
-  try {
-    regeneratorRuntime = runtime;
-  } catch (accidentalStrictMode) {
-    Function("r", "regeneratorRuntime = r")(runtime);
+    }, exports;
   }
-  });
-
-  var regenerator = runtime_1;
-
   function _typeof(obj) {
     "@babel/helpers - typeof";
 
-    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function (obj) {
-        return typeof obj;
-      };
-    } else {
-      _typeof = function (obj) {
-        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      };
-    }
-
-    return _typeof(obj);
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
   }
-
   function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
       var info = gen[key](arg);
@@ -1565,40 +1365,33 @@
       reject(error);
       return;
     }
-
     if (info.done) {
       resolve(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
   }
-
   function _asyncToGenerator(fn) {
     return function () {
       var self = this,
-          args = arguments;
+        args = arguments;
       return new Promise(function (resolve, reject) {
         var gen = fn.apply(self, args);
-
         function _next(value) {
           asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
         }
-
         function _throw(err) {
           asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
         }
-
         _next(undefined);
       });
     };
   }
-
   function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
     }
   }
-
   function _defineProperties(target, props) {
     for (var i = 0; i < props.length; i++) {
       var descriptor = props[i];
@@ -1608,13 +1401,14 @@
       Object.defineProperty(target, descriptor.key, descriptor);
     }
   }
-
   function _createClass(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
     if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
     return Constructor;
   }
-
   function _defineProperty(obj, key, value) {
     if (key in obj) {
       Object.defineProperty(obj, key, {
@@ -1626,47 +1420,37 @@
     } else {
       obj[key] = value;
     }
-
     return obj;
   }
-
   function _extends() {
-    _extends = Object.assign || function (target) {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i];
-
         for (var key in source) {
           if (Object.prototype.hasOwnProperty.call(source, key)) {
             target[key] = source[key];
           }
         }
       }
-
       return target;
     };
-
     return _extends.apply(this, arguments);
   }
-
   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) {
+        ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) {
           return Object.getOwnPropertyDescriptor(source, sym).enumerable;
         }));
       }
-
       ownKeys.forEach(function (key) {
         _defineProperty(target, key, source[key]);
       });
     }
-
     return target;
   }
-
   function _unsupportedIterableToArray(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -1675,25 +1459,18 @@
     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);
   }
-
   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;
   }
-
   function _createForOfIteratorHelper(o, allowArrayLike) {
     var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-
     if (!it) {
       if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
         if (it) o = it;
         var i = 0;
-
         var F = function () {};
-
         return {
           s: F,
           n: function () {
@@ -1711,13 +1488,11 @@
           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;
+      didErr = false,
+      err;
     return {
       s: function () {
         it = it.call(o);
@@ -1938,9 +1713,9 @@
         return element.body;
     }
     var _getStyleComputedProp = getStyleComputedProperty(element),
-        overflow = _getStyleComputedProp.overflow,
-        overflowX = _getStyleComputedProp.overflowX,
-        overflowY = _getStyleComputedProp.overflowY;
+      overflow = _getStyleComputedProp.overflow,
+      overflowX = _getStyleComputedProp.overflowX,
+      overflowY = _getStyleComputedProp.overflowY;
     if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
       return element;
     }
@@ -2204,8 +1979,8 @@
       var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
       if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
         var _getWindowSizes = getWindowSizes(popper.ownerDocument),
-            height = _getWindowSizes.height,
-            width = _getWindowSizes.width;
+          height = _getWindowSizes.height,
+          width = _getWindowSizes.width;
         boundaries.top += offsets.top - offsets.marginTop;
         boundaries.bottom = height + offsets.top;
         boundaries.left += offsets.left - offsets.marginLeft;
@@ -2224,7 +1999,7 @@
   }
   function getArea(_ref) {
     var width = _ref.width,
-        height = _ref.height;
+      height = _ref.height;
     return width * height;
   }
   function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
@@ -2262,7 +2037,7 @@
     });
     var filteredAreas = sortedAreas.filter(function (_ref2) {
       var width = _ref2.width,
-          height = _ref2.height;
+        height = _ref2.height;
       return width >= popper.clientWidth && height >= popper.clientHeight;
     });
     var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
@@ -2377,7 +2152,7 @@
   function isModifierEnabled(modifiers, modifierName) {
     return modifiers.some(function (_ref3) {
       var name = _ref3.name,
-          enabled = _ref3.enabled;
+        enabled = _ref3.enabled;
       return enabled && name === modifierName;
     });
   }
@@ -2500,10 +2275,10 @@
   }
   function getRoundedOffsets(data, shouldRound) {
     var _data$offsets = data.offsets,
-        popper = _data$offsets.popper,
-        reference = _data$offsets.reference;
+      popper = _data$offsets.popper,
+      reference = _data$offsets.reference;
     var round = Math.round,
-        floor = Math.floor;
+      floor = Math.floor;
     var noRound = function noRound(v) {
       return v;
     };
@@ -2525,7 +2300,7 @@
   var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
   function computeStyle(data, options) {
     var x = options.x,
-        y = options.y;
+      y = options.y;
     var popper = data.offsets.popper;
     var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
       return modifier.name === 'applyStyle';
@@ -2616,8 +2391,8 @@
     }
     var placement = data.placement.split('-')[0];
     var _data$offsets2 = data.offsets,
-        popper = _data$offsets2.popper,
-        reference = _data$offsets2.reference;
+      popper = _data$offsets2.popper,
+      reference = _data$offsets2.reference;
     var isVertical = ['left', 'right'].indexOf(placement) !== -1;
     var len = isVertical ? 'height' : 'width';
     var sideCapitalized = isVertical ? 'Top' : 'Left';
@@ -2724,8 +2499,8 @@
   }
   function keepTogether(data) {
     var _data$offsets3 = data.offsets,
-        popper = _data$offsets3.popper,
-        reference = _data$offsets3.reference;
+      popper = _data$offsets3.popper,
+      reference = _data$offsets3.reference;
     var placement = data.placement.split('-')[0];
     var floor = Math.floor;
     var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
@@ -2819,9 +2594,9 @@
   function offset(data, _ref5) {
     var offset = _ref5.offset;
     var placement = data.placement,
-        _data$offsets4 = data.offsets,
-        popper = _data$offsets4.popper,
-        reference = _data$offsets4.reference;
+      _data$offsets4 = data.offsets,
+      popper = _data$offsets4.popper,
+      reference = _data$offsets4.reference;
     var basePlacement = placement.split('-')[0];
     var offsets;
     if (isNumeric(+offset)) {
@@ -2853,8 +2628,8 @@
     var transformProp = getSupportedPropertyName('transform');
     var popperStyles = data.instance.popper.style;
     var top = popperStyles.top,
-        left = popperStyles.left,
-        transform = popperStyles[transformProp];
+      left = popperStyles.left,
+      transform = popperStyles[transformProp];
     popperStyles.top = '';
     popperStyles.left = '';
     popperStyles[transformProp] = '';
@@ -2895,8 +2670,8 @@
     var shiftvariation = placement.split('-')[1];
     if (shiftvariation) {
       var _data$offsets5 = data.offsets,
-          reference = _data$offsets5.reference,
-          popper = _data$offsets5.popper;
+        reference = _data$offsets5.reference,
+        popper = _data$offsets5.popper;
       var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
       var side = isVertical ? 'left' : 'top';
       var measurement = isVertical ? 'width' : 'height';
@@ -2935,8 +2710,8 @@
     var placement = data.placement;
     var basePlacement = placement.split('-')[0];
     var _data$offsets6 = data.offsets,
-        popper = _data$offsets6.popper,
-        reference = _data$offsets6.reference;
+      popper = _data$offsets6.popper,
+      reference = _data$offsets6.reference;
     var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
     var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
     popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
@@ -3110,7 +2885,7 @@
   var isIOS = isBrowser$1 && /iPhone|iPad|iPod/.test(navigator.platform) && !window.MSStream;
   var defaultProps = {
     a11y: true,
-    allowHTML: true,
+    allowHTML: false,
     animateFill: true,
     animation: 'shift-away',
     appendTo: function appendTo() {
@@ -3229,7 +3004,7 @@
   }
   function onWindowBlur() {
     var _document = document,
-        activeElement = _document.activeElement;
+      activeElement = _document.activeElement;
     if (activeElement && activeElement.blur && activeElement._tippy) {
       activeElement.blur();
     }
@@ -3515,10 +3290,10 @@
   }
   function updatePopperElement(popper, prevProps, nextProps) {
     var _getChildren = getChildren(popper),
-        tooltip = _getChildren.tooltip,
-        content = _getChildren.content,
-        backdrop = _getChildren.backdrop,
-        arrow = _getChildren.arrow;
+      tooltip = _getChildren.tooltip,
+      content = _getChildren.content,
+      backdrop = _getChildren.backdrop,
+      arrow = _getChildren.arrow;
     popper.style.zIndex = '' + nextProps.zIndex;
     tooltip.setAttribute('data-size', nextProps.size);
     tooltip.setAttribute('data-animation', nextProps.animation);
@@ -3563,8 +3338,8 @@
   }
   function hideAll() {
     var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        excludedReferenceOrInstance = _ref.exclude,
-        duration = _ref.duration;
+      excludedReferenceOrInstance = _ref.exclude,
+      duration = _ref.duration;
     arrayFrom(document.querySelectorAll(POPPER_SELECTOR)).forEach(function (popper) {
       var instance = popper._tippy;
       if (instance) {
@@ -3583,9 +3358,9 @@
       return true;
     }
     var x = event.clientX,
-        y = event.clientY;
+      y = event.clientY;
     var interactiveBorder = props.interactiveBorder,
-        distance = props.distance;
+      distance = props.distance;
     var exceedsTop = popperRect.top - y > (popperPlacement === 'top' ? interactiveBorder + distance : interactiveBorder);
     var exceedsBottom = y - popperRect.bottom > (popperPlacement === 'bottom' ? interactiveBorder + distance : interactiveBorder);
     var exceedsLeft = popperRect.left - x > (popperPlacement === 'left' ? interactiveBorder + distance : interactiveBorder);
@@ -3779,16 +3554,16 @@
     function removeTriggersFromReference() {
       listeners.forEach(function (_ref) {
         var eventType = _ref.eventType,
-            handler = _ref.handler,
-            options = _ref.options;
+          handler = _ref.handler,
+          options = _ref.options;
         getEventListenersTarget().removeEventListener(eventType, handler, options);
       });
       listeners = [];
     }
     function positionVirtualReferenceNearCursor(event) {
       var _lastMouseMoveEvent = lastMouseMoveEvent = event,
-          x = _lastMouseMoveEvent.clientX,
-          y = _lastMouseMoveEvent.clientY;
+        x = _lastMouseMoveEvent.clientX,
+        y = _lastMouseMoveEvent.clientY;
       if (!currentComputedPadding) {
         return;
       }
@@ -3919,8 +3694,8 @@
     function createPopperInstance() {
       var popperOptions = instance.props.popperOptions;
       var _instance$popperChild = instance.popperChildren,
-          tooltip = _instance$popperChild.tooltip,
-          arrow = _instance$popperChild.arrow;
+        tooltip = _instance$popperChild.tooltip,
+        arrow = _instance$popperChild.arrow;
       var preventOverflowModifier = getModifier(popperOptions, 'preventOverflow');
       function applyMutations(data) {
         if (instance.props.flip && !instance.props.flipOnUpdate) {
@@ -4247,10 +4022,10 @@
   }
   function group(instances) {
     var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        _ref$delay = _ref.delay,
-        delay = _ref$delay === void 0 ? instances[0].props.delay : _ref$delay,
-        _ref$duration = _ref.duration,
-        duration = _ref$duration === void 0 ? 0 : _ref$duration;
+      _ref$delay = _ref.delay,
+      delay = _ref$delay === void 0 ? instances[0].props.delay : _ref$delay,
+      _ref$duration = _ref.duration,
+      duration = _ref$duration === void 0 ? 0 : _ref$duration;
     var isAnyTippyOpen = false;
     instances.forEach(function (instance) {
       if (instance._originalProps) {
@@ -4357,14 +4132,18 @@
     trigger: 'mouseenter focus',
     theme: 'dark',
     interactive: true,
+    boundary: 'window',
     content: '',
-    allowHtml: false,
+    allowHTML: false,
     extCls: ''
   };
   var validPlacements$1 = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
   var createTippy$1 = function createTippy(el, binding) {
     var value = binding.value;
     var options = _objectSpread({}, defaultOptions);
+    if (value.allowHtml || value.allowHTML) {
+      value.allowHTML = true;
+    }
     if (_typeof(value) === 'object') {
       _extends(options, value);
     } else {
@@ -4375,23 +4154,21 @@
     });
     options.placement = options.placement || placement || (options.placements || ['top'])[0];
     var _binding$modifiers = binding.modifiers,
-        click = _binding$modifiers.click,
-        light = _binding$modifiers.light;
+      click = _binding$modifiers.click,
+      light = _binding$modifiers.light;
     if (click) {
       options.trigger = 'click';
     }
     if (light) {
       options.theme = 'light';
     }
-    if (options.allowHtml) {
+    if (options.allowHTML) {
       var selector = options.content;
       if (selector instanceof Vue) {
         options.content = selector.$el;
       } else if (typeof selector === 'string') {
-        var element = document.querySelector(selector);
-        if (element) {
-          options.content = element;
-        }
+        var element = document.createElement('div');
+        element.innerHTML = selector;
       }
     }
     if (options.html) {
@@ -4580,7 +4357,7 @@
         var paths = this.property.split('.');
         var data = formModel;
         var _iterator = _createForOfIteratorHelper(paths),
-            _step;
+          _step;
         try {
           for (_iterator.s(); !(_step = _iterator.n()).done;) {
             var path = _step.value;
@@ -4638,9 +4415,9 @@
         this.validator.content = '';
       },
       checkRule: function checkRule(rule, model) {
-        return _asyncToGenerator( regenerator.mark(function _callee() {
+        return _asyncToGenerator( _regeneratorRuntime().mark(function _callee() {
           var result;
-          return regenerator.wrap(function _callee$(_context) {
+          return _regeneratorRuntime().wrap(function _callee$(_context) {
             while (1) {
               switch (_context.prev = _context.next) {
                 case 0:
@@ -4729,9 +4506,9 @@
         rules.forEach(function (rule) {
           promises.push(function () {
             return new promise$1( function () {
-              var _ref = _asyncToGenerator( regenerator.mark(function _callee2(resolve, reject) {
+              var _ref = _asyncToGenerator( _regeneratorRuntime().mark(function _callee2(resolve, reject) {
                 var curRule, result;
-                return regenerator.wrap(function _callee2$(_context2) {
+                return _regeneratorRuntime().wrap(function _callee2$(_context2) {
                   while (1) {
                     switch (_context2.prev = _context2.next) {
                       case 0:
@@ -4843,15 +4620,12 @@
 
   /* script */
   var __vue_script__ = script;
-  /* template */
 
+  /* template */
   var __vue_render__ = function __vue_render__() {
     var _vm = this;
-
     var _h = _vm.$createElement;
-
     var _c = _vm._self._c || _h;
-
     return _c('div', {
       class: ['bk-form-item', {
         'is-required': _vm.required,
@@ -4925,19 +4699,15 @@
       staticClass: "form-error-tip"
     }, [_vm._v(_vm._s(_vm.validator.content))])] : _vm._e(), _vm._t("tip")], 2)]);
   };
-
   var __vue_staticRenderFns__ = [];
-  /* style */
 
+  /* style */
   var __vue_inject_styles__ = undefined;
   /* scoped */
-
   var __vue_scope_id__ = undefined;
   /* module identifier */
-
   var __vue_module_identifier__ = undefined;
   /* functional template */
-
   var __vue_is_functional_template__ = false;
   /* style inject */