@lofcz/platejs-table 52.0.11 → 52.3.6

package/dist/{constants-B6Sm9BNa.js → constants-DGdhsla3.js}

@@ -1,4 +1,4 @@
-import { ElementApi, KEYS, NodeApi, PathApi, PointApi, RangeApi, TextApi, bindFirst, combineTransformMatchOptions, createSlatePlugin, createTSlatePlugin, getEditorPlugin, getPluginTypes, isHotkey } from "platejs";
+import { ElementApi, KEYS, NodeApi, PathApi, PointApi, RangeApi, TextApi, bindFirst, combineTransformMatchOptions, createSlatePlugin, createTSlatePlugin, getEditorPlugin, getPluginTypes } from "platejs";
 import cloneDeep from "lodash/cloneDeep.js";
 
 //#region src/lib/api/getEmptyCellNode.ts
@@ -34,30 +34,6 @@ const getEmptyTableNode = (editor, { colCount, header, rowCount = 0, ...cellOpti
 	};
 };
 
-//#endregion
-//#region src/lib/queries/getCellInNextTableRow.ts
-const getCellInNextTableRow = (editor, currentRowPath) => {
-	const nextRow = editor.api.node(PathApi.next(currentRowPath));
-	if (!nextRow) return;
-	const [nextRowNode, nextRowPath] = nextRow;
-	const nextCell = nextRowNode?.children?.[0];
-	const nextCellPath = nextRowPath.concat(0);
-	if (nextCell && nextCellPath) return editor.api.node(nextCellPath);
-};
-
-//#endregion
-//#region src/lib/queries/getCellInPreviousTableRow.ts
-const getCellInPreviousTableRow = (editor, currentRowPath) => {
-	const prevPath = PathApi.previous(currentRowPath);
-	if (!prevPath) return;
-	const previousRow = editor.api.node(prevPath);
-	if (!previousRow) return;
-	const [previousRowNode, previousRowPath] = previousRow;
-	const previousCell = previousRowNode?.children?.[previousRowNode.children.length - 1];
-	const previousCellPath = previousRowPath.concat(previousRowNode.children.length - 1);
-	if (previousCell && previousCellPath) return editor.api.node(previousCellPath);
-};
-
 //#endregion
 //#region src/lib/queries/getColSpan.ts
 /**
@@ -67,6 +43,22 @@ const getCellInPreviousTableRow = (editor, currentRowPath) => {
 */
 const getColSpan = (cellElem) => cellElem.colSpan || Number(cellElem.attributes?.colspan) || 1;
 
