reamkit 1.26.0 → 1.28.0

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

@@ -0,0 +1,487 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+//#region src/pdf-reader/annot-draw.ts
+/** The circle constant: how far a Bézier handle reaches to round a quarter. */
+var KAPPA = .5523;
+/** §12.5.2 `/Border` and §12.5.4 `/BS` `/W` both default the pen to one point. */
+var DEFAULT_BORDER_PT = 1;
+/**
+* A generated normal appearance for an annotation that carries none, or
+* `undefined` when its subtype or its geometry says nothing to draw.
+*
+* The stream is in PAGE space, so the caller places it with the identity: it is
+* not fitted to `/Rect` the way an authored appearance is, because what it is
+* drawn from is already stated in page coordinates.
+*
+* @param file  The owning file, for resolving references.
+* @param annot The annotation dictionary.
+* @returns The synthesized appearance stream, or `undefined`.
+*/
+function drawnAppearance(file, annot) {
+	const subtype = file.get(annot, "Subtype");
+	if (!(subtype instanceof PdfName)) return void 0;
+	if (subtype.value === "Widget") return typedValue(file, annot) ?? checkedBox(file, annot);
+	const markup = markupShape(file, annot, subtype.value);
+	if (markup) return markup;
+	const pen = borderWidth(file, annot);
+	const drawing = pathFor(file, annot, subtype.value, pen);
+	if (!drawing || drawing.ops.length === 0) return void 0;
+	const stroke = colorOf(file.get(annot, "C"));
+	const fillColor = colorOf(file.get(annot, "IC"));
+	const body = [
+		"q",
+		`${num(pen)} w`,
+		...stroke !== void 0 ? [`${stroke} RG`] : [],
+		...fillColor !== void 0 ? [`${fillColor} rg`] : [],
+		...drawing.ops,
+		drawing.paint,
+		"Q"
+	].join("\n");
+	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(body));
+}
+/**
+* §12.7.4.2 — a check box or radio button whose appearance was never generated.
+*
+* Its state is `/AS`, or `/V` where the widget states none, and `/Off` means
+* exactly that: nothing is drawn. Anything else is the ON state, and what a
+* viewer draws for it is the caption `/MK /CA` — one character of ZapfDingbats,
+* `4` (a check) by default, `l` (a filled circle) for the radio buttons that
+* ask for it.
+*
+* The border and background come from `/MK`, and where the file gives none
+* neither is drawn: checkbox_no_appearance.pdf states no `/MK` at all, and
+* poppler draws its ticked box as a bare check mark on the paper.
+*/
+function checkedBox(file, annot) {
+	if (inherited(file, annot, "FT") !== "Btn") return void 0;
+	const as = file.get(annot, "AS");
+	const state = as instanceof PdfName ? as.value : inherited(file, annot, "V");
+	const rect = rectangle(file.get(annot, "Rect"));
+	if (!rect) return void 0;
+	const [x0, y0, x1, y1] = rect;
+	const w = x1 - x0;
+	const h = y1 - y0;
+	if (!(w > 0) || !(h > 0)) return void 0;
+	const mk = file.get(annot, "MK");
+	const border = mk instanceof Map ? colorOf(file.get(mk, "BC")) : void 0;
+	const ground = mk instanceof Map ? colorOf(file.get(mk, "BG")) : void 0;
+	const pen = borderWidth(file, annot);
+	const ops = ["q"];
+	if (ground !== void 0) ops.push(`${ground} rg`, `${num(x0)} ${num(y0)} ${num(w)} ${num(h)} re`, "f");
+	if (border !== void 0 && pen > 0) ops.push(`${border} RG`, `${num(pen)} w`, `${num(x0 + pen / 2)} ${num(y0 + pen / 2)} ${num(w - pen)} ${num(h - pen)} re`, "S");
+	if (state !== void 0 && state !== "Off") {
+		const stated = mk instanceof Map ? file.get(mk, "CA") : void 0;
+		const caption = typeof stated === "string" && stated.length > 0 ? stated[0] : "4";
+		const ink = defaultAppearance(file, annot).color;
+		const side = Math.min(w, h) * CAPTION_EM;
+		const cx = x0 + w / 2;
+		const cy = y0 + h / 2;
+		if (caption === "l" || caption === "n") {
+			ops.push(`${ink} rg`);
+			ops.push(...caption === "n" ? [`${num(cx - side / 2)} ${num(cy - side / 2)} ${num(side)} ${num(side)} re`] : circleOps(cx, cy, side / 2), "f");
+		} else {
+			const pen = Math.max(.6, side * CHECK_PEN_EM);
+			ops.push(`${ink} RG`, `${num(pen)} w`, "1 J", "1 j", `${num(cx - side * .4)} ${num(cy + side * .05)} m`, `${num(cx - side * .12)} ${num(cy - side * .32)} l`, `${num(cx + side * .42)} ${num(cy + side * .36)} l`, "S");
+		}
+	}
+	ops.push("Q");
+	if (ops.length <= 2) return void 0;
+	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(ops.join("\n")));
+}
+/** How much of the box the mark fills, and how thick the check's pen is. */
+var CAPTION_EM = .8;
+var CHECK_PEN_EM = .13;
+/** A circle of `r` about `(cx, cy)`, as the four Bézier arcs that draw one. */
+function circleOps(cx, cy, r) {
+	const k = r * .5523;
+	return [
+		`${num(cx - r)} ${num(cy)} m`,
+		`${num(cx - r)} ${num(cy + k)} ${num(cx - k)} ${num(cy + r)} ${num(cx)} ${num(cy + r)} c`,
+		`${num(cx + k)} ${num(cy + r)} ${num(cx + r)} ${num(cy + k)} ${num(cx + r)} ${num(cy)} c`,
+		`${num(cx + r)} ${num(cy - k)} ${num(cx + k)} ${num(cy - r)} ${num(cx)} ${num(cy - r)} c`,
+		`${num(cx - k)} ${num(cy - r)} ${num(cx - r)} ${num(cy - k)} ${num(cx - r)} ${num(cy)} c`
+	];
+}
+/**
+* §12.5.6.10 — a text markup drawn as a MARK on the paper.
+*
+* The usual reading puts it on the runs it covers, which is right for a page
+* with words on it. bug1538111.pdf has none: four markup annotations over an
+* empty page, and read as marks about text that is not there they came back as
+* nothing at all. Drawn, each is what its subtype says over its own quads.
+*/
+function markupShape(file, annot, kind) {
+	const markup = textMarkupOf(file, annot);
+	if (!markup) return void 0;
+	const rgb = colorOf(file.get(annot, "C")) ?? "0 0 0";
+	const ops = [
+		"q",
+		`${rgb} rg`,
+		`${rgb} RG`
+	];
+	for (const q of markup.quads) {
+		const left = q.x0;
+		const right = q.x1;
+		const bottom = q.y0;
+		const h = q.h;
+		if (!(right > left) || !(h > 0)) continue;
+		if (kind === "Highlight") {
+			ops.push(`${num(left)} ${num(bottom)} ${num(right - left)} ${num(h)} re`, "f");
+			continue;
+		}
+		const pen = Math.max(.5, h * MARK_PEN_EM);
+		if (kind === "Squiggly") {
+			const amp = Math.max(.75, h * SQUIGGLE_AMP_EM);
+			const step = amp * 2;
+			ops.push(`${num(pen)} w`, `${num(left)} ${num(bottom + amp)} m`);
+			let up = true;
+			for (let x = left + step; x < right; x += step, up = !up) ops.push(`${num(x)} ${num(bottom + (up ? amp * 2 : 0))} l`);
+			ops.push("S");
+			continue;
+		}
+		const y = kind === "StrikeOut" ? bottom + h / 2 : bottom + pen;
+		ops.push(`${num(pen)} w`, `${num(left)} ${num(y)} m`, `${num(right)} ${num(y)} l`, "S");
+	}
+	if (ops.length <= 3) return void 0;
+	ops.push("Q");
+	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(ops.join("\n")));
+}
+/** How thick a drawn underline or strike is, as a share of the line's height. */
+var MARK_PEN_EM = .05;
+/** How far a squiggle rises above its baseline, likewise. */
+var SQUIGGLE_AMP_EM = .07;
+/**
+* §12.7.2 `/DR` — the resources a generated field appearance draws with.
+*
+* The `/DA` string names a font (`/Helv 12 Tf`) and that name means nothing
+* without the form's own default resource dictionary, which is where every
+* field's face lives.
+*
+* @param file  The owning file.
+* @param annot The annotation the appearance was generated for.
+* @returns The form's `/DR`, or `undefined` when there is none.
+*/
+function drawnResources(file, annot) {
+	const subtype = file.get(annot, "Subtype");
+	if (!(subtype instanceof PdfName) || subtype.value !== "Widget") return void 0;
+	const acro = file.get(file.catalog, "AcroForm");
+	if (!(acro instanceof Map)) return void 0;
+	const dr = file.get(acro, "DR");
+	return dr instanceof Map ? dr : void 0;
+}
+/**
+* §12.7.3.3 — the text a form field holds, set the way its `/DA` asks.
+*
+* A widget normally carries the picture of its value in `/AP`, and a viewer
+* that fills a field regenerates it. One that does not — or a file flagged
+* `NeedAppearances` — leaves only `/V`, and reading the appearances alone gives
+* a form with every box empty. The field's own default appearance string names
+* the face, the size and the colour; the rest is arithmetic on `/Rect`.
+*
+* Only a TEXT field: a button's value is a state, and a choice field's list is
+* drawn from `/Opt` rather than typed into a box.
+*/
+function typedValue(file, annot) {
+	if (inherited(file, annot, "FT") !== "Tx") return void 0;
+	const value = inheritedString(file, annot, "V");
+	if (value === void 0 || value.length === 0) return void 0;
+	const rect = rectangle(file.get(annot, "Rect"));
+	if (!rect) return void 0;
+	const da = defaultAppearance(file, annot);
+	const multiline = ((inheritedNumber(file, annot, "Ff") ?? 0) & MULTILINE) !== 0;
+	const box = inset(rect, borderWidth(file, annot) + 1);
+	const height = box[3] - box[1];
+	const width = box[2] - box[0];
+	if (!(width > 0 && height > 0)) return void 0;
+	const size = da.size > 0 ? da.size : multiline ? 12 : Math.min(12, height * .66);
+	const lines = multiline ? value.split(/\r\n|[\r\n]/u) : [value.replace(/[\r\n]+/gu, " ")];
+	const leading = size * 1.16;
+	const first = multiline ? box[3] - size : box[1] + (height - size) / 2 + size * .22;
+	const ops = [
+		"q",
+		"BT",
+		`${da.font} ${num(size)} Tf`,
+		`${da.color} rg`
+	];
+	lines.forEach((line, i) => {
+		const y = first - i * leading;
+		if (y < box[1] - size) return;
+		ops.push(`1 0 0 1 ${num(box[0] + indent(line, size, width, quadding(file, annot)))} ${num(y)} Tm`);
+		ops.push(`(${escapeText(line)}) Tj`);
+	});
+	ops.push("ET", "Q");
+	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(ops.join("\n")));
+}
+/** §12.7.4.3 — the field is a multi-line text box (bit 13 of `/Ff`). */
+var MULTILINE = 4096;
+/**
+* §12.7.3.1 `/Q` — 0 left, 1 centred, 2 right. Where it is not left the line
+* has to be measured, and the face is not in hand: half the size per character
+* is what Helvetica averages, and a field's value is short enough that the
+* error stays under a character.
+*/
+function indent(line, size, width, q) {
+	if (q !== 1 && q !== 2) return 0;
+	const guess = Math.min(width, line.length * size * .5);
+	return q === 1 ? (width - guess) / 2 : width - guess;
+}
+/** §12.7.3.1 `/Q`, inherited from the field's parent. */
+function quadding(file, annot) {
+	return inheritedNumber(file, annot, "Q") ?? 0;
+}
+/**
+* §12.7.3.3 `/DA` — the default appearance string, from the field or the form.
+* Only the `Tf` and the colour are read; the rest is a content stream fragment
+* this reader does not need to run.
+*/
+function defaultAppearance(file, annot) {
+	const acro = file.get(file.catalog, "AcroForm");
+	const own = inheritedString(file, annot, "DA");
+	const form = acro instanceof Map ? file.get(acro, "DA") : void 0;
+	const da = own ?? (typeof form === "string" ? form : "");
+	const tf = /\/([^\s/]+)\s+([\d.]+)\s+Tf/u.exec(da);
+	const rgb = /([\d.]+)\s+([\d.]+)\s+([\d.]+)\s+rg/u.exec(da);
+	const gray = /(^|\s)([\d.]+)\s+g(\s|$)/u.exec(da);
+	const color = rgb ? `${num(Number(rgb[1]))} ${num(Number(rgb[2]))} ${num(Number(rgb[3]))}` : gray ? `${num(Number(gray[2]))} ${num(Number(gray[2]))} ${num(Number(gray[2]))}` : "0 0 0";
+	return {
+		font: `/${tf?.[1] ?? "Helv"}`,
+		size: Number(tf?.[2] ?? 0),
+		color
+	};
+}
+/** §7.3.4.2 — the characters a literal string may not carry unescaped. */
+function escapeText(s) {
+	return s.replace(/[\\()]/gu, (c) => `\\${c}`).replace(/[\r\n]/gu, " ");
+}
+/** A field entry, from the widget or the field tree above it (§12.7.3.1). */
+function inherited(file, annot, key) {
+	const found = climb(file, annot, key);
+	return found instanceof PdfName ? found.value : void 0;
+}
+/** The same, for an entry stated as a string. */
+function inheritedString(file, annot, key) {
+	const found = climb(file, annot, key);
+	return typeof found === "string" ? found : void 0;
+}
+/** The same, for a number. */
+function inheritedNumber(file, annot, key) {
+	const found = climb(file, annot, key);
+	return typeof found === "number" ? found : void 0;
+}
+/** Walk `/Parent` until the entry is found, or the tree ends. */
+function climb(file, annot, key) {
+	let at = annot;
+	for (let depth = 0; at && depth < 32; depth++) {
+		const here = file.get(at, key);
+		if (here !== PDF_NULL) return here;
+		const up = file.get(at, "Parent");
+		at = up instanceof Map ? up : void 0;
+	}
+}
+/**
+* §12.5.6.10 — what a TEXT-MARKUP annotation says about the words it covers.
+*
+* A highlight, an underline, a strikeout and a squiggle are not drawings: each
+* names a run of text and a way of marking it. Lifted as artwork they are a
+* band and a rule anchored to the page, which is right until the text re-sets
+* and is then a band sitting between two paragraphs it does not mark. Carried
+* on the RUNS they survive the reflow, and a .docx gets what the annotation
+* meant — `w:shd`, `w:u`, `w:strike`.
+*
+* @param file  The owning file.
+* @param annot The annotation dictionary.
+* @returns How it marks and what it marks, or `undefined` for another subtype.
+*/
+function textMarkupOf(file, annot) {
+	const subtype = file.get(annot, "Subtype");
+	if (!(subtype instanceof PdfName)) return void 0;
+	const kind = subtype.value;
+	if (kind !== "Highlight" && kind !== "Underline" && kind !== "StrikeOut" && kind !== "Squiggly") return;
+	const quads = eachQuad(file.get(annot, "QuadPoints"));
+	if (quads.length === 0) return void 0;
+	const rgb = colorOf(file.get(annot, "C"));
+	const opacity = file.get(annot, "CA");
+	const hex = rgb === void 0 ? void 0 : hexOf(rgb, typeof opacity === "number" && opacity > 0 && opacity < 1 ? opacity : 1);
+	return {
+		mark: kind === "Highlight" ? { highlightHex: hex ?? "FFFF00" } : kind === "StrikeOut" ? { strike: true } : {
+			underline: kind === "Squiggly" ? "wave" : "single",
+			...hex !== void 0 ? { underlineHex: hex } : {}
+		},
+		quads
+	};
+}
+/** The `rg` operands as a 6-hex colour, mixed with white by `alpha`. */
+function hexOf(operands, alpha = 1) {
+	const n = operands.split(" ").map(Number);
+	if (n.length !== 3 || n.some((v) => !Number.isFinite(v))) return void 0;
+	return n.map((v) => {
+		const over = Math.min(1, Math.max(0, v)) * alpha + (1 - alpha);
+		return Math.round(over * 255).toString(16).padStart(2, "0");
+	}).join("").toUpperCase();
+}
+/** What each markup subtype draws, from the geometry it states. */
+function pathFor(file, annot, subtype, pen) {
+	switch (subtype) {
+		case "Ink": return {
+			ops: polylines(listOfLists(file.get(annot, "InkList")), false),
+			paint: "S"
+		};
+		case "Line": return {
+			ops: polylines([numbers(file.get(annot, "L"))], false),
+			paint: "S"
+		};
+		case "Polygon":
+		case "PolyLine": return {
+			ops: polylines([numbers(file.get(annot, "Vertices"))], subtype === "Polygon"),
+			paint: filledOrStroked(file, annot)
+		};
+		case "Square":
+		case "Circle": {
+			const rect = rectangle(file.get(annot, "Rect"));
+			if (!rect) return void 0;
+			return {
+				ops: boxOps(inset(rect, pen / 2), subtype === "Circle"),
+				paint: filledOrStroked(file, annot)
+			};
+		}
+		default: return;
+	}
+}
+/** `/IC` fills a square, a circle or a polygon; `/C` strokes its border. */
+function filledOrStroked(file, annot) {
+	if (colorOf(file.get(annot, "IC")) === void 0) return "S";
+	return colorOf(file.get(annot, "C")) !== void 0 ? "B" : "f";
+}
+/** Each run of x y pairs as one subpath, closed or open. */
+function polylines(runs, close) {
+	const ops = [];
+	for (const pts of runs) {
+		if (pts.length < 4) continue;
+		ops.push(`${num(pts[0])} ${num(pts[1])} m`);
+		for (let i = 2; i + 1 < pts.length; i += 2) ops.push(`${num(pts[i])} ${num(pts[i + 1])} l`);
+		if (close) ops.push("h");
+	}
+	return ops;
+}
+/** §12.5.6.8 — a square is its rectangle; a circle is the ellipse inside it. */
+function boxOps(r, ellipse) {
+	const [x0, y0, x1, y1] = r;
+	if (!(x1 > x0 && y1 > y0)) return [];
+	if (!ellipse) return [`${num(x0)} ${num(y0)} ${num(x1 - x0)} ${num(y1 - y0)} re`];
+	const cx = (x0 + x1) / 2;
+	const cy = (y0 + y1) / 2;
+	const rx = (x1 - x0) / 2;
+	const ry = (y1 - y0) / 2;
+	const hx = rx * KAPPA;
+	const hy = ry * KAPPA;
+	const c = (ax, ay, bx, by, x, y) => `${num(ax)} ${num(ay)} ${num(bx)} ${num(by)} ${num(x)} ${num(y)} c`;
+	return [
+		`${num(cx + rx)} ${num(cy)} m`,
+		c(cx + rx, cy + hy, cx + hx, cy + ry, cx, cy + ry),
+		c(cx - hx, cy + ry, cx - rx, cy + hy, cx - rx, cy),
+		c(cx - rx, cy - hy, cx - hx, cy - ry, cx, cy - ry),
+		c(cx + hx, cy - ry, cx + rx, cy - hy, cx + rx, cy),
+		"h"
+	];
+}
+/**
+* §12.5.6.10 `/QuadPoints` — the run of text a text-markup annotation marks,
+* eight numbers per quad. Their stated order is notoriously not the order
+* producers write them in, so each quad is taken as the box its four corners
+* bound, which comes to the same box either way for text that is not turned.
+*/
+function eachQuad(quads) {
+	const n = numbers(quads);
+	const out = [];
+	for (let q = 0; q + 7 < n.length; q += 8) {
+		const xs = [
+			n[q],
+			n[q + 2],
+			n[q + 4],
+			n[q + 6]
+		];
+		const ys = [
+			n[q + 1],
+			n[q + 3],
+			n[q + 5],
+			n[q + 7]
+		];
+		const x0 = Math.min(...xs);
+		const x1 = Math.max(...xs);
+		const y0 = Math.min(...ys);
+		const h = Math.max(...ys) - y0;
+		if (x1 > x0 && h > 0) out.push({
+			x0,
+			x1,
+			y0,
+			h
+		});
+	}
+	return out;
+}
+/** §12.5.4 `/BS` `/W`, else §12.5.2 `/Border`'s third number, else one point. */
+function borderWidth(file, annot) {
+	const bs = file.get(annot, "BS");
+	if (bs instanceof Map) {
+		const w = file.get(bs, "W");
+		if (typeof w === "number" && w >= 0) return w;
+	}
+	const border = numbers(file.get(annot, "Border"));
+	if (border.length >= 3 && border[2] >= 0) return border[2];
+	return DEFAULT_BORDER_PT;
+}
+/**
+* §12.5.6.2 — an annotation colour is 1, 3 or 4 numbers (grey, RGB, CMYK), and
+* an EMPTY array means no colour at all. Returned as the three operands `rg`
+* and `RG` both take.
+*/
+function colorOf(value) {
+	const n = numbers(value);
+	if (n.length === 1) return `${num(n[0])} ${num(n[0])} ${num(n[0])}`;
+	if (n.length === 3) return n.map((v) => num(v)).join(" ");
+	if (n.length === 4) {
+		const [c, m, y, k] = n;
+		return [
+			num((1 - c) * (1 - k)),
+			num((1 - m) * (1 - k)),
+			num((1 - y) * (1 - k))
+		].join(" ");
+	}
+}
+/** The arrays inside an array — `/InkList` is one run of points per stroke. */
+function listOfLists(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((v) => numbers(v));
+}
+/** The numeric members of an array value, or an empty list. */
+function numbers(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((v) => typeof v === "number" && Number.isFinite(v));
+}
+/** A four-number array as an ordered rectangle, or `undefined`. */
+function rectangle(v) {
+	const n = numbers(v);
+	if (n.length < 4) return void 0;
+	return [
+		Math.min(n[0], n[2]),
+		Math.min(n[1], n[3]),
+		Math.max(n[0], n[2]),
+		Math.max(n[1], n[3])
+	];
+}
+/** The rectangle pulled in on every side, never past its own middle. */
+function inset(r, by) {
+	const dx = Math.min(by, (r[2] - r[0]) / 2);
+	const dy = Math.min(by, (r[3] - r[1]) / 2);
+	return [
+		r[0] + dx,
+		r[1] + dy,
+		r[2] - dx,
+		r[3] - dy
+	];
+}
+/** Three decimals is finer than any pen, and keeps the stream readable. */
+function num(v) {
+	return String(Math.round(v * 1e3) / 1e3);
+}
+//#endregion
+export { drawnAppearance, drawnResources, textMarkupOf };

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

