reamkit 1.5.0 → 1.7.0

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

@@ -0,0 +1,126 @@
+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";
+//#region src/pdf-reader/flow-build.ts
+function paragraphBlock(text, outlineLevel) {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: outlineLevel !== void 0 ? { outlineLevel } : {},
+			runs: text.length > 0 ? [{
+				text,
+				properties: {}
+			}] : []
+		}
+	};
+}
+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" };
+		}
+	});
+	return {
+		kind: "shape",
+		shape: {
+			width: pt(w),
+			height: pt(h),
+			geometry: {
+				kind: "custom",
+				custom: {
+					pathWidth: w,
+					pathHeight: h,
+					commands
+				}
+			},
+			fill: {
+				kind: "solid",
+				colorHex: v.fillHex
+			},
+			paragraphProperties: {}
+		}
+	};
+}
+function buildFlowDoc(body, resources = new ResourceStore()) {
+	return {
+		kind: "flow",
+		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
+		sections: [],
+		styles: EMPTY_STYLE_SHEET,
+		resources
+	};
+}
+//#endregion
+export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, shapeBlock };

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

@@ -0,0 +1,4 @@
+import { PdfDict } from '../pdf/objects.js';
+import { ContentFont } from './content.js';
+import { PdfFile } from './document.js';
+export declare function buildContentFont(file: PdfFile, fontDict: PdfDict): ContentFont;

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

@@ -0,0 +1,69 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { parseToUnicodeCMap } from "./cmap.js";
+//#region src/pdf-reader/font.ts
+function buildContentFont(file, fontDict) {
+	const isType0 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type0";
+	let toUnicode = /* @__PURE__ */ new Map();
+	let codeBytes = isType0 ? 2 : 1;
+	const tu = file.resolve(fontDict.get("ToUnicode") ?? PDF_NULL);
+	if (tu instanceof PdfStream) {
+		const parsed = parseToUnicodeCMap(file.streamData(tu));
+		toUnicode = parsed.map;
+		codeBytes = parsed.codeBytes;
+	}
+	const width = isType0 ? cidWidths(file, fontDict) : simpleWidths(file, fontDict);
+	const bytesPerCode = codeBytes;
+	return {
+		bytesPerCode,
+		decode: (codes) => codes.map((c) => toUnicode.get(c) ?? (bytesPerCode === 1 ? String.fromCharCode(c) : "")).join(""),
+		width
+	};
+}
+function simpleWidths(file, fontDict) {
+	const first = asNumber(file.resolve(fontDict.get("FirstChar") ?? PDF_NULL), 0);
+	const widthsVal = file.resolve(fontDict.get("Widths") ?? PDF_NULL);
+	const widths = Array.isArray(widthsVal) ? widthsVal : [];
+	const descriptor = file.resolve(fontDict.get("FontDescriptor") ?? PDF_NULL);
+	const missing = descriptor instanceof Map ? asNumber(file.resolve(descriptor.get("MissingWidth") ?? PDF_NULL), 0) : 0;
+	return (code) => {
+		const w = widths[code - first];
+		return typeof w === "number" ? w : missing > 0 ? missing : 500;
+	};
+}
+function cidWidths(file, fontDict) {
+	const descFonts = file.resolve(fontDict.get("DescendantFonts") ?? PDF_NULL);
+	const desc0 = Array.isArray(descFonts) ? file.resolve(descFonts[0] ?? PDF_NULL) : PDF_NULL;
+	const cidFont = desc0 instanceof Map ? desc0 : /* @__PURE__ */ new Map();
+	const dw = asNumber(file.resolve(cidFont.get("DW") ?? PDF_NULL), 1e3);
+	const wMap = parseCidW(file, file.resolve(cidFont.get("W") ?? PDF_NULL));
+	return (cid) => wMap.get(cid) ?? (dw || 1e3);
+}
+function parseCidW(file, wVal) {
+	const out = /* @__PURE__ */ new Map();
+	if (!Array.isArray(wVal)) return out;
+	let i = 0;
+	while (i < wVal.length) {
+		const c = file.resolve(wVal[i++]);
+		if (typeof c !== "number") break;
+		const next = file.resolve(wVal[i] ?? PDF_NULL);
+		if (Array.isArray(next)) {
+			i++;
+			next.forEach((w, k) => {
+				if (typeof w === "number") out.set(c + k, w);
+			});
+		} else if (typeof next === "number") {
+			i++;
+			const w = file.resolve(wVal[i++] ?? PDF_NULL);
+			if (typeof w === "number") for (let cc = c; cc <= next && cc - c < 65536; cc++) out.set(cc, w);
+		} else break;
+	}
+	return out;
+}
+function asName(v) {
+	return v instanceof PdfName ? v.value : "";
+}
+function asNumber(v, dflt) {
+	return typeof v === "number" ? v : dflt;
+}
+//#endregion
+export { buildContentFont };

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,442 @@
+import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
+import { reversePredictor } from "./predictor.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 === "CCITTFaxDecode" || last === "CCF" || last === "JBIG2Decode") return fail("dropped", "fax-encoded (CCITT/JBIG2) image not decoded");
+	if (last === "LZWDecode" || last === "LZW") return fail("dropped", "LZW-encoded image not decoded");
+	const decoded = 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 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 flate = false;
+	for (const f of filters) if (f === "FlateDecode" || f === "Fl") try {
+		data = unzlibSync(data);
+		flate = true;
+	} catch {
+		return;
+	}
+	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 flate ? 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 === "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
+	});
+}
+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;