reamkit 1.6.0 → 1.9.0

package/dist/esm/pdf-reader/flow-build.js

@@ -1,3 +1,4 @@
+import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
@@ -14,14 +15,123 @@ function paragraphBlock(text, outlineLevel) {
 		}
 	};
 }
-function buildFlowDoc(body) {
+function paragraphFromRuns(spans, outlineLevel) {
+	const merged = [];
+	for (const s of spans) {
+		const last = merged[merged.length - 1];
+		if (last && last.href === s.href) last.text += s.text;
+		else if (s.href !== void 0) merged.push({
+			text: s.text,
+			href: s.href
+		});
+		else merged.push({ text: s.text });
+	}
+	const runs = merged.map((m) => ({
+		text: m.text.replace(/\s+/g, " "),
+		href: m.href
+	})).filter((m) => m.text.length > 0);
+	if (runs.length > 0) {
+		runs[0].text = runs[0].text.replace(/^ /, "");
+		runs[runs.length - 1].text = runs[runs.length - 1].text.replace(/ $/, "");
+	}
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: outlineLevel !== void 0 ? { outlineLevel } : {},
+			runs: runs.filter((r) => r.text.length > 0).map((r) => ({
+				text: r.text,
+				properties: {},
+				...r.href ? { href: r.href } : {}
+			}))
+		}
+	};
+}
+function imageBlock(image, resources, alt) {
+	return {
+		kind: "image",
+		image: {
+			resource: resources.put(image.bytes),
+			width: pt(image.widthPt),
+			height: pt(image.heightPt),
+			paragraphProperties: {},
+			...alt ? { altText: alt } : {}
+		}
+	};
+}
+function dedupeLosses(losses) {
+	const byDetail = /* @__PURE__ */ new Map();
+	for (const loss of losses) if (!byDetail.has(loss.detail)) byDetail.set(loss.detail, loss);
+	return [...byDetail.values()];
+}
+function shapeBlock(v) {
+	const w = v.maxX - v.minX;
+	const h = v.maxY - v.minY;
+	const fx = (x) => x - v.minX;
+	const fy = (y) => v.maxY - y;
+	const commands = v.segs.map((s) => {
+		switch (s.op) {
+			case "move": return {
+				cmd: "move",
+				x: fx(s.x),
+				y: fy(s.y)
+			};
+			case "line": return {
+				cmd: "line",
+				x: fx(s.x),
+				y: fy(s.y)
+			};
+			case "cubic": return {
+				cmd: "cubic",
+				x1: fx(s.x1),
+				y1: fy(s.y1),
+				x2: fx(s.x2),
+				y2: fy(s.y2),
+				x: fx(s.x),
+				y: fy(s.y)
+			};
+			case "close": return { cmd: "close" };
+		}
+	});
+	const thick = v.strokeHex !== void 0 ? Math.max(v.lineWidth ?? .75, .5) : 0;
+	const fill = v.gradient !== void 0 ? {
+		kind: "gradient",
+		gradient: v.gradient
+	} : v.fillHex !== void 0 ? {
+		kind: "solid",
+		colorHex: v.fillHex
+	} : { kind: "none" };
+	const line = v.strokeHex !== void 0 ? {
+		width: pt(thick),
+		colorHex: v.strokeHex,
+		fill: "solid"
+	} : void 0;
+	return {
+		kind: "shape",
+		shape: {
+			width: pt(Math.max(w, thick)),
+			height: pt(Math.max(h, thick)),
+			geometry: {
+				kind: "custom",
+				custom: {
+					pathWidth: w,
+					pathHeight: h,
+					commands
+				}
+			},
+			fill,
+			...line ? { line } : {},
+			paragraphProperties: {}
+		}
+	};
+}
+function buildFlowDoc(body, resources = new ResourceStore()) {
 	return {
 		kind: "flow",
 		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
 		sections: [],
 		styles: EMPTY_STYLE_SHEET,
-		resources: new ResourceStore()
+		resources
 	};
 }
 //#endregion
-export { buildFlowDoc, paragraphBlock };
+export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, shapeBlock };

package/dist/esm/pdf-reader/image-decode.d.ts

@@ -0,0 +1,15 @@
+import { PdfFile } from './document.js';
+import { PdfStream } from '../pdf/objects.js';
+export type DecodedImage = {
+    readonly ok: true;
+    readonly bytes: Uint8Array;
+    readonly format: 'png' | 'jpeg' | 'jpeg2000';
+    readonly widthPx: number;
+    readonly heightPx: number;
+    readonly degraded?: string;
+} | {
+    readonly ok: false;
+    readonly severity: 'dropped' | 'degraded';
+    readonly detail: string;
+};
+export declare function decodePdfImage(file: PdfFile, stream: PdfStream): DecodedImage;

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

