vxe-table 3.4.3-beta.0 → 3.4.6

package/lib/index.umd.js

@@ -783,6 +783,16 @@ module.exports = function (exec, SKIP_CLOSING) {
 };
 
 
+/***/ }),
+
+/***/ "1cdc":
+/***/ (function(module, exports, __webpack_require__) {
+
+var userAgent = __webpack_require__("342f");
+
+module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
+
+
 /***/ }),
 
 /***/ "1d80":
@@ -2115,6 +2125,126 @@ $({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, {
 });
 
 
+/***/ }),
+
+/***/ "2cf4":
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__("da84");
+var isCallable = __webpack_require__("1626");
+var fails = __webpack_require__("d039");
+var bind = __webpack_require__("0366");
+var html = __webpack_require__("1be4");
+var createElement = __webpack_require__("cc12");
+var IS_IOS = __webpack_require__("1cdc");
+var IS_NODE = __webpack_require__("605d");
+
+var set = global.setImmediate;
+var clear = global.clearImmediate;
+var process = global.process;
+var MessageChannel = global.MessageChannel;
+var Dispatch = global.Dispatch;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var location, defer, channel, port;
+
+try {
+  // Deno throws a ReferenceError on `location` access without `--location` flag
+  location = global.location;
+} catch (error) { /* empty */ }
+
+var run = function (id) {
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  if (queue.hasOwnProperty(id)) {
+    var fn = queue[id];
+    delete queue[id];
+    fn();
+  }
+};
+
+var runner = function (id) {
+  return function () {
+    run(id);
+  };
+};
+
+var listener = function (event) {
+  run(event.data);
+};
+
+var post = 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(fn) {
+    var args = [];
+    var argumentsLength = arguments.length;
+    var i = 1;
+    while (argumentsLength > i) args.push(arguments[i++]);
+    queue[++counter] = function () {
+      // eslint-disable-next-line no-new-func -- spec requirement
+      (isCallable(fn) ? fn : Function(fn)).apply(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 = listener;
+    defer = bind(port.postMessage, port, 1);
+  // 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(post)
+  ) {
+    defer = post;
+    global.addEventListener('message', listener, 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
+};
+
+
 /***/ }),
 
 /***/ "2d00":
@@ -2341,6 +2471,21 @@ module.exports = function (key) {
 };
 
 
+/***/ }),
+
+/***/ "44de":
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__("da84");
+
+module.exports = function (a, b) {
+  var console = global.console;
+  if (console && console.error) {
+    arguments.length === 1 ? console.error(a) : console.error(a, b);
+  }
+};
+
+
 /***/ }),
 
 /***/ "44e7":
@@ -3484,6 +3629,25 @@ module.exports = function (input) {
 };
 
 
+/***/ }),
+
+/***/ "605d":
+/***/ (function(module, exports, __webpack_require__) {
+
+var classof = __webpack_require__("c6b6");
+var global = __webpack_require__("da84");
+
+module.exports = classof(global.process) == 'process';
+
+
+/***/ }),
+
+/***/ "6069":
+/***/ (function(module, exports) {
+
+module.exports = typeof window == 'object';
+
+
 /***/ }),
 
 /***/ "60da":
@@ -5490,6 +5654,16 @@ $({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
 });
 
 
+/***/ }),
+
+/***/ "a4b4":
+/***/ (function(module, exports, __webpack_require__) {
+
+var userAgent = __webpack_require__("342f");
+
+module.exports = /web0s(?!.*chrome)/i.test(userAgent);
+
+
 /***/ }),
 
 /***/ "a4d3":
@@ -6173,6 +6347,96 @@ if (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {
 }
 
 
+/***/ }),
+
+/***/ "b575":
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__("da84");
+var getOwnPropertyDescriptor = __webpack_require__("06cf").f;
+var macrotask = __webpack_require__("2cf4").set;
+var IS_IOS = __webpack_require__("1cdc");
+var IS_IOS_PEBBLE = __webpack_require__("d4c3");
+var IS_WEBOS_WEBKIT = __webpack_require__("a4b4");
+var IS_NODE = __webpack_require__("605d");
+
+var MutationObserver = global.MutationObserver || global.WebKitMutationObserver;
+var document = global.document;
+var process = global.process;
+var Promise = global.Promise;
+// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
+var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');
+var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
+
+var flush, head, last, notify, toggle, node, promise, then;
+
+// modern engines have queueMicrotask method
+if (!queueMicrotask) {
+  flush = function () {
+    var parent, fn;
+    if (IS_NODE && (parent = process.domain)) parent.exit();
+    while (head) {
+      fn = head.fn;
+      head = head.next;
+      try {
+        fn();
+      } catch (error) {
+        if (head) notify();
+        else last = undefined;
+        throw error;
+      }
+    } last = undefined;
+    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 = promise.then;
+    notify = function () {
+      then.call(promise, flush);
+    };
+  // Node.js without promises
+  } else if (IS_NODE) {
+    notify = function () {
+      process.nextTick(flush);
+    };
+  // for other environments - macrotask based on:
+  // - setImmediate
+  // - MessageChannel
+  // - window.postMessag
+  // - onreadystatechange
+  // - setTimeout
+  } else {
+    notify = function () {
+      // strange IE + webpack dev server bug - use .call(global)
+      macrotask.call(global, flush);
+    };
+  }
+}
+
+module.exports = queueMicrotask || function (fn) {
+  var task = { fn: fn, next: undefined };
+  if (last) last.next = task;
+  if (!head) {
+    head = task;
+    notify();
+  } last = task;
+};
+
+
 /***/ }),
 
 /***/ "b622":