+//#endregion
+//#region src/lib/queries/getRowSpan.ts
+/**
+* Returns the rowspan attribute of the table cell element.
+*
+* @default 1 if undefined
+*/
+const getRowSpan = (cellElem) => cellElem.rowSpan || Number(cellElem.attributes?.rowspan) || 1;
+
+//#endregion
+//#region src/lib/merge/getCellIndicesWithSpans.ts
+const getCellIndicesWithSpans = ({ col, row }, endCell) => ({
+	col: col + getColSpan(endCell) - 1,
+	row: row + getRowSpan(endCell) - 1
+});
+
 //#endregion
 //#region src/lib/utils/computeCellIndices.ts
 function computeCellIndices(editor, { all, cellNode, tableNode }) {
@@ -142,17 +134,100 @@ const getCellRowIndexByPath = (cellPath) => {
 const getCellTypes = (editor) => getPluginTypes(editor, [KEYS.td, KEYS.th]);
 
 //#endregion
-//#region src/lib/queries/getLeftTableCell.ts
-const getLeftTableCell = (editor, { at: cellPath } = {}) => {
-	if (!cellPath) {
-		cellPath = editor.api.node({ match: { type: getCellTypes(editor) } })?.[1];
-		if (!cellPath) return;
-	}
-	if (!cellPath.at(-1)) return;
-	const prevCellPath = PathApi.previous(cellPath);
-	return editor.api.node(prevCellPath);
+//#region src/lib/queries/getTableEntries.ts
+/**
+* If at (default = selection) is in table>tr>td|th, return table, row, and cell
+* node entries.
+*/
+const getTableEntries = (editor, { at = editor.selection } = {}) => {
+	if (!at) return;
+	const cellEntry = editor.api.node({
+		at,
+		match: { type: getCellTypes(editor) }
+	});
+	if (!cellEntry) return;
+	const [, cellPath] = cellEntry;
+	const rowEntry = editor.api.above({
+		at: cellPath,
+		match: { type: editor.getType(KEYS.tr) }
+	});
+	if (!rowEntry) return;
+	const [, rowPath] = rowEntry;
+	const tableEntry = editor.api.above({
+		at: rowPath,
+		match: { type: editor.getType(KEYS.table) }
+	});
+	if (!tableEntry) return;
+	return {
+		cell: cellEntry,
+		row: rowEntry,
+		table: tableEntry
+	};
 };
 
+//#endregion
+//#region src/lib/queries/getAdjacentTableCell.ts
+const adjacentTableCellLookup = /* @__PURE__ */ new WeakMap();
+const getLookupKey = (row, col) => `${row}:${col}`;
+const createTableCellLookup = (editor, tableEntry) => {
+	const [table, tablePath] = tableEntry;
+	const cachedLookup = adjacentTableCellLookup.get(table);
+	if (cachedLookup) return cachedLookup;
+	const nextLookup = /* @__PURE__ */ new Map();
+	table.children.forEach((rowNode, rowIndex) => {
+		rowNode.children.forEach((cellNode, cellIndex) => {
+			const cellEntry = [cellNode, tablePath.concat([rowIndex, cellIndex])];
+			const indices = getCellIndices(editor, cellEntry[0]);
+			const { col: endCol, row: endRow } = getCellIndicesWithSpans(indices, cellEntry[0]);
+			for (let row = indices.row; row <= endRow; row++) for (let col = indices.col; col <= endCol; col++) nextLookup.set(getLookupKey(row, col), cellEntry);
+		});
+	});
+	adjacentTableCellLookup.set(table, nextLookup);
+	return nextLookup;
+};
+const getAdjacentTableCell = (editor, { at, deltaCol = 0, deltaRow = 0 } = {}) => {
+	const entries = getTableEntries(editor, { at });
+	if (!entries) return;
+	const [cell] = entries.cell;
+	const tableEntry = entries.table;
+	const { col, row } = getCellIndices(editor, cell);
+	const nextCol = col + deltaCol;
+	const nextRow = row + deltaRow;
+	if (nextCol < 0 || nextRow < 0) return;
+	return createTableCellLookup(editor, tableEntry).get(getLookupKey(nextRow, nextCol));
+};
+
+//#endregion
+//#region src/lib/queries/getCellInNextTableRow.ts
+const getCellInNextTableRow = (editor, currentRowPath) => {
+	const nextRow = editor.api.node(PathApi.next(currentRowPath));
+	if (!nextRow) return;
+	const [nextRowNode, nextRowPath] = nextRow;
+	const nextCell = nextRowNode?.children?.[0];
+	const nextCellPath = nextRowPath.concat(0);
+	if (nextCell && nextCellPath) return editor.api.node(nextCellPath);
+};
+
+//#endregion
+//#region src/lib/queries/getCellInPreviousTableRow.ts
+const getCellInPreviousTableRow = (editor, currentRowPath) => {
+	const prevPath = PathApi.previous(currentRowPath);
+	if (!prevPath) return;
+	const previousRow = editor.api.node(prevPath);
+	if (!previousRow) return;
+	const [previousRowNode, previousRowPath] = previousRow;
+	const previousCell = previousRowNode?.children?.[previousRowNode.children.length - 1];
+	const previousCellPath = previousRowPath.concat(previousRowNode.children.length - 1);
+	if (previousCell && previousCellPath) return editor.api.node(previousCellPath);
+};
+
+//#endregion
+//#region src/lib/queries/getLeftTableCell.ts
+const getLeftTableCell = (editor, { at: cellPath } = {}) => getAdjacentTableCell(editor, {
+	at: cellPath,
+	deltaCol: -1
+});
+
 //#endregion
 //#region src/lib/queries/getNextTableCell.ts
 const getNextTableCell = (editor, _currentCell, currentPath, currentRow) => {
@@ -163,25 +238,277 @@ const getNextTableCell = (editor, _currentCell, currentPath, currentRow) => {
 };
 
 //#endregion
-//#region src/lib/queries/getPreviousTableCell.ts
-const getPreviousTableCell = (editor, _currentCell, currentPath, currentRow) => {
-	const prevPath = PathApi.previous(currentPath);
-	if (!prevPath) {
-		const [, currentRowPath] = currentRow;
-		return getCellInPreviousTableRow(editor, currentRowPath);
+//#region src/lib/queries/getPreviousTableCell.ts
+const getPreviousTableCell = (editor, _currentCell, currentPath, currentRow) => {
+	const prevPath = PathApi.previous(currentPath);
+	if (!prevPath) {
+		const [, currentRowPath] = currentRow;
+		return getCellInPreviousTableRow(editor, currentRowPath);
+	}
+	const cell = editor.api.node(prevPath);
+	if (cell) return cell;
+};
+
+//#endregion
+//#region src/lib/merge/findCellByIndexes.ts
+const findCellByIndexes = (editor, table, searchRowIndex, searchColIndex) => {
+	return table.children.flatMap((current) => current.children).find((cellNode) => {
+		const indices = getCellIndices(editor, cellNode);
+		const { col: _startColIndex, row: _startRowIndex } = indices;
+		const { col: _endColIndex, row: _endRowIndex } = getCellIndicesWithSpans(indices, cellNode);
+		if (searchColIndex >= _startColIndex && searchColIndex <= _endColIndex && searchRowIndex >= _startRowIndex && searchRowIndex <= _endRowIndex) return true;
+		return false;
+	});
+};
+
+//#endregion
+//#region src/lib/merge/getTableGridByRange.ts
+/**
+* Get sub table between 2 cell paths. Ensure that the selection is always a
+* valid table grid.
+*/
+const getTableMergeGridByRange = (editor, { at, format }) => {
+	const { api, type } = getEditorPlugin(editor, BaseTablePlugin);
+	const startCellEntry = editor.api.node({
+		at: at.anchor.path,
+		match: { type: getCellTypes(editor) }
+	});
+	const endCellEntry = editor.api.node({
+		at: at.focus.path,
+		match: { type: getCellTypes(editor) }
+	});
+	const startCell = startCellEntry[0];
+	const endCell = endCellEntry[0];
+	const tablePath = startCellEntry[1].slice(0, -2);
+	const realTable = editor.api.node({
+		at: tablePath,
+		match: { type }
+	})[0];
+	const { col: _startColIndex, row: _startRowIndex } = getCellIndicesWithSpans(getCellIndices(editor, startCell), startCell);
+	const { col: _endColIndex, row: _endRowIndex } = getCellIndicesWithSpans(getCellIndices(editor, endCell), endCell);
+	let startRowIndex = Math.min(_startRowIndex, _endRowIndex);
+	let endRowIndex = Math.max(_startRowIndex, _endRowIndex);
+	let startColIndex = Math.min(_startColIndex, _endColIndex);
+	let endColIndex = Math.max(_startColIndex, _endColIndex);
+	const relativeRowIndex = endRowIndex - startRowIndex;
+	const relativeColIndex = endColIndex - startColIndex;
+	let table = api.create.table({
+		children: [],
+		colCount: relativeColIndex + 1,
+		rowCount: relativeRowIndex + 1
+	});
+	let cellEntries = [];
+	let cellsSet = /* @__PURE__ */ new WeakSet();
+	let rowIndex = startRowIndex;
+	let colIndex = startColIndex;
+	while (true) {
+		const cell = findCellByIndexes(editor, realTable, rowIndex, colIndex);
+		if (!cell) break;
+		const indicies = getCellIndices(editor, cell);
+		const { col: cellColWithSpan, row: cellRowWithSpan } = getCellIndicesWithSpans(indicies, cell);
+		const { col: cellCol, row: cellRow } = indicies;
+		if (cellRow < startRowIndex || cellRowWithSpan > endRowIndex || cellCol < startColIndex || cellColWithSpan > endColIndex) {
+			cellsSet = /* @__PURE__ */ new WeakSet();
+			cellEntries = [];
+			startRowIndex = Math.min(startRowIndex, cellRow);
+			endRowIndex = Math.max(endRowIndex, cellRowWithSpan);
+			startColIndex = Math.min(startColIndex, cellCol);
+			endColIndex = Math.max(endColIndex, cellColWithSpan);
+			rowIndex = startRowIndex;
+			colIndex = startColIndex;
+			const newRelativeRowIndex = endRowIndex - startRowIndex;
+			const newRelativeColIndex = endColIndex - startColIndex;
+			table = api.create.table({
+				children: [],
+				colCount: newRelativeColIndex + 1,
+				rowCount: newRelativeRowIndex + 1
+			});
+			continue;
+		}
+		if (!cellsSet.has(cell)) {
+			cellsSet.add(cell);
+			const rows = table.children[rowIndex - startRowIndex].children;
+			rows[colIndex - startColIndex] = cell;
+			const cellPath = editor.api.findPath(cell);
+			cellEntries.push([cell, cellPath]);
+		}
+		if (colIndex + 1 <= endColIndex) colIndex += 1;
+		else if (rowIndex + 1 <= endRowIndex) {
+			colIndex = startColIndex;
+			rowIndex += 1;
+		} else break;
+	}
+	const formatType = format || "table";
+	if (formatType === "cell") return cellEntries;
+	table.children?.forEach((rowEl) => {
+		const rowElement = rowEl;
+		rowElement.children = rowElement.children?.filter((cellEl) => {
+			const cellElement = cellEl;
+			return api.table.getCellChildren(cellElement).length > 0;
+		});
+	});
+	if (formatType === "table") return [[table, tablePath]];
+	return {
+		cellEntries,
+		tableEntries: [[table, tablePath]]
+	};
+};
+
+//#endregion
+//#region src/lib/queries/getTableGridByRange.ts
+/** Get sub table between 2 cell paths. */
+const getTableGridByRange = (editor, { at, format = "table" }) => {
+	const { api } = editor.getPlugin({ key: KEYS.table });
+	const { disableMerge } = editor.getOptions(BaseTablePlugin);
+	if (!disableMerge) 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 = api.create.table({
+		children: [],
+		colCount: relativeColIndex + 1,
+		rowCount: relativeRowIndex + 1
+	});
+	let rowIndex = startRowIndex;
+	let colIndex = startColIndex;
+	const cellEntries = [];
+	while (true) {
+		const cellPath = tablePath.concat([rowIndex, colIndex]);
+		const cell = NodeApi.get(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]];
+};
+
+//#endregion
+//#region src/lib/queries/getTableGridAbove.ts
+/** Get sub table above anchor and focus. Format: tables or cells. */
+const getTableGridAbove = (editor, { format = "table", ...options } = {}) => {
+	const { api } = editor.getPlugin({ key: KEYS.table });
+	const edges = editor.api.edgeBlocks({
+		match: { type: getCellTypes(editor) },
+		...options
+	});
+	if (edges) {
+		const [start, end] = edges;
+		if (!PathApi.equals(start[1], end[1])) return getTableGridByRange(editor, {
+			at: {
+				anchor: {
+					offset: 0,
+					path: start[1]
+				},
+				focus: {
+					offset: 0,
+					path: end[1]
+				}
+			},
+			format
+		});
+		if (format === "table") {
+			const table = api.create.table({ rowCount: 1 });
+			table.children[0].children = [start[0]];
+			return [[table, start[1].slice(0, -2)]];
+		}
+		return [start];
+	}
+	return [];
+};
+
+//#endregion
+//#region src/lib/queries/getSelectedCells.ts
+const selectionQueryCache = /* @__PURE__ */ new WeakMap();
+const getSelectionQueryCache = (editor) => {
+	const { selection } = editor;
+	const { children } = editor;
+	const cachedValue = selectionQueryCache.get(editor);
+	if (cachedValue && cachedValue.children === children && cachedValue.selection === selection) return cachedValue;
+	const nextValue = {
+		children,
+		selection
+	};
+	selectionQueryCache.set(editor, nextValue);
+	return nextValue;
+};
+const getSelectedCellEntries = (editor) => {
+	const cache = getSelectionQueryCache(editor);
+	if ("cellEntries" in cache) return cache.cellEntries ?? [];
+	const cellEntries = getTableGridAbove(editor, { format: "cell" });
+	const nextValue = cellEntries.length > 1 ? cellEntries : [];
+	cache.cellEntries = nextValue;
+	return nextValue;
+};
+const getSelectedCells = (editor) => {
+	const cache = getSelectionQueryCache(editor);
+	if ("selectedCells" in cache) return cache.selectedCells ?? null;
+	const cellEntries = getSelectedCellEntries(editor);
+	if (cellEntries.length === 0) {
+		cache.selectedCells = null;
+		return null;
 	}
-	const cell = editor.api.node(prevPath);
-	if (cell) return cell;
+	const nextValue = cellEntries.map(([cell]) => cell);
+	cache.selectedCells = nextValue;
+	return nextValue;
 };
-
-//#endregion
-//#region src/lib/queries/getRowSpan.ts
-/**
-* Returns the rowspan attribute of the table cell element.
-*
-* @default 1 if undefined
-*/
-const getRowSpan = (cellElem) => cellElem.rowSpan || Number(cellElem.attributes?.rowspan) || 1;
+const getSelectedCellIds = (editor) => {
+	const cache = getSelectionQueryCache(editor);
+	if ("selectedCellIds" in cache) return cache.selectedCellIds ?? null;
+	const selectedCellIds = getSelectedCellEntries(editor).map(([cell]) => cell.id).filter((id) => !!id);
+	const nextValue = selectedCellIds.length > 0 ? selectedCellIds : null;
+	cache.selectedCellIds = nextValue;
+	return nextValue;
+};
+const getSelectedTableIds = (editor) => {
+	const cache = getSelectionQueryCache(editor);
+	if ("selectedTableIds" in cache) return cache.selectedTableIds ?? null;
+	const selectedTables = getSelectedTables(editor);
+	if (!selectedTables) {
+		cache.selectedTableIds = null;
+		return null;
+	}
+	const selectedTableIds = selectedTables.map((table) => table.id).filter((id) => !!id);
+	const nextValue = selectedTableIds.length > 0 ? selectedTableIds : null;
+	cache.selectedTableIds = nextValue;
+	return nextValue;
+};
+const getSelectedCell = (editor, id) => {
+	if (!id) return null;
+	return getSelectedCellEntries(editor).find(([cell]) => cell.id === id)?.[0] ?? null;
+};
+const getSelectedTables = (editor) => {
+	const cache = getSelectionQueryCache(editor);
+	if ("selectedTables" in cache) return cache.selectedTables ?? null;
+	if (getSelectedCellEntries(editor).length === 0) {
+		cache.selectedTables = null;
+		return null;
+	}
+	const nextValue = getTableGridAbove(editor, { format: "table" }).map(([table]) => table);
+	cache.selectedTables = nextValue;
+	return nextValue;
+};
+const isCellSelected = (editor, id) => !!getSelectedCell(editor, id);
+const isSelectingCell = (editor) => getSelectedCellEntries(editor).length > 0;
 
 //#endregion
 //#region src/lib/queries/getSelectedCellsBoundingBox.ts
@@ -211,21 +538,10 @@ function getSelectedCellsBoundingBox(editor, cells) {
 
 //#endregion
 //#region src/lib/queries/getTopTableCell.ts
-const getTopTableCell = (editor, { at: cellPath } = {}) => {
-	if (!cellPath) {
-		cellPath = editor.api.node({ match: { type: getCellTypes(editor) } })?.[1];
-		if (!cellPath) return;
-	}
-	const cellIndex = cellPath.at(-1);
-	const rowIndex = cellPath.at(-2);
-	if (rowIndex === 0) return;
-	const cellAbovePath = [
-		...PathApi.parent(PathApi.parent(cellPath)),
-		rowIndex - 1,
-		cellIndex
-	];
-	return editor.api.node(cellAbovePath);
-};
+const getTopTableCell = (editor, { at: cellPath } = {}) => getAdjacentTableCell(editor, {
+	at: cellPath,
+	deltaRow: -1
+});
 
 //#endregion
 //#region src/lib/queries/getSelectedCellsBorders.ts
@@ -419,317 +735,104 @@ function isSelectedCellBorder(editor, cells, side) {
 				if (!cellAboveEntry) return true;
 				const [cellAboveNode] = cellAboveEntry;
 				return (cellAboveNode.borders?.bottom?.size ?? 1) >= 1;
-			}
-			if (side === "bottom" && rr === maxRow) return (cell.borders?.bottom?.size ?? 1) >= 1;
-			if (side === "left" && cc === minCol) {
-				if (col === 0) return (cell.borders?.left?.size ?? 1) >= 1;
-				const prevCellEntry = getLeftTableCell(editor, { at: cellPath });
-				if (!prevCellEntry) return true;
-				const [prevCellNode] = prevCellEntry;
-				return (prevCellNode.borders?.right?.size ?? 1) >= 1;
-			}
-			if (side === "right" && cc === maxCol) return (cell.borders?.right?.size ?? 1) >= 1;
-		}
-		return true;
-	});
-}
-
-//#endregion
-//#region src/lib/queries/getTableAbove.ts
-const getTableAbove = (editor, options) => editor.api.block({
-	above: true,
-	match: { type: editor.getType(KEYS.table) },
-	...options
-});
-
-//#endregion
-//#region src/lib/queries/getTableCellBorders.ts
-const getTableCellBorders = (editor, { cellIndices, defaultBorder = { size: 1 }, element }) => {
-	const cellPath = editor.api.findPath(element);
-	const [rowNode, rowPath] = editor.api.parent(cellPath) ?? [];
-	if (!rowNode || !rowPath) return {
-		bottom: defaultBorder,
-		right: defaultBorder
-	};
-	const [tableNode] = editor.api.parent(rowPath);
-	const { col } = cellIndices ?? getCellIndices(editor, element);
-	const isFirstCell = col === 0;
-	const isFirstRow = tableNode.children?.[0] === rowNode;
-	const getBorder = (dir) => {
-		const border = element.borders?.[dir];
-		return {
-			color: border?.color ?? defaultBorder.color,
-			size: border?.size ?? defaultBorder.size,
-			style: border?.style ?? defaultBorder.style
-		};
-	};
-	return {
-		bottom: getBorder("bottom"),
-		left: isFirstCell ? getBorder("left") : void 0,
-		right: getBorder("right"),
-		top: isFirstRow ? getBorder("top") : void 0
-	};
-};
-
-//#endregion
-//#region src/lib/queries/getTableCellSize.ts
-/** Get the width of a cell with colSpan support. */
-const getTableCellSize = (editor, { cellIndices, colSizes, element, rowSize }) => {
-	const { api } = getEditorPlugin(editor, { key: KEYS.table });
-	const path = editor.api.findPath(element);
-	if (!rowSize) {
-		const [rowElement] = editor.api.parent(path) ?? [];
-		if (!rowElement) return {
-			minHeight: 0,
-			width: 0
-		};
-		rowSize = rowElement.size;
-	}
-	if (!colSizes) {
-		const [, rowPath] = editor.api.parent(path);
-		const [tableNode] = editor.api.parent(rowPath);
-		colSizes = getTableOverriddenColSizes(tableNode);
-	}
-	const colSpan = api.table.getColSpan(element);
-	const { col } = cellIndices ?? getCellIndices(editor, element);
-	const width = (colSizes ?? []).slice(col, col + colSpan).reduce((total, w) => total + (w || 0), 0);
-	return {
-		minHeight: rowSize,
-		width
-	};
-};
-
-//#endregion
-//#region src/lib/queries/getTableColumnCount.ts
-const getTableColumnCount = (tableNode) => {
-	if (tableNode.children?.[0]?.children) return tableNode.children[0].children.map((element) => element.colSpan || (element?.attributes)?.colspan || 1).reduce((total, num) => Number(total) + Number(num));
-	return 0;
-};
-
-//#endregion
-//#region src/lib/queries/getTableEntries.ts
-/**
-* If at (default = selection) is in table>tr>td|th, return table, row, and cell
-* node entries.
-*/
-const getTableEntries = (editor, { at = editor.selection } = {}) => {
-	if (!at) return;
-	const cellEntry = editor.api.node({
-		at,
-		match: { type: getCellTypes(editor) }
-	});
-	if (!cellEntry) return;
-	const [, cellPath] = cellEntry;
-	const rowEntry = editor.api.above({
-		at: cellPath,
-		match: { type: editor.getType(KEYS.tr) }
-	});
-	if (!rowEntry) return;
-	const [, rowPath] = rowEntry;
-	const tableEntry = editor.api.above({
-		at: rowPath,
-		match: { type: editor.getType(KEYS.table) }
-	});
-	if (!tableEntry) return;
-	return {
-		cell: cellEntry,
-		row: rowEntry,
-		table: tableEntry
-	};
-};
-
-//#endregion
-//#region src/lib/merge/getCellIndicesWithSpans.ts
-const getCellIndicesWithSpans = ({ col, row }, endCell) => ({
-	col: col + getColSpan(endCell) - 1,
-	row: row + getRowSpan(endCell) - 1
-});
-
-//#endregion
-//#region src/lib/merge/findCellByIndexes.ts
-const findCellByIndexes = (editor, table, searchRowIndex, searchColIndex) => {
-	return table.children.flatMap((current) => current.children).find((cellNode) => {
-		const indices = getCellIndices(editor, cellNode);
-		const { col: _startColIndex, row: _startRowIndex } = indices;
-		const { col: _endColIndex, row: _endRowIndex } = getCellIndicesWithSpans(indices, cellNode);
-		if (searchColIndex >= _startColIndex && searchColIndex <= _endColIndex && searchRowIndex >= _startRowIndex && searchRowIndex <= _endRowIndex) return true;
-		return false;
-	});
-};
-
-//#endregion
-//#region src/lib/merge/getTableGridByRange.ts
-/**
-* Get sub table between 2 cell paths. Ensure that the selection is always a
-* valid table grid.
-*/
-const getTableMergeGridByRange = (editor, { at, format }) => {
-	const { api, type } = getEditorPlugin(editor, BaseTablePlugin);
-	const startCellEntry = editor.api.node({
-		at: at.anchor.path,
-		match: { type: getCellTypes(editor) }
-	});
-	const endCellEntry = editor.api.node({
-		at: at.focus.path,
-		match: { type: getCellTypes(editor) }
-	});
-	const startCell = startCellEntry[0];
-	const endCell = endCellEntry[0];
-	const tablePath = at.anchor.path.slice(0, -2);
-	const realTable = editor.api.node({
-		at: tablePath,
-		match: { type }
-	})[0];
-	const { col: _startColIndex, row: _startRowIndex } = getCellIndicesWithSpans(getCellIndices(editor, startCell), startCell);
-	const { col: _endColIndex, row: _endRowIndex } = getCellIndicesWithSpans(getCellIndices(editor, endCell), endCell);
-	let startRowIndex = Math.min(_startRowIndex, _endRowIndex);
-	let endRowIndex = Math.max(_startRowIndex, _endRowIndex);
-	let startColIndex = Math.min(_startColIndex, _endColIndex);
-	let endColIndex = Math.max(_startColIndex, _endColIndex);
-	const relativeRowIndex = endRowIndex - startRowIndex;
-	const relativeColIndex = endColIndex - startColIndex;
-	let table = api.create.table({
-		children: [],
-		colCount: relativeColIndex + 1,
-		rowCount: relativeRowIndex + 1
-	});
-	let cellEntries = [];
-	let cellsSet = /* @__PURE__ */ new WeakSet();
-	let rowIndex = startRowIndex;
-	let colIndex = startColIndex;
-	while (true) {
-		const cell = findCellByIndexes(editor, realTable, rowIndex, colIndex);
-		if (!cell) break;
-		const indicies = getCellIndices(editor, cell);
-		const { col: cellColWithSpan, row: cellRowWithSpan } = getCellIndicesWithSpans(indicies, cell);
-		const { col: cellCol, row: cellRow } = indicies;
-		if (cellRow < startRowIndex || cellRowWithSpan > endRowIndex || cellCol < startColIndex || cellColWithSpan > endColIndex) {
-			cellsSet = /* @__PURE__ */ new WeakSet();
-			cellEntries = [];
-			startRowIndex = Math.min(startRowIndex, cellRow);
-			endRowIndex = Math.max(endRowIndex, cellRowWithSpan);
-			startColIndex = Math.min(startColIndex, cellCol);
-			endColIndex = Math.max(endColIndex, cellColWithSpan);
-			rowIndex = startRowIndex;
-			colIndex = startColIndex;
-			const newRelativeRowIndex = endRowIndex - startRowIndex;
-			const newRelativeColIndex = endColIndex - startColIndex;
-			table = api.create.table({
-				children: [],
-				colCount: newRelativeColIndex + 1,
-				rowCount: newRelativeRowIndex + 1
-			});
-			continue;
-		}
-		if (!cellsSet.has(cell)) {
-			cellsSet.add(cell);
-			const rows = table.children[rowIndex - startRowIndex].children;
-			rows[colIndex - startColIndex] = cell;
-			const cellPath = editor.api.findPath(cell);
-			cellEntries.push([cell, cellPath]);
-		}
-		if (colIndex + 1 <= endColIndex) colIndex += 1;
-		else if (rowIndex + 1 <= endRowIndex) {
-			colIndex = startColIndex;
-			rowIndex += 1;
-		} else break;
-	}
-	const formatType = format || "table";
-	if (formatType === "cell") return cellEntries;
-	table.children?.forEach((rowEl) => {
-		const rowElement = rowEl;
-		rowElement.children = rowElement.children?.filter((cellEl) => {
-			const cellElement = cellEl;
-			return api.table.getCellChildren(cellElement).length > 0;
-		});
+			}
+			if (side === "bottom" && rr === maxRow) return (cell.borders?.bottom?.size ?? 1) >= 1;
+			if (side === "left" && cc === minCol) {
+				if (col === 0) return (cell.borders?.left?.size ?? 1) >= 1;
+				const prevCellEntry = getLeftTableCell(editor, { at: cellPath });
+				if (!prevCellEntry) return true;
+				const [prevCellNode] = prevCellEntry;
+				return (prevCellNode.borders?.right?.size ?? 1) >= 1;
+			}
+			if (side === "right" && cc === maxCol) return (cell.borders?.right?.size ?? 1) >= 1;
+		}
+		return true;
 	});
-	if (formatType === "table") return [[table, tablePath]];
+}
+
+//#endregion
+//#region src/lib/queries/getTableAbove.ts
+const getTableAbove = (editor, options) => editor.api.block({
+	above: true,
+	match: { type: editor.getType(KEYS.table) },
+	...options
+});
+
+//#endregion
+//#region src/lib/queries/getTableCellBorders.ts
+const getTableCellBorders = (editor, { cellIndices, defaultBorder = { size: 1 }, element }) => {
+	const cellPath = editor.api.findPath(element);
+	const [rowNode, rowPath] = editor.api.parent(cellPath) ?? [];
+	if (!rowNode || !rowPath) return {
+		bottom: defaultBorder,
+		right: defaultBorder
+	};
+	const [tableNode] = editor.api.parent(rowPath) ?? [];
+	const tableType = editor.getType(KEYS.table);
+	if (!tableNode || tableNode.type !== tableType) return {
+		bottom: defaultBorder,
+		right: defaultBorder
+	};
+	const { col } = cellIndices ?? getCellIndices(editor, element);
+	const isFirstCell = col === 0;
+	const isFirstRow = tableNode.children?.[0] === rowNode;
+	const getBorder = (dir) => {
+		const border = element.borders?.[dir];
+		return {
+			color: border?.color ?? defaultBorder.color,
+			size: border?.size ?? defaultBorder.size,
+			style: border?.style ?? defaultBorder.style
+		};
+	};
 	return {
-		cellEntries,
-		tableEntries: [[table, tablePath]]
+		bottom: getBorder("bottom"),
+		left: isFirstCell ? getBorder("left") : void 0,
+		right: getBorder("right"),
+		top: isFirstRow ? getBorder("top") : void 0
 	};
 };
 
 //#endregion
-//#region src/lib/queries/getTableGridByRange.ts
-/** Get sub table between 2 cell paths. */
-const getTableGridByRange = (editor, { at, format = "table" }) => {
-	const { api } = editor.getPlugin({ key: KEYS.table });
-	const { disableMerge } = editor.getOptions(BaseTablePlugin);
-	if (!disableMerge) 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 = api.create.table({
-		children: [],
-		colCount: relativeColIndex + 1,
-		rowCount: relativeRowIndex + 1
-	});
-	let rowIndex = startRowIndex;
-	let colIndex = startColIndex;
-	const cellEntries = [];
-	while (true) {
-		const cellPath = tablePath.concat([rowIndex, colIndex]);
-		const cell = NodeApi.get(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;
+//#region src/lib/queries/getTableCellSize.ts
+/** Get the width of a cell with colSpan support. */
+const getTableCellSize = (editor, { cellIndices, colSizes, element, rowSize }) => {
+	const { api } = getEditorPlugin(editor, { key: KEYS.table });
+	const path = editor.api.findPath(element);
+	if (!rowSize) {
+		const [rowElement] = editor.api.parent(path) ?? [];
+		if (!rowElement || rowElement.type !== editor.getType(KEYS.tr)) return {
+			minHeight: 0,
+			width: 0
+		};
+		rowSize = rowElement.size ?? 0;
 	}
-	if (format === "cell") return cellEntries;
-	return [[table, tablePath]];
+	if (!colSizes) {
+		const [, rowPath] = editor.api.parent(path) ?? [];
+		if (!rowPath) return {
+			minHeight: rowSize,
+			width: 0
+		};
+		const [tableNode] = editor.api.parent(rowPath) ?? [];
+		if (!tableNode) return {
+			minHeight: rowSize,
+			width: 0
+		};
+		colSizes = getTableOverriddenColSizes(tableNode);
+	}
+	const colSpan = api.table.getColSpan(element);
+	const { col } = cellIndices ?? getCellIndices(editor, element);
+	const width = (colSizes ?? []).slice(col, col + colSpan).reduce((total, w) => total + (w || 0), 0);
+	return {
+		minHeight: rowSize,
+		width
+	};
 };
 
 //#endregion
-//#region src/lib/queries/getTableGridAbove.ts
-/** Get sub table above anchor and focus. Format: tables or cells. */
-const getTableGridAbove = (editor, { format = "table", ...options } = {}) => {
-	const { api } = editor.getPlugin({ key: KEYS.table });
-	const edges = editor.api.edgeBlocks({
-		match: { type: getCellTypes(editor) },
-		...options
-	});
-	if (edges) {
-		const [start, end] = edges;
-		if (!PathApi.equals(start[1], end[1])) return getTableGridByRange(editor, {
-			at: {
-				anchor: {
-					offset: 0,
-					path: start[1]
-				},
-				focus: {
-					offset: 0,
-					path: end[1]
-				}
-			},
-			format
-		});
-		if (format === "table") {
-			const table = api.create.table({ rowCount: 1 });
-			table.children[0].children = [start[0]];
-			return [[table, start[1].slice(0, -2)]];
-		}
-		return [start];
-	}
-	return [];
+//#region src/lib/queries/getTableColumnCount.ts
+const getTableColumnCount = (tableNode) => {
+	if (tableNode.children?.[0]?.children) return tableNode.children[0].children.map((element) => element.colSpan || (element?.attributes)?.colspan || 1).reduce((total, num) => Number(total) + Number(num));
+	return 0;
 };
 
 //#endregion
@@ -1215,27 +1318,6 @@ const insertTableMergeRow = (editor, { at, before, fromRow, header, select: shou
 	});
 };
 
-//#endregion
-//#region src/lib/merge/isTableRectangular.ts
-const allEqual = (arr) => arr.every((val) => val === arr[0]);
-/**
-* Checks if the given table is rectangular, meaning all rows have the same
-* effective number of cells, considering colspan and rowspan.
-*/
-const isTableRectangular = (table) => {
-	const arr = [];
-	table?.children?.forEach((row, rI) => {
-		row.children?.forEach((cell) => {
-			const cellElem = cell;
-			Array.from({ length: getRowSpan(cellElem) || 1 }).forEach((_, i) => {
-				if (!arr[rI + i]) arr[rI + i] = 0;
-				arr[rI + i] += getColSpan(cellElem);
-			});
-		});
-	});
-	return allEqual(arr);
-};
-
 //#endregion
 //#region src/lib/merge/mergeTableCells.ts
 /** Merges multiple selected cells into one. */
@@ -1661,51 +1743,6 @@ const moveSelectionFromCell = (editor, { at, edge, fromOneCell, reverse } = {})
 	}
 };
 
-//#endregion
-//#region src/lib/transforms/overrideSelectionFromCell.ts
-/**
-* Override the new selection if the previous selection and the new one are in
-* different cells.
-*/
-const overrideSelectionFromCell = (editor, newSelection) => {
-	let hotkey;
-	if (!editor.dom.currentKeyboardEvent || ![
-		"up",
-		"down",
-		"shift+up",
-		"shift+right",
-		"shift+down",
-		"shift+left"
-	].some((key) => {
-		const valid = isHotkey(key, editor.dom.currentKeyboardEvent);
-		if (valid) hotkey = key;
-		return valid;
-	}) || !editor.selection?.focus || !newSelection?.focus || !editor.api.isAt({
-		at: {
-			anchor: editor.selection.focus,
-			focus: newSelection.focus
-		},
-		blocks: true,
-		match: { type: getCellTypes(editor) }
-	})) return;
-	if (!hotkey) return;
-	const edge = KEY_SHIFT_EDGES[hotkey];
-	if (edge && !editor.api.isAt({
-		block: true,
-		match: { type: getCellTypes(editor) }
-	})) return;
-	const prevSelection = editor.selection;
-	const reverse = ["shift+up", "up"].includes(hotkey);
-	setTimeout(() => {
-		moveSelectionFromCell(editor, {
-			at: prevSelection,
-			edge,
-			fromOneCell: true,
-			reverse
-		});
-	}, 0);
-};
-
 //#endregion
 //#region src/lib/transforms/setBorderSize.ts
 const setBorderSize = (editor, size, { at, border = "all" } = {}) => {
@@ -1844,6 +1881,54 @@ const setTableRowSize = (editor, { height, rowIndex }, options = {}) => {
 	editor.tf.setNodes({ size: height }, { at: tableRowPath });
 };
 
+//#endregion
+//#region src/lib/transforms/shouldMoveSelectionFromCell.ts
+const VISUAL_LINE_TOLERANCE = 1;
+const getRangeClientRects = (domRange) => Array.from(domRange?.getClientRects?.() ?? []).filter((rect) => rect.height > 0);
+const getTableMoveSelectionContext = (editor, point = editor.selection?.anchor) => {
+	if (!point || !editor.api.isAt({
+		block: true,
+		match: { type: getCellTypes(editor) }
+	})) return;
+	const cellEntry = editor.api.block({
+		at: point,
+		match: { type: getCellTypes(editor) }
+	});
+	const blockEntry = editor.api.block({ at: point });
+	if (!cellEntry || !blockEntry) return;
+	const [, cellPath] = cellEntry;
+	const [, blockPath] = blockEntry;
+	return {
+		blockPath,
+		cellPath,
+		point
+	};
+};
+const hasAdjacentBlockInCell = (editor, { blockPath, cellPath, reverse }) => {
+	const adjacentBlock = reverse ? editor.api.previous({
+		at: blockPath,
+		block: true
+	}) : editor.api.next({
+		at: blockPath,
+		block: true
+	});
+	return !!adjacentBlock && PathApi.isAncestor(cellPath, adjacentBlock[1]);
+};
+const shouldMoveSelectionFromCell = (editor, { blockPath, point, reverse }) => {
+	const blockRange = editor.api.range(blockPath);
+	const isAtBlockEdge = reverse ? editor.api.isStart(point, blockPath) : editor.api.isEnd(point, blockPath);
+	if (!blockRange) return isAtBlockEdge;
+	const caretRects = getRangeClientRects(editor.api.toDOMRange({
+		anchor: point,
+		focus: point
+	}));
+	const blockRects = getRangeClientRects(editor.api.toDOMRange(blockRange));
+	if (caretRects.length === 0 || blockRects.length === 0) return isAtBlockEdge;
+	const caretRect = caretRects.at(-1);
+	const boundary = reverse ? Math.min(...blockRects.map((rect) => rect.top)) : Math.max(...blockRects.map((rect) => rect.bottom));
+	return reverse ? caretRect.top <= boundary + VISUAL_LINE_TOLERANCE : caretRect.bottom >= boundary - VISUAL_LINE_TOLERANCE;
+};
+
 //#endregion
 //#region src/lib/withApplyTable.ts
 /**
@@ -1889,7 +1974,6 @@ const withApplyTable = ({ api: _api, editor, getOptions, tf: { apply }, type: ta
 				}
 			}
 		}
-		overrideSelectionFromCell(editor, newSelection);
 	}
 	const opType = op.type === "remove_node" ? op.node.type : op.type === "move_node" ? editor.api.node(op.path)?.[0].type : void 0;
 	const isTableOperation = (op.type === "remove_node" || op.type === "move_node") && opType && [
@@ -2250,108 +2334,116 @@ const withSetFragmentDataTable = ({ api, editor, plugin, tf: { setFragmentData }
 
 //#endregion
 //#region src/lib/withTableCellSelection.tsx
-const withTableCellSelection = ({ api: { marks }, editor, tf: { addMark, removeMark, setNodes } }) => {
-	return {
-		api: { marks() {
+const isTargetingSelectedCell = (editor, target, cellPaths) => {
+	if (PathApi.isPath(target)) return cellPaths.some((cellPath) => PathApi.isCommon(cellPath, target));
+	const range = editor.api.range(target);
+	if (!range) return false;
+	return cellPaths.some((cellPath) => {
+		const cellRange = editor.api.range(cellPath);
+		if (!cellRange) return false;
+		return RangeApi.includes(cellRange, range.anchor) || RangeApi.includes(cellRange, range.focus) || RangeApi.includes(range, cellRange);
+	});
+};
+const withTableCellSelection = ({ api: { marks }, editor, tf: { addMark, removeMark, setNodes } }) => ({
+	api: { marks() {
+		const apply = () => {
+			const { selection } = editor;
+			if (!selection || editor.api.isCollapsed()) return;
+			const matchesCell = getTableGridAbove(editor, { format: "cell" });
+			if (matchesCell.length <= 1) return;
+			const markCounts = {};
+			const totalMarks = {};
+			let totalNodes = 0;
+			matchesCell.forEach(([_cell, cellPath]) => {
+				const textNodeEntry = editor.api.nodes({
+					at: cellPath,
+					match: (n) => TextApi.isText(n)
+				});
+				Array.from(textNodeEntry, (item) => item[0]).forEach((item) => {
+					totalNodes++;
+					const keys = Object.keys(item);
+					if (keys.length === 1) return;
+					keys.splice(keys.indexOf("text"), 1);
+					keys.forEach((k) => {
+						markCounts[k] = (markCounts[k] || 0) + 1;
+						totalMarks[k] = item[k];
+					});
+				});
+			});
+			Object.keys(markCounts).forEach((mark) => {
+				if (markCounts[mark] !== totalNodes) delete totalMarks[mark];
+			});
+			return totalMarks;
+		};
+		const result = apply();
+		if (result) return result;
+		return marks();
+	} },
+	transforms: {
+		addMark(key, value) {
 			const apply = () => {
 				const { selection } = editor;
-				if (!selection || editor.api.isCollapsed()) return;
+				if (!selection || editor.api.isCollapsed() || editor.meta.isNormalizing) return;
 				const matchesCell = getTableGridAbove(editor, { format: "cell" });
 				if (matchesCell.length <= 1) return;
-				const markCounts = {};
-				const totalMarks = {};
-				let totalNodes = 0;
 				matchesCell.forEach(([_cell, cellPath]) => {
-					const textNodeEntry = editor.api.nodes({
+					editor.tf.setNodes({ [key]: value }, {
 						at: cellPath,
+						split: true,
+						voids: true,
 						match: (n) => TextApi.isText(n)
 					});
-					Array.from(textNodeEntry, (item) => item[0]).forEach((item) => {
-						totalNodes++;
-						const keys = Object.keys(item);
-						if (keys.length === 1) return;
-						keys.splice(keys.indexOf("text"), 1);
-						keys.forEach((k) => {
-							markCounts[k] = (markCounts[k] || 0) + 1;
-							totalMarks[k] = item[k];
-						});
+				});
+				return true;
+			};
+			if (apply()) return;
+			return addMark(key, value);
+		},
+		removeMark(key) {
+			const apply = () => {
+				const { selection } = editor;
+				if (!selection || editor.api.isCollapsed() || editor.meta.isNormalizing) return;
+				const matchesCell = getTableGridAbove(editor, { format: "cell" });
+				if (matchesCell.length <= 1) return;
+				matchesCell.forEach(([_cell, cellPath]) => {
+					editor.tf.setNodes({ [key]: null }, {
+						at: cellPath,
+						split: true,
+						voids: true,
+						match: (n) => TextApi.isText(n)
 					});
 				});
-				Object.keys(markCounts).forEach((mark) => {
-					if (markCounts[mark] !== totalNodes) delete totalMarks[mark];
+				return true;
+			};
+			if (apply()) return;
+			return removeMark(key);
+		},
+		setNodes(props, options) {
+			const apply = () => {
+				const { selection } = editor;
+				if (!selection || editor.api.isCollapsed() || editor.meta.isNormalizing) return;
+				const matchesCell = getTableGridAbove(editor, { format: "cell" });
+				if (matchesCell.length <= 1) return;
+				if (options?.at) {
+					const cellPaths = matchesCell.map(([, cellPath]) => cellPath);
+					if (!isTargetingSelectedCell(editor, options.at, cellPaths)) return;
+				}
+				setNodes(props, {
+					...options,
+					match: combineTransformMatchOptions(editor, (_, p) => matchesCell.some(([_$1, cellPath]) => PathApi.isCommon(cellPath, p)), options)
 				});
-				return totalMarks;
+				return true;
 			};
-			const result = apply();
-			if (result) return result;
-			return marks();
-		} },
-		transforms: {
-			addMark(key, value) {
-				const apply = () => {
-					const { selection } = editor;
-					if (!selection || editor.api.isCollapsed() || editor.meta.isNormalizing) return;
-					const matchesCell = getTableGridAbove(editor, { format: "cell" });
-					if (matchesCell.length <= 1) return;
-					matchesCell.forEach(([_cell, cellPath]) => {
-						editor.tf.setNodes({ [key]: value }, {
-							at: cellPath,
-							split: true,
-							voids: true,
-							match: (n) => TextApi.isText(n)
-						});
-					});
-					return true;
-				};
-				if (apply()) return;
-				return addMark(key, value);
-			},
-			removeMark(key) {
-				const apply = () => {
-					const { selection } = editor;
-					if (!selection || editor.api.isCollapsed() || editor.meta.isNormalizing) return;
-					const matchesCell = getTableGridAbove(editor, { format: "cell" });
-					if (matchesCell.length <= 1) return;
-					matchesCell.forEach(([_cell, cellPath]) => {
-						editor.tf.setNodes({ [key]: null }, {
-							at: cellPath,
-							split: true,
-							voids: true,
-							match: (n) => TextApi.isText(n)
-						});
-					});
-					return true;
-				};
-				if (apply()) return;
-				return removeMark(key);
-			},
-			setNodes(props, options) {
-				const apply = () => {
-					const { selection } = editor;
-					if (!selection || editor.api.isCollapsed() || editor.meta.isNormalizing) return;
-					if (options?.at) {
-						const range = editor.api.range(options.at);
-						if (range && !RangeApi.includes(selection, range)) return;
-					}
-					const matchesCell = getTableGridAbove(editor, { format: "cell" });
-					if (matchesCell.length <= 1) return;
-					setNodes(props, {
-						...options,
-						match: combineTransformMatchOptions(editor, (_, p) => matchesCell.some(([_$1, cellPath]) => PathApi.isCommon(cellPath, p)), options)
-					});
-					return true;
-				};
-				if (apply()) return;
-				return setNodes(props, options);
-			}
+			if (apply()) return;
+			return setNodes(props, options);
 		}
-	};
-};
+	}
+});
 
 //#endregion
 //#region src/lib/withTable.ts
 const withTable = (ctx) => {
-	const { editor, tf: { selectAll, tab }, type } = ctx;
+	const { editor, tf: { moveLine, selectAll, tab }, type } = ctx;
 	const cellSelection = withTableCellSelection(ctx);
 	return {
 		api: {
@@ -2359,6 +2451,27 @@ const withTable = (ctx) => {
 			...cellSelection.api
 		},
 		transforms: {
+			moveLine: (options) => {
+				const apply = () => {
+					if (!editor.api.isCollapsed()) return;
+					const context = getTableMoveSelectionContext(editor);
+					if (!context) return;
+					const { blockPath, cellPath, point } = context;
+					if (hasAdjacentBlockInCell(editor, {
+						blockPath,
+						cellPath,
+						reverse: options.reverse
+					})) return;
+					if (!shouldMoveSelectionFromCell(editor, {
+						blockPath,
+						point,
+						reverse: options.reverse
+					})) return;
+					return moveSelectionFromCell(editor, { reverse: options.reverse });
+				};
+				if (apply()) return true;
+				return moveLine(options);
+			},
 			selectAll: () => {
 				const apply = () => {
 					const table = editor.api.above({ match: { type } });
@@ -2481,6 +2594,9 @@ const BaseTablePlugin = createTSlatePlugin({
 	normalizeInitialValue: normalizeInitialValueTable,
 	options: {
 		_cellIndices: {},
+		_selectedCellIds: void 0,
+		_selectedTableIds: void 0,
+		_selectionVersion: 0,
 		disableMerge: false,
 		minColumnWidth: 48,
 		selectedCells: null,
@@ -2492,7 +2608,41 @@ const BaseTablePlugin = createTSlatePlugin({
 		BaseTableCellPlugin,
 		BaseTableCellHeaderPlugin
 	]
-}).extendSelectors(({ getOptions }) => ({ cellIndices: (id) => getOptions()._cellIndices[id] })).extendEditorApi(({ editor }) => ({
+}).extendSelectors(({ editor, getOptions }) => ({
+	cellIndices: (id) => getOptions()._cellIndices[id],
+	isCellSelected: (id) => {
+		const selectedCellIds = getOptions()._selectedCellIds;
+		if (selectedCellIds !== void 0) return !!id && (selectedCellIds?.includes(id) ?? false);
+		return isCellSelected(editor, id);
+	},
+	isSelectingCell: () => {
+		const selectedCellIds = getOptions()._selectedCellIds;
+		if (selectedCellIds !== void 0) return !!selectedCellIds;
+		return isSelectingCell(editor);
+	},
+	selectedCell: (id) => {
+		getOptions()._selectionVersion;
+		return getSelectedCell(editor, id);
+	},
+	selectedCellIds: () => {
+		const selectedCellIds = getOptions()._selectedCellIds;
+		if (selectedCellIds !== void 0) return selectedCellIds;
+		return getSelectedCellIds(editor);
+	},
+	selectedCells: () => {
+		getOptions()._selectionVersion;
+		return getSelectedCells(editor);
+	},
+	selectedTableIds: () => {
+		const selectedTableIds = getOptions()._selectedTableIds;
+		if (selectedTableIds !== void 0) return selectedTableIds;
+		return getSelectedTableIds(editor);
+	},
+	selectedTables: () => {
+		getOptions()._selectionVersion;
+		return getSelectedTables(editor);
+	}
+})).extendEditorApi(({ editor }) => ({
 	create: {
 		table: bindFirst(getEmptyTableNode, editor),
 		tableCell: bindFirst(getEmptyCellNode, editor),
@@ -2501,9 +2651,16 @@ const BaseTablePlugin = createTSlatePlugin({
 	table: {
 		getCellBorders: bindFirst(getTableCellBorders, editor),
 		getCellSize: bindFirst(getTableCellSize, editor),
+		getSelectedCell: bindFirst(getSelectedCell, editor),
+		getSelectedCellIds: bindFirst(getSelectedCellIds, editor),
+		getSelectedCells: bindFirst(getSelectedCells, editor),
+		getSelectedTableIds: bindFirst(getSelectedTableIds, editor),
+		getSelectedTables: bindFirst(getSelectedTables, editor),
 		getColSpan,
 		getRowSpan,
-		getCellChildren: (cell) => cell.children
+		getCellChildren: (cell) => cell.children,
+		isCellSelected: bindFirst(isCellSelected, editor),
+		isSelectingCell: bindFirst(isSelectingCell, editor)
 	}
 })).extendEditorTransforms(({ editor }) => ({
 	insert: {
@@ -2532,5 +2689,4 @@ const KEY_SHIFT_EDGES = {
 };
 
 //#endregion
-export { isSelectedCellBordersNone as $, mergeTableCells as A, getTableOverriddenColSizes as B, insertTableColumn as C, deleteColumn as D, deleteRow as E, deleteTableMergeRow as F, getCellIndicesWithSpans as G, getTableGridByRange as H, deleteRowWhenExpanded as I, getTableCellSize as J, getTableEntries as K, deleteTableMergeColumn as L, insertTableMergeRow as M, insertTableMergeColumn as N, normalizeInitialValueTable as O, getTableMergedColumnCount as P, isSelectedCellBorder as Q, getCellPath as R, insertTableRow as S, deleteTable as T, getTableMergeGridByRange as U, getTableGridAbove as V, findCellByIndexes as W, getTableAbove as X, getTableCellBorders as Y, getSelectedCellsBorders as Z, setTableMarginLeft as _, BaseTableRowPlugin as a, getNextTableCell as at, overrideSelectionFromCell as b, withSetFragmentDataTable as c, getCellRowIndexByPath as ct, withInsertFragmentTable as d, getColSpan as dt, isSelectedCellBordersOuter as et, withGetFragmentTable as f, getCellInPreviousTableRow as ft, setTableRowSize as g, getEmptyCellNode as gt, withApplyTable as h, getEmptyRowNode as ht, BaseTablePlugin as i, getPreviousTableCell as it, isTableRectangular as j, splitTableCell as k, withNormalizeTable as l, getCellIndices as lt, withDeleteTable as m, getEmptyTableNode as mt, BaseTableCellHeaderPlugin as n, getSelectedCellsBoundingBox as nt, withTable as o, getLeftTableCell as ot, preventDeleteTableCell as p, getCellInNextTableRow as pt, getTableColumnCount as q, BaseTableCellPlugin as r, getRowSpan as rt, withTableCellSelection as s, getCellTypes as st, KEY_SHIFT_EDGES as t, getTopTableCell as tt, withInsertTextTable as u, computeCellIndices as ut, setTableColSize as v, insertTable as w, moveSelectionFromCell as x, setBorderSize as y, deleteColumnWhenExpanded as z };
-//# sourceMappingURL=constants-B6Sm9BNa.js.map
+export { getSelectedCellEntries as $, normalizeInitialValueTable as A, deleteColumnWhenExpanded as B, moveSelectionFromCell as C, getColSpan as Ct, deleteTable as D, insertTable as E, getEmptyCellNode as Et, getTableMergedColumnCount as F, getTableAbove as G, getTableColumnCount as H, deleteTableMergeRow as I, isSelectedCellBordersNone as J, getSelectedCellsBorders as K, deleteRowWhenExpanded as L, mergeTableCells as M, insertTableMergeRow as N, deleteRow as O, insertTableMergeColumn as P, getSelectedCell as Q, deleteTableMergeColumn as R, setBorderSize as S, getRowSpan as St, insertTableColumn as T, getEmptyRowNode as Tt, getTableCellSize as U, getTableOverriddenColSizes as V, getTableCellBorders as W, getTopTableCell as X, isSelectedCellBordersOuter as Y, getSelectedCellsBoundingBox as Z, hasAdjacentBlockInCell as _, getCellTypes as _t, BaseTableRowPlugin as a, isSelectingCell as at, setTableMarginLeft as b, computeCellIndices as bt, withSetFragmentDataTable as c, getTableMergeGridByRange as ct, withInsertFragmentTable as d, getNextTableCell as dt, getSelectedCellIds as et, withGetFragmentTable as f, getLeftTableCell as ft, getTableMoveSelectionContext as g, getTableEntries as gt, withApplyTable as h, getAdjacentTableCell as ht, BaseTablePlugin as i, isCellSelected as it, splitTableCell as j, deleteColumn as k, withNormalizeTable as l, findCellByIndexes as lt, withDeleteTable as m, getCellInNextTableRow as mt, BaseTableCellHeaderPlugin as n, getSelectedTableIds as nt, withTable as o, getTableGridAbove as ot, preventDeleteTableCell as p, getCellInPreviousTableRow as pt, isSelectedCellBorder as q, BaseTableCellPlugin as r, getSelectedTables as rt, withTableCellSelection as s, getTableGridByRange as st, KEY_SHIFT_EDGES as t, getSelectedCells as tt, withInsertTextTable as u, getPreviousTableCell as ut, shouldMoveSelectionFromCell as v, getCellRowIndexByPath as vt, insertTableRow as w, getEmptyTableNode as wt, setTableColSize as x, getCellIndicesWithSpans as xt, setTableRowSize as y, getCellIndices as yt, getCellPath as z };