vxe-table 3.8.0-beta.5 → 3.8.0-beta.7

package/lib/index.umd.js

@@ -1507,6 +1507,32 @@ var firefox = userAgent.match(/firefox\/(\d+)/i);
 module.exports = !!firefox && +firefox[1];
 
 
+/***/ }),
+
+/***/ 7290:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var IS_DENO = __webpack_require__(516);
+var IS_NODE = __webpack_require__(9088);
+
+module.exports = !IS_DENO && !IS_NODE
+  && typeof window == 'object'
+  && typeof document == 'object';
+
+
+/***/ }),
+
+/***/ 516:
+/***/ (function(module) {
+
+"use strict";
+
+/* global Deno -- Deno case */
+module.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
+
+
 /***/ }),
 
 /***/ 3202:
@@ -1519,6 +1545,56 @@ var UA = __webpack_require__(9392);
 module.exports = /MSIE|Trident/.test(UA);
 
 
+/***/ }),
+
+/***/ 28:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var userAgent = __webpack_require__(9392);
+
+module.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';
+
+
+/***/ }),
+
+/***/ 8119:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var userAgent = __webpack_require__(9392);
+
+// eslint-disable-next-line redos/no-vulnerable -- safe
+module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
+
+
+/***/ }),
+
+/***/ 9088:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(4475);
+var classof = __webpack_require__(4576);
+
+module.exports = classof(global.process) === 'process';
+
+
+/***/ }),
+
+/***/ 6765:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var userAgent = __webpack_require__(9392);
+
+module.exports = /web0s(?!.*chrome)/i.test(userAgent);
+
+
 /***/ }),
 
 /***/ 9392:
@@ -2224,6 +2300,21 @@ module.exports = Object.hasOwn || function hasOwn(it, key) {
 module.exports = {};
 
 
+/***/ }),
+
+/***/ 3138:
+/***/ (function(module) {
+
+"use strict";
+
+module.exports = function (a, b) {
+  try {
+    // eslint-disable-next-line no-console -- safe
+    arguments.length === 1 ? console.error(a) : console.error(a, b);
+  } catch (error) { /* empty */ }
+};
+
+
 /***/ }),
 
 /***/ 397:
@@ -3192,6 +3283,122 @@ module.exports = Math.trunc || function trunc(x) {
 };
 
 
+/***/ }),
+
+/***/ 1955:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(4475);
+var safeGetBuiltIn = __webpack_require__(3389);
+var bind = __webpack_require__(6080);
+var macrotask = (__webpack_require__(9225).set);
+var Queue = __webpack_require__(8265);
+var IS_IOS = __webpack_require__(8119);
+var IS_IOS_PEBBLE = __webpack_require__(28);
+var IS_WEBOS_WEBKIT = __webpack_require__(6765);
+var IS_NODE = __webpack_require__(9088);
+
+var MutationObserver = global.MutationObserver || global.WebKitMutationObserver;
+var document = global.document;
+var process = global.process;
+var Promise = global.Promise;
+var microtask = safeGetBuiltIn('queueMicrotask');
+var notify, toggle, node, promise, then;
+
+// modern engines have queueMicrotask method
+if (!microtask) {
+  var queue = new Queue();
+
+  var flush = function () {
+    var parent, fn;
+    if (IS_NODE && (parent = process.domain)) parent.exit();
+    while (fn = queue.get()) try {
+      fn();
+    } catch (error) {
+      if (queue.head) notify();
+      throw error;
+    }
+    if (parent) parent.enter();
+  };
+
+  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
+  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
+  if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {
+    toggle = true;
+    node = document.createTextNode('');
+    new MutationObserver(flush).observe(node, { characterData: true });
+    notify = function () {
+      node.data = toggle = !toggle;
+    };
+  // environments with maybe non-completely correct, but existent Promise
+  } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {
+    // Promise.resolve without an argument throws an error in LG WebOS 2
+    promise = Promise.resolve(undefined);
+    // workaround of WebKit ~ iOS Safari 10.1 bug
+    promise.constructor = Promise;
+    then = bind(promise.then, promise);
+    notify = function () {
+      then(flush);
+    };
+  // Node.js without promises
+  } else if (IS_NODE) {
+    notify = function () {
+      process.nextTick(flush);
+    };
+  // for other environments - macrotask based on:
+  // - setImmediate
+  // - MessageChannel
+  // - window.postMessage
+  // - onreadystatechange
+  // - setTimeout
+  } else {
+    // `webpack` dev server bug on IE global methods - use bind(fn, global)
+    macrotask = bind(macrotask, global);
+    notify = function () {
+      macrotask(flush);
+    };
+  }
+
+  microtask = function (fn) {
+    if (!queue.head) notify();
+    queue.add(fn);
+  };
+}
+
+module.exports = microtask;
+
+
+/***/ }),
+
+/***/ 6043:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var aCallable = __webpack_require__(9306);
+
+var $TypeError = TypeError;
+
+var PromiseCapability = function (C) {
+  var resolve, reject;
+  this.promise = new C(function ($$resolve, $$reject) {
+    if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');
+    resolve = $$resolve;
+    reject = $$reject;
+  });
+  this.resolve = aCallable(resolve);
+  this.reject = aCallable(reject);
+};
+
+// `NewPromiseCapability` abstract operation
+// https://tc39.es/ecma262/#sec-newpromisecapability
+module.exports.f = function (C) {
+  return new PromiseCapability(C);
+};
+
+
 /***/ }),
 
 /***/ 2603:
