@stll/folio-core 0.54.0 → 0.54.2

package/dist/docx/unzip.js

@@ -2,6 +2,7 @@ import { bytesToDataUrl } from "../utils/base64.js";
 import { compressionRatioLimitFor, countCentralDirectoryRecords, createInflationBudget, exceedsCompressionRatio, getZipEntrySizes, inflateEntryWithinLimits, isStoredZipEntry } from "./archiveInflation.js";
 import { DOCX_CONTAINER_TYPES, detectDocxContainerType } from "./encryption/containerFormat.js";
 import { openDocxBuffer } from "./encryption/openEncryptedDocx.js";
+import { RASTER_MIME_TYPES, detectRasterMimeType } from "./rasterMime.js";
 import { decodeXmlBytes } from "./xmlEncoding.js";
 import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "./xmlResourceLimits.js";
 import JSZip from "jszip";
@@ -38,12 +39,7 @@ var DocxSecurityError = class extends Error {
 	}
 };
 const DEFAULT_ALLOWED_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/bmp",
-	"image/tiff",
-	"image/webp",
+	...RASTER_MIME_TYPES,
 	"image/x-emf",
 	"image/x-wmf"
 ]);
@@ -227,11 +223,12 @@ async function unzipDocx(buffer, options = {}, { verifyUnreadEntries = true } =
 					return null;
 				}
 				const binaryContent = result.bytes.buffer;
-				if (!isMediaContentAllowed(binaryContent, mimeType)) return null;
+				const effectiveMimeType = RASTER_MIME_TYPES.has(mimeType) ? detectRasterMimeType(binaryContent) : mimeType;
+				if (!effectiveMimeType || !limits.allowedMediaMimeTypes.has(effectiveMimeType) || !isMediaContentAllowed(binaryContent, effectiveMimeType)) return null;
 				return {
 					type: "media",
 					path,
-					mimeType,
+					mimeType: effectiveMimeType,
 					content: binaryContent
 				};
 			});
@@ -274,6 +271,26 @@ async function unzipDocx(buffer, options = {}, { verifyUnreadEntries = true } =
 	}
 	return content;
 }
+/** Keep extracted projections and the source ZIP aligned after parser normalization. */
+const replaceRawDocxXmlParts = async (content, parts) => {
+	let identitiesChanged = false;
+	for (const [path, xmlContent] of parts) {
+		if (content.allXml.get(path) === xmlContent) continue;
+		indexXmlContent(content, {
+			type: "xml",
+			path,
+			lowerPath: path.toLowerCase(),
+			content: xmlContent
+		});
+		content.originalZip.file(path, xmlContent);
+		identitiesChanged = true;
+	}
+	if (identitiesChanged) content.originalBuffer = await content.originalZip.generateAsync({
+		type: "arraybuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 1 }
+	});
+};
 /**
 * Preflight every XML part the unzip retains, not a named few.
 *
@@ -291,6 +308,14 @@ function assignXmlContent(content, { path, lowerPath, content: xmlContent }, lim
 		partPath: path,
 		budget
 	});
+	indexXmlContent(content, {
+		type: "xml",
+		path,
+		lowerPath,
+		content: xmlContent
+	});
+}
+const indexXmlContent = (content, { path, lowerPath, content: xmlContent }) => {
 	content.allXml.set(path, xmlContent);
 	if (lowerPath === "word/document.xml") content.documentXml = xmlContent;
 	else if (lowerPath === "word/styles.xml") content.stylesXml = xmlContent;
@@ -317,7 +342,7 @@ function assignXmlContent(content, { path, lowerPath, content: xmlContent }, lim
 		const filename = path.split("/").pop() || path;
 		content.footers.set(filename, xmlContent);
 	}
-}
+};
 function inflationLimitError(limit, path) {
 	switch (limit) {
 		case "declared-size": return new DocxSecurityError(`DOCX entry inflates past its declared size: ${path}`);
@@ -499,14 +524,9 @@ function isEntryTooLarge(declaredSize, maxBytes) {
 	return declaredSize !== null && declaredSize > maxBytes;
 }
 function isMediaContentAllowed(data, mimeType) {
+	if (RASTER_MIME_TYPES.has(mimeType)) return detectRasterMimeType(data) === mimeType;
 	const bytes = new Uint8Array(data);
 	switch (mimeType) {
-		case "image/png": return bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
-		case "image/jpeg": return bytes[0] === 255 && bytes[1] === 216;
-		case "image/gif": return bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56;
-		case "image/bmp": return bytes[0] === 66 && bytes[1] === 77;
-		case "image/webp": return bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80;
-		case "image/tiff": return bytes[0] === 73 && bytes[1] === 73 || bytes[0] === 77 && bytes[1] === 77;
 		case "image/x-emf":
 		case "image/emf": return bytes.length >= 44 && bytes[0] === 1 && bytes[40] === 32 && bytes[41] === 69 && bytes[42] === 77 && bytes[43] === 70;
 		case "image/x-wmf":
@@ -605,4 +625,4 @@ function getContentSummary(content) {
 	};
 }
 //#endregion
-export { DocxSecurityError, extractFile, getContentSummary, getEntryUncompressedSize, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, unzipDocx };
+export { DocxSecurityError, extractFile, getContentSummary, getEntryUncompressedSize, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, replaceRawDocxXmlParts, unzipDocx };

package/dist/docx/verticalMergeProjection.d.ts

@@ -0,0 +1,17 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/verticalMergeProjection.d.ts
+/** The reader and revision resolver share which continuation cells remain visible. */
+type RowSpanInfo = {
+  rowSpan: number;
+  skip: boolean;
+  preserveVMergeRestart?: boolean;
+  continuationCells?: document_d_exports.TableCell[];
+};
+declare function calculateRowSpans(table: document_d_exports.Table): Map<string, RowSpanInfo>;
+/**
+ * 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;
+//#endregion
+export { RowSpanInfo, calculateRowSpans, tableCellHasMeaningfulContent };

package/dist/docx/verticalMergeProjection.js

@@ -0,0 +1,120 @@
+import { isCellMergeContinuation } from "./tableParser.js";
+//#region src/docx/verticalMergeProjection.ts
+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;
+}
+//#endregion
+export { calculateRowSpans, tableCellHasMeaningfulContent };

package/dist/layout-bridge/convert/fixedTableColumnWidths.d.ts

@@ -0,0 +1,6 @@
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/fixedTableColumnWidths.d.ts
+/** Resolve absolute cell preferences for an unbounded fixed-layout grid (§17.4.53). */
+declare const fixedTableColumnWidths: (table: Node, grid: readonly number[]) => readonly number[];
+//#endregion
+export { fixedTableColumnWidths };

