reamkit 1.25.1 → 1.27.0

package/dist/esm/pdf-reader/cie-color.js

@@ -0,0 +1,112 @@
+//#region src/pdf-reader/cie-color.ts
+/**
+* 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.
+*/
+function cieToSrgb(space, abc) {
+	const clamp01 = (v) => Math.min(1, Math.max(0, v));
+	if (space.matrix === void 0 || abc.length < 3) {
+		const v = srgbTransfer(clamp01(abc[0] ?? 0) ** (space.gamma[0] ?? 1));
+		return [
+			v,
+			v,
+			v
+		];
+	}
+	const m = space.matrix;
+	const a = clamp01(abc[0]) ** (space.gamma[0] ?? 1);
+	const b = clamp01(abc[1]) ** (space.gamma[1] ?? 1);
+	const c = clamp01(abc[2]) ** (space.gamma[2] ?? 1);
+	const [ax, ay, az] = adaptToD65((m[0] ?? 0) * a + (m[3] ?? 0) * b + (m[6] ?? 0) * c, (m[1] ?? 0) * a + (m[4] ?? 0) * b + (m[7] ?? 0) * c, (m[2] ?? 0) * a + (m[5] ?? 0) * b + (m[8] ?? 0) * c, space.white);
+	const r = 3.2404542 * ax - 1.5371385 * ay - .4985314 * az;
+	const g = -.969266 * ax + 1.8760108 * ay + .041556 * az;
+	const bl = .0556434 * ax - .2040259 * ay + 1.0572252 * az;
+	return [
+		srgbTransfer(clamp01(r)),
+		srgbTransfer(clamp01(g)),
+		srgbTransfer(clamp01(bl))
+	];
+}
+/**
+* §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.
+*/
+function labToSrgb(white, lab) {
+	const m = (Math.min(100, Math.max(0, lab[0])) + 16) / 116;
+	const l = m + lab[1] / 500;
+	const n = m - lab[2] / 200;
+	const [ax, ay, az] = adaptToD65(white[0] * inverseTransfer(l), white[1] * inverseTransfer(m), white[2] * inverseTransfer(n), white);
+	const r = 3.2404542 * ax - 1.5371385 * ay - .4985314 * az;
+	const g = -.969266 * ax + 1.8760108 * ay + .041556 * az;
+	const b = .0556434 * ax - .2040259 * ay + 1.0572252 * az;
+	const clamp01 = (v) => Math.min(1, Math.max(0, v));
+	return [
+		srgbTransfer(clamp01(r)),
+		srgbTransfer(clamp01(g)),
+		srgbTransfer(clamp01(b))
+	];
+}
+/** §8.6.5.8 — the `g` of the Lab definition, which is a cube with a linear toe. */
+function inverseTransfer(v) {
+	return v >= 6 / 29 ? v ** 3 : 108 / 841 * (v - 4 / 29);
+}
+/** The D65 white every sRGB screen is referred to. */
+var D65 = [
+	.9505,
+	1,
+	1.089
+];
+/**
+* Bradford chromatic adaptation from the space's own white to D65.
+*
+* A file may state any illuminant — calrgb.pdf states several — and a colour
+* measured against one white shown against another is the wrong colour. The
+* Bradford transform is the one every colour-managed renderer uses for this.
+*/
+function adaptToD65(x, y, z, white) {
+	const [sx, sy, sz] = coneResponse(white[0], white[1], white[2]);
+	const [dx, dy, dz] = coneResponse(D65[0], D65[1], D65[2]);
+	if (sx === 0 || sy === 0 || sz === 0) return [
+		x,
+		y,
+		z
+	];
+	const [cx, cy, cz] = coneResponse(x, y, z);
+	return fromConeResponse(cx * dx / sx, cy * dy / sy, cz * dz / sz);
+}
+/** XYZ into the Bradford cone-response space. */
+function coneResponse(x, y, z) {
+	return [
+		.8951 * x + .2664 * y - .1614 * z,
+		-.7502 * x + 1.7135 * y + .0367 * z,
+		.0389 * x - .0685 * y + 1.0296 * z
+	];
+}
+/** …and back out of it. */
+function fromConeResponse(l, m, s) {
+	return [
+		.9869929 * l - .1470543 * m + .1599627 * s,
+		.4323053 * l + .5183603 * m + .0492912 * s,
+		-.0085287 * l + .0400428 * m + .9684867 * s
+	];
+}
+/** IEC 61966-2-1 — linear light to the sRGB signal a screen takes. */
+function srgbTransfer(v) {
+	return v <= .0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - .055;
+}
+//#endregion
+export { cieToSrgb, labToSrgb };

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

