@stll/folio-core 0.32.2 → 0.33.1

package/dist/display-list/build/tablePrimitives.js

@@ -0,0 +1,409 @@
+import { createTableCellFlowState, placeTableCellBlock } from "../../layout-engine/measure/tableCellFlow.js";
+import { buildTableCellGrid, buildTableCellPlacements, getSourceCellAt } from "../../layout-engine/measure/tableCellGrid.js";
+import { resolveTableCellPadding } from "../../layout-engine/types.js";
+import { HIT_REGION_KINDS } from "../primitives.js";
+import { parseDisplayColor } from "./colors.js";
+import { paintImageFragment } from "./imagePrimitives.js";
+import { paintParagraphFragment } from "./paragraphPrimitives.js";
+import { blockRegion, createPageComposer } from "./regions.js";
+import { resolveBorderStroke } from "./strokes.js";
+import { UNSUPPORTED_CONSTRUCT } from "./unsupported.js";
+//#region src/display-list/build/tablePrimitives.ts
+/**
+* Table fragments → primitives.
+*
+* Order per cell is fixed here rather than left to a backend: background,
+* borders, content, diagonals. `renderTable.ts` gets that order from CSS
+* (a background paints under its own border, a `z-index: 1` diagonal over the
+* content); nothing in a display list would reproduce it by accident.
+*
+* One deliberate divergence from the painter: `renderCellDiagonalBorder`
+* (`renderTable.ts:533`) emulates a diagonal with a rotated bar whose dash
+* pattern is a CSS gradient. Here it is a real diagonal `line` with the
+* authored stroke pattern, so a backend draws a line rather than reverse
+* engineering a gradient.
+*/
+/** A cell edge is "visible" for collapse purposes on style alone, as the painter decides it. */
+const hasVisibleBorder = (border) => border !== void 0 && border.style !== "none" && border.style !== "nil";
+const strokeFor = (border, context, label) => {
+	if (!hasVisibleBorder(border) || !border) return;
+	const { stroke, unresolvedColor } = resolveBorderStroke(border);
+	if (unresolvedColor !== void 0) context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `${label} colour ${unresolvedColor}`);
+	return stroke;
+};
+const paintCell = ({ composer, cell, cellMeasure, box, context, paintTextBox, sides }) => {
+	const primitives = [];
+	if (cell.background) {
+		const fill = parseDisplayColor(cell.background);
+		if (fill) primitives.push({
+			kind: "rect",
+			rect: {
+				xPx: box.xPx,
+				yPx: box.yPx,
+				widthPx: box.widthPx,
+				heightPx: box.heightPx
+			},
+			fill
+		});
+		else context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `table cell background ${cell.background}`);
+	}
+	const borders = cell.borders;
+	const strokes = {
+		top: sides.top ? strokeFor(borders?.top, context, "table cell top border") : void 0,
+		bottom: sides.bottom ? strokeFor(borders?.bottom, context, "table cell bottom border") : void 0,
+		left: sides.left ? strokeFor(borders?.left, context, "table cell left border") : void 0,
+		right: strokeFor(borders?.right, context, "table cell right border")
+	};
+	const widths = {
+		top: strokes.top?.thicknessPx ?? 0,
+		right: strokes.right?.thicknessPx ?? 0,
+		bottom: strokes.bottom?.thicknessPx ?? 0,
+		left: strokes.left?.thicknessPx ?? 0
+	};
+	if (strokes.top) primitives.push({
+		kind: "line",
+		x1Px: box.xPx,
+		y1Px: box.yPx + widths.top / 2,
+		x2Px: box.xPx + box.widthPx,
+		y2Px: box.yPx + widths.top / 2,
+		stroke: strokes.top
+	});
+	if (strokes.bottom) primitives.push({
+		kind: "line",
+		x1Px: box.xPx,
+		y1Px: box.yPx + box.heightPx - widths.bottom / 2,
+		x2Px: box.xPx + box.widthPx,
+		y2Px: box.yPx + box.heightPx - widths.bottom / 2,
+		stroke: strokes.bottom
+	});
+	if (strokes.left) primitives.push({
+		kind: "line",
+		x1Px: box.xPx + widths.left / 2,
+		y1Px: box.yPx,
+		x2Px: box.xPx + widths.left / 2,
+		y2Px: box.yPx + box.heightPx,
+		stroke: strokes.left
+	});
+	if (strokes.right) primitives.push({
+		kind: "line",
+		x1Px: box.xPx + box.widthPx - widths.right / 2,
+		y1Px: box.yPx,
+		x2Px: box.xPx + box.widthPx - widths.right / 2,
+		y2Px: box.yPx + box.heightPx,
+		stroke: strokes.right
+	});
+	const padding = resolveTableCellPadding(cell);
+	const contentXPx = box.xPx + widths.left + padding.left;
+	const contentYPx = box.yPx + widths.top + padding.top;
+	const contentWidthPx = Math.max(0, cellMeasure.width - padding.left - padding.right);
+	if (cell.textDirection === "btLr" || cell.textDirection === "tbRl") context.unsupported.report(UNSUPPORTED_CONSTRUCT.verticalCellText, context.pageIndex, `w:textDirection ${cell.textDirection} paints horizontally`);
+	composer.push(primitives);
+	primitives.length = 0;
+	paintCellBlocks({
+		composer,
+		blocks: cell.blocks,
+		measures: cellMeasure.blocks,
+		xPx: contentXPx,
+		yPx: contentYPx,
+		widthPx: contentWidthPx,
+		context,
+		paintTextBox
+	});
+	const diagonals = [{
+		border: borders?.topLeftToBottomRight,
+		from: "topLeft"
+	}, {
+		border: borders?.topRightToBottomLeft,
+		from: "topRight"
+	}];
+	for (const { border, from } of diagonals) {
+		const stroke = strokeFor(border, context, "table cell diagonal border");
+		if (!stroke) continue;
+		primitives.push({
+			kind: "line",
+			x1Px: box.xPx,
+			y1Px: from === "topLeft" ? box.yPx : box.yPx + box.heightPx,
+			x2Px: box.xPx + box.widthPx,
+			y2Px: from === "topLeft" ? box.yPx + box.heightPx : box.yPx,
+			stroke
+		});
+	}
+	composer.push(primitives);
+};
+/**
+* A cell's inner blocks, stacked by the same flow state the measurer used, so
+* paragraph spacing collapses in paint exactly where it collapsed in layout.
+*/
+const paintCellBlocks = ({ composer, blocks, measures, xPx, yPx, widthPx, context, paintTextBox }) => {
+	const flowState = createTableCellFlowState();
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		const measure = measures[index];
+		if (!block || !measure) {
+			context.unsupported.report(UNSUPPORTED_CONSTRUCT.missingBlock, context.pageIndex, block === void 0 ? `table cell content at index ${String(index)} has no block` : `table cell block ${String(block.id)} has no measure`);
+			continue;
+		}
+		const placement = placeTableCellBlock(flowState, block, measure);
+		if (block.kind === "paragraph" && measure.kind === "paragraph") {
+			const previous = blocks[index - 1];
+			const next = blocks[index + 1];
+			const fragment = {
+				kind: "paragraph",
+				blockId: block.id,
+				x: xPx,
+				y: yPx + placement.contentTop,
+				width: widthPx,
+				height: placement.contentHeight,
+				fromLine: 0,
+				toLine: measure.lines.length
+			};
+			composer.region(blockRegion({
+				fragment,
+				kind: HIT_REGION_KINDS.paragraph,
+				context
+			}), () => {
+				paintParagraphFragment({
+					composer,
+					fragment,
+					block,
+					measure,
+					context,
+					...previous?.kind === "paragraph" && previous.attrs?.borders !== void 0 ? { prevBorders: previous.attrs.borders } : {},
+					...next?.kind === "paragraph" && next.attrs?.borders !== void 0 ? { nextBorders: next.attrs.borders } : {}
+				});
+			});
+			continue;
+		}
+		if (block.kind === "table" && measure.kind === "table") {
+			const fragment = {
+				blockId: block.id,
+				x: xPx,
+				y: yPx + placement.contentTop,
+				width: measure.totalWidth,
+				height: measure.totalHeight
+			};
+			composer.region(blockRegion({
+				fragment,
+				kind: HIT_REGION_KINDS.table,
+				context
+			}), () => {
+				paintTableBlock({
+					composer,
+					block,
+					measure,
+					xPx: fragment.x,
+					yPx: fragment.y,
+					context,
+					paintTextBox
+				});
+			});
+			continue;
+		}
+		if (block.kind === "image" && measure.kind === "image") {
+			const fragment = {
+				kind: "image",
+				blockId: block.id,
+				x: xPx,
+				y: yPx + placement.contentTop,
+				width: measure.width,
+				height: measure.height
+			};
+			composer.region(blockRegion({
+				fragment,
+				kind: HIT_REGION_KINDS.image,
+				context
+			}), () => {
+				composer.push(paintImageFragment(fragment, block, context));
+			});
+			continue;
+		}
+		if (block.kind === "textBox" && measure.kind === "textBox") {
+			const fragment = {
+				kind: "textBox",
+				blockId: block.id,
+				x: xPx,
+				y: yPx + placement.contentTop,
+				width: measure.width,
+				height: measure.height
+			};
+			composer.region(blockRegion({
+				fragment,
+				kind: HIT_REGION_KINDS.textBox,
+				context
+			}), () => {
+				paintTextBox({
+					composer,
+					fragment,
+					block,
+					measure,
+					context
+				});
+			});
+			continue;
+		}
+		context.unsupported.report(UNSUPPORTED_CONSTRUCT.fragmentKind, context.pageIndex, `table cell content of kind ${block.kind} is not painted`);
+	}
+};
+const rowIsPainted = (row) => row !== void 0 && row.hidden !== true;
+const paintTableBody = ({ composer, block, measure, xPx, yPx, fromRow, toRow, headerRowCount, context, paintTextBox }) => {
+	const grid = buildTableCellGrid(block.rows, measure.columnWidths.length);
+	const placements = buildTableCellPlacements({
+		grid,
+		columnWidths: measure.columnWidths,
+		bidi: block.bidi === true
+	});
+	const rowTops = [0];
+	for (const rowMeasure of measure.rows) rowTops.push((rowTops.at(-1) ?? 0) + rowMeasure.height);
+	const paintRow = (rowIndex, rowYPx) => {
+		const row = block.rows[rowIndex];
+		const rowMeasure = measure.rows[rowIndex];
+		if (!rowIsPainted(row) || !rowMeasure) return;
+		composer.region({
+			kind: HIT_REGION_KINDS.tableRow,
+			rect: {
+				xPx,
+				yPx: rowYPx,
+				widthPx: measure.columnWidths.reduce((total, width) => total + width, 0),
+				heightPx: rowMeasure.height
+			},
+			model: { rowIndex }
+		}, () => {
+			paintRowCells(row, rowMeasure, rowIndex, rowYPx);
+		});
+	};
+	const paintRowCells = (row, rowMeasure, rowIndex, rowYPx) => {
+		for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+			const cell = row.cells[cellIndex];
+			const cellMeasure = rowMeasure.cells[cellIndex];
+			if (!cell || !cellMeasure) continue;
+			const placement = placements.get(cell);
+			if (!placement) continue;
+			const rowSpan = Math.max(1, Math.trunc(cell.rowSpan ?? 1));
+			const spanEnd = Math.min(rowTops.length - 1, rowIndex + rowSpan);
+			const heightPx = spanEnd > rowIndex ? rowTops[spanEnd] - rowTops[rowIndex] : rowMeasure.height;
+			const atLogicalStart = placement.sourceColumn === 0;
+			const atLogicalEnd = placement.sourceColumn + placement.columnSpan >= measure.columnWidths.length;
+			const isFirstColumn = block.bidi === true ? atLogicalEnd : atLogicalStart;
+			const aboveCell = getSourceCellAt(grid, rowIndex - 1, placement.sourceColumn);
+			const leftNeighborColumn = block.bidi === true ? placement.sourceColumn + placement.columnSpan : placement.sourceColumn - 1;
+			const leftCell = getSourceCellAt(grid, rowIndex, leftNeighborColumn);
+			const box = {
+				xPx: xPx + placement.left,
+				yPx: rowYPx,
+				widthPx: placement.width,
+				heightPx
+			};
+			composer.region({
+				kind: HIT_REGION_KINDS.tableCell,
+				rect: box,
+				model: {
+					rowIndex,
+					columnIndex: placement.sourceColumn
+				}
+			}, () => {
+				paintCell({
+					composer,
+					cell,
+					cellMeasure,
+					box,
+					context,
+					paintTextBox,
+					sides: {
+						top: rowIndex === fromRow || !hasVisibleBorder(aboveCell?.borders?.bottom),
+						bottom: true,
+						left: isFirstColumn || !hasVisibleBorder(leftCell?.borders?.right),
+						right: true
+					}
+				});
+			});
+		}
+	};
+	let cursorYPx = yPx;
+	for (let rowIndex = 0; rowIndex < headerRowCount; rowIndex += 1) {
+		const rowMeasure = measure.rows[rowIndex];
+		if (!rowMeasure) continue;
+		paintRow(rowIndex, cursorYPx);
+		cursorYPx += rowMeasure.height;
+	}
+	for (let rowIndex = fromRow; rowIndex < toRow; rowIndex += 1) {
+		const rowMeasure = measure.rows[rowIndex];
+		if (!rowMeasure) continue;
+		paintRow(rowIndex, cursorYPx);
+		cursorYPx += rowMeasure.height;
+	}
+};
+/** A whole, unpaginated table: what a nested table inside a cell or box is. */
+const paintTableBlock = ({ composer, block, measure, xPx, yPx, context, paintTextBox }) => paintTableBody({
+	composer,
+	block,
+	measure,
+	xPx,
+	yPx,
+	fromRow: 0,
+	toRow: block.rows.length,
+	headerRowCount: 0,
+	context,
+	paintTextBox
+});
+/**
+* A table fragment's primitives. A fragment that cuts a row mid-content wraps
+* its rows in a `clipGroup` and starts them `topClip` px higher, which is what
+* the painter's negative row-stack offset plus `overflow: hidden` does.
+*/
+const paintTableFragment = ({ composer, fragment, block, measure, context, paintTextBox }) => {
+	const headerRowCount = fragment.continuesFromPrev === true ? fragment.headerRowCount ?? 0 : 0;
+	let headerHeightPx = 0;
+	for (let rowIndex = 0; rowIndex < headerRowCount; rowIndex += 1) headerHeightPx += measure.rows[rowIndex]?.height ?? 0;
+	const paintHeaders = (into) => {
+		if (headerRowCount === 0) return;
+		paintTableBody({
+			composer: into,
+			block,
+			measure,
+			xPx: fragment.x,
+			yPx: fragment.y,
+			fromRow: 0,
+			toRow: 0,
+			headerRowCount,
+			context,
+			paintTextBox
+		});
+	};
+	const topClipPx = fragment.topClip ?? 0;
+	const paintBody = (into) => {
+		paintTableBody({
+			composer: into,
+			block,
+			measure,
+			xPx: fragment.x,
+			yPx: fragment.y + headerHeightPx - topClipPx,
+			fromRow: fragment.fromRow,
+			toRow: fragment.toRow,
+			headerRowCount: 0,
+			context,
+			paintTextBox
+		});
+	};
+	if (fragment.topClip === void 0 && fragment.bottomClip === void 0) {
+		paintHeaders(composer);
+		paintBody(composer);
+		return;
+	}
+	paintHeaders(composer);
+	const clipped = createPageComposer();
+	paintBody(clipped);
+	const clip = {
+		xPx: fragment.x,
+		yPx: fragment.y + headerHeightPx,
+		widthPx: fragment.width,
+		heightPx: Math.max(0, fragment.height - headerHeightPx)
+	};
+	composer.push([{
+		kind: "clipGroup",
+		rect: clip,
+		children: [...clipped.primitives()],
+		regions: [...clipped.regions()]
+	}]);
+};
+//#endregion
+export { paintTableBlock, paintTableFragment };

package/dist/display-list/build/textBoxPrimitives.d.ts

@@ -0,0 +1,14 @@
+import { TextBoxBlock, TextBoxFragment, TextBoxMeasure } from "../../layout-engine/types.js";
+import { BuildContext } from "./buildContext.js";
+import { PageComposer } from "./regions.js";
+//#region src/display-list/build/textBoxPrimitives.d.ts
+type TextBoxPaintOptions = {
+  readonly composer: PageComposer;
+  readonly fragment: TextBoxFragment;
+  readonly block: TextBoxBlock;
+  readonly measure: TextBoxMeasure;
+  readonly context: BuildContext;
+};
+declare const paintTextBoxFragment: ({ composer, fragment, block, measure, context }: TextBoxPaintOptions) => void;
+//#endregion
+export { TextBoxPaintOptions, paintTextBoxFragment };

package/dist/display-list/build/textBoxPrimitives.js

@@ -0,0 +1,129 @@
+import { layoutTextBoxContent } from "../../layout-engine/measure/textBoxParagraphLayout.js";
+import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
+import { HIT_REGION_KINDS } from "../primitives.js";
+import { parseDisplayColor } from "./colors.js";
+import { paintParagraphFragment } from "./paragraphPrimitives.js";
+import { blockRegion } from "./regions.js";
+import { resolveBorderStroke } from "./strokes.js";
+import { paintTableBlock } from "./tablePrimitives.js";
+import { UNSUPPORTED_CONSTRUCT } from "./unsupported.js";
+//#region src/display-list/build/textBoxPrimitives.ts
+/**
+* Text-box fragments → primitives: fill, outline, then the inner block story.
+*
+* The box's own content flow is `layoutTextBoxContent`, the same helper the
+* measurer used, so the paragraphs land where their heights were reserved.
+*/
+const paintTextBoxFragment = ({ composer, fragment, block, measure, context }) => {
+	const primitives = [];
+	const box = {
+		xPx: fragment.x,
+		yPx: fragment.y,
+		widthPx: fragment.width,
+		heightPx: fragment.height
+	};
+	if (block.fillColor) {
+		const fill = parseDisplayColor(block.fillColor);
+		if (fill) primitives.push({
+			kind: "rect",
+			rect: box,
+			fill
+		});
+		else context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `text box fill ${block.fillColor}`);
+	}
+	let outlineWidthPx = 0;
+	if (block.outlineWidth !== void 0 && block.outlineWidth > 0) {
+		const { stroke, unresolvedColor } = resolveBorderStroke({
+			width: block.outlineWidth,
+			style: block.outlineStyle ?? "solid",
+			color: block.outlineColor ?? "#000000"
+		});
+		if (unresolvedColor !== void 0) context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `text box outline ${unresolvedColor}`);
+		if (stroke) {
+			outlineWidthPx = stroke.thicknessPx;
+			const inset = stroke.thicknessPx / 2;
+			primitives.push({
+				kind: "rect",
+				rect: {
+					xPx: box.xPx + inset,
+					yPx: box.yPx + inset,
+					widthPx: Math.max(0, box.widthPx - stroke.thicknessPx),
+					heightPx: Math.max(0, box.heightPx - stroke.thicknessPx)
+				},
+				stroke
+			});
+		}
+	}
+	const margins = block.margins ?? DEFAULT_TEXTBOX_MARGINS;
+	const innerWidthPx = fragment.width - margins.left - margins.right;
+	const layout = layoutTextBoxContent(block.content, measure.innerMeasures);
+	let cursorYPx = box.yPx + outlineWidthPx + margins.top;
+	for (let index = 0; index < block.content.length; index += 1) {
+		const contentBlock = block.content[index];
+		const contentMeasure = measure.innerMeasures[index];
+		const placement = layout.placements[index];
+		if (!contentBlock || !contentMeasure || !placement) continue;
+		cursorYPx += placement.leadingSpacing;
+		if (contentBlock.kind === "paragraph" && contentMeasure.kind === "paragraph") {
+			const previous = block.content[index - 1];
+			const next = block.content[index + 1];
+			composer.push(primitives);
+			primitives.length = 0;
+			const contentFragment = {
+				kind: "paragraph",
+				blockId: contentBlock.id,
+				x: box.xPx + outlineWidthPx + margins.left,
+				y: cursorYPx,
+				width: innerWidthPx,
+				height: placement.contentHeight,
+				fromLine: 0,
+				toLine: contentMeasure.lines.length
+			};
+			composer.region(blockRegion({
+				fragment: contentFragment,
+				kind: HIT_REGION_KINDS.paragraph,
+				context
+			}), () => {
+				paintParagraphFragment({
+					composer,
+					fragment: contentFragment,
+					block: contentBlock,
+					measure: contentMeasure,
+					context,
+					...previous?.kind === "paragraph" && previous.attrs?.borders !== void 0 ? { prevBorders: previous.attrs.borders } : {},
+					...next?.kind === "paragraph" && next.attrs?.borders !== void 0 ? { nextBorders: next.attrs.borders } : {}
+				});
+			});
+		} else if (contentBlock.kind === "table" && contentMeasure.kind === "table") {
+			composer.push(primitives);
+			primitives.length = 0;
+			const contentFragment = {
+				blockId: contentBlock.id,
+				x: box.xPx + outlineWidthPx + margins.left,
+				y: cursorYPx,
+				width: contentMeasure.totalWidth,
+				height: contentMeasure.totalHeight
+			};
+			composer.region(blockRegion({
+				fragment: contentFragment,
+				kind: HIT_REGION_KINDS.table,
+				context
+			}), () => {
+				paintTableBlock({
+					composer,
+					block: contentBlock,
+					measure: contentMeasure,
+					xPx: contentFragment.x,
+					yPx: contentFragment.y,
+					context,
+					paintTextBox: paintTextBoxFragment
+				});
+			});
+		} else context.unsupported.report(UNSUPPORTED_CONSTRUCT.fragmentKind, context.pageIndex, `text box content of kind ${contentBlock.kind} is not painted`);
+		cursorYPx += placement.contentHeight;
+	}
+	if (block.verticalAlign === "middle" || block.verticalAlign === "bottom") context.unsupported.report(UNSUPPORTED_CONSTRUCT.textBoxVerticalAlign, context.pageIndex, `text box anchor ${block.verticalAlign} paints from the top`);
+	composer.push(primitives);
+};
+//#endregion
+export { paintTextBoxFragment };

package/dist/display-list/build/textDecorations.d.ts

@@ -0,0 +1,29 @@
+//#region src/display-list/build/textDecorations.d.ts
+/**
+ * Text-decoration geometry.
+ *
+ * The DOM painter delegates underlines and strikethroughs to CSS
+ * `text-decoration`, which derives its position and thickness from the font's
+ * own `post`/`OS/2` tables. A display list has to state the geometry, and the
+ * builder has no font binary, so these ratios stand in for the font-derived
+ * metrics.
+ *
+ * They are approximations of what a browser computes from the face, chosen to
+ * match the common Latin text faces at body sizes. The follow-up is to read
+ * `underlinePosition` / `underlineThickness` from the embedded face and thread
+ * them through the measure seam alongside ascent and descent; until then a
+ * decoration on an unusual face sits a fraction of an em off where Word puts
+ * it. Every constant is in one place so that follow-up is a single edit.
+ */
+/** Distance below the baseline to the centre of the underline, as a fraction of the em. */
+declare const UNDERLINE_OFFSET_RATIO = 0.1;
+/** Underline thickness as a fraction of the em, floored so a hairline stays visible. */
+declare const UNDERLINE_THICKNESS_RATIO: number;
+declare const MIN_DECORATION_THICKNESS_PX = 1;
+/** Distance above the baseline to the centre of the strikethrough, as a fraction of the em. */
+declare const STRIKETHROUGH_OFFSET_RATIO = 0.28;
+declare const underlineThicknessPx: (fontSizePx: number) => number;
+declare const underlineCenterYPx: (baselineYPx: number, fontSizePx: number) => number;
+declare const strikethroughCenterYPx: (baselineYPx: number, fontSizePx: number) => number;
+//#endregion
+export { MIN_DECORATION_THICKNESS_PX, STRIKETHROUGH_OFFSET_RATIO, UNDERLINE_OFFSET_RATIO, UNDERLINE_THICKNESS_RATIO, strikethroughCenterYPx, underlineCenterYPx, underlineThicknessPx };

package/dist/display-list/build/textDecorations.js

@@ -0,0 +1,29 @@
+//#region src/display-list/build/textDecorations.ts
+/**
+* Text-decoration geometry.
+*
+* The DOM painter delegates underlines and strikethroughs to CSS
+* `text-decoration`, which derives its position and thickness from the font's
+* own `post`/`OS/2` tables. A display list has to state the geometry, and the
+* builder has no font binary, so these ratios stand in for the font-derived
+* metrics.
+*
+* They are approximations of what a browser computes from the face, chosen to
+* match the common Latin text faces at body sizes. The follow-up is to read
+* `underlinePosition` / `underlineThickness` from the embedded face and thread
+* them through the measure seam alongside ascent and descent; until then a
+* decoration on an unusual face sits a fraction of an em off where Word puts
+* it. Every constant is in one place so that follow-up is a single edit.
+*/
+/** Distance below the baseline to the centre of the underline, as a fraction of the em. */
+const UNDERLINE_OFFSET_RATIO = .1;
+/** Underline thickness as a fraction of the em, floored so a hairline stays visible. */
+const UNDERLINE_THICKNESS_RATIO = 1 / 14;
+const MIN_DECORATION_THICKNESS_PX = 1;
+/** Distance above the baseline to the centre of the strikethrough, as a fraction of the em. */
+const STRIKETHROUGH_OFFSET_RATIO = .28;
+const underlineThicknessPx = (fontSizePx) => Math.max(1, fontSizePx * UNDERLINE_THICKNESS_RATIO);
+const underlineCenterYPx = (baselineYPx, fontSizePx) => baselineYPx + fontSizePx * UNDERLINE_OFFSET_RATIO;
+const strikethroughCenterYPx = (baselineYPx, fontSizePx) => baselineYPx - fontSizePx * STRIKETHROUGH_OFFSET_RATIO;
+//#endregion
+export { MIN_DECORATION_THICKNESS_PX, STRIKETHROUGH_OFFSET_RATIO, UNDERLINE_OFFSET_RATIO, UNDERLINE_THICKNESS_RATIO, strikethroughCenterYPx, underlineCenterYPx, underlineThicknessPx };

package/dist/display-list/build/unsupported.d.ts

@@ -0,0 +1,57 @@
+import { DisplayUnsupported } from "../types.js";
+//#region src/display-list/build/unsupported.d.ts
+/**
+ * Every construct name the builder can report. Named rather than free-form so
+ * a consumer can switch over them, and so a typo cannot invent a new category.
+ */
+declare const UNSUPPORTED_CONSTRUCT: {
+  /** `w:effect` animations (blinkBackground, shimmer, …). */
+  readonly textEffect: "textEffect";
+  /** `w:smallCaps`: advances are correct, the small-cap glyph choice is not expressible. */
+  readonly smallCaps: "smallCaps";
+  /** `w:w` horizontal scale: folded into advances, but the glyphs are not narrowed. */
+  readonly horizontalScale: "horizontalScale";
+  /** `w:em` emphasis marks. */
+  readonly emphasisMark: "emphasisMark";
+  /** `w:emboss` / `w:imprint` / `w:shadow` shadow effects. */
+  readonly textShadowEffect: "textShadowEffect";
+  /** `w:vanish` hidden text, suppressed as Word's print view does. */
+  readonly hiddenRun: "hiddenRun";
+  /** OMML equations, painted as `renderMathFallback`'s plain text. */
+  readonly mathRun: "mathRun";
+  /** An image whose bytes are not PNG or JPEG (WMF/EMF/TIFF/SVG/GIF/BMP). */
+  readonly imageFormat: "imageFormat";
+  /** An image whose bytes the builder could not reach (remote or opaque `src`). */
+  readonly imageSource: "imageSource";
+  /** A colour literal the producer could not resolve to concrete channels. */
+  readonly unresolvedColor: "unresolvedColor";
+  /** Runs placed in logical order because the builder runs no bidi algorithm. */
+  readonly bidiReordering: "bidiReordering";
+  /** `w:textDirection` vertical cell text. */
+  readonly verticalCellText: "verticalCellText";
+  /** Page borders, which the layout does not carry. */
+  readonly pageBorders: "pageBorders";
+  /** Watermarks, which the layout does not carry. */
+  readonly watermark: "watermark";
+  /** Footnote bodies, which the layout does not carry. */
+  readonly footnoteContent: "footnoteContent";
+  /** Header and footer stories, which the layout does not carry. */
+  readonly headerFooterContent: "headerFooterContent";
+  /** `a:bodyPr` middle/bottom anchoring inside a text box. */
+  readonly textBoxVerticalAlign: "textBoxVerticalAlign";
+  /** A fragment kind with no builder. */
+  readonly fragmentKind: "fragmentKind";
+  /** A fragment whose block or measure is missing from the block lookup. */
+  readonly missingBlock: "missingBlock";
+  /** A block/measure pair whose kinds disagree. */
+  readonly measureMismatch: "measureMismatch";
+};
+type UnsupportedConstruct = (typeof UNSUPPORTED_CONSTRUCT)[keyof typeof UNSUPPORTED_CONSTRUCT];
+declare class UnsupportedCollector {
+  private readonly entries;
+  private readonly seen;
+  report(construct: UnsupportedConstruct, pageIndex: number, detail: string): void;
+  snapshot(): readonly DisplayUnsupported[];
+}
+//#endregion
+export { UNSUPPORTED_CONSTRUCT, UnsupportedCollector, UnsupportedConstruct };

package/dist/display-list/build/watermarkPrimitives.d.ts

@@ -0,0 +1,15 @@
+import { document_d_exports } from "../../types/document.js";
+import { Page } from "../../layout-engine/types.js";
+import { DisplayPrimitive } from "../types.js";
+import { BuildContext } from "./buildContext.js";
+//#region src/display-list/build/watermarkPrimitives.d.ts
+type WatermarkPaintOptions = {
+  readonly page: Page;
+  readonly watermark: document_d_exports.Watermark;
+  /** Resolved `data:` source for a picture watermark; absent means unresolved. */
+  readonly imageSrc?: string;
+  readonly context: BuildContext;
+};
+declare const paintWatermark: ({ page, watermark, imageSrc, context }: WatermarkPaintOptions) => readonly DisplayPrimitive[];
+//#endregion
+export { WatermarkPaintOptions, paintWatermark };