@stll/folio-core 0.29.0 → 0.31.0

package/dist/layout-engine/index.js

@@ -3,14 +3,14 @@ import { reflowFootnoteColumns } from "./footnoteColumnReflow.js";
 import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
 import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
 import { measuredLineAdvance } from "./lineFlow.js";
-import { resolveFloatingTableX } from "./measure/floatingTablePosition.js";
-import { resolveTableInlinePlacement } from "./measure/tableInlinePlacement.js";
-import { createPaginator } from "./paginator.js";
+import { resolveFloatingTablePageX } from "./measure/floatingTablePosition.js";
+import { resolveTableInlineOffset } from "./measure/tableInlinePlacement.js";
+import { SECTION_START_PLACEMENT, createPaginator } from "./paginator.js";
 import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
 import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacingTree } from "./paragraphSpacing.js";
 import { assertExhaustiveFlowBlock, findPageIndexContainingPmPos } from "./pmPageIndex.js";
-import { INITIAL_RENDERED_BREAK_STATE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary } from "./renderedBreakReconciliation.js";
-import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak } from "./section-breaks.js";
+import { INITIAL_RENDERED_BREAK_STATE, PAGE_ADVANCE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary } from "./renderedBreakReconciliation.js";
+import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, normalizeSectionBreakType, scheduleSectionBreak } from "./section-breaks.js";
 import { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak } from "./tableRowBreak.js";
 import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
 import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, resolveTableCellPadding, tableColumnsArePinned } from "./types.js";
@@ -26,7 +26,6 @@ const DEFAULT_COLUMNS = {
 	count: 1,
 	gap: 0
 };
