@lofcz/platejs-table 52.0.11

package/dist/react/index.js

@@ -0,0 +1,879 @@
+import { B as getTableOverriddenColSizes, Q as isSelectedCellBorder, V as getTableGridAbove, Y as getTableCellBorders, Z as getSelectedCellsBorders, _ as setTableMarginLeft, a as BaseTableRowPlugin, dt as getColSpan, g as setTableRowSize, i as BaseTablePlugin, j as isTableRectangular, lt as getCellIndices, n as BaseTableCellHeaderPlugin, nt as getSelectedCellsBoundingBox, ot as getLeftTableCell, r as BaseTableCellPlugin, rt as getRowSpan, st as getCellTypes, t as KEY_SHIFT_EDGES, tt as getTopTableCell, ut as computeCellIndices, v as setTableColSize, x as moveSelectionFromCell, y as setBorderSize } from "../constants-B6Sm9BNa.js";
+import { Hotkeys, KEYS, PathApi } from "platejs";
+import { atom, createAtomStore, toPlatePlugin, useEditorPlugin, useEditorRef, useEditorSelection, useEditorSelector, useElement, useElementSelector, usePluginOption, useReadOnly, useSelected } from "platejs/react";
+import { c } from "react-compiler-runtime";
+import React from "react";
+import { resizeLengthClampStatic } from "@platejs/resizable";
+
+//#region src/react/onKeyDownTable.ts
+const onKeyDownTable = ({ editor, event }) => {
+	if (event.defaultPrevented) return;
+	if (event.which === 229 && editor.selection && editor.api.isExpanded()) {
+		if (Array.from(editor.api.nodes({
+			at: editor.selection,
+			match: { type: getCellTypes(editor) }
+		})).length > 1) {
+			editor.tf.collapse({ edge: "end" });
+			return;
+		}
+	}
+	const isKeyDown = {
+		"shift+down": Hotkeys.isExtendDownward(event),
+		"shift+left": Hotkeys.isExtendBackward(event),
+		"shift+right": Hotkeys.isExtendForward(event),
+		"shift+up": Hotkeys.isExtendUpward(event)
+	};
+	Object.keys(isKeyDown).forEach((key) => {
+		if (isKeyDown[key] && moveSelectionFromCell(editor, {
+			edge: KEY_SHIFT_EDGES[key],
+			reverse: key === "shift+up"
+		})) {
+			event.preventDefault();
+			event.stopPropagation();
+		}
+	});
+};
+
+//#endregion
+//#region src/react/TablePlugin.tsx
+const TableRowPlugin = toPlatePlugin(BaseTableRowPlugin);
+const TableCellPlugin = toPlatePlugin(BaseTableCellPlugin);
+const TableCellHeaderPlugin = toPlatePlugin(BaseTableCellHeaderPlugin);
+/** Enables support for tables with React-specific features. */
+const TablePlugin = toPlatePlugin(BaseTablePlugin, {
+	handlers: { onKeyDown: onKeyDownTable },
+	plugins: [
+		TableRowPlugin,
+		TableCellPlugin,
+		TableCellHeaderPlugin
+	]
+});
+
+//#endregion
+//#region src/react/components/TableCellElement/getOnSelectTableBorderFactory.ts
+/** Helper: sets one cell's specific border(s) to `size`. */
+function setCellBorderSize(editor, cell, directions, size) {
+	const at = editor.api.findPath(cell);
+	if (!at) return;
+	if (directions === "all") setBorderSize(editor, size, {
+		at,
+		border: "all"
+	});
+	else for (const dir of directions) setBorderSize(editor, size, {
+		at,
+		border: dir
+	});
+}
+/**
+* Toggle logic for `'none'`, `'outer'`, `'top'|'bottom'|'left'|'right'`.
+* `'none'` toggles no borders ↔ all borders, `'outer'` toggles the bounding
+* rectangle's outer edges on/off, `'top'|'bottom'|'left'|'right'` toggles only
+* that side of the bounding rect.
+*/
+function setSelectedCellsBorder(editor, { border, cells }) {
+	if (cells.length === 0) return;
+	if (border === "none") {
+		const { none: allNone } = getSelectedCellsBorders(editor, cells);
+		const newSize$1 = allNone ? 1 : 0;
+		for (const cell of cells) {
+			const cellPath = editor.api.findPath(cell);
+			if (!cellPath) continue;
+			const { col, row } = getCellIndices(editor, cell);
+			const edges = [];
+			if (row === 0) edges.push("top");
+			if (col === 0) edges.push("left");
+			edges.push("bottom", "right");
+			if (row > 0) {
+				const cellAboveEntry = getTopTableCell(editor, { at: cellPath });
+				if (cellAboveEntry) {
+					const [cellAbove] = cellAboveEntry;
+					setCellBorderSize(editor, cellAbove, ["bottom"], newSize$1);
+				}
+			}
+			if (col > 0) {
+				const prevCellEntry = getLeftTableCell(editor, { at: cellPath });
+				if (prevCellEntry) {
+					const [prevCell] = prevCellEntry;
+					setCellBorderSize(editor, prevCell, ["right"], newSize$1);
+				}
+			}
+			if (edges.length > 0) setCellBorderSize(editor, cell, edges, newSize$1);
+		}
+		return;
+	}
+	if (border === "outer") {
+		const { outer: allOut } = getSelectedCellsBorders(editor, cells);
+		const newSize$1 = allOut ? 0 : 1;
+		const { maxCol: maxCol$1, maxRow: maxRow$1, minCol: minCol$1, minRow: minRow$1 } = getSelectedCellsBoundingBox(editor, cells);
+		for (const cell of cells) {
+			const { col, row } = getCellIndices(editor, cell);
+			const cSpan = getColSpan(cell);
+			const rSpan = getRowSpan(cell);
+			for (let rr = row; rr < row + rSpan; rr++) for (let cc = col; cc < col + cSpan; cc++) {
+				const edges = [];
+				if (rr === minRow$1) edges.push("top");
+				if (rr === maxRow$1) edges.push("bottom");
+				if (cc === minCol$1) edges.push("left");
+				if (cc === maxCol$1) edges.push("right");
+				if (edges.length > 0) setCellBorderSize(editor, cell, edges, newSize$1);
+			}
+		}
+		return;
+	}
+	const newSize = isSelectedCellBorder(editor, cells, border) ? 0 : 1;
+	const { maxCol, maxRow, minCol, minRow } = getSelectedCellsBoundingBox(editor, cells);
+	for (const cell of cells) {
+		const { col, row } = getCellIndices(editor, cell);
+		const cSpan = getColSpan(cell);
+		const rSpan = getRowSpan(cell);
+		const cellPath = editor.api.findPath(cell);
+		if (!cellPath) continue;
+		const edges = [];
+		if (border === "top" && row === minRow) if (row === 0) edges.push("top");
+		else {
+			const cellAboveEntry = getTopTableCell(editor, { at: cellPath });
+			if (cellAboveEntry) {
+				const [cellAbove] = cellAboveEntry;
+				setCellBorderSize(editor, cellAbove, ["bottom"], newSize);
+			}
+		}
+		if (border === "bottom" && row + rSpan - 1 === maxRow) edges.push("bottom");
+		if (border === "left" && col === minCol) if (col === 0) edges.push("left");
+		else {
+			const prevCellEntry = getLeftTableCell(editor, { at: cellPath });
+			if (prevCellEntry) {
+				const [prevCell] = prevCellEntry;
+				setCellBorderSize(editor, prevCell, ["right"], newSize);
+			}
+		}
+		if (border === "right" && col + cSpan - 1 === maxCol) edges.push("right");
+		if (edges.length > 0) setCellBorderSize(editor, cell, edges, newSize);
+	}
+}
+/**
+* Returns a function that sets borders on the selection with toggling logic. If
+* selection has one or many cells, it's the same approach: we read the bounding
+* rectangle, then decide which edges to flip on/off.
+*/
+const getOnSelectTableBorderFactory = (editor, selectedCells) => (border) => () => {
+	let cells = selectedCells;
+	if (!cells || cells.length === 0) {
+		const cell = editor.api.block({ match: { type: getCellTypes(editor) } });
+		if (cell) cells = [cell[0]];
+		else return;
+	}
+	setSelectedCellsBorder(editor, {
+		border,
+		cells: cells.map((v) => v)
+	});
+};
+
+//#endregion
+//#region src/react/components/TableCellElement/roundCellSizeToStep.ts
+/**
+* Rounds a cell size to the nearest step, or returns the size if the step is
+* not set.
+*/
+const roundCellSizeToStep = (size, step) => step ? Math.round(size / step) * step : size;
+
+//#endregion
+//#region src/react/components/TableCellElement/useIsCellSelected.ts
+const useIsCellSelected = (element) => {
+	const $ = c(3);
+	const selectedCells = usePluginOption(TablePlugin, "selectedCells");
+	let t0;
+	if ($[0] !== element || $[1] !== selectedCells) {
+		t0 = selectedCells?.includes(element);
+		$[0] = element;
+		$[1] = selectedCells;
+		$[2] = t0;
+	} else t0 = $[2];
+	return !!t0;
+};
+
+//#endregion
+//#region src/react/components/TableCellElement/useTableBordersDropdownMenuContentState.ts
+const useTableBordersDropdownMenuContentState = (t0) => {
+	const $ = c(18);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { element: el } = t1;
+	const { editor } = useEditorPlugin(TablePlugin);
+	const element = useElement() ?? el;
+	const selectedCells = usePluginOption(TablePlugin, "selectedCells");
+	let t2;
+	if ($[2] !== selectedCells) {
+		t2 = (editor_0) => getSelectedCellsBorders(editor_0, selectedCells);
+		$[2] = selectedCells;
+		$[3] = t2;
+	} else t2 = $[3];
+	let t3;
+	if ($[4] !== element || $[5] !== selectedCells) {
+		t3 = [selectedCells, element];
+		$[4] = element;
+		$[5] = selectedCells;
+		$[6] = t3;
+	} else t3 = $[6];
+	const borderStates = useEditorSelector(t2, t3);
+	let t4;
+	if ($[7] !== editor || $[8] !== selectedCells) {
+		t4 = getOnSelectTableBorderFactory(editor, selectedCells);
+		$[7] = editor;
+		$[8] = selectedCells;
+		$[9] = t4;
+	} else t4 = $[9];
+	let t5;
+	if ($[10] !== borderStates.bottom || $[11] !== borderStates.left || $[12] !== borderStates.none || $[13] !== borderStates.outer || $[14] !== borderStates.right || $[15] !== borderStates.top || $[16] !== t4) {
+		t5 = {
+			getOnSelectTableBorder: t4,
+			hasBottomBorder: borderStates.bottom,
+			hasLeftBorder: borderStates.left,
+			hasNoBorders: borderStates.none,
+			hasOuterBorders: borderStates.outer,
+			hasRightBorder: borderStates.right,
+			hasTopBorder: borderStates.top
+		};
+		$[10] = borderStates.bottom;
+		$[11] = borderStates.left;
+		$[12] = borderStates.none;
+		$[13] = borderStates.outer;
+		$[14] = borderStates.right;
+		$[15] = borderStates.top;
+		$[16] = t4;
+		$[17] = t5;
+	} else t5 = $[17];
+	return t5;
+};
+
+//#endregion
+//#region src/react/hooks/useCellIndices.ts
+const useCellIndices = () => {
+	const $ = c(5);
+	const { editor } = useEditorPlugin(TablePlugin);
+	const element = useElement();
+	const cellIndices = usePluginOption(TablePlugin, "cellIndices", element.id);
+	let t0;
+	bb0: {
+		if (!cellIndices) {
+			let t1$1;
+			if ($[0] !== editor || $[1] !== element) {
+				t1$1 = computeCellIndices(editor, { cellNode: element }) ?? {
+					col: 0,
+					row: 0
+				};
+				$[0] = editor;
+				$[1] = element;
+				$[2] = t1$1;
+			} else t1$1 = $[2];
+			t0 = t1$1;
+			break bb0;
+		}
+		let t1;
+		if ($[3] !== cellIndices) {
+			t1 = cellIndices ?? {
+				col: 0,
+				row: 0
+			};
+			$[3] = cellIndices;
+			$[4] = t1;
+		} else t1 = $[4];
+		t0 = t1;
+	}
+	return t0;
+};
+
+//#endregion
+//#region src/react/components/TableCellElement/useTableCellBorders.ts
+function useTableCellBorders(t0) {
+	const $ = c(6);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { element: el } = t1;
+	const { editor } = useEditorPlugin(TablePlugin);
+	const element = useElement() ?? el;
+	const cellIndices = useCellIndices();
+	let t2;
+	if ($[2] !== cellIndices || $[3] !== editor || $[4] !== element) {
+		t2 = getTableCellBorders(editor, {
+			cellIndices,
+			element
+		});
+		$[2] = cellIndices;
+		$[3] = editor;
+		$[4] = element;
+		$[5] = t2;
+	} else t2 = $[5];
+	return t2;
+}
+
+//#endregion
+//#region src/react/stores/useTableStore.ts
+const { TableProvider, tableStore, useTableSet, useTableState, useTableStore, useTableValue } = createAtomStore({
+	colSizeOverrides: atom(/* @__PURE__ */ new Map()),
+	marginLeftOverride: null,
+	rowSizeOverrides: atom(/* @__PURE__ */ new Map())
+}, { name: "table" });
+const useOverrideSizeFactory = (setOverrides) => {
+	const $ = c(2);
+	let t0;
+	if ($[0] !== setOverrides) {
+		t0 = (index, size) => {
+			setOverrides((overrides) => {
+				const newOverrides = new Map(overrides);
+				if (size === null) newOverrides.delete(index);
+				else newOverrides.set(index, size);
+				return newOverrides;
+			});
+		};
+		$[0] = setOverrides;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+};
+const useOverrideColSize = () => {
+	return useOverrideSizeFactory(useTableSet("colSizeOverrides"));
+};
+const useOverrideRowSize = () => {
+	return useOverrideSizeFactory(useTableSet("rowSizeOverrides"));
+};
+const useOverrideMarginLeft = () => {
+	return useTableSet("marginLeftOverride");
+};
+
+//#endregion
+//#region src/react/components/TableElement/useSelectedCells.ts
+/**
+* Many grid cells above and diff -> set No many grid cells above and diff ->
+* unset No selection -> unset
+*/
+const useSelectedCells = () => {
+	const $ = c(20);
+	const readOnly = useReadOnly();
+	const selected = useSelected();
+	const editor = useEditorRef();
+	const selection = useEditorSelection();
+	const { setOption } = useEditorPlugin(TablePlugin);
+	const selectedCells = usePluginOption(TablePlugin, "selectedCells");
+	let t0;
+	if ($[0] !== readOnly || $[1] !== selected || $[2] !== setOption) {
+		t0 = () => {
+			if (!selected || readOnly) {
+				setOption("selectedCells", null);
+				setOption("selectedTables", null);
+			}
+		};
+		$[0] = readOnly;
+		$[1] = selected;
+		$[2] = setOption;
+		$[3] = t0;
+	} else t0 = $[3];
+	let t1;
+	if ($[4] !== editor || $[5] !== readOnly || $[6] !== selected || $[7] !== setOption) {
+		t1 = [
+			selected,
+			editor,
+			readOnly,
+			setOption
+		];
+		$[4] = editor;
+		$[5] = readOnly;
+		$[6] = selected;
+		$[7] = setOption;
+		$[8] = t1;
+	} else t1 = $[8];
+	React.useEffect(t0, t1);
+	let t2;
+	if ($[9] !== editor || $[10] !== readOnly || $[11] !== selectedCells || $[12] !== setOption) {
+		t2 = () => {
+			if (readOnly) return;
+			const tableEntries = getTableGridAbove(editor, { format: "table" });
+			const cellEntries = getTableGridAbove(editor, { format: "cell" });
+			if (cellEntries?.length > 1) {
+				const cells = cellEntries.map(_temp$3);
+				const tables = tableEntries.map(_temp2);
+				if (JSON.stringify(cells) !== JSON.stringify(selectedCells)) {
+					setOption("selectedCells", cells);
+					setOption("selectedTables", tables);
+				}
+			} else if (selectedCells) {
+				setOption("selectedCells", null);
+				setOption("selectedTables", null);
+			}
+		};
+		$[9] = editor;
+		$[10] = readOnly;
+		$[11] = selectedCells;
+		$[12] = setOption;
+		$[13] = t2;
+	} else t2 = $[13];
+	let t3;
+	if ($[14] !== editor || $[15] !== readOnly || $[16] !== selectedCells || $[17] !== selection || $[18] !== setOption) {
+		t3 = [
+			editor,
+			selection,
+			readOnly,
+			selectedCells,
+			setOption
+		];
+		$[14] = editor;
+		$[15] = readOnly;
+		$[16] = selectedCells;
+		$[17] = selection;
+		$[18] = setOption;
+		$[19] = t3;
+	} else t3 = $[19];
+	React.useEffect(t2, t3);
+};
+function _temp$3(entry) {
+	return entry[0];
+}
+function _temp2(entry_0) {
+	return entry_0[0];
+}
+
+//#endregion
+//#region src/react/components/TableElement/useTableColSizes.ts
+/**
+* Returns colSizes with overrides applied. Unset node.colSizes if `colCount`
+* updates to 1.
+*/
+const useTableColSizes = (t0) => {
+	const $ = c(8);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { disableOverrides: t2, transformColSizes } = t1;
+	const disableOverrides = t2 === void 0 ? false : t2;
+	const colSizeOverrides = useTableValue("colSizeOverrides");
+	let t3;
+	let t4;
+	if ($[2] !== colSizeOverrides || $[3] !== disableOverrides || $[4] !== transformColSizes) {
+		t3 = (t5$1) => {
+			const [tableNode] = t5$1;
+			const colSizes = getTableOverriddenColSizes(tableNode, disableOverrides ? void 0 : colSizeOverrides);
+			if (transformColSizes) return transformColSizes(colSizes);
+			return colSizes;
+		};
+		t4 = [
+			disableOverrides,
+			colSizeOverrides,
+			transformColSizes
+		];
+		$[2] = colSizeOverrides;
+		$[3] = disableOverrides;
+		$[4] = transformColSizes;
+		$[5] = t3;
+		$[6] = t4;
+	} else {
+		t3 = $[5];
+		t4 = $[6];
+	}
+	let t5;
+	if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = {
+			key: KEYS.table,
+			equalityFn: _temp$2
+		};
+		$[7] = t5;
+	} else t5 = $[7];
+	return useElementSelector(t3, t4, t5);
+};
+function _temp$2(a, b) {
+	return !!a && !!b && PathApi.equals(a, b);
+}
+
+//#endregion
+//#region src/react/components/TableElement/useTableElement.ts
+const useTableElement = () => {
+	const $ = c(7);
+	const { editor, getOptions } = useEditorPlugin(TablePlugin);
+	const { disableMarginLeft } = getOptions();
+	const element = useElement();
+	const selectedCells = usePluginOption(TablePlugin, "selectedCells");
+	const marginLeftOverride = useTableValue("marginLeftOverride");
+	const marginLeft = disableMarginLeft ? 0 : marginLeftOverride ?? element.marginLeft ?? 0;
+	useSelectedCells();
+	const t0 = !!selectedCells;
+	let t1;
+	if ($[0] !== editor || $[1] !== selectedCells) {
+		t1 = { onMouseDown: () => {
+			if (selectedCells) editor.tf.collapse();
+		} };
+		$[0] = editor;
+		$[1] = selectedCells;
+		$[2] = t1;
+	} else t1 = $[2];
+	let t2;
+	if ($[3] !== marginLeft || $[4] !== t0 || $[5] !== t1) {
+		t2 = {
+			isSelectingCell: t0,
+			marginLeft,
+			props: t1
+		};
+		$[3] = marginLeft;
+		$[4] = t0;
+		$[5] = t1;
+		$[6] = t2;
+	} else t2 = $[6];
+	return t2;
+};
+
+//#endregion
+//#region src/react/components/TableCellElement/useTableCellSize.ts
+function useTableCellSize(t0) {
+	const $ = c(10);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { element: el } = t1;
+	const { api } = useEditorPlugin(TablePlugin);
+	const element = useElement() ?? el;
+	const colSizes = useTableColSizes();
+	const cellIndices = useCellIndices();
+	let t2;
+	let t3;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = [];
+		t3 = { key: KEYS.tr };
+		$[2] = t2;
+		$[3] = t3;
+	} else {
+		t2 = $[2];
+		t3 = $[3];
+	}
+	const rowSize = useElementSelector(_temp$1, t2, t3);
+	let t4;
+	if ($[4] !== api.table || $[5] !== cellIndices || $[6] !== colSizes || $[7] !== element || $[8] !== rowSize) {
+		t4 = api.table.getCellSize({
+			cellIndices,
+			colSizes,
+			element,
+			rowSize
+		});
+		$[4] = api.table;
+		$[5] = cellIndices;
+		$[6] = colSizes;
+		$[7] = element;
+		$[8] = rowSize;
+		$[9] = t4;
+	} else t4 = $[9];
+	return t4;
+}
+function _temp$1(t0) {
+	const [node] = t0;
+	return node.size;
+}
+
+//#endregion
+//#region src/react/components/TableCellElement/useTableCellElement.ts
+const useTableCellElement = () => {
+	const { api, setOption } = useEditorPlugin(TablePlugin);
+	const element = useElement();
+	const isCellSelected = useIsCellSelected(element);
+	const selectedCells = usePluginOption(TablePlugin, "selectedCells");
+	React.useEffect(() => {
+		if (selectedCells?.some((v) => v.id === element.id && element !== v)) setOption("selectedCells", selectedCells.map((v) => v.id === element.id ? element : v));
+	}, [element]);
+	const rowSizeOverrides = useTableValue("rowSizeOverrides");
+	const { minHeight, width } = useTableCellSize({ element });
+	const borders = useTableCellBorders({ element });
+	/**
+	* Row size: if rowSpan > 1, we might look up the rowSize for the bottom row
+	* or you can do something simpler if row-spanning is unusual in your app.
+	*/
+	const { col, row } = useCellIndices();
+	const colSpan = api.table.getColSpan(element);
+	const endingRowIndex = row + api.table.getRowSpan(element) - 1;
+	return {
+		borders,
+		colIndex: col + colSpan - 1,
+		colSpan,
+		isSelectingCell: !!selectedCells,
+		minHeight: rowSizeOverrides.get?.(endingRowIndex) ?? minHeight,
+		rowIndex: endingRowIndex,
+		selected: isCellSelected,
+		width
+	};
+};
+
+//#endregion
+//#region src/react/components/TableCellElement/useTableCellElementResizable.ts
+const useTableCellElementResizable = (t0) => {
+	const $ = c(57);
+	const { colIndex, colSpan, rowIndex, step, stepX: t1, stepY: t2 } = t0;
+	const stepX = t1 === void 0 ? step : t1;
+	const stepY = t2 === void 0 ? step : t2;
+	const { editor, getOptions } = useEditorPlugin(TablePlugin);
+	const element = useElement();
+	let t3;
+	if ($[0] !== getOptions) {
+		t3 = getOptions();
+		$[0] = getOptions;
+		$[1] = t3;
+	} else t3 = $[1];
+	const { disableMarginLeft, minColumnWidth: t4 } = t3;
+	const minColumnWidth = t4 === void 0 ? 0 : t4;
+	let t5;
+	let t6;
+	if ($[2] !== colIndex || $[3] !== colSpan) {
+		t5 = (t7$1) => {
+			const [node] = t7$1;
+			return colSpan > 1 ? node.colSizes?.[colIndex] : void 0;
+		};
+		t6 = [colSpan, colIndex];
+		$[2] = colIndex;
+		$[3] = colSpan;
+		$[4] = t5;
+		$[5] = t6;
+	} else {
+		t5 = $[4];
+		t6 = $[5];
+	}
+	let t7;
+	if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+		t7 = { key: KEYS.table };
+		$[6] = t7;
+	} else t7 = $[6];
+	const initialWidth = useElementSelector(t5, t6, t7);
+	let t8;
+	let t9;
+	if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+		t8 = [];
+		t9 = { key: KEYS.table };
+		$[7] = t8;
+		$[8] = t9;
+	} else {
+		t8 = $[7];
+		t9 = $[8];
+	}
+	const marginLeft = useElementSelector(_temp, t8, t9);
+	let t10;
+	if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+		t10 = { disableOverrides: true };
+		$[9] = t10;
+	} else t10 = $[9];
+	const colSizesWithoutOverrides = useTableColSizes(t10);
+	const colSizesWithoutOverridesRef = React.useRef(colSizesWithoutOverrides);
+	let t11;
+	let t12;
+	if ($[10] !== colSizesWithoutOverrides) {
+		t11 = () => {
+			colSizesWithoutOverridesRef.current = colSizesWithoutOverrides;
+		};
+		t12 = [colSizesWithoutOverrides];
+		$[10] = colSizesWithoutOverrides;
+		$[11] = t11;
+		$[12] = t12;
+	} else {
+		t11 = $[11];
+		t12 = $[12];
+	}
+	React.useEffect(t11, t12);
+	const overrideColSize = useOverrideColSize();
+	const overrideRowSize = useOverrideRowSize();
+	const overrideMarginLeft = useOverrideMarginLeft();
+	let t13;
+	if ($[13] !== editor || $[14] !== element || $[15] !== overrideColSize) {
+		t13 = (colIndex_0, width) => {
+			setTableColSize(editor, {
+				colIndex: colIndex_0,
+				width
+			}, { at: element });
+			setTimeout(() => overrideColSize(colIndex_0, null), 0);
+		};
+		$[13] = editor;
+		$[14] = element;
+		$[15] = overrideColSize;
+		$[16] = t13;
+	} else t13 = $[16];
+	const setColSize = t13;
+	let t14;
+	if ($[17] !== editor || $[18] !== element || $[19] !== overrideRowSize) {
+		t14 = (rowIndex_0, height) => {
+			setTableRowSize(editor, {
+				height,
+				rowIndex: rowIndex_0
+			}, { at: element });
+			setTimeout(() => overrideRowSize(rowIndex_0, null), 0);
+		};
+		$[17] = editor;
+		$[18] = element;
+		$[19] = overrideRowSize;
+		$[20] = t14;
+	} else t14 = $[20];
+	const setRowSize = t14;
+	let t15;
+	if ($[21] !== editor || $[22] !== element || $[23] !== overrideMarginLeft) {
+		t15 = (marginLeft_0) => {
+			setTableMarginLeft(editor, { marginLeft: marginLeft_0 }, { at: element });
+			setTimeout(() => overrideMarginLeft(null), 0);
+		};
+		$[21] = editor;
+		$[22] = element;
+		$[23] = overrideMarginLeft;
+		$[24] = t15;
+	} else t15 = $[24];
+	const setMarginLeft = t15;
+	let t16;
+	if ($[25] !== colIndex || $[26] !== minColumnWidth || $[27] !== overrideColSize || $[28] !== setColSize || $[29] !== stepX) {
+		t16 = (t17$1) => {
+			const { delta, finished, initialSize: currentInitial } = t17$1;
+			const nextInitial = colSizesWithoutOverridesRef.current[colIndex + 1];
+			const complement = (width_0) => currentInitial + nextInitial - width_0;
+			const currentNew = roundCellSizeToStep(resizeLengthClampStatic(currentInitial + delta, {
+				max: nextInitial ? complement(minColumnWidth) : void 0,
+				min: minColumnWidth
+			}), stepX);
+			const nextNew = nextInitial ? complement(currentNew) : void 0;
+			const fn = finished ? setColSize : overrideColSize;
+			fn(colIndex, currentNew);
+			if (nextNew) fn(colIndex + 1, nextNew);
+		};
+		$[25] = colIndex;
+		$[26] = minColumnWidth;
+		$[27] = overrideColSize;
+		$[28] = setColSize;
+		$[29] = stepX;
+		$[30] = t16;
+	} else t16 = $[30];
+	const handleResizeRight = t16;
+	let t17;
+	if ($[31] !== overrideRowSize || $[32] !== rowIndex || $[33] !== setRowSize || $[34] !== stepY) {
+		t17 = (event) => {
+			const newHeight = roundCellSizeToStep(event.initialSize + event.delta, stepY);
+			if (event.finished) setRowSize(rowIndex, newHeight);
+			else overrideRowSize(rowIndex, newHeight);
+		};
+		$[31] = overrideRowSize;
+		$[32] = rowIndex;
+		$[33] = setRowSize;
+		$[34] = stepY;
+		$[35] = t17;
+	} else t17 = $[35];
+	const handleResizeBottom = t17;
+	let t18;
+	if ($[36] !== colIndex || $[37] !== marginLeft || $[38] !== minColumnWidth || $[39] !== overrideColSize || $[40] !== overrideMarginLeft || $[41] !== setColSize || $[42] !== setMarginLeft || $[43] !== stepX) {
+		t18 = (event_0) => {
+			const initial = colSizesWithoutOverridesRef.current[colIndex];
+			const complement_0 = (width_1) => initial + marginLeft - width_1;
+			const newMargin = roundCellSizeToStep(resizeLengthClampStatic(marginLeft + event_0.delta, {
+				max: complement_0(minColumnWidth),
+				min: 0
+			}), stepX);
+			const newWidth = complement_0(newMargin);
+			if (event_0.finished) {
+				setMarginLeft(newMargin);
+				setColSize(colIndex, newWidth);
+			} else {
+				overrideMarginLeft(newMargin);
+				overrideColSize(colIndex, newWidth);
+			}
+		};
+		$[36] = colIndex;
+		$[37] = marginLeft;
+		$[38] = minColumnWidth;
+		$[39] = overrideColSize;
+		$[40] = overrideMarginLeft;
+		$[41] = setColSize;
+		$[42] = setMarginLeft;
+		$[43] = stepX;
+		$[44] = t18;
+	} else t18 = $[44];
+	const handleResizeLeft = t18;
+	const hasLeftHandle = colIndex === 0 && !disableMarginLeft;
+	let t19;
+	if ($[45] !== handleResizeBottom) {
+		t19 = { options: {
+			direction: "bottom",
+			onResize: handleResizeBottom
+		} };
+		$[45] = handleResizeBottom;
+		$[46] = t19;
+	} else t19 = $[46];
+	const t20 = t19;
+	const t21 = !hasLeftHandle;
+	let t22;
+	if ($[47] !== handleResizeLeft) {
+		t22 = { options: {
+			direction: "left",
+			onResize: handleResizeLeft
+		} };
+		$[47] = handleResizeLeft;
+		$[48] = t22;
+	} else t22 = $[48];
+	const t23 = t22;
+	let t24;
+	if ($[49] !== handleResizeRight || $[50] !== initialWidth) {
+		t24 = { options: {
+			direction: "right",
+			initialSize: initialWidth,
+			onResize: handleResizeRight
+		} };
+		$[49] = handleResizeRight;
+		$[50] = initialWidth;
+		$[51] = t24;
+	} else t24 = $[51];
+	const t25 = t24;
+	let t26;
+	if ($[52] !== t20 || $[53] !== t21 || $[54] !== t23 || $[55] !== t25) {
+		t26 = {
+			bottomProps: t20,
+			hiddenLeft: t21,
+			leftProps: t23,
+			rightProps: t25
+		};
+		$[52] = t20;
+		$[53] = t21;
+		$[54] = t23;
+		$[55] = t25;
+		$[56] = t26;
+	} else t26 = $[56];
+	return t26;
+};
+function _temp(t0) {
+	const [node_0] = t0;
+	return node_0.marginLeft ?? 0;
+}
+
+//#endregion
+//#region src/react/hooks/useTableMergeState.ts
+const useTableMergeState = () => {
+	const { api, getOptions } = useEditorPlugin(TablePlugin);
+	const { disableMerge } = getOptions();
+	if (disableMerge) return {
+		canMerge: false,
+		canSplit: false
+	};
+	const readOnly = useReadOnly();
+	const someTable = useEditorSelector((editor) => editor.api.some({ match: { type: KEYS.table } }), []);
+	const selectionExpanded = useEditorSelector((editor) => editor.api.isExpanded(), []);
+	const collapsed = !readOnly && someTable && !selectionExpanded;
+	const selectedTable = usePluginOption(TablePlugin, "selectedTables")?.[0];
+	const selectedCellEntries = useEditorSelector((editor) => getTableGridAbove(editor, { format: "cell" }), []);
+	if (!selectedCellEntries) return {
+		canMerge: false,
+		canSplit: false
+	};
+	return {
+		canMerge: !readOnly && someTable && selectionExpanded && selectedCellEntries.length > 1 && isTableRectangular(selectedTable),
+		canSplit: collapsed && selectedCellEntries.length === 1 && (api.table.getColSpan(selectedCellEntries[0][0]) > 1 || api.table.getRowSpan(selectedCellEntries[0][0]) > 1)
+	};
+};
+
+//#endregion
+export { TableCellHeaderPlugin, TableCellPlugin, TablePlugin, TableProvider, TableRowPlugin, getOnSelectTableBorderFactory, onKeyDownTable, roundCellSizeToStep, setSelectedCellsBorder, tableStore, useCellIndices, useIsCellSelected, useOverrideColSize, useOverrideMarginLeft, useOverrideRowSize, useSelectedCells, useTableBordersDropdownMenuContentState, useTableCellBorders, useTableCellElement, useTableCellElementResizable, useTableCellSize, useTableColSizes, useTableElement, useTableMergeState, useTableSet, useTableState, useTableStore, useTableValue };
+//# sourceMappingURL=index.js.map