@stll/folio-core 0.7.0 → 0.9.0

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

@@ -0,0 +1,17 @@
+import { ParagraphBlock } from "./types.js";
+
+//#region src/layout-engine/paragraphSpacing.d.ts
+/** Whether a paragraph has no visible run content. */
+declare function isEmptyParagraph(block: ParagraphBlock): boolean;
+/**
+ * Resolve leading paragraph spacing after applying the empty-paragraph
+ * inherited-spacing collapse rule.
+ */
+declare function getParagraphSpacingBefore(block: ParagraphBlock): number;
+/**
+ * Resolve trailing paragraph spacing after applying the empty-paragraph
+ * inherited-spacing collapse rule.
+ */
+declare function getParagraphSpacingAfter(block: ParagraphBlock): number;
+//#endregion
+export { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph };

package/dist/layout-engine/paragraphSpacing.js

@@ -0,0 +1,30 @@
+//#region src/layout-engine/paragraphSpacing.ts
+/** Whether a paragraph has no visible run content. */
+function isEmptyParagraph(block) {
+	if (block.runs.length === 0) return true;
+	if (block.runs.length !== 1) return false;
+	const run = block.runs.at(0);
+	return run?.kind === "text" && run.text === "";
+}
+/**
+* Resolve leading paragraph spacing after applying the empty-paragraph
+* inherited-spacing collapse rule.
+*/
+function getParagraphSpacingBefore(block) {
+	const value = block.attrs?.spacing?.before ?? 0;
+	if (value === 0) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.hasDirectParagraphMarkFormatting && !block.attrs?.spacingExplicit?.before) return 0;
+	return value;
+}
+/**
+* Resolve trailing paragraph spacing after applying the empty-paragraph
+* inherited-spacing collapse rule.
+*/
+function getParagraphSpacingAfter(block) {
+	const value = block.attrs?.spacing?.after ?? 0;
+	if (value === 0) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.hasDirectParagraphMarkFormatting && !block.attrs?.spacingExplicit?.after) return 0;
+	return value;
+}
+//#endregion
+export { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph };

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

@@ -0,0 +1,63 @@
+import { FlowBlock, Page } from "./types.js";
+
+//#region src/layout-engine/renderedBreakReconciliation.d.ts
+type RenderedBreakState = {
+  type: "noPageAdvance";
+} | {
+  type: "pageAdvance";
+  reason: "ordinary" | "reflowBoundary";
+} | {
+  type: "pageAdvance";
+  reason: "authoredBoundary";
+  boundary: "hardBreak" | "sectionBreak";
+};
+declare const INITIAL_RENDERED_BREAK_STATE: RenderedBreakState;
+type ReconcileBeforeBlockOptions = {
+  state: RenderedBreakState;
+  block: FlowBlock;
+  previousBlock: FlowBlock | undefined;
+  page: Page;
+  blocksById: ReadonlyMap<string, FlowBlock>;
+  hasExplicitPageBreak: boolean;
+  renderedBreakNeedsSnap: boolean;
+};
+type BreakDecision = {
+  forcePageBreak: boolean;
+  suppressSpaceBefore: boolean;
+  state: RenderedBreakState;
+};
+/**
+ * Reconcile an authored or cached break before laying out one block.
+ *
+ * Cached markers describe a boundary at a paragraph, not an ordinal page.
+ * Natural reflow may therefore satisfy the marker before layout reaches it.
+ * Every marker consumes the accumulated advance state so later markers make
+ * independent decisions.
+ */
+declare const reconcileBreakBeforeBlock: ({
+  state,
+  block,
+  previousBlock,
+  page,
+  blocksById,
+  hasExplicitPageBreak,
+  renderedBreakNeedsSnap
+}: ReconcileBeforeBlockOptions) => BreakDecision;
+declare const recordReflowBoundary: (state: RenderedBreakState, crossedPageBoundary: boolean) => RenderedBreakState;
+type ReconcileAfterBlockOptions = {
+  state: RenderedBreakState;
+  block: FlowBlock;
+  pageNumberBefore: number;
+  pageNumberAfter: number;
+  previousPage: Page | undefined;
+};
+/** Record page movement and carry authored boundaries across pagination-empty paragraphs. */
+declare const reconcileAfterBlock: ({
+  state,
+  block,
+  pageNumberBefore,
+  pageNumberAfter,
+  previousPage
+}: ReconcileAfterBlockOptions) => RenderedBreakState;
+//#endregion
+export { INITIAL_RENDERED_BREAK_STATE, RenderedBreakState, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };

package/dist/layout-engine/renderedBreakReconciliation.js

@@ -0,0 +1,86 @@
+import { continuesNumberedSequence, continuesTabbedParagraphSequence } from "./paragraphSequence.js";
+//#region src/layout-engine/renderedBreakReconciliation.ts
+const INITIAL_RENDERED_BREAK_STATE = { type: "noPageAdvance" };
+/**
+* Reconcile an authored or cached break before laying out one block.
+*
+* Cached markers describe a boundary at a paragraph, not an ordinal page.
+* Natural reflow may therefore satisfy the marker before layout reaches it.
+* Every marker consumes the accumulated advance state so later markers make
+* independent decisions.
+*/
+const reconcileBreakBeforeBlock = ({ state, block, previousBlock, page, blocksById, hasExplicitPageBreak, renderedBreakNeedsSnap }) => {
+	if (hasExplicitPageBreak) return {
+		forcePageBreak: true,
+		suppressSpaceBefore: false,
+		state: INITIAL_RENDERED_BREAK_STATE
+	};
+	if (block.kind !== "paragraph" || block.attrs?.renderedPageBreakBefore !== true) return {
+		forcePageBreak: false,
+		suppressSpaceBefore: false,
+		state
+	};
+	const markerAlreadySatisfied = pageStartsWithPreviousParagraphContinuation(page, previousBlock) || state.type === "pageAdvance" && state.reason === "authoredBoundary" || state.type === "pageAdvance" && state.reason === "reflowBoundary" || state.type === "pageAdvance" && isPaginationEmptyParagraph(block) || state.type === "pageAdvance" && (continuesNumberedSequence(previousBlock, block) || continuesTabbedParagraphSequence(previousBlock, block));
+	const forcePageBreak = (renderedBreakNeedsSnap || block.attrs?.keepNext === true) && !markerAlreadySatisfied && pageHasVisibleBodyContent(page, blocksById);
+	const followsAuthoredPageBreak = previousBlock?.kind === "pageBreak";
+	const followsSectionBreak = previousBlock?.kind === "sectionBreak";
+	const followsPageBreakingSection = followsSectionBreak && previousBlock.type !== "continuous";
+	const followsCarriedSectionBoundary = state.type === "pageAdvance" && state.reason === "authoredBoundary" && state.boundary === "sectionBreak";
+	const preserveSectionLeadingSpacing = (followsSectionBreak || followsCarriedSectionBoundary) && block.attrs?.spacingExplicit?.before === true;
+	return {
+		forcePageBreak,
+		suppressSpaceBefore: (forcePageBreak || markerAlreadySatisfied || followsAuthoredPageBreak || followsPageBreakingSection) && !preserveSectionLeadingSpacing,
+		state: INITIAL_RENDERED_BREAK_STATE
+	};
+};
+const recordReflowBoundary = (state, crossedPageBoundary) => crossedPageBoundary ? {
+	type: "pageAdvance",
+	reason: "reflowBoundary"
+} : state;
+/** Record page movement and carry authored boundaries across pagination-empty paragraphs. */
+const reconcileAfterBlock = ({ state, block, pageNumberBefore, pageNumberAfter, previousPage }) => {
+	if (isStructuralBreak(block)) {
+		if (pageNumberAfter <= pageNumberBefore) {
+			if (state.type === "pageAdvance" && state.reason === "authoredBoundary") return block.kind === "sectionBreak" ? {
+				...state,
+				boundary: "sectionBreak"
+			} : state;
+			return INITIAL_RENDERED_BREAK_STATE;
+		}
+		return {
+			type: "pageAdvance",
+			reason: "authoredBoundary",
+			boundary: block.kind === "sectionBreak" ? "sectionBreak" : "hardBreak"
+		};
+	}
+	if (block.kind === "paragraph" && isPaginationEmptyParagraph(block)) return state;
+	if (pageNumberAfter <= pageNumberBefore) return state.type === "pageAdvance" && state.reason === "authoredBoundary" ? INITIAL_RENDERED_BREAK_STATE : state;
+	return {
+		type: "pageAdvance",
+		reason: previousPage?.fragments.some(({ blockId }) => blockId === block.id) ? "reflowBoundary" : "ordinary"
+	};
+};
+const isPaginationEmptyParagraph = (block) => !hasVisibleEmptyParagraphDecoration(block) && block.runs.every((run) => {
+	if (run.kind === "text") return run.text.trim().length === 0;
+	return run.kind === "tab" || run.kind === "lineBreak";
+});
+const hasVisibleEmptyParagraphDecoration = (block) => {
+	if (block.attrs?.listMarker !== void 0 && block.attrs.listMarker.length > 0 && block.attrs.listMarkerHidden !== true) return true;
+	if (block.attrs?.shading) return true;
+	return Object.values(block.attrs?.borders ?? {}).some((border) => border !== void 0 && border.style !== "none" && border.style !== "nil" && border.width !== 0);
+};
+const pageHasVisibleBodyContent = (page, blocksById) => {
+	for (const fragment of page.fragments) {
+		if (fragment.kind !== "paragraph") return true;
+		const block = blocksById.get(String(fragment.blockId));
+		if (block?.kind !== "paragraph" || !isPaginationEmptyParagraph(block)) return true;
+	}
+	return false;
+};
+const pageStartsWithPreviousParagraphContinuation = (page, previousBlock) => {
+	if (previousBlock?.kind !== "paragraph") return false;
+	return page.fragments.some((fragment) => fragment.kind === "paragraph" && String(fragment.blockId) === String(previousBlock.id) && fragment.continuesFromPrev === true);
+};
+const isStructuralBreak = (block) => block.kind === "pageBreak" || block.kind === "columnBreak" || block.kind === "sectionBreak";
+//#endregion
+export { INITIAL_RENDERED_BREAK_STATE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };

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

@@ -9,10 +9,13 @@ type TableRowBreakInfo = {
    * at which a break is clean. Always includes the row's full height as the
    * final boundary.
    */
-  breakOffsets: number[][];
+  breakOffsets: number[][]; /** Suppressible leading paragraph whitespace after each matching break offset. */
+  continuationSkips: number[][];
 };
 /** Build break geometry for a table from its block + measure. */
 declare function buildTableRowBreakInfo(block: TableBlock, measure: TableMeasure): TableRowBreakInfo;
+/** Leading empty-paragraph whitespace to consume when a row resumes after `offset`. */
+declare function getRowContinuationSkip(info: TableRowBreakInfo, rowIndex: number, offset: number): number;
 /**
  * Given a row and how much of it has already been placed (`fromOffset`), return
  * how many more px can be placed ending on a whole line, without exceeding
@@ -20,4 +23,4 @@ declare function buildTableRowBreakInfo(block: TableBlock, measure: TableMeasure
  */
 declare function snapRowBreak(info: TableRowBreakInfo, rowIndex: number, fromOffset: number, maxSlice: number): number;
 //#endregion
-export { TableRowBreakInfo, buildTableRowBreakInfo, snapRowBreak };
+export { TableRowBreakInfo, buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak };

package/dist/layout-engine/tableRowBreak.js

@@ -1,28 +1,24 @@
-import { isFloatingTextBoxBlock } from "./types.js";
 import { measureParagraph } from "./measure/measureParagraph.js";
