reamkit 1.29.0 → 1.31.0

package/dist/esm/pdf-reader/flow-build.js

@@ -2,6 +2,7 @@ import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
+import { gradientOverBox } from "./shading.js";
 import { displayOf } from "./display.js";
 //#region src/pdf-reader/flow-build.ts
 /**
@@ -21,6 +22,35 @@ function paragraphBlock(text, outlineLevel) {
 		}
 	};
 }
+/** One piece of reconstructed text, carrying any hyperlink (E-PDF EP8). */
+/**
+* The space set between a span and what follows it, in the span's own size and
+* face: a word space is as wide as the type it stands in.
+*
+* Written bare, the space took the document's default size, whatever the words
+* around it were set at: issue10665_reduced.pdf sets "78" and "110" twenty
+* points apart in 60-point type, and the eleven-point space between them closed
+* them up to "78110"; in 7-point footnotes the same space is half as wide
+* again as the page's, and pushes their lines over.
+*
+* A space between two words one text markup marks is marked with them: the
+* band a highlighter lays runs across the gap. comments.pdf highlights two
+* lines on its sixth page, and with its spaces left bare the band came back
+* broken at every word.
+*
+* @param before The span the space follows, where there is one.
+* @param after  What follows the space, where anything does.
+* @returns The space.
+*/
+function spaceAfter(before, after) {
+	const markup = before?.markup;
+	return {
+		text: " ",
+		...before?.sizePt !== void 0 ? { sizePt: before.sizePt } : {},
+		...before?.fontName !== void 0 ? { fontName: before.fontName } : {},
+		...markup !== void 0 && after?.markup !== void 0 && sameMarkup(markup, after.markup) ? { markup } : {}
+	};
+}
 /**
 * Build a paragraph {@link BodyElement} from positioned {@link TextSpan}s,
 * coalescing consecutive spans that share an `href` into one run (so a link
@@ -31,7 +61,7 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 	const merged = [];
 	for (const s of spans) {
 		const last = merged[merged.length - 1];
-		if (last && last.href === s.href && last.sizePt === s.sizePt && last.colorHex === s.colorHex && last.fontName === s.fontName && last.outline?.colorHex === s.outline?.colorHex && last.outline?.widthPt === s.outline?.widthPt && last.bold === s.bold && last.italic === s.italic && last.script === s.script && sameMarkup(last.markup, s.markup)) last.text += s.text;
+		if (last && last.href === s.href && last.sizePt === s.sizePt && last.colorHex === s.colorHex && last.fontName === s.fontName && last.outline?.colorHex === s.outline?.colorHex && last.outline?.widthPt === s.outline?.widthPt && last.bold === s.bold && last.italic === s.italic && last.script === s.script && last.widthScale === s.widthScale && sameMarkup(last.markup, s.markup)) last.text += s.text;
 		else merged.push({
 			text: s.text,
 			...s.href !== void 0 ? { href: s.href } : {},
@@ -42,7 +72,8 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 			...s.bold !== void 0 ? { bold: s.bold } : {},
 			...s.italic !== void 0 ? { italic: s.italic } : {},
 			...s.script !== void 0 ? { script: s.script } : {},
-			...s.markup !== void 0 ? { markup: s.markup } : {}
+			...s.markup !== void 0 ? { markup: s.markup } : {},
+			...s.widthScale !== void 0 ? { widthScale: s.widthScale } : {}
 		});
 	}
 	const runs = merged.map((m) => ({
@@ -65,7 +96,10 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 				properties: {
 					...r.sizePt !== void 0 ? { fontSizePt: pt(r.sizePt) } : {},
 					...r.colorHex !== void 0 ? { colorHex: r.colorHex } : {},
-					...r.fontName !== void 0 ? { fontFamily: { ascii: r.fontName } } : {},
+					...r.fontName !== void 0 ? { fontFamily: {
+						ascii: r.fontName,
+						hAnsi: r.fontName
+					} } : {},
 					...r.outline !== void 0 ? { textOutline: r.outline } : {},
 					...r.bold ? { bold: true } : {},
 					...r.italic ? { italic: true } : {},
@@ -73,7 +107,8 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 					...r.markup?.highlightHex !== void 0 ? { shadingColorHex: r.markup.highlightHex } : {},
 					...r.markup?.underline !== void 0 ? { underline: r.markup.underline } : {},
 					...r.markup?.underlineHex !== void 0 ? { underlineColorHex: r.markup.underlineHex } : {},
-					...r.markup?.strike === true ? { strike: true } : {}
+					...r.markup?.strike === true ? { strike: true } : {},
+					...r.widthScale !== void 0 ? { widthScale: r.widthScale } : {}
 				},
 				...r.href ? { href: r.href } : {}
 			}))
@@ -85,6 +120,23 @@ function sameMarkup(a, b) {
 	return a?.highlightHex === b?.highlightHex && a?.underline === b?.underline && a?.underlineHex === b?.underlineHex && a?.strike === b?.strike;
 }
 /**
+* The height of a line that carries nothing to read: one twip, the least
+* §17.3.1.33 can state. Zero is not a height a writer states at all — it is
+* read as "no line spacing given", and the reader's single spacing comes back.
+*/
+var CARRIER_LINE_PT = pt(.05);
+/**
+* §17.3.1.33 — the paragraph a floating mark is anchored in, which takes no
+* room: the mark stands where the page drew it and the line carrying it is on
+* no page. Left at a reader's single spacing, every rule and fill an invoice
+* draws was a blank line in the flow, and the text under it moved down a line
+* for each.
+*/
+var FLOAT_CARRIER = {
+	spacingLine: CARRIER_LINE_PT,
+	spacingLineRule: "exact"
+};
+/**
 * Store a {@link PdfImage}'s bytes (content-addressed dedup) and build the image
 * {@link BodyElement} that references them, sized in points from the placement
 * CTM. `alt` becomes the block's alt text when given.
@@ -112,9 +164,10 @@ function imageBlock(image, resources, alt, frame, zOrder, behind = false) {
 			width: pt(image.widthPt),
 			height: pt(image.heightPt),
 			...image.rotationDeg !== void 0 ? { rotation60k: Math.round(-image.rotationDeg * 6e4) } : {},
+			...image.flipV === true ? { flipV: true } : {},
 			...image.crop ? { crop: image.crop } : {},
 			...image.alpha !== void 0 ? { alpha: image.alpha } : {},
-			paragraphProperties: {},
+			paragraphProperties: float ? FLOAT_CARRIER : {},
 			...alt ? { altText: alt } : {}
 		}
 	};
@@ -138,7 +191,6 @@ function imageBlock(image, resources, alt, frame, zOrder, behind = false) {
 * @returns A shape carrying the text, anchored where the glyphs were.
 */
 function positionedText(spans, box, frame, zOrder, rotation60k) {
-	const paragraph = paragraphFromRuns(spans);
 	return {
 		kind: "shape",
 		shape: {
@@ -154,22 +206,134 @@ function positionedText(spans, box, frame, zOrder, rotation60k) {
 					offsetPt: pt(Math.max(0, frame.top - box.y - box.height))
 				}
 			},
-			width: pt(Math.max(1, box.width)),
-			height: pt(Math.max(1, box.height)),
-			...rotation60k !== void 0 ? { transform: { rotation60k } } : {},
+			...lineBox(spans, box, rotation60k),
+			paragraphProperties: FLOAT_CARRIER
+		}
+	};
+}
+/** A line of text in a box of its own, sized to the box, which nobody sees. */
+function lineBox(spans, box, rotation60k, noWrap = false) {
+	const paragraph = paragraphFromRuns(spans, void 0, {
+		spacingLine: pt(Math.max(1, box.height)),
+		spacingLineRule: "exact"
+	});
+	return {
+		width: pt(Math.max(1, box.width)),
+		height: pt(Math.max(1, box.height)),
+		...rotation60k !== void 0 ? { transform: { rotation60k } } : {},
+		geometry: {
+			kind: "preset",
+			preset: "rect"
+		},
+		fill: { kind: "none" },
+		text: {
+			content: [paragraph],
+			insetLeft: pt(0),
+			insetTop: pt(0),
+			insetRight: pt(0),
+			insetBottom: pt(0),
+			...noWrap ? { noWrap: true } : {}
+		}
+	};
+}
+/** A path of a figure, drawn where the page drew it. */
+function vectorMember(v) {
+	const el = shapeBlock(v);
+	if (el.kind !== "shape") throw new Error("a path is drawn as a shape");
+	return {
+		shape: el.shape,
+		left: v.minX,
+		top: v.maxY
+	};
+}
+/**
+* A picture of a figure: a box filled with it (§20.1.8.14), which is what a
+* `pic:pic` inside a group is — the shadows comments.pdf lays under each of
+* its boxes.
+*/
+function imageMember(image, resources) {
+	const turned = image.rotationDeg !== void 0 || image.flipV === true;
+	return {
+		shape: {
+			width: pt(image.widthPt),
+			height: pt(image.heightPt),
+			...turned ? { transform: {
+				...image.rotationDeg !== void 0 ? { rotation60k: Math.round(-image.rotationDeg * 6e4) } : {},
+				...image.flipV === true ? { flipV: true } : {}
+			} } : {},
 			geometry: {
 				kind: "preset",
 				preset: "rect"
 			},
-			fill: { kind: "none" },
-			text: {
-				content: [paragraph],
-				insetLeft: pt(0),
-				insetTop: pt(0),
-				insetRight: pt(0),
-				insetBottom: pt(0)
+			fill: {
+				kind: "picture",
+				imageResource: resources.put(image.bytes),
+				...image.crop ? { imageCrop: image.crop } : {},
+				...image.alpha !== void 0 ? { alpha: image.alpha } : {}
 			},
 			paragraphProperties: {}
+		},
+		left: image.x,
+		top: image.y + image.heightPt
+	};
+}
+/**
+* A label of a figure: a line of its words, in a box as wide as they are.
+* The box never wraps — set in a face a little wider than the page's, one
+* word would break in two.
+*/
+function labelMember(spans, box, rotation60k) {
+	return {
+		shape: {
+			...lineBox(spans, box, rotation60k, true),
+			paragraphProperties: {}
+		},
+		left: box.x,
+		top: box.y + box.height
+	};
+}
+/** The box a figure's parts stand in, on the page (y-up). */
+function membersBox(members) {
+	return {
+		left: Math.min(...members.map((m) => m.left)),
+		top: Math.max(...members.map((m) => m.top)),
+		right: Math.max(...members.map((m) => m.left + m.shape.width)),
+		bottom: Math.min(...members.map((m) => m.top - m.shape.height))
+	};
+}
+/**
+* §20.5.2.17 — a figure as the one drawing it is: a group holding its paths,
+* its pictures and its labels at their places in it, set in a paragraph of
+* its own. An inline drawing takes the room it is tall (a line holding
+* nothing but a picture is the picture's height in Word), so the text after
+* it follows it, and the figure goes with its paragraph wherever the text
+* puts that.
+*
+* @param members    Its parts, in the order they are painted.
+* @param properties The paragraph it stands in.
+*/
+function figureBlock(members, properties) {
+	const box = membersBox(members);
+	return {
+		kind: "shape",
+		shape: {
+			width: pt(box.right - box.left),
+			height: pt(box.top - box.bottom),
+			children: members.map((m) => ({
+				shape: m.shape,
+				xPt: pt(m.left - box.left),
+				yPt: pt(box.top - m.top)
+			})),
+			geometry: {
+				kind: "custom",
+				custom: {
+					pathWidth: 0,
+					pathHeight: 0,
+					commands: []
+				}
+			},
+			fill: { kind: "none" },
+			paragraphProperties: properties
 		}
 	};
 }
@@ -226,17 +390,21 @@ function shapeBlock(v, frame, zOrder, behind = false) {
 	const alpha = v.alpha !== void 0 ? { alpha: v.alpha } : {};
 	const fill = v.gradient !== void 0 ? {
 		kind: "gradient",
-		gradient: v.gradient,
+		gradient: gradientOverBox(v.gradient, v),
 		...alpha
 	} : v.fillHex !== void 0 ? {
 		kind: "solid",
 		colorHex: v.fillHex,
 		...alpha
 	} : { kind: "none" };
+	const dash = v.strokeHex !== void 0 && v.dash !== void 0 ? penDash(v.dash, pen) : [];
 	const line = v.strokeHex !== void 0 ? {
 		width: pt(pen),
 		colorHex: v.strokeHex,
-		fill: "solid"
+		fill: "solid",
+		...dash.length > 0 ? { customDash: dash } : {},
+		cap: v.cap ?? "flat",
+		...v.strokeAlpha !== void 0 ? { alpha: v.strokeAlpha } : {}
 	} : void 0;
 	const float = frame !== void 0 ? {
 		wrap: "none",
@@ -267,7 +435,7 @@ function shapeBlock(v, frame, zOrder, behind = false) {
 			},
 			fill,
 			...line ? { line } : {},
-			paragraphProperties: {}
+			paragraphProperties: float ? FLOAT_CARRIER : {}
 		}
 	};
 }