@@ -0,0 +1,550 @@
+import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
+import { reversePredictor } from "./predictor.js";
+import { decodeCcitt } from "./ccitt.js";
+import { encodePng } from "./png-encode.js";
+import { unzlibSync } from "fflate";
+//#region src/pdf-reader/image-decode.ts
+var MAX_PIXELS = 4e7;
+function decodePdfImage(file, stream) {
+	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");
+	const filters = filterNames(file, d);
+	const last = filters[filters.length - 1];
+	if (last === "DCTDecode" || last === "DCT") {
+		const degraded = hasSMask(file, d) ? "image transparency dropped (JPEG carries no alpha)" : void 0;
+		return {
+			ok: true,
+			bytes: applyChainExceptLast(filters, stream.data),
+			format: "jpeg",
+			widthPx: width,
+			heightPx: height,
+			...degraded ? { degraded } : {}
+		};
+	}
+	if (last === "JPXDecode") return {
+		ok: true,
+		bytes: applyChainExceptLast(filters, stream.data),
+		format: "jpeg2000",
+		widthPx: width,
+		heightPx: height,
+		degraded: "JPEG 2000 image — limited viewer support"
+	};
+	if (last === "JBIG2Decode") return fail("dropped", "JBIG2-encoded image not decoded");
+	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);
+	const { color, samples } = alpha ? combineAlpha(decoded, alpha) : decoded;
+	return {
+		ok: true,
+		bytes: encodePng(width, height, color, samples),
+		format: "png",
+		widthPx: width,
+		heightPx: height
+	};
+}
+function decodeToSamples(file, stream, filters, width, height) {
+	const d = stream.dict;
+	const raw = decodeChain(file, stream, filters);
+	if (!raw) return "undecodable image stream";
+	const cs = resolveColorSpace(file, d.get("ColorSpace") ?? d.get("CS"));
+	if (!cs) return "unsupported image colour space";
+	const bpc = intOf(file.get(d, "BitsPerComponent")) || intOf(file.get(d, "BPC")) || 8;
+	const decodeArr = decodeArrayOf(file, d);
+	return toColor(cs, unpackSamples(raw, width, height, cs.components, bpc), width * height, bpc, decodeArr);
+}
+function decodeCcittImage(file, stream, filters, width, 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 "CCITT fax image not decoded (Group 3 2-D or malformed)";
+	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;
+		}
+	}
+	return {
+		color: "gray",
+		samples
+	};
+}
+function resolveColorSpace(file, csVal) {
+	const cs = file.resolve(csVal ?? PDF_NULL);
+	if (cs instanceof PdfName) return namedColorSpace(cs.value);
+	if (!Array.isArray(cs) || cs.length === 0) return void 0;
+	const head = file.resolve(cs[0]);
+	const tag = head instanceof PdfName ? head.value : "";
+	if (tag === "ICCBased") {
+		const profile = file.resolve(cs[1]);
+		if (profile instanceof PdfStream) {
+			const n = intOf(file.get(profile.dict, "N"));
+			if (n === 1) return {
+				kind: "gray",
+				components: 1
+			};
+			if (n === 3) return {
+				kind: "rgb",
+				components: 3
+			};
+			if (n === 4) return {
+				kind: "cmyk",
+				components: 4
+			};
+			const alt = resolveColorSpace(file, profile.dict.get("Alternate"));
+			if (alt) return alt;
+		}
+		return;
+	}
+	if (tag === "CalGray" || tag === "G") return {
+		kind: "gray",
+		components: 1
+	};
+	if (tag === "CalRGB" || tag === "RGB") return {
+		kind: "rgb",
+		components: 3
+	};
+	if (tag === "Indexed" || tag === "I") {
+		const base = resolveColorSpace(file, cs[1]);
+		const hival = intOf(file.resolve(cs[2] ?? PDF_NULL));
+		const lookup = valueToBytes(file, cs[3]);
+		if (!base || base.kind === "indexed" || !lookup) return void 0;
+		return {
+			kind: "indexed",
+			components: 1,
+			base,
+			hival,
+			lookup
+		};
+	}
+}
+function namedColorSpace(name) {
+	if (name === "DeviceGray" || name === "G" || name === "CalGray") return {
+		kind: "gray",
+		components: 1
+	};
+	if (name === "DeviceRGB" || name === "RGB" || name === "CalRGB") return {
+		kind: "rgb",
+		components: 3
+	};
+	if (name === "DeviceCMYK" || name === "CMYK") return {
+		kind: "cmyk",
+		components: 4
+	};
+}
+function toColor(cs, s, px, bpc, decode) {
+	const maxv = (1 << Math.min(bpc, 15)) * (bpc >= 16 ? 2 : 1) - 1;
+	const c01 = (v, comp) => {
+		const t = maxv > 0 ? v / maxv : 0;
+		if (decode && decode.length >= (comp + 1) * 2) {
+			const dmin = decode[comp * 2];
+			const dmax = decode[comp * 2 + 1];
+			return clamp01(dmin + t * (dmax - dmin));
+		}
+		return t;
+	};
+	const to8 = (v, comp) => Math.round(c01(v, comp) * 255);
+	if (cs.kind === "gray") {
+		const out = new Uint8Array(px);
+		for (let i = 0; i < px; i++) out[i] = to8(s[i], 0);
+		return {
+			color: "gray",
+			samples: out
+		};
+	}
+	if (cs.kind === "rgb") {
+		const out = new Uint8Array(px * 3);
+		for (let i = 0; i < px; i++) {
+			out[i * 3] = to8(s[i * 3], 0);
+			out[i * 3 + 1] = to8(s[i * 3 + 1], 1);
+			out[i * 3 + 2] = to8(s[i * 3 + 2], 2);
+		}
+		return {
+			color: "rgb",
+			samples: out
+		};
+	}
+	if (cs.kind === "cmyk") {
+		const out = new Uint8Array(px * 3);
+		for (let i = 0; i < px; i++) {
+			const c = c01(s[i * 4], 0);
+			const m = c01(s[i * 4 + 1], 1);
+			const y = c01(s[i * 4 + 2], 2);
+			const k = c01(s[i * 4 + 3], 3);
+			out[i * 3] = Math.round(255 * (1 - c) * (1 - k));
+			out[i * 3 + 1] = Math.round(255 * (1 - m) * (1 - k));
+			out[i * 3 + 2] = Math.round(255 * (1 - y) * (1 - k));
+		}
+		return {
+			color: "rgb",
+			samples: out
+		};
+	}
+	const base = cs.base;
+	const lookup = cs.lookup;
+	const hival = cs.hival ?? 255;
+	const bn = base.components;
+	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;
+		return {
+			color: "gray",
+			samples: out
+		};
+	}
+	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);
+		out[i * 3] = r;
+		out[i * 3 + 1] = g;
+		out[i * 3 + 2] = b;
+	}
+	return {
+		color: "rgb",
+		samples: out
+	};
+}
+function paletteRgb(base, lookup, off) {
+	if (base.kind === "rgb") return [
+		lookup[off] ?? 0,
+		lookup[off + 1] ?? 0,
+		lookup[off + 2] ?? 0
+	];
+	if (base.kind === "cmyk") {
+		const c = (lookup[off] ?? 0) / 255;
+		const m = (lookup[off + 1] ?? 0) / 255;
+		const y = (lookup[off + 2] ?? 0) / 255;
+		const k = (lookup[off + 3] ?? 0) / 255;
+		return [
+			Math.round(255 * (1 - c) * (1 - k)),
+			Math.round(255 * (1 - m) * (1 - k)),
+			Math.round(255 * (1 - y) * (1 - k))
+		];
+	}
+	const g = lookup[off] ?? 0;
+	return [
+		g,
+		g,
+		g
+	];
+}
+function unpackSamples(raw, width, height, ncomp, bpc) {
+	const perRow = width * ncomp;
+	const out = new Uint16Array(perRow * height);
+	const rowBytes = Math.ceil(perRow * bpc / 8);
+	for (let y = 0; y < height; y++) {
+		const rowOff = y * rowBytes;
+		const base = y * perRow;
+		if (bpc === 8) for (let i = 0; i < perRow; i++) out[base + i] = raw[rowOff + i] ?? 0;
+		else if (bpc === 16) for (let i = 0; i < perRow; i++) out[base + i] = (raw[rowOff + 2 * i] ?? 0) << 8 | (raw[rowOff + 2 * i + 1] ?? 0);
+		else {
+			const mask = (1 << bpc) - 1;
+			let bit = 0;
+			for (let i = 0; i < perRow; i++) {
+				const bytePos = rowOff + (bit >> 3);
+				const shift = 8 - bpc - (bit & 7);
+				out[base + i] = ((raw[bytePos] ?? 0) >> shift & mask) >>> 0;
+				bit += bpc;
+			}
+		}
+	}
+	return out;
+}
+function decodeSMask(file, d, width, height) {
+	const sm = file.resolve(d.get("SMask") ?? PDF_NULL);
+	if (!(sm instanceof PdfStream)) return void 0;
+	const sw = intOf(file.get(sm.dict, "Width"));
+	const sh = intOf(file.get(sm.dict, "Height"));
+	if (sw <= 0 || sh <= 0) return void 0;
+	const decoded = decodeToSamples(file, sm, filterNames(file, sm.dict), sw, sh);
+	if (typeof decoded === "string") return void 0;
+	const ch = decoded.color === "rgb" ? 3 : 1;
+	const gray = new Uint8Array(sw * sh);
+	for (let i = 0; i < sw * sh; i++) gray[i] = decoded.samples[i * ch];
+	if (sw === width && sh === height) return { data: gray };
+	const out = new Uint8Array(width * height);
+	for (let y = 0; y < height; y++) {
+		const sy = Math.min(sh - 1, Math.floor(y * sh / height));
+		for (let x = 0; x < width; x++) {
+			const sx = Math.min(sw - 1, Math.floor(x * sw / width));
+			out[y * width + x] = gray[sy * sw + sx];
+		}
+	}
+	return { data: out };
+}
+function combineAlpha(color, alpha) {
+	const px = alpha.data.length;
+	if (color.color === "gray") {
+		const out = new Uint8Array(px * 2);
+		for (let i = 0; i < px; i++) {
+			out[i * 2] = color.samples[i];
+			out[i * 2 + 1] = alpha.data[i];
+		}
+		return {
+			color: "gray-alpha",
+			samples: out
+		};
+	}
+	const out = new Uint8Array(px * 4);
+	for (let i = 0; i < px; i++) {
+		out[i * 4] = color.samples[i * 3];
+		out[i * 4 + 1] = color.samples[i * 3 + 1];
+		out[i * 4 + 2] = color.samples[i * 3 + 2];
+		out[i * 4 + 3] = alpha.data[i];
+	}
+	return {
+		color: "rgba",
+		samples: out
+	};
+}
+function filterNames(file, d) {
+	const f = file.resolve(d.get("Filter") ?? 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);
+	}
+	return out;
+}
+function decodeChain(file, stream, filters) {
+	let data = stream.data;
+	let mayPredict = false;
+	for (const f of filters) if (f === "FlateDecode" || f === "Fl") try {
+		data = unzlibSync(data);
+		mayPredict = true;
+	} catch {
+		return;
+	}
+	else if (f === "LZWDecode" || f === "LZW") {
+		const dec = lzwDecode(data, lzwEarlyChange(file, stream.dict));
+		if (!dec) return void 0;
+		data = dec;
+		mayPredict = true;
+	} else if (f === "RunLengthDecode" || f === "RL") data = runLengthDecode(data);
+	else if (f === "ASCII85Decode" || f === "A85") data = ascii85Decode(data);
+	else if (f === "ASCIIHexDecode" || f === "AHx") data = asciiHexDecode(data);
+	else return;
+	return mayPredict ? applyPredictor(file, stream.dict, data) : data;
+}
+function applyChainExceptLast(filters, raw) {
+	let data = raw;
+	for (let i = 0; i < filters.length - 1; i++) {
+		const f = filters[i];
+		if (f === "FlateDecode" || f === "Fl") try {
+			data = unzlibSync(data);
+		} catch {}
+		else if (f === "LZWDecode" || f === "LZW") data = lzwDecode(data, 1) ?? data;
+		else if (f === "RunLengthDecode" || f === "RL") data = runLengthDecode(data);
+		else if (f === "ASCII85Decode" || f === "A85") data = ascii85Decode(data);
+		else if (f === "ASCIIHexDecode" || f === "AHx") data = asciiHexDecode(data);
+	}
+	return data;
+}
+function applyPredictor(file, d, data) {
+	const parms = decodeParmsOf(file, d);
+	if (!parms) return data;
+	const predictor = intOf(file.get(parms, "Predictor"));
+	if (predictor < 2) return data;
+	return reversePredictor(data, {
+		predictor,
+		colors: intOf(file.get(parms, "Colors")) || 1,
+		bitsPerComponent: intOf(file.get(parms, "BitsPerComponent")) || 8,
+		columns: intOf(file.get(parms, "Columns")) || 1
+	});
+}
+var MAX_LZW_OUT = MAX_PIXELS * 4;
+function lzwDecode(data, earlyChange) {
+	let out = new Uint8Array(4096);
+	let outLen = 0;
+	const emit = (e) => {
+		if (outLen + e.length > MAX_LZW_OUT) return false;
+		if (outLen + e.length > out.length) {
+			let cap = out.length * 2;
+			while (cap < outLen + e.length) cap *= 2;
+			const grown = new Uint8Array(cap);
+			grown.set(out.subarray(0, outLen));
+			out = grown;
+		}
+		out.set(e, outLen);
+		outLen += e.length;
+		return true;
+	};
+	let bitBuffer = 0;
+	let bitCount = 0;
+	let pos = 0;
+	let codeLength = 9;
+	const readCode = () => {
+		while (bitCount < codeLength) {
+			if (pos >= data.length) return -1;
+			bitBuffer = (bitBuffer << 8 | data[pos++]) >>> 0;
+			bitCount += 8;
+		}
+		bitCount -= codeLength;
+		return bitBuffer >>> bitCount & (1 << codeLength) - 1;
+	};
+	const dict = new Array(4096);
+	let nextCode = 258;
+	let prev = -1;
+	const reset = () => {
+		for (let i = 0; i < 256; i++) dict[i] = Uint8Array.of(i);
+		nextCode = 258;
+		codeLength = 9;
+		prev = -1;
+	};
+	reset();
+	for (;;) {
+		const code = readCode();
+		if (code < 0 || code === 257) break;
+		if (code === 256) {
+			reset();
+			continue;
+		}
+		if (prev < 0) {
+			const first = dict[code];
+			if (!first || !emit(first)) break;
+			prev = code;
+			continue;
+		}
+		const prevEntry = dict[prev];
+		let entry = code < nextCode ? dict[code] : void 0;
+		if (!entry) {
+			entry = new Uint8Array(prevEntry.length + 1);
+			entry.set(prevEntry);
+			entry[prevEntry.length] = prevEntry[0];
+		}
+		if (!emit(entry)) break;
+		if (nextCode < 4096) {
+			const added = new Uint8Array(prevEntry.length + 1);
+			added.set(prevEntry);
+			added[prevEntry.length] = entry[0];
+			dict[nextCode++] = added;
+			if (nextCode + earlyChange === 512) codeLength = 10;
+			else if (nextCode + earlyChange === 1024) codeLength = 11;
+			else if (nextCode + earlyChange === 2048) codeLength = 12;
+		}
+		prev = code;
+	}
+	return out.subarray(0, outLen);
+}
+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;
+	if (Array.isArray(p)) for (const e of p) {
+		const r = file.resolve(e);
+		if (r instanceof Map) return r;
+	}
+}
+function decodeArrayOf(file, d) {
+	const v = file.resolve(d.get("Decode") ?? d.get("D") ?? PDF_NULL);
+	if (!Array.isArray(v)) return void 0;
+	const nums = v.map((x) => typeof x === "number" ? x : NaN);
+	return nums.some((n) => !Number.isFinite(n)) ? void 0 : nums;
+}
+function hasSMask(file, d) {
+	return file.resolve(d.get("SMask") ?? PDF_NULL) instanceof PdfStream;
+}
+function valueToBytes(file, v) {
+	const r = file.resolve(v ?? PDF_NULL);
+	if (r instanceof PdfHexString) return r.bytes;
+	if (typeof r === "string") {
+		const out = new Uint8Array(r.length);
+		for (let i = 0; i < r.length; i++) out[i] = r.charCodeAt(i) & 255;
+		return out;
+	}
+	if (r instanceof PdfStream) return file.streamData(r);
+}
+function intOf(v) {
+	return typeof v === "number" ? Math.round(v) : 0;
+}
+function boolOf(v) {
+	return v === true;
+}
+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,
+		severity,
+		detail
+	};
+}
+//#endregion
+export { decodePdfImage };

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

@@ -0,0 +1,16 @@
+import { Loss } from '../core/ir/index.js';
+import { PdfFile, PdfPage } from './document.js';
+export interface PdfImage {
+    readonly bytes: Uint8Array;
+    readonly format: 'png' | 'jpeg' | 'jpeg2000';
+    readonly widthPt: number;
+    readonly heightPt: number;
+    readonly x: number;
+    readonly y: number;
+    readonly mcid?: number;
+}
+export interface PageImages {
+    readonly images: Array<PdfImage>;
+    readonly losses: Array<Loss>;
+}
+export declare function collectPageImages(file: PdfFile, page: PdfPage): PageImages;