@mx-space/cli 0.14.1 → 0.15.0

package/dist/{LexicalTable.dev-Cc9-zqKa.mjs → LexicalTable.dev-6IFFOAE0.mjs}

@@ -1,9 +1,9 @@
-import { f as namedSignals, l as effect, p as signal } from "./LexicalExtension.node-BWH6xbzG.mjs";
-import { $t as CONTROLLED_TEXT_INSERTION_COMMAND, A as $getChildCaret, An as IS_FIREFOX, B as $getNodeByKeyOrThrow, Bn as KEY_ARROW_LEFT_COMMAND, Br as isDOMDocumentNode, C as $getAdjacentChildCaret, Ct as $normalizeCaret, Dn as IS_BOLD, Dr as getDOMSelectionRange, Er as getDOMSelectionPoints, Fn as IS_STRIKETHROUGH, G as $getSiblingCaret, H as $getPreviousSelection, Hn as KEY_ARROW_UP_COMMAND, Hr as isDOMShadowRoot, Ht as CLICK_COMMAND, I as $getEditor, Jn as KEY_TAB_COMMAND, Jr as isHTMLTableRowElement, Jt as COMMAND_PRIORITY_HIGH, Kn as KEY_ESCAPE_COMMAND, Mt as $setSelection, Nn as IS_ITALIC, R as $getNearestNodeFromDOMNode, Rn as IS_UNDERLINE, Tr as getDOMSelection, U as $getRoot, Un as KEY_BACKSPACE_COMMAND, Vn as KEY_ARROW_RIGHT_COMMAND, Vr as isDOMNode, W as $getSelection, Wn as KEY_DELETE_COMMAND, Yt as COMMAND_PRIORITY_LOW, _t as $isSiblingCaret, ai as safeCast, an as DELETE_LINE_COMMAND, ar as SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, at as $isElementNode, b as $findMatchingParent, bn as INSERT_PARAGRAPH_COMMAND, br as defineExtension, bt as $isTextNode, dn as ElementNode, fn as FOCUS_COMMAND, ft as $isParagraphNode, g as $createRangeSelectionFromDom, gr as createCommand, h as $createRangeSelection, hr as configExtension, ht as $isRootOrShadowRoot, i as $caretFromPoint, ii as removeClassNamesFromElement, in as DELETE_CHARACTER_COMMAND, ir as SELECTION_CHANGE_COMMAND, jt as $setPointFromCaret, m as $createPoint, mn as FORMAT_TEXT_COMMAND, mt as $isRootNode, n as $applyNodeReplacement, ni as mergeRegister, nt as $isChildCaret, oi as setDOMStyleFromCSS, on as DELETE_WORD_COMMAND, or as SELECT_ALL_COMMAND, ot as $isExtendableTextPointCaret, p as $createParagraphNode, pn as FORMAT_ELEMENT_COMMAND, pr as addClassNamesToElement, pt as $isRangeSelection, qr as isHTMLElement, qt as COMMAND_PRIORITY_EDITOR, si as setDOMUnmanaged, st as $isInlineElementOrDecoratorNode, tn as CUT_COMMAND, ur as TEXT_TYPE_TO_FORMAT, ut as $isLineBreakNode, v as $createTextNode, wr as getComposedEventTarget, wt as $normalizeSelection__EXPERIMENTAL, x as $fullReconcile, y as $extendCaretToRange, z as $getNodeByKey, zn as KEY_ARROW_DOWN_COMMAND, zr as isCurrentlyReadOnlyMode } from "./Lexical.node-BlCLnfA6.mjs";
-import { c as DOMImportExtension, f as ImportTextFormat, h as defineImportRule, m as contextValue, o as $propagateTextAlignToBlockChildren, p as ImportTextStyle, s as CoreImportExtension, v as sel } from "./LexicalHtml.node-CVkbWtUA.mjs";
-import { d as $unwrapAndFilterDescendants, h as objectKlassEquals, n as $dfsWithSlots, o as $insertFirst$1, s as $insertNodeToNearestRoot, t as $descendantsMatching } from "./LexicalUtils.node-BVAwOkL4.mjs";
-import { o as copyToClipboard, t as $getClipboardDataFromSelection } from "./LexicalClipboard.node-ktUajxsv.mjs";
-//#region ../../node_modules/.pnpm/@lexical+table@0.46.0_typescript@6.0.3/node_modules/@lexical/table/dist/LexicalTable.dev.mjs
+import { d as getPeerDependencyFromEditor, f as namedSignals, l as effect, p as signal } from "./LexicalExtension.node-5OymZQfy.mjs";
+import { $r as isHTMLElement, $t as COMMAND_PRIORITY_LOW, A as $getChildCaret, Ar as getComposedEventTarget, B as $getNodeByKey, Dt as $normalizeSelection__EXPERIMENTAL, Et as $normalizeCaret, Ft as $setSelection, G as $getSelection, Gn as KEY_ARROW_RIGHT_COMMAND, Gr as isCurrentlyReadOnlyMode, Hn as IS_UNDERLINE, I as $getDocument, Jn as KEY_DELETE_COMMAND, Jr as isDOMShadowRoot, K as $getSiblingCaret, Kn as KEY_ARROW_UP_COMMAND, Kr as isDOMDocumentNode, Kt as CLICK_COMMAND, L as $getEditor, Ln as IS_ITALIC, Mr as getDOMSelectionPoints, Nr as getDOMSelectionRange, Or as getActiveElement, Pn as IS_FIREFOX, Pt as $setPointFromCaret, Qn as KEY_TAB_COMMAND, Qt as COMMAND_PRIORITY_HIGH, S as $fullReconcile, St as $isTextNode, Tr as defineExtension, U as $getPreviousSelection, Un as KEY_ARROW_DOWN_COMMAND, V as $getNodeByKeyOrThrow, W as $getRoot, Wn as KEY_ARROW_LEFT_COMMAND, Xn as KEY_ESCAPE_COMMAND, Zt as COMMAND_PRIORITY_EDITOR, _n as FORMAT_ELEMENT_COMMAND, an as CUT_COMMAND, b as $findMatchingParent, br as configExtension, ci as mergeRegister, cn as DELETE_CHARACTER_COMMAND, cr as SELECTION_CHANGE_COMMAND, ct as $isInlineElementOrDecoratorNode, dt as $isLineBreakNode, ei as isHTMLTableRowElement, fi as removeClassNamesFromElement, g as $createRangeSelectionFromDom, gn as FOCUS_COMMAND, gt as $isRootOrShadowRoot, h as $createRangeSelection, hi as setDOMUnmanaged, hn as ElementNode, hr as TEXT_TYPE_TO_FORMAT, ht as $isRootNode, i as $caretFromPoint, in as COPY_COMMAND, jn as IS_BOLD, jr as getDOMSelection, ln as DELETE_LINE_COMMAND, lr as SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, m as $createPoint, mi as setDOMStyleFromCSS, mt as $isRangeSelection, n as $applyNodeReplacement, ot as $isElementNode, p as $createParagraphNode, pi as safeCast, pt as $isParagraphNode, qn as KEY_BACKSPACE_COMMAND, qr as isDOMNode, rn as CONTROLLED_TEXT_INSERTION_COMMAND, rr as PASTE_COMMAND, rt as $isChildCaret, st as $isExtendableTextPointCaret, ui as registerEventListener, un as DELETE_WORD_COMMAND, ur as SELECT_ALL_COMMAND, v as $createTextNode, vn as FORMAT_TEXT_COMMAND, vr as addClassNamesToElement, w as $getAdjacentChildCaret, wn as INSERT_PARAGRAPH_COMMAND, xr as createCommand, y as $extendCaretToRange, yt as $isSiblingCaret, z as $getNearestNodeFromDOMNode, zn as IS_STRIKETHROUGH } from "./Lexical.node-D6wf2D5M.mjs";
+import { c as CoreImportExtension, g as defineImportRule, h as contextValue, l as DOMImportExtension, m as ImportTextStyle, o as $propagateTextAlignToBlockChildren, p as ImportTextFormat, y as sel } from "./LexicalHtml.node-DpVNt7It.mjs";
+import { d as $unwrapAndFilterDescendants, m as objectKlassEquals, n as $dfs, o as $insertFirst$1, s as $insertNodeToNearestRoot, t as $descendantsMatching } from "./LexicalUtils.node-Df9oPTlA.mjs";
+import { o as copyToClipboard, t as $getClipboardDataFromSelection } from "./LexicalClipboard.node-m4nZ7IYw.mjs";
+//#region ../../node_modules/.pnpm/@lexical+table@0.49.0_typescript@6.0.3/node_modules/@lexical/table/dist/LexicalTable.dev.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -34,7 +34,7 @@ const TableCellHeaderStates = {
 	ROW: 1
 };
 /** @noInheritDoc */