@@ -282,10 +450,10 @@ function shapeBlock(v, frame, zOrder, behind = false) {
 * this single geometry — a known approximation, still far better than a fixed
 * `A4`. Returns `undefined` when there is no usable first-page box.
 */
-function sectionFromPdfPages(pages) {
+function sectionFromPdfPages(pages, display) {
 	const first = pages[0];
 	if (!first) return void 0;
-	const shown = displayOf(first);
+	const shown = display ?? displayOf(first);
 	const width = shown.width;
 	const height = shown.height;
 	if (!(width > 0 && height > 0)) return void 0;
@@ -306,6 +474,227 @@ function sectionFromPdfPages(pages) {
 	};
 }
 /**
+* §17.6.20 — a section read in a page's text frame (see `textFrameOf`), set
+* back on the sheet the page is shown on, its lines running down it (`tbRl`).
+*
+* The frame is the sheet turned back a quarter, so its measurements carry
+* over edge for edge: the frame's left margin is where each line starts, the
+* sheet's top one; its top margin is where the first line stands, the
+* sheet's right one.
+*
+* @param section The section as the frame measured it.
+* @param display The geometry its pages were read in.
+* @returns The section on the sheet, or the section unchanged for a page read
+*          on its sheet.
+*/
+function sectionOnSheet(section, display) {
+	const sheet = display?.sheet;
+	if (!section || !sheet) return section;
+	const m = section.margins;
+	return {
+		...section,
+		pageSize: {
+			width: pt(sheet.width),
+			height: pt(sheet.height),
+			orientation: sheet.width > sheet.height ? "landscape" : "portrait"
+		},
+		...m ? { margins: {
+			...m,
+			top: m.left,
+			right: m.top,
+			bottom: m.right,
+			left: m.bottom
+		} } : {},
+		textDirection: "tbRl"
+	};
+}
+/**
+* A mark anchored to a page read in its text frame, set on the SHEET the page
+* is shown on: where the page drew it, turned with the page.
+*
+* Word lays a `tbRl` section's text down the sheet but stands a drawing
+* anchored to the page at its offsets on the sheet, upright (§17.6.20) — so a
+* picture the frame placed is carried onto the sheet, and turned a quarter
+* clockwise as the words around it are.
+*
+* @param el         A body element, anchored or not.
+* @param sheetWidth The sheet's width, which is the frame's height.
+* @returns The element, anchored on the sheet.
+*/
+function floatOntoSheet(el, sheetWidth) {
+	const onto = (float, width, height) => {
+		if (float.posH?.relativeFrom !== "page" || float.posV?.relativeFrom !== "page") return void 0;
+		const cx = (float.posH.offsetPt ?? 0) + width / 2;
+		const cy = (float.posV.offsetPt ?? 0) + height / 2;
+		return {
+			...float,
+			posH: {
+				relativeFrom: "page",
+				offsetPt: pt(sheetWidth - cy - width / 2)
+			},
+			posV: {
+				relativeFrom: "page",
+				offsetPt: pt(cx - height / 2)
+			}
+		};
+	};
+	const quarter = (rotation60k) => ((rotation60k ?? 0) + 90 * 6e4) % (360 * 6e4);
+	if (el.kind === "image" && el.image.float) {
+		const float = onto(el.image.float, el.image.width, el.image.height);
+		if (!float) return el;
+		return {
+			...el,
+			image: {
+				...el.image,
+				float,
+				rotation60k: quarter(el.image.rotation60k)
+			}
+		};
+	}
+	if (el.kind === "shape" && el.shape.float) {
+		const float = onto(el.shape.float, el.shape.width, el.shape.height);
+		if (!float) return el;
+		const rotation60k = quarter(el.shape.transform?.rotation60k);
+		return {
+			...el,
+			shape: {
+				...el.shape,
+				float,
+				transform: {
+					...el.shape.transform,
+					rotation60k
+				}
+			}
+		};
+	}
+	return el;
+}
+/**
+* §8.4.3.6 — a page's dash pattern as DrawingML states one (§20.1.8.21
+* `a:custDash`): dash and gap in turn, as multiples of the pen's width.
+*
+* An odd count of lengths runs twice before it repeats, so the dashes and the
+* gaps trade places the second time round; written out once more, the pairs
+* come out even. A dash of no length is a DOT, drawn by the pen's cap alone —
+* which no .docx line carries — so it is set a pen's width long and the gap
+* after it gives that back, keeping the pattern's period.
+*
+* @param dash The lengths in page-space points.
+* @param pen  The pen's width in points.
+* @returns The pattern in pen widths, or an empty array for a solid line.
+*/
+function penDash(dash, pen) {
+	if (dash.length === 0 || !(pen > 0)) return [];
+	const out = (dash.length % 2 === 1 ? [...dash, ...dash] : [...dash]).map((n) => n / pen);
+	for (let i = 0; i < out.length; i += 2) {
+		if (out[i] > 0) continue;
+		out[i] = 1;
+		out[i + 1] = Math.max(out[i + 1] - 1, MIN_DASH_GAP);
+	}
+	return out;
+}
+/** The least gap a dash pattern keeps, in pen widths, so a dotted line stays dotted. */
+var MIN_DASH_GAP = .5;
+/** What the measure gives back, so the widest line still fits when re-set. */
+var SLACK = .01;
+/** How much of the sheet a margin down the page may take. */
+var DEEPEST_MARGIN = .5;
+/**
+* How far in, as a share of the sheet, a right margin the lines do not show
+* may come: what a sheet of a line or two is re-set across is at least the
+* rest of it.
+*/
+var GUESSED_MARGIN = 1 / 3;
+/** The narrowest measure a sheet's own lines may leave, as a share of the sheet. */
+var NARROWEST_MEASURE = .2;
+/**
+* The lines a sheet's runs stand on — baselines further apart than half the
+* size of the type on them — and how many of them END at the sheet's right
+* edge, within an em of the farthest: the lines a measure broke, or a margin
+* justified, rather than the ones their author stopped.
+*/
+function linesOf(runs) {
+	const ink = runs.filter((r) => r.text.trim() !== "").map((r) => ({
+		y: r.y,
+		end: r.endX,
+		size: r.fontSizePt || 10
+	})).sort((a, b) => b.y - a.y);
+	const lines = [];
+	for (const at of ink) {
+		const last = lines[lines.length - 1];
+		if (last !== void 0 && last.y - at.y <= Math.max(last.size, at.size) / 2) {
+			last.end = Math.max(last.end, at.end);
+			last.size = Math.max(last.size, at.size);
+		} else lines.push({ ...at });
+	}
+	const edge = Math.max(...lines.map((l) => l.end));
+	return {
+		count: lines.length,
+		atEdge: lines.filter((l) => edge - l.end <= l.size).length
+	};
+}
+/**
+* The white, in ems of the text, a running foot keeps above it — which is
+* what the reader asked of it before it took the line for a foot at all.
+*/
+var FOOT_CLEAR_EM = 2;
+/**
+* §17.3.1.33 — where the baseline of an EXACT line stands in its box, from the
+* top. LibreOffice puts it at four fifths of the height; Word at the height
+* less the face's descent, which for the faces documents use is within a tenth
+* of a line of the same place.
+*/
+var BASELINE_AT = .8;
+/** A line's box where no pitch was measured: the ordinary single spacing, in ems. */
+var NATURAL_LINE_EM = 1.2;
+/**
+* How far above its baseline the first line's BOX reaches, as a fraction of the
+* size — which is what the top margin has to leave room for. The lines are set
+* in exact boxes (see `groupIntoParagraphs`), so this is where the box's top
+* stands, not where a face's ascender happens to.
+*/
+var ASCENDER = BASELINE_AT * NATURAL_LINE_EM;
+/**
+* And how far below its baseline the last line's box reaches. A box set half
+* as deep again as its size reaches three tenths of it down; measured to a
+* face's descender instead, bug1337429.pdf's last line did not fit the sheet
+* it was drawn on and went to a second one.
+*/
+var DESCENDER = (1 - BASELINE_AT) * 1.5;
+/**
+* How small, against the document's own text, type may be set and still be
+* read as text rather than as a mark the producer left on the sheet.
+*/
+var LEGIBLE_SHARE = .25;
+/**
+* The size a document's text is set in: the middle of every size its runs
+* carry.
+*
+* @param pageRuns Each page's runs.
+* @returns The size, in points; 0 where no run states one.
+*/
+function textSizeOf(pageRuns) {
+	const sizes = pageRuns.flat().map((r) => r.fontSizePt).filter((s) => s > 0).sort((a, b) => a - b);
+	return sizes[Math.floor(sizes.length / 2)] ?? 0;
+}
+/**
+* Whether a run is set too small to be read, beside the text of its document —
+* a mark the producer leaves on the sheet, not a line of the page.
+*
+* TCPDF signs the last page of everything it makes "Powered by TCPDF
+* (www.tcpdf.org)" in type one point high, three points from the corner of the
+* paper. Taken for text it was the leftmost and the lowest thing on the page:
+* the margins came in at the edge of the sheet and every line of basicapi.pdf
+* and alphatrans.pdf was set against it.
+*
+* @param run      The run.
+* @param textSize The size the document's text is set in (see {@link textSizeOf}).
+* @returns `true` where the run is a mark rather than text.
+*/
+function tooSmallToRead(run, textSize) {
+	return run.fontSizePt > 0 && run.fontSizePt < textSize * LEGIBLE_SHARE;
+}
+/**
 * The margins the SOURCE used, measured off where its words actually sit.
 *
 * A PDF states none — text is placed anywhere on the MediaBox — so the reader
@@ -322,18 +711,13 @@ function sectionFromPdfPages(pages) {
 * @param section  The section the page box gave, or `undefined`.
 * @param shown    Each page as it is shown, for its own width and height.
 * @param pageRuns Each page's runs, already placed on the shown page.
+* @param pageMarks Each page's pictures, which the measure has to hold.
+* @param foot     The running foot lifted off the pages, as the first page
+*                 showed it — the band the text block stands above.
 * @returns The section with measured margins, or `section` when nothing is
 *          measurable.
 */
-/** What the measure gives back, so the widest line still fits when re-set. */
-var SLACK = .01;
-/** How much of the sheet a margin down the page may take. */
-var DEEPEST_MARGIN = .5;
-/** How far a face's ascender stands above its baseline, as a fraction of the size. */
-var ASCENDER = .8;
-/** And its descender below — the two together are a little over one em. */
-var DESCENDER = .22;
-function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
+function withMeasuredMargins(section, shown, pageRuns, pageMarks = [], foot = []) {
 	if (!section?.pageSize) return section;
 	const width = section.pageSize.width;
 	const height = section.pageSize.height;
@@ -341,8 +725,10 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 	const rights = [];
 	const tops = [];
 	const bottoms = [];
-	pageRuns.forEach((runs, i) => {
+	const textSize = textSizeOf(pageRuns);
+	pageRuns.forEach((all, i) => {
 		const page = shown[i];
+		const runs = all.filter((r) => r.annotation !== true && !tooSmallToRead(r, textSize));
 		if (!page || runs.length === 0) return;
 		let minX = Infinity;
 		let maxX = -Infinity;
@@ -365,6 +751,7 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 				topSize = r.fontSizePt;
 			}
 		}
+		const textEnd = maxX;
 		for (const mark of pageMarks[i] ?? []) {
 			if (!Number.isFinite(mark.x) || !Number.isFinite(mark.y)) continue;
 			maxX = Math.max(maxX, mark.x + mark.widthPt);
@@ -372,7 +759,12 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 		}
 		if (!Number.isFinite(minX) || !Number.isFinite(minY)) return;
 		lefts.push(minX);
-		rights.push(page.width - maxX);
+		const lines = linesOf(runs);
+		rights.push({
+			value: page.width - maxX,
+			full: lines.count >= 3 || maxX > textEnd,
+			edged: lines.atEdge >= 2 && maxX <= textEnd
+		});
 		tops.push(page.height - maxY - topSize * ASCENDER);
 		bottoms.push(minY - bottomSize * DESCENDER);
 	});
@@ -382,34 +774,148 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 		return s[Math.floor(s.length / 2)] ?? 0;
 	};
 	const clamp = (v, span, most = 1 / 3) => pt(Math.max(0, Math.min(v, span * most)));
+	const inked = foot.filter((r) => r.text.trim() !== "");
+	const footTop = Math.max(...inked.map((r) => r.y + r.fontSizePt * ASCENDER));
+	const footBottom = Math.min(...inked.map((r) => r.y - r.fontSizePt * DESCENDER));
+	const floor = inked.length > 0 ? footTop + textSize * FOOT_CLEAR_EM : Infinity;
+	const left = clamp(Math.min(...lefts), width);
+	const voters = rights.filter((r) => r.full);
+	const farthest = voters.length > 0 && voters.every((r) => r.edged) ? Math.max(width * GUESSED_MARGIN, width * (1 - NARROWEST_MEASURE) - left) : width * GUESSED_MARGIN;
 	return {
 		...section,
 		margins: {
-			left: clamp(Math.min(...lefts), width),
-			right: clamp(median(rights) - width * SLACK, width),
+			left,
+			right: pt(Math.max(0, Math.min(median((voters.length > 0 ? voters : rights).map((r) => r.value)) - width * SLACK, farthest))),
 			top: clamp(Math.min(...tops), height, DEEPEST_MARGIN),
-			bottom: clamp(Math.min(...bottoms) - height * SLACK, height, DEEPEST_MARGIN)
+			bottom: clamp(Math.min(...bottoms, floor) - height * SLACK, height, DEEPEST_MARGIN),
+			...inked.length > 0 ? { footer: clamp(footBottom, height, DEEPEST_MARGIN) } : {}
 		}
 	};
 }
 /**
+* The runs set in a face the page KERNED or LIGATED, marked so (see
+* `pageSpacing`, `FaceOutlines.ligatures`): a word processor kerns nothing a
+* run does not ask it to, and set unkerned, a line kerned on the page runs
+* longer than it did there; a ligature the embedded face carries is formed
+* where the run asks for its face's ligatures.
+*
+* @param blocks   The blocks to mark, tables and text boxes within them too.
+* @param typeset  Run font name → what its runs ask for.
+* @returns The blocks, their runs in those faces asking for it.
+*/
+function typesetRuns(blocks, typeset) {
+	if (typeset.size === 0) return [...blocks];
+	const shape = (s) => ({
+		...s,
+		...s.text ? { text: {
+			...s.text,
+			content: typesetRuns(s.text.content, typeset)
+		} } : {},
+		...s.children ? { children: s.children.map((child) => ({
+			...child,
+			shape: shape(child.shape)
+		})) } : {}
+	});
+	return blocks.map((el) => {
+		if (el.kind === "paragraph") {
+			const runs = el.paragraph.runs.map((run) => {
+				const face = run.properties.fontFamily?.ascii;
+				const asked = face !== void 0 ? typeset.get(face) : void 0;
+				return asked ? {
+					...run,
+					properties: {
+						...run.properties,
+						...asked
+					}
+				} : run;
+			});
+			return {
+				...el,
+				paragraph: {
+					...el.paragraph,
+					runs
+				}
+			};
+		}
+		if (el.kind === "table") {
+			const rows = el.table.rows.map((row) => ({
+				...row,
+				cells: row.cells.map((cell) => ({
+					...cell,
+					content: typesetRuns(cell.content, typeset)
+				}))
+			}));
+			return {
+				...el,
+				table: {
+					...el.table,
+					rows
+				}
+			};
+		}
+		if (el.kind === "shape") return {
+			...el,
+			shape: shape(el.shape)
+		};
+		return el;
+	});
+}
+/**
+* What each face's runs ask for: kerning where the page kerned the face, and
+* its standard ligatures where the page drew one of them (the ligatures the
+* face's embedded font then forms are exactly the ones the page drew).
+*
+* @param kerned       The run font names of the faces the page kerned.
+* @param faceOutlines Run font name → the face's outlines, ligatures among them.
+*/
+function typesetting(kerned, faceOutlines) {
+	const out = /* @__PURE__ */ new Map();
+	for (const face of kerned) out.set(face, { kerningMinPt: KERN_FROM_PT });
+	for (const [face, outlines] of faceOutlines ?? []) if (outlines.ligatures && outlines.ligatures.size > 0) out.set(face, {
+		...out.get(face),
+		ligatures: "standard"
+	});
+	return out;
+}
+/** §17.3.2.19 — kerned from one point up: at every size a page is set in. */
+var KERN_FROM_PT = pt(1);
+/**
 * Assemble the final {@link FlowDoc} for a reconstruction: the body elements
 * with their styles resolved against the empty style sheet, the lifted-image
 * resource store, and the optional page {@link SectionProperties}. Shared by
 * both reconstruction paths (the tagged fast-path EP3 and the heuristic layout
 * path EP4).
 */
-function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFonts, sections = [], headersFooters) {
+function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFonts, sections = [], headersFooters, faceFamilies, faceOutlines, kerned = /* @__PURE__ */ new Set()) {
+	const typeset = typesetting(kerned, faceOutlines);
+	const bands = headersFooters && typeset.size > 0 ? new Map([...headersFooters].map(([id, blocks]) => [id, typesetRuns(blocks, typeset)])) : headersFooters;
 	return {
 		kind: "flow",
-		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
+		body: resolveBodyStyles(typesetRuns(body, typeset), RECONSTRUCTION_SHEET),
 		sections,
-		...headersFooters && headersFooters.size > 0 ? { headersFooters } : {},
+		...bands && bands.size > 0 ? { headersFooters: bands } : {},
 		...section ? { section } : {},
 		...embeddedFonts && embeddedFonts.size > 0 ? { embeddedFonts } : {},
+		...faceFamilies && faceFamilies.size > 0 ? { faceFamilies } : {},
+		...faceOutlines && faceOutlines.size > 0 ? { faceOutlines } : {},
+		compatibilityMode: CURRENT_WORD_LAYOUT,
 		styles: EMPTY_STYLE_SHEET,
 		resources
 	};
 }
+/** [MS-DOCX] `compatibilityMode` 15 — Word 2013's layout, a current Word's. */
+var CURRENT_WORD_LAYOUT = 15;
+/**
+* §17.3.1.44 — the sheet a reconstruction's paragraphs resolve against: the
+* empty one, with widow control off. Every source page opens a page of its
+* own, and the page already broke its paragraphs where it did; where a
+* reconstructed column runs a line long, widow control — on wherever nothing
+* says otherwise — carries a second line over with it, and the column after
+* runs longer still.
+*/
+var RECONSTRUCTION_SHEET = {
+	...EMPTY_STYLE_SHEET,
+	defaultParagraphProperties: { widowControl: false }
+};
 //#endregion
-export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock, withMeasuredMargins };
+export { ASCENDER, BASELINE_AT, CARRIER_LINE_PT, GUESSED_MARGIN, NATURAL_LINE_EM, buildFlowDoc, dedupeLosses, figureBlock, floatOntoSheet, imageBlock, imageMember, labelMember, membersBox, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, sectionOnSheet, shapeBlock, spaceAfter, textSizeOf, tooSmallToRead, vectorMember, withMeasuredMargins };