reamkit 1.27.0 → 1.28.0

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

@@ -9,6 +9,11 @@ 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 { matrixBlocks } from "./math-rows.js";
+//#region src/pdf-reader/layout.ts
+/** The relationships the reconstruction files its running head and foot under. */
+var FOOTER_PART = "pdf-running-foot";
+var HEADER_PART = "pdf-running-head";
 /**
 * Heuristically reconstruct an untagged PDF into a {@link Reconstruction}
 * (E-PDF EP4). With no structure tree there is only positioned content, so
@@ -27,7 +32,10 @@ import { markDrawnRules } from "./text-rules.js";
 function reconstructByLayout(file, mode = "flow") {
 	const pages = file.pages();
 	const shown = pages.map((page) => displayOf(page));
-	const pageRuns = pages.map((page, i) => placeRuns(extractPageText(file, page), shown[i]));
+	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 medianFont = median(pageRuns.flat().map((r) => r.fontSizePt).filter((s) => s > 0)) || 12;
 	const resources = new ResourceStore();
 	const losses = [];
@@ -41,14 +49,32 @@ function reconstructByLayout(file, mode = "flow") {
 		feature: FEATURES.text,
 		detail: "text filled with a tiling pattern is drawn as a flat tint of the pattern’s colour, not as the pattern"
 	});
+	if (pageRuns.some((page) => page.some((r) => r.gradientFill === true))) losses.push({
+		severity: "degraded",
+		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 shared = commonGutters(perPage);
+	const pageGutters = perPage.map((own, i) => own.length > 0 ? own : shared && fitsGutters(pageRuns[i], shared) ? shared : own);
 	const body = [];
+	const sectionEnds = [];
+	let sectionFrom = 0;
+	let lastSize = "";
+	let curColumns = 1;
+	let curSpace = 0;
+	let pendingContinuous = false;
 	pages.forEach((page, i) => {
 		const runs = pageRuns[i];
 		const display = shown[i];
+		const gutters = pageGutters[i];
 		const pageWidth = display.width;
-		const gutter = detectGutter(runs, pageWidth);
 		const stepped = stepsBetweenWords(runs);
 		const blocks = [];
+		const split = gutters.length > 0 ? assignColumns(runs, gutters) : void 0;
+		const textEdges = pageTextEdges(runs);
+		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;
 			if (mode === "positional") {
@@ -64,22 +90,51 @@ function reconstructByLayout(file, mode = "flow") {
 				}
 				return;
 			}
-			const lines = groupIntoLines(colRuns, false, stepped).filter((l) => l.text.length > 0);
-			const measure = lines.length > 0 ? {
-				left: Math.min(...lines.map((l) => l.x)),
-				right: Math.max(...lines.map((l) => l.x + l.width))
-			} : void 0;
+			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 measure = measureOf(col, gutters, textEdges) ?? measureOfLines(lines);
+			for (const found of maths) {
+				const { alignment } = alignmentOf([{
+					y: found.top,
+					fontSize: columnSize,
+					text: "",
+					spans: [],
+					x: found.x,
+					width: found.width
+				}], measure);
+				blocks.push({
+					band: bandAt(found.top),
+					col,
+					top: found.top,
+					el: {
+						kind: "paragraph",
+						paragraph: {
+							properties: alignment ? { alignment } : {},
+							runs: [{
+								text: "",
+								properties: {},
+								math: found.math
+							}]
+						}
+					}
+				});
+			}
 			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), {
 					...para.alignment !== void 0 ? { alignment: para.alignment } : {},
-					...para.spacingBefore !== void 0 ? { spacingBefore: pt(para.spacingBefore) } : {}
+					...para.spacingBefore !== void 0 ? { spacingBefore: pt(para.spacingBefore) } : {},
+					...para.indentLeft !== void 0 ? { indentLeft: pt(para.indentLeft) } : {},
+					...para.indentFirstLine !== void 0 ? { indentFirstLine: pt(para.indentFirstLine) } : {}
 				})
 			});
 		};
 		const placed = [];
-		const colOf = (centerX) => gutter !== void 0 && centerX >= gutter ? 1 : 0;
+		const colOf = (centerX) => gutters.filter((g) => centerX >= g.mid).length;
 		const frame = {
 			left: 0,
 			top: display.height
@@ -100,9 +155,18 @@ function reconstructByLayout(file, mode = "flow") {
 		const placedVectors = placeVectors(lifted.vectors, display);
 		const ruled = markDrawnRules(runs, placedVectors);
 		const vectors = placedVectors.filter((v) => !ruled.consumed.has(v));
-		if (gutter !== void 0) {
-			addColumn(ruled.runs.filter((r) => r.x < gutter), 0);
-			addColumn(ruled.runs.filter((r) => r.x >= gutter), 1);
+		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({
+			band: bandAt(block.top),
+			col: 0,
+			top: block.top,
+			el: block.el
+		});
+		else if (split && !ruledIntoColumns) {
+			const columnFor = (r) => split.columnOf.get(r) ?? colOf(r.x);
+			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);
 		const under = mode !== "positional";
 		[
@@ -121,13 +185,29 @@ function reconstructByLayout(file, mode = "flow") {
 			...placed
 		].sort((a, b) => compareOrder(a.key, b.key)).forEach((mark, z) => {
 			blocks.push({
+				band: bandAt(mark.top),
 				col: mark.col,
 				top: mark.top,
 				el: mark.make(z)
 			});
 		});
-		blocks.sort((a, b) => a.col - b.col || b.top - a.top);
-		if (i > 0 && blocks.length > 0) body.push({
+		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;
+		if (opensSection) {
+			sectionEnds.push({
+				at: body.length,
+				from: sectionFrom,
+				to: i,
+				columns: curColumns,
+				spacePt: curSpace,
+				continuous: pendingContinuous
+			});
+			sectionFrom = i;
+			pendingContinuous = false;
+		}
+		lastSize = size;
+		if (i > 0 && !opensSection && blocks.length > 0) body.push({
 			kind: "paragraph",
 			paragraph: {
 				properties: {
@@ -138,36 +218,416 @@ function reconstructByLayout(file, mode = "flow") {
 				runs: []
 			}
 		});
-		for (const block of blocks) body.push(block.el);
+		const columnsHere = ruledIntoColumns ? 1 : gutters.length + 1;
+		const spacePt = columnsHere > 1 ? median(gutters.map((g) => g.to - g.from)) : 0;
+		for (const block of blocks) {
+			const count = block.col === SPANNING_COLUMN ? 1 : columnsHere;
+			if (count !== curColumns) {
+				sectionEnds.push({
+					at: body.length,
+					from: sectionFrom,
+					to: i + 1,
+					columns: curColumns,
+					spacePt: curSpace,
+					continuous: pendingContinuous
+				});
+				sectionFrom = i;
+				pendingContinuous = true;
+				curColumns = count;
+				curSpace = spacePt;
+			}
+			body.push(block.el);
+		}
+	});
+	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));
+	};
+	sectionEnds.push({
+		at: body.length,
+		from: sectionFrom,
+		to: pages.length,
+		columns: curColumns,
+		spacePt: curSpace,
+		continuous: pendingContinuous
 	});
-	const section = sectionFromPdfPages(pages);
+	const sections = sectionEnds.length > 1 ? sectionEnds.flatMap((end) => {
+		const base = setUp(end.from, end.to);
+		if (!base) return [];
+		return [{
+			properties: {
+				...base,
+				...end.columns > 1 && mode !== "positional" ? { columns: {
+					count: end.columns,
+					spacePt: end.spacePt
+				} } : {},
+				...end.continuous ? { sectionStart: "continuous" } : {}
+			},
+			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) : [];
+	const withFooter = (properties) => properties ? {
+		...properties,
+		...band.length > 0 ? { footers: [{
+			type: "default",
+			relationshipId: FOOTER_PART
+		}] } : {},
+		...headBand.length > 0 ? { headers: [{
+			type: "default",
+			relationshipId: HEADER_PART
+		}] } : {}
+	} : properties;
 	return {
-		doc: buildFlowDoc(body, resources, mode === "positional" ? section : withMeasuredMargins(section, shown, pageRuns), collectEmbeddedFonts(file, pages, losses)),
+		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),
 		losses: dedupeLosses(losses)
 	};
 }
-function detectGutter(runs, pageWidth) {
-	if (runs.length < 30 || pageWidth <= 0) return void 0;
+function detectGutters(runs, pageWidth) {
+	if (runs.length < 30 || pageWidth <= 0) return [];
 	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
-	const intervals = runs.map((r) => [r.x, Math.max(r.endX, r.x + 1)]).sort((a, b) => a[0] - b[0]);
-	const minX = intervals[0][0];
-	const span = Math.max(...intervals.map((iv) => iv[1])) - minX;
-	if (span < pageWidth * .5) return void 0;
-	let curEnd = intervals[0][1];
-	let gapMid = 0;
-	let gapW = 0;
-	for (const [l, r] of intervals) {
-		if (l - curEnd > gapW) {
-			gapW = l - curEnd;
-			gapMid = (curEnd + l) / 2;
-		}
+	const spans = runs.flatMap((r) => {
+		const ink = runInk(r);
+		return ink ? [ink] : [];
+	});
+	if (spans.length === 0) return [];
+	const minX = Math.min(...spans.map((iv) => iv[0]));
+	const span = Math.max(...spans.map((iv) => iv[1])) - minX;
+	if (span < pageWidth * .5) return [];
+	const sorted = [...spans].sort((a, b) => a[0] - b[0]);
+	let curEnd = sorted[0][1];
+	const empty = [];
+	for (const [l, r] of sorted) {
+		if (l - curEnd >= fontSize * 3) empty.push({
+			mid: (curEnd + l) / 2,
+			from: curEnd,
+			to: l
+		});
 		if (r > curEnd) curEnd = r;
 	}
-	const frac = (gapMid - minX) / span;
-	if (gapW < fontSize * 3 || frac < .35 || frac > .65) return void 0;
-	const left = runs.filter((r) => r.x < gapMid).length;
-	if (left < runs.length * .25 || left > runs.length * .75) return void 0;
-	return gapMid;
+	const rows = rowsOf(runs, fontSize).map((row) => row.flatMap((r) => {
+		const ink = runInk(r);
+		return ink ? [ink] : [];
+	}).sort((a, b) => a[0] - b[0]));
+	const voted = [];
+	for (const x of sample(minX + span * .1, minX + span * .9, 1)) {
+		let columned = 0;
+		let crossing = 0;
+		for (const row of rows) {
+			if (row.some(([l, r]) => l < x && r > x)) {
+				crossing++;
+				continue;
+			}
+			const before = row.filter(([, r]) => r <= x);
+			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++;
+		}
+		if (columned < MIN_COLUMNED_ROWS || crossing >= columned) continue;
+		const last = voted[voted.length - 1];
+		if (last && x - last.to <= 1.5) voted[voted.length - 1] = {
+			...last,
+			to: x,
+			mid: (last.from + x) / 2
+		};
+		else voted.push({
+			mid: x,
+			from: x,
+			to: x
+		});
+	}
+	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);
+}
+/**
+* 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
+* word between are one column and a stray. Each band is kept only where the
+* region since the last kept one holds a real share of the page's runs — and
+* the last one only if something follows it.
+*
+* @param bands The candidates, in order.
+* @param spans Every run's horizontal extent.
+* @returns The gutters worth splitting on.
+*/
+function separating(bands, spans) {
+	const need = spans.length * MIN_COLUMN_SHARE;
+	const out = [];
+	let from = -Infinity;
+	for (const band of bands) {
+		if (spans.filter(([l, r]) => (l + r) / 2 > from && (l + r) / 2 < band.mid).length < need) continue;
+		out.push(band);
+		from = band.mid;
+	}
+	const tail = spans.filter(([l, r]) => (l + r) / 2 > from).length;
+	if (out.length > 0 && tail < need) out.pop();
+	return out;
+}
+/** How much of a page's text the narrowest column holds before it is a column. */
+var MIN_COLUMN_SHARE = .08;
+/**
+* The gutters MOST of the document's pages agree on.
+*
+* A document is set one way: §17.6.4 puts the column setup on the section, and
+* a paper does not change it from sheet to sheet. So a page that says nothing
+* on its own — one carrying a figure across both columns, with too few clean
+* lines left for the vote — can be asked the question the rest of the document
+* already answered.
+*
+* @param perPage Each page's own answer, in page order.
+* @returns The answer given by more pages than any other, or `undefined` where
+*          no two pages agree.
+*/
+function commonGutters(perPage) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const gutters of perPage) {
+		if (gutters.length === 0) continue;
+		const key = gutters.map((g) => Math.round(g.mid / 2)).join(",");
+		const had = seen.get(key);
+		if (had) had.pages++;
+		else seen.set(key, {
+			gutters,
+			pages: 1
+		});
+	}
+	let best;
+	for (const entry of seen.values()) if (!best || entry.pages > best.pages) best = entry;
+	return best?.gutters;
+}
+/**
+* Whether a page's own lines agree with gutters the document states.
+*
+* The document's answer is a suggestion, not a licence: a sheet whose lines run
+* straight through the gutter is set in one column whatever its neighbours do.
+* The bar is lower than the vote's own — the evidence from the other pages is
+* already in — but it is still the page that decides.
+*
+* @param runs    The page's runs.
+* @param gutters The document's gutters.
+*/
+function fitsGutters(runs, gutters) {
+	if (runs.length < 30) return false;
+	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const rows = rowsOf(runs, fontSize).map((row) => row.flatMap((r) => {
+		const ink = runInk(r);
+		return ink ? [ink] : [];
+	}).sort((a, b) => a[0] - b[0]));
+	for (const gutter of gutters) {
+		let columned = 0;
+		let crossing = 0;
+		for (const row of rows) {
+			if (row.some(([l, r]) => l < gutter.mid && r > gutter.mid)) {
+				crossing++;
+				continue;
+			}
+			const before = row.filter(([, r]) => r <= gutter.mid);
+			const after = row.filter(([l]) => l >= gutter.mid);
+			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++;
+		}
+		if (crossing === 0) continue;
+		if (columned < MIN_SHARED_ROWS || crossing >= columned) return false;
+	}
+	return true;
+}
+/** How many lines a page must split at a gutter the DOCUMENT already states. */
+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;
+/**
+* The page's runs grouped by baseline.
+*
+* Swept in order rather than bucketed: a superscript sits a few points above
+* the baseline it belongs to, and a bucket boundary between the two would leave
+* it a line of its own — bug1885505.pdf's author block came back with the
+* asterisks and daggers standing alone on five separate lines.
+*/
+function rowsOf(runs, fontSize) {
+	const tolerance = Math.max(fontSize * .6, 1);
+	const rows = [];
+	let row = [];
+	let rowY = Number.POSITIVE_INFINITY;
+	for (const run of [...runs].sort((a, b) => b.y - a.y)) {
+		if (row.length > 0 && rowY - run.y > tolerance) {
+			rows.push(row);
+			row = [];
+		}
+		if (row.length === 0) rowY = run.y;
+		row.push(run);
+	}
+	if (row.length > 0) rows.push(row);
+	return rows;
+}
+/**
+* A run's INK — where its letters are, which a trailing space is not.
+*
+* A run carries the advance it stepped, and the space that ends a line of a
+* column is part of it: chrome-text-selection-markedContent.pdf sets two
+* columns 21 points apart and its left column's lines end ", " — five of those
+* points — so every measurement of the gutter came back a third short and the
+* page was read straight across.
+*
+* @param run The run.
+* @returns Its ink, or `undefined` for a run that is nothing but space.
+*/
+function runInk(run) {
+	const from = Math.min(run.x, run.endX);
+	const to = Math.max(run.endX, run.x + 1);
+	const chars = [...run.text];
+	if (chars.length === 0) return [from, to];
+	let head = 0;
+	while (head < chars.length && SPACE.test(chars[head])) head++;
+	if (head === chars.length) return void 0;
+	let tail = 0;
+	while (tail < chars.length - head && SPACE.test(chars[chars.length - 1 - tail])) tail++;
+	if (head === 0 && tail === 0) return [from, to];
+	const step = (to - from) / chars.length;
+	return [from + head * step, to - tail * step];
+}
+var SPACE = /\s/u;
+/** Where the page's text starts and ends, ignoring what is only a space. */
+function pageTextEdges(runs) {
+	let left = Number.POSITIVE_INFINITY;
+	let right = Number.NEGATIVE_INFINITY;
+	for (const run of runs) {
+		const ink = runInk(run);
+		if (!ink) continue;
+		left = Math.min(left, ink[0]);
+		right = Math.max(right, ink[1]);
+	}
+	return right > left ? {
+		left,
+		right
+	} : void 0;
+}
+/**
+* The measure a column is set across: from the gutter on its left to the one
+* on its right, and to the page's own text edge where there is none.
+*
+* A line that spans the page (see {@link SPANNING_COLUMN}) is set across all of
+* them, which is what makes a centred title centred.
+*
+* @param col     The column, or {@link SPANNING_COLUMN}.
+* @param gutters The page's gutters, left to right.
+* @param edges   Where the page's text starts and ends.
+*/
+function measureOf(col, gutters, edges) {
+	if (!edges) return void 0;
+	if (col === SPANNING_COLUMN || gutters.length === 0) return edges;
+	return {
+		left: col === 0 ? edges.left : gutters[col - 1]?.to ?? edges.left,
+		right: col >= gutters.length ? edges.right : gutters[col]?.from ?? edges.right
+	};
+}
+/** The measure the lines themselves reach across, where the page states none. */
+function measureOfLines(lines) {
+	if (lines.length === 0) return void 0;
+	return {
+		left: Math.min(...lines.map((l) => l.x)),
+		right: Math.max(...lines.map((l) => l.x + l.width))
+	};
+}
+/** The x's to measure at, from `a` to `b` inclusive. */
+function sample(a, b, step) {
+	const out = [];
+	for (let x = a; x <= b; x += Math.max(step, .5)) out.push(x);
+	return out;
+}
+/**
+* EP17 — which column each run belongs to, and where the page's bands break.
+*
+* The decision is made a LINE at a time, not a run at a time: a title is drawn
+* as several runs and only one of them may reach across the gutter, so judging
+* each on its own would leave the rest of the title standing in a column.
+*
+* @param runs   The page's runs.
+* @param gutter The band from {@link detectGutter}.
+* @returns The column of each run (0, 1, or {@link SPANNING_COLUMN}) and the
+*          baselines of the full-width lines, which separate the bands.
+*/
+function assignColumns(runs, gutters) {
+	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const rows = rowsOf(runs, fontSize);
+	const columnOf = /* @__PURE__ */ new Map();
+	const breaks = [];
+	const columnAt = (x) => gutters.filter((g) => x >= g.mid).length;
+	for (const row of rows) {
+		const inked = row.flatMap((run) => {
+			const ink = runInk(run);
+			return ink ? [{
+				run,
+				from: ink[0],
+				to: ink[1]
+			}] : [];
+		}).sort((a, b) => a.from - b.from);
+		if (inked.length === 0) continue;
+		const leftmost = inked[0].from;
+		const rightmost = Math.max(...inked.map((r) => r.to));
+		const straddled = gutters.filter((g) => leftmost < g.mid && rightmost > g.mid);
+		if (straddled.length === 0) {
+			const col = columnAt(leftmost);
+			for (const run of row) columnOf.set(run, col);
+			continue;
+		}
+		const gapAt = (mid) => {
+			let cur = inked[0].to;
+			let gap = 0;
+			for (const { from, to } of inked.slice(1)) {
+				if (from > cur && cur <= mid && from >= mid) gap = from - cur;
+				cur = Math.max(cur, to);
+			}
+			return gap;
+		};
+		if (straddled.every((g) => gapAt(g.mid) >= fontSize * MIN_GUTTER_EM)) {
+			for (const { run, from } of inked) columnOf.set(run, columnAt(from));
+			continue;
+		}
+		for (const run of row) columnOf.set(run, SPANNING_COLUMN);
+		breaks.push(Math.max(...row.map((r) => r.y)));
+	}
+	return {
+		columnOf,
+		breaks: breaks.sort((a, b) => b - a)
+	};
+}
+/**
+* A line that spans the page belongs to no column: it stands between the bands
+* it separates.
+*
+* Which side of them? A spanning line is what BREAKS a band, and a band runs
+* from one break to the next, so the line is always at the FOOT of its own —
+* the columns of that band are the ones above it. Read ahead of them,
+* bug1997343.pdf's page number came out between the date and the abstract.
+*/
+var SPANNING_COLUMN = -1;
+/** Where a column reads in its band: the spanning line at the foot of it. */
+function columnOrder(col) {
+	return col === SPANNING_COLUMN ? Number.MAX_SAFE_INTEGER : col;
+}
+/**
+* How wide, in ems, the gap over the middle has to be for a line to be two
+* lines. A word space is a quarter of an em (see `SPACE_GAP_EM`) and a
+* justified one no more than half; a gutter is an em and more.
+*
+* It stood at one and a half, which is wider than some magazines set:
+* chrome-text-selection-markedContent.pdf puts fourteen and a half points
+* between columns of eleven-point type — 1.31 em — and every line of it was
+* read straight across, the left column's sentence running into the right
+* column's.
+*/
+var MIN_GUTTER_EM = 1;
+/** Which band a mark at this height belongs to — how many breaks stand above it. */
+function bandOf(breaks, top, epsilon) {
+	let n = 0;
+	for (const y of breaks) if (y > top + epsilon) n++;
+	return n;
 }
 /**
 * The gap, in ems, past which the placed reader cuts a line rather than write a
@@ -321,7 +781,7 @@ 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);
+	const ordered = lineSpans(runs, fontSize, stepped || runs.length > 1 && !runs.some((r) => SPACE.test(r.text)));
 	const spans = ordered.every((s) => s.text.trim() === "" || isRightToLeft(s.text)) ? [...ordered].reverse() : ordered;
 	const ink = inkSpan(runs);
 	return {
@@ -329,11 +789,46 @@ function lineOf(runs, y, fontSize, stepped) {
 		width: ink.width,
 		y,
 		fontSize,
+		...tabbed(runs, fontSize) ? { tabbed: true } : {},
 		text: spans.map((s) => s.text).join("").replace(/\s+/g, " ").trim(),
 		spans
 	};
 }
 /**
+* Whether a TAB stands inside the line — a gap no word space could be.
+*
+* A line with one is a line the page SET OUT, not a line of prose: a contents
+* entry with its page number at the measure, a two-column list, a label and its
+* value. It does not run on into the line below it, and read as prose it does:
+* bug1997343.pdf's contents came back as "2 Document structures 1 2.1
+* Mathematics ............. 1", two entries in one line, where the file sets
+* one to a line.
+*
+* A leader says the same thing (see {@link carriesLeader}) but only where the
+* entry is dotted; a top-level entry is spaced, and nothing else marks it.
+*
+* @param runs     The line's runs.
+* @param fontSize The line's size.
+*/
+function tabbed(runs, fontSize) {
+	const inked = runs.flatMap((r) => {
+		const ink = runInk(r);
+		return ink ? [ink] : [];
+	}).sort((a, b) => a[0] - b[0]);
+	let cur = Number.NEGATIVE_INFINITY;
+	for (const [from, to] of inked) {
+		if (cur > Number.NEGATIVE_INFINITY && from - cur >= fontSize * TAB_GAP_EM) return true;
+		cur = Math.max(cur, to);
+	}
+	return false;
+}
+/**
+* How wide a gap has to be, in ems, before a word space could not have stood
+* there. Justification stretches a space to about half an em; two and a half is
+* a jump nothing but a tab makes.
+*/
+var TAB_GAP_EM = 2.5;
+/**
 * The gap between two runs that means a WORD SPACE stood there.
 *
 * A page that draws its own spaces has already said where its words divide, and
@@ -352,6 +847,28 @@ function lineOf(runs, y, fontSize, stepped) {
 function spaceGap(prev, fontSize, stepped) {
 	return (prev.fontSizePt || fontSize) * (stepped ? STEPPED_SPACE_EM : DRAWN_SPACE_EM);
 }
+/**
+* §17.3.1.25 — one character of a LEADER, the dotted rule that carries the eye
+* across a table of contents.
+*
+* A leader is drawn one character at a time with a step about as wide as a word
+* space, so every threshold that tells a space from a kern says "space" between
+* every dot. bug886717.pdf's contents came back as
+* "Abstract . . . . . . . . . . . . 3", four times as long as the page sets it,
+* and its forty entries spilled onto a second page. What tells a leader from
+* words is that it is the SAME character over and over.
+*/
+function isLeader(text) {
+	return text.length === 1 && LEADER_CHARS.has(text);
+}
+var LEADER_CHARS = new Set([
+	".",
+	"·",
+	"_",
+	"-",
+	"‐",
+	"–"
+]);
 /** A page that writes its own spaces: only a wide gap means anything more. */
 var DRAWN_SPACE_EM = .25;
 /** A page that writes none: the step between its words is all there is. */
