@segnavia/render 0.1.0 → 0.3.0

package/dist/effects/rule-c.js

@@ -0,0 +1,354 @@
+import { IDENTITY_MATRIX, applyAffine } from "../press/affine.js";
+import { visitContentOperations } from "../press/content.js";
+import { decodeContent, dictionaryOf, nameOf, numberOf, resolvedColorSpace } from "../press/pdf-objects.js";
+import { GENERATED_EFFECT_IMAGE_KEY } from "./types.js";
+import { SHADING_SAMPLE_SPACING_PT, chargeShadingSamples } from "../press/sample-shading.js";
+import { functionEvaluator } from "./function-evaluator.js";
+import { EMPTY_EFFECT_GRAPHICS_STATE, advanceEffectGraphicsState, effectFormStructure, effectGraphicsStateOpacity, effectGraphicsStateStructure, effectGraphicsStateValue } from "./structure.js";
+import { PDFArray, PDFDict, PDFName, PDFNumber, PDFRawStream, PDFRef } from "pdf-lib";
+import { deflateSync } from "node:zlib";
+//#region src/effects/rule-c.ts
+const key = (name) => PDFName.of(name);
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+const MAX_EFFECT_COVERAGE_LAYERS = 4096;
+function arrayNumbers(dictionary, label) {
+	const array = dictionary.lookupMaybe(key(label), PDFArray);
+	if (!array) return void 0;
+	const values = [];
+	for (let index = 0; index < array.size(); index++) {
+		const value = array.lookupMaybe(index, PDFNumber)?.asNumber();
+		if (value === void 0 || !Number.isFinite(value)) return void 0;
+		values.push(value);
+	}
+	return values;
+}
+function clamp(value) {
+	return Math.max(0, Math.min(1, value));
+}
+function axialLayer(document, pattern) {
+	if (numberOf(pattern, "PatternType") !== 2) return void 0;
+	const shading = dictionaryOf(resolved(document, pattern.get(key("Shading"))));
+	if (!shading || numberOf(shading, "ShadingType") !== 2) return void 0;
+	const space = resolvedColorSpace(document, resolved(document, shading.get(key("ColorSpace")))).kind;
+	const channels = space === "rgb" ? 3 : space === "gray" ? 1 : 0;
+	const coords = arrayNumbers(shading, "Coords");
+	const matrix = arrayNumbers(pattern, "Matrix") ?? IDENTITY_MATRIX;
+	const domain = arrayNumbers(shading, "Domain") ?? [0, 1];
+	const evaluate = functionEvaluator(document, shading.get(key("Function")), channels);
+	if (!channels || coords?.length !== 4 || matrix.length !== 6 || domain.length !== 2 || !evaluate) return void 0;
+	const start = applyAffine(matrix, coords[0] ?? 0, coords[1] ?? 0);
+	const end = applyAffine(matrix, coords[2] ?? 0, coords[3] ?? 0);
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	if (!(dx * dx + dy * dy > 0)) return void 0;
+	return {
+		axis: {
+			start,
+			end
+		},
+		channels,
+		cost: evaluate.cost,
+		evaluate: (position) => evaluate((domain[0] ?? 0) + position * ((domain[1] ?? 1) - (domain[0] ?? 0))).map(clamp)
+	};
+}
+function operations(stream, budget) {
+	const found = [];
+	visitContentOperations(decodeContent(stream, budget), (operation) => found.push(operation));
+	return found;
+}
+function simplePaintStream(stream, budget) {
+	const source = new TextDecoder("latin1").decode(decodeContent(stream, budget));
+	return !/[()]/.test(source) && !/(?:^|\s)(?:BT|ET|Tj|TJ)(?:\s|$)/.test(source);
+}
+function paints(document, stream, inherited, budget) {
+	const resources = stream.dict.lookupMaybe(key("Resources"), PDFDict) ?? inherited;
+	const states = resources?.lookupMaybe(key("ExtGState"), PDFDict);
+	const patterns = resources?.lookupMaybe(key("Pattern"), PDFDict);
+	const xObjects = resources?.lookupMaybe(key("XObject"), PDFDict);
+	const stack = [];
+	const graphicsStack = [];
+	let graphicsState = EMPTY_EFFECT_GRAPHICS_STATE;
+	let pattern;
+	const result = [];
+	for (const operation of operations(stream, budget)) {
+		const name = operation.operands.at(-1)?.kind === "name" ? operation.operands.at(-1)?.raw.slice(1) : void 0;
+		graphicsState = advanceEffectGraphicsState(document, operation, states, graphicsState, graphicsStack);
+		if (operation.operator === "q") stack.push(pattern);
+		else if (operation.operator === "Q") pattern = stack.pop();
+		else if (["scn", "SCN"].includes(operation.operator) && name) pattern = resolved(document, patterns?.get(key(name)));
+		else if (operation.operator === "Do" && name) result.push({
+			graphicsState,
+			operation,
+			xObject: resolved(document, xObjects?.get(key(name)))
+		});
+		else if ([
+			"f",
+			"f*",
+			"F"
+		].includes(operation.operator)) result.push({
+			graphicsState,
+			operation,
+			pattern
+		});
+	}
+	return result;
+}
+function inspectForm(context, stream) {
+	if (nameOf(stream.dict.get(key("Subtype"))) === "Form" && effectFormStructure(stream.dict) === "other") context.structure = "other";
+}
+function inspectGraphicsState(context, graphicsState) {
+	if (graphicsState.structure === "other") context.structure = "other";
+}
+function singleLayer(document, stream, budget, context, depth = 0) {
+	inspectForm(context, stream);
+	if (depth > 12 || !simplePaintStream(stream, budget)) return void 0;
+	const items = paints(document, stream, void 0, budget);
+	for (const item of items) inspectGraphicsState(context, item.graphicsState);
+	if (items.length !== 1 || effectGraphicsStateValue(items[0]?.graphicsState ?? EMPTY_EFFECT_GRAPHICS_STATE, "SMask")) return void 0;
+	const item = items[0];
+	if (!item) return void 0;
+	if (effectGraphicsStateOpacity(item.graphicsState) !== 1) return void 0;
+	if (item.pattern instanceof PDFDict) {
+		const axial = axialLayer(document, item.pattern);
+		if (axial) return axial;
+		if (item.pattern instanceof PDFRawStream) return singleLayer(document, item.pattern, budget, context, depth + 1);
+	}
+	return item.xObject instanceof PDFRawStream ? singleLayer(document, item.xObject, budget, context, depth + 1) : void 0;
+}
+function transfer(document, mask) {
+	const object = resolved(document, mask.get(key("TR")));
+	if (!object || nameOf(object) === "Identity") return "identity";
+	if (!(object instanceof PDFRawStream) || numberOf(object.dict, "FunctionType") !== 4) return void 0;
+	return new TextDecoder("latin1").decode(object.contents).replace(/\s+/g, " ").trim() === "{1 exch sub}" ? "invert" : void 0;
+}
+function mappedCoverage(coverage, mapped) {
+	if (mapped === "identity") return coverage;
+	return coverage.kind === "constant" ? {
+		kind: "constant",
+		value: 1 - coverage.value
+	} : {
+		...coverage,
+		transfer: coverage.transfer === "identity" ? "invert" : "identity"
+	};
+}
+function scaledCoverage(coverage, opacity) {
+	return coverage.kind === "constant" ? {
+		kind: "constant",
+		value: coverage.value * opacity
+	} : {
+		...coverage,
+		opacity: coverage.opacity * opacity
+	};
+}
+function maskCoverage(document, mask, budget, masks, context, depth) {
+	masks.push(mask);
+	const source = resolved(document, mask.get(key("G")));
+	if (!(source instanceof PDFRawStream)) return void 0;
+	const mode = nameOf(mask.get(key("S")));
+	const mapped = transfer(document, mask);
+	if (!mapped) return void 0;
+	if (mode === "Alpha") {
+		const coverage = alphaCoverage(document, source, budget, masks, context, depth + 1);
+		return coverage ? mappedCoverage(coverage, mapped) : void 0;
+	}
+	if (mode !== "Luminosity") return void 0;
+	const layer = singleLayer(document, source, budget, context, depth + 1);
+	const gray = layer?.channels === 1 || layer?.channels === 3 && [
+		0,
+		.5,
+		1
+	].every((position) => {
+		const sample = layer.evaluate(position);
+		return sample.every((value) => Math.abs(value - (sample[0] ?? 0)) < .001);
+	});
+	return layer && gray ? {
+		kind: "layer",
+		layer,
+		opacity: 1,
+		transfer: mapped
+	} : void 0;
+}
+function alphaCoverage(document, stream, budget, masks, context, depth = 0) {
+	inspectForm(context, stream);
+	if (depth > 12 || !simplePaintStream(stream, budget)) return void 0;
+	const items = paints(document, stream, void 0, budget);
+	for (const found of items) inspectGraphicsState(context, found.graphicsState);
+	if (items.length !== 1) return void 0;
+	const item = items[0];
+	if (!item) return void 0;
+	const opacity = effectGraphicsStateOpacity(item.graphicsState);
+	if (opacity === void 0) return void 0;
+	const mask = dictionaryOf(resolved(document, effectGraphicsStateValue(item.graphicsState, "SMask")));
+	if (mask) {
+		const found = maskCoverage(document, mask, budget, masks, context, depth);
+		return found ? scaledCoverage(found, opacity) : void 0;
+	}
+	if (item.xObject instanceof PDFRawStream) {
+		const found = alphaCoverage(document, item.xObject, budget, masks, context, depth + 1);
+		return found ? scaledCoverage(found, opacity) : void 0;
+	}
+	if (item.pattern instanceof PDFRawStream) {
+		const found = alphaCoverage(document, item.pattern, budget, masks, context, depth + 1);
+		return found ? scaledCoverage(found, opacity) : void 0;
+	}
+	return item.pattern instanceof PDFDict || [
+		"f",
+		"f*",
+		"F"
+	].includes(item.operation.operator) ? {
+		kind: "constant",
+		value: opacity
+	} : void 0;
+}
+function sameAxis(left, right) {
+	const lx = left.end.x - left.start.x;
+	const ly = left.end.y - left.start.y;
+	const rx = right.end.x - right.start.x;
+	const ry = right.end.y - right.start.y;
+	const scale = Math.hypot(lx, ly) * Math.hypot(rx, ry);
+	if (!(scale > 0) || Math.abs(lx * ry - ly * rx) > scale * 1e-4) return false;
+	return Math.abs((right.start.x - left.start.x) * ly - (right.start.y - left.start.y) * lx) <= scale * 1e-4;
+}
+function compositeCoverage(document, items, budget, context) {
+	if (items.length > 4096) return void 0;
+	const masks = [];
+	const coverage = [];
+	for (const item of items) {
+		inspectGraphicsState(context, item.graphicsState);
+		const opacity = effectGraphicsStateOpacity(item.graphicsState);
+		const mask = dictionaryOf(resolved(document, effectGraphicsStateValue(item.graphicsState, "SMask")));
+		const source = resolved(document, mask?.get(key("G")));
+		if (opacity === void 0 || !mask || !(source instanceof PDFRawStream) || nameOf(mask.get(key("S"))) !== "Alpha") return void 0;
+		masks.push(mask);
+		const found = alphaCoverage(document, source, budget, masks, context);
+		const mapped = transfer(document, mask);
+		if (!found || !mapped) return void 0;
+		coverage.push(scaledCoverage(mappedCoverage(found, mapped), opacity));
+	}
+	return {
+		coverage,
+		masks
+	};
+}
+function candidate(context, nested, oneAxis, plan) {
+	return {
+		nested,
+		oneAxis,
+		plan,
+		structure: context.structure
+	};
+}
+function ruleCPlan(document, form, outerGraphicsState, budget) {
+	const context = { structure: "allowed" };
+	if (effectGraphicsStateStructure(outerGraphicsState) === "other") context.structure = "other";
+	inspectForm(context, form);
+	if (!simplePaintStream(form, budget)) return candidate(context, false, "non-shading");
+	const bbox = arrayNumbers(form.dict, "BBox");
+	const items = paints(document, form, void 0, budget);
+	const nested = items.some((item) => dictionaryOf(resolved(document, effectGraphicsStateValue(item.graphicsState, "SMask"))) !== void 0);
+	if (bbox?.length !== 4 || items.length < 1 || items.some((item) => !(item.xObject instanceof PDFRawStream))) return candidate(context, nested, "non-shading");
+	const colorObject = items[0]?.xObject;
+	if (!(colorObject instanceof PDFRawStream) || nameOf(colorObject.dict.get(key("Subtype"))) !== "Form") return candidate(context, nested, "non-shading");
+	const color = singleLayer(document, colorObject, budget, context);
+	if (color?.channels !== 3 || items.some((item) => item.xObject !== colorObject)) return candidate(context, nested, "non-shading");
+	const combined = compositeCoverage(document, items, budget, context);
+	if (!combined) return candidate(context, nested, "non-shading");
+	const { coverage, masks } = combined;
+	const layers = coverage.filter((value) => value.kind === "layer");
+	if (layers.length === 0) return candidate(context, nested, "non-shading");
+	if (layers.some(({ layer }) => !sameAxis(color.axis, layer.axis))) return candidate(context, nested, "different");
+	return candidate(context, nested, "shared", {
+		bbox,
+		color,
+		coverage,
+		masks
+	});
+}
+function positionOnAxis(axis, x, y) {
+	const dx = axis.end.x - axis.start.x;
+	const dy = axis.end.y - axis.start.y;
+	return ((x - axis.start.x) * dx + (y - axis.start.y) * dy) / (dx * dx + dy * dy);
+}
+function buildRuleCImage(document, plan, opacity, budget, printMatrix) {
+	const dx = plan.color.axis.end.x - plan.color.axis.start.x;
+	const dy = plan.color.axis.end.y - plan.color.axis.start.y;
+	const length = Math.hypot(dx, dy);
+	if (!(length > 0)) return void 0;
+	const ux = dx / length;
+	const uy = dy / length;
+	const vx = -uy;
+	const vy = ux;
+	const [left = 0, bottom = 0, right = 0, top = 0] = plan.bbox;
+	const corners = [
+		[left, bottom],
+		[left, top],
+		[right, bottom],
+		[right, top]
+	];
+	const along = corners.map(([x = 0, y = 0]) => x * ux + y * uy);
+	const across = corners.map(([x = 0, y = 0]) => x * vx + y * vy);
+	const amin = Math.min(...along);
+	const amax = Math.max(...along);
+	const vmin = Math.min(...across);
+	const vmax = Math.max(...across);
+	const printStart = applyAffine(printMatrix, plan.color.axis.start.x, plan.color.axis.start.y);
+	const printEnd = applyAffine(printMatrix, plan.color.axis.end.x, plan.color.axis.end.y);
+	const printScale = Math.hypot(printEnd.x - printStart.x, printEnd.y - printStart.y) / length;
+	const rows = Math.ceil((amax - amin) * printScale / SHADING_SAMPLE_SPACING_PT) + 1;
+	if (rows > 1048576) return void 0;
+	const operations = rows * (plan.color.cost + plan.coverage.reduce((sum, coverage) => sum + (coverage.kind === "layer" ? coverage.layer.cost : 0), 0));
+	if ((budget.calculatorOperations ?? 0) + operations > 436207616) return void 0;
+	chargeShadingSamples(budget, rows, operations);
+	const rgb = new Uint8Array(rows * 3);
+	const gray = new Uint8Array(rows);
+	for (let row = 0; row < rows; row++) {
+		const distance = amin + (amax - amin) * row / Math.max(1, rows - 1);
+		const x = ux * distance + vx * ((vmin + vmax) / 2);
+		const y = uy * distance + vy * ((vmin + vmax) / 2);
+		const colorPosition = positionOnAxis(plan.color.axis, x, y);
+		const color = plan.color.evaluate(colorPosition);
+		rgb.set(color.map((value) => Math.round(clamp(value) * 255)), (rows - row - 1) * 3);
+		let alpha = 0;
+		for (const coverage of plan.coverage) {
+			let value = coverage.kind === "constant" ? coverage.value : coverage.layer.evaluate(positionOnAxis(coverage.layer.axis, x, y))[0] ?? 0;
+			if (coverage.kind === "layer" && coverage.transfer === "invert") value = 1 - value;
+			if (coverage.kind === "layer") value *= coverage.opacity;
+			alpha = alpha + clamp(value) * (1 - alpha);
+		}
+		gray[rows - row - 1] = Math.round(clamp(alpha * opacity) * 255);
+	}
+	const mask = document.context.register(document.context.stream(deflateSync(gray), {
+		Type: "XObject",
+		Subtype: "Image",
+		Width: 1,
+		Height: rows,
+		ColorSpace: "DeviceGray",
+		BitsPerComponent: 8,
+		Interpolate: true,
+		Filter: "FlateDecode"
+	}));
+	return {
+		image: document.context.register(document.context.stream(deflateSync(rgb), {
+			Type: "XObject",
+			Subtype: "Image",
+			Width: 1,
+			Height: rows,
+			ColorSpace: "DeviceRGB",
+			BitsPerComponent: 8,
+			Interpolate: true,
+			Filter: "FlateDecode",
+			SMask: mask,
+			[GENERATED_EFFECT_IMAGE_KEY]: true
+		})),
+		matrix: [
+			vx * (vmax - vmin),
+			vy * (vmax - vmin),
+			ux * (amax - amin),
+			uy * (amax - amin),
+			vx * vmin + ux * amin,
+			vy * vmin + uy * amin
+		]
+	};
+}
+//#endregion
+export { MAX_EFFECT_COVERAGE_LAYERS, buildRuleCImage, ruleCPlan };

