@seafile/sdoc-editor 0.3.6 → 0.3.7

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

@@ -1,8 +1,4 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import slugid from 'slugid';
 import { Editor, Range, Transforms, Point, Node } from '@seafile/slate';
 import { ReactEditor } from '@seafile/slate-react';
@@ -13,38 +9,38 @@ 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 var isTableMenuDisabled = function isTableMenuDisabled(editor, readonly) {
+export const isTableMenuDisabled = (editor, readonly) => {
   if (readonly) return true;
-  var selection = editor.selection;
+  const {
+    selection
+  } = editor;
   if (selection === null) return true;
   if (!Range.isCollapsed(selection)) return true;
-  var _Editor$nodes = Editor.nodes(editor, {
-      match: function match(n) {
-        var type = getNodeType(n);
-        if (!type && isTextNode(n) && n.id) {
-          var parentNode = getParentNode(editor.children, n.id);
-          type = getNodeType(parentNode);
-        }
-        if (type.startsWith('header')) 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 (Editor.isVoid(editor, n)) return true;
-        return false;
-      },
-      universal: true
-    }),
-    _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
-    match = _Editor$nodes2[0];
+  const [match] = 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);
+      }
+      if (type.startsWith('header')) 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 (Editor.isVoid(editor, n)) return true;
+      return false;
+    },
+    universal: true
+  });
   if (match) return true;
   return false;
 };
-export var generateTableCell = function generateTableCell() {
+export const generateTableCell = () => {
   return {
     id: slugid.nice(),
     type: ELEMENT_TYPE.TABLE_CELL,
@@ -54,17 +50,19 @@ export var generateTableCell = function generateTableCell() {
     }]
   };
 };
-export var generateTableRow = function generateTableRow(colsCount) {
-  var children = [];
-  for (var i = 0; i < colsCount; i++) {
-    var tableCell = generateTableCell();
+export const generateTableRow = colsCount => {
+  let children = [];
+  for (let i = 0; i < colsCount; i++) {
+    const tableCell = generateTableCell();
     children.push(tableCell);
   }
   return {
     id: slugid.nice(),
     type: ELEMENT_TYPE.TABLE_ROW,
     children: children,
-    style: _defineProperty({}, TABLE_ROW_STYLE.MIN_HEIGHT, TABLE_ROW_MIN_HEIGHT)
+    style: {
+      [TABLE_ROW_STYLE.MIN_HEIGHT]: TABLE_ROW_MIN_HEIGHT
+    }
   };
 };
 
@@ -75,22 +73,22 @@ export var generateTableRow = function generateTableRow(colsCount) {
  * @param {Boolean} tableProps.alternate_highlight - is alternate highlight
  * @param {string} tableProps.alternate_highlight_color - table alternate highlight color
  */
-export var generateEmptyTable = function generateEmptyTable(editor, tableProps) {
-  var _tableProps$size = tableProps.size,
-    size = _tableProps$size === void 0 ? [0, 0] : _tableProps$size,
-    _tableProps$alternate = tableProps.alternate_highlight,
-    alternate_highlight = _tableProps$alternate === void 0 ? false : _tableProps$alternate,
-    alternate_highlight_color = tableProps.alternate_highlight_color;
-  var rowsCount = size[0];
-  var colsCount = size[1];
-  var children = [];
-  for (var i = 0; i < rowsCount; i++) {
-    var tableRow = generateTableRow(colsCount);
+export 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(colsCount);
     children.push(tableRow);
   }
-  var columnWidth = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colsCount));
-  var columns = [];
-  for (var _i = 0; _i < colsCount; _i++) {
+  const columnWidth = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colsCount));
+  let columns = [];
+  for (let i = 0; i < colsCount; i++) {
     columns.push({
       width: columnWidth
     });
@@ -99,24 +97,24 @@ export var generateEmptyTable = function generateEmptyTable(editor, tableProps)
     id: slugid.nice(),
     type: ELEMENT_TYPE.TABLE,
     children: children,
-    columns: columns,
+    columns,
     style: {
-      alternate_highlight: alternate_highlight,
-      alternate_highlight_color: alternate_highlight_color
+      alternate_highlight,
+      alternate_highlight_color
     }
   };
 };
