reamkit 1.26.0 → 1.28.0

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

@@ -2,6 +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 { ascii85Decode, asciiHexDecode, runLengthDecode } from "./stream-filters.js";
+import { labToSrgb } from "./cie-color.js";
+import { readFunction } from "./function.js";
 import { decodeCcitt } from "./ccitt.js";
 import { decodeJbig2 } from "./jbig2.js";
 import { decodeJpeg } from "./jpeg.js";
@@ -16,19 +19,24 @@ 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`; `Lab` (§8.6.5.8) and
+* a `Separation`/`DeviceN` through its own tint transform (§8.6.6.4).
+* Unsupported inputs (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 +124,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 +139,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 +270,54 @@ 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
+				]
+			}
+		};
+	}
+	if (tag === "Separation" || tag === "DeviceN" || tag === "I") {
+		const names = file.resolve(cs[1] ?? PDF_NULL);
+		const components = tag === "Separation" ? 1 : Array.isArray(names) ? names.length : 0;
+		const alternate = resolveColorSpace(file, cs[2]);
+		const transform = readFunction(file, cs[3]);
+		if (components < 1 || !alternate || alternate.kind === "tint" || !transform) return void 0;
+		return {
+			kind: "tint",
+			components,
+			tint: {
+				transform,
+				alternate
+			}
+		};
+	}
 }
 function namedColorSpace(name) {
 	if (name === "DeviceGray" || name === "G" || name === "CalGray") return {
@@ -241,13 +381,71 @@ function toColor(cs, s, px, bpc, decode) {
 			samples: out
 		};
 	}
+	if (cs.kind === "tint" && cs.tint) {
+		const { transform, alternate } = cs.tint;
+		const n = cs.components;
+		const cache = /* @__PURE__ */ new Map();
+		const out = new Uint8Array(px * 3);
+		for (let i = 0; i < px; i++) {
+			const comps = [];
+			for (let k = 0; k < n; k++) comps.push(c01(s[i * n + k], k));
+			const key = comps.join(",");
+			let rgb = cache.get(key);
+			if (!rgb) {
+				rgb = alternateRgb(alternate, transform(comps));
+				if (cache.size < MAX_TINT_CACHE) cache.set(key, rgb);
+			}
+			out[i * 3] = rgb[0];
+			out[i * 3 + 1] = rgb[1];
+			out[i * 3 + 2] = rgb[2];
+		}
+		return {
+			color: "rgb",
+			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 +453,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;
@@ -265,12 +463,67 @@ function toColor(cs, s, px, bpc, decode) {
 		samples: out
 	};
 }
+/** How many distinct tint tuples are remembered before the cache stops growing. */
+var MAX_TINT_CACHE = 65536;
+/** §8.6.6.4 — what the alternate space makes of the transform's output. */
+function alternateRgb(alternate, out) {
+	const at = (i) => Math.min(1, Math.max(0, out[i] ?? 0));
+	const to255 = (v) => Math.round(v * 255);
+	if (alternate.kind === "cmyk") {
+		const k = at(3);
+		return [
+			to255((1 - at(0)) * (1 - k)),
+			to255((1 - at(1)) * (1 - k)),
+			to255((1 - at(2)) * (1 - k))
+		];
+	}
+	if (alternate.kind === "lab" && alternate.lab) {
+		const r = alternate.lab.range;
+		const [sr, sg, sb] = labToSrgb(alternate.lab.white, [
+			at(0) * 100,
+			r[0] + at(1) * (r[1] - r[0]),
+			r[2] + at(2) * (r[3] - r[2])
+		]);
+		return [
+			to255(sr),
+			to255(sg),
+			to255(sb)
+		];
+	}
+	if (alternate.kind === "gray") {
+		const g = to255(at(0));
+		return [
+			g,
+			g,
+			g
+		];
+	}
+	return [
+		to255(at(0)),
+		to255(at(1)),
+		to255(at(2))
+	];
+}
 function paletteRgb(base, lookup, off) {
 	if (base.kind === "rgb") return [
 		lookup[off] ?? 0,
 		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 +659,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;
@@ -470,61 +733,6 @@ function lzwEarlyChange(file, d) {
 	const ec = decodeParmsOf(file, d)?.get("EarlyChange");
 	return ec !== void 0 && file.resolve(ec) === 0 ? 0 : 1;
 }
-function runLengthDecode(data) {
-	const out = [];
-	let i = 0;
-	while (i < data.length) {
-		const len = data[i++];
-		if (len === 128) break;
-		if (len < 128) for (let j = 0; j <= len && i < data.length; j++) out.push(data[i++]);
-		else {
-			const b = data[i++] ?? 0;
-			for (let j = 0; j < 257 - len; j++) out.push(b);
-		}
-	}
-	return Uint8Array.from(out);
-}
-function ascii85Decode(data) {
-	const out = [];
-	let tuple = 0;
-	let count = 0;
-	for (const c of data) {
-		if (c === 126) break;
-		if (c <= 32) continue;
-		if (c === 122 && count === 0) {
-			out.push(0, 0, 0, 0);
-			continue;
-		}
-		if (c < 33 || c > 117) continue;
-		tuple = tuple * 85 + (c - 33);
-		if (++count === 5) {
-			out.push(tuple >>> 24 & 255, tuple >>> 16 & 255, tuple >>> 8 & 255, tuple & 255);
-			tuple = 0;
-			count = 0;
-		}
-	}
-	if (count > 0) {
-		for (let i = count; i < 5; i++) tuple = tuple * 85 + 84;
-		for (let i = 0; i < count - 1; i++) out.push(tuple >>> 24 - i * 8 & 255);
-	}
-	return Uint8Array.from(out);
-}
-function asciiHexDecode(data) {
-	const out = [];
-	let hi = -1;
-	for (const c of data) {
-		if (c === 62) break;
-		const v = hexVal(c);
-		if (v < 0) continue;
-		if (hi < 0) hi = v;
-		else {
-			out.push(hi << 4 | v);
-			hi = -1;
-		}
-	}
-	if (hi >= 0) out.push(hi << 4);
-	return Uint8Array.from(out);
-}
 function decodeParmsOf(file, d) {
 	const p = file.resolve(d.get("DecodeParms") ?? d.get("DP") ?? PDF_NULL);
 	if (p instanceof Map) return p;
@@ -561,12 +769,6 @@ function boolOf(v) {
 function clamp01(x) {
 	return x < 0 ? 0 : x > 1 ? 1 : x;
 }
-function hexVal(c) {
-	if (c >= 48 && c <= 57) return c - 48;
-	if (c >= 65 && c <= 70) return c - 65 + 10;
-	if (c >= 97 && c <= 102) return c - 97 + 10;
-	return -1;
-}
 function fail(severity, detail) {
 	return {
 		ok: 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,8 +16,25 @@ 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;
+    /**
+     * §11.6.4.4 `/ca` — how opaque the picture is drawn, `0..1`. Absent is
+     * opaque. alphatrans.pdf lays a photograph in at half strength over three
+     * coloured squares, and drawn full-strength it hid all three.
+     */
+    readonly alpha?: number;
     /**
      * §8.5.3 — where this was painted, as the chain of positions leading to it.
      * The same key a lifted path carries, so the two can be ordered against each

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

@@ -1,10 +1,13 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { FEATURES } from "../core/ir/features.js";
+import { encodePng } from "../core/png-encode.js";
+import { buildAlphaMap, sampledShading } from "./shading.js";
 import { interpretContent, multiply } from "./content.js";
-import { decodePdfImage } from "./image-decode.js";
 import { collectPageAppearances } from "./annots.js";
+import { hiddenProperties, hiddenXObject } from "./optional-content.js";
+import { buildFonts } from "./text.js";
+import { decodePdfImage } from "./image-decode.js";
 //#region src/pdf-reader/images.ts
-var NO_FONTS = /* @__PURE__ */ new Map();
 var MAX_FORM_DEPTH = 12;
 var MAX_IMAGES = 4096;
 /**
@@ -20,6 +23,15 @@ function collectPageImages(file, page) {
 	const images = [];
 	const lossByDetail = /* @__PURE__ */ new Map();
 	const visiting = /* @__PURE__ */ new Set();
+	const alphaCache = /* @__PURE__ */ new Map();
+	const fontCache = /* @__PURE__ */ new Map();
+	const fontsOf = (resources) => {
+		const had = fontCache.get(resources);
+		if (had) return had;
+		const made = buildFonts(file, resources);
+		fontCache.set(resources, made);
+		return made;
+	};
 	const addLoss = (severity, detail) => {
 		if (!lossByDetail.has(detail)) lossByDetail.set(detail, {
 			severity,
@@ -30,7 +42,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, fontsOf(resources), 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) {
@@ -43,20 +60,67 @@ function collectPageImages(file, page) {
 			walk(patternRes instanceof Map ? patternRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), baseCtm), depth + 1, inheritedMcid, [...prefix, vector.order]);
 			visiting.delete(stream);
 		}
+		for (const call of result.glyphs) {
+			if (depth >= MAX_FORM_DEPTH || visiting.has(call.stream)) continue;
+			visiting.add(call.stream);
+			walk(call.resources ?? resources, file.streamData(call.stream), call.ctm, depth + 1, inheritedMcid, [...prefix, call.order]);
+			visiting.delete(call.stream);
+		}
+		for (const paint of result.shadings) {
+			if (images.length >= MAX_IMAGES) return;
+			const dict = resources ? file.get(resources, "Shading") : PDF_NULL;
+			const shading = dict instanceof Map ? file.resolve(dict.get(paint.name) ?? PDF_NULL) : PDF_NULL;
+			const sh = shading instanceof PdfStream ? shading.dict : shading instanceof Map ? shading : void 0;
+			if (!sh) continue;
+			if (paint.masked) continue;
+			const sampled = sampledShading(file, sh);
+			if (!sampled) continue;
+			const placed = multiply(matrixOf(file, sh), paint.ctm);
+			const [dx0, dx1, dy0, dy1] = sampled.domain;
+			const unit = [
+				dx1 - dx0,
+				0,
+				0,
+				dy1 - dy0,
+				dx0,
+				dy0
+			];
+			images.push({
+				...geometry(multiply(unit, placed), {
+					bytes: encodePng(sampled.size, sampled.size, "rgb", sampled.rgb),
+					format: "png"
+				}, inheritedMcid, paint.clip),
+				orderKey: [...prefix, paint.order]
+			});
+		}
 		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, placement.alpha),
+						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, placement.alpha),
 						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,16 +146,95 @@ function collectPageImages(file, page) {
 		losses: [...lossByDetail.values()]
 	};
 }
-function geometry(ctm, decoded, mcid) {
+function geometry(ctm, decoded, mcid, clip, alpha) {
+	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],
-		...mcid !== void 0 ? { mcid } : {}
+		widthPt: shownW,
+		heightPt: shownH,
+		x: cx - shownW / 2,
+		y: cy - shownH / 2,
+		...crop ? { crop } : {},
+		...Math.abs(angle) > .5 ? { rotationDeg: angle } : {},
+		...mcid !== void 0 ? { mcid } : {},
+		...alpha !== void 0 ? { alpha } : {}
+	};
+}
+/** 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);