@segnavia/render 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,4 +1,9 @@
-import { PX_PER_MM, Page, sheetMm } from "@segnavia/format";
+import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
+import { renderDeckPdf } from "./deck-pdf.js";
+import { assertPrintOptions, printCss, printPage, printViewport } from "./page-paper.js";
+import { renderPagesPdf } from "./pages-pdf.js";
+import { rewritePressPdf } from "./press/adapter.js";
+import { Page, printProperties } from "@segnavia/format";
 import { frameDocument, newNonce } from "@segnavia/frame/bridge";
 import { printableDeck } from "@segnavia/frame/print-document";
 import { PDFDocument } from "pdf-lib";
@@ -18,15 +23,9 @@ const NO_NETWORK_ARGS = [
 	"--proxy-bypass-list=<-loopback>",
 	"--force-webrtc-ip-handling-policy=disable_non_proxied_udp"
 ];
-var RendererUnavailableError = class extends Error {
-	name = "RendererUnavailableError";
-};
 var RenderTimeoutError = class extends Error {
 	name = "RenderTimeoutError";
 };
-var RenderRefusedError = class extends Error {
-	name = "RenderRefusedError";
-};
 function fontFaces(fonts = []) {
 	return fonts.map((font) => `@font-face{font-family:${JSON.stringify(font.family)};src:url(data:font/${font.format === "truetype" ? "ttf" : font.format === "opentype" ? "otf" : font.format};base64,${Buffer.from(font.data).toString("base64")}) format(${JSON.stringify(font.format)});font-weight:${font.weight ?? "normal"};font-style:${font.style ?? "normal"};font-display:block}`).join("");
 }
@@ -52,6 +51,13 @@ async function enforce(pdf, limits) {
 	}
 	return pdf;
 }
