@stll/folio-core 0.4.0 → 0.6.0

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

@@ -0,0 +1,68 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/prosemirror/commands/propertyChangeScope.d.ts
+type AttrPatch = Record<string, unknown>;
+/**
+ * Paragraph attrs governed by a `w:pPrChange` — the attrs
+ * `paragraphFormattingToAttrs` (conversion/toProseDoc.ts) can produce from a
+ * parsed `CT_PPrBase` (ECMA-376 §17.13.5.29). Rejecting a pPrChange restores
+ * the stored old pPr wholesale for exactly these keys: a key absent from the
+ * stored record resets to the schema default (`null`).
+ *
+ * Deliberately OUT of scope (preserved across a reject):
+ * - identity/structure: `paraId`, `textId`, `sectionBreakType`,
+ *   `_sectionProperties`, `_propertyChanges`, `pPrMark`, `bookmarks`,
+ *   `_emptyHyperlinks`, `renderedPageBreakBefore`
+ * - paragraph-mark run properties — `pPr/rPr` is CT_PPr-only, not part of the
+ *   CT_PPrBase payload a pPrChange stores: `defaultTextFormatting`,
+ *   `runInWithNext` (`w:specVanish` lives in that rPr)
+ * - load-time style/numbering bookkeeping the command layer cannot recompute
+ *   without a style resolver: `numPrFromStyle`, the `list*` rendering attrs,
+ *   `spacingFromDocDefaults`
+ */
+declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignment", "spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "spacingExplicit", "indentLeft", "indentRight", "indentFirstLine", "hangingIndent", "borders", "shading", "tabs", "pageBreakBefore", "keepNext", "keepLines", "widowControl", "contextualSpacing", "outlineLevel", "direction", "_autospacingBase"];
+/**
+ * Build the attr patch that rejecting one pPrChange applies to a paragraph:
+ * every in-scope key set to the stored previous value, or reset to `null`
+ * when the stored old pPr does not carry it. Keys the record captured beyond
+ * the scoped set (editor-created list suggestions snapshot list-rendering
+ * bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
+ */
+declare function paragraphRejectAttrPatch(previousFormatting: Record<string, unknown> | null | undefined): AttrPatch;
+/**
+ * Rebuild the paragraph's `_originalFormatting` (the serializer's pPr source)
+ * after a reject: the stored old pPr wholesale within CT_PPrBase scope, with
+ * the paragraph-mark rPr fields (`runProperties`, `runInWithNext`) preserved
+ * from the live original — a pPrChange cannot store them, so a reject must
+ * not drop them.
+ */
+declare function paragraphRejectOriginalFormatting(previousFormatting: Record<string, unknown> | null | undefined, liveOriginal: unknown): document_d_exports.ParagraphFormatting | null;
+/**
+ * Rejected section properties: the stored old sectPr wholesale, preserving
+ * the live header/footer references — `EG_HdrFtrReferences` is not part of
+ * the `CT_SectPrBase` payload a `w:sectPrChange` stores (ECMA-376
+ * §17.13.5.32), so those children survive a reject. The caller re-attaches
+ * whatever `propertyChanges` remain unresolved.
+ */
+declare function sectionRejectProperties(live: document_d_exports.SectionProperties, previousProperties: document_d_exports.SectionProperties | undefined): document_d_exports.SectionProperties;
+/**
+ * Attr patch for rejecting a `w:tblPrChange`: the stored old tblPr wholesale
+ * (`w:tblPrChange` stores the complete previous tblPr, so every tblPr-derived
+ * attr resets when absent). `columnWidths` comes from `w:tblGrid`, not tblPr,
+ * and is untouched.
+ */
+declare function tableRejectAttrPatch(previousFormatting: document_d_exports.TableFormatting | undefined): AttrPatch;
+/** Attr patch for rejecting a `w:trPrChange`: the stored old trPr wholesale. */
+declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.TableRowFormatting | undefined): AttrPatch;
+/**
+ * Attr patch for rejecting a `w:tcPrChange`: the stored old tcPr wholesale
+ * for the non-structural attrs. `gridSpan` / `vMerge` are structural in
+ * ProseMirror (`colspan` / `rowspan` shape the table grid); restoring them
+ * from the record would desync the grid without a full table restructure, so
+ * the live structure is kept and the rebuilt `_originalFormatting` inherits
+ * the live original's `gridSpan` / `vMerge` to stay consistent with it.
+ * (Word would also restore tracked merges; folio deliberately does not.)
+ */
+declare function tableCellRejectAttrPatch(previousFormatting: document_d_exports.TableCellFormatting | undefined, liveOriginalFormatting: document_d_exports.TableCellFormatting | null | undefined): AttrPatch;
+//#endregion
+export { PPR_CHANGE_SCOPED_ATTR_KEYS, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -0,0 +1,242 @@
+import { directionFromBidi } from "../paragraphDirection.js";
+import { setAutospacingBaseValue } from "../autospacingBase.js";
+//#region src/prosemirror/commands/propertyChangeScope.ts
+/**
+* Paragraph attrs governed by a `w:pPrChange` — the attrs
+* `paragraphFormattingToAttrs` (conversion/toProseDoc.ts) can produce from a
+* parsed `CT_PPrBase` (ECMA-376 §17.13.5.29). Rejecting a pPrChange restores
+* the stored old pPr wholesale for exactly these keys: a key absent from the
+* stored record resets to the schema default (`null`).
+*
+* Deliberately OUT of scope (preserved across a reject):
+* - identity/structure: `paraId`, `textId`, `sectionBreakType`,
+*   `_sectionProperties`, `_propertyChanges`, `pPrMark`, `bookmarks`,
+*   `_emptyHyperlinks`, `renderedPageBreakBefore`
+* - paragraph-mark run properties — `pPr/rPr` is CT_PPr-only, not part of the
+*   CT_PPrBase payload a pPrChange stores: `defaultTextFormatting`,
+*   `runInWithNext` (`w:specVanish` lives in that rPr)
+* - load-time style/numbering bookkeeping the command layer cannot recompute
+*   without a style resolver: `numPrFromStyle`, the `list*` rendering attrs,
+*   `spacingFromDocDefaults`
+*/
+const PPR_CHANGE_SCOPED_ATTR_KEYS = [
+	"styleId",
+	"numPr",
+	"alignment",
+	"spaceBefore",
+	"spaceAfter",
+	"lineSpacing",
+	"lineSpacingRule",
+	"spacingExplicit",
+	"indentLeft",
+	"indentRight",
+	"indentFirstLine",
+	"hangingIndent",
+	"borders",
+	"shading",
+	"tabs",
+	"pageBreakBefore",
+	"keepNext",
+	"keepLines",
+	"widowControl",
+	"contextualSpacing",
+	"outlineLevel",
+	"direction",
+	"_autospacingBase"
+];
+const PPR_CHANGE_SCOPED_ATTR_KEY_SET = new Set(PPR_CHANGE_SCOPED_ATTR_KEYS);
+/**
+* Parser-shaped `ParagraphFormatting` keys that must NOT merge through to
+* attrs verbatim: they either normalize to a differently named attr
+* (`bidi` → `direction`, autospacing flags → `_autospacingBase`), have no
+* attr representation and round-trip via `_originalFormatting` only
+* (`frame`, `suppressLineNumbers`, `suppressAutoHyphens`), or sit outside
+* the CT_PPrBase scope entirely (`runProperties`, `runInWithNext` — the
+* paragraph-mark rPr) and so must never overwrite the live value on reject.
+*/
+const PPR_PARSER_ONLY_KEYS = /* @__PURE__ */ new Set([
+	"bidi",
+	"beforeAutospacing",
+	"afterAutospacing",
+	"runProperties",
+	"runInWithNext",
+	"frame",
+	"suppressLineNumbers",
+	"suppressAutoHyphens",
+	"numPrFromStyle"
+]);
+/**
+* `ParagraphFormatting` keys inside the CT_PPrBase scope, used to rebuild
+* `_originalFormatting` after a reject (old pPr wholesale within scope,
+* paragraph-mark rPr fields preserved from the live original).
+*/
+const PPR_CHANGE_SCOPED_FORMATTING_KEYS = [
+	"styleId",
+	"numPr",
+	"alignment",
+	"bidi",
+	"spaceBefore",
+	"spaceAfter",
+	"lineSpacing",
+	"lineSpacingRule",
+	"beforeAutospacing",
+	"afterAutospacing",
+	"spacingExplicit",
+	"indentLeft",
+	"indentRight",
+	"indentFirstLine",
+	"hangingIndent",
+	"borders",
+	"shading",
+	"tabs",
+	"pageBreakBefore",
+	"keepNext",
+	"keepLines",
+	"widowControl",
+	"contextualSpacing",
+	"outlineLevel",
+	"frame",
+	"suppressLineNumbers",
+	"suppressAutoHyphens"
+];
+/**
+* Build the attr patch that rejecting one pPrChange applies to a paragraph:
+* every in-scope key set to the stored previous value, or reset to `null`
+* when the stored old pPr does not carry it. Keys the record captured beyond
+* the scoped set (editor-created list suggestions snapshot list-rendering
+* bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
+*/
+function paragraphRejectAttrPatch(previousFormatting) {
+	const prev = previousFormatting ?? {};
+	const patch = {};
+	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) patch[key] = Object.hasOwn(prev, key) ? prev[key] ?? null : null;
+	if (!Object.hasOwn(prev, "direction")) patch["direction"] = directionFromBidi(prev["bidi"]);
+	if (!Object.hasOwn(prev, "_autospacingBase")) patch["_autospacingBase"] = autospacingBaseFromFormatting(prev);
+	for (const [key, value] of Object.entries(prev)) {
+		if (PPR_CHANGE_SCOPED_ATTR_KEY_SET.has(key) || PPR_PARSER_ONLY_KEYS.has(key)) continue;
+		patch[key] = value ?? null;
+	}
+	return patch;
+}
+/**
+* Rebuild the paragraph's `_originalFormatting` (the serializer's pPr source)
+* after a reject: the stored old pPr wholesale within CT_PPrBase scope, with
+* the paragraph-mark rPr fields (`runProperties`, `runInWithNext`) preserved
+* from the live original — a pPrChange cannot store them, so a reject must
+* not drop them.
+*/
+function paragraphRejectOriginalFormatting(previousFormatting, liveOriginal) {
+	const prev = previousFormatting ?? {};
+	const result = {};
+	for (const key of PPR_CHANGE_SCOPED_FORMATTING_KEYS) {
+		const value = Object.hasOwn(prev, key) ? prev[key] : void 0;
+		if (value != null) result[key] = value;
+	}
+	const live = isRecord(liveOriginal) ? liveOriginal : {};
+	if (live["runProperties"] != null) result["runProperties"] = live["runProperties"];
+	if (live["runInWithNext"] != null) result["runInWithNext"] = live["runInWithNext"];
+	if (Object.keys(result).length === 0) return null;
+	return result;
+}
+function autospacingBaseFromFormatting(prev) {
+	const before = prev["beforeAutospacing"] === true;
+	const after = prev["afterAutospacing"] === true;
+	if (!before && !after) return null;
+	const base = {};
+	if (before) setAutospacingBaseValue(base, "before", prev["spaceBefore"]);
+	if (after) setAutospacingBaseValue(base, "after", prev["spaceAfter"]);
+	return base;
+}
+/**
+* Rejected section properties: the stored old sectPr wholesale, preserving
+* the live header/footer references — `EG_HdrFtrReferences` is not part of
+* the `CT_SectPrBase` payload a `w:sectPrChange` stores (ECMA-376
+* §17.13.5.32), so those children survive a reject. The caller re-attaches
+* whatever `propertyChanges` remain unresolved.
+*/
+function sectionRejectProperties(live, previousProperties) {
+	const restored = { ...previousProperties };
+	delete restored.propertyChanges;
+	if (live.headerReferences) restored.headerReferences = live.headerReferences;
+	else delete restored.headerReferences;
+	if (live.footerReferences) restored.footerReferences = live.footerReferences;
+	else delete restored.footerReferences;
+	return restored;
+}
+/**
+* Attr patch for rejecting a `w:tblPrChange`: the stored old tblPr wholesale
+* (`w:tblPrChange` stores the complete previous tblPr, so every tblPr-derived
+* attr resets when absent). `columnWidths` comes from `w:tblGrid`, not tblPr,
+* and is untouched.
+*/
+function tableRejectAttrPatch(previousFormatting) {
+	return {
+		styleId: previousFormatting?.styleId ?? null,
+		width: previousFormatting?.width?.value ?? null,
+		widthType: previousFormatting?.width?.type ?? null,
+		justification: previousFormatting?.justification ?? null,
+		floating: previousFormatting?.floating ?? null,
+		cellMargins: previousFormatting?.cellMargins ? cellMarginsToAttr(previousFormatting.cellMargins) : null,
+		look: previousFormatting?.look ?? null,
+		borders: previousFormatting?.borders ?? null,
+		_originalFormatting: previousFormatting ?? null
+	};
+}
+/** Attr patch for rejecting a `w:trPrChange`: the stored old trPr wholesale. */
+function tableRowRejectAttrPatch(previousFormatting) {
+	return {
+		height: previousFormatting?.height?.value ?? null,
+		heightRule: previousFormatting?.heightRule ?? null,
+		isHeader: previousFormatting?.header ?? false,
+		hidden: previousFormatting?.hidden ?? null,
+		_originalFormatting: previousFormatting ?? null
+	};
+}
+/**
+* Attr patch for rejecting a `w:tcPrChange`: the stored old tcPr wholesale
+* for the non-structural attrs. `gridSpan` / `vMerge` are structural in
+* ProseMirror (`colspan` / `rowspan` shape the table grid); restoring them
+* from the record would desync the grid without a full table restructure, so
+* the live structure is kept and the rebuilt `_originalFormatting` inherits
+* the live original's `gridSpan` / `vMerge` to stay consistent with it.
+* (Word would also restore tracked merges; folio deliberately does not.)
+*/
+function tableCellRejectAttrPatch(previousFormatting, liveOriginalFormatting) {
+	const restoredOriginal = { ...previousFormatting };
+	delete restoredOriginal.gridSpan;
+	delete restoredOriginal.vMerge;
+	if (liveOriginalFormatting?.gridSpan !== void 0) restoredOriginal.gridSpan = liveOriginalFormatting.gridSpan;
+	if (liveOriginalFormatting?.vMerge !== void 0) restoredOriginal.vMerge = liveOriginalFormatting.vMerge;
+	return {
+		width: previousFormatting?.width?.value ?? null,
+		widthType: previousFormatting?.width?.type ?? null,
+		verticalAlign: previousFormatting?.verticalAlign ?? null,
+		backgroundColor: previousFormatting?.shading?.fill?.rgb ?? null,
+		textDirection: previousFormatting?.textDirection ?? null,
+		noWrap: previousFormatting?.noWrap ?? null,
+		borders: previousFormatting?.borders ? cellBordersToAttr(previousFormatting.borders) : null,
+		margins: previousFormatting?.margins ? cellMarginsToAttr(previousFormatting.margins) : null,
+		_originalFormatting: Object.keys(restoredOriginal).length > 0 ? restoredOriginal : null
+	};
+}
+function cellMarginsToAttr(margins) {
+	const result = {};
+	if (margins.top?.value !== void 0) result.top = margins.top.value;
+	if (margins.bottom?.value !== void 0) result.bottom = margins.bottom.value;
+	if (margins.left?.value !== void 0) result.left = margins.left.value;
+	if (margins.right?.value !== void 0) result.right = margins.right.value;
+	return result;
+}
+function cellBordersToAttr(borders) {
+	const result = {};
+	if (borders.top) result.top = borders.top;
+	if (borders.bottom) result.bottom = borders.bottom;
+	if (borders.left) result.left = borders.left;
+	if (borders.right) result.right = borders.right;
+	return result;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { PPR_CHANGE_SCOPED_ATTR_KEYS, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -493,13 +493,12 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks) {
 		}
 		if (linkMark) {
 			const linkKey = getLinkKey(linkMark);
-			if (currentHyperlink && currentHyperlinkKey === linkKey) addNodeToHyperlink(currentHyperlink, node);
-			else {
+			if (currentHyperlink && currentHyperlinkKey === linkKey) {} else {
 				flushCurrentInline();
 				currentHyperlink = createHyperlink(linkMark);
 				currentHyperlinkKey = linkKey;
-				addNodeToHyperlink(currentHyperlink, node);
 			}
+			addNodeToHyperlink(currentHyperlink, node);
 			return;
 		}
 		if (currentHyperlink) flushCurrentInline();
@@ -1236,6 +1235,7 @@ function convertPMTable(node, documentCounts) {
 				rows
 			};
 			if (attrs.columnWidths) minTable.columnWidths = attrs.columnWidths;
+			restoreTablePropertyChanges(minTable, attrs);
 			return minTable;
 		}
 	}