@@ -370,9 +887,11 @@ function stepsBetweenWords(runs) {
 }
 function lineSpans(runs, fontSize, stepped) {
 	const spans = [];
+	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)) spans.push({ text: " " });
+		if (prev !== void 0 && run.x - prev.endX > spaceGap(prev, fontSize, stepped) && !(isLeader(prev.text) && prev.text === run.text)) spans.push({ text: " " });
 		spans.push({
 			text: run.text.replaceAll("�", ""),
 			sizePt: run.fontSizePt,
@@ -384,6 +903,7 @@ function lineSpans(runs, fontSize, stepped) {
 			} } : {},
 			...run.bold ? { bold: true } : {},
 			...run.italic ? { italic: true } : {},
+			...script(run, baseline, fontSize),
 			...run.markup !== void 0 ? { markup: run.markup } : {},
 			...run.href !== void 0 ? { href: run.href } : {}
 		});
@@ -391,6 +911,55 @@ function lineSpans(runs, fontSize, stepped) {
 	}
 	return spans;
 }
+/**
+* §17.3.2.42 — a run set off the line's baseline, and smaller, as the script it
+* is.
+*
+* A PDF states no such property: an exponent is a smaller face set a little
+* higher, and an index a smaller face set a little lower. Read flat, the whole
+* of mathematics comes back on one line — bug1997343.pdf sets `n^p = n mod p`
+* and we read "np", and every prime on the page landed beside its letter
+* instead of over it.
+*
+* The size the span keeps is the LINE's, not the mark's: a document states the
+* nominal size and the layout shrinks a script, so the drawn seven points under
+* a superscript would come out at five.
+*
+* @param run      The run.
+* @param baseline The line's own baseline.
+* @param fontSize The line's size.
+*/
+function script(run, baseline, fontSize) {
+	if ((run.fontSizePt || fontSize) > fontSize * SCRIPT_SIZE) return {};
+	const rise = run.y - baseline;
+	if (rise > fontSize * SCRIPT_RISE) return {
+		script: "superscript",
+		sizePt: fontSize
+	};
+	if (rise < -fontSize * SCRIPT_DROP) return {
+		script: "subscript",
+		sizePt: fontSize
+	};
+	return {};
+}
+/** How much smaller than its line a run must be set to be a script of it. */
+var SCRIPT_SIZE = .85;
+/** How far above the baseline a superscript stands, and below it a subscript. */
+var SCRIPT_RISE = .15;
+var SCRIPT_DROP = .08;
+/**
+* §17.3.1.25 — whether a line carries a LEADER, which makes it an entry in a
+* directory rather than a line of prose.
+*
+* A contents line runs the full measure — the dots are there to make it — so
+* the ragged-edge test that ends every other paragraph never fires on one, and
+* bug886717.pdf's forty entries came back as a single reflowing paragraph.
+*/
+function carriesLeader(line) {
+	return LEADER_RUN.test(line.text);
+}
+/** 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) {
 	const groups = [];
 	const gaps = [];
@@ -398,13 +967,15 @@ function groupIntoParagraphs(lines, column, pageHeight = 0) {
 	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)) {
+		if (groups.length === 0 || opened || prev !== void 0 && (endedParagraph(prev, line, column) || carriesLeader(prev) || prev.tabbed === true)) {
 			groups.push([]);
 			gaps.push(prev === void 0 ? 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;
 	return groups.map((g, i) => {
 		const first = g[0];
 		const fontSize = Math.max(...g.map((l) => l.fontSize));
@@ -412,15 +983,102 @@ function groupIntoParagraphs(lines, column, pageHeight = 0) {
 		const most = pageHeight > 0 ? pageHeight / 3 : fontSize * 3;
 		const spacingBefore = opened > fontSize * .3 ? Math.min(opened, most) : void 0;
 		return {
-			spans: g.flatMap((l, k) => k > 0 ? [{ text: " " }, ...l.spans] : [...l.spans]),
+			spans: joinLines(g),
 			fontSize,
 			top: first.y,
 			...spacingBefore !== void 0 ? { spacingBefore } : {},
-			...alignmentOf(g, column)
+			...alignmentOf(g, column),
+			...indentOf(g, columnLeft, alignmentOf(g, column).alignment)
 		};
 	});
 }
 /**
+* 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
+* the text: re-set at another measure the word has to come back together. Which
+* hyphen decides what is left of it — U+00AD is the discretionary one, put in
+* to mark a place a word MAY break, and it goes with the break; a plain hyphen
+* belongs to the word ("two-" and "column" are "two-column") and stays.
+*
+* Read as prose with a space between every line, bug1997343.pdf came back
+* "typical two-column docu ment incorporating tables, figures and mathemat
+* ics" — the soft hyphens dropped by the page and a space in their place.
+*
+* @param lines The paragraph's lines, in order.
+*/
+function joinLines(lines) {
+	const out = [];
+	lines.forEach((line, i) => {
+		if (i > 0) {
+			const prev = out[out.length - 1];
+			const ends = prev?.text ?? "";
+			const soft = ends.endsWith(SOFT_HYPHEN);
+			const hard = HYPHENS.has(ends.slice(-1));
+			if (soft && prev) out[out.length - 1] = {
+				...prev,
+				text: ends.slice(0, -1)
+			};
+			else if (!hard) out.push({ text: " " });
+		}
+		out.push(...line.spans);
+	});
+	return out;
+}
+/** §17.3.3.29 — the hyphen that is a PLACE a word may break, not a hyphen. */
+var SOFT_HYPHEN = "­";
+/** The hyphens that belong to the word they end. */
+var HYPHENS = 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;
+/**
+* §17.3.1.12 `w:ind` — how far a paragraph is set in from its column, and where
+* its first line begins.
+*
+* A PDF states neither: every line is placed absolutely, and read flat every
+* paragraph came back against the left edge. That is most of what a list looks
+* like — bug1997343.pdf sets "• They may be unordered bullet lists" ten points
+* in and its nested "1. lists may also be nested" twenty more, and we set all
+* of them flush left — and it is the whole of a first-line indent, which is how
+* most of the world's prose marks a new paragraph.
+*
+* The first line is measured against the REST of the paragraph, which is what
+* `indentFirstLine` means: positive is a first line set in (a new paragraph),
+* negative a hanging one (a list, its marker standing out to the left).
+*
+* A paragraph that is centred or set to the right is placed, not indented, and
+* keeps neither.
+*
+* @param lines      The paragraph's lines.
+* @param columnLeft Where the column's own text begins.
+* @param alignment  What {@link alignmentOf} made of it.
+*/
+function indentOf(lines, columnLeft, alignment) {
+	if (alignment !== void 0 || lines.length === 0) return {};
+	const size = Math.max(...lines.map((l) => l.fontSize)) || 10;
+	const rest = lines.slice(1);
+	const body = rest.length > 0 ? Math.min(...rest.map((l) => l.x)) : lines[0].x;
+	const left = body - columnLeft;
+	const first = lines[0].x - body;
+	const enough = size * INDENT_EM;
+	return {
+		...Math.abs(left) >= enough ? { indentLeft: left } : {},
+		...Math.abs(first) >= enough ? { indentFirstLine: first } : {}
+	};
+}
+/**
+* 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.
+*/
+var INDENT_EM = .5;
+/**
 * Whether a line ENDED a paragraph, rather than wrapping into the next.
 *
 * Leading alone cannot tell the two apart: five labels stacked at 15pt with a
@@ -444,7 +1102,9 @@ function endedParagraph(prev, next, column) {
 	if (!column) return false;
 	const width = column.right - column.left;
 	if (!(width > 0)) return false;
-	if (Math.abs(prev.x - next.x) > Math.max(prev.fontSize, 4)) return false;
+	const step = Math.max(prev.fontSize, 4);
+	const shift = next.x - prev.x;
+	if (shift < -step || shift > step * INDENT_LINES) return false;
 	return column.right - (prev.x + prev.width) > width * .25;
 }
 /**
@@ -457,7 +1117,7 @@ function endedParagraph(prev, next, column) {
 * is left alone — a justified paragraph and a ragged-right one look the same
 * from here, and guessing between them would re-set the body of every document.
 */
