@segnavia/render 0.3.0 → 0.5.0

package/dist/book-destinations.js

@@ -0,0 +1,101 @@
+import { RenderRefusedError } from "./errors.js";
+import { PDFArray, PDFDict, PDFHexString, PDFName, PDFNumber, PDFRef, PDFString } from "pdf-lib";
+//#region src/book-destinations.ts
+const key = (value) => PDFName.of(value);
+const resolve = (document, value) => value instanceof PDFRef ? document.context.lookup(value) : value;
+function decode(value) {
+	if (value instanceof PDFString || value instanceof PDFHexString) return value.decodeText();
+	if (value instanceof PDFName) return value.toString().slice(1);
+}
+function destination(document, value) {
+	let found = resolve(document, value);
+	if (found instanceof PDFDict) found = resolve(document, found.get(key("D")));
+	if (!(found instanceof PDFArray)) return void 0;
+	const reference = found.get(0);
+	if (!(reference instanceof PDFRef)) return void 0;
+	const page = document.getPages().findIndex((candidate) => candidate.ref.toString() === reference.toString());
+	if (page < 0) return void 0;
+	const x = resolve(document, found.get(2));
+	const y = resolve(document, found.get(3));
+	return {
+		page: page + 1,
+		x: x instanceof PDFNumber ? x.asNumber() : 0,
+		y: y instanceof PDFNumber ? y.asNumber() : document.getPage(page).getHeight()
+	};
+}
+function nameTree(document, value, output) {
+	const dictionary = resolve(document, value);
+	if (!(dictionary instanceof PDFDict)) return;
+	const names = resolve(document, dictionary.get(key("Names")));
+	if (names instanceof PDFArray) for (let index = 0; index + 1 < names.size(); index += 2) {
+		const name = decode(resolve(document, names.get(index)));
+		const target = destination(document, names.get(index + 1));
+		if (name && target) output.set(name, target);
+	}
+	const kids = resolve(document, dictionary.get(key("Kids")));
+	if (kids instanceof PDFArray) for (let index = 0; index < kids.size(); index += 1) nameTree(document, kids.get(index), output);
+}
+function namedDestinations(document) {
+	const output = /* @__PURE__ */ new Map();
+	const names = resolve(document, document.catalog.get(key("Names")));
+	if (names instanceof PDFDict) nameTree(document, names.get(key("Dests")), output);
+	const direct = resolve(document, document.catalog.get(key("Dests")));
+	if (direct instanceof PDFDict) for (const [name, value] of direct.entries()) {
+		const target = destination(document, value);
+		if (target) output.set(name.toString().slice(1), target);
+	}
+	return output;
+}
+function hiddenAnnotation(document, annotation) {
+	const rectangle = resolve(document, annotation.get(key("Rect")));
+	if (!(rectangle instanceof PDFArray) || rectangle.size() !== 4) return false;
+	const values = Array.from({ length: 4 }, (_, index) => resolve(document, rectangle.get(index)));
+	if (!values.every((value) => value instanceof PDFNumber)) return false;
+	const [left = 0, bottom = 0, right = 0, top = 0] = values.map((value) => value.asNumber());
+	return Math.abs(right - left) <= 1 && Math.abs(top - bottom) <= 1;
+}
+function explicit(document, target, offset) {
+	return document.context.obj([
+		document.getPage(offset + target.page - 1).ref,
+		"XYZ",
+		target.x,
+		target.y,
+		null
+	]);
+}
+function customTarget(uri) {
+	if (!uri?.startsWith("segnavia:target/")) return void 0;
+	try {
+		return decodeURIComponent(uri.slice(16));
+	} catch {
+		return uri.slice(16);
+	}
+}
+function rewriteBookLinks(document, frontPages, front, body) {
+	for (const [pageIndex, page] of document.getPages().entries()) {
+		const annotations = resolve(document, page.node.get(key("Annots")));
+		if (!(annotations instanceof PDFArray)) continue;
+		const kept = Array.from({ length: annotations.size() }, (_, index) => annotations.get(index)).filter((object) => rewriteAnnotation(document, object, pageIndex, frontPages, front, body));
+		if (kept.length > 0) page.node.set(key("Annots"), document.context.obj(kept));
+		else page.node.delete(key("Annots"));
+	}
+}
+function rewriteAnnotation(document, object, pageIndex, frontPages, front, body) {
+	const annotation = resolve(document, object);
+	if (!(annotation instanceof PDFDict)) return true;
+	if (hiddenAnnotation(document, annotation)) return false;
+	const named = decode(resolve(document, annotation.get(key("Dest"))));
+	const action = resolve(document, annotation.get(key("A")));
+	const uri = action instanceof PDFDict ? decode(resolve(document, action.get(key("URI")))) : void 0;
+	const cross = customTarget(uri);
+	const target = cross ? front.get(cross) ?? body.get(cross) : named ? pageIndex < frontPages ? front.get(named) : body.get(named) : void 0;
+	if (cross && !target) throw new RenderRefusedError(`The segnavia link to ${cross} has no printed destination.`);
+	if (target) {
+		const offset = front.has(cross ?? "") || !cross && pageIndex < frontPages ? 0 : frontPages;
+		annotation.set(key("Dest"), explicit(document, target, offset));
+		annotation.delete(key("A"));
+	} else if (uri?.startsWith("segnavia:")) throw new RenderRefusedError(`The PDF still contains the segnavia link ${uri}.`);
+	return true;
+}
+//#endregion
+export { namedDestinations, rewriteBookLinks };

