@segnavia/render 0.4.0 → 0.6.0

package/dist/press/color-policy.js

@@ -1,31 +1,50 @@
-import { toPress } from "../color/engine.js";
+import { RenderRefusedError } from "../errors.js";
+import { toGray, toPress } from "../color/engine.js";
 //#region src/press/color-policy.ts
 const NEUTRAL_TOLERANCE = .001;
-function pressColor(profile, rgb) {
+function pressDestination(profile) {
+	return profile.colorSpace === "GRAY" ? "gray" : "cmyk";
+}
+function pdfMaskLuminosity([red, green, blue]) {
+	return [.3 * red + .59 * green + .11 * blue];
+}
+function assertNeutralTolerance(value) {
+	if (!Number.isFinite(value) || value < 0 || value > 255) throw new RenderRefusedError(`The press neutral tolerance is ${String(value)}; supported: a finite number from 0 to 255.`);
+}
+function snapsToNeutral(rgb, tolerance) {
+	return Math.max(...rgb) - Math.min(...rgb) <= Math.max(NEUTRAL_TOLERANCE, tolerance / 255) + Number.EPSILON;
+}
+function newlySnapsToNeutral(rgb, tolerance) {
+	return snapsToNeutral(rgb, tolerance) && !snapsToNeutral(rgb, 0);
+}
+function pressColor(profile, rgb, tolerance = 3) {
 	const [red, green, blue] = rgb;
-	if (Math.max(red, green, blue) - Math.min(red, green, blue) <= NEUTRAL_TOLERANCE) return [
+	if (snapsToNeutral(rgb, tolerance)) return [
 		0,
 		0,
 		0,
-		1 - red
+		1 - (red === green && green === blue ? red : (red + green + blue) / 3)
 	];
 	return toPress(profile, rgb);
 }
+function destinationColor(profile, rgb, tolerance = 3) {
+	return profile.colorSpace === "GRAY" ? toGray(profile, rgb) : pressColor(profile, rgb, tolerance);
+}
 function formatPdfNumber(value) {
 	const rounded = Math.round(value * 1e6) / 1e6;
 	if (Object.is(rounded, -0)) return "0";
 	return rounded.toFixed(6).replace(/(?:\.0+|(?<=\.[0-9]*?)0+)$/, "");
 }
-function cachedPressColor(profile) {
+function cachedPressColor(profile, tolerance = 3) {
 	const cache = /* @__PURE__ */ new Map();
 	return (rgb) => {
-		const key = rgb.join(",");
+		const key = `${tolerance}:${rgb.join(",")}`;
 		const cached = cache.get(key);
 		if (cached) return cached;
-		const converted = pressColor(profile, rgb);
+		const converted = destinationColor(profile, rgb, tolerance);
 		cache.set(key, converted);
 		return converted;
 	};
 }
 //#endregion
-export { cachedPressColor, formatPdfNumber, pressColor };
+export { assertNeutralTolerance, cachedPressColor, destinationColor, formatPdfNumber, newlySnapsToNeutral, pdfMaskLuminosity, pressColor, pressDestination, snapsToNeutral };

package/dist/press/content.js

@@ -120,7 +120,7 @@ function inlineHeader(source, at) {
 	}
 	return refusal("truncated BI operator", "an ID and EI pair");
 }
-function inlineImageEnd(source, at) {
+function inlineImageEnd(source, at, destination) {
 	const { colorSpace, id, imageMask } = inlineHeader(source, at);
 	const match = /[\0\t\n\f\r ]EI(?=[\0\t\n\f\r ()<>[\]{}/%]|$)/g;
 	match.lastIndex = id;
@@ -129,6 +129,7 @@ function inlineImageEnd(source, at) {
 	const name = colorSpace?.startsWith("/") ? colorSpace.slice(1) : void 0;
 	const policy = inlineImageAction(name, imageMask);
 	if (policy.action === "refuse") refusal(`BI operator with color space ${policy.label}`, policy.supported);
+	if (destination === "gray" && policy.kind === "cmyk") refusal(`BI operator with color space ${policy.label}`, "RGB or gray input for a greyscale press");
 	return end.index + end[0].length;
 }
 function skippedConstruct(source, cursor) {
@@ -144,7 +145,7 @@ function numeric(operands, count, operator) {
 	return operands.map((token) => Number(token.raw));
 }
 function replacement(token, operands, values) {
-	const operator = token.raw === "rg" || token.raw === "g" ? "k" : "K";
+	const operator = values.length === 1 ? token.raw === token.raw.toLowerCase() ? "g" : "G" : token.raw === token.raw.toLowerCase() ? "k" : "K";
 	return {
 		start: operands[0]?.start ?? token.start,
 		end: token.end,
@@ -169,36 +170,43 @@ function replaceGray(token, operands, convert, counts) {
 		gray
 	]));
 }
-function validateSpace(token, operands) {
+function validateSpace(token, operands, destination) {
 	if (operands.length !== 1 || operands[0]?.kind !== "name") refusal(`${token.raw} operator operands`, "one color space name");
 	const name = operands[0].raw.slice(1);
-	const policy = contentOperatorAction(token.raw, false, name);
+	const policy = contentOperatorAction(token.raw, false, name, false, destination);
 	if (policy.action === "refuse") refusal(`${token.raw} operator selecting ${colorSpaceLabel({ name })}`, policy.supported);
 }
-function enforceOperatorPolicy(token, operands, policy) {
+function enforceOperatorPolicy(token, operands, policy, destination) {
 	if (policy.action !== "refuse") return;
 	const operator = token.raw;
 	if (operator === "cs" || operator === "CS") {
-		validateSpace(token, operands);
+		validateSpace(token, operands, destination);
 		return;
 	}
 	if (operator === "sc" || operator === "SC" || operator === "scn" || operator === "SCN") refusal(`${operator} operator with numeric operands`, policy.supported);
-	refusal(`${operator === "g" || operator === "G" ? "gray" : "RGB"} color operator ${operator} after conversion`, policy.supported);
+	refusal(`${operator === "g" || operator === "G" ? "gray" : operator === "k" || operator === "K" ? "CMYK" : "RGB"} color operator ${operator} after conversion`, policy.supported);
 }
-function colorOperator(token, operands, convert, counts, inspect) {
+function colorOperator(token, operands, convert, counts, inspect, destination) {
 	const operator = token.raw;
 	if (!isContentColorOperator(operator)) return void 0;
 	const patternName = operands.length === 1 && operands[0]?.kind === "name";
-	enforceOperatorPolicy(token, operands, contentOperatorAction(operator, inspect, void 0, patternName));
+	enforceOperatorPolicy(token, operands, contentOperatorAction(operator, inspect, void 0, patternName, destination), destination);
 	if (operator === "rg" || operator === "RG") return replaceRgb(token, operands, convert, counts);
-	if (operator === "g" || operator === "G") return replaceGray(token, operands, convert, counts);
-	if (operator === "cs" || operator === "CS") validateSpace(token, operands);
+	if (operator === "g" || operator === "G") {
+		if (inspect && destination === "gray") {
+			numeric(operands, 1, operator);
+			counts[operator === "g" ? "fills" : "strokes"]++;
+			return;
+		}
+		return replaceGray(token, operands, convert, counts);
+	}
+	if (operator === "cs" || operator === "CS") validateSpace(token, operands, destination);
 	else if (operator === "k" || operator === "K") {
 		numeric(operands, 4, operator);
 		counts[operator === "k" ? "fills" : "strokes"]++;
 	}
 }
-function scan(source, convert, inspect, visit, operatorVisit) {
+function scan(source, convert, inspect, destination, visit, operatorVisit) {
 	const counts = {
 		fills: 0,
 		strokes: 0
@@ -218,11 +226,11 @@ function scan(source, convert, inspect, visit, operatorVisit) {
 		}
 		cursor = token.end;
 		if (token.raw === "BI") {
-			cursor = inlineImageEnd(source, cursor);
+			cursor = inlineImageEnd(source, cursor, destination);
 			operands = [];
 		} else if (token.kind === "operator") {
 			operatorVisit?.(token, operands);
-			const found = colorOperator(token, operands, convert, counts, inspect);
+			const found = colorOperator(token, operands, convert, counts, inspect, destination);
 			if (found) visit?.(found);
 			operands = [];
 		} else {
@@ -241,7 +249,7 @@ function visitContentOperations(bytes, visit) {
 		0,
 		0,
 		0
-	], false, void 0, (operator, operands) => {
+	], false, "cmyk", void 0, (operator, operands) => {
 		visit({
 			end: operator.end,
 			operands: operands.flatMap((operand) => operand.kind === "name" || operand.kind === "number" ? [{
@@ -255,14 +263,14 @@ function visitContentOperations(bytes, visit) {
 		});
 	});
 }
-function inspectContent(bytes) {
-	return scan(decoder.decode(bytes), () => refusal("RGB color operator after conversion", "CMYK operators"), true);
+function inspectContent(bytes, destination = "cmyk") {
+	return scan(decoder.decode(bytes), () => refusal("RGB color operator after conversion", `${destination === "gray" ? "gray" : "CMYK"} operators`), true, destination);
 }
-function rewriteContent(bytes, convert) {
+function rewriteContent(bytes, convert, destination = "cmyk") {
 	const source = decoder.decode(bytes);
 	let outputLength = bytes.length;
 	let changed = false;
-	const counts = scan(source, convert, false, (found) => {
+	const counts = scan(source, convert, false, destination, (found) => {
 		changed = true;
 		outputLength += encoder.encode(found.text).length - (found.end - found.start);
 	});
@@ -273,7 +281,7 @@ function rewriteContent(bytes, convert) {
 	const output = new Uint8Array(outputLength);
 	let inputAt = 0;
 	let outputAt = 0;
-	scan(source, convert, false, (found) => {
+	scan(source, convert, false, destination, (found) => {
 		const untouched = bytes.subarray(inputAt, found.start);
 		output.set(untouched, outputAt);
 		outputAt += untouched.length;

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