reamkit 1.28.0 → 1.29.0

package/dist/esm/core/converter/ream.d.ts

@@ -29,6 +29,14 @@ export interface ReamParseOptions {
      * carrying one for every filter anyone might write:
      *
      * ```ts
+     * // browser: any wasm/JS decoder you ship — brotli-dec-wasm is ~200 KB
+     * import brotliPromise from 'brotli-dec-wasm';
+     * const brotli = await brotliPromise;
+     * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotli.decompress(b) } });
+     * ```
+     *
+     * ```ts
+     * // node, where the runtime already carries one
      * import { brotliDecompressSync } from 'node:zlib';
      * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotliDecompressSync(b) } });
      * ```

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

@@ -32,7 +32,8 @@ function parseToUnicodeCMap(bytes) {
 			if (src.kind !== "hexstr") continue;
 			const dst = lexer.nextToken();
 			if (dst.kind !== "hexstr") continue;
-			map.set(bytesToInt(src.bytes), utf16be(dst.bytes));
+			const text = stated(utf16be(dst.bytes));
+			if (text !== void 0) map.set(bytesToInt(src.bytes), text);
 		}
 		else if (tok.value === "beginbfrange") for (;;) {
 			const lo = lexer.nextToken();
@@ -44,14 +45,17 @@ function parseToUnicodeCMap(bytes) {
 			const hiN = bytesToInt(hi.bytes);
 			const dst = lexer.nextToken();
 			if (dst.kind === "hexstr") {
-				const base = utf16be(dst.bytes);
-				for (let i = 0; loN + i <= hiN && i < MAX_RANGE; i++) map.set(loN + i, incString(base, i));
+				const base = stated(utf16be(dst.bytes));
+				if (base !== void 0) for (let i = 0; loN + i <= hiN && i < MAX_RANGE; i++) map.set(loN + i, incString(base, i));
 			} else if (dst.kind === "arrayOpen") {
 				let i = 0;
 				for (;;) {
 					const el = lexer.nextToken();
 					if (el.kind === "arrayClose" || el.kind === "eof") break;
-					if (el.kind === "hexstr") map.set(loN + i++, utf16be(el.bytes));
+					if (el.kind !== "hexstr") continue;
+					const text = stated(utf16be(el.bytes));
+					if (text !== void 0) map.set(loN + i, text);
+					i++;
 				}
 			}
 		}
@@ -61,6 +65,9 @@ function parseToUnicodeCMap(bytes) {
 		codeBytes
 	};
 }
+function stated(text) {
+	for (const ch of text) if (ch !== "\0") return text;
+}
 function bytesToInt(bytes) {
 	let n = 0;
 	for (const b of bytes) n = n * 256 + b;

package/dist/esm/pdf-reader/content.d.ts

@@ -328,7 +328,22 @@ export interface Type3Call {
     readonly ctm: Matrix;
     /** §8.5.3 — its place in the stream's painting order, as a form call has. */
     readonly order: number;
+    /**
+     * §9.6.5/§9.10 — the font SAYS what character this glyph stands for. A
+     * flowing reading re-sets that character in a face of its own, so drawing the
+     * procedure as well puts two copies of the letter on the page.
+     */
+    readonly readable: boolean;
 }
+/**
+ * §9.10 — whether the font says what character a glyph stands for: text that is
+ * neither empty nor the replacement character a reader writes where nothing is
+ * stated.
+ *
+ * @param text What the font's decode gave for the code.
+ * @returns Whether a flowing reading can write it as a letter.
+ */
+export declare function statesACharacter(text: string): boolean;
 /**
  * 2D affine matrix `[a b c d e f]`, row-vector convention (`[x y 1] · M`):
  * ```

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

@@ -35,6 +35,18 @@ function pathBox(segs) {
 }
 /** The area of a box, for choosing the smaller of two clip regions. */
 var area = (b) => Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
+/**
+* §9.10 — whether the font says what character a glyph stands for: text that is
+* neither empty nor the replacement character a reader writes where nothing is
+* stated.
+*
+* @param text What the font's decode gave for the code.
+* @returns Whether a flowing reading can write it as a letter.
+*/
+function statesACharacter(text) {
+	const trimmed = text.trim();
+	return trimmed.length > 0 && !trimmed.includes("�");
+}
 /** The identity {@link Matrix} (no transform). */
 var IDENTITY = [
 	1,
@@ -284,7 +296,8 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 					stream,
 					resources: type3.resources,
 					ctm: multiply(type3.matrix, multiply(scale, multiply(tm, state.ctm))),
-					order: paintOrder++
+					order: paintOrder++,
+					readable: statesACharacter(state.font.decode([code]))
 				});
 			}
 		}

