reamkit 1.28.0 → 1.30.0

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

@@ -3,12 +3,15 @@ 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 { 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 { BASELINE_AT, CARRIER_LINE_PT, GUESSED_MARGIN, NATURAL_LINE_EM, buildFlowDoc, dedupeLosses, imageBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock, spaceAfter, textSizeOf, tooSmallToRead, withMeasuredMargins } from "./flow-build.js";
 import { collectPageImages } from "./images.js";
 import { markDrawnRules } from "./text-rules.js";
+import { regionsOf } from "./regions.js";
+import { punctuationOf } from "./glyph-shapes.js";
 import { matrixBlocks } from "./math-rows.js";
 //#region src/pdf-reader/layout.ts
 /** The relationships the reconstruction files its running head and foot under. */
@@ -35,7 +38,11 @@ function reconstructByLayout(file, mode = "flow") {
 	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 textSize = textSizeOf(allRuns);
+	const stamp = (r) => mode !== "positional" && (r.annotation === true || tooSmallToRead(r, textSize));
+	const stamps = allRuns.map((runs) => runs.filter(stamp));
+	const pageRuns = 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))) : allRuns;
+	const pageMarks = pages.map(() => []);
 	const medianFont = median(pageRuns.flat().map((r) => r.fontSizePt).filter((s) => s > 0)) || 12;
 	const resources = new ResourceStore();
 	const losses = [];
@@ -61,6 +68,7 @@ function reconstructByLayout(file, mode = "flow") {
 	const sectionEnds = [];
 	let sectionFrom = 0;
 	let lastSize = "";
+	const leads = [];
 	let curColumns = 1;
 	let curSpace = 0;
 	let pendingContinuous = false;
@@ -71,18 +79,19 @@ function reconstructByLayout(file, mode = "flow") {
 		const pageWidth = display.width;
 		const stepped = stepsBetweenWords(runs);
 		const blocks = [];
-		const split = gutters.length > 0 ? assignColumns(runs, gutters) : void 0;
 		const textEdges = pageTextEdges(runs);
+		const inColumns = proseColumns(runs, gutters, textEdges);
+		const split = gutters.length > 0 && inColumns ? assignColumns(runs, gutters) : void 0;
 		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 colRuns = mode === "positional" ? allRuns.filter((r) => r.type3 !== true && r.invisible !== true) : allRuns;
+			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))
@@ -93,7 +102,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([{
@@ -121,17 +131,153 @@ function reconstructByLayout(file, mode = "flow") {
 					}
 				});
 			}
