@stll/folio-core 0.3.1 → 0.5.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

@@ -341,6 +341,7 @@ function paragraphAttrsToFormatting(attrs) {
 		if (attrs.styleId !== (orig.styleId ?? void 0)) if (attrs.styleId) result.styleId = attrs.styleId;
 		else delete result.styleId;
 		assignBooleanToggle(result, attrs, orig, "pageBreakBefore");
+		assignBooleanToggle(result, attrs, orig, "widowControl");
 		if (attrs.spacingExplicit !== orig.spacingExplicit) if (attrs.spacingExplicit) result.spacingExplicit = attrs.spacingExplicit;
 		else delete result.spacingExplicit;
 		const bidi = directionToBidi(attrs.direction);
@@ -350,7 +351,7 @@ function paragraphAttrsToFormatting(attrs) {
 	}
 	const outlineLevel = Reflect.get(attrs, "outlineLevel");
 	const bidi = directionToBidi(attrs.direction);
-	if (!(attrs.alignment || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || attrs.lineSpacing || attrs.indentLeft || attrs.indentRight || attrs.indentFirstLine || attrs.numPr || attrs.styleId || attrs.borders || attrs.shading || attrs.tabs || typeof outlineLevel === "number" || attrs.contextualSpacing || attrs.spacingExplicit || bidi != null || attrs.pageBreakBefore != null)) return;
+	if (!(attrs.alignment || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || attrs.lineSpacing || attrs.indentLeft || attrs.indentRight || attrs.indentFirstLine || attrs.numPr || attrs.styleId || attrs.borders || attrs.shading || attrs.tabs || typeof outlineLevel === "number" || attrs.contextualSpacing || attrs.spacingExplicit || bidi != null || attrs.pageBreakBefore != null || attrs.widowControl != null)) return;
 	const f = {};
 	if (attrs.alignment) f.alignment = attrs.alignment;
 	if (shouldSerializeSpaceBefore) f.spaceBefore = spaceBefore;
@@ -373,6 +374,7 @@ function paragraphAttrsToFormatting(attrs) {
 	if (attrs.contextualSpacing) f.contextualSpacing = attrs.contextualSpacing;
 	if (bidi != null) f.bidi = bidi;
 	if (attrs.pageBreakBefore != null) f.pageBreakBefore = attrs.pageBreakBefore;
+	if (attrs.widowControl != null) f.widowControl = attrs.widowControl;
 	return f;
 }
 /**
@@ -491,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();
@@ -1234,6 +1235,7 @@ function convertPMTable(node, documentCounts) {
 				rows
 			};
 			if (attrs.columnWidths) minTable.columnWidths = attrs.columnWidths;
+			restoreTablePropertyChanges(minTable, attrs);
 			return minTable;
 		}
 	}
@@ -1243,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();
@@ -1367,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) {
@@ -1397,9 +1409,11 @@ function tableRowAttrsToFormatting(attrs) {
 		else delete result.heightRule;
 		if (attrs.isHeader !== (orig.header ?? void 0)) if (attrs.isHeader) result.header = attrs.isHeader;
 		else delete result.header;
+		if (attrs.hidden !== (orig.hidden ?? void 0)) if (attrs.hidden) result.hidden = attrs.hidden;
+		else delete result.hidden;
 		return result;
 	}
-	if (!(attrs.height || attrs.isHeader)) return;
+	if (!(attrs.height || attrs.isHeader || attrs.hidden)) return;
 	const f = {};
 	if (attrs.height) f.height = {
 		value: attrs.height,
@@ -1407,6 +1421,7 @@ function tableRowAttrsToFormatting(attrs) {
 	};
 	if (attrs.heightRule) f.heightRule = attrs.heightRule;
 	if (attrs.isHeader) f.header = attrs.isHeader;
+	if (attrs.hidden) f.hidden = attrs.hidden;
 	return f;
 }
 /**
@@ -1425,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

@@ -11,6 +11,7 @@ import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { schema } from "../schema/index.js";
 //#region src/prosemirror/conversion/toProseDoc.ts
+const TOC_STYLE_ID = /^TOC\d*$/iu;
 /**
 * Convert a Document to a ProseMirror document
 *
@@ -80,6 +81,7 @@ function convertBlockSdt(blockSdt, convertBlocks) {
 */
 function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFormatting, tableParagraphOverlay) {
 	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
+	const isTocParagraph = TOC_STYLE_ID.test(paragraph.formatting?.styleId ?? "");
 	const inlineNodes = [];
 	let inlineOffset = 0;
 	let bookmarksArr;
@@ -98,13 +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 inheritableParagraphRunFormatting = paragraphRunFormatting ? stripParagraphMarkOnlyFormatting(paragraphRunFormatting) : 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 getInheritedRunFormatting = (formatting) => {
+	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));
@@ -224,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;
@@ -241,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;
@@ -252,11 +267,12 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		set("pageBreakBefore", formatting?.pageBreakBefore ?? stylePpr?.pageBreakBefore);
 		set("keepNext", formatting?.keepNext ?? stylePpr?.keepNext);
 		set("keepLines", formatting?.keepLines ?? stylePpr?.keepLines);