@@ -6643,6 +6907,41 @@ module.exports = function (it) {
 };
 
 
+/***/ }),
+
+/***/ "cca6":
+/***/ (function(module, exports, __webpack_require__) {
+
+var $ = __webpack_require__("23e7");
+var assign = __webpack_require__("60da");
+
+// `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, forced: Object.assign !== assign }, {
+  assign: assign
+});
+
+
+/***/ }),
+
+/***/ "cdf9":
+/***/ (function(module, exports, __webpack_require__) {
+
+var anObject = __webpack_require__("825a");
+var isObject = __webpack_require__("861d");
+var newPromiseCapability = __webpack_require__("f069");
+
+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;
+};
+
+
 /***/ }),
 
 /***/ "ce4e":
@@ -6800,6 +7099,17 @@ module.exports = function (it, TAG, STATIC) {
 };
 
 
+/***/ }),
+
+/***/ "d4c3":
+/***/ (function(module, exports, __webpack_require__) {
+
+var userAgent = __webpack_require__("342f");
+var global = __webpack_require__("da84");
+
+module.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined;
+
+
 /***/ }),
 
 /***/ "d784":
@@ -7267,6 +7577,422 @@ var wellKnownSymbol = __webpack_require__("b622");
 exports.f = wellKnownSymbol;
 
 