-			for (const para of groupIntoParagraphs(lines, measure, display.height)) blocks.push({
-				band: bandAt(para.top),
-				col,
-				top: para.top,
-				el: paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont), {
+			let above;
+			for (const region of regionsOf(textRuns)) {
+				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).filter((l) => l.text.length > 0);
+				const reach = lines.length < 3 && gutters.length === 0 ? pageWidth * (1 - GUESSED_MARGIN) : void 0;
+				const paras = groupIntoParagraphs(regionLines, measure, display.height, above, false, reach);
+				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
+				});
+				const last = paras[paras.length - 1];
+				if (last !== void 0) above = {
+					y: last.bottom,
+					lineHeight: last.lineHeight
+				};
+			}
+		};
+		/**
+		* 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 = tabbedRows(paras, tableMeasure);
+			const out = [];
+			for (const [at, para] of paras.entries()) {
+				const table = asRows.get(at);
+				if (table !== void 0) {
+					if (table !== null) out.push({
+						top: para.top,
+						el: table
+					});
+					continue;
+				}
+				const overflow = sheetWidth > 0 ? runOn(para, tableMeasure, sheetWidth) : 0;
+				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) } : {}
-				})
+					...para.indentFirstLine !== void 0 ? { indentFirstLine: pt(para.indentFirstLine) } : {},
+					...overflow > 0 ? { indentRight: pt(-overflow) } : {}
+				});
+				if (sheetWidth > 0 && para.far !== void 0) far.set(el, para.far);
+				out.push({
+					top: para.top,
+					el
+				});
+			}
+			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).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, true);
+				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;
@@ -139,12 +285,23 @@ function reconstructByLayout(file, mode = "flow") {
 			left: 0,
 			top: display.height
 		};
+		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 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,
@@ -153,8 +310,14 @@ function reconstructByLayout(file, mode = "flow") {
 		})));
 		losses.push(...lifted.losses);
 		const placedVectors = placeVectors(lifted.vectors, display);
-		const ruled = markDrawnRules(runs, placedVectors);
-		const vectors = placedVectors.filter((v) => !ruled.consumed.has(v));
+		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 drawn = drawnWords(vectors);
 		const ruledIntoColumns = mode !== "positional" && 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({
@@ -169,6 +332,8 @@ function reconstructByLayout(file, mode = "flow") {
 			for (const col of [SPANNING_COLUMN, ...columns]) addColumn(ruled.runs.filter((r) => columnFor(r) === col), col);
 		} else addColumn(ruled.runs, 0);
 		const under = mode !== "positional";
+		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) : void 0;
 		[
 			...imgs.images.map((img) => ({
 				key: img.orderKey,
@@ -176,7 +341,7 @@ function reconstructByLayout(file, mode = "flow") {
 				top: img.y + img.heightPt,
 				make: (z) => imageBlock(img, resources, void 0, frame, z, under)
 			})),
-			...vectors.map((v) => ({
+			...drawn.filter((v) => givenAway?.has(v) !== true).map((v) => ({
 				key: v.orderKey,
 				col: colOf((v.minX + v.maxX) / 2),
 				top: v.maxY,
@@ -207,20 +372,41 @@ function reconstructByLayout(file, mode = "flow") {
 			pendingContinuous = false;
 		}
 		lastSize = size;
-		if (i > 0 && !opensSection && blocks.length > 0) body.push({
+		if (i > 0 && !opensSection) body.push({
 			kind: "paragraph",
 			paragraph: {
 				properties: {
 					pageBreakBefore: true,
-					spacingLine: pt(0),
+					spacingLine: CARRIER_LINE_PT,
 					spacingLineRule: "exact"
 				},
 				runs: []
 			}
 		});
-		const columnsHere = ruledIntoColumns ? 1 : gutters.length + 1;
+		else if (i === 0 && blocks.length === 0) body.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: {
+					spacingLine: CARRIER_LINE_PT,
+					spacingLineRule: "exact"
+				},
+				runs: []
+			}
+		});
+		const columnsHere = ruledIntoColumns || !proseColumns(runs, gutters, textEdges) ? 1 : gutters.length + 1;
 		const spacePt = columnsHere > 1 ? median(gutters.map((g) => g.to - g.from)) : 0;
+		let led = false;
 		for (const block of blocks) {
+			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";
+			}
 			const count = block.col === SPANNING_COLUMN ? 1 : columnsHere;
 			if (count !== curColumns) {
 				sectionEnds.push({
@@ -241,7 +427,7 @@ function reconstructByLayout(file, mode = "flow") {
 	});
 	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));
+		return mode === "positional" ? own : withMeasuredMargins(own, shown.slice(from, to), pageRuns.slice(from, to), pageMarks.slice(from, to), foot?.band);
 	};
 	sectionEnds.push({
 		at: body.length,
@@ -266,6 +452,25 @@ function reconstructByLayout(file, mode = "flow") {
 			endIndex: end.at
 		}];
 	}) : [];
+	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 || el?.kind !== "paragraph") continue;
+		const before = page.height - top - lead.baseline - BASELINE_AT * lead.lineHeight;
+		if (before <= SPACING_NOISE_PT) continue;
+		body[lead.at] = {
+			...el,
+			paragraph: {
+				...el.paragraph,
+				properties: {
+					...el.paragraph.properties,
+					spacingBefore: pt(before)
+				}
+			}
+		};
+	}
 	const stepped0 = stepsBetweenWords(allRuns[0] ?? []);
 	const edges0 = pageTextEdges(allRuns[0] ?? []);
 	const band = foot ? footerBand(foot.band, stepped0, edges0, foot.numbered) : [];
@@ -285,7 +490,7 @@ function reconstructByLayout(file, mode = "flow") {
 		doc: buildFlowDoc(body, resources, withFooter(setUp(0, pages.length)), 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]] : [], ...headBand.length > 0 ? [[HEADER_PART, headBand]] : []]) : void 0, collectFaceFamilies(file, pages)),
 		losses: dedupeLosses(losses)
 	};
 }
@@ -302,9 +507,9 @@ function detectGutters(runs, pageWidth) {
 	if (span < pageWidth * .5) return [];
 	const sorted = [...spans].sort((a, b) => a[0] - b[0]);
 	let curEnd = sorted[0][1];
-	const empty = [];
+	const bands = [];
 	for (const [l, r] of sorted) {
-		if (l - curEnd >= fontSize * 3) empty.push({
+		if (l - curEnd >= fontSize * 3) bands.push({
 			mid: (curEnd + l) / 2,
 			from: curEnd,
 			to: l
@@ -315,6 +520,17 @@ function detectGutters(runs, pageWidth) {
 		const ink = runInk(r);
 		return ink ? [ink] : [];
 	}).sort((a, b) => a[0] - b[0]));
+	const straddling = (band) => {
+		let n = 0;
+		for (const row of rows) {
+			const before = row.filter(([, r]) => r <= band.from);
+			const after = row.filter(([l]) => l >= band.to);
+			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) n++;
+		}
+		return n;
+	};
+	const empty = bands.filter((b) => straddling(b) >= MIN_EMPTY_BAND_ROWS);
 	const voted = [];
 	for (const x of sample(minX + span * .1, minX + span * .9, 1)) {
 		let columned = 0;
@@ -442,6 +658,13 @@ var MIN_SHARED_ROWS = 3;
 /** How many lines have to be split at the same place before the page is in columns. */
 var MIN_COLUMNED_ROWS = 12;
 /**
+* How many lines a band NO run crosses must separate before it is a gutter
+* rather than an empty half of a page. Lower than the vote's bar, because a
+* band nothing crosses is stronger evidence than a band most lines avoid — but
+* not zero, which is what an invoice's blank left half offers.
+*/
+var MIN_EMPTY_BAND_ROWS = 8;
+/**
 * The page's runs grouped by baseline.
 *
 * Swept in order rather than bucketed: a superscript sits a few points above
@@ -647,6 +870,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();
@@ -733,10 +982,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));
 	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)];
 		const pieces = [[]];
 		for (const run of ordered) {
 			const prev = pieces[pieces.length - 1];
@@ -745,9 +996,49 @@ 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));
+	});
+}
+/**
+* §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.
+*
+* @param lines Each line's runs, left to right.
+* @returns The x of every stop two lines share.
+*/
+function sharedStops(lines) {
+	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) seen.push({
+				x: run.x,
+				line,
+				tab: 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;
+/** 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.
 *
@@ -780,8 +1071,8 @@ function inkSpan(runs) {
 	};
 }
 /** One run of runs, left to right on a shared baseline, as a {@link Line}. */
-function lineOf(runs, y, fontSize, stepped) {
-	const ordered = lineSpans(runs, fontSize, stepped || runs.length > 1 && !runs.some((r) => SPACE.test(r.text)));
+function lineOf(runs, y, fontSize, stepped, shared = []) {
+	const { spans: ordered, stops, pieces } = lineSpans(runs, fontSize, stepped || runs.length > 1 && !runs.some((r) => SPACE.test(r.text)), shared);
 	const spans = ordered.every((s) => s.text.trim() === "" || isRightToLeft(s.text)) ? [...ordered].reverse() : ordered;
 	const ink = inkSpan(runs);
 	return {
@@ -789,7 +1080,11 @@ function lineOf(runs, y, fontSize, stepped) {
 		width: ink.width,
 		y,
 		fontSize,
-		...tabbed(runs, fontSize) ? { tabbed: true } : {},
+		...tabbed(runs, fontSize) || stops.length > 0 ? { tabbed: true } : {},
+		...stops.length > 0 ? {
+			stops,
+			pieces
+		} : {},
 		text: spans.map((s) => s.text).join("").replace(/\s+/g, " ").trim(),
 		spans
 	};
@@ -885,13 +1180,35 @@ 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 = []) {
 	const spans = [];
+	const stops = [];
+	const pieces = [{
+		from: Infinity,
+		to: -Infinity
+	}];
 	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)) spans.push({ text: " " });
+	let inked;
+	for (const [i, run] of runs.entries()) {
+		if (run.text.trim() === "" && run.endX - run.x <= 0 && inked !== void 0) {
+			const next = runs.slice(i + 1).find((r) => r.text.trim() !== "");
+			if (next !== void 0 && next.x - inked < spaceGap(next, fontSize, true)) continue;
+		}
+		if (run.text.replaceAll("�", "") === "" && run.text !== "") continue;
+		if (prev !== void 0 && run.x - prev.endX > spaceGap(prev, fontSize, stepped) && !(isLeader(prev.text) && prev.text === run.text)) {
+			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) {
+				spans.push({ text: "	" });
+				stops.push(run.x);
+				pieces.push({
+					from: Infinity,
+					to: -Infinity
+				});
+			} else spans.push(spaceAfter(spans[spans.length - 1]));
+		}
 		spans.push({
 			text: run.text.replaceAll("�", ""),
 			sizePt: run.fontSizePt,
@@ -908,8 +1225,18 @@ 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;
+	return {
+		spans,
+		stops,
+		pieces
+	};
 }
 /**
 * §17.3.2.42 — a run set off the line's baseline, and smaller, as the script it
@@ -960,39 +1287,110 @@ function carriesLeader(line) {
 }
 /** Three of the same leader character in a row is a leader and not punctuation. */
 var LEADER_RUN = /([.\u00b7_])\1{2,}/u;
-function groupIntoParagraphs(lines, column, pageHeight = 0) {
+/**
+* Whether the line is a RULE drawn out of characters — a row of hyphens, dots
+* or underscores and nothing else.
+*
+* A page with no rule to draw types one. It is not a sentence, it does not run
+* on into the line under it and the line over it does not run on into it.
+*
+* @param line The line.
+* @returns Whether it is a rule rather than words.
+*/
+function ruleOfCharacters(line) {
+	const text = line.text.trim();
+	if (text.length < RULE_CHARS) return false;
+	for (const ch of text) if (!LEADER_CHARS.has(ch)) return false;
+	return true;
+}
+/** How many of them it takes before a row of marks is a rule. */
+var RULE_CHARS = 3;
+function groupIntoParagraphs(lines, column, pageHeight = 0, before, eachLine = false, reach) {
 	const groups = [];
 	const gaps = [];
 	let prev;
 	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 || prev !== void 0 && (endedParagraph(prev, line, column) || carriesLeader(prev) || prev.tabbed === true)) {
+		if (groups.length === 0 || eachLine || opened || ruleOfCharacters(line) || prev !== void 0 && (ruleOfCharacters(prev) || endedParagraph(prev, line, column) || reach !== void 0 && roomForWord(prev, line, reach) || 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);
 		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 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,
+			bottom: g[g.length - 1].y,
+			...stops.length > 0 ? {
+				stops: stops.map((x) => x - (column?.left ?? columnLeft)),
+				pieces: (first.pieces ?? []).map((p) => ({
+					from: p.from - (column?.left ?? columnLeft),
+					to: p.to - (column?.left ?? 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,
+			right: Math.max(...g.map((l) => l.x + l.width)),
+			...opened > most ? { far: g } : {}
 		};
 	});
 }
 /**
+* 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;
+}
+/** 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 !== "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
@@ -1019,7 +1417,7 @@ function joinLines(lines) {
 				...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));
 		}
 		out.push(...line.spans);
 	});
@@ -1073,6 +1471,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.
@@ -1093,8 +1554,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.
 */
@@ -1103,6 +1570,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;
@@ -1170,7 +1642,8 @@ 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);
@@ -1201,18 +1674,30 @@ 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 < 4) return void 0;
+	if (rows.length === 0) return void 0;
 	const at = (i) => where === "foot" ? rows[rows.length - 1 - i] : rows[i];
 	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));
+	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 ? {
+			y: edgeY(inked[inked.length - 1] ?? []),
+			runs: all
+		} : void 0;
+	}
 	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;
@@ -1231,6 +1716,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. */
@@ -1252,6 +1739,25 @@ function pageNumbered(run) {
 	const number = found[2];
 	const before = run.text.slice(0, at);
 	const after = run.text.slice(at + number.length);
+	const total = /(^|\s)(\d{1,4})(\s|$)/u.exec(after);
+	const tail = total === null ? after === "" ? [] : [{
+		...run,
+		text: after
+	}] : [
+		...after.slice(0, total.index + total[1].length) === "" ? [] : [{
+			...run,
+			text: after.slice(0, total.index + total[1].length)
+		}],
+		{
+			...run,
+			text: total[2],
+			field: "NUMPAGES"
+		},
+		...after.slice(total.index + total[1].length + total[2].length) === "" ? [] : [{
+			...run,
+			text: after.slice(total.index + total[1].length + total[2].length)
+		}]
+	];
 	return [
 		...before === "" ? [] : [{
 			...run,
@@ -1262,10 +1768,7 @@ function pageNumbered(run) {
 			text: number,
 			field: "PAGE"
 		},
-		...after === "" ? [] : [{
-			...run,
-			text: after
-		}]
+		...tail
 	];
 }
 /**
@@ -1328,9 +1831,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]),
 			properties: alignment ? { alignment } : {}
 		};
 	}
@@ -1404,6 +1909,420 @@ function looksRuled(runs, gutters, edges) {
 	return (fills[Math.floor(fills.length / 2)] ?? 1) <= TABLE_CELL_FILL;
 }
 /**
+* Whether the regions the gutters cut the page into are COLUMNS OF PROSE — the
+* only thing worth re-setting a document in columns for.
+*
+* A gutter is evidence about the page's white space, and white space is not
+* enough: an invoice sets its labels along the left and its amounts against the
+* right margin, and a dozen lines then break at the same x. Read as two columns
+* the amounts became a column of their own and every label was indented past
+* the strip it was given — "Total excluding tax" came back one letter per line.
+*
+* What tells them apart is the same thing that tells a cell from a line of
+* prose: a column of prose FILLS its measure, over and over, because that is
+* what wrapping does. A column of values never fills anything — its lines are
+* short and it is their right edges that line up, not their left. So every
+* region must hold lines of its own and they must reach across it.
+*
+* @param runs    The page's runs.
+* @param gutters The page's gutters.
+* @param edges   Where the page's text starts and ends.
+* @returns Whether the page is set in columns of prose.
+*/
+function proseColumns(runs, gutters, edges) {
+	if (gutters.length === 0) return false;
+	if (!edges) return true;
+	const rows = rowsOf(runs, median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10).filter((row) => row.length > 0);
+	if (rows.length === 0) return true;
+	const bounds = columnBounds(runs, gutters, edges);
+	const regions = bounds.slice(0, -1).map((lo, i) => [lo, bounds[i + 1]]);
+	const regionOf = (x) => {
+		for (let i = regions.length - 1; i >= 0; i--) if (x >= regions[i][0]) return i;
+		return 0;
+	};
+	const edgesIn = regions.map(() => []);
+	for (const row of rows) {
+		const byRegion = regions.map(() => []);
+		for (const run of row) byRegion[regionOf(run.x)].push(run);
+		byRegion.forEach((inRegion, i) => {
+			if (inRegion.length === 0) return;
+			edgesIn[i].push({
+				left: Math.min(...inRegion.map((r) => r.x)),
+				right: Math.max(...inRegion.map((r) => r.endX))
+			});
+		});
+	}
+	const agreeing = (xs) => {
+		let most = 0;
+		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) => {
+		if (lines.length < MIN_PROSE_LINES) return false;
+		return agreeing(lines.map((l) => l.right)) <= agreeing(lines.map((l) => l.left));
+	});
+}
+/**
+* The drawn glyphs that are STRAY marks in a line of ordinary text.
+*
+* §9.6.6 — a glyph the file states no character for is drawn, because nothing
+* downstream can write it. That is the whole content of some pages: a subset
+* that names its glyphs `g18`, a program with no `cmap`, a font of pictures.
+* On such a page the drawings ARE the words and they stay.
+*
+* A single mark among readable words is the other case, and Stripe's invoices
+* are full of them — a `/ToUnicode` stating U+0000 for every piece of
+* punctuation it sets. The flowing reading has nowhere to put a shape inside a
+* line, so the colon of "Kazakhstan VAT: 86-1696045" was placed as a floating
+* drawing and landed a word away, on a line of its own, pushing the text
+* around it aside. Dropped, the line keeps its words and the loss report still
+* says a character was unrecoverable.
+*
+* The line decides: where nearly everything on it is drawn, the drawings are
+* the text — bug1151216.pdf sets three lines of prices that way. Where one or
+* two marks stand among several readable runs, they are punctuation.
+*
+* @param vectors The page's painted paths.
+* @param runs    The page's runs.
+* @returns The drawn glyphs to leave out of a flowing reading.
+*/
+function strayMarks(vectors, runs) {
+	const glyphs = vectors.filter((v) => v.glyph === true);
+	const out = /* @__PURE__ */ new Set();
+	if (glyphs.length === 0) return out;
+	const readable = runs.filter((r) => r.text.trim() !== "" && !r.text.includes("�"));
+	for (const v of glyphs) {
+		const mid = (v.minY + v.maxY) / 2;
+		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;
+		if (glyphs.filter((g) => Math.abs((g.minY + g.maxY) / 2 - mid) <= size).length <= MOST_STRAY_MARKS && words.length >= LEAST_READABLE_RUNS) out.add(v);
+	}
+	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. */
+var LEAST_READABLE_RUNS = 4;
+/**
+* §17.4.38 — the consecutive lines a page set out on the SAME stops, as the
+* TABLE they are.
+*
+* A line broken at a gap no word space explains is a line the page laid out
+* (see {@link tabbed}); several of them one under another, broken in the same
+* places, is a table's head and its rows. An invoice's item table is exactly
+* that, and so is the payment history under it.
+*
+* Two stops at least, which is three columns: ONE stop is a contents entry with
+* its page number at the measure, and a list of those is a list.
+*
+* The stops do not have to agree to the point — a heading sits over its column
+* and a figure is set against the far side of it — so they are matched within
+* an em, and the column is put where the rows agree it is.
+*
+* @param paras   The column's paragraphs, in order.
+* @param measure The measure they are set across.
+* @returns For each paragraph that belongs to a table: the table at its first
+*          row, and `null` at the rows after it (their content is inside it).
+*/
+function tabbedRows(paras, measure) {
+	const out = /* @__PURE__ */ new Map();
+	if (!measure) return out;
+	for (let i = 0; i < paras.length;) {
+		const stops = paras[i]?.stops ?? [];
+		if (stops.length < LEAST_TABLE_STOPS) {
+			i++;
+			continue;
+		}
+		const near = (a, b) => a.length === b.length && a.every((x, k) => Math.abs(x - b[k]) <= Math.max(paras[i].fontSize, TABLE_STOP_SLACK_PT));
+		let to = i + 1;
+		while (to < paras.length && near(stops, paras[to]?.stops ?? [])) to++;
+		if (to - i < 2) {
+			i++;
+			continue;
+		}
+		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 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 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);
+			return even <= FLUSH_SLACK_PT && Math.max(...froms) - Math.min(...froms) > even + FLUSH_SLACK_PT;
+		});
+		const edges = [
+			0,
+			...bounds,
+			width
+		];
+		for (let k = 1; k < bounds.length + 1; k++) {
+			const before = inks[k - 1];
+			const own = inks[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 flushRight = flush.map((right, k) => right ? Math.max(0, edges[k + 1] - inks[k].to) : void 0);
+		const grid = edges.slice(0, -1).map((from, k) => pt(Math.max(edges[k + 1] - from, 1)));
+		out.set(i, {
+			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: rows.map((row, r) => {
+					const prev = rows[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)
+									} : {}
+								})]
+							};
+						})
+					};
+				})
+			}
+		});
+		for (let k = i + 1; k < to; k++) out.set(k, null);
+		i = to;
+	}
+	return out;
+}
+/** 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;
+/**
+* How far two rows' stops may stand apart and still be one column.
+*
+* A heading is set over its column and a figure against the far side of it: an
+* invoice's "Qty" stands eight points left of the "1" under it, and the heading
+* is set two sizes smaller, so its own em is not a wide enough tolerance.
+*/
+var TABLE_STOP_SLACK_PT = 10;
+/** One line's spans cut into its cells, at the tabs the page set out. */
+function splitAtTabs(spans) {
+	const cells = [[]];
+	for (const span of spans) if (span.text === "	") cells.push([]);
+	else cells[cells.length - 1].push(span);
+	return cells;
+}
+/**
+* Give each separator rule to the paragraph it separates, as that paragraph's
+* own border (§17.3.1.24), and say which rules were given away.
+*
+* A rule sits in the white between two blocks: under a table's headings, over a
+* total. The block BELOW it takes it as a top border, because that is the block
+* the rule introduces; where nothing follows closely enough, the block above
+* takes it as a bottom one.
+*
+* @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.
+* @returns The rules that became borders, and so must not be drawn again.
+*/
+function ruleBorders(vectors, blocks, width) {
+	const given = /* @__PURE__ */ new Set();
+	const paragraphs = blocks.filter((b) => b.el.kind === "paragraph");
+	if (paragraphs.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 side = below !== void 0 && y - below.top <= RULE_REACH_PT ? {
+			block: below,
+			edge: "top"
+		} : above !== void 0 && above.top - y <= RULE_REACH_PT ? {
+			block: above,
+			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 === "top" ? { insideH: border } : {}
+					}
+				}
+			}
+		};
+		for (const piece of band.pieces) given.add(piece);
+	}
+	return given;
+}
+/** How far from a paragraph a rule may stand and still belong to it. */
+var RULE_REACH_PT = 14;
+/** The thinnest a border may be drawn and still be seen. */
+var RULE_MIN_PT = .5;
+/**
+* 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 flatBar(v) {
+	const w = v.maxX - v.minX;
+	const h = v.maxY - v.minY;
+	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. */
+var RULE_SHARE = .2;
+/** …and how much longer than it is thick. */
+var RULE_RATIO = 20;
+/** How close two edges stand before they count as the same one. */
+var FLUSH_PT = 1;
+/** And how many lines it takes before a region is a column at all. */
+var MIN_PROSE_LINES = 6;
+/**
 * §17.4.38 — the page's rows as the TABLE they are.
 *
 * The regions between the gutters are the columns and the rows are the rows;