@seafile/sdoc-editor 2.0.82 → 2.0.83

package/dist/extension/plugins/table/helpers.js

@@ -0,0 +1,2002 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateTableRowHeight = exports.updateColumnWidth = exports.syncRemoveTable = exports.splitCell = exports.setTableSelectedRange = exports.setTableFragmentData = exports.setCellStyle = exports.removeTableElement = exports.removeTable = exports.normalizeTableELement = exports.moveRows = exports.moveColumns = exports.isTableWidthFitScreen = exports.isTableMenuDisabled = exports.isTableLocation = exports.isSelectedAllCell = exports.isPreventResetTableSelectedRange = exports.isLastTableCell = exports.isInTableSameCell = exports.isInTable = exports.isHideDragHandlerLine = exports.isCursorAtCellStart = exports.isCursorAtCellEnd = exports.isCombineCellsDisabled = exports.isAllInTable = exports.insertTableRow = exports.insertTableElement = exports.insertTableColumn = exports.insertTableByTemplate = exports.insertTable = exports.insertMultipleRowsAndColumns = exports.handleInsertTable = exports.handleCombinedCellsBeforeDeleteTableRow = exports.handleCombinedCellsBeforeDeleteTableColumn = exports.handleCombinedCellsAfterInsertTableRow = exports.handleCombinedCellsAfterInsertTableColumn = exports.getTableSelectedRangeAfterDrag = exports.getTableRowSelectedRange = exports.getTableDragType = exports.getTableColumnsWidth = exports.getTableColumnsAfterInsertColumn = exports.getTableColumns = exports.getTableColumnSelectedRange = exports.getSelectedInfo = exports.getRowHeight = exports.getRowDomHeight = exports.getResizeMaskCellInfo = exports.getInsertPosition = exports.getHighlightClass = exports.getFirstTableCell = exports.getCellInheritStyles = exports.getCellHighlightClassName = exports.getCellColumn = exports.generateTableRow = exports.generateTableCell = exports.generateInheritStyle = exports.generateEmptyTable = exports.generateDragMoveElement = exports.focusClosestCellWhenJustifyCellSize = exports.focusCell = exports.fitTableColumnToScreen = exports.elementHasImage = exports.deleteTableSelectCells = exports.deleteTableRangeData = exports.deleteHandler = exports.combineCells = exports.colorBlend = exports.adjustCombinedCellRange = void 0;
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _objectSpread3 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _deepCopy = _interopRequireDefault(require("deep-copy"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../../constants");
+var _helpers = require("../../../node-id/helpers");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _objectUtils = _interopRequireDefault(require("../../../utils/object-utils"));
+var _constants2 = require("../../constants");
+var _core = require("../../core");
+var _constants3 = require("./constants");
+var isTableMenuDisabled = exports.isTableMenuDisabled = function isTableMenuDisabled(editor, readonly) {
+  if (readonly) return true;
+  var selection = editor.selection;
+  if (selection === null) return true;
+  if (!_slate.Range.isCollapsed(selection)) return true;
+  var _Editor$nodes = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        var type = (0, _core.getNodeType)(n);
+        if (!type && (0, _core.isTextNode)(n) && n.id) {
+          var parentNode = (0, _core.getParentNode)(editor.children, n.id);
+          type = (0, _core.getNodeType)(parentNode);
+        }
+        if (type.startsWith('header')) return true;
+        if (type === _constants2.ELEMENT_TYPE.TITLE) return true;
+        if (type === _constants2.ELEMENT_TYPE.SUBTITLE) return true;
+        if (type === _constants2.ELEMENT_TYPE.CODE_BLOCK) return true;
+        if (type === _constants2.ELEMENT_TYPE.ORDERED_LIST) return true;
+        if (type === _constants2.ELEMENT_TYPE.UNORDERED_LIST) return true;
+        if (type === _constants2.ELEMENT_TYPE.BLOCKQUOTE) return true;
+        if (type === _constants2.ELEMENT_TYPE.LIST_ITEM) return true;
+        if (type === _constants2.ELEMENT_TYPE.TABLE) return true;
+        if (type === _constants2.ELEMENT_TYPE.TABLE_CELL) return true;
+        if (type === _constants2.ELEMENT_TYPE.TABLE_ROW) return true;
+        if (type === _constants2.ELEMENT_TYPE.CALL_OUT) return true;
+        if (type === _constants2.ELEMENT_TYPE.MULTI_COLUMN) return true;
+        if (_slate.Editor.isVoid(editor, n)) return true;
+        return false;
+      },
+      universal: true
+    }),
+    _Editor$nodes2 = (0, _slicedToArray2["default"])(_Editor$nodes, 1),
+    match = _Editor$nodes2[0];
+  if (match) return true;
+  return false;
+};
+var isCombineCellsDisabled = exports.isCombineCellsDisabled = function isCombineCellsDisabled(editor, readonly) {
+  if (readonly) return true;
+  var selection = editor.selection,
+    tableSelectedRange = editor.tableSelectedRange;
+  if (!selection) return true;
+  if (!_objectUtils["default"].isSameObject(tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+    return false;
+  }
+  return true;
+};
+var generateTableCell = exports.generateTableCell = function generateTableCell(editor, rowIndex, cellIndex) {
+  var style = {};
+  var tableNodeEntry = (0, _core.getSelectedNodeEntryByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
+  if (tableNodeEntry && rowIndex !== undefined && cellIndex !== undefined) {
+    var _tableNodeEntry = (0, _slicedToArray2["default"])(tableNodeEntry, 2),
+      tablePath = _tableNodeEntry[1];
+    style = getCellInheritStyles(editor, tablePath, rowIndex, cellIndex);
+  }
+  return {
+    id: _slugid["default"].nice(),
+    type: _constants2.ELEMENT_TYPE.TABLE_CELL,
+    children: [{
+      text: '',
+      id: _slugid["default"].nice()
+    }],
+    style: style,
+    inherit_style: style
+  };
+};
+var generateTableRow = exports.generateTableRow = function generateTableRow(editor, colsCount, rowIndex) {
+  var children = [];
+  for (var i = 0; i < colsCount; i++) {
+    var tableCell = generateTableCell(editor, rowIndex, i);
+    children.push(tableCell);
+  }
+  return {
+    id: _slugid["default"].nice(),
+    type: _constants2.ELEMENT_TYPE.TABLE_ROW,
+    children: children,
+    style: (0, _defineProperty2["default"])({}, _constants3.TABLE_ROW_STYLE.MIN_HEIGHT, _constants3.TABLE_ROW_MIN_HEIGHT)
+  };
+};
+
+/**
+ * @param {Editor} editor
+ * @param {Object} tableProps
+ * @param {[number,number]} tableProps.size - table size, [row,column]
+ * @param {Boolean} tableProps.alternate_highlight - is alternate highlight
+ * @param {string} tableProps.alternate_highlight_color - table alternate highlight color
+ */
+var generateEmptyTable = exports.generateEmptyTable = function generateEmptyTable(editor, tableProps) {
+  var _tableProps$size = tableProps.size,
+    size = _tableProps$size === void 0 ? [0, 0] : _tableProps$size,
+    _tableProps$alternate = tableProps.alternate_highlight,
+    alternate_highlight = _tableProps$alternate === void 0 ? false : _tableProps$alternate,
+    alternate_highlight_color = tableProps.alternate_highlight_color;
+  var rowsCount = size[0];
+  var colsCount = size[1];
+  var children = [];
+  for (var i = 0; i < rowsCount; i++) {
+    var tableRow = generateTableRow(editor, colsCount, i);
+    children.push(tableRow);
+  }
+  var columnWidth = Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colsCount));
+  var columns = [];
+  for (var _i = 0; _i < colsCount; _i++) {
+    columns.push({
+      width: columnWidth
+    });
+  }
+  return {
+    id: _slugid["default"].nice(),
+    type: _constants2.ELEMENT_TYPE.TABLE,
+    children: children,
+    columns: columns,
+    ui: {
+      alternate_highlight: alternate_highlight,
+      alternate_highlight_color: alternate_highlight_color
+    },
+    style: {
+      gridTemplateColumns: "repeat(".concat(colsCount, ", ").concat(columnWidth, "px)"),
+      gridAutoRows: "minmax(".concat(_constants3.TABLE_ROW_MIN_HEIGHT, "px, auto)")
+    }
+  };
+};
+var insertTable = exports.insertTable = function insertTable(editor, size, selection) {
+  var position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants2.INSERT_POSITION.CURRENT;
+  if (!size) return;
+  if (position !== _constants2.INSERT_POSITION.AFTER) {
+    if (isTableMenuDisabled(editor)) return;
+  }
+  var tableNode = generateEmptyTable(editor, {
+    size: size
+  });
+  var validSelection = selection || editor.selection;
+  var path = _slate.Editor.path(editor, validSelection);
+  handleInsertTable(editor, position, path, tableNode);
+};
+
+// tableSize [tableHeight, tableWidth]
+var getSelectedInfo = exports.getSelectedInfo = function getSelectedInfo(editor) {
+  var currentTable = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
+  var currentRow = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE_ROW);
+  var currentCell = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE_CELL);
+  var currentCellPath = (0, _core.findPath)(editor, currentCell);
+  return {
+    table: currentTable,
+    tablePath: (0, _core.findPath)(editor, currentTable),
+    tableSize: [currentTable.children.length, currentRow.children.length],
+    row: currentRow,
+    rowPath: (0, _core.findPath)(editor, currentRow),
+    rowIndex: currentCellPath[currentCellPath.length - 2],
+    cell: currentCell,
+    cellPath: (0, _core.findPath)(editor, currentCell),
+    cellIndex: currentCellPath[currentCellPath.length - 1]
+  };
+};
+var isInTable = exports.isInTable = function isInTable(editor) {
+  var selectedNodes = (0, _core.getSelectedElems)(editor);
+  if (!selectedNodes.some(function (node) {
+    return node.type === _constants2.ELEMENT_TYPE.TABLE;
+  })) return false;
+  var firstSelectedNode = selectedNodes[0];
+  return firstSelectedNode.type === _constants2.ELEMENT_TYPE.TABLE;
+};
+var isAllInTable = exports.isAllInTable = function isAllInTable(editor) {
+  var selectedNodes = (0, _core.getSelectedElems)(editor);
+  if (!selectedNodes.some(function (node) {
+    return node.type === _constants2.ELEMENT_TYPE.TABLE;
+  })) return false;
+  var firstSelectedNode = selectedNodes[0];
+  if (firstSelectedNode.type !== _constants2.ELEMENT_TYPE.TABLE) return false;
+  return selectedNodes.slice(1).every(function (node) {
+    return [_constants2.ELEMENT_TYPE.TABLE_ROW, _constants2.ELEMENT_TYPE.TABLE_CELL].includes(node.type);
+  }); // same table element
+};
+var isInTableSameCell = exports.isInTableSameCell = function isInTableSameCell(editor) {
+  var _editor$selection = editor.selection,
+    anchor = _editor$selection.anchor,
+    focus = _editor$selection.focus;
+  var match = function match(n) {
+    return n.type === _constants2.ELEMENT_TYPE.TABLE_CELL;
+  };
+  var anchorNode = (0, _core.getAboveBlockNode)(editor, {
+    at: anchor,
+    match: match
+  });
+  var focusNode = (0, _core.getAboveBlockNode)(editor, {
+    at: focus,
+    match: match
+  });
+  if (!anchorNode || !focusNode) return false;
+  return _slate.Path.equals(anchorNode[1], focusNode[1]);
+};
+var setCellStyle = exports.setCellStyle = function setCellStyle(editor, style) {
+  // Select single cell
+  if (_objectUtils["default"].isSameObject(editor.tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+    var selectedNodes = (0, _core.getSelectedElems)(editor);
+    var firstTableCellNodePath;
+    selectedNodes.forEach(function (node) {
+      if (node.type === _constants2.ELEMENT_TYPE.TABLE_CELL) {
+        var path = (0, _core.findPath)(editor, node);
+        if (path) {
+          firstTableCellNodePath = firstTableCellNodePath ? firstTableCellNodePath : path;
+          _slate.Transforms.setNodes(editor, {
+            style: (0, _objectSpread3["default"])((0, _objectSpread3["default"])({}, node.style), style),
+            inherit_style: generateInheritStyle(_constants3.INHERIT_CELL_STYLE_WHEN_SELECT_SINGLE, style, node)
+          }, {
+            at: path
+          });
+        }
+      }
+    });
+    if (firstTableCellNodePath) {
+      var start = _slate.Editor.start(editor, firstTableCellNodePath);
+      var end = _slate.Editor.end(editor, firstTableCellNodePath);
+      var newSelection = {
+        anchor: start,
+        focus: end
+      };
+      _slate.Transforms.select(editor, newSelection);
+    }
+    return;
+  }
+  // Select multiple cells
+  var _editor$tableSelected = editor.tableSelectedRange,
+    minColIndex = _editor$tableSelected.minColIndex,
+    maxColIndex = _editor$tableSelected.maxColIndex,
+    minRowIndex = _editor$tableSelected.minRowIndex,
+    maxRowIndex = _editor$tableSelected.maxRowIndex;
+  var _getSelectedInfo = getSelectedInfo(editor),
+    tablePath = _getSelectedInfo.tablePath;
+  for (var i = minRowIndex; i <= maxRowIndex; i++) {
+    for (var j = minColIndex; j <= maxColIndex; j++) {
+      var path = [].concat((0, _toConsumableArray2["default"])(tablePath), [i, j]);
+      var node = (0, _core.getNode)(editor, path);
+      _slate.Transforms.setNodes(editor, {
+        style: (0, _objectSpread3["default"])((0, _objectSpread3["default"])({}, node.style), style),
+        inherit_style: generateInheritStyle(_constants3.INHERIT_CELL_STYLE_WHEN_SELECT_MULTIPLE, style, node)
+      }, {
+        at: path
+      });
+    }
+  }
+};
+var insertTableRow = exports.insertTableRow = function insertTableRow(editor, table, rowIndex) {
+  var position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants3.TABLE_ELEMENT_POSITION.AFTER;
+  var tableRowCount = table.children.length;
+  if (tableRowCount >= _constants3.TABLE_MAX_ROWS) return;
+  var tableColumnCount = table.children[0].children.length;
+  var row = generateTableRow(editor, tableColumnCount, rowIndex);
+  var tablePath = (0, _core.findPath)(editor, table);
+  var targetPath = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex + 1]) : [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex]);
+  _slate.Transforms.insertNodes(editor, row, {
+    at: targetPath
+  });
+  var focusPath = [].concat((0, _toConsumableArray2["default"])(targetPath), [0]);
+  (0, _core.focusEditor)(editor, focusPath);
+
+  // handle cells with the rowspan > 1
+  if (position === _constants3.TABLE_ELEMENT_POSITION.AFTER) {
+    handleCombinedCellsAfterInsertTableRow(editor, tablePath, table, rowIndex);
+  }
+};
+var handleCombinedCellsAfterInsertTableRow = exports.handleCombinedCellsAfterInsertTableRow = function handleCombinedCellsAfterInsertTableRow(editor, tablePath, table, rowIndex) {
+  // important background info: the new row is inserted after rowIndex
+  var cells = table.children[rowIndex].children;
+  for (var i = 0, len = cells.length; i < len; i++) {
+    var _cells$i = cells[i],
+      is_combined = _cells$i.is_combined,
+      rowspan = _cells$i.rowspan,
+      colspan = _cells$i.colspan;
+    if (is_combined) {
+      for (var ri = rowIndex - 1; ri >= 0; ri--) {
+        var _table$children$ri$ch = table.children[ri].children[i],
+          ri_is_combined = _table$children$ri$ch.is_combined,
+          ri_rowspan = _table$children$ri$ch.rowspan,
+          ri_colspan = _table$children$ri$ch.colspan;
+        if (!ri_is_combined && ri + ri_rowspan - 1 > rowIndex) {
+          _slate.Transforms.setNodes(editor, {
+            rowspan: ri_rowspan + 1
+          }, {
+            at: [].concat((0, _toConsumableArray2["default"])(tablePath), [ri, i])
+          });
+          for (var j = 0; j < ri_colspan; j++) {
+            _slate.Transforms.setNodes(editor, {
+              'is_combined': true
+            }, {
+              at: [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex + 1, i + j])
+            });
+          }
+          break;
+        }
+      }
+    } else {
+      if (rowspan > 1) {
+        _slate.Transforms.setNodes(editor, {
+          rowspan: rowspan + 1
+        }, {
+          at: [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, i])
+        });
+        for (var _j = 0; _j < colspan; _j++) {
+          _slate.Transforms.setNodes(editor, {
+            'is_combined': true
+          }, {
+            at: [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex + 1, i + _j])
+          });
+        }
+      }
+    }
+  }
+};
+var insertTableColumn = exports.insertTableColumn = function insertTableColumn(editor, table, columnIndex) {
+  var position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants3.TABLE_ELEMENT_POSITION.AFTER;
+  var tableColumnCount = table.children[0].children.length;
+  if (tableColumnCount >= _constants3.TABLE_MAX_COLUMNS) return;
+  var newCellIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? columnIndex + 1 : columnIndex;
+  var newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, 1);
+  updateColumnWidth(editor, table, newColumns);
+  var tablePath = (0, _core.findPath)(editor, table);
+  var tableRowCount = table.children.length;
+  for (var i = 0; i < tableRowCount; i++) {
+    var newCellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [i, newCellIndex]);
+    var newCell = generateTableCell(editor, i, columnIndex);
+    _slate.Transforms.insertNodes(editor, newCell, {
+      at: newCellPath
+    });
+  }
+  var focusPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [0, newCellIndex, 0]);
+  (0, _core.focusEditor)(editor, focusPath);
+
+  // handle cells with the colspan > 1
+  if (position === _constants3.TABLE_ELEMENT_POSITION.AFTER) {
+    handleCombinedCellsAfterInsertTableColumn(editor, tablePath, table, columnIndex);
+  }
+};
+var handleCombinedCellsAfterInsertTableColumn = exports.handleCombinedCellsAfterInsertTableColumn = function handleCombinedCellsAfterInsertTableColumn(editor, tablePath, table, columnIndex) {
+  // important background info: the new column is inserted after columnIndex
+  for (var i = 0, len = table.children.length; i < len; i++) {
+    var _table$children$i$chi = table.children[i].children[columnIndex],
+      is_combined = _table$children$i$chi.is_combined,
+      rowspan = _table$children$i$chi.rowspan,
+      colspan = _table$children$i$chi.colspan;
+    if (is_combined) {
+      for (var ci = columnIndex - 1; ci >= 0; ci--) {
+        var _table$children$i$chi2 = table.children[i].children[ci],
+          ci_is_combined = _table$children$i$chi2.is_combined,
+          ci_rowspan = _table$children$i$chi2.rowspan,
+          ci_colspan = _table$children$i$chi2.colspan;
+        if (!ci_is_combined && ci + ci_colspan - 1 > columnIndex) {
+          _slate.Transforms.setNodes(editor, {
+            colspan: ci_colspan + 1
+          }, {
+            at: [].concat((0, _toConsumableArray2["default"])(tablePath), [i, ci])
+          });
+          for (var j = 0; j < ci_rowspan; j++) {
+            _slate.Transforms.setNodes(editor, {
+              'is_combined': true
+            }, {
+              at: [].concat((0, _toConsumableArray2["default"])(tablePath), [i + j, columnIndex + 1])
+            });
+          }
+          break;
+        }
+      }
+    } else {
+      if (colspan > 1) {
+        _slate.Transforms.setNodes(editor, {
+          colspan: colspan + 1
+        }, {
+          at: [].concat((0, _toConsumableArray2["default"])(tablePath), [i, columnIndex])
+        });
+        for (var _j2 = 0; _j2 < rowspan; _j2++) {
+          _slate.Transforms.setNodes(editor, {
+            'is_combined': true
+          }, {
+            at: [].concat((0, _toConsumableArray2["default"])(tablePath), [i + _j2, columnIndex + 1])
+          });
+        }
+      }
+    }
+  }
+};
+var insertTableElement = exports.insertTableElement = function insertTableElement(editor, type) {
+  var position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _constants3.TABLE_ELEMENT_POSITION.AFTER;
+  var count = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  var _getSelectedInfo2 = getSelectedInfo(editor),
+    table = _getSelectedInfo2.table,
+    tablePath = _getSelectedInfo2.tablePath,
+    tableSize = _getSelectedInfo2.tableSize,
+    rowIndex = _getSelectedInfo2.rowIndex,
+    cellIndex = _getSelectedInfo2.cellIndex;
+  var eventBus = _eventBus["default"].getInstance();
+  eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+  if (type === _constants3.TABLE_ELEMENT.ROW) {
+    if (tableSize[0] >= _constants3.TABLE_MAX_ROWS) return;
+    var targetPath = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex + 1]) : [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex]);
+    var validCount = Math.min(_constants3.TABLE_MAX_ROWS - tableSize[0], count);
+    for (var i = 0; i < validCount; i++) {
+      var row = generateTableRow(editor, tableSize[1], rowIndex);
+      _slate.Transforms.insertNodes(editor, row, {
+        at: targetPath
+      });
+      // handle combined cells
+      if (!(rowIndex === 0 && position === _constants3.TABLE_ELEMENT_POSITION.BEFORE)) {
+        var targetRowIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? rowIndex : rowIndex - 1;
+        var currentTable = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
+        handleCombinedCellsAfterInsertTableRow(editor, tablePath, currentTable, targetRowIndex);
+      }
+    }
+    var focusPath = [].concat((0, _toConsumableArray2["default"])(targetPath), [cellIndex]);
+    (0, _core.focusEditor)(editor, focusPath);
+    return;
+  }
+  if (type === _constants3.TABLE_ELEMENT.COLUMN) {
+    if (tableSize[1] >= _constants3.TABLE_MAX_COLUMNS) return;
+    var newCellIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? cellIndex + 1 : cellIndex;
+    var _validCount = Math.min(_constants3.TABLE_MAX_COLUMNS - tableSize[1], count);
+    var newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, _validCount);
+    updateColumnWidth(editor, table, newColumns);
+    for (var j = 0; j < _validCount; j++) {
+      for (var _i2 = 0; _i2 < tableSize[0]; _i2++) {
+        var newCellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [_i2, newCellIndex]);
+        var newCell = generateTableCell(editor, _i2, cellIndex);
+        _slate.Transforms.insertNodes(editor, newCell, {
+          at: newCellPath
+        });
+      }
+      // handle combined cells
+      if (!(cellIndex === 0 && position === _constants3.TABLE_ELEMENT_POSITION.BEFORE)) {
+        var targetColumnIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? cellIndex : cellIndex - 1;
+        var _currentTable = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
+        handleCombinedCellsAfterInsertTableColumn(editor, tablePath, _currentTable, targetColumnIndex);
+      }
+    }
+    var _focusPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, cellIndex + 1, 0]);
+    (0, _core.focusEditor)(editor, _focusPath);
+    return;
+  }
+};
+var combineCells = exports.combineCells = function combineCells(editor) {
+  var _getSelectedInfo3 = getSelectedInfo(editor),
+    tablePath = _getSelectedInfo3.tablePath;
+  var _editor$tableSelected2 = editor.tableSelectedRange,
+    minColIndex = _editor$tableSelected2.minColIndex,
+    maxColIndex = _editor$tableSelected2.maxColIndex,
+    minRowIndex = _editor$tableSelected2.minRowIndex,
+    maxRowIndex = _editor$tableSelected2.maxRowIndex;
+  var newCellContent = [];
+  for (var i = minRowIndex; i < maxRowIndex + 1; i++) {
+    for (var j = minColIndex; j < maxColIndex + 1; j++) {
+      var nodePath = [].concat((0, _toConsumableArray2["default"])(tablePath), [i, j]);
+      var node = _slate.Editor.node(editor, nodePath);
+      if (node[0].is_combined) {
+        continue;
+      }
+      _slate.Transforms.setNodes(editor, {
+        'is_combined': true
+      }, {
+        at: nodePath
+      });
+      newCellContent = newCellContent.concat(node[0].children);
+    }
+  }
+  var targetCellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [minRowIndex, minColIndex]);
+  var newCell = generateTableCell(editor);
+  newCell.children = newCellContent;
+  newCell.rowspan = maxRowIndex - minRowIndex + 1;
+  newCell.colspan = maxColIndex - minColIndex + 1;
+  // keep row.children.length not changed
+  _slate.Transforms.removeNodes(editor, {
+    at: targetCellPath
+  });
+  _slate.Transforms.insertNodes(editor, newCell, {
+    at: targetCellPath
+  });
+  (0, _core.focusEditor)(editor, targetCellPath);
+
+  // for clicking the 'combine cell' icon in the toolbar
+  var eventBus = _eventBus["default"].getInstance();
+  eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+};
+var splitCell = exports.splitCell = function splitCell(editor, rowNumber, columnNumber) {
+  if (rowNumber === 1 && columnNumber === 1) {
+    return;
+  }
+  var _getSelectedInfo4 = getSelectedInfo(editor),
+    cell = _getSelectedInfo4.cell,
+    rowIndex = _getSelectedInfo4.rowIndex,
+    cellIndex = _getSelectedInfo4.cellIndex,
+    cellPath = _getSelectedInfo4.cellPath,
+    tablePath = _getSelectedInfo4.tablePath;
+  var rowspan = cell.rowspan,
+    colspan = cell.colspan;
+  var rowspanBase = Math.floor(rowspan / rowNumber);
+  var rowspanLeft = rowspan % rowNumber;
+  var colspanBase = Math.floor(colspan / columnNumber);
+  var colspanLeft = colspan % columnNumber;
+  var cellNumber = rowNumber * columnNumber;
+  var dataBlockNumber = Math.ceil(cell.children.length / cellNumber);
+  var firstNewCell;
+  var rowspanSum = 0;
+  for (var i = 0; i < rowNumber; i++) {
+    var newRowSpan = rowspanBase + (i + 1 <= rowspanLeft ? 1 : 0);
+    var colspanSum = 0;
+    for (var j = 0; j < columnNumber; j++) {
+      var newCell = generateTableCell(editor);
+      var startIndex = (i * columnNumber + j) * dataBlockNumber;
+      if (startIndex < cell.children.length) {
+        var endIndex = Math.min(startIndex + dataBlockNumber, cell.children.length);
+        newCell.children = cell.children.slice(startIndex, endIndex);
+      }
+      newCell.rowspan = newRowSpan;
+      newCell.colspan = colspanBase + (j + 1 <= colspanLeft ? 1 : 0);
+      var newRowIndex = rowIndex + rowspanSum;
+      var newCellIndex = cellIndex + colspanSum;
+      var targetCellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [newRowIndex, newCellIndex]);
+      if (i === 0 && j === 0) {
+        firstNewCell = newCell;
+      } else {
+        _slate.Transforms.removeNodes(editor, {
+          at: targetCellPath
+        });
+        _slate.Transforms.insertNodes(editor, newCell, {
+          at: targetCellPath
+        });
+      }
+      colspanSum += newCell.colspan;
+    }
+    rowspanSum += newRowSpan;
+  }
+  _slate.Transforms.removeNodes(editor, {
+    at: cellPath
+  });
+  _slate.Transforms.insertNodes(editor, firstNewCell, {
+    at: cellPath
+  });
+};
+var syncRemoveTable = exports.syncRemoveTable = function syncRemoveTable(editor, path) {
+  var validPath = path;
+  if (!validPath) {
+    var _getSelectedInfo5 = getSelectedInfo(editor),
+      tablePath = _getSelectedInfo5.tablePath;
+    validPath = tablePath;
+  }
+  editor.reSetTableSelectedRange();
+  _slate.Transforms.removeNodes(editor, {
+    at: validPath
+  });
+};
+var removeTable = exports.removeTable = function removeTable(editor, path) {
+  var validPath = path;
+  if (!validPath) {
+    var _getSelectedInfo6 = getSelectedInfo(editor),
+      tablePath = _getSelectedInfo6.tablePath;
+    validPath = tablePath;
+  }
+  editor.reSetTableSelectedRange();
+
+  // Clicking the menu causes the table to be re-rendered, and the deletion operation is performed synchronously. When rendering, it is found that the data is lost and an error is reported.
+  setTimeout(function () {
+    _slate.Transforms.removeNodes(editor, {
+      at: validPath
+    });
+    if (_slate.Editor.hasPath(editor, validPath)) {
+      var endOfLastNodePoint = _slate.Editor.end(editor, validPath);
+      var range = {
+        anchor: endOfLastNodePoint,
+        focus: endOfLastNodePoint
+      };
+      (0, _core.focusEditor)(editor, range);
+    }
+  }, 0);
+};
+var removeTableElement = exports.removeTableElement = function removeTableElement(editor, type) {
+  var _getSelectedInfo7 = getSelectedInfo(editor),
+    table = _getSelectedInfo7.table,
+    tablePath = _getSelectedInfo7.tablePath,
+    tableSize = _getSelectedInfo7.tableSize,
+    rowPath = _getSelectedInfo7.rowPath,
+    rowIndex = _getSelectedInfo7.rowIndex,
+    cellIndex = _getSelectedInfo7.cellIndex;
+  var eventBus = _eventBus["default"].getInstance();
+  eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+  if (type === _constants3.TABLE_ELEMENT.TABLE) {
+    removeTable(editor, tablePath);
+    return;
+  }
+  if (type === _constants3.TABLE_ELEMENT.ROW) {
+    if (tableSize[0] === 1) {
+      removeTable(editor, tablePath);
+      return;
+    }
+    if (!_objectUtils["default"].isSameObject(editor.tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+      var _editor$tableSelected3 = editor.tableSelectedRange,
+        minRowIndex = _editor$tableSelected3.minRowIndex,
+        maxRowIndex = _editor$tableSelected3.maxRowIndex;
+      if (minRowIndex === 0 && maxRowIndex === tableSize[0] - 1) {
+        removeTable(editor, tablePath);
+        return;
+      }
+      for (var i = minRowIndex; i <= maxRowIndex; i++) {
+        queueMicrotask(function () {
+          _slate.Transforms.removeNodes(editor, {
+            at: [].concat((0, _toConsumableArray2["default"])(tablePath), [minRowIndex])
+          });
+        });
+      }
+      var _focusPath2 = [].concat((0, _toConsumableArray2["default"])(tablePath), [minRowIndex === 0 ? 0 : minRowIndex - 1, cellIndex]);
+      (0, _core.focusEditor)(editor, _focusPath2);
+      return;
+    }
+    handleCombinedCellsBeforeDeleteTableRow(editor, tablePath, table, rowIndex);
+    _slate.Transforms.removeNodes(editor, {
+      at: rowPath
+    });
+    var focusRowIndex = rowIndex === tableSize[0] - 1 ? rowIndex - 1 : rowIndex;
+    var focusPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [focusRowIndex, cellIndex]);
+    (0, _core.focusEditor)(editor, focusPath);
+    return;
+  }
+  if (type === _constants3.TABLE_ELEMENT.COLUMN) {
+    if (tableSize[1] === 1) {
+      removeTable(editor, tablePath);
+      return;
+    }
+    if (!_objectUtils["default"].isSameObject(editor.tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+      var _editor$tableSelected4 = editor.tableSelectedRange,
+        minColIndex = _editor$tableSelected4.minColIndex,
+        maxColIndex = _editor$tableSelected4.maxColIndex;
+      if (minColIndex === 0 && maxColIndex === tableSize[1] - 1) {
+        removeTable(editor, tablePath);
+        return;
+      }
+      var _columns = getTableColumns(editor, table);
+      var _newColumns = [].concat((0, _toConsumableArray2["default"])(_columns.slice(0, minColIndex)), (0, _toConsumableArray2["default"])(_columns.slice(maxColIndex + 1)));
+      updateColumnWidth(editor, table, _newColumns);
+      for (var _i3 = 0; _i3 < tableSize[0]; _i3++) {
+        for (var j = minColIndex; j <= maxColIndex; j++) {
+          // count
+          var cellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [_i3, minColIndex]);
+          _slate.Transforms.removeNodes(editor, {
+            at: cellPath
+          });
+        }
+      }
+      var _focusPath3 = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, minColIndex === 0 ? 0 : minColIndex - 1]);
+      (0, _core.focusEditor)(editor, _focusPath3);
+      return;
+    }
+    var columns = getTableColumns(editor, table);
+    var newColumns = columns.slice(0);
+    newColumns.splice(cellIndex, 1);
+    updateColumnWidth(editor, table, newColumns);
+    handleCombinedCellsBeforeDeleteTableColumn(editor, tablePath, table, cellIndex);
+    for (var _i4 = 0; _i4 < tableSize[0]; _i4++) {
+      var _cellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [_i4, cellIndex]);
+      _slate.Transforms.removeNodes(editor, {
+        at: _cellPath
+      });
+    }
+    var focusCellIndex = cellIndex === tableSize[1] - 1 ? cellIndex - 1 : cellIndex;
+    var _focusPath4 = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, focusCellIndex]);
+    (0, _core.focusEditor)(editor, _focusPath4);
+    return;
+  }
+};
+
+// handle combined cells before deleting a row
+var handleCombinedCellsBeforeDeleteTableRow = exports.handleCombinedCellsBeforeDeleteTableRow = function handleCombinedCellsBeforeDeleteTableRow(editor, tablePath, table, rowIndex) {
+  var cells = table.children[rowIndex].children;
+  for (var i = 0, len = cells.length; i < len; i++) {
+    var _cells$i2 = cells[i],
+      is_combined = _cells$i2.is_combined,
+      rowspan = _cells$i2.rowspan,
+      colspan = _cells$i2.colspan;
+    if (is_combined) {
+      for (var ri = rowIndex - 1; ri >= 0; ri--) {
+        var _table$children$ri$ch2 = table.children[ri].children[i],
+          ri_is_combined = _table$children$ri$ch2.is_combined,
+          ri_rowspan = _table$children$ri$ch2.rowspan;
+        if (!ri_is_combined && ri + ri_rowspan - 1 >= rowIndex) {
+          _slate.Transforms.setNodes(editor, {
+            rowspan: ri_rowspan - 1
+          }, {
+            at: [].concat((0, _toConsumableArray2["default"])(tablePath), [ri, i])
+          });
+          break;
+        }
+      }
+    } else {
+      if (rowspan > 1) {
+        var targetCellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex + 1, i]);
+        var newCell = generateTableCell(editor);
+        newCell.rowspan = rowspan - 1;
+        newCell.colspan = colspan;
+        _slate.Transforms.removeNodes(editor, {
+          at: targetCellPath
+        });
+        _slate.Transforms.insertNodes(editor, newCell, {
+          at: targetCellPath
+        });
+      }
+    }
+  }
+};
+
+// handle combined cells before deleting a column
+var handleCombinedCellsBeforeDeleteTableColumn = exports.handleCombinedCellsBeforeDeleteTableColumn = function handleCombinedCellsBeforeDeleteTableColumn(editor, tablePath, table, columnIndex) {
+  for (var i = 0, len = table.children.length; i < len; i++) {
+    var _table$children$i$chi3 = table.children[i].children[columnIndex],
+      is_combined = _table$children$i$chi3.is_combined,
+      rowspan = _table$children$i$chi3.rowspan,
+      colspan = _table$children$i$chi3.colspan;
+    if (is_combined) {
+      for (var ci = columnIndex - 1; ci >= 0; ci--) {
+        var _table$children$i$chi4 = table.children[i].children[ci],
+          ci_is_combined = _table$children$i$chi4.is_combined,
+          ci_colspan = _table$children$i$chi4.colspan;
+        if (!ci_is_combined && ci + ci_colspan - 1 >= columnIndex) {
+          _slate.Transforms.setNodes(editor, {
+            colspan: ci_colspan - 1
+          }, {
+            at: [].concat((0, _toConsumableArray2["default"])(tablePath), [i, ci])
+          });
+          break;
+        }
+      }
+    } else {
+      if (colspan > 1) {
+        var targetCellPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [i, columnIndex + 1]);
+        var newCell = generateTableCell(editor);
+        newCell.rowspan = rowspan;
+        newCell.colspan = colspan - 1;
+        _slate.Transforms.removeNodes(editor, {
+          at: targetCellPath
+        });
+        _slate.Transforms.insertNodes(editor, newCell, {
+          at: targetCellPath
+        });
+      }
+    }
+  }
+};
+var setTableSelectedRange = exports.setTableSelectedRange = function setTableSelectedRange(editor, range) {
+  if (range) {
+    editor.tableSelectedRange = range;
+    return;
+  }
+  editor.tableSelectedRange = _constants3.EMPTY_SELECTED_RANGE;
+};
+var updateTableRowHeight = exports.updateTableRowHeight = function updateTableRowHeight(editor, element, rowHeight) {
+  var path = (0, _core.findPath)(editor, element);
+  var targetNode = (0, _core.getNode)(editor, path);
+  var _targetNode$style = targetNode.style,
+    style = _targetNode$style === void 0 ? {} : _targetNode$style;
+  if (style[_constants3.TABLE_ROW_STYLE.MIN_HEIGHT] === rowHeight) return;
+  _slate.Transforms.setNodes(editor, {
+    style: (0, _objectSpread3["default"])((0, _objectSpread3["default"])({}, style), {}, (0, _defineProperty2["default"])({}, _constants3.TABLE_ROW_STYLE.MIN_HEIGHT, rowHeight))
+  }, {
+    at: path
+  });
+};
+var updateColumnWidth = exports.updateColumnWidth = function updateColumnWidth(editor, element, columns) {
+  var path = (0, _core.findPath)(editor, element);
+  _slate.Transforms.setNodes(editor, {
+    columns: columns
+  }, {
+    at: path
+  });
+};
+var getTableColumnsWidth = exports.getTableColumnsWidth = function getTableColumnsWidth() {
+  var columns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  if (!Array.isArray(columns) || columns.length === 0) return 0;
+  return columns.reduce(function (pre, cur) {
+    return pre + cur.width;
+  }, 0);
+};
+var getTableColumnsAfterInsertColumn = exports.getTableColumnsAfterInsertColumn = function getTableColumnsAfterInsertColumn(editor, element, targetColumnIndex, insertColumnCount) {
+  var columns = getTableColumns(editor, element);
+  var newColumns = columns.slice(0);
+  var totalColumnsWidth = getTableColumnsWidth(columns);
+  var targetColumn = columns[targetColumnIndex] || columns[targetColumnIndex - 1];
+  var targetInsertColumnsWidth = targetColumn.width * insertColumnCount;
+
+  // Currently in scrolling state, insert directly
+  if (totalColumnsWidth > editor.width) {
+    for (var i = 0; i < insertColumnCount; i++) {
+      newColumns.splice(targetColumnIndex, 0, targetColumn);
+    }
+    return newColumns;
+  }
+
+  // Not currently scrolling
+  // It is not a scroll state after inserting a new column
+  if (totalColumnsWidth + targetInsertColumnsWidth < editor.width) {
+    for (var _i5 = 0; _i5 < insertColumnCount; _i5++) {
+      newColumns.push(targetColumn);
+    }
+    return newColumns;
+  }
+
+  // After inserting a new column is a scrolling state
+  for (var _i6 = 0; _i6 < insertColumnCount; _i6++) {
+    totalColumnsWidth += targetColumn.width;
+    newColumns.splice(targetColumnIndex, 0, targetColumn);
+  }
+  var proportion = totalColumnsWidth / (editor.width - 1);
+  return newColumns.map(function (column) {
+    return (0, _objectSpread3["default"])((0, _objectSpread3["default"])({}, column), {}, {
+      width: Math.max(parseInt(column.width / proportion), _constants3.TABLE_CELL_MIN_WIDTH)
+    });
+  });
+};
+var getTableColumns = exports.getTableColumns = function getTableColumns(editor, element) {
+  if (!element) return [];
+  var tableElement = element;
+  if (element.type === _constants2.ELEMENT_TYPE.TABLE_CELL) {
+    var cellPath = (0, _core.findPath)(editor, element);
+    var tablePath = cellPath.slice(0, -2);
+    tableElement = (0, _core.getNode)(editor, tablePath);
+  }
+  var _tableElement = tableElement,
+    columns = _tableElement.columns,
+    children = _tableElement.children;
+  if (columns) return columns;
+  var columnsCount = children[0].children.length;
+  var initColumns = [];
+  var pageEditAreaWidth = editor.width || _constants.PAGE_EDIT_AREA_WIDTH;
+  for (var i = 0; i < columnsCount; i++) {
+    var column = {
+      width: Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
+    };
+    initColumns.push(column);
+  }
+  return initColumns;
+};
+var getCellColumn = exports.getCellColumn = function getCellColumn(editor, cellElement) {
+  var column = {
+    width: _constants3.TABLE_CELL_MIN_WIDTH
+  };
+  if (!editor || !cellElement) return column;
+  var cellPath = (0, _core.findPath)(editor, cellElement);
+  if (!cellPath) return column;
+  var pathLength = cellPath.length;
+  var cellIndex = cellPath[pathLength - 1];
+  var tablePath = cellPath.slice(0, -2);
+  var tableElement = (0, _core.getNode)(editor, tablePath);
+  var columns = tableElement.columns;
+  var columnsCount = tableElement.children[0].children.length;
+  var pageEditAreaWidth = editor.width || _constants.PAGE_EDIT_AREA_WIDTH;
+  if (columns) {
+    column = columns[cellIndex];
+  }
+  return column || {
+    width: Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
+  };
+};
+var getFirstTableCell = exports.getFirstTableCell = function getFirstTableCell(element) {
+  var tableCellElement = element;
+  while (tableCellElement && !(tableCellElement.hasAttribute('row-index') && tableCellElement.hasAttribute('cell-index'))) {
+    tableCellElement = tableCellElement.parentNode;
+  }
+  return tableCellElement;
+};
+var _elementHasImage = exports.elementHasImage = function elementHasImage(element) {
+  if (!element) return false;
+  if (!Array.isArray(element.children) || element.children.length === 0) return false;
+  return element.children.some(function (child) {
+    if (child.type === _constants2.ELEMENT_TYPE.IMAGE) return true;
+    if (_objectUtils["default"].hasProperty(child, 'children')) {
+      return _elementHasImage(child);
+    }
+    return false;
+  });
+};
+var isSelectedAllCell = exports.isSelectedAllCell = function isSelectedAllCell(editor) {
+  var _getSelectedInfo8 = getSelectedInfo(editor),
+    tableSize = _getSelectedInfo8.tableSize;
+  return _objectUtils["default"].isSameObject(editor.tableSelectedRange, {
+    minColIndex: 0,
+    maxColIndex: tableSize[1] - 1,
+    minRowIndex: 0,
+    maxRowIndex: tableSize[0] - 1
+  });
+};
+var insertMultipleRowsAndColumns = exports.insertMultipleRowsAndColumns = function insertMultipleRowsAndColumns(editor, rows, columns) {
+  var _getSelectedInfo9 = getSelectedInfo(editor),
+    table = _getSelectedInfo9.table,
+    tablePath = _getSelectedInfo9.tablePath,
+    tableSize = _getSelectedInfo9.tableSize,
+    rowIndex = _getSelectedInfo9.rowIndex,
+    cellIndex = _getSelectedInfo9.cellIndex;
+  var newTable = (0, _deepCopy["default"])(table);
+  var eventBus = _eventBus["default"].getInstance();
+  eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+  var insertRows = rows.slice(tableSize[0] - rowIndex);
+  var insertColumns = columns.slice(tableSize[1] - cellIndex);
+  var validInsertRows = insertRows.slice(0, Math.min(_constants3.TABLE_MAX_ROWS - tableSize[0], insertRows.length));
+  var validInsertColumns = insertColumns.slice(0, Math.min(_constants3.TABLE_MAX_COLUMNS - tableSize[1], columns.length));
+  for (var i = 0; i < validInsertRows.length; i++) {
+    var insertRow = validInsertRows[i];
+    var row = generateTableRow(editor, tableSize[1], rowIndex);
+    row.style = insertRow.style;
+    newTable.children.push(row);
+  }
+  if (validInsertColumns.length > 0) {
+    newTable.columns = [].concat((0, _toConsumableArray2["default"])(table.columns), (0, _toConsumableArray2["default"])(validInsertColumns));
+  }
+  for (var j = 0; j < validInsertColumns.length; j++) {
+    for (var _i7 = 0; _i7 < tableSize[0] + validInsertRows.length; _i7++) {
+      var newCell = generateTableCell(editor);
+      newTable.children[_i7].children.push(newCell);
+    }
+  }
+  for (var _i8 = rowIndex; _i8 < Math.min(_constants3.TABLE_MAX_ROWS, rowIndex + rows.length); _i8++) {
+    var _row = rows[_i8 - rowIndex];
+    var cells = _row.children;
+    for (var _j3 = cellIndex; _j3 < Math.min(_constants3.TABLE_MAX_COLUMNS, cellIndex + columns.length); _j3++) {
+      var replaceCellIndex = _j3 - cellIndex;
+      var replaceCell = cells[replaceCellIndex];
+      newTable.children[_i8].children[_j3].children = (0, _helpers.replacePastedDataId)(replaceCell.children);
+    }
+  }
+  (0, _core.replaceNode)(editor, {
+    at: tablePath,
+    nodes: newTable
+  });
+  (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, cellIndex, 0]));
+  var newFocus = editor.selection.focus;
+  _slate.Transforms.select(editor, {
+    focus: newFocus,
+    anchor: newFocus
+  });
+  return;
+};
+var setTableFragmentData = exports.setTableFragmentData = function setTableFragmentData(editor, dataTransfer) {
+  var selectedNode = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
+  var fragment = editor.getFragment();
+  var string = JSON.stringify(fragment);
+  var encoded = window.btoa(encodeURIComponent(string));
+  dataTransfer.setData("application/".concat(_constants2.CLIPBOARD_FORMAT_KEY), encoded);
+  var tableDom = document.createElement('table');
+  var _editor$tableSelected5 = editor.tableSelectedRange,
+    minColIndex = _editor$tableSelected5.minColIndex,
+    maxColIndex = _editor$tableSelected5.maxColIndex,
+    minRowIndex = _editor$tableSelected5.minRowIndex,
+    maxRowIndex = _editor$tableSelected5.maxRowIndex;
+  var tablePath = (0, _core.findPath)(editor, selectedNode);
+  for (var i = minRowIndex; i <= maxRowIndex; i++) {
+    var tr = document.createElement('tr');
+    for (var j = minColIndex; j <= maxColIndex; j++) {
+      var path = [].concat((0, _toConsumableArray2["default"])(tablePath), [i, j]);
+      var node = (0, _core.getNode)(editor, path);
+      var td = document.createElement('td');
+      var _div = document.createElement('div');
+      _div.innerHTML = _slateReact.ReactEditor.toDOMNode(editor, node).innerHTML;
+      td.appendChild(_div);
+      tr.appendChild(td);
+    }
+    tableDom.appendChild(tr);
+  }
+  tableDom.setAttribute('data-slate-fragment', encoded);
+  var div = document.createElement('div');
+  div.appendChild(tableDom);
+  dataTransfer.setData('text/html', div.innerHTML);
+  dataTransfer.setData('text/plain', div.innerText);
+  return dataTransfer;
+};
+var deleteTableRangeData = exports.deleteTableRangeData = function deleteTableRangeData(editor) {
+  var tableSelectedRange = editor.tableSelectedRange;
+  var minRowIndex = tableSelectedRange.minRowIndex,
+    maxRowIndex = tableSelectedRange.maxRowIndex,
+    minColIndex = tableSelectedRange.minColIndex,
+    maxColIndex = tableSelectedRange.maxColIndex;
+  var _getSelectedInfo0 = getSelectedInfo(editor),
+    tablePath = _getSelectedInfo0.tablePath;
+  var forceCellPath;
+  for (var i = minRowIndex; i <= maxRowIndex; i++) {
+    for (var j = minColIndex; j <= maxColIndex; j++) {
+      var path = [].concat((0, _toConsumableArray2["default"])(tablePath), [i, j]);
+      var node = (0, _core.getNode)(editor, path);
+      if (!forceCellPath && (_slate.Node.string(node) || _elementHasImage(node))) {
+        forceCellPath = path;
+      }
+      var firstNode = node.children[0];
+      (0, _core.replaceNodeChildren)(editor, {
+        at: path,
+        nodes: (0, _objectSpread3["default"])((0, _objectSpread3["default"])({}, firstNode), {}, {
+          text: ''
+        })
+      });
+    }
+  }
+  if (forceCellPath) {
+    editor.tableSelectedRange = _constants3.EMPTY_SELECTED_RANGE;
+    var eventBus = _eventBus["default"].getInstance();
+    eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+    (0, _core.focusEditor)(editor, forceCellPath);
+    var newFocus = editor.selection.focus;
+    _slate.Transforms.select(editor, {
+      focus: newFocus,
+      anchor: newFocus
+    });
+  }
+};
+var deleteHandler = exports.deleteHandler = function deleteHandler(editor) {
+  var selection = editor.selection,
+    tableSelectedRange = editor.tableSelectedRange;
+  if (selection == null) return '';
+  if (!_objectUtils["default"].isSameObject(tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+    if (isSelectedAllCell(editor)) return 'table';
+    return 'range';
+  }
+  var _Editor$nodes3 = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        var type = (0, _core.getNodeType)(n);
+        if (!type && (0, _core.isTextNode)(n) && n.id) {
+          var parentNode = (0, _core.getParentNode)(editor.children, n.id);
+          type = (0, _core.getNodeType)(parentNode);
+        }
+        return type === _constants2.ELEMENT_TYPE.TABLE_CELL;
+      }
+    }),
+    _Editor$nodes4 = (0, _slicedToArray2["default"])(_Editor$nodes3, 1),
+    cellNodeEntry = _Editor$nodes4[0];
+  if (cellNodeEntry) {
+    var _cellNodeEntry = (0, _slicedToArray2["default"])(cellNodeEntry, 2),
+      cellPath = _cellNodeEntry[1];
+    var start = _slate.Editor.start(editor, cellPath);
+    if (_slate.Point.equals(selection.anchor, start)) {
+      return 'default';
+    }
+  }
+  return '';
+};
+var isTableLocation = exports.isTableLocation = function isTableLocation(editor, location) {
+  var tables = _slate.Editor.nodes(editor, {
+    at: location,
+    match: function match(n) {
+      var type = (0, _core.getNodeType)(n);
+      if (!type && (0, _core.isTextNode)(n) && n.id) {
+        var parentNode = (0, _core.getParentNode)(editor.children, n.id);
+        type = (0, _core.getNodeType)(parentNode);
+      }
+      return type === _constants2.ELEMENT_TYPE.TABLE_CELL;
+    }
+  });
+  var hasTable = false;
+  // eslint-disable-next-line no-unused-vars
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(tables),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var table = _step.value;
+      hasTable = true;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return hasTable;
+};
+var isCursorAtCellEnd = exports.isCursorAtCellEnd = function isCursorAtCellEnd(cell) {
+  var cursor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  if (!cell) return false;
+  var childrenCount = cell.children.length;
+  var lastChildren = cell.children[childrenCount - 1];
+  var textCount = lastChildren.text.length;
+  return cursor === textCount;
+};
+var isCursorAtCellStart = exports.isCursorAtCellStart = function isCursorAtCellStart() {
+  var cursor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return cursor === 0;
+};
+var focusCell = exports.focusCell = function focusCell(editor, event) {
+  var keyboardName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  var _getSelectedInfo1 = getSelectedInfo(editor),
+    tableSize = _getSelectedInfo1.tableSize,
+    tablePath = _getSelectedInfo1.tablePath,
+    rowIndex = _getSelectedInfo1.rowIndex,
+    cellIndex = _getSelectedInfo1.cellIndex,
+    cell = _getSelectedInfo1.cell;
+  var tableParentPath = tablePath.slice(0, -1);
+  var tableIndex = tablePath[tablePath.length - 1];
+  var selection = editor.selection;
+  var focus = selection.focus;
+  if (keyboardName === _constants2.KEYBOARD.UP) {
+    if (!isCursorAtCellStart(focus.offset)) {
+      setTimeout(function () {
+        if ((0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE)) {
+          var _getSelectedInfo10 = getSelectedInfo(editor),
+            newCellIndex = _getSelectedInfo10.cellIndex;
+          if (Math.abs(newCellIndex - cellIndex) !== 0) {
+            if (rowIndex === 0) {
+              if (tableIndex !== 0) {
+                (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex - 1]));
+              }
+              return;
+            }
+            (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex - 1, cellIndex]));
+            var _newFocus = editor.selection.focus;
+            _slate.Transforms.select(editor, {
+              focus: _newFocus,
+              anchor: _newFocus
+            });
+          }
+        }
+      }, 10);
+      return;
+    }
+    event.preventDefault();
+    if (rowIndex === 0) {
+      if (tableIndex !== 0) {
+        (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex - 1]));
+      }
+      return;
+    }
+    (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex - 1, cellIndex]));
+    var newFocus = editor.selection.focus;
+    _slate.Transforms.select(editor, {
+      focus: newFocus,
+      anchor: newFocus
+    });
+  }
+  if (keyboardName === _constants2.KEYBOARD.RIGHT) {
+    if (!isCursorAtCellEnd(cell, focus.offset)) return;
+    event.preventDefault();
+    if (rowIndex === tableSize[0] - 1 && cellIndex === tableSize[1] - 1) {
+      (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex + 1]));
+      return;
+    }
+    if (cellIndex === tableSize[1] - 1) {
+      (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex + 1, 0]));
+    } else {
+      (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex, cellIndex + 1]));
+    }
+    var newAnchor = editor.selection.anchor;
+    _slate.Transforms.select(editor, {
+      focus: newAnchor,
+      anchor: newAnchor
+    });
+  }
+  if (keyboardName === _constants2.KEYBOARD.DOWN) {
+    if (!isCursorAtCellEnd(cell, focus.offset)) {
+      setTimeout(function () {
+        if ((0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE)) {
+          var _getSelectedInfo11 = getSelectedInfo(editor),
+            newCellIndex = _getSelectedInfo11.cellIndex;
+          if (Math.abs(newCellIndex - cellIndex) !== 0) {
+            if (rowIndex === tableSize[0] - 1) {
+              var nextNode = (0, _core.getNode)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex + 1]));
+              if (!nextNode) return;
+              (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex + 1]));
+              return;
+            }
+            (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex + 1, cellIndex]));
+            var _newAnchor = editor.selection.anchor;
+            _slate.Transforms.select(editor, {
+              focus: _newAnchor,
+              anchor: _newAnchor
+            });
+          }
+        }
+      }, 10);
+      return;
+    }
+    event.preventDefault();
+    if (rowIndex === tableSize[0] - 1) {
+      var nextNode = (0, _core.getNode)([].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex + 1]));
+      if (!nextNode) return;
+      (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex + 1]));
+      return;
+    }
+    (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex + 1, cellIndex]));
+    var _newAnchor2 = editor.selection.anchor;
+    _slate.Transforms.select(editor, {
+      focus: _newAnchor2,
+      anchor: _newAnchor2
+    });
+  }
+  if (keyboardName === _constants2.KEYBOARD.LEFT) {
+    if (!isCursorAtCellStart(focus.offset)) return;
+    event.preventDefault();
+    if (rowIndex === 0 && cellIndex === 0) {
+      if (tableIndex !== 0) {
+        (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex - 1]));
+      }
+      return;
+    }
+    if (cellIndex === 0) {
+      (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex - 1, tableSize[1] - 1]));
+    } else {
+      (0, _core.focusEditor)(editor, [].concat((0, _toConsumableArray2["default"])(tableParentPath), [tableIndex, rowIndex, cellIndex - 1]));
+    }
+    var _newFocus2 = editor.selection.focus;
+    _slate.Transforms.select(editor, {
+      focus: _newFocus2,
+      anchor: _newFocus2
+    });
+  }
+};
+var isLastTableCell = exports.isLastTableCell = function isLastTableCell(editor, cellNode) {
+  if (cellNode[0].type !== _constants2.ELEMENT_TYPE.TABLE_CELL) return false;
+  var _getSelectedInfo12 = getSelectedInfo(editor),
+    tableSize = _getSelectedInfo12.tableSize;
+  var lastRowIndex = tableSize[0] - 1;
+  var lastColumnIndex = tableSize[1] - 1;
+  var cellNodePath = cellNode[1];
+  var cellNodePathDeep = cellNodePath.length;
+  return cellNodePath[cellNodePathDeep - 1] === lastColumnIndex && cellNodePath[cellNodePathDeep - 2] === lastRowIndex;
+};
+var getValidColor = function getValidColor(color) {
+  if (!color) return '';
+  var validColor = color.length === 4 ? '#' + color.slice(1, 4).repeat(2) : color;
+  return validColor.toUpperCase();
+};
+var colorBlend = exports.colorBlend = function colorBlend(c1, c2, ratio) {
+  var color1 = getValidColor(c1);
+  var color2 = getValidColor(c2);
+  if (!color1 && !color2) return 'unset';
+  if (color1 && !color2) return color1;
+  if (!color1 && color2) return color2;
+  if (color1 === '#FFFFFF') return color2;
+  if (color2 === '#FFFFFF') return color1;
+  var validRatio = Math.max(Math.min(Number(ratio), 1), 0);
+  var r1 = parseInt(color1.substring(1, 3), 16);
+  var g1 = parseInt(color1.substring(3, 5), 16);
+  var b1 = parseInt(color1.substring(5, 7), 16);
+  var r2 = parseInt(color2.substring(1, 3), 16);
+  var g2 = parseInt(color2.substring(3, 5), 16);
+  var b2 = parseInt(color2.substring(5, 7), 16);
+  var r = Math.round(r1 * (1 - validRatio) + r2 * validRatio);
+  var g = Math.round(g1 * (1 - validRatio) + g2 * validRatio);
+  var b = Math.round(b1 * (1 - validRatio) + b2 * validRatio);
+  r = ('0' + (r || 0).toString(16)).slice(-2);
+  g = ('0' + (g || 0).toString(16)).slice(-2);
+  b = ('0' + (b || 0).toString(16)).slice(-2);
+  return '#' + r + g + b;
+};
+var getRowHeight = exports.getRowHeight = function getRowHeight(element, rowIndex) {
+  var _element$style = element.style,
+    style = _element$style === void 0 ? {} : _element$style;
+  var rowHeight = style[_constants3.TABLE_ROW_STYLE.MIN_HEIGHT] || _constants3.TABLE_ROW_MIN_HEIGHT;
+  return rowIndex === 0 ? rowHeight + 1 : rowHeight;
+};
+var getRowDomHeight = exports.getRowDomHeight = function getRowDomHeight(editor, row) {
+  var height = 0;
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(row.children),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var cell = _step2.value;
+      var is_combined = cell.is_combined,
+        _cell$rowspan = cell.rowspan,
+        rowspan = _cell$rowspan === void 0 ? 1 : _cell$rowspan;
+      if (is_combined || rowspan > 1) continue;
+      var cellDom = null;
+      try {
+        cellDom = _slateReact.ReactEditor.toDOMNode(editor, cell);
+      } catch (error) {
+        if (!cellDom) break;
+      }
+      height = cellDom.getBoundingClientRect().height;
+      break;
+    }
+    // if the row is empty, get the height from style
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (!height) {
+    height = row.style[_constants3.TABLE_ROW_STYLE.MIN_HEIGHT] || _constants3.TABLE_ROW_MIN_HEIGHT;
+  }
+  return height;
+};
+var normalizeTableCell = function normalizeTableCell(editor, cell) {
+  if (!cell) return generateTableCell(editor);
+  var newCell = (0, _objectSpread3["default"])({
+    children: [{
+      text: '',
+      id: _slugid["default"].nice()
+    }]
+  }, cell);
+
+  // normalize cell children
+  var newCellChildren = [];
+  newCell.children.forEach(function (cellChild) {
+    var cellChildType = cellChild.type;
+    if (cellChildType === _constants2.ELEMENT_TYPE.PARAGRAPH) {
+      newCellChildren.push.apply(newCellChildren, (0, _toConsumableArray2["default"])(cellChild.children));
+    } else {
+      newCellChildren.push(cellChild);
+    }
+  });
+  newCell.children = newCellChildren.map(function (item) {
+    if (item.BOLD) {
+      item.bold = item.BOLD;
+      delete item['BOLD'];
+    }
+    if (item.ITALIC) {
+      item.italic = item.ITALIC;
+      delete item['ITALIC'];
+    }
+    return item;
+  });
+
+  // normalize cell style
+  if (newCell.data) {
+    var cellStyle = (0, _objectSpread3["default"])({}, newCell.data);
+    delete newCell['data'];
+    Object.keys(cellStyle).forEach(function (cellStyleKey) {
+      if (cellStyleKey === 'align') {
+        cellStyle['text_align'] = cellStyle['align'];
+        delete cellStyle['align'];
+      }
+    });
+    newCell.style = cellStyle;
+  }
+  return newCell;
+};
+var normalizeTableELement = exports.normalizeTableELement = function normalizeTableELement(editor, element) {
+  if (element.type !== _constants2.ELEMENT_TYPE.TABLE) {
+    var size = [element.children.length, element.children[0].children.length];
+    return generateEmptyTable(editor, {
+      size: size
+    });
+  }
+  var newElement = (0, _objectSpread3["default"])({}, element);
+  for (var i = 0; i < element.children.length; i++) {
+    var row = newElement.children[i];
+    for (var j = 0; j < row.children.length; j++) {
+      row.children[j] = normalizeTableCell(editor, row.children[j]);
+    }
+    newElement.children[i] = row;
+  }
+  return newElement;
+};
+var insertTableByTemplate = exports.insertTableByTemplate = function insertTableByTemplate(editor, alternateColor) {
+  var size = [4, 4];
+  var tableNode = generateEmptyTable(editor, {
+    size: size,
+    alternate_highlight_color: alternateColor,
+    alternate_highlight: true
+  });
+  var path = _slate.Editor.path(editor, editor.selection);
+  var insertPosition = getInsertPosition(editor);
+  handleInsertTable(editor, insertPosition, path, tableNode);
+};
+
+/**
+ * @param {Editor} editor
+ * @param {InsertPosition} insertPosition
+ * @param {Path} path
+ * @param {Node} tableNode
+ * Insert table by insertPosition
+ */
+var handleInsertTable = exports.handleInsertTable = function handleInsertTable(editor, insertPosition, path, tableNode) {
+  var selection = editor.selection;
+  if (insertPosition === _constants2.INSERT_POSITION.BEFORE) {
+    var insertPath = [path[0]];
+    _slate.Transforms.insertNodes(editor, tableNode, {
+      at: insertPath
+    });
+  } else if (insertPosition === _constants2.INSERT_POSITION.AFTER) {
+    var _insertPath = [path[0] + 1];
+    _slate.Transforms.insertNodes(editor, tableNode, {
+      at: _insertPath
+    });
+  } else if (insertPosition === _constants2.INSERT_POSITION.CURRENT) {
+    _slate.Transforms.splitNodes(editor, {
+      at: selection,
+      always: true
+    });
+    _slate.Transforms.insertNodes(editor, tableNode, {
+      at: selection.anchor
+    });
+  }
+  _slateReact.ReactEditor.focus(editor);
+};
+var getInsertPosition = exports.getInsertPosition = function getInsertPosition(editor) {
+  var selection = editor.selection;
+  if (!selection) return _constants2.INSERT_POSITION.CURRENT;
+  if (!_slate.Range.isCollapsed(selection)) return _constants2.INSERT_POSITION.CURRENT;
+  var aboveNodeEntry = (0, _core.getAboveBlockNode)(editor);
+  if (!aboveNodeEntry) return _constants2.INSERT_POSITION.CURRENT;
+  var isAtStart = _slate.Editor.isStart(editor, selection.anchor, aboveNodeEntry[1]);
+  if (isAtStart) return _constants2.INSERT_POSITION.BEFORE;
+  var isAtEnd = _slate.Editor.isEnd(editor, selection.anchor, aboveNodeEntry[1]);
+  if (isAtEnd) return _constants2.INSERT_POSITION.AFTER;
+  return _constants2.INSERT_POSITION.CURRENT;
+};
+var generateInheritStyle = exports.generateInheritStyle = function generateInheritStyle(allowedInheritStyleList, style, cell) {
+  var inheritStyle = (0, _objectSpread3["default"])({}, cell['inherit_style']) || {};
+  for (var key in style) {
+    if (Object.hasOwnProperty.call(style, key) && allowedInheritStyleList.includes(key)) {
+      inheritStyle[key] = style[key];
+    }
+  }
+  return inheritStyle;
+};
+var getCellInheritStyles = exports.getCellInheritStyles = function getCellInheritStyles(editor, tablePath, rowIndex, colIndex) {
+  var _table$children$rowIn, _tableCell$inherit_st;
+  var _Editor$nodes5 = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        return n.type === _constants2.ELEMENT_TYPE.TABLE;
+      },
+      at: tablePath
+    }),
+    _Editor$nodes6 = (0, _slicedToArray2["default"])(_Editor$nodes5, 1),
+    tableNodeEntry = _Editor$nodes6[0];
+  if (!tableNodeEntry) return {};
+  var table = tableNodeEntry[0];
+  var tableCell = (_table$children$rowIn = table.children[rowIndex]) === null || _table$children$rowIn === void 0 ? void 0 : _table$children$rowIn.children[colIndex];
+  if (!tableCell) return {};
+  return (_tableCell$inherit_st = tableCell['inherit_style']) !== null && _tableCell$inherit_st !== void 0 ? _tableCell$inherit_st : {};
+};
+var getCellHighlightClassName = exports.getCellHighlightClassName = function getCellHighlightClassName(primaryColorClassName, rowIndex) {
+  var className = '';
+  if (rowIndex === 0) {
+    className = primaryColorClassName;
+  } else if (rowIndex % 2 === 0) {
+    className = _constants3.TABLE_ALTERNATE_HIGHLIGHT_CLASS_MAP[primaryColorClassName];
+  }
+  return className;
+};
+var focusClosestCellWhenJustifyCellSize = exports.focusClosestCellWhenJustifyCellSize = function focusClosestCellWhenJustifyCellSize(editor, adjustingCell) {
+  var cellPath = _slateReact.ReactEditor.findPath(editor, adjustingCell);
+  (0, _core.focusEditor)(editor, _slate.Editor.end(editor, cellPath));
+};
+
+// Search main cell of combined cell
+var searchCombinedMainCell = function searchCombinedMainCell(table, startRowIndex, startColIndex) {
+  for (var rowIndex = startRowIndex; rowIndex >= 0; rowIndex--) {
+    var row = table.children[rowIndex];
+    for (var cellIndex = startColIndex; cellIndex >= 0; cellIndex--) {
+      var currentCell = row.children[cellIndex];
+      var _currentCell$colspan = currentCell.colspan,
+        colspan = _currentCell$colspan === void 0 ? 0 : _currentCell$colspan,
+        _currentCell$rowspan = currentCell.rowspan,
+        rowspan = _currentCell$rowspan === void 0 ? 0 : _currentCell$rowspan;
+      if (colspan <= 1 && rowspan <= 1) continue;
+      var isInColRange = cellIndex + colspan >= startColIndex;
+      var isInRowRange = rowIndex + rowspan >= startRowIndex;
+      if (isInColRange && isInRowRange) {
+        return {
+          currentCell: currentCell,
+          rowIndex: rowIndex,
+          cellIndex: cellIndex
+        };
+      } else break;
+    }
+  }
+};
+var getResizeMaskCellInfo = exports.getResizeMaskCellInfo = function getResizeMaskCellInfo(editor, table, rowIndex, cellIndex) {
+  // The cell shown cursor as resize (mouse is on this cell)
+  var focusCellIndex = cellIndex;
+  var focusCell = table.children[rowIndex].children[cellIndex];
+  // The cell dominating resize handlers (the true cell to be resized)
+  var cell = table.children[rowIndex].children[cellIndex];
+  // Resolve combined cell
+  if (cell.is_combined) {
+    var targetCellInfo = searchCombinedMainCell(table, rowIndex, cellIndex);
+    cellIndex = targetCellInfo.cellIndex;
+    rowIndex = targetCellInfo.rowIndex;
+    cell = targetCellInfo.currentCell;
+  }
+  var columns = table.columns;
+  var focussedCell = _slateReact.ReactEditor.toDOMNode(editor, cell);
+  var colspan = focusCell.colspan,
+    rowspan = focusCell.rowspan;
+  var width = columns[cellIndex].width;
+  var height = focussedCell.getBoundingClientRect().height;
+  // Calculate cell width and height
+  if (colspan > 1) {
+    var index = cellIndex + 1;
+    while (index < cellIndex + colspan) {
+      width += columns[index].width;
+      index++;
+    }
+  }
+  if (rowspan > 1) {
+    var _index = rowIndex + 1;
+    while (_index < rowIndex + rowspan) {
+      var currentCell = table.children[_index].children[cellIndex];
+      var currentHeight = _slateReact.ReactEditor.toDOMNode(editor, currentCell).getBoundingClientRect().height;
+      height += currentHeight;
+      _index++;
+    }
+  }
+  return {
+    width: width,
+    height: height,
+    top: focussedCell.offsetTop,
+    left: focussedCell.offsetLeft,
+    rowIndex: rowIndex,
+    cellIndex: cellIndex,
+    cell: cell,
+    focusCellIndex: focusCellIndex
+  };
+};
+
+// Table alternate highlight
+var getHighlightClass = exports.getHighlightClass = function getHighlightClass(editor, cellPath) {
+  var _tableEntry$;
+  var _Editor$nodes7 = _slate.Editor.nodes(editor, {
+      at: cellPath,
+      match: function match(n) {
+        return n.type === _constants2.ELEMENT_TYPE.TABLE;
+      }
+    }),
+    _Editor$nodes8 = (0, _slicedToArray2["default"])(_Editor$nodes7, 1),
+    tableEntry = _Editor$nodes8[0];
+  var _ref = ((_tableEntry$ = tableEntry[0]) === null || _tableEntry$ === void 0 ? void 0 : _tableEntry$.ui) || {},
+    alternate_highlight = _ref.alternate_highlight,
+    alternate_highlight_color = _ref.alternate_highlight_color;
+  if (!alternate_highlight) return '';
+  var rowIndex = cellPath[cellPath.length - 2];
+  var className = getCellHighlightClassName(alternate_highlight_color, rowIndex);
+  return className;
+};
+
+// Correct the selected range when combined cell are selected
+var adjustCombinedCellRange = exports.adjustCombinedCellRange = function adjustCombinedCellRange(table, range) {
+  var minRowIndex = range.minRowIndex,
+    maxRowIndex = range.maxRowIndex,
+    minColIndex = range.minColIndex,
+    maxColIndex = range.maxColIndex;
+  var firstCell = table.children[minRowIndex].children[minColIndex];
+  var _firstCell$colspan = firstCell.colspan,
+    colspan = _firstCell$colspan === void 0 ? 0 : _firstCell$colspan,
+    _firstCell$rowspan = firstCell.rowspan,
+    rowspan = _firstCell$rowspan === void 0 ? 0 : _firstCell$rowspan;
+  if (rowspan > 1 || colspan > 1) {
+    var isRowCombined = minRowIndex + rowspan === maxRowIndex + 1;
+    var isColCombined = minColIndex + colspan === maxColIndex + 1;
+    if (isRowCombined && isColCombined) return _constants3.EMPTY_SELECTED_RANGE;
+  }
+  return range;
+};
+
+/**
+ *  Do not reset table selected range, when drag table column / row
+ * @param {MouseEvent} event
+ * @returns {Boolean}
+ */
+var isPreventResetTableSelectedRange = exports.isPreventResetTableSelectedRange = function isPreventResetTableSelectedRange(event) {
+  var target = event.target;
+  var draggable = target.getAttribute('draggable');
+  var isColumnHeader = target.classList.contains('sdoc-table-column-header');
+  var isRowHeader = target.classList.contains('sdoc-table-row-header');
+  var isHeader = isColumnHeader || isRowHeader;
+  var isPreventReset = isHeader || draggable === 'true';
+  return isPreventReset;
+};
+
+/**
+ * Check drag type, column or row
+ */
+var getTableDragType = exports.getTableDragType = function getTableDragType(table, selectedRange) {
+  var rowCount = table.children.length;
+  var minRowIndex = selectedRange.minRowIndex,
+    maxRowIndex = selectedRange.maxRowIndex;
+  var isSelectColumn = minRowIndex === 0 && maxRowIndex === rowCount - 1;
+  return isSelectColumn ? _constants3.DRAG_HANDLER_COLUMN : _constants3.DRAG_HANDLER_ROW;
+};
+var updateTableColumns = function updateTableColumns(editor, table, targetColIndex, startColIndex, endColIndex) {
+  var columns = (0, _toConsumableArray2["default"])(table.columns);
+  var deleteCount = endColIndex - startColIndex + 1;
+  var newColumns = columns.splice(startColIndex, deleteCount);
+  columns.splice.apply(columns, [targetColIndex, 0].concat((0, _toConsumableArray2["default"])(newColumns)));
+  updateColumnWidth(editor, table, columns);
+};
+var moveColumns = exports.moveColumns = function moveColumns(editor, targetColIndex, startColIndex, endColIndex) {
+  // Get selected table information
+  var _getSelectedInfo13 = getSelectedInfo(editor),
+    table = _getSelectedInfo13.table,
+    tablePath = _getSelectedInfo13.tablePath;
+  // Check if moving columns forward or backward
+  var isMoveToFroward = targetColIndex < startColIndex;
+
+  // Iterate over each row in the table
+  table.children.forEach(function (row, rowIndex) {
+    if (isMoveToFroward) {
+      // Calculate target and source paths for moving columns forward
+      var targetPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, targetColIndex]);
+      var sourcePath = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, endColIndex]);
+
+      // Move columns forward by inserting nodes
+      for (var insertIndex = endColIndex; insertIndex >= startColIndex; insertIndex--) {
+        var insertNode = row.children[insertIndex];
+        _slate.Transforms.removeNodes(editor, {
+          at: sourcePath
+        });
+        _slate.Transforms.insertNodes(editor, insertNode, {
+          at: targetPath
+        });
+      }
+    } else {
+      // Calculate target and source paths for moving columns backward
+      var _targetPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, targetColIndex - 1]);
+      var _sourcePath = [].concat((0, _toConsumableArray2["default"])(tablePath), [rowIndex, startColIndex]);
+
+      // Move columns backward by inserting nodes
+      for (var _insertIndex = startColIndex; _insertIndex <= endColIndex; _insertIndex++) {
+        var _insertNode = row.children[_insertIndex];
+        _slate.Transforms.removeNodes(editor, {
+          at: _sourcePath
+        });
+        _slate.Transforms.insertNodes(editor, _insertNode, {
+          at: _targetPath
+        });
+      }
+    }
+  });
+
+  // Update table columns after moving
+  updateTableColumns(editor, table, targetColIndex, startColIndex, endColIndex);
+
+  // Set new selected range after moving columns
+  var newSelectRange = {
+    minRowIndex: 0,
+    maxRowIndex: table.children.length - 1,
+    minColIndex: targetColIndex,
+    maxColIndex: targetColIndex + endColIndex - startColIndex
+  };
+  setTableSelectedRange(editor, newSelectRange);
+};
+
+/**
+ * Calculate the new selected range after dragging a column or row in the table.
+ * @param {Object} table - The table object containing columns and rows.
+ * @param {string} moveType - The type of drag operation (DRAG_HANDLER_COLUMN for column, DRAG_HANDLER_ROW for row).
+ * @param {number} targetIndex - The index of the target column or row after dragging.
+ * @param {number} startIndex - The index of the starting column or row before dragging.
+ * @param {number} endIndex - The index of the ending column or row before dragging.
+ * @returns {Object} - The new selected range after the drag operation.
+ */
+var getTableSelectedRangeAfterDrag = exports.getTableSelectedRangeAfterDrag = function getTableSelectedRangeAfterDrag(table, moveType, targetIndex, startIndex, endIndex) {
+  // Calculate the total number of columns and rows in the table
+  var colCount = table.columns.length;
+  var rowCount = table.children.length;
+
+  // Initialize the new selected range with full table range
+  var newSelectRange = {
+    minRowIndex: 0,
+    maxRowIndex: rowCount - 1,
+    minColIndex: 0,
+    maxColIndex: colCount - 1
+  };
+
+  // Determine if the drag movement is forward or backward
+  var isMoveToFroward = targetIndex < startIndex;
+
+  // Adjust selected range based on the type of drag operation
+  if (moveType === _constants3.DRAG_HANDLER_COLUMN) {
+    if (isMoveToFroward) {
+      newSelectRange.minColIndex = targetIndex;
+      newSelectRange.maxColIndex = targetIndex + endIndex - startIndex;
+    } else {
+      var moveCount = endIndex - startIndex + 1;
+      newSelectRange.minColIndex = targetIndex - moveCount;
+      newSelectRange.maxColIndex = targetIndex - 1;
+    }
+  } else {
+    if (isMoveToFroward) {
+      newSelectRange.minRowIndex = targetIndex;
+      newSelectRange.maxRowIndex = targetIndex + endIndex - startIndex;
+    } else {
+      var _moveCount = endIndex - startIndex + 1;
+      newSelectRange.minRowIndex = targetIndex - _moveCount;
+      newSelectRange.maxRowIndex = targetIndex - 1;
+    }
+  }
+  return newSelectRange;
+};
+var moveRows = exports.moveRows = function moveRows(editor, targetRowIndex, startRowIndex, endRowIndex) {
+  var _getSelectedInfo14 = getSelectedInfo(editor),
+    table = _getSelectedInfo14.table,
+    tablePath = _getSelectedInfo14.tablePath;
+  var isMoveToFroward = targetRowIndex < startRowIndex;
+  var targetPath = [].concat((0, _toConsumableArray2["default"])(tablePath), [isMoveToFroward ? targetRowIndex : targetRowIndex - 1]);
+  var sourcePath = [].concat((0, _toConsumableArray2["default"])(tablePath), [isMoveToFroward ? endRowIndex : startRowIndex]);
+  if (isMoveToFroward) {
+    for (var insertIndex = endRowIndex; insertIndex >= startRowIndex; insertIndex--) {
+      var insertNode = table.children[insertIndex];
+      _slate.Transforms.removeNodes(editor, {
+        at: sourcePath
+      });
+      _slate.Transforms.insertNodes(editor, insertNode, {
+        at: targetPath
+      });
+    }
+  } else {
+    for (var _insertIndex2 = startRowIndex; _insertIndex2 <= endRowIndex; _insertIndex2++) {
+      var _insertNode2 = table.children[_insertIndex2];
+      _slate.Transforms.removeNodes(editor, {
+        at: sourcePath
+      });
+      _slate.Transforms.insertNodes(editor, _insertNode2, {
+        at: targetPath
+      });
+    }
+  }
+  var newSelectRange = {
+    minRowIndex: targetRowIndex,
+    maxRowIndex: targetRowIndex + endRowIndex - startRowIndex,
+    minColIndex: 0,
+    maxColIndex: table.children.length - 1
+  };
+  setTableSelectedRange(editor, newSelectRange);
+};
+var generateDragMoveElement = exports.generateDragMoveElement = function generateDragMoveElement(tipText) {
+  var canvasId = 'sdoc-drag-image';
+  var canvas = document.getElementById(canvasId);
+  if (!canvas) {
+    var dpr = window.devicePixelRatio;
+    canvas = document.createElement('canvas');
+    canvas.width = 115;
+    canvas.height = 30;
+    canvas.id = canvasId;
+    document.body.appendChild(canvas);
+    var _canvas$getBoundingCl = canvas.getBoundingClientRect(),
+      cssWidth = _canvas$getBoundingCl.width,
+      cssHeight = _canvas$getBoundingCl.height;
+    canvas.style.width = canvas.width + 'px';
+    canvas.style.height = canvas.height + 'px';
+    canvas.width = dpr * cssWidth;
+    canvas.height = dpr * cssHeight;
+    canvas.style.position = 'fixed';
+  }
+  canvas.style.display = 'block';
+  var context = canvas.getContext('2d');
+  context.clearRect(0, 0, canvas.width, canvas.height);
+  context.fillStyle = 'rgb(241,243,246)';
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  context.font = '22px Arial';
+  context.textBaseline = 'middle';
+  context.textAlign = 'center';
+  context.fillStyle = 'black';
+  context.fillText(tipText, canvas.width / 2, canvas.height / 2);
+  return canvas;
+};
+var isHideDragHandlerLine = exports.isHideDragHandlerLine = function isHideDragHandlerLine(editor, displayType, table, cellPath, isDragOverCellHalf) {
+  var pathLength = cellPath.length;
+  var rowIndex = cellPath[pathLength - 2];
+  var cellIndex = cellPath[pathLength - 1];
+
+  // Check is above cell selected
+  var currentCellDom = _slateReact.ReactEditor.toDOMNode(editor, table.children[rowIndex].children[cellIndex]);
+  var isCurrentCellSelected = currentCellDom.classList.contains(_constants3.CELL_SELECTED);
+  if (isCurrentCellSelected) return true;
+  if (isDragOverCellHalf) {
+    if (displayType === _constants3.DRAG_HANDLER_COLUMN) {
+      cellIndex = cellIndex + 1;
+    } else {
+      rowIndex = rowIndex + 1;
+    }
+  }
+  var isEndOfRowOrColumn = displayType === _constants3.DRAG_HANDLER_COLUMN && cellIndex === table.columns.length || displayType === _constants3.DRAG_HANDLER_ROW && rowIndex === table.children.length;
+  if (isEndOfRowOrColumn) return false;
+  var preCellDom = null;
+  if (displayType === _constants3.DRAG_HANDLER_COLUMN && cellIndex > 0) {
+    var prevCell = table.children[rowIndex].children[cellIndex - 1];
+    preCellDom = _slateReact.ReactEditor.toDOMNode(editor, prevCell);
+
+    // Check if there are merged cells in the columns before and after the drag line
+    var beforeLineColumnHasCombined = table.children.find(function (item) {
+      var cell = item.children[cellIndex - 1];
+      return cell.children.length > 1;
+    });
+    var afterLineColumnHasCombined = table.children.find(function (item) {
+      var cell = item.children[cellIndex];
+      return (cell === null || cell === void 0 ? void 0 : cell.is_combined) === true;
+    });
+    if (beforeLineColumnHasCombined && afterLineColumnHasCombined) return true;
+  } else if (displayType === _constants3.DRAG_HANDLER_ROW && rowIndex > 0) {
+    var _prevCell = table.children[rowIndex - 1].children[cellIndex];
+    preCellDom = _slateReact.ReactEditor.toDOMNode(editor, _prevCell);
+
+    // Check whether there are merged cells in the rows before and after the drag line
+    var beforeLineRow = table.children[rowIndex - 1];
+    var afterLineRow = table.children[rowIndex];
+    var beforeLineRowHasCombined = beforeLineRow.children.find(function (item) {
+      return item.children.length > 1;
+    });
+    var afterLineRowHasCombined = afterLineRow.children.find(function (item) {
+      return (item === null || item === void 0 ? void 0 : item.is_combined) === true;
+    });
+    if (beforeLineRowHasCombined && afterLineRowHasCombined) return true;
+  }
+
+  // Check is above cell selected
+  currentCellDom = _slateReact.ReactEditor.toDOMNode(editor, table.children[rowIndex].children[cellIndex]);
+  isCurrentCellSelected = currentCellDom.classList.contains(_constants3.CELL_SELECTED);
+  if (isCurrentCellSelected) return true;
+
+  // Check if the previous cell is selected
+  var isPrevCellSelected = preCellDom && preCellDom.classList.contains(_constants3.CELL_SELECTED);
+  if (isPrevCellSelected) return true;
+  var isCombined = false;
+  // Check if the combined cell
+  if (displayType === _constants3.DRAG_HANDLER_COLUMN) {
+    isCombined = table.children.some(function (row) {
+      return row.children[cellIndex - isDragOverCellHalf].is_combined;
+    });
+  } else {
+    isCombined = table.children[rowIndex - isDragOverCellHalf].children.some(function (cell) {
+      return cell.is_combined;
+    });
+  }
+  if (isCombined) return true;
+
+  // Check is the last column
+  if (displayType === _constants3.DRAG_HANDLER_COLUMN) {
+    var isLastColumn = cellIndex === table.columns.length - 1;
+    if (isLastColumn) return false;
+  }
+};
+var getTableRowSelectedRange = exports.getTableRowSelectedRange = function getTableRowSelectedRange(table, rowIndex) {
+  var row = table.children[rowIndex];
+  var columnCount = row.children.length;
+  var minRowIndex = rowIndex;
+  var maxRowIndex = rowIndex;
+  var minColIndex = 0;
+  var maxColIndex = columnCount - 1;
+  var _findRowRange = function findRowRange(findRowIndex) {
+    var checkRow = table.children[findRowIndex];
+    var combinedIndexes = checkRow.children.reduce(function (acc, cell, index) {
+      if (cell.is_combined) acc.push(index);
+      if (cell.rowspan > 1) {
+        maxRowIndex = Math.max(maxRowIndex, findRowIndex + cell.rowspan - 1);
+        _findRowRange(maxRowIndex);
+      }
+      return acc;
+    }, []);
+    combinedIndexes.some(function (combinedIndex) {
+      var _searchCombinedMainCe = searchCombinedMainCell(table, findRowIndex, combinedIndex),
+        mainCellRowIndex = _searchCombinedMainCe.rowIndex,
+        currentCell = _searchCombinedMainCe.currentCell;
+      if (minRowIndex > mainCellRowIndex) {
+        minRowIndex = mainCellRowIndex;
+        _findRowRange(minRowIndex, 0);
+        return false;
+      } else if (maxRowIndex < mainCellRowIndex + currentCell.rowspan - 1) {
+        maxRowIndex = mainCellRowIndex + currentCell.rowspan - 1;
+        _findRowRange(maxRowIndex, 0);
+        return false;
+      }
+      return false;
+    });
+  };
+  _findRowRange(rowIndex);
+  return {
+    minRowIndex: minRowIndex,
+    maxRowIndex: maxRowIndex,
+    minColIndex: minColIndex,
+    maxColIndex: maxColIndex
+  };
+};
+var getTableColumnSelectedRange = exports.getTableColumnSelectedRange = function getTableColumnSelectedRange(table, columnIndex) {
+  var minRowIndex = 0;
+  var maxRowIndex = table.children.length - 1;
+  var minColIndex = columnIndex;
+  var maxColIndex = columnIndex;
+  var _findColRange = function findColRange(findColIndex) {
+    var combinedIndexes = [];
+    table.children.forEach(function (row, rowIndex) {
+      var cell = row.children[findColIndex];
+      if (cell.is_combined) combinedIndexes.push(rowIndex);
+      if (cell.colspan > 1) {
+        maxColIndex = Math.max(maxColIndex, findColIndex + cell.colspan - 1);
+        _findColRange(maxColIndex);
+      }
+    });
+    combinedIndexes.some(function (combinedIndex) {
+      var _searchCombinedMainCe2 = searchCombinedMainCell(table, combinedIndex, findColIndex),
+        mainCellColIndex = _searchCombinedMainCe2.cellIndex,
+        currentCell = _searchCombinedMainCe2.currentCell;
+      if (minColIndex > mainCellColIndex) {
+        minColIndex = mainCellColIndex;
+        _findColRange(minColIndex, 0);
+        return false;
+      } else if (maxColIndex < mainCellColIndex + currentCell.colspan - 1) {
+        maxColIndex = mainCellColIndex + currentCell.colspan - 1;
+        _findColRange(maxColIndex, 0);
+        return false;
+      }
+      return false;
+    });
+  };
+  _findColRange(columnIndex);
+  return {
+    minRowIndex: minRowIndex,
+    maxRowIndex: maxRowIndex,
+    minColIndex: minColIndex,
+    maxColIndex: maxColIndex
+  };
+};
+var isTableWidthFitScreen = exports.isTableWidthFitScreen = function isTableWidthFitScreen(editor) {
+  var _getSelectedInfo15 = getSelectedInfo(editor),
+    table = _getSelectedInfo15.table;
+  var tableNode = _slateReact.ReactEditor.toDOMNode(editor, table);
+  if (!tableNode) return;
+  var tableDom = tableNode.querySelector('.sdoc-table-scroll-wrapper');
+  var _tableDom$getBounding = tableDom.getBoundingClientRect(),
+    tableWidth = _tableDom$getBounding.width;
+  var sdocWidth = editor.width;
+  if (tableWidth >= sdocWidth) return true;
+  return false;
+};
+var fitTableColumnToScreen = exports.fitTableColumnToScreen = function fitTableColumnToScreen(editor) {
+  var _getSelectedInfo16 = getSelectedInfo(editor),
+    table = _getSelectedInfo16.table,
+    tablePath = _getSelectedInfo16.tablePath;
+  var colCount = table.columns.length;
+  var columnWidth = Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colCount));
+  var columns = table.columns.map(function (column) {
+    return (0, _objectSpread3["default"])((0, _objectSpread3["default"])({}, column), {}, {
+      width: columnWidth
+    });
+  });
+  _slate.Transforms.setNodes(editor, {
+    columns: columns
+  }, {
+    at: tablePath
+  });
+};
+var deleteTableSelectCells = exports.deleteTableSelectCells = function deleteTableSelectCells(editor, deleteRange) {
+  // eslint-disable-next-line no-unused-vars
+  var start = deleteRange.start,
+    end = deleteRange.end,
+    rowsLength = deleteRange.rowsLength,
+    columnLength = deleteRange.columnLength;
+  // table path [tableIdx, rowIdx, colIdx, ...];
+  if (start.length <= 3) return;
+  var tableIndex = start[0];
+  var minRowIndex = start[1];
+  var deletePaths = [];
+  if (start[1] === end[1]) {
+    var minColIndex = start[2];
+    var maxColIndex = end[2];
+    for (var colIndex = minColIndex; colIndex <= maxColIndex; colIndex++) {
+      deletePaths.push([tableIndex, minRowIndex, colIndex]);
+    }
+  }
+  if (start[1] !== end[1]) {
+    var isAfter = end[1] - start[1] === 1;
+    // push first row
+    var _minColIndex = start[2];
+    for (var _colIndex = _minColIndex; _colIndex <= columnLength - 1; _colIndex++) {
+      deletePaths.push([tableIndex, minRowIndex, _colIndex]);
+    }
+
+    // push center row
+    if (!isAfter) {
+      for (var i = start[1] + 1; i <= end[1] - 1; i++) {
+        for (var j = 0; j <= columnLength - 1; j++) {
+          deletePaths.push([tableIndex, i, j]);
+        }
+      }
+    }
+
+    // push last row
+    var _maxColIndex = end[2];
+    var maxRowIndex = end[1];
+    for (var _colIndex2 = 0; _colIndex2 <= _maxColIndex; _colIndex2++) {
+      deletePaths.push([tableIndex, maxRowIndex, _colIndex2]);
+    }
+  }
+  for (var _i9 = 0; _i9 < deletePaths.length; _i9++) {
+    var path = deletePaths[_i9];
+    var node = (0, _core.getNode)(editor, path);
+    var firstNode = node.children[0];
+    (0, _core.replaceNodeChildren)(editor, {
+      at: path,
+      nodes: (0, _objectSpread3["default"])((0, _objectSpread3["default"])({}, firstNode), {}, {
+        text: ''
+      })
+    });
+  }
+};