@@ -1,3 +1,5 @@
+import { ColorSpaceInfo, GsPaint } from './shading.js';
+import { TextMarkup } from './annot-draw.js';
 import { ShapeGradient } from '../core/vector.js';
 import { PdfDict, PdfStream } from '../pdf/objects.js';
 /**
@@ -71,8 +73,21 @@ export interface TextRun {
      * than in a substitute (see `./embedded-fonts`).
      */
     readonly fontName?: string;
+    /**
+     * §9.4.4 — the advance of this face's SPACE at the size the run was shown
+     * at, which is what says whether a gap between two runs was a word space.
+     * Absent where the face states no width for it.
+     */
+    readonly spaceWidthPt?: number;
     /** §9.8.1 — the face the glyphs were shown in is a bold one. */
     readonly bold?: boolean;
+    /**
+     * §12.5.6.10 — a text-markup annotation marks these glyphs: highlighted,
+     * underlined, struck through. Applied after extraction, from the page's
+     * `/Annots` (see `./text`), because it is stated about the words rather than
+     * painted among them.
+     */
+    readonly markup?: TextMarkup;
     /**
      * §8.6.6.2 — the glyphs are filled with a tiling PATTERN, named here for the
      * caller to resolve: a pattern is a content stream, not a colour, and the
@@ -119,13 +134,33 @@ export interface TextRun {
  * square to page space, so it carries both the placement and the size; the
  * `mcid` links the paint to its structure element (a `/Figure`, E-PDF EP6).
  */
+/** §8.9.7 — an image written into the content stream rather than named. */
+export interface InlineImage {
+    /** Its dictionary, keys as written — the abbreviated ones (`/W`, `/CS`, `/F`). */
+    readonly dict: PdfDict;
+    /** Its bytes, still filtered as the dictionary says. */
+    readonly data: Uint8Array;
+}
 export interface ImagePlacement {
     /** Where the `Do` fell in the stream's painting order — see {@link VectorPlacement.order}. */
     readonly order: number;
-    /** XObject resource name (no leading slash). */
+    /** XObject resource name (no leading slash), empty for an inline image. */
     readonly name: string;
+    /** §8.9.7 — the image itself, where it was written into the stream. */
+    readonly inline?: InlineImage;
     readonly ctm: Matrix;
+    /** §8.5.4 — the clip in force when it was painted, when there was one. */
+    readonly clip?: ClipRegion;
+    /**
+     * §8.9.6.2 — the non-stroking colour in force. A stencil `/ImageMask` carries
+     * no colour of its own: it says only WHERE to paint, and this is what.
+     */
+    readonly fillHex: string;
     readonly mcid?: number;
+    /** §11.3.5 `/BM` — a blend the page asked for that nothing here performs. */
+    readonly blend?: string;
+    /** §11.6.5 `/SMask` — the paint faded from place to place; nothing here does. */
+    readonly masked?: boolean;
 }
 /**
  * One segment of a painted path (E-PDF EP10/EP11), in page space (y-up): a
@@ -177,6 +212,16 @@ export interface VectorPlacement {
     readonly gradient?: ShapeGradient;
     /** §11.6.4.4 `/ca` — how opaque the fill is, when the page asked for less. */
     readonly alpha?: number;
+    /**
+     * §11.3.5 `/BM` — the fill only DARKENS what it covers (`Multiply`,
+     * `Darken`), so the marks under it read through. A highlighter is this and
+     * nothing else.
+     */
+    readonly darkens?: boolean;
+    /** §11.3.5 `/BM` — a blend the page asked for that nothing here performs. */
+    readonly blend?: string;
+    /** §11.6.5 `/SMask` — the paint faded from place to place; nothing here does. */
+    readonly masked?: boolean;
     /**
      * §8.7.3 — the TILING pattern resource name the path is filled with. Its
      * content is a stream of its own, so what the fill actually shows is only
@@ -221,22 +266,7 @@ export type Matrix = readonly [number, number, number, number, number, number];
 export declare const IDENTITY: Matrix;
 /** Compose two {@link Matrix matrices}: `a` applied first, then `b`. */
 export declare function multiply(a: Matrix, b: Matrix): Matrix;