package/dist/layout-bridge/convert/fixedTableColumnWidths.js

@@ -0,0 +1,23 @@
+import { expectTableCellAttrs, expectTableRowAttrs } from "../../prosemirror/attrs/index.js";
+//#region src/layout-bridge/convert/fixedTableColumnWidths.ts
+/** Resolve absolute cell preferences for an unbounded fixed-layout grid (§17.4.53). */
+const fixedTableColumnWidths = (table, grid) => {
+	const preferred = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
+		const row = table.child(rowIndex);
+		const rowAttrs = expectTableRowAttrs(row);
+		if (rowAttrs.trIns || rowAttrs.trDel || rowAttrs.hidden) return grid;
+		let column = Math.max(0, rowAttrs._originalFormatting?.gridBefore ?? 0);
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
+			const attrs = expectTableCellAttrs(row.child(cellIndex));
+			if (attrs._omittedGridSlot) continue;
+			const width = attrs._authoredWidth;
+			if (attrs.colspan !== 1 || attrs.rowspan !== 1 || attrs._preserveVMergeRestart || attrs._originalFormatting?.vMerge !== void 0 || !width || width.type !== "dxa" || !Number.isFinite(width.value) || width.value <= 0) return grid;
+			if (column < grid.length) preferred.set(column, Math.max(preferred.get(column) ?? 0, width.value));
+			column++;
+		}
+	}
+	return grid.map((width, column) => preferred.get(column) ?? width);
+};
+//#endregion
+export { fixedTableColumnWidths };

package/dist/layout-bridge/convert/tableConversion.js

@@ -3,6 +3,7 @@ import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
 import { expectParagraphAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs } from "../../prosemirror/attrs/index.js";
 import { textBoxHostParagraph } from "../../prosemirror/textBoxHostParagraph.js";
 import { normalizeShapeTextAnchor } from "../../types/documentEnumValues.js";
+import { fixedTableColumnWidths } from "./fixedTableColumnWidths.js";
 import { convertBorderSpecToLayout } from "./flowBorders.js";
 import { nextBlockId, twipsToPixels } from "./flowConversionShared.js";
 import { countPageBreakRuns, hasSingleLeadingProjectedPageBreak } from "./pageBreakSplitting.js";