@@ -3805,6 +4012,127 @@ var global = __webpack_require__(4475);
 module.exports = global;
 
 
+/***/ }),
+
+/***/ 1103:
+/***/ (function(module) {
+
+"use strict";
+
+module.exports = function (exec) {
+  try {
+    return { error: false, value: exec() };
+  } catch (error) {
+    return { error: true, value: error };
+  }
+};
+
+
+/***/ }),
+
+/***/ 916:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(4475);
+var NativePromiseConstructor = __webpack_require__(550);
+var isCallable = __webpack_require__(4901);
+var isForced = __webpack_require__(2796);
+var inspectSource = __webpack_require__(3706);
+var wellKnownSymbol = __webpack_require__(8227);
+var IS_BROWSER = __webpack_require__(7290);
+var IS_DENO = __webpack_require__(516);
+var IS_PURE = __webpack_require__(6395);
+var V8_VERSION = __webpack_require__(7388);
+
+var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+var SPECIES = wellKnownSymbol('species');
+var SUBCLASSING = false;
+var NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);
+
+var FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {
+  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);
+  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);
+  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+  // We can't detect it synchronously, so just check versions
+  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
+  // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution
+  if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;
+  // We can't use @@species feature detection in V8 since it causes
+  // deoptimization and performance degradation
+  // https://github.com/zloirock/core-js/issues/679
+  if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
+    // Detect correctness of subclassing with @@species support
+    var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });
+    var FakePromise = function (exec) {
+      exec(function () { /* empty */ }, function () { /* empty */ });
+    };
+    var constructor = promise.constructor = {};
+    constructor[SPECIES] = FakePromise;
+    SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
+    if (!SUBCLASSING) return true;
+  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+  } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;
+});
+
+module.exports = {
+  CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,
+  REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,
+  SUBCLASSING: SUBCLASSING
+};
+
+
+/***/ }),
+
+/***/ 550:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(4475);
+
+module.exports = global.Promise;
+
+
+/***/ }),
+
+/***/ 3438:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var anObject = __webpack_require__(8551);
+var isObject = __webpack_require__(34);
+var newPromiseCapability = __webpack_require__(6043);
+
+module.exports = function (C, x) {
+  anObject(C);
+  if (isObject(x) && x.constructor === C) return x;
+  var promiseCapability = newPromiseCapability.f(C);
+  var resolve = promiseCapability.resolve;
+  resolve(x);
+  return promiseCapability.promise;
+};
+
+
+/***/ }),
+
+/***/ 537:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var NativePromiseConstructor = __webpack_require__(550);
+var checkCorrectnessOfIteration = __webpack_require__(4428);
+var FORCED_PROMISE_CONSTRUCTOR = (__webpack_require__(916).CONSTRUCTOR);
+
+module.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {
+  NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });
+});
+
+
 /***/ }),
 
 /***/ 1056:
@@ -3823,6 +4151,39 @@ module.exports = function (Target, Source, key) {
 };
 
 
+/***/ }),
+
+/***/ 8265:
+/***/ (function(module) {
+
+"use strict";
+
+var Queue = function () {
+  this.head = null;
+  this.tail = null;
+};
+
+Queue.prototype = {
+  add: function (item) {
+    var entry = { item: item, next: null };
+    var tail = this.tail;
+    if (tail) tail.next = entry;
+    else this.head = entry;
+    this.tail = entry;
+  },
+  get: function () {
+    var entry = this.head;
+    if (entry) {
+      var next = this.head = entry.next;
+      if (next === null) this.tail = null;
+      return entry.item;
+    }
+  }
+};
+
+module.exports = Queue;
+
+
 /***/ }),
 
 /***/ 6682:
