reamkit 1.26.0 → 1.27.0

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

@@ -0,0 +1,414 @@
+import { PDF_NULL, PdfStream } from "../pdf/objects.js";
+import { Lexer } from "./lexer.js";
+//#region src/pdf-reader/function.ts
+/** A sampled function bigger than this is not read: it is a DoS, not a table. */
+var MAX_SAMPLES = 1 << 22;
+/** A type-4 program deeper than this is not run. */
+var MAX_PS_DEPTH = 32;
+/** …nor one with more tokens than this. */
+var MAX_PS_TOKENS = 65536;
+/** How far a stitching or array function may nest before this gives up. */
+var MAX_NESTING = 8;
+/**
+* Read a `/Function` entry into something callable (§7.10).
+*
+* The entry may also be an ARRAY of functions, each giving one output, which is
+* what a `/DeviceN` with a per-colorant transform states; that comes back as
+* one function returning all of them in order.
+*
+* @param file  The owning file.
+* @param value The `/Function` (or `/TintTransform`) entry, unresolved.
+* @returns The function, or `undefined` for one this cannot run.
+*/
+function readFunction(file, value) {
+	return readAt(file, value, 0);
+}
+function readAt(file, value, depth) {
+	if (value === void 0 || depth > MAX_NESTING) return void 0;
+	const resolved = file.resolve(value);
+	if (Array.isArray(resolved)) {
+		const parts = resolved.map((v) => readAt(file, v, depth + 1));
+		if (parts.some((p) => p === void 0)) return void 0;
+		return (inputs) => parts.flatMap((p) => p(inputs));
+	}
+	const dict = resolved instanceof PdfStream ? resolved.dict : resolved instanceof Map ? resolved : void 0;
+	if (!dict) return void 0;
+	const type = file.get(dict, "FunctionType");
+	const domain = numbers(file, dict.get("Domain"));
+	if (type === 2) return exponential(file, dict, domain);
+	if (type === 3) return stitching(file, dict, domain, depth);
+	if (type === 0 && resolved instanceof PdfStream) return sampled(file, resolved, domain);
+	if (type === 4 && resolved instanceof PdfStream) return calculator(file, resolved, domain);
+}
+/** §7.10.2 — a sampled function: a table, interpolated between its samples. */
+function sampled(file, stream, domain) {
+	const d = stream.dict;
+	const size = numbers(file, d.get("Size"));
+	const range = numbers(file, d.get("Range"));
+	const bps = file.get(d, "BitsPerSample");
+	const m = size.length;
+	const n = range.length >> 1;
+	if (m === 0 || n === 0 || domain.length < m * 2 || typeof bps !== "number") return void 0;
+	if (!size.every((s) => Number.isInteger(s) && s >= 1)) return void 0;
+	let total = n;
+	for (const s of size) {
+		total *= s;
+		if (total > MAX_SAMPLES) return void 0;
+	}
+	const encode = orDefault(numbers(file, d.get("Encode")), m * 2, (i) => i % 2 === 0 ? 0 : size[i - 1 >> 1] - 1);
+	const decode = orDefault(numbers(file, d.get("Decode")), n * 2, (i) => range[i] ?? 0);
+	const data = file.streamData(stream);
+	const max = 2 ** bps - 1;
+	const sample = (flat, out) => {
+		let bit = (flat * n + out) * bps;
+		let v = 0;
+		for (let k = 0; k < bps; k++) {
+			v = v * 2 + ((data[bit >> 3] ?? 0) >> 7 - (bit & 7) & 1);
+			bit++;
+		}
+		return v / max;
+	};
+	return (inputs) => {
+		const base = [];
+		const frac = [];
+		for (let i = 0; i < m; i++) {
+			const at = clamp(interpolate(clamp(inputs[i] ?? 0, domain[i * 2], domain[i * 2 + 1]), domain[i * 2], domain[i * 2 + 1], encode[i * 2], encode[i * 2 + 1]), 0, size[i] - 1);
+			const lo = Math.min(Math.floor(at), Math.max(0, size[i] - 2));
+			base.push(size[i] === 1 ? 0 : lo);
+			frac.push(size[i] === 1 ? 0 : at - lo);
+		}
+		const out = new Array(n).fill(0);
+		for (let corner = 0; corner < 1 << m; corner++) {
+			let weight = 1;
+			let flat = 0;
+			let stride = 1;
+			for (let i = 0; i < m; i++) {
+				const up = corner >> i & 1;
+				weight *= up ? frac[i] : 1 - frac[i];
+				flat += Math.min(base[i] + up, size[i] - 1) * stride;
+				stride *= size[i];
+			}
+			if (weight === 0) continue;
+			for (let j = 0; j < n; j++) out[j] = (out[j] ?? 0) + weight * sample(flat, j);
+		}
+		return out.map((v, j) => clamp(interpolate(v, 0, 1, decode[j * 2], decode[j * 2 + 1]), Math.min(range[j * 2], range[j * 2 + 1]), Math.max(range[j * 2], range[j * 2 + 1])));
+	};
+}
+/** §7.10.3 — an exponential interpolation between two colours. */
+function exponential(file, dict, domain) {
+	if (domain.length < 2) return void 0;
+	const c0 = numbers(file, dict.get("C0"));
+	const c1 = numbers(file, dict.get("C1"));
+	const nExp = file.get(dict, "N");
+	if (typeof nExp !== "number") return void 0;
+	const from = c0.length > 0 ? c0 : [0];
+	const to = c1.length > 0 ? c1 : [1];
+	const n = Math.max(from.length, to.length);
+	return (inputs) => {
+		const x = clamp(inputs[0] ?? 0, domain[0], domain[1]);
+		const t = nExp === 1 ? x : Math.max(0, x) ** nExp;
+		const out = [];
+		for (let i = 0; i < n; i++) out.push((from[i] ?? 0) + t * ((to[i] ?? 0) - (from[i] ?? 0)));
+		return out;
+	};
+}
+/** §7.10.4 — k functions laid end to end along one input. */
+function stitching(file, dict, domain, depth) {
+	if (domain.length < 2) return void 0;
+	const list = file.resolve(dict.get("Functions") ?? PDF_NULL);
+	if (!Array.isArray(list) || list.length === 0) return void 0;
+	const parts = list.map((v) => readAt(file, v, depth + 1));
+	if (parts.some((p) => p === void 0)) return void 0;
+	const bounds = numbers(file, dict.get("Bounds"));
+	const encode = orDefault(numbers(file, dict.get("Encode")), parts.length * 2, (i) => i % 2);
+	const d0 = domain[0];
+	const d1 = domain[1];
+	return (inputs) => {
+		const x = clamp(inputs[0] ?? 0, d0, d1);
+		let k = 0;
+		while (k < bounds.length && x >= bounds[k]) k++;
+		k = Math.min(k, parts.length - 1);
+		const lo = k === 0 ? d0 : bounds[k - 1];
+		const hi = k === bounds.length ? d1 : bounds[k];
+		return parts[k]([interpolate(x, lo, hi, encode[k * 2], encode[k * 2 + 1])]);
+	};
+}
+/** §7.10.5 — a PostScript calculator: a program in braces, run on a stack. */
+function calculator(file, stream, domain) {
+	const range = numbers(file, stream.dict.get("Range"));
+	const program = parseProgram(file.streamData(stream));
+	if (!program || range.length < 2) return void 0;
+	const n = range.length >> 1;
+	return (inputs) => {
+		const stack = [];
+		for (let i = 0; i * 2 + 1 < domain.length; i++) stack.push(clamp(inputs[i] ?? 0, domain[i * 2], domain[i * 2 + 1]));
+		if (domain.length === 0) stack.push(...inputs);
+		run(program, stack, 0);
+		const out = stack.slice(-n);
+		while (out.length < n) out.unshift(0);
+		return out.map((v, j) => clamp(v, Math.min(range[j * 2], range[j * 2 + 1]), Math.max(range[j * 2], range[j * 2 + 1])));
+	};
+}
+/** Read `{ … }` into nested token lists, or `undefined` where it is not one. */
+function parseProgram(bytes) {
+	const lexer = new Lexer(bytes);
+	let count = 0;
+	const read = (depth) => {
+		if (depth > MAX_PS_DEPTH) return void 0;
+		const out = [];
+		for (;;) {
+			if (++count > MAX_PS_TOKENS) return void 0;
+			const tok = lexer.nextToken();
+			if (tok.kind === "eof") return depth === 0 ? out : void 0;
+			if (tok.kind === "num") out.push(tok.value);
+			else if (tok.kind === "keyword") if (tok.value === "{") {
+				const inner = read(depth + 1);
+				if (!inner) return void 0;
+				out.push(inner);
+			} else if (tok.value === "}") return out;
+			else out.push(tok.value);
+		}
+	};
+	const top = read(0);
+	return top && top.length === 1 && Array.isArray(top[0]) ? top[0] : top;
+}
+/** Run a token list against the stack (§7.10.5, Table 42). */
+function run(program, stack, depth) {
+	if (depth > MAX_PS_DEPTH) return;
+	const pop = () => stack.pop() ?? 0;
+	const blocks = [];
+	for (const tok of program) {
+		if (typeof tok === "number") {
+			stack.push(tok);
+			continue;
+		}
+		if (Array.isArray(tok)) {
+			blocks.push(tok);
+			continue;
+		}
+		switch (tok) {
+			case "abs":
+				stack.push(Math.abs(pop()));
+				break;
+			case "add": {
+				const b = pop();
+				stack.push(pop() + b);
+				break;
+			}
+			case "atan": {
+				const den = pop();
+				const numr = pop();
+				stack.push((Math.atan2(numr, den) * 180 / Math.PI + 360) % 360);
+				break;
+			}
+			case "ceiling":
+				stack.push(Math.ceil(pop()));
+				break;
+			case "cos":
+				stack.push(Math.cos(pop() * Math.PI / 180));
+				break;
+			case "cvi":
+				stack.push(Math.trunc(pop()));
+				break;
+			case "cvr": break;
+			case "div": {
+				const b = pop();
+				const a = pop();
+				stack.push(b === 0 ? 0 : a / b);
+				break;
+			}
+			case "exp": {
+				const b = pop();
+				stack.push(pop() ** b);
+				break;
+			}
+			case "floor":
+				stack.push(Math.floor(pop()));
+				break;
+			case "idiv": {
+				const b = pop();
+				const a = pop();
+				stack.push(b === 0 ? 0 : Math.trunc(a / b));
+				break;
+			}
+			case "ln": {
+				const a = pop();
+				stack.push(a > 0 ? Math.log(a) : 0);
+				break;
+			}
+			case "log": {
+				const a = pop();
+				stack.push(a > 0 ? Math.log10(a) : 0);
+				break;
+			}
+			case "mod": {
+				const b = pop();
+				const a = pop();
+				stack.push(b === 0 ? 0 : Math.trunc(a) % Math.trunc(b));
+				break;
+			}
+			case "mul": {
+				const b = pop();
+				stack.push(pop() * b);
+				break;
+			}
+			case "neg":
+				stack.push(-pop());
+				break;
+			case "round":
+				stack.push(Math.round(pop()));
+				break;
+			case "sin":
+				stack.push(Math.sin(pop() * Math.PI / 180));
+				break;
+			case "sqrt":
+				stack.push(Math.sqrt(Math.max(0, pop())));
+				break;
+			case "sub": {
+				const b = pop();
+				stack.push(pop() - b);
+				break;
+			}
+			case "truncate":
+				stack.push(Math.trunc(pop()));
+				break;
+			case "and": {
+				const b = pop();
+				stack.push(int(pop()) & int(b));
+				break;
+			}
+			case "bitshift": {
+				const s = int(pop());
+				const a = int(pop());
+				stack.push(s >= 0 ? a << s : a >> -s);
+				break;
+			}
+			case "eq": {
+				const b = pop();
+				stack.push(pop() === b ? 1 : 0);
+				break;
+			}
+			case "false":
+				stack.push(0);
+				break;
+			case "ge": {
+				const b = pop();
+				stack.push(pop() >= b ? 1 : 0);
+				break;
+			}
+			case "gt": {
+				const b = pop();
+				stack.push(pop() > b ? 1 : 0);
+				break;
+			}
+			case "le": {
+				const b = pop();
+				stack.push(pop() <= b ? 1 : 0);
+				break;
+			}
+			case "lt": {
+				const b = pop();
+				stack.push(pop() < b ? 1 : 0);
+				break;
+			}
+			case "ne": {
+				const b = pop();
+				stack.push(pop() !== b ? 1 : 0);
+				break;
+			}
+			case "not": {
+				const a = pop();
+				stack.push(a === 0 ? 1 : a === 1 ? 0 : ~int(a));
+				break;
+			}
+			case "or": {
+				const b = pop();
+				stack.push(int(pop()) | int(b));
+				break;
+			}
+			case "true":
+				stack.push(1);
+				break;
+			case "xor": {
+				const b = pop();
+				stack.push(int(pop()) ^ int(b));
+				break;
+			}
+			case "if": {
+				const body = blocks.pop();
+				if (body && pop() !== 0) run(body, stack, depth + 1);
+				break;
+			}
+			case "ifelse": {
+				const otherwise = blocks.pop();
+				const body = blocks.pop();
+				const branch = pop() !== 0 ? body : otherwise;
+				if (branch) run(branch, stack, depth + 1);
+				break;
+			}
+			case "copy": {
+				const k = int(pop());
+				if (k > 0 && k <= stack.length) stack.push(...stack.slice(-k));
+				break;
+			}
+			case "dup": {
+				const a = pop();
+				stack.push(a, a);
+				break;
+			}
+			case "exch": {
+				const b = pop();
+				const a = pop();
+				stack.push(b, a);
+				break;
+			}
+			case "index": {
+				const k = int(pop());
+				stack.push(k >= 0 && k < stack.length ? stack[stack.length - 1 - k] : 0);
+				break;
+			}
+			case "pop":
+				pop();
+				break;
+			case "roll": {
+				const j = int(pop());
+				const k = int(pop());
+				if (k > 0 && k <= stack.length) {
+					const part = stack.splice(stack.length - k, k);
+					const by = (j % k + k) % k;
+					stack.push(...part.slice(k - by), ...part.slice(0, k - by));
+				}
+				break;
+			}
+			default: break;
+		}
+	}
+}
+/** A stack value as the 32-bit integer the bitwise operators work on. */
+function int(v) {
+	return Number.isFinite(v) ? v | 0 : 0;
+}
+function clamp(v, lo, hi) {
+	if (!Number.isFinite(v)) return lo;
+	return v < lo ? lo : v > hi ? hi : v;
+}
+/** §7.10.2 — one number carried from one interval onto another. */
+function interpolate(x, xLo, xHi, yLo, yHi) {
+	if (xHi === xLo) return yLo;
+	return yLo + (x - xLo) * (yHi - yLo) / (xHi - xLo);
+}
+function numbers(file, v) {
+	const r = v !== void 0 ? file.resolve(v) : void 0;
+	if (!Array.isArray(r)) return [];
+	return r.map((x) => {
+		const n = file.resolve(x);
+		return typeof n === "number" ? n : 0;
+	});
+}
+/** The stated array, where it is the right length; otherwise the default. */
+function orDefault(stated, length, fallback) {
+	if (stated.length === length) return stated;
+	return Array.from({ length }, (_, i) => fallback(i));
+}
+//#endregion
+export { readFunction };

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

