@segnavia/render 0.1.0 → 0.3.0

package/dist/press/pattern-bounds.js

@@ -0,0 +1,275 @@
+import { IDENTITY_MATRIX, multiplyAffine } from "./affine.js";
+import { visitContentTokens } from "./content.js";
+import { numberOf } from "./pdf-objects.js";
+import { clearPath, closePath, curveTo, curveV, curveY, deviceBox, intersectRect, lineTo, moveTo, rectTo } from "./pattern-path.js";
+const cloneGraphics = (graphics) => ({
+	clip: graphics.clip ? { ...graphics.clip } : void 0,
+	ctm: graphics.ctm.slice(),
+	fill: graphics.fill,
+	lineJoin: graphics.lineJoin,
+	lineWidth: graphics.lineWidth,
+	miterLimit: graphics.miterLimit,
+	stroke: graphics.stroke
+});
+function numbers(operands, count) {
+	if (operands.length !== count || operands.some((operand) => operand.kind !== "number")) return void 0;
+	return operands.map((operand) => Number(operand.raw));
+}
+function nameOf(operands) {
+	if (operands.length !== 1 || operands[0]?.kind !== "name") return void 0;
+	return operands[0].raw.slice(1);
+}
+function unionRect(left, right) {
+	return {
+		x0: Math.min(left.x0, right.x0),
+		y0: Math.min(left.y0, right.y0),
+		x1: Math.max(left.x1, right.x1),
+		y1: Math.max(left.y1, right.y1)
+	};
+}
+function addPaint(bounds, target, paint) {
+	if (!target) return;
+	const existing = bounds.get(target);
+	if (existing === "unbounded" || paint === "unbounded") {
+		bounds.set(target, "unbounded");
+		return;
+	}
+	bounds.set(target, existing ? unionRect(existing, paint) : paint);
+}
+function strokeMargin(graphics) {
+	const half = graphics.lineWidth / 2;
+	if (!Number.isFinite(half) || half < 0) return void 0;
+	if (graphics.lineJoin === 1 || graphics.lineJoin === 2) return half;
+	if (graphics.lineJoin !== 0 || !Number.isFinite(graphics.miterLimit) || graphics.miterLimit < 1) return void 0;
+	return graphics.miterLimit * half;
+}
+function paintFill(state) {
+	if (state.pastSaveCap) {
+		addPaint(state.bounds, state.current.fill, "unbounded");
+		return;
+	}
+	if (!state.path.box) return;
+	const box = deviceBox(state.path.box, state.current.ctm);
+	if (box) addPaint(state.bounds, state.current.fill, box);
+}
+function paintStroke(state) {
+	if (state.pastSaveCap) {
+		addPaint(state.bounds, state.current.stroke, "unbounded");
+		return;
+	}
+	if (!state.path.box) return;
+	const margin = strokeMargin(state.current);
+	if (margin === void 0) {
+		addPaint(state.bounds, state.current.stroke, "unbounded");
+		return;
+	}
+	const grown = {
+		x0: state.path.box.x0 - margin,
+		y0: state.path.box.y0 - margin,
+		x1: state.path.box.x1 + margin,
+		y1: state.path.box.y1 + margin
+	};
+	const box = deviceBox(grown, state.current.ctm);
+	if (box) addPaint(state.bounds, state.current.stroke, box);
+}
+function applyMove(state, operands) {
+	const values = numbers(operands, 2);
+	if (values) moveTo(state.path, values[0] ?? 0, values[1] ?? 0);
+}
+function applyLine(state, operands) {
+	const values = numbers(operands, 2);
+	if (values) lineTo(state.path, values[0] ?? 0, values[1] ?? 0);
+}
+function applyCurve(state, operands) {
+	const values = numbers(operands, 6);
+	if (values) curveTo(state.path, values);
+}
+function applyCurveV(state, operands) {
+	const values = numbers(operands, 4);
+	if (values) curveV(state.path, values);
+}
+function applyCurveY(state, operands) {
+	const values = numbers(operands, 4);
+	if (values) curveY(state.path, values);
+}
+function applyRect(state, operands) {
+	const values = numbers(operands, 4);
+	if (values) rectTo(state.path, values[0] ?? 0, values[1] ?? 0, values[2] ?? 0, values[3] ?? 0);
+}
+function applyCm(state, operands) {
+	const values = numbers(operands, 6);
+	if (!values) {
+		addPaint(state.bounds, state.current.fill, "unbounded");
+		addPaint(state.bounds, state.current.stroke, "unbounded");
+		return;
+	}
+	state.current.ctm = multiplyAffine(state.current.ctm, values);
+}
+function clearColor(state, fill) {
+	if (fill) state.current.fill = void 0;
+	else state.current.stroke = void 0;
+}
+function applyColor(state, operator, operands) {
+	const fill = operator === operator.toLowerCase();
+	const patternName = nameOf(operands);
+	if ((operator === "scn" || operator === "SCN") && patternName) {
+		const pattern = state.resolve(patternName);
+		if (fill) state.current.fill = pattern;
+		else state.current.stroke = pattern;
+		return;
+	}
+	if ((operator === "cs" || operator === "CS") && nameOf(operands) === "Pattern") return;
+	clearColor(state, fill);
+}
+const colorHandler = (operator) => (state, operands) => applyColor(state, operator, operands);
+function markUnbounded(state) {
+	addPaint(state.bounds, state.current.fill, "unbounded");
+	addPaint(state.bounds, state.current.stroke, "unbounded");
+}
+function strokeAndClear(state, close) {
+	if (close) closePath(state.path);
+	paintStroke(state);
+	clearPath(state.path);
+}
+function fillAndClear(state) {
+	paintFill(state);
+	clearPath(state.path);
+}
+function fillStrokeAndClear(state, close) {
+	if (close) closePath(state.path);
+	paintFill(state);
+	paintStroke(state);
+	clearPath(state.path);
+}
+function setLineWidth(state, width) {
+	if (!Number.isFinite(width) || width < 0) return false;
+	state.current.lineWidth = width;
+	return true;
+}
+function setLineJoin(state, join) {
+	if (join !== 0 && join !== 1 && join !== 2) return false;
+	state.current.lineJoin = join;
+	return true;
+}
+function setMiterLimit(state, miter) {
+	if (!Number.isFinite(miter) || miter < 1) return false;
+	state.current.miterLimit = miter;
+	return true;
+}
+function applyStrokeNumber(state, operands, assign) {
+	const value = numbers(operands, 1)?.[0];
+	if (value === void 0 || !assign(state, value)) markUnbounded(state);
+}
+function applyStyleNumber(dict, key, assign) {
+	const value = numberOf(dict, key);
+	return value === void 0 || assign(value);
+}
+function applyGraphicsState(state, operands) {
+	const name = nameOf(operands);
+	const dict = name ? state.resolveGraphicsState(name) : void 0;
+	if (!dict) {
+		markUnbounded(state);
+		return;
+	}
+	if (!(applyStyleNumber(dict, "LW", (width) => setLineWidth(state, width)) && applyStyleNumber(dict, "LJ", (join) => setLineJoin(state, join)) && applyStyleNumber(dict, "ML", (miter) => setMiterLimit(state, miter)))) markUnbounded(state);
+}
+function saveGraphics(state) {
+	if (state.pastSaveCap || state.graphics.length >= 64) {
+		state.pastSaveCap = true;
+		markUnbounded(state);
+		return;
+	}
+	state.graphics.push(cloneGraphics(state.current));
+}
+function applyClip(state) {
+	if (!state.path.box) return;
+	const box = deviceBox(state.path.box, state.current.ctm);
+	if (!box) return;
+	state.current.clip = state.current.clip ? intersectRect(state.current.clip, box) : box;
+}
+function applyShading(state, operands) {
+	const name = nameOf(operands);
+	const shading = name ? state.resolveShading(name) : void 0;
+	if (state.pastSaveCap || !state.current.clip) {
+		addPaint(state.shadingBounds, shading, "unbounded");
+		return;
+	}
+	addPaint(state.shadingBounds, shading, state.current.clip);
+}
+const handlers = {
+	q: saveGraphics,
+	Q: (state) => {
+		const restored = state.graphics.pop();
+		if (restored) state.current = restored;
+	},
+	cm: applyCm,
+	m: applyMove,
+	l: applyLine,
+	c: applyCurve,
+	v: applyCurveV,
+	y: applyCurveY,
+	h: (state) => closePath(state.path),
+	re: applyRect,
+	n: (state) => clearPath(state.path),
+	W: applyClip,
+	"W*": applyClip,
+	sh: applyShading,
+	Do: markUnbounded,
+	S: (state) => strokeAndClear(state, false),
+	s: (state) => strokeAndClear(state, true),
+	f: fillAndClear,
+	F: fillAndClear,
+	"f*": fillAndClear,
+	B: (state) => fillStrokeAndClear(state, false),
+	"B*": (state) => fillStrokeAndClear(state, false),
+	b: (state) => fillStrokeAndClear(state, true),
+	"b*": (state) => fillStrokeAndClear(state, true),
+	w: (state, operands) => applyStrokeNumber(state, operands, setLineWidth),
+	j: (state, operands) => applyStrokeNumber(state, operands, setLineJoin),
+	M: (state, operands) => applyStrokeNumber(state, operands, setMiterLimit),
+	gs: applyGraphicsState,
+	cs: colorHandler("cs"),
+	CS: colorHandler("CS"),
+	sc: colorHandler("sc"),
+	SC: colorHandler("SC"),
+	scn: colorHandler("scn"),
+	SCN: colorHandler("SCN"),
+	rg: colorHandler("rg"),
+	RG: colorHandler("RG"),
+	g: colorHandler("g"),
+	G: colorHandler("G"),
+	k: colorHandler("k"),
+	K: colorHandler("K")
+};
+function emptyGraphics() {
+	return {
+		ctm: IDENTITY_MATRIX.slice(),
+		lineJoin: 0,
+		lineWidth: 1,
+		miterLimit: 10
+	};
+}
+function createPaintedBoundsTracker(bounds, shadingBounds = /* @__PURE__ */ new WeakMap()) {
+	const state = {
+		bounds,
+		current: emptyGraphics(),
+		graphics: [],
+		pastSaveCap: false,
+		path: {},
+		resolve: () => void 0,
+		resolveGraphicsState: () => void 0,
+		resolveShading: () => void 0,
+		shadingBounds
+	};
+	return { feed(bytes, resolve, resolveGraphicsState = () => void 0, resolveShading = () => void 0) {
+		state.resolve = resolve;
+		state.resolveGraphicsState = resolveGraphicsState;
+		state.resolveShading = resolveShading;
+		visitContentTokens(bytes, (operator, operands) => handlers[operator]?.(state, operands));
+	} };
+}
+function recordPatternPaintedBounds(bytes, resolve, bounds, resolveGraphicsState = () => void 0, resolveShading = () => void 0, shadingBounds = /* @__PURE__ */ new WeakMap()) {
+	createPaintedBoundsTracker(bounds, shadingBounds).feed(bytes, resolve, resolveGraphicsState, resolveShading);
+}
+//#endregion
+export { createPaintedBoundsTracker, recordPatternPaintedBounds, unionRect };