-var TableCellNode = class TableCellNode extends ElementNode {
+var TableCellNode = class extends ElementNode {
 	/** @internal */
 	__colSpan;
 	/** @internal */
@@ -47,11 +47,20 @@ var TableCellNode = class TableCellNode extends ElementNode {
 	__backgroundColor;
 	/** @internal */
 	__verticalAlign;
-	static getType() {
-		return "tablecell";
-	}
-	static clone(node) {
-		return new TableCellNode(node.__headerState, node.__colSpan, node.__width, node.__key);
+	$config() {
+		return this.config("tablecell", {
+			extends: ElementNode,
+			importDOM: {
+				td: () => ({
+					conversion: $convertTableCellNodeElement,
+					priority: 0
+				}),
+				th: () => ({
+					conversion: $convertTableCellNodeElement,
+					priority: 0
+				})
+			}
+		});
 	}
 	afterCloneFrom(node) {
 		super.afterCloneFrom(node);
@@ -62,21 +71,6 @@ var TableCellNode = class TableCellNode extends ElementNode {
 		this.__headerState = node.__headerState;
 		this.__width = node.__width;
 	}
-	static importDOM() {
-		return {
-			td: (node) => ({
-				conversion: $convertTableCellNodeElement,
-				priority: 0
-			}),
-			th: (node) => ({
-				conversion: $convertTableCellNodeElement,
-				priority: 0
-			})
-		};
-	}
-	static importJSON(serializedNode) {
-		return $createTableCellNode().updateFromJSON(serializedNode);
-	}
 	updateFromJSON(serializedNode) {
 		return super.updateFromJSON(serializedNode).setHeaderStyles(serializedNode.headerState).setColSpan(serializedNode.colSpan || 1).setRowSpan(serializedNode.rowSpan || 1).setWidth(serializedNode.width || void 0).setBackgroundColor(serializedNode.backgroundColor || null).setVerticalAlign(serializedNode.verticalAlign || void 0);
 	}
@@ -90,7 +84,7 @@ var TableCellNode = class TableCellNode extends ElementNode {
 		this.__verticalAlign = void 0;
 	}
 	createDOM(config) {
-		const element = document.createElement(this.getTag());
+		const element = $getDocument().createElement(this.getTag());
 		if (this.__width) element.style.width = `${this.__width}px`;
 		if (this.__colSpan > 1) element.colSpan = this.__colSpan;
 		if (this.__rowSpan > 1) element.rowSpan = this.__rowSpan;
@@ -309,32 +303,26 @@ function formatDevErrorMessage(message) {
 *
 */
 /** @noInheritDoc */
-var TableRowNode = class TableRowNode extends ElementNode {
+var TableRowNode = class extends ElementNode {
 	/** @internal */
 	__height;
-	static getType() {
-		return "tablerow";
-	}
-	static clone(node) {
-		return new TableRowNode(node.__height, node.__key);
+	$config() {
+		return this.config("tablerow", {
+			extends: ElementNode,
+			importDOM: { tr: () => ({
+				conversion: $convertTableRowElement,
+				priority: 0
+			}) }
+		});
 	}
 	afterCloneFrom(prevNode) {
 		super.afterCloneFrom(prevNode);
 		this.__height = prevNode.__height;
 	}
-	static importDOM() {
-		return { tr: (node) => ({
-			conversion: $convertTableRowElement,
-			priority: 0
-		}) };
-	}
-	static importJSON(serializedNode) {
-		return $createTableRowNode().updateFromJSON(serializedNode);
-	}
 	updateFromJSON(serializedNode) {
 		return super.updateFromJSON(serializedNode).setHeight(serializedNode.height);
 	}
-	constructor(height, key) {
+	constructor(height = void 0, key) {
 		super(key);
 		this.__height = height;
 	}
@@ -346,7 +334,7 @@ var TableRowNode = class TableRowNode extends ElementNode {
 		};
 	}
 	createDOM(config) {
-		const element = document.createElement("tr");
+		const element = $getDocument().createElement("tr");
 		if (this.__height) element.style.height = `${this.__height}px`;
 		addClassNamesToElement(element, config.theme.tableRow);
 		return element;
@@ -860,6 +848,13 @@ function $unmergeCell() {
 	if (!$isTableCellNode(cellNode)) formatDevErrorMessage(`Expected to find a parent TableCellNode`);
 	return $unmergeCellNode(cellNode);
 }
+/**
+* Unmerges the given cell, splitting it back into individual cells.
+* Unlike {@link $unmergeCell}, this does not depend on the current
+* selection. No-op if the cell is not merged.
+*
+* @param cellNode The merged cell to split.
+*/
 function $unmergeCellNode(cellNode) {
 	const [cell, row, grid] = $getNodeTriplet(cellNode);
 	const colSpan = cell.__colSpan;
@@ -996,6 +991,10 @@ function $computeTableCellRectSpans(map, boundary) {
 		topSpan
 	};
 }
+/**
+* Compute the bounding rectangle of two table cells in a table map,
+* expanding iteratively to include any merged cells that overlap the boundary.
+*/
 function $computeTableCellRectBoundary(map, cellAMap, cellBMap) {
 	let minColumn = Math.min(cellAMap.startColumn, cellBMap.startColumn);
 	let minRow = Math.min(cellAMap.startRow, cellBMap.startRow);
@@ -1077,6 +1076,24 @@ function $moveTableColumn(tableNode, originColumn, targetColumn) {
 		tableNode.setColWidths(newWidths);
 	}
 }
+/**
+* Moves a row from one position to another within a simple (non-merged) table.
+*
+* @param tableNode The table node to modify.
+* @param originRow The index of the row to move.
+* @param targetRow The index to move the row to.
+*/
+function $moveTableRow(tableNode, originRow, targetRow) {
+	if (originRow === targetRow) return;
+	const rows = tableNode.getChildren().filter($isTableRowNode);
+	const rowCount = rows.length;
+	if (originRow < 0 || originRow >= rowCount || targetRow < 0 || targetRow >= rowCount) return;
+	if (!$isSimpleTable(tableNode)) return;
+	const originRowNode = rows[originRow];
+	const targetRowNode = rows[targetRow];
+	if (targetRow > originRow) targetRowNode.insertAfter(originRowNode);
+	else targetRowNode.insertBefore(originRowNode);
+}
 function $getTableCellNodeRect(tableCellNode) {
 	const [cellNode, , gridNode] = $getNodeTriplet(tableCellNode);
 	const rows = gridNode.getChildren().filter($isTableRowNode);
@@ -1104,6 +1121,119 @@ function $getTableCellNodeRect(tableCellNode) {
 	}
 	return null;
 }
+function $insertTableIntoGrid(tableNode, selection) {
+	const anchorAndFocus = selection.getStartEndPoints();
+	const isTableSel = $isTableSelection(selection);
+	if (anchorAndFocus === null) return false;
+	const [anchor, focus] = anchorAndFocus;
+	const [anchorCellNode, anchorRowNode, gridNode] = $getNodeTriplet(anchor);
+	const focusCellNode = $findMatchingParent(focus.getNode(), (n) => $isTableCellNode(n));
+	if (!$isTableCellNode(anchorCellNode) || !$isTableCellNode(focusCellNode) || !$isTableRowNode(anchorRowNode) || !$isTableNode(gridNode)) return false;
+	const [initialGridMap, anchorCellMap, focusCellMap] = $computeTableMap(gridNode, anchorCellNode, focusCellNode);
+	const [templateGridMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+	const initialRowCount = initialGridMap.length;
+	const initialColCount = initialRowCount > 0 ? initialGridMap[0].length : 0;
+	let startRow = anchorCellMap.startRow;
+	let startCol = anchorCellMap.startColumn;
+	let affectedRowCount = templateGridMap.length;
+	let affectedColCount = affectedRowCount > 0 ? templateGridMap[0].length : 0;
+	if (isTableSel) {
+		const selectionBoundary = $computeTableCellRectBoundary(initialGridMap, anchorCellMap, focusCellMap);
+		const selectionRowCount = selectionBoundary.maxRow - selectionBoundary.minRow + 1;
+		const selectionColCount = selectionBoundary.maxColumn - selectionBoundary.minColumn + 1;
+		startRow = selectionBoundary.minRow;
+		startCol = selectionBoundary.minColumn;
+		affectedRowCount = Math.min(affectedRowCount, selectionRowCount);
+		affectedColCount = Math.min(affectedColCount, selectionColCount);
+	}
+	let didPerformMergeOperations = false;
+	const lastRowForUnmerge = Math.min(initialRowCount, startRow + affectedRowCount) - 1;
+	const lastColForUnmerge = Math.min(initialColCount, startCol + affectedColCount) - 1;
+	const unmergedKeys = /* @__PURE__ */ new Set();
+	for (let row = startRow; row <= lastRowForUnmerge; row++) for (let col = startCol; col <= lastColForUnmerge; col++) {
+		const cellMap = initialGridMap[row][col];
+		if (unmergedKeys.has(cellMap.cell.getKey())) continue;
+		if (cellMap.cell.__rowSpan === 1 && cellMap.cell.__colSpan === 1) continue;
+		$unmergeCellNode(cellMap.cell);
+		unmergedKeys.add(cellMap.cell.getKey());
+		didPerformMergeOperations = true;
+	}
+	let [interimGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
+	const rowsToInsert = affectedRowCount - initialRowCount + startRow;
+	for (let i = 0; i < rowsToInsert; i++) {
+		const cellMap = interimGridMap[initialRowCount - 1][0];
+		$insertTableRowAtNode(cellMap.cell);
+	}
+	const colsToInsert = affectedColCount - initialColCount + startCol;
+	for (let i = 0; i < colsToInsert; i++) {
+		const cellMap = interimGridMap[0][initialColCount - 1];
+		$insertTableColumnAtNode(cellMap.cell, true, false);
+	}
+	[interimGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
+	for (let row = startRow; row < startRow + affectedRowCount; row++) for (let col = startCol; col < startCol + affectedColCount; col++) {
+		const templateRow = row - startRow;
+		const templateCol = col - startCol;
+		const templateCellMap = templateGridMap[templateRow][templateCol];
+		if (templateCellMap.startRow !== templateRow || templateCellMap.startColumn !== templateCol) continue;
+		const templateCell = templateCellMap.cell;
+		if (templateCell.__rowSpan !== 1 || templateCell.__colSpan !== 1) {
+			const cellsToMerge = [];
+			const lastRowForMerge = Math.min(row + templateCell.__rowSpan, startRow + affectedRowCount) - 1;
+			const lastColForMerge = Math.min(col + templateCell.__colSpan, startCol + affectedColCount) - 1;
+			for (let r = row; r <= lastRowForMerge; r++) for (let c = col; c <= lastColForMerge; c++) {
+				const cellMap = interimGridMap[r][c];
+				cellsToMerge.push(cellMap.cell);
+			}
+			$mergeCells(cellsToMerge);
+			didPerformMergeOperations = true;
+		}
+		const { cell } = interimGridMap[row][col];
+		const backgroundColor = templateCell.getBackgroundColor();
+		if (backgroundColor !== null && backgroundColor !== void 0) cell.setBackgroundColor(backgroundColor);
+		const originalChildren = cell.getChildren();
+		templateCell.getChildren().forEach((child) => {
+			if ($isTextNode(child)) {
+				$createParagraphNode().append(child);
+				cell.append(child);
+			} else cell.append(child);
+		});
+		originalChildren.forEach((n) => n.remove());
+	}
+	if (isTableSel && didPerformMergeOperations) {
+		const [finalGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
+		finalGridMap[anchorCellMap.startRow][anchorCellMap.startColumn].cell.selectEnd();
+	}
+	return true;
+}
+function $setTableRowIsHeader(tableNode, rowIndex, isHeader) {
+	const [gridMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+	if (!(rowIndex >= 0 && rowIndex < gridMap.length)) formatDevErrorMessage(`Table row index ${String(rowIndex)} out of range`);
+	const rowMap = gridMap[rowIndex];
+	const headerState = isHeader ? TableCellHeaderStates.ROW : TableCellHeaderStates.NO_STATUS;
+	const visited = /* @__PURE__ */ new Set();
+	for (let col = 0; col < rowMap.length; col++) {
+		const mapCell = rowMap[col];
+		if (mapCell == null) continue;
+		if (!visited.has(mapCell.cell)) {
+			visited.add(mapCell.cell);
+			mapCell.cell.setHeaderStyles(headerState, TableCellHeaderStates.ROW);
+		}
+	}
+}
+function $setTableColumnIsHeader(tableNode, columnIndex, isHeader) {
+	const [gridMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+	if (!(gridMap.length > 0 && columnIndex >= 0 && columnIndex < gridMap[0].length)) formatDevErrorMessage(`Table column index ${String(columnIndex)} out of range`);
+	const headerState = isHeader ? TableCellHeaderStates.COLUMN : TableCellHeaderStates.NO_STATUS;
+	const visited = /* @__PURE__ */ new Set();
+	for (let row = 0; row < gridMap.length; row++) {
+		const mapCell = gridMap[row][columnIndex];
+		if (mapCell == null) continue;
+		if (!visited.has(mapCell.cell)) {
+			visited.add(mapCell.cell);
+			mapCell.cell.setHeaderStyles(headerState, TableCellHeaderStates.COLUMN);
+		}
+	}
+}
 function $getCellNodes(tableSelection) {
 	const [[anchorNode, anchorCell, anchorRow, anchorTable], [focusNode, focusCell, focusRow, focusTable]] = ["anchor", "focus"].map((k) => {
 		const node = tableSelection[k].getNode();
@@ -1197,14 +1327,31 @@ var TableSelection = class TableSelection {
 	extract() {
 		return this.getNodes();
 	}
-	insertRawText(text) {}
+	insertRawText(text) {
+		if (text === "") return;
+		const tsvGrid = (text.endsWith("\n") ? text.slice(0, -1) : text).split("\n").map((line) => line.split("	"));
+		const tableNode = $createTableNode();
+		for (const row of tsvGrid) {
+			const rowNode = $createTableRowNode();
+			for (const cellText of row) {
+				const cellNode = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
+				const paragraph = $createParagraphNode();
+				if (cellText) paragraph.append($createTextNode(cellText));
+				cellNode.append(paragraph);
+				rowNode.append(cellNode);
+			}
+			tableNode.append(rowNode);
+		}
+		const { anchorCell } = $getCellNodes(this);
+		$insertTableIntoGrid(tableNode, anchorCell.select(0, anchorCell.getChildrenSize()));
+	}
 	insertText() {}
 	/**
 	* Returns whether the provided TextFormatType is present on the Selection.
 	* This will be true if any paragraph in table cells has the specified format.
 	*
 	* @param type the TextFormatType to check for.
-	* @returns true if the provided format is currently toggled on on the Selection, false otherwise.
+	* @returns true if the provided format is currently toggled on the Selection, false otherwise.
 	*/
 	hasFormat(type) {
 		let format = 0;
@@ -1220,6 +1367,7 @@ var TableSelection = class TableSelection {
 		if (!$isElementNode(focusNode)) formatDevErrorMessage(`Expected TableSelection focus to be an ElementNode`);
 		$normalizeSelection__EXPERIMENTAL(focusNode.select(0, focusNode.getChildrenSize())).insertNodes(nodes);
 	}
+	/** @deprecated Use {@link $computeTableMap} and {@link $computeTableCellRectBoundary} directly. */
 	getShape() {
 		const { anchorCell, focusCell } = $getCellNodes(this);
 		const anchorCellNodeRect = $getTableCellNodeRect(anchorCell);
@@ -1287,12 +1435,23 @@ var TableSelection = class TableSelection {
 		return textContent;
 	}
 };
+/** Type guard for {@link TableSelection}. */
 function $isTableSelection(x) {
 	return x instanceof TableSelection;
 }
+/** @deprecated Use {@link $createTableSelectionFrom} instead. */
 function $createTableSelection() {
 	return new TableSelection("root", $createPoint("root", 0, "element"), $createPoint("root", 0, "element"));
 }
+/**
+* Creates a {@link TableSelection} spanning from `anchorCell` to `focusCell`
+* within `tableNode`. In `__DEV__` mode, validates that both cells belong to
+* the given table and that the table is attached to the editor state.
+*
+* If the current selection is already a TableSelection, it clones and
+* re-targets it (preserving identity for dirty-checking); otherwise it
+* constructs a fresh one.
+*/
 function $createTableSelectionFrom(tableNode, anchorCell, focusCell) {
 	const tableNodeKey = tableNode.getKey();
 	const anchorCellKey = anchorCell.getKey();
@@ -1301,7 +1460,7 @@ function $createTableSelectionFrom(tableNode, anchorCell, focusCell) {
 	if (!tableNode.is($findTableNode(anchorCell))) formatDevErrorMessage(`$createTableSelectionFrom: anchorCell ${anchorCellKey} is not in table ${tableNodeKey}`);
 	if (!tableNode.is($findTableNode(focusCell))) formatDevErrorMessage(`$createTableSelectionFrom: focusCell ${focusCellKey} is not in table ${tableNodeKey}`);
 	const prevSelection = $getSelection();
-	const nextSelection = $isTableSelection(prevSelection) ? prevSelection.clone() : $createTableSelection();
+	const nextSelection = $isTableSelection(prevSelection) ? prevSelection.clone() : new TableSelection("root", $createPoint("root", 0, "element"), $createPoint("root", 0, "element"));
 	nextSelection.set(tableNode.getKey(), anchorCell.getKey(), focusCell.getKey());
 	return nextSelection;
 }
@@ -1525,7 +1684,7 @@ var TableObserver = class {
 		$updateDOMForSelection(editor, getTable(tableNode, tableElement), null);
 		if (setEmptySelection && $getSelection() !== null) {
 			$setSelection(null);
-			editor.dispatchCommand(SELECTION_CHANGE_COMMAND, void 0);
+			editor.dispatchCommand(SELECTION_CHANGE_COMMAND);
 		}
 	}
 	$enableHighlightStyle() {
@@ -1583,7 +1742,7 @@ var TableObserver = class {
 					this.focusCellNodeKey = targetCellNode.getKey();
 					this.tableSelection = $createTableSelectionFrom(tableNode, anchorTableCell, targetCellNode);
 					$setSelection(this.tableSelection);
-					editor.dispatchCommand(SELECTION_CHANGE_COMMAND, void 0);
+					editor.dispatchCommand(SELECTION_CHANGE_COMMAND);
 					$updateDOMForSelection(editor, this.table, this.tableSelection);
 					return true;
 				}
@@ -1645,7 +1804,7 @@ var TableObserver = class {
 			formatSelection.formatText(type, alignFormatWith);
 		});
 		$setSelection(selection);
-		this.editor.dispatchCommand(SELECTION_CHANGE_COMMAND, void 0);
+		this.editor.dispatchCommand(SELECTION_CHANGE_COMMAND);
 	}
 	$clearText() {
 		const { editor } = this;
@@ -1660,7 +1819,7 @@ var TableObserver = class {
 			tableNode.selectPrevious();
 			const parent = tableNode.getParent();
 			tableNode.remove();
-			if ($isRootNode(parent) && parent.isEmpty()) editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, void 0);
+			if ($isRootNode(parent) && parent.isEmpty()) editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND);
 			return;
 		}
 		selectedNodes.forEach((cellNode) => {
@@ -1676,7 +1835,7 @@ var TableObserver = class {
 		});
 		$updateDOMForSelection(editor, this.table, null);
 		$setSelection(null);
-		editor.dispatchCommand(SELECTION_CHANGE_COMMAND, void 0);
+		editor.dispatchCommand(SELECTION_CHANGE_COMMAND);
 	}
 };
 const LEXICAL_ELEMENT_KEY = "__lexicalTableSelection";
@@ -1688,6 +1847,14 @@ function $getTableNodeByKeyOrThrow(key) {
 const isPointerDownOnEvent = (event) => {
 	return (event.buttons & 1) === 1;
 };
+const AUTO_SCROLL_EDGE_ZONE = 40;
+const AUTO_SCROLL_MAX_STEP = 18;
+function autoScrollStep(pos, start, end) {
+	const speed = (depth) => Math.max(1, Math.ceil(Math.min(AUTO_SCROLL_EDGE_ZONE, depth) / AUTO_SCROLL_EDGE_ZONE * AUTO_SCROLL_MAX_STEP));
+	if (pos <= start + AUTO_SCROLL_EDGE_ZONE) return -speed(start + AUTO_SCROLL_EDGE_ZONE - pos);
+	if (pos >= end - AUTO_SCROLL_EDGE_ZONE) return speed(pos - (end - AUTO_SCROLL_EDGE_ZONE));
+	return 0;
+}
 function isHTMLTableElement(el) {
 	return isHTMLElement(el) && el.nodeName === "TABLE";
 }
@@ -1730,17 +1897,14 @@ function registerTableWindowHandlers(editor, tableObservers) {
 				if ($isTableSelection($getSelection())) {
 					for (const [observer] of tableObservers.observers.values()) observer.$clearHighlight(false);
 					$setSelection(null);
-					editor.dispatchCommand(SELECTION_CHANGE_COMMAND, void 0);
+					editor.dispatchCommand(SELECTION_CHANGE_COMMAND);
 				}
 				if (!selectionInfo) return;
 				const { tableObserver, tableElement, cellElement } = selectionInfo;
 				$handleTableClick(editor, event, cellElement, tableElement, tableObserver, tableObservers);
 			});
 		};
-		editorWindow.addEventListener("pointerdown", pointerDownCallback);
-		return () => {
-			editorWindow.removeEventListener("pointerdown", pointerDownCallback);
-		};
+		return registerEventListener(editorWindow, "pointerdown", pointerDownCallback);
 	});
 }
 function $handleTableClick(editor, event, selectedDOMCell, tableElement, tableObserver, tableObservers) {
@@ -1752,45 +1916,137 @@ function $handleTableClick(editor, event, selectedDOMCell, tableElement, tableOb
 		if (startingCell !== null && tableObserver.anchorCell === null) editor.update(() => {
 			tableObserver.$setAnchorCellForSelection(startingCell);
 		});
-		const onPointerUp = () => {
+		let lastClientX = event.clientX;
+		let lastClientY = event.clientY;
+		let autoScrollRafId = null;
+		const stopSelecting = () => {
 			tableObserver.isSelecting = false;
+			if (autoScrollRafId !== null) {
+				editorWindow.cancelAnimationFrame(autoScrollRafId);
+				autoScrollRafId = null;
+			}
 			editorWindow.removeEventListener("pointerup", onPointerUp);
 			editorWindow.removeEventListener("pointermove", onPointerMove);
 		};
+		const resolveFocusCellFromPoint = (clientX, clientY) => {
+			const tableRoot = tableElement.getRootNode();
+			if (!isDOMDocumentNode(tableRoot) && !isDOMShadowRoot(tableRoot)) return null;
+			for (const el of tableRoot.elementsFromPoint(clientX, clientY)) {
+				const cell = getDOMCellInTableFromTarget(tableElement, el);
+				if (cell) return cell;
+			}
+			return null;
+		};
+		const applyFocusCell = (focusCell, override) => {
+			if (tableObserver.anchorCell === null) editor.update(() => {
+				tableObserver.$setAnchorCellForSelection(focusCell);
+			});
+			if (tableObserver.focusCell === null || focusCell.elem !== tableObserver.focusCell.elem) {
+				tableObservers.setNextFocus({
+					focusCell,
+					override,
+					tableKey: tableObserver.tableNodeKey
+				});
+				editor.dispatchCommand(SELECTION_CHANGE_COMMAND);
+			}
+		};
+		const findScrollContainer = (axis) => {
+			for (let el = tableElement.parentElement; el; el = el.parentElement) if (axis === "x" ? el.scrollWidth > el.clientWidth : el.scrollHeight > el.clientHeight) {
+				const style = editorWindow.getComputedStyle(el);
+				const overflow = axis === "x" ? style.overflowX : style.overflowY;
+				if (overflow === "auto" || overflow === "scroll") return el;
+			}
+			return null;
+		};
+		const scrollAxis = (container, pos, axis) => {
+			let start;
+			let end;
+			if (container === null) {
+				start = 0;
+				end = axis === "x" ? editorWindow.innerWidth : editorWindow.innerHeight;
+			} else {
+				const rect = container.getBoundingClientRect();
+				start = axis === "x" ? rect.left : rect.top;
+				end = axis === "x" ? rect.right : rect.bottom;
+			}
+			const step = autoScrollStep(pos, start, end);
+			if (step === 0) return false;
+			if (container === null) {
+				const before = axis === "x" ? editorWindow.scrollX : editorWindow.scrollY;
+				editorWindow.scrollBy(axis === "x" ? step : 0, axis === "x" ? 0 : step);
+				return (axis === "x" ? editorWindow.scrollX : editorWindow.scrollY) !== before;
+			}
+			if (axis === "x") {
+				const before = container.scrollLeft;
+				container.scrollLeft += step;
+				return container.scrollLeft !== before;
+			}
+			const before = container.scrollTop;
+			container.scrollTop += step;
+			return container.scrollTop !== before;
+		};
+		const clampHitPoint = (hContainer, vContainer) => {
+			let x = lastClientX;
+			let y = lastClientY;
+			if (hContainer === null) x = Math.min(Math.max(x, 1), editorWindow.innerWidth - 1);
+			else {
+				const rect = hContainer.getBoundingClientRect();
+				x = Math.min(Math.max(x, rect.left + 1), rect.right - 1);
+			}
+			if (vContainer === null) y = Math.min(Math.max(y, 1), editorWindow.innerHeight - 1);
+			else {
+				const rect = vContainer.getBoundingClientRect();
+				y = Math.min(Math.max(y, rect.top + 1), rect.bottom - 1);
+			}
+			return [x, y];
+		};
+		const isNearScrollEdge = () => {
+			const hContainer = findScrollContainer("x");
+			if (hContainer !== null) {
+				const rect = hContainer.getBoundingClientRect();
+				if (autoScrollStep(lastClientX, rect.left, rect.right) !== 0) return true;
+			}
+			const vContainer = findScrollContainer("y");
+			const vStart = vContainer === null ? 0 : vContainer.getBoundingClientRect().top;
+			const vEnd = vContainer === null ? editorWindow.innerHeight : vContainer.getBoundingClientRect().bottom;
+			return autoScrollStep(lastClientY, vStart, vEnd) !== 0;
+		};
+		const tickAutoScroll = () => {
+			autoScrollRafId = null;
+			if (!tableObserver.isSelecting) return;
+			const hContainer = findScrollContainer("x");
+			const vContainer = findScrollContainer("y");
+			const scrolledX = hContainer !== null && scrollAxis(hContainer, lastClientX, "x");
+			const scrolledY = scrollAxis(vContainer, lastClientY, "y");
+			if (scrolledX || scrolledY) {
+				const [hitX, hitY] = clampHitPoint(hContainer, vContainer);
+				const focusCell = resolveFocusCellFromPoint(hitX, hitY);
+				if (focusCell) applyFocusCell(focusCell, false);
+				autoScrollRafId = editorWindow.requestAnimationFrame(tickAutoScroll);
+			}
+		};
+		const maybeStartAutoScroll = () => {
+			if (autoScrollRafId !== null || tableObserver.pointerType === "touch" || !isNearScrollEdge()) return;
+			autoScrollRafId = editorWindow.requestAnimationFrame(tickAutoScroll);
+		};
+		const onPointerUp = () => {
+			stopSelecting();
+		};
 		const onPointerMove = (moveEvent) => {
 			if (!isPointerDownOnEvent(moveEvent) && tableObserver.isSelecting) {
-				tableObserver.isSelecting = false;
-				editorWindow.removeEventListener("pointerup", onPointerUp);
-				editorWindow.removeEventListener("pointermove", onPointerMove);
+				stopSelecting();
 				return;
 			}
 			const moveTarget = getComposedEventTarget(moveEvent);
 			if (!isDOMNode(moveTarget)) return;
+			lastClientX = moveEvent.clientX;
+			lastClientY = moveEvent.clientY;
 			let focusCell = null;
 			const override = !(IS_FIREFOX || tableElement.contains(moveTarget));
 			if (override) focusCell = getDOMCellInTableFromTarget(tableElement, moveTarget);
-			else {
-				const tableRoot = tableElement.getRootNode();
-				if (!isDOMDocumentNode(tableRoot) && !isDOMShadowRoot(tableRoot)) return;
-				for (const el of tableRoot.elementsFromPoint(moveEvent.clientX, moveEvent.clientY)) {
-					focusCell = getDOMCellInTableFromTarget(tableElement, el);
-					if (focusCell) break;
-				}
-			}
-			if (focusCell) {
-				const anchorCell = focusCell;
-				if (tableObserver.anchorCell === null) editor.update(() => {
-					tableObserver.$setAnchorCellForSelection(anchorCell);
-				});
-				if (tableObserver.focusCell === null || focusCell.elem !== tableObserver.focusCell.elem) {
-					tableObservers.setNextFocus({
-						focusCell,
-						override,
-						tableKey: tableObserver.tableNodeKey
-					});
-					editor.dispatchCommand(SELECTION_CHANGE_COMMAND, void 0);
-				}
-			}
+			else focusCell = resolveFocusCellFromPoint(moveEvent.clientX, moveEvent.clientY);
+			if (focusCell) applyFocusCell(focusCell, override);
+			maybeStartAutoScroll();
 		};
 		editorWindow.addEventListener("pointerup", onPointerUp, tableObserver.listenerOptions);
 		editorWindow.addEventListener("pointermove", onPointerMove, tableObserver.listenerOptions);
@@ -1823,10 +2079,7 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler, tableObse
 			if (getDOMCellFromTarget(target) !== null) event.preventDefault();
 		}
 	};
-	tableElement.addEventListener("mousedown", onTripleClick, tableObserver.listenerOptions);
-	tableObserver.listenersToRemove.add(() => {
-		tableElement.removeEventListener("mousedown", onTripleClick);
-	});
+	tableObserver.listenersToRemove.add(registerEventListener(tableElement, "mousedown", onTripleClick, tableObserver.listenerOptions));
 	for (const [command, direction] of ARROW_KEY_COMMANDS_WITH_DIRECTION) tableObserver.listenersToRemove.add(editor.registerCommand(command, (event) => $handleArrowKey(editor, event, direction, tableNode, tableObserver, tableObservers), COMMAND_PRIORITY_HIGH));
 	tableObserver.listenersToRemove.add(editor.registerCommand(KEY_ESCAPE_COMMAND, (event) => {
 		const selection = $getSelection();
@@ -1840,30 +2093,16 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler, tableObse
 		}
 		return false;
 	}, COMMAND_PRIORITY_HIGH));
-	const deleteTextHandler = (command) => () => {
+	const $deleteTextHandler = () => {
 		const selection = $getSelection();
 		if (!$isSelectionInTable(selection, tableNode)) return false;
 		if ($isTableSelection(selection)) {
 			tableObserver.$clearText();
 			return true;
-		} else if ($isRangeSelection(selection)) {
-			if (!$isTableCellNode($findParentTableCellNodeInTable(tableNode, selection.anchor.getNode()))) return false;
-			const anchorNode = selection.anchor.getNode();
-			const focusNode = selection.focus.getNode();
-			const isAnchorInside = tableNode.isParentOf(anchorNode);
-			const isFocusInside = tableNode.isParentOf(focusNode);
-			if (isAnchorInside && !isFocusInside || isFocusInside && !isAnchorInside) {
-				tableObserver.$clearText();
-				return true;
-			}
-			const nearestElementNode = $findMatchingParent(selection.anchor.getNode(), (n) => $isElementNode(n));
-			const topLevelCellElementNode = nearestElementNode && $findMatchingParent(nearestElementNode, (n) => $isElementNode(n) && $isTableCellNode(n.getParent()));
-			if (!$isElementNode(topLevelCellElementNode) || !$isElementNode(nearestElementNode)) return false;
-			if (command === DELETE_LINE_COMMAND && topLevelCellElementNode.getPreviousSibling() === null) return true;
 		}
 		return false;
 	};
-	for (const command of DELETE_TEXT_COMMANDS) tableObserver.listenersToRemove.add(editor.registerCommand(command, deleteTextHandler(command), COMMAND_PRIORITY_HIGH));
+	for (const command of DELETE_TEXT_COMMANDS) tableObserver.listenersToRemove.add(editor.registerCommand(command, $deleteTextHandler, COMMAND_PRIORITY_HIGH));
 	const $deleteCellHandler = (event) => {
 		const selection = $getSelection();
 		if (!($isTableSelection(selection) || $isRangeSelection(selection))) return false;
@@ -1901,14 +2140,35 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler, tableObse
 		}
 		return false;
 	}, COMMAND_PRIORITY_HIGH));
+	const doc = rootElement.ownerDocument;
+	tableObserver.listenersToRemove.add(registerEventListener(doc, "paste", (event) => {
+		if (event.defaultPrevented) return;
+		if (editor.read("latest", () => {
+			const selection = $getSelection();
+			return rootElement.contains(doc.activeElement) && $isTableSelection(selection) && $isSelectionInTable(selection, tableNode);
+		})) {
+			event.preventDefault();
+			editor.dispatchCommand(PASTE_COMMAND, event);
+		}
+	}));
+	tableObserver.listenersToRemove.add(registerEventListener(doc, "copy", (event) => {
+		if (event.defaultPrevented) return;
+		const target = getComposedEventTarget(event);
+		if (target === rootElement || isDOMNode(target) && rootElement.contains(target)) return;
+		if (editor.read("latest", () => {
+			const selection = $getSelection();
+			return rootElement.contains(getActiveElement(rootElement)) && $isTableSelection(selection) && $isSelectionInTable(selection, tableNode);
+		})) {
+			event.preventDefault();
+			editor.dispatchCommand(COPY_COMMAND, event);
+		}
+	}));
 	tableObserver.listenersToRemove.add(editor.registerCommand(FORMAT_TEXT_COMMAND, (payload) => {
 		const selection = $getSelection();
 		if (!$isSelectionInTable(selection, tableNode)) return false;
 		if ($isTableSelection(selection)) {
 			tableObserver.$formatCells(payload);
 			return true;
-		} else if ($isRangeSelection(selection)) {
-			if (!$isTableCellNode($findMatchingParent(selection.anchor.getNode(), (n) => $isTableCellNode(n)))) return false;
 		}
 		return false;
 	}, COMMAND_PRIORITY_HIGH));
@@ -1918,15 +2178,15 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler, tableObse
 		const anchorNode = selection.anchor.getNode();
 		const focusNode = selection.focus.getNode();
 		if (!$isTableCellNode(anchorNode) || !$isTableCellNode(focusNode)) return false;
-		if ($isFullTableSelection(selection, tableNode)) {
-			tableNode.setFormat(formatType);
-			return true;
-		}
 		const [tableMap, anchorCell, focusCell] = $computeTableMap(tableNode, anchorNode, focusNode);
 		const maxRow = Math.max(anchorCell.startRow + anchorCell.cell.__rowSpan - 1, focusCell.startRow + focusCell.cell.__rowSpan - 1);
 		const maxColumn = Math.max(anchorCell.startColumn + anchorCell.cell.__colSpan - 1, focusCell.startColumn + focusCell.cell.__colSpan - 1);
 		const minRow = Math.min(anchorCell.startRow, focusCell.startRow);
 		const minColumn = Math.min(anchorCell.startColumn, focusCell.startColumn);
+		if (minRow === 0 && minColumn === 0 && maxRow === tableMap.length - 1 && maxColumn === tableMap[0].length - 1) {
+			tableNode.setFormat(formatType);
+			return true;
+		}
 		const visited = /* @__PURE__ */ new Set();
 		for (let i = minRow; i <= maxRow; i++) for (let j = minColumn; j <= maxColumn; j++) {
 			const cell = tableMap[i][j].cell;
@@ -2355,17 +2615,6 @@ function $isSelectionInTable(selection, tableNode) {
 	}
 	return false;
 }
-function $isFullTableSelection(selection, tableNode) {
-	if ($isTableSelection(selection)) {
-		const anchorNode = selection.anchor.getNode();
-		const focusNode = selection.focus.getNode();
-		if (tableNode && anchorNode && focusNode) {
-			const [map] = $computeTableMap(tableNode, anchorNode, focusNode);
-			return anchorNode.getKey() === map[0][0].cell.getKey() && focusNode.getKey() === map[map.length - 1].at(-1).cell.getKey();
-		}
-	}
-	return false;
-}
 function selectTableCellNode(tableCell, fromStart) {
 	if (fromStart) tableCell.selectStart();
 	else tableCell.selectEnd();
@@ -2650,13 +2899,21 @@ const __DEV__ = true;
 function isHTMLDivElement(element) {
 	return isHTMLElement(element) && element.nodeName === "DIV";
 }
-function updateColgroup(dom, colCount, colWidths) {
-	const colGroup = dom.querySelector("colgroup");
-	if (!colGroup) return;
+function $updateColgroup(dom, colCount, colWidths) {
+	let colGroup = dom.querySelector(":scope > colgroup");
+	if (!colWidths) {
+		if (colGroup) colGroup.remove();
+		return;
+	}
+	if (!colGroup) {
+		colGroup = $getDocument().createElement("colgroup");
+		setDOMUnmanaged(colGroup);
+		dom.insertBefore(colGroup, dom.firstChild);
+	}
 	const cols = [];
 	for (let i = 0; i < colCount; i++) {
-		const col = document.createElement("col");
-		const width = colWidths && colWidths[i];
+		const col = $getDocument().createElement("col");
+		const width = colWidths[i];
 		if (width) col.style.width = `${width}px`;
 		cols.push(col);
 	}
@@ -2701,10 +2958,115 @@ function alignTableElement(dom, config, formatType) {
 	removeClassNamesFromElement(dom, ...removeClasses);
 	addClassNamesToElement(dom, ...addClasses);
 }
+function $createScrollableWrapper(tableElement, config, hideNativeScrollbar) {
+	const wrapper = $getDocument().createElement("div");
+	const classes = config.theme.tableScrollableWrapper;
+	if (classes) addClassNamesToElement(wrapper, classes);
+	else wrapper.style.overflowX = "auto";
+	if (hideNativeScrollbar) wrapper.style.scrollbarWidth = "none";
+	wrapper.appendChild(tableElement);
+	return wrapper;
+}
+function $createStickyScrollbar(config) {
+	const doc = $getDocument();
+	const scrollbar = doc.createElement("div");
+	const classes = config.theme.tableStickyScrollbar;
+	if (classes) addClassNamesToElement(scrollbar, classes);
+	else {
+		scrollbar.style.position = "sticky";
+		scrollbar.style.bottom = "0";
+		scrollbar.style.overflowX = "scroll";
+		scrollbar.style.overflowY = "hidden";
+	}
+	scrollbar.style.display = "none";
+	scrollbar.setAttribute("aria-hidden", "true");
+	scrollbar.tabIndex = -1;
+	const spacer = doc.createElement("div");
+	spacer.style.height = "1px";
+	spacer.style.width = "0px";
+	scrollbar.appendChild(spacer);
+	return scrollbar;
+}
+const overlayStickyScrollbars = /* @__PURE__ */ new WeakSet();
+function measureScrollbarThickness(scrollbar) {
+	const prevDisplay = scrollbar.style.display;
+	scrollbar.style.display = "";
+	const thickness = scrollbar.offsetHeight - scrollbar.clientHeight;
+	scrollbar.style.display = prevDisplay;
+	return thickness;
+}
+function attachStickyScrollbarListeners(elements) {
+	const { scrollable, scrollbar, tableElement } = elements;
+	if (scrollbar.classList.length === 0 && measureScrollbarThickness(scrollbar) === 0) {
+		overlayStickyScrollbars.add(scrollbar);
+		scrollbar.style.display = "none";
+		scrollable.style.scrollbarWidth = "auto";
+		return () => {};
+	}
+	const onWrapperScroll = () => {
+		if (scrollbar.scrollLeft !== scrollable.scrollLeft) scrollbar.scrollLeft = scrollable.scrollLeft;
+	};
+	const onScrollbarScroll = () => {
+		if (scrollable.scrollLeft !== scrollbar.scrollLeft) scrollable.scrollLeft = scrollbar.scrollLeft;
+	};
+	scrollable.addEventListener("scroll", onWrapperScroll, { passive: true });
+	scrollbar.addEventListener("scroll", onScrollbarScroll, { passive: true });
+	let resizeObserver = null;
+	if (typeof ResizeObserver !== "undefined") {
+		resizeObserver = new ResizeObserver(() => {
+			syncStickyScrollbar(scrollable, scrollbar);
+		});
+		resizeObserver.observe(scrollable);
+		resizeObserver.observe(tableElement);
+	}
+	const cleanup = () => {
+		scrollable.removeEventListener("scroll", onWrapperScroll);
+		scrollbar.removeEventListener("scroll", onScrollbarScroll);
+		if (resizeObserver) resizeObserver.disconnect();
+	};
+	syncStickyScrollbar(scrollable, scrollbar);
+	return cleanup;
+}
+function syncStickyScrollbar(scrollable, scrollbar) {
+	if (overlayStickyScrollbars.has(scrollbar)) return;
+	const spacer = scrollbar.firstElementChild;
+	if (!spacer || !isHTMLElement(spacer) || !scrollable.isConnected) return;
+	const view = scrollable.ownerDocument.defaultView;
+	if (!view) {
+		scrollbar.style.display = "none";
+		return;
+	}
+	const overflowX = view.getComputedStyle(scrollable).overflowX;
+	const isScrollable = overflowX === "auto" || overflowX === "scroll";
+	const scrollWidth = scrollable.scrollWidth;
+	const clientWidth = scrollable.clientWidth;
+	const spacerWidth = scrollWidth + "px";
+	if (spacer.style.width !== spacerWidth) spacer.style.width = spacerWidth;
+	const hasOverflow = isScrollable && scrollWidth > clientWidth;
+	scrollbar.style.display = hasOverflow ? "" : "none";
+}
+function findStickyScrollbarElements(dom) {
+	if (!dom.hasAttribute("data-lexical-sticky-scrollbar")) return null;
+	const firstChild = dom.firstElementChild;
+	if (!isHTMLDivElement(firstChild)) return null;
+	const tableElement = firstChild.querySelector(":scope > table");
+	if (!isHTMLTableElement(tableElement)) return null;
+	const scrollbar = firstChild.nextElementSibling;
+	if (!isHTMLDivElement(scrollbar)) return null;
+	return {
+		scrollable: firstChild,
+		scrollbar,
+		tableElement
+	};
+}
 const scrollableEditors = /* @__PURE__ */ new WeakSet();
 function $isScrollableTablesActive(editor = $getEditor()) {
 	return scrollableEditors.has(editor);
 }
+function $isStickyScrollbarActive(editor = $getEditor()) {
+	const dep = getPeerDependencyFromEditor(editor, "@lexical/table/Table");
+	return dep ? dep.output.hasStickyScrollbar.peek() && dep.output.hasHorizontalScroll.peek() : false;
+}
 function setScrollableTablesActive(editor, active) {
 	if (active) {
 		if (!editor._config.theme.tableScrollableWrapper) console.warn("TableNode: hasHorizontalScroll is active but theme.tableScrollableWrapper is not defined.");
@@ -2712,14 +3074,20 @@ function setScrollableTablesActive(editor, active) {
 	} else scrollableEditors.delete(editor);
 }
 /** @noInheritDoc */
-var TableNode = class TableNode extends ElementNode {
+var TableNode = class extends ElementNode {
 	/** @internal */
-	__rowStriping;
-	__frozenColumnCount;
-	__frozenRowCount;
-	__colWidths;
-	static getType() {
-		return "table";
+	__rowStriping = false;
+	__frozenColumnCount = 0;
+	__frozenRowCount = 0;
+	__colWidths = void 0;
+	$config() {
+		return this.config("table", {
+			extends: ElementNode,
+			importDOM: { table: () => ({
+				conversion: $convertTableElement,
+				priority: 1
+			}) }
+		});
 	}
 	getColWidths() {
 		return this.getLatest().__colWidths;
@@ -2729,9 +3097,6 @@ var TableNode = class TableNode extends ElementNode {
 		self.__colWidths = colWidths !== void 0 && __DEV__ ? Object.freeze(colWidths) : colWidths;
 		return self;
 	}
-	static clone(node) {
-		return new TableNode(node.__key);
-	}
 	afterCloneFrom(prevNode) {
 		super.afterCloneFrom(prevNode);
 		this.__colWidths = prevNode.__colWidths;
@@ -2739,25 +3104,9 @@ var TableNode = class TableNode extends ElementNode {
 		this.__frozenColumnCount = prevNode.__frozenColumnCount;
 		this.__frozenRowCount = prevNode.__frozenRowCount;
 	}
-	static importDOM() {
-		return { table: (_node) => ({
-			conversion: $convertTableElement,
-			priority: 1
-		}) };
-	}
-	static importJSON(serializedNode) {
-		return $createTableNode().updateFromJSON(serializedNode);
-	}
 	updateFromJSON(serializedNode) {
 		return super.updateFromJSON(serializedNode).setRowStriping(serializedNode.rowStriping || false).setFrozenColumns(serializedNode.frozenColumnCount || 0).setFrozenRows(serializedNode.frozenRowCount || 0).setColWidths(serializedNode.colWidths);
 	}
-	constructor(key) {
-		super(key);
-		this.__rowStriping = false;
-		this.__frozenColumnCount = 0;
-		this.__frozenRowCount = 0;
-		this.__colWidths = void 0;
-	}
 	exportJSON() {
 		return {
 			...super.exportJSON(),
@@ -2773,24 +3122,32 @@ var TableNode = class TableNode extends ElementNode {
 	getDOMSlot(element) {
 		const tableElement = !isHTMLTableElement(element) ? element.querySelector("table") : element;
 		if (!isHTMLTableElement(tableElement)) formatDevErrorMessage(`TableNode.getDOMSlot: createDOM() did not return a table`);
-		return super.getDOMSlot(element).withElement(tableElement).withAfter(tableElement.querySelector("colgroup"));
+		return super.getDOMSlot(element).withElement(tableElement).withAfter(tableElement.querySelector(":scope > colgroup"));
 	}
 	createDOM(config, editor) {
-		const tableElement = document.createElement("table");
+		const tableElement = $getDocument().createElement("table");
 		if (this.__style) setDOMStyleFromCSS(tableElement.style, this.__style);
-		const colGroup = document.createElement("colgroup");
-		tableElement.appendChild(colGroup);
-		setDOMUnmanaged(colGroup);
+		if (this.getColWidths()) {
+			const colGroup = $getDocument().createElement("colgroup");
+			tableElement.appendChild(colGroup);
+			setDOMUnmanaged(colGroup);
+		}
 		addClassNamesToElement(tableElement, config.theme.table);
 		this.updateTableElement(null, tableElement, config);
 		if ($isScrollableTablesActive(editor)) {
-			const wrapperElement = document.createElement("div");
-			const classes = config.theme.tableScrollableWrapper;
-			if (classes) addClassNamesToElement(wrapperElement, classes);
-			else wrapperElement.style.overflowX = "auto";
-			wrapperElement.appendChild(tableElement);
-			this.updateTableWrapper(null, wrapperElement, tableElement, config);
-			return wrapperElement;
+			const hasStickyScrollbar = $isStickyScrollbarActive(editor);
+			const scrollableWrapper = $createScrollableWrapper(tableElement, config, hasStickyScrollbar);
+			this.updateTableWrapper(null, scrollableWrapper, tableElement, config);
+			if (hasStickyScrollbar) {
+				const stickyScrollbar = $createStickyScrollbar(config);
+				const outerWrapper = $getDocument().createElement("div");
+				outerWrapper.setAttribute("data-lexical-sticky-scrollbar", "true");
+				outerWrapper.appendChild(scrollableWrapper);
+				outerWrapper.appendChild(stickyScrollbar);
+				setDOMUnmanaged(stickyScrollbar);
+				return outerWrapper;
+			}
+			return scrollableWrapper;
 		}
 		return tableElement;
 	}
@@ -2803,20 +3160,24 @@ var TableNode = class TableNode extends ElementNode {
 		if (this.__rowStriping !== (prevNode ? prevNode.__rowStriping : false)) setRowStriping(tableElement, config, this.__rowStriping);
 		const prevColCount = prevNode ? prevNode.getColumnCount() : 0;
 		const prevColWidths = prevNode ? prevNode.__colWidths : void 0;
-		if (this.getColumnCount() !== prevColCount || this.getColWidths() !== prevColWidths) updateColgroup(tableElement, this.getColumnCount(), this.getColWidths());
+		if (this.getColumnCount() !== prevColCount || this.getColWidths() !== prevColWidths) $updateColgroup(tableElement, this.getColumnCount(), this.getColWidths());
 		alignTableElement(tableElement, config, this.getFormatType());
 	}
 	updateDOM(prevNode, dom, config) {
 		const tableElement = getTableElement(this, dom);
 		if (dom === tableElement === $isScrollableTablesActive()) return true;
-		if (isHTMLDivElement(dom)) this.updateTableWrapper(prevNode, dom, tableElement, config);
+		if (isHTMLDivElement(dom)) {
+			if (dom.hasAttribute("data-lexical-sticky-scrollbar") !== $isStickyScrollbarActive()) return true;
+			const scrollable = tableElement.parentElement;
+			if (isHTMLDivElement(scrollable)) this.updateTableWrapper(prevNode, scrollable, tableElement, config);
+		}
 		this.updateTableElement(prevNode, tableElement, config);
 		return false;
 	}
 	scaleDOMColWidths(dom, scale) {
 		const colWidths = this.getColWidths();
 		if (!colWidths) return;
-		updateColgroup(getTableElement(this, dom), this.getColumnCount(), colWidths.map((width) => width * scale));
+		$updateColgroup(getTableElement(this, dom), this.getColumnCount(), colWidths.map((width) => width * scale));
 	}
 	exportDOM(editor) {
 		const superExport = super.exportDOM(editor);
@@ -2855,7 +3216,7 @@ var TableNode = class TableNode extends ElementNode {
 				}
 				const rows = tableElement.querySelectorAll(":scope > tr");
 				if (rows.length > 0) {
-					const tBody = document.createElement("tbody");
+					const tBody = $getDocument().createElement("tbody");
 					for (const row of rows) tBody.appendChild(row);
 					tableElement.append(tBody);
 				}
@@ -3157,7 +3518,21 @@ function registerTablePlugin(editor, options) {
 }
 function $tableSelectionInsertClipboardNodesCommand(selectionPayload, hasNestedTables) {
 	const { nodes, selection } = selectionPayload;
-	if (!nodes.some((n) => $isTableNode(n) || $dfsWithSlots(n).some((d) => $isTableNode(d.node)))) return false;
+	if (!nodes.some((n) => $isTableNode(n) || $dfs(n).some((d) => $isTableNode(d.node)))) {
+		if ($isTableSelection(selection)) {
+			let text = "";
+			let lastWasBlock = false;
+			for (const node of nodes) {
+				const isBlock = $isElementNode(node) && !node.isInline();
+				if (text.length > 0 && (isBlock || lastWasBlock)) text += "\n";
+				text += node.getTextContent();
+				lastWasBlock = isBlock;
+			}
+			selection.insertRawText(text);
+			return true;
+		}
+		return false;
+	}
 	const isTableSelection = $isTableSelection(selection);
 	const isRangeSelection = $isRangeSelection(selection);
 	if (!(isRangeSelection && $findMatchingParent(selection.anchor.getNode(), (n) => $isTableCellNode(n)) !== null && $findMatchingParent(selection.focus.getNode(), (n) => $isTableCellNode(n)) !== null || isTableSelection)) return false;
@@ -3165,90 +3540,6 @@ function $tableSelectionInsertClipboardNodesCommand(selectionPayload, hasNestedT
 	if (isRangeSelection && hasNestedTables.peek() && !$isMultiCellTableSelection(selection)) return false;
 	return true;
 }
-function $insertTableIntoGrid(tableNode, selection) {
-	const anchorAndFocus = selection.getStartEndPoints();
-	const isTableSelection = $isTableSelection(selection);
-	if (anchorAndFocus === null) return false;
-	const [anchor, focus] = anchorAndFocus;
-	const [anchorCellNode, anchorRowNode, gridNode] = $getNodeTriplet(anchor);
-	const focusCellNode = $findMatchingParent(focus.getNode(), (n) => $isTableCellNode(n));
-	if (!$isTableCellNode(anchorCellNode) || !$isTableCellNode(focusCellNode) || !$isTableRowNode(anchorRowNode) || !$isTableNode(gridNode)) return false;
-	const [initialGridMap, anchorCellMap, focusCellMap] = $computeTableMap(gridNode, anchorCellNode, focusCellNode);
-	const [templateGridMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
-	const initialRowCount = initialGridMap.length;
-	const initialColCount = initialRowCount > 0 ? initialGridMap[0].length : 0;
-	let startRow = anchorCellMap.startRow;
-	let startCol = anchorCellMap.startColumn;
-	let affectedRowCount = templateGridMap.length;
-	let affectedColCount = affectedRowCount > 0 ? templateGridMap[0].length : 0;
-	if (isTableSelection) {
-		const selectionBoundary = $computeTableCellRectBoundary(initialGridMap, anchorCellMap, focusCellMap);
-		const selectionRowCount = selectionBoundary.maxRow - selectionBoundary.minRow + 1;
-		const selectionColCount = selectionBoundary.maxColumn - selectionBoundary.minColumn + 1;
-		startRow = selectionBoundary.minRow;
-		startCol = selectionBoundary.minColumn;
-		affectedRowCount = Math.min(affectedRowCount, selectionRowCount);
-		affectedColCount = Math.min(affectedColCount, selectionColCount);
-	}
-	let didPerformMergeOperations = false;
-	const lastRowForUnmerge = Math.min(initialRowCount, startRow + affectedRowCount) - 1;
-	const lastColForUnmerge = Math.min(initialColCount, startCol + affectedColCount) - 1;
-	const unmergedKeys = /* @__PURE__ */ new Set();
-	for (let row = startRow; row <= lastRowForUnmerge; row++) for (let col = startCol; col <= lastColForUnmerge; col++) {
-		const cellMap = initialGridMap[row][col];
-		if (unmergedKeys.has(cellMap.cell.getKey())) continue;
-		if (cellMap.cell.__rowSpan === 1 && cellMap.cell.__colSpan === 1) continue;
-		$unmergeCellNode(cellMap.cell);
-		unmergedKeys.add(cellMap.cell.getKey());
-		didPerformMergeOperations = true;
-	}
-	let [interimGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
-	const rowsToInsert = affectedRowCount - initialRowCount + startRow;
-	for (let i = 0; i < rowsToInsert; i++) {
-		const cellMap = interimGridMap[initialRowCount - 1][0];
-		$insertTableRowAtNode(cellMap.cell);
-	}
-	const colsToInsert = affectedColCount - initialColCount + startCol;
-	for (let i = 0; i < colsToInsert; i++) {
-		const cellMap = interimGridMap[0][initialColCount - 1];
-		$insertTableColumnAtNode(cellMap.cell, true, false);
-	}
-	[interimGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
-	for (let row = startRow; row < startRow + affectedRowCount; row++) for (let col = startCol; col < startCol + affectedColCount; col++) {
-		const templateRow = row - startRow;
-		const templateCol = col - startCol;
-		const templateCellMap = templateGridMap[templateRow][templateCol];
-		if (templateCellMap.startRow !== templateRow || templateCellMap.startColumn !== templateCol) continue;
-		const templateCell = templateCellMap.cell;
-		if (templateCell.__rowSpan !== 1 || templateCell.__colSpan !== 1) {
-			const cellsToMerge = [];
-			const lastRowForMerge = Math.min(row + templateCell.__rowSpan, startRow + affectedRowCount) - 1;
-			const lastColForMerge = Math.min(col + templateCell.__colSpan, startCol + affectedColCount) - 1;
-			for (let r = row; r <= lastRowForMerge; r++) for (let c = col; c <= lastColForMerge; c++) {
-				const cellMap = interimGridMap[r][c];
-				cellsToMerge.push(cellMap.cell);
-			}
-			$mergeCells(cellsToMerge);
-			didPerformMergeOperations = true;
-		}
-		const { cell } = interimGridMap[row][col];
-		const backgroundColor = templateCell.getBackgroundColor();
-		if (backgroundColor !== null && backgroundColor !== void 0) cell.setBackgroundColor(backgroundColor);
-		const originalChildren = cell.getChildren();
-		templateCell.getChildren().forEach((child) => {
-			if ($isTextNode(child)) {
-				$createParagraphNode().append(child);
-				cell.append(child);
-			} else cell.append(child);
-		});
-		originalChildren.forEach((n) => n.remove());
-	}
-	if (isTableSelection && didPerformMergeOperations) {
-		const [finalGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
-		finalGridMap[anchorCellMap.startRow][anchorCellMap.startColumn].cell.selectEnd();
-	}
-	return true;
-}
 function $isMultiCellTableSelection(selection) {
 	if ($isTableSelection(selection) && !selection.focus.getNode().is(selection.anchor.getNode())) return true;
 	if ($isRangeSelection(selection) && $isTableCellNode(selection.anchor.getNode()) && !selection.anchor.getNode().is(selection.focus.getNode())) return true;
@@ -3435,6 +3726,39 @@ const TableImportRules = [
 * LICENSE file in the root directory of this source tree.
 *
 */
+function registerStickyScrollbar(editor) {
+	const attached = /* @__PURE__ */ new Map();
+	const detachAll = () => {
+		for (const { cleanup } of attached.values()) cleanup();
+		attached.clear();
+	};
+	return mergeRegister(detachAll, editor.registerMutationListener(TableNode, (nodeMutations) => {
+		for (const [nodeKey, mutation] of nodeMutations) {
+			const prev = attached.get(nodeKey);
+			if (mutation === "destroyed") {
+				if (prev) {
+					prev.cleanup();
+					attached.delete(nodeKey);
+				}
+				continue;
+			}
+			const dom = editor.getElementByKey(nodeKey);
+			const parts = dom && isHTMLElement(dom) ? findStickyScrollbarElements(dom) : null;
+			if (prev && parts && prev.parts.scrollable === parts.scrollable && prev.parts.scrollbar === parts.scrollbar && prev.parts.tableElement === parts.tableElement) {
+				syncStickyScrollbar(parts.scrollable, parts.scrollbar);
+				continue;
+			}
+			if (prev) {
+				prev.cleanup();
+				attached.delete(nodeKey);
+			}
+			if (parts) attached.set(nodeKey, {
+				cleanup: attachStickyScrollbarListeners(parts),
+				parts
+			});
+		}
+	}, { skipInitialization: false }));
+}
 /**
 * Configures {@link TableNode}, {@link TableRowNode}, {@link TableCellNode} and
 * registers table behaviors (see {@link TableConfig})
@@ -3448,6 +3772,7 @@ const TableExtension = /* @__PURE__ */ defineExtension({
 		hasCellMerge: true,
 		hasHorizontalScroll: true,
 		hasNestedTables: false,
+		hasStickyScrollbar: false,
 		hasTabHandler: true
 	}),
 	dependencies: [CoreImportExtension, /* @__PURE__ */ configExtension(DOMImportExtension, { rules: TableImportRules })],
@@ -3459,13 +3784,19 @@ const TableExtension = /* @__PURE__ */ defineExtension({
 	],
 	register(editor, config, state) {
 		const stores = state.getOutput();
+		let prevStickyScrollbar = false;
 		return mergeRegister(effect(() => {
 			const hasHorizontalScroll = stores.hasHorizontalScroll.value;
-			if ($isScrollableTablesActive(editor) !== hasHorizontalScroll) {
-				setScrollableTablesActive(editor, hasHorizontalScroll);
-				editor.update($fullReconcile);
-			}
-		}), registerTablePlugin(editor, stores), effect(() => registerTableSelectionObserver(editor, stores.hasTabHandler.value)), effect(() => stores.hasCellMerge.value ? void 0 : registerTableCellUnmergeTransform(editor)), effect(() => stores.hasCellBackgroundColor.value ? void 0 : editor.registerNodeTransform(TableCellNode, (node) => {
+			const hasStickyScrollbar = stores.hasStickyScrollbar.value && hasHorizontalScroll;
+			const hadHorizontalScroll = $isScrollableTablesActive(editor);
+			if (hadHorizontalScroll !== hasHorizontalScroll) setScrollableTablesActive(editor, hasHorizontalScroll);
+			if (hadHorizontalScroll !== hasHorizontalScroll || prevStickyScrollbar !== hasStickyScrollbar) editor.update($fullReconcile);
+			prevStickyScrollbar = hasStickyScrollbar;
+		}), registerTablePlugin(editor, stores), effect(() => registerTableSelectionObserver(editor, stores.hasTabHandler.value)), effect(() => {
+			if (stores.hasStickyScrollbar.value && stores.hasHorizontalScroll.value) return editor.registerRootListener((rootElement) => {
+				if (rootElement) return registerStickyScrollbar(editor);
+			});
+		}), effect(() => stores.hasCellMerge.value ? void 0 : registerTableCellUnmergeTransform(editor)), effect(() => stores.hasCellBackgroundColor.value ? void 0 : editor.registerNodeTransform(TableCellNode, (node) => {
 			if (node.getBackgroundColor() !== null) node.setBackgroundColor(null);
 		})));
 	}
@@ -3484,4 +3815,4 @@ const TableImportExtension = /* @__PURE__ */ defineExtension({
 	name: "@lexical/table/Import"
 });
 //#endregion
-export { $computeTableMap, $computeTableMapSkipCellCheck, $createTableCellNode, $createTableNode, $createTableNodeWithDimensions, $createTableRowNode, $createTableSelection, $createTableSelectionFrom, $deleteTableColumn, $deleteTableColumnAtSelection, $deleteTableColumn__EXPERIMENTAL, $deleteTableRowAtSelection, $deleteTableRow__EXPERIMENTAL, $findCellNode, $findTableNode, $getElementForTableNode, $getNodeTriplet, $getTableAndElementByKey, $getTableCellNodeFromLexicalNode, $getTableCellNodeRect, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $getTableRowNodeFromTableCellNodeOrThrow, $insertTableColumn, $insertTableColumnAtSelection, $insertTableColumn__EXPERIMENTAL, $insertTableRow, $insertTableRowAtSelection, $insertTableRow__EXPERIMENTAL, $isScrollableTablesActive, $isSimpleTable, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, $mergeCells, $moveTableColumn, $removeTableRowAtIndex, $unmergeCell, INSERT_TABLE_COMMAND, TableCellHeaderStates, TableCellNode, TableExtension, TableImportExtension, TableImportRules, TableNode, TableObserver, TableRowNode, TableRowSchema, TableSchema, applyTableHandlers, getDOMCellFromTarget, getTableElement, getTableObserverFromTableElement, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive };
+export { $computeTableCellRectBoundary, $computeTableMap, $computeTableMapSkipCellCheck, $createTableCellNode, $createTableNode, $createTableNodeWithDimensions, $createTableRowNode, $createTableSelection, $createTableSelectionFrom, $deleteTableColumn, $deleteTableColumnAtSelection, $deleteTableColumn__EXPERIMENTAL, $deleteTableRowAtSelection, $deleteTableRow__EXPERIMENTAL, $findCellNode, $findTableNode, $getElementForTableNode, $getNodeTriplet, $getTableAndElementByKey, $getTableCellNodeFromLexicalNode, $getTableCellNodeRect, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $getTableRowNodeFromTableCellNodeOrThrow, $insertTableColumn, $insertTableColumnAtNode, $insertTableColumnAtSelection, $insertTableColumn__EXPERIMENTAL, $insertTableRow, $insertTableRowAtNode, $insertTableRowAtSelection, $insertTableRow__EXPERIMENTAL, $isScrollableTablesActive, $isSimpleTable, $isStickyScrollbarActive, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, $mergeCells, $moveTableColumn, $moveTableRow, $removeTableRowAtIndex, $setTableColumnIsHeader, $setTableRowIsHeader, $unmergeCell, $unmergeCellNode, INSERT_TABLE_COMMAND, TableCellHeaderStates, TableCellNode, TableExtension, TableImportExtension, TableImportRules, TableNode, TableObserver, TableRowNode, TableRowSchema, TableSchema, applyTableHandlers, getDOMCellFromTarget, getTableElement, getTableObserverFromTableElement, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive };