@stll/folio-core 0.54.0 → 0.54.2

package/dist/prosemirror/commands/tableCellMergeResolution.d.ts

@@ -5,17 +5,16 @@ import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/commands/tableCellMergeResolution.d.ts
 declare const tableCellContinuationPayload: (node: Node) => DecodedTableCellParagraphSourcePayload | null;
 declare const hasMatchingCollapsedTableCellMerge: (node: Node, revisionSet: Set<number> | null) => boolean;
-/**
- * Whether accepting a pending vertical merge folds the cell into the one above.
- * The saved `w:vMerge` continuation is read back as its own cell when it carries
- * content, so accepting such a merge keeps the cell standing; folding it would
- * hide text that reappears when the document is reopened.
- */
-declare const acceptedMergeFoldsIntoCellAbove: (cell: Node) => boolean;
-declare const resolveVisibleTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject") => boolean;
+type ResolveVisibleTableCellMergeOptions = {
+  tr: Transaction;
+  cellPos: number;
+  mode: "accept" | "reject";
+  revisionSet: ReadonlySet<number> | null;
+};
+declare const resolveVisibleTableCellMerge: ({ tr, cellPos, mode, revisionSet }: ResolveVisibleTableCellMergeOptions) => boolean;
 declare const tableCellContinuationCells: (cell: Node, rowspan: number) => document_d_exports.TableCell[];
 declare const tableCellContinuationFromNode: (cell: Node) => document_d_exports.TableCell;
 declare const resolveCollapsedTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject", revisionSet: Set<number> | null) => boolean;
 declare const createRestoredTableCell: (origin: Node, source: document_d_exports.TableCell) => Node | null;
 //#endregion
