reamkit 1.25.1 → 1.27.0

package/README.md

@@ -191,12 +191,19 @@ preview, flowed HTML export, and **docx + xlsx output** (write WordprocessingML
 tagged PDF from its structure tree (headings, tables, lists, reading order), an
 untagged one heuristically from glyph positions (lines, paragraphs, headings,
 and a clean two-column split). It lifts back the text (via each font's
-`/ToUnicode`, or the embedded program's own `cmap` where there is none), the
+`/ToUnicode`, or the embedded program's own `cmap` where there is none, or the
+glyph names its `/Encoding` states — which is all a PDF from TeX gives), the
 font programs themselves, raster images (JPEG verbatim; PNG/Flate/LZW/CCITT-fax
-decoded and re-encoded), `/Link` hyperlinks, form-XObject content, annotation
-appearances, and the page's artwork: filled / stroked / gradient shapes,
-clipping paths, tiling patterns, constant alpha, and the Type 3 glyphs that are
-drawings rather than letters. It reads modern compressed files (cross-reference
+and **JBIG2** decoded and re-encoded), `/Link` hyperlinks, form-XObject content,
+annotation appearances (drawing one itself where the file supplies none),
+colour set through a named space — device, CIE (`CalGray`, `Lab`) or a
+`Separation`/`DeviceN` run through its own tint transform — and the page's
+artwork: filled / stroked / gradient shapes, clipping paths, tiling patterns,
+stencil image masks, constant alpha, and the Type 3 glyphs that are drawings
+rather than letters. It honours the layers a file turns off (§8.11 optional
+content) and the box it says to show (`/CropBox`), and it decides for itself
+whether a file is a document to re-flow or a page to keep — a paper is mostly
+lines, a form is mostly marks — which `pdfLayout` overrides. It reads modern compressed files (cross-reference
 + object streams) and encrypted ones (RC4 / AES — the user password is passed to
 `Ream.parse(bytes, { password })`, defaulting to the permissions-only case); a
 filter it does not carry can be handed to it through

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

@@ -0,0 +1,65 @@
+import { PdfDict, PdfStream } from '../pdf/objects.js';
+import { PdfFile } from './document.js';
+/**
+ * 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`.
+ */
+export declare function drawnAppearance(file: PdfFile, annot: PdfDict): PdfStream | undefined;
+/**
+ * §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.
+ */
+export declare function drawnResources(file: PdfFile, annot: PdfDict): PdfDict | undefined;
+/**
+ * §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.
+ */
+export declare function textMarkupOf(file: PdfFile, annot: PdfDict): TextMarkupAnnot | undefined;
+/** A text-markup annotation: how it marks, and the boxes it marks. */
+export interface TextMarkupAnnot {
+    readonly mark: TextMarkup;
+    readonly quads: ReadonlyArray<Quad>;
+}
+/** §12.5.6.10 — how a text-markup annotation marks the words it covers. */
+export interface TextMarkup {
+    /** `/Highlight` — the wash painted behind them (6-hex). */
+    readonly highlightHex?: string;
+    /** `/Underline`, `/Squiggly` — a rule under them, straight or wavy. */
+    readonly underline?: 'single' | 'wave';
+    /** The rule's own colour (6-hex), when the annotation states one. */
+    readonly underlineHex?: string;
+    /** `/StrikeOut` — a rule through them. */
+    readonly strike?: boolean;
+}
+/** One marked box in page space: its span of x, its foot and its height. */
+export interface Quad {
+    readonly x0: number;
+    readonly x1: number;
+    readonly y0: number;
+    readonly h: number;
+}

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

@@ -0,0 +1,374 @@
+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);
+	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.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

@@ -15,7 +15,9 @@ export interface Appearance {
  *
  * 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.

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,7 +11,9 @@ 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.
@@ -25,10 +28,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)) 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 +62,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

