@soul-refiner/design-system 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/node_modules/@udecode/plate-table/dist/index.js

@@ -0,0 +1,1371 @@
+'use strict';
+
+var slate = require('slate');
+var cloneDeep = require('../../../lodash/cloneDeep.js');
+var React = require('react');
+var index$3 = require('../../plate-resizable/dist/index.js');
+var slateReact = require('slate-react');
+var index$1 = require('../../plate-core/dist/index.js');
+var index$4 = require('../../slate/dist/index.js');
+var index$5 = require('../../slate-utils/dist/index.js');
+var index = require('../../../jotai-x/dist/index.js');
+var vanilla = require('../../../jotai/esm/vanilla.js');
+var index$2 = require('../../slate-react/dist/index.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/queries/getColSpan.ts
+var getColSpan = (cellElem) => {
+  var _a;
+  return cellElem.colSpan || Number((_a = cellElem.attributes) == null ? void 0 : _a.colspan) || 1;
+};
+var getCellTypes = (editor) => index$1.getPluginTypes(editor, [ELEMENT_TD, ELEMENT_TH]);
+var getEmptyCellNode = (editor, { header, newCellChildren = [editor.blockFactory()] }) => {
+  return {
+    type: header ? index$1.getPluginType(editor, ELEMENT_TH) : index$1.getPluginType(editor, ELEMENT_TD),
+    children: newCellChildren
+  };
+};
+var getEmptyRowNode = (editor, _a = {}) => {
+  var _b = _a, { colCount = 1 } = _b, options = __objRest(_b, ["colCount"]);
+  return {
+    type: index$1.getPluginType(editor, ELEMENT_TR),
+    children: Array.from({ length: colCount }).fill(colCount).map(() => getEmptyCellNode(editor, options))
+  };
+};
+var getEmptyTableNode = (editor, {
+  header,
+  rowCount = 0,
+  colCount,
+  newCellChildren
+} = {}) => {
+  const rows = Array.from({ length: rowCount }).fill(rowCount).map(() => getEmptyRowNode(editor, { header, colCount, newCellChildren }));
+  return {
+    type: index$1.getPluginType(editor, ELEMENT_TABLE),
+    children: rows
+  };
+};
+
+// src/queries/getLeftTableCell.ts
+var getLeftTableCell = (editor, {
+  at: cellPath
+} = {}) => {
+  var _a;
+  if (!cellPath) {
+    cellPath = (_a = index$4.findNode(editor, {
+      match: { type: getCellTypes(editor) }
+    })) == null ? void 0 : _a[1];
+    if (!cellPath)
+      return;
+  }
+  const cellIndex = cellPath.at(-1);
+  if (!cellIndex)
+    return;
+  const prevCellPath = slate.Path.previous(cellPath);
+  return index$4.getNodeEntry(editor, prevCellPath);
+};
+
+// src/queries/getRowSpan.ts
+var getRowSpan = (cellElem) => {
+  var _a;
+  return cellElem.rowSpan || Number((_a = cellElem.attributes) == null ? void 0 : _a.rowspan) || 1;
+};
+
+// src/queries/getTableColumnCount.ts
+var getTableColumnCount = (tableNode) => {
+  var _a, _b, _c, _d;
+  return (_d = (_c = (_b = (_a = tableNode.children) == null ? void 0 : _a[0]) == null ? void 0 : _b.children) == null ? void 0 : _c.length) != null ? _d : 0;
+};
+var getTableColumnIndex = (editor, cellNode) => {
+  var _a;
+  const path = index$2.findNodePath(editor, cellNode);
+  if (!path)
+    return 0;
+  const [trNode] = (_a = index$4.getParentNode(editor, path)) != null ? _a : [];
+  if (!trNode)
+    return 0;
+  let colIndex = 0;
+  trNode.children.some((item, index) => {
+    if (item === cellNode) {
+      colIndex = index;
+      return true;
+    }
+    return false;
+  });
+  return colIndex;
+};
+function computeCellIndices(editor, tableEl, cellEl) {
+  var _a;
+  const options = index$1.getPluginOptions(editor, ELEMENT_TABLE);
+  const tableNodes = tableEl.children;
+  let rowIndex = -1;
+  let colIndex = -1;
+  for (let r = 0; r < tableNodes.length; r++) {
+    const row = tableNodes[r];
+    let cIndex = 0;
+    for (let c = 0; c < row.children.length; c++) {
+      const cell = row.children[c];
+      if (cellEl === cell) {
+        colIndex = cIndex;
+        rowIndex = r;
+        break;
+      }
+      cIndex += cell.colSpan || 1;
+    }
+  }
+  tableNodes.slice(0, rowIndex).forEach((pR, _rowIndex) => {
+    const prevRow = pR;
+    prevRow.children.forEach((pC) => {
+      var _a2;
+      const prevCell = pC;
+      const prevIndices = (_a2 = options == null ? void 0 : options._cellIndices) == null ? void 0 : _a2.get(prevCell);
+      const _rowSpan = getRowSpan(prevCell);
+      if (prevIndices) {
+        const { col: prevColIndex } = prevIndices;
+        if (
+          // colIndex affects
+          prevColIndex <= colIndex && // rowSpan affects
+          _rowSpan && _rowSpan > 1 && rowIndex - _rowIndex < _rowSpan
+        ) {
+          colIndex += prevCell.colSpan || 1;
+        }
+      }
+    });
+  });
+  if (rowIndex === -1 || colIndex === -1) {
+    return null;
+  }
+  const indices = { row: rowIndex, col: colIndex };
+  (_a = options == null ? void 0 : options._cellIndices) == null ? void 0 : _a.set(cellEl, indices);
+  return indices;
+}
+var computeAllCellIndices = (editor, tableNode) => {
+  var _a;
+  const options = index$1.getPluginOptions(editor, ELEMENT_TABLE);
+  for (let r = 0; r < tableNode.children.length; r++) {
+    const row = tableNode.children[r];
+    for (let c = 0; c < row.children.length; c++) {
+      const cell = row.children[c];
+      const indices = computeCellIndices(editor, tableNode, cell);
+      if (indices) {
+        (_a = options._cellIndices) == null ? void 0 : _a.set(cell, indices);
+      }
+    }
+  }
+};
+
+// src/merge/getCellIndices.ts
+var getCellIndices = (cellIndices, startCell) => {
+  return cellIndices == null ? void 0 : cellIndices.get(startCell);
+};
+
+// src/merge/getCellIndicesWithSpans.ts
+var getCellIndicesWithSpans = ({ col, row }, endCell) => {
+  return {
+    row: row + getRowSpan(endCell) - 1,
+    col: col + getColSpan(endCell) - 1
+  };
+};
+
+// src/merge/findCellByIndexes.ts
+var findCellByIndexes = (editor, table, searchRowIndex, searchColIndex) => {
+  const { _cellIndices: cellIndices } = index$1.getPluginOptions(
+    editor,
+    ELEMENT_TABLE
+  );
+  const allCells = table.children.flatMap(
+    (current) => current.children
+  );
+  const foundCell = allCells.find((cell) => {
+    const cellElement = cell;
+    const indices = getCellIndices(cellIndices, cellElement) || computeCellIndices(editor, table, cellElement);
+    const { col: _startColIndex, row: _startRowIndex } = indices;
+    const { row: _endRowIndex, col: _endColIndex } = getCellIndicesWithSpans(
+      indices,
+      cellElement
+    );
+    if (searchColIndex >= _startColIndex && searchColIndex <= _endColIndex && searchRowIndex >= _startRowIndex && searchRowIndex <= _endRowIndex) {
+      return true;
+    }
+    return false;
+  });
+  return foundCell;
+};
+
+// src/merge/getTableGridByRange.ts
+var getTableMergeGridByRange = (editor, { at, format }) => {
+  var _a;
+  const { _cellIndices: cellIndices } = index$1.getPluginOptions(
+    editor,
+    ELEMENT_TABLE
+  );
+  const startCellEntry = index$4.findNode(editor, {
+    at: at.anchor.path,
+    match: { type: getCellTypes(editor) }
+  });
+  const endCellEntry = index$4.findNode(editor, {
+    at: at.focus.path,
+    match: { type: getCellTypes(editor) }
+  });
+  const startCell = startCellEntry[0];
+  const endCell = endCellEntry[0];
+  const startCellPath = at.anchor.path;
+  const tablePath = startCellPath.slice(0, -2);
+  const tableEntry = index$4.findNode(editor, {
+    at: tablePath,
+    match: { type: index$1.getPluginType(editor, ELEMENT_TABLE) }
+  });
+  const realTable = tableEntry[0];
+  const { col: _startColIndex, row: _startRowIndex } = getCellIndices(cellIndices, startCell) || computeCellIndices(editor, realTable, startCell);
+  const { row: _endRowIndex, col: _endColIndex } = getCellIndicesWithSpans(
+    getCellIndices(cellIndices, endCell) || computeCellIndices(editor, realTable, endCell),
+    endCell
+  );
+  const startRowIndex = Math.min(_startRowIndex, _endRowIndex);
+  const endRowIndex = Math.max(_startRowIndex, _endRowIndex);
+  const startColIndex = Math.min(_startColIndex, _endColIndex);
+  const endColIndex = Math.max(_startColIndex, _endColIndex);
+  const relativeRowIndex = endRowIndex - startRowIndex;
+  const relativeColIndex = endColIndex - startColIndex;
+  const table = getEmptyTableNode(editor, {
+    rowCount: relativeRowIndex + 1,
+    colCount: relativeColIndex + 1,
+    newCellChildren: []
+  });
+  const cellEntries = [];
+  const cellsSet = /* @__PURE__ */ new WeakSet();
+  let rowIndex = startRowIndex;
+  let colIndex = startColIndex;
+  while (true) {
+    const cell = findCellByIndexes(editor, realTable, rowIndex, colIndex);
+    if (!cell) {
+      break;
+    }
+    if (!cellsSet.has(cell)) {
+      cellsSet.add(cell);
+      const rows = table.children[rowIndex - startRowIndex].children;
+      rows[colIndex - startColIndex] = cell;
+      const cellPath = index$2.findNodePath(editor, cell);
+      cellEntries.push([cell, cellPath]);
+    }
+    if (colIndex + 1 <= endColIndex) {
+      colIndex = colIndex + 1;
+    } else if (rowIndex + 1 <= endRowIndex) {
+      colIndex = startColIndex;
+      rowIndex = rowIndex + 1;
+    } else {
+      break;
+    }
+  }
+  const formatType = format || "table";
+  if (formatType === "cell") {
+    return cellEntries;
+  }
+  (_a = table.children) == null ? void 0 : _a.forEach((rowEl) => {
+    var _a2;
+    const rowElement = rowEl;
+    const filteredChildren = (_a2 = rowElement.children) == null ? void 0 : _a2.filter((cellEl) => {
+      const cellElement = cellEl;
+      return !!(cellElement == null ? void 0 : cellElement.children.length);
+    });
+    rowElement.children = filteredChildren;
+  });
+  if (formatType === "table") {
+    return [[table, tablePath]];
+  }
+  return {
+    tableEntries: [[table, tablePath]],
+    cellEntries
+  };
+};
+
+// src/queries/getTableGridByRange.ts
+var getTableGridByRange = (editor, { at, format = "table" }) => {
+  const { enableMerging } = index$1.getPluginOptions(
+    editor,
+    ELEMENT_TABLE
+  );
+  if (enableMerging) {
+    return getTableMergeGridByRange(editor, { at, format });
+  }
+  const startCellPath = at.anchor.path;
+  const endCellPath = at.focus.path;
+  const _startRowIndex = startCellPath.at(-2);
+  const _endRowIndex = endCellPath.at(-2);
+  const _startColIndex = startCellPath.at(-1);
+  const _endColIndex = endCellPath.at(-1);
+  const startRowIndex = Math.min(_startRowIndex, _endRowIndex);
+  const endRowIndex = Math.max(_startRowIndex, _endRowIndex);
+  const startColIndex = Math.min(_startColIndex, _endColIndex);
+  const endColIndex = Math.max(_startColIndex, _endColIndex);
+  const tablePath = startCellPath.slice(0, -2);
+  const relativeRowIndex = endRowIndex - startRowIndex;
+  const relativeColIndex = endColIndex - startColIndex;
+  const table = getEmptyTableNode(editor, {
+    rowCount: relativeRowIndex + 1,
+    colCount: relativeColIndex + 1,
+    newCellChildren: []
+  });
+  let rowIndex = startRowIndex;
+  let colIndex = startColIndex;
+  const cellEntries = [];
+  while (true) {
+    const cellPath = tablePath.concat([rowIndex, colIndex]);
+    const cell = index$4.getNode(editor, cellPath);
+    if (!cell)
+      break;
+    const rows = table.children[rowIndex - startRowIndex].children;
+    rows[colIndex - startColIndex] = cell;
+    cellEntries.push([cell, cellPath]);
+    if (colIndex + 1 <= endColIndex) {
+      colIndex += 1;
+    } else if (rowIndex + 1 <= endRowIndex) {
+      colIndex = startColIndex;
+      rowIndex += 1;
+    } else {
+      break;
+    }
+  }
+  if (format === "cell") {
+    return cellEntries;
+  }
+  return [[table, tablePath]];
+};
+
+// src/queries/getTableGridAbove.ts
+var getTableGridAbove = (editor, _a = {}) => {
+  var _b = _a, { format = "table" } = _b, options = __objRest(_b, ["format"]);
+  const edges = index$5.getEdgeBlocksAbove(editor, __spreadValues({
+    match: {
+      type: getCellTypes(editor)
+    }
+  }, options));
+  if (edges) {
+    const [start, end] = edges;
+    if (!slate.Path.equals(start[1], end[1])) {
+      return getTableGridByRange(editor, {
+        at: {
+          anchor: {
+            path: start[1],
+            offset: 0
+          },
+          focus: {
+            path: end[1],
+            offset: 0
+          }
+        },
+        format
+      });
+    }
+    if (format === "table") {
+      const table = getEmptyTableNode(editor, { rowCount: 1 });
+      table.children[0].children = [start[0]];
+      return [[table, start[1].slice(0, -2)]];
+    }
+    return [start];
+  }
+  return [];
+};
+
+// src/queries/getTableOverriddenColSizes.ts
+var getTableOverriddenColSizes = (tableNode, colSizeOverrides) => {
+  const colCount = getTableColumnCount(tableNode);
+  const colSizes = (tableNode.colSizes ? [...tableNode.colSizes] : Array.from({ length: colCount }).fill(0)).map((size, index) => {
+    var _a, _b;
+    return (_b = (_a = colSizeOverrides == null ? void 0 : colSizeOverrides.get) == null ? void 0 : _a.call(colSizeOverrides, index)) != null ? _b : size;
+  });
+  return colSizes;
+};
+var getTableRowIndex = (editor, cellNode) => {
+  const path = index$2.findNodePath(editor, cellNode);
+  if (!path)
+    return 0;
+  const rowPath = slate.Path.parent(path);
+  return rowPath.at(-1);
+};
+var getTopTableCell = (editor, {
+  at: cellPath
+} = {}) => {
+  var _a;
+  if (!cellPath) {
+    cellPath = (_a = index$4.findNode(editor, {
+      match: { type: getCellTypes(editor) }
+    })) == null ? void 0 : _a[1];
+    if (!cellPath)
+      return;
+  }
+  const cellIndex = cellPath.at(-1);
+  const rowIndex = cellPath.at(-2);
+  if (rowIndex === 0)
+    return;
+  const cellAbovePath = [
+    ...slate.Path.parent(slate.Path.parent(cellPath)),
+    rowIndex - 1,
+    cellIndex
+  ];
+  return index$4.getNodeEntry(editor, cellAbovePath);
+};
+var isTableBorderHidden = (editor, border) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (border === "left") {
+    const node = (_a = getLeftTableCell(editor)) == null ? void 0 : _a[0];
+    if (node) {
+      return ((_c = (_b = node.borders) == null ? void 0 : _b.right) == null ? void 0 : _c.size) === 0;
+    }
+  }
+  if (border === "top") {
+    const node = (_d = getTopTableCell(editor)) == null ? void 0 : _d[0];
+    if (node) {
+      return ((_f = (_e = node.borders) == null ? void 0 : _e.bottom) == null ? void 0 : _f.size) === 0;
+    }
+  }
+  return ((_i = (_h = (_g = index$4.findNode(editor, {
+    match: { type: getCellTypes(editor) }
+  })) == null ? void 0 : _g[0].borders) == null ? void 0 : _h[border]) == null ? void 0 : _i.size) === 0;
+};
+var setBorderSize = (editor, size, {
+  at,
+  border = "all"
+} = {}) => {
+  const cellEntry = index$4.findNode(editor, {
+    at,
+    match: { type: getCellTypes(editor) }
+  });
+  if (!cellEntry)
+    return;
+  const [cellNode, cellPath] = cellEntry;
+  const cellIndex = cellPath.at(-1);
+  const rowIndex = cellPath.at(-2);
+  const borderStyle = {
+    size
+  };
+  const setNodesOptions = {
+    match: (n) => index$4.isElement(n) && getCellTypes(editor).includes(n.type)
+  };
+  if (border === "top") {
+    const isFirstRow = rowIndex === 0;
+    if (isFirstRow) {
+      const newBorders2 = __spreadProps(__spreadValues({}, cellNode.borders), {
+        top: borderStyle
+      });
+      index$4.setNodes(
+        editor,
+        { borders: newBorders2 },
+        __spreadValues({
+          at: cellPath
+        }, setNodesOptions)
+      );
+      return;
+    }
+    const cellAboveEntry = getTopTableCell(editor, { at: cellPath });
+    if (!cellAboveEntry)
+      return;
+    const [cellAboveNode, cellAbovePath] = cellAboveEntry;
+    const newBorders = __spreadProps(__spreadValues({}, cellAboveNode.borders), {
+      bottom: borderStyle
+    });
+    index$4.setNodes(
+      editor,
+      { borders: newBorders },
+      __spreadValues({
+        at: cellAbovePath
+      }, setNodesOptions)
+    );
+  } else if (border === "bottom") {
+    const newBorders = __spreadProps(__spreadValues({}, cellNode.borders), {
+      bottom: borderStyle
+    });
+    index$4.setNodes(
+      editor,
+      { borders: newBorders },
+      __spreadValues({
+        at: cellPath
+      }, setNodesOptions)
+    );
+  }
+  if (border === "left") {
+    const isFirstCell = cellIndex === 0;
+    if (isFirstCell) {
+      const newBorders2 = __spreadProps(__spreadValues({}, cellNode.borders), {
+        left: borderStyle
+      });
+      index$4.setNodes(
+        editor,
+        { borders: newBorders2 },
+        __spreadValues({
+          at: cellPath
+        }, setNodesOptions)
+      );
+      return;
+    }
+    const prevCellEntry = getLeftTableCell(editor, { at: cellPath });
+    if (!prevCellEntry)
+      return;
+    const [prevCellNode, prevCellPath] = prevCellEntry;
+    const newBorders = __spreadProps(__spreadValues({}, prevCellNode.borders), {
+      right: borderStyle
+    });
+    index$4.setNodes(
+      editor,
+      { borders: newBorders },
+      __spreadValues({
+        at: prevCellPath
+      }, setNodesOptions)
+    );
+  } else if (border === "right") {
+    const newBorders = __spreadProps(__spreadValues({}, cellNode.borders), {
+      right: borderStyle
+    });
+    index$4.setNodes(
+      editor,
+      { borders: newBorders },
+      __spreadValues({
+        at: cellPath
+      }, setNodesOptions)
+    );
+  }
+  if (border === "all") {
+    index$4.withoutNormalizing(editor, () => {
+      setBorderSize(editor, size, { at, border: "top" });
+      setBorderSize(editor, size, { at, border: "bottom" });
+      setBorderSize(editor, size, { at, border: "left" });
+      setBorderSize(editor, size, { at, border: "right" });
+    });
+  }
+};
+var setTableColSize = (editor, { colIndex, width }, options = {}) => {
+  const table = index$4.findNode(editor, __spreadValues({
+    match: { type: ELEMENT_TABLE }
+  }, options));
+  if (!table)
+    return;
+  const [tableNode, tablePath] = table;
+  const colSizes = tableNode.colSizes ? [...tableNode.colSizes] : Array.from({ length: getTableColumnCount(tableNode) }).fill(0);
+  colSizes[colIndex] = width;
+  index$4.setNodes(editor, { colSizes }, { at: tablePath });
+};
+var setTableMarginLeft = (editor, { marginLeft }, options = {}) => {
+  const table = index$4.findNode(editor, __spreadValues({
+    match: { type: ELEMENT_TABLE }
+  }, options));
+  if (!table)
+    return;
+  const [, tablePath] = table;
+  index$4.setNodes(editor, { marginLeft }, { at: tablePath });
+};
+var setTableRowSize = (editor, { rowIndex, height }, options = {}) => {
+  const table = index$4.findNode(editor, __spreadValues({
+    match: { type: ELEMENT_TABLE }
+  }, options));
+  if (!table)
+    return;
+  const [, tablePath] = table;
+  const tableRowPath = [...tablePath, rowIndex];
+  index$4.setNodes(editor, { size: height }, { at: tableRowPath });
+};
+
+// src/createTablePlugin.ts
+var ELEMENT_TABLE = "table";
+var ELEMENT_TH = "th";
+var ELEMENT_TR = "tr";
+var ELEMENT_TD = "td";
+var getOnSelectTableBorderFactory = (editor, selectedCells) => (border) => () => {
+  if (selectedCells)
+    return;
+  if (border === "none") {
+    setBorderSize(editor, 0, { border: "all" });
+  } else if (border === "outer") {
+    setBorderSize(editor, 1, { border: "all" });
+  } else {
+    const size = isTableBorderHidden(editor, border) ? 1 : 0;
+    setBorderSize(editor, size, { border });
+  }
+  setTimeout(() => {
+    index$2.focusEditor(editor);
+  }, 50);
+};
+
+// src/components/TableCellElement/getTableCellBorders.ts
+var getTableCellBorders = (element, {
+  isFirstCell,
+  isFirstRow,
+  defaultBorder = {
+    size: 1,
+    style: "solid",
+    color: "rgb(209 213 219)"
+  }
+} = {}) => {
+  const getBorder = (dir) => {
+    var _a, _b, _c, _d;
+    const border = (_a = element.borders) == null ? void 0 : _a[dir];
+    return {
+      size: (_b = border == null ? void 0 : border.size) != null ? _b : defaultBorder.size,
+      style: (_c = border == null ? void 0 : border.style) != null ? _c : defaultBorder.style,
+      color: (_d = border == null ? void 0 : border.color) != null ? _d : defaultBorder.color
+    };
+  };
+  return {
+    bottom: getBorder("bottom"),
+    right: getBorder("right"),
+    left: isFirstCell ? getBorder("left") : void 0,
+    top: isFirstRow ? getBorder("top") : void 0
+  };
+};
+
+// src/components/TableCellElement/roundCellSizeToStep.ts
+var roundCellSizeToStep = (size, step) => {
+  return step ? Math.round(size / step) * step : size;
+};
+var { tableStore, useTableStore, TableProvider } = index.createAtomStore(
+  {
+    colSizeOverrides: vanilla.atom(/* @__PURE__ */ new Map()),
+    rowSizeOverrides: vanilla.atom(/* @__PURE__ */ new Map()),
+    marginLeftOverride: null,
+    hoveredColIndex: null,
+    selectedCells: null,
+    selectedTable: null
+  },
+  { name: "table" }
+);
+var useOverrideSizeFactory = (setOverrides) => React__default.default.useCallback(
+  (index, size) => {
+    setOverrides((overrides) => {
+      const newOverrides = new Map(overrides);
+      if (size === null) {
+        newOverrides.delete(index);
+      } else {
+        newOverrides.set(index, size);
+      }
+      return newOverrides;
+    });
+  },
+  [setOverrides]
+);
+var useOverrideColSize = () => {
+  const setColSizeOverrides = useTableStore().set.colSizeOverrides();
+  return useOverrideSizeFactory(setColSizeOverrides);
+};
+var useOverrideRowSize = () => {
+  const setRowSizeOverrides = useTableStore().set.rowSizeOverrides();
+  return useOverrideSizeFactory(setRowSizeOverrides);
+};
+var useOverrideMarginLeft = () => useTableStore().set.marginLeftOverride();
+
+// src/components/TableCellElement/useIsCellSelected.ts
+var useIsCellSelected = (element) => {
+  const selectedCells = useTableStore().get.selectedCells();
+  return React__default.default.useMemo(
+    () => !!(selectedCells == null ? void 0 : selectedCells.includes(element)),
+    [element, selectedCells]
+  );
+};
+var useTableBordersDropdownMenuContentState = () => {
+  const editor = index$1.useEditorRef();
+  const selectedCells = useTableStore().get.selectedCells();
+  const hasBottomBorder = index$1.useEditorSelector(
+    (editor2) => !isTableBorderHidden(editor2, "bottom"),
+    []
+  );
+  const hasTopBorder = index$1.useEditorSelector(
+    (editor2) => !isTableBorderHidden(editor2, "top"),
+    []
+  );
+  const hasLeftBorder = index$1.useEditorSelector(
+    (editor2) => !isTableBorderHidden(editor2, "left"),
+    []
+  );
+  const hasRightBorder = index$1.useEditorSelector(
+    (editor2) => !isTableBorderHidden(editor2, "right"),
+    []
+  );
+  const hasOuterBorders = hasBottomBorder && hasTopBorder && hasLeftBorder && hasRightBorder;
+  const hasNoBorders = !hasBottomBorder && !hasTopBorder && !hasLeftBorder && !hasRightBorder;
+  return {
+    hasBottomBorder,
+    hasTopBorder,
+    hasLeftBorder,
+    hasRightBorder,
+    hasNoBorders,
+    hasOuterBorders,
+    getOnSelectTableBorder: getOnSelectTableBorderFactory(
+      editor,
+      selectedCells
+    )
+  };
+};
+var useTableColSizes = (tableNode, { disableOverrides = false } = {}) => {
+  const editor = index$1.useEditorRef();
+  const colSizeOverrides = useTableStore().get.colSizeOverrides();
+  const { enableUnsetSingleColSize } = index$1.getPluginOptions(
+    editor,
+    ELEMENT_TABLE
+  );
+  const overriddenColSizes = getTableOverriddenColSizes(
+    tableNode,
+    disableOverrides ? void 0 : colSizeOverrides
+  );
+  const colCount = getTableColumnCount(tableNode);
+  React__default.default.useEffect(() => {
+    var _a;
+    if (enableUnsetSingleColSize && colCount < 2 && ((_a = tableNode.colSizes) == null ? void 0 : _a.length)) {
+      index$4.unsetNodes(editor, "colSizes", {
+        at: index$2.findNodePath(editor, tableNode)
+      });
+    }
+  }, [colCount, enableUnsetSingleColSize, editor, tableNode]);
+  return overriddenColSizes;
+};
+
+// src/components/TableCellElement/useTableCellElementResizable.ts
+var useTableCellElementResizableState = ({
+  colIndex,
+  rowIndex,
+  step,
+  stepX = step,
+  stepY = step,
+  colSpan
+}) => {
+  const editor = index$1.useEditorRef();
+  const { disableMarginLeft } = index$1.getPluginOptions(
+    editor,
+    ELEMENT_TABLE
+  );
+  return {
+    disableMarginLeft,
+    colIndex,
+    rowIndex,
+    stepX,
+    stepY,
+    colSpan
+  };
+};
+var useTableCellElementResizable = ({
+  disableMarginLeft,
+  colIndex,
+  rowIndex,
+  stepX,
+  stepY,
+  colSpan
+}) => {
+  var _a;
+  const editor = index$1.useEditorRef();
+  const element = index$1.useElement();
+  const tableElement = index$1.useElement(ELEMENT_TABLE);
+  const { minColumnWidth = 0 } = index$1.getPluginOptions(
+    editor,
+    ELEMENT_TABLE
+  );
+  let initialWidth;
+  if (colSpan > 1) {
+    initialWidth = (_a = tableElement.colSizes) == null ? void 0 : _a[colIndex];
+  }
+  const [hoveredColIndex, setHoveredColIndex] = useTableStore().use.hoveredColIndex();
+  const colSizesWithoutOverrides = useTableColSizes(tableElement, {
+    disableOverrides: true
+  });
+  const { marginLeft = 0 } = tableElement;
+  const overrideColSize = useOverrideColSize();
+  const overrideRowSize = useOverrideRowSize();
+  const overrideMarginLeft = useOverrideMarginLeft();
+  const setColSize = React__default.default.useCallback(
+    (colIndex2, width) => {
+      setTableColSize(
+        editor,
+        { colIndex: colIndex2, width },
+        { at: index$2.findNodePath(editor, element) }
+      );
+      setTimeout(() => overrideColSize(colIndex2, null), 0);
+    },
+    [editor, element, overrideColSize]
+  );
+  const setRowSize = React__default.default.useCallback(
+    (rowIndex2, height) => {
+      setTableRowSize(
+        editor,
+        { rowIndex: rowIndex2, height },
+        { at: index$2.findNodePath(editor, element) }
+      );
+      setTimeout(() => overrideRowSize(rowIndex2, null), 0);
+    },
+    [editor, element, overrideRowSize]
+  );
+  const setMarginLeft = React__default.default.useCallback(
+    (marginLeft2) => {
+      setTableMarginLeft(
+        editor,
+        { marginLeft: marginLeft2 },
+        { at: index$2.findNodePath(editor, element) }
+      );
+      setTimeout(() => overrideMarginLeft(null), 0);
+    },
+    [editor, element, overrideMarginLeft]
+  );
+  const handleResizeRight = React__default.default.useCallback(
+    ({ initialSize: currentInitial, delta, finished }) => {
+      const nextInitial = colSizesWithoutOverrides[colIndex + 1];
+      const complement = (width) => currentInitial + nextInitial - width;
+      const currentNew = roundCellSizeToStep(
+        index$3.resizeLengthClampStatic(currentInitial + delta, {
+          min: minColumnWidth,
+          max: nextInitial ? complement(minColumnWidth) : void 0
+        }),
+        stepX
+      );
+      const nextNew = nextInitial ? complement(currentNew) : void 0;
+      const fn = finished ? setColSize : overrideColSize;
+      fn(colIndex, currentNew);
+      if (nextNew)
+        fn(colIndex + 1, nextNew);
+    },
+    [
+      colIndex,
+      colSizesWithoutOverrides,
+      minColumnWidth,
+      overrideColSize,
+      setColSize,
+      stepX
+    ]
+  );
+  const handleResizeBottom = React__default.default.useCallback(
+    (event) => {
+      const newHeight = roundCellSizeToStep(
+        event.initialSize + event.delta,
+        stepY
+      );
+      if (event.finished) {
+        setRowSize(rowIndex, newHeight);
+      } else {
+        overrideRowSize(rowIndex, newHeight);
+      }
+    },
+    [overrideRowSize, rowIndex, setRowSize, stepY]
+  );
+  const handleResizeLeft = React__default.default.useCallback(
+    (event) => {
+      const initial = colSizesWithoutOverrides[colIndex];
+      const complement = (width) => initial + marginLeft - width;
+      const newMargin = roundCellSizeToStep(
+        index$3.resizeLengthClampStatic(marginLeft + event.delta, {
+          min: 0,
+          max: complement(minColumnWidth)
+        }),
+        stepX
+      );
+      const newWidth = complement(newMargin);
+      if (event.finished) {
+        setMarginLeft(newMargin);
+        setColSize(colIndex, newWidth);
+      } else {
+        overrideMarginLeft(newMargin);
+        overrideColSize(colIndex, newWidth);
+      }
+    },
+    [
+      colIndex,
+      colSizesWithoutOverrides,
+      marginLeft,
+      minColumnWidth,
+      overrideColSize,
+      overrideMarginLeft,
+      setColSize,
+      setMarginLeft,
+      stepX
+    ]
+  );
+  const getHandleHoverProps = (colIndex2) => ({
+    onHover: () => {
+      if (hoveredColIndex === null) {
+        setHoveredColIndex(colIndex2);
+      }
+    },
+    onHoverEnd: () => {
+      if (hoveredColIndex === colIndex2) {
+        setHoveredColIndex(null);
+      }
+    }
+  });
+  const hasLeftHandle = colIndex === 0 && !disableMarginLeft;
+  return {
+    rightProps: {
+      options: __spreadValues({
+        direction: "right",
+        initialSize: initialWidth,
+        onResize: handleResizeRight
+      }, getHandleHoverProps(colIndex))
+    },
+    bottomProps: {
+      options: {
+        direction: "bottom",
+        onResize: handleResizeBottom
+      }
+    },
+    hiddenLeft: !hasLeftHandle,
+    leftProps: {
+      options: __spreadValues({
+        direction: "left",
+        onResize: handleResizeLeft
+      }, getHandleHoverProps(-1))
+    }
+  };
+};
+var useTableCellElementState = ({
+  ignoreReadOnly
+} = {}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const editor = index$1.useEditorRef();
+  const cellElement = index$1.useElement();
+  const colSpan = getColSpan(cellElement);
+  const rowSpan = getRowSpan(cellElement);
+  const readOnly = slateReact.useReadOnly();
+  const isCellSelected = useIsCellSelected(cellElement);
+  const hoveredColIndex = useTableStore().get.hoveredColIndex();
+  const selectedCells = useTableStore().get.selectedCells();
+  const tableElement = index$1.useElement(ELEMENT_TABLE);
+  const rowElement = index$1.useElement(ELEMENT_TR);
+  const rowSizeOverrides = useTableStore().get.rowSizeOverrides();
+  const { enableMerging, _cellIndices } = index$1.getPluginOptions(
+    editor,
+    ELEMENT_TABLE
+  );
+  if (!enableMerging) {
+    const colIndex2 = getTableColumnIndex(editor, cellElement);
+    const rowIndex2 = getTableRowIndex(editor, cellElement);
+    const rowSize2 = (_c = (_b = (_a = rowSizeOverrides.get) == null ? void 0 : _a.call(rowSizeOverrides, rowIndex2)) != null ? _b : rowElement == null ? void 0 : rowElement.size) != null ? _c : void 0;
+    const isFirstCell2 = colIndex2 === 0;
+    const isFirstRow2 = ((_d = tableElement.children) == null ? void 0 : _d[0]) === rowElement;
+    const borders2 = getTableCellBorders(cellElement, {
+      isFirstCell: isFirstCell2,
+      isFirstRow: isFirstRow2
+    });
+    return {
+      colIndex: colIndex2,
+      rowIndex: rowIndex2,
+      readOnly: !ignoreReadOnly && readOnly,
+      selected: isCellSelected,
+      hovered: hoveredColIndex === colIndex2,
+      hoveredLeft: isFirstCell2 && hoveredColIndex === -1,
+      rowSize: rowSize2,
+      borders: borders2,
+      isSelectingCell: !!selectedCells,
+      colSpan
+    };
+  }
+  let result;
+  const calculated = getCellIndices(_cellIndices, cellElement) || computeCellIndices(editor, tableElement, cellElement);
+  if (calculated) {
+    result = calculated;
+  } else {
+    const defaultColIndex = getTableColumnIndex(editor, cellElement);
+    const defaultRowIndex = getTableRowIndex(editor, cellElement);
+    result = { col: defaultColIndex, row: defaultRowIndex };
+  }
+  const colIndex = result.col;
+  const rowIndex = result.row;
+  const endingRowIndex = rowIndex + rowSpan - 1;
+  const endingColIndex = colIndex + colSpan - 1;
+  const rowSize = (_g = (_f = (_e = rowSizeOverrides.get) == null ? void 0 : _e.call(rowSizeOverrides, endingRowIndex)) != null ? _f : rowElement == null ? void 0 : rowElement.size) != null ? _g : void 0;
+  const isFirstCell = colIndex === 0;
+  const isFirstRow = ((_h = tableElement.children) == null ? void 0 : _h[0]) === rowElement;
+  const borders = getTableCellBorders(cellElement, {
+    isFirstCell,
+    isFirstRow
+  });
+  return {
+    colIndex: endingColIndex,
+    rowIndex: endingRowIndex,
+    readOnly: !ignoreReadOnly && readOnly,
+    selected: isCellSelected,
+    hovered: hoveredColIndex === endingColIndex,
+    hoveredLeft: isFirstCell && hoveredColIndex === -1,
+    rowSize,
+    borders,
+    isSelectingCell: !!selectedCells,
+    colSpan
+  };
+};
+var useTableCellElement = ({
+  element
+}) => {
+  const setHoveredColIndex = useTableStore().set.hoveredColIndex();
+  React__default.default.useEffect(() => {
+    setHoveredColIndex(null);
+  }, [element, setHoveredColIndex]);
+  return {
+    props: {
+      colSpan: element.colSpan,
+      rowSpan: element.rowSpan
+    }
+  };
+};
+var useSelectedCells = () => {
+  const readOnly = slateReact.useReadOnly();
+  const selected = slateReact.useSelected();
+  const editor = index$1.useEditorRef();
+  const [selectedCells, setSelectedCells] = useTableStore().use.selectedCells();
+  const setSelectedTable = useTableStore().set.selectedTable();
+  React__default.default.useEffect(() => {
+    if (!selected || readOnly) {
+      setSelectedCells(null);
+      setSelectedTable(null);
+    }
+  }, [selected, editor, setSelectedCells, readOnly, setSelectedTable]);
+  React__default.default.useEffect(() => {
+    if (readOnly)
+      return;
+    const tableEntries = getTableGridAbove(editor, { format: "table" });
+    const cellEntries = getTableGridAbove(editor, { format: "cell" });
+    if ((cellEntries == null ? void 0 : cellEntries.length) > 1) {
+      const cells = cellEntries.map((entry) => entry[0]);
+      const tables = tableEntries.map((entry) => entry[0]);
+      if (JSON.stringify(cells) !== JSON.stringify(selectedCells)) {
+        setSelectedCells(cells);
+        setSelectedTable(tables);
+      }
+    } else if (selectedCells) {
+      setSelectedCells(null);
+      setSelectedTable(null);
+    }
+  }, [
+    editor,
+    editor.selection,
+    readOnly,
+    selectedCells,
+    setSelectedCells,
+    setSelectedTable
+  ]);
+};
+var useTableElementState = ({
+  transformColSizes
+} = {}) => {
+  var _a;
+  const editor = index$1.useEditorRef();
+  const { minColumnWidth, disableMarginLeft, enableMerging } = index$1.getPluginOptions(editor, ELEMENT_TABLE);
+  const element = index$1.useElement();
+  const selectedCells = useTableStore().get.selectedCells();
+  const marginLeftOverride = useTableStore().get.marginLeftOverride();
+  const marginLeft = disableMarginLeft ? 0 : (_a = marginLeftOverride != null ? marginLeftOverride : element.marginLeft) != null ? _a : 0;
+  let colSizes = useTableColSizes(element);
+  React__default.default.useEffect(() => {
+    if (enableMerging) {
+      computeAllCellIndices(editor, element);
+    }
+  }, [editor, element, enableMerging]);
+  if (transformColSizes) {
+    colSizes = transformColSizes(colSizes);
+  }
+  if (!colSizes.includes(0)) {
+    colSizes.push("100%");
+  }
+  return {
+    colSizes,
+    isSelectingCell: !!selectedCells,
+    minColumnWidth,
+    marginLeft
+  };
+};
+var useTableElement = () => {
+  const editor = index$1.useEditorRef();
+  const selectedCells = useTableStore().get.selectedCells();
+  useSelectedCells();
+  return {
+    props: {
+      onMouseDown: () => {
+        if (selectedCells) {
+          index$4.collapseSelection(editor);
+        }
+      }
+    },
+    colGroupProps: {
+      contentEditable: false,
+      style: { width: "100%" }
+    }
+  };
+};
+
+// src/merge/isTableRectangular.ts
+var allEqual = (arr) => arr.every((val) => val === arr[0]);
+var isTableRectangular = (table) => {
+  var _a;
+  const arr = [];
+  (_a = table == null ? void 0 : table.children) == null ? void 0 : _a.forEach((row, rI) => {
+    var _a2;
+    const rowEl = row;
+    (_a2 = rowEl.children) == null ? void 0 : _a2.forEach((cell) => {
+      const cellElem = cell;
+      Array.from({
+        length: getRowSpan(cellElem) || 1
+      }).forEach((_, i) => {
+        if (!arr[rI + i]) {
+          arr[rI + i] = 0;
+        }
+        arr[rI + i] += (cellElem == null ? void 0 : cellElem.colSpan) || 1;
+      });
+    });
+  });
+  return allEqual(arr);
+};
+var mergeTableCells = (editor) => {
+  index$4.withoutNormalizing(editor, () => {
+    var _a;
+    const { _cellIndices } = index$1.getPluginOptions(
+      editor,
+      ELEMENT_TABLE
+    );
+    const tableEntry = index$5.getBlockAbove(editor, {
+      at: (_a = editor.selection) == null ? void 0 : _a.anchor.path,
+      match: { type: index$1.getPluginType(editor, ELEMENT_TABLE) }
+    });
+    const cellEntries = getTableGridAbove(editor, { format: "cell" });
+    let colSpan = 0;
+    for (const entry of cellEntries) {
+      const [data, path] = entry;
+      const rowIndex = path.at(-2);
+      if (rowIndex === cellEntries[0][1].at(-2)) {
+        const cellColSpan = getColSpan(data);
+        colSpan += cellColSpan;
+      }
+    }
+    let rowSpan = 0;
+    const { col } = getCellIndices(
+      _cellIndices,
+      cellEntries[0][0]
+    );
+    cellEntries.forEach((cE) => {
+      const cell = cE[0];
+      const { col: curCol } = (_cellIndices == null ? void 0 : _cellIndices.get(cell)) || computeCellIndices(editor, tableEntry[0], cell);
+      if (col === curCol) {
+        rowSpan += getRowSpan(cell);
+      }
+    });
+    const contents = [];
+    for (const cellEntry of cellEntries) {
+      const [el] = cellEntry;
+      if (el.children.length !== 1 || !index$4.isElementEmpty(editor, el.children[0])) {
+        contents.push(...cloneDeep.default(el.children));
+      }
+    }
+    const cols = {};
+    cellEntries.forEach(([entry, path]) => {
+      const rowIndex = path.at(-2);
+      if (cols[rowIndex]) {
+        cols[rowIndex].push(path);
+      } else {
+        cols[rowIndex] = [path];
+      }
+    });
+    Object.values(cols).forEach((paths) => {
+      paths == null ? void 0 : paths.forEach(() => {
+        index$4.removeNodes(editor, { at: paths[0] });
+      });
+    });
+    const mergedCell = __spreadProps(__spreadValues({}, getEmptyCellNode(editor, {
+      header: cellEntries[0][0].type === index$1.getPluginType(editor, ELEMENT_TH),
+      newCellChildren: contents
+    })), {
+      colSpan,
+      rowSpan
+    });
+    index$5.insertElements(editor, mergedCell, { at: cellEntries[0][1] });
+    index$4.collapseSelection(editor);
+  });
+};
+var unmergeTableCells = (editor) => {
+  index$4.withoutNormalizing(editor, () => {
+    const { _cellIndices: cellIndices } = index$1.getPluginOptions(
+      editor,
+      ELEMENT_TABLE
+    );
+    const cellEntries = getTableGridAbove(editor, { format: "cell" });
+    const [[cellElem, path]] = cellEntries;
+    const createEmptyCell2 = (children) => {
+      return __spreadProps(__spreadValues({}, getEmptyCellNode(editor, {
+        header: cellElem.type === index$1.getPluginType(editor, ELEMENT_TH),
+        newCellChildren: children
+      })), {
+        colSpan: 1,
+        rowSpan: 1
+      });
+    };
+    const tablePath = path.slice(0, -2);
+    const cellPath = path.slice(-2);
+    const [rowPath, colPath] = cellPath;
+    const colSpan = getColSpan(cellElem);
+    const rowSpan = getRowSpan(cellElem);
+    const colPaths = [];
+    for (let i = 0; i < colSpan; i++) {
+      colPaths.push(colPath + i);
+    }
+    index$4.removeNodes(editor, { at: path });
+    const { col } = getCellIndices(
+      cellIndices,
+      cellElem
+    );
+    const getColPathForRow = (row) => {
+      let newColPath = 0;
+      const rowEntry = index$4.findNode(editor, {
+        at: [...tablePath, row],
+        match: { type: index$1.getPluginType(editor, ELEMENT_TR) }
+      });
+      if (!rowEntry) {
+        return newColPath;
+      }
+      const rowEl = rowEntry[0];
+      for (const item of rowEl.children) {
+        const { col: c } = getCellIndices(
+          cellIndices,
+          item
+        );
+        if (c === col - 1) {
+          newColPath = rowEl.children.indexOf(item) + 1;
+          break;
+        }
+        if (col + getColSpan(cellElem) === c - 1) {
+          newColPath = rowEl.children.indexOf(item);
+          break;
+        }
+      }
+      return newColPath;
+    };
+    for (let i = 0; i < rowSpan; i++) {
+      const currentRowPath = rowPath + i;
+      const pathForNextRows = getColPathForRow(currentRowPath);
+      const newRowChildren = [];
+      const _rowPath = [...tablePath, currentRowPath];
+      const rowEntry = index$4.findNode(editor, {
+        at: _rowPath,
+        match: { type: index$1.getPluginType(editor, ELEMENT_TABLE) }
+      });
+      for (let j = 0; j < colPaths.length; j++) {
+        const cellToInsert = i === 0 && j === 0 ? createEmptyCell2(cellElem.children) : createEmptyCell2();
+        if (rowEntry) {
+          const currentColPath = i === 0 ? colPaths[j] : pathForNextRows;
+          const pathForNewCell = [...tablePath, currentRowPath, currentColPath];
+          index$5.insertElements(editor, cellToInsert, { at: pathForNewCell });
+        } else {
+          newRowChildren.push(cellToInsert);
+        }
+      }
+      if (!rowEntry) {
+        index$5.insertElements(
+          editor,
+          {
+            type: index$1.getPluginType(editor, ELEMENT_TR),
+            children: newRowChildren
+          },
+          { at: _rowPath }
+        );
+      }
+    }
+  });
+};
+var useTableMergeState = () => {
+  const editorRef = index$1.useEditorRef();
+  const { enableMerging } = index$1.getPluginOptions(
+    editorRef,
+    ELEMENT_TABLE
+  );
+  if (!enableMerging)
+    return { canMerge: false, canUnmerge: false };
+  const readOnly = slateReact.useReadOnly();
+  const selected = slateReact.useSelected();
+  const selectionExpanded = index$1.useEditorSelector(index$5.isSelectionExpanded, []);
+  const collapsed = !readOnly && selected && !selectionExpanded;
+  const selectedTables = useTableStore().get.selectedTable();
+  const selectedTable = selectedTables == null ? void 0 : selectedTables[0];
+  const selectedCellEntries = index$1.useEditorSelector(
+    (editor) => getTableGridAbove(editor, {
+      format: "cell"
+    }),
+    []
+  );
+  const canMerge = !readOnly && selected && selectionExpanded && isTableRectangular(selectedTable);
+  const canUnmerge = collapsed && selectedCellEntries && selectedCellEntries.length === 1 && (getColSpan(selectedCellEntries[0][0]) > 1 || getRowSpan(selectedCellEntries[0][0]) > 1);
+  return { canMerge, canUnmerge };
+};
+
+exports.ELEMENT_TABLE = ELEMENT_TABLE;
+exports.ELEMENT_TD = ELEMENT_TD;
+exports.ELEMENT_TH = ELEMENT_TH;
+exports.ELEMENT_TR = ELEMENT_TR;
+exports.TableProvider = TableProvider;
+exports.computeAllCellIndices = computeAllCellIndices;
+exports.computeCellIndices = computeCellIndices;
+exports.findCellByIndexes = findCellByIndexes;
+exports.getCellIndices = getCellIndices;
+exports.getCellIndicesWithSpans = getCellIndicesWithSpans;
+exports.getCellTypes = getCellTypes;
+exports.getColSpan = getColSpan;
+exports.getEmptyCellNode = getEmptyCellNode;
+exports.getEmptyRowNode = getEmptyRowNode;
+exports.getEmptyTableNode = getEmptyTableNode;
+exports.getLeftTableCell = getLeftTableCell;
+exports.getOnSelectTableBorderFactory = getOnSelectTableBorderFactory;
+exports.getRowSpan = getRowSpan;
+exports.getTableCellBorders = getTableCellBorders;
+exports.getTableColumnCount = getTableColumnCount;
+exports.getTableColumnIndex = getTableColumnIndex;
+exports.getTableGridAbove = getTableGridAbove;
+exports.getTableGridByRange = getTableGridByRange;
+exports.getTableMergeGridByRange = getTableMergeGridByRange;
+exports.getTableOverriddenColSizes = getTableOverriddenColSizes;
+exports.getTableRowIndex = getTableRowIndex;
+exports.getTopTableCell = getTopTableCell;
+exports.isTableBorderHidden = isTableBorderHidden;
+exports.isTableRectangular = isTableRectangular;
+exports.mergeTableCells = mergeTableCells;
+exports.roundCellSizeToStep = roundCellSizeToStep;
+exports.setBorderSize = setBorderSize;
+exports.setTableColSize = setTableColSize;
+exports.setTableMarginLeft = setTableMarginLeft;
+exports.setTableRowSize = setTableRowSize;
+exports.tableStore = tableStore;
+exports.unmergeTableCells = unmergeTableCells;
+exports.useIsCellSelected = useIsCellSelected;
+exports.useOverrideColSize = useOverrideColSize;
+exports.useOverrideMarginLeft = useOverrideMarginLeft;
+exports.useOverrideRowSize = useOverrideRowSize;
+exports.useSelectedCells = useSelectedCells;
+exports.useTableBordersDropdownMenuContentState = useTableBordersDropdownMenuContentState;
+exports.useTableCellElement = useTableCellElement;
+exports.useTableCellElementResizable = useTableCellElementResizable;
+exports.useTableCellElementResizableState = useTableCellElementResizableState;
+exports.useTableCellElementState = useTableCellElementState;
+exports.useTableColSizes = useTableColSizes;
+exports.useTableElement = useTableElement;
+exports.useTableElementState = useTableElementState;
+exports.useTableMergeState = useTableMergeState;
+exports.useTableStore = useTableStore;