@@ -183,7 +184,9 @@ function convertTable(node, startPos, options) {
 		if (child.type.name === "tableRow") rows.push(convertTableRow(child, offset, options, rowContext));
 		offset += child.nodeSize;
 	});
-	let columnWidths = attrs.columnWidths?.map(twipsToPixels);
+	const columnWidthsTwips = attrs.columnWidths;
+	const hasTableWidth = (attrs.widthType === "dxa" || attrs.widthType === "pct") && (attrs.width ?? 0) > 0;
+	let columnWidths = (columnWidthsTwips && attrs._originalFormatting?.layout === "fixed" && !hasTableWidth ? fixedTableColumnWidths(node, columnWidthsTwips) : columnWidthsTwips)?.map(twipsToPixels);
 	const width = attrs.width;
 	const widthType = attrs.widthType;
 	if (!columnWidths && rows.length > 0) {

package/dist/layout-painter/index.js

@@ -1,4 +1,4 @@
-import { prefersReducedMotionBehavior } from "../paged-layout/scrollNavigation.js";
+import { scrollEditorElementIntoView } from "../paged-layout/editorScrollRoot.js";
 import { createDefaultRegistry } from "./registry/modules.js";
 import { createFeatureRegistry } from "./registry/registry.js";
 import { FRAGMENT_CLASS_NAMES, renderFragment } from "./renderFragment.js";
@@ -167,10 +167,7 @@ var LayoutPainter = class {
 	*/
 	scrollToPage(pageNumber) {
 		const state = this.pageStates.find((s) => s.pageNumber === pageNumber);
-		if (state?.element) state.element.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "start"
-		});
+		if (state?.element) scrollEditorElementIntoView(state.element, { block: "start" });
 	}
 };
 /**

package/dist/paged-layout/editorScrollRoot.d.ts

@@ -0,0 +1,15 @@
+//#region src/paged-layout/editorScrollRoot.d.ts
+declare const getEditorScrollRoot: (element: HTMLElement | null) => HTMLElement | null;
+/** Resolve the root even when a caller holds a painted descendant or viewport. */
+declare const scrollEditorTo: (element: HTMLElement | null, options: ScrollToOptions) => void;
+declare const scrollEditorBy: (element: HTMLElement | null, delta: number) => void;
+type ScrollEditorElementOptions = {
+  block?: "start" | "center" | "end" | "nearest";
+  behavior?: ScrollBehavior;
+  /** Space to leave between the target and the visible root edge. */
+  margin?: number;
+};
+/** Scroll only the marked root, including when the target is inside a scaled viewport. */
+declare const scrollEditorElementIntoView: (element: HTMLElement | null, { block, behavior, margin }?: ScrollEditorElementOptions) => void;
+//#endregion
+export { getEditorScrollRoot, scrollEditorBy, scrollEditorElementIntoView, scrollEditorTo };

package/dist/paged-layout/editorScrollRoot.js