-function alignmentOf(lines, column) {
+function alignmentOf(lines, column, least) {
 	if (!column || lines.length === 0) return {};
 	const width = column.right - column.left;
 	if (!(width > 0)) return {};
@@ -465,10 +1125,11 @@ function alignmentOf(lines, column) {
 		lead: l.x - column.left,
 		trail: column.right - (l.x + l.width)
 	}));
-	const meaningful = width * .1;
+	const meaningful = Math.min(width * .1, least ?? width);
 	const even = width * .06;
 	if (insets.every((i) => Math.abs(i.lead - i.trail) <= even) && Math.max(...insets.map((i) => Math.min(i.lead, i.trail))) >= meaningful) return { alignment: "center" };
-	if (insets.every((i) => i.trail <= even) && Math.max(...insets.map((i) => i.lead)) >= meaningful) return { alignment: "right" };
+	const leads = insets.map((i) => i.lead);
+	if (insets.every((i) => i.trail <= even) && Math.max(...leads) >= meaningful && Math.max(...leads) - Math.min(...leads) > even) return { alignment: "right" };
 	return {};
 }
 function headingLevel(fontSize, medianFont) {
@@ -490,5 +1151,447 @@ function compareOrder(a, b) {
 	for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
 	return a.length - b.length;
 }
+/**
+* §17.6.13 — the running foot a document repeats at the bottom of its pages.
+*
+* A page number, a title, a URL: it stands below the text block, in the margin,
+* and it is not part of what the page SAYS. Read as body it goes wherever the
+* reflow puts it — bug1997343.pdf's "1" came out on a sheet of its own between
+* the two the paper has, and TAMReview.pdf's "Sprouts — http://…" landed in the
+* middle of the abstract.
+*
+* What makes it a running foot is that it RUNS: the same place, page after
+* page, cut off from the text above it by more than a line of white. One page
+* proves nothing, so two are asked for.
+*
+* @param pageRuns Each page's runs, placed.
+* @param shown    Each page's shown geometry.
+* @returns The runs to lift off each page and the band to put them in, or
+*          `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 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 texts = found.map((f) => f.runs.map((r) => r.text).join("").trim());
+	return {
+		lift: feet.map((f) => new Set(f?.runs ?? [])),
+		band: found[0].runs,
+		numbered: new Set(texts).size > 1
+	};
+}
+/** How many of a document's pages must carry the foot before it is running. */
+var FOOT_SHARE = .6;
+/** How far, in points, a running foot may drift from page to page. */
+var FOOT_DRIFT = 4;
+/**
+* The lines at the very bottom of a page, where they stand ALONE below the text
+* block.
+*
+* Alone means the white above them is more than the page's own leading — a last
+* paragraph is a line's gap from the one before it, a running foot is several.
+*
+* A foot need not be ONE line. ZapfDingbats.pdf signs each page twice, the
+* publisher's line and the suite's title on one baseline and the build stamp
+* thirty points below it, and taking only the bottom line left the other in the
+* body: after a table that fills the sheet it had nowhere to go but a page of
+* 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 fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const rows = rowsOf(runs, fontSize);
+	if (rows.length < 4) 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));
+	let found;
+	let group = [];
+	const most = where === "foot" ? FOOT_ROWS : 1;
+	for (let i = 0; i < Math.min(most, rows.length - 2); i++) {
+		const row = at(i);
+		const edge = edgeY(row);
+		if (where === "foot" ? edge > pageHeight * FOOT_BAND : edge < pageHeight * (1 - FOOT_BAND)) break;
+		group = [...group, ...row];
+		const next = at(i + 1);
+		if ((where === "foot" ? inside(next) - edgeY(row) : edgeY(row) - inside(next)) < fontSize * FOOT_GAP_EM) continue;
+		const text = group.map((r) => r.text).join("").trim();
+		if (text.length > 0 && text.length <= FOOT_CHARS * (i + 1)) found = group;
+	}
+	return found ? {
+		y,
+		runs: found
+	} : void 0;
+}
+/** How much white, in ems, stands between the text block and a running foot. */
+var FOOT_GAP_EM = 2;
+/** How many lines a running foot may hold before it is a paragraph. */
+var FOOT_ROWS = 3;
+/** How far up the sheet a running foot may sit. */
+var FOOT_BAND = .12;
+/** A running foot is a line, not a paragraph. */
+var FOOT_CHARS = 90;
+/**
+* §17.16.5.35 — the number in a run, made the field it stands for.
+*
+* A foot reads "1" or "Chapter 3 — 47", and the number is not the text: it is
+* 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.
+* @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);
+	if (!found || run.field !== void 0) return [run];
+	const at = found.index + found[1].length;
+	const number = found[2];
+	const before = run.text.slice(0, at);
+	const after = run.text.slice(at + number.length);
+	return [
+		...before === "" ? [] : [{
+			...run,
+			text: before
+		}],
+		{
+			...run,
+			text: number,
+			field: "PAGE"
+		},
+		...after === "" ? [] : [{
+			...run,
+			text: after
+		}]
+	];
+}
+/**
+* The band itself: the foot's own line, with the number in it made a field.
+*
+* §17.16.5.35 — a page number is not the text "1"; it is the number of the page
+* it is drawn on, which is why the same band serves every page.
+*
+* A foot is written in REGIONS, the way a spreadsheet's is: something at the
+* left of the sheet, something at the middle, something against the far edge.
+* ZapfDingbats.pdf signs each page "© RenderX 2000" at the left and "XSL
+* Formatting Objects Test Suite" at the right, and the two hundred points
+* between them came back as one word space, the two texts crowding each other
+* at the left. They stand on TAB STOPS instead (§17.3.1.38), which is what the
+* two hundred points are.
+*
+* @param runs     The foot's runs.
+* @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.
+*/
+function footerBand(runs, stepped, measure, numbered) {
+	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);
+		if (el.kind !== "paragraph") return el;
+		return {
+			kind: "paragraph",
+			paragraph: {
+				...el.paragraph,
+				runs: numbered ? el.paragraph.runs.flatMap((run) => pageNumbered(run)) : el.paragraph.runs
+			}
+		};
+	});
+}
+/**
+* One line of a running head or foot: its spans, and the placement that puts
+* them where the page had them.
+*
+* A wide gap inside such a line is not a word space, it is the space BETWEEN
+* REGIONS — and each region after the first stands on a tab stop, at the middle
+* of the band or against its far edge, whichever it was written at.
+*
+* @param row      The line's runs.
+* @param fontSize The band's size, for the runs that state none.
+* @param stepped  Whether the page steps between its words.
+* @param measure  The measure the band was set across.
+* @returns The line, or `undefined` where it holds no text.
+*/
+function bandLine(row, fontSize, stepped, measure) {
+	const ordered = [...row].sort((a, b) => a.x - b.x);
+	const pieces = [[]];
+	for (const run of ordered) {
+		const last = pieces[pieces.length - 1];
+		const prev = last[last.length - 1];
+		if (prev && run.x - prev.endX > (run.fontSizePt || fontSize) * BAND_REGION_EM) pieces.push([]);
+		pieces[pieces.length - 1].push(run);
+	}
+	const y = Math.max(...ordered.map((r) => r.y));
+	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);
+		return {
+			spans: lines.flatMap((line, i) => i === 0 ? line.spans : [{ text: " " }, ...line.spans]),
+			properties: alignment ? { alignment } : {}
+		};
+	}
+	const width = measure.right - measure.left;
+	const spans = [...lines[0].spans];
+	const tabs = [];
+	for (const line of lines.slice(1)) {
+		const flush = measure.right - (line.x + line.width) <= width * BAND_RIGHT_SHARE;
+		tabs.push({
+			positionPt: pt(0),
+			relativeTo: flush ? "right" : "center",
+			alignment: flush ? "right" : "center"
+		});
+		spans.push({ text: "	" }, ...line.spans);
+	}
+	return {
+		spans,
+		properties: { tabs }
+	};
+}
+/** A gap this wide, in ems, stands BETWEEN the regions of a head or foot. */
+var BAND_REGION_EM = 4;
+/** How many regions a band line may hold — left, centre, right. */
+var BAND_REGIONS = 3;
+/** How near the far edge a region has to end to be set against it. */
+var BAND_RIGHT_SHARE = .05;
+/**
+* Whether the page is RULED into columns rather than SET in them.
+*
+* A page of two columns and a page of two columns of a table look alike from
+* here: both have gutters, and both put their lines on one baseline grid — a
+* paper's columns are set on the same grid as a matter of course, so "the rows
+* line up" says nothing. What separates them is the CELL: a line of prose fills
+* its measure and a cell does not. Across this corpus a paper's lines cover 84
+* to 95 per cent of their column, and ZapfDingbats.pdf's cells cover 45.
+*
+* Read by column, its five hundred entries came back one column at a time with
+* every row torn into three — "1 a17", "[x2711]", "2 a18" — over five pages.
+* Read by ROW, which is what a ruled page says, each entry is a line of its own.
+*
+* @param runs    The page's runs.
+* @param gutters The page's gutters.
+* @param edges   Where the page's text starts and ends.
+*/
+function looksRuled(runs, gutters, edges) {
+	if (gutters.length < MIN_RULED_GUTTERS || !edges) return false;
+	const rows = rowsOf(runs, median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10).filter((row) => row.length > 0);
+	if (rows.length < MIN_TABLE_ROWS) return false;
+	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 fills = [];
+	let aligned = 0;
+	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;
+			const from = Math.min(...inRegion.map((r) => r.x));
+			const to = Math.max(...inRegion.map((r) => r.endX));
+			const width = regions[i][1] - regions[i][0];
+			if (width > 0) fills.push((to - from) / width);
+		});
+		if (byRegion.every((inRegion) => inRegion.length > 0)) aligned++;
+	}
+	if (aligned < rows.length * TABLE_ALIGNED_SHARE) return false;
+	fills.sort((a, b) => a - b);
+	return (fills[Math.floor(fills.length / 2)] ?? 1) <= TABLE_CELL_FILL;
+}
+/**
+* §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;
+* a cell is what one row leaves in one region, and an empty cell is empty. The
+* grid is measured, so the columns come out where the page put them.
+*
+* The lines the page hangs ABOVE its ruling come back as themselves. A line
+* that crosses every column is not a row of the table — ZapfDingbats.pdf heads
+* each sheet with two red lines of provenance that run wider than the frame
+* drawn under them, and squeezed into a cell they wrapped and cost the sheet a
+* row.
+*
+* @param runs    The page's runs.
+* @param gutters The page's gutters.
+* @param edges   Where the page's text starts and ends.
+* @param stepped Whether the page steps between its words.
+* @returns The blocks, the table among them, each with where it stands.
+*/
+function tableFrom(runs, gutters, edges, stepped) {
+	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const all = rowsOf(runs, fontSize).filter((row) => row.length > 0);
+	if (all.length === 0) return void 0;
+	const bounds = columnBounds(runs, gutters, edges);
+	const regionsAt = (from) => {
+		const regions = from.slice(0, -1).map((lo, i) => [lo, from[i + 1]]);
+		return {
+			regions,
+			of: (x) => {
+				for (let i = regions.length - 1; i >= 0; i--) if (x >= regions[i][0]) return i;
+				return 0;
+			}
+		};
+	};
+	const first = regionsAt(bounds);
+	const oneWideLine = (row) => {
+		const to = spanEnd(row, 0, first.regions.length, first.of);
+		return to > 0 && row.every((run) => first.of(run.x) <= to);
+	};
+	let start = 0;
+	while (start < all.length - 1 && oneWideLine(all[start])) start++;
+	const above = all.slice(0, start);
+	const rows = all.slice(start);
+	const own = rows.filter((row) => spanEnd(row, 0, first.regions.length, first.of) === 0).flatMap((row) => row.filter((run) => first.of(run.x) === 0)).map((run) => runInk(run)?.[0]).filter((x) => x !== void 0);
+	const left = own.length > 0 ? Math.min(...own) : bounds[0];
+	const { regions, of: regionOf } = regionsAt([left, ...bounds.slice(1)]);
+	const flush = regions.map((region, i) => {
+		const starts = [];
+		for (const row of rows) {
+			const at = row.filter((run) => regionOf(run.x) === i).map((run) => runInk(run)?.[0]).filter((x) => x !== void 0);
+			if (at.length > 0) starts.push(Math.min(...at));
+		}
+		if (starts.length === 0) return region[0];
+		starts.sort((a, b) => a - b);
+		return starts[Math.floor(starts.length * COLUMN_LEFT_QUANTILE)] ?? region[0];
+	});
+	const table = {
+		properties: {
+			defaultCellMargins: {
+				left: pt(0),
+				right: pt(0)
+			},
+			layout: "fixed",
+			...left > edges.left ? { indentPt: pt(left - edges.left) } : {}
+		},
+		grid: regions.map((r) => pt(Math.max(r[1] - r[0], 1))),
+		rows: rows.map((row, r) => {
+			const byRegion = regions.map(() => []);
+			for (const run of row) byRegion[regionOf(run.x)].push(run);
+			const y = Math.max(...row.map((r2) => r2.y));
+			const cells = [];
+			for (let i = 0; i < regions.length;) {
+				const to = spanEnd(row, i, regions.length, regionOf);
+				const inSpan = byRegion.slice(i, to + 1).flat();
+				const width = to - i + 1;
+				const size = inSpan.length > 0 ? Math.max(...inSpan.map((r) => r.fontSizePt || fontSize)) : fontSize;
+				const line = inSpan.length > 0 ? lineOf(inSpan, y, size, stepped) : void 0;
+				const placed = line && line.x - flush[i] >= size / 4 ? alignmentOf([line], {
+					left: regions[i][0],
+					right: regions[to][1]
+				}, size / 2) : {};
+				cells.push({
+					properties: width > 1 ? { colSpan: width } : {},
+					content: line === void 0 ? [{
+						kind: "paragraph",
+						paragraph: {
+							properties: {},
+							runs: []
+						}
+					}] : [paragraphFromRuns(line.spans, void 0, placed.alignment ? { alignment: placed.alignment } : {})]
+				});
+				i = to + 1;
+			}
+			const next = rows[r + 1];
+			const pitch = next ? y - Math.max(...next.map((r2) => r2.y)) : 0;
+			return {
+				properties: pitch > 0 ? {
+					height: pt(pitch),
+					heightRule: "atLeast"
+				} : {},
+				cells
+			};
+		})
+	};
+	return [...above.map((row) => {
+		const y = Math.max(...row.map((r) => r.y));
+		return {
+			el: paragraphFromRuns(lineOf(row, y, Math.max(...row.map((r) => r.fontSizePt || fontSize)), stepped).spans),
+			top: y
+		};
+	}), {
+		el: {
+			kind: "table",
+			table
+		},
+		top: Math.max(...rows[0].map((r) => r.y))
+	}];
+}
+/**
+* Where one column of a ruled page ends and the next begins.
+*
+* The gutter is a BAND, and its middle is only a guess at the line inside it: a
+* gutter is where the fewest lines cross, not where none do (see
+* `detectGutters`), so a page whose prose overhangs the first column by a few
+* points has that prose crossing the middle. Cut there, ZapfDingbats.pdf's
+* heading and its lead paragraph either wrapped inside a cell too narrow for
+* them or swallowed the glyph standing beside them. The boundary is put past
+* the crossing ink instead, as far as the band allows — where the columns
+* really do divide.
+*
+* @param runs    The page's runs.
+* @param gutters The page's gutters.
+* @param edges   Where the page's text starts and ends.
+* @returns The column boundaries, left edge first and right edge last.
+*/
+function columnBounds(runs, gutters, edges) {
+	const inks = runs.map((r) => runInk(r)).filter((ink) => ink !== void 0);
+	const clearance = (median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10) / 4;
+	return [
+		edges.left,
+		...gutters.map((g) => {
+			let at = g.mid;
+			for (const [from, to] of inks) if (from < g.mid && to > at && to <= g.to) at = Math.min(to + clearance, g.to);
+			return at;
+		}),
+		edges.right
+	];
+}
+/**
+* The last column a cell starting at `from` covers — the one where no run
+* reaches any further right.
+*
+* A run whose INK ends past a column boundary was drawn as one line across
+* both, so both belong to one cell; and a cell widened that way may pick up a
+* run that crosses the next boundary in turn.
+*
+* @param row       The row's runs.
+* @param from      The column the cell starts in.
+* @param count     How many columns the table has.
+* @param regionOf  Which column an x falls in.
+*/
+function spanEnd(row, from, count, regionOf) {
+	let to = from;
+	for (let grew = true; grew && to < count - 1;) {
+		grew = false;
+		for (const run of row) {
+			const ink = runInk(run);
+			if (ink === void 0) continue;
+			const start = regionOf(ink[0]);
+			if (start < from || start > to) continue;
+			const end = regionOf(ink[1] - 1);
+			if (end > to) {
+				to = Math.min(end, count - 1);
+				grew = true;
+			}
+		}
+	}
+	return to;
+}
+/** Below this many gutters a page in columns is read as columns. */
+var MIN_RULED_GUTTERS = 2;
+/** Below this many rows a page is not ruled into anything. */
+var MIN_TABLE_ROWS = 6;
+/** How many of a table's rows must carry a cell in every one of its columns. */
+var TABLE_ALIGNED_SHARE = .6;
+/**
+* How much of its column a CELL covers, at the median. A line of prose fills
+* its measure — 84 to 95 per cent across this corpus — and a cell does not.
+*/
+var TABLE_CELL_FILL = .65;
 //#endregion
 export { endedParagraph, reconstructByLayout };