@@ -27,10 +27,14 @@ export type DecodedImage = {
  * Supports DeviceGray/RGB/CMYK, CalGray/CalRGB, ICCBased (by `/N`) and Indexed
  * colour spaces; Flate, LZW (EP12), RunLength, ASCII85, ASCIIHex and CCITT
  * Group 4 / Group 3 1-D fax (EP15) filters; PNG/TIFF predictors; bit depths
- * 1/2/4/8/16; and an `/SMask` folded in as the PNG alpha channel. Unsupported
- * inputs (stencil `/ImageMask`, Separation/DeviceN/Lab, JBIG2, CCITT Group 3
- * 2-D) return a typed failure so the caller records a loss.
+ * 1/2/4/8/16; an `/SMask` folded in as the PNG alpha channel; and a stencil
+ * `/ImageMask` (§8.9.6.2) given back as RGBA in `fillHex`. Unsupported inputs
+ * (Separation/DeviceN/Lab, CCITT Group 3 2-D) return a typed failure so the
+ * caller records a loss.
  *
+ * @param file    The owning file.
+ * @param stream  The image XObject, or an inline image wrapped as one.
+ * @param fillHex §8.9.6.2 — the non-stroking colour a stencil mask paints in.
  * @returns The decoded image, or `{ ok: false }` with the loss severity and reason.
  */
-export declare function decodePdfImage(file: PdfFile, stream: PdfStream): DecodedImage;
+export declare function decodePdfImage(file: PdfFile, stream: PdfStream, fillHex?: string): DecodedImage;