-/**
- * Walk a page's decoded content stream (§9.4) and extract its positioned text,
- * painted XObjects and painted paths. Tracks the graphics state (CTM via
- * `q`/`Q`/`cm`) and text state (text/line matrices, font, size, spacing), and
- * emits one {@link TextRun} per show operator (`Tj` / `TJ` / `'` / `"`) in page
- * space (points).
- *
- * @param bytes      The page's decoded content-stream bytes.
- * @param fonts      Page fonts by resource key (`Tf` name), for decoding + widths;
- *                   an unmapped key falls back to Latin-1 with a half-em advance.
- * @param initialCtm The starting CTM mapping user space to page space.
- * @param shadings   Shading patterns by name, selected by `scn`/`sc` (EP16c).
- * @param alphas     Constant fill alphas by `/ExtGState` name, selected by `gs`.
- * @returns The extracted text runs, image placements and vector paths.
- */
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>, alphas?: ReadonlyMap<string, number>): InterpretResult;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>, alphas?: ReadonlyMap<string, GsPaint>, spaces?: ReadonlyMap<string, ColorSpaceInfo>, hiddenOc?: ReadonlySet<string>): InterpretResult;
 /**
  * Whether a string is wholly right-to-left: at least one letter of an RTL
  * script and nothing of any other, spaces and joiners aside.

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

@@ -1,5 +1,6 @@
 import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
 import { Lexer } from "./lexer.js";
+import { cieToSrgb } from "./cie-color.js";
 //#region src/pdf-reader/content.ts
 /**
 * A painted path emitted by the path-painting operators (§8.5.3), captured in
@@ -73,6 +74,8 @@ var FALLBACK_FONT = {
 var UPRIGHT_TOLERANCE_DEG = .5;
 function initialState() {
 	return {
+		fillSpace: void 0,
+		strokeSpace: void 0,
 		ctm: IDENTITY,
 		fontKey: "",
 		font: FALLBACK_FONT,
@@ -89,6 +92,9 @@ function initialState() {
 		fillGradient: void 0,
 		fillPattern: void 0,
 		fillAlpha: 1,
+		fillDarkens: false,
+		blendMode: void 0,
+		softMask: false,
 		clip: void 0
 	};
 }
@@ -107,7 +113,58 @@ function initialState() {
 * @param alphas     Constant fill alphas by `/ExtGState` name, selected by `gs`.
 * @returns The extracted text runs, image placements and vector paths.
 */