+async function finishPdf(pdf, options) {
+	if (!options.press) return enforce(pdf, options.limits);
+	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}.`);
+	const converted = await rewritePressPdf(pdf, options.press.profile);
+	options.press.report?.(converted.report);
+	return enforce(converted.bytes, options.limits);
+}
 async function captureImage(tab, options, fullPage) {
 	const format = options.format ?? "png";
 	if (format !== "webp") return tab.screenshot({
@@ -171,8 +177,8 @@ async function openRenderer(options) {
 			release();
 		}
 	}
-	function pageDocument(page, options) {
-		const css = `${fontFaces(options.fonts)}${options.css ?? ""}`;
+	function pageDocument(page, options, printing = false) {
+		const css = `${page.print ? printing ? printCss(page.print) : printProperties(page.print) : ""}${fontFaces(options.fonts)}${options.css ?? ""}`;
 		return frameDocument(page.html, {
 			scripts: page.scripts,
 			nonce: newNonce(),
@@ -183,14 +189,8 @@ async function openRenderer(options) {
 			reportHeight: false
 		});
 	}
-	function pageViewport(page, width) {
-		if (page.print) {
-			const mm = sheetMm(page.print);
-			return {
-				width: Math.round(mm.width * PX_PER_MM),
-				height: Math.round(mm.height * PX_PER_MM)
-			};
-		}
+	function pageViewport(page, width, printing = false) {
+		if (page.print) return printViewport(page.print, printing);
 		if (page.size === "fluid") return {
 			width: width ?? FLUID_WIDTH,
 			height: 800
@@ -201,43 +201,62 @@ async function openRenderer(options) {
 		};
 	}
 	const image = captureImage;
+	async function renderPagePdf(page, opts) {
+		if (page.print) assertPrintOptions(page.print, opts.preferCssPageSize);
+		const viewport = pageViewport(page, void 0, true);
+		return await withTab({
+			viewport,
+			scripts: page.scripts === "sandboxed",
+			html: pageDocument(page, opts, true),
+			waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
+			boundMs: opts.boundMs,
+			beforeOutput: opts.beforeOutput
+		}, async (tab) => {
+			if (page.print) return printPage(tab, page.print, opts.preferCssPageSize);
+			const fixedHeight = typeof page.size === "object" && page.size.height !== "auto" ? page.size.height : null;
+			const height = fixedHeight ?? await contentHeight(tab);
+			return tab.pdf({
+				width: `${viewport.width}px`,
+				height: `${height}px`,
+				printBackground: true,
+				pageRanges: fixedHeight ? void 0 : "1"
+			});
+		});
+	}
+	async function renderPiecePdf(page, geometry, css, opts) {
+		const html = frameDocument(page.html, {
+			scripts: page.scripts,
+			nonce: newNonce(),
+			dir: page.dir,
+			lang: page.lang,
+			css,
+			relayKeys: false,
+			reportHeight: false
+		});
+		return withTab({
+			viewport: geometry.viewport,
+			scripts: page.scripts === "sandboxed",
+			html,
+			waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
+			boundMs: opts.boundMs,
+			beforeOutput: opts.beforeOutput
+		}, (tab) => tab.pdf({
+			width: geometry.pdf.width,
+			height: geometry.pdf.height,
+			printBackground: true,
+			preferCSSPageSize: false,
+			pageRanges: "1",
+			margin: {
+				top: "0mm",
+				right: "0mm",
+				bottom: "0mm",
+				left: "0mm"
+			}
+		}));
+	}
 	return {
 		async pagePdf(input, opts = {}) {
-			const page = Page.parse(input);
-			const viewport = pageViewport(page);
-			return enforce(await withTab({
-				viewport,
-				scripts: page.scripts === "sandboxed",
-				html: pageDocument(page, opts),
-				waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
-				boundMs: opts.boundMs,
-				beforeOutput: opts.beforeOutput
-			}, async (tab) => {
-				if (page.print) {
-					const mm = sheetMm(page.print);
-					const margin = page.print.margin;
-					return tab.pdf({
-						width: `${mm.width}mm`,
-						height: `${mm.height}mm`,
-						printBackground: true,
-						preferCSSPageSize: opts.preferCssPageSize ?? false,
-						margin: margin ? {
-							top: `${margin.top}mm`,
-							right: `${margin.right}mm`,
-							bottom: `${margin.bottom}mm`,
-							left: `${margin.left}mm`
-						} : void 0
-					});
-				}
-				const fixedHeight = typeof page.size === "object" && page.size.height !== "auto" ? page.size.height : null;
-				const height = fixedHeight ?? await contentHeight(tab);
-				return tab.pdf({
-					width: `${viewport.width}px`,
-					height: `${height}px`,
-					printBackground: true,
-					pageRanges: fixedHeight ? void 0 : "1"
-				});
-			}), opts.limits);
+			return finishPdf(await renderPagePdf(Page.parse(input), opts), opts);
 		},
 		async pageImage(input, opts = {}) {
 			const page = Page.parse(input);
@@ -256,31 +275,23 @@ async function openRenderer(options) {
 				return image(tab, opts, false);
 			});
 		},
-		async deckPdf(deck, opts = {}) {
-			const css = `${fontFaces(opts.fonts)}${opts.css ?? ""}`;
-			const html = printableDeck(deck, {
-				...opts,
-				css
+		pagesPdf(inputs, opts = {}) {
+			return renderPagesPdf(inputs, opts, {
+				pagePdf: renderPagePdf,
+				piecePdf: renderPiecePdf,
+				fontFaces: (options) => fontFaces(options.fonts),
+				finish: finishPdf
+			});
+		},
+		deckPdf(deck, opts = {}) {
+			return renderDeckPdf(deck, opts, {
+				renderPdf: (setup, pdf) => withTab({
+					...setup,
+					waitForReady: false
+				}, (tab) => tab.pdf(pdf)),
+				fontFaces: (options) => fontFaces(options.fonts),
+				finish: finishPdf
 			});
-			return enforce(await withTab({
-				viewport: opts.layout === "notes" ? pageViewport({
-					html: "",
-					size: "fluid",
-					scripts: "refuse",
-					print: opts.notesPaper ?? {
-						paper: "letter",
-						orientation: "portrait"
-					}
-				}) : deck.size,
-				scripts: deck.scripts === "sandboxed",
-				html,
-				waitForReady: false,
-				boundMs: opts.boundMs,
-				beforeOutput: opts.beforeOutput
-			}, (tab) => tab.pdf({
-				preferCSSPageSize: true,
-				printBackground: true
-			})), opts.limits);
 		},
 		async slideImage(deck, index, opts = {}) {
 			const slide = deck.slides[index];

package/dist/page-paper.js

@@ -0,0 +1,94 @@
+import { RenderRefusedError } from "./errors.js";
+import { pdfBox, pdfPoint, pt } from "./pdf-geometry.js";
+import { PX_PER_MM, printBoxes, printPadding, printProperties, sheetMm } from "@segnavia/format";
+import { PDFDocument, PDFName, rgb } from "pdf-lib";
+//#region src/page-paper.ts
+const usesPressLayout = (print) => print.bleed > 0 || print.marks;
+function printCss(print) {
+	const properties = printProperties(print);
+	if (!usesPressLayout(print)) return properties;
+	const margin = print.margin ?? {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	return `${properties}${printPadding({
+		top: margin.top + print.bleed,
+		right: margin.right + print.bleed,
+		bottom: margin.bottom + print.bleed,
+		left: margin.left + print.bleed
+	})}`;
+}
+function printViewport(print, pressLayout) {
+	const size = pressLayout && usesPressLayout(print) ? printBoxes(print).bleedBox : sheetMm(print);
+	return {
+		width: Math.round(size.width * PX_PER_MM),
+		height: Math.round(size.height * PX_PER_MM)
+	};
+}
+function assertPrintOptions(print, preferCssPageSize) {
+	if (usesPressLayout(print) && preferCssPageSize) throw new RenderRefusedError("A page with bleed or marks takes its size from its print setting. Remove preferCssPageSize, or remove the bleed and marks, to clear this refusal.");
+}
+async function addPressBoxes(pdf, print) {
+	const boxes = printBoxes(print);
+	const document = await PDFDocument.load(pdf);
+	const source = document.getPage(0);
+	const content = await document.embedPage(source);
+	const page = document.addPage([pt(boxes.media.width), pt(boxes.media.height)]);
+	const bleedBox = pdfBox(boxes.bleedBox, boxes.media.height);
+	const trimBox = pdfBox(boxes.trim, boxes.media.height);
+	page.drawPage(content, {
+		x: bleedBox.x,
+		y: bleedBox.y,
+		width: source.getWidth(),
+		height: source.getHeight()
+	});
+	document.removePage(0);
+	page.node.delete(PDFName.of("CropBox"));
+	page.setBleedBox(bleedBox.x, bleedBox.y, bleedBox.width, bleedBox.height);
+	page.setTrimBox(trimBox.x, trimBox.y, trimBox.width, trimBox.height);
+	for (const mark of boxes.marks) page.drawLine({
+		start: pdfPoint(mark.x1, mark.y1, boxes.media.height),
+		end: pdfPoint(mark.x2, mark.y2, boxes.media.height),
+		thickness: .25,
+		color: rgb(0, 0, 0)
+	});
+	return document.save();
+}
+async function printPage(tab, print, preferCssPageSize) {
+	if (!usesPressLayout(print)) {
+		const mm = sheetMm(print);
+		const margin = print.margin;
+		return tab.pdf({
+			width: `${mm.width}mm`,
+			height: `${mm.height}mm`,
+			printBackground: true,
+			preferCSSPageSize: preferCssPageSize ?? false,
+			margin: margin ? {
+				top: `${margin.top}mm`,
+				right: `${margin.right}mm`,
+				bottom: `${margin.bottom}mm`,
+				left: `${margin.left}mm`
+			} : void 0
+		});
+	}
+	const boxes = printBoxes(print);
+	const pdf = await tab.pdf({
+		width: `${boxes.bleedBox.width}mm`,
+		height: `${boxes.bleedBox.height}mm`,
+		printBackground: true,
+		preferCSSPageSize: false,
+		margin: {
+			top: "0mm",
+			right: "0mm",
+			bottom: "0mm",
+			left: "0mm"
+		}
+	});
+	const papers = (await PDFDocument.load(pdf)).getPageCount();
+	if (papers > 1) throw new RenderRefusedError(`A page with bleed or marks is one printed piece, but the content needs ${papers} papers. Shorten the content, or remove the bleed and marks.`);
+	return addPressBoxes(pdf, print);
+}
+//#endregion
+export { assertPrintOptions, printCss, printPage, printViewport };

package/dist/pages-imposition.js

@@ -0,0 +1,65 @@
+import { pdfBox } from "./pdf-geometry.js";
+import { fitPage, pagePlacementLayout } from "@segnavia/format";
+//#region src/pages-imposition.ts
+const geometryKey = (page, pageValue, placement) => pageValue.size === "fluid" ? JSON.stringify([
+	page,
+	placement.bleedBox.width,
+	placement.bleedBox.height,
+	placement.bleed.top,
+	placement.bleed.right,
+	placement.bleed.bottom,
+	placement.bleed.left
+]) : String(page);
+function groupPieces(pages, imposed, mode) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const placement of imposed.placements) {
+		const page = pages[placement.page];
+		if (!page) throw new RangeError(`The placement names missing page ${placement.page}.`);
+		const fit = fitPage(page, placement, mode);
+		const layout = pagePlacementLayout(page.size, placement, fit);
+		const key = geometryKey(placement.page, page, placement);
+		const group = groups.get(key) ?? {
+			key,
+			page: placement.page,
+			placements: []
+		};
+		group.placements.push({
+			placement,
+			layout
+		});
+		groups.set(key, group);
+	}
+	return [...groups.values()];
+}
+function pieceGeometry(item) {
+	const { placement, layout } = item;
+	if (layout.kind === "fluid") return {
+		viewport: {
+			width: Math.round(layout.piece.width),
+			height: Math.round(layout.piece.height)
+		},
+		pdf: {
+			width: `${layout.paper.width}mm`,
+			height: `${layout.paper.height}mm`
+		},
+		padding: layout.inset ? placement.bleed : void 0
+	};
+	return {
+		viewport: {
+			width: layout.piece.width,
+			height: Math.round(layout.piece.height)
+		},
+		pdf: {
+			width: `${layout.piece.width}px`,
+			height: `${layout.piece.height}px`
+		}
+	};
+}
+function placementPdfGeometry(placement, layout, paperHeight) {
+	return {
+		draw: pdfBox(layout.paper, paperHeight),
+		clip: pdfBox(placement.bleedBox, paperHeight)
+	};
+}
+//#endregion
+export { groupPieces, pieceGeometry, placementPdfGeometry };

package/dist/pages-pdf.js

@@ -0,0 +1,66 @@
+import { RenderRefusedError } from "./errors.js";
+import { groupPieces, pieceGeometry } from "./pages-imposition.js";
+import { composeImposedPdf } from "./pdf-compose.js";
+import { Imposition, Page, impose, printPadding, printProperties } from "@segnavia/format";
+import { PDFDocument } from "pdf-lib";
+//#region src/pages-pdf.ts
+async function joinPdfs(pdfs) {
+	const joined = await PDFDocument.create();
+	for (const bytes of pdfs) {
+		const source = await PDFDocument.load(bytes);
+		const pages = await joined.copyPages(source, source.getPageIndices());
+		for (const page of pages) joined.addPage(page);
+	}
+	return joined.save();
+}
+function namePageError(error, page) {
+	if (error instanceof Error) {
+		error.message = `Page at index ${page} could not be rendered: ${error.message}`;
+		throw error;
+	}
+	throw new Error(`Page at index ${page} could not be rendered: ${String(error)}`);
+}
+async function composedPdf(pages, imposition, opts, services) {
+	const imposed = impose(imposition, pages.length);
+	const groups = groupPieces(pages, imposed, imposition.fit);
+	const properties = printProperties(imposition, imposition.unit);
+	const hostCss = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const rendered = await Promise.all(groups.map(async (group) => {
+		const page = pages[group.page];
+		const first = group.placements[0];
+		if (!page || !first) throw new Error(`The piece for page ${group.page} has no placement.`);
+		const geometry = pieceGeometry(first);
+		const css = `${properties}${geometry.padding ? printPadding(geometry.padding) : ""}${hostCss}`;
+		try {
+			return {
+				group,
+				bytes: await services.piecePdf(page, geometry, css, opts)
+			};
+		} catch (error) {
+			namePageError(error, group.page);
+		}
+	}));
+	return composeImposedPdf(imposed, rendered.map(({ group, bytes }) => ({
+		key: group.key,
+		name: `The rendered piece for page ${group.page}`,
+		bytes,
+		placements: group.placements
+	})));
+}
+async function renderPagesPdf(inputs, opts, services) {
+	if (inputs.length === 0) throw new RenderRefusedError("There is nothing to render. Pass at least one page to clear this refusal.");
+	const pages = inputs.map((input) => Page.parse(input));
+	if (!opts.imposition) {
+		const rendered = await Promise.all(pages.map((page) => services.pagePdf(page, {
+			...opts,
+			limits: void 0,
+			press: void 0
+		})));
+		return services.finish(await joinPdfs(rendered), opts);
+	}
+	const imposition = Imposition.parse(opts.imposition);
+	if (opts.preferCssPageSize) throw new RenderRefusedError("Pages in an imposition take their size from its paper. Remove preferCssPageSize, or remove the imposition, to clear this refusal.");
+	return services.finish(await composedPdf(pages, imposition, opts, services), opts);
+}
+//#endregion
+export { renderPagesPdf };

package/dist/pdf-compose.js

@@ -0,0 +1,35 @@
+import { placementPdfGeometry } from "./pages-imposition.js";
+import { MM_PER_PT } from "@segnavia/format";
+import { PDFDocument, clip, endPath, popGraphicsState, pushGraphicsState, rectangle } from "pdf-lib";
+//#region src/pdf-compose.ts
+async function embedOnePage(output, bytes, name) {
+	const [embedded] = await output.embedPdf(bytes, [0]);
+	if (!embedded) throw new Error(`${name} has no PDF page.`);
+	return embedded;
+}
+function drawClippedPage(target, embedded, draw, clipBox) {
+	target.pushOperators(pushGraphicsState(), rectangle(clipBox.x, clipBox.y, clipBox.width, clipBox.height), clip(), endPath());
+	target.drawPage(embedded, draw);
+	target.pushOperators(popGraphicsState());
+}
+function drawImposedSide(output, imposed, embedded, pieces, paperIndex, side) {
+	const paper = output.addPage([imposed.paper.width / MM_PER_PT, imposed.paper.height / MM_PER_PT]);
+	for (const piece of pieces) {
+		const image = embedded.get(piece.key);
+		if (!image) throw new Error(`${piece.name} was not embedded.`);
+		for (const { placement, layout } of piece.placements) {
+			if (placement.paper !== paperIndex || placement.side !== side) continue;
+			const { draw, clip: clipBox } = placementPdfGeometry(placement, layout, imposed.paper.height);
+			drawClippedPage(paper, image, draw, clipBox);
+		}
+	}
+}
+async function composeImposedPdf(imposed, pieces) {
+	const output = await PDFDocument.create();
+	const embedded = /* @__PURE__ */ new Map();
+	for (const piece of pieces) embedded.set(piece.key, await embedOnePage(output, piece.bytes, piece.name));
+	for (let paperIndex = 0; paperIndex < imposed.papers; paperIndex += 1) for (const side of ["front", "back"].slice(0, imposed.sides)) drawImposedSide(output, imposed, embedded, pieces, paperIndex, side);
+	return output.save();
+}
+//#endregion
+export { composeImposedPdf, drawClippedPage, embedOnePage };

package/dist/pdf-geometry.js

@@ -0,0 +1,27 @@
+import { MM_PER_PT, PX_PER_MM } from "@segnavia/format";
+//#region src/pdf-geometry.ts
+const pt = (millimeters) => millimeters / MM_PER_PT;
+const pixelPt = (pixels) => pt(pixels / PX_PER_MM);
+function pdfPoint(x, y, mediaHeight) {
+	return {
+		x: pt(x),
+		y: pt(mediaHeight - y)
+	};
+}
+function pdfBox(box, mediaHeight) {
+	return {
+		...pdfPoint(box.x, box.y + box.height, mediaHeight),
+		width: pt(box.width),
+		height: pt(box.height)
+	};
+}
+function pdfPixelBox(box, mediaHeight) {
+	return {
+		x: pixelPt(box.x),
+		y: pixelPt(mediaHeight - box.y - box.height),
+		width: pixelPt(box.width),
+		height: pixelPt(box.height)
+	};
+}
+//#endregion
+export { pdfBox, pdfPixelBox, pdfPoint, pixelPt, pt };

package/dist/press/adapter.js

@@ -0,0 +1,145 @@
+import { RenderRefusedError } from "../errors.js";
+import { readProfile } from "../color/profile.js";
+import { cachedPressColor } from "./color-policy.js";
+import { groupAction, shadingAction } from "./policy.js";
+import { rewriteContent } from "./content.js";
+import { arrayNumbers, decodeContent, nameOf, numberOf, replaceArray, resolvedColorSpace } from "./pdf-objects.js";
+import { walkPressGraph } from "./visitor.js";
+import { inspectPressPdf } from "./report.js";
+import { PDFDict, PDFDocument, PDFName, PDFRef, PDFString } from "pdf-lib";
+import { deflateSync } from "node:zlib";
+//#region src/press/adapter.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;
+function convertFunction(state, fn, policy) {
+	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", [
+			0,
+			1,
+			0,
+			1,
+			0,
+			1,
+			0,
+			1
+		]);
+		state.totals.gradientStops += 2;
+		return;
+	}
+	if (fn.has(key("Range"))) replaceArray(fn, "Range", [
+		0,
+		1,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1
+	]);
+}
+function convertShading(state, shading) {
+	if (state.seenShadings.has(shading)) return false;
+	state.seenShadings.add(shading);
+	const type = numberOf(shading, "ShadingType");
+	const space = resolvedColorSpace(state.document, resolved(state, shading.get(key("ColorSpace"))));
+	const policy = shadingAction(space.kind, type);
+	if (policy.action === "refuse") 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"));
+	return true;
+}
+function convertGroup(state, owner, maskSource) {
+	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);
+	if (policy.action === "refuse") refuse(`transparency group color space ${space.label}`, policy.supported);
+	if (policy.action === "convert") {
+		group.set(key("CS"), key("DeviceCMYK"));
+		state.totals.groups++;
+	}
+}
+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"
+		].includes(label)) dictionary[label] = value;
+	}
+	return dictionary;
+}
+function convertContent(state, object, stream, setDirect) {
+	const rewritten = rewriteContent(decodeContent(stream, state.budget), state.convert);
+	state.totals.fills += rewritten.counts.fills;
+	state.totals.strokes += rewritten.counts.strokes;
+	const replacement = state.document.context.stream(deflateSync(rewritten.bytes), streamDictionary(stream));
+	const reference = object instanceof PDFRef ? object : state.document.context.getObjectRef(object);
+	if (reference) state.document.context.assign(reference, replacement);
+	else setDirect(replacement);
+}
+function newState(document, profile) {
+	return {
+		budget: { decodedBytes: 0 },
+		convert: cachedPressColor(profile),
+		document,
+		seenGroups: /* @__PURE__ */ new WeakSet(),
+		seenShadings: /* @__PURE__ */ new WeakSet(),
+		totals: {
+			fills: 0,
+			strokes: 0,
+			gradientStops: 0,
+			groups: 0
+		}
+	};
+}
+function rewritePressDocument(document, profile) {
+	const state = newState(document, profile);
+	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: () => void 0,
+		shading: (shading) => convertShading(state, shading)
+	});
+	return state.totals;
+}
+function addOutputIntent(document, profile) {
+	const profileRef = document.context.register(document.context.stream(profile, { N: 4 }));
+	const intentRef = document.context.register(document.context.obj({
+		Type: "OutputIntent",
+		S: "GTS_PDFX",
+		OutputConditionIdentifier: PDFString.of("Custom"),
+		DestOutputProfile: profileRef
+	}));
+	document.catalog.set(key("OutputIntents"), document.context.obj([intentRef]));
+}
+async function rewritePressPdf(bytes, profileBytes) {
+	try {
+		const profile = readProfile(profileBytes);
+		if (profile.colorSpace !== "CMYK") refuse(`press profile color space ${profile.colorSpace}`, "CMYK");
+		const document = await PDFDocument.load(bytes, { updateMetadata: false });
+		rewritePressDocument(document, profile);
+		addOutputIntent(document, profileBytes);
+		const output = await document.save({ useObjectStreams: false });
+		return {
+			bytes: output,
+			report: await inspectPressPdf(output)
+		};
+	} catch (error) {
+		if (error instanceof RenderRefusedError) throw error;
+		throw new RenderRefusedError("The PDF has unsupported malformed structure; supported: a valid PDF produced by the renderer.");
+	}
+}
+//#endregion
+export { rewritePressDocument, rewritePressPdf };

package/dist/press/color-policy.js

@@ -0,0 +1,31 @@
+import { toPress } from "../color/engine.js";
+//#region src/press/color-policy.ts
+const NEUTRAL_TOLERANCE = .001;
+function pressColor(profile, rgb) {
+	const [red, green, blue] = rgb;
+	if (Math.max(red, green, blue) - Math.min(red, green, blue) <= NEUTRAL_TOLERANCE) return [
+		0,
+		0,
+		0,
+		1 - red
+	];
+	return toPress(profile, rgb);
+}
+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) {
+	const cache = /* @__PURE__ */ new Map();
+	return (rgb) => {
+		const key = rgb.join(",");
+		const cached = cache.get(key);
+		if (cached) return cached;
+		const converted = pressColor(profile, rgb);
+		cache.set(key, converted);
+		return converted;
+	};
+}
+//#endregion
+export { cachedPressColor, formatPdfNumber, pressColor };