reamkit 1.26.0 → 1.27.0

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

@@ -2,6 +2,7 @@ import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
 import { encodePng } from "../core/png-encode.js";
 import { lzwDecodeMsb } from "../core/lzw.js";
 import { reversePredictor } from "./predictor.js";
+import { labToSrgb } from "./cie-color.js";
 import { decodeCcitt } from "./ccitt.js";
 import { decodeJbig2 } from "./jbig2.js";
 import { decodeJpeg } from "./jpeg.js";
@@ -16,19 +17,23 @@ var MAX_PIXELS = 4e7;
 * Supports DeviceGray/RGB/CMYK, CalGray/CalRGB, ICCBased (by `/N`) and Indexed
 * colour spaces; Flate, LZW (EP12), RunLength, ASCII85, ASCIIHex and CCITT
 * Group 4 / Group 3 1-D fax (EP15) filters; PNG/TIFF predictors; bit depths
-* 1/2/4/8/16; and an `/SMask` folded in as the PNG alpha channel. Unsupported
-* inputs (stencil `/ImageMask`, Separation/DeviceN/Lab, JBIG2, CCITT Group 3
-* 2-D) return a typed failure so the caller records a loss.
+* 1/2/4/8/16; an `/SMask` folded in as the PNG alpha channel; and a stencil
+* `/ImageMask` (§8.9.6.2) given back as RGBA in `fillHex`. Unsupported inputs
+* (Separation/DeviceN/Lab, CCITT Group 3 2-D) return a typed failure so the
+* caller records a loss.
 *
+* @param file    The owning file.
+* @param stream  The image XObject, or an inline image wrapped as one.
+* @param fillHex §8.9.6.2 — the non-stroking colour a stencil mask paints in.
 * @returns The decoded image, or `{ ok: false }` with the loss severity and reason.
 */