@@ -1245,8 +1245,17 @@ function convertPMTable(node, documentCounts) {
 	};
 	if (attrs.columnWidths) table.columnWidths = attrs.columnWidths;
 	if (formatting) table.formatting = formatting;
+	restoreTablePropertyChanges(table, attrs);
 	return table;
 }
+/**
+* Restore `w:tblPrChange` entries that PM carried opaquely on the table attrs
+* (same rationale as the paragraph `_propertyChanges` attr): they must survive
+* an edit so the saved DOCX keeps the tracked property-change history.
+*/
+function restoreTablePropertyChanges(table, attrs) {
+	if (Array.isArray(attrs.tblPrChange) && attrs.tblPrChange.length > 0) table.propertyChanges = [...attrs.tblPrChange];
+}
 function convertPMTableRows(node, documentCounts) {
 	const rows = [];
 	const activeVerticalMerges = /* @__PURE__ */ new Map();
@@ -1369,6 +1378,7 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges) {
 	};
 	const rowFormatting = tableRowAttrsToFormatting(attrs);
 	if (rowFormatting) row.formatting = rowFormatting;
+	if (Array.isArray(attrs.trPrChange) && attrs.trPrChange.length > 0) row.propertyChanges = [...attrs.trPrChange];
 	return row;
 }
 function createVerticalMergeContinuationCell(colspan) {
@@ -1430,6 +1440,7 @@ function convertPMTableCell(node, documentCounts) {
 	};
 	const cellFormatting = tableCellAttrsToFormatting(attrs);
 	if (cellFormatting) cell.formatting = cellFormatting;
+	if (Array.isArray(attrs.tcPrChange) && attrs.tcPrChange.length > 0) cell.propertyChanges = [...attrs.tcPrChange];
 	return cell;
 }
 /**

package/dist/prosemirror/conversion/toProseDoc.js

@@ -100,15 +100,16 @@ function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFo
 	};
 	let styleRunFormatting;
 	if (styleResolver) styleRunFormatting = styleResolver.resolveParagraphStyle(paragraph.formatting?.styleId).runFormatting;
-	const paragraphRunFormatting = paragraph.formatting?.runProperties ? resolveTextFormatting(paragraph.formatting.runProperties, styleResolver) : void 0;
+	const paragraphRunFormatting = resolveParagraphMarkRunFormatting(paragraph.formatting?.runProperties, styleResolver);
 	let inheritableParagraphRunFormatting;
 	if (paragraphRunFormatting && !isTocParagraph) inheritableParagraphRunFormatting = stripParagraphMarkOnlyFormatting(paragraphRunFormatting);
 	const baseRunFormatting = mergeTextFormatting(styleRunFormatting, extraRunFormatting);
-	const defaultRunFormatting = mergeTextFormatting(baseRunFormatting, inheritableParagraphRunFormatting);
+	const paragraphMarkPrecedesStyle = paragraph.formatting?.styleId !== void 0;
+	const defaultRunFormatting = paragraphMarkPrecedesStyle ? mergeTextFormatting(inheritableParagraphRunFormatting, baseRunFormatting) : mergeTextFormatting(baseRunFormatting, inheritableParagraphRunFormatting);
 	const getInheritedRunFormatting = (formatting, fieldType) => {
 		if (fieldType === "TOC") return hasDirectRunFormatting(formatting) ? suppressParagraphMarkFormatting(baseRunFormatting, void 0, formatting) : baseRunFormatting;
 		if (!hasDirectRunFormatting(formatting)) return defaultRunFormatting;
-		return suppressParagraphMarkFormatting(baseRunFormatting, inheritableParagraphRunFormatting, formatting);
+		return suppressParagraphMarkFormatting(baseRunFormatting, inheritableParagraphRunFormatting, formatting, paragraphMarkPrecedesStyle);
 	};
 	const emitTrackedChange = (change, markType, moveKind) => {
 		emitInlineNodes(convertTrackedChange(change, markType, getInheritedRunFormatting, styleResolver, moveKind));
@@ -228,6 +229,10 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 	if (paragraph.listRendering?.implicitChildLevelAdvances !== void 0) attrs.listImplicitChildLevelAdvances = paragraph.listRendering.implicitChildLevelAdvances;
 	if (paragraph.listRendering?.markerSecondSlotOffsetTwips !== void 0) attrs.listMarkerSecondSlotOffsetTwips = paragraph.listRendering.markerSecondSlotOffsetTwips;
 	if (paragraph.listRendering?.levelNumFmts) attrs.listLevelNumFmts = paragraph.listRendering.levelNumFmts;
+	if (paragraph.listRendering && "levelStarts" in paragraph.listRendering) {
+		const { levelStarts } = paragraph.listRendering;
+		if (Array.isArray(levelStarts) && levelStarts.every((value) => typeof value === "number")) attrs.listLevelStarts = levelStarts;
+	}
 	if (paragraph.listRendering?.abstractNumId !== void 0) attrs.listAbstractNumId = paragraph.listRendering.abstractNumId;
 	if (paragraph.listRendering?.startOverride !== void 0) attrs.listStartOverride = paragraph.listRendering.startOverride;
 	if (formatting) attrs._originalFormatting = formatting;
@@ -245,6 +250,12 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		set("lineSpacing", formatting?.lineSpacing ?? stylePpr?.lineSpacing);
 		set("lineSpacingRule", formatting?.lineSpacingRule ?? stylePpr?.lineSpacingRule);
 		set("spacingExplicit", formatting?.spacingExplicit);
+		const paragraphStyle = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
+		const docDefaultSpacing = styleResolver.getDocDefaults()?.pPr;
+		const spacingFromDocDefaults = {};
+		if (formatting?.spaceBefore === void 0 && tableParagraphOverlay?.spaceBefore === void 0 && paragraphStyle?.pPr?.spaceBefore === void 0 && docDefaultSpacing?.spaceBefore !== void 0) spacingFromDocDefaults.before = true;
+		if (formatting?.spaceAfter === void 0 && tableParagraphOverlay?.spaceAfter === void 0 && paragraphStyle?.pPr?.spaceAfter === void 0 && docDefaultSpacing?.spaceAfter !== void 0) spacingFromDocDefaults.after = true;
+		if (spacingFromDocDefaults.before || spacingFromDocDefaults.after) attrs.spacingFromDocDefaults = spacingFromDocDefaults;
 		set("indentLeft", formatting?.indentLeft ?? stylePpr?.indentLeft);
 		set("indentRight", formatting?.indentRight ?? stylePpr?.indentRight);
 		const styleFirstLine = formatting?.numPr?.numId === 0 && stylePpr?.numPr !== void 0 && stylePpr.numPr.numId !== 0 ? void 0 : stylePpr;
@@ -390,9 +401,9 @@ function stripParagraphMarkOnlyFormatting(formatting) {
 	const { allCaps: _ac, highlight: _h, shading: _s, smallCaps: _sc, ...rest } = formatting;
 	return Object.keys(rest).length > 0 ? rest : void 0;
 }
-function suppressParagraphMarkFormatting(base, paragraphMark, direct) {
+function suppressParagraphMarkFormatting(base, paragraphMark, direct, paragraphMarkPrecedesStyle = false) {
 	if (!paragraphMark) return base;
-	const result = { ...base };
+	const result = (paragraphMarkPrecedesStyle ? mergeTextFormatting(paragraphMark, base) : mergeTextFormatting(base, paragraphMark)) ?? {};
 	suppressBooleanParagraphMark(result, paragraphMark, direct, "bold");
 	suppressBooleanParagraphMark(result, paragraphMark, direct, "italic");
 	suppressBooleanParagraphMark(result, paragraphMark, direct, "strike");
@@ -405,7 +416,10 @@ function suppressParagraphMarkFormatting(base, paragraphMark, direct) {
 	suppressBooleanParagraphMark(result, paragraphMark, direct, "shadow");
 	suppressBooleanParagraphMark(result, paragraphMark, direct, "outline");
 	suppressBooleanParagraphMark(result, paragraphMark, direct, "rtl");
+	if (paragraphMark.fontSize !== void 0 && direct?.fontSize === void 0 && base?.fontSize !== void 0) result.fontSize = base.fontSize;
+	if (paragraphMark.fontSizeCs !== void 0 && direct?.fontSizeCs === void 0 && base?.fontSizeCs !== void 0) result.fontSizeCs = base.fontSizeCs;
 	if (paragraphMark.underline !== void 0 && direct?.underline === void 0) result.underline = { style: "none" };
+	if (paragraphMark.spacing !== void 0 && direct?.spacing === void 0) result.spacing = 0;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
 function suppressBooleanParagraphMark(result, paragraphMark, direct, key) {
@@ -417,13 +431,17 @@ function resolveTextFormatting(formatting, styleResolver) {
 	if (!styleResolver) return formatting;
 	return mergeTextFormatting(styleResolver.resolveRunStyle(formatting.styleId), formatting);
 }
+function resolveParagraphMarkRunFormatting(formatting, styleResolver) {
+	if (!formatting || !styleResolver) return formatting;
+	return mergeTextFormatting(formatting.styleId ? styleResolver.getRunStyleOwnProperties(formatting.styleId) : void 0, formatting);
+}
 function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, options = {}) {
 	const style = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
 	const paragraphStyleRpr = style?.type === "paragraph" ? style.rPr : void 0;
 	const rawParagraphMarkRpr = options.includeParagraphMarkRunProperties === false ? void 0 : formatting?.runProperties;
-	const characterStyleRpr = rawParagraphMarkRpr?.styleId !== void 0 ? styleResolver.getRunStyleOwnProperties(rawParagraphMarkRpr.styleId) : void 0;
-	const paragraphRunProperties = rawParagraphMarkRpr ? stripParagraphMarkOnlyFormatting(mergeTextFormatting(characterStyleRpr, rawParagraphMarkRpr) ?? {}) : void 0;
-	return mergeTextFormatting(mergeTextFormatting(mergeTextFormatting(styleResolver.getDocDefaults()?.rPr, styleResolver.getDefaultCharacterStyle()?.rPr), paragraphStyleRpr), paragraphRunProperties);
+	const paragraphRunProperties = rawParagraphMarkRpr ? stripParagraphMarkOnlyFormatting(resolveParagraphMarkRunFormatting(rawParagraphMarkRpr, styleResolver) ?? {}) : void 0;
+	const bodyRunDefaults = mergeTextFormatting(mergeTextFormatting(styleResolver.getDocDefaults()?.rPr, styleResolver.getDefaultCharacterStyle()?.rPr), paragraphStyleRpr);
+	return styleId === void 0 ? mergeTextFormatting(bodyRunDefaults, paragraphRunProperties) : mergeTextFormatting(paragraphRunProperties, bodyRunDefaults);
 }
 function calculateRowSpans(table) {
 	const result = /* @__PURE__ */ new Map();
