@prosekit/extensions 0.9.3 → 0.10.0

package/dist/prosekit-extensions-autocomplete.d.ts

@@ -40,6 +40,19 @@ interface MatchHandlerOptions {
 */
 type MatchHandler = (options: MatchHandlerOptions) => void;
 /**
+* Options for the {@link CanMatchPredicate} callback.
+*/
+interface CanMatchOptions {
+  /**
+  * The editor state.
+  */
+  state: EditorState;
+}
+/**
+* A predicate to determine if the rule can be applied in the current editor state.
+*/
+type CanMatchPredicate = (options: CanMatchOptions) => boolean;
+/**
 * Options for creating an {@link AutocompleteRule}
 */
 interface AutocompleteRuleOptions {
@@ -65,9 +78,7 @@ interface AutocompleteRuleOptions {
   * state. If not provided, it defaults to only allowing matches in empty
   * selections that are not inside a code block or code mark.
   */
-  canMatch?: (options: {
-    state: EditorState;
-  }) => boolean;
+  canMatch?: CanMatchPredicate;
 }
 /**
 * An autocomplete rule that can be used to create an autocomplete extension.
@@ -91,4 +102,4 @@ declare class AutocompleteRule {
 //#region src/autocomplete/autocomplete.d.ts
 declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 //#endregion
-export { AutocompleteRule, AutocompleteRuleOptions, MatchHandler, MatchHandlerOptions, defineAutocomplete };
+export { AutocompleteRule, AutocompleteRuleOptions, CanMatchOptions, CanMatchPredicate, MatchHandler, MatchHandlerOptions, defineAutocomplete };

package/dist/prosekit-extensions-commit.js

@@ -1,4 +1,4 @@
-import { collectChildren, defineDefaultState, definePlugin, jsonFromNode, union } from "@prosekit/core";
+import { defineDefaultState, definePlugin, jsonFromNode, union } from "@prosekit/core";
 import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";
 import { DOMSerializer, Fragment, Slice } from "@prosekit/pm/model";
@@ -33,13 +33,13 @@ function decorateDeletionSlice(slice) {
 		];
 	}
 	if (openStart > 0 && content.childCount >= 2) {
-		const nodes = collectChildren(content);
+		const nodes = content.content;
 		const head = Fragment.from(nodes.slice(0, 1));
 		const body = Fragment.from(nodes.slice(1));
 		return [...decorateDeletionSlice(new Slice(head, openStart, openStart)), ...decorateDeletionSlice(new Slice(body, 0, openEnd))];
 	}
 	if (openEnd > 0 && content.childCount >= 2) {
-		const nodes = collectChildren(content);
+		const nodes = content.content;
 		const body = Fragment.from(nodes.slice(0, -1));
 		const tail = Fragment.from(nodes.slice(-1));
 		return [...decorateDeletionSlice(new Slice(body, openStart, 0)), ...decorateDeletionSlice(new Slice(tail, openEnd, openEnd))];

package/dist/prosekit-extensions-link.js

@@ -9,10 +9,10 @@ const TLD_RE_PATTERN = "a(?:a(?:a|rp)|b(?:arth|b(?:ott|vie)?|c|le|ogado|udhabi)|
 const PUNCTUATION_CHAR_PATTERN = "\\.\\,\\;\\!\\?";
 const STOP_CHAR_PATTERN = "[" + PUNCTUATION_CHAR_PATTERN + "]";
 const END_CHAR_PATTERN = "[^\\s" + PUNCTUATION_CHAR_PATTERN + "]";
-const LINK_RE_BASE_PATTERN = "((?:(?:(?:https?:)?\\/\\/)?(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:" + TLD_RE_PATTERN + "))(?::\\d{2,5})?(?:/(?:\\S*" + END_CHAR_PATTERN + ")?)?(?:\\?(?:\\S*" + END_CHAR_PATTERN + "))?(?:\\#(?:\\S*" + END_CHAR_PATTERN + ")?)?)";
+const LINK_RE_BASE_PATTERN = "((?:(?:(?:https?:)?\\/\\/)?(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:" + TLD_RE_PATTERN + "))(?::\\d{2,5})?(?:/(?:\\S*[^\\s\\.\\,\\;\\!\\?])?)?(?:\\?(?:\\S*[^\\s\\.\\,\\;\\!\\?]))?(?:\\#(?:\\S*[^\\s\\.\\,\\;\\!\\?])?)?)";
 const LINK_ENTER_PATTERN = LINK_RE_BASE_PATTERN + STOP_CHAR_PATTERN + "?$";
 const LINK_INPUT_PATTERN = LINK_RE_BASE_PATTERN + STOP_CHAR_PATTERN + "?\\s$";
-const LINK_MARK_PATTERN = LINK_RE_BASE_PATTERN + "(?=" + STOP_CHAR_PATTERN + "|\\s|$)";
+const LINK_MARK_PATTERN = LINK_RE_BASE_PATTERN + "(?=[\\.\\,\\;\\!\\?]|\\s|$)";
 const LINK_ENTER_RE = new RegExp(LINK_ENTER_PATTERN, "gi");
 const LINK_INPUT_RE = new RegExp(LINK_INPUT_PATTERN, "gi");
 const LINK_MARK_RE = new RegExp(LINK_MARK_PATTERN, "gi");

package/dist/prosekit-extensions-placeholder.js

@@ -1,4 +1,4 @@
-import { findTable } from "./table-DnVliJ6E.js";
+import { findTable } from "./table-dVQqzLlz.js";
 import { definePlugin, isInCodeBlock, maybeRun } from "@prosekit/core";
 import { Plugin, PluginKey } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";

package/dist/prosekit-extensions-table.d.ts

@@ -3,6 +3,72 @@ import { Command, Selection } from "@prosekit/pm/state";
 import { Attrs, ProseMirrorNode, ResolvedPos } from "@prosekit/pm/model";
 import { CellSelection } from "prosemirror-tables";
 
+//#region src/table/table-commands/move-table-column.d.ts
+/**
+* Options for {@link moveTableColumn}
+*
+* @public
+*/
+interface MoveTableColumnOptions {
+  /**
+  * The source column index to move from.
+  */
+  from: number;
+  /**
+  * The destination column index to move to.
+  */
+  to: number;
+  /**
+  * Whether to select the moved column after the operation.
+  *
+  * @default true
+  */
+  select?: boolean;
+  /**
+  * Optional position to resolve table from. If not provided, uses the current selection.
+  */
+  pos?: number;
+}
+/**
+* Move a table column from index `origin` to index `target`.
+*
+* @public
+*/
+declare function moveTableColumn(options: MoveTableColumnOptions): Command;
+//#endregion
+//#region src/table/table-commands/move-table-row.d.ts
+/**
+* Options for {@link moveTableRow}
+*
+* @public
+*/
+interface MoveTableRowOptions {
+  /**
+  * The source row index to move from.
+  */
+  from: number;
+  /**
+  * The destination row index to move to.
+  */
+  to: number;
+  /**
+  * Whether to select the moved row after the operation.
+  *
+  * @default true
+  */
+  select?: boolean;
+  /**
+  * Optional position to resolve table from. If not provided, uses the current selection.
+  */
+  pos?: number;
+}
+/**
+* Move a table row from index `origin` to index `target`.
+*
+* @public
+*/
+declare function moveTableRow(options: MoveTableRowOptions): Command;
+//#endregion
 //#region src/table/table-commands.d.ts
 /**
 * @public
@@ -126,6 +192,8 @@ type TableCommandsExtension = Extension<{
     deleteCellSelection: [];
     mergeTableCells: [];
     splitTableCell: [];
+    moveTableRow: [options: MoveTableRowOptions];
+    moveTableColumn: [options: MoveTableColumnOptions];
   };
 }>;
 /**
@@ -140,9 +208,9 @@ declare function defineTableCommands(): TableCommandsExtension;
 * @public
 */
 interface CellAttrs {
-  colspan: number;
-  rowspan: number;
-  colwidth: number[] | null;
+  colspan?: number;
+  rowspan?: number;
+  colwidth?: number[] | null;
 }
 /**
 * @internal
@@ -206,7 +274,7 @@ declare function defineTable(): TableExtension;
 */
 declare function defineTablePlugins(): PlainExtension;
 //#endregion
-//#region src/table/table-utils.d.ts
+//#region src/table/table-utils/query.d.ts
 /**
 * Checks if the given object is a `CellSelection` instance.
 *
@@ -228,4 +296,4 @@ declare function findTable($pos: ResolvedPos): FindParentNodeResult | undefined;
 */
 
 //#endregion
-export { InsertTableOptions, SelectTableCellOptions, SelectTableColumnOptions, SelectTableOptions, SelectTableRowOptions, TableCellSpecExtension, TableCommandsExtension, TableExtension, TableHeaderCellSpecExtension, TableRowSpecExtension, TableSpecExtension, defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, selectTable, selectTableCell, selectTableColumn, selectTableRow };
+export { InsertTableOptions, MoveTableColumnOptions, MoveTableRowOptions, SelectTableCellOptions, SelectTableColumnOptions, SelectTableOptions, SelectTableRowOptions, TableCellSpecExtension, TableCommandsExtension, TableExtension, TableHeaderCellSpecExtension, TableRowSpecExtension, TableSpecExtension, defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };

package/dist/prosekit-extensions-table.js

@@ -1,3 +1,3 @@
-import { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, selectTable, selectTableCell, selectTableColumn, selectTableRow } from "./table-DnVliJ6E.js";
+import { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow } from "./table-dVQqzLlz.js";
 
-export { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, selectTable, selectTableCell, selectTableColumn, selectTableRow };
+export { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };

package/dist/prosekit-extensions-yjs.d.ts

@@ -1,7 +1,6 @@
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 import { yCursorPlugin, ySyncPlugin, yUndoPlugin } from "y-prosemirror";
 import { Awareness } from "y-protocols/awareness";
-import * as Y$1 from "yjs";
 import * as Y from "yjs";
 
 //#region src/yjs/yjs-commands.d.ts
@@ -32,7 +31,7 @@ declare function defineYjsCursorPlugin(options: YjsCursorOptions): PlainExtensio
 */
 type YjsSyncPluginOptions = NonNullable<Parameters<typeof ySyncPlugin>[1]>;
 interface YjsSyncOptions extends YjsSyncPluginOptions {
-  fragment: Y$1.XmlFragment;
+  fragment: Y.XmlFragment;
 }
 declare function defineYjsSyncPlugin(options: YjsSyncOptions): PlainExtension;
 //#endregion

package/dist/shiki-highlighter-chunk.js

@@ -2,17 +2,21 @@ import { createHighlighter } from "shiki/bundle/full";
 import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
 
 //#region src/code-block/shiki-highlighter-chunk.ts
+let highlighterPromise;
 let highlighter;
 const loadedLangs = /* @__PURE__ */ new Set();
 const loadedThemes = /* @__PURE__ */ new Set();
-async function createAndCacheHighlighter({ ...options }) {
-	if (!highlighter) {
+function ensureHighlighter({ ...options }) {
+	if (!highlighterPromise) {
 		if (!options.engine) {
 			const engine = createJavaScriptRegexEngine({ forgiving: true });
 			options.engine = engine;
 		}
-		highlighter = await createHighlighter(options);
+		highlighterPromise = createHighlighter(options).then((createdHighlighter) => {
+			highlighter = createdHighlighter;
+		});
 	}
+	return highlighterPromise;
 }
 async function loadLanguages(langs) {
 	for (const lang of langs) {
@@ -29,7 +33,7 @@ async function loadThemes(themes) {
 	}
 }
 function createOrGetHighlighter(options) {
-	if (!highlighter) return { promise: createAndCacheHighlighter(options) };
+	if (!highlighter) return { promise: ensureHighlighter(options) };
 	const langs = options.langs.filter((lang) => !loadedLangs.has(lang));
 	if (langs.length > 0) return { promise: loadLanguages(langs) };
 	const themes = options.themes.filter((theme) => !loadedThemes.has(theme));

package/dist/table/style.css

@@ -16,6 +16,11 @@
   border-width: 1px;
   vertical-align: top;
 }
+
+prosekit-table-handle-drop-indicator {
+  background-color: HighlightText;
+}
+
 .ProseMirror .column-resize-handle {
   z-index: 20;
   position: absolute;

package/dist/table-dVQqzLlz.js

@@ -0,0 +1,734 @@
+import { defaultBlockAt, defineCommands, defineNodeSpec, definePlugin, findParentNode, getNodeType, insertNode, union } from "@prosekit/core";
+import { TextSelection } from "@prosekit/pm/state";
+import { CellSelection, TableMap, addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, cellAround, cellNear, columnResizing, deleteCellSelection, deleteColumn, deleteRow, deleteTable, inSameTable, mergeCells, splitCell, tableEditing, tableNodes } from "prosemirror-tables";
+
+//#region src/table/table-utils/convert-array-of-rows-to-table-node.ts
+/**
+* Convert an array of rows to a table node.
+*
+* @internal
+*/
+function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
+	const rowsPM = [];
+	const map = TableMap.get(tableNode);
+	for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+		const row = tableNode.child(rowIndex);
+		const rowCells = [];
+		for (let colIndex = 0; colIndex < map.width; colIndex++) {
+			if (!arrayOfNodes[rowIndex][colIndex]) continue;
+			const cellPos = map.map[rowIndex * map.width + colIndex];
+			const cell = arrayOfNodes[rowIndex][colIndex];
+			const oldCell = tableNode.nodeAt(cellPos);
+			const newCell = oldCell.type.createChecked(Object.assign({}, cell.attrs), cell.content, cell.marks);
+			rowCells.push(newCell);
+		}
+		rowsPM.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+	}
+	const newTable = tableNode.type.createChecked(tableNode.attrs, rowsPM, tableNode.marks);
+	return newTable;
+}
+
+//#endregion
+//#region src/table/table-utils/convert-table-node-to-array-of-rows.ts
+/**
+* This function will transform the table node into a matrix of rows and columns
+* respecting merged cells, for example this table:
+*
+* ```
+* ┌──────┬──────┬─────────────┐
+* │  A1  │  B1  │     C1      │
+* ├──────┼──────┴──────┬──────┤
+* │  A2  │     B2      │      │
+* ├──────┼─────────────┤  D1  │
+* │  A3  │  B3  │  C3  │      │
+* └──────┴──────┴──────┴──────┘
+* ```
+*
+* will be converted to the below:
+*
+* ```javascript
+* [
+*   [A1, B1, C1, null],
+*   [A2, B2, null, D1],
+*   [A3, B3, C3, null],
+* ]
+* ```
+* @internal
+*/
+function convertTableNodeToArrayOfRows(tableNode) {
+	const map = TableMap.get(tableNode);
+	const rows = [];
+	const rowCount = map.height;
+	const colCount = map.width;
+	for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+		const row = [];
+		for (let colIndex = 0; colIndex < colCount; colIndex++) {
+			let cellIndex = rowIndex * colCount + colIndex;
+			let cellPos = map.map[cellIndex];
+			if (rowIndex > 0) {
+				const topCellIndex = cellIndex - colCount;
+				const topCellPos = map.map[topCellIndex];
+				if (cellPos === topCellPos) {
+					row.push(null);
+					continue;
+				}
+			}
+			if (colIndex > 0) {
+				const leftCellIndex = cellIndex - 1;
+				const leftCellPos = map.map[leftCellIndex];
+				if (cellPos === leftCellPos) {
+					row.push(null);
+					continue;
+				}
+			}
+			row.push(tableNode.nodeAt(cellPos));
+		}
+		rows.push(row);
+	}
+	return rows;
+}
+
+//#endregion
+//#region src/table/table-utils/query.ts
+/**
+* Checks if the given object is a `CellSelection` instance.
+*
+* @public
+*/
+function isCellSelection(value) {
+	return value instanceof CellSelection;
+}
+/**
+* Find the closest table node.
+*
+* @internal
+*/
+function findTable($pos) {
+	return findParentNode((node) => node.type.spec.tableRole === "table", $pos);
+}
+/**
+* Try to find the anchor and head cell in the same table by using the given
+* anchor and head as hit points, or fallback to the selection's anchor and
+* head.
+*
+* @internal
+*/
+function findCellRange(selection, anchorHit, headHit) {
+	if (anchorHit == null && headHit == null && isCellSelection(selection)) return [selection.$anchorCell, selection.$headCell];
+	const anchor = anchorHit ?? headHit ?? selection.anchor;
+	const head = headHit ?? anchorHit ?? selection.head;
+	const doc = selection.$head.doc;
+	const $anchorCell = findCellPos(doc, anchor);
+	const $headCell = findCellPos(doc, head);
+	if ($anchorCell && $headCell && inSameTable($anchorCell, $headCell)) return [$anchorCell, $headCell];
+}
+/**
+* Try to find a resolved pos of a cell by using the given pos as a hit point.
+*
+* @internal
+*/
+function findCellPos(doc, pos) {
+	const $pos = doc.resolve(pos);
+	return cellAround($pos) || cellNear($pos);
+}
+
+//#endregion
+//#region src/table/table-utils/get-cells-in-column.ts
+/**
+* Returns an array of cells in a column(s), where `columnIndex` could be a column index or an array of column indexes.
+*
+* @internal
+*/
+function getCellsInColumn(columnIndexes, selection) {
+	const table = findTable(selection.$from);
+	if (!table) return;
+	const map = TableMap.get(table.node);
+	const indexes = Array.isArray(columnIndexes) ? columnIndexes : [columnIndexes];
+	return indexes.filter((index) => index >= 0 && index <= map.width - 1).flatMap((index) => {
+		const cells = map.cellsInRect({
+			left: index,
+			right: index + 1,
+			top: 0,
+			bottom: map.height
+		});
+		return cells.map((nodePos) => {
+			const node = table.node.nodeAt(nodePos);
+			const pos = nodePos + table.start;
+			return {
+				pos,
+				start: pos + 1,
+				node,
+				depth: table.depth + 2
+			};
+		});
+	});
+}
+
+//#endregion
+//#region src/table/table-utils/get-cells-in-row.ts
+/**
+* Returns an array of cells in a row(s), where `rowIndex` could be a row index or an array of row indexes.
+*
+* @internal
+*/
+function getCellsInRow(rowIndex, selection) {
+	const table = findTable(selection.$from);
+	if (!table) return;
+	const map = TableMap.get(table.node);
+	const indexes = Array.isArray(rowIndex) ? rowIndex : [rowIndex];
+	return indexes.filter((index) => index >= 0 && index <= map.height - 1).flatMap((index) => {
+		const cells = map.cellsInRect({
+			left: 0,
+			right: map.width,
+			top: index,
+			bottom: index + 1
+		});
+		return cells.map((nodePos) => {
+			const node = table.node.nodeAt(nodePos);
+			const pos = nodePos + table.start;
+			return {
+				pos,
+				start: pos + 1,
+				node,
+				depth: table.depth + 2
+			};
+		});
+	});
+}
+
+//#endregion
+//#region src/table/table-utils/get-selection-range-in-column.ts
+/**
+* Returns a range of rectangular selection spanning all merged cells around a
+* column at index `columnIndex`.
+*
+* Original implementation from Atlassian (Apache License 2.0)
+*
+* https://bitbucket.org/atlassian/atlassian-frontend-mirror/src/5f91cb871e8248bc3bae5ddc30bb9fd9200fadbb/editor/editor-tables/src/utils/get-selection-range-in-column.ts#editor/editor-tables/src/utils/get-selection-range-in-column.ts
+*
+* @internal
+*/
+function getSelectionRangeInColumn(tr, startColIndex, endColIndex = startColIndex) {
+	let startIndex = startColIndex;
+	let endIndex = endColIndex;
+	for (let i = startColIndex; i >= 0; i--) {
+		const cells = getCellsInColumn(i, tr.selection);
+		if (cells) cells.forEach((cell) => {
+			const maybeEndIndex = cell.node.attrs.colspan + i - 1;
+			if (maybeEndIndex >= startIndex) startIndex = i;
+			if (maybeEndIndex > endIndex) endIndex = maybeEndIndex;
+		});
+	}
+	for (let i = startColIndex; i <= endIndex; i++) {
+		const cells = getCellsInColumn(i, tr.selection);
+		if (cells) cells.forEach((cell) => {
+			const maybeEndIndex = cell.node.attrs.colspan + i - 1;
+			if (cell.node.attrs.colspan > 1 && maybeEndIndex > endIndex) endIndex = maybeEndIndex;
+		});
+	}
+	const indexes = [];
+	for (let i = startIndex; i <= endIndex; i++) {
+		const maybeCells = getCellsInColumn(i, tr.selection);
+		if (maybeCells && maybeCells.length > 0) indexes.push(i);
+	}
+	startIndex = indexes[0];
+	endIndex = indexes[indexes.length - 1];
+	const firstSelectedColumnCells = getCellsInColumn(startIndex, tr.selection);
+	const firstRowCells = getCellsInRow(0, tr.selection);
+	if (!firstSelectedColumnCells || !firstRowCells) return;
+	const $anchor = tr.doc.resolve(firstSelectedColumnCells[firstSelectedColumnCells.length - 1].pos);
+	let headCell;
+	for (let i = endIndex; i >= startIndex; i--) {
+		const columnCells = getCellsInColumn(i, tr.selection);
+		if (columnCells && columnCells.length > 0) {
+			for (let j = firstRowCells.length - 1; j >= 0; j--) if (firstRowCells[j].pos === columnCells[0].pos) {
+				headCell = columnCells[0];
+				break;
+			}
+			if (headCell) break;
+		}
+	}
+	if (!headCell) return;
+	const $head = tr.doc.resolve(headCell.pos);
+	return {
+		$anchor,
+		$head,
+		indexes
+	};
+}
+
+//#endregion
+//#region src/table/table-utils/move-row-in-array-of-rows.ts
+/**
+* Move a row in an array of rows.
+*
+* @internal
+*/
+function moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, directionOverride) {
+	const direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
+	const rowsExtracted = rows.splice(indexesOrigin[0], indexesOrigin.length);
+	const positionOffset = rowsExtracted.length % 2 === 0 ? 1 : 0;
+	let target;
+	if (directionOverride === -1 && direction === 1) target = indexesTarget[0] - 1;
+	else if (directionOverride === 1 && direction === -1) target = indexesTarget[indexesTarget.length - 1] - positionOffset + 1;
+	else target = direction === -1 ? indexesTarget[0] : indexesTarget[indexesTarget.length - 1] - positionOffset;
+	rows.splice(target, 0, ...rowsExtracted);
+	return rows;
+}
+
+//#endregion
+//#region src/table/table-utils/transpose.ts
+/**
+* Transposes a 2D array by flipping columns to rows.
+*
+* Transposition is a familiar algebra concept where the matrix is flipped
+* along its diagonal. For more details, see:
+* https://en.wikipedia.org/wiki/Transpose
+*
+* @example
+* ```javascript
+* const arr = [
+*   ['a1', 'a2', 'a3'],
+*   ['b1', 'b2', 'b3'],
+*   ['c1', 'c2', 'c3'],
+*   ['d1', 'd2', 'd3'],
+* ];
+*
+* const result = transpose(arr);
+* result === [
+*   ['a1', 'b1', 'c1', 'd1'],
+*   ['a2', 'b2', 'c2', 'd2'],
+*   ['a3', 'b3', 'c3', 'd3'],
+* ]
+* ```
+*/
+function transpose(array) {
+	return array[0].map((_, i) => {
+		return array.map((column) => column[i]);
+	});
+}
+
+//#endregion
+//#region src/table/table-utils/move-column.ts
+/**
+* Move a column from index `origin` to index `target`.
+*
+* @internal
+*/
+function moveColumn(moveColParams) {
+	const { tr, originIndex, targetIndex, select, pos } = moveColParams;
+	const $pos = tr.doc.resolve(pos);
+	const table = findTable($pos);
+	if (!table) return false;
+	const indexesOriginColumn = getSelectionRangeInColumn(tr, originIndex)?.indexes;
+	const indexesTargetColumn = getSelectionRangeInColumn(tr, targetIndex)?.indexes;
+	if (!indexesOriginColumn || !indexesTargetColumn) return false;
+	if (indexesOriginColumn.includes(targetIndex)) return false;
+	const newTable = moveTableColumn$1(table.node, indexesOriginColumn, indexesTargetColumn, 0);
+	tr.replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
+	if (!select) return true;
+	const map = TableMap.get(newTable);
+	const start = table.start;
+	const index = targetIndex;
+	const lastCell = map.positionAt(map.height - 1, index, newTable);
+	const $lastCell = tr.doc.resolve(start + lastCell);
+	const firstCell = map.positionAt(0, index, newTable);
+	const $firstCell = tr.doc.resolve(start + firstCell);
+	tr.setSelection(CellSelection.colSelection($lastCell, $firstCell));
+	return true;
+}
+function moveTableColumn$1(table, indexesOrigin, indexesTarget, direction) {
+	let rows = transpose(convertTableNodeToArrayOfRows(table));
+	rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
+	rows = transpose(rows);
+	return convertArrayOfRowsToTableNode(table, rows);
+}
+
+//#endregion
+//#region src/table/table-utils/get-selection-range-in-row.ts
+/**
+* Returns a range of rectangular selection spanning all merged cells around a
+* row at index `rowIndex`.
+*
+* Original implementation from Atlassian (Apache License 2.0)
+*
+* https://bitbucket.org/atlassian/atlassian-frontend-mirror/src/5f91cb871e8248bc3bae5ddc30bb9fd9200fadbb/editor/editor-tables/src/utils/get-selection-range-in-row.ts#editor/editor-tables/src/utils/get-selection-range-in-row.ts
+*
+* @internal
+*/
+function getSelectionRangeInRow(tr, startRowIndex, endRowIndex = startRowIndex) {
+	let startIndex = startRowIndex;
+	let endIndex = endRowIndex;
+	for (let i = startRowIndex; i >= 0; i--) {
+		const cells = getCellsInRow(i, tr.selection);
+		if (cells) cells.forEach((cell) => {
+			const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
+			if (maybeEndIndex >= startIndex) startIndex = i;
+			if (maybeEndIndex > endIndex) endIndex = maybeEndIndex;
+		});
+	}
+	for (let i = startRowIndex; i <= endIndex; i++) {
+		const cells = getCellsInRow(i, tr.selection);
+		if (cells) cells.forEach((cell) => {
+			const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
+			if (cell.node.attrs.rowspan > 1 && maybeEndIndex > endIndex) endIndex = maybeEndIndex;
+		});
+	}
+	const indexes = [];
+	for (let i = startIndex; i <= endIndex; i++) {
+		const maybeCells = getCellsInRow(i, tr.selection);
+		if (maybeCells && maybeCells.length > 0) indexes.push(i);
+	}
+	startIndex = indexes[0];
+	endIndex = indexes[indexes.length - 1];
+	const firstSelectedRowCells = getCellsInRow(startIndex, tr.selection);
+	const firstColumnCells = getCellsInColumn(0, tr.selection);
+	if (!firstSelectedRowCells || !firstColumnCells) return;
+	const $anchor = tr.doc.resolve(firstSelectedRowCells[firstSelectedRowCells.length - 1].pos);
+	let headCell;
+	for (let i = endIndex; i >= startIndex; i--) {
+		const rowCells = getCellsInRow(i, tr.selection);
+		if (rowCells && rowCells.length > 0) {
+			for (let j = firstColumnCells.length - 1; j >= 0; j--) if (firstColumnCells[j].pos === rowCells[0].pos) {
+				headCell = rowCells[0];
+				break;
+			}
+			if (headCell) break;
+		}
+	}
+	if (!headCell) return;
+	const $head = tr.doc.resolve(headCell.pos);
+	return {
+		$anchor,
+		$head,
+		indexes
+	};
+}
+
+//#endregion
+//#region src/table/table-utils/move-row.ts
+/**
+* Move a row from index `origin` to index `target`.
+*
+* @internal
+*/
+function moveRow(moveRowParams) {
+	const { tr, originIndex, targetIndex, select, pos } = moveRowParams;
+	const $pos = tr.doc.resolve(pos);
+	const table = findTable($pos);
+	if (!table) return false;
+	const indexesOriginRow = getSelectionRangeInRow(tr, originIndex)?.indexes;
+	const indexesTargetRow = getSelectionRangeInRow(tr, targetIndex)?.indexes;
+	if (!indexesOriginRow || !indexesTargetRow) return false;
+	if (indexesOriginRow.includes(targetIndex)) return false;
+	const newTable = moveTableRow$1(table.node, indexesOriginRow, indexesTargetRow, 0);
+	tr.replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
+	if (!select) return true;
+	const map = TableMap.get(newTable);
+	const start = table.start;
+	const index = targetIndex;
+	const lastCell = map.positionAt(index, map.width - 1, newTable);
+	const $lastCell = tr.doc.resolve(start + lastCell);
+	const firstCell = map.positionAt(index, 0, newTable);
+	const $firstCell = tr.doc.resolve(start + firstCell);
+	tr.setSelection(CellSelection.rowSelection($lastCell, $firstCell));
+	return true;
+}
+function moveTableRow$1(table, indexesOrigin, indexesTarget, direction) {
+	let rows = convertTableNodeToArrayOfRows(table);
+	rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
+	return convertArrayOfRowsToTableNode(table, rows);
+}
+
+//#endregion
+//#region src/table/table-commands/move-table-column.ts
+/**
+* Move a table column from index `origin` to index `target`.
+*
+* @public
+*/
+function moveTableColumn(options) {
+	return (state, dispatch) => {
+		const { from: originIndex, to: targetIndex, select = true, pos = state.selection.from } = options;
+		const tr = state.tr;
+		if (moveColumn({
+			tr,
+			originIndex,
+			targetIndex,
+			select,
+			pos
+		})) {
+			dispatch?.(tr);
+			return true;
+		}
+		return false;
+	};
+}
+
+//#endregion
+//#region src/table/table-commands/move-table-row.ts
+/**
+* Move a table row from index `origin` to index `target`.
+*
+* @public
+*/
+function moveTableRow(options) {
+	return (state, dispatch) => {
+		const { from: originIndex, to: targetIndex, select = true, pos = state.selection.from } = options;
+		const tr = state.tr;
+		if (moveRow({
+			tr,
+			originIndex,
+			targetIndex,
+			select,
+			pos
+		})) {
+			dispatch?.(tr);
+			return true;
+		}
+		return false;
+	};
+}
+
+//#endregion
+//#region src/table/table-commands.ts
+function createEmptyTable(schema, row, col, header) {
+	const tableType = getNodeType(schema, "table");
+	const tableRowType = getNodeType(schema, "tableRow");
+	const tableCellType = getNodeType(schema, "tableCell");
+	const tableHeaderCellType = getNodeType(schema, "tableHeaderCell");
+	if (header) {
+		const headerCell = tableHeaderCellType.createAndFill();
+		const headerCells = repeat(headerCell, col);
+		const headerRow = tableRowType.createAndFill(null, headerCells);
+		const bodyCell = tableCellType.createAndFill();
+		const bodyCells = repeat(bodyCell, col);
+		const bodyRow = tableRowType.createAndFill(null, bodyCells);
+		const bodyRows = repeat(bodyRow, row - 1);
+		return tableType.createAndFill(null, [headerRow, ...bodyRows]);
+	} else {
+		const bodyCell = tableCellType.createAndFill();
+		const bodyCells = repeat(bodyCell, col);
+		const bodyRow = tableRowType.createAndFill(null, bodyCells);
+		const bodyRows = repeat(bodyRow, row);
+		return tableType.createAndFill(null, bodyRows);
+	}
+}
+function repeat(node, length) {
+	return Array(length).fill(node);
+}
+/**
+* Insert a table node with the given number of rows and columns, and optionally
+* a header row.
+*
+* @param options
+*
+* @public
+*/
+function insertTable(options) {
+	return (state, dispatch, view) => {
+		const { row, col, header = false } = options;
+		const table = createEmptyTable(state.schema, row, col, header);
+		return insertNode({ node: table })(state, dispatch, view);
+	};
+}
+/**
+* When the selection is in a table node, create a default block after the table
+* table, and move the cursor there.
+*
+* @public
+*/
+const exitTable = (state, dispatch) => {
+	const { $head, $anchor } = state.selection;
+	if (!$head.sameParent($anchor)) return false;
+	let tableStart = -1;
+	let tableDepth = -1;
+	for (let depth = $head.depth; depth >= 0; depth--) {
+		const node$1 = $head.node(depth);
+		if (node$1.type.spec.tableRole === "table") {
+			tableStart = $head.before(depth);
+			tableDepth = depth;
+		}
+	}
+	if (tableStart < 0 || tableDepth <= 0) return false;
+	const above = $head.node(tableDepth - 1);
+	const after = $head.indexAfter(tableDepth - 1);
+	const type = defaultBlockAt(above.contentMatchAt(after));
+	const node = type?.createAndFill();
+	if (!type || !node || !above.canReplaceWith(after, after, type)) return false;
+	if (dispatch) {
+		const pos = $head.after(tableDepth);
+		const tr = state.tr.replaceWith(pos, pos, node);
+		tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
+		dispatch(tr.scrollIntoView());
+	}
+	return true;
+};
+/**
+* @public
+*/
+function selectTableColumn(options) {
+	return (state, dispatch) => {
+		const range = findCellRange(state.selection, options?.anchor, options?.head);
+		if (!range) return false;
+		if (dispatch) {
+			const [$anchorCell, $headCell] = range;
+			const selection = CellSelection.colSelection($anchorCell, $headCell);
+			dispatch(state.tr.setSelection(selection));
+		}
+		return true;
+	};
+}
+/**
+* @public
+*/
+function selectTableRow(options) {
+	return (state, dispatch) => {
+		const range = findCellRange(state.selection, options?.anchor, options?.head);
+		if (!range) return false;
+		if (dispatch) {
+			const [$anchorCell, $headCell] = range;
+			const selection = CellSelection.rowSelection($anchorCell, $headCell);
+			dispatch(state.tr.setSelection(selection));
+		}
+		return true;
+	};
+}
+/**
+* @public
+*/
+function selectTableCell(options) {
+	return (state, dispatch) => {
+		const $cellPos = findCellPos(state.doc, options?.pos ?? state.selection.anchor);
+		if (!$cellPos) return false;
+		if (dispatch) {
+			const selection = new CellSelection($cellPos);
+			dispatch(state.tr.setSelection(selection));
+		}
+		return true;
+	};
+}
+/**
+* @public
+*/
+function selectTable(options) {
+	return (state, dispatch) => {
+		const $pos = options?.pos ? state.doc.resolve(options.pos) : state.selection.$anchor;
+		const table = findTable($pos);
+		if (!table) return false;
+		const map = TableMap.get(table.node);
+		if (map.map.length === 0) return false;
+		if (dispatch) {
+			let tr = state.tr;
+			const firstCellPosInTable = map.map[0];
+			const lastCellPosInTable = map.map[map.map.length - 1];
+			const firstCellPos = table.pos + firstCellPosInTable + 1;
+			const lastCellPos = table.pos + lastCellPosInTable + 1;
+			const $firstCellPos = tr.doc.resolve(firstCellPos);
+			const $lastCellPos = tr.doc.resolve(lastCellPos);
+			const selection = new CellSelection($firstCellPos, $lastCellPos);
+			tr = tr.setSelection(selection);
+			dispatch?.(tr);
+		}
+		return true;
+	};
+}
+/**
+* Adds commands for working with `table` nodes.
+*
+* @public
+*/
+function defineTableCommands() {
+	return defineCommands({
+		insertTable,
+		exitTable: () => exitTable,
+		selectTable,
+		selectTableCell,
+		selectTableColumn,
+		selectTableRow,
+		addTableColumnBefore: () => addColumnBefore,
+		addTableColumnAfter: () => addColumnAfter,
+		addTableRowAbove: () => addRowBefore,
+		addTableRowBelow: () => addRowAfter,
+		deleteTable: () => deleteTable,
+		deleteTableColumn: () => deleteColumn,
+		deleteTableRow: () => deleteRow,
+		deleteCellSelection: () => deleteCellSelection,
+		mergeTableCells: () => mergeCells,
+		splitTableCell: () => splitCell,
+		moveTableRow,
+		moveTableColumn
+	});
+}
+
+//#endregion
+//#region src/table/table-plugins.ts
+/**
+* @public
+*/
+function defineTablePlugins() {
+	return definePlugin([tableEditing(), columnResizing()]);
+}
+
+//#endregion
+//#region src/table/table-spec.ts
+const cellContent = "block+";
+const cellAttrs = {
+	colspan: { default: 1 },
+	rowspan: { default: 1 },
+	colwidth: { default: null }
+};
+const specs = tableNodes({
+	tableGroup: "block",
+	cellContent,
+	cellAttributes: {}
+});
+/**
+* @internal
+*/
+function defineTableSpec() {
+	return defineNodeSpec({
+		...specs["table"],
+		content: "tableRow+",
+		name: "table"
+	});
+}
+/**
+* @internal
+*/
+function defineTableRowSpec() {
+	return defineNodeSpec({
+		...specs["table_row"],
+		content: "(tableCell | tableHeaderCell)*",
+		name: "tableRow"
+	});
+}
+/**
+* @internal
+*/
+function defineTableCellSpec() {
+	return defineNodeSpec({
+		...specs["table_cell"],
+		name: "tableCell",
+		attrs: cellAttrs
+	});
+}
+function defineTableHeaderCellSpec() {
+	return defineNodeSpec({
+		...specs["table_header"],
+		name: "tableHeaderCell",
+		attrs: cellAttrs
+	});
+}
+
+//#endregion
+//#region src/table/table.ts
+/**
+* @public
+*/
+function defineTable() {
+	return union(defineTableSpec(), defineTableRowSpec(), defineTableCellSpec(), defineTableHeaderCellSpec(), defineTablePlugins(), defineTableCommands());
+}
+
+//#endregion
+export { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.9.3",
+  "version": "0.10.0",
   "private": false,
   "description": "A collection of common extensions for ProseKit",
   "author": {
@@ -206,9 +206,9 @@
     "prosemirror-highlight": "^0.13.0",
     "prosemirror-search": "^1.1.0",
     "prosemirror-tables": "^1.7.1",
-    "shiki": "^3.6.0",
-    "@prosekit/core": "^0.8.2",
-    "@prosekit/pm": "^0.1.11"
+    "shiki": "^3.7.0",
+    "@prosekit/pm": "^0.1.11",
+    "@prosekit/core": "^0.8.3"
   },
   "peerDependencies": {
     "loro-crdt": ">= 0.16.7",
@@ -231,20 +231,20 @@
     }
   },
   "devDependencies": {
-    "@vitest/browser": "^3.2.3",
+    "@vitest/browser": "^3.2.4",
     "just-pick": "^4.2.0",
-    "loro-crdt": "^1.5.8",
+    "loro-crdt": "^1.5.9",
     "loro-prosemirror": "^0.2.3",
-    "prettier": "^3.5.3",
-    "tsdown": "^0.12.7",
+    "prettier": "^3.6.0",
+    "tsdown": "^0.12.9",
     "type-fest": "^4.41.0",
     "typescript": "~5.8.3",
-    "vitest": "^3.2.3",
-    "y-prosemirror": "^1.3.5",
+    "vitest": "^3.2.4",
+    "y-prosemirror": "^1.3.6",
     "y-protocols": "^1.0.6",
     "yjs": "^13.6.27",
-    "@prosekit/config-tsdown": "0.0.0",
-    "@prosekit/config-vitest": "0.0.0"
+    "@prosekit/config-vitest": "0.0.0",
+    "@prosekit/config-tsdown": "0.0.0"
   },
   "publishConfig": {
     "dev": {}

package/dist/table-DnVliJ6E.js

@@ -1,287 +0,0 @@
-import { defaultBlockAt, defineCommands, defineNodeSpec, definePlugin, findParentNode, getNodeType, insertNode, union } from "@prosekit/core";
-import { TextSelection } from "@prosekit/pm/state";
-import { CellSelection, TableMap, addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, cellAround, cellNear, columnResizing, deleteCellSelection, deleteColumn, deleteRow, deleteTable, inSameTable, mergeCells, splitCell, tableEditing, tableNodes } from "prosemirror-tables";
-
-//#region src/table/table-utils.ts
-/**
-* Checks if the given object is a `CellSelection` instance.
-*
-* @public
-*/
-function isCellSelection(value) {
-	return value instanceof CellSelection;
-}
-/**
-* Find the closest table node.
-*
-* @internal
-*/
-function findTable($pos) {
-	return findParentNode((node) => node.type.spec.tableRole === "table", $pos);
-}
-/**
-* Try to find the anchor and head cell in the same table by using the given
-* anchor and head as hit points, or fallback to the selection's anchor and
-* head.
-*
-* @internal
-*/
-function findCellRange(selection, anchorHit, headHit) {
-	if (anchorHit == null && headHit == null && isCellSelection(selection)) return [selection.$anchorCell, selection.$headCell];
-	const anchor = anchorHit ?? headHit ?? selection.anchor;
-	const head = headHit ?? anchorHit ?? selection.head;
-	const doc = selection.$head.doc;
-	const $anchorCell = findCellPos(doc, anchor);
-	const $headCell = findCellPos(doc, head);
-	if ($anchorCell && $headCell && inSameTable($anchorCell, $headCell)) return [$anchorCell, $headCell];
-}
-/**
-* Try to find a resolved pos of a cell by using the given pos as a hit point.
-*
-* @internal
-*/
-function findCellPos(doc, pos) {
-	const $pos = doc.resolve(pos);
-	return cellAround($pos) || cellNear($pos);
-}
-
-//#endregion
-//#region src/table/table-commands.ts
-function createEmptyTable(schema, row, col, header) {
-	const tableType = getNodeType(schema, "table");
-	const tableRowType = getNodeType(schema, "tableRow");
-	const tableCellType = getNodeType(schema, "tableCell");
-	const tableHeaderCellType = getNodeType(schema, "tableHeaderCell");
-	if (header) {
-		const headerCell = tableHeaderCellType.createAndFill();
-		const headerCells = repeat(headerCell, col);
-		const headerRow = tableRowType.createAndFill(null, headerCells);
-		const bodyCell = tableCellType.createAndFill();
-		const bodyCells = repeat(bodyCell, col);
-		const bodyRow = tableRowType.createAndFill(null, bodyCells);
-		const bodyRows = repeat(bodyRow, row - 1);
-		return tableType.createAndFill(null, [headerRow, ...bodyRows]);
-	} else {
-		const bodyCell = tableCellType.createAndFill();
-		const bodyCells = repeat(bodyCell, col);
-		const bodyRow = tableRowType.createAndFill(null, bodyCells);
-		const bodyRows = repeat(bodyRow, row);
-		return tableType.createAndFill(null, bodyRows);
-	}
-}
-function repeat(node, length) {
-	return Array(length).fill(node);
-}
-/**
-* Insert a table node with the given number of rows and columns, and optionally
-* a header row.
-*
-* @param options
-*
-* @public
-*/
-function insertTable(options) {
-	return (state, dispatch, view) => {
-		const { row, col, header = false } = options;
-		const table = createEmptyTable(state.schema, row, col, header);
-		return insertNode({ node: table })(state, dispatch, view);
-	};
-}
-/**
-* When the selection is in a table node, create a default block after the table
-* table, and move the cursor there.
-*
-* @public
-*/
-const exitTable = (state, dispatch) => {
-	const { $head, $anchor } = state.selection;
-	if (!$head.sameParent($anchor)) return false;
-	let tableStart = -1;
-	let tableDepth = -1;
-	for (let depth = $head.depth; depth >= 0; depth--) {
-		const node$1 = $head.node(depth);
-		if (node$1.type.spec.tableRole === "table") {
-			tableStart = $head.before(depth);
-			tableDepth = depth;
-		}
-	}
-	if (tableStart < 0 || tableDepth <= 0) return false;
-	const above = $head.node(tableDepth - 1);
-	const after = $head.indexAfter(tableDepth - 1);
-	const type = defaultBlockAt(above.contentMatchAt(after));
-	const node = type?.createAndFill();
-	if (!type || !node || !above.canReplaceWith(after, after, type)) return false;
-	if (dispatch) {
-		const pos = $head.after(tableDepth);
-		const tr = state.tr.replaceWith(pos, pos, node);
-		tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
-		dispatch(tr.scrollIntoView());
-	}
-	return true;
-};
-/**
-* @public
-*/
-function selectTableColumn(options) {
-	return (state, dispatch) => {
-		const range = findCellRange(state.selection, options?.anchor, options?.head);
-		if (!range) return false;
-		if (dispatch) {
-			const [$anchorCell, $headCell] = range;
-			const selection = CellSelection.colSelection($anchorCell, $headCell);
-			dispatch(state.tr.setSelection(selection));
-		}
-		return true;
-	};
-}
-/**
-* @public
-*/
-function selectTableRow(options) {
-	return (state, dispatch) => {
-		const range = findCellRange(state.selection, options?.anchor, options?.head);
-		if (!range) return false;
-		if (dispatch) {
-			const [$anchorCell, $headCell] = range;
-			const selection = CellSelection.rowSelection($anchorCell, $headCell);
-			dispatch(state.tr.setSelection(selection));
-		}
-		return true;
-	};
-}
-/**
-* @public
-*/
-function selectTableCell(options) {
-	return (state, dispatch) => {
-		const $cellPos = findCellPos(state.doc, options?.pos ?? state.selection.anchor);
-		if (!$cellPos) return false;
-		if (dispatch) {
-			const selection = new CellSelection($cellPos);
-			dispatch(state.tr.setSelection(selection));
-		}
-		return true;
-	};
-}
-/**
-* @public
-*/
-function selectTable(options) {
-	return (state, dispatch) => {
-		const $pos = options?.pos ? state.doc.resolve(options.pos) : state.selection.$anchor;
-		const table = findTable($pos);
-		if (!table) return false;
-		const map = TableMap.get(table.node);
-		if (map.map.length === 0) return false;
-		if (dispatch) {
-			let tr = state.tr;
-			const firstCellPosInTable = map.map[0];
-			const lastCellPosInTable = map.map[map.map.length - 1];
-			const firstCellPos = table.pos + firstCellPosInTable + 1;
-			const lastCellPos = table.pos + lastCellPosInTable + 1;
-			const $firstCellPos = tr.doc.resolve(firstCellPos);
-			const $lastCellPos = tr.doc.resolve(lastCellPos);
-			const selection = new CellSelection($firstCellPos, $lastCellPos);
-			tr = tr.setSelection(selection);
-			dispatch?.(tr);
-		}
-		return true;
-	};
-}
-/**
-* Adds commands for working with `table` nodes.
-*
-* @public
-*/
-function defineTableCommands() {
-	return defineCommands({
-		insertTable,
-		exitTable: () => exitTable,
-		selectTable,
-		selectTableCell,
-		selectTableColumn,
-		selectTableRow,
-		addTableColumnBefore: () => addColumnBefore,
-		addTableColumnAfter: () => addColumnAfter,
-		addTableRowAbove: () => addRowBefore,
-		addTableRowBelow: () => addRowAfter,
-		deleteTable: () => deleteTable,
-		deleteTableColumn: () => deleteColumn,
-		deleteTableRow: () => deleteRow,
-		deleteCellSelection: () => deleteCellSelection,
-		mergeTableCells: () => mergeCells,
-		splitTableCell: () => splitCell
-	});
-}
-
-//#endregion
-//#region src/table/table-plugins.ts
-/**
-* @public
-*/
-function defineTablePlugins() {
-	return definePlugin([tableEditing(), columnResizing()]);
-}
-
-//#endregion
-//#region src/table/table-spec.ts
-const cellContent = "block+";
-const cellAttrs = {
-	colspan: { default: 1 },
-	rowspan: { default: 1 },
-	colwidth: { default: null }
-};
-const specs = tableNodes({
-	tableGroup: "block",
-	cellContent,
-	cellAttributes: {}
-});
-/**
-* @internal
-*/
-function defineTableSpec() {
-	return defineNodeSpec({
-		...specs["table"],
-		content: "tableRow+",
-		name: "table"
-	});
-}
-/**
-* @internal
-*/
-function defineTableRowSpec() {
-	return defineNodeSpec({
-		...specs["table_row"],
-		content: "(tableCell | tableHeaderCell)*",
-		name: "tableRow"
-	});
-}
-/**
-* @internal
-*/
-function defineTableCellSpec() {
-	return defineNodeSpec({
-		...specs["table_cell"],
-		name: "tableCell",
-		attrs: cellAttrs
-	});
-}
-function defineTableHeaderCellSpec() {
-	return defineNodeSpec({
-		...specs["table_header"],
-		name: "tableHeaderCell",
-		attrs: cellAttrs
-	});
-}
-
-//#endregion
-//#region src/table/table.ts
-/**
-* @public
-*/
-function defineTable() {
-	return union(defineTableSpec(), defineTableRowSpec(), defineTableCellSpec(), defineTableHeaderCellSpec(), defineTablePlugins(), defineTableCommands());
-}
-
-//#endregion
-export { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, selectTable, selectTableCell, selectTableColumn, selectTableRow };