@stll/folio-core 0.46.0 → 0.47.0

package/dist/content-controls/checkboxDisplay.js

@@ -11,16 +11,22 @@ const defaultDisplay = (checked) => ({
 	char: checked ? DEFAULT_CHECKED_CHARACTER : DEFAULT_UNCHECKED_CHARACTER,
 	font: DEFAULT_CHECKBOX_FONT
 });
-/** Resolve the authored checkbox state into the run payload Word expects. */
-const checkboxDisplayContent = (rawPropertiesXml, checked) => {
-	if (!rawPropertiesXml || rawPropertiesXml.length > MAX_CHECKBOX_PROPERTIES_CHARACTERS) return defaultDisplay(checked);
+/**
+* Resolve the authored checkbox state into the run payload Word expects.
+*
+* @param checkboxXml the preserved `w14:checkbox` element, from
+*   `SdtProperties.preserved`. A control that carries none — one built in
+*   code, or one whose author wrote no glyphs — gets Word's own defaults.
+*/
+const checkboxDisplayContent = (checkboxXml, checked) => {
+	if (!checkboxXml || checkboxXml.length > MAX_CHECKBOX_PROPERTIES_CHARACTERS) return defaultDisplay(checked);
 	let root;
 	try {
-		root = parseXml(rawPropertiesXml, OOXML_NAMESPACE_SCOPE);
+		root = parseXml(checkboxXml, OOXML_NAMESPACE_SCOPE);
 	} catch {
 		return defaultDisplay(checked);
 	}
-	const state = findChildByNamespaceUri(findChildByNamespaceUri(findChildByNamespaceUri(root, WORDPROCESSINGML_NAMESPACE_URIS, "sdtPr"), CHECKBOX_NAMESPACE_URIS, "checkbox"), CHECKBOX_NAMESPACE_URIS, checked ? "checkedState" : "uncheckedState");
+	const state = findChildByNamespaceUri(findChildByNamespaceUri(root, CHECKBOX_NAMESPACE_URIS, "checkbox"), CHECKBOX_NAMESPACE_URIS, checked ? "checkedState" : "uncheckedState");
 	const rawCharacter = getAttributeByNamespaceUri(state, CHECKBOX_NAMESPACE_URIS, "val");
 	if (!rawCharacter || !HEX_CODE_POINT.test(rawCharacter)) return defaultDisplay(checked);
 	const codePoint = Number.parseInt(rawCharacter, 16);

package/dist/content-controls/mutateContentControls.js

@@ -1,5 +1,6 @@
 import { formatDate } from "../docx/fieldParser.js";
 import { cloneParagraphWithPropertySource } from "../docx/paragraphPropertySource.js";
+import { preservedSdtChild, withoutPreservedSdtChild } from "../docx/sdtProperties.js";
 import { checkboxDisplayContent } from "./checkboxDisplay.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "./errors.js";
 import { sanitizeXmlCharacters } from "@stll/docx-core";
@@ -95,22 +96,16 @@ function ensureSdtNotLocked(control, force) {
 	if (lock === "sdtLocked" || lock === "sdtContentLocked") throwLocked(control, lock);
 }
 function isRepeatingSection(control) {
-	const raw = control.properties.rawPropertiesXml;
-	return raw !== void 0 && REPEATING_SECTION_RE.test(raw);
+	return preservedSdtChild(control.properties.preserved, "repeatingSection") !== void 0;
 }
-const REPEATING_SECTION_RE = /<\w+:repeatingSection\b/u;
-const DATA_BINDING_RE = /<\w+:dataBinding\b(?<attrs>[^>]*)\/?>/iu;
 /**
-* Detect a `<w:dataBinding w:xpath="…"/>` (or alt-prefix variant) inside
-* the captured rawPropertiesXml + extract the xpath / storeItemID for
-* the error payload. Returns null when no binding is present.
+* The binding a `<w:dataBinding w:xpath="…"/>` states, for the error payload.
+*
+* Returns null when the control carries no binding.
 */
 function readDataBinding(control) {
-	const raw = control.properties.rawPropertiesXml;
-	if (raw === void 0) return null;
-	const match = DATA_BINDING_RE.exec(raw);
-	if (!match) return null;
-	const attrs = match.groups?.["attrs"] ?? "";
+	const attrs = preservedSdtChild(control.properties.preserved, "dataBinding");
+	if (attrs === void 0) return null;
 	const xpathMatch = /\bxpath="(?<xpath>[^"]*)"/iu.exec(attrs);
 	if (!xpathMatch) return null;
 	const xpath = xpathMatch.groups?.["xpath"] ?? "";
@@ -123,14 +118,13 @@ function readDataBinding(control) {
 }
 /**
 * Refuse content mutations on bound SDTs unless the caller passes
-* `{ force: true }`. When force is set, return the rawPropertiesXml
-* with the `<w:dataBinding>` element stripped so the caller's write
-* actually sticks on next Word open. See `ContentControlBoundError`
-* for the rationale.
+* `{ force: true }`. When force is set, return the property set without its
+* `<w:dataBinding>` child so the caller's write actually sticks on next Word
+* open. See `ContentControlBoundError` for the rationale.
 */
 function ensureContentNotBound(control, force) {
 	const binding = readDataBinding(control);
-	if (!binding) return { strippedRawPropertiesXml: void 0 };
+	if (!binding) return { wasBound: false };
 	if (!force) throw new ContentControlBoundError({
 		message: `Control "${control.properties.tag ?? control.properties.alias ?? "(unnamed)"}" is bound to ${binding.xpath}. Word regenerates the body from the bound XML on open; pass { force: true } to strip the binding inline, or remove it explicitly before writing.`,
 		xpath: binding.xpath,
@@ -138,9 +132,19 @@ function ensureContentNotBound(control, force) {
 		...control.properties.tag !== void 0 ? { tag: control.properties.tag } : {},
 		...control.properties.alias !== void 0 ? { alias: control.properties.alias } : {}
 	});
-	const raw = control.properties.rawPropertiesXml;
-	if (raw === void 0) return { strippedRawPropertiesXml: void 0 };
-	return { strippedRawPropertiesXml: raw.replaceAll(/<\w+:dataBinding\b[^>]*\/?>(?:[\s\S]*?<\/\w+:dataBinding>)?/giu, "") };
+	return {
+		wasBound: true,
+		unbound: withoutPreservedSdtChild(control.properties.preserved, "dataBinding")
+	};
+}
+/** Write a {@link BindingRemoval} onto a copy of a control's properties. */
+function applyBindingRemoval(properties, removal) {
+	if (!removal.wasBound) return;
+	if (removal.unbound === void 0) {
+		delete properties.preserved;
+		return;
+	}
+	properties.preserved = removal.unbound;
 }
 function mapBlock(block, match) {
 	if (block.type === "blockSdt") {
@@ -242,7 +246,7 @@ function makeCheckboxParagraph(control, checked) {
 	const content = [{
 		type: "run",
 		...run?.formatting !== void 0 ? { formatting: run.formatting } : {},
-		content: [checkboxDisplayContent(control.properties.rawPropertiesXml, checked)]
+		content: [checkboxDisplayContent(preservedSdtChild(control.properties.preserved, "checkbox"), checked)]
 	}];
 	if (!paragraph) return {
 		type: "paragraph",
@@ -273,11 +277,11 @@ function setContentControlContent(doc, filter, input, options = {}) {
 	const match = (control) => {
 		if (!controlMatchesFilter(control, filter)) return;
 		ensureContentNotLocked(control, options.force);
-		const { strippedRawPropertiesXml } = ensureContentNotBound(control, options.force);
+		const removal = ensureContentNotBound(control, options.force);
 		const blocks = typeof input === "string" ? [makeParagraphFromText(input)] : input.map(cloneBlock);
 		const properties = { ...control.properties };
 		properties.showingPlaceholder = false;
-		if (strippedRawPropertiesXml !== void 0) properties.rawPropertiesXml = strippedRawPropertiesXml;
+		applyBindingRemoval(properties, removal);
 		return {
 			...control,
 			properties,
@@ -295,7 +299,17 @@ function setContentControlValue(doc, filter, input, options = {}) {
 	const match = (control) => {
 		if (!controlMatchesFilter(control, filter)) return;
 		ensureContentNotLocked(control, options.force);
-		const { strippedRawPropertiesXml } = ensureContentNotBound(control, options.force);
+		const removal = ensureContentNotBound(control, options.force);
+		/** The control's properties, unbound, plus whatever this input sets. */
+		const nextProperties = (set) => {
+			const properties = {
+				...control.properties,
+				...set
+			};
+			properties.showingPlaceholder = false;
+			applyBindingRemoval(properties, removal);
+			return properties;
+		};
 		const sdtType = control.properties.sdtType;
 		if (input.kind === "dropdown") {
 			if (sdtType !== "dropdown" && sdtType !== "comboBox") throw new ContentControlTypeError({
@@ -316,12 +330,7 @@ function setContentControlValue(doc, filter, input, options = {}) {
 			const display = item?.displayText ?? input.value;
 			return {
 				...control,
-				properties: {
-					...control.properties,
-					dropdownLastValue: sanitizeXmlCharacters(input.value),
-					showingPlaceholder: false,
-					...strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {}
-				},
+				properties: nextProperties({ dropdownLastValue: sanitizeXmlCharacters(input.value) }),
 				content: [makeParagraphFromText(display)]
 			};
 		}
@@ -335,12 +344,7 @@ function setContentControlValue(doc, filter, input, options = {}) {
 			});
 			return {
 				...control,
-				properties: {
-					...control.properties,
-					checked: input.checked,
-					showingPlaceholder: false,
-					...strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {}
-				},
+				properties: nextProperties({ checked: input.checked }),
 				content: [makeCheckboxParagraph(control, input.checked)]
 			};
 		}
@@ -354,12 +358,7 @@ function setContentControlValue(doc, filter, input, options = {}) {
 		const display = formatDateForSdtBody(input.date, control.properties.dateFormat);
 		return {
 			...control,
-			properties: {
-				...control.properties,
-				dateValueISO: input.date,
-				showingPlaceholder: false,
-				...strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {}
-			},
+			properties: nextProperties({ dateValueISO: input.date }),
 			content: [makeParagraphFromText(display)]
 		};
 	};

package/dist/controller/layoutPipeline.js

@@ -119,7 +119,8 @@ function runLayoutPipeline(deps, state, options = {}) {
 		const flowOpts = {
 			pageContentHeight,
 			fontAlternates,
-			...styles ? { styles } : {}
+			...styles ? { styles } : {},
+			...document === null ? {} : { defaultSize: 10 }
 		};
 		if (_theme !== void 0) flowOpts.theme = _theme;
 		if (defaultTabStop !== void 0) flowOpts.defaultTabStopTwips = defaultTabStop;
@@ -188,6 +189,7 @@ function runLayoutPipeline(deps, state, options = {}) {
 			const hfMeasureBlocks = (hfBlocks, hfWidth) => measureBlocks(hfBlocks, hfWidth, void 0, void 0, buildHeaderFooterFieldValues(hfBlocks, pageCount, hfClock, fieldInputs), { allowEndTabOverflow: true });
 			return {
 				...flowOpts.styles ? { styles: flowOpts.styles } : {},
+				...flowOpts.defaultSize === void 0 ? {} : { defaultSize: flowOpts.defaultSize },
 				..._theme !== void 0 ? { theme: _theme } : {},
 				fontAlternates,
 				measureBlocks: hfMeasureBlocks,
@@ -288,7 +290,8 @@ function runLayoutPipeline(deps, state, options = {}) {
 				marginBottom: blockMeasureInputs.physicalPageGeometry.marginBottoms
 			},
 			columnIndex: blockMeasureInputs.columnIndices,
-			columnCount: blockMeasureInputs.columnCounts
+			columnCount: blockMeasureInputs.columnCounts,
+			sectionAdvances: blockMeasureInputs.sectionAdvances
 		});
 		newBlocks = resolveEffectiveParagraphSpacingTree(newBlocks);
 		outcome.blocks = newBlocks;
@@ -338,6 +341,7 @@ function runLayoutPipeline(deps, state, options = {}) {
 			footnoteContentMap = buildFootnoteContentMap(documentFootnotes, footnoteRefs, contentWidth, (() => {
 				const footnoteOptions = { measureBlocks };
 				if (flowOpts.styles) footnoteOptions.styles = flowOpts.styles;
+				if (flowOpts.defaultSize !== void 0) footnoteOptions.defaultSize = flowOpts.defaultSize;
 				if (_theme !== void 0) footnoteOptions.theme = _theme;
 				footnoteOptions.fontAlternates = fontAlternates;
 				if (defaultTabStop !== void 0) footnoteOptions.defaultTabStopTwips = defaultTabStop;
@@ -416,7 +420,8 @@ function runLayoutPipeline(deps, state, options = {}) {
 						marginBottom: blockMeasureInputs.physicalPageGeometry.marginBottoms
 					},
 					columnIndex: blockMeasureInputs.columnIndices,
-					columnCount: blockMeasureInputs.columnCounts
+					columnCount: blockMeasureInputs.columnCounts,
+					sectionAdvances: blockMeasureInputs.sectionAdvances
 				}, values);
 				relayoutWithCurrentMeasures(layoutOptsUsed);
 				pendingArtifacts = {

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

@@ -1,4 +1,3 @@
-import { isHeadingOutlineLevel } from "../../docx/builtInStyles.js";
 import { HIT_REGION_KINDS } from "../primitives.js";
 import { AuthorColorTable } from "./buildContext.js";
 import { DOC_CANVAS } from "./colors.js";
@@ -12,6 +11,7 @@ import { blockRegion, createPageComposer } from "./regions.js";
 import { paintTableFragment } from "./tablePrimitives.js";
 import { paintTextBoxFragment } from "./textBoxPrimitives.js";
 import { UNSUPPORTED_CONSTRUCT, UnsupportedCollector } from "./unsupported.js";
+import { headingLevelOf } from "@stll/docx-core/model";
 //#region src/display-list/build/buildDisplayList.ts
 /**
 * `Layout` + `BlockLookup` → `DisplayList`.
@@ -75,10 +75,10 @@ const paragraphTextOf = (block) => block.runs.map((run) => run.kind === "text" ?
 * where each bookmark lands (a `#name` hyperlink cannot become a page target
 * until then) and the heading outline.
 *
-* The outline takes the levels {@link isHeadingOutlineLevel} accepts and no
-* others: `w:outlineLvl` 9 is the reserved body-text value, not a tenth level,
-* and a `TOC Heading` paragraph carrying it would otherwise become a PDF
-* bookmark nested nine deep.
+* The outline takes the levels {@link headingLevelOf} names and no others:
+* `w:outlineLvl` 9 is the reserved body-text value, not a tenth level, and a
+* `TOC Heading` paragraph carrying it would otherwise become a PDF bookmark
+* nested nine deep.
 */
 const collectDocumentTargets = (layout, blockLookup) => {
 	const bookmarkTargets = /* @__PURE__ */ new Map();
@@ -92,8 +92,8 @@ const collectDocumentTargets = (layout, blockLookup) => {
 			pageIndex,
 			yPx: fragment.y
 		});
-		const level = block.attrs?.outlineLevel;
-		if (isHeadingOutlineLevel(level) && fragment.continuesFromPrev !== true) {
+		const level = headingLevelOf(block.attrs?.outlineLevel);
+		if (level !== void 0 && fragment.continuesFromPrev !== true) {
 			const title = paragraphTextOf(block);
 			if (title.length > 0) outline.push({
 				title,

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

@@ -15,7 +15,7 @@ declare class ImageTable {
   failureFor(src: string): string | undefined;
   snapshot(): readonly DisplayImageSource[];
 }
-type ImageVisualSource = Pick<ImageBlock, "src" | "opacity" | "brightness" | "contrast" | "cropTop" | "cropRight" | "cropBottom" | "cropLeft" | "borderWidth" | "borderColor" | "borderStyle" | "transform">;
+type ImageVisualSource = Pick<ImageBlock, "src" | "preview" | "opacity" | "brightness" | "contrast" | "cropTop" | "cropRight" | "cropBottom" | "cropLeft" | "borderWidth" | "borderColor" | "borderStyle" | "transform">;
 type PaintImageOptions = {
   readonly source: ImageVisualSource;
   readonly rect: DisplayRect;
@@ -24,9 +24,9 @@ type PaintImageOptions = {
   readonly label: string;
 };
 /**
- * The primitives one picture draws: the bitmap (rotated and/or washed as the
- * source asks) followed by its border. Empty when the bytes are unusable, with
- * the reason already reported.
+ * The primitives one picture draws: the bitmap or the drawn preview (rotated
+ * and/or washed as the source asks) followed by its border. Empty when the
+ * bytes are unusable, with the reason already reported.
  */
 declare const paintImage: ({ source, rect, context, label }: PaintImageOptions) => readonly DisplayPrimitive[];
 /** An anchored or block image fragment placed by the layout engine. */

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

@@ -1,5 +1,6 @@
 import { parseRotationDegrees } from "../../utils/rotationBoundingBox.js";
 import { sanitizeImageSrc } from "../../utils/sanitizeImageSrc.js";
+import { paintPreview } from "./previewPrimitives.js";
 import { resolveBorderStroke } from "./strokes.js";
 import { UNSUPPORTED_CONSTRUCT } from "./unsupported.js";
 import { Result } from "better-result";
@@ -194,37 +195,54 @@ const cropOf = (source) => {
 		b
 	};
 };
-/**
-* The primitives one picture draws: the bitmap (rotated and/or washed as the
-* source asks) followed by its border. Empty when the bytes are unusable, with
-* the reason already reported.
-*/
-const paintImage = ({ source, rect, context, label }) => {
-	const primitives = [];
+const opacityOf = (source) => source.opacity == null ? 1 : Math.min(1, Math.max(0, source.opacity));
+const withOpacity = (children, opacity) => opacity === 1 || children.length === 0 ? children : [{
+	kind: "opacityGroup",
+	opacity,
+	children
+}];
+/** The bitmap one picture draws, or nothing, with the reason already reported. */
+const paintBitmap = ({ source, rect, context, label }) => {
 	const ref = context.images.intern(source.src);
 	if (ref === void 0) {
 		const reason = context.images.failureFor(source.src) ?? "image could not be decoded";
 		const construct = reason.includes("not PNG or JPEG") ? UNSUPPORTED_CONSTRUCT.imageFormat : UNSUPPORTED_CONSTRUCT.imageSource;
 		context.unsupported.report(construct, context.pageIndex, `${label}: ${reason}`);
-	} else {
-		const crop = cropOf(source);
-		const image = {
-			kind: "image",
-			image: ref,
-			rect,
-			...crop === void 0 ? {} : { crop },
-			opacity: source.opacity == null ? 1 : Math.min(1, Math.max(0, source.opacity)),
-			...source.brightness == null ? {} : { brightness: source.brightness },
-			...source.contrast == null ? {} : { contrast: source.contrast }
-		};
+		return [];
+	}
+	const crop = cropOf(source);
+	return [{
+		kind: "image",
+		image: ref,
+		rect,
+		...crop === void 0 ? {} : { crop },
+		opacity: opacityOf(source),
+		...source.brightness == null ? {} : { brightness: source.brightness },
+		...source.contrast == null ? {} : { contrast: source.contrast }
+	}];
+};
+/**
+* The primitives one picture draws: the bitmap or the drawn preview (rotated
+* and/or washed as the source asks) followed by its border. Empty when the
+* bytes are unusable, with the reason already reported.
+*/
+const paintImage = ({ source, rect, context, label }) => {
+	const primitives = [];
+	const drawn = source.preview === void 0 ? paintBitmap({
+		source,
+		rect,
+		context,
+		label
+	}) : withOpacity(paintPreview(source.preview, rect), opacityOf(source));
+	if (drawn.length > 0) {
 		const degrees = parseRotationDegrees(source.transform);
-		if (degrees === 0) primitives.push(image);
+		if (degrees === 0) primitives.push(...drawn);
 		else primitives.push({
 			kind: "rotateGroup",
 			degrees,
 			originXPx: rect.xPx + rect.widthPx / 2,
 			originYPx: rect.yPx + rect.heightPx / 2,
-			children: [image]
+			children: drawn
 		});
 	}
 	if (source.borderWidth != null && source.borderWidth > 0) {

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

@@ -1,3 +1,4 @@
+import { cssBorderStyle } from "../../utils/borderCss.js";
 import { resolveColor } from "../../utils/colorResolver.js";
 import { eighthsToPixels, pointsToPixels } from "../../utils/units.js";
 import { resolveBorderStroke } from "./strokes.js";
@@ -25,7 +26,7 @@ const strokeOf = (border, theme, context) => {
 	if (!border) return;
 	const { stroke, unresolvedColor } = resolveBorderStroke({
 		width: border.size === void 0 || border.size === 0 ? HAIRLINE_WIDTH_PX : eighthsToPixels(border.size),
-		style: border.style,
+		style: cssBorderStyle(border.style),
 		color: resolveColor(border.color, theme)
 	});
 	if (unresolvedColor !== void 0) context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `page border colour ${unresolvedColor}`);

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

@@ -6,17 +6,17 @@ import { countCompressibleSpaces, toPaintedText } from "../../layout-engine/meas
 import { isFloatingImageRun } from "../../layout-engine/types.js";
 import { resolveParagraphBorderHorizontalOutsets } from "../../layout-painter/borderStroke.js";
 import { getAutomaticTextColorForBackground } from "../../layout-painter/documentColors.js";
-import { UNICODE_BIDI_BY_WRAPPER_CONTROL, getLeaderChar, getRenderableTextColor, sliceRunsForLine, splitCollapsibleLineEdgeSpaces, splitTextRunsByEastAsia, startsAfterSoftWrap } from "../../layout-painter/renderParagraph.js";
+import { UNICODE_BIDI_BY_WRAPPER_CONTROL, getLeaderChar, getRenderableTextColor, paragraphHasTrackedChanges, sliceRunsForLine, splitCollapsibleLineEdgeSpaces, splitTextRunsByEastAsia, startsAfterSoftWrap } from "../../layout-painter/renderParagraph.js";
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
 import { resolvePhysicalParagraphInlineLayout } from "../../utils/paragraphInlineLayout.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 import { sanitizeExternalUrl } from "../../utils/urlSecurity.js";
-import { HIT_REGION_KINDS } from "../primitives.js";
+import { HIT_REGION_KINDS, strokeCrossExtentPx } from "../primitives.js";
 import { trackedChangeColor } from "./buildContext.js";
 import { DOC_CANVAS_TEXT, parseDisplayColor } from "./colors.js";
 import { buildGlyphs, glyphRunText } from "./glyphs.js";
 import { paintImage } from "./imagePrimitives.js";
-import { decorationPatternForStyle, resolveBorderStroke } from "./strokes.js";
+import { resolveBorderStroke, underlinePattern, underlineStrokeCount, underlineWeight } from "./strokes.js";
 import { strikethroughCenterYPx, underlineCenterYPx, underlineThicknessPx } from "./textDecorations.js";
 import { UNSUPPORTED_CONSTRUCT } from "./unsupported.js";
 //#region src/display-list/build/paragraphPrimitives.ts
@@ -66,6 +66,14 @@ const SUBSCRIPT_DROP_RATIO = .2;
 const WIDTH_EPSILON_PX = .5;
 /** `w:pBdr` bar borders hang this far left of the text (`renderParagraph.ts:3072`). */
 const BAR_BORDER_OFFSET_PX = 8;
+/** Word's review indicator sits in the page margin outside the paragraph. */
+const REVIEW_BAR_OFFSET_PX = 24;
+const REVIEW_BAR_COLOR = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 1
+};
 const AUTOMATIC_TEXT_COLOR_VALUES = /* @__PURE__ */ new Set(["auto", "windowtext"]);
 /** `w:color w:val="auto"` and its `windowtext` spelling, normalized as the painter normalizes them. */
 const isAutomaticTextColor = (color) => AUTOMATIC_TEXT_COLOR_VALUES.has(color.trim().toLowerCase().replace(/^#/u, ""));
@@ -151,6 +159,18 @@ const paintParagraphChrome = ({ fragment, block, context, prevBorders, nextBorde
 		});
 		else context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `paragraph shading ${shading}`);
 	}
+	if (paragraphHasTrackedChanges(block)) primitives.push({
+		kind: "line",
+		x1Px: fragment.x - REVIEW_BAR_OFFSET_PX,
+		y1Px: fragment.y,
+		x2Px: fragment.x - REVIEW_BAR_OFFSET_PX,
+		y2Px: fragment.y + fragment.height,
+		stroke: {
+			color: REVIEW_BAR_COLOR,
+			thicknessPx: 2,
+			pattern: "solid"
+		}
+	});
 	const borders = block.attrs?.borders;
 	if (!borders) return primitives;
 	const topBorder = bordersFormGroup(prevBorders, borders) ? borders.between : borders.top;
@@ -380,7 +400,7 @@ const emitGlyphRun = ({ sink, context, run, glyphs, style, paintXPx, baselineYPx
 		color,
 		context,
 		xPx: paintXPx,
-		widthPx: glyphs.widthPx,
+		glyphs,
 		baselineYPx: runBaselineYPx,
 		fontSizePx
 	});
@@ -399,23 +419,83 @@ const emitGlyphRun = ({ sink, context, run, glyphs, style, paintXPx, baselineYPx
 	}
 	reportRunEffects(run, context);
 };
-const emitDecorations = ({ sink, run, color, context, xPx, widthPx, baselineYPx, fontSizePx }) => {
+/**
+* The ordinary space, the only character `words` breaks an underline at.
+*
+* It is the same character justification stretches (`countCompressibleSpaces`):
+* a no-break space holds two words together, so Word underlines through it.
+*/
+const WORD_SEPARATOR = " ";
+/**
+* Where an underline is drawn under a run: the whole run, or one span per word.
+*
+* Word's `words` member underlines the words and not the gaps between them.
+* CSS cannot express that, so the editor underlines the run whole
+* (`text-decoration-skip-ink` skips descender ink, and
+* `text-decoration-skip: spaces` never shipped). A display list carries one
+* advance per code point, so here the member is exact rather than approximated.
+*/
+const underlineSpans = (glyphs, xPx, perWord) => {
+	if (!perWord) return [{
+		xPx,
+		widthPx: glyphs.widthPx
+	}];
+	const spans = [];
+	let cursorPx = xPx;
+	let wordStartPx;
+	let index = 0;
+	const pushWord = (endPx) => {
+		if (wordStartPx !== void 0 && endPx > wordStartPx) spans.push({
+			xPx: wordStartPx,
+			widthPx: endPx - wordStartPx
+		});
+		wordStartPx = void 0;
+	};
+	for (const char of glyphs.text) {
+		const advancePx = glyphs.advancesPx[index] ?? 0;
+		index += 1;
+		if (char === WORD_SEPARATOR) pushWord(cursorPx);
+		else if (wordStartPx === void 0) wordStartPx = cursorPx;
+		cursorPx += advancePx;
+	}
+	pushWord(cursorPx);
+	return spans;
+};
+/**
+* Where each stroke of a stacked decoration sits, relative to the path.
+*
+* One stroke sits on the path. Two are pushed apart by the band each occupies
+* plus the gap a `double` stroke leaves between its rules, so `wavyDouble`'s
+* waves clear each other by the same margin and stay centred on the underline.
+*/
+const stackedStrokeOffsetsPx = (stroke, count) => {
+	if (count < 2) return [0];
+	const separationPx = strokeCrossExtentPx(stroke) + 1 * stroke.thicknessPx;
+	return Array.from({ length: count }, (_, index) => (index - (count - 1) / 2) * separationPx);
+};
+const emitDecorations = ({ sink, run, color, context, xPx, glyphs, baselineYPx, fontSizePx }) => {
+	const { widthPx } = glyphs;
 	if (widthPx <= 0) return;
-	const thicknessPx = underlineThicknessPx(fontSizePx);
+	const plainThicknessPx = underlineThicknessPx(fontSizePx);
 	const trackedColor = run.isInsertion || run.isDeletion ? trackedChangeColor(context.authorColors, run.changeAuthor, run.isSuggestion) : void 0;
 	if (Boolean(run.underline) && !isNoteReferenceRun(run) || run.isInsertion) {
 		const authored = typeof run.underline === "object" ? run.underline : void 0;
 		const authoredColor = authored?.color === void 0 ? void 0 : parseDisplayColor(authored.color);
-		const pattern = run.isSuggestion ? "dotted" : decorationPatternForStyle(authored?.style);
-		sink.decorations.push(horizontalLine(xPx, widthPx, underlineCenterYPx(baselineYPx, fontSizePx), {
-			color: trackedColor ?? authoredColor ?? color,
-			thicknessPx,
-			pattern
-		}));
+		const style = run.isSuggestion ? void 0 : authored?.style;
+		const pattern = run.isSuggestion ? "dotted" : underlinePattern(style);
+		if (pattern !== "none") {
+			const stroke = {
+				color: trackedColor ?? authoredColor ?? color,
+				thicknessPx: plainThicknessPx * underlineWeight(style),
+				pattern
+			};
+			const centerYPx = underlineCenterYPx(baselineYPx, fontSizePx);
+			for (const span of underlineSpans(glyphs, xPx, style === "words")) for (const offsetPx of stackedStrokeOffsetsPx(stroke, underlineStrokeCount(style))) sink.decorations.push(horizontalLine(span.xPx, span.widthPx, centerYPx + offsetPx, stroke));
+		}
 	}
 	if (run.strike || run.isDeletion) sink.decorations.push(horizontalLine(xPx, widthPx, strikethroughCenterYPx(baselineYPx, fontSizePx), {
 		color: trackedColor ?? color,
-		thicknessPx,
+		thicknessPx: plainThicknessPx,
 		pattern: run.isSuggestion ? "dotted" : "solid"
 	}));
 };

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

@@ -0,0 +1,10 @@
+import { document_d_exports } from "../../types/document.js";
+import { DisplayPrimitive, DisplayRect } from "../types.js";
+//#region src/display-list/build/previewPrimitives.d.ts
+/**
+ * The marks a descriptor makes inside `box`, back to front: the backdrop, then
+ * each shape in the order the drawing lists them.
+ */
+declare const paintPreview: (descriptor: document_d_exports.PreviewDescriptor, box: DisplayRect) => readonly DisplayPrimitive[];
+//#endregion
+export { paintPreview };

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

@@ -0,0 +1,89 @@
+import { parseDisplayColor } from "./colors.js";
+import { panic } from "better-result";
+//#region src/display-list/build/previewPrimitives.ts
+/**
+* The primitives a preview descriptor draws.
+*
+* A drawing with no image data used to be given one: a megapixel PNG built the
+* moment something was about to paint it, which the DOM backend showed as an
+* `<img>` and the PDF exporter embedded as a bitmap — a photograph of a
+* drawing that is nothing but flat rectangles.
+*
+* The descriptor already holds those rectangles, in the drawing's own
+* coordinate space, and `rect` is a primitive both backends draw natively. So
+* the preview is drawn rather than sampled: the extent maps affinely onto the
+* image's box, every shape becomes a filled rectangle inside it, and no raster
+* exists at any point. The DOM backend paints each one as the absolutely
+* positioned div it paints every other `rect` as, and the PDF backend emits
+* `re`/`f` operators, so the drawing stays a drawing at any zoom.
+*/
+/** The flat backdrop a preview is drawn on, behind every shape. */
+const PREVIEW_BACKGROUND = {
+	r: 238,
+	g: 242,
+	b: 247,
+	a: 1
+};
+/** A shape whose `a:srgbClr` was missing or is not a colour. */
+const PREVIEW_SHAPE_FILL = {
+	r: 232,
+	g: 238,
+	b: 247,
+	a: 1
+};
+const clampFraction = (value) => Math.min(1, Math.max(0, value));
+/**
+* One shape's box, as the fraction of the extent it covers applied to the
+* image's box. `undefined` for a shape the box keeps nothing of, which is the
+* clip the raster did by clamping to its own bounds.
+*/
+const shapeRect = ({ shape, extent, box }) => {
+	const left = clampFraction(shape.x / extent.width);
+	const right = clampFraction((shape.x + shape.width) / extent.width);
+	const top = clampFraction(shape.y / extent.height);
+	const bottom = clampFraction((shape.y + shape.height) / extent.height);
+	if (right <= left || bottom <= top) return;
+	return {
+		xPx: box.xPx + left * box.widthPx,
+		yPx: box.yPx + top * box.heightPx,
+		widthPx: (right - left) * box.widthPx,
+		heightPx: (bottom - top) * box.heightPx
+	};
+};
+/**
+* The marks a descriptor makes inside `box`, back to front: the backdrop, then
+* each shape in the order the drawing lists them.
+*/
+const paintPreview = (descriptor, box) => {
+	switch (descriptor.kind) {
+		case "diagram": {
+			const primitives = [{
+				kind: "rect",
+				rect: box,
+				fill: PREVIEW_BACKGROUND
+			}];
+			const { extent } = descriptor;
+			if (!(extent.width > 0 && extent.height > 0)) return primitives;
+			for (const shape of descriptor.shapes) {
+				const rect = shapeRect({
+					shape,
+					extent,
+					box
+				});
+				if (rect === void 0) continue;
+				primitives.push({
+					kind: "rect",
+					rect,
+					fill: parseDisplayColor(shape.color) ?? PREVIEW_SHAPE_FILL
+				});
+			}
+			return primitives;
+		}
+		default: {
+			const unreachable = descriptor.kind;
+			return panic(`unhandled preview kind: ${String(unreachable)}`);
+		}
+	}
+};
+//#endregion
+export { paintPreview };