reamkit 1.26.0 → 1.28.0

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

@@ -45,6 +45,8 @@ export declare class Lexer {
     constructor(buf: Uint8Array, pos?: number);
     /** The length of the underlying byte buffer. */
     get length(): number;
+    /** The bytes between two offsets, as a view onto the buffer. */
+    slice(from: number, to: number): Uint8Array;
     /** The byte at index `i`, or −1 when out of range. */
     byteAt(i: number): number;
     /** §7.2.3 — skip whitespace and `%`-to-end-of-line comments. */

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

@@ -34,6 +34,10 @@ var Lexer = class {
 	get length() {
 		return this.buf.length;
 	}
+	/** The bytes between two offsets, as a view onto the buffer. */
+	slice(from, to) {
+		return this.buf.subarray(Math.max(0, from), Math.min(this.buf.length, Math.max(from, to)));
+	}
 	/** The byte at index `i`, or −1 when out of range. */
 	byteAt(i) {
 		return i >= 0 && i < this.buf.length ? this.buf[i] : -1;

package/dist/esm/pdf-reader/math-rows.d.ts

@@ -0,0 +1,23 @@
+import { MathNode } from '../core/document-model/index.js';
+import { TextRun } from './content.js';
+/** A matrix found on the page: what to draw, where, and which runs it used. */
+export interface MathBlock {
+    /** The math object — a row of delimiters and whatever stands between them. */
+    readonly math: MathNode;
+    /** The top baseline it was drawn on, for ordering the page's blocks. */
+    readonly top: number;
+    /** Where it stands across the page. */
+    readonly x: number;
+    readonly width: number;
+    /** The runs it consumed, which the prose reading must not read again. */
+    readonly used: ReadonlySet<TextRun>;
+}
+/**
+ * The matrices a page's rows hold (§22.1.2.68 `m:m`).
+ *
+ * @param runs     The column's runs.
+ * @param fontSize The text's own size, which says how far apart the lines of
+ *                 PROSE stand — a display's sub-lines stand closer.
+ * @returns One entry per matrix found, in page order.
+ */
+export declare function matrixBlocks(runs: ReadonlyArray<TextRun>, fontSize: number): Array<MathBlock>;

package/dist/esm/pdf-reader/math-rows.js

@@ -0,0 +1,198 @@
+//#region src/pdf-reader/math-rows.ts
+/** The brackets a matrix may be written in, opening → closing. */
+var BRACKETS = new Map([
+	["(", ")"],
+	["[", "]"],
+	["{", "}"],
+	["⟨", "⟩"],
+	["|", "|"]
+]);
+/**
+* The matrices a page's rows hold (§22.1.2.68 `m:m`).
+*
+* @param runs     The column's runs.
+* @param fontSize The text's own size, which says how far apart the lines of
+*                 PROSE stand — a display's sub-lines stand closer.
+* @returns One entry per matrix found, in page order.
+*/
+function matrixBlocks(runs, fontSize) {
+	const out = [];
+	for (const cluster of clusters(baselines(runs, fontSize), fontSize)) {
+		const found = matrixFrom(cluster);
+		if (found) out.push(found);
+	}
+	return out;
+}
+/** The baseline a row of runs stands on. */
+var baselineOf = (row) => Math.max(...row.map((r) => r.y));
+/**
+* The runs grouped by the baseline they were DRAWN on, top to bottom.
+*
+* Tighter than the reading's own rows, which allow a line half an em of drift
+* so that a footnote mark stays with its word: the sub-lines of a display stand
+* six points apart in a ten-point face, and grouped that loosely
+* bug1997343.pdf's brackets joined the row of numbers under them.
+*/
+function baselines(runs, fontSize) {
+	const tol = Math.max(1, fontSize * SAME_BASELINE);
+	const out = [];
+	for (const run of [...runs].sort((a, b) => b.y - a.y || a.x - b.x)) {
+		const last = out[out.length - 1];
+		if (last && Math.abs(baselineOf(last) - run.y) <= tol) last.push(run);
+		else out.push([run]);
+	}
+	return out;
+}
+/** How far off a baseline, in ems, a run may sit and still be ON it. */
+var SAME_BASELINE = .15;
+/**
+* The runs of a page grouped into the SUB-LINES of one display: rows standing
+* closer together than a line of prose does, three or more of them (two rows
+* and the brackets between).
+*/
+function clusters(rows, fontSize) {
+	const out = [];
+	let run = [];
+	for (const row of rows) {
+		const last = run[run.length - 1];
+		if (last && baselineOf(last) - baselineOf(row) >= fontSize * SUBLINE_GAP) {
+			if (run.length >= MIN_SUBLINES) out.push(run);
+			run = [];
+		}
+		run.push(row);
+	}
+	if (run.length >= MIN_SUBLINES) out.push(run);
+	return out;
+}
+/** How far apart, in ems, two baselines have to stand to be separate LINES. */
+var SUBLINE_GAP = .9;
+/** A matrix is a row of cells above another, and the brackets between them. */
+var MIN_SUBLINES = 3;
+/** Build the matrix a cluster of sub-lines holds, or nothing where it holds none. */
+function matrixFrom(cluster) {
+	const middle = cluster.find((row) => pairsOf(row).length > 0);
+	if (!middle) return void 0;
+	const pairs = pairsOf(middle);
+	const cells = cluster.filter((row) => row !== middle);
+	if (cells.length === 0) return void 0;
+	const children = [];
+	let used = /* @__PURE__ */ new Set();
+	let at = -Infinity;
+	for (const pair of pairs) {
+		for (const run of middle) if (run.x >= at && run.endX <= pair.open.x && run.text.trim().length > 0) {
+			children.push({
+				type: "run",
+				text: spaced(run.text)
+			});
+			used.add(run);
+		}
+		const inside = matrixInside(cluster, middle, pair);
+		if (!inside) return void 0;
+		children.push({
+			type: "delimiter",
+			begChr: pair.open.text.trim(),
+			endChr: pair.close.text.trim(),
+			children: [inside.matrix]
+		});
+		used = new Set([
+			...used,
+			...inside.used,
+			pair.open,
+			pair.close
+		]);
+		at = pair.close.endX;
+	}
+	for (const run of middle) if (run.x >= at && run.text.trim().length > 0) {
+		children.push({
+			type: "run",
+			text: spaced(run.text)
+		});
+		used.add(run);
+	}
+	if (children.length === 0) return void 0;
+	for (const row of cluster) for (const run of row) if (!used.has(run)) return void 0;
+	const all = [...used];
+	return {
+		math: {
+			type: "row",
+			children
+		},
+		top: baselineOf(cells[0] ?? middle),
+		x: Math.min(...all.map((r) => r.x)),
+		width: Math.max(...all.map((r) => r.endX)) - Math.min(...all.map((r) => r.x)),
+		used
+	};
+}
+/**
+* An operator standing between two matrices, with the air the page gave it.
+* The file sets `(1 2 / 3 4)(1 1 / 0 1) = (1 3 / 3 7)` with the equals sign
+* clear of both brackets; set tight against them it reads as one word.
+*/
+var spaced = (text) => ` ${text.trim()} `;
+/** The bracket pairs a row holds, left to right and never nested. */
+function pairsOf(row) {
+	const out = [];
+	let open;
+	for (const run of [...row].sort((a, b) => a.x - b.x)) {
+		const text = run.text.trim();
+		if (open === void 0) {
+			if (BRACKETS.has(text)) open = run;
+			continue;
+		}
+		if (text === BRACKETS.get(open.text.trim())) {
+			out.push({
+				open,
+				close: run
+			});
+			open = void 0;
+		}
+	}
+	return out;
+}
+/**
+* The grid inside one bracket pair: every sub-line's runs that fall between the
+* brackets, clustered into columns by where they stand.
+*/
+function matrixInside(cluster, middle, pair) {
+	const used = /* @__PURE__ */ new Set();
+	const rows = [];
+	for (const row of cluster) {
+		const inside = row.filter((run) => run !== pair.open && run !== pair.close && run.x >= pair.open.x && run.endX <= pair.close.endX && run.text.trim().length > 0);
+		if (inside.length === 0) continue;
+		if (row === middle && inside.some((run) => BRACKETS.has(run.text.trim()))) return void 0;
+		inside.sort((a, b) => a.x - b.x);
+		for (const run of inside) used.add(run);
+		rows.push(inside);
+	}
+	if (rows.length < 2) return void 0;
+	const size = Math.max(...rows.flat().map((r) => r.fontSizePt || 10));
+	const centres = [];
+	const columnOf = (run) => {
+		const centre = (run.x + run.endX) / 2;
+		const found = centres.findIndex((c) => Math.abs(c - centre) <= size / 2);
+		if (found >= 0) return found;
+		centres.push(centre);
+		return centres.length - 1;
+	};
+	const grid = rows.map((row) => {
+		const cells = [];
+		for (const run of row) {
+			const at = columnOf(run);
+			(cells[at] ??= []).push(run.text.trim());
+		}
+		return cells;
+	});
+	const width = Math.max(...grid.map((row) => row.length));
+	return {
+		matrix: {
+			type: "matrix",
+			rows: grid.map((row) => Array.from({ length: width }, (_, i) => ({
+				type: "run",
+				text: (row[i] ?? []).join("")
+			})))
+		},
+		used
+	};
+}
+//#endregion
+export { matrixBlocks };

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

@@ -0,0 +1,36 @@
+import { PdfDict, PdfStream, PdfValue } from '../pdf/objects.js';
+import { PdfFile } from './document.js';
+/**
+ * The optional-content groups the file's DEFAULT configuration turns off
+ * (§8.11.4.3).
+ *
+ * `/BaseState` says what an unlisted group does — `/ON` unless the file says
+ * `/OFF` — and the `/ON` and `/OFF` arrays name the exceptions, `/OFF` last.
+ *
+ * @param file The document.
+ * @returns The resolved OCG dictionaries that are hidden.
+ */
+export declare function hiddenGroups(file: PdfFile): ReadonlySet<PdfValue>;
+/**
+ * Whether an `/OC` entry names something the page does not show.
+ *
+ * The entry is either a group itself or an `/OCMD` — a membership dictionary
+ * naming several groups and a `/P` policy over them (§8.11.2.3). `AnyOn` is the
+ * default and the common case: the content shows if any of its groups does.
+ *
+ * @param file The document.
+ * @param oc   The `/OC` value, unresolved.
+ * @returns `true` where the content it guards is hidden.
+ */
+export declare function hiddenByOc(file: PdfFile, oc: PdfValue | undefined): boolean;
+/**
+ * The `/Properties` names a page's content may name in `/OC … BDC` that are
+ * hidden (§8.11.3.2).
+ *
+ * @param file      The document.
+ * @param resources The resource dictionary in force.
+ * @returns Name → hidden, for the names that ARE hidden.
+ */
+export declare function hiddenProperties(file: PdfFile, resources: PdfDict | undefined): Set<string>;
+/** Whether an XObject carries an `/OC` that hides it (§8.11.3.1). */
+export declare function hiddenXObject(file: PdfFile, stream: PdfStream): boolean;

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

@@ -0,0 +1,93 @@
+import { PDF_NULL, PdfName } from "../pdf/objects.js";
+//#region src/pdf-reader/optional-content.ts
+/** The document's own answer to "is this group shown?", worked out once. */
+var cache = /* @__PURE__ */ new WeakMap();
+/** An `/OCMD` naming more groups than this is not read: it is not a document. */
+var MAX_GROUPS = 4096;
+/**
+* The optional-content groups the file's DEFAULT configuration turns off
+* (§8.11.4.3).
+*
+* `/BaseState` says what an unlisted group does — `/ON` unless the file says
+* `/OFF` — and the `/ON` and `/OFF` arrays name the exceptions, `/OFF` last.
+*
+* @param file The document.
+* @returns The resolved OCG dictionaries that are hidden.
+*/
+function hiddenGroups(file) {
+	const had = cache.get(file);
+	if (had) return had;
+	const hidden = /* @__PURE__ */ new Set();
+	const props = file.get(file.catalog, "OCProperties");
+	const config = props instanceof Map ? file.get(props, "D") : void 0;
+	if (config instanceof Map) {
+		const base = file.get(config, "BaseState");
+		if (base instanceof PdfName && base.value === "OFF") {
+			const all = file.get(props instanceof Map ? props : /* @__PURE__ */ new Map(), "OCGs");
+			for (const g of asArray(file, all)) hidden.add(g);
+		}
+		for (const g of asArray(file, file.get(config, "ON"))) hidden.delete(g);
+		for (const g of asArray(file, file.get(config, "OFF"))) hidden.add(g);
+	}
+	cache.set(file, hidden);
+	return hidden;
+}
+/**
+* Whether an `/OC` entry names something the page does not show.
+*
+* The entry is either a group itself or an `/OCMD` — a membership dictionary
+* naming several groups and a `/P` policy over them (§8.11.2.3). `AnyOn` is the
+* default and the common case: the content shows if any of its groups does.
+*
+* @param file The document.
+* @param oc   The `/OC` value, unresolved.
+* @returns `true` where the content it guards is hidden.
+*/
+function hiddenByOc(file, oc) {
+	if (oc === void 0) return false;
+	const hidden = hiddenGroups(file);
+	const resolved = file.resolve(oc);
+	if (!(resolved instanceof Map)) return false;
+	const type = file.get(resolved, "Type");
+	if (!(type instanceof PdfName) || type.value !== "OCMD") return hidden.has(resolved);
+	const groups = asArray(file, file.get(resolved, "OCGs"));
+	const single = file.resolve(resolved.get("OCGs") ?? PDF_NULL);
+	const list = groups.length > 0 ? groups : single instanceof Map ? [single] : [];
+	if (list.length === 0) return false;
+	const on = list.filter((g) => !hidden.has(g)).length;
+	const policy = file.get(resolved, "P");
+	switch (policy instanceof PdfName ? policy.value : "AnyOn") {
+		case "AllOn": return on < list.length;
+		case "AnyOff": return on === list.length;
+		case "AllOff": return on > 0;
+		default: return on === 0;
+	}
+}
+/**
+* The `/Properties` names a page's content may name in `/OC … BDC` that are
+* hidden (§8.11.3.2).
+*
+* @param file      The document.
+* @param resources The resource dictionary in force.
+* @returns Name → hidden, for the names that ARE hidden.
+*/
+function hiddenProperties(file, resources) {
+	const out = /* @__PURE__ */ new Set();
+	if (!resources) return out;
+	const props = file.get(resources, "Properties");
+	if (!(props instanceof Map)) return out;
+	for (const [name, value] of props) if (hiddenByOc(file, value)) out.add(name);
+	return out;
+}
+/** Whether an XObject carries an `/OC` that hides it (§8.11.3.1). */
+function hiddenXObject(file, stream) {
+	return hiddenByOc(file, stream.dict.get("OC"));
+}
+/** An array entry, resolved; a missing or malformed one comes back empty. */
+function asArray(file, value) {
+	const r = value !== void 0 ? file.resolve(value) : void 0;
+	if (!Array.isArray(r)) return [];
+	return r.slice(0, MAX_GROUPS).map((v) => file.resolve(v));
+}
+//#endregion
+export { hiddenProperties, hiddenXObject };

package/dist/esm/pdf-reader/predefined-cmap.d.ts

@@ -0,0 +1,21 @@
+/** How a named CMap breaks a string into codes, and what those codes mean. */
+export interface PredefinedCMap {
+    /** The `TextDecoder` label the code bytes are in. */
+    readonly charset: string;
+    /** Whether a byte begins a TWO-byte code; anything else stands alone. */
+    readonly leadsPair: (byte: number) => boolean;
+    /** §9.7.5.2 — a `…-V` CMap sets its text down the page. */
+    readonly vertical: boolean;
+}
+/**
+ * What a predefined CMap name comes to.
+ *
+ * @param name The `/Encoding` name, as the font states it.
+ * @returns Its encoding and code structure, or `undefined` for `Identity` and
+ *          for any name whose encoding this cannot decode.
+ */
+export declare function predefinedCMap(name: string): PredefinedCMap | undefined;
+/** Split a shown string the way this CMap's codespace says (§9.7.6.2). */
+export declare function splitPredefined(cmap: PredefinedCMap, bytes: Uint8Array): Array<number>;
+/** The character one code stands for: its own bytes, read in the CMap's encoding. */
+export declare function decodePredefined(cmap: PredefinedCMap, code: number): string;

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

@@ -0,0 +1,102 @@
+//#region src/pdf-reader/predefined-cmap.ts
+/** Shift-JIS: 81–9F and E0–FC lead a pair; 00–80 and A0–DF stand alone. */
+var shiftJis = (b) => b >= 129 && b <= 159 || b >= 224 && b <= 252;
+/** The EUC family: A1–FE lead a pair, and 8E/8F introduce one as well. */
+var euc = (b) => b >= 161 || b === 142 || b === 143;
+/** Big5, GBK and UHC: everything from 81 up leads a pair. */
+var highLeads = (b) => b >= 129;
+/** Two bytes always, big-endian — the UCS-2 and UTF-16 CMaps. */
+var always = () => true;
+/** The families, longest name first so `90ms-RKSJ` is not read as `RKSJ`. */
+var FAMILIES = [
+	{
+		match: /RKSJ/u,
+		charset: "shift_jis",
+		leadsPair: shiftJis
+	},
+	{
+		match: /-EUC(-|$)|^EUC-/u,
+		charset: "euc-jp",
+		leadsPair: euc
+	},
+	{
+		match: /^(ETen|ETenms|B5pc|HKscs-B5|CNS-EUC)/u,
+		charset: "big5",
+		leadsPair: highLeads
+	},
+	{
+		match: /^(GBK|GBpc|GBK2K|GB-EUC|GBKp)/u,
+		charset: "gbk",
+		leadsPair: highLeads
+	},
+	{
+		match: /^(KSC|KSCms|KSCpc)/u,
+		charset: "euc-kr",
+		leadsPair: highLeads
+	},
+	{
+		match: /UCS2|UTF16/u,
+		charset: "utf-16be",
+		leadsPair: always
+	}
+];
+/**
+* What a predefined CMap name comes to.
+*
+* @param name The `/Encoding` name, as the font states it.
+* @returns Its encoding and code structure, or `undefined` for `Identity` and
+*          for any name whose encoding this cannot decode.
+*/
+function predefinedCMap(name) {
+	if (name.startsWith("Identity")) return void 0;
+	const vertical = name.endsWith("-V");
+	const family = FAMILIES.find((f) => f.match.test(name));
+	if (!family) return void 0;
+	if (!canDecode(family.charset)) return void 0;
+	return {
+		charset: family.charset,
+		leadsPair: family.leadsPair,
+		vertical
+	};
+}
+/** Split a shown string the way this CMap's codespace says (§9.7.6.2). */
+function splitPredefined(cmap, bytes) {
+	const out = [];
+	for (let i = 0; i < bytes.length;) {
+		const b = bytes[i];
+		if (cmap.leadsPair(b) && i + 1 < bytes.length) {
+			out.push(b << 8 | bytes[i + 1]);
+			i += 2;
+		} else {
+			out.push(b);
+			i++;
+		}
+	}
+	return out;
+}
+/** The character one code stands for: its own bytes, read in the CMap's encoding. */
+function decodePredefined(cmap, code) {
+	const bytes = code > 255 ? Uint8Array.from([code >> 8, code & 255]) : Uint8Array.from([code]);
+	try {
+		return new TextDecoder(cmap.charset, { fatal: false }).decode(bytes);
+	} catch {
+		return "";
+	}
+}
+/** Whether this runtime's `TextDecoder` carries the legacy encoding. */
+function canDecode(charset) {
+	const had = supported.get(charset);
+	if (had !== void 0) return had;
+	let ok = false;
+	try {
+		new TextDecoder(charset);
+		ok = true;
+	} catch {
+		ok = false;
+	}
+	supported.set(charset, ok);
+	return ok;
+}
+var supported = /* @__PURE__ */ new Map();
+//#endregion
+export { decodePredefined, predefinedCMap, splitPredefined };

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

@@ -13,14 +13,14 @@ import { FlowDoc } from '../core/ir/flow.js';
  *                 opens permissions-only encryption.
  * @param filters  Decoders for `/Filter` names this reader does not implement
  *                 (§7.4); see {@link StreamFilters}.
- * @param layout   `'flow'` reads a re-flowable document out of the page —
- *                 paragraphs and tables in reading order, from the structure
- *                 tree where there is one. `'positional'` keeps the page: every
- *                 line stands where its glyphs do, beside the artwork, which is
- *                 what a form or a drawing needs and what a paragraph cannot be.
  * @returns The reconstructed FlowDoc and its accumulated {@link Loss} report.
+ *
+ * Which of the two readings a file gets is the FILE's to decide and no
+ * caller's: a page that is mostly marks is reproduced where it stands, one
+ * that is mostly lines is re-set as a document, and the reader records which
+ * it chose. There is no override — see the note on {@link readingOf}.
  */
-export declare function readPdf(bytes: Uint8Array, password?: string, layout?: 'flow' | 'positional', filters?: StreamFilters): ReadResult<FlowDoc>;
+export declare function readPdf(bytes: Uint8Array, password?: string, filters?: StreamFilters): ReadResult<FlowDoc>;
 /**
  * The `pdfReader` adapter: a {@link DocumentReader} that sniffs the `%PDF-`
  * header and parses the bytes into a {@link FlowDoc} (E-PDF EP5).

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

@@ -1,12 +1,32 @@
 import { FEATURES } from "../core/ir/features.js";
 import { PdfFile } from "./document.js";
+import { extractPageText } from "./text.js";
+import { collectPageVectors } from "./vector.js";
 import { reconstructByLayout } from "./layout.js";
 import { reconstructTaggedPdf } from "./tagged.js";
 //#region src/pdf-reader/reader.ts
 function sniffPdf(bytes) {
 	const limit = Math.min(bytes.length - 5, 1024);
 	for (let i = 0; i <= limit; i++) if (bytes[i] === 37 && bytes[i + 1] === 80 && bytes[i + 2] === 68 && bytes[i + 3] === 70 && bytes[i + 4] === 45) return true;
-	return false;
+	return endsLikePdf(bytes);
+}
+/**
+* §7.5.5 — a file with no header at all, recognised by how it ENDS.
+*
+* bug1606566.pdf begins with the binary comment that normally FOLLOWS the
+* header and has no `%PDF-` anywhere: the producer wrote the second line and
+* not the first. Every reader takes it — poppler says "May not be a PDF file
+* (continuing anyway)" and reads its one line of text — and we refused the file
+* outright, which is the worst answer of the three.
+*
+* The two tokens that close every PDF and close nothing else: the cross-
+* reference offset and the end-of-file marker, in that order, at the end.
+*/
+function endsLikePdf(bytes) {
+	const tail = bytes.subarray(Math.max(0, bytes.length - 2048));
+	const text = new TextDecoder("latin1").decode(tail);
+	const eof = text.lastIndexOf("%%EOF");
+	return eof >= 0 && text.lastIndexOf("startxref") < eof;
 }
 /**
 * Parse PDF bytes into a {@link FlowDoc} (E-PDF EP5): reconstruct via the tagged
@@ -20,14 +40,14 @@ function sniffPdf(bytes) {
 *                 opens permissions-only encryption.
 * @param filters  Decoders for `/Filter` names this reader does not implement
 *                 (§7.4); see {@link StreamFilters}.
-* @param layout   `'flow'` reads a re-flowable document out of the page —
-*                 paragraphs and tables in reading order, from the structure
-*                 tree where there is one. `'positional'` keeps the page: every
-*                 line stands where its glyphs do, beside the artwork, which is
-*                 what a form or a drawing needs and what a paragraph cannot be.
 * @returns The reconstructed FlowDoc and its accumulated {@link Loss} report.
+*
+* Which of the two readings a file gets is the FILE's to decide and no
+* caller's: a page that is mostly marks is reproduced where it stands, one
+* that is mostly lines is re-set as a document, and the reader records which
+* it chose. There is no override — see the note on {@link readingOf}.
 */
-function readPdf(bytes, password = "", layout = "flow", filters = {}) {
+function readPdf(bytes, password = "", filters = {}) {
 	const file = PdfFile.parse(bytes, password, filters);
 	const losses = [];
 	if (file.encryptionUnsupported) losses.push({
@@ -40,25 +60,91 @@ function readPdf(bytes, password = "", layout = "flow", filters = {}) {
 		feature: FEATURES.text,
 		detail: `PDF stream filter /${name} is not supported; streams using it are unreadable`
 	});
-	const tagged = layout === "positional" ? void 0 : reconstructTaggedPdf(file);
-	const reconstruction = tagged ?? reconstructByLayout(file, layout);
-	if (!tagged && layout !== "positional") losses.push({
+	const reading = readingOf(file);
+	losses.push({
+		severity: "degraded",
+		feature: FEATURES.text,
+		detail: reading === "positional" ? "PDF read as a PAGE (placed): its artwork outweighs its prose, so every line stands where its glyphs stand" : "PDF read as a DOCUMENT (flowing): its prose outweighs its artwork, so the words re-set and the artwork takes its turn in reading order"
+	});
+	const tagged = reading === "positional" ? void 0 : reconstructTaggedPdf(file);
+	const reconstruction = tagged ?? reconstructByLayout(file, reading);
+	if (!tagged && reading !== "positional") losses.push({
 		severity: "degraded",
 		feature: FEATURES.text,
 		detail: "untagged PDF — text and headings reconstructed heuristically from glyph positions; structure is approximate"
 	});
 	losses.push(...reconstruction.losses);
-	losses.push({
-		severity: "dropped",
-		feature: FEATURES.images,
-		detail: "PDF bare-shading (sh) vector regions are not reconstructed"
-	});
 	return {
 		doc: reconstruction.doc,
 		losses
 	};
 }
 /**
+* Which reading a PDF asks for: a DOCUMENT to re-set, or a PAGE to reproduce.
+*
+* The two cannot be mixed. A flowing reading moves the words, and words that
+* move cannot agree with rules that do not — anchored artwork over reflowed
+* text puts every label on the wrong box. A placed reading keeps both where
+* they were drawn, and reflows nothing.
+*
+* The file says which it is by what is on it. A form or a drawing is mostly
+* MARKS — 160F-2019.pdf sets 28 numbered rows in 355 ruled boxes — and a paper
+* is mostly LINES, with a rule or two between them. So the marks are counted
+* against the lines, on the MEDIAN page rather than the worst, since one plan
+* folded into a report does not make the report a plan.
+*
+* A threshold is a guess, and this one is stated rather than hidden: the reader
+* records which reading it took and why, and the caller can name the other.
+*/
+function readingOf(file) {
+	/**
+	* Below this many marks a page is prose with decoration, whatever the ratio.
+	*
+	* It stood at twenty, and calgray.pdf is a five-by-four grid of grey swatches
+	* with a label in each: twenty boxes, of which the one painted white is not a
+	* mark anybody can see. Nineteen — one short — and all three pages of it were
+	* read as prose, the labels of each row run together into a line and the
+	* sheet spilling onto a second page. Nineteen boxes in a grid are not a page
+	* of prose with a rule under its heading.
+	*/
+	const ENOUGH_MARKS = 12;
+	/** Twice as many marks as lines is a page that is drawn rather than written. */
+	const DRAWN = 2;
+	/** Below this many runs, an angle is a stamp or a watermark and not the page. */
+	const ENOUGH_TURNED = 8;
+	const ratios = [];
+	for (const page of file.pages()) {
+		let marks = 0;
+		let lines = 0;
+		let turned = 0;
+		let runs = 0;
+		try {
+			marks = collectPageVectors(file, page, []).vectors.length;
+			const ys = /* @__PURE__ */ new Set();
+			for (const run of extractPageText(file, page)) {
+				ys.add(Math.round(run.y));
+				runs++;
+				if (run.angleDeg !== void 0) turned++;
+			}
+			lines = ys.size;
+		} catch {
+			continue;
+		}
+		if (runs >= ENOUGH_TURNED && turned > runs * .5) {
+			ratios.push(DRAWN);
+			continue;
+		}
+		if (marks < ENOUGH_MARKS) {
+			ratios.push(0);
+			continue;
+		}
+		ratios.push(lines > 0 ? marks / lines : DRAWN);
+	}
+	if (ratios.length === 0) return "flow";
+	const sorted = [...ratios].sort((a, b) => a - b);
+	return (sorted[Math.floor(sorted.length / 2)] ?? 0) >= DRAWN ? "positional" : "flow";
+}
+/**
 * The `pdfReader` adapter: a {@link DocumentReader} that sniffs the `%PDF-`
 * header and parses the bytes into a {@link FlowDoc} (E-PDF EP5).
 */
@@ -72,7 +158,7 @@ var pdfReader = {
 		FEATURES.images
 	]),
 	sniff: sniffPdf,
-	read: (bytes, opts) => readPdf(bytes, typeof opts?.password === "string" ? opts.password : "", opts?.pdfLayout === "positional" ? "positional" : "flow", isFilters(opts?.filters) ? opts.filters : {})
+	read: (bytes, opts) => readPdf(bytes, typeof opts?.password === "string" ? opts.password : "", isFilters(opts?.filters) ? opts.filters : {})
 };
 /** A caller's `filters` option, when it is the shape the reader can use. */
 function isFilters(value) {