@seafile/comment-editor 0.0.1-alpha.9 → 0.0.2

package/dist/basic-sdk/extension/plugins/table/helpers.js

@@ -1,2124 +0,0 @@
-"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 _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");
-const isTableMenuDisabled = (editor, readonly) => {
-  if (readonly) return true;
-  const {
-    selection
-  } = editor;
-  if (selection === null) return true;
-  if (!_slate.Range.isCollapsed(selection)) return true;
-  const [match] = _slate.Editor.nodes(editor, {
-    match: n => {
-      let type = (0, _core.getNodeType)(n);
-      if (!type && (0, _core.isTextNode)(n) && n.id) {
-        const 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
-  });
-  if (match) return true;
-  return false;
-};
-exports.isTableMenuDisabled = isTableMenuDisabled;
-const isCombineCellsDisabled = (editor, readonly) => {
-  if (readonly) return true;
-  const {
-    selection,
-    tableSelectedRange
-  } = editor;
-  if (!selection) return true;
-  if (!_objectUtils.default.isSameObject(tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
-    return false;
-  }
-  return true;
-};
-exports.isCombineCellsDisabled = isCombineCellsDisabled;
-const generateTableCell = (editor, rowIndex, cellIndex) => {
-  let style = {};
-  const tableNodeEntry = (0, _core.getSelectedNodeEntryByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
-  if (tableNodeEntry && rowIndex !== undefined && cellIndex !== undefined) {
-    const [, tablePath] = tableNodeEntry;
-    style = getCellInheritStyles(editor, tablePath, rowIndex, cellIndex);
-  }
-  return {
-    id: _slugid.default.nice(),
-    type: _constants2.ELEMENT_TYPE.TABLE_CELL,
-    children: [{
-      text: '',
-      id: _slugid.default.nice()
-    }],
-    style,
-    inherit_style: style
-  };
-};
-exports.generateTableCell = generateTableCell;
-const generateTableRow = (editor, colsCount, rowIndex) => {
-  let children = [];
-  for (let i = 0; i < colsCount; i++) {
-    const tableCell = generateTableCell(editor, rowIndex, i);
-    children.push(tableCell);
-  }
-  return {
-    id: _slugid.default.nice(),
-    type: _constants2.ELEMENT_TYPE.TABLE_ROW,
-    children: children,
-    style: {
-      [_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
- */
-exports.generateTableRow = generateTableRow;
-const generateEmptyTable = (editor, tableProps) => {
-  const {
-    size = [0, 0],
-    alternate_highlight = false,
-    alternate_highlight_color
-  } = tableProps;
-  const rowsCount = size[0];
-  const colsCount = size[1];
-  let children = [];
-  for (let i = 0; i < rowsCount; i++) {
-    const tableRow = generateTableRow(editor, colsCount, i);
-    children.push(tableRow);
-  }
-  const columnWidth = Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colsCount));
-  let columns = [];
-  for (let i = 0; i < colsCount; i++) {
-    columns.push({
-      width: columnWidth
-    });
-  }
-  return {
-    id: _slugid.default.nice(),
-    type: _constants2.ELEMENT_TYPE.TABLE,
-    children: children,
-    columns,
-    ui: {
-      alternate_highlight,
-      alternate_highlight_color
-    },
-    style: {
-      gridTemplateColumns: `repeat(${colsCount}, ${columnWidth}px)`,
-      gridAutoRows: `minmax(${_constants3.TABLE_ROW_MIN_HEIGHT}px, auto)`
-    }
-  };
-};
-exports.generateEmptyTable = generateEmptyTable;
-const insertTable = function (editor, size, selection) {
-  let 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;
-  }
-  const tableNode = generateEmptyTable(editor, {
-    size
-  });
-  const validSelection = selection || editor.selection;
-  const path = _slate.Editor.path(editor, validSelection);
-  handleInsertTable(editor, position, path, tableNode);
-};
-
-// tableSize [tableHeight, tableWidth]
-exports.insertTable = insertTable;
-const getSelectedInfo = editor => {
-  const currentTable = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
-  const currentRow = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE_ROW);
-  const currentCell = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE_CELL);
-  const 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]
-  };
-};
-exports.getSelectedInfo = getSelectedInfo;
-const isInTable = editor => {
-  const selectedNodes = (0, _core.getSelectedElems)(editor);
-  if (!selectedNodes.some(node => node.type === _constants2.ELEMENT_TYPE.TABLE)) return false;
-  const firstSelectedNode = selectedNodes[0];
-  return firstSelectedNode.type === _constants2.ELEMENT_TYPE.TABLE;
-};
-exports.isInTable = isInTable;
-const isAllInTable = editor => {
-  const selectedNodes = (0, _core.getSelectedElems)(editor);
-  if (!selectedNodes.some(node => node.type === _constants2.ELEMENT_TYPE.TABLE)) return false;
-  const firstSelectedNode = selectedNodes[0];
-  if (firstSelectedNode.type !== _constants2.ELEMENT_TYPE.TABLE) return false;
-  return selectedNodes.slice(1).every(node => [_constants2.ELEMENT_TYPE.TABLE_ROW, _constants2.ELEMENT_TYPE.TABLE_CELL].includes(node.type)); // same table element
-};
-exports.isAllInTable = isAllInTable;
-const isInTableSameCell = editor => {
-  const {
-    anchor,
-    focus
-  } = editor.selection;
-  const match = n => n.type === _constants2.ELEMENT_TYPE.TABLE_CELL;
-  const anchorNode = (0, _core.getAboveBlockNode)(editor, {
-    at: anchor,
-    match
-  });
-  const focusNode = (0, _core.getAboveBlockNode)(editor, {
-    at: focus,
-    match
-  });
-  if (!anchorNode || !focusNode) return false;
-  return _slate.Path.equals(anchorNode[1], focusNode[1]);
-};
-exports.isInTableSameCell = isInTableSameCell;
-const setCellStyle = (editor, style) => {
-  // Select single cell
-  if (_objectUtils.default.isSameObject(editor.tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
-    const selectedNodes = (0, _core.getSelectedElems)(editor);
-    let firstTableCellNodePath;
-    selectedNodes.forEach(node => {
-      if (node.type === _constants2.ELEMENT_TYPE.TABLE_CELL) {
-        const path = (0, _core.findPath)(editor, node);
-        if (path) {
-          firstTableCellNodePath = firstTableCellNodePath ? firstTableCellNodePath : path;
-          _slate.Transforms.setNodes(editor, {
-            style: {
-              ...node.style,
-              ...style
-            },
-            inherit_style: generateInheritStyle(_constants3.INHERIT_CELL_STYLE_WHEN_SELECT_SINGLE, style, node)
-          }, {
-            at: path
-          });
-        }
-      }
-    });
-    if (firstTableCellNodePath) {
-      const start = _slate.Editor.start(editor, firstTableCellNodePath);
-      const end = _slate.Editor.end(editor, firstTableCellNodePath);
-      const newSelection = {
-        anchor: start,
-        focus: end
-      };
-      _slate.Transforms.select(editor, newSelection);
-    }
-    return;
-  }
-  // Select multiple cells
-  const {
-    minColIndex,
-    maxColIndex,
-    minRowIndex,
-    maxRowIndex
-  } = editor.tableSelectedRange;
-  const {
-    tablePath
-  } = getSelectedInfo(editor);
-  for (let i = minRowIndex; i <= maxRowIndex; i++) {
-    for (let j = minColIndex; j <= maxColIndex; j++) {
-      const path = [...tablePath, i, j];
-      const node = (0, _core.getNode)(editor, path);
-      _slate.Transforms.setNodes(editor, {
-        style: {
-          ...node.style,
-          ...style
-        },
-        inherit_style: generateInheritStyle(_constants3.INHERIT_CELL_STYLE_WHEN_SELECT_MULTIPLE, style, node)
-      }, {
-        at: path
-      });
-    }
-  }
-};
-exports.setCellStyle = setCellStyle;
-const insertTableRow = function (editor, table, rowIndex) {
-  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants3.TABLE_ELEMENT_POSITION.AFTER;
-  const tableRowCount = table.children.length;
-  if (tableRowCount >= _constants3.TABLE_MAX_ROWS) return;
-  const tableColumnCount = table.children[0].children.length;
-  const row = generateTableRow(editor, tableColumnCount, rowIndex);
-  const tablePath = (0, _core.findPath)(editor, table);
-  const targetPath = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
-  _slate.Transforms.insertNodes(editor, row, {
-    at: targetPath
-  });
-  const focusPath = [...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);
-  }
-};
-exports.insertTableRow = insertTableRow;
-const handleCombinedCellsAfterInsertTableRow = (editor, tablePath, table, rowIndex) => {
-  // important background info: the new row is inserted after rowIndex
-  const cells = table.children[rowIndex].children;
-  for (let i = 0, len = cells.length; i < len; i++) {
-    const {
-      is_combined,
-      rowspan,
-      colspan
-    } = cells[i];
-    if (is_combined) {
-      for (let ri = rowIndex - 1; ri >= 0; ri--) {
-        const {
-          is_combined: ri_is_combined,
-          rowspan: ri_rowspan,
-          colspan: ri_colspan
-        } = table.children[ri].children[i];
-        if (!ri_is_combined && ri + ri_rowspan - 1 > rowIndex) {
-          _slate.Transforms.setNodes(editor, {
-            rowspan: ri_rowspan + 1
-          }, {
-            at: [...tablePath, ri, i]
-          });
-          for (let j = 0; j < ri_colspan; j++) {
-            _slate.Transforms.setNodes(editor, {
-              'is_combined': true
-            }, {
-              at: [...tablePath, rowIndex + 1, i + j]
-            });
-          }
-          break;
-        }
-      }
-    } else {
-      if (rowspan > 1) {
-        _slate.Transforms.setNodes(editor, {
-          rowspan: rowspan + 1
-        }, {
-          at: [...tablePath, rowIndex, i]
-        });
-        for (let j = 0; j < colspan; j++) {
-          _slate.Transforms.setNodes(editor, {
-            'is_combined': true
-          }, {
-            at: [...tablePath, rowIndex + 1, i + j]
-          });
-        }
-      }
-    }
-  }
-};
-exports.handleCombinedCellsAfterInsertTableRow = handleCombinedCellsAfterInsertTableRow;
-const insertTableColumn = function (editor, table, columnIndex) {
-  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants3.TABLE_ELEMENT_POSITION.AFTER;
-  const tableColumnCount = table.children[0].children.length;
-  if (tableColumnCount >= _constants3.TABLE_MAX_COLUMNS) return;
-  const newCellIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? columnIndex + 1 : columnIndex;
-  const newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, 1);
-  updateColumnWidth(editor, table, newColumns);
-  const tablePath = (0, _core.findPath)(editor, table);
-  const tableRowCount = table.children.length;
-  for (let i = 0; i < tableRowCount; i++) {
-    const newCellPath = [...tablePath, i, newCellIndex];
-    const newCell = generateTableCell(editor, i, columnIndex);
-    _slate.Transforms.insertNodes(editor, newCell, {
-      at: newCellPath
-    });
-  }
-  const focusPath = [...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);
-  }
-};
-exports.insertTableColumn = insertTableColumn;
-const handleCombinedCellsAfterInsertTableColumn = (editor, tablePath, table, columnIndex) => {
-  // important background info: the new column is inserted after columnIndex
-  for (let i = 0, len = table.children.length; i < len; i++) {
-    const {
-      is_combined,
-      rowspan,
-      colspan
-    } = table.children[i].children[columnIndex];
-    if (is_combined) {
-      for (let ci = columnIndex - 1; ci >= 0; ci--) {
-        const {
-          is_combined: ci_is_combined,
-          rowspan: ci_rowspan,
-          colspan: ci_colspan
-        } = table.children[i].children[ci];
-        if (!ci_is_combined && ci + ci_colspan - 1 > columnIndex) {
-          _slate.Transforms.setNodes(editor, {
-            colspan: ci_colspan + 1
-          }, {
-            at: [...tablePath, i, ci]
-          });
-          for (let j = 0; j < ci_rowspan; j++) {
-            _slate.Transforms.setNodes(editor, {
-              'is_combined': true
-            }, {
-              at: [...tablePath, i + j, columnIndex + 1]
-            });
-          }
-          break;
-        }
-      }
-    } else {
-      if (colspan > 1) {
-        _slate.Transforms.setNodes(editor, {
-          colspan: colspan + 1
-        }, {
-          at: [...tablePath, i, columnIndex]
-        });
-        for (let j = 0; j < rowspan; j++) {
-          _slate.Transforms.setNodes(editor, {
-            'is_combined': true
-          }, {
-            at: [...tablePath, i + j, columnIndex + 1]
-          });
-        }
-      }
-    }
-  }
-};
-exports.handleCombinedCellsAfterInsertTableColumn = handleCombinedCellsAfterInsertTableColumn;
-const insertTableElement = function (editor, type) {
-  let position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _constants3.TABLE_ELEMENT_POSITION.AFTER;
-  let count = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-  const {
-    table,
-    tablePath,
-    tableSize,
-    rowIndex,
-    cellIndex
-  } = getSelectedInfo(editor);
-  const 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;
-    const targetPath = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
-    const validCount = Math.min(_constants3.TABLE_MAX_ROWS - tableSize[0], count);
-    for (let i = 0; i < validCount; i++) {
-      const 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)) {
-        const targetRowIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? rowIndex : rowIndex - 1;
-        const currentTable = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
-        handleCombinedCellsAfterInsertTableRow(editor, tablePath, currentTable, targetRowIndex);
-      }
-    }
-    const focusPath = [...targetPath, cellIndex];
-    (0, _core.focusEditor)(editor, focusPath);
-    return;
-  }
-  if (type === _constants3.TABLE_ELEMENT.COLUMN) {
-    if (tableSize[1] >= _constants3.TABLE_MAX_COLUMNS) return;
-    const newCellIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? cellIndex + 1 : cellIndex;
-    const validCount = Math.min(_constants3.TABLE_MAX_COLUMNS - tableSize[1], count);
-    const newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, validCount);
-    updateColumnWidth(editor, table, newColumns);
-    for (let j = 0; j < validCount; j++) {
-      for (let i = 0; i < tableSize[0]; i++) {
-        const newCellPath = [...tablePath, i, newCellIndex];
-        const newCell = generateTableCell(editor, i, cellIndex);
-        _slate.Transforms.insertNodes(editor, newCell, {
-          at: newCellPath
-        });
-      }
-      // handle combined cells
-      if (!(cellIndex === 0 && position === _constants3.TABLE_ELEMENT_POSITION.BEFORE)) {
-        const targetColumnIndex = position === _constants3.TABLE_ELEMENT_POSITION.AFTER ? cellIndex : cellIndex - 1;
-        const currentTable = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
-        handleCombinedCellsAfterInsertTableColumn(editor, tablePath, currentTable, targetColumnIndex);
-      }
-    }
-    const focusPath = [...tablePath, rowIndex, cellIndex + 1, 0];
-    (0, _core.focusEditor)(editor, focusPath);
-    return;
-  }
-};
-exports.insertTableElement = insertTableElement;
-const combineCells = editor => {
-  const {
-    tablePath
-  } = getSelectedInfo(editor);
-  const {
-    minColIndex,
-    maxColIndex,
-    minRowIndex,
-    maxRowIndex
-  } = editor.tableSelectedRange;
-  let newCellContent = [];
-  for (let i = minRowIndex; i < maxRowIndex + 1; i++) {
-    for (let j = minColIndex; j < maxColIndex + 1; j++) {
-      let nodePath = [...tablePath, i, j];
-      let 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);
-    }
-  }
-  const targetCellPath = [...tablePath, minRowIndex, minColIndex];
-  const 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
-  const eventBus = _eventBus.default.getInstance();
-  eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
-};
-exports.combineCells = combineCells;
-const splitCell = (editor, rowNumber, columnNumber) => {
-  if (rowNumber === 1 && columnNumber === 1) {
-    return;
-  }
-  const {
-    cell,
-    rowIndex,
-    cellIndex,
-    cellPath,
-    tablePath
-  } = getSelectedInfo(editor);
-  const {
-    rowspan,
-    colspan
-  } = cell;
-  const rowspanBase = Math.floor(rowspan / rowNumber);
-  const rowspanLeft = rowspan % rowNumber;
-  const colspanBase = Math.floor(colspan / columnNumber);
-  const colspanLeft = colspan % columnNumber;
-  const cellNumber = rowNumber * columnNumber;
-  const dataBlockNumber = Math.ceil(cell.children.length / cellNumber);
-  let firstNewCell;
-  let rowspanSum = 0;
-  for (let i = 0; i < rowNumber; i++) {
-    let newRowSpan = rowspanBase + (i + 1 <= rowspanLeft ? 1 : 0);
-    let colspanSum = 0;
-    for (let j = 0; j < columnNumber; j++) {
-      const newCell = generateTableCell(editor);
-      let startIndex = (i * columnNumber + j) * dataBlockNumber;
-      if (startIndex < cell.children.length) {
-        let 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);
-      const newRowIndex = rowIndex + rowspanSum;
-      const newCellIndex = cellIndex + colspanSum;
-      const targetCellPath = [...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
-  });
-};
-exports.splitCell = splitCell;
-const syncRemoveTable = (editor, path) => {
-  let validPath = path;
-  if (!validPath) {
-    const {
-      tablePath
-    } = getSelectedInfo(editor);
-    validPath = tablePath;
-  }
-  editor.reSetTableSelectedRange();
-  _slate.Transforms.removeNodes(editor, {
-    at: validPath
-  });
-};
-exports.syncRemoveTable = syncRemoveTable;
-const removeTable = (editor, path) => {
-  let validPath = path;
-  if (!validPath) {
-    const {
-      tablePath
-    } = getSelectedInfo(editor);
-    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(() => {
-    _slate.Transforms.removeNodes(editor, {
-      at: validPath
-    });
-    if (_slate.Editor.hasPath(editor, validPath)) {
-      const endOfLastNodePoint = _slate.Editor.end(editor, validPath);
-      const range = {
-        anchor: endOfLastNodePoint,
-        focus: endOfLastNodePoint
-      };
-      (0, _core.focusEditor)(editor, range);
-    }
-  }, 0);
-};
-exports.removeTable = removeTable;
-const removeTableElement = (editor, type) => {
-  const {
-    table,
-    tablePath,
-    tableSize,
-    rowPath,
-    rowIndex,
-    cellIndex
-  } = getSelectedInfo(editor);
-  const 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)) {
-      const {
-        minRowIndex,
-        maxRowIndex
-      } = editor.tableSelectedRange;
-      if (minRowIndex === 0 && maxRowIndex === tableSize[0] - 1) {
-        removeTable(editor, tablePath);
-        return;
-      }
-      for (let i = minRowIndex; i <= maxRowIndex; i++) {
-        queueMicrotask(() => {
-          _slate.Transforms.removeNodes(editor, {
-            at: [...tablePath, minRowIndex]
-          });
-        });
-      }
-      const focusPath = [...tablePath, minRowIndex === 0 ? 0 : minRowIndex - 1, cellIndex];
-      (0, _core.focusEditor)(editor, focusPath);
-      return;
-    }
-    handleCombinedCellsBeforeDeleteTableRow(editor, tablePath, table, rowIndex);
-    _slate.Transforms.removeNodes(editor, {
-      at: rowPath
-    });
-    const focusRowIndex = rowIndex === tableSize[0] - 1 ? rowIndex - 1 : rowIndex;
-    const focusPath = [...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)) {
-      const {
-        minColIndex,
-        maxColIndex
-      } = editor.tableSelectedRange;
-      if (minColIndex === 0 && maxColIndex === tableSize[1] - 1) {
-        removeTable(editor, tablePath);
-        return;
-      }
-      const columns = getTableColumns(editor, table);
-      const newColumns = [...columns.slice(0, minColIndex), ...columns.slice(maxColIndex + 1)];
-      updateColumnWidth(editor, table, newColumns);
-      for (let i = 0; i < tableSize[0]; i++) {
-        for (let j = minColIndex; j <= maxColIndex; j++) {
-          // count
-          const cellPath = [...tablePath, i, minColIndex];
-          _slate.Transforms.removeNodes(editor, {
-            at: cellPath
-          });
-        }
-      }
-      const focusPath = [...tablePath, rowIndex, minColIndex === 0 ? 0 : minColIndex - 1];
-      (0, _core.focusEditor)(editor, focusPath);
-      return;
-    }
-    const columns = getTableColumns(editor, table);
-    const newColumns = columns.slice(0);
-    newColumns.splice(cellIndex, 1);
-    updateColumnWidth(editor, table, newColumns);
-    handleCombinedCellsBeforeDeleteTableColumn(editor, tablePath, table, cellIndex);
-    for (let i = 0; i < tableSize[0]; i++) {
-      const cellPath = [...tablePath, i, cellIndex];
-      _slate.Transforms.removeNodes(editor, {
-        at: cellPath
-      });
-    }
-    const focusCellIndex = cellIndex === tableSize[1] - 1 ? cellIndex - 1 : cellIndex;
-    const focusPath = [...tablePath, rowIndex, focusCellIndex];
-    (0, _core.focusEditor)(editor, focusPath);
-    return;
-  }
-};
-
-// handle combined cells before deleting a row
-exports.removeTableElement = removeTableElement;
-const handleCombinedCellsBeforeDeleteTableRow = (editor, tablePath, table, rowIndex) => {
-  const cells = table.children[rowIndex].children;
-  for (let i = 0, len = cells.length; i < len; i++) {
-    const {
-      is_combined,
-      rowspan,
-      colspan
-    } = cells[i];
-    if (is_combined) {
-      for (let ri = rowIndex - 1; ri >= 0; ri--) {
-        const {
-          is_combined: ri_is_combined,
-          rowspan: ri_rowspan
-        } = table.children[ri].children[i];
-        if (!ri_is_combined && ri + ri_rowspan - 1 >= rowIndex) {
-          _slate.Transforms.setNodes(editor, {
-            rowspan: ri_rowspan - 1
-          }, {
-            at: [...tablePath, ri, i]
-          });
-          break;
-        }
-      }
-    } else {
-      if (rowspan > 1) {
-        const targetCellPath = [...tablePath, rowIndex + 1, i];
-        const 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
-exports.handleCombinedCellsBeforeDeleteTableRow = handleCombinedCellsBeforeDeleteTableRow;
-const handleCombinedCellsBeforeDeleteTableColumn = (editor, tablePath, table, columnIndex) => {
-  for (let i = 0, len = table.children.length; i < len; i++) {
-    const {
-      is_combined,
-      rowspan,
-      colspan
-    } = table.children[i].children[columnIndex];
-    if (is_combined) {
-      for (let ci = columnIndex - 1; ci >= 0; ci--) {
-        const {
-          is_combined: ci_is_combined,
-          colspan: ci_colspan
-        } = table.children[i].children[ci];
-        if (!ci_is_combined && ci + ci_colspan - 1 >= columnIndex) {
-          _slate.Transforms.setNodes(editor, {
-            colspan: ci_colspan - 1
-          }, {
-            at: [...tablePath, i, ci]
-          });
-          break;
-        }
-      }
-    } else {
-      if (colspan > 1) {
-        const targetCellPath = [...tablePath, i, columnIndex + 1];
-        const newCell = generateTableCell(editor);
-        newCell.rowspan = rowspan;
-        newCell.colspan = colspan - 1;
-        _slate.Transforms.removeNodes(editor, {
-          at: targetCellPath
-        });
-        _slate.Transforms.insertNodes(editor, newCell, {
-          at: targetCellPath
-        });
-      }
-    }
-  }
-};
-exports.handleCombinedCellsBeforeDeleteTableColumn = handleCombinedCellsBeforeDeleteTableColumn;
-const setTableSelectedRange = (editor, range) => {
-  if (range) {
-    editor.tableSelectedRange = range;
-    return;
-  }
-  editor.tableSelectedRange = _constants3.EMPTY_SELECTED_RANGE;
-};
-exports.setTableSelectedRange = setTableSelectedRange;
-const updateTableRowHeight = (editor, element, rowHeight) => {
-  const path = (0, _core.findPath)(editor, element);
-  const targetNode = (0, _core.getNode)(editor, path);
-  const {
-    style = {}
-  } = targetNode;
-  if (style[_constants3.TABLE_ROW_STYLE.MIN_HEIGHT] === rowHeight) return;
-  _slate.Transforms.setNodes(editor, {
-    style: {
-      ...style,
-      [_constants3.TABLE_ROW_STYLE.MIN_HEIGHT]: rowHeight
-    }
-  }, {
-    at: path
-  });
-};
-exports.updateTableRowHeight = updateTableRowHeight;
-const updateColumnWidth = (editor, element, columns) => {
-  const path = (0, _core.findPath)(editor, element);
-  _slate.Transforms.setNodes(editor, {
-    columns: columns
-  }, {
-    at: path
-  });
-};
-exports.updateColumnWidth = updateColumnWidth;
-const getTableColumnsWidth = function () {
-  let columns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  if (!Array.isArray(columns) || columns.length === 0) return 0;
-  return columns.reduce((pre, cur) => pre + cur.width, 0);
-};
-exports.getTableColumnsWidth = getTableColumnsWidth;
-const getTableColumnsAfterInsertColumn = (editor, element, targetColumnIndex, insertColumnCount) => {
-  const columns = getTableColumns(editor, element);
-  let newColumns = columns.slice(0);
-  let totalColumnsWidth = getTableColumnsWidth(columns);
-  const targetColumn = columns[targetColumnIndex] || columns[targetColumnIndex - 1];
-  const targetInsertColumnsWidth = targetColumn.width * insertColumnCount;
-
-  // Currently in scrolling state, insert directly
-  if (totalColumnsWidth > editor.width) {
-    for (let 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 (let i = 0; i < insertColumnCount; i++) {
-      newColumns.push(targetColumn);
-    }
-    return newColumns;
-  }
-
-  // After inserting a new column is a scrolling state
-  for (let i = 0; i < insertColumnCount; i++) {
-    totalColumnsWidth += targetColumn.width;
-    newColumns.splice(targetColumnIndex, 0, targetColumn);
-  }
-  const proportion = totalColumnsWidth / (editor.width - 1);
-  return newColumns.map(column => {
-    return {
-      ...column,
-      width: Math.max(parseInt(column.width / proportion), _constants3.TABLE_CELL_MIN_WIDTH)
-    };
-  });
-};
-exports.getTableColumnsAfterInsertColumn = getTableColumnsAfterInsertColumn;
-const getTableColumns = (editor, element) => {
-  if (!element) return [];
-  let tableElement = element;
-  if (element.type === _constants2.ELEMENT_TYPE.TABLE_CELL) {
-    const cellPath = (0, _core.findPath)(editor, element);
-    const tablePath = cellPath.slice(0, -2);
-    tableElement = (0, _core.getNode)(editor, tablePath);
-  }
-  const {
-    columns,
-    children
-  } = tableElement;
-  if (columns) return columns;
-  const columnsCount = children[0].children.length;
-  let initColumns = [];
-  const pageEditAreaWidth = editor.width || _constants.PAGE_EDIT_AREA_WIDTH;
-  for (let i = 0; i < columnsCount; i++) {
-    const column = {
-      width: Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
-    };
-    initColumns.push(column);
-  }
-  return initColumns;
-};
-exports.getTableColumns = getTableColumns;
-const getCellColumn = (editor, cellElement) => {
-  let column = {
-    width: _constants3.TABLE_CELL_MIN_WIDTH
-  };
-  if (!editor || !cellElement) return column;
-  const cellPath = (0, _core.findPath)(editor, cellElement);
-  if (!cellPath) return column;
-  const pathLength = cellPath.length;
-  const cellIndex = cellPath[pathLength - 1];
-  const tablePath = cellPath.slice(0, -2);
-  const tableElement = (0, _core.getNode)(editor, tablePath);
-  const {
-    columns
-  } = tableElement;
-  const columnsCount = tableElement.children[0].children.length;
-  const 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))
-  };
-};
-exports.getCellColumn = getCellColumn;
-const getFirstTableCell = element => {
-  let tableCellElement = element;
-  while (tableCellElement && !(tableCellElement.hasAttribute('row-index') && tableCellElement.hasAttribute('cell-index'))) {
-    tableCellElement = tableCellElement.parentNode;
-  }
-  return tableCellElement;
-};
-exports.getFirstTableCell = getFirstTableCell;
-const elementHasImage = element => {
-  if (!element) return false;
-  if (!Array.isArray(element.children) || element.children.length === 0) return false;
-  return element.children.some(child => {
-    if (child.type === _constants2.ELEMENT_TYPE.IMAGE) return true;
-    if (_objectUtils.default.hasProperty(child, 'children')) {
-      return elementHasImage(child);
-    }
-    return false;
-  });
-};
-exports.elementHasImage = elementHasImage;
-const isSelectedAllCell = editor => {
-  const {
-    tableSize
-  } = getSelectedInfo(editor);
-  return _objectUtils.default.isSameObject(editor.tableSelectedRange, {
-    minColIndex: 0,
-    maxColIndex: tableSize[1] - 1,
-    minRowIndex: 0,
-    maxRowIndex: tableSize[0] - 1
-  });
-};
-exports.isSelectedAllCell = isSelectedAllCell;
-const insertMultipleRowsAndColumns = (editor, rows, columns) => {
-  const {
-    table,
-    tablePath,
-    tableSize,
-    rowIndex,
-    cellIndex
-  } = getSelectedInfo(editor);
-  let newTable = (0, _deepCopy.default)(table);
-  const eventBus = _eventBus.default.getInstance();
-  eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
-  const insertRows = rows.slice(tableSize[0] - rowIndex);
-  const insertColumns = columns.slice(tableSize[1] - cellIndex);
-  const validInsertRows = insertRows.slice(0, Math.min(_constants3.TABLE_MAX_ROWS - tableSize[0], insertRows.length));
-  const validInsertColumns = insertColumns.slice(0, Math.min(_constants3.TABLE_MAX_COLUMNS - tableSize[1], columns.length));
-  for (let i = 0; i < validInsertRows.length; i++) {
-    const insertRow = validInsertRows[i];
-    const row = generateTableRow(editor, tableSize[1], rowIndex);
-    row.style = insertRow.style;
-    newTable.children.push(row);
-  }
-  if (validInsertColumns.length > 0) {
-    newTable.columns = [...table.columns, ...validInsertColumns];
-  }
-  for (let j = 0; j < validInsertColumns.length; j++) {
-    for (let i = 0; i < tableSize[0] + validInsertRows.length; i++) {
-      const newCell = generateTableCell(editor);
-      newTable.children[i].children.push(newCell);
-    }
-  }
-  for (let i = rowIndex; i < Math.min(_constants3.TABLE_MAX_ROWS, rowIndex + rows.length); i++) {
-    const row = rows[i - rowIndex];
-    const cells = row.children;
-    for (let j = cellIndex; j < Math.min(_constants3.TABLE_MAX_COLUMNS, cellIndex + columns.length); j++) {
-      const replaceCellIndex = j - cellIndex;
-      const replaceCell = cells[replaceCellIndex];
-      newTable.children[i].children[j].children = (0, _helpers.replacePastedDataId)(replaceCell.children);
-    }
-  }
-  (0, _core.replaceNode)(editor, {
-    at: tablePath,
-    nodes: newTable
-  });
-  (0, _core.focusEditor)(editor, [...tablePath, rowIndex, cellIndex, 0]);
-  const {
-    focus: newFocus
-  } = editor.selection;
-  _slate.Transforms.select(editor, {
-    focus: newFocus,
-    anchor: newFocus
-  });
-  return;
-};
-exports.insertMultipleRowsAndColumns = insertMultipleRowsAndColumns;
-const setTableFragmentData = (editor, dataTransfer) => {
-  const selectedNode = (0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
-  const fragment = editor.getFragment();
-  const string = JSON.stringify(fragment);
-  const encoded = window.btoa(encodeURIComponent(string));
-  dataTransfer.setData(`application/${_constants2.CLIPBOARD_FORMAT_KEY}`, encoded);
-  const tableDom = document.createElement('table');
-  const {
-    minColIndex,
-    maxColIndex,
-    minRowIndex,
-    maxRowIndex
-  } = editor.tableSelectedRange;
-  const tablePath = (0, _core.findPath)(editor, selectedNode);
-  for (let i = minRowIndex; i <= maxRowIndex; i++) {
-    const tr = document.createElement('tr');
-    for (let j = minColIndex; j <= maxColIndex; j++) {
-      const path = [...tablePath, i, j];
-      const node = (0, _core.getNode)(editor, path);
-      const td = document.createElement('td');
-      const 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);
-  const div = document.createElement('div');
-  div.appendChild(tableDom);
-  dataTransfer.setData('text/html', div.innerHTML);
-  dataTransfer.setData('text/plain', div.innerText);
-  return dataTransfer;
-};
-exports.setTableFragmentData = setTableFragmentData;
-const deleteTableRangeData = editor => {
-  const {
-    tableSelectedRange
-  } = editor;
-  const {
-    minRowIndex,
-    maxRowIndex,
-    minColIndex,
-    maxColIndex
-  } = tableSelectedRange;
-  const {
-    tablePath
-  } = getSelectedInfo(editor);
-  let forceCellPath;
-  for (let i = minRowIndex; i <= maxRowIndex; i++) {
-    for (let j = minColIndex; j <= maxColIndex; j++) {
-      const path = [...tablePath, i, j];
-      const node = (0, _core.getNode)(editor, path);
-      if (!forceCellPath && (_slate.Node.string(node) || elementHasImage(node))) {
-        forceCellPath = path;
-      }
-      const firstNode = node.children[0];
-      (0, _core.replaceNodeChildren)(editor, {
-        at: path,
-        nodes: {
-          ...firstNode,
-          text: ''
-        }
-      });
-    }
-  }
-  if (forceCellPath) {
-    editor.tableSelectedRange = _constants3.EMPTY_SELECTED_RANGE;
-    const eventBus = _eventBus.default.getInstance();
-    eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
-    (0, _core.focusEditor)(editor, forceCellPath);
-    const {
-      focus: newFocus
-    } = editor.selection;
-    _slate.Transforms.select(editor, {
-      focus: newFocus,
-      anchor: newFocus
-    });
-  }
-};
-exports.deleteTableRangeData = deleteTableRangeData;
-const deleteHandler = editor => {
-  const {
-    selection,
-    tableSelectedRange
-  } = editor;
-  if (selection == null) return '';
-  if (!_objectUtils.default.isSameObject(tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
-    if (isSelectedAllCell(editor)) return 'table';
-    return 'range';
-  }
-  const [cellNodeEntry] = _slate.Editor.nodes(editor, {
-    match: n => {
-      let type = (0, _core.getNodeType)(n);
-      if (!type && (0, _core.isTextNode)(n) && n.id) {
-        const parentNode = (0, _core.getParentNode)(editor.children, n.id);
-        type = (0, _core.getNodeType)(parentNode);
-      }
-      return type === _constants2.ELEMENT_TYPE.TABLE_CELL;
-    }
-  });
-  if (cellNodeEntry) {
-    const [, cellPath] = cellNodeEntry;
-    const start = _slate.Editor.start(editor, cellPath);
-    if (_slate.Point.equals(selection.anchor, start)) {
-      return 'default';
-    }
-  }
-  return '';
-};
-exports.deleteHandler = deleteHandler;
-const isTableLocation = (editor, location) => {
-  const tables = _slate.Editor.nodes(editor, {
-    at: location,
-    match: n => {
-      let type = (0, _core.getNodeType)(n);
-      if (!type && (0, _core.isTextNode)(n) && n.id) {
-        const parentNode = (0, _core.getParentNode)(editor.children, n.id);
-        type = (0, _core.getNodeType)(parentNode);
-      }
-      return type === _constants2.ELEMENT_TYPE.TABLE_CELL;
-    }
-  });
-  let hasTable = false;
-  // eslint-disable-next-line no-unused-vars
-  for (const table of tables) {
-    hasTable = true;
-  }
-  return hasTable;
-};
-exports.isTableLocation = isTableLocation;
-const isCursorAtCellEnd = function (cell) {
-  let cursor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  if (!cell) return false;
-  const childrenCount = cell.children.length;
-  const lastChildren = cell.children[childrenCount - 1];
-  const textCount = lastChildren.text.length;
-  return cursor === textCount;
-};
-exports.isCursorAtCellEnd = isCursorAtCellEnd;
-const isCursorAtCellStart = function () {
-  let cursor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  return cursor === 0;
-};
-exports.isCursorAtCellStart = isCursorAtCellStart;
-const focusCell = function (editor, event) {
-  let keyboardName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
-  const {
-    tableSize,
-    tablePath,
-    rowIndex,
-    cellIndex,
-    cell
-  } = getSelectedInfo(editor);
-  const tableParentPath = tablePath.slice(0, -1);
-  const tableIndex = tablePath[tablePath.length - 1];
-  const {
-    selection
-  } = editor;
-  const {
-    focus
-  } = selection;
-  if (keyboardName === _constants2.KEYBOARD.UP) {
-    if (!isCursorAtCellStart(focus.offset)) {
-      setTimeout(() => {
-        if ((0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE)) {
-          const {
-            cellIndex: newCellIndex
-          } = getSelectedInfo(editor);
-          if (Math.abs(newCellIndex - cellIndex) !== 0) {
-            if (rowIndex === 0) {
-              if (tableIndex !== 0) {
-                (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex - 1]);
-              }
-              return;
-            }
-            (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
-            const {
-              focus: newFocus
-            } = editor.selection;
-            _slate.Transforms.select(editor, {
-              focus: newFocus,
-              anchor: newFocus
-            });
-          }
-        }
-      }, 10);
-      return;
-    }
-    event.preventDefault();
-    if (rowIndex === 0) {
-      if (tableIndex !== 0) {
-        (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex - 1]);
-      }
-      return;
-    }
-    (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
-    const {
-      focus: newFocus
-    } = editor.selection;
-    _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, [...tableParentPath, tableIndex + 1]);
-      return;
-    }
-    if (cellIndex === tableSize[1] - 1) {
-      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex + 1, 0]);
-    } else {
-      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex + 1]);
-    }
-    const {
-      anchor: newAnchor
-    } = editor.selection;
-    _slate.Transforms.select(editor, {
-      focus: newAnchor,
-      anchor: newAnchor
-    });
-  }
-  if (keyboardName === _constants2.KEYBOARD.DOWN) {
-    if (!isCursorAtCellEnd(cell, focus.offset)) {
-      setTimeout(() => {
-        if ((0, _core.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE)) {
-          const {
-            cellIndex: newCellIndex
-          } = getSelectedInfo(editor);
-          if (Math.abs(newCellIndex - cellIndex) !== 0) {
-            if (rowIndex === tableSize[0] - 1) {
-              const nextNode = (0, _core.getNode)(editor, [...tableParentPath, tableIndex + 1]);
-              if (!nextNode) return;
-              (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex + 1]);
-              return;
-            }
-            (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
-            const {
-              anchor: newAnchor
-            } = editor.selection;
-            _slate.Transforms.select(editor, {
-              focus: newAnchor,
-              anchor: newAnchor
-            });
-          }
-        }
-      }, 10);
-      return;
-    }
-    event.preventDefault();
-    if (rowIndex === tableSize[0] - 1) {
-      const nextNode = (0, _core.getNode)([...tableParentPath, tableIndex + 1]);
-      if (!nextNode) return;
-      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex + 1]);
-      return;
-    }
-    (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
-    const {
-      anchor: newAnchor
-    } = editor.selection;
-    _slate.Transforms.select(editor, {
-      focus: newAnchor,
-      anchor: newAnchor
-    });
-  }
-  if (keyboardName === _constants2.KEYBOARD.LEFT) {
-    if (!isCursorAtCellStart(focus.offset)) return;
-    event.preventDefault();
-    if (rowIndex === 0 && cellIndex === 0) {
-      if (tableIndex !== 0) {
-        (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex - 1]);
-      }
-      return;
-    }
-    if (cellIndex === 0) {
-      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex - 1, tableSize[1] - 1]);
-    } else {
-      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex - 1]);
-    }
-    const {
-      focus: newFocus
-    } = editor.selection;
-    _slate.Transforms.select(editor, {
-      focus: newFocus,
-      anchor: newFocus
-    });
-  }
-};
-exports.focusCell = focusCell;
-const isLastTableCell = (editor, cellNode) => {
-  if (cellNode[0].type !== _constants2.ELEMENT_TYPE.TABLE_CELL) return false;
-  const {
-    tableSize
-  } = getSelectedInfo(editor);
-  const lastRowIndex = tableSize[0] - 1;
-  const lastColumnIndex = tableSize[1] - 1;
-  const cellNodePath = cellNode[1];
-  const cellNodePathDeep = cellNodePath.length;
-  return cellNodePath[cellNodePathDeep - 1] === lastColumnIndex && cellNodePath[cellNodePathDeep - 2] === lastRowIndex;
-};
-exports.isLastTableCell = isLastTableCell;
-const getValidColor = color => {
-  if (!color) return '';
-  const validColor = color.length === 4 ? '#' + color.slice(1, 4).repeat(2) : color;
-  return validColor.toUpperCase();
-};
-const colorBlend = (c1, c2, ratio) => {
-  const color1 = getValidColor(c1);
-  const 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;
-  const validRatio = Math.max(Math.min(Number(ratio), 1), 0);
-  let r1 = parseInt(color1.substring(1, 3), 16);
-  let g1 = parseInt(color1.substring(3, 5), 16);
-  let b1 = parseInt(color1.substring(5, 7), 16);
-  let r2 = parseInt(color2.substring(1, 3), 16);
-  let g2 = parseInt(color2.substring(3, 5), 16);
-  let b2 = parseInt(color2.substring(5, 7), 16);
-  let r = Math.round(r1 * (1 - validRatio) + r2 * validRatio);
-  let g = Math.round(g1 * (1 - validRatio) + g2 * validRatio);
-  let 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;
-};
-exports.colorBlend = colorBlend;
-const getRowHeight = (element, rowIndex) => {
-  const {
-    style = {}
-  } = element;
-  const rowHeight = style[_constants3.TABLE_ROW_STYLE.MIN_HEIGHT] || _constants3.TABLE_ROW_MIN_HEIGHT;
-  return rowIndex === 0 ? rowHeight + 1 : rowHeight;
-};
-exports.getRowHeight = getRowHeight;
-const getRowDomHeight = (editor, row) => {
-  let height = 0;
-  for (const cell of row.children) {
-    const {
-      is_combined,
-      rowspan = 1
-    } = cell;
-    if (is_combined || rowspan > 1) continue;
-    let 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
-  if (!height) {
-    height = row.style[_constants3.TABLE_ROW_STYLE.MIN_HEIGHT] || _constants3.TABLE_ROW_MIN_HEIGHT;
-  }
-  return height;
-};
-exports.getRowDomHeight = getRowDomHeight;
-const normalizeTableCell = (editor, cell) => {
-  if (!cell) return generateTableCell(editor);
-  let newCell = {
-    children: [{
-      text: '',
-      id: _slugid.default.nice()
-    }],
-    ...cell
-  };
-
-  // normalize cell children
-  let newCellChildren = [];
-  newCell.children.forEach(cellChild => {
-    const cellChildType = cellChild.type;
-    if (cellChildType === _constants2.ELEMENT_TYPE.PARAGRAPH) {
-      newCellChildren.push(...cellChild.children);
-    } else {
-      newCellChildren.push(cellChild);
-    }
-  });
-  newCell.children = newCellChildren.map(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) {
-    const cellStyle = {
-      ...newCell.data
-    };
-    delete newCell['data'];
-    Object.keys(cellStyle).forEach(cellStyleKey => {
-      if (cellStyleKey === 'align') {
-        cellStyle['text_align'] = cellStyle['align'];
-        delete cellStyle['align'];
-      }
-    });
-    newCell.style = cellStyle;
-  }
-  return newCell;
-};
-const normalizeTableELement = (editor, element) => {
-  if (element.type !== _constants2.ELEMENT_TYPE.TABLE) {
-    const size = [element.children.length, element.children[0].children.length];
-    return generateEmptyTable(editor, {
-      size
-    });
-  }
-  let newElement = {
-    ...element
-  };
-  for (let i = 0; i < element.children.length; i++) {
-    const row = newElement.children[i];
-    for (let j = 0; j < row.children.length; j++) {
-      row.children[j] = normalizeTableCell(editor, row.children[j]);
-    }
-    newElement.children[i] = row;
-  }
-  return newElement;
-};
-exports.normalizeTableELement = normalizeTableELement;
-const insertTableByTemplate = (editor, alternateColor) => {
-  const size = [4, 4];
-  const tableNode = generateEmptyTable(editor, {
-    size,
-    alternate_highlight_color: alternateColor,
-    alternate_highlight: true
-  });
-  const path = _slate.Editor.path(editor, editor.selection);
-  const insertPosition = getInsertPosition(editor);
-  handleInsertTable(editor, insertPosition, path, tableNode);
-};
-
-/**
- * @param {Editor} editor
- * @param {InsertPosition} insertPosition
- * @param {Path} path
- * @param {Node} tableNode
- * Insert table by insertPosition
- */
-exports.insertTableByTemplate = insertTableByTemplate;
-const handleInsertTable = (editor, insertPosition, path, tableNode) => {
-  const {
-    selection
-  } = editor;
-  if (insertPosition === _constants2.INSERT_POSITION.BEFORE) {
-    const insertPath = [path[0]];
-    _slate.Transforms.insertNodes(editor, tableNode, {
-      at: insertPath
-    });
-  } else if (insertPosition === _constants2.INSERT_POSITION.AFTER) {
-    const 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);
-};
-exports.handleInsertTable = handleInsertTable;
-const getInsertPosition = editor => {
-  const {
-    selection
-  } = editor;
-  if (!selection) return _constants2.INSERT_POSITION.CURRENT;
-  if (!_slate.Range.isCollapsed(selection)) return _constants2.INSERT_POSITION.CURRENT;
-  const aboveNodeEntry = (0, _core.getAboveBlockNode)(editor);
-  if (!aboveNodeEntry) return _constants2.INSERT_POSITION.CURRENT;
-  const isAtStart = _slate.Editor.isStart(editor, selection.anchor, aboveNodeEntry[1]);
-  if (isAtStart) return _constants2.INSERT_POSITION.BEFORE;
-  const isAtEnd = _slate.Editor.isEnd(editor, selection.anchor, aboveNodeEntry[1]);
-  if (isAtEnd) return _constants2.INSERT_POSITION.AFTER;
-  return _constants2.INSERT_POSITION.CURRENT;
-};
-exports.getInsertPosition = getInsertPosition;
-const generateInheritStyle = (allowedInheritStyleList, style, cell) => {
-  const inheritStyle = {
-    ...cell['inherit_style']
-  } || {};
-  for (const key in style) {
-    if (Object.hasOwnProperty.call(style, key) && allowedInheritStyleList.includes(key)) {
-      inheritStyle[key] = style[key];
-    }
-  }
-  return inheritStyle;
-};
-exports.generateInheritStyle = generateInheritStyle;
-const getCellInheritStyles = (editor, tablePath, rowIndex, colIndex) => {
-  var _table$children$rowIn, _tableCell$inherit_st;
-  const [tableNodeEntry] = _slate.Editor.nodes(editor, {
-    match: n => n.type === _constants2.ELEMENT_TYPE.TABLE,
-    at: tablePath
-  });
-  if (!tableNodeEntry) return {};
-  const table = tableNodeEntry[0];
-  const 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 : {};
-};
-exports.getCellInheritStyles = getCellInheritStyles;
-const getCellHighlightClassName = (primaryColorClassName, rowIndex) => {
-  let className = '';
-  if (rowIndex === 0) {
-    className = primaryColorClassName;
-  } else if (rowIndex % 2 === 0) {
-    className = _constants3.TABLE_ALTERNATE_HIGHLIGHT_CLASS_MAP[primaryColorClassName];
-  }
-  return className;
-};
-exports.getCellHighlightClassName = getCellHighlightClassName;
-const focusClosestCellWhenJustifyCellSize = (editor, adjustingCell) => {
-  const cellPath = _slateReact.ReactEditor.findPath(editor, adjustingCell);
-  (0, _core.focusEditor)(editor, _slate.Editor.end(editor, cellPath));
-};
-
-// Search main cell of combined cell
-exports.focusClosestCellWhenJustifyCellSize = focusClosestCellWhenJustifyCellSize;
-const searchCombinedMainCell = (table, startRowIndex, startColIndex) => {
-  for (let rowIndex = startRowIndex; rowIndex >= 0; rowIndex--) {
-    const row = table.children[rowIndex];
-    for (let cellIndex = startColIndex; cellIndex >= 0; cellIndex--) {
-      const currentCell = row.children[cellIndex];
-      const {
-        colspan = 0,
-        rowspan = 0
-      } = currentCell;
-      if (colspan <= 1 && rowspan <= 1) continue;
-      const isInColRange = cellIndex + colspan >= startColIndex;
-      const isInRowRange = rowIndex + rowspan >= startRowIndex;
-      if (isInColRange && isInRowRange) {
-        return {
-          currentCell,
-          rowIndex,
-          cellIndex
-        };
-      } else break;
-    }
-  }
-};
-const getResizeMaskCellInfo = (editor, table, rowIndex, cellIndex) => {
-  // The cell shown cursor as resize (mouse is on this cell)
-  const focusCellIndex = cellIndex;
-  let focusCell = table.children[rowIndex].children[cellIndex];
-  // The cell dominating resize handlers (the true cell to be resized)
-  let cell = table.children[rowIndex].children[cellIndex];
-  // Resolve combined cell
-  if (cell.is_combined) {
-    const targetCellInfo = searchCombinedMainCell(table, rowIndex, cellIndex);
-    cellIndex = targetCellInfo.cellIndex;
-    rowIndex = targetCellInfo.rowIndex;
-    cell = targetCellInfo.currentCell;
-  }
-  const columns = table.columns;
-  const focussedCell = _slateReact.ReactEditor.toDOMNode(editor, cell);
-  const {
-    colspan,
-    rowspan
-  } = focusCell;
-  let width = columns[cellIndex].width;
-  let height = focussedCell.getBoundingClientRect().height;
-  // Calculate cell width and height
-  if (colspan > 1) {
-    let index = cellIndex + 1;
-    while (index < cellIndex + colspan) {
-      width += columns[index].width;
-      index++;
-    }
-  }
-  if (rowspan > 1) {
-    let index = rowIndex + 1;
-    while (index < rowIndex + rowspan) {
-      const currentCell = table.children[index].children[cellIndex];
-      const currentHeight = _slateReact.ReactEditor.toDOMNode(editor, currentCell).getBoundingClientRect().height;
-      height += currentHeight;
-      index++;
-    }
-  }
-  return {
-    width,
-    height,
-    top: focussedCell.offsetTop,
-    left: focussedCell.offsetLeft,
-    rowIndex,
-    cellIndex,
-    cell,
-    focusCellIndex
-  };
-};
-
-// Table alternate highlight
-exports.getResizeMaskCellInfo = getResizeMaskCellInfo;
-const getHighlightClass = (editor, cellPath) => {
-  var _tableEntry$;
-  const [tableEntry] = _slate.Editor.nodes(editor, {
-    at: cellPath,
-    match: n => n.type === _constants2.ELEMENT_TYPE.TABLE
-  });
-  const {
-    alternate_highlight,
-    alternate_highlight_color
-  } = ((_tableEntry$ = tableEntry[0]) === null || _tableEntry$ === void 0 ? void 0 : _tableEntry$.ui) || {};
-  if (!alternate_highlight) return '';
-  const rowIndex = cellPath[cellPath.length - 2];
-  const className = getCellHighlightClassName(alternate_highlight_color, rowIndex);
-  return className;
-};
-
-// Correct the selected range when combined cell are selected
-exports.getHighlightClass = getHighlightClass;
-const adjustCombinedCellRange = (table, range) => {
-  const {
-    minRowIndex,
-    maxRowIndex,
-    minColIndex,
-    maxColIndex
-  } = range;
-  const firstCell = table.children[minRowIndex].children[minColIndex];
-  const {
-    colspan = 0,
-    rowspan = 0
-  } = firstCell;
-  if (rowspan > 1 || colspan > 1) {
-    const isRowCombined = minRowIndex + rowspan === maxRowIndex + 1;
-    const 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}
- */
-exports.adjustCombinedCellRange = adjustCombinedCellRange;
-const isPreventResetTableSelectedRange = event => {
-  const {
-    target
-  } = event;
-  const draggable = target.getAttribute('draggable');
-  const isColumnHeader = target.classList.contains('sdoc-table-column-header');
-  const isRowHeader = target.classList.contains('sdoc-table-row-header');
-  const isHeader = isColumnHeader || isRowHeader;
-  const isPreventReset = isHeader || draggable === 'true';
-  return isPreventReset;
-};
-
-/**
- * Check drag type, column or row
- */
-exports.isPreventResetTableSelectedRange = isPreventResetTableSelectedRange;
-const getTableDragType = (table, selectedRange) => {
-  const rowCount = table.children.length;
-  const {
-    minRowIndex,
-    maxRowIndex
-  } = selectedRange;
-  const isSelectColumn = minRowIndex === 0 && maxRowIndex === rowCount - 1;
-  return isSelectColumn ? _constants3.DRAG_HANDLER_COLUMN : _constants3.DRAG_HANDLER_ROW;
-};
-exports.getTableDragType = getTableDragType;
-const updateTableColumns = (editor, table, targetColIndex, startColIndex, endColIndex) => {
-  const columns = [...table.columns];
-  const deleteCount = endColIndex - startColIndex + 1;
-  const newColumns = columns.splice(startColIndex, deleteCount);
-  columns.splice(targetColIndex, 0, ...newColumns);
-  updateColumnWidth(editor, table, columns);
-};
-const moveColumns = (editor, targetColIndex, startColIndex, endColIndex) => {
-  // Get selected table information
-  const {
-    table,
-    tablePath
-  } = getSelectedInfo(editor);
-  // Check if moving columns forward or backward
-  const isMoveToFroward = targetColIndex < startColIndex;
-
-  // Iterate over each row in the table
-  table.children.forEach((row, rowIndex) => {
-    if (isMoveToFroward) {
-      // Calculate target and source paths for moving columns forward
-      const targetPath = [...tablePath, rowIndex, targetColIndex];
-      const sourcePath = [...tablePath, rowIndex, endColIndex];
-
-      // Move columns forward by inserting nodes
-      for (let insertIndex = endColIndex; insertIndex >= startColIndex; insertIndex--) {
-        const 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
-      const targetPath = [...tablePath, rowIndex, targetColIndex - 1];
-      const sourcePath = [...tablePath, rowIndex, startColIndex];
-
-      // Move columns backward by inserting nodes
-      for (let insertIndex = startColIndex; insertIndex <= endColIndex; insertIndex++) {
-        const 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
-  const 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.
- */
-exports.moveColumns = moveColumns;
-const getTableSelectedRangeAfterDrag = (table, moveType, targetIndex, startIndex, endIndex) => {
-  // Calculate the total number of columns and rows in the table
-  const colCount = table.columns.length;
-  const rowCount = table.children.length;
-
-  // Initialize the new selected range with full table range
-  const newSelectRange = {
-    minRowIndex: 0,
-    maxRowIndex: rowCount - 1,
-    minColIndex: 0,
-    maxColIndex: colCount - 1
-  };
-
-  // Determine if the drag movement is forward or backward
-  const 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 {
-      const moveCount = endIndex - startIndex + 1;
-      newSelectRange.minColIndex = targetIndex - moveCount;
-      newSelectRange.maxColIndex = targetIndex - 1;
-    }
-  } else {
-    if (isMoveToFroward) {
-      newSelectRange.minRowIndex = targetIndex;
-      newSelectRange.maxRowIndex = targetIndex + endIndex - startIndex;
-    } else {
-      const moveCount = endIndex - startIndex + 1;
-      newSelectRange.minRowIndex = targetIndex - moveCount;
-      newSelectRange.maxRowIndex = targetIndex - 1;
-    }
-  }
-  return newSelectRange;
-};
-exports.getTableSelectedRangeAfterDrag = getTableSelectedRangeAfterDrag;
-const moveRows = (editor, targetRowIndex, startRowIndex, endRowIndex) => {
-  const {
-    table,
-    tablePath
-  } = getSelectedInfo(editor);
-  const isMoveToFroward = targetRowIndex < startRowIndex;
-  const targetPath = [...tablePath, isMoveToFroward ? targetRowIndex : targetRowIndex - 1];
-  const sourcePath = [...tablePath, isMoveToFroward ? endRowIndex : startRowIndex];
-  if (isMoveToFroward) {
-    for (let insertIndex = endRowIndex; insertIndex >= startRowIndex; insertIndex--) {
-      const insertNode = table.children[insertIndex];
-      _slate.Transforms.removeNodes(editor, {
-        at: sourcePath
-      });
-      _slate.Transforms.insertNodes(editor, insertNode, {
-        at: targetPath
-      });
-    }
-  } else {
-    for (let insertIndex = startRowIndex; insertIndex <= endRowIndex; insertIndex++) {
-      const insertNode = table.children[insertIndex];
-      _slate.Transforms.removeNodes(editor, {
-        at: sourcePath
-      });
-      _slate.Transforms.insertNodes(editor, insertNode, {
-        at: targetPath
-      });
-    }
-  }
-  const newSelectRange = {
-    minRowIndex: targetRowIndex,
-    maxRowIndex: targetRowIndex + endRowIndex - startRowIndex,
-    minColIndex: 0,
-    maxColIndex: table.children.length - 1
-  };
-  setTableSelectedRange(editor, newSelectRange);
-};
-exports.moveRows = moveRows;
-const generateDragMoveElement = tipText => {
-  const canvasId = 'sdoc-drag-image';
-  let canvas = document.getElementById(canvasId);
-  if (!canvas) {
-    let dpr = window.devicePixelRatio;
-    canvas = document.createElement('canvas');
-    canvas.width = 115;
-    canvas.height = 30;
-    canvas.id = canvasId;
-    document.body.appendChild(canvas);
-    let {
-      width: cssWidth,
-      height: cssHeight
-    } = canvas.getBoundingClientRect();
-    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';
-  const 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;
-};
-exports.generateDragMoveElement = generateDragMoveElement;
-const isHideDragHandlerLine = (editor, displayType, table, cellPath, isDragOverCellHalf) => {
-  const pathLength = cellPath.length;
-  let rowIndex = cellPath[pathLength - 2];
-  let cellIndex = cellPath[pathLength - 1];
-
-  // Check is above cell selected
-  let currentCellDom = _slateReact.ReactEditor.toDOMNode(editor, table.children[rowIndex].children[cellIndex]);
-  let 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;
-    }
-  }
-  const isEndOfRowOrColumn = displayType === _constants3.DRAG_HANDLER_COLUMN && cellIndex === table.columns.length || displayType === _constants3.DRAG_HANDLER_ROW && rowIndex === table.children.length;
-  if (isEndOfRowOrColumn) return false;
-  let preCellDom = null;
-  if (displayType === _constants3.DRAG_HANDLER_COLUMN && cellIndex > 0) {
-    const 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
-    const beforeLineColumnHasCombined = table.children.find(item => {
-      const cell = item.children[cellIndex - 1];
-      return cell.children.length > 1;
-    });
-    const afterLineColumnHasCombined = table.children.find(item => {
-      const 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) {
-    const 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
-    const beforeLineRow = table.children[rowIndex - 1];
-    const afterLineRow = table.children[rowIndex];
-    const beforeLineRowHasCombined = beforeLineRow.children.find(item => item.children.length > 1);
-    const afterLineRowHasCombined = afterLineRow.children.find(item => (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
-  const isPrevCellSelected = preCellDom && preCellDom.classList.contains(_constants3.CELL_SELECTED);
-  if (isPrevCellSelected) return true;
-  let isCombined = false;
-  // Check if the combined cell
-  if (displayType === _constants3.DRAG_HANDLER_COLUMN) {
-    isCombined = table.children.some(row => row.children[cellIndex - isDragOverCellHalf].is_combined);
-  } else {
-    isCombined = table.children[rowIndex - isDragOverCellHalf].children.some(cell => cell.is_combined);
-  }
-  if (isCombined) return true;
-
-  // Check is the last column
-  if (displayType === _constants3.DRAG_HANDLER_COLUMN) {
-    const isLastColumn = cellIndex === table.columns.length - 1;
-    if (isLastColumn) return false;
-  }
-};
-exports.isHideDragHandlerLine = isHideDragHandlerLine;
-const getTableRowSelectedRange = (table, rowIndex) => {
-  const row = table.children[rowIndex];
-  const columnCount = row.children.length;
-  let minRowIndex = rowIndex;
-  let maxRowIndex = rowIndex;
-  let minColIndex = 0;
-  let maxColIndex = columnCount - 1;
-  const findRowRange = findRowIndex => {
-    let checkRow = table.children[findRowIndex];
-    const combinedIndexes = checkRow.children.reduce((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(combinedIndex => {
-      const {
-        rowIndex: mainCellRowIndex,
-        currentCell
-      } = searchCombinedMainCell(table, findRowIndex, combinedIndex);
-      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,
-    maxRowIndex,
-    minColIndex,
-    maxColIndex
-  };
-};
-exports.getTableRowSelectedRange = getTableRowSelectedRange;
-const getTableColumnSelectedRange = (table, columnIndex) => {
-  let minRowIndex = 0;
-  let maxRowIndex = table.children.length - 1;
-  let minColIndex = columnIndex;
-  let maxColIndex = columnIndex;
-  const findColRange = findColIndex => {
-    let combinedIndexes = [];
-    table.children.forEach((row, rowIndex) => {
-      const 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(combinedIndex => {
-      const {
-        cellIndex: mainCellColIndex,
-        currentCell
-      } = searchCombinedMainCell(table, combinedIndex, findColIndex);
-      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,
-    maxRowIndex,
-    minColIndex,
-    maxColIndex
-  };
-};
-exports.getTableColumnSelectedRange = getTableColumnSelectedRange;
-const isTableWidthFitScreen = editor => {
-  const {
-    table
-  } = getSelectedInfo(editor);
-  const tableNode = _slateReact.ReactEditor.toDOMNode(editor, table);
-  if (!tableNode) return;
-  const tableDom = tableNode.querySelector('.sdoc-table-scroll-wrapper');
-  const {
-    width: tableWidth
-  } = tableDom.getBoundingClientRect();
-  const sdocWidth = editor.width;
-  if (tableWidth >= sdocWidth) return true;
-  return false;
-};
-exports.isTableWidthFitScreen = isTableWidthFitScreen;
-const fitTableColumnToScreen = editor => {
-  const {
-    table,
-    tablePath
-  } = getSelectedInfo(editor);
-  const colCount = table.columns.length;
-  const columnWidth = Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colCount));
-  const columns = table.columns.map(column => ({
-    ...column,
-    width: columnWidth
-  }));
-  _slate.Transforms.setNodes(editor, {
-    columns
-  }, {
-    at: tablePath
-  });
-};
-exports.fitTableColumnToScreen = fitTableColumnToScreen;
-const deleteTableSelectCells = (editor, deleteRange) => {
-  // eslint-disable-next-line no-unused-vars
-  const {
-    start,
-    end,
-    rowsLength,
-    columnLength
-  } = deleteRange;
-  // table path [tableIdx, rowIdx, colIdx, ...];
-  if (start.length <= 3) return;
-  const tableIndex = start[0];
-  const minRowIndex = start[1];
-  let deletePaths = [];
-  if (start[1] === end[1]) {
-    const minColIndex = start[2];
-    const maxColIndex = end[2];
-    for (let colIndex = minColIndex; colIndex <= maxColIndex; colIndex++) {
-      deletePaths.push([tableIndex, minRowIndex, colIndex]);
-    }
-  }
-  if (start[1] !== end[1]) {
-    const isAfter = end[1] - start[1] === 1;
-    // push first row
-    const minColIndex = start[2];
-    for (let colIndex = minColIndex; colIndex <= columnLength - 1; colIndex++) {
-      deletePaths.push([tableIndex, minRowIndex, colIndex]);
-    }
-
-    // push center row
-    if (!isAfter) {
-      for (let i = start[1] + 1; i <= end[1] - 1; i++) {
-        for (let j = 0; j <= columnLength - 1; j++) {
-          deletePaths.push([tableIndex, i, j]);
-        }
-      }
-    }
-
-    // push last row
-    const maxColIndex = end[2];
-    const maxRowIndex = end[1];
-    for (let colIndex = 0; colIndex <= maxColIndex; colIndex++) {
-      deletePaths.push([tableIndex, maxRowIndex, colIndex]);
-    }
-  }
-  for (let i = 0; i < deletePaths.length; i++) {
-    const path = deletePaths[i];
-    const node = (0, _core.getNode)(editor, path);
-    const firstNode = node.children[0];
-    (0, _core.replaceNodeChildren)(editor, {
-      at: path,
-      nodes: {
-        ...firstNode,
-        text: ''
-      }
-    });
-  }
-};
-exports.deleteTableSelectCells = deleteTableSelectCells;