@seafile/sdoc-editor 1.0.54 → 1.0.55

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

@@ -1,41 +1,48 @@
-import slugid from 'slugid';
-import { Editor, Range, Transforms, Point, Node } from '@seafile/slate';
-import { ReactEditor } from '@seafile/slate-react';
-import deepCopy from 'deep-copy';
-import { getNodeType, getParentNode, getSelectedNodeByType, isTextNode, getSelectedElems, focusEditor, getNode, findPath, replaceNodeChildren, replaceNode, getSelectedNodeEntryByType, getAboveBlockNode } from '../../core';
-import { ELEMENT_TYPE, KEYBOARD, CLIPBOARD_FORMAT_KEY, INSERT_POSITION } from '../../constants';
-import { TABLE_MAX_ROWS, TABLE_MAX_COLUMNS, EMPTY_SELECTED_RANGE, TABLE_ROW_MIN_HEIGHT, TABLE_CELL_MIN_WIDTH, TABLE_ELEMENT, TABLE_ELEMENT_POSITION, TABLE_ROW_STYLE, INHERIT_CELL_STYLE_WHEN_SELECT_MULTIPLE, INHERIT_CELL_STYLE_WHEN_SELECT_SINGLE, TABLE_ALTERNATE_HIGHLIGHT_CLASS_MAP, CELL_SELECTED, DRAG_HANDLER_COLUMN, DRAG_HANDLER_ROW } from './constants';
-import EventBus from '../../../utils/event-bus';
-import { INTERNAL_EVENT, PAGE_EDIT_AREA_WIDTH } from '../../../constants';
-import ObjectUtils from '../../../utils/object-utils';
-import { replacePastedDataId } from '../../../node-id/helpers';
-export const isTableMenuDisabled = (editor, readonly) => {
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateTableRowHeight = exports.updateColumnWidth = 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.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.deleteTableRangeData = exports.deleteHandler = exports.combineCells = exports.colorBlend = exports.adjustCombinedCellRange = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _deepCopy = _interopRequireDefault(require("deep-copy"));
+var _core = require("../../core");
+var _constants = require("../../constants");
+var _constants2 = require("./constants");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _constants3 = require("../../../constants");
+var _objectUtils = _interopRequireDefault(require("../../../utils/object-utils"));
+var _helpers = require("../../../node-id/helpers");
+const isTableMenuDisabled = (editor, readonly) => {
   if (readonly) return true;
   const {
     selection
   } = editor;
   if (selection === null) return true;
-  if (!Range.isCollapsed(selection)) return true;
-  const [match] = Editor.nodes(editor, {
+  if (!_slate.Range.isCollapsed(selection)) return true;
+  const [match] = _slate.Editor.nodes(editor, {
     match: n => {
-      let type = getNodeType(n);
-      if (!type && isTextNode(n) && n.id) {
-        const parentNode = getParentNode(editor.children, n.id);
-        type = getNodeType(parentNode);
+      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 === ELEMENT_TYPE.TITLE) return true;
-      if (type === ELEMENT_TYPE.SUBTITLE) return true;
-      if (type === ELEMENT_TYPE.CODE_BLOCK) return true;
-      if (type === ELEMENT_TYPE.ORDERED_LIST) return true;
-      if (type === ELEMENT_TYPE.UNORDERED_LIST) return true;
-      if (type === ELEMENT_TYPE.BLOCKQUOTE) return true;
-      if (type === ELEMENT_TYPE.LIST_ITEM) return true;
-      if (type === ELEMENT_TYPE.TABLE) return true;
-      if (type === ELEMENT_TYPE.TABLE_CELL) return true;
-      if (type === ELEMENT_TYPE.TABLE_ROW) return true;
-      if (type === ELEMENT_TYPE.CALL_OUT) return true;
-      if (Editor.isVoid(editor, n)) return true;
+      if (type === _constants.ELEMENT_TYPE.TITLE) return true;
+      if (type === _constants.ELEMENT_TYPE.SUBTITLE) return true;
+      if (type === _constants.ELEMENT_TYPE.CODE_BLOCK) return true;
+      if (type === _constants.ELEMENT_TYPE.ORDERED_LIST) return true;
+      if (type === _constants.ELEMENT_TYPE.UNORDERED_LIST) return true;
+      if (type === _constants.ELEMENT_TYPE.BLOCKQUOTE) return true;
+      if (type === _constants.ELEMENT_TYPE.LIST_ITEM) return true;
+      if (type === _constants.ELEMENT_TYPE.TABLE) return true;
+      if (type === _constants.ELEMENT_TYPE.TABLE_CELL) return true;
+      if (type === _constants.ELEMENT_TYPE.TABLE_ROW) return true;
+      if (type === _constants.ELEMENT_TYPE.CALL_OUT) return true;
+      if (_slate.Editor.isVoid(editor, n)) return true;
       return false;
     },
     universal: true
@@ -43,48 +50,51 @@ export const isTableMenuDisabled = (editor, readonly) => {
   if (match) return true;
   return false;
 };
-export const isCombineCellsDisabled = (editor, readonly) => {
+exports.isTableMenuDisabled = isTableMenuDisabled;
+const isCombineCellsDisabled = (editor, readonly) => {
   if (readonly) return true;
   const {
     selection,
     tableSelectedRange
   } = editor;
   if (!selection) return true;
-  if (!ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
+  if (!_objectUtils.default.isSameObject(tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
     return false;
   }
   return true;
 };
-export const generateTableCell = (editor, rowIndex, cellIndex) => {
+exports.isCombineCellsDisabled = isCombineCellsDisabled;
+const generateTableCell = (editor, rowIndex, cellIndex) => {
   let style = {};
-  const tableNodeEntry = getSelectedNodeEntryByType(editor, ELEMENT_TYPE.TABLE);
+  const tableNodeEntry = (0, _core.getSelectedNodeEntryByType)(editor, _constants.ELEMENT_TYPE.TABLE);
   if (tableNodeEntry && rowIndex !== undefined && cellIndex !== undefined) {
     const [, tablePath] = tableNodeEntry;
     style = getCellInheritStyles(editor, tablePath, rowIndex, cellIndex);
   }
   return {
-    id: slugid.nice(),
-    type: ELEMENT_TYPE.TABLE_CELL,
+    id: _slugid.default.nice(),
+    type: _constants.ELEMENT_TYPE.TABLE_CELL,
     children: [{
       text: '',
-      id: slugid.nice()
+      id: _slugid.default.nice()
     }],
     style,
     inherit_style: style
   };
 };
-export const generateTableRow = (editor, colsCount, rowIndex) => {
+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.nice(),
-    type: ELEMENT_TYPE.TABLE_ROW,
+    id: _slugid.default.nice(),
+    type: _constants.ELEMENT_TYPE.TABLE_ROW,
     children: children,
     style: {
-      [TABLE_ROW_STYLE.MIN_HEIGHT]: TABLE_ROW_MIN_HEIGHT
+      [_constants2.TABLE_ROW_STYLE.MIN_HEIGHT]: _constants2.TABLE_ROW_MIN_HEIGHT
     }
   };
 };
@@ -96,7 +106,8 @@ export const generateTableRow = (editor, colsCount, rowIndex) => {
  * @param {Boolean} tableProps.alternate_highlight - is alternate highlight
  * @param {string} tableProps.alternate_highlight_color - table alternate highlight color
  */
-export const generateEmptyTable = (editor, tableProps) => {
+exports.generateTableRow = generateTableRow;
+const generateEmptyTable = (editor, tableProps) => {
   const {
     size = [0, 0],
     alternate_highlight = false,
@@ -109,7 +120,7 @@ export const generateEmptyTable = (editor, tableProps) => {
     const tableRow = generateTableRow(editor, colsCount, i);
     children.push(tableRow);
   }
-  const columnWidth = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colsCount));
+  const columnWidth = Math.max(_constants2.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colsCount));
   let columns = [];
   for (let i = 0; i < colsCount; i++) {
     columns.push({
@@ -117,8 +128,8 @@ export const generateEmptyTable = (editor, tableProps) => {
     });
   }
   return {
-    id: slugid.nice(),
-    type: ELEMENT_TYPE.TABLE,
+    id: _slugid.default.nice(),
+    type: _constants.ELEMENT_TYPE.TABLE,
     children: children,
     columns,
     ui: {
@@ -126,73 +137,77 @@ export const generateEmptyTable = (editor, tableProps) => {
       alternate_highlight_color
     },
     style: {
-      gridTemplateColumns: "repeat(".concat(colsCount, ", ").concat(columnWidth, "px)"),
-      gridAutoRows: "minmax(".concat(TABLE_ROW_MIN_HEIGHT, "px, auto)")
+      gridTemplateColumns: `repeat(${colsCount}, ${columnWidth}px)`,
+      gridAutoRows: `minmax(${_constants2.TABLE_ROW_MIN_HEIGHT}px, auto)`
     }
   };
 };
-export const insertTable = function (editor, size, selection) {
-  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : INSERT_POSITION.CURRENT;
+exports.generateEmptyTable = generateEmptyTable;
+const insertTable = function (editor, size, selection) {
+  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants.INSERT_POSITION.CURRENT;
   if (!size) return;
-  if (position !== INSERT_POSITION.AFTER) {
+  if (position !== _constants.INSERT_POSITION.AFTER) {
     if (isTableMenuDisabled(editor)) return;
   }
   const tableNode = generateEmptyTable(editor, {
     size
   });
   const validSelection = selection || editor.selection;
-  const path = Editor.path(editor, validSelection);
+  const path = _slate.Editor.path(editor, validSelection);
   handleInsertTable(editor, position, path, tableNode);
 };
 
 // tableSize [tableHeight, tableWidth]
-export const getSelectedInfo = editor => {
-  const currentTable = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
-  const currentRow = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE_ROW);
-  const currentCell = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE_CELL);
-  const currentCellPath = findPath(editor, currentCell);
+exports.insertTable = insertTable;
+const getSelectedInfo = editor => {
+  const currentTable = (0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE);
+  const currentRow = (0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE_ROW);
+  const currentCell = (0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE_CELL);
+  const currentCellPath = (0, _core.findPath)(editor, currentCell);
   return {
     table: currentTable,
-    tablePath: findPath(editor, currentTable),
+    tablePath: (0, _core.findPath)(editor, currentTable),
     tableSize: [currentTable.children.length, currentRow.children.length],
     row: currentRow,
-    rowPath: findPath(editor, currentRow),
+    rowPath: (0, _core.findPath)(editor, currentRow),
     rowIndex: currentCellPath[currentCellPath.length - 2],
     cell: currentCell,
-    cellPath: findPath(editor, currentCell),
+    cellPath: (0, _core.findPath)(editor, currentCell),
     cellIndex: currentCellPath[currentCellPath.length - 1]
   };
 };
-export const isInTable = editor => {
-  const selectedNodes = getSelectedElems(editor);
-  if (!selectedNodes.some(node => node.type === ELEMENT_TYPE.TABLE)) return false;
+exports.getSelectedInfo = getSelectedInfo;
+const isInTable = editor => {
+  const selectedNodes = (0, _core.getSelectedElems)(editor);
+  if (!selectedNodes.some(node => node.type === _constants.ELEMENT_TYPE.TABLE)) return false;
   const firstSelectedNode = selectedNodes[0];
-  return firstSelectedNode.type === ELEMENT_TYPE.TABLE;
+  return firstSelectedNode.type === _constants.ELEMENT_TYPE.TABLE;
 };
-export const isAllInTable = editor => {
-  const selectedNodes = getSelectedElems(editor);
-  if (!selectedNodes.some(node => node.type === ELEMENT_TYPE.TABLE)) return false;
+exports.isInTable = isInTable;
+const isAllInTable = editor => {
+  const selectedNodes = (0, _core.getSelectedElems)(editor);
+  if (!selectedNodes.some(node => node.type === _constants.ELEMENT_TYPE.TABLE)) return false;
   const firstSelectedNode = selectedNodes[0];
-  if (firstSelectedNode.type !== ELEMENT_TYPE.TABLE) return false;
-  return selectedNodes.slice(1).every(node => [ELEMENT_TYPE.TABLE_ROW, ELEMENT_TYPE.TABLE_CELL].includes(node.type)); // same table element
+  if (firstSelectedNode.type !== _constants.ELEMENT_TYPE.TABLE) return false;
+  return selectedNodes.slice(1).every(node => [_constants.ELEMENT_TYPE.TABLE_ROW, _constants.ELEMENT_TYPE.TABLE_CELL].includes(node.type)); // same table element
 };
-
-export const setCellStyle = (editor, style) => {
+exports.isAllInTable = isAllInTable;
+const setCellStyle = (editor, style) => {
   // Select single cell
-  if (ObjectUtils.isSameObject(editor.tableSelectedRange, EMPTY_SELECTED_RANGE)) {
-    const selectedNodes = getSelectedElems(editor);
+  if (_objectUtils.default.isSameObject(editor.tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
+    const selectedNodes = (0, _core.getSelectedElems)(editor);
     let firstTableCellNodePath;
     selectedNodes.forEach(node => {
-      if (node.type === ELEMENT_TYPE.TABLE_CELL) {
-        const path = findPath(editor, node);
+      if (node.type === _constants.ELEMENT_TYPE.TABLE_CELL) {
+        const path = (0, _core.findPath)(editor, node);
         if (path) {
           firstTableCellNodePath = firstTableCellNodePath ? firstTableCellNodePath : path;
-          Transforms.setNodes(editor, {
+          _slate.Transforms.setNodes(editor, {
             style: {
               ...node.style,
               ...style
             },
-            inherit_style: generateInheritStyle(INHERIT_CELL_STYLE_WHEN_SELECT_SINGLE, style, node)
+            inherit_style: generateInheritStyle(_constants2.INHERIT_CELL_STYLE_WHEN_SELECT_SINGLE, style, node)
           }, {
             at: path
           });
@@ -200,13 +215,13 @@ export const setCellStyle = (editor, style) => {
       }
     });
     if (firstTableCellNodePath) {
-      const start = Editor.start(editor, firstTableCellNodePath);
-      const end = Editor.end(editor, firstTableCellNodePath);
+      const start = _slate.Editor.start(editor, firstTableCellNodePath);
+      const end = _slate.Editor.end(editor, firstTableCellNodePath);
       const newSelection = {
         anchor: start,
         focus: end
       };
-      Transforms.select(editor, newSelection);
+      _slate.Transforms.select(editor, newSelection);
     }
     return;
   }
@@ -223,39 +238,41 @@ export const setCellStyle = (editor, style) => {
   for (let i = minRowIndex; i <= maxRowIndex; i++) {
     for (let j = minColIndex; j <= maxColIndex; j++) {
       const path = [...tablePath, i, j];
-      const node = getNode(editor, path);
-      Transforms.setNodes(editor, {
+      const node = (0, _core.getNode)(editor, path);
+      _slate.Transforms.setNodes(editor, {
         style: {
           ...node.style,
           ...style
         },
-        inherit_style: generateInheritStyle(INHERIT_CELL_STYLE_WHEN_SELECT_MULTIPLE, style, node)
+        inherit_style: generateInheritStyle(_constants2.INHERIT_CELL_STYLE_WHEN_SELECT_MULTIPLE, style, node)
       }, {
         at: path
       });
     }
   }
 };
-export const insertTableRow = function (editor, table, rowIndex) {
-  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TABLE_ELEMENT_POSITION.AFTER;
+exports.setCellStyle = setCellStyle;
+const insertTableRow = function (editor, table, rowIndex) {
+  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants2.TABLE_ELEMENT_POSITION.AFTER;
   const tableRowCount = table.children.length;
-  if (tableRowCount >= TABLE_MAX_ROWS) return;
+  if (tableRowCount >= _constants2.TABLE_MAX_ROWS) return;
   const tableColumnCount = table.children[0].children.length;
   const row = generateTableRow(editor, tableColumnCount, rowIndex);
-  const tablePath = findPath(editor, table);
-  const targetPath = position === TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
-  Transforms.insertNodes(editor, row, {
+  const tablePath = (0, _core.findPath)(editor, table);
+  const targetPath = position === _constants2.TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
+  _slate.Transforms.insertNodes(editor, row, {
     at: targetPath
   });
   const focusPath = [...targetPath, 0];
-  focusEditor(editor, focusPath);
+  (0, _core.focusEditor)(editor, focusPath);
 
   // handle cells with the rowspan > 1
-  if (position === TABLE_ELEMENT_POSITION.AFTER) {
+  if (position === _constants2.TABLE_ELEMENT_POSITION.AFTER) {
     handleCombinedCellsAfterInsertTableRow(editor, tablePath, table, rowIndex);
   }
 };
-export const 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++) {
@@ -272,13 +289,13 @@ export const handleCombinedCellsAfterInsertTableRow = (editor, tablePath, table,
           colspan: ri_colspan
         } = table.children[ri].children[i];
         if (!ri_is_combined && ri + ri_rowspan - 1 > rowIndex) {
-          Transforms.setNodes(editor, {
+          _slate.Transforms.setNodes(editor, {
             rowspan: ri_rowspan + 1
           }, {
             at: [...tablePath, ri, i]
           });
           for (let j = 0; j < ri_colspan; j++) {
-            Transforms.setNodes(editor, {
+            _slate.Transforms.setNodes(editor, {
               'is_combined': true
             }, {
               at: [...tablePath, rowIndex + 1, i + j]
@@ -289,13 +306,13 @@ export const handleCombinedCellsAfterInsertTableRow = (editor, tablePath, table,
       }
     } else {
       if (rowspan > 1) {
-        Transforms.setNodes(editor, {
+        _slate.Transforms.setNodes(editor, {
           rowspan: rowspan + 1
         }, {
           at: [...tablePath, rowIndex, i]
         });
         for (let j = 0; j < colspan; j++) {
-          Transforms.setNodes(editor, {
+          _slate.Transforms.setNodes(editor, {
             'is_combined': true
           }, {
             at: [...tablePath, rowIndex + 1, i + j]
@@ -305,31 +322,33 @@ export const handleCombinedCellsAfterInsertTableRow = (editor, tablePath, table,
     }
   }
 };
-export const insertTableColumn = function (editor, table, columnIndex) {
-  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TABLE_ELEMENT_POSITION.AFTER;
+exports.handleCombinedCellsAfterInsertTableRow = handleCombinedCellsAfterInsertTableRow;
+const insertTableColumn = function (editor, table, columnIndex) {
+  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants2.TABLE_ELEMENT_POSITION.AFTER;
   const tableColumnCount = table.children[0].children.length;
-  if (tableColumnCount >= TABLE_MAX_COLUMNS) return;
-  const newCellIndex = position === TABLE_ELEMENT_POSITION.AFTER ? columnIndex + 1 : columnIndex;
+  if (tableColumnCount >= _constants2.TABLE_MAX_COLUMNS) return;
+  const newCellIndex = position === _constants2.TABLE_ELEMENT_POSITION.AFTER ? columnIndex + 1 : columnIndex;
   const newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, 1);
   updateColumnWidth(editor, table, newColumns);
-  const tablePath = findPath(editor, table);
+  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);
-    Transforms.insertNodes(editor, newCell, {
+    _slate.Transforms.insertNodes(editor, newCell, {
       at: newCellPath
     });
   }
   const focusPath = [...tablePath, 0, newCellIndex, 0];
-  focusEditor(editor, focusPath);
+  (0, _core.focusEditor)(editor, focusPath);
 
   // handle cells with the colspan > 1
-  if (position === TABLE_ELEMENT_POSITION.AFTER) {
+  if (position === _constants2.TABLE_ELEMENT_POSITION.AFTER) {
     handleCombinedCellsAfterInsertTableColumn(editor, tablePath, table, columnIndex);
   }
 };
-export const 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 {
@@ -345,13 +364,13 @@ export const handleCombinedCellsAfterInsertTableColumn = (editor, tablePath, tab
           colspan: ci_colspan
         } = table.children[i].children[ci];
         if (!ci_is_combined && ci + ci_colspan - 1 > columnIndex) {
-          Transforms.setNodes(editor, {
+          _slate.Transforms.setNodes(editor, {
             colspan: ci_colspan + 1
           }, {
             at: [...tablePath, i, ci]
           });
           for (let j = 0; j < ci_rowspan; j++) {
-            Transforms.setNodes(editor, {
+            _slate.Transforms.setNodes(editor, {
               'is_combined': true
             }, {
               at: [...tablePath, i + j, columnIndex + 1]
@@ -362,13 +381,13 @@ export const handleCombinedCellsAfterInsertTableColumn = (editor, tablePath, tab
       }
     } else {
       if (colspan > 1) {
-        Transforms.setNodes(editor, {
+        _slate.Transforms.setNodes(editor, {
           colspan: colspan + 1
         }, {
           at: [...tablePath, i, columnIndex]
         });
         for (let j = 0; j < rowspan; j++) {
-          Transforms.setNodes(editor, {
+          _slate.Transforms.setNodes(editor, {
             'is_combined': true
           }, {
             at: [...tablePath, i + j, columnIndex + 1]
@@ -378,8 +397,9 @@ export const handleCombinedCellsAfterInsertTableColumn = (editor, tablePath, tab
     }
   }
 };
-export const insertTableElement = function (editor, type) {
-  let position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : TABLE_ELEMENT_POSITION.AFTER;
+exports.handleCombinedCellsAfterInsertTableColumn = handleCombinedCellsAfterInsertTableColumn;
+const insertTableElement = function (editor, type) {
+  let position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _constants2.TABLE_ELEMENT_POSITION.AFTER;
   let count = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
   const {
     table,
@@ -388,55 +408,56 @@ export const insertTableElement = function (editor, type) {
     rowIndex,
     cellIndex
   } = getSelectedInfo(editor);
-  const eventBus = EventBus.getInstance();
-  eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
-  if (type === TABLE_ELEMENT.ROW) {
-    if (tableSize[0] >= TABLE_MAX_ROWS) return;
-    const targetPath = position === TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
-    const validCount = Math.min(TABLE_MAX_ROWS - tableSize[0], count);
+  const eventBus = _eventBus.default.getInstance();
+  eventBus.dispatch(_constants3.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+  if (type === _constants2.TABLE_ELEMENT.ROW) {
+    if (tableSize[0] >= _constants2.TABLE_MAX_ROWS) return;
+    const targetPath = position === _constants2.TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
+    const validCount = Math.min(_constants2.TABLE_MAX_ROWS - tableSize[0], count);
     for (let i = 0; i < validCount; i++) {
       const row = generateTableRow(editor, tableSize[1], rowIndex);
-      Transforms.insertNodes(editor, row, {
+      _slate.Transforms.insertNodes(editor, row, {
         at: targetPath
       });
       // handle combined cells
-      if (!(rowIndex === 0 && position === TABLE_ELEMENT_POSITION.BEFORE)) {
-        const targetRowIndex = position === TABLE_ELEMENT_POSITION.AFTER ? rowIndex : rowIndex - 1;
-        const currentTable = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
+      if (!(rowIndex === 0 && position === _constants2.TABLE_ELEMENT_POSITION.BEFORE)) {
+        const targetRowIndex = position === _constants2.TABLE_ELEMENT_POSITION.AFTER ? rowIndex : rowIndex - 1;
+        const currentTable = (0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE);
         handleCombinedCellsAfterInsertTableRow(editor, tablePath, currentTable, targetRowIndex);
       }
     }
     const focusPath = [...targetPath, cellIndex];
-    focusEditor(editor, focusPath);
+    (0, _core.focusEditor)(editor, focusPath);
     return;
   }
-  if (type === TABLE_ELEMENT.COLUMN) {
-    if (tableSize[1] >= TABLE_MAX_COLUMNS) return;
-    const newCellIndex = position === TABLE_ELEMENT_POSITION.AFTER ? cellIndex + 1 : cellIndex;
-    const validCount = Math.min(TABLE_MAX_COLUMNS - tableSize[1], count);
+  if (type === _constants2.TABLE_ELEMENT.COLUMN) {
+    if (tableSize[1] >= _constants2.TABLE_MAX_COLUMNS) return;
+    const newCellIndex = position === _constants2.TABLE_ELEMENT_POSITION.AFTER ? cellIndex + 1 : cellIndex;
+    const validCount = Math.min(_constants2.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);
-        Transforms.insertNodes(editor, newCell, {
+        _slate.Transforms.insertNodes(editor, newCell, {
           at: newCellPath
         });
       }
       // handle combined cells
-      if (!(cellIndex === 0 && position === TABLE_ELEMENT_POSITION.BEFORE)) {
-        const targetColumnIndex = position === TABLE_ELEMENT_POSITION.AFTER ? cellIndex : cellIndex - 1;
-        const currentTable = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
+      if (!(cellIndex === 0 && position === _constants2.TABLE_ELEMENT_POSITION.BEFORE)) {
+        const targetColumnIndex = position === _constants2.TABLE_ELEMENT_POSITION.AFTER ? cellIndex : cellIndex - 1;
+        const currentTable = (0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE);
         handleCombinedCellsAfterInsertTableColumn(editor, tablePath, currentTable, targetColumnIndex);
       }
     }
     const focusPath = [...tablePath, rowIndex, cellIndex + 1, 0];
-    focusEditor(editor, focusPath);
+    (0, _core.focusEditor)(editor, focusPath);
     return;
   }
 };
-export const combineCells = editor => {
+exports.insertTableElement = insertTableElement;
+const combineCells = editor => {
   const {
     tablePath
   } = getSelectedInfo(editor);
@@ -450,11 +471,11 @@ export const combineCells = editor => {
   for (let i = minRowIndex; i < maxRowIndex + 1; i++) {
     for (let j = minColIndex; j < maxColIndex + 1; j++) {
       let nodePath = [...tablePath, i, j];
-      let node = Editor.node(editor, nodePath);
+      let node = _slate.Editor.node(editor, nodePath);
       if (node[0].is_combined) {
         continue;
       }
-      Transforms.setNodes(editor, {
+      _slate.Transforms.setNodes(editor, {
         'is_combined': true
       }, {
         at: nodePath
@@ -468,19 +489,20 @@ export const combineCells = editor => {
   newCell.rowspan = maxRowIndex - minRowIndex + 1;
   newCell.colspan = maxColIndex - minColIndex + 1;
   // keep row.children.length not changed
-  Transforms.removeNodes(editor, {
+  _slate.Transforms.removeNodes(editor, {
     at: targetCellPath
   });
-  Transforms.insertNodes(editor, newCell, {
+  _slate.Transforms.insertNodes(editor, newCell, {
     at: targetCellPath
   });
-  focusEditor(editor, targetCellPath);
+  (0, _core.focusEditor)(editor, targetCellPath);
 
   // for clicking the 'combine cell' icon in the toolbar
-  const eventBus = EventBus.getInstance();
-  eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+  const eventBus = _eventBus.default.getInstance();
+  eventBus.dispatch(_constants3.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
 };
-export const splitCell = (editor, rowNumber, columnNumber) => {
+exports.combineCells = combineCells;
+const splitCell = (editor, rowNumber, columnNumber) => {
   if (rowNumber === 1 && columnNumber === 1) {
     return;
   }
@@ -521,10 +543,10 @@ export const splitCell = (editor, rowNumber, columnNumber) => {
       if (i === 0 && j === 0) {
         firstNewCell = newCell;
       } else {
-        Transforms.removeNodes(editor, {
+        _slate.Transforms.removeNodes(editor, {
           at: targetCellPath
         });
-        Transforms.insertNodes(editor, newCell, {
+        _slate.Transforms.insertNodes(editor, newCell, {
           at: targetCellPath
         });
       }
@@ -532,14 +554,15 @@ export const splitCell = (editor, rowNumber, columnNumber) => {
     }
     rowspanSum += newRowSpan;
   }
-  Transforms.removeNodes(editor, {
+  _slate.Transforms.removeNodes(editor, {
     at: cellPath
   });
-  Transforms.insertNodes(editor, firstNewCell, {
+  _slate.Transforms.insertNodes(editor, firstNewCell, {
     at: cellPath
   });
 };
-export const removeTable = (editor, path) => {
+exports.splitCell = splitCell;
+const removeTable = (editor, path) => {
   let validPath = path;
   if (!validPath) {
     const {
@@ -548,11 +571,12 @@ export const removeTable = (editor, path) => {
     validPath = tablePath;
   }
   editor.reSetTableSelectedRange();
-  Transforms.removeNodes(editor, {
+  _slate.Transforms.removeNodes(editor, {
     at: validPath
   });
 };
-export const removeTableElement = (editor, type) => {
+exports.removeTable = removeTable;
+const removeTableElement = (editor, type) => {
   const {
     table,
     tablePath,
@@ -561,18 +585,18 @@ export const removeTableElement = (editor, type) => {
     rowIndex,
     cellIndex
   } = getSelectedInfo(editor);
-  const eventBus = EventBus.getInstance();
-  eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
-  if (type === TABLE_ELEMENT.TABLE) {
+  const eventBus = _eventBus.default.getInstance();
+  eventBus.dispatch(_constants3.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+  if (type === _constants2.TABLE_ELEMENT.TABLE) {
     removeTable(editor, tablePath);
     return;
   }
-  if (type === TABLE_ELEMENT.ROW) {
+  if (type === _constants2.TABLE_ELEMENT.ROW) {
     if (tableSize[0] === 1) {
       removeTable(editor, tablePath);
       return;
     }
-    if (!ObjectUtils.isSameObject(editor.tableSelectedRange, EMPTY_SELECTED_RANGE)) {
+    if (!_objectUtils.default.isSameObject(editor.tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
       const {
         minRowIndex,
         maxRowIndex
@@ -583,30 +607,30 @@ export const removeTableElement = (editor, type) => {
       }
       for (let i = minRowIndex; i <= maxRowIndex; i++) {
         queueMicrotask(() => {
-          Transforms.removeNodes(editor, {
+          _slate.Transforms.removeNodes(editor, {
             at: [...tablePath, minRowIndex]
           });
         });
       }
       const focusPath = [...tablePath, minRowIndex === 0 ? 0 : minRowIndex - 1, cellIndex];
-      focusEditor(editor, focusPath);
+      (0, _core.focusEditor)(editor, focusPath);
       return;
     }
     handleCombinedCellsBeforeDeleteTableRow(editor, tablePath, table, rowIndex);
-    Transforms.removeNodes(editor, {
+    _slate.Transforms.removeNodes(editor, {
       at: rowPath
     });
     const focusRowIndex = rowIndex === tableSize[0] - 1 ? rowIndex - 1 : rowIndex;
     const focusPath = [...tablePath, focusRowIndex, cellIndex];
-    focusEditor(editor, focusPath);
+    (0, _core.focusEditor)(editor, focusPath);
     return;
   }
-  if (type === TABLE_ELEMENT.COLUMN) {
+  if (type === _constants2.TABLE_ELEMENT.COLUMN) {
     if (tableSize[1] === 1) {
       removeTable(editor, tablePath);
       return;
     }
-    if (!ObjectUtils.isSameObject(editor.tableSelectedRange, EMPTY_SELECTED_RANGE)) {
+    if (!_objectUtils.default.isSameObject(editor.tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
       const {
         minColIndex,
         maxColIndex
@@ -622,13 +646,13 @@ export const removeTableElement = (editor, type) => {
         for (let j = minColIndex; j <= maxColIndex; j++) {
           // count
           const cellPath = [...tablePath, i, minColIndex];
-          Transforms.removeNodes(editor, {
+          _slate.Transforms.removeNodes(editor, {
             at: cellPath
           });
         }
       }
       const focusPath = [...tablePath, rowIndex, minColIndex === 0 ? 0 : minColIndex - 1];
-      focusEditor(editor, focusPath);
+      (0, _core.focusEditor)(editor, focusPath);
       return;
     }
     const columns = getTableColumns(editor, table);
@@ -638,19 +662,20 @@ export const removeTableElement = (editor, type) => {
     handleCombinedCellsBeforeDeleteTableColumn(editor, tablePath, table, cellIndex);
     for (let i = 0; i < tableSize[0]; i++) {
       const cellPath = [...tablePath, i, cellIndex];
-      Transforms.removeNodes(editor, {
+      _slate.Transforms.removeNodes(editor, {
         at: cellPath
       });
     }
     const focusCellIndex = cellIndex === tableSize[1] - 1 ? cellIndex - 1 : cellIndex;
     const focusPath = [...tablePath, rowIndex, focusCellIndex];
-    focusEditor(editor, focusPath);
+    (0, _core.focusEditor)(editor, focusPath);
     return;
   }
 };
 
 // handle combined cells before deleting a row
-export const handleCombinedCellsBeforeDeleteTableRow = (editor, tablePath, table, rowIndex) => {
+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 {
@@ -665,7 +690,7 @@ export const handleCombinedCellsBeforeDeleteTableRow = (editor, tablePath, table
           rowspan: ri_rowspan
         } = table.children[ri].children[i];
         if (!ri_is_combined && ri + ri_rowspan - 1 >= rowIndex) {
-          Transforms.setNodes(editor, {
+          _slate.Transforms.setNodes(editor, {
             rowspan: ri_rowspan - 1
           }, {
             at: [...tablePath, ri, i]
@@ -679,10 +704,10 @@ export const handleCombinedCellsBeforeDeleteTableRow = (editor, tablePath, table
         const newCell = generateTableCell(editor);
         newCell.rowspan = rowspan - 1;
         newCell.colspan = colspan;
-        Transforms.removeNodes(editor, {
+        _slate.Transforms.removeNodes(editor, {
           at: targetCellPath
         });
-        Transforms.insertNodes(editor, newCell, {
+        _slate.Transforms.insertNodes(editor, newCell, {
           at: targetCellPath
         });
       }
@@ -691,7 +716,8 @@ export const handleCombinedCellsBeforeDeleteTableRow = (editor, tablePath, table
 };
 
 // handle combined cells before deleting a column
-export const handleCombinedCellsBeforeDeleteTableColumn = (editor, tablePath, table, columnIndex) => {
+exports.handleCombinedCellsBeforeDeleteTableRow = handleCombinedCellsBeforeDeleteTableRow;
+const handleCombinedCellsBeforeDeleteTableColumn = (editor, tablePath, table, columnIndex) => {
   for (let i = 0, len = table.children.length; i < len; i++) {
     const {
       is_combined,
@@ -705,7 +731,7 @@ export const handleCombinedCellsBeforeDeleteTableColumn = (editor, tablePath, ta
           colspan: ci_colspan
         } = table.children[i].children[ci];
         if (!ci_is_combined && ci + ci_colspan - 1 >= columnIndex) {
-          Transforms.setNodes(editor, {
+          _slate.Transforms.setNodes(editor, {
             colspan: ci_colspan - 1
           }, {
             at: [...tablePath, i, ci]
@@ -719,53 +745,58 @@ export const handleCombinedCellsBeforeDeleteTableColumn = (editor, tablePath, ta
         const newCell = generateTableCell(editor);
         newCell.rowspan = rowspan;
         newCell.colspan = colspan - 1;
-        Transforms.removeNodes(editor, {
+        _slate.Transforms.removeNodes(editor, {
           at: targetCellPath
         });
-        Transforms.insertNodes(editor, newCell, {
+        _slate.Transforms.insertNodes(editor, newCell, {
           at: targetCellPath
         });
       }
     }
   }
 };
-export const setTableSelectedRange = (editor, range) => {
+exports.handleCombinedCellsBeforeDeleteTableColumn = handleCombinedCellsBeforeDeleteTableColumn;
+const setTableSelectedRange = (editor, range) => {
   if (range) {
     editor.tableSelectedRange = range;
     return;
   }
-  editor.tableSelectedRange = EMPTY_SELECTED_RANGE;
+  editor.tableSelectedRange = _constants2.EMPTY_SELECTED_RANGE;
 };
-export const updateTableRowHeight = (editor, element, rowHeight) => {
-  const path = findPath(editor, element);
-  const targetNode = getNode(editor, path);
+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[TABLE_ROW_STYLE.MIN_HEIGHT] === rowHeight) return;
-  Transforms.setNodes(editor, {
+  if (style[_constants2.TABLE_ROW_STYLE.MIN_HEIGHT] === rowHeight) return;
+  _slate.Transforms.setNodes(editor, {
     style: {
       ...style,
-      [TABLE_ROW_STYLE.MIN_HEIGHT]: rowHeight
+      [_constants2.TABLE_ROW_STYLE.MIN_HEIGHT]: rowHeight
     }
   }, {
     at: path
   });
 };
-export const updateColumnWidth = (editor, element, columns) => {
-  const path = findPath(editor, element);
-  Transforms.setNodes(editor, {
+exports.updateTableRowHeight = updateTableRowHeight;
+const updateColumnWidth = (editor, element, columns) => {
+  const path = (0, _core.findPath)(editor, element);
+  _slate.Transforms.setNodes(editor, {
     columns: columns
   }, {
     at: path
   });
 };
-export const getTableColumnsWidth = function () {
+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);
 };
-export const getTableColumnsAfterInsertColumn = (editor, element, targetColumnIndex, insertColumnCount) => {
+exports.getTableColumnsWidth = getTableColumnsWidth;
+const getTableColumnsAfterInsertColumn = (editor, element, targetColumnIndex, insertColumnCount) => {
   const columns = getTableColumns(editor, element);
   let newColumns = columns.slice(0);
   let totalColumnsWidth = getTableColumnsWidth(columns);
@@ -798,17 +829,18 @@ export const getTableColumnsAfterInsertColumn = (editor, element, targetColumnIn
   return newColumns.map(column => {
     return {
       ...column,
-      width: Math.max(parseInt(column.width / proportion), TABLE_CELL_MIN_WIDTH)
+      width: Math.max(parseInt(column.width / proportion), _constants2.TABLE_CELL_MIN_WIDTH)
     };
   });
 };
-export const getTableColumns = (editor, element) => {
+exports.getTableColumnsAfterInsertColumn = getTableColumnsAfterInsertColumn;
+const getTableColumns = (editor, element) => {
   if (!element) return [];
   let tableElement = element;
-  if (element.type === ELEMENT_TYPE.TABLE_CELL) {
-    const cellPath = findPath(editor, element);
+  if (element.type === _constants.ELEMENT_TYPE.TABLE_CELL) {
+    const cellPath = (0, _core.findPath)(editor, element);
     const tablePath = cellPath.slice(0, -2);
-    tableElement = getNode(editor, tablePath);
+    tableElement = (0, _core.getNode)(editor, tablePath);
   }
   const {
     columns,
@@ -817,68 +849,73 @@ export const getTableColumns = (editor, element) => {
   if (columns) return columns;
   const columnsCount = children[0].children.length;
   let initColumns = [];
-  const pageEditAreaWidth = editor.width || PAGE_EDIT_AREA_WIDTH;
+  const pageEditAreaWidth = editor.width || _constants3.PAGE_EDIT_AREA_WIDTH;
   for (let i = 0; i < columnsCount; i++) {
     const column = {
-      width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
+      width: Math.max(_constants2.TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
     };
     initColumns.push(column);
   }
   return initColumns;
 };
-export const getCellColumn = (editor, cellElement) => {
+exports.getTableColumns = getTableColumns;
+const getCellColumn = (editor, cellElement) => {
   let column = {
-    width: TABLE_CELL_MIN_WIDTH
+    width: _constants2.TABLE_CELL_MIN_WIDTH
   };
   if (!editor || !cellElement) return column;
-  const cellPath = findPath(editor, cellElement);
+  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 = getNode(editor, tablePath);
+  const tableElement = (0, _core.getNode)(editor, tablePath);
   const {
     columns
   } = tableElement;
   const columnsCount = tableElement.children[0].children.length;
-  const pageEditAreaWidth = editor.width || PAGE_EDIT_AREA_WIDTH;
+  const pageEditAreaWidth = editor.width || _constants3.PAGE_EDIT_AREA_WIDTH;
   if (columns) {
     column = columns[cellIndex];
   }
   return column || {
-    width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
+    width: Math.max(_constants2.TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
   };
 };
-export const getFirstTableCell = element => {
+exports.getCellColumn = getCellColumn;
+const getFirstTableCell = element => {
   let tableCellElement = element;
   while (tableCellElement && !(tableCellElement.hasAttribute('row-index') && tableCellElement.hasAttribute('cell-index'))) {
     tableCellElement = tableCellElement.parentNode;
   }
   return tableCellElement;
 };
-export const elementHasImage = element => {
+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 === ELEMENT_TYPE.IMAGE) return true;
-    if (ObjectUtils.hasProperty(child, 'children')) {
+    if (child.type === _constants.ELEMENT_TYPE.IMAGE) return true;
+    if (_objectUtils.default.hasProperty(child, 'children')) {
       return elementHasImage(child);
     }
     return false;
   });
 };
-export const isSelectedAllCell = editor => {
+exports.elementHasImage = elementHasImage;
+const isSelectedAllCell = editor => {
   const {
     tableSize
   } = getSelectedInfo(editor);
-  return ObjectUtils.isSameObject(editor.tableSelectedRange, {
+  return _objectUtils.default.isSameObject(editor.tableSelectedRange, {
     minColIndex: 0,
     maxColIndex: tableSize[1] - 1,
     minRowIndex: 0,
     maxRowIndex: tableSize[0] - 1
   });
 };
-export const insertMultipleRowsAndColumns = (editor, rows, columns) => {
+exports.isSelectedAllCell = isSelectedAllCell;
+const insertMultipleRowsAndColumns = (editor, rows, columns) => {
   const {
     table,
     tablePath,
@@ -886,13 +923,13 @@ export const insertMultipleRowsAndColumns = (editor, rows, columns) => {
     rowIndex,
     cellIndex
   } = getSelectedInfo(editor);
-  let newTable = deepCopy(table);
-  const eventBus = EventBus.getInstance();
-  eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+  let newTable = (0, _deepCopy.default)(table);
+  const eventBus = _eventBus.default.getInstance();
+  eventBus.dispatch(_constants3.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(TABLE_MAX_ROWS - tableSize[0], insertRows.length));
-  const validInsertColumns = insertColumns.slice(0, Math.min(TABLE_MAX_COLUMNS - tableSize[1], columns.length));
+  const validInsertRows = insertRows.slice(0, Math.min(_constants2.TABLE_MAX_ROWS - tableSize[0], insertRows.length));
+  const validInsertColumns = insertColumns.slice(0, Math.min(_constants2.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);
@@ -908,35 +945,36 @@ export const insertMultipleRowsAndColumns = (editor, rows, columns) => {
       newTable.children[i].children.push(newCell);
     }
   }
-  for (let i = rowIndex; i < Math.min(TABLE_MAX_ROWS, rowIndex + rows.length); i++) {
+  for (let i = rowIndex; i < Math.min(_constants2.TABLE_MAX_ROWS, rowIndex + rows.length); i++) {
     const row = rows[i - rowIndex];
     const cells = row.children;
-    for (let j = cellIndex; j < Math.min(TABLE_MAX_COLUMNS, cellIndex + columns.length); j++) {
+    for (let j = cellIndex; j < Math.min(_constants2.TABLE_MAX_COLUMNS, cellIndex + columns.length); j++) {
       const replaceCellIndex = j - cellIndex;
       const replaceCell = cells[replaceCellIndex];
-      newTable.children[i].children[j].children = replacePastedDataId(replaceCell.children);
+      newTable.children[i].children[j].children = (0, _helpers.replacePastedDataId)(replaceCell.children);
     }
   }
-  replaceNode(editor, {
+  (0, _core.replaceNode)(editor, {
     at: tablePath,
     nodes: newTable
   });
-  focusEditor(editor, [...tablePath, rowIndex, cellIndex, 0]);
+  (0, _core.focusEditor)(editor, [...tablePath, rowIndex, cellIndex, 0]);
   const {
     focus: newFocus
   } = editor.selection;
-  Transforms.select(editor, {
+  _slate.Transforms.select(editor, {
     focus: newFocus,
     anchor: newFocus
   });
   return;
 };
-export const setTableFragmentData = (editor, dataTransfer) => {
-  const selectedNode = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
+exports.insertMultipleRowsAndColumns = insertMultipleRowsAndColumns;
+const setTableFragmentData = (editor, dataTransfer) => {
+  const selectedNode = (0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE);
   const fragment = editor.getFragment();
   const string = JSON.stringify(fragment);
   const encoded = window.btoa(encodeURIComponent(string));
-  dataTransfer.setData("application/".concat(CLIPBOARD_FORMAT_KEY), encoded);
+  dataTransfer.setData(`application/${_constants.CLIPBOARD_FORMAT_KEY}`, encoded);
   const tableDom = document.createElement('table');
   const {
     minColIndex,
@@ -944,15 +982,15 @@ export const setTableFragmentData = (editor, dataTransfer) => {
     minRowIndex,
     maxRowIndex
   } = editor.tableSelectedRange;
-  const tablePath = findPath(editor, selectedNode);
+  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 = getNode(editor, path);
+      const node = (0, _core.getNode)(editor, path);
       const td = document.createElement('td');
       const div = document.createElement('div');
-      div.innerHTML = ReactEditor.toDOMNode(editor, node).innerHTML;
+      div.innerHTML = _slateReact.ReactEditor.toDOMNode(editor, node).innerHTML;
       td.appendChild(div);
       tr.appendChild(td);
     }
@@ -965,7 +1003,8 @@ export const setTableFragmentData = (editor, dataTransfer) => {
   dataTransfer.setData('text/plain', div.innerText);
   return dataTransfer;
 };
-export const deleteTableRangeData = editor => {
+exports.setTableFragmentData = setTableFragmentData;
+const deleteTableRangeData = editor => {
   const {
     tableSelectedRange
   } = editor;
@@ -982,12 +1021,12 @@ export const deleteTableRangeData = editor => {
   for (let i = minRowIndex; i <= maxRowIndex; i++) {
     for (let j = minColIndex; j <= maxColIndex; j++) {
       const path = [...tablePath, i, j];
-      const node = getNode(editor, path);
-      if (!forceCellPath && (Node.string(node) || elementHasImage(node))) {
+      const node = (0, _core.getNode)(editor, path);
+      if (!forceCellPath && (_slate.Node.string(node) || elementHasImage(node))) {
         forceCellPath = path;
       }
       const firstNode = node.children[0];
-      replaceNodeChildren(editor, {
+      (0, _core.replaceNodeChildren)(editor, {
         at: path,
         nodes: {
           ...firstNode,
@@ -997,58 +1036,60 @@ export const deleteTableRangeData = editor => {
     }
   }
   if (forceCellPath) {
-    editor.tableSelectedRange = EMPTY_SELECTED_RANGE;
-    const eventBus = EventBus.getInstance();
-    eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
-    focusEditor(editor, forceCellPath);
+    editor.tableSelectedRange = _constants2.EMPTY_SELECTED_RANGE;
+    const eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_constants3.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+    (0, _core.focusEditor)(editor, forceCellPath);
     const {
       focus: newFocus
     } = editor.selection;
-    Transforms.select(editor, {
+    _slate.Transforms.select(editor, {
       focus: newFocus,
       anchor: newFocus
     });
   }
 };
-export const deleteHandler = editor => {
+exports.deleteTableRangeData = deleteTableRangeData;
+const deleteHandler = editor => {
   const {
     selection,
     tableSelectedRange
   } = editor;
   if (selection == null) return '';
-  if (!ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
+  if (!_objectUtils.default.isSameObject(tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
     if (isSelectedAllCell(editor)) return 'table';
     return 'range';
   }
-  const [cellNodeEntry] = Editor.nodes(editor, {
+  const [cellNodeEntry] = _slate.Editor.nodes(editor, {
     match: n => {
-      let type = getNodeType(n);
-      if (!type && isTextNode(n) && n.id) {
-        const parentNode = getParentNode(editor.children, n.id);
-        type = getNodeType(parentNode);
+      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 === ELEMENT_TYPE.TABLE_CELL;
+      return type === _constants.ELEMENT_TYPE.TABLE_CELL;
     }
   });
   if (cellNodeEntry) {
     const [, cellPath] = cellNodeEntry;
-    const start = Editor.start(editor, cellPath);
-    if (Point.equals(selection.anchor, start)) {
+    const start = _slate.Editor.start(editor, cellPath);
+    if (_slate.Point.equals(selection.anchor, start)) {
       return 'default';
     }
   }
   return '';
 };
-export const isTableLocation = (editor, location) => {
-  const tables = Editor.nodes(editor, {
+exports.deleteHandler = deleteHandler;
+const isTableLocation = (editor, location) => {
+  const tables = _slate.Editor.nodes(editor, {
     at: location,
     match: n => {
-      let type = getNodeType(n);
-      if (!type && isTextNode(n) && n.id) {
-        const parentNode = getParentNode(editor.children, n.id);
-        type = getNodeType(parentNode);
+      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 === ELEMENT_TYPE.TABLE_CELL;
+      return type === _constants.ELEMENT_TYPE.TABLE_CELL;
     }
   });
   let hasTable = false;
@@ -1058,7 +1099,8 @@ export const isTableLocation = (editor, location) => {
   }
   return hasTable;
 };
-export const isCursorAtCellEnd = function (cell) {
+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;
@@ -1066,11 +1108,13 @@ export const isCursorAtCellEnd = function (cell) {
   const textCount = lastChildren.text.length;
   return cursor === textCount;
 };
-export const isCursorAtCellStart = function () {
+exports.isCursorAtCellEnd = isCursorAtCellEnd;
+const isCursorAtCellStart = function () {
   let cursor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
   return cursor === 0;
 };
-export const focusCell = function (editor, event) {
+exports.isCursorAtCellStart = isCursorAtCellStart;
+const focusCell = function (editor, event) {
   let keyboardName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
   const {
     tableSize,
@@ -1087,25 +1131,25 @@ export const focusCell = function (editor, event) {
   const {
     focus
   } = selection;
-  if (keyboardName === KEYBOARD.UP) {
+  if (keyboardName === _constants.KEYBOARD.UP) {
     if (!isCursorAtCellStart(focus.offset)) {
       setTimeout(() => {
-        if (getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE)) {
+        if ((0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE)) {
           const {
             cellIndex: newCellIndex
           } = getSelectedInfo(editor);
           if (Math.abs(newCellIndex - cellIndex) !== 0) {
             if (rowIndex === 0) {
               if (tableIndex !== 0) {
-                focusEditor(editor, [...tableParentPath, tableIndex - 1]);
+                (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex - 1]);
               }
               return;
             }
-            focusEditor(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
+            (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
             const {
               focus: newFocus
             } = editor.selection;
-            Transforms.select(editor, {
+            _slate.Transforms.select(editor, {
               focus: newFocus,
               anchor: newFocus
             });
@@ -1117,58 +1161,58 @@ export const focusCell = function (editor, event) {
     event.preventDefault();
     if (rowIndex === 0) {
       if (tableIndex !== 0) {
-        focusEditor(editor, [...tableParentPath, tableIndex - 1]);
+        (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex - 1]);
       }
       return;
     }
-    focusEditor(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
+    (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
     const {
       focus: newFocus
     } = editor.selection;
-    Transforms.select(editor, {
+    _slate.Transforms.select(editor, {
       focus: newFocus,
       anchor: newFocus
     });
   }
-  if (keyboardName === KEYBOARD.RIGHT) {
+  if (keyboardName === _constants.KEYBOARD.RIGHT) {
     if (!isCursorAtCellEnd(cell, focus.offset)) return;
     event.preventDefault();
     if (rowIndex === tableSize[0] - 1 && cellIndex === tableSize[1] - 1) {
-      focusEditor(editor, [...tableParentPath, tableIndex + 1]);
+      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex + 1]);
       return;
     }
     if (cellIndex === tableSize[1] - 1) {
-      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex + 1, 0]);
+      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex + 1, 0]);
     } else {
-      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex + 1]);
+      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex + 1]);
     }
     const {
       anchor: newAnchor
     } = editor.selection;
-    Transforms.select(editor, {
+    _slate.Transforms.select(editor, {
       focus: newAnchor,
       anchor: newAnchor
     });
   }
-  if (keyboardName === KEYBOARD.DOWN) {
+  if (keyboardName === _constants.KEYBOARD.DOWN) {
     if (!isCursorAtCellEnd(cell, focus.offset)) {
       setTimeout(() => {
-        if (getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE)) {
+        if ((0, _core.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE)) {
           const {
             cellIndex: newCellIndex
           } = getSelectedInfo(editor);
           if (Math.abs(newCellIndex - cellIndex) !== 0) {
             if (rowIndex === tableSize[0] - 1) {
-              const nextNode = getNode(editor, [...tableParentPath, tableIndex + 1]);
+              const nextNode = (0, _core.getNode)(editor, [...tableParentPath, tableIndex + 1]);
               if (!nextNode) return;
-              focusEditor(editor, [...tableParentPath, tableIndex + 1]);
+              (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex + 1]);
               return;
             }
-            focusEditor(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
+            (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
             const {
               anchor: newAnchor
             } = editor.selection;
-            Transforms.select(editor, {
+            _slate.Transforms.select(editor, {
               focus: newAnchor,
               anchor: newAnchor
             });
@@ -1179,45 +1223,46 @@ export const focusCell = function (editor, event) {
     }
     event.preventDefault();
     if (rowIndex === tableSize[0] - 1) {
-      const nextNode = getNode([...tableParentPath, tableIndex + 1]);
+      const nextNode = (0, _core.getNode)([...tableParentPath, tableIndex + 1]);
       if (!nextNode) return;
-      focusEditor(editor, [...tableParentPath, tableIndex + 1]);
+      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex + 1]);
       return;
     }
-    focusEditor(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
+    (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
     const {
       anchor: newAnchor
     } = editor.selection;
-    Transforms.select(editor, {
+    _slate.Transforms.select(editor, {
       focus: newAnchor,
       anchor: newAnchor
     });
   }
-  if (keyboardName === KEYBOARD.LEFT) {
+  if (keyboardName === _constants.KEYBOARD.LEFT) {
     if (!isCursorAtCellStart(focus.offset)) return;
     event.preventDefault();
     if (rowIndex === 0 && cellIndex === 0) {
       if (tableIndex !== 0) {
-        focusEditor(editor, [...tableParentPath, tableIndex - 1]);
+        (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex - 1]);
       }
       return;
     }
     if (cellIndex === 0) {
-      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex - 1, tableSize[1] - 1]);
+      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex - 1, tableSize[1] - 1]);
     } else {
-      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex - 1]);
+      (0, _core.focusEditor)(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex - 1]);
     }
     const {
       focus: newFocus
     } = editor.selection;
-    Transforms.select(editor, {
+    _slate.Transforms.select(editor, {
       focus: newFocus,
       anchor: newFocus
     });
   }
 };
-export const isLastTableCell = (editor, cellNode) => {
-  if (cellNode[0].type !== ELEMENT_TYPE.TABLE_CELL) return false;
+exports.focusCell = focusCell;
+const isLastTableCell = (editor, cellNode) => {
+  if (cellNode[0].type !== _constants.ELEMENT_TYPE.TABLE_CELL) return false;
   const {
     tableSize
   } = getSelectedInfo(editor);
@@ -1227,12 +1272,13 @@ export const isLastTableCell = (editor, cellNode) => {
   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();
 };
-export const colorBlend = (c1, c2, ratio) => {
+const colorBlend = (c1, c2, ratio) => {
   const color1 = getValidColor(c1);
   const color2 = getValidColor(c2);
   if (!color1 && !color2) return 'unset';
@@ -1255,14 +1301,16 @@ export const colorBlend = (c1, c2, ratio) => {
   b = ('0' + (b || 0).toString(16)).slice(-2);
   return '#' + r + g + b;
 };
-export const getRowHeight = (element, rowIndex) => {
+exports.colorBlend = colorBlend;
+const getRowHeight = (element, rowIndex) => {
   const {
     style = {}
   } = element;
-  const rowHeight = style[TABLE_ROW_STYLE.MIN_HEIGHT] || TABLE_ROW_MIN_HEIGHT;
+  const rowHeight = style[_constants2.TABLE_ROW_STYLE.MIN_HEIGHT] || _constants2.TABLE_ROW_MIN_HEIGHT;
   return rowIndex === 0 ? rowHeight + 1 : rowHeight;
 };
-export const getRowDomHeight = (editor, row) => {
+exports.getRowHeight = getRowHeight;
+const getRowDomHeight = (editor, row) => {
   let height = 0;
   for (const cell of row.children) {
     const {
@@ -1272,7 +1320,7 @@ export const getRowDomHeight = (editor, row) => {
     if (is_combined || rowspan > 1) continue;
     let cellDom = null;
     try {
-      cellDom = ReactEditor.toDOMNode(editor, cell);
+      cellDom = _slateReact.ReactEditor.toDOMNode(editor, cell);
     } catch (error) {
       if (!cellDom) break;
     }
@@ -1281,16 +1329,17 @@ export const getRowDomHeight = (editor, row) => {
   }
   // if the row is empty, get the height from style
   if (!height) {
-    height = row.style[TABLE_ROW_STYLE.MIN_HEIGHT] || TABLE_ROW_MIN_HEIGHT;
+    height = row.style[_constants2.TABLE_ROW_STYLE.MIN_HEIGHT] || _constants2.TABLE_ROW_MIN_HEIGHT;
   }
   return height;
 };
+exports.getRowDomHeight = getRowDomHeight;
 const normalizeTableCell = (editor, cell) => {
   if (!cell) return generateTableCell(editor);
   let newCell = {
     children: [{
       text: '',
-      id: slugid.nice()
+      id: _slugid.default.nice()
     }],
     ...cell
   };
@@ -1299,7 +1348,7 @@ const normalizeTableCell = (editor, cell) => {
   let newCellChildren = [];
   newCell.children.forEach(cellChild => {
     const cellChildType = cellChild.type;
-    if (cellChildType === ELEMENT_TYPE.PARAGRAPH) {
+    if (cellChildType === _constants.ELEMENT_TYPE.PARAGRAPH) {
       newCellChildren.push(...cellChild.children);
     } else {
       newCellChildren.push(cellChild);
@@ -1333,8 +1382,8 @@ const normalizeTableCell = (editor, cell) => {
   }
   return newCell;
 };
-export const normalizeTableELement = (editor, element) => {
-  if (element.type !== ELEMENT_TYPE.TABLE) {
+const normalizeTableELement = (editor, element) => {
+  if (element.type !== _constants.ELEMENT_TYPE.TABLE) {
     const size = [element.children.length, element.children[0].children.length];
     return generateEmptyTable(editor, {
       size
@@ -1352,14 +1401,15 @@ export const normalizeTableELement = (editor, element) => {
   }
   return newElement;
 };
-export const insertTableByTemplate = (editor, alternateColor) => {
+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 = Editor.path(editor, editor.selection);
+  const path = _slate.Editor.path(editor, editor.selection);
   const insertPosition = getInsertPosition(editor);
   handleInsertTable(editor, insertPosition, path, tableNode);
 };
@@ -1371,46 +1421,49 @@ export const insertTableByTemplate = (editor, alternateColor) => {
  * @param {Node} tableNode
  * Insert table by insertPosition
  */
-export const handleInsertTable = (editor, insertPosition, path, tableNode) => {
+exports.insertTableByTemplate = insertTableByTemplate;
+const handleInsertTable = (editor, insertPosition, path, tableNode) => {
   const {
     selection
   } = editor;
-  if (insertPosition === INSERT_POSITION.BEFORE) {
+  if (insertPosition === _constants.INSERT_POSITION.BEFORE) {
     const insertPath = [path[0]];
-    Transforms.insertNodes(editor, tableNode, {
+    _slate.Transforms.insertNodes(editor, tableNode, {
       at: insertPath
     });
-  } else if (insertPosition === INSERT_POSITION.AFTER) {
+  } else if (insertPosition === _constants.INSERT_POSITION.AFTER) {
     const insertPath = [path[0] + 1];
-    Transforms.insertNodes(editor, tableNode, {
+    _slate.Transforms.insertNodes(editor, tableNode, {
       at: insertPath
     });
-  } else if (insertPosition === INSERT_POSITION.CURRENT) {
-    Transforms.splitNodes(editor, {
+  } else if (insertPosition === _constants.INSERT_POSITION.CURRENT) {
+    _slate.Transforms.splitNodes(editor, {
       at: selection,
       always: true
     });
-    Transforms.insertNodes(editor, tableNode, {
+    _slate.Transforms.insertNodes(editor, tableNode, {
       at: selection.anchor
     });
   }
-  ReactEditor.focus(editor);
+  _slateReact.ReactEditor.focus(editor);
 };
-export const getInsertPosition = editor => {
+exports.handleInsertTable = handleInsertTable;
+const getInsertPosition = editor => {
   const {
     selection
   } = editor;
-  if (!selection) return INSERT_POSITION.CURRENT;
-  if (!Range.isCollapsed(selection)) return INSERT_POSITION.CURRENT;
-  const aboveNodeEntry = getAboveBlockNode(editor);
-  if (!aboveNodeEntry) return INSERT_POSITION.CURRENT;
-  const isAtStart = Editor.isStart(editor, selection.anchor, aboveNodeEntry[1]);
-  if (isAtStart) return INSERT_POSITION.BEFORE;
-  const isAtEnd = Editor.isEnd(editor, selection.anchor, aboveNodeEntry[1]);
-  if (isAtEnd) return INSERT_POSITION.AFTER;
-  return INSERT_POSITION.CURRENT;
-};
-export const generateInheritStyle = (allowedInheritStyleList, style, cell) => {
+  if (!selection) return _constants.INSERT_POSITION.CURRENT;
+  if (!_slate.Range.isCollapsed(selection)) return _constants.INSERT_POSITION.CURRENT;
+  const aboveNodeEntry = (0, _core.getAboveBlockNode)(editor);
+  if (!aboveNodeEntry) return _constants.INSERT_POSITION.CURRENT;
+  const isAtStart = _slate.Editor.isStart(editor, selection.anchor, aboveNodeEntry[1]);
+  if (isAtStart) return _constants.INSERT_POSITION.BEFORE;
+  const isAtEnd = _slate.Editor.isEnd(editor, selection.anchor, aboveNodeEntry[1]);
+  if (isAtEnd) return _constants.INSERT_POSITION.AFTER;
+  return _constants.INSERT_POSITION.CURRENT;
+};
+exports.getInsertPosition = getInsertPosition;
+const generateInheritStyle = (allowedInheritStyleList, style, cell) => {
   const inheritStyle = {
     ...cell['inherit_style']
   } || {};
@@ -1421,10 +1474,11 @@ export const generateInheritStyle = (allowedInheritStyleList, style, cell) => {
   }
   return inheritStyle;
 };
-export const getCellInheritStyles = (editor, tablePath, rowIndex, colIndex) => {
+exports.generateInheritStyle = generateInheritStyle;
+const getCellInheritStyles = (editor, tablePath, rowIndex, colIndex) => {
   var _table$children$rowIn, _tableCell$inherit_st;
-  const [tableNodeEntry] = Editor.nodes(editor, {
-    match: n => n.type === ELEMENT_TYPE.TABLE,
+  const [tableNodeEntry] = _slate.Editor.nodes(editor, {
+    match: n => n.type === _constants.ELEMENT_TYPE.TABLE,
     at: tablePath
   });
   if (!tableNodeEntry) return {};
@@ -1433,21 +1487,24 @@ export const getCellInheritStyles = (editor, tablePath, rowIndex, colIndex) => {
   if (!tableCell) return {};
   return (_tableCell$inherit_st = tableCell['inherit_style']) !== null && _tableCell$inherit_st !== void 0 ? _tableCell$inherit_st : {};
 };
-export const getCellHighlightClassName = (primaryColorClassName, rowIndex) => {
+exports.getCellInheritStyles = getCellInheritStyles;
+const getCellHighlightClassName = (primaryColorClassName, rowIndex) => {
   let className = '';
   if (rowIndex === 0) {
     className = primaryColorClassName;
   } else if (rowIndex % 2 === 0) {
-    className = TABLE_ALTERNATE_HIGHLIGHT_CLASS_MAP[primaryColorClassName];
+    className = _constants2.TABLE_ALTERNATE_HIGHLIGHT_CLASS_MAP[primaryColorClassName];
   }
   return className;
 };
-export const focusClosestCellWhenJustifyCellSize = (editor, adjustingCell) => {
-  const cellPath = ReactEditor.findPath(editor, adjustingCell);
-  focusEditor(editor, Editor.end(editor, cellPath));
+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];
@@ -1470,7 +1527,7 @@ const searchCombinedMainCell = (table, startRowIndex, startColIndex) => {
     }
   }
 };
-export const getResizeMaskCellInfo = (editor, table, rowIndex, cellIndex) => {
+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];
@@ -1484,7 +1541,7 @@ export const getResizeMaskCellInfo = (editor, table, rowIndex, cellIndex) => {
     cell = targetCellInfo.currentCell;
   }
   const columns = table.columns;
-  const focussedCell = ReactEditor.toDOMNode(editor, cell);
+  const focussedCell = _slateReact.ReactEditor.toDOMNode(editor, cell);
   const {
     colspan,
     rowspan
@@ -1503,7 +1560,7 @@ export const getResizeMaskCellInfo = (editor, table, rowIndex, cellIndex) => {
     let index = rowIndex + 1;
     while (index < rowIndex + rowspan) {
       const currentCell = table.children[index].children[cellIndex];
-      const currentHeight = ReactEditor.toDOMNode(editor, currentCell).getBoundingClientRect().height;
+      const currentHeight = _slateReact.ReactEditor.toDOMNode(editor, currentCell).getBoundingClientRect().height;
       height += currentHeight;
       index++;
     }
@@ -1521,11 +1578,12 @@ export const getResizeMaskCellInfo = (editor, table, rowIndex, cellIndex) => {
 };
 
 // Table alternate highlight
-export const getHighlightClass = (editor, cellPath) => {
+exports.getResizeMaskCellInfo = getResizeMaskCellInfo;
+const getHighlightClass = (editor, cellPath) => {
   var _tableEntry$;
-  const [tableEntry] = Editor.nodes(editor, {
+  const [tableEntry] = _slate.Editor.nodes(editor, {
     at: cellPath,
-    match: n => n.type === ELEMENT_TYPE.TABLE
+    match: n => n.type === _constants.ELEMENT_TYPE.TABLE
   });
   const {
     alternate_highlight,
@@ -1538,7 +1596,8 @@ export const getHighlightClass = (editor, cellPath) => {
 };
 
 // Correct the selected range when combined cell are selected
-export const adjustCombinedCellRange = (table, range) => {
+exports.getHighlightClass = getHighlightClass;
+const adjustCombinedCellRange = (table, range) => {
   const {
     minRowIndex,
     maxRowIndex,
@@ -1553,7 +1612,7 @@ export const adjustCombinedCellRange = (table, range) => {
   if (rowspan > 1 || colspan > 1) {
     const isRowCombined = minRowIndex + rowspan === maxRowIndex + 1;
     const isColCombined = minColIndex + colspan === maxColIndex + 1;
-    if (isRowCombined && isColCombined) return EMPTY_SELECTED_RANGE;
+    if (isRowCombined && isColCombined) return _constants2.EMPTY_SELECTED_RANGE;
   }
   return range;
 };
@@ -1563,7 +1622,8 @@ export const adjustCombinedCellRange = (table, range) => {
  * @param {MouseEvent} event
  * @returns {Boolean}
  */
-export const isPreventResetTableSelectedRange = event => {
+exports.adjustCombinedCellRange = adjustCombinedCellRange;
+const isPreventResetTableSelectedRange = event => {
   const {
     target
   } = event;
@@ -1578,15 +1638,17 @@ export const isPreventResetTableSelectedRange = event => {
 /**
  * Check drag type, column or row
  */
-export const getTableDragType = (table, selectedRange) => {
+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 ? DRAG_HANDLER_COLUMN : DRAG_HANDLER_ROW;
+  return isSelectColumn ? _constants2.DRAG_HANDLER_COLUMN : _constants2.DRAG_HANDLER_ROW;
 };
+exports.getTableDragType = getTableDragType;
 const updateTableColumns = (editor, table, targetColIndex, startColIndex, endColIndex) => {
   const columns = [...table.columns];
   const deleteCount = endColIndex - startColIndex + 1;
@@ -1594,7 +1656,7 @@ const updateTableColumns = (editor, table, targetColIndex, startColIndex, endCol
   columns.splice(targetColIndex, 0, ...newColumns);
   updateColumnWidth(editor, table, columns);
 };
-export const moveColumns = (editor, targetColIndex, startColIndex, endColIndex) => {
+const moveColumns = (editor, targetColIndex, startColIndex, endColIndex) => {
   // Get selected table information
   const {
     table,
@@ -1613,10 +1675,10 @@ export const moveColumns = (editor, targetColIndex, startColIndex, endColIndex)
       // Move columns forward by inserting nodes
       for (let insertIndex = endColIndex; insertIndex >= startColIndex; insertIndex--) {
         const insertNode = row.children[insertIndex];
-        Transforms.removeNodes(editor, {
+        _slate.Transforms.removeNodes(editor, {
           at: sourcePath
         });
-        Transforms.insertNodes(editor, insertNode, {
+        _slate.Transforms.insertNodes(editor, insertNode, {
           at: targetPath
         });
       }
@@ -1628,10 +1690,10 @@ export const moveColumns = (editor, targetColIndex, startColIndex, endColIndex)
       // Move columns backward by inserting nodes
       for (let insertIndex = startColIndex; insertIndex <= endColIndex; insertIndex++) {
         const insertNode = row.children[insertIndex];
-        Transforms.removeNodes(editor, {
+        _slate.Transforms.removeNodes(editor, {
           at: sourcePath
         });
-        Transforms.insertNodes(editor, insertNode, {
+        _slate.Transforms.insertNodes(editor, insertNode, {
           at: targetPath
         });
       }
@@ -1660,7 +1722,8 @@ export const moveColumns = (editor, targetColIndex, startColIndex, endColIndex)
  * @param {number} endIndex - The index of the ending column or row before dragging.
  * @returns {Object} - The new selected range after the drag operation.
  */
-export const getTableSelectedRangeAfterDrag = (table, moveType, targetIndex, startIndex, endIndex) => {
+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;
@@ -1677,7 +1740,7 @@ export const getTableSelectedRangeAfterDrag = (table, moveType, targetIndex, sta
   const isMoveToFroward = targetIndex < startIndex;
 
   // Adjust selected range based on the type of drag operation
-  if (moveType === DRAG_HANDLER_COLUMN) {
+  if (moveType === _constants2.DRAG_HANDLER_COLUMN) {
     if (isMoveToFroward) {
       newSelectRange.minColIndex = targetIndex;
       newSelectRange.maxColIndex = targetIndex + endIndex - startIndex;
@@ -1698,7 +1761,8 @@ export const getTableSelectedRangeAfterDrag = (table, moveType, targetIndex, sta
   }
   return newSelectRange;
 };
-export const moveRows = (editor, targetRowIndex, startRowIndex, endRowIndex) => {
+exports.getTableSelectedRangeAfterDrag = getTableSelectedRangeAfterDrag;
+const moveRows = (editor, targetRowIndex, startRowIndex, endRowIndex) => {
   const {
     table,
     tablePath
@@ -1709,20 +1773,20 @@ export const moveRows = (editor, targetRowIndex, startRowIndex, endRowIndex) =>
   if (isMoveToFroward) {
     for (let insertIndex = endRowIndex; insertIndex >= startRowIndex; insertIndex--) {
       const insertNode = table.children[insertIndex];
-      Transforms.removeNodes(editor, {
+      _slate.Transforms.removeNodes(editor, {
         at: sourcePath
       });
-      Transforms.insertNodes(editor, insertNode, {
+      _slate.Transforms.insertNodes(editor, insertNode, {
         at: targetPath
       });
     }
   } else {
     for (let insertIndex = startRowIndex; insertIndex <= endRowIndex; insertIndex++) {
       const insertNode = table.children[insertIndex];
-      Transforms.removeNodes(editor, {
+      _slate.Transforms.removeNodes(editor, {
         at: sourcePath
       });
-      Transforms.insertNodes(editor, insertNode, {
+      _slate.Transforms.insertNodes(editor, insertNode, {
         at: targetPath
       });
     }
@@ -1735,7 +1799,8 @@ export const moveRows = (editor, targetRowIndex, startRowIndex, endRowIndex) =>
   };
   setTableSelectedRange(editor, newSelectRange);
 };
-export const generateDragMoveElement = tipText => {
+exports.moveRows = moveRows;
+const generateDragMoveElement = tipText => {
   const canvasId = 'sdoc-drag-image';
   let canvas = document.getElementById(canvasId);
   if (!canvas) {
@@ -1767,28 +1832,29 @@ export const generateDragMoveElement = tipText => {
   context.fillText(tipText, canvas.width / 2, canvas.height / 2);
   return canvas;
 };
-export const isHideDragHandlerLine = (editor, displayType, table, cellPath, isDragOverCellHalf) => {
+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 = ReactEditor.toDOMNode(editor, table.children[rowIndex].children[cellIndex]);
-  let isCurrentCellSelected = currentCellDom.classList.contains(CELL_SELECTED);
+  let currentCellDom = _slateReact.ReactEditor.toDOMNode(editor, table.children[rowIndex].children[cellIndex]);
+  let isCurrentCellSelected = currentCellDom.classList.contains(_constants2.CELL_SELECTED);
   if (isCurrentCellSelected) return true;
   if (isDragOverCellHalf) {
-    if (displayType === DRAG_HANDLER_COLUMN) {
+    if (displayType === _constants2.DRAG_HANDLER_COLUMN) {
       cellIndex = cellIndex + 1;
     } else {
       rowIndex = rowIndex + 1;
     }
   }
-  const isEndOfRowOrColumn = displayType === DRAG_HANDLER_COLUMN && cellIndex === table.columns.length || displayType === DRAG_HANDLER_ROW && rowIndex === table.children.length;
+  const isEndOfRowOrColumn = displayType === _constants2.DRAG_HANDLER_COLUMN && cellIndex === table.columns.length || displayType === _constants2.DRAG_HANDLER_ROW && rowIndex === table.children.length;
   if (isEndOfRowOrColumn) return false;
   let preCellDom = null;
-  if (displayType === DRAG_HANDLER_COLUMN && cellIndex > 0) {
+  if (displayType === _constants2.DRAG_HANDLER_COLUMN && cellIndex > 0) {
     const prevCell = table.children[rowIndex].children[cellIndex - 1];
-    preCellDom = ReactEditor.toDOMNode(editor, prevCell);
+    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 => {
@@ -1800,9 +1866,9 @@ export const isHideDragHandlerLine = (editor, displayType, table, cellPath, isDr
       return (cell === null || cell === void 0 ? void 0 : cell.is_combined) === true;
     });
     if (beforeLineColumnHasCombined && afterLineColumnHasCombined) return true;
-  } else if (displayType === DRAG_HANDLER_ROW && rowIndex > 0) {
+  } else if (displayType === _constants2.DRAG_HANDLER_ROW && rowIndex > 0) {
     const prevCell = table.children[rowIndex - 1].children[cellIndex];
-    preCellDom = ReactEditor.toDOMNode(editor, prevCell);
+    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];
@@ -1813,16 +1879,16 @@ export const isHideDragHandlerLine = (editor, displayType, table, cellPath, isDr
   }
 
   // Check is above cell selected
-  currentCellDom = ReactEditor.toDOMNode(editor, table.children[rowIndex].children[cellIndex]);
-  isCurrentCellSelected = currentCellDom.classList.contains(CELL_SELECTED);
+  currentCellDom = _slateReact.ReactEditor.toDOMNode(editor, table.children[rowIndex].children[cellIndex]);
+  isCurrentCellSelected = currentCellDom.classList.contains(_constants2.CELL_SELECTED);
   if (isCurrentCellSelected) return true;
 
   // Check if the previous cell is selected
-  const isPrevCellSelected = preCellDom && preCellDom.classList.contains(CELL_SELECTED);
+  const isPrevCellSelected = preCellDom && preCellDom.classList.contains(_constants2.CELL_SELECTED);
   if (isPrevCellSelected) return true;
   let isCombined = false;
   // Check if the combined cell
-  if (displayType === DRAG_HANDLER_COLUMN) {
+  if (displayType === _constants2.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);
@@ -1830,12 +1896,13 @@ export const isHideDragHandlerLine = (editor, displayType, table, cellPath, isDr
   if (isCombined) return true;
 
   // Check is the last column
-  if (displayType === DRAG_HANDLER_COLUMN) {
+  if (displayType === _constants2.DRAG_HANDLER_COLUMN) {
     const isLastColumn = cellIndex === table.columns.length - 1;
     if (isLastColumn) return false;
   }
 };
-export const getTableRowSelectedRange = (table, rowIndex) => {
+exports.isHideDragHandlerLine = isHideDragHandlerLine;
+const getTableRowSelectedRange = (table, rowIndex) => {
   const row = table.children[rowIndex];
   const columnCount = row.children.length;
   let minRowIndex = rowIndex;
@@ -1877,7 +1944,8 @@ export const getTableRowSelectedRange = (table, rowIndex) => {
     maxColIndex
   };
 };
-export const getTableColumnSelectedRange = (table, columnIndex) => {
+exports.getTableRowSelectedRange = getTableRowSelectedRange;
+const getTableColumnSelectedRange = (table, columnIndex) => {
   let minRowIndex = 0;
   let maxRowIndex = table.children.length - 1;
   let minColIndex = columnIndex;
@@ -1917,11 +1985,12 @@ export const getTableColumnSelectedRange = (table, columnIndex) => {
     maxColIndex
   };
 };
-export const isTableWidthFitScreen = editor => {
+exports.getTableColumnSelectedRange = getTableColumnSelectedRange;
+const isTableWidthFitScreen = editor => {
   const {
     table
   } = getSelectedInfo(editor);
-  const tableNode = ReactEditor.toDOMNode(editor, table);
+  const tableNode = _slateReact.ReactEditor.toDOMNode(editor, table);
   if (!tableNode) return;
   const tableDom = tableNode.querySelector('.sdoc-table-scroll-wrapper');
   const {
@@ -1931,20 +2000,22 @@ export const isTableWidthFitScreen = editor => {
   if (tableWidth >= sdocWidth) return true;
   return false;
 };
-export const fitTableColumnToScreen = editor => {
+exports.isTableWidthFitScreen = isTableWidthFitScreen;
+const fitTableColumnToScreen = editor => {
   const {
     table,
     tablePath
   } = getSelectedInfo(editor);
   const colCount = table.columns.length;
-  const columnWidth = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colCount));
+  const columnWidth = Math.max(_constants2.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colCount));
   const columns = table.columns.map(column => ({
     ...column,
     width: columnWidth
   }));
-  Transforms.setNodes(editor, {
+  _slate.Transforms.setNodes(editor, {
     columns
   }, {
     at: tablePath
   });
-};
+};
+exports.fitTableColumnToScreen = fitTableColumnToScreen;