+import { isEmptyParagraph } from "./paragraphSpacing.js";
+import { createTableCellFlowState, placeTableCellBlock } from "./measure/tableCellFlow.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "./measure/tableCellFloating.js";
 //#region src/layout-engine/tableRowBreak.ts
 /**
 * Table row-break geometry. Ported from eigenpal/docx-editor#698 (folio subset).
 *
-* Word lets a table row break across a page boundary ("allow row to break
-* across pages", on by default). When a row is taller than a whole page it
-* cannot fit anywhere, so the portion that fits stays and the rest continues on
-* the next page — broken between whole text lines, never through a glyph.
-* Without this folio forced the oversized row onto one page and the overflow
-* was clipped (content lost; upstream #570).
+* Table rows may break across flow regions unless `cantSplit` is set. When a
+* permitted row exceeds the current region, the portion that fits stays and
+* the rest continues in the next region, broken between whole text lines and
+* never through a glyph. This also prevents oversized rows from overflowing
+* one page and clipping content (upstream #570).
 *
 * This computes, per row, the safe break offsets (the y of every line bottom in
 * the row's cells) so the paginator can snap a break to the deepest whole line
 * that still fits. Vertically-merged cells that span into a row are not modeled
 * here yet (a separate follow-up); each row uses its own cells' content.
 */
+const BREAK_OFFSET_EPSILON = .01;
 const DEFAULT_TABLE_CELL_PADDING_TOP = 1;
-function getAtomicBlockHeight(measure) {
-	if ("totalHeight" in measure) return measure.totalHeight;
-	if ("height" in measure) return measure.height;
-	return 0;
-}
 function isInsideRange(offset, range) {
 	return offset > range.top && offset < range.bottom;
 }
@@ -39,6 +35,10 @@ function shiftCellGeometry(geometry, offset) {
 		unsafeRanges: geometry.unsafeRanges.map((range) => ({
 			top: range.top + offset,
 			bottom: range.bottom + offset
+		})),
+		suppressibleLeadingRanges: geometry.suppressibleLeadingRanges.map((range) => ({
+			top: range.top + offset,
+			bottom: range.bottom + offset
 		}))
 	};
 }