-function decodePdfImage(file, stream) {
+function decodePdfImage(file, stream, fillHex) {
 	const d = stream.dict;
 	const width = intOf(file.get(d, "Width")) || intOf(file.get(d, "W"));
 	const height = intOf(file.get(d, "Height")) || intOf(file.get(d, "H"));
 	if (width <= 0 || height <= 0) return fail("dropped", "image with no dimensions");
 	if (width * height > MAX_PIXELS) return fail("dropped", "image too large to decode");
-	if (boolOf(d.get("ImageMask")) || boolOf(d.get("IM"))) return fail("dropped", "stencil image mask not reconstructed");
+	if (boolOf(d.get("ImageMask")) || boolOf(d.get("IM"))) return stencil(file, stream, width, height, fillHex);
 	const filters = filterNames(file, d);
 	const last = filters[filters.length - 1];
 	if (last === "DCTDecode" || last === "DCT") {
@@ -116,13 +121,14 @@ function decodeCcittImage(file, stream, filters, width, height) {
 		byteAlign: parms ? boolOf(file.get(parms, "EncodedByteAlign")) : false
 	});
 	if (!packed) return "CCITT fax image not decoded (Group 3 2-D or malformed)";
+	const blackIs1 = parms ? boolOf(file.get(parms, "BlackIs1")) : false;
 	const rowBytes = columns + 7 >> 3;
 	const samples = new Uint8Array(width * height);
 	for (let y = 0; y < height; y++) {
 		const rowOff = y * rowBytes;
 		for (let x = 0; x < width; x++) {
-			const black = x < columns ? packed[rowOff + (x >> 3)] >> 7 - (x & 7) & 1 : 0;
-			samples[y * width + x] = black ? 0 : 255;
+			const bit = x < columns ? packed[rowOff + (x >> 3)] >> 7 - (x & 7) & 1 : 0;
+			samples[y * width + x] = bit === (blackIs1 ? 0 : 1) ? 0 : 255;
 		}
 	}
 	return {
@@ -130,6 +136,89 @@ function decodeCcittImage(file, stream, filters, width, height) {
 		samples
 	};
 }
+/**
+* §8.9.6.2 — a stencil mask: one bit per pixel saying WHERE to paint, and the
+* colour is whatever the page's non-stroking colour was at the `Do`.
+*
+* A sample of 0 paints and 1 leaves the page alone, which `/Decode [1 0]`
+* swaps. Given back as an RGBA picture — the fill colour throughout, opaque
+* where the stencil paints and clear where it does not — which is what the mask
+* MEANS and what every format downstream can show.
+* images_1bit_grayscale.pdf draws two of them and they were dropped entirely.
+*/
+function stencil(file, stream, width, height, fillHex) {
+	const d = stream.dict;
+	const filters = filterNames(file, d);
+	const last = filters[filters.length - 1];
+	const packed = last === "CCITTFaxDecode" || last === "CCF" ? ccittBits(file, stream, filters, height) : last === "JBIG2Decode" ? jbig2Bits(file, stream, filters, width, height) : decodeChain(file, stream, filters);
+	if (!packed) return fail("dropped", "stencil image mask not decoded");
+	const decode = file.resolve(d.get("Decode") ?? d.get("D") ?? PDF_NULL);
+	const paintBit = Array.isArray(decode) && file.resolve(decode[0] ?? PDF_NULL) === 1 ? 1 : 0;
+	const rgb = fillHex !== void 0 ? parseHex(fillHex) : [
+		0,
+		0,
+		0
+	];
+	const rowBytes = width + 7 >> 3;
+	if (packed.length < rowBytes * height) return fail("dropped", "stencil image mask truncated");
+	const samples = new Uint8Array(width * height * 4);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		const bit = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
+		const at = (y * width + x) * 4;
+		samples[at] = rgb[0];
+		samples[at + 1] = rgb[1];
+		samples[at + 2] = rgb[2];
+		samples[at + 3] = bit === paintBit ? 255 : 0;
+	}
+	return {
+		ok: true,
+		bytes: encodePng(width, height, "rgba", samples),
+		format: "png",
+		widthPx: width,
+		heightPx: height
+	};
+}
+/** A 6-hex colour as its three bytes. */
+function parseHex(hex) {
+	const v = Number.parseInt(hex, 16);
+	if (!Number.isFinite(v)) return [
+		0,
+		0,
+		0
+	];
+	return [
+		v >> 16 & 255,
+		v >> 8 & 255,
+		v & 255
+	];
+}
+/** A stencil's bits where the file coded them as fax (§7.4.6). */
+function ccittBits(file, stream, filters, height) {
+	const parms = decodeParmsOf(file, stream.dict);
+	const columns = (parms ? intOf(file.get(parms, "Columns")) : 0) || 1728;
+	const packed = decodeCcitt(applyChainExceptLast(filters, stream.data), {
+		k: parms ? intOf(file.get(parms, "K")) : 0,
+		columns,
+		rows: height,
+		byteAlign: parms ? boolOf(file.get(parms, "EncodedByteAlign")) : false
+	});
+	if (!packed) return void 0;
+	if (parms ? boolOf(file.get(parms, "BlackIs1")) : false) return packed;
+	const flipped = new Uint8Array(packed.length);
+	for (let i = 0; i < packed.length; i++) flipped[i] = ~packed[i] & 255;
+	return flipped;
+}
+/** …or as JBIG2, which codes 1 as black and so paints on 1. */
+function jbig2Bits(file, stream, filters, width, height) {
+	const parms = decodeParmsOf(file, stream.dict);
+	const globalsVal = parms ? file.get(parms, "JBIG2Globals") : void 0;
+	const globals = globalsVal instanceof PdfStream ? file.streamData(globalsVal) : void 0;
+	const packed = decodeJbig2(applyChainExceptLast(filters, stream.data), globals, width, height);
+	if (!packed) return void 0;
+	const flipped = new Uint8Array(packed.length);
+	for (let i = 0; i < packed.length; i++) flipped[i] = ~packed[i] & 255;
+	return flipped;
+}
 function resolveColorSpace(file, csVal) {
 	const cs = file.resolve(csVal ?? PDF_NULL);
 	if (cs instanceof PdfName) return namedColorSpace(cs.value);
@@ -178,6 +267,39 @@ function resolveColorSpace(file, csVal) {
 			lookup
 		};
 	}
+	if (tag === "Lab") {
+		const params = file.resolve(cs[1] ?? PDF_NULL);
+		const dict = params instanceof Map ? params : void 0;
+		const nums = (v) => {
+			const r = v !== void 0 ? file.resolve(v) : void 0;
+			return Array.isArray(r) ? r.map((x) => typeof file.resolve(x) === "number" ? file.resolve(x) : 0) : [];
+		};
+		const white = dict ? nums(file.get(dict, "WhitePoint")) : [];
+		if (white.length < 3 || !(white[1] > 0)) return void 0;
+		const range = dict ? nums(file.get(dict, "Range")) : [];
+		return {
+			kind: "lab",
+			components: 3,
+			lab: {
+				white: [
+					white[0],
+					white[1],
+					white[2]
+				],
+				range: range.length === 4 ? [
+					range[0],
+					range[1],
+					range[2],
+					range[3]
+				] : [
+					-100,
+					100,
+					-100,
+					100
+				]
+			}
+		};
+	}
 }
 function namedColorSpace(name) {
 	if (name === "DeviceGray" || name === "G" || name === "CalGray") return {
@@ -241,13 +363,48 @@ function toColor(cs, s, px, bpc, decode) {
 			samples: out
 		};
 	}
+	if (cs.kind === "lab") {
+		const lab = cs.lab;
+		const out = new Uint8Array(px * 3);
+		const span = (i) => decode && decode.length >= 6 ? [0, 1] : i === 0 ? [0, 100] : [lab.range[(i - 1) * 2], lab.range[(i - 1) * 2 + 1]];
+		for (let i = 0; i < px; i++) {
+			const comp = [
+				0,
+				1,
+				2
+			].map((k) => {
+				const t = c01(s[i * 3 + k], k);
+				const [lo, hi] = span(k);
+				return lo + t * (hi - lo);
+			});
+			const [r, g, b] = labToSrgb(lab.white, [
+				comp[0],
+				comp[1],
+				comp[2]
+			]);
+			out[i * 3] = Math.round(r * 255);
+			out[i * 3 + 1] = Math.round(g * 255);
+			out[i * 3 + 2] = Math.round(b * 255);
+		}
+		return {
+			color: "rgb",
+			samples: out
+		};
+	}
 	const base = cs.base;
 	const lookup = cs.lookup;
 	const hival = cs.hival ?? 255;
 	const bn = base.components;
+	const index = (v) => {
+		if (!decode || decode.length < 2) return Math.min(v, hival);
+		const lo = decode[0];
+		const hi = decode[1];
+		const at = maxv > 0 ? lo + v / maxv * (hi - lo) : lo;
+		return Math.min(Math.max(0, Math.round(at)), hival);
+	};
 	if (base.kind === "gray") {
 		const out = new Uint8Array(px);
-		for (let i = 0; i < px; i++) out[i] = lookup[Math.min(s[i], hival) * bn] ?? 0;
+		for (let i = 0; i < px; i++) out[i] = lookup[index(s[i]) * bn] ?? 0;
 		return {
 			color: "gray",
 			samples: out
@@ -255,7 +412,7 @@ function toColor(cs, s, px, bpc, decode) {
 	}
 	const out = new Uint8Array(px * 3);
 	for (let i = 0; i < px; i++) {
-		const [r, g, b] = paletteRgb(base, lookup, Math.min(s[i], hival) * bn);
+		const [r, g, b] = paletteRgb(base, lookup, index(s[i]) * bn);
 		out[i * 3] = r;
 		out[i * 3 + 1] = g;
 		out[i * 3 + 2] = b;
@@ -271,6 +428,20 @@ function paletteRgb(base, lookup, off) {
 		lookup[off + 1] ?? 0,
 		lookup[off + 2] ?? 0
 	];
+	if (base.kind === "lab" && base.lab) {
+		const r = base.lab.range;
+		const at = (i, lo, hi) => lo + (lookup[off + i] ?? 0) / 255 * (hi - lo);
+		const [sr, sg, sb] = labToSrgb(base.lab.white, [
+			at(0, 0, 100),
+			at(1, r[0], r[1]),
+			at(2, r[2], r[3])
+		]);
+		return [
+			Math.round(sr * 255),
+			Math.round(sg * 255),
+			Math.round(sb * 255)
+		];
+	}
 	if (base.kind === "cmyk") {
 		const c = (lookup[off] ?? 0) / 255;
 		const m = (lookup[off + 1] ?? 0) / 255;
@@ -406,15 +577,25 @@ function combineAlpha(color, alpha) {
 	};
 }
 function filterNames(file, d) {
-	const f = file.resolve(d.get("Filter") ?? PDF_NULL);
+	const f = file.resolve(d.get("Filter") ?? d.get("F") ?? PDF_NULL);
 	const arr = Array.isArray(f) ? f : [f];
 	const out = [];
 	for (const x of arr) {
 		const r = file.resolve(x);
-		if (r instanceof PdfName) out.push(r.value);
+		if (r instanceof PdfName) out.push(FILTER_ABBREVIATIONS[r.value] ?? r.value);
 	}
 	return out;
 }
+/** §8.9.7 Table 93 — the short name an inline image writes a filter under. */
+var FILTER_ABBREVIATIONS = {
+	AHx: "ASCIIHexDecode",
+	A85: "ASCII85Decode",
+	LZW: "LZWDecode",
+	Fl: "FlateDecode",
+	RL: "RunLengthDecode",
+	CCF: "CCITTFaxDecode",
+	DCT: "DCTDecode"
+};
 function decodeChain(file, stream, filters) {
 	let data = stream.data;
 	let mayPredict = false;

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

@@ -1,3 +1,4 @@
+import { ImageCrop } from '../core/document-model/types.js';
 import { Loss } from '../core/ir/index.js';
 import { PdfFile, PdfPage } from './document.js';
 /**
@@ -15,6 +16,17 @@ export interface PdfImage {
     /** Page-space lower-left corner (points, y-up). */
     readonly x: number;
     readonly y: number;
+    /**
+     * §8.9.5 — how far the CTM turns the picture, in degrees counter-clockwise.
+     * The box above is the picture's own, unturned; a turn spins it about its
+     * centre, which is what every downstream format does with one.
+     */
+    readonly rotationDeg?: number;
+    /**
+     * §8.5.4 — the fraction of each of the picture's OWN edges a clip cut away,
+     * where one bounded it: `a:srcRect` in DrawingML terms. Absent is whole.
+     */
+    readonly crop?: ImageCrop;
     /** Enclosing marked-content id, if the placement was inside a `/Figure`. */
     readonly mcid?: number;
     /**

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

@@ -1,8 +1,10 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { FEATURES } from "../core/ir/features.js";
 import { interpretContent, multiply } from "./content.js";
-import { decodePdfImage } from "./image-decode.js";
+import { buildAlphaMap } from "./shading.js";
 import { collectPageAppearances } from "./annots.js";
+import { hiddenProperties, hiddenXObject } from "./optional-content.js";
+import { decodePdfImage } from "./image-decode.js";
 //#region src/pdf-reader/images.ts
 var NO_FONTS = /* @__PURE__ */ new Map();
 var MAX_FORM_DEPTH = 12;
@@ -20,6 +22,7 @@ function collectPageImages(file, page) {
 	const images = [];
 	const lossByDetail = /* @__PURE__ */ new Map();
 	const visiting = /* @__PURE__ */ new Set();
+	const alphaCache = /* @__PURE__ */ new Map();
 	const addLoss = (severity, detail) => {
 		if (!lossByDetail.has(detail)) lossByDetail.set(detail, {
 			severity,
@@ -30,7 +33,12 @@ function collectPageImages(file, page) {
 	const walk = (resources, content, baseCtm, depth, inheritedMcid, prefix) => {
 		const xobjects = resources ? file.get(resources, "XObject") : PDF_NULL;
 		const xobjDict = xobjects instanceof Map ? xobjects : void 0;
-		const result = interpretContent(content, NO_FONTS, baseCtm);
+		let paints = alphaCache.get(resources);
+		if (!paints) {
+			paints = buildAlphaMap(file, resources);
+			alphaCache.set(resources, paints);
+		}
+		const result = interpretContent(content, NO_FONTS, baseCtm, void 0, paints, void 0, hiddenProperties(file, resources));
 		const patterns = resources ? file.get(resources, "Pattern") : PDF_NULL;
 		const patternDict = patterns instanceof Map ? patterns : void 0;
 		for (const vector of result.vectors) {
@@ -45,18 +53,32 @@ function collectPageImages(file, page) {
 		}
 		for (const placement of result.images) {
 			if (images.length >= MAX_IMAGES) return;
+			if (placement.inline) {
+				const decoded = decodePdfImage(file, new PdfStream(placement.inline.dict, placement.inline.data), placement.fillHex);
+				if (decoded.ok) {
+					images.push({
+						...geometry(placement.ctm, decoded, placement.mcid ?? inheritedMcid, placement.clip),
+						orderKey: [...prefix, placement.order]
+					});
+					if (decoded.degraded) addLoss("degraded", decoded.degraded);
+				} else addLoss(decoded.severity, decoded.detail);
+				continue;
+			}
 			const stream = xobjDict ? file.resolve(xobjDict.get(placement.name) ?? PDF_NULL) : PDF_NULL;
 			if (!(stream instanceof PdfStream)) continue;
+			if (hiddenXObject(file, stream)) continue;
 			const subtype = nameOf(file.get(stream.dict, "Subtype"));
 			const mcid = placement.mcid ?? inheritedMcid;
 			if (subtype === "Image") {
-				const decoded = decodePdfImage(file, stream);
+				const decoded = decodePdfImage(file, stream, placement.fillHex);
 				if (decoded.ok) {
 					images.push({
-						...geometry(placement.ctm, decoded, mcid),
+						...geometry(placement.ctm, decoded, mcid, placement.clip),
 						orderKey: [...prefix, placement.order]
 					});
 					if (decoded.degraded) addLoss("degraded", decoded.degraded);
+					if (placement.blend !== void 0) addLoss("degraded", `PDF blend mode /${placement.blend} is not performed; the picture is drawn over what it was to blend with`);
+					if (placement.masked === true) addLoss("degraded", "PDF soft mask (/SMask in the graphics state) is not applied; the picture is drawn at full opacity throughout");
 				} else addLoss(decoded.severity, decoded.detail);
 			} else if (subtype === "Form" && depth < MAX_FORM_DEPTH && !visiting.has(stream)) {
 				visiting.add(stream);
@@ -82,17 +104,95 @@ function collectPageImages(file, page) {
 		losses: [...lossByDetail.values()]
 	};
 }
-function geometry(ctm, decoded, mcid) {
+function geometry(ctm, decoded, mcid, clip) {
+	const widthPt = Math.hypot(ctm[0], ctm[1]) || 1;
+	const heightPt = Math.hypot(ctm[2], ctm[3]) || 1;
+	const angle = Math.atan2(ctm[1], ctm[0]) * 180 / Math.PI;
+	const box = clippedUnitBox(ctm, clip);
+	const u = (box.u0 + box.u1) / 2;
+	const v = (box.v0 + box.v1) / 2;
+	const cx = ctm[0] * u + ctm[2] * v + ctm[4];
+	const cy = ctm[1] * u + ctm[3] * v + ctm[5];
+	const shownW = widthPt * (box.u1 - box.u0);
+	const shownH = heightPt * (box.v1 - box.v0);
+	const crop = box.u0 > 0 || box.v0 > 0 || box.u1 < 1 || box.v1 < 1 ? {
+		left: box.u0,
+		right: 1 - box.u1,
+		top: 1 - box.v1,
+		bottom: box.v0
+	} : void 0;
 	return {
 		bytes: decoded.bytes,
 		format: decoded.format,
-		widthPt: Math.hypot(ctm[0], ctm[1]) || 1,
-		heightPt: Math.hypot(ctm[2], ctm[3]) || 1,
-		x: ctm[4],
-		y: ctm[5],
+		widthPt: shownW,
+		heightPt: shownH,
+		x: cx - shownW / 2,
+		y: cy - shownH / 2,
+		...crop ? { crop } : {},
+		...Math.abs(angle) > .5 ? { rotationDeg: angle } : {},
 		...mcid !== void 0 ? { mcid } : {}
 	};
 }
+/** Below this the clip took a sliver off an edge and is not worth a crop. */
+var CROPS = .01;
+/**
+* §8.5.4 — the part of the unit square a clip leaves showing, in the PICTURE's
+* own axes.
+*
+* A clip is stated in the page's coordinates and a picture may be turned within
+* them, so intersecting the two boxes as they stand crops along the wrong axes.
+* Carried back through the placement matrix the clip lands in the unit square
+* the image is drawn into, where a crop is what `a:srcRect` means: the fraction
+* off each of the picture's own edges. image-rotated-black-white-ratio.pdf
+* turns picture and clip together by thirty-one degrees, and in that space the
+* clip is square on and takes the middle 53% of both sides.
+*
+* Where the clip is turned differently from the picture this bounds it rather
+* than cutting it exactly — a rectangle is all `a:srcRect` can say.
+*/
+function clippedUnitBox(ctm, clip) {
+	const whole = {
+		u0: 0,
+		v0: 0,
+		u1: 1,
+		v1: 1
+	};
+	if (!clip) return whole;
+	const det = ctm[0] * ctm[3] - ctm[1] * ctm[2];
+	if (!Number.isFinite(det) || Math.abs(det) < 1e-9) return whole;
+	let u0 = Infinity;
+	let v0 = Infinity;
+	let u1 = -Infinity;
+	let v1 = -Infinity;
+	const add = (x, y) => {
+		const dx = x - ctm[4];
+		const dy = y - ctm[5];
+		const u = (ctm[3] * dx - ctm[2] * dy) / det;
+		const v = (ctm[0] * dy - ctm[1] * dx) / det;
+		u0 = Math.min(u0, u);
+		v0 = Math.min(v0, v);
+		u1 = Math.max(u1, u);
+		v1 = Math.max(v1, v);
+	};
+	for (const seg of clip.segs) {
+		if (seg.op === "close") continue;
+		if (seg.op === "cubic") {
+			add(seg.x1, seg.y1);
+			add(seg.x2, seg.y2);
+		}
+		add(seg.x, seg.y);
+	}
+	if (!Number.isFinite(u0) || !Number.isFinite(v0)) return whole;
+	const cut = {
+		u0: Math.min(1, Math.max(0, u0)),
+		v0: Math.min(1, Math.max(0, v0)),
+		u1: Math.min(1, Math.max(0, u1)),
+		v1: Math.min(1, Math.max(0, v1))
+	};
+	if (!(cut.u1 - cut.u0 > CROPS) || !(cut.v1 - cut.v0 > CROPS)) return whole;
+	if (cut.u1 - cut.u0 > 1 - CROPS && cut.v1 - cut.v0 > 1 - CROPS) return whole;
+	return cut;
+}
 function matrixOf(file, dict) {
 	const m = file.resolve(dict.get("Matrix") ?? PDF_NULL);
 	if (Array.isArray(m) && m.length >= 6 && m.every((v) => typeof v === "number")) return [

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

@@ -71,6 +71,29 @@ export declare function decodeGenericRegion(mq: MQDecoder, cx: Cx, width: number
  * @param dy Likewise, vertically.
  */
 export declare function decodeRefinement(mq: MQDecoder, cx: Cx, width: number, height: number, template: number, reference: Jbig2Bitmap, dx: number, dy: number, at: ReadonlyArray<At>, tpgron: boolean): Jbig2Bitmap;
+/**
+ * §6.4.5 — draw a text region: a run of strips, each holding instances of the
+ * symbols in `symbols`, placed by running coordinates rather than absolute ones.
+ *
+ * This is what JBIG2 is for. A scanned page is not stored as pixels but as "the
+ * shape called 37, here; the shape called 12, four pixels on" — so the letter
+ * "e" costs its bitmap once and a few bits per occurrence after that.
+ */
+/**
+ * §6.4.5 Table 34 — SBSYMCODELEN, how many bits a text region spends naming
+ * one of its symbols.
+ *
+ * `ceil(log2(SBNUMSYMS))`, and for ONE symbol that is ZERO: there is nothing to
+ * choose, so no bits are read and the id is always that symbol.
+ * Rounded up to one — which the HUFFMAN side of the same table does need — the
+ * decoder takes a bit belonging to the next field and reads the id as 1, which
+ * is no symbol at all: bitmap-symbol-big-segmentid.pdf places one instance of
+ * one symbol in each of two regions, and both came back empty.
+ *
+ * @param symbols How many symbols the region has to choose between.
+ * @returns The number of bits an id takes.
+ */
+export declare function symbolCodeLength(symbols: number): number;
 /**
  * Decode an embedded JBIG2 image.
  *

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

@@ -1,4 +1,4 @@
-import { decodeCcitt } from "./ccitt.js";
+import { decodeCcitt, decodeCcittPlanes } from "./ccitt.js";
 //#region src/pdf-reader/jbig2.ts
 function makeBitmap(width, height, fill = 0) {
 	const data = new Uint8Array(width * height);
@@ -1792,10 +1792,27 @@ var Corner = /* @__PURE__ */ function(Corner) {
 * shape called 37, here; the shape called 12, four pixels on" — so the letter
 * "e" costs its bitmap once and a few bits per occurrence after that.
 */
+/**
+* §6.4.5 Table 34 — SBSYMCODELEN, how many bits a text region spends naming
+* one of its symbols.
+*
+* `ceil(log2(SBNUMSYMS))`, and for ONE symbol that is ZERO: there is nothing to
+* choose, so no bits are read and the id is always that symbol.
+* Rounded up to one — which the HUFFMAN side of the same table does need — the
+* decoder takes a bit belonging to the next field and reads the id as 1, which
+* is no symbol at all: bitmap-symbol-big-segmentid.pdf places one instance of
+* one symbol in each of two regions, and both came back empty.
+*
+* @param symbols How many symbols the region has to choose between.
+* @returns The number of bits an id takes.
+*/
+function symbolCodeLength(symbols) {
+	return Math.ceil(Math.log2(Math.max(symbols, 1)));
+}
 function decodeTextRegion(mq, symbols, p, stripsLog) {
 	const bmp = makeBitmap(p.width, p.height, p.defPixel);
 	const strips = 1 << stripsLog;
-	const codeLen = Math.max(1, Math.ceil(Math.log2(Math.max(symbols.length, 1))));
+	const codeLen = symbolCodeLength(symbols.length);
 	const iadt = new IntDecoder(mq);
 	const iafs = new IntDecoder(mq);
 	const iads = new IntDecoder(mq);
@@ -2164,21 +2181,13 @@ function decodePatternDictionary(data, mmr, template, pw, ph, grayMax) {
 function decodeGrayScale(mq, data, mmr, template, at, width, height, bits, skip) {
 	const cx = newContexts(65536);
 	const planes = new Array(bits);
-	let mmrOffset = 0;
+	const packed = mmr ? decodeCcittPlanes(data, width, height, bits) : void 0;
+	const rowBytes = width + 7 >> 3;
 	const decoder = mq ?? new MQDecoder(data);
 	for (let j = bits - 1; j >= 0; j--) if (mmr) {
-		const packed = decodeCcitt(data.subarray(mmrOffset), {
-			k: -1,
-			columns: width,
-			rows: height,
-			byteAlign: false
-		});
+		const bytes = packed?.[bits - 1 - j];
 		const plane = makeBitmap(width, height);
-		if (packed) {
-			const rowBytes = width + 7 >> 3;
-			for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) plane.data[y * width + x] = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
-			mmrOffset += packed.length;
-		}
+		if (bytes) for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) plane.data[y * width + x] = bytes[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
 		planes[j] = plane;
 	} else planes[j] = decodeGenericRegion(decoder, cx, width, height, template, at, false, skip);
 	const values = new Array(width * height).fill(0);

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

@@ -1,5 +1,7 @@
 import { PdfFile } from './document.js';
 import { Reconstruction } from './flow-build.js';
+/** §9.10.2 — a glyph the face maps to no character (see `./font`). */
+export declare const UNMAPPED = "\uFFFD";
 /**
  * Heuristically reconstruct an untagged PDF into a {@link Reconstruction}
  * (E-PDF EP4). With no structure tree there is only positioned content, so
@@ -16,3 +18,33 @@ import { Reconstruction } from './flow-build.js';
  * @returns The reconstructed {@link FlowDoc} plus any read-time losses.
  */
 export declare function reconstructByLayout(file: PdfFile, mode?: 'flow' | 'positional'): Reconstruction;
+/**
+ * Whether a line ENDED a paragraph, rather than wrapping into the next.
+ *
+ * Leading alone cannot tell the two apart: five labels stacked at 15pt with a
+ * 12pt face look exactly like five wrapped lines, and alphatrans.pdf's five are
+ * read as one paragraph and re-wrapped into two. But a wrapping engine pulls
+ * the next word UP — so a line that stops well short of the measure stopped
+ * because its author stopped it, and the line after it begins something new.
+ * The same rule separates two paragraphs set with no extra space between them,
+ * which used to run together for the same reason.
+ *
+ * Only where both lines start at the same edge. Where they do not, the block is
+ * placed rather than set — a centred title's every line is short of the measure
+ * and none of them ends anything.
+ *
+ * @param prev   The line before: where it starts, how wide it is, its face.
+ * @param next   The line after — only where it starts matters.
+ * @param column The measure both were set in, when it is known.
+ * @returns Whether the first line ended a paragraph.
+ */
+export declare function endedParagraph(prev: {
+    x: number;
+    width: number;
+    fontSize: number;
+}, next: {
+    x: number;
+}, column: {
+    left: number;
+    right: number;
+} | undefined): boolean;