@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/prosemirror/extensions/nodes/TableExtension.js

@@ -0,0 +1,1972 @@
+import { TABLE_CELL_TEXT_DIRECTION_VALUES, TABLE_WIDTH_TYPE_VALUES } from "../../../types/documentEnumValues.js";
+import { resolveColor } from "../../../utils/colorResolver.js";
+import { expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs } from "../../attrs/index.js";
+import { createExtension, createNodeExtension } from "../create.js";
+import { panic } from "better-result";
+import { Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
+import { Decoration, DecorationSet } from "prosemirror-view";
+import { CellSelection, TableMap, columnResizing, mergeCells, removeRow, selectedRect, splitCell, tableEditing } from "prosemirror-tables";
+//#region src/prosemirror/extensions/nodes/TableExtension.ts
+/**
+* Table Extension — 4 node specs + plugins + commands
+*
+* Uses separate NodeExtension instances for each table node type,
+* plus an Extension for plugins and commands.
+*/
+const isOneOf = (value, values) => value !== null && value !== void 0 && values.some((allowed) => allowed === value);
+/** Map CSS border-style to OOXML border style. */
+function cssBorderStyleToOoxml(cssStyle) {
+	switch (cssStyle.toLowerCase()) {
+		case "solid": return "single";
+		case "double": return "double";
+		case "dotted": return "dotted";
+		case "dashed": return "dashed";
+		case "groove": return "threeDEngrave";
+		case "ridge": return "threeDEmboss";
+		case "inset": return "inset";
+		case "outset": return "outset";
+		default: return "single";
+	}
+}
+/** Convert CSS border width to OOXML eighths-of-a-point. 1pt = 8 eighths. */
+function cssBorderWidthToEighths(cssWidth) {
+	if (!cssWidth) return 8;
+	const trimmed = cssWidth.trim().toLowerCase();
+	if (trimmed === "thin") return 4;
+	if (trimmed === "medium") return 8;
+	if (trimmed === "thick") return 16;
+	const num = Number.parseFloat(trimmed);
+	if (Number.isNaN(num)) return 8;
+	if (trimmed.endsWith("pt")) return Math.round(num * 8);
+	if (trimmed.endsWith("px")) return Math.round(num * 6);
+	return Math.round(num * 6);
+}
+/** Parse CSS color (hex, rgb()) to ColorValue { rgb: 'RRGGBB' }. */
+function parseCssColorToColorValue(cssColor) {
+	if (!cssColor || cssColor === "transparent" || cssColor === "inherit") return null;
+	const hexMatch = /#(?<hex>[0-9a-fA-F]{6})/u.exec(cssColor);
+	if (hexMatch) return { rgb: (hexMatch.groups?.["hex"] ?? "").toUpperCase() };
+	const shortHex = /#(?<hex>[0-9a-fA-F]{3})$/u.exec(cssColor);
+	if (shortHex) {
+		const hex3 = shortHex.groups?.["hex"] ?? "";
+		const r = hex3[0] ?? "";
+		const g = hex3[1] ?? "";
+		const b = hex3[2] ?? "";
+		return { rgb: (r + r + g + g + b + b).toUpperCase() };
+	}
+	const rgbMatch = /rgb\(\s*(?<r>\d+)\s*,\s*(?<g>\d+)\s*,\s*(?<b>\d+)\s*\)/u.exec(cssColor);
+	if (rgbMatch) return { rgb: [
+		rgbMatch.groups?.["r"] ?? "0",
+		rgbMatch.groups?.["g"] ?? "0",
+		rgbMatch.groups?.["b"] ?? "0"
+	].map((v) => Number.parseInt(v, 10).toString(16).padStart(2, "0")).join("").toUpperCase() };
+	return null;
+}
+/** Extract cell borders from inline CSS (Google Docs: "border-left:solid #000000 1pt"). */
+function extractCellBordersFromCSS(style) {
+	const parseSide = (cssStyle, cssColor, cssWidth) => {
+		if (!cssStyle || cssStyle === "none" || cssStyle === "hidden") return;
+		const color = parseCssColorToColorValue(cssColor);
+		return {
+			style: cssBorderStyleToOoxml(cssStyle),
+			...color ? { color } : {},
+			size: cssBorderWidthToEighths(cssWidth)
+		};
+	};
+	const top = parseSide(style.borderTopStyle, style.borderTopColor, style.borderTopWidth);
+	const bottom = parseSide(style.borderBottomStyle, style.borderBottomColor, style.borderBottomWidth);
+	const left = parseSide(style.borderLeftStyle, style.borderLeftColor, style.borderLeftWidth);
+	const right = parseSide(style.borderRightStyle, style.borderRightColor, style.borderRightWidth);
+	if (!top && !bottom && !left && !right) return null;
+	return {
+		...top !== void 0 ? { top } : {},
+		...bottom !== void 0 ? { bottom } : {},
+		...left !== void 0 ? { left } : {},
+		...right !== void 0 ? { right } : {}
+	};
+}
+/** Extract cell padding from inline CSS and convert to twips. */
+function extractCellMarginsFromCSS(style) {
+	const toTwips = (cssValue) => {
+		if (!cssValue || cssValue === "0px") return;
+		const num = Number.parseFloat(cssValue);
+		if (Number.isNaN(num) || num === 0) return;
+		if (cssValue.endsWith("pt")) return Math.round(num * 20);
+		return Math.round(num * 15);
+	};
+	const top = toTwips(style.paddingTop);
+	const right = toTwips(style.paddingRight);
+	const bottom = toTwips(style.paddingBottom);
+	const left = toTwips(style.paddingLeft);
+	if (top === void 0 && right === void 0 && bottom === void 0 && left === void 0) return null;
+	return {
+		...top !== void 0 ? { top } : {},
+		...right !== void 0 ? { right } : {},
+		...bottom !== void 0 ? { bottom } : {},
+		...left !== void 0 ? { left } : {}
+	};
+}
+/** Map CSS vertical-align to editor's verticalAlign attr. */
+function mapCssVerticalAlign(cssValue) {
+	if (!cssValue) return;
+	switch (cssValue.toLowerCase()) {
+		case "top": return "top";
+		case "middle": return "center";
+		case "bottom": return "bottom";
+		default: return;
+	}
+}
+/** Parse CSS color to hex string (without '#' prefix) for backgroundColor attr. */
+function parseCssColorToHex(cssColor) {
+	return parseCssColorToColorValue(cssColor)?.rgb;
+}
+/** Shared parseDOM getAttrs for td/th — extracts borders, padding, alignment from CSS. */
+function parseCellAttrsFromDOM(element) {
+	const style = element.style;
+	const borders = extractCellBordersFromCSS(style);
+	const margins = extractCellMarginsFromCSS(style);
+	const rawValign = element.dataset["valign"];
+	const verticalAlign = (rawValign === "top" || rawValign === "center" || rawValign === "bottom" ? rawValign : void 0) ?? mapCssVerticalAlign(style.verticalAlign) ?? void 0;
+	const backgroundColor = element.dataset["bgcolor"] || parseCssColorToHex(style.backgroundColor) || void 0;
+	return {
+		colspan: Number(element.getAttribute("colspan") ?? "1") || 1,
+		rowspan: Number(element.getAttribute("rowspan") ?? "1") || 1,
+		...verticalAlign !== void 0 ? { verticalAlign } : {},
+		...backgroundColor !== void 0 ? { backgroundColor } : {},
+		...borders ? { borders } : {},
+		...margins ? { margins } : {}
+	};
+}
+const tableSpec = {
+	content: "tableRow+",
+	group: "block",
+	tableRole: "table",
+	isolating: true,
+	attrs: {
+		styleId: { default: null },
+		width: { default: null },
+		widthType: { default: null },
+		justification: { default: null },
+		columnWidths: { default: null },
+		floating: { default: null },
+		cellMargins: { default: null },
+		look: { default: null },
+		borders: { default: null },
+		_originalFormatting: { default: null }
+	},
+	parseDOM: [{
+		tag: "table",
+		getAttrs(dom) {
+			const styleId = dom.dataset["styleId"];
+			const rawJustification = dom.dataset["justification"];
+			const justification = rawJustification === "left" || rawJustification === "center" || rawJustification === "right" ? rawJustification : void 0;
+			return {
+				...styleId ? { styleId } : {},
+				...justification !== void 0 ? { justification } : {}
+			};
+		}
+	}],
+	toDOM(node) {
+		const attrs = expectTableAttrs(node);
+		const domAttrs = { class: "docx-table" };
+		if (attrs.styleId) domAttrs["data-style-id"] = attrs.styleId;
+		const styles = ["border-collapse: collapse"];
+		if (attrs.width !== void 0 && attrs.widthType === "pct") {
+			styles.push(`width: ${attrs.width / 50}%`);
+			styles.push("table-layout: fixed");
+		} else if (attrs.width !== void 0 && attrs.widthType === "dxa") {
+			const widthPx = Math.round(attrs.width / 20 * 1.333);
+			styles.push(`width: ${widthPx}px`);
+			styles.push("table-layout: fixed");
+		} else {
+			styles.push("width: 100%");
+			styles.push("table-layout: fixed");
+		}
+		if (attrs.justification === "center") styles.push("margin-left: auto", "margin-right: auto");
+		else if (attrs.justification === "right") styles.push("margin-left: auto");
+		domAttrs["style"] = styles.join("; ");
+		return [
+			"table",
+			domAttrs,
+			["tbody", 0]
+		];
+	}
+};
+const tableRowSpec = {
+	content: "(tableCell | tableHeader)+",
+	tableRole: "row",
+	attrs: {
+		height: { default: null },
+		heightRule: { default: null },
+		isHeader: { default: false },
+		_originalFormatting: { default: null }
+	},
+	parseDOM: [{ tag: "tr" }],
+	toDOM(node) {
+		const attrs = expectTableRowAttrs(node);
+		const domAttrs = {};
+		if (typeof attrs.height === "number") domAttrs["style"] = `height: ${Math.round(attrs.height / 20 * 1.333)}px`;
+		return [
+			"tr",
+			domAttrs,
+			0
+		];
+	}
+};
+const BORDER_STYLE_CSS = {
+	single: "solid",
+	double: "double",
+	dotted: "dotted",
+	dashed: "dashed",
+	thick: "solid",
+	dashSmallGap: "dashed",
+	dotDash: "dashed",
+	dotDotDash: "dotted",
+	triple: "double",
+	thinThickSmallGap: "double",
+	thickThinSmallGap: "double",
+	thinThickThinSmallGap: "double",
+	thinThickMediumGap: "double",
+	thickThinMediumGap: "double",
+	thinThickThinMediumGap: "double",
+	thinThickLargeGap: "double",
+	thickThinLargeGap: "double",
+	thinThickThinLargeGap: "double",
+	wave: "solid",
+	doubleWave: "double",
+	dashDotStroked: "dashed",
+	threeDEmboss: "ridge",
+	threeDEngrave: "groove",
+	outset: "outset",
+	inset: "inset"
+};
+function buildCellBorderStyles(attrs) {
+	const styles = [];
+	const borders = attrs.borders;
+	if (!borders) return styles;
+	const borderToCss = (border) => {
+		if (!border || !border.style || border.style === "none" || border.style === "nil") return "none";
+		return `${border.size !== void 0 && border.size > 0 ? Math.max(1, Math.round(border.size / 8 * 1.333)) : 1}px ${BORDER_STYLE_CSS[border.style] || "solid"} ${resolveColor(border.color, void 0)}`;
+	};
+	styles.push(`border-top: ${borderToCss(borders.top)}`);
+	styles.push(`border-bottom: ${borderToCss(borders.bottom)}`);
+	styles.push(`border-left: ${borderToCss(borders.left)}`);
+	styles.push(`border-right: ${borderToCss(borders.right)}`);
+	return styles;
+}
+function buildCellPaddingStyles(attrs) {
+	const margins = attrs.margins;
+	if (!margins) {
+		const px = Math.round(108 / 20 * 1.333);
+		return [`padding: ${px}px ${px}px`];
+	}
+	const toPixels = (twips) => twips !== void 0 && twips > 0 ? Math.round(twips / 20 * 1.333) : 0;
+	return [`padding: ${toPixels(margins.top)}px ${toPixels(margins.right)}px ${toPixels(margins.bottom)}px ${toPixels(margins.left)}px`];
+}
+function buildTextDirectionStyles(textDirection) {
+	if (!textDirection) return [];
+	const styles = [];
+	switch (textDirection) {
+		case "tbRl":
+		case "tbRlV":
+			styles.push("writing-mode: vertical-rl");
+			break;
+		case "btLr":
+			styles.push("writing-mode: vertical-lr", "transform: rotate(180deg)");
+			break;
+		case "rl":
+		case "rlV":
+			styles.push("direction: rtl");
+			break;
+		case "tb":
+		case "tbV":
+			styles.push("writing-mode: vertical-lr");
+			break;
+		default: break;
+	}
+	return styles;
+}
+function buildCellWidthStyles(attrs) {
+	const styles = [];
+	if (attrs.colwidth && attrs.colwidth.length > 0) {
+		const totalWidth = attrs.colwidth.reduce((sum, w) => sum + w, 0);
+		styles.push(`width: ${totalWidth}px`);
+	} else if (attrs.width !== void 0 && attrs.widthType === "pct") styles.push(`width: ${attrs.width}%`);
+	else if (attrs.width !== void 0) {
+		const widthPx = Math.round(attrs.width / 20 * 1.333);
+		styles.push(`width: ${widthPx}px`);
+	}
+	return styles;
+}
+const tableCellSpec = {
+	content: "(paragraph | table)+",
+	tableRole: "cell",
+	isolating: true,
+	attrs: {
+		colspan: { default: 1 },
+		rowspan: { default: 1 },
+		colwidth: { default: null },
+		width: { default: null },
+		widthType: { default: null },
+		verticalAlign: { default: null },
+		backgroundColor: { default: null },
+		borders: { default: null },
+		margins: { default: null },
+		textDirection: { default: null },
+		noWrap: { default: false },
+		_originalFormatting: { default: null },
+		_preserveVMergeRestart: { default: null },
+		_docxVMergeContinuationCells: { default: null }
+	},
+	parseDOM: [{
+		tag: "td",
+		getAttrs: (dom) => parseCellAttrsFromDOM(dom)
+	}],
+	toDOM(node) {
+		const attrs = expectTableCellAttrs(node);
+		const domAttrs = { class: "docx-table-cell" };
+		if (attrs.colspan > 1) domAttrs["colspan"] = String(attrs.colspan);
+		if (attrs.rowspan > 1) domAttrs["rowspan"] = String(attrs.rowspan);
+		const styles = [];
+		styles.push(...buildCellPaddingStyles(attrs));
+		if (attrs.noWrap) styles.push("white-space: nowrap");
+		else styles.push("word-wrap: break-word", "overflow-wrap: break-word", "overflow: hidden");
+		styles.push(...buildCellWidthStyles(attrs));
+		styles.push(...buildCellBorderStyles(attrs));
+		styles.push(...buildTextDirectionStyles(attrs.textDirection));
+		if (attrs.verticalAlign) {
+			domAttrs["data-valign"] = attrs.verticalAlign;
+			styles.push(`vertical-align: ${attrs.verticalAlign}`);
+		}
+		if (attrs.backgroundColor) {
+			domAttrs["data-bgcolor"] = attrs.backgroundColor;
+			styles.push(`background-color: #${attrs.backgroundColor}`);
+		}
+		domAttrs["style"] = styles.join("; ");
+		return [
+			"td",
+			domAttrs,
+			0
+		];
+	}
+};
+const tableHeaderSpec = {
+	content: "(paragraph | table)+",
+	tableRole: "header_cell",
+	isolating: true,
+	attrs: {
+		colspan: { default: 1 },
+		rowspan: { default: 1 },
+		colwidth: { default: null },
+		width: { default: null },
+		widthType: { default: null },
+		verticalAlign: { default: null },
+		backgroundColor: { default: null },
+		borders: { default: null },
+		margins: { default: null },
+		textDirection: { default: null },
+		noWrap: { default: false },
+		_originalFormatting: { default: null },
+		_preserveVMergeRestart: { default: null },
+		_docxVMergeContinuationCells: { default: null }
+	},
+	parseDOM: [{
+		tag: "th",
+		getAttrs: (dom) => parseCellAttrsFromDOM(dom)
+	}],
+	toDOM(node) {
+		const attrs = expectTableCellAttrs(node);
+		const domAttrs = { class: "docx-table-header" };
+		if (attrs.colspan > 1) domAttrs["colspan"] = String(attrs.colspan);
+		if (attrs.rowspan > 1) domAttrs["rowspan"] = String(attrs.rowspan);
+		const styles = ["font-weight: bold"];
+		styles.push(...buildCellPaddingStyles(attrs));
+		if (attrs.noWrap) styles.push("white-space: nowrap");
+		else styles.push("word-wrap: break-word", "overflow-wrap: break-word", "overflow: hidden");
+		styles.push(...buildCellWidthStyles(attrs));
+		styles.push(...buildCellBorderStyles(attrs));
+		styles.push(...buildTextDirectionStyles(attrs.textDirection));
+		if (attrs.verticalAlign) {
+			domAttrs["data-valign"] = attrs.verticalAlign;
+			styles.push(`vertical-align: ${attrs.verticalAlign}`);
+		}
+		if (attrs.backgroundColor) {
+			domAttrs["data-bgcolor"] = attrs.backgroundColor;
+			styles.push(`background-color: #${attrs.backgroundColor}`);
+		}
+		domAttrs["style"] = styles.join("; ");
+		return [
+			"th",
+			domAttrs,
+			0
+		];
+	}
+};
+function getTableContext(state) {
+	const { selection } = state;
+	const { $from } = selection;
+	const isCellSel = selection instanceof CellSelection;
+	let table;
+	let tablePos;
+	let rowIndex;
+	let columnIndex;
+	let cellNode;
+	for (let d = $from.depth; d > 0; d--) {
+		const node = $from.node(d);
+		if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+			cellNode = node;
+			const rowNode = $from.node(d - 1);
+			if (rowNode.type.name === "tableRow") columnIndex = getColumnIndex(rowNode, $from.index(d - 1));
+		} else if (node.type.name === "tableRow") {
+			if ($from.node(d - 1).type.name === "table") rowIndex = $from.index(d - 1);
+		} else if (node.type.name === "table") {
+			table = node;
+			tablePos = $from.before(d);
+			break;
+		}
+	}
+	if (!table) return { isInTable: false };
+	let rowCount = 0;
+	let columnCount = 0;
+	table.forEach((row) => {
+		if (row.type.name === "tableRow") {
+			rowCount++;
+			let cols = 0;
+			row.forEach((cell) => {
+				cols += Number(cell.attrs["colspan"]) || 1;
+			});
+			columnCount = Math.max(columnCount, cols);
+		}
+	});
+	const canSplitCell = cellNode !== void 0 && ((Number(cellNode.attrs["colspan"]) || 1) > 1 || (Number(cellNode.attrs["rowspan"]) || 1) > 1);
+	let cellBorderColor;
+	let cellBackgroundColor;
+	if (cellNode) {
+		const attrs = cellNode.attrs;
+		if (typeof attrs["backgroundColor"] === "string" && attrs["backgroundColor"]) cellBackgroundColor = attrs["backgroundColor"];
+		const borders = attrs["borders"];
+		if (borders) for (const side of [
+			"top",
+			"right",
+			"bottom",
+			"left"
+		]) {
+			const border = borders[side];
+			if (border?.color && border.style && border.style !== "none" && border.style !== "nil") {
+				cellBorderColor = border.color;
+				break;
+			}
+		}
+	}
+	return {
+		isInTable: true,
+		table,
+		...tablePos !== void 0 ? { tablePos } : {},
+		...rowIndex !== void 0 ? { rowIndex } : {},
+		...columnIndex !== void 0 ? { columnIndex } : {},
+		rowCount,
+		columnCount,
+		hasMultiCellSelection: isCellSel,
+		canSplitCell,
+		...cellBorderColor !== void 0 ? { cellBorderColor } : {},
+		...cellBackgroundColor !== void 0 ? { cellBackgroundColor } : {}
+	};
+}
+const getColumnIndex = (rowNode, targetIndex) => {
+	let columnIndex = 0;
+	let foundColumnIndex;
+	rowNode.forEach((child, _offset, index) => {
+		if (foundColumnIndex !== void 0) return;
+		if (index === targetIndex) {
+			foundColumnIndex = columnIndex;
+			return;
+		}
+		columnIndex += Number(child.attrs["colspan"]) || 1;
+	});
+	return foundColumnIndex;
+};
+function isInTableCell(state) {
+	const { $from } = state.selection;
+	for (let d = $from.depth; d > 0; d--) {
+		const node = $from.node(d);
+		if (node.type.name === "tableCell" || node.type.name === "tableHeader") return true;
+	}
+	return false;
+}
+function findCellInfo(state) {
+	const { $from } = state.selection;
+	let cellDepth = -1;
+	let rowDepth = -1;
+	let tableDepth = -1;
+	for (let d = $from.depth; d > 0; d--) {
+		const node = $from.node(d);
+		if (node.type.name === "tableCell" || node.type.name === "tableHeader") cellDepth = d;
+		else if (node.type.name === "tableRow") rowDepth = d;
+		else if (node.type.name === "table") {
+			tableDepth = d;
+			break;
+		}
+	}
+	if (cellDepth === -1 || rowDepth === -1 || tableDepth === -1) return null;
+	return {
+		cellDepth,
+		cellPos: $from.before(cellDepth),
+		rowDepth,
+		tableDepth
+	};
+}
+function goToNextCell() {
+	return (state, dispatch) => {
+		if (!isInTableCell(state)) return false;
+		const info = findCellInfo(state);
+		if (!info) return false;
+		const { $from } = state.selection;
+		const table = $from.node(info.tableDepth);
+		const row = $from.node(info.rowDepth);
+		const cellIndex = $from.index(info.rowDepth);
+		const rowIndex = $from.index(info.tableDepth);
+		if (cellIndex < row.childCount - 1) {
+			const nextCellPos = info.cellPos + $from.node(info.cellDepth).nodeSize;
+			if (dispatch) {
+				const textPos = nextCellPos + 1 + 1;
+				dispatch(state.tr.setSelection(Selection.near(state.doc.resolve(textPos))).scrollIntoView());
+			}
+			return true;
+		}
+		if (rowIndex < table.childCount - 1) {
+			const nextRowPos = $from.before(info.rowDepth) + row.nodeSize;
+			if (dispatch) {
+				const textPos = nextRowPos + 1 + 1 + 1;
+				dispatch(state.tr.setSelection(Selection.near(state.doc.resolve(textPos))).scrollIntoView());
+			}
+			return true;
+		}
+		return false;
+	};
+}
+function goToPrevCell() {
+	return (state, dispatch) => {
+		if (!isInTableCell(state)) return false;
+		const info = findCellInfo(state);
+		if (!info) return false;
+		const { $from } = state.selection;
+		const table = $from.node(info.tableDepth);
+		const cellIndex = $from.index(info.rowDepth);
+		const rowIndex = $from.index(info.tableDepth);
+		if (cellIndex > 0) {
+			const prevCell = $from.node(info.rowDepth).child(cellIndex - 1);
+			const cellStartPos = info.cellPos - prevCell.nodeSize;
+			if (dispatch) {
+				const textPos = cellStartPos + prevCell.nodeSize - 2;
+				dispatch(state.tr.setSelection(Selection.near(state.doc.resolve(textPos), -1)).scrollIntoView());
+			}
+			return true;
+		}
+		if (rowIndex > 0) {
+			const prevRow = table.child(rowIndex - 1);
+			const prevRowPos = $from.before(info.rowDepth) - prevRow.nodeSize;
+			if (dispatch) {
+				const textPos = prevRowPos + prevRow.nodeSize - 1 - 1;
+				dispatch(state.tr.setSelection(Selection.near(state.doc.resolve(textPos), -1)).scrollIntoView());
+			}
+			return true;
+		}
+		return false;
+	};
+}
+const TableNodeExtension = createNodeExtension({
+	name: "table",
+	schemaNodeName: "table",
+	nodeSpec: tableSpec
+});
+const TableRowExtension = createNodeExtension({
+	name: "tableRow",
+	schemaNodeName: "tableRow",
+	nodeSpec: tableRowSpec
+});
+const TableCellExtension = createNodeExtension({
+	name: "tableCell",
+	schemaNodeName: "tableCell",
+	nodeSpec: tableCellSpec
+});
+const TableHeaderExtension = createNodeExtension({
+	name: "tableHeader",
+	schemaNodeName: "tableHeader",
+	nodeSpec: tableHeaderSpec
+});
+const TablePluginExtension = createExtension({
+	name: "tablePlugin",
+	onSchemaReady(ctx) {
+		const { schema } = ctx;
+		if (!schema.nodes["paragraph"]) panic("Missing node type: paragraph");
+		if (!schema.nodes["tableCell"]) panic("Missing node type: tableCell");
+		if (!schema.nodes["tableRow"]) panic("Missing node type: tableRow");
+		if (!schema.nodes["table"]) panic("Missing node type: table");
+		const nodeTypeParagraph = schema.nodes["paragraph"];
+		const nodeTypeTableCell = schema.nodes["tableCell"];
+		const nodeTypeTableRow = schema.nodes["tableRow"];
+		const nodeTypeTable = schema.nodes["table"];
+		function chainCommands(...commands) {
+			return (state, dispatch, view) => {
+				for (const cmd of commands) if (cmd(state, dispatch, view)) return true;
+				return false;
+			};
+		}
+		function buildCellAttrsFromTemplate(templateCell, overrides = {}) {
+			const baseAttrs = templateCell?.attrs ?? {};
+			return {
+				colspan: Number(baseAttrs["colspan"]) || 1,
+				rowspan: 1,
+				colwidth: baseAttrs["colwidth"],
+				width: baseAttrs["width"],
+				widthType: baseAttrs["widthType"],
+				verticalAlign: baseAttrs["verticalAlign"],
+				backgroundColor: baseAttrs["backgroundColor"],
+				borders: baseAttrs["borders"],
+				margins: baseAttrs["margins"],
+				textDirection: baseAttrs["textDirection"],
+				noWrap: baseAttrs["noWrap"],
+				...overrides
+			};
+		}
+		function createTable(rows, cols, borderColor = "000000", contentWidthTwips = 9360) {
+			const tableRows = [];
+			const colWidthTwips = Math.floor(contentWidthTwips / cols);
+			const defaultRowHeightTwips = 360;
+			const defaultRowHeightRule = "atLeast";
+			const defaultBorder = {
+				style: "single",
+				size: 4,
+				color: { rgb: borderColor }
+			};
+			const defaultBorders = {
+				top: defaultBorder,
+				bottom: defaultBorder,
+				left: defaultBorder,
+				right: defaultBorder
+			};
+			for (let r = 0; r < rows; r++) {
+				const cells = [];
+				for (let c = 0; c < cols; c++) {
+					const paragraph = nodeTypeParagraph.create();
+					const cellAttrs = {
+						colspan: 1,
+						rowspan: 1,
+						borders: defaultBorders,
+						width: colWidthTwips,
+						widthType: "dxa"
+					};
+					cells.push(nodeTypeTableCell.create(cellAttrs, paragraph));
+				}
+				tableRows.push(nodeTypeTableRow.create({
+					height: defaultRowHeightTwips,
+					heightRule: defaultRowHeightRule
+				}, cells));
+			}
+			const columnWidths = Array.from({ length: cols }, () => colWidthTwips);
+			return nodeTypeTable.create({
+				columnWidths,
+				width: contentWidthTwips,
+				widthType: "dxa"
+			}, tableRows);
+		}
+		function insertTable(rows, cols) {
+			return (state, dispatch) => {
+				const { $from } = state.selection;
+				let borderColor = "000000";
+				const marks = state.storedMarks ?? $from.marks();
+				for (const mark of marks) if (mark.type.name === "textColor" && typeof mark.attrs["rgb"] === "string") {
+					borderColor = mark.attrs["rgb"];
+					break;
+				}
+				let insertPos = $from.pos;
+				for (let d = $from.depth; d > 0; d--) {
+					const node = $from.node(d);
+					if (node.type.name === "paragraph" || node.type.name === "table") {
+						insertPos = $from.after(d);
+						break;
+					}
+				}
+				if (dispatch) {
+					let contentWidthTwips = 9360;
+					for (let d = $from.depth; d > 0; d--) {
+						const node = $from.node(d);
+						if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+							const cellWidth = Number(node.attrs["width"]);
+							if (cellWidth > 0) contentWidthTwips = Math.max(cellWidth - 216, 360);
+							break;
+						}
+					}
+					const table = createTable(rows, cols, borderColor, contentWidthTwips);
+					const emptyParagraph = nodeTypeParagraph.create();
+					const needsLeadingParagraph = state.doc.resolve(insertPos).nodeBefore?.type.name === "table";
+					const insertContent = needsLeadingParagraph ? [
+						emptyParagraph,
+						table,
+						emptyParagraph
+					] : [table, emptyParagraph];
+					const tr = state.tr.insert(insertPos, insertContent);
+					let tableStartPos = insertPos + 1;
+					if (needsLeadingParagraph) tableStartPos += emptyParagraph.nodeSize;
+					const firstCellContentPos = tableStartPos + 1 + 1;
+					tr.setSelection(TextSelection.create(tr.doc, firstCellContentPos));
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function addRowAbove(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.rowIndex === void 0 || !context.table || context.tablePos === void 0) return false;
+			if (dispatch) {
+				const tr = state.tr;
+				const rowNode = context.table.child(context.rowIndex);
+				const cells = [];
+				rowNode.forEach((cell) => {
+					const paragraph = nodeTypeParagraph.create();
+					const cellAttrs = buildCellAttrsFromTemplate(cell);
+					cells.push(nodeTypeTableCell.create(cellAttrs, paragraph));
+				});
+				const newRow = nodeTypeTableRow.create({
+					height: rowNode.attrs["height"] ?? 360,
+					heightRule: rowNode.attrs["heightRule"] ?? "atLeast"
+				}, cells);
+				let rowPos = context.tablePos + 1;
+				for (let i = 0; i < context.rowIndex; i++) rowPos += context.table.child(i).nodeSize;
+				tr.insert(rowPos, newRow);
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		}
+		function addRowBelow(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.rowIndex === void 0 || !context.table || context.tablePos === void 0) return false;
+			if (dispatch) {
+				const tr = state.tr;
+				const rowNode = context.table.child(context.rowIndex);
+				const cells = [];
+				rowNode.forEach((cell) => {
+					const paragraph = nodeTypeParagraph.create();
+					const cellAttrs = buildCellAttrsFromTemplate(cell);
+					cells.push(nodeTypeTableCell.create(cellAttrs, paragraph));
+				});
+				const newRow = nodeTypeTableRow.create({
+					height: rowNode.attrs["height"] ?? 360,
+					heightRule: rowNode.attrs["heightRule"] ?? "atLeast"
+				}, cells);
+				let rowPos = context.tablePos + 1;
+				for (let i = 0; i <= context.rowIndex; i++) rowPos += context.table.child(i).nodeSize;
+				tr.insert(rowPos, newRow);
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		}
+		function deleteRow(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.rowIndex === void 0 || !context.table || context.tablePos === void 0) return false;
+			const tablePos = context.tablePos;
+			const table = context.table;
+			const rowCount = context.rowCount ?? 0;
+			if (rowCount <= 0) return false;
+			let firstRow;
+			let lastRow;
+			if (state.selection instanceof CellSelection) {
+				const rect = selectedRect(state);
+				firstRow = Math.max(0, Math.min(rect.top, rowCount - 1));
+				lastRow = Math.min(Math.max(rect.bottom - 1, firstRow), rowCount - 1);
+			} else {
+				firstRow = context.rowIndex;
+				lastRow = context.rowIndex;
+			}
+			const coversAllRows = firstRow === 0 && lastRow >= rowCount - 1;
+			if (dispatch) {
+				const tr = state.tr;
+				if (coversAllRows) {
+					const tableEnd = tablePos + table.nodeSize;
+					const emptyParagraph = state.doc.resolve(tablePos).parent.childCount === 1 ? state.schema.nodes["paragraph"]?.createAndFill() : null;
+					if (emptyParagraph) {
+						tr.replaceWith(tablePos, tableEnd, emptyParagraph);
+						tr.setSelection(TextSelection.near(tr.doc.resolve(tablePos + 1)));
+					} else tr.delete(tablePos, tableEnd);
+					dispatch(tr.scrollIntoView());
+					return true;
+				}
+				const rect = selectedRect(state);
+				for (let row = lastRow; row >= firstRow; row--) {
+					removeRow(tr, rect, row);
+					if (row > firstRow) {
+						const updated = tr.doc.nodeAt(rect.tableStart - 1);
+						if (updated) {
+							rect.table = updated;
+							rect.map = TableMap.get(updated);
+						}
+					}
+				}
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		}
+		function addColumnLeft(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.columnIndex === void 0 || !context.table || context.tablePos === void 0) return false;
+			if (dispatch) {
+				let tr = state.tr;
+				const newColumnCount = (context.columnCount ?? 1) + 1;
+				const newColWidthPercent = Math.floor(100 / newColumnCount);
+				let rowPos = context.tablePos + 1;
+				context.table.forEach((row) => {
+					if (row.type.name === "tableRow") {
+						let cellPos = rowPos + 1;
+						let colIdx = 0;
+						row.forEach((cell) => {
+							if (colIdx === context.columnIndex) {
+								const paragraph = nodeTypeParagraph.create();
+								const cellAttrs = buildCellAttrsFromTemplate(cell, {
+									colspan: 1,
+									rowspan: 1
+								});
+								cellAttrs["width"] = newColWidthPercent;
+								cellAttrs["widthType"] = "pct";
+								const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
+								tr = tr.insert(tr.mapping.map(cellPos), newCell);
+							}
+							cellPos += cell.nodeSize;
+							colIdx += Number(cell.attrs["colspan"]) || 1;
+						});
+						if (context.columnIndex !== void 0 && colIdx <= context.columnIndex) {
+							const paragraph = nodeTypeParagraph.create();
+							const cellAttrs = buildCellAttrsFromTemplate(row.child(row.childCount - 1), {
+								colspan: 1,
+								rowspan: 1
+							});
+							cellAttrs["width"] = newColWidthPercent;
+							cellAttrs["widthType"] = "pct";
+							const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
+							tr = tr.insert(tr.mapping.map(cellPos), newCell);
+						}
+					}
+					rowPos += row.nodeSize;
+				});
+				const updatedTable = tr.doc.nodeAt(context.tablePos);
+				if (updatedTable && updatedTable.type.name === "table") {
+					const firstRow = updatedTable.child(0);
+					if (firstRow.type.name === "tableRow") {
+						let cellPos = context.tablePos + 2;
+						firstRow.forEach((cell) => {
+							if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
+								width: newColWidthPercent,
+								widthType: "pct"
+							}));
+							cellPos += cell.nodeSize;
+						});
+					}
+					const colCount = firstRow.childCount;
+					const tableWidthTwips = expectTableAttrs(updatedTable).width ?? 9360;
+					const colWidthTwips = Math.floor(tableWidthTwips / Math.max(1, colCount));
+					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(updatedTable, { columnWidths: Array.from({ length: colCount }, () => colWidthTwips) }));
+				}
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		}
+		function addColumnRight(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.columnIndex === void 0 || !context.table || context.tablePos === void 0) return false;
+			if (dispatch) {
+				let tr = state.tr;
+				const newColumnCount = (context.columnCount ?? 1) + 1;
+				const newColWidthPercent = Math.floor(100 / newColumnCount);
+				let rowPos = context.tablePos + 1;
+				context.table.forEach((row) => {
+					if (row.type.name === "tableRow") {
+						let cellPos = rowPos + 1;
+						let colIdx = 0;
+						let insertedCount = 0;
+						row.forEach((cell) => {
+							cellPos += cell.nodeSize;
+							colIdx += Number(cell.attrs["colspan"]) || 1;
+							if (insertedCount === 0 && context.columnIndex !== void 0 && colIdx > context.columnIndex) {
+								const paragraph = nodeTypeParagraph.create();
+								const cellAttrs = buildCellAttrsFromTemplate(cell, {
+									colspan: 1,
+									rowspan: 1
+								});
+								cellAttrs["width"] = newColWidthPercent;
+								cellAttrs["widthType"] = "pct";
+								const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
+								tr = tr.insert(tr.mapping.map(cellPos), newCell);
+								insertedCount += 1;
+							}
+						});
+						if (insertedCount === 0) {
+							const paragraph = nodeTypeParagraph.create();
+							const cellAttrs = buildCellAttrsFromTemplate(row.child(row.childCount - 1), {
+								colspan: 1,
+								rowspan: 1
+							});
+							cellAttrs["width"] = newColWidthPercent;
+							cellAttrs["widthType"] = "pct";
+							const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
+							tr = tr.insert(tr.mapping.map(cellPos), newCell);
+						}
+					}
+					rowPos += row.nodeSize;
+				});
+				const updatedTable = tr.doc.nodeAt(context.tablePos);
+				if (updatedTable && updatedTable.type.name === "table") {
+					const firstRow = updatedTable.child(0);
+					if (firstRow.type.name === "tableRow") {
+						let cellPos = context.tablePos + 2;
+						firstRow.forEach((cell) => {
+							if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
+								width: newColWidthPercent,
+								widthType: "pct"
+							}));
+							cellPos += cell.nodeSize;
+						});
+					}
+					const colCount = firstRow.childCount;
+					const tableWidthTwips = expectTableAttrs(updatedTable).width ?? 9360;
+					const colWidthTwips = Math.floor(tableWidthTwips / Math.max(1, colCount));
+					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(updatedTable, { columnWidths: Array.from({ length: colCount }, () => colWidthTwips) }));
+				}
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		}
+		function deleteColumn(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.columnIndex === void 0 || !context.table || context.tablePos === void 0 || (context.columnCount ?? 0) <= 1) return false;
+			if (dispatch) {
+				let tr = state.tr;
+				const newColumnCount = (context.columnCount ?? 2) - 1;
+				const newColWidthPercent = Math.floor(100 / newColumnCount);
+				const deleteOps = [];
+				let rowPos = context.tablePos + 1;
+				context.table.forEach((row) => {
+					if (row.type.name === "tableRow") {
+						let cellPos = rowPos + 1;
+						let colIdx = 0;
+						row.forEach((cell) => {
+							const cellStart = cellPos;
+							const cellEnd = cellPos + cell.nodeSize;
+							const cellColspan = Number(cell.attrs["colspan"]) || 1;
+							if (context.columnIndex !== void 0 && colIdx <= context.columnIndex && context.columnIndex < colIdx + cellColspan) deleteOps.push({
+								start: cellStart,
+								end: cellEnd
+							});
+							cellPos = cellEnd;
+							colIdx += cellColspan;
+						});
+					}
+					rowPos += row.nodeSize;
+				});
+				for (const { start, end } of deleteOps.toReversed()) tr = tr.delete(start, end);
+				const updatedTable = tr.doc.nodeAt(context.tablePos);
+				if (updatedTable && updatedTable.type.name === "table") {
+					const firstRow = updatedTable.child(0);
+					if (firstRow.type.name === "tableRow") {
+						let cellPos = context.tablePos + 2;
+						firstRow.forEach((cell) => {
+							if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
+								width: newColWidthPercent,
+								widthType: "pct"
+							}));
+							cellPos += cell.nodeSize;
+						});
+					}
+					const colCount = firstRow.childCount;
+					const tableWidthTwips = expectTableAttrs(updatedTable).width ?? 9360;
+					const colWidthTwips = Math.floor(tableWidthTwips / Math.max(1, colCount));
+					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(updatedTable, { columnWidths: Array.from({ length: colCount }, () => colWidthTwips) }));
+				}
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		}
+		function deleteTable(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+			if (dispatch) {
+				const tr = state.tr;
+				tr.delete(context.tablePos, context.tablePos + context.table.nodeSize);
+				dispatch(tr.scrollIntoView());
+			}
+			return true;
+		}
+		function selectTable(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+			if (dispatch) {
+				const tableStart = context.tablePos + 1;
+				const $first = state.doc.resolve(tableStart);
+				const $last = state.doc.resolve(context.tablePos + context.table.nodeSize - 2);
+				const cellSel = CellSelection.create(state.doc, $first.pos, $last.pos);
+				dispatch(state.tr.setSelection(cellSel));
+			}
+			return true;
+		}
+		function selectRow(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.tablePos === void 0 || !context.table || context.rowIndex === void 0) return false;
+			if (dispatch) {
+				let rowPos = context.tablePos + 1;
+				for (let r = 0; r < context.rowIndex; r++) {
+					const row = context.table.child(r);
+					rowPos += row.nodeSize;
+				}
+				const row = context.table.child(context.rowIndex);
+				const firstCellPos = rowPos + 1;
+				const lastCellPos = rowPos + row.nodeSize - 2;
+				const cellSel = CellSelection.create(state.doc, firstCellPos, lastCellPos);
+				dispatch(state.tr.setSelection(cellSel));
+			}
+			return true;
+		}
+		function selectColumn(state, dispatch) {
+			const context = getTableContext(state);
+			if (!context.isInTable || context.tablePos === void 0 || !context.table || context.columnIndex === void 0) return false;
+			if (dispatch) {
+				const tableStart = context.tablePos + 1;
+				const firstRow = context.table.child(0);
+				const lastRow = context.table.child(context.table.childCount - 1);
+				let firstCellPos = tableStart + 1;
+				for (let c = 0; c < context.columnIndex && c < firstRow.childCount; c++) firstCellPos += firstRow.child(c).nodeSize;
+				let lastRowPos = tableStart;
+				for (let r = 0; r < context.table.childCount - 1; r++) lastRowPos += context.table.child(r).nodeSize;
+				let lastCellPos = lastRowPos + 1;
+				for (let c = 0; c < context.columnIndex && c < lastRow.childCount; c++) lastCellPos += lastRow.child(c).nodeSize;
+				const cellSel = CellSelection.create(state.doc, firstCellPos, lastCellPos);
+				dispatch(state.tr.setSelection(cellSel));
+			}
+			return true;
+		}
+		/**
+		* Get cell positions to operate on: all cells from CellSelection, or
+		* all cells in the table if a single cursor is inside a cell.
+		*/
+		function getTargetCellPositions(state) {
+			const sel = state.selection;
+			const cells = [];
+			if (sel instanceof CellSelection) {
+				sel.forEachCell((node, pos) => {
+					cells.push({
+						pos,
+						node
+					});
+				});
+				return cells;
+			}
+			const { $from } = sel;
+			for (let d = $from.depth; d > 0; d--) {
+				const node = $from.node(d);
+				if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+					cells.push({
+						pos: $from.before(d),
+						node
+					});
+					break;
+				}
+			}
+			return cells;
+		}
+		/**
+		* Build a full grid map of all cells in the table: pos → grid info.
+		* Also builds a reverse lookup by (rowIdx, colIdx).
+		*/
+		function buildTableGrid(table, tableStart) {
+			const cellByPos = /* @__PURE__ */ new Map();
+			const cellByRC = /* @__PURE__ */ new Map();
+			const totalRows = table.childCount;
+			let totalCols = 0;
+			table.forEach((row, rowOffset, rowIdx) => {
+				if (row.type.name !== "tableRow") return;
+				let colIdx = 0;
+				row.forEach((cell, cellOffset) => {
+					const pos = tableStart + rowOffset + cellOffset + 2;
+					const colspan = expectTableCellAttrs(cell).colspan || 1;
+					cellByPos.set(pos, {
+						rowIdx,
+						colIdx,
+						colspan,
+						pos,
+						node: cell
+					});
+					cellByRC.set(`${rowIdx},${colIdx}`, pos);
+					colIdx += colspan;
+				});
+				totalCols = Math.max(totalCols, colIdx);
+			});
+			return {
+				cellByPos,
+				cellByRC,
+				totalRows,
+				totalCols
+			};
+		}
+		function setTableBorders(preset, borderSpec) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const table = context.table;
+					const tableStart = context.tablePos;
+					const solidBorder = borderSpec ?? {
+						style: "single",
+						size: 4,
+						color: { rgb: "000000" }
+					};
+					const noBorder = { style: "none" };
+					const { cellByPos, cellByRC } = buildTableGrid(table, tableStart);
+					const targetCells = getTargetCellPositions(state);
+					let maxCol = -1, maxRow = -1, minCol = Infinity, minRow = Infinity;
+					for (const { pos } of targetCells) {
+						const info = cellByPos.get(pos);
+						if (info) {
+							minRow = Math.min(minRow, info.rowIdx);
+							maxRow = Math.max(maxRow, info.rowIdx);
+							minCol = Math.min(minCol, info.colIdx);
+							maxCol = Math.max(maxCol, info.colIdx + info.colspan - 1);
+						}
+					}
+					const modified = /* @__PURE__ */ new Map();
+					const getAttrs = (pos, node) => modified.get(pos) ?? expectTableCellAttrs(node);
+					const setAttrs = (pos, attrs) => {
+						modified.set(pos, attrs);
+					};
+					for (const { pos } of targetCells) {
+						const info = cellByPos.get(pos);
+						if (!info) continue;
+						const isTopEdge = info.rowIdx === minRow;
+						const isBottomEdge = info.rowIdx === maxRow;
+						const isLeftEdge = info.colIdx === minCol;
+						const isRightEdge = info.colIdx + info.colspan - 1 === maxCol;
+						let cellBorders = {};
+						switch (preset) {
+							case "all":
+								cellBorders = {
+									top: solidBorder,
+									bottom: solidBorder,
+									left: solidBorder,
+									right: solidBorder
+								};
+								break;
+							case "outside":
+								cellBorders = {
+									top: isTopEdge ? solidBorder : noBorder,
+									bottom: isBottomEdge ? solidBorder : noBorder,
+									left: isLeftEdge ? solidBorder : noBorder,
+									right: isRightEdge ? solidBorder : noBorder
+								};
+								break;
+							case "inside":
+								cellBorders = {
+									top: isTopEdge ? noBorder : solidBorder,
+									bottom: isBottomEdge ? noBorder : solidBorder,
+									left: isLeftEdge ? noBorder : solidBorder,
+									right: isRightEdge ? noBorder : solidBorder
+								};
+								break;
+							case "none":
+								cellBorders = {
+									top: noBorder,
+									bottom: noBorder,
+									left: noBorder,
+									right: noBorder
+								};
+								break;
+							default: break;
+						}
+						const attrs = getAttrs(pos, info.node);
+						const existingBorders = attrs.borders ?? {};
+						setAttrs(pos, {
+							...attrs,
+							borders: {
+								...existingBorders,
+								...cellBorders
+							}
+						});
+						if (cellBorders.top) {
+							const adjPos = cellByRC.get(`${info.rowIdx - 1},${info.colIdx}`);
+							if (adjPos !== void 0) {
+								const adj = cellByPos.get(adjPos);
+								if (!adj) continue;
+								const adjAttrs = getAttrs(adjPos, adj.node);
+								const adjBorders = adjAttrs.borders ?? {};
+								setAttrs(adjPos, {
+									...adjAttrs,
+									borders: {
+										...adjBorders,
+										bottom: cellBorders.top
+									}
+								});
+							}
+						}
+						if (cellBorders.bottom) {
+							const adjPos = cellByRC.get(`${info.rowIdx + 1},${info.colIdx}`);
+							if (adjPos !== void 0) {
+								const adj = cellByPos.get(adjPos);
+								if (!adj) continue;
+								const adjAttrs = getAttrs(adjPos, adj.node);
+								const adjBorders = adjAttrs.borders ?? {};
+								setAttrs(adjPos, {
+									...adjAttrs,
+									borders: {
+										...adjBorders,
+										top: cellBorders.bottom
+									}
+								});
+							}
+						}
+						if (cellBorders.left) {
+							const adjPos = cellByRC.get(`${info.rowIdx},${info.colIdx - 1}`);
+							if (adjPos !== void 0) {
+								const adj = cellByPos.get(adjPos);
+								if (!adj) continue;
+								const adjAttrs = getAttrs(adjPos, adj.node);
+								const adjBorders = adjAttrs.borders ?? {};
+								setAttrs(adjPos, {
+									...adjAttrs,
+									borders: {
+										...adjBorders,
+										right: cellBorders.left
+									}
+								});
+							}
+						}
+						if (cellBorders.right) {
+							const adjPos = cellByRC.get(`${info.rowIdx},${info.colIdx + info.colspan}`);
+							if (adjPos !== void 0) {
+								const adj = cellByPos.get(adjPos);
+								if (!adj) continue;
+								const adjAttrs = getAttrs(adjPos, adj.node);
+								const adjBorders = adjAttrs.borders ?? {};
+								setAttrs(adjPos, {
+									...adjAttrs,
+									borders: {
+										...adjBorders,
+										left: cellBorders.right
+									}
+								});
+							}
+						}
+					}
+					for (const [pos, attrs] of modified) tr.setNodeMarkup(tr.mapping.map(pos), void 0, attrs);
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		/**
+		* Apply a whole-table border preset (Word's "All Borders" / "No Border")
+		* to the table containing the caret. Updates the table node's `borders`
+		* attr (serialized as w:tblBorders) and bakes the same spec into every
+		* cell's `borders` attr so the paged painter reflects the change live.
+		*/
+		function setTableBorderPreset(preset) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const table = context.table;
+					const tableStart = context.tablePos;
+					const spec = preset === "all" ? {
+						style: "single",
+						size: 4,
+						space: 0,
+						color: { auto: true }
+					} : { style: "none" };
+					const tableBorders = {
+						top: spec,
+						bottom: spec,
+						left: spec,
+						right: spec,
+						insideH: spec,
+						insideV: spec
+					};
+					tr.setNodeMarkup(tableStart, void 0, {
+						...expectTableAttrs(table),
+						borders: tableBorders
+					});
+					table.forEach((row, rowOffset) => {
+						if (row.type.name !== "tableRow") return;
+						row.forEach((cell, cellOffset) => {
+							const pos = tableStart + rowOffset + cellOffset + 2;
+							tr.setNodeMarkup(pos, void 0, {
+								...expectTableCellAttrs(cell),
+								borders: {
+									top: spec,
+									bottom: spec,
+									left: spec,
+									right: spec
+								}
+							});
+						});
+					});
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setCellFillColor(color) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					const bgColor = color ? color.replace(/^#/u, "") : void 0;
+					for (const { pos, node } of cells) tr.setNodeMarkup(tr.mapping.map(pos), void 0, mergeTableCellAttrs(node, { backgroundColor: bgColor }));
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setCellBorder(side, spec, clearOthers) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					const borderValue = spec ?? { style: "none" };
+					const noBorder = { style: "none" };
+					const allSides = [
+						"top",
+						"bottom",
+						"left",
+						"right"
+					];
+					const { cellByPos, cellByRC } = buildTableGrid(context.table, context.tablePos);
+					const modified = /* @__PURE__ */ new Map();
+					const getAttrs = (p, n) => modified.get(p) ?? expectTableCellAttrs(n);
+					const setAttrs = (p, a) => modified.set(p, a);
+					const adjacentMap = {
+						top: {
+							adjSide: "bottom",
+							dRow: -1,
+							dCol: 0
+						},
+						bottom: {
+							adjSide: "top",
+							dRow: 1,
+							dCol: 0
+						},
+						left: {
+							adjSide: "right",
+							dRow: 0,
+							dCol: -1
+						},
+						right: {
+							adjSide: "left",
+							dRow: 0,
+							dCol: 1
+						}
+					};
+					for (const { pos, node } of cells) {
+						const info = cellByPos.get(pos);
+						const attrs = getAttrs(pos, node);
+						const currentBorders = attrs.borders ?? {};
+						const sides = side === "all" ? allSides : [side];
+						const newBorders = clearOthers ? {
+							top: noBorder,
+							bottom: noBorder,
+							left: noBorder,
+							right: noBorder
+						} : { ...currentBorders };
+						for (const s of sides) newBorders[s] = borderValue;
+						if (info) {
+							const sidesToSync = clearOthers ? allSides : sides;
+							for (const s of sidesToSync) {
+								const syncValue = newBorders[s];
+								const adj = adjacentMap[s];
+								const adjColIdx = s === "right" ? info.colIdx + info.colspan : info.colIdx + adj.dCol;
+								const adjPos = cellByRC.get(`${info.rowIdx + adj.dRow},${adjColIdx}`);
+								if (adjPos !== void 0) {
+									const adjInfo = cellByPos.get(adjPos);
+									if (!adjInfo) continue;
+									const adjAttrs = getAttrs(adjPos, adjInfo.node);
+									const adjBorders = adjAttrs.borders ?? {};
+									setAttrs(adjPos, {
+										...adjAttrs,
+										borders: {
+											...adjBorders,
+											[adj.adjSide]: syncValue
+										}
+									});
+								}
+							}
+						}
+						setAttrs(pos, {
+							...attrs,
+							borders: newBorders
+						});
+					}
+					for (const [p, a] of modified) tr.setNodeMarkup(tr.mapping.map(p), void 0, a);
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setCellVerticalAlign(align) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					for (const { pos, node } of cells) tr.setNodeMarkup(tr.mapping.map(pos), void 0, mergeTableCellAttrs(node, { verticalAlign: align }));
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setCellMargins(margins) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					for (const { pos, node } of cells) {
+						const newMargins = {
+							...expectTableCellAttrs(node).margins ?? {},
+							...margins
+						};
+						tr.setNodeMarkup(tr.mapping.map(pos), void 0, mergeTableCellAttrs(node, { margins: newMargins }));
+					}
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setCellTextDirection(direction) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					if (direction !== null && !isOneOf(direction, TABLE_CELL_TEXT_DIRECTION_VALUES)) return false;
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					for (const { pos, node } of cells) tr.setNodeMarkup(tr.mapping.map(pos), void 0, mergeTableCellAttrs(node, { textDirection: direction ?? void 0 }));
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function toggleNoWrap() {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					for (const { pos, node } of cells) {
+						const attrs = expectTableCellAttrs(node);
+						tr.setNodeMarkup(tr.mapping.map(pos), void 0, mergeTableCellAttrs(node, { noWrap: attrs.noWrap !== true }));
+					}
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setRowHeight(height, rule) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const { $from } = state.selection;
+					for (let d = $from.depth; d > 0; d--) {
+						const node = $from.node(d);
+						if (node.type.name === "tableRow") {
+							const pos = $from.before(d);
+							tr.setNodeMarkup(pos, void 0, mergeTableRowAttrs(node, {
+								height: height ?? void 0,
+								heightRule: height !== null ? rule ?? "atLeast" : void 0
+							}));
+							dispatch(tr.scrollIntoView());
+							return true;
+						}
+					}
+				}
+				return true;
+			};
+		}
+		function distributeColumns() {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table || context.columnCount === void 0 || context.columnCount === 0) return false;
+				if (dispatch) {
+					let tr = state.tr;
+					const table = context.table;
+					const colCount = context.columnCount;
+					const existingWidths = expectTableAttrs(table).columnWidths;
+					const totalWidthTwips = existingWidths ? existingWidths.reduce((sum, w) => sum + w, 0) : 9360;
+					const equalWidth = Math.floor(totalWidthTwips / colCount);
+					let rowPos = context.tablePos + 1;
+					table.forEach((row) => {
+						if (row.type.name === "tableRow") {
+							let cellPos = rowPos + 1;
+							row.forEach((cell) => {
+								if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
+									width: equalWidth,
+									widthType: "dxa",
+									colwidth: null
+								}));
+								cellPos += cell.nodeSize;
+							});
+						}
+						rowPos += row.nodeSize;
+					});
+					const newColumnWidths = Array.from({ length: colCount }, () => equalWidth);
+					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(table, { columnWidths: newColumnWidths }));
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function autoFitContents() {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					let tr = state.tr;
+					const table = context.table;
+					let rowPos = context.tablePos + 1;
+					table.forEach((row) => {
+						if (row.type.name === "tableRow") {
+							let cellPos = rowPos + 1;
+							row.forEach((cell) => {
+								if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
+									width: void 0,
+									widthType: void 0,
+									colwidth: null
+								}));
+								cellPos += cell.nodeSize;
+							});
+						}
+						rowPos += row.nodeSize;
+					});
+					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(table, {
+						columnWidths: void 0,
+						width: void 0,
+						widthType: "auto"
+					}));
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		/**
+		* Apply a table style to the current table.
+		* Accepts pre-resolved style data (borders, shading per conditional type).
+		*/
+		function applyTableStyle(styleData) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					let tr = state.tr;
+					const table = context.table;
+					const tablePos = context.tablePos;
+					const totalRows = table.childCount;
+					const look = styleData.look ?? {
+						firstRow: true,
+						lastRow: false,
+						noHBand: false,
+						noVBand: true
+					};
+					const conditionals = styleData.conditionals ?? {};
+					const tableBorders = styleData.tableBorders;
+					tr = tr.setNodeMarkup(tablePos, void 0, mergeTableAttrs(table, { styleId: styleData.styleId }));
+					let dataRowIndex = 0;
+					let rowOffset = tablePos + 1;
+					for (let rowIdx = 0; rowIdx < totalRows; rowIdx++) {
+						const row = table.child(rowIdx);
+						const isFirstRow = rowIdx === 0 && !!look.firstRow;
+						const isLastRow = rowIdx === totalRows - 1 && !!look.lastRow;
+						const bandingEnabled = look.noHBand !== true;
+						const totalCols = row.childCount;
+						let condType;
+						if (isFirstRow) condType = "firstRow";
+						else if (isLastRow) condType = "lastRow";
+						else if (bandingEnabled) {
+							condType = dataRowIndex % 2 === 0 ? "band1Horz" : "band2Horz";
+							dataRowIndex++;
+						} else dataRowIndex++;
+						let cellOffset = rowOffset + 1;
+						for (let colIdx = 0; colIdx < totalCols; colIdx++) {
+							const cell = row.child(colIdx);
+							const cellPos = tr.mapping.map(cellOffset);
+							let cellCondType = condType;
+							const isFirstCol = colIdx === 0 && !!look.firstCol;
+							const isLastCol = colIdx === totalCols - 1 && !!look.lastCol;
+							if (isFirstRow && isFirstCol && conditionals["nwCell"]) cellCondType = "nwCell";
+							else if (isFirstRow && isLastCol && conditionals["neCell"]) cellCondType = "neCell";
+							else if (isLastRow && isFirstCol && conditionals["swCell"]) cellCondType = "swCell";
+							else if (isLastRow && isLastCol && conditionals["seCell"]) cellCondType = "seCell";
+							else if (isFirstCol) cellCondType = "firstCol";
+							else if (isLastCol) cellCondType = "lastCol";
+							const cond = cellCondType ? conditionals[cellCondType] : void 0;
+							const cellBorders = {};
+							for (const side of [
+								"top",
+								"bottom",
+								"left",
+								"right"
+							]) if (cond?.borders && cond.borders[side] !== void 0) {
+								const border = cond.borders[side];
+								if (border) cellBorders[side] = border;
+							} else if (tableBorders) {
+								let border;
+								if (side === "top" && rowIdx > 0 || side === "bottom" && rowIdx < totalRows - 1) border = tableBorders.insideH ?? tableBorders[side];
+								else if (side === "left" && colIdx > 0 || side === "right" && colIdx < totalCols - 1) border = tableBorders.insideV ?? tableBorders[side];
+								else border = tableBorders[side];
+								if (border) cellBorders[side] = border;
+							}
+							tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
+								backgroundColor: cond?.backgroundColor,
+								borders: Object.keys(cellBorders).length > 0 ? cellBorders : void 0
+							}));
+							cellOffset += cell.nodeSize;
+						}
+						rowOffset += row.nodeSize;
+					}
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setTableProperties(props) {
+			return (state, dispatch) => {
+				if (props.widthType !== void 0 && props.widthType !== null && !isOneOf(props.widthType, TABLE_WIDTH_TYPE_VALUES)) return false;
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(context.table, {
+						..."width" in props ? { width: props.width ?? void 0 } : {},
+						..."widthType" in props ? { widthType: props.widthType ?? void 0 } : {},
+						..."justification" in props ? { justification: props.justification ?? void 0 } : {}
+					}));
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function toggleHeaderRow() {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const { $from } = state.selection;
+					for (let d = $from.depth; d > 0; d--) {
+						const node = $from.node(d);
+						if (node.type.name === "tableRow") {
+							const pos = $from.before(d);
+							const attrs = expectTableRowAttrs(node);
+							tr.setNodeMarkup(pos, void 0, mergeTableRowAttrs(node, { isHeader: attrs.isHeader !== true }));
+							dispatch(tr.scrollIntoView());
+							return true;
+						}
+					}
+				}
+				return true;
+			};
+		}
+		function setTableBorderColor(color) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					const rgb = color.replace(/^#/u, "");
+					const defaultBorder = {
+						style: "single",
+						size: 4
+					};
+					const { cellByPos, cellByRC } = buildTableGrid(context.table, context.tablePos);
+					const modified = /* @__PURE__ */ new Map();
+					const getAttrs = (p, n) => modified.get(p) ?? expectTableCellAttrs(n);
+					const setAttrs = (p, a) => modified.set(p, a);
+					const adjacentMap = {
+						top: {
+							adjSide: "bottom",
+							dRow: -1,
+							dCol: 0
+						},
+						bottom: {
+							adjSide: "top",
+							dRow: 1,
+							dCol: 0
+						},
+						left: {
+							adjSide: "right",
+							dRow: 0,
+							dCol: -1
+						},
+						right: {
+							adjSide: "left",
+							dRow: 0,
+							dCol: 1
+						}
+					};
+					for (const { pos, node } of cells) {
+						const info = cellByPos.get(pos);
+						const attrs = getAttrs(pos, node);
+						const currentBorders = attrs.borders ?? {};
+						const newBorders = {};
+						for (const side of [
+							"top",
+							"bottom",
+							"left",
+							"right"
+						]) {
+							const borderVal = {
+								...defaultBorder,
+								...currentBorders[side],
+								color: { rgb }
+							};
+							newBorders[side] = borderVal;
+							if (info) {
+								const adj = adjacentMap[side];
+								const adjColIdx = side === "right" ? info.colIdx + info.colspan : info.colIdx + adj.dCol;
+								const adjPos = cellByRC.get(`${info.rowIdx + adj.dRow},${adjColIdx}`);
+								if (adjPos !== void 0) {
+									const adjInfo = cellByPos.get(adjPos);
+									if (!adjInfo) continue;
+									const adjAttrs = getAttrs(adjPos, adjInfo.node);
+									const adjBorders = adjAttrs.borders ?? {};
+									setAttrs(adjPos, {
+										...adjAttrs,
+										borders: {
+											...adjBorders,
+											[adj.adjSide]: borderVal
+										}
+									});
+								}
+							}
+						}
+						setAttrs(pos, {
+							...attrs,
+							borders: {
+								...currentBorders,
+								...newBorders
+							}
+						});
+					}
+					for (const [p, a] of modified) tr.setNodeMarkup(tr.mapping.map(p), void 0, a);
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function setTableBorderWidth(size) {
+			return (state, dispatch) => {
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				if (dispatch) {
+					const tr = state.tr;
+					const cells = getTargetCellPositions(state);
+					const defaultBorder = {
+						style: "single",
+						color: { rgb: "000000" }
+					};
+					const { cellByPos, cellByRC } = buildTableGrid(context.table, context.tablePos);
+					const modified = /* @__PURE__ */ new Map();
+					const getAttrs = (p, n) => modified.get(p) ?? expectTableCellAttrs(n);
+					const setAttrs = (p, a) => modified.set(p, a);
+					const adjacentMap = {
+						top: {
+							adjSide: "bottom",
+							dRow: -1,
+							dCol: 0
+						},
+						bottom: {
+							adjSide: "top",
+							dRow: 1,
+							dCol: 0
+						},
+						left: {
+							adjSide: "right",
+							dRow: 0,
+							dCol: -1
+						},
+						right: {
+							adjSide: "left",
+							dRow: 0,
+							dCol: 1
+						}
+					};
+					for (const { pos, node } of cells) {
+						const info = cellByPos.get(pos);
+						const attrs = getAttrs(pos, node);
+						const currentBorders = attrs.borders ?? {};
+						const newBorders = {};
+						for (const side of [
+							"top",
+							"bottom",
+							"left",
+							"right"
+						]) {
+							const borderVal = {
+								...defaultBorder,
+								...currentBorders[side],
+								size
+							};
+							newBorders[side] = borderVal;
+							if (info) {
+								const adj = adjacentMap[side];
+								const adjColIdx = side === "right" ? info.colIdx + info.colspan : info.colIdx + adj.dCol;
+								const adjPos = cellByRC.get(`${info.rowIdx + adj.dRow},${adjColIdx}`);
+								if (adjPos !== void 0) {
+									const adjInfo = cellByPos.get(adjPos);
+									if (!adjInfo) continue;
+									const adjAttrs = getAttrs(adjPos, adjInfo.node);
+									const adjBorders = adjAttrs.borders ?? {};
+									setAttrs(adjPos, {
+										...adjAttrs,
+										borders: {
+											...adjBorders,
+											[adj.adjSide]: borderVal
+										}
+									});
+								}
+							}
+						}
+						setAttrs(pos, {
+							...attrs,
+							borders: {
+								...currentBorders,
+								...newBorders
+							}
+						});
+					}
+					for (const [p, a] of modified) tr.setNodeMarkup(tr.mapping.map(p), void 0, a);
+					dispatch(tr.scrollIntoView());
+				}
+				return true;
+			};
+		}
+		function deleteTableIfSelected() {
+			return (state, dispatch) => {
+				const selection = state.selection;
+				if (!("$anchorCell" in selection && typeof selection.forEachCell === "function")) return false;
+				const context = getTableContext(state);
+				if (!context.isInTable || context.tablePos === void 0 || !context.table) return false;
+				let totalCells = 0;
+				context.table.descendants((node) => {
+					if (node.type.name === "tableCell" || node.type.name === "tableHeader") totalCells += 1;
+				});
+				let selectedCells = 0;
+				selection.forEachCell(() => {
+					selectedCells += 1;
+				});
+				if (!(totalCells > 0 && selectedCells >= totalCells)) return false;
+				if (dispatch) dispatch(state.tr.delete(context.tablePos, context.tablePos + context.table.nodeSize).scrollIntoView());
+				return true;
+			};
+		}
+		function preventTableMergeAtGap() {
+			return (state) => {
+				const { $from, empty } = state.selection;
+				if (!empty) return false;
+				const parent = $from.parent;
+				if (parent.type.name !== "paragraph") return false;
+				if (parent.textContent.length > 0) return false;
+				const depth = $from.depth;
+				if (depth < 1) return false;
+				const container = $from.node(depth - 1);
+				const index = $from.index(depth - 1);
+				const before = index > 0 ? container.child(index - 1) : null;
+				const after = index + 1 < container.childCount ? container.child(index + 1) : null;
+				const beforeIsTable = before?.type.name === "table";
+				const afterIsTable = after?.type.name === "table";
+				if (beforeIsTable || afterIsTable) return true;
+				return false;
+			};
+		}
+		const activeCellPlugin = new Plugin({
+			key: new PluginKey("activeCell"),
+			props: { decorations(state) {
+				const { selection } = state;
+				if (selection instanceof CellSelection) return DecorationSet.empty;
+				const { $from } = selection;
+				for (let d = $from.depth; d > 0; d--) {
+					const node = $from.node(d);
+					if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+						const pos = $from.before(d);
+						return DecorationSet.create(state.doc, [Decoration.node(pos, pos + node.nodeSize, { class: "activeCell" })]);
+					}
+				}
+				return DecorationSet.empty;
+			} }
+		});
+		return {
+			plugins: [
+				columnResizing({
+					handleWidth: 5,
+					cellMinWidth: 25,
+					lastColumnResizable: true
+				}),
+				tableEditing(),
+				activeCellPlugin
+			],
+			keyboardShortcuts: {
+				Backspace: chainCommands(deleteTableIfSelected(), preventTableMergeAtGap()),
+				Delete: chainCommands(deleteTableIfSelected(), preventTableMergeAtGap())
+			},
+			commands: {
+				insertTable: (rows, cols) => insertTable(rows, cols),
+				addRowAbove: () => addRowAbove,
+				addRowBelow: () => addRowBelow,
+				deleteRow: () => deleteRow,
+				addColumnLeft: () => addColumnLeft,
+				addColumnRight: () => addColumnRight,
+				deleteColumn: () => deleteColumn,
+				deleteTable: () => deleteTable,
+				selectTable: () => selectTable,
+				selectRow: () => selectRow,
+				selectColumn: () => selectColumn,
+				mergeCells: () => mergeCells,
+				splitCell: () => splitCell,
+				setCellBorder: (side, spec, clearOthers) => setCellBorder(side, spec, clearOthers),
+				setTableBorders: (preset, borderSpec) => setTableBorders(preset, borderSpec),
+				setTableBorderPreset: (preset) => setTableBorderPreset(preset),
+				setCellVerticalAlign: (align) => setCellVerticalAlign(align),
+				setCellMargins: (margins) => setCellMargins(margins),
+				setCellTextDirection: (direction) => setCellTextDirection(direction),
+				toggleNoWrap: () => toggleNoWrap(),
+				setRowHeight: (height, rule) => setRowHeight(height, rule),
+				toggleHeaderRow: () => toggleHeaderRow(),
+				distributeColumns: () => distributeColumns(),
+				autoFitContents: () => autoFitContents(),
+				setTableProperties: (props) => setTableProperties(props),
+				applyTableStyle: (styleData) => applyTableStyle(styleData),
+				setCellFillColor: (color) => setCellFillColor(color),
+				setTableBorderColor: (color) => setTableBorderColor(color),
+				setTableBorderWidth: (size) => setTableBorderWidth(size),
+				removeTableBorders: () => setTableBorders("none"),
+				setAllTableBorders: (borderSpec) => setTableBorders("all", borderSpec),
+				setOutsideTableBorders: (borderSpec) => setTableBorders("outside", borderSpec),
+				setInsideTableBorders: (borderSpec) => setTableBorders("inside", borderSpec)
+			}
+		};
+	}
+});
+function createTableExtensions() {
+	return [
+		TableNodeExtension(),
+		TableRowExtension(),
+		TableCellExtension(),
+		TableHeaderExtension(),
+		TablePluginExtension()
+	];
+}
+//#endregion
+export { TableCellExtension, TableHeaderExtension, TableNodeExtension, TablePluginExtension, TableRowExtension, createTableExtensions, getTableContext, goToNextCell, goToPrevCell, isInTableCell as isInTable };