@@ -46,22 +46,28 @@ function shiftCellGeometry(geometry, offset) {
 function cellBreakGeometry(cell, measure) {
 	const bottoms = [];
 	const unsafeRanges = [];
+	const suppressibleLeadingRanges = [];
 	const cellBlocks = cell?.blocks;
 	const blockMeasures = measure.blocks;
 	const padTop = cell?.padding?.top ?? DEFAULT_TABLE_CELL_PADDING_TOP;
 	const contentWidth = getTableCellContentWidth(cell, measure);
 	const floatingZones = buildTableCellFloatingZones(cell !== void 0 ? getTableCellFloatingImages(cell, measure, contentWidth) : [], contentWidth);
-	let y = padTop;
-	let paragraphY = 0;
+	const flowState = createTableCellFlowState();
 	for (let i = 0; i < blockMeasures.length; i++) {
 		let blockMeasure = blockMeasures[i];
 		if (blockMeasure?.kind === "paragraph") {
 			const block = cellBlocks?.[i];
-			if (block?.kind === "paragraph" && floatingZones.length > 0) blockMeasure = measureParagraph(block, contentWidth, {
+			if (block?.kind !== "paragraph") continue;
+			if (floatingZones.length > 0) blockMeasure = measureParagraph(block, contentWidth, {
 				floatingZones,
-				paragraphYOffset: paragraphY
+				paragraphYOffset: placeTableCellBlock({ ...flowState }, block, blockMeasure).contentTop
+			});
+			const placement = placeTableCellBlock(flowState, block, blockMeasure);
+			if (placement.leadingSpacing > 0 && isEmptyParagraph(block)) suppressibleLeadingRanges.push({
+				top: padTop + placement.top,
+				bottom: padTop + placement.contentTop
 			});
-			const blockTop = y;
+			let y = padTop + placement.contentTop;
 			for (const line of blockMeasure.lines) {
 				y += line.floatSkipBefore ?? 0;
 				const top = y;
@@ -72,16 +78,15 @@ function cellBreakGeometry(cell, measure) {
 				});
 				bottoms.push(y);
 			}
-			y = blockTop + blockMeasure.totalHeight;
-			paragraphY += blockMeasure.totalHeight;
+			bottoms.push(padTop + flowState.height);
 		} else if (blockMeasure) {
 			const block = cellBlocks?.[i];
-			if (block?.kind === "textBox" && isFloatingTextBoxBlock(block)) continue;
-			const blockHeight = getAtomicBlockHeight(blockMeasure);
+			if (!block) continue;
+			const placement = placeTableCellBlock(flowState, block, blockMeasure);
+			const blockHeight = placement.contentHeight;
 			if (blockHeight > 0) {
-				const top = y;
-				y += blockHeight;
-				paragraphY += blockHeight;
+				const top = padTop + placement.contentTop;
+				const y = top + blockHeight;
 				unsafeRanges.push({
 					top,
 					bottom: y
@@ -92,9 +97,26 @@ function cellBreakGeometry(cell, measure) {
 	}
 	return {
 		bottoms,
-		unsafeRanges
+		unsafeRanges,
+		suppressibleLeadingRanges
 	};
 }
+const continuationSkipForCell = (geometry, offset) => {
+	if (!geometry.unsafeRanges.some(({ bottom }) => bottom > offset + BREAK_OFFSET_EPSILON)) return;
+	const leadingRange = geometry.suppressibleLeadingRanges.find(({ top, bottom }) => top <= offset + BREAK_OFFSET_EPSILON && bottom > offset + BREAK_OFFSET_EPSILON);
+	return leadingRange ? leadingRange.bottom - offset : 0;
+};
+/**
+* Leading spacing before an empty paragraph is consumed when a split row
+* resumes at the top of a fresh flow region. Only a whitespace band shared by
+* every cell with remaining content is suppressible; non-empty paragraphs,
+* line boxes, cell padding, and explicit row height retain authored space.
+*/
+const continuationSkipAfter = (geometries, offset) => {
+	const skips = geometries.map((geometry) => continuationSkipForCell(geometry, offset)).filter((skip) => skip !== void 0);
+	if (skips.length === 0 || skips.some((skip) => skip <= BREAK_OFFSET_EPSILON)) return 0;
+	return Math.min(...skips);
+};
 /** Build break geometry for a table from its block + measure. */
 function buildTableRowBreakInfo(block, measure) {
 	const rowCount = measure.rows.length;
@@ -106,6 +128,7 @@ function buildTableRowBreakInfo(block, measure) {
 	}
 	rowTops.push(acc);
 	const breakOffsets = [];
+	const continuationSkips = [];
 	for (let r = 0; r < rowCount; r++) {
 		const rowHeight = measure.rows[r]?.height ?? 0;
 		const offsets = /* @__PURE__ */ new Set();
@@ -121,14 +144,24 @@ function buildTableRowBreakInfo(block, measure) {
 			cellGeometries.push(geometry);
 			for (const b of geometry.bottoms) if (b > 0 && b < rowHeight) offsets.add(b);
 		}
-		const safeOffsets = [...offsets].filter((offset) => offset === rowHeight || cellGeometries.every((geometry) => geometry.unsafeRanges.every((range) => !isInsideRange(offset, range))));
-		breakOffsets.push(safeOffsets.sort((a, b) => a - b));
+		const sortedOffsets = [...offsets].filter((offset) => offset === rowHeight || cellGeometries.every((geometry) => geometry.unsafeRanges.every((range) => !isInsideRange(offset, range)))).sort((a, b) => a - b);
+		breakOffsets.push(sortedOffsets);
+		continuationSkips.push(sortedOffsets.map((offset) => continuationSkipAfter(cellGeometries, offset)));
 	}
 	return {
 		rowTops,
-		breakOffsets
+		breakOffsets,
+		continuationSkips
 	};
 }
+/** Leading empty-paragraph whitespace to consume when a row resumes after `offset`. */
+function getRowContinuationSkip(info, rowIndex, offset) {
+	const offsets = info.breakOffsets[rowIndex];
+	const skips = info.continuationSkips[rowIndex];
+	const index = offsets?.findIndex((candidate) => Math.abs(candidate - offset) <= BREAK_OFFSET_EPSILON);
+	if (index === void 0 || index < 0) return 0;
+	return skips?.[index] ?? 0;
+}
 /**
 * Given a row and how much of it has already been placed (`fromOffset`), return
 * how many more px can be placed ending on a whole line, without exceeding
@@ -147,4 +180,4 @@ function snapRowBreak(info, rowIndex, fromOffset, maxSlice) {
 	return best;
 }
 //#endregion
-export { buildTableRowBreakInfo, snapRowBreak };
+export { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak };

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

@@ -1,9 +1,9 @@
 import { OutlineStyleAttr } from "../types/documentEnumValues.js";
-import { ImagePosition, ImageWrap, SdtProperties, SdtType, TableWidthType } from "@stll/docx-core/model";
+import { ImagePosition, ImageWrap, SdtProperties, SdtType, ShapeTextBody, TableCellFormatting, TableWidthType } from "@stll/docx-core/model";
 
 //#region src/layout-engine/types.d.ts
 declare namespace types_d_exports {
-  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
+  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
 }
 /**
  * Unique identifier for a block in the document.
@@ -38,7 +38,12 @@ type RunFormatting = {
    * `segmentByScript`) so wrapping stays correct. Absent means CJK falls back
    * to `fontFamily`.
    */
-  eastAsiaFontFamily?: string;
+  eastAsiaFontFamily?: string; /** Run language metadata resolved from `w:lang`. */
+  language?: {
+    val?: string;
+    eastAsia?: string;
+    bidi?: string;
+  };
   fontSize?: number;
   letterSpacing?: number;
   superscript?: boolean;
@@ -164,7 +169,8 @@ type ImageRun = {
   distTop?: number;
   distBottom?: number;
   distLeft?: number;
-  distRight?: number;
+  distRight?: number; /** Use the image box as the exact line height for an embedded-object preview. */
+  exactLineHeight?: boolean;
   /**
    * wp:srcRect crop fractions in [0, 1]; emit as CSS `clip-path: inset(...)`
    * to match Word's visible region. eigenpal #424 (image-crop subset).
@@ -286,7 +292,26 @@ type ListNumPr = {
  * Paragraph block attributes.
  */
 type ParagraphAttrs = {
-  alignment?: "left" | "center" | "right" | "justify"; /** OOXML outline level (`w:outlineLvl`), where zero is the top level. */
+  alignment?: "left" | "center" | "right" | "justify"; /** East Asian first/last-character restrictions (`w:kinsoku`). */
+  kinsoku?: boolean; /** Hanging punctuation (`w:overflowPunct`), retained for layout policy. */
+  overflowPunctuation?: boolean; /** Exempt this paragraph from document automatic hyphenation. */
+  suppressAutoHyphens?: boolean; /** Document-wide automatic hyphenation controls retained for line layout. */
+  automaticHyphenation?: {
+    enabled: true;
+    doNotHyphenateCaps?: boolean;
+    consecutiveLineLimit?: number;
+  }; /** Document-wide custom line-edge characters and compatibility behavior. */
+  lineBreakRules?: {
+    noLineBreaksBefore?: {
+      language?: string;
+      characters: string;
+    };
+    noLineBreaksAfter?: {
+      language?: string;
+      characters: string;
+    };
+    useLegacyEthiopicAmharicRules?: boolean;
+  }; /** OOXML outline level (`w:outlineLvl`), where zero is the top level. */
   outlineLevel?: number;
   spacing?: ParagraphSpacing; /** Spacing sides resolved from OOXML automatic paragraph spacing. */
   automaticSpacing?: {
@@ -310,7 +335,8 @@ type ParagraphAttrs = {
    * source `w:pPr`. Word treats such a blank as authored and keeps its
    * inherited spacing; a bare empty paragraph still collapses that spacing.
    */
-  hasDirectParagraphFormatting?: boolean;
+  hasDirectParagraphFormatting?: boolean; /** Whether an empty paragraph carries direct formatting on its paragraph mark. */
+  hasDirectParagraphMarkFormatting?: boolean;
   indent?: ParagraphIndent;
   keepNext?: boolean;
   keepLines?: boolean;
@@ -338,6 +364,8 @@ type ParagraphAttrs = {
   listMarkerHidden?: boolean;
   listMarkerFontFamily?: string;
   listMarkerFontSize?: number;
+  listMarkerBold?: boolean; /** Horizontal alignment of the marker around the paragraph's list anchor. */
+  listMarkerAlignment?: "left" | "center" | "right";
   /**
    * `w:suff` (§17.9.25) — what follows the marker before body text.
    * `tab` (default) grows the marker to the next tab stop; `space` adds
@@ -411,6 +439,8 @@ type CellBorders = {
   bottom?: CellBorderSpec;
   left?: CellBorderSpec;
   right?: CellBorderSpec;
+  topLeftToBottomRight?: CellBorderSpec;
+  topRightToBottomLeft?: CellBorderSpec;
 };
 /**
  * A table cell with content.
@@ -422,6 +452,7 @@ type TableCell = {
   rowSpan?: number;
   width?: number;
   verticalAlign?: "top" | "center" | "bottom";
+  textDirection?: NonNullable<TableCellFormatting["textDirection"]>;
   background?: string;
   borders?: CellBorders; /** Per-cell padding in pixels (from w:tcMar or table-level w:tblCellMar) */
   padding?: {
@@ -443,9 +474,12 @@ type TableCell = {
 type TableRow = {
   id: BlockId;
   cells: TableCell[];
+  gridBefore?: number;
+  gridAfter?: number;
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
-  isHeader?: boolean;
+  isHeader?: boolean; /** `w:cantSplit`: keep this row in one flow region. */
+  cantSplit?: boolean;
   hidden?: boolean;
 };
 /**
@@ -582,7 +616,8 @@ type TextBoxBlock = {
   kind: "textBox";
   id: BlockId; /** Width in pixels */
   width: number; /** Height in pixels (may be auto-calculated) */
-  height?: number; /** Fill/background color */
+  height?: number; /** Text fitting behavior */
+  autoFit?: ShapeTextBody["autoFit"]; /** Fill/background color */
   fillColor?: string; /** Border width in pixels */
   outlineWidth?: number; /** Border color */
   outlineColor?: string; /** Outline dash style, or `"none"` for an explicit no-outline. */
@@ -664,7 +699,10 @@ type MeasuredLine = {
    * no usable horizontal room at the natural line Y. Painters render this
    * as marginTop on the line element; measurement adds it to totalHeight.
    */
-  floatSkipBefore?: number;
+  floatSkipBefore?: number; /** Decorative hyphen inserted at a dictionary break without changing source text. */
+  discretionaryHyphen?: {
+    runIndex: number;
+  };
 };
 /**
  * Measurement result for a paragraph block.
@@ -913,7 +951,8 @@ type LayoutOptions = {
    * overflowing first-page header without forcing pages 2+ to inherit the
    * same extension.
    */
-  firstPageMargins?: PageMargins; /** Body-level final section page size. */
+  firstPageMargins?: PageMargins; /** Per-section body margins used on even section pages. */
+  sectionEvenPageMargins?: (PageMargins | undefined)[]; /** Body-level final section page size. */
   finalPageSize?: {
     w: number;
     h: number;
@@ -1016,7 +1055,8 @@ type HeaderFooterContent = {
 /**
  * `true` when the image run is anchored at page-level coordinates instead of
  * participating in inline flow. Covers the OOXML floating wrap types
- * (`square`, `tight`, `through`, `behind`, `inFront`) and the legacy
+ * (`square`, `tight`, `through`, `behind`, `inFront`), explicitly positioned
+ * `topAndBottom` artwork, and the legacy
  * `displayMode === "float"` escape hatch used by ProseMirror nodes that
  * pre-date the wrap-type round-trip.
  *
@@ -1067,5 +1107,7 @@ declare function floatingTextBoxReservesBand(block: TextBoxFlowAttrs): boolean;
  * and the painter both consult this so their line count and `white-space` agree.
  */
 declare function tableColumnsArePinned(table: TableBlock): boolean;
+/** Return the leading visual offset for a row with omitted grid columns. */
+declare const getTableRowLeadingWidth: (row: TableRow, columnWidths: readonly number[]) => number;
 //#endregion
-export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };
+export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };

package/dist/layout-engine/types.js

@@ -9,6 +9,7 @@ var types_exports = /* @__PURE__ */ __exportAll({
 	FOOTNOTE_SEPARATOR_HEIGHT: () => 12,
 	floatingTextBoxReservesBand: () => floatingTextBoxReservesBand,
 	floatingTextBoxWrapsText: () => floatingTextBoxWrapsText,
+	getTableRowLeadingWidth: () => getTableRowLeadingWidth,
 	isFloatingImageRun: () => isFloatingImageRun,
 	isFloatingTextBoxBlock: () => isFloatingTextBoxBlock,
 	isTextWrappingFloatingImageRun: () => isTextWrappingFloatingImageRun,
@@ -46,7 +47,8 @@ const FOOTNOTE_FALLBACK_LINE_HEIGHT = 13;
 /**
 * `true` when the image run is anchored at page-level coordinates instead of
 * participating in inline flow. Covers the OOXML floating wrap types
-* (`square`, `tight`, `through`, `behind`, `inFront`) and the legacy
+* (`square`, `tight`, `through`, `behind`, `inFront`), explicitly positioned
+* `topAndBottom` artwork, and the legacy
 * `displayMode === "float"` escape hatch used by ProseMirror nodes that
 * pre-date the wrap-type round-trip.
 *
@@ -55,6 +57,7 @@ const FOOTNOTE_FALLBACK_LINE_HEIGHT = 13;
 */
 const isFloatingImageRun = (run) => {
 	const wrapType = run.wrapType;
+	if (wrapType === "topAndBottom" && run.position !== void 0) return true;
 	if (wrapType === "square" || wrapType === "tight" || wrapType === "through" || wrapType === "behind" || wrapType === "inFront") return true;
 	return run.displayMode === "float";
 };
@@ -114,5 +117,15 @@ function tableColumnsArePinned(table) {
 	if (table.layout === "fixed") return true;
 	return table.widthType === "dxa" || table.widthType === "pct";
 }
+const tableRowOwnsNestedGrid = (row) => {
+	const cell = row.cells.length === 1 ? row.cells.at(0) : void 0;
+	if (!cell?.blocks.some((block) => block.kind === "table")) return false;
+	return cell.blocks.every((block) => block.kind === "table" || block.kind === "paragraph" && block.runs.length === 0);
+};
+/** Return the leading visual offset for a row with omitted grid columns. */
+const getTableRowLeadingWidth = (row, columnWidths) => {
+	if (tableRowOwnsNestedGrid(row)) return 0;
+	return columnWidths.slice(0, row.gridBefore ?? 0).reduce((sum, columnWidth) => sum + columnWidth, 0);
+};
 //#endregion
-export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_exports };
+export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_exports };

package/dist/layout-painter/anchoredImagePosition.d.ts

@@ -0,0 +1,23 @@
+import { ImageRun } from "../layout-engine/types.js";
+
+//#region src/layout-painter/anchoredImagePosition.d.ts
+type PageGeometry = {
+  pageWidth: number;
+  pageHeight: number;
+  marginLeft: number;
+  marginTop: number;
+  marginRight: number;
+  marginBottom: number;
+  contentWidth: number;
+  contentHeight: number;
+};
+/** Coordinates relative to the page content area's top-left corner. */
+type AnchoredImagePosition = {
+  x: number;
+  y: number;
+  side: "left" | "right";
+};
+/** Resolve an anchored image into page-content-relative coordinates. */
+declare function resolveAnchoredImagePosition(imgRun: ImageRun, fragmentY: number, geometry: PageGeometry): AnchoredImagePosition;
+//#endregion
+export { AnchoredImagePosition, PageGeometry, resolveAnchoredImagePosition };