@stll/folio-core 0.7.0 → 0.9.0

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

@@ -1,4 +1,4 @@
-import { MeasureWorkerRequest, MeasureWorkerResponse } from "./measureWorkerProtocol.js";
+import { MeasureRequestEntry, MeasureWorkerRequest, MeasureWorkerResponse } from "./measureWorkerProtocol.js";
 
 //#region src/layout-engine/measure/measureWorker.d.ts
 /**
@@ -32,7 +32,7 @@ declare function __setMeasureWorkerTransport(factory: TransportFactory | null):
  * `OffscreenCanvas`/`Worker`, or when the proxy has been disabled by
  * a previous error.
  */
-declare function prefetchMeasurement(text: string, font: string, letterSpacing: number, horizontalScale: number, fontCacheKey: string, fontFingerprintWidth: number): void;
+declare function prefetchMeasurement(request: MeasureRequestEntry): void;
 declare function canPrefetchMeasurement(): boolean;
 /**
  * Test-only: synchronously drain the pending queue. The caller is

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

@@ -142,16 +142,10 @@ function flush(current) {
 	const entries = [];
 	for (const entry of current.pending.values()) {
 		if (entries.length >= MAX_BATCH_SIZE) break;
-		current.pending.delete(makeKey(entry.text, entry.fontCacheKey, entry.letterSpacing));
-		if (entry.cacheGeneration !== cacheGeneration) continue;
-		entries.push({
-			text: entry.text,
-			font: entry.font,
-			fontCacheKey: entry.fontCacheKey,
-			fontFingerprintWidth: entry.fontFingerprintWidth,
-			letterSpacing: entry.letterSpacing,
-			horizontalScale: entry.horizontalScale
-		});
+		const { cacheGeneration: entryGeneration, ...request } = entry;
+		current.pending.delete(makeKey(request.text, request.fontCacheKey, request.letterSpacing));
+		if (entryGeneration !== cacheGeneration) continue;
+		entries.push(request);
 	}
 	if (entries.length === 0) {
 		if (current.pending.size > 0) scheduleFlush(current);
@@ -196,20 +190,15 @@ function handleResponse(current, message) {
 * `OffscreenCanvas`/`Worker`, or when the proxy has been disabled by
 * a previous error.
 */
-function prefetchMeasurement(text, font, letterSpacing, horizontalScale, fontCacheKey, fontFingerprintWidth) {
+function prefetchMeasurement(request) {
 	if (!isWorkerFontMetricsEnabled()) return;
-	if (!text) return;
+	if (!request.text) return;
 	const current = ensureProxy();
 	if (current === null) return;
-	const key = makeKey(text, fontCacheKey, letterSpacing);
+	const key = makeKey(request.text, request.fontCacheKey, request.letterSpacing);
 	if (current.pending.has(key)) return;
 	current.pending.set(key, {
-		text,
-		font,
-		fontCacheKey,
-		fontFingerprintWidth,
-		letterSpacing,
-		horizontalScale,
+		...request,
 		cacheGeneration: getTextWidthCacheGeneration()
 	});
 	scheduleFlush(current);

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

@@ -1,18 +1,6 @@
+import { FontKerningMode } from "./textMeasurementPolicy.js";
+
 //#region src/layout-engine/measure/measureWorkerProtocol.d.ts
-/**
- * Wire format shared between the main-thread proxy
- * (`measureWorker.ts`) and the worker entry
- * (`font-metrics.worker.ts`).
- *
- * The protocol is intentionally minimal: a batched request carrying an
- * array of measurement inputs, and a matching response with widths in
- * the same order. The worker is a pure function — no state, no cache.
- * The main thread owns the LRU cache and is the sole authority on what
- * is worth measuring.
- *
- * Keep this file tiny and dependency-free so it can be imported from
- * both contexts.
- */
 /**
  * Single measurement request inside a batch. Mirrors the inputs that
  * `measureTextWidth` already takes on the main thread.
@@ -40,6 +28,7 @@ type MeasureRequestEntry = {
   fontFingerprintWidth: number;
   letterSpacing: number;
   horizontalScale: number;
+  fontKerning: FontKerningMode;
 };
 declare const WORKER_FONT_FINGERPRINT_TEXT = "HAMBURGEFONTS ivwqy 0123456789";
 /**

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

@@ -1,4 +1,4 @@
-import { TableCell, TableCellMeasure } from "../types.js";
+import { ImageRun, TableCell, TableCellMeasure } from "../types.js";
 import { FloatingImageZone } from "./floatingZones.js";
 
 //#region src/layout-engine/measure/tableCellFloating.d.ts
@@ -8,6 +8,11 @@ type TableCellFloatingImage = {
   height: number;
   alt?: string;
   transform?: string;
+  opacity?: number;
+  cropTop?: number;
+  cropRight?: number;
+  cropBottom?: number;
+  cropLeft?: number;
   x: number;
   y: number;
   side: "left" | "right";
@@ -19,8 +24,10 @@ type TableCellFloatingImage = {
   pmStart?: number;
   pmEnd?: number;
 };
+type TableCellFloatingPosition = Pick<TableCellFloatingImage, "x" | "y" | "side">;
+type ResolveTableCellFloatingPosition = (run: ImageRun, paragraphY: number) => TableCellFloatingPosition;
 declare function getTableCellContentWidth(cell: TableCell | undefined, cellMeasure: TableCellMeasure): number;
-declare function getTableCellFloatingImages(cell: TableCell, cellMeasure: TableCellMeasure, contentWidth: number): TableCellFloatingImage[];
+declare function getTableCellFloatingImages(cell: TableCell, cellMeasure: TableCellMeasure, contentWidth: number, resolvePosition?: ResolveTableCellFloatingPosition): TableCellFloatingImage[];
 declare function buildTableCellFloatingZones(floatingImages: TableCellFloatingImage[], contentWidth: number): FloatingImageZone[];
 //#endregion
-export { TableCellFloatingImage, buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };
+export { ResolveTableCellFloatingPosition, TableCellFloatingImage, buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };

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

@@ -1,22 +1,22 @@
 import { emuToPixels } from "../../utils/units.js";
 import { isFloatingImageRun } from "../types.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+import { createTableCellFlowState, placeTableCellBlock } from "./tableCellFlow.js";
 //#region src/layout-engine/measure/tableCellFloating.ts
 function getTableCellContentWidth(cell, cellMeasure) {
 	const padLeft = cell?.padding?.left ?? 7;
 	const padRight = cell?.padding?.right ?? 7;
 	return Math.max(0, cellMeasure.width - padLeft - padRight);
 }
-function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
+function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosition) {
 	const result = [];
-	let paragraphY = 0;
+	const flowState = createTableCellFlowState();
 	for (let blockIndex = 0; blockIndex < cell.blocks.length; blockIndex++) {
 		const block = cell.blocks[blockIndex];
-		if (block?.kind !== "paragraph") {
-			const blockMeasure = cellMeasure.blocks[blockIndex];
-			if (blockMeasure?.kind === "table") paragraphY += blockMeasure.totalHeight;
-			continue;
-		}
+		const blockMeasure = cellMeasure.blocks[blockIndex];
+		if (!block || !blockMeasure) continue;
+		const placement = placeTableCellBlock(flowState, block, blockMeasure);
+		if (block.kind !== "paragraph") continue;
 		for (const run of block.runs) {
 			if (run.kind !== "image" || !isFloatingImageRun(run)) continue;
 			const position = run.position;
@@ -24,30 +24,35 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
 			const distBottom = run.distBottom ?? 0;
 			const distLeft = run.distLeft ?? 12;
 			const distRight = run.distRight ?? 12;
-			let side = "left";
-			let x = 0;
-			if (position?.horizontal) {
-				const horizontal = position.horizontal;
-				if (horizontal.align === "right") {
+			let side;
+			let x;
+			let y;
+			if (resolvePosition) ({side, x, y} = resolvePosition(run, placement.contentTop));
+			else {
+				side = "left";
+				x = 0;
+				if (position?.horizontal) {
+					const horizontal = position.horizontal;
+					if (horizontal.align === "right") {
+						side = "right";
+						x = contentWidth - run.width;
+					} else if (horizontal.align === "center") x = (contentWidth - run.width) / 2;
+					else if (horizontal.posOffset !== void 0) {
+						x = emuToPixels(horizontal.posOffset);
+						side = x > contentWidth / 2 ? "right" : "left";
+					}
+				} else if (run.cssFloat === "right") {
 					side = "right";
 					x = contentWidth - run.width;
-				} else if (horizontal.align === "left") x = 0;
-				else if (horizontal.align === "center") x = (contentWidth - run.width) / 2;
-				else if (horizontal.posOffset !== void 0) {
-					x = emuToPixels(horizontal.posOffset);
-					side = x > contentWidth / 2 ? "right" : "left";
 				}
-			} else if (run.cssFloat === "right") {
-				side = "right";
-				x = contentWidth - run.width;
-			}
-			let y = paragraphY;
-			if (position?.vertical) {
-				const vertical = position.vertical;
-				if (vertical.posOffset !== void 0) y = paragraphY + emuToPixels(vertical.posOffset);
-				else if (vertical.align === "top") y = 0;
+				y = placement.contentTop;
+				if (position?.vertical) {
+					const vertical = position.vertical;
+					if (vertical.posOffset !== void 0) y = placement.contentTop + emuToPixels(vertical.posOffset);
+					else if (vertical.align === "top") y = 0;
+				}
+				x = Math.max(0, Math.min(x, contentWidth - run.width));
 			}
-			x = Math.max(0, Math.min(x, contentWidth - run.width));
 			let wrapText = "bothSides";
 			if (run.cssFloat === "left") wrapText = "right";
 			else if (run.cssFloat === "right") wrapText = "left";
@@ -57,6 +62,11 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
 				height: run.height,
 				...run.alt !== void 0 ? { alt: run.alt } : {},
 				...run.transform !== void 0 ? { transform: run.transform } : {},
+				...run.opacity != null ? { opacity: run.opacity } : {},
+				...run.cropTop != null ? { cropTop: run.cropTop } : {},
+				...run.cropRight != null ? { cropRight: run.cropRight } : {},
+				...run.cropBottom != null ? { cropBottom: run.cropBottom } : {},
+				...run.cropLeft != null ? { cropLeft: run.cropLeft } : {},
 				x,
 				y,
 				side,
@@ -69,8 +79,6 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
 				...run.pmEnd !== void 0 ? { pmEnd: run.pmEnd } : {}
 			});
 		}
-		const blockMeasure = cellMeasure.blocks[blockIndex];
-		if (blockMeasure?.kind === "paragraph") paragraphY += blockMeasure.totalHeight;
 	}
 	return result;
 }

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

@@ -0,0 +1,27 @@
+import { FlowBlock, Measure } from "../types.js";
+
+//#region src/layout-engine/measure/tableCellFlow.d.ts
+type TableCellBlockPlacement = {
+  top: number;
+  contentTop: number;
+  contentHeight: number;
+  leadingSpacing: number;
+};
+type TableCellFlowState = {
+  height: number;
+  previousParagraphWasEmpty: boolean;
+  trailingSpacing: number;
+};
+declare const createTableCellFlowState: () => TableCellFlowState;
+declare const finishTableCellFlow: (state: TableCellFlowState) => number;
+declare const getTableCellBlockContentHeight: (block: FlowBlock, measure: Measure) => number;
+/**
+ * Place one block in an unpaginated table-cell story.
+ *
+ * Adjacent paragraph spacing collapses to the larger side. Consecutive
+ * authored empty paragraphs remain independent vertical spacers, including
+ * at the end of the cell.
+ */
+declare const placeTableCellBlock: (state: TableCellFlowState, block: FlowBlock, measure: Measure) => TableCellBlockPlacement;
+//#endregion
+export { TableCellBlockPlacement, TableCellFlowState, createTableCellFlowState, finishTableCellFlow, getTableCellBlockContentHeight, placeTableCellBlock };

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

@@ -0,0 +1,73 @@
+import { measuredLineRangeHeight } from "../lineFlow.js";
+import { isFloatingTextBoxBlock } from "../types.js";
+import { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph } from "../paragraphSpacing.js";
+//#region src/layout-engine/measure/tableCellFlow.ts
+const createTableCellFlowState = () => ({
+	height: 0,
+	previousParagraphWasEmpty: false,
+	trailingSpacing: 0
+});
+const finishTableCellFlow = (state) => state.height + state.trailingSpacing;
+const isSuppressedParagraphMeasure = (measure) => measure.totalHeight === 0 && measure.lines.every(({ lineHeight }) => lineHeight === 0);
+const paragraphSpacing = (block, measure) => {
+	if (isSuppressedParagraphMeasure(measure)) return {
+		before: 0,
+		after: 0
+	};
+	return {
+		before: getParagraphSpacingBefore(block),
+		after: getParagraphSpacingAfter(block)
+	};
+};
+const getTableCellBlockContentHeight = (block, measure) => {
+	if (block.kind === "textBox" && isFloatingTextBoxBlock(block)) return 0;
+	if (block.kind === "paragraph" && measure.kind === "paragraph") return measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
+	if ("totalHeight" in measure) return measure.totalHeight;
+	if ("height" in measure) return measure.height;
+	return 0;
+};
+/**
+* Place one block in an unpaginated table-cell story.
+*
+* Adjacent paragraph spacing collapses to the larger side. Consecutive
+* authored empty paragraphs remain independent vertical spacers, including
+* at the end of the cell.
+*/
+const placeTableCellBlock = (state, block, measure) => {
+	const top = state.height;
+	const contentHeight = getTableCellBlockContentHeight(block, measure);
+	if (block.kind === "paragraph" && measure.kind === "paragraph" && isSuppressedParagraphMeasure(measure)) return {
+		top,
+		contentTop: top,
+		contentHeight: 0,
+		leadingSpacing: 0
+	};
+	if (block.kind !== "paragraph" || measure.kind !== "paragraph") {
+		const leadingSpacing = state.trailingSpacing;
+		const contentTop = top + leadingSpacing;
+		state.height = contentTop + contentHeight;
+		state.previousParagraphWasEmpty = false;
+		state.trailingSpacing = 0;
+		return {
+			top,
+			contentTop,
+			contentHeight,
+			leadingSpacing
+		};
+	}
+	const spacing = paragraphSpacing(block, measure);
+	const empty = isEmptyParagraph(block);
+	const leadingSpacing = empty && state.previousParagraphWasEmpty ? spacing.before + state.trailingSpacing : Math.max(spacing.before, state.trailingSpacing);
+	const contentTop = top + leadingSpacing;
+	state.height = contentTop + contentHeight;
+	state.previousParagraphWasEmpty = empty;
+	state.trailingSpacing = spacing.after;
+	return {
+		top,
+		contentTop,
+		contentHeight,
+		leadingSpacing
+	};
+};
+//#endregion
+export { createTableCellFlowState, finishTableCellFlow, getTableCellBlockContentHeight, placeTableCellBlock };

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

@@ -0,0 +1,15 @@
+import { TableCell, TableRow } from "../types.js";
+
+//#region src/layout-engine/measure/tableCellGrid.d.ts
+type TableCellGrid = {
+  occupiedColumnsByRow: ReadonlyMap<number, ReadonlySet<number>>;
+  sourceCellsByRow: ReadonlyMap<number, ReadonlyMap<number, TableCell>>;
+  sourceColumnsByCell: ReadonlyMap<TableCell, number>;
+};
+declare const buildTableCellGrid: (rows: readonly TableRow[], columnCount: number) => TableCellGrid;
+declare const getFirstAvailableColumn: (grid: TableCellGrid, rowIndex: number, startingColumn: number) => number;
+declare const getSourceCellAt: (grid: TableCellGrid, rowIndex: number, columnIndex: number) => TableCell | undefined;
+declare const getSourceCellColumn: (grid: TableCellGrid, cell: TableCell) => number | undefined;
+declare const getTableCellVerticalBorderHeight: (grid: TableCellGrid, cell: TableCell | undefined, rowIndex: number) => number;
+//#endregion
+export { TableCellGrid, buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -0,0 +1,62 @@
+//#region src/layout-engine/measure/tableCellGrid.ts
+const buildTableCellGrid = (rows, columnCount) => {
+	const occupiedColumnsByRow = /* @__PURE__ */ new Map();
+	const sourceCellsByRow = /* @__PURE__ */ new Map();
+	const sourceColumnsByCell = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		let columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), row.gridBefore ?? 0);
+		for (const cell of row.cells) {
+			const columnSpan = cell.colSpan ?? 1;
+			const rowSpan = cell.rowSpan ?? 1;
+			sourceColumnsByCell.set(cell, columnIndex);
+			const rowEnd = Math.min(rows.length, rowIndex + rowSpan);
+			const columnEnd = Math.min(columnCount, columnIndex + columnSpan);
+			for (let gridRowIndex = rowIndex; gridRowIndex < rowEnd; gridRowIndex++) {
+				const cellsByColumn = getOrCreateCellRow(sourceCellsByRow, gridRowIndex);
+				for (let gridColumnIndex = columnIndex; gridColumnIndex < columnEnd; gridColumnIndex++) cellsByColumn.set(gridColumnIndex, cell);
+			}
+			if (rowSpan > 1) for (let spannedRowIndex = rowIndex + 1; spannedRowIndex < rowIndex + rowSpan; spannedRowIndex++) {
+				const occupied = getOrCreateOccupiedRow(occupiedColumnsByRow, spannedRowIndex);
+				for (let columnOffset = 0; columnOffset < columnSpan; columnOffset++) occupied.add(columnIndex + columnOffset);
+			}
+			columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), columnIndex + columnSpan);
+		}
+	}
+	return {
+		occupiedColumnsByRow,
+		sourceCellsByRow,
+		sourceColumnsByCell
+	};
+};
+const getFirstAvailableColumn = (grid, rowIndex, startingColumn) => firstAvailableColumn(grid.occupiedColumnsByRow.get(rowIndex), startingColumn);
+const getSourceCellAt = (grid, rowIndex, columnIndex) => grid.sourceCellsByRow.get(rowIndex)?.get(columnIndex);
+const getSourceCellColumn = (grid, cell) => grid.sourceColumnsByCell.get(cell);
+const getTableCellVerticalBorderHeight = (grid, cell, rowIndex) => {
+	const sourceColumn = cell ? getSourceCellColumn(grid, cell) : void 0;
+	const aboveBottom = (sourceColumn === void 0 ? void 0 : getSourceCellAt(grid, rowIndex - 1, sourceColumn))?.borders?.bottom;
+	const aboveOwnsEdge = aboveBottom !== void 0 && aboveBottom.style !== "none" && aboveBottom.style !== "nil";
+	return (rowIndex === 0 || !aboveOwnsEdge ? cell?.borders?.top?.width ?? 0 : 0) + (cell?.borders?.bottom?.width ?? 0);
+};
+const firstAvailableColumn = (occupiedColumns, startingColumn) => {
+	let columnIndex = startingColumn;
+	while (occupiedColumns?.has(columnIndex)) columnIndex++;
+	return columnIndex;
+};
+const getOrCreateCellRow = (sourceCellsByRow, rowIndex) => {
+	const existing = sourceCellsByRow.get(rowIndex);
+	if (existing !== void 0) return existing;
+	const cellsByColumn = /* @__PURE__ */ new Map();
+	sourceCellsByRow.set(rowIndex, cellsByColumn);
+	return cellsByColumn;
+};
+const getOrCreateOccupiedRow = (occupiedColumnsByRow, rowIndex) => {
+	const existing = occupiedColumnsByRow.get(rowIndex);
+	if (existing !== void 0) return existing;
+	const occupiedColumns = /* @__PURE__ */ new Set();
+	occupiedColumnsByRow.set(rowIndex, occupiedColumns);
+	return occupiedColumns;
+};
+//#endregion
+export { buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -0,0 +1,18 @@
+import { ParagraphBlock, ParagraphMeasure } from "../types.js";
+
+//#region src/layout-engine/measure/textBoxParagraphLayout.d.ts
+type TextBoxParagraphPlacement = {
+  leadingSpacing: number;
+  contentHeight: number;
+};
+type TextBoxParagraphLayout = {
+  placements: TextBoxParagraphPlacement[];
+  totalHeight: number;
+};
+/**
+ * Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+ * before/after spacing collapses to the larger value, matching body flow.
+ */
+declare function layoutTextBoxParagraphs(blocks: readonly ParagraphBlock[], measures: readonly ParagraphMeasure[]): TextBoxParagraphLayout;
+//#endregion
+export { TextBoxParagraphLayout, TextBoxParagraphPlacement, layoutTextBoxParagraphs };

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

@@ -0,0 +1,32 @@
+import { measuredLineRangeHeight } from "../lineFlow.js";
+import { getParagraphSpacingAfter, getParagraphSpacingBefore } from "../paragraphSpacing.js";
+import { panic } from "better-result";
+//#region src/layout-engine/measure/textBoxParagraphLayout.ts
+/**
+* Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+* before/after spacing collapses to the larger value, matching body flow.
+*/
+function layoutTextBoxParagraphs(blocks, measures) {
+	if (blocks.length !== measures.length) panic("layoutTextBoxParagraphs: block and measure counts must match");
+	const placements = [];
+	let totalHeight = 0;
+	let trailingSpacing = 0;
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		const measure = measures[index];
+		const leadingSpacing = Math.max(getParagraphSpacingBefore(block), trailingSpacing);
+		const contentHeight = measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
+		placements.push({
+			leadingSpacing,
+			contentHeight
+		});
+		totalHeight += leadingSpacing + contentHeight;
+		trailingSpacing = getParagraphSpacingAfter(block);
+	}
+	return {
+		placements,
+		totalHeight: totalHeight + trailingSpacing
+	};
+}
+//#endregion
+export { layoutTextBoxParagraphs };

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

@@ -0,0 +1,18 @@
+import { RunFormatting } from "../types.js";
+import { FontStyle } from "./measureTypes.js";
+
+//#region src/layout-engine/measure/textMeasurementPolicy.d.ts
+declare const FONT_KERNING_MODE: {
+  readonly enabled: "normal";
+  readonly disabled: "none";
+};
+type FontKerningMode = (typeof FONT_KERNING_MODE)[keyof typeof FONT_KERNING_MODE];
+type RunKerningInput = Pick<RunFormatting, "fontSize" | "kerningMinPt">;
+/** Resolve an authored kerning threshold against the effective run size. */
+declare function getRunFontKerningMode(run: RunKerningInput, fallbackFontSize: number): FontKerningMode;
+/** Convert normalized measurement style into the canvas/CSS kerning mode. */
+declare function getFontKerningMode(style: Pick<FontStyle, "kerning">): FontKerningMode;
+/** Count ordinary ASCII spaces that justification may compress. */
+declare function countCompressibleSpaces(text: string): number;
+//#endregion
+export { FONT_KERNING_MODE, FontKerningMode, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };

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

@@ -0,0 +1,24 @@
+//#region src/layout-engine/measure/textMeasurementPolicy.ts
+const FONT_KERNING_MODE = {
+	enabled: "normal",
+	disabled: "none"
+};
+/** Resolve an authored kerning threshold against the effective run size. */
+function getRunFontKerningMode(run, fallbackFontSize) {
+	const threshold = run.kerningMinPt;
+	const fontSize = run.fontSize ?? fallbackFontSize;
+	if (threshold === void 0 || fontSize < threshold) return FONT_KERNING_MODE.disabled;
+	return FONT_KERNING_MODE.enabled;
+}
+/** Convert normalized measurement style into the canvas/CSS kerning mode. */
+function getFontKerningMode(style) {
+	return style.kerning ? FONT_KERNING_MODE.enabled : FONT_KERNING_MODE.disabled;
+}
+/** Count ordinary ASCII spaces that justification may compress. */
+function countCompressibleSpaces(text) {
+	let count = 0;
+	for (const char of text) if (char === " ") count += 1;
+	return count;
+}
+//#endregion
+export { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };

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

@@ -35,7 +35,8 @@ type PaginatorOptions = {
    * its title page (typically extended top margin to clear an overflowing
    * first-page header) vs. its body pages. Pages 2+ use `margins`.
    */
-  firstPageMargins?: PageMargins; /** Column configuration (optional). */
+  firstPageMargins?: PageMargins; /** Per-section body margins used on even section pages. */
+  sectionEvenPageMargins?: (PageMargins | undefined)[]; /** Column configuration (optional). */
   columns?: ColumnLayout; /** Per-page footnote reserved heights (pageNumber → height in pixels). */
   footnoteReservedHeights?: Map<number, number>; /** Header/footer refs by section index. */
   sectionHeaderFooterRefs?: PageHeaderFooterRefs[]; /** Callback when a new page is created. */

package/dist/layout-engine/paginator.js

@@ -47,7 +47,7 @@ function createPaginator(options) {
 	}
 	function currentPageUsesActiveLayout(state) {
 		if (pendingPageSize || pendingMargins) return false;
-		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, getPageMargins(state.page.number));
+		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, getPageMargins(state.page.number, state.page.sectionPageNumber ?? currentSectionPageNumber));
 	}
 	if (getContentHeight() <= 0) panic("Paginator: page size and margins yield no content area");
 	let columnWidths = calculateColumnWidths(pageSize.w, margins.left, margins.right, columns);
@@ -62,8 +62,9 @@ function createPaginator(options) {
 		if (getContentHeight() <= 0) panic("Paginator: section page size and margins yield no content area");
 		recalculateColumnWidths();
 	}
-	function getPageMargins(pageNumber) {
-		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...margins };
+	function getPageMargins(pageNumber, sectionPageNumber) {
+		const evenMargins = sectionPageNumber % 2 === 0 ? options.sectionEvenPageMargins?.[currentSectionIndex] : void 0;
+		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...evenMargins ?? margins };
 		if (options.mirrorMargins === true && pageNumber % 2 === 0) return {
 			...pageMargins,
 			left: pageMargins.right,
@@ -77,7 +78,7 @@ function createPaginator(options) {
 	* Get X position for a given column index.
 	*/
 	function getColumnX(columnIndex) {
-		let x = states.at(-1)?.page.margins.left ?? getPageMargins(1).left;
+		let x = states.at(-1)?.page.margins.left ?? getPageMargins(1, 1).left;
 		for (let index = 0; index < columnIndex; index++) x += (columnWidths[index] ?? columnWidths[0] ?? 0) + gapAfterColumn(columns, index);
 		return x;
 	}
@@ -88,7 +89,7 @@ function createPaginator(options) {
 		if (pendingPageSize || pendingMargins) applyPendingLayout();
 		const pageNumber = pages.length + 1;
 		currentSectionPageNumber += 1;
-		const pageMargins = getPageMargins(pageNumber);
+		const pageMargins = getPageMargins(pageNumber, currentSectionPageNumber);
 		const topMargin = pageMargins.top;
 		const contentBottom = pageSize.h - pageMargins.bottom;
 		const footnoteHeight = options.footnoteReservedHeights?.get(pageNumber) ?? 0;
@@ -244,7 +245,7 @@ function createPaginator(options) {
 		const current = states.at(-1);
 		if (!current || current.page.fragments.length > 0 || current.cursorY !== current.topMargin) return false;
 		if (pendingPageSize || pendingMargins) applyPendingLayout();
-		const pageMargins = getPageMargins(current.page.number);
+		const pageMargins = getPageMargins(current.page.number, 1);
 		const topMargin = pageMargins.top;
 		const rawContentBottom = pageSize.h - pageMargins.bottom;
 		const footnoteHeight = options.footnoteReservedHeights?.get(current.page.number) ?? 0;

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

@@ -0,0 +1,22 @@
+import { ParagraphBlock, TextBoxBlock } from "./types.js";
+
+//#region src/layout-engine/paragraphFrame.d.ts
+type ParagraphFrame = {
+  width?: number;
+  height?: number;
+  hSpace?: number;
+  vSpace?: number;
+  hAnchor?: "text" | "margin" | "page";
+  vAnchor?: "text" | "margin" | "page";
+  x?: number;
+  y?: number;
+  xAlign?: "left" | "center" | "right" | "inside" | "outside";
+  yAlign?: "top" | "center" | "bottom" | "inside" | "outside" | "inline";
+  wrap?: "around" | "auto" | "none" | "notBeside" | "through" | "tight";
+};
+declare function setParagraphFrame(block: ParagraphBlock, frame: ParagraphFrame): void;
+declare function getParagraphFrame(block: ParagraphBlock): ParagraphFrame | undefined;
+declare function markParagraphFrameTextBox(block: TextBoxBlock): void;
+declare function isParagraphFrameTextBox(block: TextBoxBlock): boolean;
+//#endregion
+export { ParagraphFrame, getParagraphFrame, isParagraphFrameTextBox, markParagraphFrameTextBox, setParagraphFrame };

package/dist/layout-engine/paragraphFrame.js

@@ -0,0 +1,17 @@
+//#region src/layout-engine/paragraphFrame.ts
+const paragraphFrames = /* @__PURE__ */ new WeakMap();
+const paragraphFrameTextBoxes = /* @__PURE__ */ new WeakSet();
+function setParagraphFrame(block, frame) {
+	paragraphFrames.set(block, frame);
+}
+function getParagraphFrame(block) {
+	return paragraphFrames.get(block);
+}
+function markParagraphFrameTextBox(block) {
+	paragraphFrameTextBoxes.add(block);
+}
+function isParagraphFrameTextBox(block) {
+	return paragraphFrameTextBoxes.has(block);
+}
+//#endregion
+export { getParagraphFrame, isParagraphFrameTextBox, markParagraphFrameTextBox, setParagraphFrame };

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

@@ -0,0 +1,7 @@
+import { FlowBlock } from "./types.js";
+
+//#region src/layout-engine/paragraphSequence.d.ts
+declare const continuesNumberedSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
+declare const continuesTabbedParagraphSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
+//#endregion
+export { continuesNumberedSequence, continuesTabbedParagraphSequence };

package/dist/layout-engine/paragraphSequence.js

@@ -0,0 +1,25 @@
+//#region src/layout-engine/paragraphSequence.ts
+const continuesNumberedSequence = (previous, current) => {
+	if (previous?.kind !== "paragraph" || current.kind !== "paragraph") return false;
+	const previousNumPr = previous.attrs?.numPr;
+	const currentNumPr = current.attrs?.numPr;
+	if (previousNumPr?.numId === void 0 || currentNumPr?.numId === void 0) return false;
+	return previousNumPr.numId === currentNumPr.numId && previousNumPr.ilvl === currentNumPr.ilvl;
+};
+const continuesTabbedParagraphSequence = (previous, current) => {
+	if (previous?.kind !== "paragraph" || current.kind !== "paragraph") return false;
+	if (!previous.attrs?.styleId || previous.attrs.styleId !== current.attrs?.styleId) return false;
+	if (!previous.runs.some((run) => run.kind === "tab") || !current.runs.some((run) => run.kind === "tab")) return false;
+	const previousIndent = previous.attrs.indent;
+	const currentIndent = current.attrs.indent;
+	if (previousIndent?.left !== currentIndent?.left || previousIndent?.right !== currentIndent?.right || previousIndent?.firstLine !== currentIndent?.firstLine || previousIndent?.hanging !== currentIndent?.hanging) return false;
+	const previousTabs = previous.attrs.tabs ?? [];
+	const currentTabs = current.attrs.tabs ?? [];
+	return previousTabs.length === currentTabs.length && previousTabs.every((tab, index) => {
+		const currentTab = currentTabs[index];
+		if (!currentTab) return false;
+		return tab.val === currentTab.val && tab.pos === currentTab.pos && tab.leader === currentTab.leader;
+	});
+};
+//#endregion
+export { continuesNumberedSequence, continuesTabbedParagraphSequence };