-export var insertTable = function insertTable(editor, size, selection) {
-  var position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : INSERT_POSITION.CURRENT;
+export const insertTable = function (editor, size, selection) {
+  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : INSERT_POSITION.CURRENT;
   if (!size) return;
   if (position !== INSERT_POSITION.AFTER) {
     if (isTableMenuDisabled(editor)) return;
   }
-  var tableNode = generateEmptyTable(editor, {
-    size: size
+  const tableNode = generateEmptyTable(editor, {
+    size
   });
-  var validSelection = selection || editor.selection;
-  var path = Editor.path(editor, validSelection);
+  const validSelection = selection || editor.selection;
+  const path = Editor.path(editor, validSelection);
   if (position === INSERT_POSITION.AFTER) {
     Transforms.insertNodes(editor, tableNode, {
       at: [path[0] + 1]
@@ -127,11 +125,11 @@ export var insertTable = function insertTable(editor, size, selection) {
     at: [path[0]]
   });
 };
-export var getSelectedInfo = function getSelectedInfo(editor) {
-  var currentTable = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
-  var currentRow = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE_ROW);
-  var currentCell = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE_CELL);
-  var currentCellPath = findPath(editor, currentCell);
+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);
   return {
     table: currentTable,
     tablePath: findPath(editor, currentTable),
@@ -144,33 +142,27 @@ export var getSelectedInfo = function getSelectedInfo(editor) {
     cellIndex: currentCellPath[currentCellPath.length - 1]
   };
 };
-export var isInTable = function isInTable(editor) {
-  var selectedNodes = getSelectedElems(editor);
-  if (!selectedNodes.some(function (node) {
-    return node.type === ELEMENT_TYPE.TABLE;
-  })) return false;
-  var firstSelectedNode = selectedNodes[0];
+export const isInTable = editor => {
+  const selectedNodes = getSelectedElems(editor);
+  if (!selectedNodes.some(node => node.type === ELEMENT_TYPE.TABLE)) return false;
+  const firstSelectedNode = selectedNodes[0];
   return firstSelectedNode.type === ELEMENT_TYPE.TABLE;
 };
-export var isAllInTable = function isAllInTable(editor) {
-  var selectedNodes = getSelectedElems(editor);
-  if (!selectedNodes.some(function (node) {
-    return node.type === ELEMENT_TYPE.TABLE;
-  })) return false;
-  var firstSelectedNode = selectedNodes[0];
+export const isAllInTable = editor => {
+  const selectedNodes = getSelectedElems(editor);
+  if (!selectedNodes.some(node => node.type === ELEMENT_TYPE.TABLE)) return false;
+  const firstSelectedNode = selectedNodes[0];
   if (firstSelectedNode.type !== ELEMENT_TYPE.TABLE) return false;
-  return selectedNodes.slice(1).every(function (node) {
-    return [ELEMENT_TYPE.TABLE_ROW, ELEMENT_TYPE.TABLE_CELL].includes(node.type);
-  }); // same table element
+  return selectedNodes.slice(1).every(node => [ELEMENT_TYPE.TABLE_ROW, ELEMENT_TYPE.TABLE_CELL].includes(node.type)); // same table element
 };
 
-export var setCellStyle = function setCellStyle(editor, style) {
+export const setCellStyle = (editor, style) => {
   if (ObjectUtils.isSameObject(editor.tableSelectedRange, EMPTY_SELECTED_RANGE)) {
-    var selectedNodes = getSelectedElems(editor);
-    var firstTableCellNodePath;
-    selectedNodes.forEach(function (node) {
+    const selectedNodes = getSelectedElems(editor);
+    let firstTableCellNodePath;
+    selectedNodes.forEach(node => {
       if (node.type === ELEMENT_TYPE.TABLE_CELL) {
-        var path = findPath(editor, node);
+        const path = findPath(editor, node);
         if (path) {
           firstTableCellNodePath = firstTableCellNodePath ? firstTableCellNodePath : path;
           Transforms.setNodes(editor, {
@@ -182,9 +174,9 @@ export var setCellStyle = function setCellStyle(editor, style) {
       }
     });
     if (firstTableCellNodePath) {
-      var start = Editor.start(editor, firstTableCellNodePath);
-      var end = Editor.end(editor, firstTableCellNodePath);
-      var newSelection = {
+      const start = Editor.start(editor, firstTableCellNodePath);
+      const end = Editor.end(editor, firstTableCellNodePath);
+      const newSelection = {
         anchor: start,
         focus: end
       };
@@ -192,17 +184,19 @@ export var setCellStyle = function setCellStyle(editor, style) {
     }
     return;
   }
-  var _editor$tableSelected = editor.tableSelectedRange,
-    minColIndex = _editor$tableSelected.minColIndex,
-    maxColIndex = _editor$tableSelected.maxColIndex,
-    minRowIndex = _editor$tableSelected.minRowIndex,
-    maxRowIndex = _editor$tableSelected.maxRowIndex;
-  var _getSelectedInfo = getSelectedInfo(editor),
-    tablePath = _getSelectedInfo.tablePath;
-  for (var i = minRowIndex; i <= maxRowIndex; i++) {
-    for (var j = minColIndex; j <= maxColIndex; j++) {
-      var path = [].concat(_toConsumableArray(tablePath), [i, j]);
-      var node = getNode(editor, path);
+  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 = getNode(editor, path);
       Transforms.setNodes(editor, {
         style: _objectSpread(_objectSpread({}, node.style), style)
       }, {
@@ -211,89 +205,91 @@ export var setCellStyle = function setCellStyle(editor, style) {
     }
   }
 };
-export var insertTableRow = function insertTableRow(editor, table, rowIndex) {
-  var position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TABLE_ELEMENT_POSITION.AFTER;
-  var tableRowCount = table.children.length;
+export const insertTableRow = function (editor, table, rowIndex) {
+  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TABLE_ELEMENT_POSITION.AFTER;
+  const tableRowCount = table.children.length;
   if (tableRowCount >= TABLE_MAX_ROWS) return;
-  var tableColumnCount = table.children[0].children.length;
-  var row = generateTableRow(tableColumnCount);
-  var tablePath = findPath(editor, table);
-  var targetPath = position === TABLE_ELEMENT_POSITION.AFTER ? [].concat(_toConsumableArray(tablePath), [rowIndex + 1]) : [].concat(_toConsumableArray(tablePath), [rowIndex]);
+  const tableColumnCount = table.children[0].children.length;
+  const row = generateTableRow(tableColumnCount);
+  const tablePath = findPath(editor, table);
+  const targetPath = position === TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
   Transforms.insertNodes(editor, row, {
     at: targetPath
   });
-  var focusPath = [].concat(_toConsumableArray(targetPath), [0]);
+  const focusPath = [...targetPath, 0];
   focusEditor(editor, focusPath);
 };
-export var insertTableColumn = function insertTableColumn(editor, table, columnIndex) {
-  var position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TABLE_ELEMENT_POSITION.AFTER;
-  var tableColumnCount = table.children[0].children.length;
+export const insertTableColumn = function (editor, table, columnIndex) {
+  let position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TABLE_ELEMENT_POSITION.AFTER;
+  const tableColumnCount = table.children[0].children.length;
   if (tableColumnCount >= TABLE_MAX_COLUMNS) return;
-  var newCellIndex = position === TABLE_ELEMENT_POSITION.AFTER ? columnIndex + 1 : columnIndex;
-  var newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, 1);
+  const newCellIndex = position === TABLE_ELEMENT_POSITION.AFTER ? columnIndex + 1 : columnIndex;
+  const newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, 1);
   updateColumnWidth(editor, table, newColumns);
-  var tablePath = findPath(editor, table);
-  var tableRowCount = table.children.length;
-  for (var i = 0; i < tableRowCount; i++) {
-    var newCellPath = [].concat(_toConsumableArray(tablePath), [i, newCellIndex]);
-    var newCell = generateTableCell();
+  const tablePath = findPath(editor, table);
+  const tableRowCount = table.children.length;
+  for (let i = 0; i < tableRowCount; i++) {
+    const newCellPath = [...tablePath, i, newCellIndex];
+    const newCell = generateTableCell();
     Transforms.insertNodes(editor, newCell, {
       at: newCellPath
     });
   }
-  var focusPath = [].concat(_toConsumableArray(tablePath), [0, newCellIndex, 0]);
+  const focusPath = [...tablePath, 0, newCellIndex, 0];
   focusEditor(editor, focusPath);
 };
-export var insertTableElement = function insertTableElement(editor, type) {
-  var position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : TABLE_ELEMENT_POSITION.AFTER;
-  var count = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-  var _getSelectedInfo2 = getSelectedInfo(editor),
-    table = _getSelectedInfo2.table,
-    tablePath = _getSelectedInfo2.tablePath,
-    tableSize = _getSelectedInfo2.tableSize,
-    rowIndex = _getSelectedInfo2.rowIndex,
-    cellIndex = _getSelectedInfo2.cellIndex;
-  var eventBus = EventBus.getInstance();
+export const insertTableElement = function (editor, type) {
+  let position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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.getInstance();
   eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
   if (type === TABLE_ELEMENT.ROW) {
     if (tableSize[0] >= TABLE_MAX_ROWS) return;
-    var targetPath = position === TABLE_ELEMENT_POSITION.AFTER ? [].concat(_toConsumableArray(tablePath), [rowIndex + 1]) : [].concat(_toConsumableArray(tablePath), [rowIndex]);
-    var validCount = Math.min(TABLE_MAX_ROWS - tableSize[0], count);
-    for (var i = 0; i < validCount; i++) {
-      var row = generateTableRow(tableSize[1]);
+    const targetPath = position === TABLE_ELEMENT_POSITION.AFTER ? [...tablePath, rowIndex + 1] : [...tablePath, rowIndex];
+    const validCount = Math.min(TABLE_MAX_ROWS - tableSize[0], count);
+    for (let i = 0; i < validCount; i++) {
+      const row = generateTableRow(tableSize[1]);
       Transforms.insertNodes(editor, row, {
         at: targetPath
       });
     }
-    var focusPath = [].concat(_toConsumableArray(targetPath), [cellIndex]);
+    const focusPath = [...targetPath, cellIndex];
     focusEditor(editor, focusPath);
     return;
   }
   if (type === TABLE_ELEMENT.COLUMN) {
     if (tableSize[1] >= TABLE_MAX_COLUMNS) return;
-    var newCellIndex = position === TABLE_ELEMENT_POSITION.AFTER ? cellIndex + 1 : cellIndex;
-    var _validCount = Math.min(TABLE_MAX_COLUMNS - tableSize[1], count);
-    var newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, _validCount);
+    const newCellIndex = position === TABLE_ELEMENT_POSITION.AFTER ? cellIndex + 1 : cellIndex;
+    const validCount = Math.min(TABLE_MAX_COLUMNS - tableSize[1], count);
+    const newColumns = getTableColumnsAfterInsertColumn(editor, table, newCellIndex, validCount);
     updateColumnWidth(editor, table, newColumns);
-    for (var j = 0; j < _validCount; j++) {
-      for (var _i2 = 0; _i2 < tableSize[0]; _i2++) {
-        var newCellPath = [].concat(_toConsumableArray(tablePath), [_i2, newCellIndex]);
-        var newCell = generateTableCell();
+    for (let j = 0; j < validCount; j++) {
+      for (let i = 0; i < tableSize[0]; i++) {
+        const newCellPath = [...tablePath, i, newCellIndex];
+        const newCell = generateTableCell();
         Transforms.insertNodes(editor, newCell, {
           at: newCellPath
         });
       }
     }
-    var _focusPath = [].concat(_toConsumableArray(tablePath), [rowIndex, cellIndex + 1, 0]);
-    focusEditor(editor, _focusPath);
+    const focusPath = [...tablePath, rowIndex, cellIndex + 1, 0];
+    focusEditor(editor, focusPath);
     return;
   }
 };
-export var removeTable = function removeTable(editor, path) {
-  var validPath = path;
+export const removeTable = (editor, path) => {
+  let validPath = path;
   if (!validPath) {
-    var _getSelectedInfo3 = getSelectedInfo(editor),
-      tablePath = _getSelectedInfo3.tablePath;
+    const {
+      tablePath
+    } = getSelectedInfo(editor);
     validPath = tablePath;
   }
   editor.reSetTableSelectedRange();
@@ -301,15 +297,16 @@ export var removeTable = function removeTable(editor, path) {
     at: validPath
   });
 };
-export var removeTableElement = function removeTableElement(editor, type) {
-  var _getSelectedInfo4 = getSelectedInfo(editor),
-    table = _getSelectedInfo4.table,
-    tablePath = _getSelectedInfo4.tablePath,
-    tableSize = _getSelectedInfo4.tableSize,
-    rowPath = _getSelectedInfo4.rowPath,
-    rowIndex = _getSelectedInfo4.rowIndex,
-    cellIndex = _getSelectedInfo4.cellIndex;
-  var eventBus = EventBus.getInstance();
+export const removeTableElement = (editor, type) => {
+  const {
+    table,
+    tablePath,
+    tableSize,
+    rowPath,
+    rowIndex,
+    cellIndex
+  } = getSelectedInfo(editor);
+  const eventBus = EventBus.getInstance();
   eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
   if (type === TABLE_ELEMENT.TABLE) {
     removeTable(editor, tablePath);
@@ -321,27 +318,28 @@ export var removeTableElement = function removeTableElement(editor, type) {
       return;
     }
     if (!ObjectUtils.isSameObject(editor.tableSelectedRange, EMPTY_SELECTED_RANGE)) {
-      var _editor$tableSelected2 = editor.tableSelectedRange,
-        minRowIndex = _editor$tableSelected2.minRowIndex,
-        maxRowIndex = _editor$tableSelected2.maxRowIndex;
+      const {
+        minRowIndex,
+        maxRowIndex
+      } = editor.tableSelectedRange;
       if (minRowIndex === 0 && maxRowIndex === tableSize[0] - 1) {
         removeTable(editor, tablePath);
         return;
       }
-      for (var i = minRowIndex; i <= maxRowIndex; i++) {
+      for (let i = minRowIndex; i <= maxRowIndex; i++) {
         Transforms.removeNodes(editor, {
-          at: [].concat(_toConsumableArray(tablePath), [minRowIndex])
+          at: [...tablePath, minRowIndex]
         });
       }
-      var _focusPath2 = [].concat(_toConsumableArray(tablePath), [minRowIndex === 0 ? 0 : minRowIndex - 1, cellIndex]);
-      focusEditor(editor, _focusPath2);
+      const focusPath = [...tablePath, minRowIndex === 0 ? 0 : minRowIndex - 1, cellIndex];
+      focusEditor(editor, focusPath);
       return;
     }
     Transforms.removeNodes(editor, {
       at: rowPath
     });
-    var focusRowIndex = rowIndex === tableSize[0] - 1 ? rowIndex - 1 : rowIndex;
-    var focusPath = [].concat(_toConsumableArray(tablePath), [focusRowIndex, cellIndex]);
+    const focusRowIndex = rowIndex === tableSize[0] - 1 ? rowIndex - 1 : rowIndex;
+    const focusPath = [...tablePath, focusRowIndex, cellIndex];
     focusEditor(editor, focusPath);
     return;
   }
@@ -351,89 +349,91 @@ export var removeTableElement = function removeTableElement(editor, type) {
       return;
     }
     if (!ObjectUtils.isSameObject(editor.tableSelectedRange, EMPTY_SELECTED_RANGE)) {
-      var _editor$tableSelected3 = editor.tableSelectedRange,
-        minColIndex = _editor$tableSelected3.minColIndex,
-        maxColIndex = _editor$tableSelected3.maxColIndex;
+      const {
+        minColIndex,
+        maxColIndex
+      } = editor.tableSelectedRange;
       if (minColIndex === 0 && maxColIndex === tableSize[1] - 1) {
         removeTable(editor, tablePath);
         return;
       }
-      var _columns = getTableColumns(editor, table);
-      var _newColumns = [].concat(_toConsumableArray(_columns.slice(0, minColIndex)), _toConsumableArray(_columns.slice(maxColIndex + 1)));
-      updateColumnWidth(editor, table, _newColumns);
-      for (var _i3 = 0; _i3 < tableSize[0]; _i3++) {
-        for (var j = minColIndex; j <= maxColIndex; j++) {
+      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
-          var cellPath = [].concat(_toConsumableArray(tablePath), [_i3, minColIndex]);
+          const cellPath = [...tablePath, i, minColIndex];
           Transforms.removeNodes(editor, {
             at: cellPath
           });
         }
       }
-      var _focusPath3 = [].concat(_toConsumableArray(tablePath), [rowIndex, minColIndex === 0 ? 0 : minColIndex - 1]);
-      focusEditor(editor, _focusPath3);
+      const focusPath = [...tablePath, rowIndex, minColIndex === 0 ? 0 : minColIndex - 1];
+      focusEditor(editor, focusPath);
       return;
     }
-    var columns = getTableColumns(editor, table);
-    var newColumns = columns.slice(0);
+    const columns = getTableColumns(editor, table);
+    const newColumns = columns.slice(0);
     newColumns.splice(cellIndex, 1);
     updateColumnWidth(editor, table, newColumns);
-    for (var _i4 = 0; _i4 < tableSize[0]; _i4++) {
-      var _cellPath = [].concat(_toConsumableArray(tablePath), [_i4, cellIndex]);
+    for (let i = 0; i < tableSize[0]; i++) {
+      const cellPath = [...tablePath, i, cellIndex];
       Transforms.removeNodes(editor, {
-        at: _cellPath
+        at: cellPath
       });
     }
-    var focusCellIndex = cellIndex === tableSize[1] - 1 ? cellIndex - 1 : cellIndex;
-    var _focusPath4 = [].concat(_toConsumableArray(tablePath), [rowIndex, focusCellIndex]);
-    focusEditor(editor, _focusPath4);
+    const focusCellIndex = cellIndex === tableSize[1] - 1 ? cellIndex - 1 : cellIndex;
+    const focusPath = [...tablePath, rowIndex, focusCellIndex];
+    focusEditor(editor, focusPath);
     return;
   }
 };
-export var setTableSelectedRange = function setTableSelectedRange(editor, range) {
+export const setTableSelectedRange = (editor, range) => {
   if (range) {
     editor.tableSelectedRange = range;
     return;
   }
   editor.tableSelectedRange = EMPTY_SELECTED_RANGE;
 };
-export var updateTableRowHeight = function updateTableRowHeight(editor, element, rowHeight) {
-  var path = findPath(editor, element);
-  var targetNode = getNode(editor, path);
-  var _targetNode$style = targetNode.style,
-    style = _targetNode$style === void 0 ? {} : _targetNode$style;
+export const updateTableRowHeight = (editor, element, rowHeight) => {
+  const path = findPath(editor, element);
+  const targetNode = getNode(editor, path);
+  const {
+    style = {}
+  } = targetNode;
   if (style[TABLE_ROW_STYLE.MIN_HEIGHT] === rowHeight) return;
   Transforms.setNodes(editor, {
-    style: _objectSpread(_objectSpread({}, style), {}, _defineProperty({}, TABLE_ROW_STYLE.MIN_HEIGHT, rowHeight))
+    style: _objectSpread(_objectSpread({}, style), {}, {
+      [TABLE_ROW_STYLE.MIN_HEIGHT]: rowHeight
+    })
   }, {
     at: path
   });
 };
-export var updateColumnWidth = function updateColumnWidth(editor, element, columns) {
-  var path = findPath(editor, element);
+export const updateColumnWidth = (editor, element, columns) => {
+  const path = findPath(editor, element);
   Transforms.setNodes(editor, {
     columns: columns
   }, {
     at: path
   });
 };
-export var getTableColumnsWidth = function getTableColumnsWidth() {
-  var columns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+export 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(function (pre, cur) {
-    return pre + cur.width;
-  }, 0);
-};
-export var getTableColumnsAfterInsertColumn = function getTableColumnsAfterInsertColumn(editor, element, targetColumnIndex, insertColumnCount) {
-  var columns = getTableColumns(editor, element);
-  var newColumns = columns.slice(0);
-  var totalColumnsWidth = getTableColumnsWidth(columns);
-  var targetColumn = columns[targetColumnIndex] || columns[targetColumnIndex - 1];
-  var targetInsertColumnsWidth = targetColumn.width * insertColumnCount;
+  return columns.reduce((pre, cur) => pre + cur.width, 0);
+};
+export 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 (var i = 0; i < insertColumnCount; i++) {
+    for (let i = 0; i < insertColumnCount; i++) {
       newColumns.splice(targetColumnIndex, 0, targetColumn);
     }
     return newColumns;
@@ -442,61 +442,64 @@ export var getTableColumnsAfterInsertColumn = function getTableColumnsAfterInser
   // Not currently scrolling
   // It is not a scroll state after inserting a new column
   if (totalColumnsWidth + targetInsertColumnsWidth < editor.width) {
-    for (var _i5 = 0; _i5 < insertColumnCount; _i5++) {
+    for (let i = 0; i < insertColumnCount; i++) {
       newColumns.push(targetColumn);
     }
     return newColumns;
   }
 
   // After inserting a new column is a scrolling state
-  for (var _i6 = 0; _i6 < insertColumnCount; _i6++) {
+  for (let i = 0; i < insertColumnCount; i++) {
     totalColumnsWidth += targetColumn.width;
     newColumns.splice(targetColumnIndex, 0, targetColumn);
   }
-  var proportion = totalColumnsWidth / (editor.width - 1);
-  return newColumns.map(function (column) {
+  const proportion = totalColumnsWidth / (editor.width - 1);
+  return newColumns.map(column => {
     return _objectSpread(_objectSpread({}, column), {}, {
       width: Math.max(parseInt(column.width / proportion), TABLE_CELL_MIN_WIDTH)
     });
   });
 };
-export var getTableColumns = function getTableColumns(editor, element) {
+export const getTableColumns = (editor, element) => {
   if (!element) return [];
-  var tableElement = element;
+  let tableElement = element;
   if (element.type === ELEMENT_TYPE.TABLE_CELL) {
-    var cellPath = findPath(editor, element);
-    var tablePath = cellPath.slice(0, -2);
+    const cellPath = findPath(editor, element);
+    const tablePath = cellPath.slice(0, -2);
     tableElement = getNode(editor, tablePath);
   }
-  var _tableElement = tableElement,
-    columns = _tableElement.columns,
-    children = _tableElement.children;
+  const {
+    columns,
+    children
+  } = tableElement;
   if (columns) return columns;
-  var columnsCount = children[0].children.length;
-  var initColumns = [];
-  var pageEditAreaWidth = editor.width || PAGE_EDIT_AREA_WIDTH;
-  for (var i = 0; i < columnsCount; i++) {
-    var column = {
+  const columnsCount = children[0].children.length;
+  let initColumns = [];
+  const pageEditAreaWidth = editor.width || PAGE_EDIT_AREA_WIDTH;
+  for (let i = 0; i < columnsCount; i++) {
+    const column = {
       width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
     };
     initColumns.push(column);
   }
   return initColumns;
 };
-export var getCellColumn = function getCellColumn(editor, cellElement) {
-  var column = {
+export const getCellColumn = (editor, cellElement) => {
+  let column = {
     width: TABLE_CELL_MIN_WIDTH
   };
   if (!editor || !cellElement) return column;
-  var cellPath = findPath(editor, cellElement);
+  const cellPath = findPath(editor, cellElement);
   if (!cellPath) return column;
-  var pathLength = cellPath.length;
-  var cellIndex = cellPath[pathLength - 1];
-  var tablePath = cellPath.slice(0, -2);
-  var tableElement = getNode(editor, tablePath);
-  var columns = tableElement.columns;
-  var columnsCount = tableElement.children[0].children.length;
-  var pageEditAreaWidth = editor.width || PAGE_EDIT_AREA_WIDTH;
+  const pathLength = cellPath.length;
+  const cellIndex = cellPath[pathLength - 1];
+  const tablePath = cellPath.slice(0, -2);
+  const tableElement = getNode(editor, tablePath);
+  const {
+    columns
+  } = tableElement;
+  const columnsCount = tableElement.children[0].children.length;
+  const pageEditAreaWidth = editor.width || PAGE_EDIT_AREA_WIDTH;
   if (columns) {
     column = columns[cellIndex];
   }
@@ -504,17 +507,17 @@ export var getCellColumn = function getCellColumn(editor, cellElement) {
     width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(pageEditAreaWidth / columnsCount))
   };
 };
-export var getFirstTableCell = function getFirstTableCell(element) {
-  var tableCellElement = element;
+export const getFirstTableCell = element => {
+  let tableCellElement = element;
   while (tableCellElement && !(tableCellElement.hasAttribute('row-index') && tableCellElement.hasAttribute('cell-index'))) {
     tableCellElement = tableCellElement.parentNode;
   }
   return tableCellElement;
 };
-export var elementHasImage = function elementHasImage(element) {
+export const elementHasImage = element => {
   if (!element) return false;
   if (!Array.isArray(element.children) || element.children.length === 0) return false;
-  return element.children.some(function (child) {
+  return element.children.some(child => {
     if (child.type === ELEMENT_TYPE.IMAGE) return true;
     if (ObjectUtils.hasProperty(child, 'children')) {
       return elementHasImage(child);
@@ -522,9 +525,10 @@ export var elementHasImage = function elementHasImage(element) {
     return false;
   });
 };
-export var isSelectedAllCell = function isSelectedAllCell(editor) {
-  var _getSelectedInfo5 = getSelectedInfo(editor),
-    tableSize = _getSelectedInfo5.tableSize;
+export const isSelectedAllCell = editor => {
+  const {
+    tableSize
+  } = getSelectedInfo(editor);
   return ObjectUtils.isSameObject(editor.tableSelectedRange, {
     minColIndex: 0,
     maxColIndex: tableSize[1] - 1,
@@ -532,109 +536,118 @@ export var isSelectedAllCell = function isSelectedAllCell(editor) {
     maxRowIndex: tableSize[0] - 1
   });
 };
-export var insertMultipleRowsAndColumns = function insertMultipleRowsAndColumns(editor, rows, columns) {
-  var _getSelectedInfo6 = getSelectedInfo(editor),
-    table = _getSelectedInfo6.table,
-    tablePath = _getSelectedInfo6.tablePath,
-    tableSize = _getSelectedInfo6.tableSize,
-    rowIndex = _getSelectedInfo6.rowIndex,
-    cellIndex = _getSelectedInfo6.cellIndex;
-  var eventBus = EventBus.getInstance();
+export const insertMultipleRowsAndColumns = (editor, rows, columns) => {
+  const {
+    table,
+    tablePath,
+    tableSize,
+    rowIndex,
+    cellIndex
+  } = getSelectedInfo(editor);
+  const eventBus = EventBus.getInstance();
   eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
-  var insertRows = rows.slice(tableSize[0] - rowIndex);
-  var insertColumns = columns.slice(tableSize[1] - cellIndex);
-  var validInsertRows = insertRows.slice(0, Math.min(TABLE_MAX_ROWS - tableSize[0], insertRows.length));
-  var validInsertColumns = insertColumns.slice(0, Math.min(TABLE_MAX_COLUMNS - tableSize[1], columns.length));
-  for (var i = 0; i < validInsertRows.length; i++) {
-    var insertRow = validInsertRows[i];
-    var row = generateTableRow(tableSize[1]);
+  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));
+  for (let i = 0; i < validInsertRows.length; i++) {
+    const insertRow = validInsertRows[i];
+    const row = generateTableRow(tableSize[1]);
     row.style = insertRow.style;
     Transforms.insertNodes(editor, row, {
-      at: [].concat(_toConsumableArray(tablePath), [tableSize[0] + i])
+      at: [...tablePath, tableSize[0] + i]
     });
   }
   if (validInsertColumns.length > 0) {
-    updateColumnWidth(editor, table, [].concat(_toConsumableArray(table.columns), _toConsumableArray(validInsertColumns)));
+    updateColumnWidth(editor, table, [...table.columns, ...validInsertColumns]);
   }
-  for (var j = 0; j < validInsertColumns.length; j++) {
-    for (var _i7 = 0; _i7 < tableSize[0] + validInsertRows.length; _i7++) {
-      var newCellPath = [].concat(_toConsumableArray(tablePath), [_i7, tableSize[1] - 1]);
-      var newCell = generateTableCell();
+  for (let j = 0; j < validInsertColumns.length; j++) {
+    for (let i = 0; i < tableSize[0] + validInsertRows.length; i++) {
+      const newCellPath = [...tablePath, i, tableSize[1] - 1];
+      const newCell = generateTableCell();
       Transforms.insertNodes(editor, newCell, {
         at: newCellPath
       });
     }
   }
-  for (var _i8 = rowIndex; _i8 < Math.min(TABLE_MAX_ROWS, rowIndex + rows.length); _i8++) {
-    var _row = rows[_i8 - rowIndex];
-    var cells = _row.children;
-    for (var _j = cellIndex; _j < Math.min(TABLE_MAX_COLUMNS, cellIndex + columns.length); _j++) {
-      var replaceCellIndex = _j - cellIndex;
-      var replaceCell = cells[replaceCellIndex];
+  for (let i = rowIndex; i < Math.min(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++) {
+      const replaceCellIndex = j - cellIndex;
+      const replaceCell = cells[replaceCellIndex];
       replaceNodeChildren(editor, {
-        at: [].concat(_toConsumableArray(tablePath), [_i8, _j]),
+        at: [...tablePath, i, j],
         nodes: replacePastedDataId(replaceCell.children)
       });
     }
   }
-  focusEditor(editor, [].concat(_toConsumableArray(tablePath), [rowIndex, cellIndex, 0]));
-  var newFocus = editor.selection.focus;
+  focusEditor(editor, [...tablePath, rowIndex, cellIndex, 0]);
+  const {
+    focus: newFocus
+  } = editor.selection;
   Transforms.select(editor, {
     focus: newFocus,
     anchor: newFocus
   });
   return;
 };
-export var setTableFragmentData = function setTableFragmentData(editor, dataTransfer) {
-  var selectedNode = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
-  var fragment = editor.getFragment();
-  var string = JSON.stringify(fragment);
-  var encoded = window.btoa(encodeURIComponent(string));
+export const setTableFragmentData = (editor, dataTransfer) => {
+  const selectedNode = getSelectedNodeByType(editor, 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);
-  var tableDom = document.createElement('table');
-  var _editor$tableSelected4 = editor.tableSelectedRange,
-    minColIndex = _editor$tableSelected4.minColIndex,
-    maxColIndex = _editor$tableSelected4.maxColIndex,
-    minRowIndex = _editor$tableSelected4.minRowIndex,
-    maxRowIndex = _editor$tableSelected4.maxRowIndex;
-  var tablePath = findPath(editor, selectedNode);
-  for (var i = minRowIndex; i <= maxRowIndex; i++) {
-    var tr = document.createElement('tr');
-    for (var j = minColIndex; j <= maxColIndex; j++) {
-      var path = [].concat(_toConsumableArray(tablePath), [i, j]);
-      var node = getNode(editor, path);
-      var td = document.createElement('td');
-      var _div = document.createElement('div');
-      _div.innerHTML = ReactEditor.toDOMNode(editor, node).innerHTML;
-      td.appendChild(_div);
+  const tableDom = document.createElement('table');
+  const {
+    minColIndex,
+    maxColIndex,
+    minRowIndex,
+    maxRowIndex
+  } = editor.tableSelectedRange;
+  const tablePath = 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 td = document.createElement('td');
+      const div = document.createElement('div');
+      div.innerHTML = ReactEditor.toDOMNode(editor, node).innerHTML;
+      td.appendChild(div);
       tr.appendChild(td);
     }
     tableDom.appendChild(tr);
   }
   tableDom.setAttribute('data-slate-fragment', encoded);
-  var div = document.createElement('div');
+  const div = document.createElement('div');
   div.appendChild(tableDom);
   dataTransfer.setData('text/html', div.innerHTML);
   dataTransfer.setData('text/plain', div.innerText);
   return dataTransfer;
 };
-export var deleteTableRangeData = function deleteTableRangeData(editor) {
-  var tableSelectedRange = editor.tableSelectedRange;
-  var minRowIndex = tableSelectedRange.minRowIndex,
-    maxRowIndex = tableSelectedRange.maxRowIndex,
-    minColIndex = tableSelectedRange.minColIndex,
-    maxColIndex = tableSelectedRange.maxColIndex;
-  var _getSelectedInfo7 = getSelectedInfo(editor),
-    tablePath = _getSelectedInfo7.tablePath;
-  var forceCellPath;
-  for (var i = minRowIndex; i <= maxRowIndex; i++) {
-    for (var j = minColIndex; j <= maxColIndex; j++) {
-      var path = [].concat(_toConsumableArray(tablePath), [i, j]);
-      var node = getNode(editor, path);
+export 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 = getNode(editor, path);
       if (!forceCellPath && (Node.string(node) || elementHasImage(node))) {
         forceCellPath = path;
       }
-      var firstNode = node.children[0];
+      const firstNode = node.children[0];
       replaceNodeChildren(editor, {
         at: path,
         nodes: _objectSpread(_objectSpread({}, firstNode), {}, {
@@ -645,116 +658,116 @@ export var deleteTableRangeData = function deleteTableRangeData(editor) {
   }
   if (forceCellPath) {
     editor.tableSelectedRange = EMPTY_SELECTED_RANGE;
-    var eventBus = EventBus.getInstance();
+    const eventBus = EventBus.getInstance();
     eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
     focusEditor(editor, forceCellPath);
-    var newFocus = editor.selection.focus;
+    const {
+      focus: newFocus
+    } = editor.selection;
     Transforms.select(editor, {
       focus: newFocus,
       anchor: newFocus
     });
   }
 };
-export var deleteHandler = function deleteHandler(editor) {
-  var selection = editor.selection,
-    tableSelectedRange = editor.tableSelectedRange;
+export const deleteHandler = editor => {
+  const {
+    selection,
+    tableSelectedRange
+  } = editor;
   if (selection == null) return '';
   if (!ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
     if (isSelectedAllCell(editor)) return 'table';
     return 'range';
   }
-  var _Editor$nodes3 = Editor.nodes(editor, {
-      match: function match(n) {
-        var type = getNodeType(n);
-        if (!type && isTextNode(n) && n.id) {
-          var parentNode = getParentNode(editor.children, n.id);
-          type = getNodeType(parentNode);
-        }
-        return type === ELEMENT_TYPE.TABLE_CELL;
+  const [cellNodeEntry] = 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);
       }
-    }),
-    _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1),
-    cellNodeEntry = _Editor$nodes4[0];
+      return type === ELEMENT_TYPE.TABLE_CELL;
+    }
+  });
   if (cellNodeEntry) {
-    var _cellNodeEntry = _slicedToArray(cellNodeEntry, 2),
-      cellPath = _cellNodeEntry[1];
-    var start = Editor.start(editor, cellPath);
+    const [, cellPath] = cellNodeEntry;
+    const start = Editor.start(editor, cellPath);
     if (Point.equals(selection.anchor, start)) {
       return 'default';
     }
   }
   return '';
 };
-export var isTableLocation = function isTableLocation(editor, location) {
-  var tables = Editor.nodes(editor, {
+export const isTableLocation = (editor, location) => {
+  const tables = Editor.nodes(editor, {
     at: location,
-    match: function match(n) {
-      var type = getNodeType(n);
+    match: n => {
+      let type = getNodeType(n);
       if (!type && isTextNode(n) && n.id) {
-        var parentNode = getParentNode(editor.children, n.id);
+        const parentNode = getParentNode(editor.children, n.id);
         type = getNodeType(parentNode);
       }
       return type === ELEMENT_TYPE.TABLE_CELL;
     }
   });
-  var hasTable = false;
+  let hasTable = false;
   // eslint-disable-next-line no-unused-vars
-  var _iterator = _createForOfIteratorHelper(tables),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var table = _step.value;
-      hasTable = true;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  for (const table of tables) {
+    hasTable = true;
   }
   return hasTable;
 };
-export var isCursorAtCellEnd = function isCursorAtCellEnd(cell) {
-  var cursor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+export const isCursorAtCellEnd = function (cell) {
+  let cursor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
   if (!cell) return false;
-  var childrenCount = cell.children.length;
-  var lastChildren = cell.children[childrenCount - 1];
-  var textCount = lastChildren.text.length;
+  const childrenCount = cell.children.length;
+  const lastChildren = cell.children[childrenCount - 1];
+  const textCount = lastChildren.text.length;
   return cursor === textCount;
 };
-export var isCursorAtCellStart = function isCursorAtCellStart() {
-  var cursor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+export const isCursorAtCellStart = function () {
+  let cursor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
   return cursor === 0;
 };
-export var focusCell = function focusCell(editor, event) {
-  var keyboardName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
-  var _getSelectedInfo8 = getSelectedInfo(editor),
-    tableSize = _getSelectedInfo8.tableSize,
-    tablePath = _getSelectedInfo8.tablePath,
-    rowIndex = _getSelectedInfo8.rowIndex,
-    cellIndex = _getSelectedInfo8.cellIndex,
-    cell = _getSelectedInfo8.cell;
-  var tableParentPath = tablePath.slice(0, -1);
-  var tableIndex = tablePath[tablePath.length - 1];
-  var selection = editor.selection;
-  var focus = selection.focus;
+export 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 === KEYBOARD.UP) {
     if (!isCursorAtCellStart(focus.offset)) {
-      setTimeout(function () {
+      setTimeout(() => {
         if (getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE)) {
-          var _getSelectedInfo9 = getSelectedInfo(editor),
-            newCellIndex = _getSelectedInfo9.cellIndex;
+          const {
+            cellIndex: newCellIndex
+          } = getSelectedInfo(editor);
           if (Math.abs(newCellIndex - cellIndex) !== 0) {
             if (rowIndex === 0) {
               if (tableIndex !== 0) {
-                focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex - 1]));
+                focusEditor(editor, [...tableParentPath, tableIndex - 1]);
               }
               return;
             }
-            focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex - 1, cellIndex]));
-            var _newFocus = editor.selection.focus;
+            focusEditor(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
+            const {
+              focus: newFocus
+            } = editor.selection;
             Transforms.select(editor, {
-              focus: _newFocus,
-              anchor: _newFocus
+              focus: newFocus,
+              anchor: newFocus
             });
           }
         }
@@ -764,12 +777,14 @@ export var focusCell = function focusCell(editor, event) {
     event.preventDefault();
     if (rowIndex === 0) {
       if (tableIndex !== 0) {
-        focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex - 1]));
+        focusEditor(editor, [...tableParentPath, tableIndex - 1]);
       }
       return;
     }
-    focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex - 1, cellIndex]));
-    var newFocus = editor.selection.focus;
+    focusEditor(editor, [...tableParentPath, tableIndex, rowIndex - 1, cellIndex]);
+    const {
+      focus: newFocus
+    } = editor.selection;
     Transforms.select(editor, {
       focus: newFocus,
       anchor: newFocus
@@ -779,15 +794,17 @@ export var focusCell = function focusCell(editor, event) {
     if (!isCursorAtCellEnd(cell, focus.offset)) return;
     event.preventDefault();
     if (rowIndex === tableSize[0] - 1 && cellIndex === tableSize[1] - 1) {
-      focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex + 1]));
+      focusEditor(editor, [...tableParentPath, tableIndex + 1]);
       return;
     }
     if (cellIndex === tableSize[1] - 1) {
-      focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex + 1, 0]));
+      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex + 1, 0]);
     } else {
-      focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex, cellIndex + 1]));
+      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex + 1]);
     }
-    var newAnchor = editor.selection.anchor;
+    const {
+      anchor: newAnchor
+    } = editor.selection;
     Transforms.select(editor, {
       focus: newAnchor,
       anchor: newAnchor
@@ -795,22 +812,25 @@ export var focusCell = function focusCell(editor, event) {
   }
   if (keyboardName === KEYBOARD.DOWN) {
     if (!isCursorAtCellEnd(cell, focus.offset)) {
-      setTimeout(function () {
+      setTimeout(() => {
         if (getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE)) {
-          var _getSelectedInfo10 = getSelectedInfo(editor),
-            newCellIndex = _getSelectedInfo10.cellIndex;
+          const {
+            cellIndex: newCellIndex
+          } = getSelectedInfo(editor);
           if (Math.abs(newCellIndex - cellIndex) !== 0) {
             if (rowIndex === tableSize[0] - 1) {
-              var nextNode = getNode(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex + 1]));
+              const nextNode = getNode(editor, [...tableParentPath, tableIndex + 1]);
               if (!nextNode) return;
-              focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex + 1]));
+              focusEditor(editor, [...tableParentPath, tableIndex + 1]);
               return;
             }
-            focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex + 1, cellIndex]));
-            var _newAnchor = editor.selection.anchor;
+            focusEditor(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
+            const {
+              anchor: newAnchor
+            } = editor.selection;
             Transforms.select(editor, {
-              focus: _newAnchor,
-              anchor: _newAnchor
+              focus: newAnchor,
+              anchor: newAnchor
             });
           }
         }
@@ -819,16 +839,18 @@ export var focusCell = function focusCell(editor, event) {
     }
     event.preventDefault();
     if (rowIndex === tableSize[0] - 1) {
-      var nextNode = getNode([].concat(_toConsumableArray(tableParentPath), [tableIndex + 1]));
+      const nextNode = getNode([...tableParentPath, tableIndex + 1]);
       if (!nextNode) return;
-      focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex + 1]));
+      focusEditor(editor, [...tableParentPath, tableIndex + 1]);
       return;
     }
-    focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex + 1, cellIndex]));
-    var _newAnchor2 = editor.selection.anchor;
+    focusEditor(editor, [...tableParentPath, tableIndex, rowIndex + 1, cellIndex]);
+    const {
+      anchor: newAnchor
+    } = editor.selection;
     Transforms.select(editor, {
-      focus: _newAnchor2,
-      anchor: _newAnchor2
+      focus: newAnchor,
+      anchor: newAnchor
     });
   }
   if (keyboardName === KEYBOARD.LEFT) {
@@ -836,69 +858,73 @@ export var focusCell = function focusCell(editor, event) {
     event.preventDefault();
     if (rowIndex === 0 && cellIndex === 0) {
       if (tableIndex !== 0) {
-        focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex - 1]));
+        focusEditor(editor, [...tableParentPath, tableIndex - 1]);
       }
       return;
     }
     if (cellIndex === 0) {
-      focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex - 1, tableSize[1] - 1]));
+      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex - 1, tableSize[1] - 1]);
     } else {
-      focusEditor(editor, [].concat(_toConsumableArray(tableParentPath), [tableIndex, rowIndex, cellIndex - 1]));
+      focusEditor(editor, [...tableParentPath, tableIndex, rowIndex, cellIndex - 1]);
     }
-    var _newFocus2 = editor.selection.focus;
+    const {
+      focus: newFocus
+    } = editor.selection;
     Transforms.select(editor, {
-      focus: _newFocus2,
-      anchor: _newFocus2
+      focus: newFocus,
+      anchor: newFocus
     });
   }
 };
-export var isLastTableCell = function isLastTableCell(editor, cellNode) {
+export const isLastTableCell = (editor, cellNode) => {
   if (cellNode[0].type !== ELEMENT_TYPE.TABLE_CELL) return false;
-  var _getSelectedInfo11 = getSelectedInfo(editor),
-    tableSize = _getSelectedInfo11.tableSize;
-  var lastRowIndex = tableSize[0] - 1;
-  var lastColumnIndex = tableSize[1] - 1;
-  var cellNodePath = cellNode[1];
-  var cellNodePathDeep = cellNodePath.length;
+  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;
 };
-var getValidColor = function getValidColor(color) {
+const getValidColor = color => {
   if (!color) return '';
-  var validColor = color.length === 4 ? '#' + color.slice(1, 4).repeat(2) : color;
+  const validColor = color.length === 4 ? '#' + color.slice(1, 4).repeat(2) : color;
   return validColor.toUpperCase();
 };
-export var colorBlend = function colorBlend(c1, c2, ratio) {
-  var color1 = getValidColor(c1);
-  var color2 = getValidColor(c2);
+export 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;
-  var validRatio = Math.max(Math.min(Number(ratio), 1), 0);
-  var r1 = parseInt(color1.substring(1, 3), 16);
-  var g1 = parseInt(color1.substring(3, 5), 16);
-  var b1 = parseInt(color1.substring(5, 7), 16);
-  var r2 = parseInt(color2.substring(1, 3), 16);
-  var g2 = parseInt(color2.substring(3, 5), 16);
-  var b2 = parseInt(color2.substring(5, 7), 16);
-  var r = Math.round(r1 * (1 - validRatio) + r2 * validRatio);
-  var g = Math.round(g1 * (1 - validRatio) + g2 * validRatio);
-  var b = Math.round(b1 * (1 - validRatio) + b2 * validRatio);
+  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;
 };
-export var getRowHeight = function getRowHeight(element, rowIndex) {
-  var _element$style = element.style,
-    style = _element$style === void 0 ? {} : _element$style;
-  var rowHeight = style[TABLE_ROW_STYLE.MIN_HEIGHT] || TABLE_ROW_MIN_HEIGHT;
+export const getRowHeight = (element, rowIndex) => {
+  const {
+    style = {}
+  } = element;
+  const rowHeight = style[TABLE_ROW_STYLE.MIN_HEIGHT] || TABLE_ROW_MIN_HEIGHT;
   return rowIndex === 0 ? rowHeight + 1 : rowHeight;
 };
-var normalizeTableCell = function normalizeTableCell(cell) {
+const normalizeTableCell = cell => {
   if (!cell) return generateTableCell();
-  var newCell = _objectSpread({
+  let newCell = _objectSpread({
     children: [{
       text: '',
       id: slugid.nice()
@@ -906,16 +932,16 @@ var normalizeTableCell = function normalizeTableCell(cell) {
   }, cell);
 
   // normalize cell children
-  var newCellChildren = [];
-  newCell.children.forEach(function (cellChild) {
-    var cellChildType = cellChild.type;
+  let newCellChildren = [];
+  newCell.children.forEach(cellChild => {
+    const cellChildType = cellChild.type;
     if (cellChildType === ELEMENT_TYPE.PARAGRAPH) {
-      newCellChildren.push.apply(newCellChildren, _toConsumableArray(cellChild.children));
+      newCellChildren.push(...cellChild.children);
     } else {
       newCellChildren.push(cellChild);
     }
   });
-  newCell.children = newCellChildren.map(function (item) {
+  newCell.children = newCellChildren.map(item => {
     if (item.BOLD) {
       item.bold = item.BOLD;
       delete item['BOLD'];
@@ -929,9 +955,9 @@ var normalizeTableCell = function normalizeTableCell(cell) {
 
   // normalize cell style
   if (newCell.data) {
-    var cellStyle = _objectSpread({}, newCell.data);
+    const cellStyle = _objectSpread({}, newCell.data);
     delete newCell['data'];
-    Object.keys(cellStyle).forEach(function (cellStyleKey) {
+    Object.keys(cellStyle).forEach(cellStyleKey => {
       if (cellStyleKey === 'align') {
         cellStyle['text_align'] = cellStyle['align'];
         delete cellStyle['align'];
@@ -941,31 +967,31 @@ var normalizeTableCell = function normalizeTableCell(cell) {
   }
   return newCell;
 };
-export var normalizeTableELement = function normalizeTableELement(editor, element) {
+export const normalizeTableELement = (editor, element) => {
   if (element.type !== ELEMENT_TYPE.TABLE) {
-    var size = [element.children.length, element.children[0].children.length];
+    const size = [element.children.length, element.children[0].children.length];
     return generateEmptyTable(editor, {
-      size: size
+      size
     });
   }
-  var newElement = _objectSpread({}, element);
-  for (var i = 0; i < element.children.length; i++) {
-    var row = newElement.children[i];
-    for (var j = 0; j < row.children.length; j++) {
+  let newElement = _objectSpread({}, 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(row.children[j]);
     }
     newElement.children[i] = row;
   }
   return newElement;
 };
-export var insertTableByTemplate = function insertTableByTemplate(editor, alternateColor) {
-  var size = [4, 4];
-  var tableNode = generateEmptyTable(editor, {
-    size: size,
+export const insertTableByTemplate = (editor, alternateColor) => {
+  const size = [4, 4];
+  const tableNode = generateEmptyTable(editor, {
+    size,
     alternate_highlight_color: alternateColor,
     alternate_highlight: true
   });
-  var path = Editor.path(editor, editor.selection);
+  const path = Editor.path(editor, editor.selection);
   Transforms.insertNodes(editor, tableNode, {
     at: [path[0]]
   });