@segnavia/render 0.5.0 → 0.7.0

package/dist/press/image.js

@@ -0,0 +1,327 @@
+import { RenderRefusedError } from "../errors.js";
+import { destinationColor, pdfMaskLuminosity } from "./color-policy.js";
+import { nameOf, numberOf, rawStreamOf } from "./pdf-objects.js";
+import { PDFArray, PDFDict, PDFHexString, PDFName, PDFNumber, PDFRef, PDFString } from "pdf-lib";
+import { deflateSync, inflateSync } from "node:zlib";
+//#region src/press/image.ts
+const MAX_IMAGE_PIXELS = 5e7;
+const MAX_TOTAL_IMAGE_PIXELS = 4e8;
+const key = (value) => PDFName.of(value);
+const refuse = (found, supported) => {
+	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
+};
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+function bytesOf(document, object) {
+	const value = resolved(document, object);
+	if (value instanceof PDFString || value instanceof PDFHexString) return value.asBytes();
+	const stream = rawStreamOf(value);
+	if (!stream) return void 0;
+	const filter = nameOf(resolved(document, stream.dict.get(key("Filter"))));
+	if (!filter) return stream.contents;
+	if (filter === "FlateDecode" || filter === "Fl") return inflate(stream.contents, "Indexed lookup");
+}
+function baseSpace(document, object) {
+	const value = resolved(document, object);
+	const name = nameOf(value);
+	if (name === "DeviceRGB") return {
+		channels: 3,
+		kind: "rgb",
+		label: name
+	};
+	if (name === "DeviceGray") return {
+		channels: 1,
+		kind: "gray",
+		label: name
+	};
+	if (!(value instanceof PDFArray) || nameOf(resolved(document, value.get(0))) !== "ICCBased") return void 0;
+	const profile = rawStreamOf(resolved(document, value.get(1)));
+	const channels = profile ? numberOf(profile.dict, "N") : void 0;
+	if (channels === 1) return {
+		channels,
+		kind: "gray",
+		label: "ICCBased N 1"
+	};
+	if (channels === 3) return {
+		channels,
+		kind: "rgb",
+		label: "ICCBased N 3"
+	};
+}
+function imageSpace(document, object) {
+	const base = baseSpace(document, object);
+	if (base) return base;
+	const value = resolved(document, object);
+	if (value instanceof PDFArray && nameOf(resolved(document, value.get(0))) === "Indexed") {
+		const indexedBase = baseSpace(document, value.get(1));
+		const high = resolved(document, value.get(2));
+		const lookup = bytesOf(document, value.get(3));
+		if (indexedBase && high instanceof PDFNumber && lookup) return {
+			base: indexedBase,
+			high: high.asNumber(),
+			kind: "indexed",
+			label: `Indexed over ${indexedBase.label}`,
+			lookup
+		};
+	}
+	const label = nameOf(value) ?? (value instanceof PDFArray ? nameOf(resolved(document, value.get(0))) ?? "array" : "missing");
+	return refuse(`image color space ${label}`, "DeviceRGB, DeviceGray, ICCBased with N 1 or 3, or Indexed over one of those");
+}
+function filterName(document, image) {
+	const value = resolved(document, image.dict.get(key("Filter")));
+	if (!value) return "none";
+	if (value instanceof PDFArray) refuse("image filter chain", "no filter, FlateDecode, or DCTDecode");
+	const name = nameOf(value);
+	if (name === "FlateDecode" || name === "Fl") return "flate";
+	if (name === "DCTDecode" || name === "DCT") return "jpeg";
+	return refuse(`image filter ${name ?? "other"}`, "no filter, FlateDecode, or DCTDecode");
+}
+function inflate(bytes, structure, maximum) {
+	try {
+		return inflateSync(bytes, maximum === void 0 ? void 0 : { maxOutputLength: maximum });
+	} catch (error) {
+		if (maximum !== void 0 && error instanceof Error && "code" in error && error.code === "ERR_BUFFER_TOO_LARGE") return refuse(`${structure} data length greater than ${maximum}`, `${maximum} bytes`);
+		return refuse(`${structure} FlateDecode data`, "valid FlateDecode data");
+	}
+}
+const paeth = (left, above, upperLeft) => {
+	const estimate = left + above - upperLeft;
+	const leftDistance = Math.abs(estimate - left);
+	const aboveDistance = Math.abs(estimate - above);
+	const upperLeftDistance = Math.abs(estimate - upperLeft);
+	return leftDistance <= aboveDistance && leftDistance <= upperLeftDistance ? left : aboveDistance <= upperLeftDistance ? above : upperLeft;
+};
+const predictorAddition = (filter, left, above, upperLeft) => {
+	if (filter === 1) return left;
+	if (filter === 2) return above;
+	if (filter === 3) return Math.floor((left + above) / 2);
+	if (filter === 4) return paeth(left, above, upperLeft);
+	return 0;
+};
+function undoPngPredictor(bytes, width, height, colors, bits) {
+	const rowBytes = Math.ceil(width * colors * bits / 8);
+	const pixelBytes = Math.max(1, Math.ceil(colors * bits / 8));
+	if (bytes.length !== (rowBytes + 1) * height) refuse(`image predictor data length ${bytes.length}`, `${height} rows of ${rowBytes + 1} bytes`);
+	const output = new Uint8Array(rowBytes * height);
+	let source = 0;
+	for (let row = 0; row < height; row++) {
+		const filter = bytes[source++] ?? 0;
+		if (filter > 4) refuse(`image PNG predictor filter ${filter}`, "filters 0 through 4");
+		const target = row * rowBytes;
+		for (let column = 0; column < rowBytes; column++) {
+			const raw = bytes[source++] ?? 0;
+			const left = output[target + column - pixelBytes] ?? 0;
+			const above = output[target + column - rowBytes] ?? 0;
+			const upperLeft = output[target + column - rowBytes - pixelBytes] ?? 0;
+			const add = predictorAddition(filter, left, above, upperLeft);
+			output[target + column] = raw + add & 255;
+		}
+	}
+	return output;
+}
+function decodeFlate(state, image, width, height, channels, bits) {
+	const rawParms = resolved(state.document, image.dict.get(key("DecodeParms")));
+	const rowBytes = Math.ceil(width * channels * bits / 8);
+	if (!rawParms) return inflate(image.contents, "image", rowBytes * height);
+	if (!(rawParms instanceof PDFDict)) refuse("image DecodeParms", "no DecodeParms or a PNG predictor 10 through 15");
+	const parms = rawParms;
+	const predictor = numberOf(parms, "Predictor") ?? 1;
+	if (predictor < 10 || predictor > 15) refuse(`image predictor ${predictor}`, "a PNG predictor 10 through 15");
+	const colors = numberOf(parms, "Colors") ?? 1;
+	const columns = numberOf(parms, "Columns") ?? 1;
+	const predictorBits = numberOf(parms, "BitsPerComponent") ?? 8;
+	if (columns !== width || colors !== channels || predictorBits !== bits) refuse("image PNG predictor parameters", `Colors ${channels}, Columns ${width}, and BitsPerComponent ${bits}`);
+	const expected = (rowBytes + 1) * height;
+	return undoPngPredictor(inflate(image.contents, "image predictor", expected), width, height, colors, predictorBits);
+}
+function isDefaultDecode(image, channels, bits, indexed) {
+	const decode = image.dict.lookupMaybe(key("Decode"), PDFArray);
+	if (!decode) return true;
+	if (decode.size() !== channels * 2) return false;
+	const high = 2 ** bits - 1;
+	for (let channel = 0; channel < channels; channel++) {
+		const lowValue = decode.lookupMaybe(channel * 2, PDFNumber)?.asNumber();
+		const highValue = decode.lookupMaybe(channel * 2 + 1, PDFNumber)?.asNumber();
+		if (lowValue !== 0 || highValue !== (indexed ? high : 1)) return false;
+	}
+	return true;
+}
+function grayTable(profile) {
+	const table = /* @__PURE__ */ new Uint8Array(256);
+	for (let value = 0; value < 256; value++) table[value] = Math.round(destinationColor(profile, [
+		value / 255,
+		value / 255,
+		value / 255
+	], 0)[0] * 255);
+	return table;
+}
+function buildGrayImageLookup(profile, size = 33) {
+	const table = new Uint8Array(size ** 3);
+	const at = (red, green, blue) => (red * size + green) * size + blue;
+	for (let red = 0; red < size; red++) for (let green = 0; green < size; green++) for (let blue = 0; blue < size; blue++) {
+		const value = destinationColor(profile, [
+			red / (size - 1),
+			green / (size - 1),
+			blue / (size - 1)
+		], 0)[0];
+		table[at(red, green, blue)] = Math.round(Math.max(0, Math.min(1, value)) * 255);
+	}
+	return (red, green, blue) => {
+		const scale = (size - 1) / 255;
+		const r = red * scale, g = green * scale, b = blue * scale;
+		const r0 = Math.floor(r), g0 = Math.floor(g), b0 = Math.floor(b);
+		const r1 = Math.min(size - 1, r0 + 1), g1 = Math.min(size - 1, g0 + 1), b1 = Math.min(size - 1, b0 + 1);
+		const rf = r - r0, gf = g - g0, bf = b - b0;
+		const mix = (first, second, amount) => first + (second - first) * amount;
+		const low = mix(mix(table[at(r0, g0, b0)] ?? 0, table[at(r1, g0, b0)] ?? 0, rf), mix(table[at(r0, g1, b0)] ?? 0, table[at(r1, g1, b0)] ?? 0, rf), gf);
+		const high = mix(mix(table[at(r0, g0, b1)] ?? 0, table[at(r1, g0, b1)] ?? 0, rf), mix(table[at(r0, g1, b1)] ?? 0, table[at(r1, g1, b1)] ?? 0, rf), gf);
+		return Math.round(mix(low, high, bf));
+	};
+}
+function streamDictionary(stream) {
+	const dictionary = { Filter: key("FlateDecode") };
+	for (const [name, value] of stream.dict.entries()) {
+		const label = name.toString().slice(1);
+		if (![
+			"Filter",
+			"DecodeParms",
+			"Length",
+			"ColorSpace",
+			"BitsPerComponent",
+			"Decode"
+		].includes(label)) dictionary[label] = value;
+	}
+	return dictionary;
+}
+function profileRgb(state, source, space, mask, pixels) {
+	const expected = pixels * space.channels;
+	if (source.length !== expected) refuse(`image sample length ${source.length}`, `${expected} bytes for its dimensions and color space`);
+	const output = new Uint8Array(pixels);
+	for (let pixel = 0; pixel < pixels; pixel++) {
+		const first = source[pixel * space.channels] ?? 0;
+		const red = first, green = space.channels === 1 ? first : source[pixel * 3 + 1] ?? 0, blue = space.channels === 1 ? first : source[pixel * 3 + 2] ?? 0;
+		output[pixel] = mask === "none" ? space.kind === "gray" ? state.grayLookup[first] ?? 0 : state.rgbLookup(red, green, blue) : Math.round(pdfMaskLuminosity([
+			red / 255,
+			green / 255,
+			blue / 255
+		])[0] * 255);
+	}
+	return output;
+}
+function paletteToGray(state, space, mask) {
+	const count = space.high + 1;
+	const expected = count * space.base.channels;
+	if (!Number.isInteger(space.high) || space.high < 0 || space.high > 255 || space.lookup.length < expected) refuse(`Indexed image lookup length ${space.lookup.length}`, `${expected} bytes for entries 0 through ${space.high}`);
+	return profileRgb(state, space.lookup.subarray(0, expected), space.base, mask, count);
+}
+async function sourceBytes(state, image, filter, width, height, channels, bits) {
+	if (filter === "none") return image.contents;
+	if (filter === "flate") return decodeFlate(state, image, width, height, channels, bits);
+	if (!state.decodeJpeg) refuse("DCTDecode image without a JPEG decoder", "a JPEG needs the renderer's decoder");
+	const decoder = state.decodeJpeg;
+	const decoded = await decodeJpeg(decoder, image.contents);
+	if (decoded.width !== width || decoded.height !== height) refuse(`decoded JPEG dimensions ${decoded.width}x${decoded.height}`, `the image Width and Height ${width}x${height}`);
+	if (decoded.rgb.length !== width * height * 3) refuse(`decoded JPEG sample length ${decoded.rgb.length}`, `${width * height * 3} RGB bytes`);
+	return decoded.rgb;
+}
+async function decodeJpeg(decoder, bytes) {
+	try {
+		return await decoder(bytes);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return refuse(`JPEG decoding failure: ${message}`, "a JPEG the renderer's browser can decode");
+	}
+}
+function createImageState(document, profile, decodeJpeg) {
+	return {
+		counted: /* @__PURE__ */ new WeakSet(),
+		converted: /* @__PURE__ */ new WeakMap(),
+		decodeJpeg,
+		document,
+		profile,
+		rgbLookup: buildGrayImageLookup(profile),
+		grayLookup: grayTable(profile),
+		pixels: 0,
+		total: 0
+	};
+}
+function countSuppliedImage(state, image, mask) {
+	if (mask !== "none" || state.counted.has(image)) return;
+	state.counted.add(image);
+	state.total++;
+}
+function imageGeometry(image) {
+	const width = numberOf(image.dict, "Width") ?? refuse("image Width missing", "a positive Width number");
+	const height = numberOf(image.dict, "Height") ?? refuse("image Height missing", "a positive Height number");
+	if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) refuse(`image dimensions ${width}x${height}`, "positive integer Width and Height");
+	const pixels = width * height;
+	if (pixels > 5e7) refuse(`image pixel count ${pixels}`, `at most ${MAX_IMAGE_PIXELS} pixels in one image`);
+	return {
+		height,
+		pixels,
+		width
+	};
+}
+function chargePixels(state, pixels) {
+	state.pixels += pixels;
+	if (state.pixels > 4e8) refuse(`total image pixel count ${state.pixels}`, `at most ${MAX_TOTAL_IMAGE_PIXELS} pixels in one render`);
+}
+async function convertSuppliedImage(state, image, mask) {
+	const context = mask === "none" ? "profile" : "luminosity";
+	const variants = state.converted.get(image);
+	const existing = variants?.[context];
+	if (existing) {
+		countSuppliedImage(state, image, mask);
+		return existing;
+	}
+	if (image.dict.has(key("SegnaviaGeneratedEffect")) || image.dict.get(key("ImageMask"))?.toString() === "true") return void 0;
+	const { width, height, pixels } = imageGeometry(image);
+	chargePixels(state, pixels);
+	const space = imageSpace(state.document, image.dict.get(key("ColorSpace")));
+	const bits = numberOf(image.dict, "BitsPerComponent");
+	const allowedBits = space.kind === "indexed" ? [
+		1,
+		2,
+		4,
+		8
+	] : [8];
+	if (bits === void 0 || !allowedBits.includes(bits)) refuse(`image BitsPerComponent ${bits ?? "missing"}`, allowedBits.join(", "));
+	const componentBits = bits;
+	const channels = space.kind === "indexed" ? 1 : space.channels;
+	if (!isDefaultDecode(image, channels, componentBits, space.kind === "indexed")) refuse("image Decode array", "the default Decode array");
+	const filter = filterName(state.document, image);
+	if (space.kind === "indexed" && filter === "jpeg") refuse("Indexed image filter DCTDecode", "no filter or FlateDecode");
+	const source = await sourceBytes(state, image, filter, width, height, filter === "jpeg" ? 3 : channels, componentBits);
+	const dictionary = streamDictionary(image);
+	let output;
+	if (space.kind === "indexed") {
+		const expected = Math.ceil(width * componentBits / 8) * height;
+		if (source.length !== expected) refuse(`Indexed image sample length ${source.length}`, `${expected} bytes for its dimensions`);
+		output = source;
+		const palette = paletteToGray(state, space, mask);
+		dictionary.ColorSpace = state.document.context.obj([
+			"Indexed",
+			"DeviceGray",
+			space.high,
+			PDFHexString.of(Buffer.from(palette).toString("hex"))
+		]);
+		dictionary.BitsPerComponent = state.document.context.obj(componentBits);
+	} else {
+		output = profileRgb(state, source, filter === "jpeg" ? {
+			channels: 3,
+			kind: "rgb",
+			label: "decoded JPEG"
+		} : space, mask, pixels);
+		dictionary.ColorSpace = key("DeviceGray");
+		dictionary.BitsPerComponent = state.document.context.obj(8);
+	}
+	const replacement = state.document.context.stream(deflateSync(output), dictionary);
+	state.converted.set(image, {
+		...variants,
+		[context]: replacement
+	});
+	countSuppliedImage(state, image, mask);
+	return replacement;
+}
+const convertedImageCount = (state) => state.total;
+//#endregion
+export { MAX_IMAGE_PIXELS, MAX_TOTAL_IMAGE_PIXELS, buildGrayImageLookup, convertSuppliedImage, convertedImageCount, createImageState };