+/***/ }),
+
+/***/ "e667":
+/***/ (function(module, exports) {
+
+module.exports = function (exec) {
+  try {
+    return { error: false, value: exec() };
+  } catch (error) {
+    return { error: true, value: error };
+  }
+};
+
+
+/***/ }),
+
+/***/ "e6cf":
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__("23e7");
+var IS_PURE = __webpack_require__("c430");
+var global = __webpack_require__("da84");
+var getBuiltIn = __webpack_require__("d066");
+var NativePromise = __webpack_require__("fea9");
+var redefine = __webpack_require__("6eeb");
+var redefineAll = __webpack_require__("e2cc");
+var setPrototypeOf = __webpack_require__("d2bb");
+var setToStringTag = __webpack_require__("d44e");
+var setSpecies = __webpack_require__("2626");
+var aCallable = __webpack_require__("59ed");
+var isCallable = __webpack_require__("1626");
+var isObject = __webpack_require__("861d");
+var anInstance = __webpack_require__("19aa");
+var inspectSource = __webpack_require__("8925");
+var iterate = __webpack_require__("2266");
+var checkCorrectnessOfIteration = __webpack_require__("1c7e");
+var speciesConstructor = __webpack_require__("4840");
+var task = __webpack_require__("2cf4").set;
+var microtask = __webpack_require__("b575");
+var promiseResolve = __webpack_require__("cdf9");
+var hostReportErrors = __webpack_require__("44de");
+var newPromiseCapabilityModule = __webpack_require__("f069");
+var perform = __webpack_require__("e667");
+var InternalStateModule = __webpack_require__("69f3");
+var isForced = __webpack_require__("94ca");
+var wellKnownSymbol = __webpack_require__("b622");
+var IS_BROWSER = __webpack_require__("6069");
+var IS_NODE = __webpack_require__("605d");
+var V8_VERSION = __webpack_require__("2d00");
+
+var SPECIES = wellKnownSymbol('species');
+var PROMISE = 'Promise';
+var getInternalState = InternalStateModule.get;
+var setInternalState = InternalStateModule.set;
+var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+var NativePromisePrototype = NativePromise && NativePromise.prototype;
+var PromiseConstructor = NativePromise;
+var PromiseConstructorPrototype = 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 NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);
+var UNHANDLED_REJECTION = 'unhandledrejection';
+var REJECTION_HANDLED = 'rejectionhandled';
+var PENDING = 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+var HANDLED = 1;
+var UNHANDLED = 2;
+var SUBCLASSING = false;
+var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
+
+var FORCED = isForced(PROMISE, function () {
+  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);
+  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);
+  // 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#finally in the pure version for preventing prototype pollution
+  if (IS_PURE && !PromiseConstructorPrototype['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 >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;
+  // Detect correctness of subclassing with @@species support
+  var promise = new PromiseConstructor(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 && !NATIVE_REJECTION_EVENT;
+});
+
+var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
+  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
+});
+
+// helpers
+var isThenable = function (it) {
+  var then;
+  return isObject(it) && isCallable(then = it.then) ? then : false;
+};
+
+var notify = function (state, isReject) {
+  if (state.notified) return;
+  state.notified = true;
+  var chain = state.reactions;
+  microtask(function () {
+    var value = state.value;
+    var ok = state.state == FULFILLED;
+    var index = 0;
+    // variable length - can't use forEach
+    while (chain.length > index) {
+      var reaction = chain[index++];
+      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(TypeError('Promise-chain cycle'));
+          } else if (then = isThenable(result)) {
+            then.call(result, resolve, reject);
+          } else resolve(result);
+        } else reject(value);
+      } catch (error) {
+        if (domain && !exited) domain.exit();
+        reject(error);
+      }
+    }
+    state.reactions = [];
+    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_REJECTION_EVENT && (handler = global['on' + name])) handler(event);
+  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
+};
+
+var onUnhandled = function (state) {
+  task.call(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) {
+  task.call(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 TypeError("Promise can't be resolved itself");
+    var then = isThenable(value);
+    if (then) {
+      microtask(function () {
+        var wrapper = { done: false };
+        try {
+          then.call(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) {
+  // 25.4.3.1 Promise(executor)
+  PromiseConstructor = function Promise(executor) {
+    anInstance(this, PromiseConstructor, PROMISE);
+    aCallable(executor);
+    Internal.call(this);
+    var state = getInternalState(this);
+    try {
+      executor(bind(internalResolve, state), bind(internalReject, state));
+    } catch (error) {
+      internalReject(state, error);
+    }
+  };
+  PromiseConstructorPrototype = 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: [],
+      rejection: false,
+      state: PENDING,
+      value: undefined
+    });
+  };
+  Internal.prototype = redefineAll(PromiseConstructorPrototype, {
+    // `Promise.prototype.then` method
+    // https://tc39.es/ecma262/#sec-promise.prototype.then
+    then: function then(onFulfilled, onRejected) {
+      var state = getInternalPromiseState(this);
+      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
+      reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;
+      reaction.fail = isCallable(onRejected) && onRejected;
+      reaction.domain = IS_NODE ? process.domain : undefined;
+      state.parent = true;
+      state.reactions.push(reaction);
+      if (state.state != PENDING) notify(state, false);
+      return reaction.promise;
+    },
+    // `Promise.prototype.catch` method
+    // https://tc39.es/ecma262/#sec-promise.prototype.catch
+    'catch': function (onRejected) {
+      return this.then(undefined, onRejected);
+    }
+  });
+  OwnPromiseCapability = function () {
+    var promise = new Internal();
+    var state = getInternalState(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(NativePromise) && NativePromisePrototype !== Object.prototype) {
+    nativeThen = NativePromisePrototype.then;
+
+    if (!SUBCLASSING) {
+      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
+      redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
+        var that = this;
+        return new PromiseConstructor(function (resolve, reject) {
+          nativeThen.call(that, resolve, reject);
+        }).then(onFulfilled, onRejected);
+      // https://github.com/zloirock/core-js/issues/640
+      }, { unsafe: true });
+
+      // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
+      redefine(NativePromisePrototype, 'catch', PromiseConstructorPrototype['catch'], { 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, PromiseConstructorPrototype);
+    }
+  }
+}
+
+$({ global: true, wrap: true, forced: FORCED }, {
+  Promise: PromiseConstructor
+});
+
+setToStringTag(PromiseConstructor, PROMISE, false, true);
+setSpecies(PROMISE);
+
+PromiseWrapper = getBuiltIn(PROMISE);
+
+// statics
+$({ target: PROMISE, stat: true, forced: FORCED }, {
+  // `Promise.reject` method
+  // https://tc39.es/ecma262/#sec-promise.reject
+  reject: function reject(r) {
+    var capability = newPromiseCapability(this);
+    capability.reject.call(undefined, r);
+    return capability.promise;
+  }
+});
+
+$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {
+  // `Promise.resolve` method
+  // https://tc39.es/ecma262/#sec-promise.resolve
+  resolve: function resolve(x) {
+    return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);
+  }
+});
+
+$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
+  // `Promise.all` method
+  // https://tc39.es/ecma262/#sec-promise.all
+  all: function all(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(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;
+        values.push(undefined);
+        remaining++;
+        $promiseResolve.call(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;
+  },
+  // `Promise.race` method
+  // https://tc39.es/ecma262/#sec-promise.race
+  race: function race(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(C);
+    var reject = capability.reject;
+    var result = perform(function () {
+      var $promiseResolve = aCallable(C.resolve);
+      iterate(iterable, function (promise) {
+        $promiseResolve.call(C, promise).then(capability.resolve, reject);
+      });
+    });
+    if (result.error) reject(result.value);
+    return capability.promise;
+  }
+});
+
+
 /***/ }),
 
 /***/ "e893":
@@ -7320,6 +8046,33 @@ module.exports = function (it) {
 };
 
 
+/***/ }),
+
+/***/ "f069":
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var aCallable = __webpack_require__("59ed");
+
+var PromiseCapability = function (C) {
+  var resolve, reject;
+  this.promise = new C(function ($$resolve, $$reject) {
+    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+    resolve = $$resolve;
+    reject = $$reject;
+  });
+  this.resolve = aCallable(resolve);
+  this.reject = aCallable(reject);
+};
+
+// `NewPromiseCapability` abstract operation
+// https://tc39.es/ecma262/#sec-newpromisecapability
+module.exports.f = function (C) {
+  return new PromiseCapability(C);
+};
+
+
 /***/ }),
 
 /***/ "f0af":