package/dist/esm/pdf-reader/document.d.ts

@@ -110,6 +110,14 @@ export declare class PdfFile {
  * reader takes one from whoever needs it:
  *
  * ```ts
+ * // browser: any wasm/JS decoder you ship — brotli-dec-wasm is ~200 KB
+ * import brotliPromise from 'brotli-dec-wasm';
+ * const brotli = await brotliPromise;
+ * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotli.decompress(b) } });
+ * ```
+ *
+ * ```ts
+ * // node, where the runtime already carries one
  * import { brotliDecompressSync } from 'node:zlib';
  * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotliDecompressSync(b) } });
  * ```

package/dist/esm/pdf-reader/flow-build.d.ts

@@ -66,7 +66,7 @@ export interface TextSpan {
  * survives as its own run) and squashing whitespace. With no hrefs this
  * collapses to a single run — the same shape {@link paragraphBlock} produces.
  */
-export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlineLevel?: number, placement?: Pick<ParagraphProperties, 'alignment' | 'spacingBefore' | 'indentLeft' | 'indentFirstLine'>): BodyElement;
+export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlineLevel?: number, placement?: Pick<ParagraphProperties, 'alignment' | 'spacingBefore' | 'indentLeft' | 'indentFirstLine' | 'tabs'>): BodyElement;
 /**
  * Store a {@link PdfImage}'s bytes (content-addressed dedup) and build the image
  * {@link BodyElement} that references them, sized in points from the placement
@@ -126,7 +126,12 @@ export declare function sectionFromPdfPages(pages: ReadonlyArray<PdfPage>): Sect
 export declare function withMeasuredMargins(section: SectionProperties | undefined, shown: ReadonlyArray<{
     width: number;
     height: number;
-}>, pageRuns: ReadonlyArray<ReadonlyArray<TextRun>>): SectionProperties | undefined;
+}>, pageRuns: ReadonlyArray<ReadonlyArray<TextRun>>, pageMarks?: ReadonlyArray<ReadonlyArray<{
+    x: number;
+    y: number;
+    widthPt: number;
+    heightPt: number;
+}>>): SectionProperties | undefined;
 /**
  * Assemble the final {@link FlowDoc} for a reconstruction: the body elements
  * with their styles resolved against the empty style sheet, the lifted-image

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

@@ -333,7 +333,7 @@ var DEEPEST_MARGIN = .5;
 var ASCENDER = .8;
 /** And its descender below — the two together are a little over one em. */
 var DESCENDER = .22;