@@ -23,6 +23,24 @@ export interface CcittParams {
  *   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';

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

@@ -10,10 +10,46 @@
 *   decoded at all).
 */
 function decodeCcitt(data, params) {
+	return decodeInto(new BitReader(data), params);
+}
+/**
+* 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.
+*/
+function decodeCcittPlanes(data, columns, rows, count) {
+	const reader = new BitReader(data);
+	const out = [];
+	for (let i = 0; i < count; i++) {
+		const plane = decodeInto(reader, {
+			k: -1,
+			columns,
+			rows,
+			byteAlign: false
+		});
+		if (!plane) return out.length > 0 ? out : void 0;
+		out.push(plane);
+		reader.skipEofb();
+		reader.align();
+	}
+	return out;
+}
+function decodeInto(reader, params) {
 	const { k, columns, rows, byteAlign } = params;
 	if (k > 0) return void 0;
 	if (columns <= 0 || rows <= 0 || columns > 1 << 20) return void 0;
-	const reader = new BitReader(data);
 	const rowBytes = columns + 7 >> 3;
 	const out = new Uint8Array(rowBytes * rows);
 	let ref = [columns, columns];
@@ -145,6 +181,38 @@ var BitReader = class {
 			this.bytePos++;
 		}
 	}
+	/**
+	* Step over the end-of-facsimile-block that closes an MMR plane: two EOLs,
+	* each eleven zeroes and a one. Anything else is left where it stands.
+	*/
+	skipEofb() {
+		const at = {
+			byte: this.bytePos,
+			bit: this.bitPos
+		};
+		for (let eol = 0; eol < 2; eol++) {
+			let zeros = 0;
+			for (;;) {
+				const b = this.readBit();
+				if (b < 0) return;
+				if (b === 0) {
+					zeros++;
+					if (zeros > 64) {
+						this.bytePos = at.byte;
+						this.bitPos = at.bit;
+						return;
+					}
+					continue;
+				}
+				if (zeros < 11) {
+					this.bytePos = at.byte;
+					this.bitPos = at.bit;
+					return;
+				}
+				break;
+			}
+		}
+	}
 };
 /**
 * T.4 white-run modified-Huffman codes as `[run, bit-string]` (terminating runs
@@ -406,4 +474,4 @@ var WHITE = buildRunTable(WHITE_CODES, SHARED_MAKEUP);
 var BLACK = buildRunTable(BLACK_CODES, SHARED_MAKEUP);
 var MODES = new Map(MODE_CODES.map(([bits, m]) => [bits.length << 8 | parseInt(bits, 2), m]));
 //#endregion
-export { decodeCcitt };
+export { decodeCcitt, decodeCcittPlanes };

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

@@ -0,0 +1,33 @@
+/** §8.6.5.6/§8.6.5.7 — what a CIE-based space states about itself. */
+export interface CieSpace {
+    /** `/WhitePoint` — the colour of the illuminant, in XYZ. */
+    readonly white: readonly [number, number, number];
+    /** `/Gamma` — one per component. */
+    readonly gamma: ReadonlyArray<number>;
+    /** §8.6.5.7 `/Matrix` — components to XYZ, column-major as the PDF states it. */
+    readonly matrix?: ReadonlyArray<number>;
+}
+/**
+ * One colour in a CIE-based space, as sRGB in 0..1.
+ *
+ * @param space The space's own parameters.
+ * @param abc   Its components: one for a grey space, three for an RGB one.
+ * @returns The sRGB triple a viewer shows for it.
+ */
+export declare function cieToSrgb(space: CieSpace, abc: ReadonlyArray<number>): [number, number, number];
+/**
+ * §8.6.5.8 — one colour in a `Lab` space, as sRGB in 0..1.
+ *
+ * Lab is the one CIE space a file states in absolute terms: `L*` from 0 to 100
+ * is lightness and `a*`/`b*` are the two opponent axes, and unlike `CalRGB`
+ * (see the note above) there is no argument about the way out — every renderer
+ * takes it through XYZ against the stated white and adapts to the screen's.
+ * issue10339_reduced.pdf paints two grids of blue swatches through an `Indexed`
+ * palette whose base is one, and read as anything else the page came back
+ * blank.
+ *
+ * @param white The space's `/WhitePoint`, in XYZ.
+ * @param lab   `L*`, `a*`, `b*`.
+ * @returns The sRGB triple a viewer shows for it.
+ */
+export declare function labToSrgb(white: readonly [number, number, number], lab: readonly [number, number, number]): [number, number, number];