reamkit 1.25.1 → 1.27.0

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

@@ -2,7 +2,9 @@ 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";
 import { unzlibSync } from "fflate";
 //#region src/pdf-reader/image-decode.ts
@@ -15,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") {
@@ -52,7 +58,17 @@ function decodePdfImage(file, stream) {
 		heightPx: height,
 		degraded: "JPEG 2000 image — limited viewer support"
 	};
-	if (last === "JBIG2Decode") return fail("dropped", "JBIG2-encoded image not decoded");
+	if (last === "JBIG2Decode") {
+		const raster = decodeJbig2Image(file, stream, filters, width, height);
+		if (typeof raster === "string") return fail("dropped", raster);
+		return {
+			ok: true,
+			bytes: encodePng(width, height, raster.color, raster.samples),
+			format: "png",
+			widthPx: width,
+			heightPx: height
+		};
+	}
 	const decoded = last === "CCITTFaxDecode" || last === "CCF" ? decodeCcittImage(file, stream, filters, width, height) : decodeToSamples(file, stream, filters, width, height);
 	if (typeof decoded === "string") return fail("dropped", decoded);
 	const alpha = decodeSMask(file, d, width, height);
@@ -75,6 +91,26 @@ function decodeToSamples(file, stream, filters, width, height) {
 	const decodeArr = decodeArrayOf(file, d);
 	return toColor(cs, unpackSamples(raw, width, height, cs.components, bpc), width * height, bpc, decodeArr);
 }
+/**
+* §7.4.7 — a `/JBIG2Decode` image: the stream's own segments, plus the shared
+* ones a `/JBIG2Globals` holds (the symbol dictionary a scanned book stores
+* once for all its pages).
+*/
+function decodeJbig2Image(file, stream, filters, width, height) {
+	const parms = decodeParmsOf(file, stream.dict);
+	const globalsVal = parms ? file.get(parms, "JBIG2Globals") : void 0;
+	const globalsStream = globalsVal instanceof PdfStream ? globalsVal : void 0;
+	const globals = globalsStream ? file.streamData(globalsStream) : void 0;
+	const packed = decodeJbig2(applyChainExceptLast(filters, stream.data), globals, width, height);
+	if (!packed) return "JBIG2 image not decoded";
+	const rowBytes = width + 7 >> 3;
+	const samples = new Uint8Array(width * height);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) samples[y * width + x] = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1 ? 0 : 255;
+	return {
+		color: "gray",
+		samples
+	};
+}
 function decodeCcittImage(file, stream, filters, width, height) {
 	const parms = decodeParmsOf(file, stream.dict);
 	const columns = (parms ? intOf(file.get(parms, "Columns")) : 0) || 1728;
@@ -85,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 {
@@ -99,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);
@@ -147,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 {
@@ -210,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
@@ -224,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;
@@ -240,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;
@@ -375,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

@@ -0,0 +1,109 @@
+/** A bilevel raster, one byte per pixel, 1 = black — JBIG2's own sense. */
+export interface Jbig2Bitmap {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+}
+/** A context's state: the Table E.1 index and which symbol is currently more probable. */
+interface Cx {
+    i: Uint8Array;
+    mps: Uint8Array;
+}
+/** §E.3.5 — a fresh set of `size` contexts, all at state 0 with MPS 0. */
+export declare function newContexts(size: number): Cx;
+/**
+ * §E.3 — the MQ arithmetic decoder.
+ *
+ * Written as a class with the spec's own register names (`c`, `a`, `ct`)
+ * because the procedures below are transcribed from its flow charts, and a
+ * renaming makes them impossible to check against it.
+ */
+export declare class MQDecoder {
+    private readonly data;
+    private bp;
+    private readonly end;
+    private c;
+    private a;
+    private ct;
+    constructor(data: Uint8Array, start?: number, end?: number);
+    private byteAt;
+    /** BYTEIN (§E.3.4) — 0xFF is the marker escape, so it feeds a shorter byte. */
+    private byteIn;
+    /**
+     * DECODE (§E.3.2) — one bit in context `k`.
+     *
+     * @param cx The context set the caller keeps for this decoding procedure.
+     * @param k  Which context within it.
+     */
+    decode(cx: Cx, k: number): number;
+}
+/** An adaptive template pixel — a coordinate the coder may move (§6.2.5.3). */
+interface At {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * §6.2.5.7 — decode a generic region with the arithmetic coder.
+ *
+ * The context for a pixel is the pattern of already-decoded neighbours the
+ * template names, read MSB first in the order the figures give. `TPGDON` adds a
+ * per-row bit that says "this row is the same as the one above", which is what
+ * makes a page of white space nearly free.
+ *
+ * @param mq       The decoder, positioned at the region's data.
+ * @param cx       The 2^16 generic contexts (shared across a segment's regions).
+ * @param width    Region width in pixels.
+ * @param height   Region height in pixels.
+ * @param template Which of the four templates (0-3).
+ * @param at       The adaptive pixels, one for templates 1-3 and four for 0.
+ * @param tpgdon   Whether typical prediction is on.
+ * @param skip     A bitmap of pixels to leave white without decoding (halftone).
+ */
+export declare function decodeGenericRegion(mq: MQDecoder, cx: Cx, width: number, height: number, template: number, at: ReadonlyArray<At>, tpgdon: boolean, skip?: Jbig2Bitmap): Jbig2Bitmap;
+/**
+ * §6.3.5.6 — refine `reference` into a bitmap of `width` × `height`.
+ *
+ * Refinement codes a bitmap against one already decoded — the same glyph at a
+ * lower resolution, or the same region in an earlier pass — so only where the
+ * two differ costs anything.
+ *
+ * @param dx Where the reference sits relative to the region (GRREFERENCEDX).
+ * @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.
+ *
+ * @param data    The `/JBIG2Decode` stream's own segments.
+ * @param globals The `/JBIG2Globals` stream's segments, when the image names one.
+ * @param width   The image's `/Width`, which the page info may not state.
+ * @param height  Its `/Height`.
+ * @returns A packed 1-bit-per-pixel bitmap (`rowBytes × height`, bit 1 = black,
+ *   MSB first) — the same shape {@link decodeCcitt} returns — or `undefined`
+ *   when nothing in the stream could be decoded.
+ */
+export declare function decodeJbig2(data: Uint8Array, globals: Uint8Array | undefined, width: number, height: number): Uint8Array | undefined;
+export {};