-const DEFAULT_SECTION_BREAK_TYPE = "nextPage";
 const CONTINUE_PAGE_NUMBERING = { type: "continue" };
 function collectSectionConfigs(blocks, initialConfig, finalConfig) {
 	const configs = [];
@@ -215,7 +214,7 @@ function layoutDocumentPass(blocks, measures, options) {
 		const firstLine = measure.kind === "paragraph" ? measure.lines.at(0) : void 0;
 		const firstLineAdvance = firstLine ? measuredLineAdvance(firstLine) : 0;
 		const renderedBreakNeedsSnap = measure.kind === "paragraph" && (!paginator.fits(measure.totalHeight) || firstLineAdvance > 0 && paginator.getAvailableHeight() <= firstLineAdvance * RENDERED_BREAK_REFLOW_TOLERANCE_LINES);
-		const hasExplicitPageBreak = hasPageBreakBefore(block);
+		const hasExplicitPageBreak = block.kind === "pageBreak" || hasPageBreakBefore(block);
 		const breakDecision = reconcileBreakBeforeBlock({
 			state: renderedBreakState,
 			block,
@@ -225,7 +224,10 @@ function layoutDocumentPass(blocks, measures, options) {
 			hasExplicitPageBreak,
 			renderedBreakNeedsSnap
 		});
-		if (breakDecision.forcePageBreak) paginator.forcePageBreak();
+		if (block.kind !== "pageBreak") {
+			if (breakDecision.pageAdvance === PAGE_ADVANCE.PHYSICAL) paginator.forcePageBreak();
+			else if (breakDecision.pageAdvance === PAGE_ADVANCE.COALESCED) paginator.coalescePageBreak();
+		}
 		renderedBreakState = breakDecision.state;
 		const chain = keepNextChains.get(i);
 		if (chain && !midChainIndices.has(i)) {
@@ -262,14 +264,15 @@ function layoutDocumentPass(blocks, measures, options) {
 				});
 				break;
 			case "pageBreak":
-				paginator.forcePageBreak();
+				if (breakDecision.pageAdvance === PAGE_ADVANCE.PHYSICAL) paginator.forcePageBreak();
+				else if (breakDecision.pageAdvance === PAGE_ADVANCE.COALESCED) paginator.coalescePageBreak();
 				break;
 			case "columnBreak":
 				paginator.forceColumnBreak();
 				break;
 			case "sectionBreak": {
 				const nextSectionConfig = sectionConfigs[sectionIdx + 1] ?? initialConfig;
-				handleSectionBreak(block, paginator, nextSectionConfig, sectionBreakTypes[sectionIdx] ?? DEFAULT_SECTION_BREAK_TYPE, sectionIdx + 1);
+				handleSectionBreak(block, paginator, nextSectionConfig, normalizeSectionBreakType(sectionBreakTypes[sectionIdx]), sectionIdx + 1);
 				const nextColumns = nextSectionConfig.columns;
 				const nextBreakIndex = breakIndices[sectionIdx + 1] ?? blocks.length;
 				const nextBreak = blocks[nextBreakIndex];
@@ -539,17 +542,18 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 	let currentRowIndex = 0;
 	const breakInfo = buildTableRowBreakInfo(block, measure);
 	const verticallyMergedRows = getVerticallyMergedRows(block);
-	const computeTableX = (columnIndex) => {
-		const x = paginator.getColumnX(columnIndex);
-		const placement = resolveTableInlinePlacement(block);
-		if (placement.alignment === "center") return x + (paginator.columnWidth - measure.totalWidth) / 2;
-		if (placement.alignment === "right") return x + paginator.columnWidth - measure.totalWidth - placement.offset;
-		return x + placement.offset;
+	const computeTableX = ({ columnIndex, rowIndex }) => {
+		return paginator.getColumnX(columnIndex) + resolveTableInlineOffset({
+			table: block,
+			rowJustification: block.rows[rowIndex]?.justification,
+			frameWidth: paginator.columnWidth,
+			tableWidth: measure.totalWidth
+		});
 	};
 	const getCurrentRowCapacity = (state = paginator.getCurrentState()) => state.rawContentBottom - state.topMargin;
 	const hasAdjacentPriorTableRows = (rowIndex, state = paginator.getCurrentState()) => {
 		const previous = state.page.fragments.at(-1);
-		return previous?.kind === "table" && previous.blockId === block.id && previous.toRow === rowIndex && previous.y + previous.height === state.cursorY && previous.x === computeTableX(state.columnIndex);
+		return previous?.kind === "table" && previous.blockId === block.id && previous.toRow === rowIndex && previous.y + previous.height === state.cursorY;
 	};
 	const shouldRepeatHeaderRows = (rowIndex, consumed, state = paginator.getCurrentState()) => headerRowCount > 0 && rowIndex >= headerRowCount && !(consumed === 0 && hasAdjacentPriorTableRows(rowIndex, state));
 	const canSplitRow = (rowIndex, state = paginator.getCurrentState()) => {
@@ -616,7 +620,10 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 				const sliceFragment = {
 					kind: "table",
 					blockId: block.id,
-					x: computeTableX(sliceState.columnIndex),
+					x: computeTableX({
+						columnIndex: sliceState.columnIndex,
+						rowIndex: currentRowIndex
+					}),
 					y: 0,
 					width: measure.totalWidth,
 					height: fragmentHeight,
@@ -633,7 +640,10 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 				};
 				const sliceResult = paginator.addFragment(sliceFragment, fragmentHeight, 0, 0);
 				sliceFragment.y = sliceResult.y;
-				sliceFragment.x = computeTableX(sliceResult.state.columnIndex);
+				sliceFragment.x = computeTableX({
+					columnIndex: sliceResult.state.columnIndex,
+					rowIndex: currentRowIndex
+				});
 				consumed = nextConsumed;
 				if (consumed < splittableRow.height) if (forceRenderedPageBreak) paginator.forcePageBreak();
 				else {
@@ -658,7 +668,15 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		const fragmentFootnoteIds = [];
 		let fragmentFootnoteHeight = 0;
 		let retryOnNextFlowRegion = false;
+		const fragmentX = computeTableX({
+			columnIndex: state.columnIndex,
+			rowIndex: currentRowIndex
+		});
 		for (let j = currentRowIndex; j < rows.length; j++) {
+			if (j > currentRowIndex && computeTableX({
+				columnIndex: state.columnIndex,
+				rowIndex: j
+			}) !== fragmentX) break;
 			const rowHeight = rows[j].height;
 			const currentRowFootnoteIds = rowFootnoteIds[j] ?? [];
 			const fragmentFootnoteCountBeforeRow = fragmentFootnoteIds.length;
@@ -693,7 +711,7 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		if (retryOnNextFlowRegion) continue;
 		const fragmentHeight = rowsHeight + normalHeaderOverhead;
 		const isLastFragment = currentRowIndex + fittingRows >= rows.length;
-		const desiredX = computeTableX(state.columnIndex);
+		const desiredX = fragmentX;
 		const fragment = {
 			kind: "table",
 			blockId: block.id,
@@ -760,13 +778,20 @@ function layoutFloatingTable(block, measure, paginator, contentWidth) {
 	const tableWidth = measure.totalWidth;
 	const tableHeight = measure.totalHeight;
 	const contentHeight = page.size.h - margins.top - margins.bottom;
-	let baseX = margins.left;
 	let baseY = margins.top;
-	if (floating?.horzAnchor === "page") baseX = 0;
 	if (floating?.vertAnchor === "page") baseY = 0;
 	else if (floating?.vertAnchor === "text") baseY = state.cursorY;
 	let x = paginator.getColumnX(state.columnIndex);
-	if (floating) x = baseX + resolveFloatingTableX(floating, block.justification, tableWidth, contentWidth);
+	if (floating) x = resolveFloatingTablePageX({
+		anchor: floating,
+		justification: block.justification,
+		tableWidth,
+		marginWidth: contentWidth,
+		pageWidth: page.size.w,
+		marginLeft: margins.left,
+		textFrameWidth: paginator.columnWidth,
+		textFrameLeft: paginator.getColumnX(state.columnIndex)
+	});
 	let y = state.cursorY;
 	let usedExplicitY = false;
 	if (floating?.tblpY !== void 0) {
@@ -780,11 +805,6 @@ function layoutFloatingTable(block, measure, paginator, contentWidth) {
 		else if (spec === "center") y = baseY + (contentHeight - tableHeight) / 2;
 	}
 	if (!usedExplicitY) y = paginator.ensureFits(tableHeight).cursorY;
-	const usesNumericOffset = floating?.tblpX !== void 0 && floating.tblpXSpec === void 0;
-	const clampToPage = floating?.horzAnchor === "page" || usesNumericOffset;
-	const minX = clampToPage ? 0 : margins.left;
-	const maxX = clampToPage ? page.size.w - tableWidth : margins.left + contentWidth - tableWidth;
-	if (Number.isFinite(maxX)) x = Math.max(minX, Math.min(x, maxX));
 	const fragment = {
 		kind: "table",
 		blockId: block.id,
@@ -943,26 +963,39 @@ function handleSectionBreak(_block, paginator, nextSectionConfig, nextSectionTyp
 	switch (nextSectionType) {
 		case "nextPage":
 			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
-			if (nextSectionIndex !== void 0) paginator.startSection(nextSectionIndex, nextSectionConfig.pageNumbering);
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering
+			});
 			paginator.forcePageBreak({ coalesceBlankPage: true });
 			break;
 		case "evenPage":
 			if (paginator.forcePageBreak({ coalesceBlankPage: true }).page.number % 2 !== 0) paginator.forcePageBreak();
 			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
-			if (nextSectionIndex !== void 0) paginator.startSection(nextSectionIndex, nextSectionConfig.pageNumbering);
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering
+			});
 			if (!paginator.retargetCurrentBlankPage()) panic("Even-page section target must be blank");
 			break;
 		case "oddPage":
 			if (paginator.forcePageBreak({ coalesceBlankPage: true }).page.number % 2 === 0) paginator.forcePageBreak();
 			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
-			if (nextSectionIndex !== void 0) paginator.startSection(nextSectionIndex, nextSectionConfig.pageNumbering);
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering
+			});
 			if (!paginator.retargetCurrentBlankPage()) panic("Odd-page section target must be blank");
 			break;
 		case "continuous": {
 			const currentPage = paginator.pages.at(-1);
 			const nextSize = nextSectionConfig.pageSize;
 			const pageSizeChanges = currentPage != null && (Math.round(nextSize.w) !== Math.round(currentPage.size.w) || Math.round(nextSize.h) !== Math.round(currentPage.size.h));
-			if (nextSectionIndex !== void 0) paginator.startSection(nextSectionIndex, nextSectionConfig.pageNumbering);
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering,
+				placement: pageSizeChanges ? SECTION_START_PLACEMENT.NEXT_PAGE : SECTION_START_PLACEMENT.CONTINUOUS
+			});
 			if (pageSizeChanges) {
 				paginator.updatePageLayout(nextSize, nextSectionConfig.margins);
 				if (!paginator.retargetCurrentBlankPage()) paginator.forcePageBreak({ coalesceBlankPage: true });

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

@@ -0,0 +1,7 @@
+import { ParagraphBlock } from "./types.js";
+//#region src/layout-engine/justifiedLineFit.d.ts
+declare const JUSTIFIED_LIST_FINAL_LINE_MAX_SHRINK_RATIO = 0.025;
+declare const JUSTIFIED_LIST_SPACE_CONTRACTION_RATIO = 0.32;
+declare const supportsJustifiedListFinalLineContraction: (block: ParagraphBlock) => boolean;
+//#endregion
+export { JUSTIFIED_LIST_FINAL_LINE_MAX_SHRINK_RATIO, JUSTIFIED_LIST_SPACE_CONTRACTION_RATIO, supportsJustifiedListFinalLineContraction };

package/dist/layout-engine/justifiedLineFit.js

@@ -0,0 +1,6 @@
+//#region src/layout-engine/justifiedLineFit.ts
+const JUSTIFIED_LIST_FINAL_LINE_MAX_SHRINK_RATIO = .025;
+const JUSTIFIED_LIST_SPACE_CONTRACTION_RATIO = .32;
+const supportsJustifiedListFinalLineContraction = (block) => block.attrs?.justificationCompatibility?.type !== "legacy" && block.attrs?.listMarker !== void 0;
+//#endregion
+export { JUSTIFIED_LIST_FINAL_LINE_MAX_SHRINK_RATIO, JUSTIFIED_LIST_SPACE_CONTRACTION_RATIO, supportsJustifiedListFinalLineContraction };

package/dist/layout-engine/keep-together.js

@@ -1,4 +1,4 @@
-import { collapseParagraphSpacing } from "./paragraphSpacing.js";
+import { collapseParagraphSpacing, isAuthoredEmptyParagraph, isEmptyParagraph } from "./paragraphSpacing.js";
 //#region src/layout-engine/keep-together.ts
 /**
 * Keep Together Logic - Handle keepNext and keepLines paragraph properties
@@ -6,19 +6,24 @@ import { collapseParagraphSpacing } from "./paragraphSpacing.js";
 * DOCX paragraphs can have keepNext (keep with next paragraph) and keepLines
 * (keep all lines together) properties that affect pagination.
 */
-function isVisuallyEmptyParagraph(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 === "";
+/**
+* Whether an empty paragraph is only a structural separator through which a
+* keep-with-next chain may pass. An explicitly styled or directly formatted
+* blank is authored layout content: it anchors the preceding keepNext rather
+* than implicitly linking that heading to later content.
+*/
+function isKeepNextPassThroughParagraph(block) {
+	if (!isEmptyParagraph(block)) return false;
+	if (block.attrs?.suppressEmptyParagraphHeight === true) return true;
+	return !isAuthoredEmptyParagraph(block);
 }
 function startsTrailingTableSeparatorChain(blocks, index) {
 	const block = blocks[index];
-	if (block?.kind !== "paragraph" || !isVisuallyEmptyParagraph(block) || blocks[index - 1]?.kind !== "table") return false;
+	if (block?.kind !== "paragraph" || !isKeepNextPassThroughParagraph(block) || blocks[index - 1]?.kind !== "table") return false;
 	for (let nextIndex = index + 1; nextIndex < blocks.length; nextIndex++) {
 		const nextBlock = blocks[nextIndex];
 		if (nextBlock?.kind !== "paragraph") return false;
-		if (!isVisuallyEmptyParagraph(nextBlock)) return true;
+		if (!isKeepNextPassThroughParagraph(nextBlock)) return true;
 	}
 	return false;
 }
@@ -47,7 +52,7 @@ function computeKeepNextChains(blocks) {
 			if (nextBlock.kind === "sectionBreak" || nextBlock.kind === "pageBreak" || nextBlock.kind === "columnBreak") break;
 			if (nextBlock.kind !== "paragraph") break;
 			const nextPara = nextBlock;
-			if (nextPara.attrs?.keepNext || isVisuallyEmptyParagraph(nextPara)) {
+			if (nextPara.attrs?.keepNext || isKeepNextPassThroughParagraph(nextPara)) {
 				memberIndices.push(j);
 				endIndex = j;
 				processed.add(j);
@@ -85,7 +90,7 @@ function calculateChainHeight(chain, blocks, measures) {
 	if (firstBlock?.kind !== "paragraph" || firstMeasure?.kind !== "paragraph") return 0;
 	let totalHeight = (firstBlock.attrs?.spacing?.before ?? 0) + firstMeasure.totalHeight;
 	let trailingSpacing = firstBlock.attrs?.spacing?.after ?? 0;
-	const startsWithTrailingTableSeparator = blocks[firstMemberIndex - 1]?.kind === "table" && isVisuallyEmptyParagraph(firstBlock) && !firstBlock.attrs?.keepNext;
+	const startsWithTrailingTableSeparator = blocks[firstMemberIndex - 1]?.kind === "table" && isEmptyParagraph(firstBlock) && !firstBlock.attrs?.keepNext;
 	const successorIndices = [...chain.memberIndices.slice(1)];
 	if (chain.anchorIndex !== -1) successorIndices.push(chain.anchorIndex);
 	for (let index = 0; index < successorIndices.length; index++) {

package/dist/layout-engine/measure/complexScriptFormatting.d.ts

@@ -1,18 +1,23 @@
 //#region src/layout-engine/measure/complexScriptFormatting.d.ts
 type ComplexScriptFormattingSource = {
   complexScriptFontFamily?: string;
+  complexScriptAlternateFontFamily?: string;
   complexScriptFontSize?: number;
   complexScriptBold?: boolean;
   complexScriptItalic?: boolean;
 };
 type ResolvedComplexScriptFormatting = {
   fontFamily?: string;
+  alternateFontFamily?: string;
   fontSize?: number;
   bold?: boolean;
   italic?: boolean;
 };
 /** Resolve Word's independent complex-script slot into ordinary paint fields. */
 declare const resolveComplexScriptFormatting: (source: ComplexScriptFormattingSource) => ResolvedComplexScriptFormatting;
+declare const applyComplexScriptFormatting: <T extends {
+  alternateFontFamily?: string;
+}>(base: T, source: ComplexScriptFormattingSource) => T & ResolvedComplexScriptFormatting;
 declare const hasComplexScriptFormatting: (source: ComplexScriptFormattingSource) => boolean;
 //#endregion
-export { ResolvedComplexScriptFormatting, hasComplexScriptFormatting, resolveComplexScriptFormatting };
+export { ResolvedComplexScriptFormatting, applyComplexScriptFormatting, hasComplexScriptFormatting, resolveComplexScriptFormatting };

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

@@ -2,10 +2,19 @@
 /** Resolve Word's independent complex-script slot into ordinary paint fields. */
 const resolveComplexScriptFormatting = (source) => ({
 	...source.complexScriptFontFamily !== void 0 ? { fontFamily: source.complexScriptFontFamily } : {},
+	...source.complexScriptAlternateFontFamily !== void 0 ? { alternateFontFamily: source.complexScriptAlternateFontFamily } : {},
 	...source.complexScriptFontSize !== void 0 ? { fontSize: source.complexScriptFontSize } : {},
 	...source.complexScriptBold !== void 0 ? { bold: source.complexScriptBold } : {},
 	...source.complexScriptItalic !== void 0 ? { italic: source.complexScriptItalic } : {}
 });
-const hasComplexScriptFormatting = (source) => source.complexScriptFontFamily !== void 0 || source.complexScriptFontSize !== void 0 || source.complexScriptBold !== void 0 || source.complexScriptItalic !== void 0;
+const applyComplexScriptFormatting = (base, source) => {
+	const result = {
+		...base,
+		...resolveComplexScriptFormatting(source)
+	};
+	if (source.complexScriptFontFamily !== void 0 && source.complexScriptAlternateFontFamily === void 0) delete result.alternateFontFamily;
+	return result;
+};
+const hasComplexScriptFormatting = (source) => source.complexScriptFontFamily !== void 0 || source.complexScriptAlternateFontFamily !== void 0 || source.complexScriptFontSize !== void 0 || source.complexScriptBold !== void 0 || source.complexScriptItalic !== void 0;
 //#endregion
-export { hasComplexScriptFormatting, resolveComplexScriptFormatting };
+export { applyComplexScriptFormatting, hasComplexScriptFormatting, resolveComplexScriptFormatting };

package/dist/layout-engine/measure/floatingTablePosition.d.ts

@@ -1,8 +1,23 @@
 import { FloatingTablePosition, TableBlock } from "../types.js";
 //#region src/layout-engine/measure/floatingTablePosition.d.ts
+type FloatingTablePageXOptions = {
+  anchor: FloatingTablePosition;
+  justification: TableBlock["justification"];
+  tableWidth: number;
+  marginWidth: number;
+  pageWidth: number;
+  marginLeft: number;
+  textFrameWidth: number;
+  textFrameLeft: number;
+};
 /**
  * X of the table's left edge relative to the content-box left edge, px.
  */
 declare function resolveFloatingTableX(anchor: FloatingTablePosition, justification: TableBlock["justification"], tableWidth: number, contentWidth: number): number;
+/**
+ * Absolute page X after resolving the selected anchor frame and constraining
+ * the table to the physical page.
+ */
+declare function resolveFloatingTablePageX({ anchor, justification, tableWidth, marginWidth, pageWidth, marginLeft, textFrameWidth, textFrameLeft }: FloatingTablePageXOptions): number;
 //#endregion
-export { resolveFloatingTableX };
+export { resolveFloatingTablePageX, resolveFloatingTableX };

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

@@ -3,15 +3,38 @@
 * X of the table's left edge relative to the content-box left edge, px.
 */
 function resolveFloatingTableX(anchor, justification, tableWidth, contentWidth) {
-	const clamp = (x) => Math.max(0, x);
 	const spec = anchor.tblpXSpec;
 	if (spec === "left" || spec === "inside") return 0;
-	if (spec === "right" || spec === "outside") return clamp(contentWidth - tableWidth);
-	if (spec === "center") return clamp((contentWidth - tableWidth) / 2);
+	if (spec === "right" || spec === "outside") return contentWidth - tableWidth;
+	if (spec === "center") return (contentWidth - tableWidth) / 2;
 	if (anchor.tblpX !== void 0) return anchor.tblpX;
-	if (justification === "center") return clamp((contentWidth - tableWidth) / 2);
-	if (justification === "right") return clamp(contentWidth - tableWidth);
+	if (justification === "center") return (contentWidth - tableWidth) / 2;
+	if (justification === "right") return contentWidth - tableWidth;
 	return 0;
 }
+/**
+* Absolute page X after resolving the selected anchor frame and constraining
+* the table to the physical page.
+*/
+function resolveFloatingTablePageX({ anchor, justification, tableWidth, marginWidth, pageWidth, marginLeft, textFrameWidth, textFrameLeft }) {
+	let frameWidth = marginWidth;
+	let frameLeft = marginLeft;
+	switch (anchor.horzAnchor) {
+		case "page":
+			frameWidth = pageWidth;
+			frameLeft = 0;
+			break;
+		case "text":
+			frameWidth = textFrameWidth;
+			frameLeft = textFrameLeft;
+			break;
+		case "margin":
+		case void 0: break;
+		default: anchor.horzAnchor;
+	}
+	const resolvedX = frameLeft + resolveFloatingTableX(anchor, justification, tableWidth, frameWidth);
+	const maxX = Math.max(0, pageWidth - tableWidth);
+	return Math.max(0, Math.min(resolvedX, maxX));
+}
 //#endregion
-export { resolveFloatingTableX };
+export { resolveFloatingTablePageX, resolveFloatingTableX };

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

@@ -16,11 +16,13 @@ const { hyphenateSync: hyphenateBritishEnglish } = britishEnglishHyphenation;
 const { hyphenateSync: hyphenateAmericanEnglish } = americanEnglishHyphenation;
 const { hyphenateSync: hyphenateSlovak } = slovakHyphenation;
 const SEGMENTER_CACHE_LIMIT = 16;
+const LINE_BREAK_LOCALE_CACHE_LIMIT = 16;
 const DEFAULT_SEGMENTER_KEY = "";
 const SOFT_HYPHEN = "­";
 const MAX_HYPHENATION_WORD_LENGTH = 256;
 const wordSegmenters = /* @__PURE__ */ new Map();
 const graphemeSegmenters = /* @__PURE__ */ new Map();
+const eastAsianLineBreakLocales = /* @__PURE__ */ new Map();
 const segmenterLocale = (locale) => {
 	const language = locale?.trim().replaceAll("_", "-").split("-").at(0);
 	return language && /^[a-z]{2,3}$/iu.test(language) ? language.toLowerCase() : void 0;
@@ -28,11 +30,19 @@ const segmenterLocale = (locale) => {
 const DICTIONARY_BREAK_SCRIPT = /[\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}]/u;
 const CJK_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
 const WORD_HANGING_PUNCTUATION_LANGUAGES = /* @__PURE__ */ new Set([
+	"cmn",
 	"ii",
 	"ja",
 	"ko",
 	"zh"
 ]);
+const EAST_ASIAN_LINE_BREAK_SCRIPTS = /* @__PURE__ */ new Set([
+	"Hans",
+	"Hant",
+	"Jpan",
+	"Kore",
+	"Yiii"
+]);
 const SIMPLE_BREAK_TEXT = /^[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Number}\p{Punctuation}\p{White_Space}]*$/u;
 const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
 	"-",
@@ -81,6 +91,7 @@ const DEFAULT_PROHIBITED_LINE_START = /* @__PURE__ */ new Set([
 	"：",
 	"；",
 	"！",
+	"％",
 	"？",
 	"…",
 	"’",
@@ -136,14 +147,34 @@ const isLegacyEthiopicBreakCharacter = (character, policy) => {
 	const codePoint = character.codePointAt(0);
 	return codePoint !== void 0 && codePoint >= 4961 && codePoint <= 4968;
 };
-const allowsBreak = (text, index, policy) => {
+const localeUsesEastAsianLineBreaking = (locale) => {
+	const language = segmenterLocale(locale);
+	if (language === void 0) return;
+	const normalized = locale?.trim().replaceAll("_", "-").toLowerCase() ?? language;
+	const cached = eastAsianLineBreakLocales.get(normalized);
+	if (cached !== void 0) return cached;
+	const subtags = normalized.split("-");
+	const extensionIndex = subtags.findIndex((part, index) => index > 0 && part.length === 1);
+	const explicitScript = subtags.slice(1, extensionIndex === -1 ? void 0 : extensionIndex).find((part) => /^[a-z]{4}$/u.test(part));
+	const script = explicitScript ? `${explicitScript[0]?.toUpperCase()}${explicitScript.slice(1)}` : new Intl.Locale(language).maximize().script;
+	const result = WORD_HANGING_PUNCTUATION_LANGUAGES.has(language) || script !== void 0 && EAST_ASIAN_LINE_BREAK_SCRIPTS.has(script);
+	if (eastAsianLineBreakLocales.size >= LINE_BREAK_LOCALE_CACHE_LIMIT) {
+		const oldestKey = eastAsianLineBreakLocales.keys().next().value;
+		if (typeof oldestKey === "string") eastAsianLineBreakLocales.delete(oldestKey);
+	}
+	eastAsianLineBreakLocales.set(normalized, result);
+	return result;
+};
+const usesEastAsianLineBreaking = (text, locale) => localeUsesEastAsianLineBreaking(locale) ?? CJK_SCRIPT.test(text);
+const allowsBreak = (text, index, policy, usesEastAsianRules, nextLineStart) => {
 	const previous = previousCodePoint(text, index);
-	const next = firstCodePoint(text, index);
+	const next = nextLineStart ?? firstCodePoint(text, index);
+	if (previous === " " && next === "%" && policy?.kinsoku !== true && policy?.noLineBreaksBefore === void 0 && !usesEastAsianRules) return !isProhibitedLineEnd(previous, policy);
 	return !isProhibitedLineEnd(previous, policy) && !isProhibitedLineStart(next, policy);
 };
-const pushBreak = (breaks, text, index, policy) => {
+const pushBreak = (breaks, text, index, policy, usesEastAsianRules, nextLineStart) => {
 	if (index <= 0 || index > text.length || breaks.at(-1) === index) return;
-	if (allowsBreak(text, index, policy)) breaks.push(index);
+	if (allowsBreak(text, index, policy, usesEastAsianRules, nextLineStart)) breaks.push(index);
 };
 const findSimpleGraphemeBreaks = (text) => {
 	if (!SIMPLE_BREAK_TEXT.test(text)) return;
@@ -180,12 +211,26 @@ const isSimpleWhitespace = (character, codePoint) => codePoint === 32 || codePoi
 const findSimpleBreaks = (text, policy) => {
 	if (!SIMPLE_BREAK_TEXT.test(text)) return;
 	const breaks = [];
+	const usesEastAsianRules = usesEastAsianLineBreaking(text, policy?.locale);
+	let whitespaceRunEnd = 0;
+	let nextVisibleAfterWhitespace;
 	for (let index = 0; index < text.length; index += 1) {
 		const codePoint = text.charCodeAt(index);
 		if (codePoint >= 55296 && codePoint <= 57343) return;
 		if (codePoint === 13 && text.charCodeAt(index + 1) === 10) continue;
 		const character = text[index];
-		if (isSimpleWhitespace(character, codePoint) && !NONBREAKING_SPACES.has(character) || BREAK_AFTER_CHARACTER.has(character) || isLegacyEthiopicBreakCharacter(character, policy)) pushBreak(breaks, text, index + 1, policy);
+		if (isSimpleWhitespace(character, codePoint) && !NONBREAKING_SPACES.has(character)) {
+			if (index >= whitespaceRunEnd) {
+				whitespaceRunEnd = index + 1;
+				let next = firstCodePoint(text, whitespaceRunEnd);
+				while (next !== void 0 && /\s/u.test(next) && !NONBREAKING_SPACES.has(next)) {
+					whitespaceRunEnd += next.length;
+					next = firstCodePoint(text, whitespaceRunEnd);
+				}
+				nextVisibleAfterWhitespace = next;
+			}
+			pushBreak(breaks, text, index + 1, policy, usesEastAsianRules, nextVisibleAfterWhitespace);
+		} else if (BREAK_AFTER_CHARACTER.has(character) || isLegacyEthiopicBreakCharacter(character, policy)) pushBreak(breaks, text, index + 1, policy, usesEastAsianRules);
 	}
 	return breaks;
 };
@@ -194,20 +239,34 @@ const findUnicodeBreaks = (text, policy) => {
 	const simpleBreaks = findSimpleBreaks(text, policy);
 	if (simpleBreaks !== void 0) return simpleBreaks;
 	const breaks = [];
+	const usesEastAsianRules = usesEastAsianLineBreaking(text, policy?.locale);
 	const graphemeBreaks = findUnicodeGraphemeBreaks(text, policy);
+	let whitespaceRunEnd = 0;
+	let nextVisibleAfterWhitespace;
 	for (const index of graphemeBreaks) {
 		const previous = previousCodePoint(text, index);
-		if (previous !== void 0 && (/\s/u.test(previous) && !NONBREAKING_SPACES.has(previous) || BREAK_AFTER_CHARACTER.has(previous) || isLegacyEthiopicBreakCharacter(previous, policy))) pushBreak(breaks, text, index, policy);
+		if (previous !== void 0 && /\s/u.test(previous) && !NONBREAKING_SPACES.has(previous)) {
+			if (index > whitespaceRunEnd) {
+				whitespaceRunEnd = index;
+				let next = firstCodePoint(text, whitespaceRunEnd);
+				while (next !== void 0 && /\s/u.test(next) && !NONBREAKING_SPACES.has(next)) {
+					whitespaceRunEnd += next.length;
+					next = firstCodePoint(text, whitespaceRunEnd);
+				}
+				nextVisibleAfterWhitespace = next;
+			}
+			pushBreak(breaks, text, index, policy, usesEastAsianRules, nextVisibleAfterWhitespace);
+		} else if (previous !== void 0 && (BREAK_AFTER_CHARACTER.has(previous) || isLegacyEthiopicBreakCharacter(previous, policy))) pushBreak(breaks, text, index, policy, usesEastAsianRules);
 	}
 	const wordSegments = [...getSegmenter(wordSegmenters, "word", policy?.locale).segment(text)];
 	for (const [segmentIndex, segment] of wordSegments.entries()) {
 		const end = segment.index + segment.segment.length;
 		const nextSegment = wordSegments[segmentIndex + 1];
-		if (segment.isWordLike && nextSegment?.isWordLike === true && DICTIONARY_BREAK_SCRIPT.test(segment.segment + nextSegment.segment)) pushBreak(breaks, text, end, policy);
+		if (segment.isWordLike && nextSegment?.isWordLike === true && DICTIONARY_BREAK_SCRIPT.test(segment.segment + nextSegment.segment)) pushBreak(breaks, text, end, policy, usesEastAsianRules);
 	}
 	if (CJK_SCRIPT.test(text)) for (const index of graphemeBreaks) {
 		const previous = previousCodePoint(text, index);
-		if (isCjkLineBreakParticipant(previous, policy)) pushBreak(breaks, text, index, policy);
+		if (isCjkLineBreakParticipant(previous, policy)) pushBreak(breaks, text, index, policy, usesEastAsianRules);
 	}
 	return [...new Set(breaks)].sort((left, right) => left - right);
 };

package/dist/layout-engine/measure/listMarkerWidth.d.ts

@@ -14,6 +14,7 @@ declare const DEFAULT_TAB_STOP_TWIPS = 720;
  */
 declare function resolveListMarkerFont(block: ParagraphBlock): {
   fontFamily: string;
+  alternateFontFamily?: string;
   fontSize: number;
   bold?: boolean;
   italic?: boolean;

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

@@ -1,5 +1,5 @@
 import { hasCjk, hasComplexScript } from "../../utils/scriptSegments.js";
-import { hasComplexScriptFormatting, resolveComplexScriptFormatting } from "./complexScriptFormatting.js";
+import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
 import { ptToPx } from "./measureHelpers.js";
 import { measureTextWidth } from "./measureProvider.js";
 //#region src/layout-engine/measure/listMarkerWidth.ts
@@ -24,22 +24,35 @@ function resolveListMarkerFont(block) {
 	const markerFormatting = attrs?.listMarkerFormatting;
 	const bold = markerFormatting?.bold ?? firstTextRun?.bold;
 	const italic = markerFormatting?.italic ?? firstTextRun?.italic;
+	let fontFamily = attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
+	let alternateFontFamily = attrs?.defaultAlternateFontFamily;
+	if (firstTextRun?.fontFamily !== void 0) {
+		fontFamily = firstTextRun.fontFamily;
+		alternateFontFamily = firstTextRun.alternateFontFamily;
+	}
+	if (markerFormatting?.fontFamily !== void 0) {
+		fontFamily = markerFormatting.fontFamily;
+		alternateFontFamily = markerFormatting.alternateFontFamily;
+	}
 	const base = {
-		fontFamily: markerFormatting?.fontFamily ?? firstTextRun?.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY,
+		fontFamily,
+		...alternateFontFamily !== void 0 ? { alternateFontFamily } : {},
 		fontSize: markerFormatting?.fontSize ?? firstTextRun?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE,
 		...bold !== void 0 ? { bold } : {},
 		...italic !== void 0 ? { italic } : {},
 		...markerFormatting?.rtl !== void 0 ? { rtl: markerFormatting.rtl } : {}
 	};
 	const marker = attrs?.listMarker ?? "";
-	if (markerFormatting && hasComplexScriptFormatting(markerFormatting) && (markerFormatting.forceComplexScript || hasComplexScript(marker))) return {
-		...base,
-		...resolveComplexScriptFormatting(markerFormatting)
-	};
-	if (markerFormatting?.eastAsiaFontFamily && hasCjk(marker)) return {
-		...base,
-		fontFamily: markerFormatting.eastAsiaFontFamily
-	};
+	if (markerFormatting && hasComplexScriptFormatting(markerFormatting) && (markerFormatting.forceComplexScript || hasComplexScript(marker))) return applyComplexScriptFormatting(base, markerFormatting);
+	if (markerFormatting?.eastAsiaFontFamily && hasCjk(marker)) {
+		const result = {
+			...base,
+			fontFamily: markerFormatting.eastAsiaFontFamily
+		};
+		delete result.alternateFontFamily;
+		if (markerFormatting.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = markerFormatting.eastAsiaAlternateFontFamily;
+		return result;
+	}
 	return base;
 }
 /**

package/dist/layout-engine/measure/measureBlocks.d.ts

@@ -3,12 +3,27 @@ import { FloatingImageZone } from "./floatingZones.js";
 import "./measureParagraph.js";
 //#region src/layout-engine/measure/measureBlocks.d.ts
 declare function measureTableBlock(tableBlock: TableBlock, contentWidth: number, fieldValues?: ReadonlyMap<number, string>): TableMeasure;
+type PhysicalBandPageGeometry = {
+  pageWidth: number | number[];
+  pageHeight: number | number[];
+  marginTop: number | number[];
+  marginLeft: number | number[];
+  marginRight: number | number[];
+  marginBottom: number | number[];
+};
 type BandPageGeometry = {
   pageWidth?: number | number[];
   pageHeight: number | number[];
   marginLeft?: number | number[];
   marginRight?: number | number[];
   marginBottom: number | number[];
+  /** Absolute page X of each block's active column origin. */
+  contentLeft?: number | number[];
+  physicalPage?: PhysicalBandPageGeometry;
+  /** Authored flow-column index occupied by each block. */
+  columnIndex?: number | number[];
+  /** Authored flow-column count for each block's section. */
+  columnCount?: number | number[];
 };
 /**
  * Measure a block based on its type.