@@ -4733,6 +5094,131 @@ var NATIVE_SYMBOL = __webpack_require__(4495);
 module.exports = NATIVE_SYMBOL && !!Symbol['for'] && !!Symbol.keyFor;
 
 
+/***/ }),
+
+/***/ 9225:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var global = __webpack_require__(4475);
+var apply = __webpack_require__(8745);
+var bind = __webpack_require__(6080);
+var isCallable = __webpack_require__(4901);
+var hasOwn = __webpack_require__(9297);
+var fails = __webpack_require__(9039);
+var html = __webpack_require__(397);
+var arraySlice = __webpack_require__(7680);
+var createElement = __webpack_require__(4055);
+var validateArgumentsLength = __webpack_require__(2812);
+var IS_IOS = __webpack_require__(8119);
+var IS_NODE = __webpack_require__(9088);
+
+var set = global.setImmediate;
+var clear = global.clearImmediate;
+var process = global.process;
+var Dispatch = global.Dispatch;
+var Function = global.Function;
+var MessageChannel = global.MessageChannel;
+var String = global.String;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var $location, defer, channel, port;
+
+fails(function () {
+  // Deno throws a ReferenceError on `location` access without `--location` flag
+  $location = global.location;
+});
+
+var run = function (id) {
+  if (hasOwn(queue, id)) {
+    var fn = queue[id];
+    delete queue[id];
+    fn();
+  }
+};
+
+var runner = function (id) {
+  return function () {
+    run(id);
+  };
+};
+
+var eventListener = function (event) {
+  run(event.data);
+};
+
+var globalPostMessageDefer = function (id) {
+  // old engines have not location.origin
+  global.postMessage(String(id), $location.protocol + '//' + $location.host);
+};
+
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if (!set || !clear) {
+  set = function setImmediate(handler) {
+    validateArgumentsLength(arguments.length, 1);
+    var fn = isCallable(handler) ? handler : Function(handler);
+    var args = arraySlice(arguments, 1);
+    queue[++counter] = function () {
+      apply(fn, undefined, args);
+    };
+    defer(counter);
+    return counter;
+  };
+  clear = function clearImmediate(id) {
+    delete queue[id];
+  };
+  // Node.js 0.8-
+  if (IS_NODE) {
+    defer = function (id) {
+      process.nextTick(runner(id));
+    };
+  // Sphere (JS game engine) Dispatch API
+  } else if (Dispatch && Dispatch.now) {
+    defer = function (id) {
+      Dispatch.now(runner(id));
+    };
+  // Browsers with MessageChannel, includes WebWorkers
+  // except iOS - https://github.com/zloirock/core-js/issues/624
+  } else if (MessageChannel && !IS_IOS) {
+    channel = new MessageChannel();
+    port = channel.port2;
+    channel.port1.onmessage = eventListener;
+    defer = bind(port.postMessage, port);
+  // Browsers with postMessage, skip WebWorkers
+  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+  } else if (
+    global.addEventListener &&
+    isCallable(global.postMessage) &&
+    !global.importScripts &&
+    $location && $location.protocol !== 'file:' &&
+    !fails(globalPostMessageDefer)
+  ) {
+    defer = globalPostMessageDefer;
+    global.addEventListener('message', eventListener, false);
+  // IE8-
+  } else if (ONREADYSTATECHANGE in createElement('script')) {
+    defer = function (id) {
+      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
+        html.removeChild(this);
+        run(id);
+      };
+    };
+  // Rest old browsers
+  } else {
+    defer = function (id) {
+      setTimeout(runner(id), 0);
+    };
+  }
+}
+
+module.exports = {
+  set: set,
+  clear: clear
+};
+
+
 /***/ }),
 
 /***/ 1240:
@@ -6412,6 +6898,24 @@ $({ target: 'Number', proto: true, forced: FORCED }, {
 });
 
 
+/***/ }),
+
+/***/ 9085:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var assign = __webpack_require__(4213);
+
+// `Object.assign` method
+// https://tc39.es/ecma262/#sec-object.assign
+// eslint-disable-next-line es/no-object-assign -- required for testing
+$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
+  assign: assign
+});
+
+
 /***/ }),
 
 /***/ 3851:
@@ -6537,6 +7041,533 @@ if (!TO_STRING_TAG_SUPPORT) {
 }
 
 