@@ -9,16 +9,4 @@ export interface Appearance {
     /** The appearance's `/Resources`, when it states its own. */
     readonly resources: PdfDict | undefined;
 }
-/**
- * Every annotation appearance the page shows, in `/Annots` order — which is
- * the order they paint in, over the page's own content.
- *
- * A `Popup` is a note's window and is never part of the page. An annotation
- * flagged Hidden or NoView paints nothing. An `/AP` `/N` may be a stream or a
- * dictionary of states, in which case `/AS` names the one in force.
- *
- * @param file The owning file, for resolving references.
- * @param page The page whose annotations are wanted.
- * @returns The appearances, each with the matrix that places it on the page.
- */
 export declare function collectPageAppearances(file: PdfFile, page: PdfPage): Array<Appearance>;

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

@@ -1,5 +1,6 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { IDENTITY, multiply } from "./content.js";
+import { drawnAppearance, drawnResources, textMarkupOf } from "./annot-draw.js";
 //#region src/pdf-reader/annots.ts
 /** §12.5.3 `/F` — the annotation is not painted at all. */
 var FLAG_HIDDEN = 2;
@@ -10,12 +11,26 @@ var FLAG_NOVIEW = 32;
 *
 * A `Popup` is a note's window and is never part of the page. An annotation
 * flagged Hidden or NoView paints nothing. An `/AP` `/N` may be a stream or a