-export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };
+export { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

package/dist/prosemirror/commands/tableCellMergeResolution.js

@@ -1,9 +1,10 @@
 import { decodeTableCellParagraphSourcePayload, restoreTableCellsWithParagraphPropertySources, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
 import { isTableCellMergeRevisionContinuation } from "../../docx/tableParser.js";
 import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
-import { standaloneTableCellToProseMirror, tableCellHasMeaningfulContent } from "../conversion/toProseDoc.js";
+import { standaloneTableCellToProseMirror } from "../conversion/toProseDoc.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { removeRowsWithoutCellsInRange } from "../tableGridMutation.js";
+import { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions } from "./tableMergeFoldDecisions.js";
 import { Result, panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/commands/tableCellMergeResolution.ts
@@ -37,33 +38,35 @@ const tableCellContext = (doc, cellPos) => {
 	}
 	return null;
 };
-/**
-* Whether accepting a pending vertical merge folds the cell into the one above.
-* The saved `w:vMerge` continuation is read back as its own cell when it carries
-* content, so accepting such a merge keeps the cell standing; folding it would
-* hide text that reappears when the document is reopened.
-*/
-const acceptedMergeFoldsIntoCellAbove = (cell) => !tableCellHasMeaningfulContent(standaloneTableCellFromProseMirror(cell));
-const resolveVisibleTableCellMerge = (tr, cellPos, mode) => {
+const resolveVisibleTableCellMerge = ({ tr, cellPos, mode, revisionSet }) => {
 	const cell = tr.doc.nodeAt(cellPos);
 	const marker = cell?.attrs["cellMarker"];
 	if (!cell || !isTableCellMergeRevisionAttr(marker)) return false;
-	if (mode === "accept" ? isTableCellMergeRevisionContinuation(marker.verticalMerge) && acceptedMergeFoldsIntoCellAbove(cell) : isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal)) return mergeTableCellWithCellAbove(tr, cellPos);
-	if (mode === "accept") {
-		tr.setNodeAttribute(cellPos, "cellMarker", null);
-		return true;
-	}
-	const originalFormatting = cell.attrs["_originalFormatting"];
-	let nextOriginalFormatting = originalFormatting;
-	if (typeof originalFormatting === "object" && originalFormatting !== null) {
-		nextOriginalFormatting = { ...originalFormatting };
-		delete nextOriginalFormatting.vMerge;
-	}
-	tr.setNodeMarkup(cellPos, void 0, {
-		...cell.attrs,
-		cellMarker: null,
-		_originalFormatting: nextOriginalFormatting
+	const context = tableCellContext(tr.doc, cellPos);
+	if (!context) return false;
+	const rectangle = TableMap.get(context.table).findCell(context.relativeCellPos);
+	if (mode === "reject" && isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal) && rectangle.top === 0) return false;
+	const decisions = tableMergeFoldDecisions({
+		table: context.table,
+		mode,
+		revisionSet
 	});
+	if (decisions.invalid.has(context.relativeCellPos)) return false;
+	const folds = decisions.folds.get(context.relativeCellPos);
+	if (folds === void 0) return panic("Merge resolution lost its cell");
+	for (const origin of decisions.origins) {
+		if (origin === context.relativeCellPos) continue;
+		const originPos = context.tableStart + origin;
+		const originCell = tr.doc.nodeAt(originPos);
+		if (!originCell) return panic("Merge resolution lost its origin");
+		tr.setNodeMarkup(originPos, void 0, resolvedTableMergeOriginAttrs(originCell));
+	}
+	if (folds) return mergeTableCellWithCellAbove(tr, cellPos);
+	tr.setNodeMarkup(cellPos, void 0, resolvedVisibleTableCellMergeAttrs({
+		cell,
+		mode,
+		origin: decisions.origins.has(context.relativeCellPos)
+	}));
 	return true;
 };
 const mergeTableCellWithCellAbove = (tr, cellPos) => {
@@ -201,4 +204,4 @@ const createRestoredTableCell = (origin, source) => {
 	return Result.try(() => origin.type.schema.nodeFromJSON(restored.toJSON())).unwrapOr(null);
 };
 //#endregion
-export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };
+export { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

package/dist/prosemirror/commands/tableMergeFoldDecisions.d.ts

@@ -0,0 +1,61 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/commands/tableMergeFoldDecisions.d.ts
+type TableMergeFoldDecisionsOptions = {
+  table: Node;
+  mode: "accept" | "reject";
+  revisionSet: ReadonlySet<number> | null;
+};
+/** Resolve raw merge states without converting unrelated table revisions. */
+declare const tableMergeFoldDecisions: ({ table, mode, revisionSet }: TableMergeFoldDecisionsOptions) => {
+  folds: Map<number, boolean>;
+  origins: Set<number>;
+  invalid: Set<number>;
+};
+/** Persist an implicit merge origin even when reader rules retain its continuation. */
+declare const resolvedTableMergeOriginAttrs: (cell: Node) => {
+  _originalFormatting: {
+    vMerge: string;
+    width?: import("@stll/docx-core/model").TableMeasurement;
+    borders?: import("@stll/docx-core/model").TableCellBorders;
+    margins?: import("@stll/docx-core/model").CellMargins;
+    shading?: import("@stll/docx-core/model").ShadingProperties;
+    verticalAlign?: "top" | "center" | "bottom";
+    textDirection?: import("@stll/docx-core/model").TextDirection;
+    gridSpan?: number;
+    fitText?: boolean;
+    noWrap?: boolean;
+    hideMark?: boolean;
+    conditionalFormat?: import("@stll/docx-core/model").ConditionalFormatStyle;
+    preserved?: import("@stll/docx-core/model").PreservedMarkup;
+    sourceXml?: string;
+  };
+  _preserveVMergeRestart: boolean;
+};
+type ResolvedVisibleTableCellMergeOptions = {
+  cell: Node;
+  mode: "accept" | "reject";
+  origin: boolean;
+};
+/** A retained continuation must save the merge state the reviewer resolved. */
+declare const resolvedVisibleTableCellMergeAttrs: ({ cell, mode, origin }: ResolvedVisibleTableCellMergeOptions) => {
+  cellMarker: null;
+  _originalFormatting: {
+    width?: import("@stll/docx-core/model").TableMeasurement;
+    borders?: import("@stll/docx-core/model").TableCellBorders;
+    margins?: import("@stll/docx-core/model").CellMargins;
+    shading?: import("@stll/docx-core/model").ShadingProperties;
+    verticalAlign?: "top" | "center" | "bottom";
+    textDirection?: import("@stll/docx-core/model").TextDirection;
+    gridSpan?: number;
+    vMerge?: "restart" | "continue";
+    fitText?: boolean;
+    noWrap?: boolean;
+    hideMark?: boolean;
+    conditionalFormat?: import("@stll/docx-core/model").ConditionalFormatStyle;
+    preserved?: import("@stll/docx-core/model").PreservedMarkup;
+    sourceXml?: string;
+  };
+  _preserveVMergeRestart: boolean;
+};
+//#endregion
+export { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions };

package/dist/prosemirror/commands/tableMergeFoldDecisions.js

@@ -0,0 +1,79 @@
+import { isCellMergeContinuation, isCellMergeStart, isTableCellMergeRevisionContinuation } from "../../docx/tableParser.js";
+import { tableCellHasMeaningfulContent } from "../../docx/verticalMergeProjection.js";
+import { expectTableCellAttrs } from "../attrs/index.js";
+import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
+import { panic } from "better-result";
+import { TableMap } from "prosemirror-tables";
+//#region src/prosemirror/commands/tableMergeFoldDecisions.ts
+/** Resolve raw merge states without converting unrelated table revisions. */
+const tableMergeFoldDecisions = ({ table, mode, revisionSet }) => {
+	const decisions = /* @__PURE__ */ new Map();
+	const origins = /* @__PURE__ */ new Set();
+	const invalid = /* @__PURE__ */ new Set();
+	const map = TableMap.get(table);
+	const visited = /* @__PURE__ */ new Set();
+	for (const [index, position] of map.map.entries()) {
+		if (visited.has(position)) continue;
+		visited.add(position);
+		const cell = table.nodeAt(position);
+		if (cell?.attrs["cellMarker"]?.kind !== "merge") continue;
+		const marker = expectTableCellAttrs(cell).cellMarker;
+		if (marker?.kind !== "merge" || revisionSet !== null && !revisionSet.has(marker.info.revisionId)) continue;
+		const continues = isTableCellMergeRevisionContinuation(mode === "accept" ? marker.verticalMerge : marker.verticalMergeOriginal);
+		decisions.set(position, continues && (mode === "reject" || !tableCellHasMeaningfulContent(standaloneTableCellFromProseMirror(cell))));
+		if (!continues) continue;
+		if (Math.floor(index / map.width) === 0) {
+			invalid.add(position);
+			continue;
+		}
+		const abovePosition = map.map[index - map.width];
+		if (abovePosition === void 0) return panic("Merge resolution lost its origin");
+		const above = table.nodeAt(abovePosition);
+		if (!above) return panic("Merge resolution lost its origin");
+		const rectangle = map.findCell(position);
+		const aboveRectangle = map.findCell(abovePosition);
+		if (rectangle.left !== aboveRectangle.left || rectangle.right !== aboveRectangle.right || rectangle.top !== aboveRectangle.bottom) {
+			invalid.add(position);
+			continue;
+		}
+		const aboveMarker = expectTableCellAttrs(above).cellMarker;
+		const aboveContinues = aboveMarker?.kind === "merge" && (revisionSet === null || revisionSet.has(aboveMarker.info.revisionId)) && isTableCellMergeRevisionContinuation(mode === "accept" ? aboveMarker.verticalMerge : aboveMarker.verticalMergeOriginal);
+		const aboveModel = standaloneTableCellFromProseMirror(above);
+		if (mode === "accept" && (aboveContinues && decisions.get(abovePosition) === false || isCellMergeContinuation(aboveModel) && tableCellHasMeaningfulContent(aboveModel))) decisions.set(position, false);
+		if (aboveContinues || isCellMergeContinuation(aboveModel) || isCellMergeStart(aboveModel)) continue;
+		origins.add(abovePosition);
+	}
+	return {
+		folds: decisions,
+		origins,
+		invalid
+	};
+};
+/** Persist an implicit merge origin even when reader rules retain its continuation. */
+const resolvedTableMergeOriginAttrs = (cell) => ({
+	...cell.attrs,
+	_originalFormatting: {
+		...expectTableCellAttrs(cell)._originalFormatting,
+		vMerge: "restart"
+	},
+	_preserveVMergeRestart: true
+});
+/** A retained continuation must save the merge state the reviewer resolved. */
+const resolvedVisibleTableCellMergeAttrs = ({ cell, mode, origin }) => {
+	const attrs = expectTableCellAttrs(cell);
+	const marker = attrs.cellMarker;
+	if (marker?.kind !== "merge") return panic("Cell has no merge revision");
+	const continuation = mode === "accept" ? marker.verticalMerge : marker.verticalMergeOriginal;
+	const formatting = { ...attrs._originalFormatting };
+	if (origin) formatting.vMerge = "restart";
+	else if (isTableCellMergeRevisionContinuation(continuation)) formatting.vMerge = "continue";
+	else delete formatting.vMerge;
+	return {
+		...cell.attrs,
+		cellMarker: null,
+		_originalFormatting: formatting,
+		_preserveVMergeRestart: origin
+	};
+};
+//#endregion
+export { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions };

package/dist/prosemirror/commentIdAllocator.d.ts

@@ -3,30 +3,23 @@ import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/commentIdAllocator.d.ts
 /** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
 declare const PENDING_COMMENT_ID = -1;
+declare const CommentIdSpaceExhaustedError_base: import("better-result").TaggedErrorClass<"CommentIdSpaceExhaustedError">;
+declare class CommentIdSpaceExhaustedError extends CommentIdSpaceExhaustedError_base<{
+  message: string;
+}> {}
+/** Allocate a valid, unused comment ID in this realm. */
+declare function allocateCommentId(): number;
+/** Reserve a loaded ID and advance past it when the upper bound permits. */
+declare function seedCommentIdAbove(id: number): void;
 type CommentIdAllocator = {
-  /** Allocate the next ID and advance the counter. */
+  /** Allocate the next unused ID. */
   next(): number;
-  /**
-   * On document load, bump the counter above the highest ID found in the
-   * loaded comments and tracked-change marks so subsequent allocations don't
-   * collide with already-present IDs.
-   */
-  seedAbove(maxId: number): void;
+  /** Reserve a loaded ID and seed above it when possible. */
+  seedAbove(id: number): void;
 };
-/**
- * Create an instance-scoped monotonic comment/revision ID allocator. IDs are
- * never reused (deleting a comment does not free its ID), and the counter is
- * private to this allocator — multiple editors get independent ID spaces.
- */
+/** Every handle uses the same counter, including separate editor instances. */
 declare function createCommentIdAllocator(): CommentIdAllocator;
-/**
- * Seed an allocator above every comment/revision ID currently in the document
- * — comment objects (including replies, which carry no mark) plus
- * tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
- * counter, this is safe to call on load (React) or before each allocation
- * (Vue): new IDs never collide with or reuse an existing one, and the comment
- * and revision ID spaces stay unified.
- */
-declare function seedCommentAllocator(allocator: CommentIdAllocator, comments: Comment[] | undefined, view: EditorView | null): void;
+/** Seed from comments, replies, and the document's conservative annotation maximum. */
+declare function seedCommentAllocator(allocator: CommentIdAllocator, comments: Comment[] | undefined, view: Pick<EditorView, "state"> | null): void;
 //#endregion
-export { CommentIdAllocator, PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };
+export { CommentIdAllocator, CommentIdSpaceExhaustedError, PENDING_COMMENT_ID, allocateCommentId, createCommentIdAllocator, seedCommentAllocator, seedCommentIdAbove };

package/dist/prosemirror/commentIdAllocator.js

@@ -1,40 +1,65 @@
 import { maxAnnotationIdInDoc, seedRevisionIdsAbove } from "./plugins/revisionIds.js";
+import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
+import { TaggedError } from "better-result";
 import { MAX_REVISION_ID } from "@stll/docx-core/model";
 //#region src/prosemirror/commentIdAllocator.ts
-/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
-const PENDING_COMMENT_ID = -1;
 /**
-* Create an instance-scoped monotonic comment/revision ID allocator. IDs are
-* never reused (deleting a comment does not free its ID), and the counter is
-* private to this allocator — multiple editors get independent ID spaces.
+* Realm-wide comment ID allocation, shared by live editors and headless reviewers.
+* Loaded and issued IDs stay reserved even when a comment is deleted.
 */
+/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
+const PENDING_COMMENT_ID = -1;
+var CommentIdSpaceExhaustedError = class extends TaggedError("CommentIdSpaceExhaustedError") {};
+let nextId = 1;
+const reservedIds = /* @__PURE__ */ new Set();
+/** Allocate a valid, unused comment ID in this realm. */
+function allocateCommentId() {
+	if (reservedIds.size >= MAX_REVISION_ID) throw new CommentIdSpaceExhaustedError({ message: "The OOXML comment ID space is exhausted." });
+	while (reservedIds.has(nextId)) nextId = nextId === MAX_REVISION_ID ? 1 : nextId + 1;
+	const id = nextId;
+	reservedIds.add(id);
+	nextId = id === MAX_REVISION_ID ? 1 : id + 1;
+	return id;
+}
+/** Reserve a loaded ID and advance past it when the upper bound permits. */
+function seedCommentIdAbove(id) {
+	if (!Number.isInteger(id) || id < 0 || id > MAX_REVISION_ID) return;
+	if (id > 0) reservedIds.add(id);
+	if (id >= nextId) nextId = id === MAX_REVISION_ID ? 1 : id + 1;
+}
+/** Every handle uses the same counter, including separate editor instances. */
 function createCommentIdAllocator() {
-	let nextId = 1;
 	return {
-		next: () => {
-			if (nextId > MAX_REVISION_ID) nextId = 1;
-			return nextId++;
-		},
-		seedAbove(maxId) {
-			if (!Number.isInteger(maxId) || maxId < 0 || maxId >= MAX_REVISION_ID) return;
-			if (maxId >= nextId) nextId = maxId + 1;
-		}
+		next: allocateCommentId,
+		seedAbove: seedCommentIdAbove
 	};
 }
-/**
-* Seed an allocator above every comment/revision ID currently in the document
-* — comment objects (including replies, which carry no mark) plus
-* tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
-* counter, this is safe to call on load (React) or before each allocation
-* (Vue): new IDs never collide with or reuse an existing one, and the comment
-* and revision ID spaces stay unified.
-*/
+/** Seed from comments, replies, and the document's conservative annotation maximum. */
 function seedCommentAllocator(allocator, comments, view) {
 	let max = 0;
-	for (const comment of comments ?? []) if (Number.isInteger(comment.id) && comment.id > max && comment.id <= MAX_REVISION_ID) max = comment.id;
-	if (view) max = Math.max(max, maxAnnotationIdInDoc(view.state.doc));
+	for (const comment of comments ?? []) {
+		allocator.seedAbove(comment.id);
+		if (Number.isInteger(comment.id) && comment.id > max && comment.id <= MAX_REVISION_ID) max = comment.id;
+	}
+	if (view) {
+		view.state.doc.descendants((node) => {
+			for (const mark of node.marks) {
+				const id = mark.attrs["commentId"];
+				if (typeof id === "number") allocator.seedAbove(id);
+			}
+			if (node.type.name === "commentReference") {
+				const id = node.attrs["commentId"];
+				if (typeof id === "number") allocator.seedAbove(id);
+			}
+			if (node.type.name === "rangeAnchor") {
+				const attrs = readRangeAnchorAttrs(node);
+				if (attrs.ok && attrs.value.start.type === "commentRangeStart") allocator.seedAbove(attrs.value.start.id);
+			}
+		});
+		max = Math.max(max, maxAnnotationIdInDoc(view.state.doc));
+	}
 	allocator.seedAbove(max);
 	seedRevisionIdsAbove(max);
 }
 //#endregion
-export { PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };
+export { CommentIdSpaceExhaustedError, PENDING_COMMENT_ID, allocateCommentId, createCommentIdAllocator, seedCommentAllocator, seedCommentIdAbove };

package/dist/prosemirror/conversion/toProseDoc.d.ts

@@ -23,11 +23,6 @@ type ToProseDocOptions = {
  * @param options - Conversion options including style definitions
  */
 declare function toProseDoc(document: document_d_exports.Document, options?: ToProseDocOptions): Node;
-/**
- * Whether a cell carries content a vertical-merge continuation must not hide.
- * The reader keeps such a continuation as a cell of its own.
- */
-declare function tableCellHasMeaningfulContent(cell: document_d_exports.TableCell): boolean;
 declare function standaloneTableCellToProseMirror(cell: document_d_exports.TableCell, nodeType: "tableCell" | "tableHeader"): Node;
 /**
  * Convert HeaderFooter content (array of Paragraph/Table blocks) to a ProseMirror document.
@@ -44,4 +39,4 @@ declare function footnoteToProseDoc(content: document_d_exports.BlockContent[],
  */
 declare function createEmptyDoc(): Node;
 //#endregion
-export { ToProseDocOptions, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, tableCellHasMeaningfulContent, toProseDoc };
+export { ToProseDocOptions, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, toProseDoc };

package/dist/prosemirror/conversion/toProseDoc.js

@@ -6,6 +6,7 @@ import { isBaselineVertAlign } from "../../docx/runParser.js";
 import { replayableShapeAlternateContent } from "../../docx/shapeAlternateContent.js";
 import { resolveTableLook } from "../../docx/tableLook.js";
 import { isCellMergeContinuation } from "../../docx/tableParser.js";
+import { calculateRowSpans } from "../../docx/verticalMergeProjection.js";
 import { copiedWrapPolygon } from "../../docx/wrapPolygon.js";
 import { buildPageBreakRunSourceDescendantIndex } from "../../internal/pageBreakRunSourceDescendantIndex.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
@@ -893,122 +894,6 @@ function resolveTextFormatting(formatting, styleResolver) {
 	if (!styleResolver) return formatting;
 	return mergeTextFormatting(styleResolver.resolveRunStyle(formatting.styleId), formatting);
 }
-function calculateRowSpans(table) {
-	const result = /* @__PURE__ */ new Map();
-	const numRows = table.rows.length;
-	const activeMerges = /* @__PURE__ */ new Map();
-	for (let rowIndex = 0; rowIndex < numRows; rowIndex++) {
-		const row = table.rows[rowIndex];
-		if (row.cells.length === 0) {
-			clearActiveVerticalMerges(activeMerges, result);
-			continue;
-		}
-		let colIndex = row.formatting?.gridBefore ?? 0;
-		const rowCells = row.cells.map((cell) => {
-			const colspan = cell.formatting?.gridSpan ?? 1;
-			const vMerge = cell.formatting?.vMerge;
-			const isMergeContinuation = isCellMergeContinuation(cell);
-			const startRow = isMergeContinuation ? activeMerges.get(colIndex) : void 0;
-			const info = {
-				cell,
-				colIndex,
-				colspan,
-				vMerge,
-				isMergeContinuation,
-				startRow,
-				hasMeaningfulContent: tableCellHasMeaningfulContent(cell),
-				shouldSkip: isMergeContinuation && startRow !== void 0
-			};
-			colIndex += colspan;
-			return info;
-		});
-		const rowWouldBeEmpty = rowCells.length > 0 && rowCells.every((cell) => cell.shouldSkip);
-		for (const cellInfo of rowCells) {
-			const { colIndex: cellColIndex, vMerge, isMergeContinuation, startRow, hasMeaningfulContent } = cellInfo;
-			const key = `${rowIndex}-${cellColIndex}`;
-			if (vMerge === "restart") {
-				closeVerticalMerge(activeMerges, result, cellColIndex);
-				activeMerges.set(cellColIndex, rowIndex);
-				result.set(key, {
-					rowSpan: 1,
-					skip: false
-				});
-			} else if (isMergeContinuation) {
-				if (startRow === void 0 || rowWouldBeEmpty || hasMeaningfulContent) {
-					result.set(key, {
-						rowSpan: 1,
-						skip: false
-					});
-					if ((rowWouldBeEmpty || hasMeaningfulContent) && startRow !== void 0) {
-						const restartCell = result.get(`${startRow}-${cellColIndex}`);
-						if (restartCell) restartCell.preserveVMergeRestart = true;
-						activeMerges.delete(cellColIndex);
-					}
-					continue;
-				}
-				const startKey = `${startRow}-${cellColIndex}`;
-				const startCell = result.get(startKey);
-				if (startCell) {
-					startCell.rowSpan++;
-					startCell.continuationCells ??= [];
-					startCell.continuationCells.push(cellInfo.cell);
-				}
-				result.set(key, {
-					rowSpan: 1,
-					skip: true
-				});
-			} else {
-				closeVerticalMerge(activeMerges, result, cellColIndex);
-				result.set(key, {
-					rowSpan: 1,
-					skip: false
-				});
-			}
-		}
-	}
-	clearActiveVerticalMerges(activeMerges, result);
-	return result;
-}
-/**
-* End the vertical merge active in one column.
-*
-* A `w:vMerge="restart"` is carried through the editor by its cell's rowspan,
-* which only exists once a continuation joins it. A merge that closes with a
-* rowspan of 1 — a restart with no continuation, one interrupted by a plain
-* cell, one whose continuation is in a row a revision removed — has nothing
-* but this flag to say the cell was a merge origin, and dropping it changes
-* the table's visible structure.
-*/
-function closeVerticalMerge(activeMerges, result, colIndex) {
-	const startRow = activeMerges.get(colIndex);
-	if (startRow === void 0) return;
-	const restartCell = result.get(`${startRow}-${colIndex}`);
-	if (restartCell && restartCell.rowSpan === 1) restartCell.preserveVMergeRestart = true;
-	activeMerges.delete(colIndex);
-}
-function clearActiveVerticalMerges(activeMerges, result) {
-	for (const colIndex of [...activeMerges.keys()]) closeVerticalMerge(activeMerges, result, colIndex);
-}
-/**
-* Whether a cell carries content a vertical-merge continuation must not hide.
-* The reader keeps such a continuation as a cell of its own.
-*/
-function tableCellHasMeaningfulContent(cell) {
-	return cell.content.some(blockHasMeaningfulContent);
-}
-function blockHasMeaningfulContent(block) {
-	if (block.type === "preservedBlock") return true;
-	if (block.type === "bookmarkStart" || block.type === "bookmarkEnd") return true;
-	if (block.type === "table") return block.rows.some((row) => row.cells.some((cell) => tableCellHasMeaningfulContent(cell)));
-	if (block.type === "blockSdt" || block.type === "blockCustomXml") return true;
-	return block.content.some(paragraphContentHasMeaningfulContent);
-}
-function paragraphContentHasMeaningfulContent(content) {
-	if (content.type === "run") return content.content.length > 0;
-	if (content.type === "hyperlink") return content.children.some(paragraphContentHasMeaningfulContent);
-	if (content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") return content.content.some(paragraphContentHasMeaningfulContent);
-	return true;
-}
 function convertTable(table, styleResolver, context) {
 	for (const row of table.rows) for (const cell of row.cells) {
 		if (isCellMergeContinuation(cell) && context.pageBreakRunSourceDescendants.containsPageBreakRun(cell.content)) {
@@ -2840,4 +2725,4 @@ function createEmptyDoc() {
 	return schema.node("doc", null, [schema.node("paragraph", {}, [])]);
 }
 //#endregion
-export { createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, tableCellHasMeaningfulContent, toProseDoc };
+export { createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, toProseDoc };

package/dist/prosemirror/extensions/core/HistoryExtension.js

@@ -1,5 +1,97 @@
 import { createExtension } from "../create.js";
-import { history, redo, undo } from "prosemirror-history";
+import { Plugin } from "prosemirror-state";
+import { closeHistory, history, isHistoryTransaction, redo, undo } from "prosemirror-history";
+//#region src/prosemirror/extensions/core/HistoryExtension.ts
+/**
+* History Extension — undo/redo via prosemirror-history
+*/
+/**
+* History adjacency is based on step maps, which differ for physical deletions
+* and suggestion marks. Group continuous typing and same-direction deletions explicitly; each
+* structural edit, paste, drop, or composition starts its own undo event.
+* Capture DOM input before the shared input router or a keymap handles it.
+*/
+const inputBoundaryPlugin = (newGroupDelay) => {
+	let previousKind;
+	let deletionGroup = 0;
+	let previousInputTime = 0;
+	let pendingDeletionGroup = null;
+	return new Plugin({
+		filterTransaction(tr) {
+			const pendingGroup = pendingDeletionGroup;
+			pendingDeletionGroup = null;
+			if (isHistoryTransaction(tr) || !tr.docChanged && tr.selectionSet) {
+				previousKind = void 0;
+				return true;
+			}
+			if (tr.docChanged && (previousKind === "deleteBackward" || previousKind === "deleteForward" || previousKind === "deletion")) {
+				if (pendingGroup !== null) tr.setMeta("composition", pendingGroup);
+				else if (!tr.getMeta("appendedTransaction")) previousKind = void 0;
+			}
+			return true;
+		},
+		view(view) {
+			const startInput = (kind) => {
+				const now = Date.now();
+				if (kind !== previousKind || kind === "structure" || kind === "paste" || kind === "drop" || now - previousInputTime > newGroupDelay) {
+					deletionGroup--;
+					view.dispatch(closeHistory(view.state.tr));
+				}
+				previousInputTime = now;
+				previousKind = kind;
+				pendingDeletionGroup = kind === "deleteBackward" || kind === "deleteForward" || kind === "deletion" ? deletionGroup : null;
+			};
+			const keydown = (event) => {
+				if (event.isComposing) return;
+				if (event.key === "Backspace" || event.key === "Delete") {
+					startInput(event.key === "Backspace" ? "deleteBackward" : "deleteForward");
+					return;
+				}
+				if (event.key === "Enter") {
+					startInput("structure");
+					return;
+				}
+				if (event.key.length === 1 && !event.metaKey && !event.ctrlKey) startInput("typing");
+			};
+			const beforeinput = (event) => {
+				if (event.inputType === "insertCompositionText" || event.isComposing) {
+					startInput("composition");
+					return;
+				}
+				if (event.inputType === "insertText" || event.inputType === "insertReplacementText") {
+					startInput("typing");
+					return;
+				}
+				if (event.inputType.startsWith("delete")) if (event.inputType.endsWith("Backward")) startInput("deleteBackward");
+				else if (event.inputType.endsWith("Forward")) startInput("deleteForward");
+				else startInput("deletion");
+				else if (event.inputType === "insertParagraph" || event.inputType === "insertLineBreak") startInput("structure");
+			};
+			const paste = () => startInput("paste");
+			const drop = () => startInput("drop");
+			const compositionstart = () => {
+				view.dispatch(closeHistory(view.state.tr));
+				previousKind = "composition";
+			};
+			view.dom.addEventListener("keydown", keydown, true);
+			view.dom.addEventListener("beforeinput", beforeinput, true);
+			view.dom.addEventListener("paste", paste, true);
+			view.dom.addEventListener("drop", drop, true);
+			view.dom.addEventListener("compositionstart", compositionstart, true);
+			return { destroy() {
+				view.dom.removeEventListener("keydown", keydown, true);
+				view.dom.removeEventListener("beforeinput", beforeinput, true);
+				view.dom.removeEventListener("paste", paste, true);
+				view.dom.removeEventListener("drop", drop, true);
+				view.dom.removeEventListener("compositionstart", compositionstart, true);
+			} };
+		}
+	});
+};
+const consumeHistoryShortcut = (command) => (state, dispatch, view) => {
+	command(state, dispatch, view);
+	return true;
+};
 const HistoryExtension = createExtension({
 	name: "history",
 	defaultOptions: {
@@ -12,15 +104,15 @@ const HistoryExtension = createExtension({
 			plugins: [history({
 				depth: options.depth,
 				newGroupDelay: options.newGroupDelay
-			})],
+			}), inputBoundaryPlugin(options.newGroupDelay)],
 			commands: {
 				undo: () => undo,
 				redo: () => redo
 			},
 			...options.shortcuts === "editor" && { keyboardShortcuts: {
-				"Mod-z": undo,
-				"Mod-y": redo,
-				"Mod-Shift-z": redo
+				"Mod-z": consumeHistoryShortcut(undo),
+				"Mod-y": consumeHistoryShortcut(redo),
+				"Mod-Shift-z": consumeHistoryShortcut(redo)
 			} }
 		};
 	}