reamkit 1.29.0 → 1.31.0

package/dist/esm/pdf-reader/layout.js

@@ -3,16 +3,24 @@ import { ResourceStore } from "../core/ir/resources.js";
 import { FEATURES } from "../core/ir/features.js";
 import { isRightToLeft } from "./content.js";
 import { collectEmbeddedFonts } from "./embedded-fonts.js";
+import { collectFaceFamilies } from "./font.js";
+import { displayOf, placeImages, placeRuns, placeVectors, textFrameOf, wordsTurnOf } from "./display.js";
+import { BASELINE_AT, CARRIER_LINE_PT, GUESSED_MARGIN, NATURAL_LINE_EM, buildFlowDoc, dedupeLosses, figureBlock, floatOntoSheet, imageBlock, imageMember, labelMember, membersBox, paragraphFromRuns, positionedText, sectionFromPdfPages, sectionOnSheet, shapeBlock, spaceAfter, textSizeOf, tooSmallToRead, vectorMember, withMeasuredMargins } from "./flow-build.js";
+import { faceOutlinesOf, kernedFaces, pageSpacing } from "./face-outlines.js";
 import { extractPageText } from "./text.js";
 import { collectPageVectors } from "./vector.js";
-import { displayOf, placeImages, placeRuns, placeVectors } from "./display.js";
-import { buildFlowDoc, dedupeLosses, imageBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock, withMeasuredMargins } from "./flow-build.js";
 import { collectPageImages } from "./images.js";
 import { markDrawnRules } from "./text-rules.js";
+import { joinLetters, pageFigures, tracedRun } from "./figures.js";
+import { regionsOf } from "./regions.js";
+import { punctuationOf } from "./glyph-shapes.js";
 import { matrixBlocks } from "./math-rows.js";
+import { pageNumberingOf, runOf } from "./page-numbers.js";
 //#region src/pdf-reader/layout.ts
 /** The relationships the reconstruction files its running head and foot under. */
 var FOOTER_PART = "pdf-running-foot";
