@stll/folio-core 0.3.0 → 0.4.0

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

@@ -16,13 +16,13 @@ function hasAuthoredVisualContent(block) {
 	if (attrs.spacingExplicit?.before || attrs.spacingExplicit?.after) return true;
 	return false;
 }
-function normalizeHeaderFooterMeasureBlocks(blocks) {
-	return normalizeFlowBlockArray(blocks);
+function normalizeHeaderFooterMeasureBlocks(blocks, section = "header") {
+	return normalizeFlowBlockArray(blocks, { suppressTrailingEmptyAfterTable: section === "header" });
 }
-function normalizeFlowBlockArray(blocks) {
+function normalizeFlowBlockArray(blocks, normalization) {
 	const trailingEmptyAfterTable = /* @__PURE__ */ new Set();
 	const lastIndex = blocks.length - 1;
-	if (lastIndex > 0) {
+	if (normalization.suppressTrailingEmptyAfterTable && lastIndex > 0) {
 		const cur = blocks[lastIndex];
 		if (blocks[lastIndex - 1]?.kind === "table" && cur?.kind === "paragraph" && cur.runs.length === 0 && !hasAuthoredVisualContent(cur)) trailingEmptyAfterTable.add(lastIndex);
 	}
@@ -70,12 +70,21 @@ function normalizeFlowBlockArray(blocks) {
 		};
 	});
 }
+function isCanonicalTrailingEmptyParagraphAfterTable(blocks, index) {
+	const cur = blocks[index];
+	const prev = blocks[index - 1];
+	return index === blocks.length - 1 && prev?.kind === "table" && cur?.kind === "paragraph" && isVisuallyEmptyParagraph(cur) && !hasAuthoredVisualContent(cur);
+}
+function isVisuallyEmptyParagraph(block) {
+	if (block.kind !== "paragraph") return false;
+	return block.runs.every((run) => run.kind === "text" && run.text.trim().length === 0);
+}
 function normalizeTableBlock(block) {
 	const blockState = { changed: false };
 	const rows = block.rows.map((row) => {
 		const rowState = { changed: false };
 		const cells = row.cells.map((cell) => {
-			const normalizedBlocks = normalizeFlowBlockArray(cell.blocks);
+			const normalizedBlocks = normalizeFlowBlockArray(cell.blocks, { suppressTrailingEmptyAfterTable: true });
 			if (!normalizedBlocks.some((normalizedBlock, idx) => normalizedBlock !== cell.blocks[idx])) return cell;
 			rowState.changed = true;
 			return {
@@ -232,6 +241,7 @@ function calculateHeaderFooterMarginPushBounds(blocks, measures, flowHeight, met
 		const block = blocks[i];
 		const measure = measures[i];
 		if (!block || !measure) continue;
+		if (isCanonicalTrailingEmptyParagraphAfterTable(blocks, i)) continue;
 		if (block.kind === "paragraph" && measure.kind === "paragraph") {
 			const paragraphBottomY = cursorY + measure.totalHeight;
 			top = Math.min(top, cursorY);
@@ -312,7 +322,7 @@ function convertHeaderFooterPmDocToContent(pmDoc, contentWidth, metrics, options
 }
 function finalizeHeaderFooterContent(blocks, contentWidth, metrics, options) {
 	if (blocks.length === 0) return;
-	const blocksForMeasure = normalizeHeaderFooterMeasureBlocks(blocks);
+	const blocksForMeasure = normalizeHeaderFooterMeasureBlocks(blocks, metrics.section);
 	const measures = options.measureBlocks(blocksForMeasure, contentWidth);
 	let flowHeight = 0;
 	for (let i = 0; i < measures.length; i++) {

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

@@ -1,5 +1,5 @@
-import { FlowBlock } from "../../layout-engine/types.js";
 import { TemplatePreviewValue } from "../../prosemirror/plugins/templatePreviewValues.js";
+import { FlowBlock } from "../../layout-engine/types.js";
 
 //#region src/layout-bridge/convert/templatePreviewFlow.d.ts
 /** One marker→value substitution, in PM doc positions. */

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

@@ -732,6 +732,7 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 	if (pmAttrs.pageBreakBefore) attrs.pageBreakBefore = true;
 	if (pmAttrs.keepNext) attrs.keepNext = true;
 	if (pmAttrs.keepLines) attrs.keepLines = true;
+	if (pmAttrs.widowControl === false) attrs.widowControl = false;
 	if (pmAttrs.contextualSpacing) attrs.contextualSpacing = true;
 	if (pmAttrs.runInWithNext) attrs.runInWithNext = true;
 	if (directionIsRtl(pmAttrs.direction)) attrs.bidi = true;
@@ -941,6 +942,7 @@ function convertTableRow(node, startPos, options, tableCellMargins) {
 	if (attrs.height) row.height = twipsToPixels(attrs.height);
 	if (attrs.heightRule) row.heightRule = attrs.heightRule;
 	if (attrs.isHeader) row.isHeader = attrs.isHeader;
+	if (attrs.hidden) row.hidden = attrs.hidden;
 	return row;
 }
 /**

package/dist/layout-engine/index.js

@@ -72,6 +72,9 @@ function getSpacingAfter(block) {
 	if (isEmptyParagraph(block) && !block.attrs?.spacingExplicit?.after) return 0;
 	return value;
 }
+function hasWidowControl(block) {
+	return block.attrs?.widowControl !== false;
+}
 /**
 * Apply contextual spacing suppression (OOXML §17.3.1.9).
 *
@@ -309,6 +312,28 @@ function layoutParagraph(block, measure, paginator, contentWidth, footnoteHeight
 				fittingLines++;
 			} else break;
 		}
+		let forceBreakAfterFragment = false;
+		if (hasWidowControl(block)) {
+			const remainingAfter = lines.length - (currentLineIndex + fittingLines);
+			if (fittingLines > 1 && remainingAfter === 1) {
+				if (currentLineIndex === 0 && fittingLines === 2 && state.cursorY !== state.topMargin) {
+					paginator.forceColumnBreak();
+					continue;
+				}
+				fittingLines -= 1;
+				forceBreakAfterFragment = true;
+				linesHeight = 0;
+				linesFnHeight = 0;
+				linesFnIds.length = 0;
+				for (let j = currentLineIndex; j < currentLineIndex + fittingLines; j++) {
+					const line = lines[j];
+					linesHeight += measuredLineAdvance(line);
+					const lineRefs = getLineFootnoteRefs(block, line.fromRun, line.toRun, footnoteHeightById);
+					linesFnHeight += lineRefs.height;
+					for (const id of lineRefs.ids) linesFnIds.push(id);
+				}
+			}
+		}
 		const isFirstFragment = currentLineIndex === 0;
 		const isLastFragment = currentLineIndex + fittingLines >= lines.length;
 		const effectiveSpaceBefore = isFirstFragment ? spaceBefore : 0;
@@ -336,7 +361,8 @@ function layoutParagraph(block, measure, paginator, contentWidth, footnoteHeight
 		fragment.y = paginator.addFragment(fragment, linesHeight, effectiveSpaceBefore, effectiveSpaceAfter).y;
 		if (linesFnHeight > 0) paginator.addFootnoteHeight(linesFnHeight, linesFnIds);
 		currentLineIndex += fittingLines;
-		if (currentLineIndex < lines.length) paginator.ensureFits(measuredLineAdvance(lines[currentLineIndex]));
+		if (currentLineIndex < lines.length) if (forceBreakAfterFragment) paginator.forceColumnBreak();
+		else paginator.ensureFits(measuredLineAdvance(lines[currentLineIndex]));
 	}
 }
 /**

package/dist/layout-engine/measure/measureBlocks.js

@@ -71,6 +71,11 @@ function measureTableCellBlockVisualHeight(block, blockMeasure) {
 	}
 	let maxImageHeight = 0;
 	for (const run of inlineImageRuns) maxImageHeight = Math.max(maxImageHeight, run.height);
+	if (inlineImageRuns.length === 1) {
+		const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
+		const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
+		return spacingBefore + maxImageHeight + spacingAfter;
+	}
 	const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
 	const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
 	return spacingBefore + maxImageHeight + spacingAfter;
@@ -143,6 +148,16 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	});
 	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
 		const row = rows[rowIdx];
+		const sourceRow = tableBlock.rows[rowIdx];
+		if (sourceRow?.hidden) {
+			row.height = 0;
+			row.cells = sourceRow.cells.map(() => ({
+				blocks: [],
+				width: 0,
+				height: 0
+			}));
+			continue;
+		}
 		const sourceRowCells = tableBlock.rows[rowIdx]?.cells;
 		let maxCellHeightWithBorders = 0;
 		for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {
@@ -160,7 +175,6 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			cell.height += padTop + padBottom;
 			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + getTableCellVerticalBorderHeight(sourceCell));
 		}
-		const sourceRow = tableBlock.rows[rowIdx];
 		const explicitHeight = sourceRow?.height;
 		const heightRule = sourceRow?.heightRule;
 		if (explicitHeight && heightRule === "exact") row.height = explicitHeight;

package/dist/layout-engine/measure/measureParagraph.js

@@ -21,6 +21,10 @@ const DEFAULT_FONT_SIZE = 11;
 const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
+const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
+const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .025;
+const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
+const ALL_CAPS_RATIO_THRESHOLD = .8;
 /**
 * Find the longest prefix of `text` that fits within `maxWidth` pixels.
 * Returns the number of characters that fit (at least 1 if `forceMin` is true).
@@ -266,6 +270,10 @@ function hasFollowingTabOnLine(runs, tabIndex) {
 	}
 	return false;
 }
+function canClampTabToRightEdge(alignment, currentLineWidth) {
+	if (alignment === "start" || alignment === "default") return currentLineWidth > WIDTH_TOLERANCE;
+	return true;
+}
 /**
 * Width of the inline content preceding the first `.` in the runs that follow
 * a tab, used to anchor `decimal` tab stops. Mirrors `getTextAfterTab` +
@@ -299,6 +307,25 @@ function measureDecimalPrefixWidthAfterTab(runs, tabIndex, fieldValues) {
 function isSpaceOrTab(char) {
 	return char === " " || char === "	";
 }
+function uppercaseLetterRatio(text) {
+	let letters = 0;
+	let uppercase = 0;
+	for (const char of text) {
+		const lower = char.toLocaleLowerCase();
+		const upper = char.toLocaleUpperCase();
+		if (lower === upper) continue;
+		letters++;
+		if (char === upper) uppercase++;
+	}
+	return letters === 0 ? 0 : uppercase / letters;
+}
+function justifyShrinkToleranceRatio(block) {
+	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
+	const hasTabRuns = block.runs.some(isTabRun);
+	if (hasTabStops || hasTabRuns) return (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO;
+	if (uppercaseLetterRatio(block.runs.map((run) => isTextRun(run) ? run.text ?? "" : "").join("")) > ALL_CAPS_RATIO_THRESHOLD) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
+	return JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO;
+}
 function trimTrailingSpacesAndTabs(text) {
 	let end = text.length;
 	while (end > 0) {
@@ -384,6 +411,8 @@ function measureParagraph(block, maxWidth, options) {
 	const runs = block.runs;
 	const attrs = block.attrs;
 	const spacing = attrs?.spacing;
+	const isJustifiedParagraph = attrs?.alignment === "justify";
+	const justifyToleranceRatio = justifyShrinkToleranceRatio(block);
 	const floatingZones = options?.floatingZones;
 	const paragraphYOffset = options?.paragraphYOffset ?? 0;
 	const indent = attrs?.indent;
@@ -589,15 +618,16 @@ function measureParagraph(block, maxWidth, options) {
 			const lineX = currentLine.width + currentLine.leftOffset;
 			const isFirstLine = lines.length === 0;
 			const contentX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + lineX;
-			let tabWidth = calculateTabWidth(contentX, {
+			const tabResult = calculateTabWidth(contentX, {
 				...attrs?.tabs !== void 0 ? { explicitStops: attrs.tabs } : {},
 				leftIndent: pixelsToTwips(indentLeft)
 			}, {
 				followingWidth,
 				decimalPrefixWidth
-			}).width;
+			});
+			let tabWidth = tabResult.width;
 			const lineRightEdgeX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + currentLine.availableWidth + currentLine.leftOffset;
-			if (!hasFollowingTabOnLine(runs, runIndex) && (tabWidth > 0 || followingWidth > 0) && contentX + tabWidth + followingWidth > lineRightEdgeX + WIDTH_TOLERANCE) tabWidth = Math.max(1, lineRightEdgeX - contentX - followingWidth);
+			if (!hasFollowingTabOnLine(runs, runIndex) && canClampTabToRightEdge(tabResult.alignment, currentLine.width) && (tabWidth > 0 || followingWidth > 0) && contentX + tabWidth + followingWidth > lineRightEdgeX + WIDTH_TOLERANCE) tabWidth = Math.max(1, lineRightEdgeX - contentX - followingWidth);
 			if (currentLine.width + tabWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
 				startNewLine(runIndex, 0);
 				updateMaxFont(style);
@@ -691,7 +721,8 @@ function measureParagraph(block, maxWidth, options) {
 				}
 				const word = text.slice(charIndex, nextBreak);
 				const wordWidth = measureTextWidth(word, style);
-				if (wordWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+				const widthTolerance = isJustifiedParagraph ? Math.max(WIDTH_TOLERANCE, currentLine.availableWidth * justifyToleranceRatio) : WIDTH_TOLERANCE;
+				if (wordWidth > currentLine.availableWidth + widthTolerance) {
 					let chunkStart = 0;
 					while (chunkStart < word.length) {
 						const spaceLeft = currentLine.availableWidth - currentLine.width + WIDTH_TOLERANCE;
@@ -719,8 +750,8 @@ function measureParagraph(block, maxWidth, options) {
 					continue;
 				}
 				const rawGlueWidth = nextBreak === text.length && word.length > 0 && !isBreakChar(word[word.length - 1]) ? trailingGlueWidths[runIndex] ?? 0 : 0;
-				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + WIDTH_TOLERANCE ? rawGlueWidth : 0;
-				if (currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + widthTolerance ? rawGlueWidth : 0;
+				if (currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + widthTolerance) {
 					startNewLine(runIndex, charIndex);
 					updateMaxFont(lineHeightStyle);
 				}

package/dist/layout-engine/types.d.ts

@@ -303,6 +303,7 @@ type ParagraphAttrs = {
   indent?: ParagraphIndent;
   keepNext?: boolean;
   keepLines?: boolean;
+  widowControl?: boolean;
   pageBreakBefore?: boolean;
   styleId?: string;
   contextualSpacing?: boolean;
@@ -432,6 +433,7 @@ type TableRow = {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  hidden?: boolean;
 };
 /**
  * Floating table positioning info (pixel values).
@@ -518,6 +520,7 @@ type SectionBreakBlock = {
 };
 type PageHeaderFooterRefs = {
   titlePg?: boolean;
+  evenAndOddHeaders?: boolean;
   headerDefault?: string;
   headerFirst?: string;
   headerEven?: string;

package/dist/layout-painter/renderPage.js

@@ -1162,7 +1162,8 @@ function applySectionHeaderFooterOptions(page, pageOptions, options) {
 	if (!refs) return false;
 	const isFirstSectionPage = page.sectionPageNumber === 1;
 	const useFirst = refs.titlePg === true && isFirstSectionPage;
-	const useEven = (page.sectionPageNumber ?? page.number) % 2 === 0;
+	const sectionPageNumber = page.sectionPageNumber ?? page.number;
+	const useEven = refs.evenAndOddHeaders === true && sectionPageNumber % 2 === 0;
 	const headerRId = (() => {
 		if (useFirst) return refs.headerFirst;
 		if (useEven && refs.headerEven) return refs.headerEven;

package/dist/layout-painter/renderParagraph.js

@@ -330,6 +330,10 @@ function renderTabRun(run, doc, width, leader) {
 	} else span.textContent = "\xA0";
 	return span;
 }
+function canClampTabToRightEdge(alignment, hasPriorRenderedContent) {
+	if (alignment === "start" || alignment === "default") return hasPriorRenderedContent;
+	return true;
+}
 function applyTabUnderline(element, run) {
 	if (!run.underline) return;
 	removeUnderlineTextDecoration(element);
@@ -529,7 +533,9 @@ const EMPTY_SEQ_VALUES = /* @__PURE__ */ new Map();
 * Returns the cached fallback when no render context is available.
 */
 function resolveFieldText(run, context) {
-	if (!context) return run.fallback ?? "";
+	const fallback = run.fallback ?? "";
+	if (run.fieldType === "OTHER" && run.pmStart === void 0) return fallback;
+	if (!context) return fallback;
 	const fieldContext = {
 		pageNumber: context.pageNumber,
 		totalPages: context.totalPages,
@@ -540,7 +546,7 @@ function resolveFieldText(run, context) {
 		...context.sectionPages === void 0 ? {} : { sectionPages: context.sectionPages }
 	};
 	return evaluateFieldInstruction(run.instruction || run.fieldType, fieldContext, {
-		fallback: run.fallback ?? "",
+		fallback,
 		...run.pmStart === void 0 ? {} : { instanceId: run.pmStart },
 		...run.fldLock ? { locked: true } : {}
 	});
@@ -710,6 +716,17 @@ function splitTextRunsByEastAsia(runs) {
 * must trigger within this slack.
 */
 const RIGHT_EDGE_EPSILON_PX = .5;
+function countShrinkableSpaces(runs) {
+	let count = 0;
+	for (const run of runs) if (isTextRun(run)) {
+		for (const char of run.text ?? "") if (char === " ") count++;
+	} else if (isFieldRun(run)) {
+		for (const char of run.fallback ?? "") if (char === " ") count++;
+	} else if (isMathRun(run)) {
+		for (const char of run.plainText ?? "") if (char === " ") count++;
+	}
+	return count;
+}
 /**
 * Build a TextMeasureStyle from a TextRun or FieldRun's relevant fields.
 */
@@ -890,8 +907,16 @@ function renderLine(block, line, alignment, doc, options) {
 	}
 	if (alignment === "justify" && options) {
 		if (!options.isLastLine || options.paragraphEndsWithLineBreak) {
-			lineEl.style.textAlign = "justify";
-			lineEl.style.textAlignLast = "justify";
+			const overfullPx = line.width - options.availableWidth;
+			const shrinkableSpaces = countShrinkableSpaces(runsForLine);
+			if (overfullPx > RIGHT_EDGE_EPSILON_PX && shrinkableSpaces > 0) {
+				lineEl.style.textAlign = "left";
+				lineEl.style.textAlignLast = "auto";
+				lineEl.style.wordSpacing = `${-overfullPx / shrinkableSpaces}px`;
+			} else {
+				lineEl.style.textAlign = "justify";
+				lineEl.style.textAlignLast = "justify";
+			}
 			lineEl.style.width = `${options.availableWidth}px`;
 		}
 	}
@@ -967,7 +992,7 @@ function renderLine(block, line, alignment, doc, options) {
 				break;
 			}
 			let tabWidth = tabResult.width;
-			if (lineRightEdgeX !== void 0 && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
+			if (lineRightEdgeX !== void 0 && canClampTabToRightEdge(tabResult.alignment, i > 0) && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
 			const tabEl = renderTabRun(run, doc, tabWidth, tabResult.leader);
 			lineEl.append(tabEl);
 			currentX += tabWidth;

package/dist/layout-painter/renderTable.js

@@ -97,6 +97,10 @@ function renderCellContent(cell, cellMeasure, context, doc) {
 			};
 			const fragEl = renderParagraphFragment(syntheticFragment, paragraphBlock, paragraphMeasure, cellContext, { document: doc });
 			fragEl.style.position = "relative";
+			fragEl.style.boxSizing = "border-box";
+			fragEl.style.height = `${paragraphMeasure.totalHeight}px`;
+			const spaceBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
+			if (spaceBefore > 0) fragEl.style.paddingTop = `${spaceBefore}px`;
 			contentEl.append(fragEl);
 			cumulativeY += paragraphMeasure.totalHeight;
 		} else if (block?.kind === "table" && measure?.kind === "table") {
@@ -138,6 +142,10 @@ function renderNestedTable(block, measure, context, doc) {
 		const row = block.rows[rowIndex];
 		const rowMeasure = measure.rows[rowIndex];
 		if (!row || !rowMeasure) continue;
+		if (row.hidden) {
+			y += rowMeasure.height;
+			continue;
+		}
 		const rowEl = renderTableRow(row, rowMeasure, rowIndex, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, void 0, block.bidi);
 		tableEl.append(rowEl);
 		y += rowMeasure.height;
@@ -346,6 +354,10 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 		const hdrRow = block.rows[hdrIdx];
 		const hdrRowMeasure = measure.rows[hdrIdx];
 		if (!hdrRow || !hdrRowMeasure) continue;
+		if (hdrRow.hidden) {
+			y += hdrRowMeasure.height;
+			continue;
+		}
 		const rowEl = renderTableRow(hdrRow, hdrRowMeasure, hdrIdx, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, hdrIdx === 0, block.bidi);
 		rowEl.dataset["repeatedHeader"] = "true";
 		tableEl.append(rowEl);
@@ -369,6 +381,10 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 		const row = block.rows[rowIndex];
 		const rowMeasure = measure.rows[rowIndex];
 		if (!row || !rowMeasure) continue;
+		if (row.hidden) {
+			y += rowMeasure.height;
+			continue;
+		}
 		const isFirstRowInFragment = headerRowCount > 0 && fragment.continuesFromPrev ? false : fragment.continuesFromPrev && rowIndex === fragment.fromRow;
 		const rowEl = renderTableRow(row, rowMeasure, rowIndex, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, isFirstRowInFragment, block.bidi);
 		contentParent.append(rowEl);
@@ -376,6 +392,7 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 	}
 	let handleY = 0;
 	for (let rowIdx = fragment.fromRow; rowIdx < fragment.toRow; rowIdx++) {
+		if (block.rows[rowIdx]?.hidden) continue;
 		handleY += measure.rows[rowIdx]?.height ?? 0;
 		if (rowIdx < fragment.toRow - 1) {
 			const rowHandle = doc.createElement("div");

package/dist/managers/DocumentLoaderManager.d.ts

@@ -41,7 +41,9 @@ declare class DocumentLoaderManager {
    * the result (and any error) when a newer load started while this one was in
    * flight.
    */
-  loadBuffer(buffer: DocxInput): Promise<void>;
+  loadBuffer(buffer: DocxInput, options?: {
+    password?: string | undefined;
+  }): Promise<void>;
 }
 //#endregion
 export { DocumentLoadState, DocumentLoaderCallbacks, DocumentLoaderHistory, DocumentLoaderManager };

package/dist/managers/DocumentLoaderManager.js

@@ -43,14 +43,15 @@ var DocumentLoaderManager = class {
 	* the result (and any error) when a newer load started while this one was in
 	* flight.
 	*/
-	async loadBuffer(buffer) {
+	async loadBuffer(buffer, options = {}) {
 		const { history, onError, setDocumentLoadState } = this.callbacks;
 		const generation = ++this.loadGeneration;
 		if (!(history.state !== null)) setDocumentLoadState({ status: "loading" });
 		try {
 			const doc = await parseDocx(buffer, {
 				detectVariables: false,
-				preloadFonts: false
+				preloadFonts: false,
+				password: options.password
 			});
 			if (this.loadGeneration !== generation) return;
 			this.loadParsedDocument(doc);

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

@@ -43,7 +43,8 @@ declare function computeEffectiveHeaderFooterMargins({
 /** Rendered header/footer content shared by every extender on a page. */
 type HeaderFooterExtenderContent = Omit<EffectiveHeaderFooterMarginsInput, "margins" | "pageSize" | "warn">;
 type ExtendSectionBreakMarginsInput = {
-  content: HeaderFooterExtenderContent; /** Body page size and effective margins — the inheritance seed. */
+  content: HeaderFooterExtenderContent;
+  sectionContent?: HeaderFooterExtenderContent[] | undefined; /** Body page size and effective margins — the inheritance seed. */
   bodyPageSize: {
     w: number;
     h: number;
@@ -65,6 +66,7 @@ type ExtendSectionBreakMarginsInput = {
  */
 declare function extendSectionBreakMargins(sectionBreaks: SectionBreakBlock[], {
   content,
+  sectionContent,
   bodyPageSize,
   bodyMargins,
   warn

package/dist/paged-layout/headerFooterMargins.js

@@ -102,14 +102,16 @@ function computeEffectiveHeaderFooterMargins({ margins, headerContent, footerCon
 * clamped reservation (and vice versa). Materializes `margins` on every
 * non-inheriting break in place.
 */
-function extendSectionBreakMargins(sectionBreaks, { content, bodyPageSize, bodyMargins, warn }) {
+function extendSectionBreakMargins(sectionBreaks, { content, sectionContent, bodyPageSize, bodyMargins, warn }) {
 	let pageSize = bodyPageSize;
 	let margins = bodyMargins;
-	for (const sb of sectionBreaks) {
+	for (let index = 0; index < sectionBreaks.length; index++) {
+		const sb = sectionBreaks[index];
+		if (!sb) continue;
 		if (!sb.pageSize && !sb.margins) continue;
 		pageSize = sb.pageSize ?? pageSize;
 		margins = computeHeaderFooterMarginExtender({
-			...content,
+			...sectionContent?.[index + 1] ?? content,
 			pageSize,
 			warn
 		})(sb.margins ?? margins);

package/dist/prosemirror/attrs/index.js

@@ -236,6 +236,7 @@ const readTableRowAttrs = (node) => {
 	optionalNumber(attrs, "height", "tableRow.attrs.height", issues);
 	optionalOneOf(attrs, "heightRule", "tableRow.attrs.heightRule", issues, TABLE_ROW_HEIGHT_RULE_VALUES);
 	optionalBoolean(attrs, "isHeader", "tableRow.attrs.isHeader", issues);
+	optionalBoolean(attrs, "hidden", "tableRow.attrs.hidden", issues);
 	optionalRecord(attrs, "_originalFormatting", "tableRow.attrs._originalFormatting", issues);
 	return attrsResult(attrs, issues);
 };

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;
 }
 /**
@@ -1397,9 +1399,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 +1411,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;
 }
 /**

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;
@@ -99,10 +101,12 @@ 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;
+	let inheritableParagraphRunFormatting;
+	if (paragraphRunFormatting && !isTocParagraph) inheritableParagraphRunFormatting = stripParagraphMarkOnlyFormatting(paragraphRunFormatting);
 	const baseRunFormatting = mergeTextFormatting(styleRunFormatting, extraRunFormatting);
 	const defaultRunFormatting = mergeTextFormatting(baseRunFormatting, inheritableParagraphRunFormatting);
-	const getInheritedRunFormatting = (formatting) => {
+	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);
 	};
@@ -252,11 +256,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 +283,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,7 +387,7 @@ 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) {
@@ -411,10 +417,10 @@ function resolveTextFormatting(formatting, styleResolver) {
 	if (!styleResolver) return formatting;
 	return mergeTextFormatting(styleResolver.resolveRunStyle(formatting.styleId), formatting);
 }
-function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver) {
+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 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);
@@ -599,6 +605,7 @@ 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;
 	const numCells = row.cells.length;
 	const isFirstRow = rowIndex === 0;
@@ -769,7 +776,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

@@ -213,6 +213,7 @@ const paragraphNodeSpec = {
 		renderedPageBreakBefore: { default: null },
 		keepNext: { default: null },
 		keepLines: { default: null },
+		widowControl: { default: null },
 		contextualSpacing: { default: null },
 		runInWithNext: { default: null },
 		defaultTextFormatting: { default: null },