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

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

@@ -1,1371 +0,0 @@
-'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;