package/dist/press/policy.js

@@ -39,23 +39,29 @@ function contentFilter(names) {
 		encoding: "unsupported"
 	};
 }
-function groupAction(kind, label, maskSource) {
+function groupAction(kind, label, maskSource, destination = "cmyk") {
+	if (destination === "gray") {
+		const supported = "DeviceGray, DeviceRGB, or no declared space";
+		if (kind === "gray") return decision("keep", supported);
+		if (label === "missing" || label === "DeviceRGB") return decision("convert", supported);
+		return decision("refuse", supported);
+	}
 	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) {
+function shadingAction(kind, type, functionType, destination = "cmyk") {
 	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 === destination) 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);
+	if (kind === destination) return decision("keep", supported);
 	return decision("refuse", supported);
 }
 function shadingFunctionAction(type, dictionary, functions) {
@@ -96,8 +102,10 @@ function inlineImageAction(name, imageMask) {
 		label: colorSpaceLabel(value)
 	};
 }
-function contentColorSpaceAction(name) {
-	return decision(name === "Pattern" || name === "DeviceCMYK" ? "keep" : "refuse", "Pattern or DeviceCMYK");
+function contentColorSpaceAction(name, destination = "cmyk") {
+	const device = destination === "gray" ? "DeviceGray" : "DeviceCMYK";
+	const supported = `Pattern or ${device}`;
+	return decision(name === "Pattern" || name === device ? "keep" : "refuse", supported);
 }
 const colorOperators = [
 	"rg",
@@ -116,10 +124,19 @@ const colorOperators = [
 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);
+function deviceColorAction(operator, inspect, destination) {
+	const rgb = operator === "rg" || operator === "RG";
+	const gray = operator === "g" || operator === "G";
+	const cmyk = operator === "k" || operator === "K";
+	if (!rgb && !gray && !cmyk) return void 0;
+	if (!inspect && (rgb || gray)) return decision("convert", "RGB or DeviceGray color operands");
+	if (destination === "gray") return decision(gray ? "keep" : "refuse", "RGB or gray input for a greyscale press");
+	return decision(cmyk ? "keep" : "refuse", "CMYK operators");
+}
+function contentOperatorAction(operator, inspect, selectedSpace, patternName = false, destination = "cmyk") {
+	const device = deviceColorAction(operator, inspect, destination);
+	if (device) return device;
+	if (operator === "cs" || operator === "CS") return contentColorSpaceAction(selectedSpace, destination);
 	return decision((operator === "scn" || operator === "SCN") && patternName ? "keep" : "refuse", "a pattern name with scn or SCN");
 }
 //#endregion

package/dist/press/report.js

@@ -1,9 +1,9 @@
 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 { decodeContent, dictionaryOf, nameOf, numberOf, rawStreamOf, resolvedColorSpace } from "./pdf-objects.js";
 import { walkPressGraph } from "./visitor.js";
-import { PDFDict, PDFDocument, PDFName, PDFRef } from "pdf-lib";
+import { PDFArray, PDFDict, PDFDocument, PDFName, PDFRef } from "pdf-lib";
 //#region src/press/report.ts
 const key = (name) => PDFName.of(name);
 const refuse = (found, supported) => {
@@ -15,6 +15,7 @@ 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 (state.report.destination === "gray" && (space.kind === "rgb" || space.kind === "cmyk")) refuse(`image color space ${space.label}`, "DeviceGray or Indexed over DeviceGray");
 	if (space.kind !== "rgb") return;
 	const width = requiredDimension(numberOf(image.dict, "Width"), "Width");
 	const height = requiredDimension(numberOf(image.dict, "Height"), "Height");
@@ -24,18 +25,19 @@ function inspectImage(state, image) {
 		colorSpace: space.label
 	});
 }
-function inspectFunction(state, fn, policy) {
+function inspectFunction(state, fn, policy, _mask) {
 	if (policy.action === "refuse") refuse(policy.found, policy.supported);
 	if (fn && numberOf(fn, "FunctionType") === 2) state.report.gradientStops += 2;
 }
-function inspectShading(state, shading) {
+function inspectShading(state, shading, _mask) {
 	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);
+	const destination = state.report.destination;
+	const policy = shadingAction(space.kind, type, functionType, destination);
 	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);
@@ -46,24 +48,33 @@ function inspectShading(state, shading) {
 	}
 	return true;
 }
-function inspectGroup(state, owner, maskSource) {
+function inspectGroup(state, owner, mask) {
 	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);
+	const destination = state.report.destination;
+	const policy = groupAction(space.kind, space.label, mask !== "none", destination);
 	if (policy.action !== "keep") refuse(`transparency group color space ${space.label}`, policy.supported);
-	if (space.kind === "cmyk") state.report.groups++;
+	if (space.kind === destination) state.report.groups++;
 }
-async function inspectPressPdf(bytes) {
+function outputDestination(document) {
+	const intent = document.catalog.lookupMaybe(key("OutputIntents"), PDFArray)?.lookup(0, PDFDict);
+	const profile = rawStreamOf(intent?.get(key("DestOutputProfile")) ? document.context.lookup(intent.get(key("DestOutputProfile"))) : void 0);
+	return profile && numberOf(profile.dict, "N") === 1 ? "gray" : "cmyk";
+}
+async function inspectPressPdf(bytes, requested) {
 	const document = await PDFDocument.load(bytes, { updateMetadata: false });
+	const destination = requested ?? outputDestination(document);
 	const state = {
 		budget: { decodedBytes: 0 },
 		document,
 		groups: /* @__PURE__ */ new WeakSet(),
 		images: /* @__PURE__ */ new WeakSet(),
 		report: {
+			destination,
 			images: [],
+			convertedImages: 0,
 			fills: 0,
 			strokes: 0,
 			gradientStops: 0,
@@ -75,14 +86,14 @@ async function inspectPressPdf(bytes) {
 	};
 	walkPressGraph(document, {
 		content: (_object, stream) => {
-			const counts = inspectContent(decodeContent(stream, state.budget));
+			const counts = inspectContent(decodeContent(stream, state.budget), destination);
 			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),
+		function: (fn, decision, mask) => inspectFunction(state, fn, decision, mask),
+		group: (owner, _stream, mask) => inspectGroup(state, owner, mask),
 		image: (image) => inspectImage(state, image),
-		shading: (shading) => inspectShading(state, shading)
+		shading: (shading, _pattern, mask) => inspectShading(state, shading, mask)
 	});
 	return state.report;
 }

package/dist/press/sample-shading.js

@@ -10,7 +10,6 @@ const MAX_SHADING_SAMPLES = 1048576;
 const MAX_DOCUMENT_SHADING_SAMPLES = 4 * MAX_SHADING_SAMPLES;
 const MAX_DOCUMENT_CALCULATOR_OPERATIONS = 8 * MAX_SHADING_SAMPLES * 52;
 const MAX_SAMPLING_COLOR_CACHE = 4096;
-const SAMPLE_CHANNELS = 4;
 const SAMPLE_BYTES = 1;
 function refuse(found, supported) {
 	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
@@ -186,12 +185,12 @@ function domainValue(min, max, index, size) {
 	if (size <= 1) return min;
 	return min + (max - min) * index / (size - 1);
 }
-function sampleShadingToCmyk(program, domain, size, convert) {
+function sampleShading(program, domain, size, convert, channels) {
 	const x0 = domain[0] ?? 0;
 	const x1 = domain[1] ?? 0;
 	const y0 = domain[2] ?? 0;
 	const y1 = domain[3] ?? 0;
-	const samples = new Uint8Array(size.n * size.m * SAMPLE_CHANNELS * SAMPLE_BYTES);
+	const samples = new Uint8Array(size.n * size.m * channels * SAMPLE_BYTES);
 	const toCmyk = createSamplingColorConverter(convert).convert;
 	let offset = 0;
 	for (let j = 0; j < size.m; j++) {
@@ -213,8 +212,8 @@ function sampleShadingToCmyk(program, domain, size, convert) {
 	}
 	return samples;
 }
-function chargeShadingSamples(budget, samples, operations) {
-	const bytes = samples * SAMPLE_CHANNELS * SAMPLE_BYTES;
+function chargeShadingSamples(budget, samples, operations, channels = 4) {
+	const bytes = samples * channels * SAMPLE_BYTES;
 	if (!Number.isFinite(samples) || samples < 0 || !Number.isFinite(bytes) || bytes < 0) refuse(`document shading samples ${samples}`, "a finite non-negative sample count and byte charge");
 	if (!Number.isFinite(operations) || operations < 0) refuse(`document calculator operations ${operations}`, "a finite non-negative operator count");
 	const totalSamples = (budget.shadingSamples ?? 0) + samples;
@@ -228,7 +227,7 @@ function chargeShadingSamples(budget, samples, operations) {
 	budget.calculatorOperations = totalOperations;
 }
 const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
-function replaceType1Function(document, shading, pattern, convert, budget, painted, sampleDomain, sampleSize) {
+function replaceType1Function(document, shading, pattern, convert, budget, painted, sampleDomain, sampleSize, channels = 4) {
 	const existing = shading.get(PDFName.of("Function"));
 	const stream = rawStreamOf(resolved(document, existing));
 	if (!stream) return refuse("shading FunctionType 4 stream", "a FunctionType 4 stream");
@@ -239,21 +238,12 @@ function replaceType1Function(document, shading, pattern, convert, budget, paint
 	const size = sampleSize ?? shadingSampleGrid(domain, matrix);
 	const program = parseCalculator(new TextDecoder("latin1").decode(decodeContent(stream, budget)));
 	const samples = size.n * size.m;
-	chargeShadingSamples(budget, samples, samples * staticOperatorCount(program));
-	const data = sampleShadingToCmyk(program, domain, size, convert);
+	chargeShadingSamples(budget, samples, samples * staticOperatorCount(program), channels);
+	const data = sampleShading(program, domain, size, convert, channels);
 	const replacement = document.context.stream(deflateSync(data), {
 		FunctionType: 0,
 		Domain: domain,
-		Range: [
-			0,
-			1,
-			0,
-			1,
-			0,
-			1,
-			0,
-			1
-		],
+		Range: Array.from({ length: channels }, () => [0, 1]).flat(),
 		Size: [size.n, size.m],
 		BitsPerSample: 8,
 		Order: 1,
@@ -263,4 +253,4 @@ function replaceType1Function(document, shading, pattern, convert, budget, paint
 	return size;
 }
 //#endregion
-export { MAX_DOCUMENT_CALCULATOR_OPERATIONS, MAX_DOCUMENT_SHADING_SAMPLES, MAX_SAMPLING_COLOR_CACHE, MAX_SHADING_SAMPLES, SHADING_SAMPLE_SPACING_PT, chargeShadingSamples, createSamplingColorConverter, domainValue, matrixOf, packedRgb8, replaceType1Function, sampleDomainForPainted, sampleDomainForUses, sampleShadingToCmyk, shadingDeviceMatrix, shadingDomainOf, shadingSampleGrid, shadingSampleGridForUses, unionSampleDomain, unpackRgb8 };
+export { MAX_DOCUMENT_CALCULATOR_OPERATIONS, MAX_DOCUMENT_SHADING_SAMPLES, MAX_SAMPLING_COLOR_CACHE, MAX_SHADING_SAMPLES, SHADING_SAMPLE_SPACING_PT, chargeShadingSamples, createSamplingColorConverter, domainValue, matrixOf, packedRgb8, replaceType1Function, sampleDomainForPainted, sampleDomainForUses, sampleShading, shadingDeviceMatrix, shadingDomainOf, shadingSampleGrid, shadingSampleGridForUses, unionSampleDomain, unpackRgb8 };

package/dist/press/types.d.ts

@@ -4,14 +4,19 @@ export interface PressImage {
   height: number;
   colorSpace: 'DeviceRGB' | 'CalRGB' | 'ICCBased' | 'Indexed';
 }
+export type PressDestination = 'cmyk' | 'gray';
 export interface PressReport {
+  /** Device color space written for press-ready vector and generated-image output. */
+  destination: PressDestination;
   /** Authored raster images left in RGB, read back from the finished PDF. */
   images: PressImage[];
-  /** CMYK painting and group counts read back from the finished PDF. */
+  /** Supplied raster image objects converted to DeviceGray. */
+  convertedImages: number;
+  /** Destination-space painting and group counts read back from the finished PDF. */
   fills: number;
   strokes: number;
   gradientStops: number;
-  /** Function-based shadings rewritten as DeviceCMYK sampled functions. */
+  /** Function-based shadings rewritten as sampled functions in the destination space. */
   sampledShadings: number;
   groups: number;
   /** Color conversions snapped to black ink by the configured tolerance but not by the exact-neutral rule. */