@segnavia/render 0.4.0 → 0.6.0

package/dist/color/tables.js

@@ -1,7 +1,7 @@
 import { REVERSE_LUT, checked, clamp, refuse } from "./types.js";
 import { invert3, matrix3 } from "./spaces.js";
 import { align4, fixed, need, signature, u16, u32 } from "./binary.js";
-import { interpolate, matrixInput, multilinear, tetrahedral4 } from "./interpolation.js";
+import { interpolate, linearGrid, matrixInput, multilinear, tetrahedral4 } from "./interpolation.js";
 //#region src/color/tables.ts
 function packed(bytes, view, offset, length, width, bounds) {
 	need(offset, length * width, bounds);
@@ -73,6 +73,16 @@ function parseCurve(bytes, view, offset, bounds) {
 		size: 12 + count * 4
 	};
 }
+function invertCurve(curve, target) {
+	let low = 0, high = 1;
+	const descending = curve(0) > curve(1);
+	for (let index = 0; index < 24; index++) {
+		const middle = (low + high) / 2;
+		if (descending ? curve(middle) > target : curve(middle) < target) low = middle;
+		else high = middle;
+	}
+	return (low + high) / 2;
+}
 function curvesAt(bytes, view, offset, count, bounds) {
 	const curves = [];
 	let cursor = offset;
@@ -132,7 +142,7 @@ function parseMft(bytes, view, record, type, inputs, outputs) {
 				];
 				current = matrix3(fixedMatrix, matrixInput(current));
 			}
-			current = inputs === 3 ? multilinear(grid, points, outputs, current) : tetrahedral4(grid, points, outputs, current);
+			current = inputs === 1 ? linearGrid(grid, points, outputs, current) : inputs === 3 ? multilinear(grid, points, outputs, current) : tetrahedral4(grid, points, outputs, current);
 			return current.map((value, channel) => interpolate(checked(outputTables, channel, `${type} output tables`), value));
 		}
 	};
@@ -179,7 +189,7 @@ function parseMab(bytes, view, record, type, inputs, outputs) {
 			2
 		].map((row) => checked(matrix, row * 3, `${type} matrix`) * x + checked(matrix, row * 3 + 1, `${type} matrix`) * y + checked(matrix, row * 3 + 2, `${type} matrix`) * z + checked(matrix, 9 + row, `${type} matrix`));
 	};