package/dist/effects/structure.js

@@ -0,0 +1,86 @@
+import { dictionaryOf, nameOf } from "../press/pdf-objects.js";
+import { PDFArray, PDFName, PDFNumber, PDFRef } from "pdf-lib";
+//#region src/effects/structure.ts
+const key = (name) => PDFName.of(name);
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+const EMPTY_EFFECT_GRAPHICS_STATE = {
+	dictionaries: [],
+	structure: "allowed"
+};
+function finiteNumber(dictionary, label) {
+	const object = dictionary.get(key(label));
+	const value = object instanceof PDFRef ? dictionary.context.lookup(object) : object;
+	const number = value instanceof PDFNumber ? value.asNumber() : void 0;
+	return number !== void 0 && Number.isFinite(number) ? number : void 0;
+}
+function effectOpacity(graphicsState) {
+	if (!graphicsState?.has(key("ca"))) return 1;
+	return finiteNumber(graphicsState, "ca");
+}
+function effectGraphicsStateStructure(graphicsState) {
+	if (!graphicsState) return "allowed";
+	for (const [name] of graphicsState.entries()) {
+		const label = name.toString().slice(1);
+		if (label === "Type" || label === "SMask") continue;
+		if (label === "ca" && finiteNumber(graphicsState, label) !== void 0) continue;
+		if (label === "CA" && finiteNumber(graphicsState, label) === 1) continue;
+		if (label === "BM" && nameOf(graphicsState.lookup(key(label))) === "Normal") continue;
+		return "other";
+	}
+	return "allowed";
+}
+function advanceEffectGraphicsState(document, operation, states, current, stack) {
+	if (operation.operator === "q") {
+		stack.push(current);
+		return current;
+	}
+	if (operation.operator === "Q") return stack.pop() ?? EMPTY_EFFECT_GRAPHICS_STATE;
+	const operand = operation.operands[0];
+	if (operation.operator !== "gs") return current;
+	if (operation.operands.length !== 1 || operand?.kind !== "name") return {
+		...current,
+		structure: "other"
+	};
+	const dictionary = dictionaryOf(resolved(document, states?.get(key(operand.raw.slice(1)))));
+	if (!dictionary) return {
+		...current,
+		structure: "other"
+	};
+	return {
+		dictionaries: [...current.dictionaries, dictionary],
+		structure: current.structure === "other" || effectGraphicsStateStructure(dictionary) === "other" ? "other" : "allowed"
+	};
+}
+function effectGraphicsStateValue(state, label) {
+	for (let index = state.dictionaries.length - 1; index >= 0; index--) {
+		const dictionary = state.dictionaries[index];
+		if (dictionary?.has(key(label))) return dictionary.get(key(label));
+	}
+}
+function effectGraphicsStateOpacity(state) {
+	for (let index = state.dictionaries.length - 1; index >= 0; index--) {
+		const dictionary = state.dictionaries[index];
+		if (dictionary?.has(key("ca"))) return effectOpacity(dictionary);
+	}
+	return 1;
+}
+function effectFormStructure(form) {
+	if (!form.has(key("Matrix"))) return "allowed";
+	const matrix = form.lookupMaybe(key("Matrix"), PDFArray);
+	if (matrix?.size() !== 6) return "other";
+	const identity = [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	for (let index = 0; index < identity.length; index++) {
+		const value = matrix.lookupMaybe(index, PDFNumber)?.asNumber();
+		if (value === void 0 || !Number.isFinite(value) || Math.abs(value - (identity[index] ?? 0)) > 1e-9) return "other";
+	}
+	return "allowed";
+}
+//#endregion
+export { EMPTY_EFFECT_GRAPHICS_STATE, advanceEffectGraphicsState, effectFormStructure, effectGraphicsStateOpacity, effectGraphicsStateStructure, effectGraphicsStateValue, effectOpacity };

package/dist/effects/types.d.ts

@@ -0,0 +1,15 @@
+//#region src/effects/types.d.ts
+/**
+ * Counts the implemented rewrites. Rule 2 is unbuilt, Rule 3 is left out
+ * because measurements show it is ineffective, and Rule 4 is unbuilt and
+ * will be opt-in and off by default when implemented.
+ */
+export interface EffectsReport {
+  /** Luminosity masks rewritten from a grayscale image group to a direct image alpha mask. */
+  rule1: number;
+  /** Nested one-axis shading composites rewritten as an interpolated image and direct alpha mask. */
+  ruleC: number;
+  /** Soft masks left in the form Chromium wrote. */
+  kept: number;
+}
+//#endregion

package/dist/effects/types.js

@@ -0,0 +1,4 @@
+//#region src/effects/types.ts
+const GENERATED_EFFECT_IMAGE_KEY = "SegnaviaGeneratedEffect";
+//#endregion
+export { GENERATED_EFFECT_IMAGE_KEY };

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+//#region src/errors.d.ts
+export declare class RendererUnavailableError extends Error {
+  name: string;
+}
+export declare class RenderRefusedError extends Error {
+  name: string;
+}
+//#endregion

package/dist/errors.js

@@ -0,0 +1,9 @@
+//#region src/errors.ts
+var RendererUnavailableError = class extends Error {
+	name = "RendererUnavailableError";
+};
+var RenderRefusedError = class extends Error {
+	name = "RenderRefusedError";
+};
+//#endregion
+export { RenderRefusedError, RendererUnavailableError };

package/dist/index.d.ts

@@ -1,19 +1,16 @@
-import { Deck, PageInput } from "@segnavia/format";
+import { EffectsReport } from "./effects/types.js";
+import { PressImage, PressReport } from "./press/types.js";
+import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
+import { 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
 export declare const RENDER_BOUND_MS = 60000;
 export declare const PAGE_READY_BOUND_MS = 10000;
 export declare const CONTAINER_ARGS: string[];
-export declare class RendererUnavailableError extends Error {
-  name: string;
-}
 export declare class RenderTimeoutError extends Error {
   name: string;
 }
-export declare class RenderRefusedError extends Error {
-  name: string;
-}
 export interface Font {
   family: string;
   data: Uint8Array;
@@ -33,6 +30,15 @@ export interface RenderOptions {
   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';
@@ -48,6 +54,9 @@ export interface RendererOptions {
 }
 export interface Renderer {
   pagePdf(page: PageInput, options?: RenderOptions): Promise<Uint8Array>;
+  pagesPdf(pages: PageInput[], options?: RenderOptions & {
+    imposition?: ImpositionInput;
+  }): Promise<Uint8Array>;
   pageImage(page: PageInput, options?: ImageOptions): Promise<Uint8Array>;
   deckPdf(deck: Deck, options?: RenderOptions & PrintOptions): Promise<Uint8Array>;
   slideImage(deck: Deck, index: number, options?: ImageOptions & Pick<PrintOptions, 'inline'>): Promise<Uint8Array>;
@@ -56,4 +65,5 @@ export interface Renderer {
 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
+//#endregion
+export { type EffectsReport, type PressImage, type PressReport, RenderRefusedError, RendererUnavailableError };