+/***/ }),
+
+/***/ 6499:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var call = __webpack_require__(9565);
+var aCallable = __webpack_require__(9306);
+var newPromiseCapabilityModule = __webpack_require__(6043);
+var perform = __webpack_require__(1103);
+var iterate = __webpack_require__(2652);
+var PROMISE_STATICS_INCORRECT_ITERATION = __webpack_require__(537);
+
+// `Promise.all` method
+// https://tc39.es/ecma262/#sec-promise.all
+$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+  all: function all(iterable) {
+    var C = this;
+    var capability = newPromiseCapabilityModule.f(C);
+    var resolve = capability.resolve;
+    var reject = capability.reject;
+    var result = perform(function () {
+      var $promiseResolve = aCallable(C.resolve);
+      var values = [];
+      var counter = 0;
+      var remaining = 1;
+      iterate(iterable, function (promise) {
+        var index = counter++;
+        var alreadyCalled = false;
+        remaining++;
+        call($promiseResolve, C, promise).then(function (value) {
+          if (alreadyCalled) return;
+          alreadyCalled = true;
+          values[index] = value;
+          --remaining || resolve(values);
+        }, reject);
+      });
+      --remaining || resolve(values);
+    });
+    if (result.error) reject(result.value);
+    return capability.promise;
+  }
+});
+
+
+/***/ }),
+
+/***/ 2003:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var IS_PURE = __webpack_require__(6395);
+var FORCED_PROMISE_CONSTRUCTOR = (__webpack_require__(916).CONSTRUCTOR);
+var NativePromiseConstructor = __webpack_require__(550);
+var getBuiltIn = __webpack_require__(7751);
+var isCallable = __webpack_require__(4901);
+var defineBuiltIn = __webpack_require__(6840);
+
+var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+
+// `Promise.prototype.catch` method
+// https://tc39.es/ecma262/#sec-promise.prototype.catch
+$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {
+  'catch': function (onRejected) {
+    return this.then(undefined, onRejected);
+  }
+});
+
+// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
+if (!IS_PURE && isCallable(NativePromiseConstructor)) {
+  var method = getBuiltIn('Promise').prototype['catch'];
+  if (NativePromisePrototype['catch'] !== method) {
+    defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });
+  }
+}
+
+
+/***/ }),
+
+/***/ 436:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var IS_PURE = __webpack_require__(6395);
+var IS_NODE = __webpack_require__(9088);
+var global = __webpack_require__(4475);
+var call = __webpack_require__(9565);
+var defineBuiltIn = __webpack_require__(6840);
+var setPrototypeOf = __webpack_require__(2967);
+var setToStringTag = __webpack_require__(687);
+var setSpecies = __webpack_require__(7633);
+var aCallable = __webpack_require__(9306);
+var isCallable = __webpack_require__(4901);
+var isObject = __webpack_require__(34);
+var anInstance = __webpack_require__(679);
+var speciesConstructor = __webpack_require__(2293);
+var task = (__webpack_require__(9225).set);
+var microtask = __webpack_require__(1955);
+var hostReportErrors = __webpack_require__(3138);
+var perform = __webpack_require__(1103);
+var Queue = __webpack_require__(8265);
+var InternalStateModule = __webpack_require__(1181);
+var NativePromiseConstructor = __webpack_require__(550);
+var PromiseConstructorDetection = __webpack_require__(916);
+var newPromiseCapabilityModule = __webpack_require__(6043);
+
+var PROMISE = 'Promise';
+var FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;
+var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
+var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
+var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+var setInternalState = InternalStateModule.set;
+var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+var PromiseConstructor = NativePromiseConstructor;
+var PromisePrototype = NativePromisePrototype;
+var TypeError = global.TypeError;
+var document = global.document;
+var process = global.process;
+var newPromiseCapability = newPromiseCapabilityModule.f;
+var newGenericPromiseCapability = newPromiseCapability;
+
+var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);
+var UNHANDLED_REJECTION = 'unhandledrejection';
+var REJECTION_HANDLED = 'rejectionhandled';
+var PENDING = 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+var HANDLED = 1;
+var UNHANDLED = 2;
+
+var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
+
+// helpers
+var isThenable = function (it) {
+  var then;
+  return isObject(it) && isCallable(then = it.then) ? then : false;
+};
+
+var callReaction = function (reaction, state) {
+  var value = state.value;
+  var ok = state.state === FULFILLED;
+  var handler = ok ? reaction.ok : reaction.fail;
+  var resolve = reaction.resolve;
+  var reject = reaction.reject;
+  var domain = reaction.domain;
+  var result, then, exited;
+  try {
+    if (handler) {
+      if (!ok) {
+        if (state.rejection === UNHANDLED) onHandleUnhandled(state);
+        state.rejection = HANDLED;
+      }
+      if (handler === true) result = value;
+      else {
+        if (domain) domain.enter();
+        result = handler(value); // can throw
+        if (domain) {
+          domain.exit();
+          exited = true;
+        }
+      }
+      if (result === reaction.promise) {
+        reject(new TypeError('Promise-chain cycle'));
+      } else if (then = isThenable(result)) {
+        call(then, result, resolve, reject);
+      } else resolve(result);
+    } else reject(value);
+  } catch (error) {
+    if (domain && !exited) domain.exit();
+    reject(error);
+  }
+};
+
+var notify = function (state, isReject) {
+  if (state.notified) return;
+  state.notified = true;
+  microtask(function () {
+    var reactions = state.reactions;
+    var reaction;
+    while (reaction = reactions.get()) {
+      callReaction(reaction, state);
+    }
+    state.notified = false;
+    if (isReject && !state.rejection) onUnhandled(state);
+  });
+};
+
+var dispatchEvent = function (name, promise, reason) {
+  var event, handler;
+  if (DISPATCH_EVENT) {
+    event = document.createEvent('Event');
+    event.promise = promise;
+    event.reason = reason;
+    event.initEvent(name, false, true);
+    global.dispatchEvent(event);
+  } else event = { promise: promise, reason: reason };
+  if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);
+  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
+};
+
+var onUnhandled = function (state) {
+  call(task, global, function () {
+    var promise = state.facade;
+    var value = state.value;
+    var IS_UNHANDLED = isUnhandled(state);
+    var result;
+    if (IS_UNHANDLED) {
+      result = perform(function () {
+        if (IS_NODE) {
+          process.emit('unhandledRejection', value, promise);
+        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
+      });
+      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
+      if (result.error) throw result.value;
+    }
+  });
+};
+
+var isUnhandled = function (state) {
+  return state.rejection !== HANDLED && !state.parent;
+};
+
+var onHandleUnhandled = function (state) {
+  call(task, global, function () {
+    var promise = state.facade;
+    if (IS_NODE) {
+      process.emit('rejectionHandled', promise);
+    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
+  });
+};
+
+var bind = function (fn, state, unwrap) {
+  return function (value) {
+    fn(state, value, unwrap);
+  };
+};
+
+var internalReject = function (state, value, unwrap) {
+  if (state.done) return;
+  state.done = true;
+  if (unwrap) state = unwrap;
+  state.value = value;
+  state.state = REJECTED;
+  notify(state, true);
+};
+
+var internalResolve = function (state, value, unwrap) {
+  if (state.done) return;
+  state.done = true;
+  if (unwrap) state = unwrap;
+  try {
+    if (state.facade === value) throw new TypeError("Promise can't be resolved itself");
+    var then = isThenable(value);
+    if (then) {
+      microtask(function () {
+        var wrapper = { done: false };
+        try {
+          call(then, value,
+            bind(internalResolve, wrapper, state),
+            bind(internalReject, wrapper, state)
+          );
+        } catch (error) {
+          internalReject(wrapper, error, state);
+        }
+      });
+    } else {
+      state.value = value;
+      state.state = FULFILLED;
+      notify(state, false);
+    }
+  } catch (error) {
+    internalReject({ done: false }, error, state);
+  }
+};
+
+// constructor polyfill
+if (FORCED_PROMISE_CONSTRUCTOR) {
+  // 25.4.3.1 Promise(executor)
+  PromiseConstructor = function Promise(executor) {
+    anInstance(this, PromisePrototype);
+    aCallable(executor);
+    call(Internal, this);
+    var state = getInternalPromiseState(this);
+    try {
+      executor(bind(internalResolve, state), bind(internalReject, state));
+    } catch (error) {
+      internalReject(state, error);
+    }
+  };
+
+  PromisePrototype = PromiseConstructor.prototype;
+
+  // eslint-disable-next-line no-unused-vars -- required for `.length`
+  Internal = function Promise(executor) {
+    setInternalState(this, {
+      type: PROMISE,
+      done: false,
+      notified: false,
+      parent: false,
+      reactions: new Queue(),
+      rejection: false,
+      state: PENDING,
+      value: undefined
+    });
+  };
+
+  // `Promise.prototype.then` method
+  // https://tc39.es/ecma262/#sec-promise.prototype.then
+  Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
+    var state = getInternalPromiseState(this);
+    var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
+    state.parent = true;
+    reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;
+    reaction.fail = isCallable(onRejected) && onRejected;
+    reaction.domain = IS_NODE ? process.domain : undefined;
+    if (state.state === PENDING) state.reactions.add(reaction);
+    else microtask(function () {
+      callReaction(reaction, state);
+    });
+    return reaction.promise;
+  });
+
+  OwnPromiseCapability = function () {
+    var promise = new Internal();
+    var state = getInternalPromiseState(promise);
+    this.promise = promise;
+    this.resolve = bind(internalResolve, state);
+    this.reject = bind(internalReject, state);
+  };
+
+  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+    return C === PromiseConstructor || C === PromiseWrapper
+      ? new OwnPromiseCapability(C)
+      : newGenericPromiseCapability(C);
+  };
+
+  if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {
+    nativeThen = NativePromisePrototype.then;
+
+    if (!NATIVE_PROMISE_SUBCLASSING) {
+      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
+      defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
+        var that = this;
+        return new PromiseConstructor(function (resolve, reject) {
+          call(nativeThen, that, resolve, reject);
+        }).then(onFulfilled, onRejected);
+      // https://github.com/zloirock/core-js/issues/640
+      }, { unsafe: true });
+    }
+
+    // make `.constructor === Promise` work for native promise-based APIs
+    try {
+      delete NativePromisePrototype.constructor;
+    } catch (error) { /* empty */ }
+
+    // make `instanceof Promise` work for native promise-based APIs
+    if (setPrototypeOf) {
+      setPrototypeOf(NativePromisePrototype, PromisePrototype);
+    }
+  }
+}
+
+$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+  Promise: PromiseConstructor
+});
+
+setToStringTag(PromiseConstructor, PROMISE, false, true);
+setSpecies(PROMISE);
+
+
+/***/ }),
+
+/***/ 9391:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var IS_PURE = __webpack_require__(6395);
+var NativePromiseConstructor = __webpack_require__(550);
+var fails = __webpack_require__(9039);
+var getBuiltIn = __webpack_require__(7751);
+var isCallable = __webpack_require__(4901);
+var speciesConstructor = __webpack_require__(2293);
+var promiseResolve = __webpack_require__(3438);
+var defineBuiltIn = __webpack_require__(6840);
+
+var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+
+// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829
+var NON_GENERIC = !!NativePromiseConstructor && fails(function () {
+  // eslint-disable-next-line unicorn/no-thenable -- required for testing
+  NativePromisePrototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });
+});
+
+// `Promise.prototype.finally` method
+// https://tc39.es/ecma262/#sec-promise.prototype.finally
+$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {
+  'finally': function (onFinally) {
+    var C = speciesConstructor(this, getBuiltIn('Promise'));
+    var isFunction = isCallable(onFinally);
+    return this.then(
+      isFunction ? function (x) {
+        return promiseResolve(C, onFinally()).then(function () { return x; });
+      } : onFinally,
+      isFunction ? function (e) {
+        return promiseResolve(C, onFinally()).then(function () { throw e; });
+      } : onFinally
+    );
+  }
+});
+
+// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`
+if (!IS_PURE && isCallable(NativePromiseConstructor)) {
+  var method = getBuiltIn('Promise').prototype['finally'];
+  if (NativePromisePrototype['finally'] !== method) {
+    defineBuiltIn(NativePromisePrototype, 'finally', method, { unsafe: true });
+  }
+}
+
+
+/***/ }),
+
+/***/ 3362:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+// TODO: Remove this module from `core-js@4` since it's split to modules listed below
+__webpack_require__(436);
+__webpack_require__(6499);
+__webpack_require__(2003);
+__webpack_require__(7743);
+__webpack_require__(1481);
+__webpack_require__(280);
+
+
+/***/ }),
+
+/***/ 7743:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var call = __webpack_require__(9565);
+var aCallable = __webpack_require__(9306);
+var newPromiseCapabilityModule = __webpack_require__(6043);
+var perform = __webpack_require__(1103);
+var iterate = __webpack_require__(2652);
+var PROMISE_STATICS_INCORRECT_ITERATION = __webpack_require__(537);
+
+// `Promise.race` method
+// https://tc39.es/ecma262/#sec-promise.race
+$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+  race: function race(iterable) {
+    var C = this;
+    var capability = newPromiseCapabilityModule.f(C);
+    var reject = capability.reject;
+    var result = perform(function () {
+      var $promiseResolve = aCallable(C.resolve);
+      iterate(iterable, function (promise) {
+        call($promiseResolve, C, promise).then(capability.resolve, reject);
+      });
+    });
+    if (result.error) reject(result.value);
+    return capability.promise;
+  }
+});
+
+
+/***/ }),
+
+/***/ 1481:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var newPromiseCapabilityModule = __webpack_require__(6043);
+var FORCED_PROMISE_CONSTRUCTOR = (__webpack_require__(916).CONSTRUCTOR);
+
+// `Promise.reject` method
+// https://tc39.es/ecma262/#sec-promise.reject
+$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+  reject: function reject(r) {
+    var capability = newPromiseCapabilityModule.f(this);
+    var capabilityReject = capability.reject;
+    capabilityReject(r);
+    return capability.promise;
+  }
+});
+
+
+/***/ }),
+
+/***/ 280:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var getBuiltIn = __webpack_require__(7751);
+var IS_PURE = __webpack_require__(6395);
+var NativePromiseConstructor = __webpack_require__(550);
+var FORCED_PROMISE_CONSTRUCTOR = (__webpack_require__(916).CONSTRUCTOR);
+var promiseResolve = __webpack_require__(3438);
+
+var PromiseConstructorWrapper = getBuiltIn('Promise');
+var CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;
+
+// `Promise.resolve` method
+// https://tc39.es/ecma262/#sec-promise.resolve
+$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {
+  resolve: function resolve(x) {
+    return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);
+  }
+});
+
+
 /***/ }),
 
 /***/ 4864:
@@ -10243,10 +11274,6 @@ var iconPrefix = 'vxe-icon-';
     // export: {
     //   types: ['csv', 'html', 'xml', 'txt']
     // },
-    custom: {
-      allowFixed: true,
-      showFooter: true
-    }
     // buttons: []
   },
   button: {
@@ -10319,7 +11346,7 @@ var es_array_concat = __webpack_require__(8706);
 
 
 function getLog(message, params) {
-  return "[vxe-table v".concat("3.8.0-beta.5", "] ").concat(conf.i18n(message, params));
+  return "[vxe-table v".concat("3.8.0-beta.7", "] ").concat(conf.i18n(message, params));
 }
 function outLog(type) {
   return function (message, params) {
@@ -12040,7 +13067,7 @@ var setup = config;
 var globalStore = {};
 var VXETable = {
   v: v,
-  version: "3.8.0-beta.5",
+  version: "3.8.0-beta.7",
   reg: reg,
   use: use,
   setup: setup,
@@ -12064,8 +13091,12 @@ var VXETable = {
 
 
 /* harmony default export */ var v_x_e_table = (VXETable);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.iterator.js
+var es_array_iterator = __webpack_require__(3792);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.map.js
 var es_map = __webpack_require__(6033);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.assign.js
+var es_object_assign = __webpack_require__(9085);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.fixed.js
 var es_string_fixed = __webpack_require__(4298);
 ;// CONCATENATED MODULE: ./packages/table/src/columnInfo.js
@@ -14609,6 +15640,10 @@ function _slicedToArray(arr, i) {
 }
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.sort.js
 var es_array_sort = __webpack_require__(6910);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.js
+var es_promise = __webpack_require__(3362);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.finally.js
+var es_promise_finally = __webpack_require__(9391);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.trim.js
 var es_string_trim = __webpack_require__(2762);
 ;// CONCATENATED MODULE: ./packages/table/src/cell.js
@@ -15495,6 +16530,10 @@ var Cell = {
 
 
 
+
+
+
+
 
 
 
@@ -18705,12 +19744,13 @@ var Methods = {
     if (tipContent) {
       var $refs = this.$refs,
         tooltipStore = this.tooltipStore;
+      var column = params.column;
       var content = getFuncText(tipContent);
       this.handleTargetEnterEvent(true);
+      tooltipStore.row = null;
+      tooltipStore.column = column;
       tooltipStore.visible = true;
-      tooltipStore.currOpts = _objectSpread2(_objectSpread2({}, params), {}, {
-        content: null
-      });
+      // tooltipStore.currOpts = { content: null }
       this.$nextTick(function () {
         var $tooltip = $refs.tooltip;
         if ($tooltip) {
@@ -18805,8 +19845,7 @@ var Methods = {
       Object.assign(tooltipStore, {
         row: row,
         column: column,
-        visible: true,
-        currOpts: null
+        visible: true
       });
       this.$nextTick(function () {
         var $tooltip = $refs.tooltip;
@@ -18838,8 +19877,7 @@ var Methods = {
         row: null,
         column: null,
         content: null,
-        visible: false,
-        currOpts: null
+        visible: false
       });
       if (tooltip) {
         tooltip.close();
@@ -21728,6 +22766,8 @@ var Loading = (/* unused pure expression or super */ null && (VxeLoading));
 
 
 
+
+
 
 
 
@@ -22263,8 +23303,7 @@ function handleUupdateResize(_vm) {
       tooltipStore: {
         row: null,
         column: null,
-        visible: false,
-        currOpts: null
+        visible: false
       },
       // 存放数据校验相关信息
       validStore: {
@@ -22363,7 +23402,7 @@ function handleUupdateResize(_vm) {
       return Object.assign({}, conf.tooltip, conf.table.tooltipConfig, this.tooltipConfig);
     },
     tipConfig: function tipConfig() {
-      return _objectSpread2(_objectSpread2({}, this.tooltipOpts), this.tooltipStore.currOpts);
+      return _objectSpread2({}, this.tooltipOpts);
     },
     validTipOpts: function validTipOpts() {
       return Object.assign({
@@ -33388,6 +34427,7 @@ function renderSimplePanel(h, _vm) {
     isMaxFixedColumn = $xetable.isMaxFixedColumn;
   var maxHeight = customStore.maxHeight;
   var checkMethod = customOpts.checkMethod,
+    visibleMethod = customOpts.visibleMethod,
     trigger = customOpts.trigger;
   var colVNs = [];
   var customWrapperOns = {};
@@ -33397,16 +34437,19 @@ function renderSimplePanel(h, _vm) {
     customWrapperOns.onMouseleave = _vm.handleWrapperMouseleaveEvent;
   }
   external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(collectColumn, function (column, index, items, path, parent) {
-    var colTitle = utils.formatText(column.getTitle(), 1);
-    var colKey = column.getKey();
-    var isColGroup = column.children && column.children.length;
-    var isDisabled = checkMethod ? !checkMethod({
+    var isVisible = visibleMethod ? visibleMethod({
       column: column
-    }) : false;
-    if (isColGroup || colKey) {
+    }) : true;
+    if (isVisible) {
       var isChecked = column.visible;
       var isIndeterminate = column.halfVisible;
+      var colTitle = utils.formatText(column.getTitle(), 1);
+      var isColGroup = column.children && column.children.length;
+      var isDisabled = checkMethod ? !checkMethod({
+        column: column
+      }) : false;
       colVNs.push(h('li', {
+        key: column.id,
         class: ['vxe-table-custom--option', "level--".concat(column.level), {
           'is--group': isColGroup
         }]
@@ -33512,20 +34555,26 @@ var renderPopupPanel = function renderPopupPanel(h, _vm) {
   var customOpts = $xetable.customOpts,
     collectColumn = $xetable.collectColumn,
     isMaxFixedColumn = $xetable.isMaxFixedColumn;
-  var checkMethod = customOpts.checkMethod;
+  var checkMethod = customOpts.checkMethod,
+    visibleMethod = customOpts.visibleMethod;
   var trVNs = [];
   external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(collectColumn, function (column, index, items, path, parent) {
-    var colTitle = utils.formatText(column.getTitle(), 1);
-    var colKey = column.getKey();
-    var isColGroup = column.children && column.children.length;
-    var isDisabled = checkMethod ? !checkMethod({
+    var isVisible = visibleMethod ? visibleMethod({
       column: column
-    }) : false;
-    if (isColGroup || colKey) {
+    }) : true;
+    if (isVisible) {
       var isChecked = column.visible;
       var isIndeterminate = column.halfVisible;
+      var colTitle = utils.formatText(column.getTitle(), 1);
+      var isColGroup = column.children && column.children.length;
+      var isDisabled = checkMethod ? !checkMethod({
+        column: column
+      }) : false;
       trVNs.push(h('tr', {
-        class: ["vxe-table-custom-popup--row-level".concat(column.level)]
+        key: column.id,
+        class: ["vxe-table-custom-popup--row-level".concat(column.level), {
+          'is--group': isColGroup
+        }]
       }, [h('td', {
         class: 'vxe-table-custom-popup--column-name'
       }, [h('div', {
@@ -35260,6 +36309,8 @@ var Grid = VxeGrid;
 
 
 
+
+
 var renderDropdowns = function renderDropdowns(h, _vm, item, isBtn) {
   var _e = _vm._e;
   var dropdowns = item.dropdowns;
@@ -37588,6 +38639,7 @@ var Modal = VxeModal;
 
 
 
+
 function updateTipStyle(_vm) {
   var wrapperElem = _vm.$el,
     tipTarget = _vm.tipTarget,
@@ -37786,9 +38838,6 @@ function renderContent(h, _vm) {
       target = this.target,
       trigger = this.trigger;
     var parentNode = $el.parentNode;
-    if (parentNode) {
-      parentNode.removeChild($el);
-    }
     if (target) {
       if (trigger === 'hover') {
         target.onmouseenter = null;
@@ -37797,6 +38846,9 @@ function renderContent(h, _vm) {
         target.onclick = null;
       }
     }
+    if (parentNode) {
+      parentNode.removeChild($el);
+    }
   },
   render: function render(h) {
     var $scopedSlots = this.$scopedSlots,