package/dist/book-margins.js

@@ -0,0 +1,20 @@
+import { resolveDirection, sheetMm } from "@segnavia/format";
+//#region src/book-margins.ts
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+function marginCss(book) {
+	if (!book.page) return "";
+	const size = sheetMm(book.page);
+	const edge = book.page.margin;
+	return `@page{size:${size.width}mm ${size.height}mm;margin:0}:where(html,body){margin:0}:where(.segnavia-margin-page){position:relative;inline-size:${size.width}mm;block-size:${size.height}mm;break-after:page;direction:ltr}:where(.segnavia-running-head,.segnavia-folio){position:absolute;display:flex;align-items:center}:where(.segnavia-running-head){inset-block-start:0;block-size:${edge.top}mm}:where(.segnavia-folio){inset-block-end:0;block-size:${edge.bottom}mm}:where([data-side="left"] .segnavia-running-head,[data-side="left"] .segnavia-folio){inset-inline-start:${edge.outer}mm;inset-inline-end:${edge.inner}mm;justify-content:flex-start}:where([data-side="right"] .segnavia-running-head,[data-side="right"] .segnavia-folio){inset-inline-start:${edge.inner}mm;inset-inline-end:${edge.outer}mm;justify-content:flex-end}`;
+}
+function marginDocument(book, pages) {
+	return pages.map((page) => {
+		const head = page.runningHead === void 0 ? "" : `<div class="segnavia-running-head"><bdi dir="${resolveDirection(book.dir, book.lang, page.runningHead)}">${escapeHtml(page.runningHead)}</bdi></div>`;
+		const folio = page.folio === void 0 ? "" : `<div class="segnavia-folio"><bdi dir="${resolveDirection(book.dir, book.lang, page.folio)}">${escapeHtml(page.folio)}</bdi></div>`;
+		return `<div class="segnavia-margin-page" data-side="${page.side}">${head}${folio}</div>`;
+	}).join("");
+}
+//#endregion
+export { marginCss, marginDocument };

package/dist/book-pdf.js