package/dist/press/pattern-path.js

@@ -0,0 +1,102 @@
+import { applyAffine } from "./affine.js";
+//#region src/press/pattern-path.ts
+function includePoint(box, x, y) {
+	if (!box) return {
+		x0: x,
+		y0: y,
+		x1: x,
+		y1: y
+	};
+	return {
+		x0: Math.min(box.x0, x),
+		y0: Math.min(box.y0, y),
+		x1: Math.max(box.x1, x),
+		y1: Math.max(box.y1, y)
+	};
+}
+function addPoint(path, x, y) {
+	const point = {
+		x,
+		y
+	};
+	path.box = includePoint(path.box, x, y);
+	path.current = point;
+	return point;
+}
+function deviceBox(box, ctm) {
+	const corners = [
+		applyAffine(ctm, box.x0, box.y0),
+		applyAffine(ctm, box.x1, box.y0),
+		applyAffine(ctm, box.x0, box.y1),
+		applyAffine(ctm, box.x1, box.y1)
+	];
+	const xs = corners.map((point) => point.x);
+	const ys = corners.map((point) => point.y);
+	const x0 = Math.min(...xs);
+	const y0 = Math.min(...ys);
+	const x1 = Math.max(...xs);
+	const y1 = Math.max(...ys);
+	if (!Number.isFinite(x0) || !Number.isFinite(y0) || !Number.isFinite(x1) || !Number.isFinite(y1)) return void 0;
+	return {
+		x0,
+		y0,
+		x1,
+		y1
+	};
+}
+function closePath(path) {
+	if (path.start) addPoint(path, path.start.x, path.start.y);
+}
+function clearPath(path) {
+	path.box = void 0;
+	path.current = void 0;
+	path.start = void 0;
+}
+function moveTo(path, x, y) {
+	path.start = addPoint(path, x, y);
+}
+function lineTo(path, x, y) {
+	addPoint(path, x, y);
+}
+function curveTo(path, values) {
+	addPoint(path, values[0] ?? 0, values[1] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+	addPoint(path, values[4] ?? 0, values[5] ?? 0);
+}
+function curveV(path, values) {
+	if (!path.current) return;
+	addPoint(path, path.current.x, path.current.y);
+	addPoint(path, values[0] ?? 0, values[1] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+}
+function curveY(path, values) {
+	addPoint(path, values[0] ?? 0, values[1] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+}
+function rectTo(path, x, y, width, height) {
+	addPoint(path, x, y);
+	path.start = {
+		x,
+		y
+	};
+	addPoint(path, x + width, y);
+	addPoint(path, x + width, y + height);
+	addPoint(path, x, y + height);
+	addPoint(path, x, y);
+}
+function intersectRect(left, right) {
+	const x0 = Math.max(left.x0, right.x0);
+	const y0 = Math.max(left.y0, right.y0);
+	const x1 = Math.min(left.x1, right.x1);
+	const y1 = Math.min(left.y1, right.y1);
+	if (!(x0 < x1) || !(y0 < y1)) return void 0;
+	return {
+		x0,
+		y0,
+		x1,
+		y1
+	};
+}
+//#endregion
+export { addPoint, clearPath, closePath, curveTo, curveV, curveY, deviceBox, includePoint, intersectRect, lineTo, moveTo, rectTo };

package/dist/press/pdf-objects.js

@@ -0,0 +1,88 @@
+import { RenderRefusedError } from "../errors.js";
+import { colorSpaceKind, colorSpaceLabel, contentFilter } from "./policy.js";
+import { PDFArray, PDFDict, PDFName, PDFNumber, PDFRawStream, PDFRef, PDFStream } from "pdf-lib";
+import { inflateSync } from "node:zlib";
+//#region src/press/pdf-objects.ts
+const MAX_CONTENT_BYTES = 33554432;
+const MAX_DOCUMENT_CONTENT_BYTES = 134217728;
+const nameOf = (object) => object instanceof PDFName ? object.toString().slice(1) : void 0;
+function dictionaryOf(object) {
+	if (object instanceof PDFDict) return object;
+	if (object instanceof PDFStream) return object.dict;
+}
+function numberOf(dictionary, key) {
+	return dictionary.lookupMaybe(PDFName.of(key), PDFNumber)?.asNumber();
+}
+function arrayNumbers(dictionary, key, count) {
+	const array = dictionary.lookupMaybe(PDFName.of(key), PDFArray);
+	if (!array || array.size() !== count) throw new Error(`PDF ${key} has unsupported length ${array?.size() ?? "missing"}; supported: ${count} numbers`);
+	return Array.from({ length: count }, (_, index) => {
+		const value = array.lookupMaybe(index, PDFNumber)?.asNumber();
+		if (value === void 0) throw new Error(`PDF ${key} has unsupported non-number at index ${index}; supported: ${count} numbers`);
+		return value;
+	});
+}
+function replaceArray(dictionary, key, values) {
+	const array = dictionary.context.obj(values);
+	dictionary.set(PDFName.of(key), array);
+}
+function rawStreamOf(object) {
+	return object instanceof PDFRawStream ? object : void 0;
+}
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+function colorSpaceValue(document, object) {
+	const value = resolved(document, object);
+	const name = nameOf(value);
+	if (name) return { name };
+	if (!(value instanceof PDFArray)) return void 0;
+	const family = nameOf(resolved(document, value.get(0)));
+	if (family === "ICCBased") return {
+		family,
+		channels: rawStreamOf(resolved(document, value.get(1)))?.dict.lookupMaybe(PDFName.of("N"), PDFNumber)?.asNumber()
+	};
+	if (family === "Indexed") return {
+		family,
+		base: colorSpaceValue(document, value.get(1))
+	};
+	return { family };
+}
+function resolvedColorSpace(document, object) {
+	const value = colorSpaceValue(document, object);
+	return {
+		kind: colorSpaceKind(value),
+		label: object ? colorSpaceLabel(value) : "missing"
+	};
+}
+function filterNames(filter) {
+	if (!filter) return void 0;
+	const direct = nameOf(filter);
+	if (direct) return [direct];
+	if (!(filter instanceof PDFArray)) return [];
+	const names = [];
+	for (let index = 0; index < filter.size(); index++) {
+		const name = nameOf(filter.get(index));
+		if (!name) return [];
+		names.push(name);
+	}
+	return names;
+}
+function decodeContent(stream, budget) {
+	const filter = stream.dict.get(PDFName.of("Filter"));
+	const decision = contentFilter(filterNames(filter));
+	if (decision.action === "refuse") throw new RenderRefusedError(`The PDF has unsupported content stream filter other; supported: ${decision.supported}.`);
+	let decoded;
+	try {
+		decoded = decision.encoding === "compressed" ? inflateSync(stream.contents, { maxOutputLength: MAX_CONTENT_BYTES }) : stream.contents;
+	} catch (error) {
+		if (error.code === "ERR_BUFFER_TOO_LARGE") throw new RenderRefusedError(`The PDF has unsupported decoded content stream longer than ${MAX_CONTENT_BYTES} bytes; supported: at most ${MAX_CONTENT_BYTES} bytes.`);
+		throw new RenderRefusedError(`The PDF has unsupported content stream decode failure; supported: a valid FlateDecode or unfiltered stream.`);
+	}
+	if (decoded.byteLength > 33554432) throw new RenderRefusedError(`The PDF has unsupported decoded content stream length ${decoded.byteLength}; supported: at most ${MAX_CONTENT_BYTES} bytes.`);
+	if (budget) {
+		budget.decodedBytes += decoded.byteLength;
+		if (budget.decodedBytes > 134217728) throw new RenderRefusedError(`The PDF has unsupported total decoded content length ${budget.decodedBytes}; supported: at most ${MAX_DOCUMENT_CONTENT_BYTES} bytes.`);
+	}
+	return decoded;
+}
+//#endregion
+export { MAX_CONTENT_BYTES, MAX_DOCUMENT_CONTENT_BYTES, arrayNumbers, decodeContent, dictionaryOf, nameOf, numberOf, rawStreamOf, replaceArray, resolvedColorSpace };

package/dist/press/policy.js

@@ -0,0 +1,126 @@
+//#region src/press/policy.ts
+function colorSpaceKind(value) {
+	if (value?.name === "DeviceRGB" || value?.name === "CalRGB") return "rgb";
+	if (value?.name === "DeviceGray") return "gray";
+	if (value?.name === "DeviceCMYK") return "cmyk";
+	if (value?.family === "ICCBased") return value.channels === 3 ? "rgb" : value.channels === 1 ? "gray" : value.channels === 4 ? "cmyk" : "other";
+	if (value?.family === "Indexed") return colorSpaceKind(value.base);
+	return "other";
+}
+function colorSpaceLabel(value) {
+	const label = value?.name ?? value?.family;
+	if (!label) return "missing";
+	return [
+		"DeviceRGB",
+		"DeviceGray",
+		"DeviceCMYK",
+		"CalRGB",
+		"ICCBased",
+		"Indexed",
+		"Pattern"
+	].includes(label) ? label : "other";
+}
+const decision = (action, supported) => ({
+	action,
+	supported
+});
+function contentFilter(names) {
+	const supported = `FlateDecode or no filter`;
+	if (!names) return {
+		...decision("keep", supported),
+		encoding: "none"
+	};
+	if (names.length === 1 && names[0] === "FlateDecode") return {
+		...decision("keep", supported),
+		encoding: "compressed"
+	};
+	return {
+		...decision("refuse", supported),
+		encoding: "unsupported"
+	};
+}
+function groupAction(kind, label, maskSource) {
+	const supported = "DeviceCMYK, DeviceGray, DeviceRGB on a mask source, or no declared space";
+	if (kind === "gray" || kind === "cmyk" || maskSource && (label === "DeviceRGB" || label === "missing")) return decision("keep", supported);
+	if (label === "missing" || label === "DeviceRGB") return decision("convert", supported);
+	return decision("refuse", supported);
+}
+function shadingAction(kind, type, functionType) {
+	if (type === 1) {
+		const supported = "ShadingType 1 in an RGB space with FunctionType 4, or DeviceCMYK";
+		if (kind === "cmyk") return decision("keep", supported);
+		if (kind === "rgb" && functionType === 4) return decision("convert", supported);
+		return decision("refuse", supported);
+	}
+	const supported = "ShadingType 2 or 3 in an RGB or DeviceCMYK color space";
+	if (type !== 2 && type !== 3) return decision("refuse", supported);
+	if (kind === "rgb") return decision("convert", supported);
+	if (kind === "cmyk") return decision("keep", supported);
+	return decision("refuse", supported);
+}
+function shadingFunctionAction(type, dictionary, functions) {
+	if (!dictionary) return {
+		...decision("refuse", "FunctionType 2 or 3"),
+		found: "shading function other"
+	};
+	if (type !== 2 && type !== 3) return {
+		...decision("refuse", "FunctionType 2 or 3"),
+		found: `shading FunctionType ${type ?? "missing"}`
+	};
+	if (type === 3 && !functions) return {
+		...decision("refuse", "a Functions array"),
+		found: "FunctionType 3 Functions missing"
+	};
+	return {
+		...decision("keep", "FunctionType 2 or 3"),
+		found: `shading FunctionType ${type}`
+	};
+}
+const inlineNames = {
+	G: { name: "DeviceGray" },
+	DeviceGray: { name: "DeviceGray" },
+	RGB: { name: "DeviceRGB" },
+	DeviceRGB: { name: "DeviceRGB" },
+	CMYK: { name: "DeviceCMYK" },
+	DeviceCMYK: { name: "DeviceCMYK" },
+	I: { family: "Indexed" },
+	Indexed: { family: "Indexed" },
+	CalRGB: { name: "CalRGB" }
+};
+function inlineImageAction(name, imageMask) {
+	const value = name ? inlineNames[name] ?? { name } : void 0;
+	const kind = colorSpaceKind(value);
+	return {
+		...decision(imageMask || kind === "gray" || kind === "cmyk" ? "keep" : "refuse", "an image mask, DeviceGray, or DeviceCMYK"),
+		kind,
+		label: colorSpaceLabel(value)
+	};
+}
+function contentColorSpaceAction(name) {
+	return decision(name === "Pattern" || name === "DeviceCMYK" ? "keep" : "refuse", "Pattern or DeviceCMYK");
+}
+const colorOperators = [
+	"rg",
+	"RG",
+	"g",
+	"G",
+	"k",
+	"K",
+	"sc",
+	"SC",
+	"scn",
+	"SCN",
+	"cs",
+	"CS"
+];
+function isContentColorOperator(operator) {
+	return colorOperators.includes(operator);
+}
+function contentOperatorAction(operator, inspect, selectedSpace, patternName = false) {
+	if (operator === "rg" || operator === "RG" || operator === "g" || operator === "G") return decision(inspect ? "refuse" : "convert", inspect ? "CMYK operators" : "RGB or DeviceGray color operands");
+	if (operator === "k" || operator === "K") return decision("keep", "four CMYK operands");
+	if (operator === "cs" || operator === "CS") return contentColorSpaceAction(selectedSpace);
+	return decision((operator === "scn" || operator === "SCN") && patternName ? "keep" : "refuse", "a pattern name with scn or SCN");
+}
+//#endregion
+export { colorSpaceKind, colorSpaceLabel, contentColorSpaceAction, contentFilter, contentOperatorAction, groupAction, inlineImageAction, isContentColorOperator, shadingAction, shadingFunctionAction };

package/dist/press/report.js

@@ -0,0 +1,89 @@
+import { RenderRefusedError } from "../errors.js";
+import { groupAction, shadingAction } from "./policy.js";
+import { inspectContent } from "./content.js";
+import { decodeContent, dictionaryOf, nameOf, numberOf, resolvedColorSpace } from "./pdf-objects.js";
+import { walkPressGraph } from "./visitor.js";
+import { PDFDict, PDFDocument, PDFName, PDFRef } from "pdf-lib";
+//#region src/press/report.ts
+const key = (name) => PDFName.of(name);
+const refuse = (found, supported) => {
+	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
+};
+const resolved = (state, object) => object instanceof PDFRef ? state.document.context.lookup(object) : object;
+const requiredDimension = (value, name) => value ?? refuse(`RGB image ${name} missing`, `a ${name} number`);
+function inspectImage(state, image) {
+	if (state.images.has(image)) return;
+	state.images.add(image);
+	const space = resolvedColorSpace(state.document, resolved(state, image.dict.get(key("ColorSpace"))));
+	if (space.kind !== "rgb") return;
+	const width = requiredDimension(numberOf(image.dict, "Width"), "Width");
+	const height = requiredDimension(numberOf(image.dict, "Height"), "Height");
+	state.report.images.push({
+		width,
+		height,
+		colorSpace: space.label
+	});
+}
+function inspectFunction(state, fn, policy) {
+	if (policy.action === "refuse") refuse(policy.found, policy.supported);
+	if (fn && numberOf(fn, "FunctionType") === 2) state.report.gradientStops += 2;
+}
+function inspectShading(state, shading) {
+	if (state.shadings.has(shading)) return false;
+	state.shadings.add(shading);
+	const type = numberOf(shading, "ShadingType");
+	const fn = dictionaryOf(resolved(state, shading.get(key("Function"))));
+	const functionType = fn ? numberOf(fn, "FunctionType") : void 0;
+	const space = resolvedColorSpace(state.document, resolved(state, shading.get(key("ColorSpace"))));
+	const policy = shadingAction(space.kind, type, functionType);
+	if (policy.action !== "keep") {
+		if (type === 1) refuse(`ShadingType 1 FunctionType ${functionType ?? "missing"} color space ${space.label}`, policy.supported);
+		refuse(`ShadingType ${type ?? "missing"} color space ${space.label}`, policy.supported);
+	}
+	if (type === 1) {
+		state.report.sampledShadings++;
+		return false;
+	}
+	return true;
+}
+function inspectGroup(state, owner, maskSource) {
+	const group = owner.lookupMaybe(key("Group"), PDFDict);
+	if (!group || nameOf(group.get(key("S"))) !== "Transparency" || state.groups.has(group)) return;
+	state.groups.add(group);
+	const space = resolvedColorSpace(state.document, resolved(state, group.get(key("CS"))));
+	const policy = groupAction(space.kind, space.label, maskSource);
+	if (policy.action !== "keep") refuse(`transparency group color space ${space.label}`, policy.supported);
+	if (space.kind === "cmyk") state.report.groups++;
+}
+async function inspectPressPdf(bytes) {
+	const document = await PDFDocument.load(bytes, { updateMetadata: false });
+	const state = {
+		budget: { decodedBytes: 0 },
+		document,
+		groups: /* @__PURE__ */ new WeakSet(),
+		images: /* @__PURE__ */ new WeakSet(),
+		report: {
+			images: [],
+			fills: 0,
+			strokes: 0,
+			gradientStops: 0,
+			sampledShadings: 0,
+			groups: 0
+		},
+		shadings: /* @__PURE__ */ new WeakSet()
+	};
+	walkPressGraph(document, {
+		content: (_object, stream) => {
+			const counts = inspectContent(decodeContent(stream, state.budget));
+			state.report.fills += counts.fills;
+			state.report.strokes += counts.strokes;
+		},
+		function: (fn, decision) => inspectFunction(state, fn, decision),
+		group: (owner, _stream, maskSource) => inspectGroup(state, owner, maskSource),
+		image: (image) => inspectImage(state, image),
+		shading: (shading) => inspectShading(state, shading)
+	});
+	return state.report;
+}
+//#endregion
+export { inspectPressPdf };