-	const clut = (values) => !grid ? [...values] : inputs === 3 ? multilinear(grid, points, outputs, values) : tetrahedral4(grid, points, outputs, values);
+	const clut = (values) => !grid ? [...values] : inputs === 1 ? linearGrid(grid, points, outputs, values) : inputs === 3 ? multilinear(grid, points, outputs, values) : tetrahedral4(grid, points, outputs, values);
 	return {
 		inputChannels: inputs,
 		outputChannels: outputs,
@@ -227,15 +237,6 @@ function matrixTables(bytes, view, records) {
 		checked(checked(columns, 2, "colorants"), 2, "blue")
 	];
 	const inverse = invert3(matrix);
-	const invertCurve = (curve, target) => {
-		let low = 0, high = 1;
-		for (let index = 0; index < 24; index++) {
-			const middle = (low + high) / 2;
-			if (curve(middle) < target) low = middle;
-			else high = middle;
-		}
-		return (low + high) / 2;
-	};
 	return {
 		a2b: {
 			inputChannels: 3,
@@ -251,5 +252,38 @@ function matrixTables(bytes, view, records) {
 		}
 	};
 }
+function grayTables(bytes, view, record, pcs) {
+	const curve = parseCurve(bytes, view, record.offset, record).curve;
+	const scale = 32768 / 65535;
+	return {
+		a2b: {
+			inputChannels: 1,
+			outputChannels: 3,
+			encoding: "mAB ",
+			run(input) {
+				const luminance = curve(checked(input, 0, "gray input"));
+				if (pcs === "XYZ ") return [
+					luminance * .9642 * scale,
+					luminance * scale,
+					luminance * .8249 * scale
+				];
+				return [
+					luminance,
+					128 / 255,
+					128 / 255
+				];
+			}
+		},
+		b2a: {
+			inputChannels: 3,
+			outputChannels: 1,
+			encoding: REVERSE_LUT,
+			run(input) {
+				const luminance = pcs === "XYZ " ? checked(input, 1, "gray PCS input") / scale : checked(input, 0, "gray PCS input");
+				return [invertCurve(curve, luminance)];
+			}
+		}
+	};
+}
 //#endregion
-export { matrixTables, parseCurve, parseMab, parseMft };
+export { grayTables, invertCurve, matrixTables, parseCurve, parseMab, parseMft };

package/dist/color/types.js

@@ -8,6 +8,9 @@ function checked(values, index, structure) {
 	if (value === void 0) throw new Error(`${structure} index ${index} is outside length ${values.length}`);
 	return value;
 }
+function color1(values, structure) {
+	return [checked(values, 0, structure)];
+}
 function color4(values, structure) {
 	return [
 		checked(values, 0, structure),
@@ -18,4 +21,4 @@ function color4(values, structure) {
 }
 const clamp = (value) => Math.max(0, Math.min(1, value));
 //#endregion
-export { REVERSE_LUT, checked, clamp, color4, refuse };
+export { REVERSE_LUT, checked, clamp, color1, color4, refuse };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { EffectsReport } from "./effects/types.js";
-import { PressImage, PressReport } from "./press/types.js";
+import { PressDestination, PressImage, PressReport } from "./press/types.js";
+import { Font, ImageOptions, RenderLimits, RenderOptions } from "./options.js";
 import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
-import { Deck, ImpositionInput, PageInput } from "@segnavia/format";
+import { BookInput, Deck, ImpositionInput, PageInput } from "@segnavia/format";
 import { PrintOptions } from "@segnavia/frame/print-document";
 import { Page as Page$1 } from "playwright-core";
 //#region src/index.d.ts
@@ -11,41 +12,6 @@ export declare const CONTAINER_ARGS: string[];
 export declare class RenderTimeoutError extends Error {
   name: string;
 }
-export interface Font {
-  family: string;
-  data: Uint8Array;
-  format: 'woff2' | 'woff' | 'truetype' | 'opentype';
-  weight?: number | string;
-  style?: 'normal' | 'italic';
-}
-export interface RenderLimits {
-  maxSheets?: number;
-  maxBytes?: number;
-}
-export interface RenderOptions {
-  css?: string;
-  fonts?: Font[];
-  limits?: RenderLimits;
-  boundMs?: number;
-  waitForPageReady?: boolean;
-  preferCssPageSize?: boolean;
-  beforeOutput?: (tab: Page$1) => Promise<void>;
-  effects?: false | {
-    report?: (report: EffectsReport) => void;
-  };
-  press?: {
-    /** The ICC profile of the press, as bytes. The library ships none. */
-    profile: Uint8Array;
-    /** Called with authored RGB images left unchanged and counts read back from the output. */
-    report?: (report: PressReport) => void;
-  };
-}
-export interface ImageOptions extends RenderOptions {
-  format?: 'png' | 'jpeg' | 'webp';
-  quality?: number[];
-  scale?: number;
-  width?: number;
-}
 export interface RendererOptions {
   executablePath: string;
   args?: string[];
@@ -53,6 +19,7 @@ export interface RendererOptions {
   jsHeapMb?: number;
 }
 export interface Renderer {
+  bookPdf(book: BookInput, options?: RenderOptions): Promise<Uint8Array>;
   pagePdf(page: PageInput, options?: RenderOptions): Promise<Uint8Array>;
   pagesPdf(pages: PageInput[], options?: RenderOptions & {
     imposition?: ImpositionInput;
@@ -66,4 +33,4 @@ export declare function fontFaces(fonts?: Font[]): string;
 export declare function captureImage(tab: Page$1, options: Pick<ImageOptions, 'format' | 'quality' | 'limits'>, fullPage: boolean): Promise<Uint8Array>;
 export declare function openRenderer(options: RendererOptions): Promise<Renderer>;
 //#endregion
-export { type EffectsReport, type PressImage, type PressReport, RenderRefusedError, RendererUnavailableError };
+export { type EffectsReport, type Font, type ImageOptions, type PressDestination, type PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };

package/dist/index.js

@@ -1,6 +1,9 @@
 import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
+import { renderBrowserBookPdf } from "./book-render.js";
+import { browserJpegDecoder } from "./browser-jpeg.js";
 import { containFixedPageOverflow } from "./overflow-containment.js";
 import { renderDeckPdf } from "./deck-pdf.js";
+import { assertNeutralTolerance } from "./press/color-policy.js";
 import { rewriteEffectsPdf } from "./effects/adapter.js";
 import { assertPrintOptions, printCss, printPage, printViewport } from "./page-paper.js";
 import { renderPagesPdf } from "./pages-pdf.js";
@@ -53,7 +56,7 @@ async function enforce(pdf, limits) {
 	}
 	return pdf;
 }
-async function finishPdf(pdf, options) {
+async function finishPdf(pdf, options, decodeJpeg) {
 	if (options.limits?.maxBytes !== void 0 && pdf.byteLength > options.limits.maxBytes) throw new RenderRefusedError(`The PDF is ${pdf.byteLength} bytes; the limit is ${options.limits.maxBytes}.`);
 	let output = pdf;
 	if (options.effects !== false) {
@@ -62,7 +65,9 @@ async function finishPdf(pdf, options) {
 		options.effects?.report?.(rewritten.report);
 	}
 	if (options.press) {
-		const converted = await rewritePressPdf(output, options.press.profile);
+		const neutralTolerance = options.press.neutralTolerance ?? 3;
+		assertNeutralTolerance(neutralTolerance);
+		const converted = await rewritePressPdf(output, options.press.profile, neutralTolerance, decodeJpeg);
 		output = converted.bytes;
 		options.press.report?.(converted.report);
 	}
@@ -201,6 +206,18 @@ async function openRenderer(options) {
 			reportHeight: false
 		});
 	}
+	async function finishWithBrowser(pdf, options) {
+		if (!options.press || new TextDecoder().decode(options.press.profile.subarray(16, 20)) !== "GRAY") return finishPdf(pdf, options);
+		return withTab({
+			viewport: {
+				width: 1,
+				height: 1
+			},
+			scripts: true,
+			html: "<!doctype html>",
+			waitForReady: false
+		}, (tab) => finishPdf(pdf, options, browserJpegDecoder(tab)));
+	}
 	function pageViewport(page, width, printing = false) {
 		if (page.print) return printViewport(page.print, printing);
 		if (page.size === "fluid") return {
@@ -267,8 +284,15 @@ async function openRenderer(options) {
 		}));
 	}
 	return {
+		bookPdf(input, opts = {}) {
+			return renderBrowserBookPdf(input, opts, {
+				render: (setup, pdf) => withTab(setup, (tab) => tab.pdf(pdf)),
+				fontFaces: (options) => fontFaces(options.fonts),
+				finish: finishWithBrowser
+			});
+		},
 		async pagePdf(input, opts = {}) {
-			return finishPdf(await renderPagePdf(Page.parse(input), opts), opts);
+			return finishWithBrowser(await renderPagePdf(Page.parse(input), opts), opts);
 		},
 		async pageImage(input, opts = {}) {
 			const page = Page.parse(input);
@@ -292,7 +316,7 @@ async function openRenderer(options) {
 				pagePdf: renderPagePdf,
 				piecePdf: renderPiecePdf,
 				fontFaces: (options) => fontFaces(options.fonts),
-				finish: finishPdf
+				finish: finishWithBrowser
 			});
 		},
 		deckPdf(deck, opts = {}) {
@@ -302,7 +326,7 @@ async function openRenderer(options) {
 					waitForReady: false
 				}, (tab) => tab.pdf(pdf)),
 				fontFaces: (options) => fontFaces(options.fonts),
-				finish: finishPdf
+				finish: finishWithBrowser
 			});
 		},
 		async slideImage(deck, index, opts = {}) {

package/dist/options.d.ts

@@ -0,0 +1,39 @@
+import { EffectsReport } from "./effects/types.js";
+import { PressReport } from "./press/types.js";
+import { Page } from "playwright-core";
+//#region src/options.d.ts
+export interface Font {
+  family: string;
+  data: Uint8Array;
+  format: 'woff2' | 'woff' | 'truetype' | 'opentype';
+  weight?: number | string;
+  style?: 'normal' | 'italic';
+}
+export interface RenderLimits {
+  maxSheets?: number;
+  maxBytes?: number;
+}
+export interface RenderOptions {
+  css?: string;
+  fonts?: Font[];
+  limits?: RenderLimits;
+  boundMs?: number;
+  waitForPageReady?: boolean;
+  preferCssPageSize?: boolean;
+  beforeOutput?: (tab: Page) => Promise<void>;
+  effects?: false | {
+    report?: (report: EffectsReport) => void;
+  };
+  press?: {
+    profile: Uint8Array;
+    neutralTolerance?: number;
+    report?: (report: PressReport) => void;
+  };
+}
+export interface ImageOptions extends RenderOptions {
+  format?: 'png' | 'jpeg' | 'webp';
+  quality?: number[];
+  scale?: number;
+  width?: number;
+}
+//#endregion

package/dist/press/adapter.js

@@ -1,5 +1,5 @@
 import { RenderRefusedError } from "../errors.js";
-import { cachedPressColor, pressColor } from "./color-policy.js";
+import { cachedPressColor, destinationColor, newlySnapsToNeutral, pdfMaskLuminosity, pressDestination } from "./color-policy.js";
 import { groupAction, shadingAction } from "./policy.js";
 import { rewriteContent } from "./content.js";
 import { arrayNumbers, decodeContent, dictionaryOf, nameOf, numberOf, replaceArray, resolvedColorSpace } from "./pdf-objects.js";
@@ -7,6 +7,7 @@ import { walkPressGraph } from "./visitor.js";
 import "../effects/types.js";
 import { replaceType1Function, sampleDomainForUses, shadingDeviceMatrix, shadingDomainOf, shadingSampleGridForUses } from "./sample-shading.js";
 import { readProfile } from "../color/profile.js";
+import { convertSuppliedImage, convertedImageCount, createImageState } from "./image.js";
 import { createPaintedBoundsTracker, recordPatternPaintedBounds } from "./pattern-bounds.js";
 import { inspectPressPdf } from "./report.js";
 import { PDFDict, PDFDocument, PDFHexString, PDFName, PDFRef, PDFString } from "pdf-lib";
@@ -17,12 +18,14 @@ 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;
-function convertFunction(state, fn, policy) {
+const isGrayMask = (state, mask) => state.destination === "gray" && mask !== "none";
+const converterFor = (state, mask) => isGrayMask(state, mask) ? pdfMaskLuminosity : state.convert;
+function convertFunction(state, fn, policy, mask) {
 	if (policy.action === "refuse") refuse(policy.found, policy.supported);
 	if (!fn) return;
 	if (numberOf(fn, "FunctionType") === 2) {
-		for (const name of ["C0", "C1"]) replaceArray(fn, name, state.convert(arrayNumbers(fn, name, 3)));
-		if (fn.has(key("Range"))) replaceArray(fn, "Range", [
+		for (const name of ["C0", "C1"]) replaceArray(fn, name, converterFor(state, mask)(arrayNumbers(fn, name, 3)));
+		if (fn.has(key("Range"))) replaceArray(fn, "Range", state.destination === "gray" ? [0, 1] : [
 			0,
 			1,
 			0,
@@ -35,7 +38,7 @@ function convertFunction(state, fn, policy) {
 		state.totals.gradientStops += 2;
 		return;
 	}
-	if (fn.has(key("Range"))) replaceArray(fn, "Range", [
+	if (fn.has(key("Range"))) replaceArray(fn, "Range", state.destination === "gray" ? [0, 1] : [
 		0,
 		1,
 		0,
@@ -72,78 +75,81 @@ function shadingUses(state, shading, pattern) {
 	});
 	return uses.filter((use) => use.painted !== void 0);
 }
-function convertType1Shading(state, shading, pattern) {
+function convertType1Shading(state, shading, pattern, mask) {
 	const uses = shadingUses(state, shading, pattern);
 	const domain = sampleDomainForUses(shadingDomainOf(shading), uses);
 	const matrices = uses.length > 0 ? uses.map((use) => use.matrix) : [shadingDeviceMatrix(shading, pattern)];
 	const size = shadingSampleGridForUses(domain, matrices);
-	replaceType1Function(state.document, shading, pattern, (rgb) => pressColor(state.profile, rgb), state.budget, void 0, domain, size);
+	replaceType1Function(state.document, shading, pattern, isGrayMask(state, mask) ? pdfMaskLuminosity : state.sampleConvert, state.budget, void 0, domain, size, state.destination === "gray" ? 1 : 4);
 }
-function convertShading(state, shading, pattern) {
+function convertShading(state, shading, pattern, mask) {
 	if (state.seenShadings.has(shading)) return false;
 	state.seenShadings.add(shading);
 	const type = numberOf(shading, "ShadingType");
 	const functionType = functionTypeOf(state, shading);
 	const space = resolvedColorSpace(state.document, resolved(state, shading.get(key("ColorSpace"))));
-	const policy = shadingAction(space.kind, type, functionType);
+	const destination = state.destination;
+	const policy = shadingAction(space.kind, type, functionType, destination);
 	if (policy.action === "refuse") {
 		if (type === 1) refuse(`ShadingType 1 FunctionType ${functionType ?? "missing"}`, policy.supported);
 		refuse(`ShadingType ${type ?? "missing"} color space ${space.label}`, policy.supported);
 	}
 	if (policy.action === "keep") return false;
-	if (shading.has(key("Background"))) replaceArray(shading, "Background", state.convert(arrayNumbers(shading, "Background", 3)));
-	shading.set(key("ColorSpace"), key("DeviceCMYK"));
+	if (shading.has(key("Background"))) replaceArray(shading, "Background", converterFor(state, mask)(arrayNumbers(shading, "Background", 3)));
+	shading.set(key("ColorSpace"), key(destination === "gray" ? "DeviceGray" : "DeviceCMYK"));
 	if (type === 1) {
-		convertType1Shading(state, shading, pattern);
+		convertType1Shading(state, shading, pattern, mask);
 		return false;
 	}
 	return true;
 }
-function convertGroup(state, owner, maskSource) {
+function convertGroup(state, owner, mask) {
 	const group = owner.lookupMaybe(key("Group"), PDFDict);
 	if (!group || nameOf(group.get(key("S"))) !== "Transparency" || state.seenGroups.has(group)) return;
 	state.seenGroups.add(group);
 	const space = resolvedColorSpace(state.document, resolved(state, group.get(key("CS"))));
-	const policy = groupAction(space.kind, space.label, maskSource);
+	const destination = state.destination;
+	const policy = groupAction(space.kind, space.label, mask !== "none", destination);
 	if (policy.action === "refuse") refuse(`transparency group color space ${space.label}`, policy.supported);
 	if (policy.action === "convert") {
-		group.set(key("CS"), key("DeviceCMYK"));
+		group.set(key("CS"), key(destination === "gray" ? "DeviceGray" : "DeviceCMYK"));
 		state.totals.groups++;
 	}
 }
-function convertRuleCImage(state, image, width, height, dictionary) {
+function convertRuleCImage(state, image, width, height, dictionary, convert) {
 	const source = decodeContent(image, state.budget);
 	if (source.length !== width * height * 3) refuse("effect image sample length", "three 8-bit RGB samples per pixel");
-	const converted = new Uint8Array(width * height * 4);
+	const channels = state.destination === "gray" ? 1 : 4;
+	const converted = new Uint8Array(width * height * channels);
 	for (let pixel = 0; pixel < width * height; pixel++) {
-		const color = state.convert([
+		const color = convert([
 			(source[pixel * 3] ?? 0) / 255,
 			(source[pixel * 3 + 1] ?? 0) / 255,
 			(source[pixel * 3 + 2] ?? 0) / 255
 		]);
-		for (let channel = 0; channel < 4; channel++) converted[pixel * 4 + channel] = Math.round(Math.max(0, Math.min(1, color[channel] ?? 0)) * 255);
+		for (let channel = 0; channel < channels; channel++) converted[pixel * channels + channel] = Math.round(Math.max(0, Math.min(1, color[channel] ?? 0)) * 255);
 	}
-	dictionary.ColorSpace = key("DeviceCMYK");
+	dictionary.ColorSpace = key(state.destination === "gray" ? "DeviceGray" : "DeviceCMYK");
 	const replacement = state.document.context.stream(deflateSync(converted), dictionary);
 	const reference = state.document.context.getObjectRef(image);
 	if (reference) state.document.context.assign(reference, replacement);
 }
-function convertEffectImage(state, image) {
+function convertEffectImage(state, image, mask) {
 	if (!image.dict.has(key("SegnaviaGeneratedEffect")) || resolvedColorSpace(state.document, resolved(state, image.dict.get(key("ColorSpace")))).kind !== "rgb") return;
 	const width = numberOf(image.dict, "Width") ?? refuse("effect image Width missing", "a positive Width number");
 	const height = numberOf(image.dict, "Height") ?? refuse("effect image Height missing", "a positive Height number");
 	if (width <= 0 || height <= 0) refuse("effect image dimensions", "positive Width and Height numbers");
 	const dictionary = streamDictionary(image);
+	const convert = converterFor(state, mask);
 	if (!image.dict.has(key("SegnaviaEffectColor"))) {
-		convertRuleCImage(state, image, width, height, dictionary);
+		convertRuleCImage(state, image, width, height, dictionary, convert);
 		return;
 	}
-	const source = arrayNumbers(image.dict, "SegnaviaEffectColor", 3);
-	const color = state.convert(source);
+	const color = convert(arrayNumbers(image.dict, "SegnaviaEffectColor", 3));
 	const palette = color.map((value) => Math.round(Math.max(0, Math.min(1, value)) * 255));
 	dictionary.ColorSpace = state.document.context.obj([
 		"Indexed",
-		"DeviceCMYK",
+		state.destination === "gray" ? "DeviceGray" : "DeviceCMYK",
 		0,
 		PDFHexString.of(Buffer.from(palette).toString("hex"))
 	]);
@@ -185,9 +191,10 @@ function recordContentBounds(state, stream, resources, budget) {
 	if (state.sequence) state.sequence.feed(bytes, resolve, resolveGs, resolveShading);
 	else recordPatternPaintedBounds(bytes, resolve, state.painted, resolveGs, resolveShading, state.shadingPainted);
 }
-function convertContent(state, object, stream, setDirect) {
+function convertContent(state, object, stream, setDirect, mask) {
 	const bytes = decodeContent(stream, state.budget);
-	const rewritten = rewriteContent(bytes, state.convert);
+	const destination = state.destination;
+	const rewritten = rewriteContent(bytes, converterFor(state, mask), destination);
 	state.totals.fills += rewritten.counts.fills;
 	state.totals.strokes += rewritten.counts.strokes;
 	const replacement = state.document.context.stream(deflateSync(rewritten.bytes), streamDictionary(stream));
@@ -195,37 +202,50 @@ function convertContent(state, object, stream, setDirect) {
 	if (reference) state.document.context.assign(reference, replacement);
 	else setDirect(replacement);
 }
-function newState(document, profile) {
+function newState(document, profile, tolerance) {
+	const cached = cachedPressColor(profile, tolerance);
+	const totals = {
+		fills: 0,
+		strokes: 0,
+		gradientStops: 0,
+		groups: 0,
+		neutralColors: 0
+	};
 	return {
 		budget: {
 			calculatorOperations: 0,
 			decodedBytes: 0,
 			shadingSamples: 0
 		},
-		convert: cachedPressColor(profile),
+		convert: (rgb) => {
+			if (profile.colorSpace === "CMYK" && newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
+			return cached(rgb);
+		},
+		destination: pressDestination(profile),
 		document,
 		painted: /* @__PURE__ */ new WeakMap(),
 		profile,
+		sampleConvert: (rgb) => {
+			if (profile.colorSpace === "CMYK" && newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
+			return destinationColor(profile, rgb, tolerance);
+		},
 		seenGroups: /* @__PURE__ */ new WeakSet(),
 		seenShadings: /* @__PURE__ */ new WeakSet(),
 		shadingPainted: /* @__PURE__ */ new WeakMap(),
 		shadingPatterns: /* @__PURE__ */ new WeakMap(),
-		totals: {
-			fills: 0,
-			strokes: 0,
-			gradientStops: 0,
-			groups: 0
-		}
+		totals
 	};
 }
-function rewritePressDocument(document, profile) {
-	const state = newState(document, profile);
+function rewritePressDocument(document, profile, tolerance = 3) {
+	const state = newState(document, profile, tolerance);
 	const boundsBudget = { decodedBytes: 0 };
 	walkPressGraph(document, {
 		beginContentsSequence: () => {
 			state.sequence = createPaintedBoundsTracker(state.painted, state.shadingPainted);
 		},
-		content: (_object, stream, _replace, resources) => recordContentBounds(state, stream, resources, boundsBudget),
+		content: (_object, stream, _replace, resources) => {
+			recordContentBounds(state, stream, resources, boundsBudget);
+		},
 		endContentsSequence: () => {
 			state.sequence = void 0;
 		},
@@ -236,16 +256,16 @@ function rewritePressDocument(document, profile) {
 		shading: (shading, pattern) => indexShadingPattern(state, shading, pattern)
 	});
 	walkPressGraph(document, {
-		content: (object, stream, replace) => convertContent(state, object, stream, replace),
-		function: (fn, decision) => convertFunction(state, fn, decision),
-		group: (owner, _stream, maskSource) => convertGroup(state, owner, maskSource),
-		image: (image) => convertEffectImage(state, image),
-		shading: (shading, pattern) => convertShading(state, shading, pattern)
+		content: (object, stream, replace, _resources, mask) => convertContent(state, object, stream, replace, mask),
+		function: (fn, decision, mask) => convertFunction(state, fn, decision, mask),
+		group: (owner, _stream, mask) => convertGroup(state, owner, mask),
+		image: (image, mask) => convertEffectImage(state, image, mask),
+		shading: (shading, pattern, mask) => convertShading(state, shading, pattern, mask)
 	});
 	return state.totals;
 }
-function addOutputIntent(document, profile) {
-	const profileRef = document.context.register(document.context.stream(profile, { N: 4 }));
+function addOutputIntent(document, profile, channels) {
+	const profileRef = document.context.register(document.context.stream(profile, { N: channels }));
 	const intentRef = document.context.register(document.context.obj({
 		Type: "OutputIntent",
 		S: "GTS_PDFX",
@@ -254,17 +274,64 @@ function addOutputIntent(document, profile) {
 	}));
 	document.catalog.set(key("OutputIntents"), document.context.obj([intentRef]));
 }
-async function rewritePressPdf(bytes, profileBytes) {
+function replaceSourceImage(document, image, uses, replacement) {
+	const reference = document.context.getObjectRef(image);
+	if (reference) document.context.assign(reference, replacement);
+	else for (const use of uses) use.replace(replacement);
+}
+async function convertImageUses(state, image, uses) {
+	const normal = uses.filter((use) => use.mask === "none");
+	const masks = uses.filter((use) => use.mask !== "none");
+	if (normal.length > 0) {
+		const replacement = await convertSuppliedImage(state, image, "none");
+		if (!replacement) return;
+		replaceSourceImage(state.document, image, normal, replacement);
+	}
+	if (masks.length === 0) return;
+	const replacement = await convertSuppliedImage(state, image, masks[0]?.mask ?? "luminosity");
+	if (!replacement) return;
+	if (normal.length === 0) replaceSourceImage(state.document, image, masks, replacement);
+	else {
+		const reference = state.document.context.getObjectRef(replacement) ?? state.document.context.register(replacement);
+		for (const use of masks) use.replace(reference);
+	}
+}
+async function convertGrayImages(document, profile, decodeJpeg) {
+	const state = createImageState(document, profile, decodeJpeg);
+	const images = [];
+	walkPressGraph(document, {
+		content: () => void 0,
+		function: () => void 0,
+		group: () => void 0,
+		image: (image, mask, replace) => images.push({
+			image,
+			mask,
+			replace
+		}),
+		shading: () => false
+	});
+	const uses = /* @__PURE__ */ new Map();
+	for (const found of images) uses.set(found.image, [...uses.get(found.image) ?? [], found]);
+	for (const [image, found] of uses) await convertImageUses(state, image, found);
+	return convertedImageCount(state);
+}
+async function rewritePressPdf(bytes, profileBytes, tolerance = 3, decodeJpeg) {
 	try {
 		const profile = readProfile(profileBytes);
-		if (profile.colorSpace !== "CMYK") refuse(`press profile color space ${profile.colorSpace}`, "CMYK");
+		if (profile.colorSpace !== "CMYK" && profile.colorSpace !== "GRAY") refuse(`press profile color space ${profile.colorSpace}`, "CMYK or GRAY");
 		const document = await PDFDocument.load(bytes, { updateMetadata: false });
-		rewritePressDocument(document, profile);
-		addOutputIntent(document, profileBytes);
+		const counts = rewritePressDocument(document, profile, tolerance);
+		let convertedImages = 0;
+		const destination = pressDestination(profile);
+		if (destination === "gray") convertedImages = await convertGrayImages(document, profile, decodeJpeg);
+		addOutputIntent(document, profileBytes, destination === "gray" ? 1 : 4);
 		const output = await document.save({ useObjectStreams: false });
+		const report = await inspectPressPdf(output, destination);
+		report.neutralColors = counts.neutralColors;
+		report.convertedImages = convertedImages;
 		return {
 			bytes: output,
-			report: await inspectPressPdf(output)
+			report
 		};
 	} catch (error) {
 		if (error instanceof RenderRefusedError) throw error;