-function withMeasuredMargins(section, shown, pageRuns) {
+function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 	if (!section?.pageSize) return section;
 	const width = section.pageSize.width;
 	const height = section.pageSize.height;
@@ -352,8 +352,10 @@ function withMeasuredMargins(section, shown, pageRuns) {
 		let bottomSize = 0;
 		for (const r of runs) {
 			if (!Number.isFinite(r.x) || !Number.isFinite(r.y)) continue;
-			minX = Math.min(minX, r.x);
-			maxX = Math.max(maxX, r.endX);
+			if (r.text.trim() !== "") {
+				minX = Math.min(minX, r.x);
+				maxX = Math.max(maxX, r.endX);
+			}
 			if (r.y < minY) {
 				minY = r.y;
 				bottomSize = r.fontSizePt;
@@ -363,6 +365,11 @@ function withMeasuredMargins(section, shown, pageRuns) {
 				topSize = r.fontSizePt;
 			}
 		}
+		for (const mark of pageMarks[i] ?? []) {
+			if (!Number.isFinite(mark.x) || !Number.isFinite(mark.y)) continue;
+			maxX = Math.max(maxX, mark.x + mark.widthPt);
+			minY = Math.min(minY, mark.y);
+		}
 		if (!Number.isFinite(minX) || !Number.isFinite(minY)) return;
 		lefts.push(minX);
 		rights.push(page.width - maxX);
@@ -378,7 +385,7 @@ function withMeasuredMargins(section, shown, pageRuns) {
 	return {
 		...section,
 		margins: {
-			left: clamp(median(lefts), width),
+			left: clamp(Math.min(...lefts), width),
 			right: clamp(median(rights) - width * SLACK, width),
 			top: clamp(Math.min(...tops), height, DEEPEST_MARGIN),
 			bottom: clamp(Math.min(...bottoms) - height * SLACK, height, DEEPEST_MARGIN)

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

@@ -36,6 +36,7 @@ function reconstructByLayout(file, mode = "flow") {
 	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 pageMarks = pages.map(() => []);
 	const medianFont = median(pageRuns.flat().map((r) => r.fontSizePt).filter((s) => s > 0)) || 12;
 	const resources = new ResourceStore();
 	const losses = [];
@@ -71,12 +72,13 @@ 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)) {
 					if (line.text.length === 0) continue;
@@ -121,17 +123,38 @@ 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), {
-					...para.alignment !== void 0 ? { alignment: para.alignment } : {},
-					...para.spacingBefore !== void 0 ? { spacingBefore: pt(para.spacingBefore) } : {},
-					...para.indentLeft !== void 0 ? { indentLeft: pt(para.indentLeft) } : {},
-					...para.indentFirstLine !== void 0 ? { indentFirstLine: pt(para.indentFirstLine) } : {}
-				})
+			const paras = groupIntoParagraphs(lines, measure, display.height);
+			const asRows = tabbedRows(paras, measure && {
+				left: measure.left,
+				right: Math.max(measure.right, textEdges?.right ?? measure.right)
 			});
+			for (const [at, para] of paras.entries()) {
+				const table = asRows.get(at);
+				if (table !== void 0) {
+					if (table !== null) blocks.push({
+						band: bandAt(para.top),
+						col,
+						top: para.top,
+						el: table
+					});
+					continue;
+				}
+				blocks.push({
+					band: bandAt(para.top),
+					col,
+					top: para.top,
+					el: paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont), {
+						...para.stops !== void 0 && para.stops.length > 0 ? { tabs: para.stops.filter((x) => x > 0).map((x) => ({
+							positionPt: pt(x),
+							alignment: "left"
+						})) } : {},
+						...para.alignment !== void 0 ? { alignment: para.alignment } : {},
+						...para.spacingBefore !== void 0 ? { spacingBefore: pt(para.spacingBefore) } : {},
+						...para.indentLeft !== void 0 ? { indentLeft: pt(para.indentLeft) } : {},
+						...para.indentFirstLine !== void 0 ? { indentFirstLine: pt(para.indentFirstLine) } : {}
+					})
+				});
+			}
 		};
 		const placed = [];
 		const colOf = (centerX) => gutters.filter((g) => centerX >= g.mid).length;
@@ -145,6 +168,7 @@ function reconstructByLayout(file, mode = "flow") {
 			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,
@@ -154,7 +178,8 @@ 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 strayGlyphs = strayMarks(placedVectors, runs);
+		const vectors = placedVectors.filter((v) => !ruled.consumed.has(v)).filter((v) => !(mode !== "positional" && strayGlyphs.has(v)));
 		const ruledIntoColumns = mode !== "positional" && looksRuled(ruled.runs, gutters, textEdges);
 		const asTable = ruledIntoColumns && textEdges ? tableFrom(ruled.runs, gutters, textEdges, stepped) : void 0;
 		if (asTable) for (const block of asTable) blocks.push({
@@ -169,6 +194,7 @@ 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";
+		const givenAway = mode !== "positional" ? ruleBorders(vectors, blocks, display.width) : void 0;
 		[
 			...imgs.images.map((img) => ({
 				key: img.orderKey,
@@ -176,7 +202,7 @@ function reconstructByLayout(file, mode = "flow") {
 				top: img.y + img.heightPt,
 				make: (z) => imageBlock(img, resources, void 0, frame, z, under)
 			})),
-			...vectors.map((v) => ({
+			...vectors.filter((v) => givenAway?.has(v) !== true).map((v) => ({
 				key: v.orderKey,
 				col: colOf((v.minX + v.maxX) / 2),
 				top: v.maxY,
@@ -218,7 +244,7 @@ function reconstructByLayout(file, mode = "flow") {
 				runs: []
 			}
 		});
-		const columnsHere = ruledIntoColumns ? 1 : gutters.length + 1;
+		const columnsHere = ruledIntoColumns || !proseColumns(runs, gutters, textEdges) ? 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;
@@ -241,7 +267,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));
 	};
 	sectionEnds.push({
 		at: body.length,
@@ -302,9 +328,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 +341,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 +479,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
@@ -781,7 +825,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 || runs.length > 1 && !runs.some((r) => SPACE.test(r.text)));
+	const { spans: ordered, stops } = 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 {
@@ -790,6 +834,7 @@ function lineOf(runs, y, fontSize, stepped) {
 		y,
 		fontSize,
 		...tabbed(runs, fontSize) ? { tabbed: true } : {},
+		...stops.length > 0 ? { stops } : {},
 		text: spans.map((s) => s.text).join("").replace(/\s+/g, " ").trim(),
 		spans
 	};
@@ -887,11 +932,15 @@ function stepsBetweenWords(runs) {
 }
 function lineSpans(runs, fontSize, stepped) {
 	const spans = [];
+	const stops = [];
 	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: " " });
+		if (prev !== void 0 && run.x - prev.endX > spaceGap(prev, fontSize, stepped) && !(isLeader(prev.text) && prev.text === run.text)) if (run.x - prev.endX >= (run.fontSizePt || fontSize) * TAB_GAP_EM) {
+			spans.push({ text: "	" });
+			stops.push(run.x);
+		} else spans.push({ text: " " });
 		spans.push({
 			text: run.text.replaceAll("�", ""),
 			sizePt: run.fontSizePt,
@@ -909,7 +958,10 @@ function lineSpans(runs, fontSize, stepped) {
 		});
 		prev = run;
 	}
-	return spans;
+	return {
+		spans,
+		stops
+	};
 }
 /**
 * §17.3.2.42 — a run set off the line's baseline, and smaller, as the script it
@@ -960,6 +1012,24 @@ 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;
+/**
+* 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) {
 	const groups = [];
 	const gaps = [];
@@ -967,7 +1037,7 @@ 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) || carriesLeader(prev) || prev.tabbed === true)) {
+		if (groups.length === 0 || opened || ruleOfCharacters(line) || prev !== void 0 && (ruleOfCharacters(prev) || endedParagraph(prev, line, column) || carriesLeader(prev) || prev.tabbed === true)) {
 			groups.push([]);
 			gaps.push(prev === void 0 ? 0 : gap);
 		}
@@ -982,10 +1052,12 @@ function groupIntoParagraphs(lines, column, pageHeight = 0) {
 		const opened = (gaps[i] ?? 0) - fontSize * 1.2;
 		const most = pageHeight > 0 ? pageHeight / 3 : fontSize * 3;
 		const spacingBefore = opened > fontSize * .3 ? Math.min(opened, most) : void 0;
+		const stops = g.length === 1 ? first.stops ?? [] : [];
 		return {
 			spans: joinLines(g),
 			fontSize,
 			top: first.y,
+			...stops.length > 0 ? { stops: stops.map((x) => x - (column?.left ?? columnLeft)) } : {},
 			...spacingBefore !== void 0 ? { spacingBefore } : {},
 			...alignmentOf(g, column),
 			...indentOf(g, columnLeft, alignmentOf(g, column).alignment)
@@ -1204,11 +1276,21 @@ 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;
+	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));
+	if (rows.length < 4) {
+		const inked = rows.filter((row) => row.some((r) => r.text.trim() !== ""));
+		const inBand = inked.length > 0 && inked.every((row) => where === "foot" ? edgeY(row) <= pageHeight * FOOT_BAND : edgeY(row) >= pageHeight * (1 - FOOT_BAND));
+		const 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;
@@ -1252,6 +1334,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 +1363,7 @@ function pageNumbered(run) {
 			text: number,
 			field: "PAGE"
 		},
-		...after === "" ? [] : [{
-			...run,
-			text: after
-		}]
+		...tail
 	];
 }
 /**
@@ -1404,6 +1502,281 @@ 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 size = v.maxY - v.minY || 10;
+		const words = readable.filter((r) => Math.abs(r.y - mid) <= size);
+		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;
+}
+/** 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 edges = [
+			0,
+			...bounds,
+			width
+		];
+		out.set(i, {
+			kind: "table",
+			table: {
+				properties: {
+					defaultCellMargins: {
+						left: pt(0),
+						right: pt(0)
+					},
+					layout: "fixed"
+				},
+				grid: edges.slice(0, -1).map((from, k) => pt(Math.max(edges[k + 1] - from, 1))),
+				rows: rows.map((row, r) => {
+					const prev = rows[r - 1];
+					const pitch = prev ? prev.top - row.top - row.fontSize * 1.2 : 0;
+					const opening = r === 0 ? row.spacingBefore : pitch > row.fontSize * .3 ? pitch : void 0;
+					return {
+						properties: {},
+						cells: splitAtTabs(row.spans).map((cell) => ({
+							properties: {},
+							content: [paragraphFromRuns(cell, void 0, opening !== void 0 ? { spacingBefore: pt(opening) } : {})]
+						}))
+					};
+				})
+			}
+		});
+		for (let k = i + 1; k < to; k++) out.set(k, null);
+		i = to;
+	}
+	return out;
+}
+/** 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 v of vectors) {
+		if (!separatorRule(v, width)) 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;
+		side.block.el = {
+			kind: "paragraph",
+			paragraph: {
+				...paragraph,
+				properties: {
+					...paragraph.properties,
+					borders: {
+						...paragraph.properties.borders,
+						[side.edge]: border
+					}
+				}
+			}
+		};
+		given.add(v);
+	}
+	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 a RULE — a line drawn to separate one block from
+* the next, rather than a piece of the page's artwork.
+*
+* Flat and long: a hairline the width of a column under a table's headings, or
+* the line a total is written over. Everything else — boxes, panels, drawings —
+* keeps the place on the page it was drawn at.
+*
+* @param v     The painted path.
+* @param width The page's width, which the rule is long RELATIVE to.
+* @returns Whether it separates blocks rather than drawing something.
+*/
+function separatorRule(v, width) {
+	const w = v.maxX - v.minX;
+	const h = v.maxY - v.minY;
+	return h <= RULE_THICK_PT && w >= width * RULE_SHARE && w > h * RULE_RATIO;
+}
+/** 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;

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

@@ -323,7 +323,7 @@ function reconstructTaggedPdf(file) {
 	const reached = [...claimed].reduce((n, r) => n + r.text.length, 0);
 	if (onPage > 0 && reached * 2 < onPage) return void 0;
 	return {
-		doc: buildFlowDoc(body, resources, withMeasuredMargins(sectionFromPdfPages(pages), shown, placedRuns), collectEmbeddedFonts(file, pages, imageLosses)),
+		doc: buildFlowDoc(body, resources, withMeasuredMargins(sectionFromPdfPages(pages), shown, placedRuns, pageImages.map((p) => p.images)), collectEmbeddedFonts(file, pages, imageLosses)),
 		losses: imageLosses
 	};
 }

package/dist/esm/pdf-reader/vector.d.ts

@@ -37,6 +37,8 @@ export interface PdfVector {
     readonly minY: number;
     readonly maxX: number;
     readonly maxY: number;
+    /** §9.6.6 — a traced glyph rather than artwork: type the file states no character for. */
+    readonly glyph?: boolean;
     readonly mcid?: number;
 }
 /**

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

@@ -199,6 +199,7 @@ function collectPageVectors(file, page, occupied = []) {
 				...v.lineWidth !== void 0 ? { lineWidth: v.lineWidth } : {}
 			} : {},
 			...b,
+			...v.glyph === true ? { glyph: true } : {},
 			...v.mcid !== void 0 ? { mcid: v.mcid } : {}
 		});
 	}

package/dist/esm/word/docx-writer.js

@@ -482,7 +482,7 @@ function chartBlockXml(chart, state, scope, losses) {
 	const cx = Math.round(chart.width * EMU_PER_PT);
 	const cy = Math.round(chart.height * EMU_PER_PT);
 	const id = ++state.drawingSeq;
-	return `<w:drawing><wp:inline xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"><wp:extent cx="${cx}" cy="${cy}"/><wp:docPr id="${id}" name="Chart ${id}"${chart.altText ? ` descr="${escapeAttr(chart.altText)}"` : ""}/><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:id="${relId}"/></a:graphicData></a:graphic></wp:inline></w:drawing>`;
+	return `<w:drawing><wp:inline xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${cx}" cy="${cy}"/><wp:docPr id="${id}" name="Chart ${id}"${chart.altText ? ` descr="${escapeAttr(chart.altText)}"` : ""}/><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:id="${relId}"/></a:graphicData></a:graphic></wp:inline></w:drawing>`;
 }
 /**
 * §20.4.2.3 — the frame a drawing is placed by: `wp:anchor` where the block
@@ -510,7 +510,7 @@ function chartBlockXml(chart, state, scope, losses) {
 */
 function drawingFrame(float, cx, cy, head, graphic, state, rotation60k) {
 	const WP_NS = " xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\"";
-	if (!float) return `<w:drawing><wp:inline${WP_NS}><wp:extent cx="${cx}" cy="${cy}"/>${head}${graphic}</wp:inline></w:drawing>`;
+	if (!float) return `<w:drawing><wp:inline${WP_NS} distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${cx}" cy="${cy}"/>${head}${graphic}</wp:inline></w:drawing>`;
 	const emu = (pt) => Number.isFinite(pt) ? Math.round((pt ?? 0) * EMU_PER_PT) : 0;
 	const d = float.wrapDist;
 	const dist = ` distT="${String(emu(d?.topPt))}" distB="${String(emu(d?.bottomPt))}" distL="${String(emu(d?.leftPt))}" distR="${String(emu(d?.rightPt))}"`;
@@ -821,22 +821,27 @@ function runXml(run, state, scope) {
 	if (run.noteNumber) return `<w:r>${rPr}<${scope.noteKind === "endnote" ? "w:endnoteRef" : "w:footnoteRef"}/></w:r>`;
 	if (run.commentRef !== void 0) return `<w:r>${rPr}<w:commentReference w:id="${escapeAttr(run.commentRef)}"/></w:r>`;
 	const brk = run.pageBreak ? "<w:br w:type=\"page\"/>" : "";
+	if (run.field !== void 0 && run.text !== "") {
+		const inner = `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(run.text)}</w:t></w:r>`;
+		return `<w:fldSimple w:instr=" ${run.field} ">${inner}</w:fldSimple>${brk}`;
+	}
 	if (run.text === "") return brk ? `<w:r>${rPr}${brk}</w:r>` : "";
-	return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(run.text)}</w:t>${brk}</w:r>`;
+	return `<w:r>${rPr}${run.text.split("	").map((piece) => piece === "" ? "" : `<w:t xml:space="preserve">${escapeXml(piece)}</w:t>`).join("<w:tab/>")}${brk}</w:r>`;
 }
 function rPrXml(r) {
 	const out = [];
+	const states = (key) => r[key] !== void 0 && r[key] !== DEFAULT_RUN[key];
 	const fonts = rFontsXml(r.fontFamily);
 	if (fonts) out.push(fonts);
-	if (r.bold !== DEFAULT_RUN.bold) out.push(toggle("w:b", r.bold));
-	if (r.italic !== DEFAULT_RUN.italic) out.push(toggle("w:i", r.italic));
-	if (r.strike !== DEFAULT_RUN.strike) out.push(toggle("w:strike", r.strike));
-	if (r.colorHex !== DEFAULT_RUN.colorHex) out.push(`<w:color w:val="${r.colorHex}"/>`);
-	if (r.fontSizePt !== DEFAULT_RUN.fontSizePt) out.push(`<w:sz w:val="${Math.round(r.fontSizePt * 2)}"/>`);
-	if (r.underline !== DEFAULT_RUN.underline) out.push(underlineXml(r));
+	if (states("bold")) out.push(toggle("w:b", r.bold));
+	if (states("italic")) out.push(toggle("w:i", r.italic));
+	if (states("strike")) out.push(toggle("w:strike", r.strike));
+	if (states("colorHex")) out.push(`<w:color w:val="${r.colorHex}"/>`);
+	if (states("fontSizePt")) out.push(`<w:sz w:val="${Math.round(r.fontSizePt * 2)}"/>`);
+	if (states("underline")) out.push(underlineXml(r));
 	if (r.shadingColorHex !== void 0) out.push(runShdXml(r.shadingColorHex));
-	if (r.verticalAlign !== DEFAULT_RUN.verticalAlign) out.push(`<w:vertAlign w:val="${r.verticalAlign}"/>`);
-	if (r.rtl !== DEFAULT_RUN.rtl) out.push(toggle("w:rtl", r.rtl));
+	if (states("verticalAlign")) out.push(`<w:vertAlign w:val="${r.verticalAlign}"/>`);
+	if (states("rtl")) out.push(toggle("w:rtl", r.rtl));
 	if (r.lang !== void 0) out.push(`<w:lang w:val="${escapeAttr(r.lang)}"/>`);
 	return out.length > 0 ? `<w:rPr>${out.join("")}</w:rPr>` : "";
 }
@@ -858,6 +863,17 @@ function pPrBody(p) {
 	const spacing = spacingXml(p);
 	if (spacing) out.push(spacing);
 	if (JC.has(p.alignment) && p.alignment !== DEFAULT_PARA.alignment) out.push(`<w:jc w:val="${p.alignment}"/>`);
+	const pBdr = bordersXml("w:pBdr", p.borders);
+	if (pBdr) out.push(pBdr);
+	const tabs = p.tabs ?? [];
+	if (tabs.length > 0) {
+		const stops = tabs.map((t) => {
+			const pos = twips(t.positionPt);
+			const leader = t.leader !== void 0 ? ` w:leader="${escapeAttr(t.leader)}"` : "";
+			return `<w:tab w:val="${escapeAttr(t.alignment ?? "left")}" w:pos="${String(pos)}"${leader}/>`;
+		}).join("");
+		out.push(`<w:tabs>${stops}</w:tabs>`);
+	}
 	return out.join("");
 }
 function pPrWithSect(p, closingSectPr) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reamkit",
-  "version": "1.28.0",
+  "version": "1.29.0",
   "description": "Ream — convert DOCX, XLSX, PPTX and PDF to PDF, SVG, HTML, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
   "author": "Alex Krassavin <info@reamkit.dev>",