+		set("widowControl", formatting?.widowControl ?? stylePpr?.widowControl);
 		set("contextualSpacing", formatting?.contextualSpacing ?? stylePpr?.contextualSpacing);
 		set("runInWithNext", formatting?.runInWithNext ?? stylePpr?.runInWithNext);
 		set("outlineLevel", formatting?.outlineLevel ?? stylePpr?.outlineLevel);
 		set("direction", directionFromBidi(formatting?.bidi ?? stylePpr?.bidi));
-		set("defaultTextFormatting", resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver));
+		set("defaultTextFormatting", resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, { includeParagraphMarkRunProperties: !TOC_STYLE_ID.test(styleId ?? "") }));
 		if (!formatting?.numPr && stylePpr?.numPr && stylePpr.numPr.numId !== 0) {
 			attrs.numPr = stylePpr.numPr;
 			attrs.numPrFromStyle = stylePpr.numPr;
@@ -278,6 +294,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		set("pageBreakBefore", formatting?.pageBreakBefore);
 		set("keepNext", formatting?.keepNext);
 		set("keepLines", formatting?.keepLines);
+		set("widowControl", formatting?.widowControl);
 		set("runInWithNext", formatting?.runInWithNext);
 		set("outlineLevel", formatting?.outlineLevel);
 		set("direction", directionFromBidi(formatting?.bidi));
@@ -381,12 +398,12 @@ function hasDirectRunFormatting(formatting) {
 	return Object.entries(formatting).some(([key, value]) => key !== "styleId" && value !== void 0);
 }
 function stripParagraphMarkOnlyFormatting(formatting) {
-	const { highlight: _h, shading: _s, ...rest } = 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");
@@ -399,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) {
@@ -411,13 +431,17 @@ function resolveTextFormatting(formatting, styleResolver) {
 	if (!styleResolver) return formatting;
 	return mergeTextFormatting(styleResolver.resolveRunStyle(formatting.styleId), formatting);
 }
-function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver) {
+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 = 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 rawParagraphMarkRpr = options.includeParagraphMarkRunProperties === false ? void 0 : formatting?.runProperties;
+	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();
@@ -543,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);
@@ -599,7 +624,9 @@ function convertTableRow(row, styleResolver, isHeaderRow, columnWidths, totalWid
 	const attrs = { isHeader: !!row.formatting?.header };
 	if (row.formatting?.height?.value !== void 0) attrs.height = row.formatting.height.value;
 	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;
@@ -745,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 = [];
@@ -769,7 +797,7 @@ function convertField(field, getInheritedRunFormatting, styleResolver) {
 		if (!fieldFormatting && r.formatting) fieldFormatting = r.formatting;
 	}
 	if (!fieldFormatting && field.type === "complexField" && field.fieldResult.length === 0) fieldFormatting = field.formatting;
-	const inheritedFormatting = getInheritedRunFormatting(fieldFormatting);
+	const inheritedFormatting = getInheritedRunFormatting(fieldFormatting, field.fieldType);
 	const { marks } = buildRunMarks(fieldFormatting, inheritedFormatting, styleResolver);
 	return schema.node("field", {
 		fieldType: field.fieldType,

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 },
@@ -213,6 +215,7 @@ const paragraphNodeSpec = {
 		renderedPageBreakBefore: { default: null },
 		keepNext: { default: null },
 		keepLines: { default: null },
+		widowControl: { default: null },
 		contextualSpacing: { default: null },
 		runInWithNext: { default: null },
 		defaultTextFormatting: { 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;
 }