+/** The part the running foot of a book's even pages is written to (see `sidesOf`). */
+var EVEN_FOOTER_PART = "pdf-running-foot-even";
 var HEADER_PART = "pdf-running-head";
 /**
 * Heuristically reconstruct an untagged PDF into a {@link Reconstruction}
@@ -31,16 +39,60 @@ var HEADER_PART = "pdf-running-head";
 */
 function reconstructByLayout(file, mode = "flow") {
 	const pages = file.pages();
-	const shown = pages.map((page) => displayOf(page));
-	const allRuns = pages.map((page, i) => placeRuns(extractPageText(file, page), shown[i]));
-	const foot = mode === "positional" ? void 0 : runningFoot(allRuns, shown, "foot");
-	const head = mode === "positional" ? void 0 : runningFoot(allRuns, shown, "head");
-	const pageRuns = foot || head ? allRuns.map((runs, i) => runs.filter((r) => foot?.lift[i]?.has(r) !== true && head?.lift[i]?.has(r) !== true)) : allRuns;
+	const sheets = pages.map((page) => displayOf(page));
+	const painted = /* @__PURE__ */ new Map();
+	const extracted = typewritten(pages.map((page) => extractPageText(file, page, painted)));
+	const spacing = pageSpacing(extracted);
+	const outlines = faceOutlinesOf(painted, spacing);
+	const faceSpaces = new Map([...outlines].flatMap(([name, face]) => {
+		const advance = face.glyphs.get(" ")?.advance;
+		return advance !== void 0 ? [[name, advance]] : [];
+	}));
+	const onSheets = extracted.map((runs, i) => placeRuns(runs, sheets[i]));
+	const turns = onSheets.map((runs) => wordsTurnOf(runs));
+	const shown = sheets.map((sheet, i) => mode !== "positional" && turns[i] === 270 ? textFrameOf(sheet) : sheet);
+	const allRuns = shown.map((d, i) => d.sheet ? placeRuns(extracted[i], d) : onSheets[i]);
+	const offSheet = (r, i) => r.y < 0 || r.y > shown[i].height;
+	const bandRuns = allRuns.map((runs, i) => shown[i].sheet ? [] : runs.filter((r) => !offSheet(r, i)));
+	const foot = mode === "positional" ? void 0 : runningFoot(bandRuns, shown, "foot");
+	const head = mode === "positional" ? void 0 : runningFoot(bandRuns, shown, "head");
+	const numberedBand = foot?.numbered === true ? foot : head?.numbered === true ? head : void 0;
+	const numbering = numberingOf(numberedBand);
+	const textSize = textSizeOf(allRuns);
+	const stamp = (r, i) => mode !== "positional" && (r.annotation === true || tooSmallToRead(r, textSize) || offSheet(r, i));
+	const stamps = allRuns.map((runs, i) => runs.filter((r) => stamp(r, i)));
+	const readRuns = foot || head || stamps.some((s) => s.length > 0) ? allRuns.map((runs, i) => runs.filter((r) => foot?.lift[i]?.has(r) !== true && head?.lift[i]?.has(r) !== true && !stamp(r, i))) : allRuns;
+	const art = pages.map((page, i) => {
+		const raw = collectPageImages(file, page);
+		const images = placeImages(raw.images, shown[i]);
+		const lifted = collectPageVectors(file, page, images.map((img) => ({
+			minX: img.x,
+			minY: img.y,
+			maxX: img.x + img.widthPt,
+			maxY: img.y + img.heightPt
+		})));
+		return {
+			images,
+			imageLosses: raw.losses,
+			vectors: placeVectors(lifted.vectors, shown[i]),
+			vectorLosses: lifted.losses
+		};
+	});
+	const figures = art.map((a, i) => mode === "positional" || shown[i].sheet !== void 0 ? [] : pageFigures(a.vectors, a.images, readRuns[i], shown[i]));
+	const pageRuns = figures.some((f) => f.length > 0) ? readRuns.map((runs, i) => {
+		const labels = new Set(figures[i].flatMap((f) => f.labels));
+		return labels.size > 0 ? runs.filter((r) => !labels.has(r)) : runs;
+	}) : readRuns;
 	const pageMarks = pages.map(() => []);
 	const medianFont = median(pageRuns.flat().map((r) => r.fontSizePt).filter((s) => s > 0)) || 12;
 	const resources = new ResourceStore();
 	const losses = [];
-	if (pageRuns.some((page) => page.some((r) => r.text.includes("�")))) losses.push({
+	if (mode !== "positional" && turns.some((t) => t === 90 || t === 180)) losses.push({
+		severity: "degraded",
+		feature: FEATURES.text,
+		detail: "a page shows its words running up the sheet or upside down; a document sets a section’s text across the sheet or down it, so they are set across it"
+	});
+	if (readRuns.some((page) => page.some((r) => r.text.includes("�")))) losses.push({
 		severity: "dropped",
 		feature: FEATURES.text,
 		detail: "some glyphs map to no character — the font states no /ToUnicode and its program says nothing either, so that text is unrecoverable"
@@ -55,36 +107,50 @@ function reconstructByLayout(file, mode = "flow") {
 		feature: FEATURES.text,
 		detail: "text filled with a shading pattern is drawn in the middle colour of the gradient, not as the gradient"
 	});
-	const perPage = pages.map((_, i) => detectGutters(pageRuns[i], shown[i].width));
+	const gutterRuns = pageRuns.map((runs, i) => {
+		const listed = withoutListings(runs);
+		const prose = withoutTables(listed);
+		return prose !== listed && detectGutters(prose, shown[i].width).length > 0 ? prose : listed;
+	});
+	const perPage = pages.map((_, i) => detectGutters(gutterRuns[i], shown[i].width));
 	const shared = commonGutters(perPage);
-	const pageGutters = perPage.map((own, i) => own.length > 0 ? own : shared && fitsGutters(pageRuns[i], shared) ? shared : own);
+	const pageGutters = perPage.map((own, i) => own.length > 0 ? own : shared && fitsGutters(gutterRuns[i], shared) ? shared : own);
 	const body = [];
 	const sectionEnds = [];
 	let sectionFrom = 0;
 	let lastSize = "";
+	const sheetSizes = [];
+	const leads = [];
 	let curColumns = 1;
 	let curSpace = 0;
 	let pendingContinuous = false;
+	const columnFeet = [];
+	const columnTurns = [];
 	pages.forEach((page, i) => {
 		const runs = pageRuns[i];
 		const display = shown[i];
+		const turned = display.sheet !== void 0;
 		const gutters = pageGutters[i];
 		const pageWidth = display.width;
 		const stepped = stepsBetweenWords(runs);
 		const blocks = [];
+		const shaded = /* @__PURE__ */ new Set();
 		const textEdges = pageTextEdges(runs);
 		const inColumns = proseColumns(runs, gutters, textEdges);
 		const split = gutters.length > 0 && inColumns ? assignColumns(runs, gutters) : void 0;
+		const figs = figures[i];
+		const spansGutter = (f) => gutters.some((g) => f.minX < g.mid && f.maxX > g.mid);
+		const breaks = split ? [...split.breaks, ...figs.filter(spansGutter).map((f) => f.maxY)].sort((a, b) => b - a) : [];
 		const bandEpsilon = (median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10) / 2;
-		const bandAt = (top) => bandOf(split?.breaks ?? [], top, bandEpsilon);
-		const addColumn = (allRuns, col) => {
+		const bandAt = (top) => bandOf(breaks, top, bandEpsilon);
+		const addColumn = (allRuns, col, columnFigures = []) => {
 			const colRuns = allRuns.filter((r) => r.type3 !== true && (mode !== "positional" || r.invisible !== true));
 			if (mode === "positional") {
-				for (const [angle, runs] of byAngle(colRuns)) for (const line of groupIntoLines(rotate(runs, -angle), true, stepped)) {
+				for (const [angle, turned] of byAngle(colRuns)) for (const runs of byPainter(turned)) for (const line of groupIntoLines(rotate(runs, -angle), true, stepped)) {
 					if (line.text.length === 0) continue;
 					const box = turnedBox(line, angle, pageWidth);
 					placed.push({
-						key: [Number.MAX_SAFE_INTEGER, placed.length],
+						key: placedKey(runs, placed.length),
 						col,
 						top: box.y + box.height,
 						make: (z) => positionedText(line.spans, box, frame, z, rotation60kOf(angle))
@@ -95,7 +161,8 @@ function reconstructByLayout(file, mode = "flow") {
 			const columnSize = median(colRuns.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
 			const maths = matrixBlocks(colRuns, columnSize);
 			const inMath = new Set(maths.flatMap((m) => [...m.used]));
-			const lines = groupIntoLines(inMath.size > 0 ? colRuns.filter((r) => !inMath.has(r)) : colRuns, false, stepped).filter((l) => l.text.length > 0);
+			const textRuns = inMath.size > 0 ? colRuns.filter((r) => !inMath.has(r)) : colRuns;
+			const lines = groupIntoLines(textRuns, false, stepped).filter((l) => l.text.length > 0);
 			const measure = measureOf(col, gutters, textEdges) ?? measureOfLines(lines);
 			for (const found of maths) {
 				const { alignment } = alignmentOf([{
@@ -123,38 +190,239 @@ function reconstructByLayout(file, mode = "flow") {
 					}
 				});
 			}
-			const paras = groupIntoParagraphs(lines, measure, display.height);
-			const asRows = tabbedRows(paras, measure && {
-				left: measure.left,
-				right: Math.max(measure.right, textEdges?.right ?? measure.right)
-			});
+			let above;
+			const slabs = [];
+			let rest = textRuns;
+			for (const figure of columnFigures) {
+				slabs.push({
+					runs: rest.filter((r) => r.y > figure.maxY),
+					figure
+				});
+				rest = rest.filter((r) => r.y <= figure.maxY);
+			}
+			slabs.push({ runs: rest });
+			for (const slab of slabs) {
+				const regions = turned ? [{
+					kind: "flow",
+					runs: slab.runs
+				}] : regionsOf(slab.runs);
+				for (const region of regions) {
+					if (region.kind === "side") {
+						const made = sideBySide(region, measure, above);
+						if (made === void 0) continue;
+						blocks.push({
+							band: bandAt(made.top),
+							col,
+							top: made.top,
+							el: made.el
+						});
+						above = made.below;
+						continue;
+					}
+					const regionLines = groupIntoLines(region.runs, false, stepped, faceSpaces, columnRules(vectors)).filter((l) => l.text.length > 0);
+					const reach = lines.length < 3 && gutters.length === 0 ? pageWidth * (1 - GUESSED_MARGIN) : void 0;
+					const { paras, under } = onBoxes(groupIntoParagraphs(regionLines, measure, display.height, above, false, reach), vectors.filter(solidBox), measure);
+					for (const set of setParagraphs(paras, measure && {
+						left: measure.left,
+						right: Math.max(measure.right, textEdges?.right ?? measure.right)
+					}, pageWidth)) blocks.push({
+						band: bandAt(set.top),
+						col,
+						top: set.top,
+						el: set.el,
+						...set.foot !== void 0 ? { foot: set.foot } : {}
+					});
+					const last = paras[paras.length - 1];
+					if (last !== void 0) above = {
+						y: last.bottom - under,
+						lineHeight: last.lineHeight
+					};
+				}
+				if (slab.figure !== void 0) {
+					const made = figureIn(slab.figure, measure, above, col === SPANNING_COLUMN);
+					blocks.push({
+						band: bandAt(made.top),
+						col,
+						top: made.top,
+						el: made.el
+					});
+					above = made.below;
+				}
+			}
+		};
+		/** A figure's parts in the order the page painted them, its words over its drawing. */
+		const figureMembers = (figure) => {
+			const drawn = [...joinLetters([...figure.vectors].sort((a, b) => compareOrder(a.orderKey, b.orderKey))).map((v) => ({
+				key: v.orderKey,
+				member: vectorMember(v)
+			})), ...figure.images.map((img) => ({
+				key: img.orderKey,
+				member: imageMember(img, resources)
+			}))].sort((a, b) => compareOrder(a.key, b.key));
+			const labels = [];
+			const written = figure.labels.filter((r) => !tracedRun(r));
+			for (const [angle, turnedRuns] of byAngle(written)) for (const layer of byPainter(turnedRuns)) for (const line of groupIntoLines(rotate(layer, -angle), true, stepped)) {
+				if (line.text.length === 0) continue;
+				const box = angle === 0 ? {
+					x: line.x,
+					y: line.y - line.fontSize * .25,
+					width: line.width + line.fontSize,
+					height: line.fontSize * 1.25
+				} : turnedBox(line, angle, pageWidth);
+				labels.push(labelMember(line.spans, box, rotation60kOf(angle)));
+			}
+			return [...drawn.map((d) => d.member), ...labels];
+		};
+		/**
+		* §20.5.2.17 — a figure as the paragraph it stands in (see `figureBlock`):
+		* spaced from the text over it as a paragraph is, and set in from its
+		* column's edge as far as the page set it.
+		*
+		* A figure across the columns is spaced from the text nearest over it in
+		* any column: what its own column holds over it is the line before the
+		* columns began.
+		*/
+		const figureIn = (figure, measure, over, across = false) => {
+			const members = figureMembers(figure);
+			const box = membersBox(members);
+			const nearest = across ? runs.map((r) => r.y - r.fontSizePt * .25).filter((edge) => edge > box.top).reduce((low, edge) => Math.min(low ?? edge, edge), void 0) : void 0;
+			const above = nearest !== void 0 ? {
+				y: nearest,
+				lineHeight: 0
+			} : over;
+			const opened = above !== void 0 ? above.y - (1 - BASELINE_AT) * above.lineHeight - box.top : 0;
+			const indent = box.left - (measure?.left ?? box.left);
+			const properties = {
+				...opened > SPACING_NOISE_PT ? { spacingBefore: pt(Math.min(opened, display.height / 3)) } : {},
+				...Math.abs(indent) > SPACING_NOISE_PT ? { indentLeft: pt(indent) } : {}
+			};
+			return {
+				top: box.top,
+				below: {
+					y: box.bottom,
+					lineHeight: 0
+				},
+				el: figureBlock(members, properties)
+			};
+		};
+		/**
+		* A region's paragraphs as the elements they are set in: the lines that
+		* stand on the same stops as a table (§17.4.38), the rest as paragraphs
+		* placed and spaced the way the page placed and spaced them.
+		*/
+		const far = /* @__PURE__ */ new WeakMap();
+		const setParagraphs = (paras, tableMeasure, sheetWidth = 0) => {
+			const asRows = turned ? /* @__PURE__ */ new Map() : tabbedRows(paras, tableMeasure);
+			const out = [];
 			for (const [at, para] of paras.entries()) {
 				const table = asRows.get(at);
 				if (table !== void 0) {
-					if (table !== null) blocks.push({
-						band: bandAt(para.top),
-						col,
+					if (table !== null) out.push({
 						top: para.top,
 						el: table
 					});
 					continue;
 				}
-				blocks.push({
-					band: bandAt(para.top),
-					col,
+				const overflow = sheetWidth > 0 ? runOn(para, tableMeasure, sheetWidth) : 0;
+				const { shade } = para;
+				if (shade) shaded.add(shade.box);
+				const el = paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont), {
+					...para.stops !== void 0 && para.stops.length > 0 ? { tabs: para.stops.filter((x) => x > 0).map((x) => ({
+						positionPt: pt(x),
+						alignment: "left"
+					})) } : {},
+					...para.alignment !== void 0 ? { alignment: para.alignment } : {},
+					...para.spacingBefore !== void 0 ? { spacingBefore: pt(para.spacingBefore) } : {},
+					spacingLine: pt(para.lineHeight),
+					spacingLineRule: "exact",
+					...para.indentLeft !== void 0 ? { indentLeft: pt(para.indentLeft) } : {},
+					...para.indentFirstLine !== void 0 ? { indentFirstLine: pt(para.indentFirstLine) } : {},
+					...overflow > 0 ? { indentRight: pt(-overflow) } : {},
+					...shade ? shadeProperties(shade) : {}
+				});
+				if (sheetWidth > 0 && para.far !== void 0) far.set(el, para.far);
+				out.push({
 					top: para.top,
-					el: paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont), {
-						...para.stops !== void 0 && para.stops.length > 0 ? { tabs: para.stops.filter((x) => x > 0).map((x) => ({
-							positionPt: pt(x),
-							alignment: "left"
-						})) } : {},
-						...para.alignment !== void 0 ? { alignment: para.alignment } : {},
-						...para.spacingBefore !== void 0 ? { spacingBefore: pt(para.spacingBefore) } : {},
-						...para.indentLeft !== void 0 ? { indentLeft: pt(para.indentLeft) } : {},
-						...para.indentFirstLine !== void 0 ? { indentFirstLine: pt(para.indentFirstLine) } : {}
-					})
+					el,
+					foot: para.bottom - (1 - BASELINE_AT) * para.lineHeight - (shade?.under ?? 0)
 				});
 			}
+			return out;
+		};
+		/**
+		* §17.4.38 — a band of blocks side by side, as the borderless table a
+		* writer sets such a band in: one row, a cell a block, each cell's lines
+		* read down on their own and spaced from what stands above the band.
+		*/
+		const sideBySide = (region, measure, above) => {
+			const left = measure?.left ?? Math.min(...region.cells.map((c) => c.from));
+			const right = Math.max(measure?.right ?? 0, textEdges?.right ?? 0, ...region.cells.map((c) => c.to));
+			const cells = region.cells.map((cell) => {
+				return {
+					cell,
+					lines: groupIntoLines(cell.runs, false, stepped, faceSpaces).filter((l) => l.text.length > 0)
+				};
+			});
+			if (cells.some((c) => c.lines.length === 0)) return void 0;
+			const top = Math.max(...cells.map((c) => c.lines[0].y));
+			const edge = above ?? {
+				y: Math.max(...cells.map((c) => c.lines[0].y + .8 * 1.2 * c.lines[0].fontSize)),
+				lineHeight: 0
+			};
+			const starts = cells.map((c, k) => k === 0 ? left : c.cell.from);
+			let foot = Infinity;
+			const row = cells.map(({ cell, lines }, k) => {
+				const own = {
+					left: cell.from,
+					right: cell.to
+				};
+				const paras = groupIntoParagraphs(lines, own, display.height, edge, !isProse(lines, own));
+				const last = paras[paras.length - 1];
+				foot = Math.min(foot, last.bottom - (1 - BASELINE_AT) * last.lineHeight);
+				const inset = cell.from - starts[k];
+				const content = setParagraphs(paras, own).map(({ el }) => inset > 0 && el.kind === "paragraph" ? {
+					...el,
+					paragraph: {
+						...el.paragraph,
+						properties: {
+							...el.paragraph.properties,
+							indentLeft: pt((el.paragraph.properties.indentLeft ?? 0) + inset)
+						}
+					}
+				} : el);
+				const width = (starts[k + 1] ?? right) - starts[k];
+				return {
+					properties: { width: pt(Math.max(width, 1)) },
+					content
+				};
+			});
+			const grid = row.map((c) => c.properties.width);
+			return {
+				top,
+				below: {
+					y: foot,
+					lineHeight: 0
+				},
+				el: {
+					kind: "table",
+					table: {
+						properties: {
+							defaultCellMargins: {
+								left: pt(0),
+								right: pt(0)
+							},
+							layout: "fixed",
+							widthType: "dxa",
+							widthPt: pt(grid.reduce((sum, w) => sum + w, 0))
+						},
+						grid,
+						rows: [{
+							properties: {},
+							cells: row
+						}]
+					}
+				}
+			};
 		};
 		const placed = [];
 		const colOf = (centerX) => gutters.filter((g) => centerX >= g.mid).length;
@@ -162,39 +430,59 @@ function reconstructByLayout(file, mode = "flow") {
 			left: 0,
 			top: display.height
 		};
-		const raw = collectPageImages(file, page);
-		const imgs = {
-			images: placeImages(raw.images, display),
-			losses: raw.losses
-		};
-		losses.push(...imgs.losses);
-		pageMarks[i] = imgs.images;
-		const lifted = collectPageVectors(file, page, imgs.images.map((img) => ({
-			minX: img.x,
-			minY: img.y,
-			maxX: img.x + img.widthPt,
-			maxY: img.y + img.heightPt
-		})));
-		losses.push(...lifted.losses);
-		const placedVectors = placeVectors(lifted.vectors, display);
-		const ruled = markDrawnRules(runs, placedVectors);
+		for (const runs of byPainter(stamps[i] ?? [])) for (const line of groupIntoLines(runs, true, stepped)) {
+			if (line.text.length === 0) continue;
+			const box = turnedBox(line, 0, pageWidth);
+			placed.push({
+				key: placedKey(runs, placed.length),
+				col: colOf(box.x + box.width / 2),
+				top: box.y + box.height,
+				make: (z) => positionedText(line.spans, box, frame, z)
+			});
+		}
+		const lifted = art[i];
+		losses.push(...lifted.imageLosses);
+		pageMarks[i] = lifted.images;
+		losses.push(...lifted.vectorLosses);
+		const figured = new Set(figures[i].flatMap((f) => [...f.vectors, ...f.images]));
+		const imgs = { images: figured.size > 0 ? lifted.images.filter((img) => !figured.has(img)) : lifted.images };
+		const placedVectors = figured.size > 0 ? lifted.vectors.filter((v) => !figured.has(v)) : lifted.vectors;
+		const drawnRules = markDrawnRules(runs, placedVectors);
 		const strayGlyphs = strayMarks(placedVectors, runs);
+		const ruled = mode !== "positional" ? {
+			...drawnRules,
+			runs: readDrawnMarks(drawnRules.runs, strayGlyphs)
+		} : drawnRules;
 		const vectors = placedVectors.filter((v) => !ruled.consumed.has(v)).filter((v) => !(mode !== "positional" && strayGlyphs.has(v)));
-		const ruledIntoColumns = mode !== "positional" && looksRuled(ruled.runs, gutters, textEdges);
+		const drawn = drawnWords(vectors);
+		const ruledIntoColumns = mode !== "positional" && !turned && looksRuled(ruled.runs, gutters, textEdges);
 		const asTable = ruledIntoColumns && textEdges ? tableFrom(ruled.runs, gutters, textEdges, stepped) : void 0;
-		if (asTable) for (const block of asTable) blocks.push({
-			band: bandAt(block.top),
-			col: 0,
-			top: block.top,
-			el: block.el
-		});
-		else if (split && !ruledIntoColumns) {
+		if (asTable) {
+			for (const block of asTable) blocks.push({
+				band: bandAt(block.top),
+				col: 0,
+				top: block.top,
+				el: block.el
+			});
+			for (const figure of figs) {
+				const made = figureIn(figure, void 0, void 0);
+				blocks.push({
+					band: bandAt(made.top),
+					col: 0,
+					top: made.top,
+					el: made.el
+				});
+			}
+		} else if (split && !ruledIntoColumns) {
 			const columnFor = (r) => split.columnOf.get(r) ?? colOf(r.x);
+			const figureColumn = (f) => spansGutter(f) ? SPANNING_COLUMN : colOf((f.minX + f.maxX) / 2);
 			const columns = Array.from({ length: gutters.length + 1 }, (_, n) => n);
-			for (const col of [SPANNING_COLUMN, ...columns]) addColumn(ruled.runs.filter((r) => columnFor(r) === col), col);
-		} else addColumn(ruled.runs, 0);
+			for (const col of [SPANNING_COLUMN, ...columns]) addColumn(ruled.runs.filter((r) => columnFor(r) === col), col, figs.filter((f) => figureColumn(f) === col));
+			spaceUnderSpans(blocks);
+		} else addColumn(ruled.runs, 0, figs);
 		const under = mode !== "positional";
-		const givenAway = mode !== "positional" ? ruleBorders(vectors, blocks, display.width) : void 0;
+		setOff(blocks, far, (line, k) => positionedText(line.spans, turnedBox(line, 0, pageWidth), frame, FAR_Z + k));
+		const givenAway = mode !== "positional" ? ruleBorders(vectors, blocks, display.width, colOf) : void 0;
 		[
 			...imgs.images.map((img) => ({
 				key: img.orderKey,
@@ -202,7 +490,7 @@ function reconstructByLayout(file, mode = "flow") {
 				top: img.y + img.heightPt,
 				make: (z) => imageBlock(img, resources, void 0, frame, z, under)
 			})),
-			...vectors.filter((v) => givenAway?.has(v) !== true).map((v) => ({
+			...drawn.filter((v) => givenAway?.has(v) !== true && !shaded.has(v)).map((v) => ({
 				key: v.orderKey,
 				col: colOf((v.minX + v.maxX) / 2),
 				top: v.maxY,
@@ -218,8 +506,8 @@ function reconstructByLayout(file, mode = "flow") {
 			});
 		});
 		blocks.sort((a, b) => a.band - b.band || columnOrder(a.col) - columnOrder(b.col) || b.top - a.top);
-		const size = `${shown[i].width.toFixed(2)}x${shown[i].height.toFixed(2)}`;
-		const opensSection = i > 0 && size !== lastSize;
+		const size = `${shown[i].width.toFixed(2)}x${shown[i].height.toFixed(2)}${turned ? " down" : ""}`;
+		const opensSection = i > 0 && (size !== lastSize || numbering?.runs.some((run) => run.from === i) === true);
 		if (opensSection) {
 			sectionEnds.push({
 				at: body.length,
@@ -233,12 +521,24 @@ function reconstructByLayout(file, mode = "flow") {
 			pendingContinuous = false;
 		}
 		lastSize = size;
-		if (i > 0 && !opensSection && blocks.length > 0) body.push({
+		sheetSizes[i] = size;
+		const breakAt = i > 0 && !opensSection ? body.length : void 0;
+		if (i > 0 && !opensSection) body.push({
 			kind: "paragraph",
 			paragraph: {
 				properties: {
 					pageBreakBefore: true,
-					spacingLine: pt(0),
+					spacingLine: CARRIER_LINE_PT,
+					spacingLineRule: "exact"
+				},
+				runs: []
+			}
+		});
+		else if (i === 0 && blocks.length === 0) body.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: {
+					spacingLine: CARRIER_LINE_PT,
 					spacingLineRule: "exact"
 				},
 				runs: []
@@ -246,29 +546,147 @@ function reconstructByLayout(file, mode = "flow") {
 		});
 		const columnsHere = ruledIntoColumns || !proseColumns(runs, gutters, textEdges) ? 1 : gutters.length + 1;
 		const spacePt = columnsHere > 1 ? median(gutters.map((g) => g.to - g.from)) : 0;
+		columnFeet[i] = columnsHere > 1 ? lastColumnFeet(blocks) : void 0;
+		let led = false;
+		let begun = false;
+		const footOf = (band, col) => {
+			const column = blocks.filter((b) => b.band === band && b.col === col);
+			if (column.length === 0) return void 0;
+			return column.reduce((low, b) => b.top < low.top ? b : low).foot;
+		};
+		let prev;
+		const placedAt = /* @__PURE__ */ new Map();
 		for (const block of blocks) {
+			if (columnsHere > 1 && prev !== void 0 && block.band === prev.band && prev.col !== SPANNING_COLUMN && block.col > prev.col) {
+				const ends = footOf(prev.band, prev.col);
+				const next = footOf(block.band, block.col);
+				const closed = blocks.some((b) => b.band === block.band && b.col === SPANNING_COLUMN);
+				if (ends !== void 0 && next !== void 0) {
+					const rest = blocks.slice(blocks.indexOf(block));
+					const skipped = rest.findIndex((b) => !floating(b.el));
+					const lead = skipped >= 0 ? leadingLine(rest[skipped].el) : void 0;
+					const opener = blocks.find((b) => b.band === block.band && b.col !== SPANNING_COLUMN && !floating(b.el));
+					const openerAt = opener !== void 0 ? placedAt.get(opener) : void 0;
+					const openerLine = opener !== void 0 ? leadingLine(opener.el) : void 0;
+					columnTurns.push({
+						at: body.length,
+						foot: ends,
+						next,
+						closed,
+						...lead !== void 0 ? { head: {
+							at: body.length + skipped,
+							baseline: rest[skipped].top,
+							lineHeight: lead
+						} } : {},
+						...opener !== void 0 && openerAt !== void 0 && openerLine !== void 0 ? { opens: {
+							at: openerAt,
+							baseline: opener.top,
+							lineHeight: openerLine
+						} } : {}
+					});
+				}
+			}
+			prev = block;
 			const count = block.col === SPANNING_COLUMN ? 1 : columnsHere;
 			if (count !== curColumns) {
+				const opensPage = breakAt !== void 0 && !begun;
+				if (opensPage) {
+					const last = body[breakAt - 1];
+					const own = sectionEnds.every((e) => e.at < breakAt);
+					if (last?.kind === "paragraph" && own) body.pop();
+					else body[breakAt] = {
+						kind: "paragraph",
+						paragraph: {
+							properties: {
+								spacingLine: CARRIER_LINE_PT,
+								spacingLineRule: "exact"
+							},
+							runs: []
+						}
+					};
+				}
 				sectionEnds.push({
 					at: body.length,
 					from: sectionFrom,
-					to: i + 1,
+					to: opensPage ? i : i + 1,
 					columns: curColumns,
 					spacePt: curSpace,
 					continuous: pendingContinuous
 				});
 				sectionFrom = i;
-				pendingContinuous = true;
+				pendingContinuous = !opensPage;
 				curColumns = count;
 				curSpace = spacePt;
 			}
+			if (!led && mode !== "positional") {
+				const lead = leadingLine(block.el);
+				if (lead !== void 0) leads.push({
+					page: i,
+					at: body.length,
+					baseline: block.top,
+					lineHeight: lead
+				});
+				led = lead !== void 0 || block.el.kind === "table" || block.el.kind === "paragraph";
+			}
+			placedAt.set(block, body.length);
 			body.push(block.el);
+			begun = true;
 		}
 	});
+	const measured = (own, from, to) => withMeasuredMargins(own, shown.slice(from, to), pageRuns.slice(from, to), pageMarks.slice(from, to), shown[from]?.sheet ? void 0 : foot?.band);
+	const sheetRun = (from) => {
+		let start = from;
+		while (start > 0 && sheetSizes[start - 1] === sheetSizes[from]) start--;
+		let end = from + 1;
+		while (end < pages.length && sheetSizes[end] === sheetSizes[from]) end++;
+		return [start, end];
+	};
+	const setUps = /* @__PURE__ */ new Map();
 	const setUp = (from, to) => {
-		const own = sectionFromPdfPages(pages.slice(from, to));
-		return mode === "positional" ? own : withMeasuredMargins(own, shown.slice(from, to), pageRuns.slice(from, to), pageMarks.slice(from, to));
+		const key = `${String(from)}:${String(to)}`;
+		if (setUps.has(key)) return setUps.get(key);
+		const own = sectionFromPdfPages(pages.slice(from, to), shown[from]);
+		let section = mode === "positional" ? own : measured(own, from, to);
+		const [start, end] = sheetRun(from);
+		if (mode !== "positional" && section?.margins && (start < from || end > to)) {
+			const sheet = measured(own, start, end)?.margins;
+			if (sheet) section = {
+				...section,
+				margins: {
+					...section.margins,
+					top: sheet.top,
+					bottom: sheet.bottom
+				}
+			};
+		}
+		setUps.set(key, section);
+		return section;
 	};
+	const lastFeet = columnFeet[pages.length - 1];
+	const floor = setUp(sectionFrom, pages.length)?.margins?.bottom;
+	if (mode !== "positional" && curColumns > 1 && lastFeet !== void 0 && floor !== void 0 && balancedEnd(lastFeet, floor, medianFont)) {
+		sectionEnds.push({
+			at: body.length,
+			from: sectionFrom,
+			to: pages.length,
+			columns: curColumns,
+			spacePt: curSpace,
+			continuous: pendingContinuous
+		});
+		body.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: {
+					spacingLine: CARRIER_LINE_PT,
+					spacingLineRule: "exact"
+				},
+				runs: []
+			}
+		});
+		curColumns = 1;
+		curSpace = 0;
+		pendingContinuous = true;
+	}
 	sectionEnds.push({
 		at: body.length,
 		from: sectionFrom,
@@ -277,12 +695,96 @@ function reconstructByLayout(file, mode = "flow") {
 		spacePt: curSpace,
 		continuous: pendingContinuous
 	});
+	for (const lead of leads) {
+		const end = sectionEnds.find((e) => e.at > lead.at);
+		const top = (end ? setUp(end.from, end.to) : setUp(0, pages.length))?.margins?.top;
+		const page = shown[lead.page];
+		const el = body[lead.at];
+		if (top === void 0 || page === void 0) continue;
+		const border = el?.kind === "paragraph" ? el.paragraph.properties.borders?.top?.width ?? 0 : 0;
+		const before = page.height - top - lead.baseline - BASELINE_AT * lead.lineHeight - border;
+		if (before <= SPACING_NOISE_PT) continue;
+		if (el?.kind === "paragraph") body[lead.at] = {
+			...el,
+			paragraph: {
+				...el.paragraph,
+				properties: {
+					...el.paragraph.properties,
+					spacingBefore: pt(before)
+				}
+			}
+		};
+		else if (el?.kind === "shape") body[lead.at] = {
+			...el,
+			shape: {
+				...el.shape,
+				paragraphProperties: {
+					...el.shape.paragraphProperties,
+					spacingBefore: pt(before)
+				}
+			}
+		};
+	}
+	const line = medianFont * NATURAL_LINE_EM;
+	const breaks = [];
+	for (const turn of columnTurns) {
+		const end = sectionEnds.find((e) => e.at > turn.at);
+		const margins = (end ? setUp(end.from, end.to) : void 0)?.margins;
+		if (turn.closed) {
+			if (Math.abs(turn.foot - turn.next) <= line * BALANCED_LINES) continue;
+		} else if (margins?.bottom === void 0 || turn.foot - margins.bottom < line * SHORT_LINES) continue;
+		const { head: start, opens } = turn;
+		const opener = opens !== void 0 ? body[opens.at] : void 0;
+		const openerProps = opener?.kind === "paragraph" ? opener.paragraph.properties : opener?.kind === "shape" ? opener.shape.paragraphProperties : void 0;
+		const before = start !== void 0 && opens !== void 0 && openerProps !== void 0 ? (openerProps.spacingBefore ?? 0) + (openerProps.borders?.top?.width ?? 0) + (opens.baseline + BASELINE_AT * opens.lineHeight) - (start.baseline + BASELINE_AT * start.lineHeight) : void 0;
+		breaks.push({
+			at: turn.at,
+			...start !== void 0 && before !== void 0 ? { head: {
+				at: start.at,
+				before
+			} } : {}
+		});
+	}
+	for (const brk of [...breaks].sort((x, y) => y.at - x.at)) {
+		const el = brk.head !== void 0 ? body[brk.head.at] : void 0;
+		if (brk.head !== void 0 && el?.kind === "paragraph") {
+			const border = el.paragraph.properties.borders?.top?.width ?? 0;
+			const before = brk.head.before - border;
+			const { spacingBefore: _, ...rest } = el.paragraph.properties;
+			body[brk.head.at] = {
+				...el,
+				paragraph: {
+					...el.paragraph,
+					properties: before > SPACING_NOISE_PT ? {
+						...rest,
+						spacingBefore: pt(before)
+					} : rest
+				}
+			};
+		}
+		body.splice(brk.at, 0, {
+			kind: "paragraph",
+			paragraph: {
+				properties: {
+					spacingLine: CARRIER_LINE_PT,
+					spacingLineRule: "exact"
+				},
+				runs: [{
+					text: "\n",
+					properties: {},
+					columnBreak: true
+				}]
+			}
+		});
+		for (const e of sectionEnds) if (e.at > brk.at) e.at++;
+	}
 	const sections = sectionEnds.length > 1 ? sectionEnds.flatMap((end) => {
-		const base = setUp(end.from, end.to);
+		const base = sectionOnSheet(setUp(end.from, end.to), shown[end.from]);
 		if (!base) return [];
 		return [{
 			properties: {
 				...base,
+				...numberedFrom(numbering, end.from),
 				...end.columns > 1 && mode !== "positional" ? { columns: {
 					count: end.columns,
 					spacePt: end.spacePt
@@ -292,26 +794,47 @@ function reconstructByLayout(file, mode = "flow") {
 			endIndex: end.at
 		}];
 	}) : [];
-	const stepped0 = stepsBetweenWords(allRuns[0] ?? []);
-	const edges0 = pageTextEdges(allRuns[0] ?? []);
-	const band = foot ? footerBand(foot.band, stepped0, edges0, foot.numbered) : [];
-	const headBand = head ? footerBand(head.band, stepped0, edges0, head.numbered) : [];
+	let sectionStart = 0;
+	for (const end of sectionEnds) {
+		const sheet = shown[end.from]?.sheet;
+		if (sheet) for (let k = sectionStart; k < end.at; k++) body[k] = floatOntoSheet(body[k], sheet.width);
+		sectionStart = end.at;
+	}
+	const setOn = (runs, page, numbered, numeral) => footerBand(runs, stepsBetweenWords(allRuns[page] ?? []), pageTextEdges(allRuns[page] ?? []), numbered, numeral);
+	const firstOf = (of) => Math.max(0, of?.lift.findIndex((set) => set.size > 0) ?? 0);
+	const numeralOf = (of) => {
+		if (of === void 0 || of !== numberedBand || numbering === void 0) return void 0;
+		const first = of.lift.findIndex((set) => set.size > 0);
+		return first >= 0 ? numbering.numbers[first]?.text : void 0;
+	};
+	const sides = foot !== void 0 && foot === numberedBand && numbering !== void 0 ? sidesOf(foot, numbering, shown.map((s) => s.width / 2)) : void 0;
+	const band = foot ? sides ? setOn(sides.odd.runs, sides.odd.page, true, sides.odd.numeral) : setOn(foot.band, firstOf(foot), foot.numbered, numeralOf(foot)) : [];
+	const evenBand = sides ? setOn(sides.even.runs, sides.even.page, true, sides.even.numeral) : [];
+	const headBand = head ? setOn(head.band, firstOf(head), head.numbered, numeralOf(head)) : [];
 	const withFooter = (properties) => properties ? {
 		...properties,
 		...band.length > 0 ? { footers: [{
 			type: "default",
 			relationshipId: FOOTER_PART
-		}] } : {},
+		}, ...evenBand.length > 0 ? [{
+			type: "even",
+			relationshipId: EVEN_FOOTER_PART
+		}] : []] } : {},
+		...evenBand.length > 0 ? { evenAndOddHeaders: true } : {},
 		...headBand.length > 0 ? { headers: [{
 			type: "default",
 			relationshipId: HEADER_PART
 		}] } : {}
 	} : properties;
 	return {
-		doc: buildFlowDoc(body, resources, withFooter(setUp(0, pages.length)), collectEmbeddedFonts(file, pages, losses), sections.map((s) => ({
+		doc: buildFlowDoc(body, resources, withFooter(numberedAs(sectionOnSheet(setUp(0, pages.length), shown[0]), numbering)), collectEmbeddedFonts(file, pages, losses), sections.map((s) => ({
 			...s,
 			properties: withFooter(s.properties) ?? s.properties
-		})), band.length > 0 || headBand.length > 0 ? new Map([...band.length > 0 ? [[FOOTER_PART, band]] : [], ...headBand.length > 0 ? [[HEADER_PART, headBand]] : []]) : void 0),
+		})), band.length > 0 || headBand.length > 0 ? new Map([
+			...band.length > 0 ? [[FOOTER_PART, band]] : [],
+			...evenBand.length > 0 ? [[EVEN_FOOTER_PART, evenBand]] : [],
+			...headBand.length > 0 ? [[HEADER_PART, headBand]] : []
+		]) : void 0, collectFaceFamilies(file, pages), outlines, kernedFaces(spacing)),
 		losses: dedupeLosses(losses)
 	};
 }
@@ -324,7 +847,8 @@ function detectGutters(runs, pageWidth) {
 	});
 	if (spans.length === 0) return [];
 	const minX = Math.min(...spans.map((iv) => iv[0]));
-	const span = Math.max(...spans.map((iv) => iv[1])) - minX;
+	const maxX = Math.max(...spans.map((iv) => iv[1]));
+	const span = maxX - minX;
 	if (span < pageWidth * .5) return [];
 	const sorted = [...spans].sort((a, b) => a[0] - b[0]);
 	let curEnd = sorted[0][1];
@@ -365,6 +889,7 @@ function detectGutters(runs, pageWidth) {
 			const after = row.filter(([l]) => l >= x);
 			if (before.length === 0 || after.length === 0) continue;
 			if (Math.min(...after.map(([l]) => l)) - Math.max(...before.map(([, r]) => r)) >= fontSize * MIN_GUTTER_EM) columned++;
+			else crossing++;
 		}
 		if (columned < MIN_COLUMNED_ROWS || crossing >= columned) continue;
 		const last = voted[voted.length - 1];
@@ -380,9 +905,124 @@ function detectGutters(runs, pageWidth) {
 		});
 	}
 	const near = (band) => empty.some((e) => band.mid > e.from - fontSize && band.mid < e.to + fontSize);
-	return separating([...empty, ...voted.filter((v) => !near(v))].sort((a, b) => a.mid - b.mid), spans);
+	return withoutNarrowColumns(separating([...empty, ...voted.filter((v) => !near(v))].sort((a, b) => a.mid - b.mid), spans), empty, rows, [minX, maxX], fontSize);
 }
 /**
+* The gutters left when no column beside a gap the page's lines run across is
+* narrower than a page's column can be.
+*
+* A table's columns stand apart as a page's do, line after line, and a page
+* set in columns of tables has gaps between its tables' columns as well as
+* its own: canvas.pdf sets two columns of Name, Type and Default, and read at
+* every gap its sheets came back in three and five columns, a word wide each,
+* on seven pages where it has two. What gives such a gap away is that the
+* page's other lines — the headings over each table, the prose between them —
+* run across it, and that a column it leaves is a few ems wide: such a gap
+* goes, the one with the less white beside the narrowest column first, until
+* no column is left so narrow. A gap NO line crosses stays however narrow the
+* columns beside it — a page that is one table from edge to edge is read by
+* its columns, as a table — and so does a page's one gap.
+*
+* The gaps that stay are then measured afresh, as the white every line split
+* there leaves. The vote answers wherever more lines stand apart than run
+* across, which is where MOST of a column's lines end and not where its
+* longest does: a gutter voted across a column of short cells reaches back
+* into that column, and a section set with it stood its columns sixty-five
+* points further apart than the page does. freeculture.pdf's index sets its
+* entries ragged, two columns six to twenty points apart, and set seventy
+* apart its columns came back a third narrower than the page's: the thirteen
+* pages of the index ran to twenty-seven, and its longest entries ran on past
+* the middle of the white and were read as lines across the page.
+*
+* @param gutters  The gutters found, left to right.
+* @param firm     The gutters no line crosses, which stay.
+* @param rows     Each line's ink across the page, left to right.
+* @param extent   Where the page's ink begins and ends.
+* @param fontSize The page's body size.
+*/
+function withoutNarrowColumns(gutters, firm, rows, extent, fontSize) {
+	const kept = [...gutters];
+	const least = fontSize * NARROWEST_COLUMN_EM;
+	const white = (g) => g.to - g.from;
+	while (kept.length > 1) {
+		const edges = [
+			extent[0],
+			...kept.flatMap((g) => [g.from, g.to]),
+			extent[1]
+		];
+		let narrowest;
+		for (let k = 0; k <= kept.length; k++) {
+			const width = edges[2 * k + 1] - edges[2 * k];
+			if (width >= least || narrowest && narrowest.width <= width) continue;
+			const beside = [kept[k - 1], kept[k]].filter((g) => g !== void 0 && !firm.includes(g));
+			if (beside.length === 0) continue;
+			narrowest = {
+				width,
+				gap: beside.reduce((a, b) => white(b) < white(a) ? b : a)
+			};
+		}
+		if (!narrowest) break;
+		kept.splice(kept.indexOf(narrowest.gap), 1);
+	}
+	return kept.map((g) => {
+		if (firm.includes(g)) return g;
+		const starts = [];
+		const ends = [];
+		for (const row of rows) {
+			let widest;
+			let reach = row[0]?.[1] ?? -Infinity;
+			for (const [l, r] of row.slice(1)) {
+				const overlaps = l > g.from && reach < g.to;
+				if (l - reach >= fontSize * MIN_GUTTER_EM && overlaps) {
+					if (!widest || l - reach > widest[1] - widest[0]) widest = [reach, l];
+				}
+				reach = Math.max(reach, r);
+			}
+			if (!widest) continue;
+			starts.push(widest[0]);
+			ends.push(widest[1]);
+		}
+		if (starts.length === 0) return g;
+		const from = sharedEdge(starts) ?? Math.max(...starts);
+		const to = Math.min(...ends);
+		return to > from ? {
+			from,
+			to,
+			mid: (from + to) / 2
+		} : g;
+	});
+}
+/**
+* The edge at least half of `ends` agree on, to {@link FLUSH_PT}: the furthest
+* out of the agreeing ones, which every one of them clears — where no more
+* than a line in twenty stops past it, set over the measure. Lines of one
+* length agree on where they stop too, and the column's longer lines past
+* them are its measure.
+*
+* @param ends Where each line stops.
+* @returns The edge, or `undefined` where no half of them agree on one.
+*/
+function sharedEdge(ends) {
+	const sorted = [...ends].sort((a, b) => a - b);
+	let best;
+	let low = 0;
+	for (let high = 0; high < sorted.length; high++) {
+		while (sorted[high] - sorted[low] > FLUSH_PT) low++;
+		if (!best || high - low > best[1] - best[0]) best = [low, high];
+	}
+	if (!best || (best[1] - best[0] + 1) * 2 < sorted.length) return void 0;
+	if (sorted.length - 1 - best[1] > Math.max(1, Math.floor(sorted.length * OVERSET_SHARE))) return void 0;
+	return sorted[best[1]];
+}
+/** How many of a column's lines, as a share of them, may be set over its measure. */
+var OVERSET_SHARE = .05;
+/**
+* How narrow, in ems of the page's body, a column of the page may be: narrower
+* is a table's. The columns canvas.pdf's tables leave are two to six ems wide,
+* and eight is four or five words of prose.
+*/
+var NARROWEST_COLUMN_EM = 8;
+/**
 * The candidate gutters that actually separate something, left to right.
 *
 * A gutter with nothing on one side of it is a margin, and two of them with a
@@ -636,6 +1276,13 @@ function assignColumns(runs, gutters) {
 		for (const run of row) columnOf.set(run, SPANNING_COLUMN);
 		breaks.push(Math.max(...row.map((r) => r.y)));
 	}
+	const inRows = rows.filter((row) => row.some((r) => r.text.trim() !== ""));
+	const across = (block) => block.some((row) => row.some((r) => columnOf.get(r) === SPANNING_COLUMN));
+	const blocks = [...blocksOf(inRows, isCode, 1).filter(across), ...blocksOf(inRows, isTableRow, LEAST_TABLE_ROWS).filter((block) => across(block) || block.length >= SPANNING_TABLE_ROWS)];
+	for (const block of blocks) for (const row of block) {
+		if (row.some((r) => columnOf.get(r) !== SPANNING_COLUMN)) breaks.push(Math.max(...row.map((r) => r.y)));
+		for (const run of row) columnOf.set(run, SPANNING_COLUMN);
+	}
 	return {
 		columnOf,
 		breaks: breaks.sort((a, b) => b - a)
@@ -691,6 +1338,32 @@ function bandOf(breaks, top, epsilon) {
 * does this — a flowing paragraph is meant to be read across.
 */
 var SPACE_GAP_EM = .25;
+/**
+* §12.5.5 — the runs the page's own content paints, and then the ones an
+* annotation's appearance does: two layers, grouped into lines apart.
+*/
+function byPainter(runs) {
+	return [runs.filter((r) => r.annotation !== true), runs.filter((r) => r.annotation === true)].filter((group) => group.length > 0);
+}
+/**
+* §8.5.3 / §12.5.5 — where a placed line stands among the page's marks, which
+* are ordered as they were painted (see `compareOrder`): the page's own words
+* over everything its content drew, and under every annotation, whose
+* appearances paint after it (`[MAX_SAFE_INTEGER, index, …]`); an
+* annotation's words over all of it. Keyed as one layer, the placed lines
+* fell among the appearances by their count: evaljs.pdf's "Execute" went
+* under the grey of the button it names.
+*
+* @param runs  The layer the line was grouped from (see `byPainter`).
+* @param count How many lines are placed already.
+*/
+function placedKey(runs, count) {
+	return runs[0]?.annotation === true ? [
+		Number.MAX_SAFE_INTEGER,
+		Number.MAX_SAFE_INTEGER,
+		count
+	] : [Number.MAX_SAFE_INTEGER - 1, count];
+}
 /** Runs by the direction of their baseline, upright first, each angle rounded. */
 function byAngle(runs) {
 	const groups = /* @__PURE__ */ new Map();
@@ -762,7 +1435,7 @@ function rotation60kOf(angleDeg) {
 * 0.05, and thirty at 0.05 em or more. A twentieth of an em sits in that gap.
 */
 var BASELINE_STEP_EM = .05;
-function groupIntoLines(runs, split = false, stepped = false) {
+function groupIntoLines(runs, split = false, stepped = false, spaces, rules = []) {
 	const sorted = [...runs].sort((a, b) => b.y - a.y || a.x - b.x);
 	const clusters = [];
 	for (const run of sorted) {
@@ -770,6 +1443,7 @@ function groupIntoLines(runs, split = false, stepped = false) {
 		const tol = Math.max(1, (run.fontSizePt || 10) * .5);
 		if (last && Math.abs(last.y - run.y) <= tol) {
 			last.runs.push(run);
+			if ((run.fontSizePt || 0) > last.fontSize) last.y = run.y;
 			last.fontSize = Math.max(last.fontSize, run.fontSizePt || 0);
 		} else clusters.push({
 			y: run.y,
@@ -777,10 +1451,12 @@ function groupIntoLines(runs, split = false, stepped = false) {
 			runs: [run]
 		});
 	}
+	for (const c of clusters) c.runs.sort((a, b) => a.x - b.x);
+	const stops = sharedStops(clusters.map((c) => c.runs), rules);
 	return clusters.flatMap((c) => {
-		const ordered = c.runs.sort((a, b) => a.x - b.x);
+		const ordered = c.runs;
 		const fontSize = c.fontSize || 10;
-		if (!split) return [lineOf(ordered, c.y, fontSize, stepped)];
+		if (!split) return [lineOf(ordered, c.y, fontSize, stepped, stops, spaces)];
 		const pieces = [[]];
 		for (const run of ordered) {
 			const prev = pieces[pieces.length - 1];
@@ -789,10 +1465,103 @@ function groupIntoLines(runs, split = false, stepped = false) {
 			if (last !== void 0 && (Math.abs(run.x - last.endX) > size * SPACE_GAP_EM || Math.abs(run.y - prev[0].y) > size * BASELINE_STEP_EM || isRightToLeft(run.text) || isRightToLeft(last.text))) pieces.push([]);
 			pieces[pieces.length - 1].push(run);
 		}
-		return pieces.map((piece) => lineOf(piece, piece[0].y, Math.max(...piece.map((r) => r.fontSizePt || 0)) || fontSize, stepped));
+		return pieces.map((piece) => lineOf(piece, piece[0].y, Math.max(...piece.map((r) => r.fontSizePt || 0)) || fontSize, stepped, stops, spaces));
 	});
 }
 /**
+* Whether a block's lines are PROSE: many of them, across a measure a sentence
+* is set to, and most running out to the edge that measure breaks them at, as
+* a column of text does — where a stack of labels and values, or an address,
+* is short lines of their own lengths.
+*
+* @param lines The block's lines, top first.
+* @param own   The block's own left and right edges.
+* @returns True for a column of running text.
+*/
+function isProse(lines, own) {
+	if (lines.length < PROSE_LINES) return false;
+	const size = median(lines.map((l) => l.fontSize)) || 10;
+	if (own.right - own.left < size * PROSE_MEASURE_EM) return false;
+	const asked = lines.slice(0, -1);
+	return asked.filter((l) => l.x + l.width >= own.right - l.fontSize * FULL_LINE_EM).length >= asked.length * PROSE_FULL_SHARE;
+}
+/** How many lines a block needs before it can be told for prose. */
+var PROSE_LINES = 5;
+/** The narrowest measure, in ems, a column of prose is set to. */
+var PROSE_MEASURE_EM = 20;
+/** How near the block's edge, in ems, a line has to end to have run out to it. */
+var FULL_LINE_EM = 2;
+/** The share of a block's lines that run out to its edge in a column of prose. */
+var PROSE_FULL_SHARE = .6;
+/**
+* §17.3.1.38 — the stops a block of lines is set out on: where text resumes,
+* after a gap wider than a word space, at the same place on more than one line
+* — and on at least one of them after a gap only a tab makes.
+*
+* A tab's gap is as wide as what stands before it leaves it. An invoice sets
+* "Date due", "Date of issue" and "Invoice number" over one column of values
+* at 108pt, and only the shortest label leaves a gap no space could make: the
+* other two came back with their values a word's width after the label
+* instead of in the column.
+*
+* …or a gap a rule is drawn down. A table ruled into columns needs no white
+* wider than a space between them, the rule says where one ends: comments.pdf's
+* Figure 9 sets its codes "xx1", "000" in a column all as wide as each other,
+* twelve points from the types beside them and a rule between, and the two
+* columns came back one, "xx1 number", with the rule struck through it.
+*
+* @param lines Each line's runs, left to right.
+* @param rules The rules drawn down the block (see {@link columnRules}).
+* @returns The x of every stop two lines share.
+*/
+function sharedStops(lines, rules = []) {
+	const seen = [];
+	lines.forEach((runs, line) => {
+		let end;
+		for (const run of runs) {
+			if (run.text.replaceAll("�", "").trim() === "") continue;
+			const size = run.fontSizePt || 10;
+			if (end !== void 0 && run.x - end >= size * STOP_GAP_EM) {
+				const from = end;
+				const ruled = rules.some((r) => r.x > from && r.x < run.x && r.minY <= run.y + size * .5 && r.maxY >= run.y);
+				seen.push({
+					x: run.x,
+					line,
+					tab: ruled || run.x - end >= size * TAB_GAP_EM
+				});
+			}
+			end = Math.max(end ?? run.endX, run.endX);
+		}
+	});
+	const stops = [];
+	for (const tab of seen) {
+		if (!tab.tab || stops.some((x) => Math.abs(x - tab.x) <= STOP_SLACK_PT)) continue;
+		if (new Set(seen.filter((o) => Math.abs(o.x - tab.x) <= STOP_SLACK_PT).map((o) => o.line)).size >= 2) stops.push(tab.x);
+	}
+	return stops;
+}
+/** The least gap, in ems, that lands a run on a stop the lines around it share. */
+var STOP_GAP_EM = .5;
+/**
+* The rules a page draws down its lines: thin upright paths, a line's height
+* long at the least — the edges of a table's columns.
+*
+* @param vectors The page's paths.
+*/
+function columnRules(vectors) {
+	return vectors.filter((v) => v.glyph !== true && v.maxX - v.minX <= COLUMN_RULE_THIN_PT && v.maxY - v.minY >= COLUMN_RULE_LEAST_PT).map((v) => ({
+		x: (v.minX + v.maxX) / 2,
+		minY: v.minY,
+		maxY: v.maxY
+	}));
+}
+/** No thicker than this, a path drawn down the page is a rule. */
+var COLUMN_RULE_THIN_PT = 1;
+/** …and no shorter than this: a rule stands at least a line of small type tall. */
+var COLUMN_RULE_LEAST_PT = 5;
+/** How far from a shared stop a run may start and still stand on it. */
+var STOP_SLACK_PT = .75;
+/**
 * Where a line's INK is, which is not how far its pen travelled.
 *
 * A run of spaces advances the pen and marks nothing. basicapi.pdf sets its
@@ -823,9 +1592,154 @@ function inkSpan(runs) {
 		width: Math.max(0, last.endX - trail - x)
 	};
 }
+/**
+* A document's runs as its listings are read (see {@link isCode}).
+*
+* A typewriter face is a listing's only where the document is set in another:
+* a letter typed throughout, a screenplay, a page set in Courier for its even
+* widths, is PROSE in that face, and its lines run on and its double spaces
+* are spaces. Where most of what the document shows is typewritten, its runs
+* are read as any other face's.
+*
+* @param pages Each page's runs.
+* @returns The same runs, or copies without `fixedPitch` where the typewriter
+*          face is the document's own.
+*/
+function typewritten(pages) {
+	let typed = 0;
+	let all = 0;
+	for (const runs of pages) for (const run of runs) {
+		const letters = run.text.replace(/\s/gu, "").length;
+		all += letters;
+		if (run.fixedPitch === true) typed += letters;
+	}
+	if (typed === 0 || typed * 2 <= all) return pages;
+	return pages.map((runs) => runs.map((run) => {
+		if (run.fixedPitch !== true) return run;
+		const { fixedPitch: _typed, ...prose } = run;
+		return prose;
+	}));
+}
+/**
+* Whether a line is CODE: every word of it set in a typewriter face (§9.8.2).
+*
+* A listing is set line by line with its indents and its comments lined up in
+* columns of the typewriter's cells, and re-set as prose it is no program:
+* comments.pdf's "v0 := ld state[748]" and "st sp[0], v0" ran together as
+* one line of a paragraph, and so did line 4 of Figure 1 and its line 5.
+*/
+function isCode(runs) {
+	const inked = runs.filter((r) => r.text.trim() !== "");
+	return inked.length > 0 && inked.every((r) => r.fixedPitch === true);
+}
+/**
+* Whether the white between two runs of a typewriter face LINES UP what
+* follows it: wider than a cell and a half, where a word space is one cell.
+* A listing puts its comments in a column that way, and a space in their
+* place set each comment against its own line's code.
+*/
+function aligned(before, after) {
+	if (before.fixedPitch !== true || after.fixedPitch !== true) return false;
+	const letters = [...before.text].length;
+	if (letters === 0) return false;
+	const cell = (before.endX - before.x) / letters;
+	return cell > 0 && after.x - before.endX >= cell * ALIGNED_CELLS;
+}
+/** How many of a typewriter's cells of white line up what follows them. */
+var ALIGNED_CELLS = 1.5;
+/**
+* A page's runs less its code listings: the rows every word of which is set
+* in a typewriter face (see {@link isCode}).
+*
+* A listing says nothing about the page's columns. comments.pdf sets two
+* across the head of its third page, the code at the left and each comment
+* lined up at one x: the white between them — thirty-five lines of it at the
+* same place — was taken for the gutter of a page in two columns, while the
+* real one, under the listings, was crossed by every comment and not found.
+* The code came back as a column of prose and the comments as another.
+*/
+function withoutListings(runs) {
+	if (!runs.some((r) => r.fixedPitch === true)) return runs;
+	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const listed = new Set(rowsOf(runs, fontSize).filter(isCode).flat());
+	return listed.size > 0 ? runs.filter((r) => !listed.has(r)) : runs;
+}
+/**
+* A page's runs less its tables (see {@link isTableRow}): the rows of every
+* block of three and more table rows. The same runs where it has none.
+*
+* The white between a table's columns says nothing about the columns of the
+* text around it. comments.pdf sets Figure 13, a benchmark and nine figures a
+* row, twenty-six rows deep, over two columns of text: its nine gaps were
+* taken for the page's gutters, the text's own was crossed by its rows and
+* not found, and the whole page came back as one table, each line of the text
+* a row of it.
+*/
+function withoutTables(runs) {
+	const rows = rowsOf(runs, median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10).filter((row) => row.some((r) => r.text.trim() !== ""));
+	const tabled = new Set(blocksOf(rows, isTableRow, LEAST_TABLE_ROWS).flat(2));
+	return tabled.size > 0 ? runs.filter((r) => !tabled.has(r)) : runs;
+}
+/**
+* The rows of a page that stand in runs of at least `least` for which `holds`
+* is true, each run of them a block.
+*/
+function blocksOf(rows, holds, least) {
+	const out = [];
+	for (let from = 0; from < rows.length;) {
+		let to = from;
+		while (to < rows.length && holds(rows[to])) to++;
+		if (to - from >= least) out.push(rows.slice(from, to));
+		from = Math.max(to, from + 1);
+	}
+	return out;
+}
+/**
+* Whether a row is a TABLE's: four cells or more — its words as far as each
+* gap wider than an em — and none of them as long as a line of prose. A row
+* of a page in columns is two long pieces; comments.pdf's Figure 13 is ten
+* short ones a row, a benchmark and nine figures, twenty-six rows deep.
+*/
+function isTableRow(runs) {
+	const cells = cellsOf(runs);
+	if (cells.length < TABLE_CELLS) return false;
+	const size = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	return cells.every((c) => c.to - c.from <= size * WIDEST_CELL_EM);
+}
+/** A row's ink as its cells: its words, as far as each gap wider than an em. */
+function cellsOf(runs) {
+	const inks = runs.map((run) => ({
+		run,
+		ink: runInk(run)
+	})).filter((r) => r.ink !== void 0).sort((a, b) => a.ink[0] - b.ink[0]);
+	const cells = [];
+	for (const { run, ink } of inks) {
+		const last = cells[cells.length - 1];
+		if (last && ink[0] - last.to < (run.fontSizePt || 10) * CELL_GAP_EM) last.to = Math.max(last.to, ink[1]);
+		else cells.push({
+			from: ink[0],
+			to: ink[1]
+		});
+	}
+	return cells;
+}
+/** How many cells make a row a table's. */
+var TABLE_CELLS = 4;
+/** How many such rows make a table. */
+var LEAST_TABLE_ROWS = 3;
+/**
+* …and how many make one across the page's columns with no row of it
+* reaching over the gutter on its own: more than two columns' rows fall
+* together by chance.
+*/
+var SPANNING_TABLE_ROWS = 6;
+/** The white between two cells of a table row, in ems: wider than a word space ever is. */
+var CELL_GAP_EM = 1;
+/** The longest a table's cell runs, in ems; a line of a column of prose runs further. */
+var WIDEST_CELL_EM = 12;
 /** One run of runs, left to right on a shared baseline, as a {@link Line}. */
-function lineOf(runs, y, fontSize, stepped) {
-	const { spans: ordered, stops } = lineSpans(runs, fontSize, stepped || runs.length > 1 && !runs.some((r) => SPACE.test(r.text)));
+function lineOf(runs, y, fontSize, stepped, shared = [], spaces) {
+	const { spans: ordered, stops, pieces } = lineSpans(runs, fontSize, stepped || runs.length > 1 && !runs.some((r) => SPACE.test(r.text)), shared, spaces);
 	const spans = ordered.every((s) => s.text.trim() === "" || isRightToLeft(s.text)) ? [...ordered].reverse() : ordered;
 	const ink = inkSpan(runs);
 	return {
@@ -833,8 +1747,12 @@ function lineOf(runs, y, fontSize, stepped) {
 		width: ink.width,
 		y,
 		fontSize,
-		...tabbed(runs, fontSize) ? { tabbed: true } : {},
-		...stops.length > 0 ? { stops } : {},
+		...tabbed(runs, fontSize) || stops.length > 0 ? { tabbed: true } : {},
+		...stops.length > 0 ? {
+			stops,
+			pieces
+		} : {},
+		...isCode(runs) ? { code: true } : {},
 		text: spans.map((s) => s.text).join("").replace(/\s+/g, " ").trim(),
 		spans
 	};
@@ -888,10 +1806,25 @@ var TAB_GAP_EM = 2.5;
 * {@link stepsBetweenWords}). The tight one still clears the gaps a producer
 * leaves INSIDE a word when it splits one for kerning, which measure eight
 * hundredths of an em at their widest across this corpus.
+*
+* …and a page that draws its spaces may step some of them all the same: a
+* gap as wide as most of the face's own space is one, set by a step instead
+* of a glyph. freeculture.pdf's index draws the space in "academic journals"
+* and steps the one after "journals," — 1.71 points against a space of 2.03,
+* short of a quarter em — and the entry came back "journals,262,280–82".
 */
 function spaceGap(prev, fontSize, stepped) {
-	return (prev.fontSizePt || fontSize) * (stepped ? STEPPED_SPACE_EM : DRAWN_SPACE_EM);
+	const size = prev.fontSizePt || fontSize;
+	if (stepped) return size * STEPPED_SPACE_EM;
+	const space = prev.spaceWidthPt;
+	const face = space !== void 0 && space >= size * LEAST_FACE_SPACE_EM && space <= size * MOST_FACE_SPACE_EM ? space * STEPPED_SPACE_SHARE : Infinity;
+	return Math.min(size * DRAWN_SPACE_EM, face);
 }
+/** How much of the face's own space a step has to be to stand for one. */
+var STEPPED_SPACE_SHARE = .75;
+/** The narrowest and widest space, in ems, a face is taken at its word for. */
+var LEAST_FACE_SPACE_EM = .15;
+var MOST_FACE_SPACE_EM = .5;
 /**
 * §17.3.1.25 — one character of a LEADER, the dotted rule that carries the eye
 * across a table of contents.
@@ -906,6 +1839,17 @@ function spaceGap(prev, fontSize, stepped) {
 function isLeader(text) {
 	return text.length === 1 && LEADER_CHARS.has(text);
 }
+/**
+* Whether `run` carries on the leader `prev` is a character of: the same
+* character, a step no wider than a word space on from it. A dash a column
+* further on is a cell's: comments.pdf's Figure 13 marks three empty figures
+* "-", a column apart, and joined as one leader they came back "---", one
+* cell standing where three had.
+*/
+function continuesLeader(prev, run, fontSize) {
+	const dots = prev.text.endsWith(".") && run.text.startsWith(".");
+	return (isLeader(prev.text) && prev.text === run.text || dots) && run.x - prev.endX < (run.fontSizePt || fontSize) * CELL_GAP_EM;
+}
 var LEADER_CHARS = new Set([
 	".",
 	"·",
@@ -930,17 +1874,48 @@ function stepsBetweenWords(runs) {
 	if (runs.length < 8) return false;
 	return runs.filter((r) => /\s/u.test(r.text)).length / runs.length < .05;
 }
-function lineSpans(runs, fontSize, stepped) {
+function lineSpans(runs, fontSize, stepped, shared = [], spaces) {
 	const spans = [];
 	const stops = [];
+	const pieces = [{
+		from: Infinity,
+		to: -Infinity
+	}];
+	const table = isTableRow(runs);
+	const code = isCode(runs);
 	const body = runs.filter((r) => (r.fontSizePt || fontSize) > fontSize * SCRIPT_SIZE);
 	const baseline = median((body.length > 0 ? body : runs).map((r) => r.y));
 	let prev;
-	for (const run of runs) {
-		if (prev !== void 0 && run.x - prev.endX > spaceGap(prev, fontSize, stepped) && !(isLeader(prev.text) && prev.text === run.text)) if (run.x - prev.endX >= (run.fontSizePt || fontSize) * TAB_GAP_EM) {
+	let inked;
+	for (const [i, run] of runs.entries()) {
+		if (run.text.trim() === "" && inked !== void 0) {
+			const next = runs.slice(i + 1).find((r) => r.text.trim() !== "");
+			if ((run.endX - run.x <= 0 || next !== void 0 && next.x < (run.x + run.endX) / 2) && next !== void 0 && next.x - inked < spaceGap(next, fontSize, true)) continue;
+		}
+		if (run.text.replaceAll("�", "") === "" && run.text !== "") continue;
+		if (!code && prev !== void 0 && prev.text.trim() === "" && run.text.trim() !== "" && inked !== void 0 && run.x - inked >= (run.fontSizePt || fontSize) * STOP_GAP_EM && shared.some((x) => Math.abs(x - run.x) <= STOP_SLACK_PT)) {
+			while (spans.length > 0 && spans[spans.length - 1].text.trim() === "") {
+				if (spans[spans.length - 1].text === "	") break;
+				spans.pop();
+			}
 			spans.push({ text: "	" });
 			stops.push(run.x);
-		} else spans.push({ text: " " });
+			pieces.push({
+				from: Infinity,
+				to: -Infinity
+			});
+		} else if (prev !== void 0 && run.x - prev.endX > spaceGap(prev, fontSize, stepped) && !continuesLeader(prev, run, fontSize)) {
+			const size = run.fontSizePt || fontSize;
+			const onStop = inked !== void 0 && run.x - inked >= size * STOP_GAP_EM && shared.some((x) => Math.abs(x - run.x) <= STOP_SLACK_PT);
+			if (run.x - prev.endX >= size * TAB_GAP_EM || onStop || aligned(prev, run) || table && run.x - prev.endX >= size * CELL_GAP_EM) {
+				spans.push({ text: "	" });
+				stops.push(run.x);
+				pieces.push({
+					from: Infinity,
+					to: -Infinity
+				});
+			} else if (!/\s$/u.test(prev.text) && !/^\s/u.test(run.text) || run.x - prev.endX > (prev.fontSizePt || fontSize) * DRAWN_SPACE_EM) spans.push(fittedSpace(spaceAfter(spans[spans.length - 1], run), prev, run, spaces));
+		}
 		spans.push({
 			text: run.text.replaceAll("�", ""),
 			sizePt: run.fontSizePt,
@@ -957,12 +1932,70 @@ function lineSpans(runs, fontSize, stepped) {
 			...run.href !== void 0 ? { href: run.href } : {}
 		});
 		prev = run;
+		if (run.text.trim() !== "") {
+			inked = Math.max(inked ?? run.endX, run.endX);
+			const piece = pieces[pieces.length - 1];
+			piece.from = Math.min(piece.from, run.x);
+			piece.to = Math.max(piece.to, run.endX);
+		}
 	}
 	return {
 		spans,
-		stops
+		stops,
+		pieces
+	};
+}
+/**
+* §17.3.2.43 — a word space set as narrow as the page set it.
+*
+* TeX justifies a line by stretching its word spaces or SHRINKING them, and a
+* line it shrank holds more than the same words with the face's own spaces:
+* re-set with those, its last word no longer fits and goes to the next line,
+* and the paragraph grows by a line. comments.pdf sets its 9pt Times with
+* word spaces of 1.70 to 3.44 points against the face's 2.24, and every column
+* of it ran one to four lines long. A space the page set narrower than the
+* face's is set at that share of the face's width (`w:w`, whole percent
+* rounded down, so the line still fits). A wider one is left alone: a line TeX
+* stretched fits with the face's spaces too.
+*
+* The share of the glyph and not a spacing after it: LibreOffice lays no
+* character spacing (§17.3.2.35) after the last character of a run, and a
+* run that is one space has nothing else — Word and LibreOffice both narrow
+* the glyph itself.
+*
+* Only in a face the document carries, whose space is known: a substitute's
+* could be anything.
+*
+* @param space  The space as the line would have it.
+* @param before The run the space follows.
+* @param after  The run it precedes.
+* @param spaces The space each face the document carries is set with.
+* @returns The space, narrowed where the page set it narrower.
+*/
+function fittedSpace(space, before, after, spaces) {
+	if (spaces === void 0 || /\s$/u.test(before.text) || /^\s/u.test(after.text)) return space;
+	const advance = before.fontName !== void 0 ? spaces.get(before.fontName) : void 0;
+	const size = space.sizePt ?? before.fontSizePt;
+	if (advance === void 0 || !(size > 0)) return space;
+	const own = advance / 1e3 * size;
+	const gap = after.x - before.endX;
+	if (gap > own - FIT_SLACK_PT) return space;
+	const share = Math.floor(gap / own * 100) / 100;
+	return {
+		...space,
+		widthScale: Math.max(share, 1 - MOST_SHRINK)
 	};
 }
+/** A space this much narrower than the face's is the page's rounding, not a shrink. */
+var FIT_SLACK_PT = .02;
+/**
+* The most of a space a line may take back. TeX shrinks a Times space by a
+* quarter of itself and a Computer Modern one by a third — but the space after
+* a word in type is written in the type's face, and comments.pdf sets its
+* `primes` in 9pt Courier-wide cmtt9 and the space after it in Times: 2.25
+* points of a 4.72-point space. A gap narrower still is not a word space.
+*/
+var MOST_SHRINK = .6;
 /**
 * §17.3.2.42 — a run set off the line's baseline, and smaller, as the script it
 * is.
@@ -1030,41 +2063,234 @@ function ruleOfCharacters(line) {
 }
 /** How many of them it takes before a row of marks is a rule. */
 var RULE_CHARS = 3;
-function groupIntoParagraphs(lines, column, pageHeight = 0) {
+function groupIntoParagraphs(lines, column, pageHeight = 0, before, eachLine = false, reach) {
 	const groups = [];
 	const gaps = [];
+	const flushEnds = column ? lines.filter((l) => Math.abs(column.right - (l.x + l.width)) <= JUSTIFIED_SLACK_PT).length : 0;
+	const setJustified = column !== void 0 && lines.length >= JUSTIFIED_COLUMN_LINES && flushEnds >= lines.length * JUSTIFIED_COLUMN_SHARE;
+	const hangsAt = column !== void 0 ? hangingEdge(lines, column) : void 0;
 	let prev;
+	let beforePrev;
 	for (const line of lines) {
 		const gap = prev !== void 0 ? prev.y - line.y : 0;
 		const opened = prev !== void 0 && gap > line.fontSize * 1.5;
-		if (groups.length === 0 || opened || ruleOfCharacters(line) || prev !== void 0 && (ruleOfCharacters(prev) || endedParagraph(prev, line, column) || carriesLeader(prev) || prev.tabbed === true)) {
+		const goesOn = hangsAt !== void 0 && line.x >= hangsAt;
+		if (groups.length === 0 || eachLine || opened || ruleOfCharacters(line) || line.code === true || hangsAt !== void 0 && line.x < hangsAt || line.tabbed === true || prev !== void 0 && opensItem(prev, line) || prev !== void 0 && (ruleOfCharacters(prev) || prev.code === true || !goesOn && (endedParagraph(prev, line, column) || reach !== void 0 && roomForWord(prev, line, reach) || setJustified && endedJustified(beforePrev, prev, line, column) || column !== void 0 && endedCentred(prev, line, column)) || carriesLeader(prev) || prev.tabbed === true)) {
 			groups.push([]);
-			gaps.push(prev === void 0 ? 0 : gap);
+			gaps.push(prev === void 0 ? before !== void 0 ? before.y - line.y : 0 : gap);
 		}
 		groups[groups.length - 1].push(line);
+		beforePrev = prev;
 		prev = line;
 	}
 	const starts = lines.map((l) => l.x).sort((a, b) => a - b);
-	const columnLeft = starts[Math.floor(starts.length * COLUMN_LEFT_QUANTILE)] ?? 0;
+	const columnLeft = column?.left ?? starts[Math.floor(starts.length * COLUMN_LEFT_QUANTILE)] ?? 0;
+	const heights = [];
 	return groups.map((g, i) => {
 		const first = g[0];
 		const fontSize = Math.max(...g.map((l) => l.fontSize));
-		const opened = (gaps[i] ?? 0) - fontSize * 1.2;
+		const inner = g.slice(1).map((l, k) => g[k].y - l.y);
+		let lineHeight = Math.min(Math.max(inner.length > 0 ? median(inner) : fontSize * NATURAL_LINE_EM, fontSize), fontSize * TALLEST_LINE_EM);
+		const above = i > 0 ? heights[i - 1] : before?.lineHeight;
+		const gap = gaps[i] ?? 0;
+		if (inner.length === 0 && above !== void 0) {
+			const room = (gap - (1 - BASELINE_AT) * above) / BASELINE_AT;
+			if (room < lineHeight) lineHeight = Math.max(room, fontSize);
+		}
+		heights.push(lineHeight);
+		const opened = above !== void 0 ? gap - (1 - BASELINE_AT) * above - BASELINE_AT * lineHeight : 0;
 		const most = pageHeight > 0 ? pageHeight / 3 : fontSize * 3;
-		const spacingBefore = opened > fontSize * .3 ? Math.min(opened, most) : void 0;
+		const spacingBefore = opened > SPACING_NOISE_PT ? Math.min(opened, most) : void 0;
 		const stops = g.length === 1 ? first.stops ?? [] : [];
+		const aligned = g.every((l) => lines.some((o) => !g.includes(o) && (Math.abs(o.x - l.x) <= STOP_SLACK_PT || (o.stops ?? []).some((x) => Math.abs(x - l.x) <= STOP_SLACK_PT)))) ? {} : alignmentOf(g, column);
 		return {
 			spans: joinLines(g),
 			fontSize,
 			top: first.y,
-			...stops.length > 0 ? { stops: stops.map((x) => x - (column?.left ?? columnLeft)) } : {},
+			bottom: g[g.length - 1].y,
+			...stops.length > 0 ? {
+				stops: stops.map((x) => x - columnLeft),
+				pieces: (first.pieces ?? []).map((p) => ({
+					from: p.from - columnLeft,
+					to: p.to - columnLeft
+				}))
+			} : {},
 			...spacingBefore !== void 0 ? { spacingBefore } : {},
-			...alignmentOf(g, column),
-			...indentOf(g, columnLeft, alignmentOf(g, column).alignment)
+			lineHeight,
+			...aligned,
+			...indentOf(g, columnLeft, aligned.alignment),
+			lineCount: g.length,
+			left: Math.min(...g.map((l) => l.x)),
+			right: Math.max(...g.map((l) => l.x + l.width)),
+			...opened > most ? { far: g } : {}
 		};
 	});
 }
 /**
+* Where a column's paragraphs go on, where they HANG: the first line of each
+* at the column's edge — or at a level set in from it — and the lines after it
+* set in further, as an index sets its entries and a bibliography its
+* references. freeculture.pdf's index sets "democracy:" at the edge, "digital
+* sharing within, 184" and the other entries under it a level in, and the
+* lines that carry an entry on — "41–42, 43, 44–45" — at a level further in
+* again; read by the measure alone, its short entries ran together, and a line
+* back at the edge after one set in was taken for the second line of a
+* paragraph whose first is set in.
+*
+* The level a paragraph goes on at is reached from full lines, the ones the
+* entry ran to the measure and turned from, and many of its lines are short:
+* they end their entries. The level a paragraph's own first line is set in to
+* is reached from short lines — the paragraph before ended there — or runs to
+* the measure itself.
+*
+* @param lines  The column's lines, top to bottom.
+* @param column The column they are set in.
+* @returns How far in a line goes on its paragraph; a line nearer the edge
+*          opens one. `undefined` where the column's paragraphs do not hang.
+*/
+function hangingEdge(lines, column) {
+	const width = column.right - column.left;
+	if (!(width > 0) || lines.length < HANGING_LINES) return void 0;
+	const size = median(lines.map((l) => l.fontSize)) || 10;
+	const edge = Math.min(...lines.map((l) => l.x));
+	const short = (l) => column.right - (l.x + l.width) > width * .25;
+	const levels = [];
+	for (let k = 1; k < lines.length; k++) {
+		const prev = lines[k - 1];
+		const line = lines[k];
+		const setIn = line.x - edge;
+		if (setIn < size * .5 || setIn > size * HANGING_DEEPEST_EM) continue;
+		let level = levels.find((v) => Math.abs(v.x - line.x) <= size * HANGING_SLACK_EM);
+		if (level === void 0) {
+			level = {
+				x: line.x,
+				lines: 0,
+				afterFull: 0,
+				short: 0
+			};
+			levels.push(level);
+		}
+		level.lines++;
+		if (!short(prev)) level.afterFull++;
+		if (short(line)) level.short++;
+	}
+	const goesOn = levels.filter((v) => v.lines >= HANGING_LEAST && v.afterFull >= v.lines * HANGING_FULL_SHARE && v.short >= v.lines * HANGING_SHORT_SHARE);
+	if (goesOn.length === 0) return void 0;
+	let pairs = 0;
+	let fullPairs = 0;
+	for (let k = 1; k < lines.length; k++) {
+		if (lines[k - 1].x - edge >= size * .5 || lines[k].x - edge >= size * .5) continue;
+		pairs++;
+		if (!short(lines[k - 1])) fullPairs++;
+	}
+	if (fullPairs > Math.max(1, pairs * HANGING_RUN_ON_SHARE)) return void 0;
+	return Math.min(...goesOn.map((v) => v.x)) - size * HANGING_SLACK_EM;
+}
+/** How many lines a column needs before its paragraphs can be seen to hang. */
+var HANGING_LINES = 8;
+/** …and how many lines a level needs before a paragraph can be seen to go on at it. */
+var HANGING_LEAST = 2;
+/** How far off a level, in ems, a line may start and still stand at it. */
+var HANGING_SLACK_EM = .25;
+/** How far in from the edge, in ems, a level may stand. */
+var HANGING_DEEPEST_EM = 4;
+/** How many of a level's lines, as a share of them, follow full lines where paragraphs go on at it. */
+var HANGING_FULL_SHARE = .8;
+/** …and how many of them are short, ending their paragraphs. */
+var HANGING_SHORT_SHARE = .3;
+/** How many lines at the edge, as a share of those after another, may follow a full one. */
+var HANGING_RUN_ON_SHARE = .6;
+/**
+* Whether the first word of `next` would have fit on `prev` short of `reach` —
+* so the page did not break `prev` for want of room, and ended it.
+*
+* The width of the word is its share of its line's: a guess good to a letter,
+* and the margin it is compared with is the rest of the sheet.
+*/
+function roomForWord(prev, next, reach) {
+	const text = next.text.trimStart();
+	const word = text.split(/\s/u)[0] ?? "";
+	if (word.length === 0) return false;
+	const width = next.width * word.length / text.length;
+	return reach - (prev.x + prev.width) > width + prev.fontSize * WORD_SPACE_EM;
+}
+/**
+* Whether a centred line ended its paragraph: the line under it is centred too,
+* and its first word would have fit on this one. A centred paragraph that wraps
+* fills its lines to the measure but the last, as any paragraph does; lines a
+* page centres one by one do not. comments.pdf centres its authors'
+* affiliations a line apiece — "{gal,brendan,…}@mozilla.com", and under it
+* "Adobe Corporation" — and run together they came back re-wrapped a line
+* shorter, the columns under them risen into the white.
+*/
+function endedCentred(prev, next, column) {
+	const width = column.right - column.left;
+	if (!(width > 0)) return false;
+	const centred = (l) => {
+		const lead = l.x - column.left;
+		const trail = column.right - (l.x + l.width);
+		return Math.abs(lead - trail) <= width * CENTRED_SLACK && Math.min(lead, trail) > 0;
+	};
+	if (!centred(prev) || !centred(next)) return false;
+	const inset = (l) => Math.min(l.x - column.left, column.right - (l.x + l.width));
+	if (Math.max(inset(prev), inset(next)) < width * CENTRED_INSET) return false;
+	const text = next.text.trimStart();
+	const word = text.split(/\s/u)[0] ?? "";
+	if (word.length === 0) return false;
+	const wordWidth = next.width * word.length / text.length;
+	return width - prev.width > wordWidth + prev.fontSize * WORD_SPACE_EM;
+}
+/** How far off the middle of the measure, as a share of it, a centred line may stand. */
+var CENTRED_SLACK = .06;
+/**
+* How far in from both edges, as a share of the measure, a centred line
+* stands: further than a full line stands in from a column whose edges are
+* its bullets' and an overfull line's (comments.pdf's, a thirtieth at most),
+* and no further than a block of names needs — the paper's second line of
+* authors stands in by a thirteenth, and asked for a tenth, the line under it
+* came back run into it.
+*/
+var CENTRED_INSET = .05;
+/**
+* Whether a line of a column set against both edges ended its paragraph: it
+* stops short of the measure, and the line after it is indented or its first
+* word would have fit on it.
+*
+* Not where a line beside it stops at the same place: that is the edge of a
+* narrower block, not the end of the text. A quotation set in from both sides
+* stops short of the measure on every line, and freeculture.pdf's came back a
+* paragraph a line.
+*/
+function endedJustified(before, prev, next, column) {
+	const end = prev.x + prev.width;
+	if (column.right - end <= prev.fontSize * WORD_SPACE_EM) return false;
+	const edge = (l) => l !== void 0 && Math.abs(l.x + l.width - end) <= JUSTIFIED_SLACK_PT;
+	if (edge(before) || edge(next)) return false;
+	return next.x - prev.x >= prev.fontSize * INDENT_EM || roomForWord(prev, next, column.right);
+}
+/** How many lines a column needs to show it is set against both edges. */
+var JUSTIFIED_COLUMN_LINES = 8;
+/** …and how many of them run to the measure, at the least. */
+var JUSTIFIED_COLUMN_SHARE = .6;
+/** How far short of the measure a line of it may end and still run to it: the page's rounding. */
+var JUSTIFIED_SLACK_PT = 1;
+/** A word space, in ems: what stands between a line's end and the word put after it. */
+var WORD_SPACE_EM = .3;
+/**
+* The exact box a paragraph's first line stands in, where the paragraph is a
+* line of text set to one (see {@link groupIntoParagraphs}).
+*/
+function leadingLine(el) {
+	if (el.kind === "shape" && el.shape.float === void 0) return 0;
+	if (el.kind !== "paragraph" || el.paragraph.runs.length === 0) return void 0;
+	const { spacingLine, spacingLineRule } = el.paragraph.properties;
+	return spacingLineRule === "exact" && spacingLine !== void 0 && spacingLine > 0 ? spacingLine : void 0;
+}
+/** The tallest box a line is given, in ems — past it the gap is paragraph spacing. */
+var TALLEST_LINE_EM = 3;
+/** Spacing under this is the rounding of the page's own numbers, not white put there. */
+var SPACING_NOISE_PT = .25;
+/**
 * A paragraph's lines as one run of spans, joined the way the page broke them.
 *
 * A line that ends in a hyphen was broken THERE, and the break is not part of
@@ -1077,6 +2303,11 @@ function groupIntoParagraphs(lines, column, pageHeight = 0) {
 * "typical two-column docu ment incorporating tables, figures and mathemat
 * ics" — the soft hyphens dropped by the page and a space in their place.
 *
+* A dash closed up to the word before it binds that word to the one after,
+* as the hyphen does: freeculture.pdf's index breaks "167–68" after its dash,
+* and the entry came back "167– 68". A dash with a space before it stands
+* apart, and the break is a space.
+*
 * @param lines The paragraph's lines, in order.
 */
 function joinLines(lines) {
@@ -1086,12 +2317,13 @@ function joinLines(lines) {
 			const prev = out[out.length - 1];
 			const ends = prev?.text ?? "";
 			const soft = ends.endsWith(SOFT_HYPHEN);
-			const hard = HYPHENS.has(ends.slice(-1));
+			const before = ends.length > 1 ? ends.slice(-2, -1) : out[out.length - 2]?.text.slice(-1) ?? "";
+			const hard = HYPHENS.has(ends.slice(-1)) || DASHES.has(ends.slice(-1)) && /\S/u.test(before);
 			if (soft && prev) out[out.length - 1] = {
 				...prev,
 				text: ends.slice(0, -1)
 			};
-			else if (!hard) out.push({ text: " " });
+			else if (!hard && !/\s$/u.test(ends) && !/^\s/u.test(line.spans[0]?.text ?? "")) out.push(spaceAfter(prev, line.spans[0]));
 		}
 		out.push(...line.spans);
 	});
@@ -1105,11 +2337,36 @@ var HYPHENS = new Set([
 	"‐",
 	"‑"
 ]);
+/** The dashes, en and em, that belong to the words either side where closed up to them. */
+var DASHES = new Set(["–", "—"]);
 /** How many lines' worth of indent still reads as a first line, not a placement. */
 var INDENT_LINES = 3;
 /** Where in the run of line starts the column's own left edge is looked for. */
 var COLUMN_LEFT_QUANTILE = .15;
 /**
+* Whether a line opens a list item: it begins with a bullet set apart from the
+* words it marks, or with a label — "[19]", "3." — standing out left of the
+* line over it. Where the item before it ends on a line that runs to the
+* measure, or nearly, nothing else says it ended: comments.pdf's "• We explain
+* how to speculatively generate…" came back run into the item over it, its
+* bullet in the middle of a line, and its reference "[19] M. Zaleski…" into
+* "[18]". A label that does not stand out is a line of prose that begins
+* with one — a citation, a figure.
+*
+* @param prev The line over it.
+* @param line A line of the column.
+*/
+function opensItem(prev, line) {
+	if (BULLET_LEAD.test(line.text)) return true;
+	return LABEL_LEAD.test(line.text) && prev.x - line.x >= line.fontSize * HANGING_EM;
+}
+/** A bullet and the white after it, at the head of a line. */
+var BULLET_LEAD = /^[\u2022\u2023\u2043\u2219\u25aa\u25ab\u25cb\u25cf\u25e6\u25a0\u25a1]\s/u;
+/** A reference's or a step's label, "[19]" or "3.", and the white after it. */
+var LABEL_LEAD = /^(?:\[\d{1,4}\]|\d{1,3}\.)\s/u;
+/** How far, in ems, a label stands out left of the line over it to hang. */
+var HANGING_EM = 1;
+/**
 * §17.3.1.12 `w:ind` — how far a paragraph is set in from its column, and where
 * its first line begins.
 *
@@ -1145,6 +2402,69 @@ function indentOf(lines, columnLeft, alignment) {
 	};
 }
 /**
+* §17.3.1.12 — how far a line the page set in ONE piece may run on into the
+* right margin, rather than wrap.
+*
+* The line is re-set in a face this reader has, and a face wider than the
+* page's pushes the last word of a line that ran nearly to the measure onto a
+* line of its own: bug1252420.pdf's one italic line came back with
+* "Centuries" under it, and on bug1108301.pdf's sheet, fifty points tall, the
+* word it pushed down fell off the paper altogether. A line the page did not
+* break is not broken: it may run on — so far as a sixth of its measure, and
+* never past the edge of the sheet. Only a line set flush, with nothing on
+* stops: a centred one would move its centre, and a tabbed one its stops.
+*
+* @param para      The paragraph.
+* @param measure   The column it was set in.
+* @param pageWidth The sheet's width.
+* @returns How far it may run past the measure, in points; 0 where it keeps to it.
+*/
+function runOn(para, measure, pageWidth) {
+	if (measure === void 0 || para.lineCount !== 1 || para.alignment !== void 0) return 0;
+	if ((para.stops?.length ?? 0) > 0) return 0;
+	const width = measure.right - measure.left;
+	if (!(width > 0) || para.right - measure.left < width * FULL_LINE_SHARE) return 0;
+	return Math.max(0, Math.min(width * RUN_ON_SHARE, pageWidth - measure.right));
+}
+/**
+* §17.3.1.33 — the last text of a sheet, set farther below everything above it
+* than a paragraph's spacing may say, stands where the page set it.
+*
+* The spacing before a paragraph is held to a third of the sheet, so that a
+* gap misread cannot throw everything after it off the page. The last text on
+* the sheet has nothing after it to throw, and held to a third it came back
+* half way up the paper: bug1989304.pdf signs its sheet "World" at the foot
+* and we set it in the middle. Its lines are placed instead, each where the
+* page drew it.
+*
+* @param blocks The sheet's blocks, in the order they are read.
+* @param far    The paragraphs whose spacing was held, with their lines.
+* @param place  A line as the box that places it, `k` counting them.
+*/
+function setOff(blocks, far, place) {
+	const after = (a, b) => (a.band - b.band || columnOrder(a.col) - columnOrder(b.col) || b.top - a.top) > 0;
+	let at = -1;
+	blocks.forEach((b, k) => {
+		if (b.el.kind !== "paragraph" && b.el.kind !== "table") return;
+		if (at < 0 || after(b, blocks[at])) at = k;
+	});
+	const block = at >= 0 ? blocks[at] : void 0;
+	const lines = block ? far.get(block.el) : void 0;
+	if (!block || !lines) return;
+	blocks.splice(at, 1, ...lines.map((line, k) => ({
+		band: block.band,
+		col: block.col,
+		top: line.y,
+		el: place(line, k)
+	})));
+}
+/** Where the placed last text stands in the page's painting order: over it all. */
+var FAR_Z = 1e6;
+/** How far across its measure a line runs before it is at risk of wrapping when re-set. */
+var FULL_LINE_SHARE = .85;
+/** How far past its measure, as a share of it, a one-piece line may run on. */
+var RUN_ON_SHARE = 1 / 6;
+/**
 * How far, in ems, a paragraph has to be set in before it is indented rather
 * than merely started. Half an em clears the rounding a producer leaves at the
 * head of a line and is well under the smallest indent anybody sets.
@@ -1165,8 +2485,14 @@ var INDENT_EM = .5;
 * placed rather than set — a centred title's every line is short of the measure
 * and none of them ends anything.
 *
-* @param prev   The line before: where it starts, how wide it is, its face.
-* @param next   The line after — only where it starts matters.
+* A line of a right-to-left script starts at the RIGHT and ends at the left,
+* and is read the other way round: ArabicCIDTrueType.pdf sets four lines, each
+* flush right and shorter than the one before, and read as a left-to-right
+* setting every pair of them ran together as one paragraph.
+*
+* @param prev   The line before: where it starts, how wide it is, its face,
+*               and its text when it has any.
+* @param next   The line after — where it starts, and how wide it is.
 * @param column The measure both were set in, when it is known.
 * @returns Whether the first line ended a paragraph.
 */
@@ -1175,6 +2501,11 @@ function endedParagraph(prev, next, column) {
 	const width = column.right - column.left;
 	if (!(width > 0)) return false;
 	const step = Math.max(prev.fontSize, 4);
+	if (prev.text !== void 0 && next.width !== void 0 && isRightToLeft(prev.text)) {
+		const indent = prev.x + prev.width - (next.x + next.width);
+		if (indent < -step || indent > step * INDENT_LINES) return false;
+		return prev.x - column.left > width * .25;
+	}
 	const shift = next.x - prev.x;
 	if (shift < -step || shift > step * INDENT_LINES) return false;
 	return column.right - (prev.x + prev.width) > width * .25;
@@ -1242,12 +2573,13 @@ function compareOrder(a, b) {
 *          `undefined` where the document repeats nothing.
 */
 function runningFoot(pageRuns, shown, where) {
-	const feet = pageRuns.map((runs, i) => edgeLine(runs, shown[i]?.height ?? 0, where));
+	const textSize = textSizeOf(pageRuns);
+	const feet = pageRuns.map((runs, i) => edgeLine(runs.filter((r) => !tooSmallToRead(r, textSize)), shown[i]?.height ?? 0, where));
 	const found = feet.filter((f) => f !== void 0);
 	if (found.length < 2 || found.length < pageRuns.length * FOOT_SHARE) return void 0;
-	const ys = found.map((f) => f.y);
-	const mid = median(ys);
-	if (ys.some((y) => Math.abs(y - mid) > FOOT_DRIFT)) return void 0;
+	const inner = (f) => where === "foot" ? Math.max(...f.runs.map((r) => r.y)) : Math.min(...f.runs.map((r) => r.y));
+	const mid = median(found.map(inner));
+	if (found.some((f) => (where === "foot" ? inner(f) - mid : mid - inner(f)) > FOOT_DRIFT)) return;
 	const texts = found.map((f) => f.runs.map((r) => r.text).join("").trim());
 	return {
 		lift: feet.map((f) => new Set(f?.runs ?? [])),
@@ -1255,7 +2587,107 @@ function runningFoot(pageRuns, shown, where) {
 		numbered: new Set(texts).size > 1
 	};
 }
+/**
+* §17.10.1, §17.15.1.36 — the running feet of a book's two sides, where they
+* differ. A book signs its left-hand pages one way and its right-hand ones
+* another, its folio at the outer edge of each: freeculture.pdf sets "6 FREE
+* CULTURE" at the left of its even pages with the URL it is published at
+* under it, and "INTRODUCTION 5" at the right of its odd ones. Read as one
+* foot, every page was signed the way its first was.
+*
+* The side is the page number's, as Word takes it, printing the even foot on
+* the pages it numbers even; the sides differ where their numbers stand on
+* opposite halves of the page. A side's foot says what most of that side's
+* feet say, and its number: the chapter a page is in is not named alike in
+* any two chapters, and set once it would name every page after the first.
+*
+* @param foot      The running foot, a page's runs to each page.
+* @param numbering The numbers its pages print.
+* @param middle    The middle of each page, across.
+* @returns Each side's runs and the numeral they print, or `undefined` where
+*          the two sides are signed alike.
+*/
+function sidesOf(foot, numbering, middle) {
+	const bySide = [[], []];
+	foot.lift.forEach((set, i) => {
+		const number = numbering.numbers[i];
+		if (set.size === 0 || number === void 0) return;
+		const runs = [...set];
+		const numeral = runs.find((r) => r.text.trim() === number.text);
+		if (numeral === void 0) return;
+		bySide[number.value % 2].push({
+			runs,
+			numeral,
+			left: (numeral.x + numeral.endX) / 2 < (middle[i] ?? 0),
+			page: i
+		});
+	});
+	const [even, odd] = bySide;
+	if (even.length < LEAST_SIDE_FEET || odd.length < LEAST_SIDE_FEET) return void 0;
+	const leftOf = (side) => side.filter((f) => f.left).length * 2 > side.length;
+	if (leftOf(even) === leftOf(odd)) return void 0;
+	const wordsOf = (runs) => runs.flatMap((r) => r.text.split(/\s+/u)).filter((w) => w !== "");
+	const sideOf = (side) => {
+		const counts = /* @__PURE__ */ new Map();
+		for (const f of side) for (const w of new Set(wordsOf(f.runs.filter((r) => r !== f.numeral)))) counts.set(w, (counts.get(w) ?? 0) + 1);
+		const said = (r) => wordsOf([r]).every((w) => (counts.get(w) ?? 0) >= side.length * SIDE_SHARE);
+		const kept = (f) => f.runs.filter((r) => r === f.numeral || said(r));
+		const best = side.filter((f) => f.left === leftOf(side)).reduce((a, b) => kept(b).length > kept(a).length ? b : a);
+		return {
+			runs: kept(best),
+			numeral: best.numeral.text.trim(),
+			page: best.page
+		};
+	};
+	return {
+		even: sideOf(even),
+		odd: sideOf(odd)
+	};
+}
+/** How many feet each side must show before a book is taken to sign its sides apart. */
+var LEAST_SIDE_FEET = 2;
+/** How many of a side's feet, as a share of them, must say a word before its foot does. */
+var SIDE_SHARE = .6;
 /** How many of a document's pages must carry the foot before it is running. */
+/**
+* §17.6.12 — how a document's pages are numbered, read off the band that
+* prints their numbers (see ./page-numbers).
+*
+* @param band The running head or foot whose numbers change from page to page.
+* @returns The numbering, or undefined where no band numbers the pages.
+*/
+function numberingOf(band) {
+	if (!band) return void 0;
+	return pageNumberingOf(band.lift.map((set) => set.size > 0 ? bandText([...set]) : void 0));
+}
+/** A band's text on one page, with a word space wherever the page shows one. */
+function bandText(runs) {
+	return groupIntoLines(runs, false, stepsBetweenWords(runs)).map((line) => line.text).join(" ");
+}
+/**
+* The numbering a section opening at `page` states: the numerals of the
+* sequence the page is counted in, and the number the sequence starts at where
+* it starts there.
+*
+* @param numbering The document's numbering.
+* @param page      The section's first page.
+* @returns The section's `pageNumberFormat` and `pageNumberStart`, as needed.
+*/
+function numberedFrom(numbering, page) {
+	const run = numbering ? runOf(numbering.runs, page) : void 0;
+	if (!run) return {};
+	return {
+		...run.format !== "decimal" ? { pageNumberFormat: run.format } : {},
+		...run.from === page && (page > 0 || run.start !== 1) ? { pageNumberStart: run.start } : {}
+	};
+}
+/** A document of one section, numbered from its first page. */
+function numberedAs(section, numbering) {
+	return section ? {
+		...section,
+		...numberedFrom(numbering, 0)
+	} : section;
+}
 var FOOT_SHARE = .6;
 /** How far, in points, a running foot may drift from page to page. */
 var FOOT_DRIFT = 4;
@@ -1273,7 +2705,8 @@ var FOOT_DRIFT = 4;
 * its own, and a two-page document came out as four.
 */
 function edgeLine(runs, pageHeight, where) {
-	if (runs.length < 4 || pageHeight <= 0) return void 0;
+	const head = where === "head";
+	if (runs.length < (head ? HEAD_RUNS : 1) || pageHeight <= 0) return void 0;
 	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
 	const rows = rowsOf(runs, fontSize);
 	if (rows.length === 0) return void 0;
@@ -1281,9 +2714,9 @@ function edgeLine(runs, pageHeight, where) {
 	const edgeY = (row) => where === "foot" ? Math.max(...row.map((r) => r.y)) : Math.min(...row.map((r) => r.y));
 	const inside = (row) => where === "foot" ? Math.min(...row.map((r) => r.y)) : Math.max(...row.map((r) => r.y));
 	const y = edgeY(at(0));
-	if (rows.length < 4) {
-		const inked = rows.filter((row) => row.some((r) => r.text.trim() !== ""));
-		const inBand = inked.length > 0 && inked.every((row) => where === "foot" ? edgeY(row) <= pageHeight * FOOT_BAND : edgeY(row) >= pageHeight * (1 - FOOT_BAND));
+	const inked = rows.filter((row) => row.some((r) => r.text.trim() !== ""));
+	const inBand = inked.length > 0 && inked.every((row) => where === "foot" ? edgeY(row) <= pageHeight * FOOT_BAND : edgeY(row) >= pageHeight * (1 - FOOT_BAND));
+	if (rows.length < 4 && (inBand || head)) {
 		const all = inked.flat();
 		const text = all.map((r) => r.text).join("").trim();
 		return inBand && text.length > 0 && text.length <= FOOT_CHARS * inked.length ? {
@@ -1293,8 +2726,9 @@ function edgeLine(runs, pageHeight, where) {
 	}
 	let found;
 	let group = [];
-	const most = where === "foot" ? FOOT_ROWS : 1;
-	for (let i = 0; i < Math.min(most, rows.length - 2); i++) {
+	const most = head ? 1 : FOOT_ROWS;
+	const above = head ? 2 : 1;
+	for (let i = 0; i < Math.min(most, rows.length - above); i++) {
 		const row = at(i);
 		const edge = edgeY(row);
 		if (where === "foot" ? edge > pageHeight * FOOT_BAND : edge < pageHeight * (1 - FOOT_BAND)) break;
@@ -1313,6 +2747,8 @@ function edgeLine(runs, pageHeight, where) {
 var FOOT_GAP_EM = 2;
 /** How many lines a running foot may hold before it is a paragraph. */
 var FOOT_ROWS = 3;
+/** How many runs a page must hold before its first line is asked whether it is a running head. */
+var HEAD_RUNS = 4;
 /** How far up the sheet a running foot may sit. */
 var FOOT_BAND = .12;
 /** A running foot is a line, not a paragraph. */
@@ -1324,11 +2760,12 @@ var FOOT_CHARS = 90;
 * the number of the page it is drawn on, which is what lets ONE band serve
 * every page. The run is cut around it and the middle becomes the field.
 *
-* @param run The footer's run.
+* @param run     The footer's run.
+* @param numeral The page's number as this band prints it, where it is known.
 * @returns The run, or the two or three it is cut into.
 */
-function pageNumbered(run) {
-	const found = /(^|\s)(\d{1,4})(\s|$)/u.exec(run.text);
+function pageNumbered(run, numeral) {
+	const found = (numeral !== void 0 ? new RegExp(`(^|\\s)(${numeral})(\\s|$)`, "u") : /(^|\s)(\d{1,4})(\s|$)/u).exec(run.text);
 	if (!found || run.field !== void 0) return [run];
 	const at = found.index + found[1].length;
 	const number = found[2];
@@ -1384,8 +2821,9 @@ function pageNumbered(run) {
 * @param stepped  Whether the page steps between its words.
 * @param measure  The measure it was set across, for its alignment.
 * @param numbered Whether a number in it is the page's own.
+* @param numeral  That number as this band prints it, where it is known.
 */
-function footerBand(runs, stepped, measure, numbered) {
+function footerBand(runs, stepped, measure, numbered, numeral) {
 	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
 	return rowsOf(runs, fontSize).map((row) => bandLine(row, fontSize, stepped, measure)).filter((line) => line !== void 0).map(({ spans, properties }) => {
 		const el = paragraphFromRuns(spans, void 0, properties);
@@ -1394,7 +2832,7 @@ function footerBand(runs, stepped, measure, numbered) {
 			kind: "paragraph",
 			paragraph: {
 				...el.paragraph,
-				runs: numbered ? el.paragraph.runs.flatMap((run) => pageNumbered(run)) : el.paragraph.runs
+				runs: numbered ? el.paragraph.runs.flatMap((run) => pageNumbered(run, numeral)) : el.paragraph.runs
 			}
 		};
 	});
@@ -1426,9 +2864,11 @@ function bandLine(row, fontSize, stepped, measure) {
 	const lines = pieces.filter((piece) => piece.length > 0).map((piece) => lineOf(piece, y, Math.max(...piece.map((r) => r.fontSizePt || fontSize)), stepped)).filter((line) => line.text.length > 0);
 	if (lines.length === 0) return void 0;
 	if (lines.length === 1 || lines.length > BAND_REGIONS || !measure) {
-		const { alignment } = alignmentOf(lines.slice(0, 1), measure);
+		const only = lines.length === 1 ? lines[0] : void 0;
+		const width = measure ? measure.right - measure.left : 0;
+		const alignment = only !== void 0 && measure !== void 0 && measure.right - (only.x + only.width) <= width * BAND_RIGHT_SHARE && only.x - measure.left >= width * BAND_RIGHT_SHARE ? "right" : alignmentOf(lines.slice(0, 1), measure).alignment;
 		return {
-			spans: lines.flatMap((line, i) => i === 0 ? line.spans : [{ text: " " }, ...line.spans]),
+			spans: lines.flatMap((line, i) => i === 0 ? line.spans : [spaceAfter(lines[i - 1].spans.at(-1), line.spans[0]), ...line.spans]),
 			properties: alignment ? { alignment } : {}
 		};
 	}
@@ -1550,9 +2990,11 @@ function proseColumns(runs, gutters, edges) {
 		for (const x of xs) most = Math.max(most, xs.filter((y) => Math.abs(y - x) <= FLUSH_PT).length);
 		return most;
 	};
-	return edgesIn.every((lines) => {
+	return edgesIn.every((lines, i) => {
 		if (lines.length < MIN_PROSE_LINES) return false;
-		return agreeing(lines.map((l) => l.right)) <= agreeing(lines.map((l) => l.left));
+		const [lo, hi] = regions[i];
+		const full = lines.filter((l) => l.right - l.left >= (hi - lo) * FULL_LINE_SHARE).length;
+		return agreeing(lines.map((l) => l.right)) <= agreeing(lines.map((l) => l.left)) || full >= lines.length * FILLED_SHARE;
 	});
 }
 /**
@@ -1586,8 +3028,8 @@ function strayMarks(vectors, runs) {
 	const readable = runs.filter((r) => r.text.trim() !== "" && !r.text.includes("�"));
 	for (const v of glyphs) {
 		const mid = (v.minY + v.maxY) / 2;
-		const size = v.maxY - v.minY || 10;
-		const words = readable.filter((r) => Math.abs(r.y - mid) <= size);
+		const words = readable.filter((r) => Math.abs(r.y - mid) <= (r.fontSizePt || 10));
+		const size = words.length > 0 ? median(words.map((r) => r.fontSizePt || 10)) : v.maxY - v.minY || 10;
 		const before = words.some((r) => r.endX <= v.minX + size);
 		const after = words.some((r) => r.x >= v.maxX - size);
 		if (!before && !after) continue;
@@ -1595,6 +3037,68 @@ function strayMarks(vectors, runs) {
 	}
 	return out;
 }
+/**
+* §9.10.2 — the runs of a line with each glyph the file names no character for
+* read off the shape it draws (see {@link punctuationOf}), where it is one of
+* the stray marks inside a readable line.
+*
+* @param runs   The page's runs.
+* @param strays The drawn glyphs that stand inside lines of readable text.
+* @returns The runs, with every mark that could be read written as text.
+*/
+function readDrawnMarks(runs, strays) {
+	if (strays.size === 0) return [...runs];
+	const marks = [...strays];
+	return runs.map((run) => {
+		if (!run.text.includes("�") || run.text.replaceAll("�", "").trim() !== "") return run;
+		const size = run.fontSizePt || 10;
+		const mark = marks.find((v) => {
+			const x = (v.minX + v.maxX) / 2;
+			return x >= run.x - .5 && x <= run.endX + .5 && Math.abs((v.minY + v.maxY) / 2 - run.y) <= size;
+		});
+		const read = mark ? punctuationOf(mark, run.y, size) : void 0;
+		return read === void 0 ? run : {
+			...run,
+			text: run.text.replaceAll("�", read)
+		};
+	});
+}
+/**
+* §9.6.6 — the glyphs a page draws for want of characters, gathered into the
+* WORDS they stand in: a traced glyph that stands against the one before it,
+* on its line and in its colour, is drawn as one shape with it.
+*
+* Every mark kept apart is a shape of its own in the document, anchored to
+* the page — and a paper set in a subset whose glyphs name nothing is nothing
+* but such marks: TAMReview.pdf came back as forty-two thousand shapes, a
+* package no reader would open in under three minutes. The picture is the
+* same either way.
+*
+* @param vectors The page's painted paths, in painting order.
+* @returns The same paths, each run of traced glyphs made one.
+*/
+function drawnWords(vectors) {
+	const out = [];
+	for (const v of vectors) {
+		const last = out[out.length - 1];
+		const size = v.maxY - v.minY;
+		if (v.glyph === true && last?.glyph === true && last.fillHex === v.fillHex && last.strokeHex === v.strokeHex && last.alpha === v.alpha && Math.min(last.maxY, v.maxY) - Math.max(last.minY, v.minY) > Math.min(size, last.maxY - last.minY) * .3 && v.minX >= last.minX && v.minX - last.maxX <= Math.max(size, last.maxY - last.minY) * WORD_GAP_EM) {
+			out[out.length - 1] = {
+				...last,
+				segs: [...last.segs, ...v.segs],
+				minX: Math.min(last.minX, v.minX),
+				minY: Math.min(last.minY, v.minY),
+				maxX: Math.max(last.maxX, v.maxX),
+				maxY: Math.max(last.maxY, v.maxY)
+			};
+			continue;
+		}
+		out.push(v);
+	}
+	return out;
+}
+/** How far apart, in heights of the taller glyph, two drawn glyphs may stand and be one word. */
+var WORD_GAP_EM = .6;
 /** How few drawn glyphs a line may hold before they are its text, not marks in it. */
 var MOST_STRAY_MARKS = 2;
 /** …and how many readable runs must stand on that line for them to be strays. */
@@ -1639,41 +3143,173 @@ function tabbedRows(paras, measure) {
 		const rows = paras.slice(i, to);
 		const bounds = stops.map((_, k) => Math.min(...rows.map((r) => r.stops[k])));
 		const width = measure.right - measure.left;
-		const edges = [
-			0,
-			...bounds,
-			width
-		];
-		out.set(i, {
-			kind: "table",
-			table: {
-				properties: {
-					defaultCellMargins: {
-						left: pt(0),
-						right: pt(0)
-					},
-					layout: "fixed"
-				},
-				grid: edges.slice(0, -1).map((from, k) => pt(Math.max(edges[k + 1] - from, 1))),
-				rows: rows.map((row, r) => {
-					const prev = rows[r - 1];
-					const pitch = prev ? prev.top - row.top - row.fontSize * 1.2 : 0;
-					const opening = r === 0 ? row.spacingBefore : pitch > row.fontSize * .3 ? pitch : void 0;
-					return {
-						properties: {},
-						cells: splitAtTabs(row.spans).map((cell) => ({
-							properties: {},
-							content: [paragraphFromRuns(cell, void 0, opening !== void 0 ? { spacingBefore: pt(opening) } : {})]
-						}))
-					};
-				})
+		const inks = [0, ...bounds].map((_, k) => {
+			const cells = rows.map((r) => r.pieces?.[k]);
+			if (cells.some((c) => c === void 0 || !Number.isFinite(c.from))) return void 0;
+			return {
+				from: Math.min(...cells.map((c) => c.from)),
+				to: Math.max(...cells.map((c) => c.to))
+			};
+		});
+		const above = i > 0 && !out.has(i - 1) ? paras[i - 1] : void 0;
+		const close = above !== void 0 && above.top - rows[0].top <= rows[0].lineHeight * HEADING_LINES;
+		const columnsFor = (heading) => {
+			const flush = inks.map((ink, k) => {
+				if (k === 0 || ink === void 0) return false;
+				const tos = rows.map((r) => r.pieces[k].to);
+				const froms = rows.map((r) => r.pieces[k].from);
+				const even = Math.max(...tos) - Math.min(...tos);
+				if (even > FLUSH_SLACK_PT) return false;
+				if (Math.max(...froms) - Math.min(...froms) > even + FLUSH_SLACK_PT) return true;
+				const head = heading?.over[k];
+				return head !== void 0 && Math.abs(head.to - Math.max(...tos)) <= FLUSH_SLACK_PT && Math.min(...froms) - head.from > FLUSH_SLACK_PT;
+			});
+			const holds = inks.map((ink, k) => {
+				const head = heading?.over[k];
+				return ink !== void 0 && head !== void 0 ? {
+					from: Math.min(ink.from, head.from),
+					to: Math.max(ink.to, head.to)
+				} : ink;
+			});
+			const edges = [
+				0,
+				...bounds,
+				width
+			];
+			for (let k = 1; k < bounds.length + 1; k++) {
+				const before = holds[k - 1];
+				const own = holds[k];
+				if (!flush[k] || before === void 0 || own === void 0) continue;
+				const mid = (before.to + own.from) / 2;
+				if (mid > edges[k - 1] && mid < own.from) edges[k] = mid;
 			}
+			const lead = holds[0]?.from ?? 0;
+			if (lead > FLUSH_SLACK_PT && lead < edges[1]) edges[0] = lead;
+			const flushRight = flush.map((right, k) => right ? Math.max(0, edges[k + 1] - inks[k].to) : void 0);
+			return {
+				holds,
+				edges,
+				flushRight,
+				held: heading?.over.every((head, k) => head === void 0 || edges[k + 1] - edges[k] - (flushRight[k] ?? 0) >= head.to - head.from - FLUSH_SLACK_PT) ?? true
+			};
+		};
+		const offered = above && close ? headingOver(above, inks) : void 0;
+		const withHeading = offered ? columnsFor(offered) : void 0;
+		const heading = withHeading?.held === true ? offered : void 0;
+		const { holds, edges, flushRight } = heading && withHeading ? withHeading : columnsFor(void 0);
+		const grid = edges.slice(0, -1).map((from, k) => pt(Math.max(edges[k + 1] - from, 1)));
+		const tableRows = above && heading ? [{
+			...above,
+			spans: heading.spans
+		}, ...rows] : rows;
+		const table = {
+			properties: {
+				defaultCellMargins: {
+					left: pt(0),
+					right: pt(0)
+				},
+				layout: "fixed",
+				widthType: "dxa",
+				widthPt: pt(grid.reduce((sum, w) => sum + w, 0)),
+				...edges[0] > 0 ? { indentPt: pt(edges[0]) } : {}
+			},
+			grid,
+			rows: tableRows.map((row, r) => {
+				const prev = tableRows[r - 1];
+				const pitch = prev ? prev.top - row.top - (1 - BASELINE_AT) * prev.lineHeight - BASELINE_AT * row.lineHeight : 0;
+				const opening = r === 0 ? row.spacingBefore : pitch > 0 ? pitch : void 0;
+				return {
+					properties: {},
+					cells: splitAtTabs(row.spans).map((cell, k) => {
+						const inset = flushRight[k];
+						const own = grid[k];
+						return {
+							properties: own !== void 0 ? { width: own } : {},
+							content: [paragraphFromRuns(cell, void 0, {
+								...opening !== void 0 ? { spacingBefore: pt(opening) } : {},
+								spacingLine: pt(row.lineHeight),
+								spacingLineRule: "exact",
+								...inset !== void 0 ? {
+									alignment: "right",
+									indentRight: pt(inset)
+								} : {}
+							})]
+						};
+					})
+				};
+			})
+		};
+		const ink = holds.filter((h) => h !== void 0);
+		tableReads.set(table, {
+			rows: tableRows.map((row) => ({
+				top: row.top,
+				lineHeight: row.lineHeight
+			})),
+			from: measure.left + Math.min(...ink.map((h) => h.from)),
+			to: measure.left + Math.max(...ink.map((h) => h.to)),
+			left: measure.left
+		});
+		out.set(heading ? i - 1 : i, {
+			kind: "table",
+			table
 		});
+		if (heading) out.set(i, null);
 		for (let k = i + 1; k < to; k++) out.set(k, null);
 		i = to;
 	}
 	return out;
 }
+/**
+* A line's cells as a heading row over a table's columns: each cell over the
+* column whose figures it overlaps most, left to right, and an empty cell over
+* a column it leaves bare. `undefined` where the line is no such row.
+*
+* @param line The line above the table, with the cells it was set out in.
+* @param inks The ink of each of the table's columns.
+* @returns The line's spans with a tab between every two columns, and the ink
+*          of the heading over each column.
+*/
+function headingOver(line, inks) {
+	const cells = splitAtTabs(line.spans);
+	const pieces = line.pieces ?? [];
+	if (cells.length < 2 || pieces.length !== cells.length || cells.length > inks.length || cells.length * 2 < inks.length) return;
+	const columns = [];
+	for (const piece of pieces) {
+		let best = -1;
+		let most = 0;
+		inks.forEach((ink, k) => {
+			if (ink === void 0) return;
+			const overlap = Math.min(piece.to, ink.to) - Math.max(piece.from, ink.from);
+			if (overlap > most) {
+				most = overlap;
+				best = k;
+			}
+		});
+		if (best <= (columns[columns.length - 1] ?? -1)) return void 0;
+		columns.push(best);
+	}
+	return {
+		spans: inks.flatMap((_, k) => {
+			const own = columns.indexOf(k);
+			return [...k > 0 ? [{ text: "	" }] : [], ...own >= 0 ? cells[own] : []];
+		}),
+		over: inks.map((_, k) => {
+			const own = columns.indexOf(k);
+			return own >= 0 ? pieces[own] : void 0;
+		})
+	};
+}
+/**
+* Where a table read off the page stood on it (see `tabbedRows`): each row's
+* baseline and the box its line stands in, top to bottom, and how far across
+* the page its words reach — which is what a rule drawn between two of its
+* rows is measured against (see `ruleBorders`).
+*/
+var tableReads = /* @__PURE__ */ new WeakMap();
+/** How many of its rows' lines a heading may stand over a table and head it. */
+var HEADING_LINES = 3;
+/** How far apart the ends of a column's cells may stand and still be flush. */
+var FLUSH_SLACK_PT = 2;
 /** How many stops a line must stand on before a run of them is a table. */
 var LEAST_TABLE_STOPS = 2;
 /**
@@ -1700,20 +3336,47 @@ function splitAtTabs(spans) {
 * the rule introduces; where nothing follows closely enough, the block above
 * takes it as a bottom one.
 *
+* A rule drawn down one column is a border of a block in that column, and one
+* drawn across the columns of a block across them: comments.pdf rules off
+* Figure 9's caption in the right column, and taken by the nearest line under
+* it on the page, the rule came back over "Every time the trace recorder
+* emits…" in the left column, and none over the caption.
+*
 * @param vectors The page's painted paths.
 * @param blocks  The blocks read off the page so far, which the rule joins.
 * @param width   The page's width, which a rule is long relative to.
+* @param colOf   The column an x across the page stands in.
 * @returns The rules that became borders, and so must not be drawn again.
 */
-function ruleBorders(vectors, blocks, width) {
+function ruleBorders(vectors, blocks, width, colOf = () => 0) {
 	const given = /* @__PURE__ */ new Set();
 	const paragraphs = blocks.filter((b) => b.el.kind === "paragraph");
-	if (paragraphs.length === 0) return given;
-	for (const v of vectors) {
-		if (!separatorRule(v, width)) continue;
+	const tables = blocks.filter((b) => b.el.kind === "table");
+	if (paragraphs.length === 0 && tables.length === 0) return given;
+	for (const band of collinear(vectors.filter((v) => flatBar(v)))) {
+		const v = band.pieces[0];
+		if (band.to - band.from < width * RULE_SHARE) continue;
 		const y = (v.minY + v.maxY) / 2;
-		const below = paragraphs.filter((b) => b.top < y).sort((a, b) => b.top - a.top)[0];
-		const above = paragraphs.filter((b) => b.top >= y).sort((a, b) => a.top - b.top)[0];
+		const border = {
+			style: "single",
+			width: pt(Math.max(v.lineWidth ?? v.maxY - v.minY, RULE_MIN_PT)),
+			colorHex: v.strokeHex ?? v.fillHex ?? "000000"
+		};
+		const seat = seatOf(tables, band, y);
+		if (seat !== void 0 && seat.block.el.kind === "table") {
+			seat.block.el = {
+				kind: "table",
+				table: ruledRow(seat.block.el.table, seat.row, border, band)
+			};
+			for (const piece of band.pieces) given.add(piece);
+			continue;
+		}
+		if (paragraphs.length === 0) continue;
+		const first = colOf(band.from + RULE_INSET_PT);
+		const col = first === colOf(band.to - RULE_INSET_PT) ? first : SPANNING_COLUMN;
+		const own = paragraphs.filter((b) => b.col === col);
+		const below = own.filter((b) => b.top < y).sort((a, b) => b.top - a.top)[0];
+		const above = own.filter((b) => b.top >= y).sort((a, b) => a.top - b.top)[0];
 		const side = below !== void 0 && y - below.top <= RULE_REACH_PT ? {
 			block: below,
 			edge: "top"
@@ -1722,50 +3385,420 @@ function ruleBorders(vectors, blocks, width) {
 			edge: "bottom"
 		} : void 0;
 		if (!side || side.block.el.kind !== "paragraph") continue;
-		const border = {
-			style: "single",
-			width: pt(Math.max(v.lineWidth ?? v.maxY - v.minY, RULE_MIN_PT)),
-			colorHex: v.strokeHex ?? v.fillHex ?? "000000"
-		};
 		const { paragraph } = side.block.el;
+		const before = paragraph.properties.spacingBefore;
+		const room = side.edge === "top" && before !== void 0 ? { spacingBefore: pt(Math.max(0, before - border.width)) } : {};
 		side.block.el = {
 			kind: "paragraph",
 			paragraph: {
 				...paragraph,
 				properties: {
 					...paragraph.properties,
+					...room,
 					borders: {
 						...paragraph.properties.borders,
-						[side.edge]: border
+						[side.edge]: border,
+						...side.edge === "top" ? { insideH: border } : {}
 					}
 				}
 			}
 		};
-		given.add(v);
+		for (const piece of band.pieces) given.add(piece);
 	}
 	return given;
 }
+/**
+* §17.3.1.33 — the white a block across the page leaves over the columns
+* under it, as the space after its last paragraph. Each column reads its own
+* lines from nothing (see `addColumn`), so the white went nowhere, and
+* comments.pdf's Figure 13 caption came down onto the text under it. As the
+* space before each column's first paragraph Word and LibreOffice drop it at
+* the head of the second column, which then stands higher than the first.
+*
+* @param blocks A page's blocks, as read; each block across the page with
+*               columns under it is given its white.
+*/
+function spaceUnderSpans(blocks) {
+	for (const span of blocks) {
+		if (span.col !== SPANNING_COLUMN || span.foot === void 0 || span.el.kind !== "paragraph") continue;
+		const next = blocks.filter((b) => b.col === SPANNING_COLUMN && b.top < span.top).reduce((high, b) => Math.max(high, b.top), -Infinity);
+		const heads = blocks.filter((b) => b.col !== SPANNING_COLUMN && b.top < span.top && b.top > next).map((b) => b.top + BASELINE_AT * (leadingLine(b.el) ?? 0));
+		if (heads.length === 0) continue;
+		const white = span.foot - Math.max(...heads);
+		if (white <= SPACING_NOISE_PT) continue;
+		const { paragraph } = span.el;
+		span.el = {
+			kind: "paragraph",
+			paragraph: {
+				...paragraph,
+				properties: {
+					...paragraph.properties,
+					spacingAfter: pt(white)
+				}
+			}
+		};
+	}
+}
+/**
+* Where each column of a page's last stretch of columns — under the last block
+* across the page — ends: the foot of its lowest paragraph, up the page.
+*
+* @param blocks The page's blocks.
+* @returns The feet, one a column, or nothing where fewer than two columns hold text.
+*/
+function lastColumnFeet(blocks) {
+	const across = blocks.filter((b) => b.col === SPANNING_COLUMN).reduce((low, b) => Math.min(low, b.top), Infinity);
+	const feet = /* @__PURE__ */ new Map();
+	for (const b of blocks) {
+		if (b.col === SPANNING_COLUMN || b.foot === void 0 || b.top >= across) continue;
+		feet.set(b.col, Math.min(feet.get(b.col) ?? Infinity, b.foot));
+	}
+	return feet.size >= 2 ? [...feet.values()] : void 0;
+}
+/**
+* Whether a page's last columns are set BALANCED: they end within a couple of
+* lines of each other, and well above the foot of the text.
+*
+* @param feet  Where each column ends, up the page.
+* @param floor Where the text ends at its lowest, up the page.
+* @param size  The body's type size.
+*/
+function balancedEnd(feet, floor, size) {
+	const line = size * NATURAL_LINE_EM;
+	const deepest = Math.min(...feet);
+	return Math.max(...feet) - deepest <= line * BALANCED_LINES && deepest - floor >= line * SHORT_LINES;
+}
+/** How many lines apart the ends of balanced columns may stand. */
+var BALANCED_LINES = 4;
+/** How many lines short of the foot a page's columns stop to be set short. */
+var SHORT_LINES = 3;
+/** Whether an element is a drawing anchored to the page, which takes no room in the flow. */
+function floating(el) {
+	return el?.kind === "shape" && el.shape.float !== void 0 || el?.kind === "image" && el.image.float !== void 0;
+}
+/**
+* A table with a rule over one of its rows: the top edge of each of the row's
+* cells (§17.4.39), the rule taking its room out of the white the row keeps
+* over it as a paragraph's does (see `ruleBorders`).
+*/
+function ruledRow(table, at, border, rule) {
+	const ruled = {
+		...table,
+		rows: table.rows.map((row, r) => r !== at ? row : {
+			...row,
+			cells: row.cells.map((cell) => ({
+				properties: {
+					...cell.properties,
+					borders: {
+						...cell.properties.borders,
+						top: border
+					}
+				},
+				content: cell.content.map((block, k) => {
+					const before = block.kind === "paragraph" && k === 0 ? block.paragraph.properties.spacingBefore : void 0;
+					return before === void 0 || block.kind !== "paragraph" ? block : {
+						...block,
+						paragraph: {
+							...block.paragraph,
+							properties: {
+								...block.paragraph.properties,
+								spacingBefore: pt(Math.max(0, before - border.width))
+							}
+						}
+					};
+				})
+			}))
+		})
+	};
+	const read = tableReads.get(table);
+	if (!read) return ruled;
+	const fitted = fittedToRule(ruled, read, rule);
+	tableReads.set(fitted, read);
+	return fitted;
+}
+/**
+* §17.4.63 — a table as wide as the rule drawn across it.
+*
+* A table read off a page begins where its words do, and its last column runs
+* to the measure; a rule drawn across it is its own edge, standing a little
+* past its words on either side. comments.pdf rules Figure 13 from six points
+* left of its names to six right of its last figures, and written as the
+* edge of the row under its headings, the rule ran on twenty points past the
+* table, to the margin. The table now spans what the rule does: its first
+* column reaches out to where the rule begins, its words held where they
+* stood, and its last column ends where the rule ends.
+*
+* Only a rule that reaches past the words on both sides is the table's edge.
+*
+* @param table The table, its rule written as a row's border.
+* @param read  Where it stood on the page.
+* @param rule  The rule, across the page.
+*/
+function fittedToRule(table, read, rule) {
+	const last = table.grid.length - 1;
+	if (last < 0 || rule.from > read.from || rule.to < read.to) return table;
+	const left = read.left + (table.properties.indentPt ?? 0);
+	const right = left + table.grid.reduce((sum, w) => sum + w, 0);
+	const out = left - rule.from;
+	const inward = right - rule.to;
+	if (Math.abs(out) < FIT_NOISE_PT && Math.abs(inward) < FIT_NOISE_PT) return table;
+	const grid = table.grid.map((w, k) => {
+		const wider = k === 0 ? w + out : w;
+		return pt(Math.max(1, k === last ? wider - inward : wider));
+	});
+	/** A cell's paragraphs, its words held where the page set them. */
+	const held = (content, k) => content.map((block) => {
+		if (block.kind !== "paragraph") return block;
+		const { indentLeft, indentRight } = block.paragraph.properties;
+		const properties = {
+			...block.paragraph.properties,
+			...k === 0 && Math.abs(out) >= FIT_NOISE_PT ? { indentLeft: pt(Math.max(0, (indentLeft ?? 0) + out)) } : {},
+			...k === last && Math.abs(inward) >= FIT_NOISE_PT && indentRight !== void 0 ? { indentRight: pt(Math.max(0, indentRight - inward)) } : {}
+		};
+		return {
+			...block,
+			paragraph: {
+				...block.paragraph,
+				properties
+			}
+		};
+	});
+	return {
+		...table,
+		properties: {
+			...table.properties,
+			widthPt: pt(grid.reduce((sum, w) => sum + w, 0)),
+			indentPt: pt((table.properties.indentPt ?? 0) - out)
+		},
+		grid,
+		rows: table.rows.map((row) => ({
+			...row,
+			cells: row.cells.map((cell, k) => k !== 0 && k !== last ? cell : {
+				properties: {
+					...cell.properties,
+					width: grid[k]
+				},
+				content: held(cell.content, k)
+			})
+		}))
+	};
+}
+/** A fit smaller than this moves nothing a reader sees. */
+var FIT_NOISE_PT = .5;
+/**
+* The table row a rule is drawn on the top edge of: a row after the first,
+* the rule standing where its line's box meets the box of the line above it,
+* and reaching across the table's words. `undefined` where the rule is no
+* such row's.
+*
+* @param tables The page's tables, as blocks.
+* @param band   The rule, across the page.
+* @param y      Its height on the page.
+*/
+function seatOf(tables, band, y) {
+	for (const block of tables) {
+		const read = block.el.kind === "table" ? tableReads.get(block.el.table) : void 0;
+		if (!read) continue;
+		if (band.from > read.from + RULE_SEAT_PT || band.to < read.to - RULE_SEAT_PT) continue;
+		for (let r = 1; r < read.rows.length; r++) {
+			const row = read.rows[r];
+			const prev = read.rows[r - 1];
+			const edge = row.top + BASELINE_AT * row.lineHeight;
+			const over = prev.top - (1 - BASELINE_AT) * prev.lineHeight;
+			if (y > row.top && y < prev.top && y - edge <= RULE_SEAT_PT && over - y <= RULE_SEAT_PT) return {
+				block,
+				row: r
+			};
+		}
+	}
+}
+/**
+* How far off the edge between two rows a rule may stand and still be that
+* edge — a point or two either way, which the white a row keeps does not
+* notice.
+*/
+var RULE_SEAT_PT = 3;
 /** How far from a paragraph a rule may stand and still belong to it. */
 var RULE_REACH_PT = 14;
+/** How far in from its ends a rule is looked at to say which column it stands in. */
+var RULE_INSET_PT = 2;
+/**
+* §17.3.1.31 — the paragraphs a page sets on a box it fills, each given the box
+* as its shading.
+*
+* canvas.pdf heads each section with its name in white on a dark bar, and each
+* table with "Attributes" or "Methods" on a grey one. Drawn where the page drew
+* them, the bars stayed on the sheet while the words were set again: headings
+* slid off their bars, white on white, and the bars struck through the tables
+* under them. As a paragraph's shading the bar goes where the paragraph goes.
+*
+* A paragraph's shading fills its line's box across its indents, and the box
+* a page draws stands out over and under the line: that is a border of its
+* own colour over the line, and one under it (§17.3.1.24), as thick as the box
+* stands out. The room the borders take comes out of the white the page left
+* over the paragraph and under it — and where there is none to take, the box
+* reaches no further than the line's box does.
+*
+* A box is a paragraph's only where it holds the paragraph's one line and no
+* other, stands out by less than a line over it and under it, and is no wider
+* than the column: a panel drawn behind a block of text is drawn where the
+* page drew it. And only a box of a colour: white is the paper's, and
+* bug1815476.pdf backs a whole form with white boxes as wide as the sheet —
+* taken for shading, "A N E X O" stood off centre by as much as the box
+* reached past the column.
+*
+* @param paras   A region's paragraphs, top to bottom.
+* @param boxes   The page's filled boxes (see {@link solidBox}).
+* @param measure The column the paragraphs are set in.
+* @returns The paragraphs, and how far under the last one its box reaches.
+*/
+function onBoxes(paras, boxes, measure) {
+	const out = paras.map((para) => ({ ...para }));
+	if (boxes.length === 0 || measure === void 0) return {
+		paras: out,
+		under: 0
+	};
+	let under = 0;
+	out.forEach((para, k) => {
+		if (para.lineCount !== 1 || (para.stops?.length ?? 0) > 0) return;
+		const lineTop = para.top + BASELINE_AT * para.lineHeight;
+		const lineFoot = para.bottom - (1 - BASELINE_AT) * para.lineHeight;
+		const reach = para.fontSize * BAR_REACH_EM;
+		const box = boxes.find((b) => b.minX >= measure.left - reach && b.maxX <= measure.right + reach && b.minX <= para.left + FLUSH_PT && b.maxX >= para.right - FLUSH_PT && b.maxY >= lineTop - FLUSH_PT && b.maxY - lineTop <= para.lineHeight && b.minY <= lineFoot + FLUSH_PT && lineFoot - b.minY <= para.lineHeight && paras.every((o, n) => n === k || o.bottom > b.maxY || o.top < b.minY));
+		if (box === void 0) return;
+		const next = out[k + 1];
+		const over = Math.min(Math.max(0, box.maxY - lineTop), para.spacingBefore ?? 0, MOST_BORDER_PT);
+		const below = Math.min(Math.max(0, lineFoot - box.minY), next !== void 0 ? next.spacingBefore ?? 0 : Infinity, MOST_BORDER_PT);
+		const inset = para.alignment === void 0 ? Math.max(0, para.left - box.minX) : 0;
+		const shade = {
+			box,
+			over: over > SPACING_NOISE_PT ? over : 0,
+			under: below > SPACING_NOISE_PT ? below : 0,
+			indentLeft: box.minX - measure.left,
+			indentFirstLine: inset,
+			indentRight: measure.right - box.maxX
+		};
+		para.shade = shade;
+		if (para.spacingBefore !== void 0) para.spacingBefore -= shade.over;
+		if (next?.spacingBefore !== void 0) next.spacingBefore -= shade.under;
+		if (k === out.length - 1) under = shade.under;
+	});
+	return {
+		paras: out,
+		under
+	};
+}
+/**
+* The paragraph properties a {@link Shade} sets: the box's colour behind the
+* line, a border of it as thick as the box stands out over the line and under
+* it, and the indents that put its edges where the page drew them.
+*/
+function shadeProperties(shade) {
+	const colorHex = shade.box.fillHex ?? "FFFFFF";
+	const edge = (width) => width > 0 ? {
+		style: "single",
+		width: pt(width),
+		colorHex
+	} : void 0;
+	const top = edge(shade.over);
+	const bottom = edge(shade.under);
+	const noted = (value) => Math.abs(value) > SPACING_NOISE_PT ? pt(value) : void 0;
+	const indentLeft = noted(shade.indentLeft);
+	const indentFirstLine = noted(shade.indentFirstLine);
+	const indentRight = noted(shade.indentRight);
+	return {
+		shading: { colorHex },
+		...top || bottom ? { borders: {
+			...top ? { top } : {},
+			...bottom ? { bottom } : {}
+		} } : {},
+		...indentLeft !== void 0 ? { indentLeft } : {},
+		...indentFirstLine !== void 0 ? { indentFirstLine } : {},
+		...indentRight !== void 0 ? { indentRight } : {}
+	};
+}
+/**
+* §17.3.4 — the thickest border a single line may be, twelve points: a box
+* standing out further than that from its line is not a bar behind it.
+*/
+var MOST_BORDER_PT = 12;
+/** How far past its column, in ems of its line, a bar behind a line may reach. */
+var BAR_REACH_EM = 2;
+/** How light, in each of its channels, a fill is the paper's rather than a colour. */
+var PAPER_LEVEL = 250;
+/**
+* Whether a painted path is a box filled in one opaque colour, square to the
+* page: a bar a heading is set on, a panel. A shape, a gradient, a stroked
+* frame or a glyph is none, and nor is a box of the paper's own white.
+*
+* @param v The painted path.
+*/
+function solidBox(v) {
+	if (v.fillHex === void 0 || v.gradient !== void 0 || v.glyph === true) return false;
+	if ([
+		0,
+		2,
+		4
+	].map((k) => parseInt(v.fillHex.slice(k, k + 2), 16)).every((c) => c >= PAPER_LEVEL)) return false;
+	if ((v.alpha ?? 1) < 1 || v.darkens === true) return false;
+	if (v.strokeHex !== void 0 && v.strokeHex !== v.fillHex) return false;
+	if (v.segs.filter((s) => s.op === "move").length !== 1) return false;
+	const points = v.segs.filter((s) => s.op !== "close");
+	if (points.length < 4 || points.length > 5) return false;
+	const at = (value, edge) => Math.abs(value - edge) <= FLUSH_PT;
+	return points.every((s) => s.op !== "cubic" && (at(s.x, v.minX) || at(s.x, v.maxX)) && (at(s.y, v.minY) || at(s.y, v.maxY)));
+}
 /** The thinnest a border may be drawn and still be seen. */
 var RULE_MIN_PT = .5;
 /**
-* Whether a painted path is a RULE — a line drawn to separate one block from
-* the next, rather than a piece of the page's artwork.
-*
-* Flat and long: a hairline the width of a column under a table's headings, or
-* the line a total is written over. Everything else — boxes, panels, drawings —
-* keeps the place on the page it was drawn at.
-*
-* @param v     The painted path.
-* @param width The page's width, which the rule is long RELATIVE to.
-* @returns Whether it separates blocks rather than drawing something.
+* Whether a painted path is flat and thin enough to be a piece of a RULE — a
+* line drawn to separate one block from the next, rather than a piece of the
+* page's artwork. How LONG the rule is is a question for the whole of it (see
+* {@link collinear}): a hairline the width of a column under a table's
+* headings, or the line a total is written over. Everything else — boxes,
+* panels, drawings — keeps the place on the page it was drawn at.
+*
+* @param v The painted path.
+* @returns Whether it could be a rule, or a piece of one.
 */
-function separatorRule(v, width) {
+function flatBar(v) {
 	const w = v.maxX - v.minX;
 	const h = v.maxY - v.minY;
-	return h <= RULE_THICK_PT && w >= width * RULE_SHARE && w > h * RULE_RATIO;
+	return h <= RULE_THICK_PT && w > h * RULE_RATIO;
+}
+/**
+* The flat bars of a page gathered into the rules they draw: pieces on one
+* baseline, end to end, are one rule from the first's left edge to the last's
+* right.
+*
+* @param bars The page's flat bars.
+* @returns One band per rule, with the pieces it was drawn in.
+*/
+function collinear(bars) {
+	const out = [];
+	for (const bar of [...bars].sort((a, b) => b.maxY - a.maxY || a.minX - b.minX)) {
+		const y = (bar.minY + bar.maxY) / 2;
+		const band = out.find((b) => Math.abs((b.pieces[0].minY + b.pieces[0].maxY) / 2 - y) <= RULE_SAME_LINE_PT && bar.minX <= b.to + RULE_JOIN_PT && (bar.strokeHex ?? bar.fillHex) === (b.pieces[0].strokeHex ?? b.pieces[0].fillHex));
+		if (band) {
+			band.from = Math.min(band.from, bar.minX);
+			band.to = Math.max(band.to, bar.maxX);
+			band.pieces.push(bar);
+		} else out.push({
+			from: bar.minX,
+			to: bar.maxX,
+			pieces: [bar]
+		});
+	}
+	return out;
 }
+/** How far apart two bars' baselines may be and still be one rule. */
+var RULE_SAME_LINE_PT = 1.5;
+/**
+* …and how wide a gap between two pieces of it the page may leave: an invoice
+* draws the rule under its item row cell by cell and skips the thirteen points
+* of gutter between two of them.
+*/
+var RULE_JOIN_PT = 18;
 /** How thick a mark may be and still be a rule. */
 var RULE_THICK_PT = 2;
 /** How much of the sheet it must run across. */
@@ -1776,6 +3809,8 @@ var RULE_RATIO = 20;
 var FLUSH_PT = 1;
 /** And how many lines it takes before a region is a column at all. */
 var MIN_PROSE_LINES = 6;
+/** How many of a column's lines fill it when it is justified prose. */
+var FILLED_SHARE = .5;
 /**
 * §17.4.38 — the page's rows as the TABLE they are.
 *
@@ -1967,4 +4002,4 @@ var TABLE_ALIGNED_SHARE = .6;
 */
 var TABLE_CELL_FILL = .65;
 //#endregion
-export { endedParagraph, reconstructByLayout };
+export { FOOTER_PART, HEADER_PART, endedParagraph, footerBand, numberedFrom, numberingOf, pageTextEdges, reconstructByLayout, runningFoot, stepsBetweenWords };