@@ -549,6 +567,7 @@ function convertTable(table, styleResolver, theme) {
 	if (table.formatting?.look) attrs.look = table.formatting.look;
 	if (table.formatting?.borders) attrs.borders = table.formatting.borders;
 	if (table.formatting) attrs._originalFormatting = table.formatting;
+	if (table.propertyChanges && table.propertyChanges.length > 0) attrs.tblPrChange = [...table.propertyChanges];
 	const conditionalStyles = {};
 	const setCS = (key, type) => {
 		const val = resolveTableStyleConditional(styleResolver, conditionalTableStyleId, type);
@@ -607,6 +626,7 @@ function convertTableRow(row, styleResolver, isHeaderRow, columnWidths, totalWid
 	if (row.formatting?.heightRule) attrs.heightRule = row.formatting.heightRule;
 	if (row.formatting?.hidden) attrs.hidden = true;
 	if (row.formatting) attrs._originalFormatting = row.formatting;
+	if (row.propertyChanges && row.propertyChanges.length > 0) attrs.trPrChange = [...row.propertyChanges];
 	const numCells = row.cells.length;
 	const isFirstRow = rowIndex === 0;
 	const isLastRow = rowIndex === (totalRows ?? 1) - 1;
@@ -752,6 +772,7 @@ function convertTableCell(cell, styleResolver, isHeader, gridWidthPercent, condi
 	else if (conditionalStyle?.tcPr?.margins) attrs.margins = buildMarginsAttr(conditionalStyle.tcPr.margins);
 	else if (defaultCellMargins) attrs.margins = defaultCellMargins;
 	if (formatting) attrs._originalFormatting = formatting;
+	if (cell.propertyChanges && cell.propertyChanges.length > 0) attrs.tcPrChange = [...cell.propertyChanges];
 	if (preserveVMergeRestart) attrs._preserveVMergeRestart = true;
 	if (vMergeContinuationCells && vMergeContinuationCells.length > 0) attrs._docxVMergeContinuationCells = vMergeContinuationCells;
 	const contentNodes = [];

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

@@ -185,6 +185,7 @@ const paragraphNodeSpec = {
 		lineSpacing: { default: null },
 		lineSpacingRule: { default: null },
 		spacingExplicit: { default: null },
+		spacingFromDocDefaults: { default: null },
 		indentLeft: { default: null },
 		indentRight: { default: null },
 		indentFirstLine: { default: null },
@@ -203,6 +204,7 @@ const paragraphNodeSpec = {
 		listImplicitChildLevelAdvances: { default: null },
 		listMarkerSecondSlotOffsetTwips: { default: null },
 		listLevelNumFmts: { default: null },
+		listLevelStarts: { default: null },
 		listAbstractNumId: { default: null },
 		listStartOverride: { default: null },
 		styleId: { default: null },

package/dist/prosemirror/extensions/features/ListExtension.js

@@ -1,3 +1,4 @@
+import { PPR_CHANGE_SCOPED_ATTR_KEYS } from "../../commands/propertyChangeScope.js";
 import { Priority } from "../types.js";
 import { createExtension } from "../create.js";
 import { SUGGESTION_META, makeRevisionInfo } from "../../plugins/suggestionMode.js";
@@ -35,11 +36,16 @@ const LIST_FORMATTING_ATTRS = [
 	"listMarkerFontSize",
 	"listMarkerSuffix",
 	"listLevelNumFmts",
+	"listLevelStarts",
 	"listAbstractNumId",
 	"listStartOverride"
 ];
 function getPreviousListFormatting(attrs) {
 	const previousFormatting = {};
+	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) {
+		const value = attrs[key];
+		if (value != null) previousFormatting[key] = value;
+	}
 	for (const key of LIST_FORMATTING_ATTRS) previousFormatting[key] = attrs[key] ?? null;
 	return previousFormatting;
 }

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

@@ -152,7 +152,8 @@ const tableSpec = {
 		cellMargins: { default: null },
 		look: { default: null },
 		borders: { default: null },
-		_originalFormatting: { default: null }
+		_originalFormatting: { default: null },
+		tblPrChange: { default: null }
 	},
 	parseDOM: [{
 		tag: "table",
@@ -171,17 +172,12 @@ const tableSpec = {
 		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") {
+		if (attrs.width !== void 0 && attrs.widthType === "pct") styles.push(`width: ${attrs.width / 50}%`);
+		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");
-		}
+		} 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("; ");
@@ -200,7 +196,8 @@ const tableRowSpec = {
 		heightRule: { default: null },
 		isHeader: { default: false },
 		hidden: { default: false },
-		_originalFormatting: { default: null }
+		_originalFormatting: { default: null },
+		trPrChange: { default: null }
 	},
 	parseDOM: [{ tag: "tr" }],
 	toDOM(node) {
@@ -317,6 +314,7 @@ const tableCellSpec = {
 		textDirection: { default: null },
 		noWrap: { default: false },
 		_originalFormatting: { default: null },
+		tcPrChange: { default: null },
 		_preserveVMergeRestart: { default: null },
 		_docxVMergeContinuationCells: { default: null }
 	},
@@ -369,6 +367,7 @@ const tableHeaderSpec = {
 		textDirection: { default: null },
 		noWrap: { default: false },
 		_originalFormatting: { default: null },
+		tcPrChange: { default: null },
 		_preserveVMergeRestart: { default: null },
 		_docxVMergeContinuationCells: { default: null }
 	},

package/dist/prosemirror/findReplaceSelection.js

@@ -44,7 +44,8 @@ function resolveFindMatchRange(doc, match) {
 					cellOffset += cell.nodeSize;
 					continue;
 				}
-				if (!walkBlocks(cell, rowPos + 1 + cellOffset + 1)) return false;
+				const cellPos = rowPos + 1 + cellOffset;
+				if (!walkBlocks(cell, cellPos + 1)) return false;
 				cellOffset += cell.nodeSize;
 			}
 			rowOffset += row.nodeSize;

package/dist/prosemirror/schema/nodes.d.ts

@@ -18,7 +18,8 @@ type ParagraphAttrs = {
   spaceAfter?: number;
   lineSpacing?: number;
   lineSpacingRule?: document_d_exports.LineSpacingRule;
-  spacingExplicit?: SpacingExplicit;
+  spacingExplicit?: SpacingExplicit; /** Layout provenance: document defaults survive on empty paragraphs. */
+  spacingFromDocDefaults?: SpacingExplicit;
   indentLeft?: number;
   indentRight?: number;
   indentFirstLine?: number;
@@ -65,7 +66,8 @@ type ParagraphAttrs = {
    * inline LISTNUM "(a)" with the deeper level's marker column.
    */
   listMarkerSecondSlotOffsetTwips?: number; /** Number format for each level used by multi-level marker templates. */
-  listLevelNumFmts?: document_d_exports.NumberFormat[]; /** Abstract numbering ID shared by numbering instances. */
+  listLevelNumFmts?: document_d_exports.NumberFormat[]; /** Initial counter for each level used by multi-level marker templates. */
+  listLevelStarts?: number[]; /** Abstract numbering ID shared by numbering instances. */
   listAbstractNumId?: number; /** Numbering start override for this numId/level. */
   listStartOverride?: number;
   styleId?: string;
@@ -346,7 +348,8 @@ type TableAttrs = {
   }; /** Table look flags for conditional formatting (w:tblLook) */
   look?: document_d_exports.TableLook; /** Table-level borders (w:tblBorders) — full BorderSpec per side */
   borders?: document_d_exports.TableBorders; /** Original table formatting from DOCX for lossless round-trip serialization */
-  _originalFormatting?: document_d_exports.TableFormatting;
+  _originalFormatting?: document_d_exports.TableFormatting; /** Tracked table property changes (w:tblPrChange) for round-trip + accept/reject */
+  tblPrChange?: document_d_exports.TablePropertyChange[];
 };
 /**
  * Table row attributes
@@ -356,7 +359,8 @@ type TableRowAttrs = {
   heightRule?: NonNullable<document_d_exports.TableRowFormatting["heightRule"]>; /** Is header row */
   isHeader?: boolean; /** Whether the row is hidden (`w:hidden`) */
   hidden?: boolean; /** Original row formatting from DOCX for lossless round-trip serialization */
-  _originalFormatting?: document_d_exports.TableRowFormatting;
+  _originalFormatting?: document_d_exports.TableRowFormatting; /** Tracked row property changes (w:trPrChange) for round-trip + accept/reject */
+  trPrChange?: document_d_exports.TableRowPropertyChange[];
 };
 /**
  * Table cell attributes
@@ -383,7 +387,8 @@ type TableCellAttrs = {
     left?: number;
     right?: number;
   }; /** Original cell formatting from DOCX for lossless round-trip serialization */
-  _originalFormatting?: document_d_exports.TableCellFormatting; /** Preserve a DOCX vMerge restart even when PM cannot model it as a rowspan. */
+  _originalFormatting?: document_d_exports.TableCellFormatting; /** Tracked cell property changes (w:tcPrChange) for round-trip + accept/reject */
+  tcPrChange?: document_d_exports.TableCellPropertyChange[]; /** Preserve a DOCX vMerge restart even when PM cannot model it as a rowspan. */
   _preserveVMergeRestart?: boolean; /** Original DOCX vMerge continuation cells skipped into this PM rowspan. */
   _docxVMergeContinuationCells?: document_d_exports.TableCell[];
 };

package/dist/prosemirror/styles/resolvedStyleAttrs.js

@@ -91,6 +91,7 @@ function listAttrsFromResolvedStyle(resolved, numbering) {
 		listImplicitChildLevelAdvances: null,
 		listMarkerSecondSlotOffsetTwips: null,
 		listLevelNumFmts: rendering?.levelNumFmts ?? null,
+		listLevelStarts: rendering?.levelStarts ?? null,
 		listAbstractNumId: rendering?.abstractNumId ?? null,
 		listStartOverride: rendering?.startOverride ?? null
 	};