-function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__PURE__ */ new Map(), alphas = /* @__PURE__ */ new Map()) {
+/** §8.6.8 — the space a `cs` / `CS` operand names, if it is one we read. */
+function spaceOf(operands, spaces) {
+	const name = operands[operands.length - 1];
+	if (!(name instanceof PdfName)) return void 0;
+	const direct = spaces.get(name.value);
+	if (direct) return direct;
+	switch (name.value) {
+		case "DeviceGray": return {
+			kind: "gray",
+			components: 1
+		};
+		case "DeviceRGB": return {
+			kind: "rgb",
+			components: 3
+		};
+		case "DeviceCMYK": return {
+			kind: "cmyk",
+			components: 4
+		};
+		default: return;
+	}
+}
+/**
+* §8.6.8 — the colour a run of `sc` / `scn` components comes to.
+*
+* The space in force decides, and where it was not read the COUNT is the next
+* best witness: three numbers are RGB and four are CMYK on every device space
+* there is. One number is the ambiguous case — grey in a device space, but the
+* strength of a colorant in a Separation, where 1 is the ink at full and reads
+* dark — so a lone component is only taken where the space said what it means.
+*/
+function componentColor(operands, space) {
+	const nums = operands.filter((o) => typeof o === "number");
+	if (nums.length === 0) return void 0;
+	if (space?.cie) {
+		const [r, g, b] = cieToSrgb(space.cie, nums);
+		return rgbHex(r, g, b);
+	}
+	switch (space?.kind ?? (nums.length === 3 ? "rgb" : nums.length === 4 ? "cmyk" : void 0)) {
+		case "rgb": return nums.length >= 3 ? rgbHex(nums[0], nums[1], nums[2]) : void 0;
+		case "cmyk": return nums.length >= 4 ? cmykHex(nums[0], nums[1], nums[2], nums[3]) : void 0;
+		case "gray": return grayHex(nums[0]);
+		case "tint":
+			if (space?.tint) {
+				const hex = componentColor(space.tint.transform(nums), space.tint.alternate);
+				if (hex !== void 0) return hex;
+			}
+			return grayHex(1 - Math.max(...nums));
+		default: return;
+	}
+}
+function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__PURE__ */ new Map(), alphas = /* @__PURE__ */ new Map(), spaces = /* @__PURE__ */ new Map(), hiddenOc = /* @__PURE__ */ new Set()) {
 	const runs = [];
 	const images = [];
 	const vectors = [];
@@ -123,6 +180,9 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 	let paintOrder = 0;
 	let operands = [];
 	const mcStack = [];
+	const ocStack = [];
+	let hiddenDepth = 0;
+	const visible = () => hiddenDepth === 0;
 	const toPage = (x, y) => [x * state.ctm[0] + y * state.ctm[2] + state.ctm[4], x * state.ctm[1] + y * state.ctm[3] + state.ctm[5]];
 	const moveTo = (x, y) => {
 		const [px, py] = toPage(x, y);
@@ -167,7 +227,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		return state.lineWidth * scale;
 	};
 	const paintPath = (fill, stroke) => {
-		if (path.length >= 2 && (fill || stroke)) {
+		if (path.length >= 2 && (fill || stroke) && visible()) {
 			const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 			vectors.push({
 				order: paintOrder++,
@@ -176,6 +236,9 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				...fill && state.fillPattern !== void 0 ? { patternName: state.fillPattern } : {},
 				...fill ? { fillHex: state.fillColor } : {},
 				...fill && state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
+				...fill && state.fillDarkens ? { darkens: true } : {},
+				...state.blendMode !== void 0 ? { blend: state.blendMode } : {},
+				...state.softMask ? { masked: true } : {},
 				...fill && state.fillGradient ? { gradient: state.fillGradient } : {},
 				...stroke ? {
 					strokeHex: state.strokeColor,
@@ -205,7 +268,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const type3 = state.font.type3;
 		if (type3) {
 			const stream = type3.proc(code);
-			if (stream) {
+			if (stream && visible()) {
 				const scale = [
 					state.fontSize * state.hScale,
 					0,
@@ -235,8 +298,10 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const text = logicalOrder(shown);
 		if (text.length === 0) return;
 		const scaleY = Math.hypot(origin[2], origin[3]) || 1;
+		const scaleX = (Math.hypot(origin[0], origin[1]) || 1) * state.hScale;
 		const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 		const angle = Math.atan2(origin[1], origin[0]) * 180 / Math.PI;
+		if (!visible()) return;
 		runs.push({
 			text,
 			x: origin[4],
@@ -244,7 +309,8 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			endX: end[4],
 			endY: end[5],
 			...Math.abs(angle) > UPRIGHT_TOLERANCE_DEG ? { angleDeg: angle } : {},
-			fontSizePt: state.fontSize * scaleY,
+			fontSizePt: Math.abs(state.fontSize) * scaleY,
+			spaceWidthPt: (state.font.width(32) / 1e3 * state.fontSize + state.charSpacing + state.wordSpacing) * scaleX,
 			fontKey: state.fontKey,
 			...state.font.name !== void 0 ? { fontName: state.font.name } : {},
 			...state.font.type3 ? { type3: true } : {},
@@ -348,23 +414,31 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				const props = operands[operands.length - 1];
 				const mcidVal = !(tag instanceof PdfName && tag.value === "Artifact") && props instanceof Map ? props.get("MCID") : void 0;
 				mcStack.push(typeof mcidVal === "number" ? mcidVal : void 0);
+				const isOc = tag instanceof PdfName && tag.value === "OC" && props instanceof PdfName && hiddenOc.has(props.value);
+				ocStack.push(isOc);
+				if (isOc) hiddenDepth++;
 				break;
 			}
 			case "BMC":
 				mcStack.push(void 0);
+				ocStack.push(false);
 				break;
 			case "EMC":
 				mcStack.pop();
+				if (ocStack.pop() === true) hiddenDepth--;
 				break;
 			case "Do": {
 				const nm = operands[0];
-				if (nm instanceof PdfName) {
+				if (nm instanceof PdfName && visible()) {
 					const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 					images.push({
 						order: paintOrder++,
 						name: nm.value,
 						ctm: state.ctm,
-						...mcid !== void 0 ? { mcid } : {}
+						...state.clip ? { clip: state.clip } : {},
+						fillHex: state.fillColor,
+						...mcid !== void 0 ? { mcid } : {},
+						...state.blendMode !== void 0 ? { blend: state.blendMode } : {}
 					});
 				}
 				break;
@@ -384,12 +458,34 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				state.fillGradient = void 0;
 				state.fillPattern = void 0;
 				break;
+			case "cs":
+				state.fillSpace = spaceOf(operands, spaces);
+				break;
+			case "CS":
+				state.strokeSpace = spaceOf(operands, spaces);
+				break;
 			case "scn":
 			case "sc": {
 				const last = operands[operands.length - 1];
 				const named = last instanceof PdfName ? last.value : void 0;
-				state.fillGradient = named !== void 0 ? shadings.get(named) : void 0;
-				state.fillPattern = named !== void 0 && !state.fillGradient ? named : void 0;
+				if (named !== void 0) {
+					state.fillGradient = shadings.get(named);
+					state.fillPattern = state.fillGradient ? void 0 : named;
+					break;
+				}
+				const hex = componentColor(operands, state.fillSpace);
+				if (hex !== void 0) {
+					state.fillColor = hex;
+					state.fillGradient = void 0;
+					state.fillPattern = void 0;
+				}
+				break;
+			}
+			case "SCN":
+			case "SC": {
+				if (operands[operands.length - 1] instanceof PdfName) break;
+				const hex = componentColor(operands, state.strokeSpace);
+				if (hex !== void 0) state.strokeColor = hex;
 				break;
 			}
 			case "RG":
@@ -445,7 +541,13 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				break;
 			case "gs": {
 				const nm = operands[operands.length - 1];
-				if (nm instanceof PdfName) state.fillAlpha = alphas.get(nm.value) ?? 1;
+				if (nm instanceof PdfName) {
+					const paint = alphas.get(nm.value);
+					state.fillAlpha = paint?.alpha ?? 1;
+					state.fillDarkens = paint?.darkens ?? false;
+					state.blendMode = paint?.blend;
+					state.softMask = paint?.masked ?? false;
+				}
 				break;
 			}
 			case "W":
@@ -479,8 +581,19 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				operands.push(readDict(lexer));
 				break;
 			case "keyword":
-				if (tok.value === "BI") skipInlineImage(lexer);
-				else exec(tok.value);
+				if (tok.value === "BI") {
+					const inline = readInlineImage(lexer);
+					if (inline && visible()) images.push({
+						order: paintOrder++,
+						name: "",
+						inline,
+						ctm: state.ctm,
+						...state.clip ? { clip: state.clip } : {},
+						fillHex: state.fillColor,
+						...mcStack.length > 0 ? { mcid: mcStack[mcStack.length - 1] } : {},
+						...state.blendMode !== void 0 ? { blend: state.blendMode } : {}
+					});
+				} else exec(tok.value);
 				operands = [];
 				break;
 			default:
@@ -621,14 +734,62 @@ function readValue(lexer) {
 		default: return PDF_NULL;
 	}
 }
-function skipInlineImage(lexer) {
+/**
+* §8.9.7 — an inline image: its dictionary between `BI` and `ID`, then its
+* bytes up to `EI`.
+*
+* The bytes are binary and may hold `EI` themselves, so the end is found by
+* MEASURING where the dictionary says how much there is — an unfiltered image
+* is exactly `ceil(W · BPC · components / 8) · H` bytes — and only searched for
+* where a filter makes the length unknowable. images_1bit_grayscale.pdf draws
+* two of them and both were skipped over.
+*/
+function readInlineImage(lexer) {
+	const dict = /* @__PURE__ */ new Map();
 	for (;;) {
 		const tok = lexer.nextToken();
-		if (tok.kind === "eof") return;
+		if (tok.kind === "eof") return void 0;
 		if (tok.kind === "keyword" && tok.value === "ID") break;
+		if (tok.kind === "name") dict.set(tok.value, readValue(lexer));
 	}
-	const ei = lexer.indexOfAscii("EI", lexer.pos);
+	const start = lexer.pos + 1;
+	const measured = inlineLength(dict);
+	let end = measured !== void 0 ? start + measured : -1;
+	if (end < 0 || end > lexer.length) {
+		end = lexer.indexOfAscii("EI", start);
+		if (end < 0) {
+			lexer.pos = lexer.length;
+			return;
+		}
+	}
+	const data = lexer.slice(start, Math.min(end, lexer.length));
+	const ei = lexer.indexOfAscii("EI", end);
 	lexer.pos = ei < 0 ? lexer.length : ei + 2;
+	return {
+		dict,
+		data
+	};
+}
+/** How many bytes an UNFILTERED inline image's samples take, if that is known. */
+function inlineLength(dict) {
+	if (dict.has("F") || dict.has("Filter")) return void 0;
+	const num = (...keys) => {
+		for (const k of keys) {
+			const v = dict.get(k);
+			if (typeof v === "number") return v;
+		}
+		return 0;
+	};
+	const w = num("W", "Width");
+	const h = num("H", "Height");
+	if (w <= 0 || h <= 0) return void 0;
+	const mask = dict.get("IM") === true || dict.get("ImageMask") === true;
+	const bpc = mask ? 1 : num("BPC", "BitsPerComponent") || 8;
+	const cs = dict.get("CS") ?? dict.get("ColorSpace");
+	const name = cs instanceof PdfName ? cs.value : "";
+	const comps = mask ? 1 : /^(RGB|DeviceRGB|CalRGB)$/u.test(name) ? 3 : /^(CMYK|DeviceCMYK)$/u.test(name) ? 4 : /^(G|DeviceGray|CalGray|I|Indexed)$/u.test(name) || name === "" ? 1 : 0;
+	if (comps === 0) return void 0;
+	return ((w * comps * bpc + 7) / 8 | 0) * h;
 }
 //#endregion
 export { IDENTITY, interpretContent, isRightToLeft, multiply };

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

@@ -17,7 +17,7 @@ export interface Display {
     };
 }
 /**
- * The {@link Display} a page's `/MediaBox` and `/Rotate` describe.
+ * The {@link Display} a page's shown box and `/Rotate` describe.
  *
  * `/Rotate` turns the page CLOCKWISE when shown, so the content turns with it —
  * counter-clockwise by the same amount as seen from the content's own frame,

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

@@ -1,6 +1,6 @@
 //#region src/pdf-reader/display.ts
 /**
-* The {@link Display} a page's `/MediaBox` and `/Rotate` describe.
+* The {@link Display} a page's shown box and `/Rotate` describe.
 *
 * `/Rotate` turns the page CLOCKWISE when shown, so the content turns with it —
 * counter-clockwise by the same amount as seen from the content's own frame,
@@ -10,7 +10,7 @@
 * @returns Its size, its turn, and the map onto it.
 */
 function displayOf(page) {
-	const [x0, y0, x1, y1] = page.mediaBox;
+	const [x0, y0, x1, y1] = page.cropBox;
 	const left = Math.min(x0, x1);
 	const bottom = Math.min(y0, y1);
 	const w = Math.abs(x1 - x0);
@@ -66,7 +66,20 @@ function placeRuns(runs, d) {
 			endY: end.y,
 			...Math.abs(angle) > .5 ? { angleDeg: angle } : {}
 		};
-	});
+	}).filter((r) => shows(d, Math.min(r.x, r.endX), Math.min(r.y, r.endY) - r.fontSizePt * .25, Math.max(r.x, r.endX), Math.max(r.y, r.endY) + r.fontSizePt * .85));
+}
+/**
+* §14.11.2 — whether a box falls inside the region the page SHOWS.
+*
+* The crop box is the region "to which the contents of the page shall be
+* clipped", and a page cropped to less than its sheet is generally a page with
+* something outside the crop: freeculture.pdf carries a printer's slug —
+* "14773_07_347-348_r4jm.qxd 2/10/04 4:45 PM Page 347" — in the 42 points the
+* crop cuts off the top, and lifted with the rest it stood at the head of the
+* page and pushed the sheet taller to hold it.
+*/
+function shows(d, minX, minY, maxX, maxY) {
+	return maxX > 0 && minX < d.width && maxY > 0 && minY < d.height;
 }
 /**
 * The same pictures, placed on the shown page. A quarter turn swaps a picture's
@@ -89,14 +102,16 @@ function placeImages(images, d) {
 		const ys = corners.map((c) => c.y);
 		const minX = Math.min(...xs);
 		const minY = Math.min(...ys);
+		const turned = (img.rotationDeg ?? 0) + d.turnDeg;
 		return {
 			...img,
 			x: minX,
 			y: minY,
 			widthPt: Math.max(...xs) - minX,
-			heightPt: Math.max(...ys) - minY
+			heightPt: Math.max(...ys) - minY,
+			...Math.abs(turned) > .5 ? { rotationDeg: turned } : {}
 		};
-	});
+	}).filter((img) => shows(d, img.x, img.y, img.x + img.widthPt, img.y + img.heightPt));
 }
 /**
 * The same paths, placed on the shown page. A path is geometry, so every point
@@ -156,7 +171,7 @@ function placeVectors(vectors, d) {
 			maxX: Math.max(...xs),
 			maxY: Math.max(...ys)
 		};
-	});
+	}).filter((v) => shows(d, v.minX, v.minY, v.maxX, v.maxY));
 }
 //#endregion
 export { displayOf, placeImages, placeRuns, placeVectors };

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

@@ -5,6 +5,12 @@ export type Rectangle = readonly [number, number, number, number];
 export interface PdfPage {
     readonly dict: PdfDict;
     readonly mediaBox: Rectangle;
+    /**
+     * §14.11.2 `/CropBox` — the region of the page a viewer SHOWS, which is what
+     * a page's size means to anyone looking at it. Defaults to the media box and
+     * is clipped to it; inherited down the page tree like the media box is.
+     */
+    readonly cropBox: Rectangle;
     /**
      * §14.11.1 `/Rotate` — how far the page turns CLOCKWISE when it is shown,
      * normalised to 0, 90, 180 or 270 and inherited down the page tree.

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

@@ -162,6 +162,7 @@ var PdfFile = class PdfFile {
 		if (out.length >= MAX_PAGES || seen.has(node)) return;
 		seen.add(node);
 		const mediaBox = readRectangle(this.get(node, "MediaBox")) ?? inherited.mediaBox;
+		const cropBox = readRectangle(this.get(node, "CropBox")) ?? inherited.cropBox;
 		const resourcesVal = this.get(node, "Resources");
 		const resources = resourcesVal instanceof Map ? resourcesVal : inherited.resources;
 		const rotate = readRotate(this.get(node, "Rotate")) ?? inherited.rotate;
@@ -172,6 +173,7 @@ var PdfFile = class PdfFile {
 				const kidNode = this.resolve(kid);
 				if (kidNode instanceof Map) this.walkPageTree(kidNode, {
 					mediaBox,
+					cropBox,
 					resources,
 					rotate
 				}, out, seen);
@@ -179,9 +181,11 @@ var PdfFile = class PdfFile {
 			}
 			return;
 		}
+		const media = mediaBox ?? DEFAULT_MEDIA_BOX;
 		out.push({
 			dict: node,
-			mediaBox: mediaBox ?? DEFAULT_MEDIA_BOX,
+			mediaBox: media,
+			cropBox: shownBox(media, cropBox),
 			rotate: rotate ?? 0,
 			resources
 		});
@@ -526,5 +530,29 @@ function lastIndexOfAscii(buf, needle) {
 	}
 	return -1;
 }
+/**
+* §14.11.2 — the box a viewer SHOWS: the crop box where there is one, clipped
+* to the media box, and the media box where there is not.
+*
+* A crop box that states nothing usable — zero-sized, or outside the sheet
+* altogether — is a crop box no viewer honours, and the media box stands.
+* bug1844576.pdf is 612×792 of paper cropped to 181×53.75, and read as its
+* media box the form on it arrived a fifth of the way down a letter page.
+*/
+function shownBox(media, crop) {
+	if (!crop) return media;
+	const [mx0, my0, mx1, my1] = media;
+	const [cx0, cy0, cx1, cy1] = crop;
+	const x0 = Math.max(Math.min(mx0, mx1), Math.min(cx0, cx1));
+	const y0 = Math.max(Math.min(my0, my1), Math.min(cy0, cy1));
+	const x1 = Math.min(Math.max(mx0, mx1), Math.max(cx0, cx1));
+	const y1 = Math.min(Math.max(my0, my1), Math.max(cy0, cy1));
+	return x1 - x0 > 1 && y1 - y0 > 1 ? [
+		x0,
+		y0,
+		x1,
+		y1
+	] : media;
+}
 //#endregion
 export { PdfFile };