@@ -7661,6 +8414,7 @@ var iconPrefix = 'vxe-icon--';
     showHeader: true,
     animat: true,
     delayHover: 250,
+    autoResize: true,
     // keepSource: false,
     // showOverflow: null,
     // showHeaderOverflow: null,
@@ -7668,7 +8422,6 @@ var iconPrefix = 'vxe-icon--';
     // resizeInterval: 500,
     // size: null,
     // zIndex: null,
-    // autoResize: false,
     // stripe: false,
     // border: false,
     // round: false,
@@ -7741,6 +8494,9 @@ var iconPrefix = 'vxe-icon--';
     mouseConfig: {
       extension: true
     },
+    keyboardConfig: {
+      isEsc: true
+    },
     areaConfig: {
       selectCellByHeader: true
     },
@@ -9942,6 +10698,12 @@ var Icon = {
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.number.constructor.js
 var es_number_constructor = __webpack_require__("a9e3");
 
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.assign.js
+var es_object_assign = __webpack_require__("cca6");
+
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.iterator.js
+var es_array_iterator = __webpack_require__("e260");
+
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.map.js
 var es_map = __webpack_require__("4ec9");
 
@@ -11116,6 +11878,9 @@ function _objectSpread2(target) {
 
   return target;
 }
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.js
+var es_promise = __webpack_require__("e6cf");
+
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.trim.js
 var es_string_trim = __webpack_require__("498a");
 
@@ -12073,6 +12838,9 @@ var Cell = {
 
 
 
+
+
+
 
 
 
@@ -12648,16 +13416,12 @@ var Methods = {
 
       if (oRow && row) {
         if (field) {
-          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.set(oRow, field, external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.get(record || row, field));
+          var newValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.get(record || row, field);
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.set(row, field, newValue);
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.set(oRow, field, newValue);
         } else {
-          if (record) {
-            tableSourceData[rowIndex] = record;
-            external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.clear(row, undefined);
-            Object.assign(row, this.defineField(Object.assign({}, record)));
-            this.cacheRowMap(true);
-          } else {
-            external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.destructuring(oRow, external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.clone(row, true));
-          }
+          var newRecord = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.clone(_objectSpread2({}, record), true);
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.destructuring(oRow, Object.assign(row, newRecord));
         }
       }
 
@@ -14756,7 +15520,8 @@ var Methods = {
         editStore = this.editStore,
         keyboardConfig = this.keyboardConfig,
         mouseConfig = this.mouseConfig,
-        mouseOpts = this.mouseOpts;
+        mouseOpts = this.mouseOpts,
+        keyboardOpts = this.keyboardOpts;
     var actived = editStore.actived;
     var keyCode = evnt.keyCode;
     var isEsc = keyCode === 27;
@@ -14770,19 +15535,21 @@ var Methods = {
 
           _this23.closeFilter();
 
-          _this23.closeMenu(); // 如果是激活编辑状态，则取消编辑
-
+          _this23.closeMenu();
 
-          if (actived.row) {
-            var params = actived.args;
+          if (keyboardConfig && keyboardOpts.isEsc) {
+            // 如果是激活编辑状态，则取消编辑
+            if (actived.row) {
+              var params = actived.args;
 
-            _this23.clearActived(evnt); // 如果配置了选中功能，则为选中状态
+              _this23.clearActived(evnt); // 如果配置了选中功能，则为选中状态
 
 
-            if (mouseConfig && mouseOpts.selected) {
-              _this23.$nextTick(function () {
-                return _this23.handleSelected(params, evnt);
-              });
+              if (mouseConfig && mouseOpts.selected) {
+                _this23.$nextTick(function () {
+                  return _this23.handleSelected(params, evnt);
+                });
+              }
             }
           }
         }
@@ -15927,6 +16694,18 @@ var Methods = {
     var reserveSelection = [];
 
     if (checkboxOpts.reserve) {
+      var afterFullIdMaps = {};
+
+      if (treeConfig) {
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.eachTree(afterFullData, function (row) {
+          afterFullIdMaps[methods_getRowid(_this30, row)] = 1;
+        }, treeOpts);
+      } else {
+        afterFullData.forEach(function (row) {
+          afterFullIdMaps[methods_getRowid(_this30, row)] = 1;
+        });
+      }
+
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.each(checkboxReserveRowMap, function (oldRow, oldRowid) {
         if (oldRow) {
           if (isFull) {
@@ -15934,18 +16713,8 @@ var Methods = {
               reserveSelection.push(oldRow);
             }
           } else {
-            if (treeConfig) {
-              if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.findTree(afterFullData, function (row) {
-                return methods_getRowid(_this30, row) === oldRowid;
-              }, treeOpts)) {
-                reserveSelection.push(oldRow);
-              }
-            } else {
-              if (!afterFullData.some(function (row) {
-                return methods_getRowid(_this30, row) === oldRowid;
-              })) {
-                reserveSelection.push(oldRow);
-              }
+            if (!afterFullIdMaps[oldRowid]) {
+              reserveSelection.push(oldRow);
             }
           }
         }
@@ -18062,6 +18831,8 @@ funcs.forEach(function (name) {
 
 
 
+
+
 /**
  * 渲染浮固定列
  * 分别渲染左边固定列和右边固定列
@@ -18232,35 +19003,35 @@ function handleUupdateResize(_vm) {
         return conf.table.showHeader;
       }
     },
-    // 是否要高亮当前选中行
+    // （即将废弃）是否要高亮当前选中行
     highlightCurrentRow: {
       type: Boolean,
       default: function _default() {
         return conf.table.highlightCurrentRow;
       }
     },
-    // 鼠标移到行是否要高亮显示
+    // （即将废弃）鼠标移到行是否要高亮显示
     highlightHoverRow: {
       type: Boolean,
       default: function _default() {
         return conf.table.highlightHoverRow;
       }
     },
-    // 是否要高亮当前选中列
+    // （即将废弃）是否要高亮当前选中列
     highlightCurrentColumn: {
       type: Boolean,
       default: function _default() {
         return conf.table.highlightCurrentColumn;
       }
     },
-    // 鼠标移到列是否要高亮显示
+    // （即将废弃）鼠标移到列是否要高亮显示
     highlightHoverColumn: {
       type: Boolean,
       default: function _default() {
         return conf.table.highlightHoverColumn;
       }
     },
-    // 激活单元格编辑时是否高亮显示
+    // （即将废弃）激活单元格编辑时是否高亮显示
     highlightCell: Boolean,
     // 是否显示表尾合计
     showFooter: Boolean,
@@ -18408,7 +19179,7 @@ function handleUupdateResize(_vm) {
     scrollX: Object,
     // 纵向虚拟滚动配置项
     scrollY: Object,
-    // 优化相关
+    // （即将废弃）优化相关
     animat: {
       type: Boolean,
       default: function _default() {
@@ -20385,6 +21156,67 @@ var Menu = {
 
 
 var mixin_getRowid = UtilTools.getRowid;
+
+function insertTreeRow(_vm, newRecords, isAppend) {
+  var treeFullData = _vm.treeFullData,
+      afterFullData = _vm.afterFullData,
+      fullDataRowIdData = _vm.fullDataRowIdData,
+      fullAllDataRowIdData = _vm.fullAllDataRowIdData,
+      treeOpts = _vm.treeOpts;
+  var funcName = isAppend ? 'push' : 'unshift';
+  newRecords.forEach(function (item) {
+    var parentRowId = item[treeOpts.parentField];
+    var rowid = mixin_getRowid(_vm, item);
+    var matchObj = parentRowId ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.findTree(treeFullData, function (item) {
+      return parentRowId === item[treeOpts.rowField];
+    }, treeOpts) : null;
+
+    if (matchObj) {
+      var parentRow = matchObj.item;
+      var parentRest = fullAllDataRowIdData[mixin_getRowid(_vm, parentRow)];
+      var parentLevel = parentRest ? parentRest.level : 0;
+      var parentChilds = parentRow[treeOpts.children];
+
+      if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.isArray(parentChilds)) {
+        parentChilds = parentRow[treeOpts.children] = [];
+      }
+
+      parentChilds[funcName](item);
+      var rest = {
+        row: item,
+        rowid: rowid,
+        index: -1,
+        _index: -1,
+        $index: -1,
+        items: parentChilds,
+        parent: parent,
+        level: parentLevel + 1
+      };
+      fullDataRowIdData[rowid] = rest;
+      fullAllDataRowIdData[rowid] = rest;
+    } else {
+      if (false) {}
+
+      afterFullData[funcName](item);
+      treeFullData[funcName](item);
+      var _rest = {
+        row: item,
+        rowid: rowid,
+        index: -1,
+        _index: -1,
+        $index: -1,
+        items: treeFullData,
+        parent: null,
+        level: 0
+      };
+      fullDataRowIdData[rowid] = _rest;
+      fullAllDataRowIdData[rowid] = _rest;
+    }
+  });
+
+  _vm.updateVirtualTreeData();
+}
+
 /* harmony default export */ var edit_src_mixin = ({
   methods: {
     /**
@@ -20419,6 +21251,7 @@ var mixin_getRowid = UtilTools.getRowid;
           fullDataRowIdData = this.fullDataRowIdData,
           fullAllDataRowIdData = this.fullAllDataRowIdData,
           treeOpts = this.treeOpts;
+      var transform = treeOpts.transform;
 
       if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.isArray(records)) {
         records = [records];
@@ -20430,27 +21263,60 @@ var mixin_getRowid = UtilTools.getRowid;
 
       if (!row) {
         // 如果为虚拟树
-        if (treeConfig && treeOpts.transform) {
-          newRecords.forEach(function (item) {
-            var parentRowId = item[treeOpts.parentField];
-            var rowid = mixin_getRowid(_this, item);
+        if (treeConfig && transform) {
+          insertTreeRow(this, newRecords, false);
+        } else {
+          afterFullData.unshift.apply(afterFullData, _toConsumableArray(newRecords));
+          tableFullData.unshift.apply(tableFullData, _toConsumableArray(newRecords)); // 刷新单元格合并
 
-            if (parentRowId) {
-              var matchObj = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.findTree(treeFullData, function (item) {
-                return parentRowId === item[treeOpts.rowField];
-              }, treeOpts);
+          mergeList.forEach(function (mergeItem) {
+            var mergeRowIndex = mergeItem.row;
+
+            if (mergeRowIndex > 0) {
+              mergeItem.row = mergeRowIndex + newRecords.length;
+            }
+          });
+        }
+      } else {
+        if (row === -1) {
+          // 如果为虚拟树
+          if (treeConfig && transform) {
+            insertTreeRow(this, newRecords, true);
+          } else {
+            afterFullData.push.apply(afterFullData, _toConsumableArray(newRecords));
+            tableFullData.push.apply(tableFullData, _toConsumableArray(newRecords)); // 刷新单元格合并
 
-              if (matchObj) {
-                var parentRow = matchObj.item;
-                var parentRest = fullAllDataRowIdData[mixin_getRowid(_this, parentRow)];
-                var parentLevel = parentRest ? parentRest.level : 0;
-                var parentChilds = parentRow[treeOpts.children];
+            mergeList.forEach(function (mergeItem) {
+              var mergeRowIndex = mergeItem.row,
+                  mergeRowspan = mergeItem.rowspan;
 
-                if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.isArray(parentChilds)) {
-                  parentChilds = parentRow[treeOpts.children] = [];
+              if (mergeRowIndex + mergeRowspan > afterFullData.length) {
+                mergeItem.rowspan = mergeRowspan + newRecords.length;
+              }
+            });
+          }
+        } else {
+          // 如果为虚拟树
+          if (treeConfig && transform) {
+            var matchObj = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.findTree(treeFullData, function (item) {
+              return row[treeOpts.rowField] === item[treeOpts.rowField];
+            }, treeOpts);
+
+            if (matchObj) {
+              var parentRow = matchObj.parent;
+              var parentChilds = matchObj.items;
+              var parentRest = fullAllDataRowIdData[mixin_getRowid(this, parentRow)];
+              var parentLevel = parentRest ? parentRest.level : 0;
+              newRecords.forEach(function (item, i) {
+                var rowid = mixin_getRowid(_this, item);
+
+                if (false) {}
+
+                if (parentRow) {
+                  item[treeOpts.parentField] = parentRow[treeOpts.rowField];
                 }
 
-                parentChilds.push(item);
+                parentChilds.splice(matchObj.index + i, 0, item);
                 var rest = {
                   row: item,
                   rowid: rowid,
@@ -20458,75 +21324,50 @@ var mixin_getRowid = UtilTools.getRowid;
                   _index: -1,
                   $index: -1,
                   items: parentChilds,
-                  parent: parent,
+                  parent: parentRow,
                   level: parentLevel + 1
                 };
                 fullDataRowIdData[rowid] = rest;
                 fullAllDataRowIdData[rowid] = rest;
-              } else {// 父节点不存在
-              }
+              });
+              this.updateVirtualTreeData();
             } else {
-              afterFullData.unshift(item);
-              treeFullData.unshift(item);
-            }
-          });
-          this.updateVirtualTreeData();
-        } else {
-          afterFullData.unshift.apply(afterFullData, _toConsumableArray(newRecords));
-          tableFullData.unshift.apply(tableFullData, _toConsumableArray(newRecords)); // 刷新单元格合并
-
-          mergeList.forEach(function (mergeItem) {
-            var mergeRowIndex = mergeItem.row;
+              if (false) {}
 
-            if (mergeRowIndex > 0) {
-              mergeItem.row = mergeRowIndex + newRecords.length;
+              insertTreeRow(this, newRecords, true);
             }
-          });
-        }
-      } else {
-        if (row === -1) {
-          afterFullData.push.apply(afterFullData, _toConsumableArray(newRecords));
-          tableFullData.push.apply(tableFullData, _toConsumableArray(newRecords)); // 刷新单元格合并
-
-          mergeList.forEach(function (mergeItem) {
-            var mergeRowIndex = mergeItem.row,
-                mergeRowspan = mergeItem.rowspan;
-
-            if (mergeRowIndex + mergeRowspan > afterFullData.length) {
-              mergeItem.rowspan = mergeRowspan + newRecords.length;
+          } else {
+            if (treeConfig) {
+              throw new Error(UtilTools.getLog('vxe.error.noTree', ['insert']));
             }
-          });
-        } else {
-          if (treeConfig) {
-            throw new Error(UtilTools.getLog('vxe.error.noTree', ['insert']));
-          }
 
-          var afIndex = afterFullData.indexOf(row);
+            var afIndex = afterFullData.indexOf(row);
 
-          if (afIndex === -1) {
-            throw new Error(UtilTools.error('vxe.error.unableInsert'));
-          }
+            if (afIndex === -1) {
+              throw new Error(UtilTools.error('vxe.error.unableInsert'));
+            }
 
-          afterFullData.splice.apply(afterFullData, [afIndex, 0].concat(_toConsumableArray(newRecords)));
-          tableFullData.splice.apply(tableFullData, [tableFullData.indexOf(row), 0].concat(_toConsumableArray(newRecords))); // 刷新单元格合并
+            afterFullData.splice.apply(afterFullData, [afIndex, 0].concat(_toConsumableArray(newRecords)));
+            tableFullData.splice.apply(tableFullData, [tableFullData.indexOf(row), 0].concat(_toConsumableArray(newRecords))); // 刷新单元格合并
 
-          mergeList.forEach(function (mergeItem) {
-            var mergeRowIndex = mergeItem.row,
-                mergeRowspan = mergeItem.rowspan;
+            mergeList.forEach(function (mergeItem) {
+              var mergeRowIndex = mergeItem.row,
+                  mergeRowspan = mergeItem.rowspan;
 
-            if (mergeRowIndex > afIndex) {
-              mergeItem.row = mergeRowIndex + newRecords.length;
-            } else if (mergeRowIndex + mergeRowspan > afIndex) {
-              mergeItem.rowspan = mergeRowspan + newRecords.length;
-            }
-          });
+              if (mergeRowIndex > afIndex) {
+                mergeItem.row = mergeRowIndex + newRecords.length;
+              } else if (mergeRowIndex + mergeRowspan > afIndex) {
+                mergeItem.rowspan = mergeRowspan + newRecords.length;
+              }
+            });
+          }
         }
       }
 
       (_editStore$insertList = editStore.insertList).unshift.apply(_editStore$insertList, _toConsumableArray(newRecords));
 
       this.scrollYLoad = !treeConfig && sYOpts.gt > -1 && sYOpts.gt < tableFullData.length;
-      this.handleTableData();
+      this.handleTableData(transform);
       this.updateFooter();
       this.cacheRowMap();
       this.checkSelectionStatus();
@@ -20568,6 +21409,7 @@ var mixin_getRowid = UtilTools.getRowid;
           sYOpts = this.sYOpts,
           scrollYLoad = this.scrollYLoad,
           treeOpts = this.treeOpts;
+      var transform = treeOpts.transform;
       var actived = editStore.actived,
           removeList = editStore.removeList,
           insertList = editStore.insertList;
@@ -20605,7 +21447,7 @@ var mixin_getRowid = UtilTools.getRowid;
         this.clearMergeCells();
       } else {
         // 如果为虚拟树
-        if (treeConfig && treeOpts.transform) {
+        if (treeConfig && transform) {
           rows.forEach(function (row) {
             var rowid = mixin_getRowid(_this2, row);
             var matchObj = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.findTree(treeFullData, function (item) {
@@ -20668,7 +21510,7 @@ var mixin_getRowid = UtilTools.getRowid;
         }
       });
       this.scrollYLoad = !treeConfig && sYOpts.gt > -1 && sYOpts.gt < tableFullData.length;
-      this.handleTableData();
+      this.handleTableData(transform);
       this.updateFooter();
       this.cacheRowMap();
       this.checkSelectionStatus();
@@ -22549,12 +23391,20 @@ function getDateQuarter(date) {
   return 4;
 }
 
+function toFloatValueFixed(inputValue, digitsValue) {
+  if (/^-/.test('' + inputValue)) {
+    return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toFixed(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.ceil(inputValue, digitsValue), digitsValue);
+  }
+
+  return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toFixed(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.floor(inputValue, digitsValue), digitsValue);
+}
+
 function getNumberValue(_vm, val) {
   var type = _vm.type,
       exponential = _vm.exponential,
       digitsValue = _vm.digitsValue,
       inpMaxlength = _vm.inpMaxlength;
-  var restVal = type === 'float' ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toFixed(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.floor(val, digitsValue), digitsValue) : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toValueString(val);
+  var restVal = type === 'float' ? toFloatValueFixed(val, digitsValue) : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toValueString(val);
 
   if (exponential && (val === restVal || external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toValueString(val).toLowerCase() === external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toNumber(restVal).toExponential())) {
     return val;
@@ -23998,7 +24848,7 @@ function renderExtraSuffixIcon(h, _vm) {
         this.changeValue();
       } else if (type === 'float') {
         if (inputValue) {
-          var validValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toFixed(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.floor(inputValue, digitsValue), digitsValue);
+          var validValue = toFloatValueFixed(inputValue, digitsValue);
 
           if (inputValue !== validValue) {
             this.emitModel(validValue, {
@@ -26795,6 +27645,11 @@ var es_string_repeat = __webpack_require__("38cf");
 
 
 
+
+
+
+
+
 
 
 
@@ -26834,15 +27689,26 @@ function hasTreeChildren($xetable, row) {
   return row[treeOpts.children] && row[treeOpts.children].length > 0;
 }
 
-function getSeq($xetable, row, rowIndex, column, columnIndex) {
+function getSeq($xetable, row, rowIndex, column, columnIndex, paths) {
   var seqOpts = $xetable.seqOpts;
   var seqMethod = seqOpts.seqMethod || column.seqMethod;
-  return seqMethod ? seqMethod({
-    row: row,
-    rowIndex: rowIndex,
-    column: column,
-    columnIndex: columnIndex
-  }) : seqOpts.startIndex + rowIndex + 1;
+
+  if (seqMethod) {
+    return seqMethod({
+      row: row,
+      rowIndex: rowIndex,
+      column: column,
+      columnIndex: columnIndex
+    });
+  }
+
+  if (paths) {
+    return paths.map(function (num, i) {
+      return i % 2 === 0 ? Number(num) + 1 : '.';
+    }).join('');
+  }
+
+  return seqOpts.startIndex + rowIndex + 1;
 }
 
 function defaultFilterExportColumn(column) {
@@ -26879,11 +27745,12 @@ function getLabelData($xetable, opts, columns, datas) {
   if (treeConfig) {
     // 如果是树表格只允许导出数据源
     var rest = [];
+    var expandMaps = new Map();
     external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.eachTree(datas, function (item, rowIndex, items, path, parent, nodes) {
       var row = item._row || item;
       var parentRow = parent && parent._row ? parent._row : parent;
 
-      if (isAllExpand || !parentRow || $xetable.isTreeExpandByRow(parentRow)) {
+      if (isAllExpand || !parentRow || expandMaps.has(parentRow) && $xetable.isTreeExpandByRow(parentRow)) {
         var hasRowChild = hasTreeChildren($xetable, row);
         var _item = {
           _row: row,
@@ -26914,7 +27781,7 @@ function getLabelData($xetable, opts, columns, datas) {
           } else {
             switch (column.type) {
               case 'seq':
-                cellValue = getSeq($xetable, row, rowIndex, column, columnIndex);
+                cellValue = getSeq($xetable, row, rowIndex, column, columnIndex, path);
                 break;
 
               case 'checkbox':
@@ -26956,6 +27823,7 @@ function getLabelData($xetable, opts, columns, datas) {
 
           _item[column.id] = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default.a.toValueString(cellValue);
         });
+        expandMaps.set(row, 1);
         rest.push(Object.assign(_item, row));
       }
     }, treeOpts);
@@ -26989,7 +27857,7 @@ function getLabelData($xetable, opts, columns, datas) {
       } else {
         switch (column.type) {
           case 'seq':
-            cellValue = getSeq($xetable, row, rowIndex, column, columnIndex);
+            cellValue = getSeq($xetable, row, rowIndex, column, columnIndex, null);
             break;
 
           case 'checkbox':
@@ -27097,6 +27965,10 @@ function getFooterData(opts, footerTableData) {
 
 function getCsvCellTypeLabel(column, cellValue) {
   if (cellValue) {
+    if (column.type === 'seq') {
+      return "\t".concat(cellValue);
+    }
+
     switch (column.cellType) {
       case 'string':
         if (!isNaN(cellValue)) {
@@ -29368,7 +30240,7 @@ function validErrorRuleValue(rule, val) {
           var ruleProps = Object.keys(validRest);
           return _this2.$nextTick().then(function () {
             if (ruleProps.length) {
-              return Promise.reject(validRest[ruleProps[0]][0]);
+              return validRest[ruleProps[0]][0];
             }
 
             if (cb) {
@@ -29376,14 +30248,14 @@ function validErrorRuleValue(rule, val) {
             }
           });
         }).catch(function (firstErrParams) {
-          return new Promise(function (resolve, reject) {
+          return new Promise(function (resolve) {
             var finish = function finish() {
               _this2.$nextTick(function () {
                 if (cb) {
                   cb(validRest);
                   resolve();
                 } else {
-                  reject(validRest);
+                  resolve(validRest);
                 }
               });
             };
@@ -30634,6 +31506,8 @@ var Colgroup = Object.assign(src_group, {
 
 
 
+
+
 var grid_methods = {};
 var propKeys = Object.keys(packages_table.props);
 
@@ -31486,7 +32360,12 @@ Object.keys(packages_table.methods).forEach(function (name) {
               } // 只校验新增和修改的数据
 
 
-              return this.validate(_body.insertRecords.concat(updateRecords)).then(function () {
+              return this.validate(_body.insertRecords.concat(updateRecords)).then(function (errMap) {
+                if (errMap) {
+                  // 如果校验不通过
+                  return;
+                }
+
                 if (_body.insertRecords.length || _removeRecords.length || updateRecords.length || _body.pendingRecords.length) {
                   _this5.tableLoading = true;
                   return Promise.resolve((beforeSave || _ajaxMethods2).apply(void 0, _toConsumableArray(_applyArgs2))).then(function (rest) {
@@ -31534,8 +32413,6 @@ Object.keys(packages_table.methods).forEach(function (name) {
                     });
                   }
                 }
-              }).catch(function (errMap) {
-                return errMap;
               });
             } else {
               if (false) {}
@@ -37258,7 +38135,18 @@ module.exports = NATIVE_SYMBOL
   && typeof Symbol.iterator == 'symbol';
 
 
+/***/ }),
+
+/***/ "fea9":
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__("da84");
+
+module.exports = global.Promise;
+
+
 /***/ })
 
 /******/ });
-});
+});
+//# sourceMappingURL=index.umd.js.map