@wangeditor-next/editor 5.3.12-alpha.1 → 5.3.12-alpha.2

package/dist/index.js

@@ -38565,15 +38565,1866 @@
   }));
   });
 
+  /**
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="npm" -o ./`
+   * Copyright JS Foundation and other contributors <https://js.foundation/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   */
+
+  var lodash_isequal = createCommonjsModule$1(function (module, exports) {
+  /** Used as the size to enable large array optimizations. */
+  var LARGE_ARRAY_SIZE = 200;
+
+  /** Used to stand-in for `undefined` hash values. */
+  var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+  /** Used to compose bitmasks for value comparisons. */
+  var COMPARE_PARTIAL_FLAG = 1,
+      COMPARE_UNORDERED_FLAG = 2;
+
+  /** Used as references for various `Number` constants. */
+  var MAX_SAFE_INTEGER = 9007199254740991;
+
+  /** `Object#toString` result references. */
+  var argsTag = '[object Arguments]',
+      arrayTag = '[object Array]',
+      asyncTag = '[object AsyncFunction]',
+      boolTag = '[object Boolean]',
+      dateTag = '[object Date]',
+      errorTag = '[object Error]',
+      funcTag = '[object Function]',
+      genTag = '[object GeneratorFunction]',
+      mapTag = '[object Map]',
+      numberTag = '[object Number]',
+      nullTag = '[object Null]',
+      objectTag = '[object Object]',
+      promiseTag = '[object Promise]',
+      proxyTag = '[object Proxy]',
+      regexpTag = '[object RegExp]',
+      setTag = '[object Set]',
+      stringTag = '[object String]',
+      symbolTag = '[object Symbol]',
+      undefinedTag = '[object Undefined]',
+      weakMapTag = '[object WeakMap]';
+
+  var arrayBufferTag = '[object ArrayBuffer]',
+      dataViewTag = '[object DataView]',
+      float32Tag = '[object Float32Array]',
+      float64Tag = '[object Float64Array]',
+      int8Tag = '[object Int8Array]',
+      int16Tag = '[object Int16Array]',
+      int32Tag = '[object Int32Array]',
+      uint8Tag = '[object Uint8Array]',
+      uint8ClampedTag = '[object Uint8ClampedArray]',
+      uint16Tag = '[object Uint16Array]',
+      uint32Tag = '[object Uint32Array]';
+
+  /**
+   * Used to match `RegExp`
+   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+   */
+  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+  /** Used to detect host constructors (Safari). */
+  var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+  /** Used to detect unsigned integer values. */
+  var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+  /** Used to identify `toStringTag` values of typed arrays. */
+  var typedArrayTags = {};
+  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+  typedArrayTags[uint32Tag] = true;
+  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+  typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+  typedArrayTags[setTag] = typedArrayTags[stringTag] =
+  typedArrayTags[weakMapTag] = false;
+
+  /** Detect free variable `global` from Node.js. */
+  var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+  /** Detect free variable `self`. */
+  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+  /** Used as a reference to the global object. */
+  var root = freeGlobal || freeSelf || Function('return this')();
+
+  /** Detect free variable `exports`. */
+  var freeExports = exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+
+  /** Detect free variable `process` from Node.js. */
+  var freeProcess = moduleExports && freeGlobal.process;
+
+  /** Used to access faster Node.js helpers. */
+  var nodeUtil = (function() {
+    try {
+      return freeProcess && freeProcess.binding && freeProcess.binding('util');
+    } catch (e) {}
+  }());
+
+  /* Node.js helper references. */
+  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+  /**
+   * A specialized version of `_.filter` for arrays without support for
+   * iteratee shorthands.
+   *
+   * @private
+   * @param {Array} [array] The array to iterate over.
+   * @param {Function} predicate The function invoked per iteration.
+   * @returns {Array} Returns the new filtered array.
+   */
+  function arrayFilter(array, predicate) {
+    var index = -1,
+        length = array == null ? 0 : array.length,
+        resIndex = 0,
+        result = [];
+
+    while (++index < length) {
+      var value = array[index];
+      if (predicate(value, index, array)) {
+        result[resIndex++] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Appends the elements of `values` to `array`.
+   *
+   * @private
+   * @param {Array} array The array to modify.
+   * @param {Array} values The values to append.
+   * @returns {Array} Returns `array`.
+   */
+  function arrayPush(array, values) {
+    var index = -1,
+        length = values.length,
+        offset = array.length;
+
+    while (++index < length) {
+      array[offset + index] = values[index];
+    }
+    return array;
+  }
+
+  /**
+   * A specialized version of `_.some` for arrays without support for iteratee
+   * shorthands.
+   *
+   * @private
+   * @param {Array} [array] The array to iterate over.
+   * @param {Function} predicate The function invoked per iteration.
+   * @returns {boolean} Returns `true` if any element passes the predicate check,
+   *  else `false`.
+   */
+  function arraySome(array, predicate) {
+    var index = -1,
+        length = array == null ? 0 : array.length;
+
+    while (++index < length) {
+      if (predicate(array[index], index, array)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * The base implementation of `_.times` without support for iteratee shorthands
+   * or max array length checks.
+   *
+   * @private
+   * @param {number} n The number of times to invoke `iteratee`.
+   * @param {Function} iteratee The function invoked per iteration.
+   * @returns {Array} Returns the array of results.
+   */
+  function baseTimes(n, iteratee) {
+    var index = -1,
+        result = Array(n);
+
+    while (++index < n) {
+      result[index] = iteratee(index);
+    }
+    return result;
+  }
+
+  /**
+   * The base implementation of `_.unary` without support for storing metadata.
+   *
+   * @private
+   * @param {Function} func The function to cap arguments for.
+   * @returns {Function} Returns the new capped function.
+   */
+  function baseUnary(func) {
+    return function(value) {
+      return func(value);
+    };
+  }
+
+  /**
+   * Checks if a `cache` value for `key` exists.
+   *
+   * @private
+   * @param {Object} cache The cache to query.
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function cacheHas(cache, key) {
+    return cache.has(key);
+  }
+
+  /**
+   * Gets the value at `key` of `object`.
+   *
+   * @private
+   * @param {Object} [object] The object to query.
+   * @param {string} key The key of the property to get.
+   * @returns {*} Returns the property value.
+   */
+  function getValue(object, key) {
+    return object == null ? undefined : object[key];
+  }
+
+  /**
+   * Converts `map` to its key-value pairs.
+   *
+   * @private
+   * @param {Object} map The map to convert.
+   * @returns {Array} Returns the key-value pairs.
+   */
+  function mapToArray(map) {
+    var index = -1,
+        result = Array(map.size);
+
+    map.forEach(function(value, key) {
+      result[++index] = [key, value];
+    });
+    return result;
+  }
+
+  /**
+   * Creates a unary function that invokes `func` with its argument transformed.
+   *
+   * @private
+   * @param {Function} func The function to wrap.
+   * @param {Function} transform The argument transform.
+   * @returns {Function} Returns the new function.
+   */
+  function overArg(func, transform) {
+    return function(arg) {
+      return func(transform(arg));
+    };
+  }
+
+  /**
+   * Converts `set` to an array of its values.
+   *
+   * @private
+   * @param {Object} set The set to convert.
+   * @returns {Array} Returns the values.
+   */
+  function setToArray(set) {
+    var index = -1,
+        result = Array(set.size);
+
+    set.forEach(function(value) {
+      result[++index] = value;
+    });
+    return result;
+  }
+
+  /** Used for built-in method references. */
+  var arrayProto = Array.prototype,
+      funcProto = Function.prototype,
+      objectProto = Object.prototype;
+
+  /** Used to detect overreaching core-js shims. */
+  var coreJsData = root['__core-js_shared__'];
+
+  /** Used to resolve the decompiled source of functions. */
+  var funcToString = funcProto.toString;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /** Used to detect methods masquerading as native. */
+  var maskSrcKey = (function() {
+    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+    return uid ? ('Symbol(src)_1.' + uid) : '';
+  }());
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto.toString;
+
+  /** Used to detect if a method is native. */
+  var reIsNative = RegExp('^' +
+    funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+  );
+
+  /** Built-in value references. */
+  var Buffer = moduleExports ? root.Buffer : undefined,
+      Symbol = root.Symbol,
+      Uint8Array = root.Uint8Array,
+      propertyIsEnumerable = objectProto.propertyIsEnumerable,
+      splice = arrayProto.splice,
+      symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeGetSymbols = Object.getOwnPropertySymbols,
+      nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+      nativeKeys = overArg(Object.keys, Object);
+
+  /* Built-in method references that are verified to be native. */
+  var DataView = getNative(root, 'DataView'),
+      Map = getNative(root, 'Map'),
+      Promise = getNative(root, 'Promise'),
+      Set = getNative(root, 'Set'),
+      WeakMap = getNative(root, 'WeakMap'),
+      nativeCreate = getNative(Object, 'create');
+
+  /** Used to detect maps, sets, and weakmaps. */
+  var dataViewCtorString = toSource(DataView),
+      mapCtorString = toSource(Map),
+      promiseCtorString = toSource(Promise),
+      setCtorString = toSource(Set),
+      weakMapCtorString = toSource(WeakMap);
+
+  /** Used to convert symbols to primitives and strings. */
+  var symbolProto = Symbol ? Symbol.prototype : undefined,
+      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+  /**
+   * Creates a hash object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function Hash(entries) {
+    var index = -1,
+        length = entries == null ? 0 : entries.length;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  /**
+   * Removes all key-value entries from the hash.
+   *
+   * @private
+   * @name clear
+   * @memberOf Hash
+   */
+  function hashClear() {
+    this.__data__ = nativeCreate ? nativeCreate(null) : {};
+    this.size = 0;
+  }
+
+  /**
+   * Removes `key` and its value from the hash.
+   *
+   * @private
+   * @name delete
+   * @memberOf Hash
+   * @param {Object} hash The hash to modify.
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function hashDelete(key) {
+    var result = this.has(key) && delete this.__data__[key];
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+
+  /**
+   * Gets the hash value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf Hash
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function hashGet(key) {
+    var data = this.__data__;
+    if (nativeCreate) {
+      var result = data[key];
+      return result === HASH_UNDEFINED ? undefined : result;
+    }
+    return hasOwnProperty.call(data, key) ? data[key] : undefined;
+  }
+
+  /**
+   * Checks if a hash value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf Hash
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function hashHas(key) {
+    var data = this.__data__;
+    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
+  }
+
+  /**
+   * Sets the hash `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf Hash
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the hash instance.
+   */
+  function hashSet(key, value) {
+    var data = this.__data__;
+    this.size += this.has(key) ? 0 : 1;
+    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+    return this;
+  }
+
+  // Add methods to `Hash`.
+  Hash.prototype.clear = hashClear;
+  Hash.prototype['delete'] = hashDelete;
+  Hash.prototype.get = hashGet;
+  Hash.prototype.has = hashHas;
+  Hash.prototype.set = hashSet;
+
+  /**
+   * Creates an list cache object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function ListCache(entries) {
+    var index = -1,
+        length = entries == null ? 0 : entries.length;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  /**
+   * Removes all key-value entries from the list cache.
+   *
+   * @private
+   * @name clear
+   * @memberOf ListCache
+   */
+  function listCacheClear() {
+    this.__data__ = [];
+    this.size = 0;
+  }
+
+  /**
+   * Removes `key` and its value from the list cache.
+   *
+   * @private
+   * @name delete
+   * @memberOf ListCache
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function listCacheDelete(key) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    if (index < 0) {
+      return false;
+    }
+    var lastIndex = data.length - 1;
+    if (index == lastIndex) {
+      data.pop();
+    } else {
+      splice.call(data, index, 1);
+    }
+    --this.size;
+    return true;
+  }
+
+  /**
+   * Gets the list cache value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf ListCache
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function listCacheGet(key) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    return index < 0 ? undefined : data[index][1];
+  }
+
+  /**
+   * Checks if a list cache value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf ListCache
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function listCacheHas(key) {
+    return assocIndexOf(this.__data__, key) > -1;
+  }
+
+  /**
+   * Sets the list cache `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf ListCache
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the list cache instance.
+   */
+  function listCacheSet(key, value) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    if (index < 0) {
+      ++this.size;
+      data.push([key, value]);
+    } else {
+      data[index][1] = value;
+    }
+    return this;
+  }
+
+  // Add methods to `ListCache`.
+  ListCache.prototype.clear = listCacheClear;
+  ListCache.prototype['delete'] = listCacheDelete;
+  ListCache.prototype.get = listCacheGet;
+  ListCache.prototype.has = listCacheHas;
+  ListCache.prototype.set = listCacheSet;
+
+  /**
+   * Creates a map cache object to store key-value pairs.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function MapCache(entries) {
+    var index = -1,
+        length = entries == null ? 0 : entries.length;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  /**
+   * Removes all key-value entries from the map.
+   *
+   * @private
+   * @name clear
+   * @memberOf MapCache
+   */
+  function mapCacheClear() {
+    this.size = 0;
+    this.__data__ = {
+      'hash': new Hash,
+      'map': new (Map || ListCache),
+      'string': new Hash
+    };
+  }
+
+  /**
+   * Removes `key` and its value from the map.
+   *
+   * @private
+   * @name delete
+   * @memberOf MapCache
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function mapCacheDelete(key) {
+    var result = getMapData(this, key)['delete'](key);
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+
+  /**
+   * Gets the map value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf MapCache
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function mapCacheGet(key) {
+    return getMapData(this, key).get(key);
+  }
+
+  /**
+   * Checks if a map value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf MapCache
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function mapCacheHas(key) {
+    return getMapData(this, key).has(key);
+  }
+
+  /**
+   * Sets the map `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf MapCache
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the map cache instance.
+   */
+  function mapCacheSet(key, value) {
+    var data = getMapData(this, key),
+        size = data.size;
+
+    data.set(key, value);
+    this.size += data.size == size ? 0 : 1;
+    return this;
+  }
+
+  // Add methods to `MapCache`.
+  MapCache.prototype.clear = mapCacheClear;
+  MapCache.prototype['delete'] = mapCacheDelete;
+  MapCache.prototype.get = mapCacheGet;
+  MapCache.prototype.has = mapCacheHas;
+  MapCache.prototype.set = mapCacheSet;
+
+  /**
+   *
+   * Creates an array cache object to store unique values.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [values] The values to cache.
+   */
+  function SetCache(values) {
+    var index = -1,
+        length = values == null ? 0 : values.length;
+
+    this.__data__ = new MapCache;
+    while (++index < length) {
+      this.add(values[index]);
+    }
+  }
+
+  /**
+   * Adds `value` to the array cache.
+   *
+   * @private
+   * @name add
+   * @memberOf SetCache
+   * @alias push
+   * @param {*} value The value to cache.
+   * @returns {Object} Returns the cache instance.
+   */
+  function setCacheAdd(value) {
+    this.__data__.set(value, HASH_UNDEFINED);
+    return this;
+  }
+
+  /**
+   * Checks if `value` is in the array cache.
+   *
+   * @private
+   * @name has
+   * @memberOf SetCache
+   * @param {*} value The value to search for.
+   * @returns {number} Returns `true` if `value` is found, else `false`.
+   */
+  function setCacheHas(value) {
+    return this.__data__.has(value);
+  }
+
+  // Add methods to `SetCache`.
+  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+  SetCache.prototype.has = setCacheHas;
+
+  /**
+   * Creates a stack cache object to store key-value pairs.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function Stack(entries) {
+    var data = this.__data__ = new ListCache(entries);
+    this.size = data.size;
+  }
+
+  /**
+   * Removes all key-value entries from the stack.
+   *
+   * @private
+   * @name clear
+   * @memberOf Stack
+   */
+  function stackClear() {
+    this.__data__ = new ListCache;
+    this.size = 0;
+  }
+
+  /**
+   * Removes `key` and its value from the stack.
+   *
+   * @private
+   * @name delete
+   * @memberOf Stack
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function stackDelete(key) {
+    var data = this.__data__,
+        result = data['delete'](key);
+
+    this.size = data.size;
+    return result;
+  }
+
+  /**
+   * Gets the stack value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf Stack
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function stackGet(key) {
+    return this.__data__.get(key);
+  }
+
+  /**
+   * Checks if a stack value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf Stack
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function stackHas(key) {
+    return this.__data__.has(key);
+  }
+
+  /**
+   * Sets the stack `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf Stack
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the stack cache instance.
+   */
+  function stackSet(key, value) {
+    var data = this.__data__;
+    if (data instanceof ListCache) {
+      var pairs = data.__data__;
+      if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+        pairs.push([key, value]);
+        this.size = ++data.size;
+        return this;
+      }
+      data = this.__data__ = new MapCache(pairs);
+    }
+    data.set(key, value);
+    this.size = data.size;
+    return this;
+  }
+
+  // Add methods to `Stack`.
+  Stack.prototype.clear = stackClear;
+  Stack.prototype['delete'] = stackDelete;
+  Stack.prototype.get = stackGet;
+  Stack.prototype.has = stackHas;
+  Stack.prototype.set = stackSet;
+
+  /**
+   * Creates an array of the enumerable property names of the array-like `value`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @param {boolean} inherited Specify returning inherited property names.
+   * @returns {Array} Returns the array of property names.
+   */
+  function arrayLikeKeys(value, inherited) {
+    var isArr = isArray(value),
+        isArg = !isArr && isArguments(value),
+        isBuff = !isArr && !isArg && isBuffer(value),
+        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+        skipIndexes = isArr || isArg || isBuff || isType,
+        result = skipIndexes ? baseTimes(value.length, String) : [],
+        length = result.length;
+
+    for (var key in value) {
+      if ((inherited || hasOwnProperty.call(value, key)) &&
+          !(skipIndexes && (
+             // Safari 9 has enumerable `arguments.length` in strict mode.
+             key == 'length' ||
+             // Node.js 0.10 has enumerable non-index properties on buffers.
+             (isBuff && (key == 'offset' || key == 'parent')) ||
+             // PhantomJS 2 has enumerable non-index properties on typed arrays.
+             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+             // Skip index properties.
+             isIndex(key, length)
+          ))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Gets the index at which the `key` is found in `array` of key-value pairs.
+   *
+   * @private
+   * @param {Array} array The array to inspect.
+   * @param {*} key The key to search for.
+   * @returns {number} Returns the index of the matched value, else `-1`.
+   */
+  function assocIndexOf(array, key) {
+    var length = array.length;
+    while (length--) {
+      if (eq(array[length][0], key)) {
+        return length;
+      }
+    }
+    return -1;
+  }
+
+  /**
+   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+   * symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Function} keysFunc The function to get the keys of `object`.
+   * @param {Function} symbolsFunc The function to get the symbols of `object`.
+   * @returns {Array} Returns the array of property names and symbols.
+   */
+  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+  }
+
+  /**
+   * The base implementation of `getTag` without fallbacks for buggy environments.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return (symToStringTag && symToStringTag in Object(value))
+      ? getRawTag(value)
+      : objectToString(value);
+  }
+
+  /**
+   * The base implementation of `_.isArguments`.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+   */
+  function baseIsArguments(value) {
+    return isObjectLike(value) && baseGetTag(value) == argsTag;
+  }
+
+  /**
+   * The base implementation of `_.isEqual` which supports partial comparisons
+   * and tracks traversed objects.
+   *
+   * @private
+   * @param {*} value The value to compare.
+   * @param {*} other The other value to compare.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Unordered comparison
+   *  2 - Partial comparison
+   * @param {Function} [customizer] The function to customize comparisons.
+   * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+   */
+  function baseIsEqual(value, other, bitmask, customizer, stack) {
+    if (value === other) {
+      return true;
+    }
+    if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+      return value !== value && other !== other;
+    }
+    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+  }
+
+  /**
+   * A specialized version of `baseIsEqual` for arrays and objects which performs
+   * deep comparisons and tracks traversed objects enabling objects with circular
+   * references to be compared.
+   *
+   * @private
+   * @param {Object} object The object to compare.
+   * @param {Object} other The other object to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+   */
+  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+    var objIsArr = isArray(object),
+        othIsArr = isArray(other),
+        objTag = objIsArr ? arrayTag : getTag(object),
+        othTag = othIsArr ? arrayTag : getTag(other);
+
+    objTag = objTag == argsTag ? objectTag : objTag;
+    othTag = othTag == argsTag ? objectTag : othTag;
+
+    var objIsObj = objTag == objectTag,
+        othIsObj = othTag == objectTag,
+        isSameTag = objTag == othTag;
+
+    if (isSameTag && isBuffer(object)) {
+      if (!isBuffer(other)) {
+        return false;
+      }
+      objIsArr = true;
+      objIsObj = false;
+    }
+    if (isSameTag && !objIsObj) {
+      stack || (stack = new Stack);
+      return (objIsArr || isTypedArray(object))
+        ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+        : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+    }
+    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+      var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+          othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+      if (objIsWrapped || othIsWrapped) {
+        var objUnwrapped = objIsWrapped ? object.value() : object,
+            othUnwrapped = othIsWrapped ? other.value() : other;
+
+        stack || (stack = new Stack);
+        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+      }
+    }
+    if (!isSameTag) {
+      return false;
+    }
+    stack || (stack = new Stack);
+    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+  }
+
+  /**
+   * The base implementation of `_.isNative` without bad shim checks.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a native function,
+   *  else `false`.
+   */
+  function baseIsNative(value) {
+    if (!isObject(value) || isMasked(value)) {
+      return false;
+    }
+    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource(value));
+  }
+
+  /**
+   * The base implementation of `_.isTypedArray` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+   */
+  function baseIsTypedArray(value) {
+    return isObjectLike(value) &&
+      isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+  }
+
+  /**
+   * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   */
+  function baseKeys(object) {
+    if (!isPrototype(object)) {
+      return nativeKeys(object);
+    }
+    var result = [];
+    for (var key in Object(object)) {
+      if (hasOwnProperty.call(object, key) && key != 'constructor') {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * A specialized version of `baseIsEqualDeep` for arrays with support for
+   * partial deep comparisons.
+   *
+   * @private
+   * @param {Array} array The array to compare.
+   * @param {Array} other The other array to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} stack Tracks traversed `array` and `other` objects.
+   * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+   */
+  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+        arrLength = array.length,
+        othLength = other.length;
+
+    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+      return false;
+    }
+    // Assume cyclic values are equal.
+    var stacked = stack.get(array);
+    if (stacked && stack.get(other)) {
+      return stacked == other;
+    }
+    var index = -1,
+        result = true,
+        seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
+
+    stack.set(array, other);
+    stack.set(other, array);
+
+    // Ignore non-index properties.
+    while (++index < arrLength) {
+      var arrValue = array[index],
+          othValue = other[index];
+
+      if (customizer) {
+        var compared = isPartial
+          ? customizer(othValue, arrValue, index, other, array, stack)
+          : customizer(arrValue, othValue, index, array, other, stack);
+      }
+      if (compared !== undefined) {
+        if (compared) {
+          continue;
+        }
+        result = false;
+        break;
+      }
+      // Recursively compare arrays (susceptible to call stack limits).
+      if (seen) {
+        if (!arraySome(other, function(othValue, othIndex) {
+              if (!cacheHas(seen, othIndex) &&
+                  (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+                return seen.push(othIndex);
+              }
+            })) {
+          result = false;
+          break;
+        }
+      } else if (!(
+            arrValue === othValue ||
+              equalFunc(arrValue, othValue, bitmask, customizer, stack)
+          )) {
+        result = false;
+        break;
+      }
+    }
+    stack['delete'](array);
+    stack['delete'](other);
+    return result;
+  }
+
+  /**
+   * A specialized version of `baseIsEqualDeep` for comparing objects of
+   * the same `toStringTag`.
+   *
+   * **Note:** This function only supports comparing values with tags of
+   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+   *
+   * @private
+   * @param {Object} object The object to compare.
+   * @param {Object} other The other object to compare.
+   * @param {string} tag The `toStringTag` of the objects to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} stack Tracks traversed `object` and `other` objects.
+   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+   */
+  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+    switch (tag) {
+      case dataViewTag:
+        if ((object.byteLength != other.byteLength) ||
+            (object.byteOffset != other.byteOffset)) {
+          return false;
+        }
+        object = object.buffer;
+        other = other.buffer;
+
+      case arrayBufferTag:
+        if ((object.byteLength != other.byteLength) ||
+            !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+          return false;
+        }
+        return true;
+
+      case boolTag:
+      case dateTag:
+      case numberTag:
+        // Coerce booleans to `1` or `0` and dates to milliseconds.
+        // Invalid dates are coerced to `NaN`.
+        return eq(+object, +other);
+
+      case errorTag:
+        return object.name == other.name && object.message == other.message;
+
+      case regexpTag:
+      case stringTag:
+        // Coerce regexes to strings and treat strings, primitives and objects,
+        // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+        // for more details.
+        return object == (other + '');
+
+      case mapTag:
+        var convert = mapToArray;
+
+      case setTag:
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+        convert || (convert = setToArray);
+
+        if (object.size != other.size && !isPartial) {
+          return false;
+        }
+        // Assume cyclic values are equal.
+        var stacked = stack.get(object);
+        if (stacked) {
+          return stacked == other;
+        }
+        bitmask |= COMPARE_UNORDERED_FLAG;
+
+        // Recursively compare objects (susceptible to call stack limits).
+        stack.set(object, other);
+        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+        stack['delete'](object);
+        return result;
+
+      case symbolTag:
+        if (symbolValueOf) {
+          return symbolValueOf.call(object) == symbolValueOf.call(other);
+        }
+    }
+    return false;
+  }
+
+  /**
+   * A specialized version of `baseIsEqualDeep` for objects with support for
+   * partial deep comparisons.
+   *
+   * @private
+   * @param {Object} object The object to compare.
+   * @param {Object} other The other object to compare.
+   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+   * @param {Function} customizer The function to customize comparisons.
+   * @param {Function} equalFunc The function to determine equivalents of values.
+   * @param {Object} stack Tracks traversed `object` and `other` objects.
+   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+   */
+  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+        objProps = getAllKeys(object),
+        objLength = objProps.length,
+        othProps = getAllKeys(other),
+        othLength = othProps.length;
+
+    if (objLength != othLength && !isPartial) {
+      return false;
+    }
+    var index = objLength;
+    while (index--) {
+      var key = objProps[index];
+      if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+        return false;
+      }
+    }
+    // Assume cyclic values are equal.
+    var stacked = stack.get(object);
+    if (stacked && stack.get(other)) {
+      return stacked == other;
+    }
+    var result = true;
+    stack.set(object, other);
+    stack.set(other, object);
+
+    var skipCtor = isPartial;
+    while (++index < objLength) {
+      key = objProps[index];
+      var objValue = object[key],
+          othValue = other[key];
+
+      if (customizer) {
+        var compared = isPartial
+          ? customizer(othValue, objValue, key, other, object, stack)
+          : customizer(objValue, othValue, key, object, other, stack);
+      }
+      // Recursively compare objects (susceptible to call stack limits).
+      if (!(compared === undefined
+            ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+            : compared
+          )) {
+        result = false;
+        break;
+      }
+      skipCtor || (skipCtor = key == 'constructor');
+    }
+    if (result && !skipCtor) {
+      var objCtor = object.constructor,
+          othCtor = other.constructor;
+
+      // Non `Object` object instances with different constructors are not equal.
+      if (objCtor != othCtor &&
+          ('constructor' in object && 'constructor' in other) &&
+          !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+            typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+        result = false;
+      }
+    }
+    stack['delete'](object);
+    stack['delete'](other);
+    return result;
+  }
+
+  /**
+   * Creates an array of own enumerable property names and symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names and symbols.
+   */
+  function getAllKeys(object) {
+    return baseGetAllKeys(object, keys, getSymbols);
+  }
+
+  /**
+   * Gets the data for `map`.
+   *
+   * @private
+   * @param {Object} map The map to query.
+   * @param {string} key The reference key.
+   * @returns {*} Returns the map data.
+   */
+  function getMapData(map, key) {
+    var data = map.__data__;
+    return isKeyable(key)
+      ? data[typeof key == 'string' ? 'string' : 'hash']
+      : data.map;
+  }
+
+  /**
+   * Gets the native function at `key` of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {string} key The key of the method to get.
+   * @returns {*} Returns the function if it's native, else `undefined`.
+   */
+  function getNative(object, key) {
+    var value = getValue(object, key);
+    return baseIsNative(value) ? value : undefined;
+  }
+
+  /**
+   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the raw `toStringTag`.
+   */
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty.call(value, symToStringTag),
+        tag = value[symToStringTag];
+
+    try {
+      value[symToStringTag] = undefined;
+      var unmasked = true;
+    } catch (e) {}
+
+    var result = nativeObjectToString.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag] = tag;
+      } else {
+        delete value[symToStringTag];
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Creates an array of the own enumerable symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of symbols.
+   */
+  var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+    if (object == null) {
+      return [];
+    }
+    object = Object(object);
+    return arrayFilter(nativeGetSymbols(object), function(symbol) {
+      return propertyIsEnumerable.call(object, symbol);
+    });
+  };
+
+  /**
+   * Gets the `toStringTag` of `value`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  var getTag = baseGetTag;
+
+  // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+  if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+      (Map && getTag(new Map) != mapTag) ||
+      (Promise && getTag(Promise.resolve()) != promiseTag) ||
+      (Set && getTag(new Set) != setTag) ||
+      (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+    getTag = function(value) {
+      var result = baseGetTag(value),
+          Ctor = result == objectTag ? value.constructor : undefined,
+          ctorString = Ctor ? toSource(Ctor) : '';
+
+      if (ctorString) {
+        switch (ctorString) {
+          case dataViewCtorString: return dataViewTag;
+          case mapCtorString: return mapTag;
+          case promiseCtorString: return promiseTag;
+          case setCtorString: return setTag;
+          case weakMapCtorString: return weakMapTag;
+        }
+      }
+      return result;
+    };
+  }
+
+  /**
+   * Checks if `value` is a valid array-like index.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+   * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+   */
+  function isIndex(value, length) {
+    length = length == null ? MAX_SAFE_INTEGER : length;
+    return !!length &&
+      (typeof value == 'number' || reIsUint.test(value)) &&
+      (value > -1 && value % 1 == 0 && value < length);
+  }
+
+  /**
+   * Checks if `value` is suitable for use as unique object key.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+   */
+  function isKeyable(value) {
+    var type = typeof value;
+    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+      ? (value !== '__proto__')
+      : (value === null);
+  }
+
+  /**
+   * Checks if `func` has its source masked.
+   *
+   * @private
+   * @param {Function} func The function to check.
+   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+   */
+  function isMasked(func) {
+    return !!maskSrcKey && (maskSrcKey in func);
+  }
+
+  /**
+   * Checks if `value` is likely a prototype object.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+   */
+  function isPrototype(value) {
+    var Ctor = value && value.constructor,
+        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+    return value === proto;
+  }
+
+  /**
+   * Converts `value` to a string using `Object.prototype.toString`.
+   *
+   * @private
+   * @param {*} value The value to convert.
+   * @returns {string} Returns the converted string.
+   */
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+
+  /**
+   * Converts `func` to its source code.
+   *
+   * @private
+   * @param {Function} func The function to convert.
+   * @returns {string} Returns the source code.
+   */
+  function toSource(func) {
+    if (func != null) {
+      try {
+        return funcToString.call(func);
+      } catch (e) {}
+      try {
+        return (func + '');
+      } catch (e) {}
+    }
+    return '';
+  }
+
+  /**
+   * Performs a
+   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+   * comparison between two values to determine if they are equivalent.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to compare.
+   * @param {*} other The other value to compare.
+   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+   * @example
+   *
+   * var object = { 'a': 1 };
+   * var other = { 'a': 1 };
+   *
+   * _.eq(object, object);
+   * // => true
+   *
+   * _.eq(object, other);
+   * // => false
+   *
+   * _.eq('a', 'a');
+   * // => true
+   *
+   * _.eq('a', Object('a'));
+   * // => false
+   *
+   * _.eq(NaN, NaN);
+   * // => true
+   */
+  function eq(value, other) {
+    return value === other || (value !== value && other !== other);
+  }
+
+  /**
+   * Checks if `value` is likely an `arguments` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+   *  else `false`.
+   * @example
+   *
+   * _.isArguments(function() { return arguments; }());
+   * // => true
+   *
+   * _.isArguments([1, 2, 3]);
+   * // => false
+   */
+  var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+    return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
+      !propertyIsEnumerable.call(value, 'callee');
+  };
+
+  /**
+   * Checks if `value` is classified as an `Array` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+   * @example
+   *
+   * _.isArray([1, 2, 3]);
+   * // => true
+   *
+   * _.isArray(document.body.children);
+   * // => false
+   *
+   * _.isArray('abc');
+   * // => false
+   *
+   * _.isArray(_.noop);
+   * // => false
+   */
+  var isArray = Array.isArray;
+
+  /**
+   * Checks if `value` is array-like. A value is considered array-like if it's
+   * not a function and has a `value.length` that's an integer greater than or
+   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+   * @example
+   *
+   * _.isArrayLike([1, 2, 3]);
+   * // => true
+   *
+   * _.isArrayLike(document.body.children);
+   * // => true
+   *
+   * _.isArrayLike('abc');
+   * // => true
+   *
+   * _.isArrayLike(_.noop);
+   * // => false
+   */
+  function isArrayLike(value) {
+    return value != null && isLength(value.length) && !isFunction(value);
+  }
+
+  /**
+   * Checks if `value` is a buffer.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.3.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+   * @example
+   *
+   * _.isBuffer(new Buffer(2));
+   * // => true
+   *
+   * _.isBuffer(new Uint8Array(2));
+   * // => false
+   */
+  var isBuffer = nativeIsBuffer || stubFalse;
+
+  /**
+   * Performs a deep comparison between two values to determine if they are
+   * equivalent.
+   *
+   * **Note:** This method supports comparing arrays, array buffers, booleans,
+   * date objects, error objects, maps, numbers, `Object` objects, regexes,
+   * sets, strings, symbols, and typed arrays. `Object` objects are compared
+   * by their own, not inherited, enumerable properties. Functions and DOM
+   * nodes are compared by strict equality, i.e. `===`.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to compare.
+   * @param {*} other The other value to compare.
+   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+   * @example
+   *
+   * var object = { 'a': 1 };
+   * var other = { 'a': 1 };
+   *
+   * _.isEqual(object, other);
+   * // => true
+   *
+   * object === other;
+   * // => false
+   */
+  function isEqual(value, other) {
+    return baseIsEqual(value, other);
+  }
+
+  /**
+   * Checks if `value` is classified as a `Function` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+   * @example
+   *
+   * _.isFunction(_);
+   * // => true
+   *
+   * _.isFunction(/abc/);
+   * // => false
+   */
+  function isFunction(value) {
+    if (!isObject(value)) {
+      return false;
+    }
+    // The use of `Object#toString` avoids issues with the `typeof` operator
+    // in Safari 9 which returns 'object' for typed arrays and other constructors.
+    var tag = baseGetTag(value);
+    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+  }
+
+  /**
+   * Checks if `value` is a valid array-like length.
+   *
+   * **Note:** This method is loosely based on
+   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+   * @example
+   *
+   * _.isLength(3);
+   * // => true
+   *
+   * _.isLength(Number.MIN_VALUE);
+   * // => false
+   *
+   * _.isLength(Infinity);
+   * // => false
+   *
+   * _.isLength('3');
+   * // => false
+   */
+  function isLength(value) {
+    return typeof value == 'number' &&
+      value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+  }
+
+  /**
+   * Checks if `value` is the
+   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+   * @example
+   *
+   * _.isObject({});
+   * // => true
+   *
+   * _.isObject([1, 2, 3]);
+   * // => true
+   *
+   * _.isObject(_.noop);
+   * // => true
+   *
+   * _.isObject(null);
+   * // => false
+   */
+  function isObject(value) {
+    var type = typeof value;
+    return value != null && (type == 'object' || type == 'function');
+  }
+
+  /**
+   * Checks if `value` is object-like. A value is object-like if it's not `null`
+   * and has a `typeof` result of "object".
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+   * @example
+   *
+   * _.isObjectLike({});
+   * // => true
+   *
+   * _.isObjectLike([1, 2, 3]);
+   * // => true
+   *
+   * _.isObjectLike(_.noop);
+   * // => false
+   *
+   * _.isObjectLike(null);
+   * // => false
+   */
+  function isObjectLike(value) {
+    return value != null && typeof value == 'object';
+  }
+
+  /**
+   * Checks if `value` is classified as a typed array.
+   *
+   * @static
+   * @memberOf _
+   * @since 3.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+   * @example
+   *
+   * _.isTypedArray(new Uint8Array);
+   * // => true
+   *
+   * _.isTypedArray([]);
+   * // => false
+   */
+  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+  /**
+   * Creates an array of the own enumerable property names of `object`.
+   *
+   * **Note:** Non-object values are coerced to objects. See the
+   * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+   * for more details.
+   *
+   * @static
+   * @since 0.1.0
+   * @memberOf _
+   * @category Object
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   * @example
+   *
+   * function Foo() {
+   *   this.a = 1;
+   *   this.b = 2;
+   * }
+   *
+   * Foo.prototype.c = 3;
+   *
+   * _.keys(new Foo);
+   * // => ['a', 'b'] (iteration order is not guaranteed)
+   *
+   * _.keys('hi');
+   * // => ['0', '1']
+   */
+  function keys(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+  }
+
+  /**
+   * This method returns a new empty array.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.13.0
+   * @category Util
+   * @returns {Array} Returns the new empty array.
+   * @example
+   *
+   * var arrays = _.times(2, _.stubArray);
+   *
+   * console.log(arrays);
+   * // => [[], []]
+   *
+   * console.log(arrays[0] === arrays[1]);
+   * // => false
+   */
+  function stubArray() {
+    return [];
+  }
+
+  /**
+   * This method returns `false`.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.13.0
+   * @category Util
+   * @returns {boolean} Returns `false`.
+   * @example
+   *
+   * _.times(2, _.stubFalse);
+   * // => [false, false]
+   */
+  function stubFalse() {
+    return false;
+  }
+
+  module.exports = isEqual;
+  });
+
   var dist$3 = createCommonjsModule$1(function (module, exports) {
   (function (global, factory) {
-    module.exports = factory(dist$6, require$$2$1, lodash_debounce, require$$2, lodash_throttle, require$$1, require$$4) ;
-  })(commonjsGlobal, (function (core, slate, debounce, snabbdom, throttle, $) {
+    module.exports = factory(dist$6, require$$2$1, require$$2, lodash_throttle, require$$1, require$$4, lodash_isequal) ;
+  })(commonjsGlobal, (function (core, slate, snabbdom, throttle, $, nanoid, isEqual) {
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-    var debounce__default = /*#__PURE__*/_interopDefaultLegacy(debounce);
     var throttle__default = /*#__PURE__*/_interopDefaultLegacy(throttle);
     var $__default = /*#__PURE__*/_interopDefaultLegacy($);
+    var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
 
     /**
      * @description i18n en
@@ -38589,8 +40440,6 @@
             insertRow: 'Insert row',
             insertTable: 'Insert table',
             header: 'Header',
-            mergeCell: 'merge cell',
-            splitCell: 'split cell',
         },
     };
 
@@ -38608,472 +40457,64 @@
             insertRow: '插入行',
             insertTable: '插入表格',
             header: '表头',
-            mergeCell: '合并单元格',
-            splitCell: '拆分单元格',
-        },
-    };
-
-    /**
-     * @description i18n entry
-     * @author wangfupeng
-     */
-    core.i18nAddResources('en', enResources);
-    core.i18nAddResources('zh-CN', zhResources);
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (g && (g = 0, op[0] && (_ = 0)), _) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m) return m.call(o);
-        if (o && typeof o.length === "number") return {
-            next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-            }
-        };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m) return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-        }
-        catch (error) { e = { error: error }; }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"])) m.call(i);
-            }
-            finally { if (e) throw e.error; }
-        }
-        return ar;
-    }
-
-    function __spreadArray(to, from, pack) {
-        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-            if (ar || !(i in from)) {
-                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-            }
-        }
-        return to.concat(ar || Array.prototype.slice.call(from));
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    /** Weak reference between the `Editor` and the selected elements */
-    var EDITOR_TO_SELECTION = new WeakMap();
-    /** Weak reference between the `Editor` and a set of the selected elements */
-    var EDITOR_TO_SELECTION_SET = new WeakMap();
-
-    var DEFAULT_WITH_TABLE_OPTIONS = {
-        blocks: {
-            td: 'table-cell',
-            th: 'table-cell',
-            content: 'paragraph',
-            tr: 'table-row',
-            table: 'table',
-            tbody: 'table-body',
-            // tfoot: "table-footer",
-            // thead: "table-head",
         },
     };
 