-* dictionary of states, in which case `/AS` names the one in force.
+* dictionary of states, in which case `/AS` names the one in force. An
+* annotation with no appearance at all gets one written for it from its own
+* geometry, where its subtype says exactly what that is ({@link drawnAppearance}).
 *
 * @param file The owning file, for resolving references.
 * @param page The page whose annotations are wanted.
 * @returns The appearances, each with the matrix that places it on the page.
 */
+/** Whether the page's own content stream shows any glyphs at all. */
+function pageHasText(file, page) {
+	const had = textful.get(page.dict);
+	if (had !== void 0) return had;
+	const content = file.pageContent(page);
+	let found = false;
+	for (let i = 0; i + 1 < content.length && !found; i++) found = content[i] === 66 && content[i + 1] === 84;
+	textful.set(page.dict, found);
+	return found;
+}
+/** One answer per page: the collector is called from three passes. */
+var textful = /* @__PURE__ */ new WeakMap();
 function collectPageAppearances(file, page) {
 	const annots = file.get(page.dict, "Annots");
 	if (!Array.isArray(annots)) return [];
@@ -25,10 +40,19 @@ function collectPageAppearances(file, page) {
 		if (!(annot instanceof Map)) continue;
 		const subtype = file.get(annot, "Subtype");
 		if (subtype instanceof PdfName && subtype.value === "Popup") continue;
+		if (textMarkupOf(file, annot) && pageHasText(file, page)) continue;
 		const flags = file.get(annot, "F");
 		if (typeof flags === "number" && (flags & FLAG_HIDDEN || flags & FLAG_NOVIEW)) continue;
 		const stream = normalAppearance(file, annot);
-		if (!stream) continue;
+		if (!stream) {
+			const drawn = drawnAppearance(file, annot);
+			if (drawn) out.push({
+				stream: drawn,
+				ctm: IDENTITY,
+				resources: drawnResources(file, annot)
+			});
+			continue;
+		}
 		const rect = rectangle(file.get(annot, "Rect"));
 		if (!rect) continue;
 		const matrix = matrixOf(file, stream.dict);
@@ -50,8 +74,10 @@ function normalAppearance(file, annot) {
 	if (normal instanceof PdfStream) return normal;
 	if (!(normal instanceof Map)) return void 0;
 	const state = file.get(annot, "AS");
-	const picked = state instanceof PdfName ? file.resolve(normal.get(state.value) ?? PDF_NULL) : PDF_NULL;
-	if (picked instanceof PdfStream) return picked;
+	if (state instanceof PdfName) {
+		const picked = file.resolve(normal.get(state.value) ?? PDF_NULL);
+		return picked instanceof PdfStream ? picked : void 0;
+	}
 	const only = [...normal.values()].map((v) => file.resolve(v)).filter((v) => v instanceof PdfStream);
 	return only.length === 1 ? only[0] : void 0;
 }

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

@@ -3,7 +3,7 @@
  * §7.4.6), pulled from the filter's `/DecodeParms`.
  */
 export interface CcittParams {
-    /** `/K` — `<0` Group 4, `0` Group 3 1-D, `>0` Group 3 2-D (unsupported). */
+    /** `/K` — `<0` Group 4, `0` Group 3 1-D, `>0` Group 3 mixed 1-D/2-D. */
     readonly k: number;
     /** `/Columns` (pixels per row). */
     readonly columns: number;
@@ -19,10 +19,27 @@ export interface CcittParams {
  * @param data   The raw fax codestream (any wrapping filters already stripped).
  * @param params The `/CCITTFaxDecode` parameters.
  * @returns The packed bitmap (`rowBytes × rows`, bit 1 = black, MSB first), or
- *   `undefined` when the stream cannot be decoded (e.g. Group 3 2-D, or nothing
- *   decoded at all).
+ *   `undefined` when nothing could be decoded at all.
  */
 export declare function decodeCcitt(data: Uint8Array, params: CcittParams): Uint8Array | undefined;
+/**
+ * ISO/IEC 14492 §C.5 — the bitplanes of a grey-scale image, all MMR-coded into
+ * ONE stream, one after another with an EOFB between them.
+ *
+ * They cannot be decoded a plane at a time from the head of the data, because
+ * nothing says how many BYTES a plane took: the reader has to carry its place
+ * across them. Advancing instead by the size of what came OUT left every plane
+ * after the first reading from the middle of the one before it, and
+ * bitmap-halftone-10bpp-mmr.pdf came back as three specks.
+ *
+ * @param data    The stream holding all the planes.
+ * @param columns Each plane's width, in pixels.
+ * @param rows    Each plane's height.
+ * @param count   How many planes to read.
+ * @returns One packed bitmap per plane, or `undefined` if the first will not
+ *          decode at all.
+ */
+export declare function decodeCcittPlanes(data: Uint8Array, columns: number, rows: number, count: number): Array<Uint8Array> | undefined;
 /** A decoded T.6 two-dimensional mode code: pass, horizontal, or vertical V(d). */
 export interface Mode {
     readonly kind: 'pass' | 'horizontal' | 'vertical';