@@ -0,0 +1,72 @@
+import { prefersReducedMotionBehavior } from "./scrollNavigation.js";
+//#region src/paged-layout/editorScrollRoot.ts
+/** The marked editor owns scrolling; navigation must never move host ancestors. */
+const EDITOR_SCROLL_ROOT_SELECTOR = "[data-folio-scroll]";
+const getEditorScrollRoot = (element) => element?.closest(EDITOR_SCROLL_ROOT_SELECTOR) ?? null;
+/** Resolve the root even when a caller holds a painted descendant or viewport. */
+const scrollEditorTo = (element, options) => {
+	getEditorScrollRoot(element)?.scrollTo(options);
+};
+const scrollEditorBy = (element, delta) => {
+	const root = getEditorScrollRoot(element);
+	if (root) scrollEditorTo(root, {
+		top: root.scrollTop + delta,
+		behavior: "instant"
+	});
+};
+const nearestScrollOffset = ({ targetStart, targetEnd, viewportStart, viewportEnd }) => {
+	const above = targetStart < viewportStart;
+	const below = targetEnd > viewportEnd;
+	if (above && below) return 0;
+	const targetSize = targetEnd - targetStart;
+	const viewportSize = viewportEnd - viewportStart;
+	if (above && targetSize <= viewportSize || below && targetSize > viewportSize) return targetStart - viewportStart;
+	if (below && targetSize <= viewportSize || above && targetSize > viewportSize) return targetEnd - viewportEnd;
+	return 0;
+};
+/** Scroll only the marked root, including when the target is inside a scaled viewport. */
+const scrollEditorElementIntoView = (element, { block = "center", behavior = prefersReducedMotionBehavior(), margin = 0 } = {}) => {
+	const root = getEditorScrollRoot(element);
+	if (!root || !element) return;
+	const targetRect = element.getBoundingClientRect();
+	const rootRect = root.getBoundingClientRect();
+	const visibleTop = rootRect.top + root.clientTop;
+	const targetTop = targetRect.top - visibleTop + root.scrollTop;
+	const targetBottom = targetRect.bottom - visibleTop + root.scrollTop;
+	let top;
+	switch (block) {
+		case "start":
+			top = targetTop - margin;
+			break;
+		case "center":
+			top = targetTop - (root.clientHeight - targetRect.height) / 2;
+			break;
+		case "end":
+			top = targetBottom - root.clientHeight + margin;
+			break;
+		case "nearest":
+			top = root.scrollTop + nearestScrollOffset({
+				targetStart: targetTop,
+				targetEnd: targetBottom,
+				viewportStart: root.scrollTop + margin,
+				viewportEnd: root.scrollTop + root.clientHeight - margin
+			});
+			break;
+		default: return block;
+	}
+	const visibleLeft = rootRect.left + root.clientLeft;
+	const left = root.scrollLeft + nearestScrollOffset({
+		targetStart: targetRect.left,
+		targetEnd: targetRect.right,
+		viewportStart: visibleLeft,
+		viewportEnd: visibleLeft + root.clientWidth
+	});
+	if (top === root.scrollTop && left === root.scrollLeft) return;
+	scrollEditorTo(root, {
+		top: Math.max(0, top),
+		left: Math.max(0, left),
+		behavior
+	});
+};
+//#endregion
+export { getEditorScrollRoot, scrollEditorBy, scrollEditorElementIntoView, scrollEditorTo };

package/dist/paged-layout/scrollToPmPosition.js

@@ -1,6 +1,7 @@
 import { findBodyPmAnchor, findBodyPmAnchors } from "../layout-bridge/dom/findBodyPmSpans.js";
 import { findPageShellForPmPos } from "../layout-painter/renderPage.js";
-import { isValidPmScrollPosition, prefersReducedMotionBehavior } from "./scrollNavigation.js";
+import { getEditorScrollRoot, scrollEditorElementIntoView } from "./editorScrollRoot.js";
+import { isValidPmScrollPosition } from "./scrollNavigation.js";
 //#region src/paged-layout/scrollToPmPosition.ts
 /** Class on the pages container `PagedEditor` paints into. */
 const PAGES_CONTAINER_CLASS = "paged-editor__pages";
@@ -9,10 +10,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 	if (!isValidPmScrollPosition(pmPos)) return;
 	const exact = findBodyPmAnchor(pageContainer, pmPos);
 	if (exact) {
-		exact.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "center"
-		});
+		scrollEditorElementIntoView(exact);
 		return;
 	}
 	let runMatch = null;
@@ -27,28 +25,19 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 		}
 	}
 	if (runMatch) {
-		runMatch.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "center"
-		});
+		scrollEditorElementIntoView(runMatch);
 		return;
 	}
 	const shellHit = findPageShellForPmPos(pageContainer, pmPos);
 	if (!shellHit) return;
 	const { element: shell } = shellHit;
-	shell.scrollIntoView({
-		behavior: prefersReducedMotionBehavior(),
-		block: "center"
-	});
+	scrollEditorElementIntoView(shell);
 	let attempts = 0;
 	const refine = () => {
 		attempts++;
 		const exactInShell = findBodyPmAnchor(shell, pmPos);
 		if (exactInShell) {
-			exactInShell.scrollIntoView({
-				behavior: prefersReducedMotionBehavior(),
-				block: "center"
-			});
+			scrollEditorElementIntoView(exactInShell);
 			return;
 		}
 		let bestEl = null;
@@ -68,10 +57,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 			}
 		}
 		if (bestEl) {
-			bestEl.scrollIntoView({
-				behavior: prefersReducedMotionBehavior(),
-				block: "center"
-			});
+			scrollEditorElementIntoView(bestEl);
 			return;
 		}
 		if (attempts < 20) requestAnimationFrame(refine);