-    function isElement(node) {
-        return !slate.Editor.isEditor(node) && slate.Element.isElement(node) && 'type' in node;
-    }
-    /** @returns a `NodeMatch` function which is used to match the elements of a specific `type`. */
-    function isOfType(editor) {
-        var types = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            types[_i - 1] = arguments[_i];
-        }
-        var options = DEFAULT_WITH_TABLE_OPTIONS, elementTypes = types.map(function (type) { var _a; return (_a = options === null || options === void 0 ? void 0 : options.blocks) === null || _a === void 0 ? void 0 : _a[type]; });
-        return function (node) { return isElement(node) && elementTypes.includes(node.type); };
-    }
-
     /**
-     * Determines whether two paths belong to the same types by checking
-     * if they share a common ancestor node of type table
-     */
-    function hasCommon(editor, _a) {
-        var _b = __read(_a, 2), path = _b[0], another = _b[1];
-        var types = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            types[_i - 2] = arguments[_i];
-        }
-        var _c = __read(slate.Node.common(editor, path, another), 2), node = _c[0], commonPath = _c[1];
-        if (isOfType.apply(void 0, __spreadArray([editor], __read(types)))(node, commonPath)) {
-            return true;
-        }
-        // Warning: returns the common ancestor but will return `undefined` if the
-        // `commonPath` is equal to the specified types path
-        return !!slate.Editor.above(editor, {
-            match: isOfType.apply(void 0, __spreadArray([editor], __read(types))),
-            at: commonPath,
-        });
-    }
-
-    /** Generates a matrix for each table section (`thead`, `tbody`, `tfoot`) */
-    function matrices(editor, options) {
-        var _a, table, _b, tablePath, _c, _d, _e, path, matrix, _f, _g, _h, trPath, e_1_1;
-        var e_1, _j, e_2, _k;
-        if (options === void 0) { options = {}; }
-        return __generator(this, function (_l) {
-            switch (_l.label) {
-                case 0:
-                    _a = __read(slate.Editor.nodes(editor, {
-                        match: isOfType(editor, 'table'),
-                        at: options.at,
-                    }), 1), table = _a[0];
-                    if (!table) {
-                        return [2 /*return*/, []];
-                    }
-                    _b = __read(table, 2), tablePath = _b[1];
-                    _l.label = 1;
-                case 1:
-                    _l.trys.push([1, 6, 7, 8]);
-                    _c = __values(slate.Editor.nodes(editor, {
-                        // match: isOfType(editor, "thead", "tbody", "tfoot"),
-                        match: isOfType(editor, 'table'),
-                        at: tablePath,
-                    })), _d = _c.next();
-                    _l.label = 2;
-                case 2:
-                    if (!!_d.done) return [3 /*break*/, 5];
-                    _e = __read(_d.value, 2), path = _e[1];
-                    matrix = [];
-                    try {
-                        for (_f = (e_2 = void 0, __values(slate.Editor.nodes(editor, {
-                            match: isOfType(editor, 'tr'),
-                            at: path,
-                        }))), _g = _f.next(); !_g.done; _g = _f.next()) {
-                            _h = __read(_g.value, 2), trPath = _h[1];
-                            matrix.push(__spreadArray([], __read(slate.Editor.nodes(editor, {
-                                match: isOfType(editor, 'th', 'td'),
-                                at: trPath,
-                            }))));
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_g && !_g.done && (_k = _f.return)) _k.call(_f);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                    return [4 /*yield*/, matrix];
-                case 3:
-                    _l.sent();
-                    _l.label = 4;
-                case 4:
-                    _d = _c.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_1_1 = _l.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (_d && !_d.done && (_j = _c.return)) _j.call(_c);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [2 /*return*/];
-            }
-        });
-    }
-    function filledMatrix(editor, options) {
-        var e_3, _a;
-        if (options === void 0) { options = {}; }
-        var filled = [];
-        try {
-            // Expand each section separately to avoid sections collapsing into each other.
-            for (var _b = __values(matrices(editor, { at: options.at })), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var matrix = _c.value;
-                var filledSection = [];
-                for (var x = 0; x < matrix.length; x++) {
-                    if (!filledSection[x]) {
-                        filledSection[x] = [];
-                    }
-                    for (var y = 0; y < matrix[x].length; y++) {
-                        var _d = __read(matrix[x][y], 1), _e = _d[0], _f = _e.rowSpan, rowSpan = _f === void 0 ? 1 : _f, _g = _e.colSpan, colSpan = _g === void 0 ? 1 : _g;
-                        for (var c = 0, occupied = 0; c < colSpan + occupied; c++) {
-                            for (var r = 0; r < rowSpan; r++) {
-                                if (!filledSection[x + r]) {
-                                    filledSection[x + r] = [];
-                                }
-                                if (filledSection[x + r][y + c]) {
-                                    continue;
-                                }
-                                filledSection[x + r][y + c] = [
-                                    matrix[x + r][y + c],
-                                    {
-                                        rtl: c - occupied + 1,
-                                        ltr: colSpan - c + occupied,
-                                        ttb: r + 1,
-                                        btt: rowSpan - r,
-                                    },
-                                ];
-                            }
-                        }
-                    }
-                }
-                filled.push.apply(filled, __spreadArray([], __read(filledSection)));
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        return filled;
-    }
-
-    var Point = /** @class */ (function () {
-        function Point(x, y) {
-            this.x = x;
-            this.y = y;
-        }
-        Point.valueOf = function (x, y) {
-            return new this(x, y);
-        };
-        Point.equals = function (point, another) {
-            return point.x === another.x && point.y === another.y;
-        };
-        return Point;
-    }());
-
-    var TableCursor = {
-        /** @returns {boolean} `true` if the selection is inside a table, otherwise `false`. */
-        isInTable: function (editor, options) {
-            if (options === void 0) { options = {}; }
-            var _a = __read(slate.Editor.nodes(editor, {
-                match: isOfType(editor, 'table'),
-                at: options.at,
-            }), 1), table = _a[0];
-            return !!table;
-        },
-        /**
-         * Retrieves a matrix representing the selected cells within a table.
-         * @returns {NodeEntry<T>[][]} A matrix containing the selected cells.
-         */
-        selection: function (editor) {
-            var matrix, x, cells, y, _a, entry, _b, colSpan, ttb;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        matrix = EDITOR_TO_SELECTION.get(editor);
-                        x = 0;
-                        _c.label = 1;
-                    case 1:
-                        if (!(matrix && x < matrix.length)) return [3 /*break*/, 4];
-                        cells = [];
-                        for (y = 0; y < matrix[x].length; y++) {
-                            _a = __read(matrix[x][y], 2), entry = _a[0], _b = _a[1], colSpan = _b.ltr, ttb = _b.ttb;
-                            ttb === 1 && cells.push(entry);
-                            y += colSpan - 1;
-                        }
-                        return [4 /*yield*/, cells];
-                    case 2:
-                        _c.sent();
-                        _c.label = 3;
-                    case 3:
-                        x++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        },
-        /** Clears the selection from the table */
-        unselect: function (editor) {
-            // const matrix = EDITOR_TO_SELECTION.get(editor);
-            var _a;
-            // if (!matrix?.length) {
-            //   return;
-            // }
-            // for (let x = 0; x < matrix.length; x++) {
-            //   for (let y = 0; y < matrix[x].length; y++) {
-            //     const [[, path], { ltr: colSpan, ttb }] = matrix[x][y];
-            //     y += colSpan - 1;
-            //     if (ttb > 1) {
-            //       continue;
-            //     }
-            //     // no-op since the paths are the same
-            //     const noop: Operation = {
-            //       type: "move_node",
-            //       newPath: path,
-            //       path: path,
-            //     };
-            //     Transforms.transform(editor, noop);
-            //   }
-            // }
-            EDITOR_TO_SELECTION_SET.delete(editor);
-            EDITOR_TO_SELECTION.delete(editor);
-            // 清除选区
-            (_a = document.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
-        },
-        /**
-         * Checks whether a given cell is part of the current table selection.
-         * @returns {boolean} - Returns true if the cell is selected, otherwise false.
-         */
-        isSelected: function (editor, element) {
-            var selectedElements = EDITOR_TO_SELECTION_SET.get(editor);
-            if (!selectedElements) {
-                return false;
-            }
-            return selectedElements.has(element);
-        },
-    };
-
-    function withSelection(editor) {
-        var apply = editor.apply;
-        editor.apply = function (op) {
-            if (!slate.Operation.isSelectionOperation(op) || !op.newProperties) {
-                // TableCursor.unselect(editor);
-                // 仿飞书效果，拖动单元格宽度时，选区不消失
-                return apply(op);
-            }
-            var selection = __assign(__assign({}, editor.selection), op.newProperties);
-            if (!slate.Range.isRange(selection)) {
-                TableCursor.unselect(editor);
-                return apply(op);
-            }
-            var _a = __read(slate.Editor.nodes(editor, {
-                match: isOfType(editor, 'th', 'td'),
-                at: slate.Range.start(selection),
-            }), 1), fromEntry = _a[0];
-            var _b = __read(slate.Editor.nodes(editor, {
-                match: isOfType(editor, 'th', 'td'),
-                at: slate.Range.end(selection),
-            }), 1), toEntry = _b[0];
-            if (!fromEntry || !toEntry) {
-                TableCursor.unselect(editor);
-                return apply(op);
-            }
-            var _c = __read(fromEntry, 2), fromPath = _c[1];
-            var _d = __read(toEntry, 2), toPath = _d[1];
-            if (slate.Path.equals(fromPath, toPath) || !hasCommon(editor, [fromPath, toPath], 'table')) {
-                TableCursor.unselect(editor);
-                return apply(op);
-            }
-            // TODO: perf: could be improved by passing a Span [fromPath, toPath]
-            var filled = filledMatrix(editor, { at: fromPath });
-            // find initial bounds
-            var from = Point.valueOf(0, 0);
-            var to = Point.valueOf(0, 0);
-            outer: for (var x = 0; x < filled.length; x++) {
-                for (var y = 0; y < filled[x].length; y++) {
-                    var _e = __read(filled[x][y], 1), _f = __read(_e[0], 2), path = _f[1];
-                    if (slate.Path.equals(fromPath, path)) {
-                        from.x = x;
-                        from.y = y;
-                    }
-                    if (slate.Path.equals(toPath, path)) {
-                        to.x = x;
-                        to.y = y;
-                        break outer;
-                    }
-                }
-            }
-            var start = Point.valueOf(Math.min(from.x, to.x), Math.min(from.y, to.y));
-            var end = Point.valueOf(Math.max(from.x, to.x), Math.max(from.y, to.y));
-            // expand the selection based on rowspan and colspan
-            for (;;) {
-                var nextStart = Point.valueOf(start.x, start.y);
-                var nextEnd = Point.valueOf(end.x, end.y);
-                for (var x = nextStart.x; x <= nextEnd.x; x++) {
-                    for (var y = nextStart.y; y <= nextEnd.y; y++) {
-                        var _g = __read(filled[x][y], 2), _h = _g[1], rtl = _h.rtl, ltr = _h.ltr, btt = _h.btt, ttb = _h.ttb;
-                        nextStart.x = Math.min(nextStart.x, x - (ttb - 1));
-                        nextStart.y = Math.min(nextStart.y, y - (rtl - 1));
-                        nextEnd.x = Math.max(nextEnd.x, x + (btt - 1));
-                        nextEnd.y = Math.max(nextEnd.y, y + (ltr - 1));
-                    }
-                }
-                if (Point.equals(start, nextStart) && Point.equals(end, nextEnd)) {
-                    break;
-                }
-                start = nextStart;
-                end = nextEnd;
-            }
-            var selected = [];
-            var selectedSet = new WeakSet();
-            for (var x = start.x; x <= end.x; x++) {
-                var cells = [];
-                for (var y = start.y; y <= end.y; y++) {
-                    var _j = __read(filled[x][y], 1), _k = __read(_j[0], 1), element = _k[0];
-                    selectedSet.add(element);
-                    cells.push(filled[x][y]);
-                }
-                selected.push(cells);
+     * @description i18n entry
+     * @author wangfupeng
+     */
+    core.i18nAddResources('en', enResources);
+    core.i18nAddResources('zh-CN', zhResources);
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
             }
-            EDITOR_TO_SELECTION.set(editor, selected);
-            EDITOR_TO_SELECTION_SET.set(editor, selectedSet);
-            apply(op);
         };
-        return editor;
-    }
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
 
     /**
      * @description editor 插件，重写 editor API
@@ -39151,9 +40592,9 @@
                 var before = slate.Editor.before(newEditor, selection); // 前一个 location
                 if (before) {
                     var isTableOnBeforeLocation = isTableLocation(newEditor, before); // before 是否是 table
-                    // 如果前面是 table, 当前是空 p，则不执行删除。否则会删除 table 最后一个 cell
-                    if (isTableOnBeforeLocation && core.DomEditor.isSelectedEmptyParagraph(newEditor)) {
-                        return;
+                    var isTableOnCurSelection = isTableLocation(newEditor, selection); // 当前是否是 table
+                    if (isTableOnBeforeLocation && !isTableOnCurSelection) {
+                        return; // 如果当前不是 table ，前面是 table ，则不执行删除。否则会删除 table 最后一个 cell
                     }
                 }
             }
@@ -39264,299 +40705,49 @@
             };
             newEditor.select(newSelection); // 选中 table-cell 内部的全部文字
         };
-        /**
-         * 光标选区行为新增
-         */
-        withSelection(newEditor);
         // 可继续修改其他 newEditor API ...
         // 返回 editor ，重要！
         return newEditor;
     }
 
     /**
-     * @description DOM 操作
+     * @description table menu helpers
      * @author wangfupeng
      */
-    if ($.append)
-        $__default["default"].fn.append = $.append;
-    if ($.on)
-        $__default["default"].fn.on = $.on;
-    if ($.focus)
-        $__default["default"].fn.focus = $.focus;
-    if ($.attr)
-        $__default["default"].fn.attr = $.attr;
-    if ($.val)
-        $__default["default"].fn.val = $.val;
-    if ($.html)
-        $__default["default"].fn.html = $.html;
-    if ($.dataset)
-        $__default["default"].fn.dataset = $.dataset;
-    if ($.addClass)
-        $__default["default"].fn.addClass = $.addClass;
-    if ($.removeClass)
-        $__default["default"].fn.removeClass = $.removeClass;
-    if ($.children)
-        $__default["default"].fn.children = $.children;
-    if ($.each)
-        $__default["default"].fn.each = $.each;
-    if ($.find)
-        $__default["default"].fn.find = $.find;
-    /**
-     * 获取 tagName lower-case
-     * @param $elem $elem
-     */
-    function getTagName($elem) {
-        if ($elem.length)
-            return $elem[0].tagName.toLowerCase();
-        return '';
-    }
     /**
-     * 获取 $elem 某一个 style 值
-     * @param $elem $elem
-     * @param styleKey style key
-     */
-    function getStyleValue($elem, styleKey) {
-        var res = '';
-        var styleStr = $elem.attr('style') || ''; // 如 'line-height: 2.5; color: red;'
-        var styleArr = styleStr.split(';'); // 如 ['line-height: 2.5', ' color: red', '']
-        var length = styleArr.length;
-        for (var i = 0; i < length; i++) {
-            var styleItemStr = styleArr[i]; // 如 'line-height: 2.5'
-            if (styleItemStr) {
-                var arr = styleItemStr.split(':'); // ['line-height', ' 2.5']
-                if (arr[0].trim() === styleKey) {
-                    res = arr[1].trim();
-                }
-            }
-        }
-        return res;
-    }
-
-    /***
-     * 计算 cell border 距离 table 左侧距离
-     */
-    function getCumulativeWidths(columnWidths) {
-        var e_1, _a;
-        var cumulativeWidths = [];
-        var totalWidth = 0;
-        try {
-            for (var columnWidths_1 = __values(columnWidths), columnWidths_1_1 = columnWidths_1.next(); !columnWidths_1_1.done; columnWidths_1_1 = columnWidths_1.next()) {
-                var width = columnWidths_1_1.value;
-                totalWidth += width;
-                cumulativeWidths.push(totalWidth);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (columnWidths_1_1 && !columnWidths_1_1.done && (_a = columnWidths_1.return)) _a.call(columnWidths_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return cumulativeWidths;
-    }
-    /***
-     * 用于计算拖动 cell 时，cell 宽度变化的比例
+     * 获取第一行所有 cells
+     * @param tableNode table node
      */
-    function getColumnWidthRatios(columnWidths) {
-        var e_2, _a;
-        var columnWidthsRatio = [];
-        var totalWidth = columnWidths.reduce(function (a, b) { return a + b; }, 0);
-        try {
-            for (var columnWidths_2 = __values(columnWidths), columnWidths_2_1 = columnWidths_2.next(); !columnWidths_2_1.done; columnWidths_2_1 = columnWidths_2.next()) {
-                var width = columnWidths_2_1.value;
-                columnWidthsRatio.push(width / totalWidth);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (columnWidths_2_1 && !columnWidths_2_1.done && (_a = columnWidths_2.return)) _a.call(columnWidths_2);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return columnWidthsRatio;
-    }
-    /**
-     * 监听 table 内部变化，如新增行、列，删除行列等操作，引起的高度变化。
-     * ResizeObserver 需要即时释放，以免引起内存泄露
-     */
-    var resizeObserver = null;
-    function observerTableResize(editor, elm) {
-        if (elm instanceof HTMLElement) {
-            var table = elm.querySelector('table');
-            if (table) {
-                resizeObserver = new ResizeObserver(function (_a) {
-                    var _b = __read(_a, 1), contentRect = _b[0].contentRect;
-                    // 当非拖动引起的宽度变化，需要调整 columnWidths
-                    slate.Transforms.setNodes(editor, {
-                        scrollWidth: contentRect.width,
-                        height: contentRect.height,
-                    }, { mode: 'highest' });
-                });
-                resizeObserver.observe(table);
-            }
-        }
-    }
-    function unObserveTableResize() {
-        if (resizeObserver) {
-            resizeObserver === null || resizeObserver === void 0 ? void 0 : resizeObserver.disconnect();
-            resizeObserver = null;
-        }
-    }
-    // 是否为光标选区行为
-    var isSelectionOperation = false;
-    // 拖拽列宽相关信息
-    var isMouseDownForResize = false;
-    var clientXWhenMouseDown = 0;
-    var cellWidthWhenMouseDown = 0;
-    var editorWhenMouseDown = null;
-    var $window = $__default["default"](window);
-    $window.on('mousedown', onMouseDown);
-    function onMouseDown(event) {
-        var elem = event.target;
-        // 判断是否为光标选区行为，对列宽变更行为进行过滤
-        // console.log('onMouseDown', elem)
-        if (elem.closest('[data-block-type="table-cell"]')) {
-            isSelectionOperation = true;
-        }
-        else if (elem.tagName == 'DIV' && elem.closest('.column-resizer-item')) {
-            if (editorWhenMouseDown == null)
-                return;
-            var _a = __read(slate.Editor.nodes(editorWhenMouseDown, {
-                match: isOfType(editorWhenMouseDown, 'table'),
-            }), 1), _b = __read(_a[0], 1), elemNode = _b[0];
-            var _c = elemNode, _d = _c.width, tableWidth = _d === void 0 ? 'auto' : _d, _e = _c.columnWidths, columnWidths = _e === void 0 ? [] : _e, _f = _c.resizingIndex, resizingIndex = _f === void 0 ? -1 : _f;
-            /**
-             * table width 为 100% 模式时，因无法增加Table宽度，不触发 列宽变更行为
-             * 如需变更，到底哪个列增宽度，哪个列减去宽度？？
-             */
-            if (tableWidth == '100%')
-                return;
-            // 记录必要信息
-            isMouseDownForResize = true;
-            var clientX = event.clientX;
-            clientXWhenMouseDown = clientX;
-            cellWidthWhenMouseDown = columnWidths[resizingIndex];
-            document.body.style.cursor = 'col-resize';
-            event.preventDefault();
-        }
-        $window.on('mousemove', onMouseMove);
-        $window.on('mouseup', onMouseUp);
-    }
-    var onMouseMove = throttle__default["default"](function (event) {
-        if (!isMouseDownForResize)
-            return;
-        if (editorWhenMouseDown == null)
-            return;
-        event.preventDefault();
-        var clientX = event.clientX;
-        var newWith = cellWidthWhenMouseDown + (clientX - clientXWhenMouseDown); // 计算新宽度
-        newWith = Math.floor(newWith * 100) / 100; // 保留小数点后两位
-        if (newWith < 30)
-            newWith = 30; // 最小宽度
-        var _a = __read(slate.Editor.nodes(editorWhenMouseDown, {
-            match: isOfType(editorWhenMouseDown, 'table'),
-        }), 1), _b = __read(_a[0], 1), elemNode = _b[0];
-        var _c = elemNode, _d = _c.columnWidths, columnWidths = _d === void 0 ? [] : _d, _e = _c.resizingIndex, resizingIndex = _e === void 0 ? -1 : _e, _f = _c.scrollWidth, scrollWidth = _f === void 0 ? 0 : _f;
-        /**
-         * 判断拖动引起的宽度是否最大化了
-         * 如果最大化了，则需要调整列的宽度
-         *
-         * 0.5 很微妙
-         */
-        var cumulativeTotalWidth = columnWidths.reduce(function (a, b) { return a + b; }, 0);
-        var remainWidth = cumulativeTotalWidth - columnWidths[resizingIndex];
-        if (cumulativeTotalWidth > scrollWidth && remainWidth + newWith > scrollWidth) {
-            newWith = scrollWidth - remainWidth + 0.5;
-        }
-        var adjustColumnWidths = __spreadArray([], __read(columnWidths)).map(function (width) { return Math.floor(width); });
-        adjustColumnWidths[resizingIndex] = newWith;
-        // 这是宽度
-        slate.Transforms.setNodes(editorWhenMouseDown, { columnWidths: adjustColumnWidths }, {
-            mode: 'highest',
-        });
-    }, 100);
-    function onMouseUp(event) {
-        isSelectionOperation = false;
-        isMouseDownForResize = false;
-        editorWhenMouseDown = null;
-        document.body.style.cursor = '';
-        // 解绑事件
-        $window.off('mousemove', onMouseMove);
-        $window.off('mouseup', onMouseUp);
+    function getFirstRowCells(tableNode) {
+        var rows = tableNode.children || []; // 所有行
+        if (rows.length === 0)
+            return [];
+        var firstRow = rows[0] || {}; // 第一行
+        var cells = firstRow.children || []; // 第一行所有 cell
+        return cells;
     }
     /**
-     * 鼠标移动时，判断在哪个 Cell border 上
-     * Class 先 visible 后 highlight @跟随飞书
-     * 避免光标选区功能收到干扰
+     * 表格是否带有表头？
+     * @param tableNode table node
      */
-    function handleCellBorderVisible(editor, elemNode, e) {
-        if (editor.isDisabled())
-            return;
-        if (isSelectionOperation || isMouseDownForResize)
-            return;
-        var _a = elemNode, _b = _a.width, tableWidth = _b === void 0 ? 'auto' : _b, _c = _a.columnWidths, columnWidths = _c === void 0 ? [] : _c, isHoverCellBorder = _a.isHoverCellBorder, resizingIndex = _a.resizingIndex;
-        /**
-         * table width 为 100% 模式时，因无法增加Table宽度，不触发 列宽变更行为
-         * 如需变更，到底哪个列增宽度，哪个列减去宽度？？
-         */
-        if (tableWidth == '100%')
-            return;
-        // Cell Border 宽度为 10px
-        var clientX = e.clientX, target = e.target;
-        // 当单元格合并的时候，鼠标在 cell 中间，则不显示 cell border
-        if (target instanceof HTMLElement) {
-            var rect = target.getBoundingClientRect();
-            if (clientX > rect.x + 5 && clientX < rect.x + rect.width - 5) {
-                if (isHoverCellBorder) {
-                    slate.Transforms.setNodes(editor, { isHoverCellBorder: false, resizingIndex: -1 }, { mode: 'highest' });
-                }
-                return;
-            }
-        }
-        if (target instanceof HTMLElement) {
-            var parent_1 = target.closest('.table');
-            if (parent_1) {
-                var clientX_1 = e.clientX;
-                var rect = parent_1.getBoundingClientRect();
-                var cumulativeWidths = getCumulativeWidths(columnWidths);
-                // 鼠标移动时，计算当前鼠标位置，判断在哪个 Cell border 上
-                for (var i = 0; i < cumulativeWidths.length; i++) {
-                    if (clientX_1 - rect.x >= cumulativeWidths[i] - 5 &&
-                        clientX_1 - rect.x < cumulativeWidths[i] + 5) {
-                        // 节流，防止多次引起Transforms.setNodes重绘
-                        if (resizingIndex == i)
-                            return;
-                        slate.Transforms.setNodes(editor, { isHoverCellBorder: true, resizingIndex: i }, { mode: 'highest' });
-                        return;
-                    }
-                }
-            }
-        }
-        // 鼠标移出时，重置
-        if (isHoverCellBorder == true) {
-            slate.Transforms.setNodes(editor, { isHoverCellBorder: false, resizingIndex: -1 }, {
-                mode: 'highest',
-            });
-        }
+    function isTableWithHeader(tableNode) {
+        var firstRowCells = getFirstRowCells(tableNode);
+        return firstRowCells.every(function (cell) { return !!cell.isHeader; });
     }
     /**
-     * 设置 class highlight
-     * 将 render-cell.tsx 拖动功能迁移至 div.column-resize
+     * 单元格是否在第一行
+     * @param editor editor
+     * @param cellNode cell node
      */
-    function handleCellBorderHighlight(editor, e) {
-        if (e.type === 'mouseenter') {
-            slate.Transforms.setNodes(editor, { isResizing: true }, { mode: 'highest' });
-        }
-        else {
-            slate.Transforms.setNodes(editor, { isResizing: false }, { mode: 'highest' });
-        }
-    }
-    function handleCellBorderMouseDown(editor, elemNode) {
-        if (isMouseDownForResize)
-            return; // 此时正在修改列宽
-        editorWhenMouseDown = editor;
+    function isCellInFirstRow(editor, cellNode) {
+        var rowNode = core.DomEditor.getParentNode(editor, cellNode);
+        if (rowNode == null)
+            return false;
+        var tableNode = core.DomEditor.getParentNode(editor, rowNode);
+        if (tableNode == null)
+            return false;
+        var firstRowCells = getFirstRowCells(tableNode);
+        return firstRowCells.some(function (c) { return c === cellNode; });
     }
 
     /**
@@ -39594,13 +40785,11 @@
         // 是否可编辑
         var editable = getContentEditable(editor, elemNode);
         // 宽度
-        var _a = elemNode, _b = _a.width, tableWidth = _b === void 0 ? 'auto' : _b, height = _a.height, _c = _a.columnWidths, columnWidths = _c === void 0 ? [] : _c, _d = _a.scrollWidth, scrollWidth = _d === void 0 ? 0 : _d, isHoverCellBorder = _a.isHoverCellBorder, resizingIndex = _a.resizingIndex, isResizing = _a.isResizing;
-        // 光标是否选中
+        var _a = elemNode.width, width = _a === void 0 ? 'auto' : _a;
+        // 是否选中
         var selected = core.DomEditor.isNodeSelected(editor, elemNode);
-        // 光标是否有选区
-        var _e = __read(TableCursor.selection(editor), 1), isSelecting = _e[0];
-        // 列宽之间比值
-        var columnWidthRatios = getColumnWidthRatios(columnWidths);
+        // 第一行的 cells ，以计算列宽
+        var firstRowCells = getFirstRowCells(elemNode);
         var vnode = (snabbdom.jsx("div", { className: "table-container", "data-selected": selected, on: {
                 mousedown: function (e) {
                     // @ts-ignore 阻止光标定位到 table 后面
@@ -39608,10 +40797,6 @@
                         e.preventDefault();
                     if (editor.isDisabled())
                         return;
-                    // @ts-ignore 如果用户行为是获取焦点输入文本时，需释放选区
-                    if (e.target.closest('[data-block-type="table-cell"]')) {
-                        TableCursor.unselect(editor);
-                    }
                     // 是否需要定位到 table 内部
                     var tablePath = core.DomEditor.findPath(editor, elemNode);
                     var tableStart = slate.Editor.start(editor, tablePath);
@@ -39626,64 +40811,13 @@
                     editor.select(tableStart); // 选中 table 内部
                 },
             } },
-            snabbdom.jsx("table", { width: tableWidth, contentEditable: editable, 
-                /**
-                 * 1. 当表格处于选区状态，屏蔽 Chrome 自带的样式
-                 * 2. table 宽度为 auto 时，宽度为 列宽之和
-                 * 3. 鼠标移动到 单元格 边缘，设置 visible className
-                 */
-                className: 'table ' + (isSelecting ? 'table-selection-none' : ''), style: {
-                    width: tableWidth == '100%' ? '' : columnWidths.reduce(function (a, b) { return a + b; }, 0) + 'px',
-                }, on: {
-                    mousemove: debounce__default["default"](function (e) { return handleCellBorderVisible(editor, elemNode, e); }, 25),
-                } },
-                snabbdom.jsx("colgroup", { contentEditable: false }, 
-                /**
-                 * 剔除 firstRowCells，因单元格合并 表头 th，会计算错误。
-                 * 使用 columnWidth 数组长度代表列数
-                 * 拖动行为及变量设置均参考 飞书
-                 */
-                columnWidths.map(function (width) {
+            snabbdom.jsx("table", { width: width, contentEditable: editable },
+                snabbdom.jsx("colgroup", { contentEditable: false }, firstRowCells.map(function (cell) {
+                    var _a = cell.width, width = _a === void 0 ? 'auto' : _a;
                     return snabbdom.jsx("col", { width: width });
                 })),
-                snabbdom.jsx("tbody", null, children)),
-            snabbdom.jsx("div", { className: "column-resizer", contenteditable: "false" }, columnWidths.map(function (width, index) {
-                var minWidth = width;
-                /**
-                 * table width 为 100% 模式时
-                 * columnWidths 表示的是比例
-                 * 1. 需要计算出真实的宽度
-                 */
-                if (tableWidth == '100%') {
-                    minWidth = columnWidthRatios[index] * scrollWidth;
-                }
-                return (snabbdom.jsx("div", { className: "column-resizer-item", style: { minWidth: minWidth + "px" } },
-                    snabbdom.jsx("div", { className: 'resizer-line-hotzone ' +
-                            (isHoverCellBorder && index == resizingIndex ? 'visible ' : '') +
-                            (isResizing && index == resizingIndex ? 'highlight' : ''), style: { height: height + 'px' }, on: {
-                            mouseenter: function (e) { return handleCellBorderHighlight(editor, e); },
-                            mouseleave: function (e) { return handleCellBorderHighlight(editor, e); },
-                            mousedown: function (e) { return handleCellBorderMouseDown(editor); },
-                        } },
-                        snabbdom.jsx("div", { className: "resizer-line" }))));
-            }))));
-        /**
-         * 移出直接返回 vnode
-         * 添加 ObserverResize 监听行为
-         * 监听 table 内部变化，更新 table resize-bar 高度
-         */
-        var containerVnode = snabbdom.h('div', {
-            hook: {
-                insert: function (_a) {
-                    var elm = _a.elm;
-                    return observerTableResize(editor, elm);
-                },
-                destroy: function () {
-                    unObserveTableResize();
-                },
-            },
-        }, vnode);
-        return containerVnode;
+                snabbdom.jsx("tbody", null, children))));
+        return vnode;
     }
 
     /**
@@ -39694,62 +40828,156 @@
         var vnode = snabbdom.jsx("tr", null, children);
         return vnode;
     }
-
-    /**
-     * @description table menu helpers
-     * @author wangfupeng
-     */
-    /**
-     * 获取第一行所有 cells
-     * @param tableNode table node
-     */
-    function getFirstRowCells(tableNode) {
-        var rows = tableNode.children || []; // 所有行
-        if (rows.length === 0)
-            return [];
-        var firstRow = rows[0] || {}; // 第一行
-        var cells = firstRow.children || []; // 第一行所有 cell
-        return cells;
-    }
+
     /**
-     * 表格是否带有表头？
-     * @param tableNode table node
+     * @description DOM 操作
+     * @author wangfupeng
      */
-    function isTableWithHeader(tableNode) {
-        var firstRowCells = getFirstRowCells(tableNode);
-        return firstRowCells.every(function (cell) { return !!cell.isHeader; });
+    if ($.append)
+        $__default["default"].fn.append = $.append;
+    if ($.on)
+        $__default["default"].fn.on = $.on;
+    if ($.focus)
+        $__default["default"].fn.focus = $.focus;
+    if ($.attr)
+        $__default["default"].fn.attr = $.attr;
+    if ($.val)
+        $__default["default"].fn.val = $.val;
+    if ($.html)
+        $__default["default"].fn.html = $.html;
+    if ($.dataset)
+        $__default["default"].fn.dataset = $.dataset;
+    if ($.addClass)
+        $__default["default"].fn.addClass = $.addClass;
+    if ($.removeClass)
+        $__default["default"].fn.removeClass = $.removeClass;
+    if ($.children)
+        $__default["default"].fn.children = $.children;
+    if ($.each)
+        $__default["default"].fn.each = $.each;
+    if ($.find)
+        $__default["default"].fn.find = $.find;
+    /**
+     * 获取 tagName lower-case
+     * @param $elem $elem
+     */
+    function getTagName($elem) {
+        if ($elem.length)
+            return $elem[0].tagName.toLowerCase();
+        return '';
     }
     /**
-     * 单元格是否在第一行
-     * @param editor editor
-     * @param cellNode cell node
+     * 获取 $elem 某一个 style 值
+     * @param $elem $elem
+     * @param styleKey style key
      */
-    function isCellInFirstRow(editor, cellNode) {
-        var rowNode = core.DomEditor.getParentNode(editor, cellNode);
-        if (rowNode == null)
-            return false;
-        var tableNode = core.DomEditor.getParentNode(editor, rowNode);
-        if (tableNode == null)
-            return false;
-        var firstRowCells = getFirstRowCells(tableNode);
-        return firstRowCells.some(function (c) { return c === cellNode; });
+    function getStyleValue($elem, styleKey) {
+        var res = '';
+        var styleStr = $elem.attr('style') || ''; // 如 'line-height: 2.5; color: red;'
+        var styleArr = styleStr.split(';'); // 如 ['line-height: 2.5', ' color: red', '']
+        var length = styleArr.length;
+        for (var i = 0; i < length; i++) {
+            var styleItemStr = styleArr[i]; // 如 'line-height: 2.5'
+            if (styleItemStr) {
+                var arr = styleItemStr.split(':'); // ['line-height', ' 2.5']
+                if (arr[0].trim() === styleKey) {
+                    res = arr[1].trim();
+                }
+            }
+        }
+        return res;
     }
 
     /**
      * @description render cell
      * @author wangfupeng
      */
+    // 拖拽列宽相关信息
+    var isMouseDownForResize = false;
+    var clientXWhenMouseDown = 0;
+    var cellWidthWhenMouseDown = 0;
+    var cellPathWhenMouseDown = null;
+    var editorWhenMouseDown = null;
+    var $body = $__default["default"]('body');
+    function onMouseDown(event) {
+        var elem = event.target;
+        if (elem.tagName !== 'TH' && elem.tagName !== 'TD')
+            return;
+        if (elem.style.cursor !== 'col-resize')
+            return;
+        elem.style.cursor = 'auto';
+        event.preventDefault();
+        // 记录必要信息
+        isMouseDownForResize = true;
+        var clientX = event.clientX;
+        clientXWhenMouseDown = clientX;
+        var width = elem.getBoundingClientRect().width;
+        cellWidthWhenMouseDown = width;
+        // 绑定事件
+        $body.on('mousemove', onMouseMove);
+        $body.on('mouseup', onMouseUp);
+    }
+    $body.on('mousedown', onMouseDown); // 绑定事件
+    function onMouseUp(event) {
+        isMouseDownForResize = false;
+        editorWhenMouseDown = null;
+        cellPathWhenMouseDown = null;
+        // 解绑事件
+        $body.off('mousemove', onMouseMove);
+        $body.off('mouseup', onMouseUp);
+    }
+    var onMouseMove = throttle__default["default"](function (event) {
+        if (!isMouseDownForResize)
+            return;
+        if (editorWhenMouseDown == null || cellPathWhenMouseDown == null)
+            return;
+        event.preventDefault();
+        var clientX = event.clientX;
+        var newWith = cellWidthWhenMouseDown + (clientX - clientXWhenMouseDown); // 计算新宽度
+        newWith = Math.floor(newWith * 100) / 100; // 保留小数点后两位
+        if (newWith < 30)
+            newWith = 30; // 最小宽度
+        // 这是宽度
+        slate.Transforms.setNodes(editorWhenMouseDown, { width: newWith.toString() }, {
+            at: cellPathWhenMouseDown,
+        });
+    }, 100);
     function renderTableCell(cellNode, children, editor) {
         var isFirstRow = isCellInFirstRow(editor, cellNode);
-        var _a = cellNode, _b = _a.colSpan, colSpan = _b === void 0 ? 1 : _b, _c = _a.rowSpan, rowSpan = _c === void 0 ? 1 : _c, _d = _a.isHeader, isHeader = _d === void 0 ? false : _d, _e = _a.hidden, hidden = _e === void 0 ? false : _e;
-        var selected = TableCursor.isSelected(editor, cellNode);
+        var _a = cellNode, _b = _a.colSpan, colSpan = _b === void 0 ? 1 : _b, _c = _a.rowSpan, rowSpan = _c === void 0 ? 1 : _c, _d = _a.isHeader, isHeader = _d === void 0 ? false : _d;
         // ------------------ 不是第一行，直接渲染 <td> ------------------
         if (!isFirstRow) {
-            return (snabbdom.jsx("td", { colSpan: colSpan, rowSpan: rowSpan, "data-block-type": "table-cell", className: selected ? 'w-e-selected' : '', style: { display: hidden ? 'none' : '' } }, children));
+            return (snabbdom.jsx("td", { colSpan: colSpan, rowSpan: rowSpan }, children));
         }
         // ------------------ 是第一行：1. 判断 th ；2. 拖拽列宽 ------------------
         var Tag = isHeader ? 'th' : 'td';
-        var vnode = (snabbdom.jsx(Tag, { colSpan: colSpan, rowSpan: rowSpan, "data-block-type": "table-cell", className: selected ? 'w-e-selected' : '', style: { display: hidden ? 'none' : '' } }, children));
+        var vnode = (snabbdom.jsx(Tag, { colSpan: colSpan, rowSpan: rowSpan, style: { borderRightWidth: '3px' }, on: {
+                mousemove: throttle__default["default"](function (event) {
+                    var elem = this.elm;
+                    if (elem == null)
+                        return;
+                    var _a = elem.getBoundingClientRect(), left = _a.left, width = _a.width, top = _a.top, height = _a.height;
+                    var clientX = event.clientX, clientY = event.clientY;
+                    if (isMouseDownForResize)
+                        return; // 此时正在修改列宽
+                    // 非 mousedown 状态，计算 cursor 样式
+                    var matchX = clientX > left + width - 5 && clientX < left + width; // X 轴，是否接近 cell 右侧？
+                    var matchY = clientY > top && clientY < top + height; // Y 轴，是否在 cell 之内
+                    // X Y 轴都接近，则修改鼠标样式
+                    if (matchX && matchY) {
+                        elem.style.cursor = 'col-resize';
+                        editorWhenMouseDown = editor;
+                        cellPathWhenMouseDown = core.DomEditor.findPath(editor, cellNode);
+                    }
+                    else {
+                        if (!isMouseDownForResize) {
+                            elem.style.cursor = 'auto';
+                            editorWhenMouseDown = null;
+                            cellPathWhenMouseDown = null;
+                        }
+                    }
+                }, 100),
+            } }, children));
         return vnode;
     }
 
@@ -39776,16 +41004,15 @@
      */
     function tableToHtml(elemNode, childrenHtml) {
         var _a = elemNode.width, width = _a === void 0 ? 'auto' : _a;
-        return "<table style=\"width: " + width + ";table-layout: fixed;\"><tbody>" + childrenHtml + "</tbody></table>";
+        return "<table style=\"width: " + width + ";\"><tbody>" + childrenHtml + "</tbody></table>";
     }
     function tableRowToHtml(elem, childrenHtml) {
         return "<tr>" + childrenHtml + "</tr>";
     }
     function tableCellToHtml(cellNode, childrenHtml) {
-        var _a = cellNode, _b = _a.colSpan, colSpan = _b === void 0 ? 1 : _b, _c = _a.rowSpan, rowSpan = _c === void 0 ? 1 : _c, _d = _a.isHeader, isHeader = _d === void 0 ? false : _d, _e = _a.width, width = _e === void 0 ? 'auto' : _e, _f = _a.hidden, hidden = _f === void 0 ? false : _f;
+        var _a = cellNode, _b = _a.colSpan, colSpan = _b === void 0 ? 1 : _b, _c = _a.rowSpan, rowSpan = _c === void 0 ? 1 : _c, _d = _a.isHeader, isHeader = _d === void 0 ? false : _d, _e = _a.width, width = _e === void 0 ? 'auto' : _e;
         var tag = isHeader ? 'th' : 'td';
-        var style = hidden ? 'display:none' : '';
-        return "<" + tag + " colSpan=\"" + colSpan + "\" rowSpan=\"" + rowSpan + "\" width=\"" + width + "\" style=\"" + style + "\">" + childrenHtml + "</" + tag + ">";
+        return "<" + tag + " colSpan=\"" + colSpan + "\" rowSpan=\"" + rowSpan + "\" width=\"" + width + "\">" + childrenHtml + "</" + tag + ">";
     }
     var tableToHtmlConf = {
         type: 'table',
@@ -39874,7 +41101,6 @@
         parseElemHtml: parseRowHtml,
     };
     function parseTableHtml(elem, children, editor) {
-        var _a;
         var $elem = $__default["default"](elem);
         // 计算宽度
         var width = 'auto';
@@ -39882,17 +41108,12 @@
             width = '100%';
         if ($elem.attr('width') === '100%')
             width = '100%'; // 兼容 v4 格式
-        var tableELement = {
+        return {
             type: 'table',
             width: width,
             // @ts-ignore
             children: children.filter(function (child) { return core.DomEditor.getNodeType(child) === 'table-row'; }),
         };
-        var cellLength = (_a = $elem.find('tr')[0]) === null || _a === void 0 ? void 0 : _a.children.length;
-        if (cellLength > 0) {
-            tableELement.columnWidths = Array(cellLength).fill(180);
-        }
-        return tableELement;
     }
     var parseTableHtmlConf = {
         selector: 'table:not([data-w-e-type])',
@@ -39923,11 +41144,7 @@
     // 表头
     var TABLE_HEADER_SVG = '<svg viewBox="0 0 1024 1024"><path d="M704 128l-64 0L384 128 320 128 0 128l0 256 0 64 0 192 0 64 0 256 320 0 64 0 256 0 64 0 320 0 0-256 0-64L1024 448 1024 384 1024 128 704 128zM640 640 384 640 384 448l256 0L640 640zM64 448l256 0 0 192L64 640 64 448zM320 896 64 896l0-192 256 0L320 896zM640 896 384 896l0-192 256 0L640 896zM960 896l-256 0 0-192 256 0L960 896zM960 640l-256 0L704 448l256 0L960 640z"></path></svg>';
     // 宽度
-    var FULL_WIDTH_SVG = '<svg viewBox="0 0 1228 1024"><path d="M862.514337 563.200461H404.581995v121.753478a13.311987 13.311987 0 0 1-6.655993 11.468789 10.23999 10.23999 0 0 1-12.083188-1.433599l-204.799795-179.199821a13.721586 13.721586 0 0 1 0-20.479979l204.799795-179.302221a10.23999 10.23999 0 0 1 12.185588-1.535998 13.209587 13.209587 0 0 1 6.553593 11.673588v115.097485h457.932342V319.693504a11.571188 11.571188 0 0 1 18.841582-10.239989l204.799795 179.19982a13.721586 13.721586 0 0 1 0 20.47998l-204.799795 179.199821a10.23999 10.23999 0 0 1-12.185588 1.535998 13.311987 13.311987 0 0 1-6.655994-11.571188V563.200461zM136.499064 14.951409v993.893406a15.257585 15.257585 0 0 1-15.155185 15.052785H15.155185A15.155185 15.155185 0 0 1 0 1008.844815V14.951409a15.257585 15.257585 0 0 1 15.155185-15.052785h106.086294a15.155185 15.155185 0 0 1 15.257585 15.155185zM1228.798771 14.951409v993.893406a15.257585 15.257585 0 0 1-15.155185 15.052785h-106.188693a15.155185 15.155185 0 0 1-15.155185-15.052785V14.951409a15.257585 15.257585 0 0 1 15.155185-15.052785h106.086293A15.155185 15.155185 0 0 1 1228.798771 15.053809z"></path></svg>';
-    // 合并单元格
-    var MERGE_CELL_SVG = '<svg viewBox="0 0 1024 1024"><path d="M482.2 508.4 331.3 389c-3-2.4-7.3-.2-7.3 3.6V478H184V184h204v128c0 2.2 1.8 4 4 4h60c2.2 0 4-1.8 4-4V144c0-15.5-12.5-28-28-28H144c-15.5 0-28 12.5-28 28v736c0 15.5 12.5 28 28 28h284c15.5 0 28-12.5 28-28V712c0-2.2-1.8-4-4-4h-60c-2.2 0-4 1.8-4 4v128H184V546h140v85.4c0 3.8 4.4 6 7.3 3.6l150.9-119.4c2.4-1.8 2.4-5.4 0-7.2zM880 116H596c-15.5 0-28 12.5-28 28v168c0 2.2 1.8 4 4 4h60c2.2 0 4-1.8 4-4V184h204v294H700v-85.4c0-3.8-4.3-6-7.3-3.6l-151 119.4c-2.3 1.8-2.3 5.3 0 7.1l151 119.5c2.9 2.3 7.3.2 7.3-3.6V546h140v294H636V712c0-2.2-1.8-4-4-4h-60c-2.2 0-4 1.8-4 4v168c0 15.5 12.5 28 28 28h284c15.5 0 28-12.5 28-28V144c0-15.5-12.5-28-28-28z"/></svg>';
-    // 拆分单元格
-    var SPLIT_CELL_SVG = '<svg viewBox="0 0 1024 1024"><path d="M362.667 494.933v53.334l25.6-25.6zm0-241.066L460.8 352V78.933H57.6v98.134h305.067zm0 535.466v57.6H57.6v98.134h403.2V691.2zM661.333 494.933v53.334l-25.6-25.6zm0-241.066L563.2 352V78.933h403.2v98.134H661.333zm0 535.466v57.6H966.4v98.134H563.2V691.2z"/><path d="M753.067 341.333 693.333 281.6 512 460.8 330.667 281.6l-59.734 59.733 181.334 181.334L270.933 704l59.734 59.733L512 582.4l181.333 181.333L753.067 704 571.733 522.667z"/></svg>';
+    var FULL_WIDTH_SVG = '<svg viewBox="0 0 1228 1024"><path d="M862.514337 563.200461H404.581995v121.753478a13.311987 13.311987 0 0 1-6.655993 11.468789 10.23999 10.23999 0 0 1-12.083188-1.433599l-204.799795-179.199821a13.721586 13.721586 0 0 1 0-20.479979l204.799795-179.302221a10.23999 10.23999 0 0 1 12.185588-1.535998 13.209587 13.209587 0 0 1 6.553593 11.673588v115.097485h457.932342V319.693504a11.571188 11.571188 0 0 1 18.841582-10.239989l204.799795 179.19982a13.721586 13.721586 0 0 1 0 20.47998l-204.799795 179.199821a10.23999 10.23999 0 0 1-12.185588 1.535998 13.311987 13.311987 0 0 1-6.655994-11.571188V563.200461zM136.499064 14.951409v993.893406a15.257585 15.257585 0 0 1-15.155185 15.052785H15.155185A15.155185 15.155185 0 0 1 0 1008.844815V14.951409a15.257585 15.257585 0 0 1 15.155185-15.052785h106.086294a15.155185 15.155185 0 0 1 15.257585 15.155185zM1228.798771 14.951409v993.893406a15.257585 15.257585 0 0 1-15.155185 15.052785h-106.188693a15.155185 15.155185 0 0 1-15.155185-15.052785V14.951409a15.257585 15.257585 0 0 1 15.155185-15.052785h106.086293A15.155185 15.155185 0 0 1 1228.798771 15.053809z"></path></svg>';
 
     /**
      * @description insert table menu
@@ -39936,7 +41153,6 @@
     function genTableNode(rowNum, colNum) {
         // 拼接 rows
         var rows = [];
-        var columnWidths = Array(colNum).fill(60);
         for (var i = 0; i < rowNum; i++) {
             // 拼接 cells
             var cells = [];
@@ -39960,7 +41176,6 @@
             type: 'table',
             width: 'auto',
             children: rows,
-            columnWidths: columnWidths,
         };
     }
     var InsertTable = /** @class */ (function () {
@@ -40082,12 +41297,6 @@
             if (core.DomEditor.isSelectedEmptyParagraph(editor)) {
                 slate.Transforms.removeNodes(editor, { mode: 'highest' });
             }
-            if (editor.children.length === 0) {
-                // table 作为第一个 children 时会导致无法正常删除
-                // 在当前位置插入空行，当前元素下移
-                var newElem = { type: 'paragraph', children: [{ text: '' }] };
-                slate.Transforms.insertNodes(editor, newElem, { mode: 'highest' });
-            }
             // 插入表格
             var tableNode = genTableNode(rowNum, colNum);
             slate.Transforms.insertNodes(editor, tableNode, { mode: 'highest' });
@@ -40176,56 +41385,19 @@
             var cellsLength = (rowNode === null || rowNode === void 0 ? void 0 : rowNode.children.length) || 0;
             if (cellsLength === 0)
                 return;
-            var matrix = filledMatrix(editor);
-            // 向下插入行为，先找到
-            // 当前选区所在的 tr 索引
-            var trIndex = 0;
-            outer: for (var x = 0; x < matrix.length; x++) {
-                for (var y = 0; y < matrix[x].length; y++) {
-                    var _c = __read(matrix[x][y], 1), _d = __read(_c[0], 2), path = _d[1];
-                    if (!slate.Path.equals(cellPath, path)) {
-                        continue;
-                    }
-                    trIndex = x;
-                    break outer;
-                }
+            // 拼接新的 row
+            var newRow = { type: 'table-row', children: [] };
+            for (var i = 0; i < cellsLength; i++) {
+                var cell = {
+                    type: 'table-cell',
+                    children: [{ text: '' }],
+                };
+                newRow.children.push(cell);
             }
-            slate.Editor.withoutNormalizing(editor, function () {
-                // 向下添加 tr 索引
-                var destIndex = trIndex + 1;
-                var isWithinBounds = destIndex >= 0 && destIndex < matrix.length;
-                var exitMerge = [];
-                for (var y = 0; isWithinBounds && y < matrix[trIndex].length; y++) {
-                    var _a = __read(matrix[trIndex][y], 2), _b = _a[1], ttb = _b.ttb, btt = _b.btt;
-                    // 向上找到 1 元素为止
-                    if (ttb > 1 || btt > 1) {
-                        if (btt == 1)
-                            continue;
-                        var _c = __read(matrix[trIndex - (ttb - 1)][y], 1), _d = __read(_c[0], 2), element = _d[0], path = _d[1];
-                        var rowSpan = element.rowSpan || 1;
-                        exitMerge.push(y);
-                        if (!element.hidden) {
-                            slate.Transforms.setNodes(editor, {
-                                rowSpan: rowSpan + 1,
-                            }, { at: path });
-                        }
-                    }
-                }
-                // 拼接新的 row
-                var newRow = { type: 'table-row', children: [] };
-                for (var i = 0; i < cellsLength; i++) {
-                    var cell = {
-                        type: 'table-cell',
-                        hidden: exitMerge.includes(i),
-                        children: [{ text: '' }],
-                    };
-                    newRow.children.push(cell);
-                }
-                // 插入 row
-                var rowPath = slate.Path.parent(cellPath); // 获取 tr 的 path
-                var newRowPath = slate.Path.next(rowPath);
-                slate.Transforms.insertNodes(editor, newRow, { at: newRowPath });
-            });
+            // 插入 row
+            var rowPath = slate.Path.parent(cellPath); // 获取 tr 的 path
+            var newRowPath = slate.Path.next(rowPath);
+            slate.Transforms.insertNodes(editor, newRow, { at: newRowPath });
         };
         return InsertRow;
     }());
@@ -40277,67 +41449,7 @@
                 return;
             }
             // row > 1 行，则删掉这一行
-            var _c = __read(slate.Editor.nodes(editor, {
-                match: function (n) { return core.DomEditor.checkNodeType(n, 'table-cell'); },
-                universal: true,
-            }), 1), cellEntry = _c[0];
-            var _d = __read(cellEntry, 2), cellPath = _d[1];
-            var matrix = filledMatrix(editor);
-            var trIndex = 0;
-            outer: for (var x = 0; x < matrix.length; x++) {
-                for (var y = 0; y < matrix[x].length; y++) {
-                    var _e = __read(matrix[x][y], 1), _f = __read(_e[0], 2), path = _f[1];
-                    if (!slate.Path.equals(cellPath, path)) {
-                        continue;
-                    }
-                    trIndex = x;
-                    break outer;
-                }
-            }
-            slate.Editor.withoutNormalizing(editor, function () {
-                var e_1, _a;
-                for (var y = 0; y < matrix[trIndex].length; y++) {
-                    var _b = __read(matrix[trIndex][y], 2), _c = __read(_b[0], 1), hidden = _c[0].hidden, _d = _b[1], ttb = _d.ttb, btt = _d.btt;
-                    // 寻找跨行行为
-                    if (ttb > 1 || btt > 1) {
-                        // 找到显示中 rowSpan 节点
-                        var _e = __read(matrix[trIndex - (ttb - 1)][y], 1), _f = __read(_e[0], 2), _g = _f[0], _h = _g.rowSpan, rowSpan = _h === void 0 ? 1 : _h, _j = _g.colSpan, colSpan = _j === void 0 ? 1 : _j, path = _f[1];
-                        // 如果当前选中节点为隐藏节点，则向上寻找处理 rowSpan 逻辑
-                        if (hidden) {
-                            slate.Transforms.setNodes(editor, {
-                                rowSpan: Math.max(rowSpan - 1, 1),
-                                colSpan: colSpan,
-                            }, { at: path });
-                        }
-                        else {
-                            var _k = __read(matrix[trIndex + 1][y], 1), _l = __read(_k[0], 2), belowPath = _l[1];
-                            slate.Transforms.setNodes(editor, {
-                                rowSpan: rowSpan - 1,
-                                colSpan: colSpan,
-                                hidden: false,
-                            }, { at: belowPath });
-                            try {
-                                // 移动单元格 文本、图片等元素
-                                for (var _m = (e_1 = void 0, __values(slate.Node.children(editor, path, { reverse: true }))), _o = _m.next(); !_o.done; _o = _m.next()) {
-                                    var _p = __read(_o.value, 2), childPath = _p[1];
-                                    slate.Transforms.moveNodes(editor, {
-                                        to: __spreadArray(__spreadArray([], __read(belowPath)), [0]),
-                                        at: childPath,
-                                    });
-                                }
-                            }
-                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                            finally {
-                                try {
-                                    if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
-                                }
-                                finally { if (e_1) throw e_1.error; }
-                            }
-                        }
-                    }
-                }
-                slate.Transforms.removeNodes(editor, { at: rowPath });
-            });
+            slate.Transforms.removeNodes(editor, { at: rowPath });
         };
         return DeleteRow;
     }());
@@ -40387,62 +41499,27 @@
             var tableNode = core.DomEditor.getParentNode(editor, rowNode);
             if (tableNode == null)
                 return;
-            var matrix = filledMatrix(editor);
-            var tdIndex = 0;
-            out: for (var x = 0; x < matrix.length; x++) {
-                for (var y = 0; y < matrix[x].length; y++) {
-                    var _c = __read(matrix[x][y], 1), _d = __read(_c[0], 2), path = _d[1];
-                    if (slate.Path.equals(selectedCellPath, path)) {
-                        tdIndex = y;
-                        break out;
-                    }
-                }
-            }
-            slate.Editor.withoutNormalizing(editor, function () {
-                var exitMerge = [];
-                for (var x = 0; x < matrix.length; x++) {
-                    var _a = __read(matrix[x][tdIndex], 2), _b = _a[1], ltr = _b.ltr, rtl = _b.rtl;
-                    // 向左找到 1 元素为止
-                    if (ltr > 1 || rtl > 1) {
-                        if (rtl == 1)
-                            continue;
-                        var _c = __read(matrix[x][tdIndex - (rtl - 1)], 1), _d = __read(_c[0], 2), element = _d[0], path = _d[1];
-                        var colSpan = element.colSpan || 1;
-                        exitMerge.push(x);
-                        if (!element.hidden) {
-                            slate.Transforms.setNodes(editor, {
-                                colSpan: colSpan + 1,
-                            }, { at: path });
+            // 遍历所有 rows ，挨个添加 cell
+            var rows = tableNode.children || [];
+            rows.forEach(function (row, rowIndex) {
+                if (!slate.Element.isElement(row))
+                    return;
+                var cells = row.children || [];
+                // 遍历一个 row 的所有 cells
+                cells.forEach(function (cell) {
+                    var path = core.DomEditor.findPath(editor, cell);
+                    if (path.length === selectedCellPath.length &&
+                        isEqual__default["default"](path.slice(-1), selectedCellPath.slice(-1)) // 俩数组，最后一位相同
+                    ) {
+                        // 如果当前 td 的 path 和选中 td 的 path ，最后一位相同，说明是同一列
+                        // 则在其后插入一个 cell
+                        var newCell = { type: 'table-cell', children: [{ text: '' }] };
+                        if (rowIndex === 0 && isTableWithHeader(tableNode)) {
+                            newCell.isHeader = true;
                         }
+                        slate.Transforms.insertNodes(editor, newCell, { at: path });
                     }
-                }
-                // 遍历所有 rows ，挨个添加 cell
-                for (var x = 0; x < matrix.length; x++) {
-                    var newCell = {
-                        type: 'table-cell',
-                        hidden: exitMerge.includes(x),
-                        children: [{ text: '' }],
-                    };
-                    if (x === 0 && isTableWithHeader(tableNode)) {
-                        newCell.isHeader = true;
-                    }
-                    var _e = __read(matrix[x][tdIndex], 1), _f = __read(_e[0], 2), insertPath = _f[1];
-                    slate.Transforms.insertNodes(editor, newCell, { at: insertPath });
-                }
-                // 需要调整 columnWidths
-                var _g = __read(slate.Editor.nodes(editor, {
-                    match: function (n) { return core.DomEditor.checkNodeType(n, 'table'); },
-                    universal: true,
-                }), 1), tableEntry = _g[0];
-                if (tableEntry) {
-                    var _h = __read(tableEntry, 2), elemNode = _h[0], tablePath = _h[1];
-                    var _j = elemNode.columnWidths, columnWidths = _j === void 0 ? [] : _j;
-                    var adjustColumnWidths = __spreadArray([], __read(columnWidths));
-                    adjustColumnWidths.splice(tdIndex, 0, 60);
-                    slate.Transforms.setNodes(editor, { columnWidths: adjustColumnWidths }, {
-                        at: tablePath,
-                    });
-                }
+                });
             });
         };
         return InsertCol;
@@ -40498,76 +41575,23 @@
             var tableNode = core.DomEditor.getParentNode(editor, rowNode);
             if (tableNode == null)
                 return;
-            var matrix = filledMatrix(editor);
-            var tdIndex = 0;
-            out: for (var x = 0; x < matrix.length; x++) {
-                for (var y = 0; y < matrix[x].length; y++) {
-                    var _c = __read(matrix[x][y], 1), _d = __read(_c[0], 2), path = _d[1];
-                    if (slate.Path.equals(selectedCellPath, path)) {
-                        tdIndex = y;
-                        break out;
-                    }
-                }
-            }
-            slate.Editor.withoutNormalizing(editor, function () {
-                var e_1, _a;
-                for (var x = 0; x < matrix.length; x++) {
-                    var _b = __read(matrix[x][tdIndex], 2), _c = __read(_b[0], 1), hidden = _c[0].hidden, _d = _b[1], rtl = _d.rtl, ltr = _d.ltr;
-                    if (rtl > 1 || ltr > 1) {
-                        // 找到显示中 colSpan 节点
-                        var _e = __read(matrix[x][tdIndex - (rtl - 1)], 1), _f = __read(_e[0], 2), _g = _f[0], _h = _g.rowSpan, rowSpan = _h === void 0 ? 1 : _h, _j = _g.colSpan, colSpan = _j === void 0 ? 1 : _j, path = _f[1];
-                        if (hidden) {
-                            slate.Transforms.setNodes(editor, {
-                                rowSpan: rowSpan,
-                                colSpan: Math.max(colSpan - 1, 1),
-                            }, { at: path });
-                        }
-                        else {
-                            var _k = __read(matrix[x][tdIndex + 1], 1), _l = __read(_k[0], 2), rightPath = _l[1];
-                            slate.Transforms.setNodes(editor, {
-                                rowSpan: rowSpan,
-                                colSpan: colSpan - 1,
-                                hidden: false,
-                            }, { at: rightPath });
-                            try {
-                                // 移动单元格 文本、图片等元素
-                                for (var _m = (e_1 = void 0, __values(slate.Node.children(editor, path, { reverse: true }))), _o = _m.next(); !_o.done; _o = _m.next()) {
-                                    var _p = __read(_o.value, 2), childPath = _p[1];
-                                    slate.Transforms.moveNodes(editor, {
-                                        to: __spreadArray(__spreadArray([], __read(rightPath)), [0]),
-                                        at: childPath,
-                                    });
-                                }
-                            }
-                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                            finally {
-                                try {
-                                    if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
-                                }
-                                finally { if (e_1) throw e_1.error; }
-                            }
-                        }
+            // 遍历所有 rows ，挨个删除 cell
+            var rows = tableNode.children || [];
+            rows.forEach(function (row) {
+                if (!slate.Element.isElement(row))
+                    return;
+                var cells = row.children || [];
+                // 遍历一个 row 的所有 cells
+                cells.forEach(function (cell) {
+                    var path = core.DomEditor.findPath(editor, cell);
+                    if (path.length === selectedCellPath.length &&
+                        isEqual__default["default"](path.slice(-1), selectedCellPath.slice(-1)) // 俩数组，最后一位相同
+                    ) {
+                        // 如果当前 td 的 path 和选中 td 的 path ，最后一位相同，说明是同一列
+                        // 删除当前的 cell
+                        slate.Transforms.removeNodes(editor, { at: path });
                     }
-                }
-                // 挨个删除 cell
-                for (var x = 0; x < matrix.length; x++) {
-                    var _q = __read(matrix[x][tdIndex], 1), _r = __read(_q[0], 2), path = _r[1];
-                    slate.Transforms.removeNodes(editor, { at: path });
-                }
-                // 需要调整 columnWidths
-                var _s = __read(slate.Editor.nodes(editor, {
-                    match: function (n) { return core.DomEditor.checkNodeType(n, 'table'); },
-                    universal: true,
-                }), 1), tableEntry = _s[0];
-                if (tableEntry) {
-                    var _t = __read(tableEntry, 2), elemNode = _t[0], tablePath = _t[1];
-                    var _u = elemNode.columnWidths, columnWidths = _u === void 0 ? [] : _u;
-                    var adjustColumnWidths = __spreadArray([], __read(columnWidths));
-                    adjustColumnWidths.splice(tdIndex, 1);
-                    slate.Transforms.setNodes(editor, { columnWidths: adjustColumnWidths }, {
-                        at: tablePath,
-                    });
-                }
+                });
             });
         };
         return DeleteCol;
@@ -40670,234 +41694,6 @@
         return TableFullWidth;
     }());
 
-    var MergeCell = /** @class */ (function () {
-        function MergeCell() {
-            this.title = core.t('tableModule.mergeCell');
-            this.iconSvg = MERGE_CELL_SVG;
-            this.tag = 'button';
-        }
-        MergeCell.prototype.getValue = function (editor) {
-            // 无需获取 val
-            return '';
-        };
-        MergeCell.prototype.isActive = function (editor) {
-            // 无需 active
-            return false;
-        };
-        MergeCell.prototype.isDisabled = function (editor) {
-            return !this.canMerge(editor);
-        };
-        MergeCell.prototype.exec = function (editor, value) {
-            if (this.isDisabled(editor))
-                return;
-            this.merge(editor);
-            // 释放选区
-            TableCursor.unselect(editor);
-        };
-        /**
-         * Checks if the current selection can be merged. Merging is not possible when any of the following conditions are met:
-         * - The selection is empty.
-         * - The selection is not within the same "thead", "tbody," or "tfoot" section.
-         * @returns {boolean} `true` if the selection can be merged, otherwise `false`.
-         */
-        MergeCell.prototype.canMerge = function (editor) {
-            var matrix = EDITOR_TO_SELECTION.get(editor);
-            // cannot merge when selection is empty
-            if (!matrix || !matrix.length) {
-                return false;
-            }
-            // prettier-ignore
-            var _a = __read(matrix[matrix.length - 1][matrix[matrix.length - 1].length - 1], 1), _b = __read(_a[0], 2), lastPath = _b[1];
-            var _c = __read(matrix[0][0], 1), _d = __read(_c[0], 2), firstPath = _d[1];
-            // cannot merge when selection is not in common section
-            if (!hasCommon(editor, [firstPath, lastPath], 'table')) {
-                return false;
-            }
-            return true;
-        };
-        /**
-         * Merges the selected cells in the table.
-         * @returns void
-         */
-        MergeCell.prototype.merge = function (editor) {
-            if (!this.canMerge(editor)) {
-                return;
-            }
-            var selection = EDITOR_TO_SELECTION.get(editor);
-            if (!selection || !selection.length) {
-                return;
-            }
-            var _a = __read(selection[0][0], 1), _b = __read(_a[0], 2), basePath = _b[1];
-            var _c = __read(slate.Node.children(editor, basePath, { reverse: true }), 1), _d = __read(_c[0], 2), lastPath = _d[1];
-            filledMatrix(editor, { at: basePath });
-            slate.Editor.withoutNormalizing(editor, function () {
-                var e_1, _a;
-                var rowSpan = 0;
-                var colSpan = 0;
-                for (var x = selection.length - 1; x >= 0; x--, rowSpan++) {
-                    colSpan = 0;
-                    for (var y = selection[x].length - 1; y >= 0; y--, colSpan++) {
-                        var _b = __read(selection[x][y], 2), _c = __read(_b[0], 2), path = _c[1], ttb = _b[1].ttb;
-                        // skip first cell and "fake" cells which belong to a cell with a `rowspan`
-                        if (slate.Path.equals(basePath, path) || ttb > 1) {
-                            continue;
-                        }
-                        try {
-                            // prettier-ignore
-                            for (var _d = (e_1 = void 0, __values(slate.Node.children(editor, path, { reverse: true }))), _e = _d.next(); !_e.done; _e = _d.next()) {
-                                var _f = __read(_e.value, 2), childPath = _f[1];
-                                slate.Transforms.moveNodes(editor, {
-                                    to: slate.Path.next(lastPath),
-                                    at: childPath,
-                                });
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        var _g = __read(slate.Editor.nodes(editor, {
-                            match: isOfType(editor, 'tr'),
-                            at: path,
-                        }), 1), _h = __read(_g[0], 2), trPath = _h[1];
-                        var _j = __read(slate.Node.children(editor, trPath), 2), sibling = _j[1];
-                        if (sibling) {
-                            /**
-                             * 删除节点调整成隐藏节点
-                             * 隐藏节点不会影响 table 布局
-                             */
-                            slate.Transforms.setNodes(editor, { hidden: true }, { at: path });
-                            continue;
-                        }
-                    }
-                }
-                slate.Transforms.setNodes(editor, { rowSpan: rowSpan, colSpan: colSpan }, { at: basePath });
-            });
-        };
-        return MergeCell;
-    }());
-
-    // import { DEFAULT_WITH_TABLE_OPTIONS } from "../../utils/options";
-    var SplitCell = /** @class */ (function () {
-        function SplitCell() {
-            this.title = core.t('tableModule.splitCell');
-            this.iconSvg = SPLIT_CELL_SVG;
-            this.tag = 'button';
-        }
-        SplitCell.prototype.getValue = function (editor) {
-            // 无需获取 val
-            return '';
-        };
-        SplitCell.prototype.isActive = function (editor) {
-            // 无需 active
-            return false;
-        };
-        SplitCell.prototype.isDisabled = function (editor) {
-            var _a = __read(slate.Editor.nodes(editor, {
-                match: isOfType(editor, 'td'),
-            }), 1), td = _a[0];
-            var _b = __read(td, 1), _c = _b[0], _d = _c.rowSpan, rowSpan = _d === void 0 ? 1 : _d, _e = _c.colSpan, colSpan = _e === void 0 ? 1 : _e;
-            if (rowSpan > 1 || colSpan > 1) {
-                return false;
-            }
-            return true;
-        };
-        SplitCell.prototype.exec = function (editor, value) {
-            if (this.isDisabled(editor))
-                return;
-            this.split(editor);
-        };
-        /**
-         * Splits either the cell at the current selection or a specified location. If a range
-         * selection is present, all cells within the range will be split.
-         * @param {Location} [options.at] - Splits the cell at the specified location. If no
-         * location is specified it will split the cell at the current selection
-         * @param {boolean} [options.all] - If true, splits all cells in the table
-         * @returns void
-         */
-        SplitCell.prototype.split = function (editor, options) {
-            if (options === void 0) { options = {}; }
-            var _a = __read(slate.Editor.nodes(editor, {
-                match: isOfType(editor, 'table', 'th', 'td'),
-                // @ts-ignore
-                at: options.at,
-            }), 2), table = _a[0], td = _a[1];
-            if (!table || !td) {
-                return;
-            }
-            var selection = EDITOR_TO_SELECTION.get(editor) || [];
-            // @ts-ignore
-            var matrix = filledMatrix(editor, { at: options.at });
-            // const { blocks } = DEFAULT_WITH_TABLE_OPTIONS;
-            slate.Editor.withoutNormalizing(editor, function () {
-                for (var x = matrix.length - 1; x >= 0; x--) {
-                    for (var y = matrix[x].length - 1; y >= 0; y--) {
-                        var _a = __read(matrix[x][y], 2), _b = __read(_a[0], 2), path = _b[1], context = _a[1];
-                        var colSpan = context.ltr, rtl = context.rtl, rowSpan = context.btt, ttb = context.ttb;
-                        if (rtl > 1) {
-                            // get to the start of the colspan
-                            y -= rtl - 2;
-                            continue;
-                        }
-                        if (ttb > 1) {
-                            continue;
-                        }
-                        if (rowSpan === 1 && colSpan === 1) {
-                            continue;
-                        }
-                        var found = !!options.all;
-                        if (selection.length) {
-                            outer: for (var i = 0; !options.all && i < selection.length; i++) {
-                                for (var j = 0; j < selection[i].length; j++) {
-                                    var _c = __read(selection[i][j], 1), _d = __read(_c[0], 2), tdPath = _d[1];
-                                    if (slate.Path.equals(tdPath, path)) {
-                                        found = true;
-                                        break outer;
-                                    }
-                                }
-                            }
-                        }
-                        else {
-                            var _e = __read(td, 2), tdPath = _e[1];
-                            if (slate.Path.equals(tdPath, path)) {
-                                found = true;
-                            }
-                        }
-                        if (!found) {
-                            continue;
-                        }
-                        var _f = __read(slate.Editor.nodes(editor, {
-                            match: isOfType(editor, 'table'),
-                            at: path,
-                        }), 1), _g = __read(_f[0], 1); _g[0];
-                        out: for (var r = 1; r < rowSpan; r++) {
-                            for (var i = y; i >= 0; i--) {
-                                var _h = __read(matrix[x + r][i], 2), _j = __read(_h[0], 2); _j[1]; var ttb_1 = _h[1].ttb;
-                                if (ttb_1 == 1) {
-                                    continue;
-                                }
-                                for (var c = 0; c < colSpan; c++) {
-                                    var _k = __read(matrix[x + r][i + c], 1), _l = __read(_k[0], 2), nextPath = _l[1];
-                                    slate.Transforms.unsetNodes(editor, ['hidden', 'colSpan', 'rowSpan'], { at: nextPath });
-                                }
-                                continue out;
-                            }
-                        }
-                        for (var c = 1; c < colSpan; c++) {
-                            var _m = __read(matrix[x][y + c], 1), _o = __read(_m[0], 2), nextPath = _o[1];
-                            slate.Transforms.unsetNodes(editor, ['hidden', 'colSpan', 'rowSpan'], { at: nextPath });
-                        }
-                        slate.Transforms.setNodes(editor, { rowSpan: 1, colSpan: 1 }, { at: path });
-                    }
-                }
-            });
-        };
-        return SplitCell;
-    }());
-
     /**
      * @description table menu
      * @author wangfupeng
@@ -40949,19 +41745,6 @@
         factory: function () {
             return new TableFullWidth();
         },
-    };
-    /** Meger / Split conf */
-    var mergeTableCellConf = {
-        key: 'mergeTableCell',
-        factory: function () {
-            return new MergeCell();
-        },
-    };
-    var splitTableCellConf = {
-        key: 'splitTableCell',
-        factory: function () {
-            return new SplitCell();
-        },
     };
 
     /**
@@ -40982,8 +41765,6 @@
             deleteTableColConf,
             tableHeaderMenuConf,
             tableFullWidthMenuConf,
-            mergeTableCellConf,
-            splitTableCellConf,
         ],
         editorPlugin: withTable,
     };
@@ -47951,9 +48732,6 @@
               'insertTableCol',
               'deleteTableCol',
               'deleteTable',
-              /** 注册单元格合并 拆分 */
-              'mergeTableCell',
-              'splitTableCell',
           ],
       },
       divider: {