@@ -0,0 +1,233 @@
+import { marginDocument } from "./book-margins.js";
+import { RenderRefusedError } from "./errors.js";
+import { namedDestinations, rewriteBookLinks } from "./book-destinations.js";
+import { Book, formatNumber, resolveDirection, sheetMm } from "@segnavia/format";
+import { PDFDocument } from "pdf-lib";
+import { bookDocument, bookPrintPart } from "@segnavia/html";
+//#region src/book-pdf.ts
+async function inspect(bytes) {
+	const document = await PDFDocument.load(bytes);
+	return {
+		bytes,
+		pages: document.getPageCount(),
+		destinations: namedDestinations(document)
+	};
+}
+function hashTargets(document) {
+	return [...new Set([...document.html.matchAll(/href="#([^"]+)"/g)].map((match) => match[1]))];
+}
+function requireTargets(part, expected) {
+	const missing = expected.filter((id) => !part.destinations.has(id));
+	if (missing.length > 0) throw new RenderRefusedError(`Chromium wrote ${expected.length - missing.length} of ${expected.length} named destinations for hidden targets; missing ${missing.join(", ")}.`);
+}
+const sectionsFor = (sections, part) => sections.filter((section) => bookPrintPart(section.kind) === part);
+function planBlanks(sections, destinations) {
+	const ids = [];
+	const predicted = /* @__PURE__ */ new Map();
+	let blanks = 0;
+	for (const section of sectionsFor(sections, "body")) {
+		const original = destinations.get(section.id)?.page;
+		if (original === void 0) throw new RenderRefusedError(`The first body print has no destination for ${section.id}.`);
+		let page = original + blanks;
+		if (page % 2 === 0) {
+			ids.push(section.id);
+			blanks += 1;
+			page += 1;
+		}
+		predicted.set(section.id, page);
+	}
+	return {
+		ids,
+		predicted
+	};
+}
+function verifyStarts(label, sections, expected, actual) {
+	for (const section of sections) {
+		const predicted = expected.get(section.id);
+		const found = actual.get(section.id)?.page;
+		if (predicted !== found) throw new RenderRefusedError(`${section.id} was predicted to start on ${label} page ${predicted}, but started on page ${found}.`);
+	}
+}
+async function appendBlank(part) {
+	if (!part.bytes) return part;
+	const document = await PDFDocument.load(part.bytes);
+	const last = document.getPage(document.getPageCount() - 1);
+	document.addPage([last.getWidth(), last.getHeight()]);
+	return {
+		...part,
+		bytes: await document.save(),
+		pages: part.pages + 1
+	};
+}
+function pageSide(book, physicalPage) {
+	const odd = resolveDirection(book.dir, book.lang, book.title) === "rtl" ? "left" : "right";
+	return physicalPage % 2 === 1 ? odd : odd === "left" ? "right" : "left";
+}
+function marginsFor(book, sections, destinations, pages, offset, blanks, system) {
+	const starts = sections.flatMap((section) => {
+		const page = destinations.get(section.id)?.page;
+		return page === void 0 ? [] : [{
+			page,
+			section
+		}];
+	}).sort((left, right) => left.page - right.page);
+	return Array.from({ length: pages }, (_, index) => {
+		const page = index + 1;
+		if (blanks.has(page)) return {
+			kind: "blank",
+			side: pageSide(book, offset + page)
+		};
+		const owner = starts.filter((start) => start.page <= page).at(-1);
+		return {
+			kind: owner?.section.kind ?? "blank",
+			side: pageSide(book, offset + page),
+			folio: formatNumber(page, system),
+			runningHead: owner?.page === page ? void 0 : owner?.section.runningHead
+		};
+	});
+}
+function destinationOwner(id, destination, sections, destinations) {
+	const owner = sections.flatMap((section) => {
+		const start = destinations.get(section.id);
+		return start && start.page <= destination.page ? [{
+			section,
+			start
+		}] : [];
+	}).sort((left, right) => left.start.page - right.start.page).at(-1)?.section;
+	return owner ? `${owner.title ?? owner.id} (${owner.id})` : id;
+}
+function frontPrintStatus(prints, ids, sections) {
+	if (prints.length < 2) return { status: "more" };
+	const expected = prints.at(-2);
+	const actual = prints.at(-1);
+	for (const id of ids) {
+		const before = expected.get(id);
+		const after = actual.get(id);
+		if (!before || !after || before.page === after.page) continue;
+		if (prints.length < 3) return { status: "more" };
+		return {
+			status: "refused",
+			message: `Front destination ${id} in ${destinationOwner(id, before, sections, expected)} moved from page ${before.page} to page ${after.page} after three prints.`
+		};
+	}
+	return { status: "stable" };
+}
+function finalNumbers(book, headings, front, body) {
+	return Object.fromEntries(headings.map((heading) => {
+		const frontPage = front.destinations.get(heading.id)?.page;
+		if (frontPage !== void 0) return [heading.id, formatNumber(frontPage, book.numbering.frontMatter)];
+		const bodyPage = body.destinations.get(heading.id)?.page;
+		if (bodyPage === void 0) throw new RenderRefusedError(`The heading ${heading.id} has no printed destination.`);
+		return [heading.id, formatNumber(bodyPage, book.numbering.body)];
+	}));
+}
+async function printBody(book, options, adapter) {
+	const firstDocument = bookDocument(book, {
+		part: "body",
+		targets: true
+	});
+	if (firstDocument.issues.length > 0) throw new RenderRefusedError(`The book cannot be printed: ${firstDocument.issues.join("; ")}.`);
+	let part = await inspect(await adapter.print(firstDocument.html, book, options));
+	requireTargets(part, hashTargets(firstDocument));
+	const plan = book.rectoOpenings ? planBlanks(firstDocument.sections, part.destinations) : {
+		ids: [],
+		predicted: /* @__PURE__ */ new Map()
+	};
+	if (book.rectoOpenings) {
+		const finalDocument = bookDocument(book, {
+			part: "body",
+			targets: true,
+			blankBefore: plan.ids
+		});
+		part = await inspect(await adapter.print(finalDocument.html, book, options));
+		requireTargets(part, hashTargets(finalDocument));
+		verifyStarts("body", sectionsFor(firstDocument.sections, "body"), plan.predicted, part.destinations);
+	}
+	return {
+		document: firstDocument,
+		part,
+		blankBefore: plan.ids
+	};
+}
+async function printFront(book, source, body, options, adapter) {
+	const sections = sectionsFor(source.sections, "front");
+	if (sections.length === 0) return {
+		part: {
+			pages: 0,
+			destinations: /* @__PURE__ */ new Map()
+		},
+		trailingBlank: false
+	};
+	const ids = [];
+	const prints = [];
+	let numbers;
+	let final;
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		const document = bookDocument(book, {
+			part: "front",
+			targets: true,
+			crossLinks: true,
+			pageNumbers: numbers
+		});
+		const printed = await inspect(await adapter.print(document.html, book, options));
+		if (ids.length === 0) ids.push(...hashTargets(document));
+		requireTargets(printed, ids);
+		prints.push(printed);
+		const status = frontPrintStatus(prints.map((part) => part.destinations), ids, sections);
+		if (status.status === "stable") {
+			final = printed;
+			break;
+		}
+		if (status.status === "refused") throw new RenderRefusedError(status.message);
+		numbers = finalNumbers(book, source.headings, printed, body);
+	}
+	if (!final) throw new RenderRefusedError("The front print did not converge after three prints.");
+	const trailingBlank = book.rectoOpenings && final.pages % 2 === 1;
+	return {
+		part: trailingBlank ? await appendBlank(final) : final,
+		trailingBlank
+	};
+}
+async function join(front, body, marginBytes) {
+	const output = await PDFDocument.create();
+	for (const part of [front, body]) {
+		if (!part.bytes) continue;
+		const source = await PDFDocument.load(part.bytes);
+		for (const page of await output.copyPages(source, source.getPageIndices())) output.addPage(page);
+	}
+	const layer = await PDFDocument.load(marginBytes);
+	if (layer.getPageCount() !== output.getPageCount()) throw new RenderRefusedError(`The margin layer has ${layer.getPageCount()} pages, but the book has ${output.getPageCount()}.`);
+	for (const [index, page] of layer.getPages().entries()) {
+		const [embedded] = await output.embedPdf(layer, [index]);
+		if (embedded) output.getPage(index).drawPage(embedded, {
+			x: 0,
+			y: 0,
+			width: page.getWidth(),
+			height: page.getHeight()
+		});
+	}
+	rewriteBookLinks(output, front.pages, front.destinations, body.destinations);
+	return output.save();
+}
+async function renderBookPdf(input, options, adapter) {
+	const book = Book.parse(input);
+	if (book.mode === "paginated") throw new RenderRefusedError("bookPdf prints continuous books; printing a paginated book is not built yet.");
+	if (!book.page) throw new RenderRefusedError("Printing a continuous book needs page; set page before calling bookPdf.");
+	const printedBody = await printBody(book, options, adapter);
+	const printedFront = await printFront(book, printedBody.document, printedBody.part, options, adapter);
+	const front = printedFront.part;
+	const bodyBlankPages = new Set(printedBody.blankBefore.map((id) => (printedBody.part.destinations.get(id)?.page ?? 1) - 1));
+	const frontBlankPages = new Set(printedFront.trailingBlank ? [front.pages] : []);
+	const marginPages = [...marginsFor(book, sectionsFor(printedBody.document.sections, "front"), front.destinations, front.pages, 0, frontBlankPages, book.numbering.frontMatter), ...marginsFor(book, sectionsFor(printedBody.document.sections, "body"), printedBody.part.destinations, printedBody.part.pages, front.pages, bodyBlankPages, book.numbering.body)];
+	const marginBytes = await adapter.print(marginDocument(book, marginPages), book, options, true);
+	return adapter.finish(await join(front, printedBody.part, marginBytes), options);
+}
+function bookPageCss(book, marginLayer = false) {
+	if (!book.page) return "";
+	const size = sheetMm(book.page);
+	if (marginLayer) return `@page{size:${size.width}mm ${size.height}mm;margin:0}`;
+	const edge = book.page.margin;
+	return `@page{size:${size.width}mm ${size.height}mm;margin-top:${edge.top}mm;margin-bottom:${edge.bottom}mm}@page :right{margin-left:${edge.inner}mm;margin-right:${edge.outer}mm}@page :left{margin-left:${edge.outer}mm;margin-right:${edge.inner}mm}`;
+}
+//#endregion
+export { bookPageCss, frontPrintStatus, renderBookPdf };

package/dist/book-render.js

@@ -0,0 +1,48 @@
+import { marginCss } from "./book-margins.js";
+import { RenderRefusedError } from "./errors.js";
+import { bookPageCss, renderBookPdf } from "./book-pdf.js";
+import { PX_PER_MM, resolveDirection, sheetMm } from "@segnavia/format";
+import { frameDocument, newNonce } from "@segnavia/frame/bridge";
+//#region src/book-render.ts
+function renderBrowserBookPdf(input, options, dependencies) {
+	return renderBookPdf(input, options, {
+		print: (html, book, renderOptions, marginLayer = false) => {
+			if (!book.page) throw new RenderRefusedError("Printing a continuous book needs page; set page before calling bookPdf.");
+			const size = sheetMm(book.page);
+			const css = `${bookPageCss(book, marginLayer)}${marginLayer ? marginCss(book) : ""}${dependencies.fontFaces(renderOptions)}${renderOptions.css ?? ""}`;
+			return dependencies.render({
+				viewport: {
+					width: Math.round(size.width * PX_PER_MM),
+					height: Math.round(size.height * PX_PER_MM)
+				},
+				scripts: !marginLayer && book.scripts === "sandboxed",
+				html: frameDocument(html, {
+					scripts: marginLayer ? "refuse" : book.scripts,
+					nonce: newNonce(),
+					dir: marginLayer ? "ltr" : resolveDirection(book.dir, book.lang, book.title),
+					lang: book.lang,
+					css,
+					relayKeys: false,
+					reportHeight: false
+				}),
+				waitForReady: !marginLayer && book.scripts === "sandboxed" && renderOptions.waitForPageReady !== false,
+				boundMs: renderOptions.boundMs,
+				beforeOutput: renderOptions.beforeOutput
+			}, {
+				width: `${size.width}mm`,
+				height: `${size.height}mm`,
+				printBackground: true,
+				preferCSSPageSize: true,
+				margin: {
+					top: "0mm",
+					right: "0mm",
+					bottom: "0mm",
+					left: "0mm"
+				}
+			});
+		},
+		finish: dependencies.finish
+	});
+}
+//#endregion
+export { renderBrowserBookPdf };

package/dist/deck-pdf.js

@@ -1,4 +1,5 @@
 import { RenderRefusedError } from "./errors.js";
+import { containFixedPageOverflow } from "./overflow-containment.js";
 import { pdfPixelBox } from "./pdf-geometry.js";
 import { composeImposedPdf, drawClippedPage, embedOnePage } from "./pdf-compose.js";
 import { Imposition, fitPage, impose, pagePlacementLayout } from "@segnavia/format";
@@ -20,6 +21,7 @@ async function regularDeckPdf(deck, opts, services) {
 		html: slide.content.html
 	}] : []);
 	const css = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const slideCss = containFixedPageOverflow(css);
 	const notesGeometry = opts.layout === "notes" ? notesLayoutGeometry(deck.size, opts.notesPaper) : void 0;
 	const [printable, rendered] = await Promise.all([services.renderPdf({
 		viewport: notesGeometry ? {
@@ -46,7 +48,7 @@ async function regularDeckPdf(deck, opts, services) {
 					scripts: deck.scripts === "sandboxed",
 					html: htmlSlideDocument(deck, html, {
 						nonce: newNonce(),
-						css
+						css: slideCss
 					}),
 					boundMs: opts.boundMs
 				}, {
@@ -84,7 +86,7 @@ async function regularDeckPdf(deck, opts, services) {
 	return services.finish(await output.save(), opts);
 }
 async function imposedDeckPdf(deck, imposition, opts, services) {
-	const css = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const css = containFixedPageOverflow(`${services.fontFaces(opts)}${opts.css ?? ""}`);
 	const imposed = impose(imposition, deck.slides.length);
 	const rendered = await Promise.all(deck.slides.map(async (slide, index) => {
 		const single = {

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { EffectsReport } from "./effects/types.js";
 import { 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 PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };

package/dist/index.js

@@ -1,5 +1,8 @@
 import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
+import { renderBrowserBookPdf } from "./book-render.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";
@@ -61,7 +64,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);
 		output = converted.bytes;
 		options.press.report?.(converted.report);
 	}
@@ -187,7 +192,9 @@ async function openRenderer(options) {
 		}
 	}
 	function pageDocument(page, options, printing = false) {
-		const css = `${page.print ? printing ? printCss(page.print) : printProperties(page.print) : ""}${fontFaces(options.fonts)}${options.css ?? ""}`;
+		const hostCss = `${page.print ? printing ? printCss(page.print) : printProperties(page.print) : ""}${fontFaces(options.fonts)}${options.css ?? ""}`;
+		const fixedSize = typeof page.size === "object" && page.size.height !== "auto";
+		const css = printing && !page.print && fixedSize ? containFixedPageOverflow(hostCss) : hostCss;
 		return frameDocument(page.html, {
 			scripts: page.scripts,
 			nonce: newNonce(),
@@ -238,7 +245,7 @@ async function openRenderer(options) {
 			nonce: newNonce(),
 			dir: page.dir,
 			lang: page.lang,
-			css,
+			css: containFixedPageOverflow(css),
 			relayKeys: false,
 			reportHeight: false
 		});
@@ -264,6 +271,13 @@ 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: finishPdf
+			});
+		},
 		async pagePdf(input, opts = {}) {
 			return finishPdf(await renderPagePdf(Page.parse(input), opts), 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/overflow-containment.js

@@ -0,0 +1,7 @@
+//#region src/overflow-containment.ts
+const CSS = ":where(:root){contain:paint;min-height:100%}";
+function containFixedPageOverflow(css) {
+	return `${CSS}${css}`;
+}
+//#endregion
+export { containFixedPageOverflow };

package/dist/press/adapter.js

@@ -1,5 +1,5 @@
 import { RenderRefusedError } from "../errors.js";
-import { cachedPressColor, pressColor } from "./color-policy.js";
+import { cachedPressColor, newlySnapsToNeutral, pressColor } 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";
@@ -77,7 +77,7 @@ function convertType1Shading(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, state.sampleConvert, state.budget, void 0, domain, size);
 }
 function convertShading(state, shading, pattern) {
 	if (state.seenShadings.has(shading)) return false;
@@ -195,31 +195,41 @@ 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 (newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
+			return cached(rgb);
+		},
 		document,
 		painted: /* @__PURE__ */ new WeakMap(),
 		profile,
+		sampleConvert: (rgb) => {
+			if (newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
+			return pressColor(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: () => {
@@ -254,17 +264,19 @@ function addOutputIntent(document, profile) {
 	}));
 	document.catalog.set(key("OutputIntents"), document.context.obj([intentRef]));
 }
-async function rewritePressPdf(bytes, profileBytes) {
+async function rewritePressPdf(bytes, profileBytes, tolerance = 3) {
 	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);
+		const counts = rewritePressDocument(document, profile, tolerance);
 		addOutputIntent(document, profileBytes);
 		const output = await document.save({ useObjectStreams: false });
+		const report = await inspectPressPdf(output);
+		report.neutralColors = counts.neutralColors;
 		return {
 			bytes: output,
-			report: await inspectPressPdf(output)
+			report
 		};
 	} catch (error) {
 		if (error instanceof RenderRefusedError) throw error;

package/dist/press/color-policy.js

@@ -1,13 +1,23 @@
+import { RenderRefusedError } from "../errors.js";
 import { toPress } from "../color/engine.js";
 //#region src/press/color-policy.ts
 const NEUTRAL_TOLERANCE = .001;
-function pressColor(profile, rgb) {
+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);
 }
@@ -16,16 +26,16 @@ function formatPdfNumber(value) {
 	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 = pressColor(profile, rgb, tolerance);
 		cache.set(key, converted);
 		return converted;
 	};
 }
 //#endregion
-export { cachedPressColor, formatPdfNumber, pressColor };
+export { assertNeutralTolerance, cachedPressColor, formatPdfNumber, newlySnapsToNeutral, pressColor, snapsToNeutral };

package/dist/press/report.js

@@ -68,7 +68,8 @@ async function inspectPressPdf(bytes) {
 			strokes: 0,
 			gradientStops: 0,
 			sampledShadings: 0,
-			groups: 0
+			groups: 0,
+			neutralColors: 0
 		},
 		shadings: /* @__PURE__ */ new WeakSet()
 	};

package/dist/press/types.d.ts

@@ -14,5 +14,7 @@ export interface PressReport {
   /** Function-based shadings rewritten as DeviceCMYK sampled functions. */
   sampledShadings: number;
   groups: number;
+  /** Color conversions snapped to black ink by the configured tolerance but not by the exact-neutral rule. */
+  neutralColors: number;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/render",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,8 +26,9 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.3.0",
-    "@segnavia/frame": "0.3.0",
+    "@segnavia/format": "0.5.0",
+    "@segnavia/frame": "0.5.0",
+    "@segnavia/html": "0.5.0",
     "playwright-core": "1.55.1",
     "pdf-lib": "^1.17.1"
   }