@@ -86,7 +72,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 * callers can fall back to coordinate-based scrolling.
 */
 const scrollFolioPositionIntoView = (view, pmPos) => {
-	const pageContainer = view.dom.closest("[data-folio-scroll]")?.querySelector(`.paged-editor__pages`) ?? null;
+	const pageContainer = getEditorScrollRoot(view.dom)?.querySelector(`.paged-editor__pages`) ?? null;
 	if (!pageContainer) return false;
 	scrollPagesToPmPosition(pageContainer, pmPos);
 	return true;

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

@@ -0,0 +1,6 @@
+import { Command } from "prosemirror-state";
+//#region src/prosemirror/commands/clearParagraphIndent.d.ts
+/** Clear indentation at paragraph start before Backspace joins paragraphs. */
+declare const clearIndentOnBackspace: Command;
+//#endregion
+export { clearIndentOnBackspace };

package/dist/prosemirror/commands/clearParagraphIndent.js

@@ -0,0 +1,25 @@
+import { expectParagraphAttrs } from "../attrs/index.js";
+import { TextSelection } from "prosemirror-state";
+//#region src/prosemirror/commands/clearParagraphIndent.ts
+/** Clear indentation at paragraph start before Backspace joins paragraphs. */
+const clearIndentOnBackspace = (state, dispatch) => {
+	if (!(state.selection instanceof TextSelection)) return false;
+	const { $cursor } = state.selection;
+	if (!$cursor || $cursor.parentOffset !== 0 || $cursor.parent.type.name !== "paragraph") return false;
+	const attrs = expectParagraphAttrs($cursor.parent);
+	const hasFirstLine = typeof attrs.indentFirstLine === "number" && attrs.indentFirstLine > 0;
+	const hasIndentLeft = typeof attrs.indentLeft === "number" && attrs.indentLeft > 0;
+	if (!hasFirstLine && !attrs.hangingIndent && !hasIndentLeft) return false;
+	if (dispatch) {
+		const position = $cursor.before();
+		dispatch(state.tr.setNodeMarkup(position, void 0, {
+			...attrs,
+			indentFirstLine: null,
+			hangingIndent: null,
+			indentLeft: null
+		}).scrollIntoView());
+	}
+	return true;
+};
+//#endregion
+export { clearIndentOnBackspace };

package/dist/prosemirror/commands/comments.js

@@ -287,7 +287,12 @@ function resolveChange(from, to, mode, revisionIds) {
 				const cell = tr.doc.nodeAt(mappedPos);
 				if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") continue;
 				if (op.type === "merge") {
-					const resolved = op.source === "collapsed" ? resolveCollapsedTableCellMerge(tr, mappedPos, op.mode, op.revisionSet) : resolveVisibleTableCellMerge(tr, mappedPos, op.mode);
+					const resolved = op.source === "collapsed" ? resolveCollapsedTableCellMerge(tr, mappedPos, op.mode, op.revisionSet) : resolveVisibleTableCellMerge({
+						tr,
+						cellPos: mappedPos,
+						mode: op.mode,
+						revisionSet: op.revisionSet
+					});
 					if (!resolved) {
 						failedTableCellMergeResolution = true;
 						break;

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -1,3 +1,4 @@
+import { isStyleSourcedParagraphNumbering } from "../../internal/paragraphFormattingSerialization.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { readParagraphNumberingAttr } from "../numberingAttr.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
@@ -126,7 +127,9 @@ const paragraphPropertiesSnapshot = (node) => {
 	const attrs = expectParagraphAttrs(node);
 	const snapshot = {};
 	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) {
-		if (key === "alignment" || PPR_SPACING_ATTR_KEYS.has(key)) continue;
+		if (key === "alignment" || PPR_SPACING_ATTR_KEYS.has(key) || key === "numPr" && isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) continue;
+		if (styleSuppliedParagraphValue(attrs, key)) continue;
+		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) continue;
 		if (styleSuppliedParagraphValue(attrs, key)) continue;
 		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) continue;
 		const value = attrs[key];

package/dist/prosemirror/commands/resolveAllTableChanges.js

@@ -5,7 +5,8 @@ import { nodePropertyRevisionSites, propertyRevisionRecords } from "../revisionC
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { resolveAllNodePropertyChangeAttrs } from "./resolveNodePropertyChangeAttrs.js";
-import { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload } from "./tableCellMergeResolution.js";
+import { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload } from "./tableCellMergeResolution.js";
+import { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions } from "./tableMergeFoldDecisions.js";
 import { panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 import { StepMap } from "prosemirror-transform";
@@ -358,6 +359,12 @@ const compactColumnWidths = (widths, removals) => {
 /** Resolve all cell edits in reverse order against one grid and mutable slots. */
 const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched, sourceTable }) => {
 	const map = TableMap.get(table);
+	const mergeDecisions = tableMergeFoldDecisions({
+		table,
+		mode,
+		revisionSet: null
+	});
+	if (mergeDecisions.invalid.size > 0) return failedTableResolution(table);
 	const cellRectangle = indexedTableCells(map);
 	const rows = Array.from({ length: table.childCount }, (_, index) => table.child(index));
 	const rowCells = rows.map(() => /* @__PURE__ */ new Map());
@@ -383,7 +390,7 @@ const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched
 			for (let coveredRow = rectangle.top; coveredRow < rectangle.bottom; coveredRow++) rowOccupancy[coveredRow] = elementAt(rowOccupancy, coveredRow) + (rectangle.right - rectangle.left);
 			const initial = elementAt(elementAt(rowMetadata, rowIndex).cells, cellIndex);
 			const entry = {
-				node,
+				node: mergeDecisions.origins.has(cellOffset) ? node.type.create(resolvedTableMergeOriginAttrs(node), node.content, node.marks) : node,
 				position: cellOffset,
 				left,
 				row: rowIndex,
@@ -438,28 +445,15 @@ const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched
 				});
 			}
 		} else if (marker?.kind === "merge") {
-			const joinsAbove = mode === "accept" ? isTableCellMergeRevisionContinuation(marker.verticalMerge) && acceptedMergeFoldsIntoCellAbove(entry.node) : isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal);
-			if (mode === "accept" && !joinsAbove) {
-				entry.touched = true;
-				entry.node = entry.node.type.create({
-					...entry.node.attrs,
-					cellMarker: null
-				}, entry.node.content, entry.node.marks);
-			} else if (!joinsAbove) {
-				entry.touched = true;
-				const original = entry.node.attrs["_originalFormatting"];
-				let formatting = original;
-				if (typeof original === "object" && original !== null) {
-					const copy = { ...original };
-					delete copy["vMerge"];
-					formatting = copy;
-				}
-				entry.node = entry.node.type.create({
-					...entry.node.attrs,
-					cellMarker: null,
-					_originalFormatting: formatting
-				}, entry.node.content, entry.node.marks);
-			} else {
+			const joinsAbove = mergeDecisions.folds.get(entry.position);
+			if (joinsAbove === void 0) return panic("Merge resolution lost its cell");
+			if (mode === "reject" && isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal) && cellRectangle(entry.position).top === 0) return failedTableResolution(table);
+			if (!joinsAbove) entry.node = entry.node.type.create(resolvedVisibleTableCellMergeAttrs({
+				cell: entry.node,
+				mode,
+				origin: mergeDecisions.origins.has(entry.position)
+			}), entry.node.content, entry.node.marks);
+			else {
 				const rectangle = cellRectangle(entry.position);
 				if (rectangle.top === 0) return failedTableResolution(table);
 				const abovePosition = map.map[(rectangle.top - 1) * map.width + rectangle.left];

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -1,5 +1,7 @@
+import { resolveParagraphNumbering } from "../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { rejectedListRenderingPatch } from "../listRendering.js";
+import { paragraphNumberingAttr } from "../numberingAttr.js";
 import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
 import { resolveParagraphDefaultTextFormatting } from "../styles/paragraphStyleCascade.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties } from "./propertyChangeScope.js";
@@ -38,11 +40,20 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 					...previousFormattingFromStyle,
 					...resolvedFromStyle
 				};
+				let styleNumbering = previousFormattingFromStyle?.numPr;
+				if (!styleResolver && sameStyle) styleNumbering = currentAttrs.numPrFromStyle ?? void 0;
+				const inheritedNumbering = styleNumbering == null ? null : paragraphNumberingAttr(resolveParagraphNumbering(styleNumbering));
+				const recordedNumbering = rejection.previousFormatting?.numPr;
+				const restoredNumbering = recordedNumbering ?? inheritedNumbering;
 				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, inheritedFormatting), rejectedListRenderingPatch({
 					current: expectParagraphAttrs(node),
 					previousFormatting: rejection.previousFormatting,
-					numbering
-				}));
+					numbering,
+					restoredNumbering
+				}), {
+					numPr: restoredNumbering,
+					numPrFromStyle: recordedNumbering == null ? inheritedNumbering : null
+				});
 				const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
 				nextAttrs["_originalFormatting"] = restoredFormatting;
 				if (styleResolver) nextAttrs["defaultTextFormatting"] = resolveParagraphDefaultTextFormatting(rejection.previousFormatting?.styleId, restoredFormatting ?? void 0, styleResolver) ?? null;