@segnavia/render 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,322 @@
+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";
+import { chromium } from "playwright-core";
+//#region src/index.ts
+const RENDER_BOUND_MS = 6e4;
+const PAGE_READY_BOUND_MS = 1e4;
+const FLUID_WIDTH = 1024;
+const CONTAINER_ARGS = [
+	"--no-sandbox",
+	"--disable-setuid-sandbox",
+	"--disable-dev-shm-usage",
+	"--disable-gpu"
+];
+const NO_NETWORK_ARGS = [
+	"--proxy-server=socks5://127.0.0.1:9",
+	"--proxy-bypass-list=<-loopback>",
+	"--force-webrtc-ip-handling-policy=disable_non_proxied_udp"
+];
+var RenderTimeoutError = class extends Error {
+	name = "RenderTimeoutError";
+};
+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("");
+}
+async function withinBound(ms, work) {
+	let timer;
+	const bound = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(new RenderTimeoutError(`The render did not finish within ${ms / 1e3}s.`)), ms);
+	});
+	try {
+		return await Promise.race([work, bound]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function sheets(pdf) {
+	return (await PDFDocument.load(pdf)).getPageCount();
+}
+async function enforce(pdf, limits) {
+	if (limits?.maxBytes !== void 0 && pdf.byteLength > limits.maxBytes) throw new RenderRefusedError(`The PDF is ${pdf.byteLength} bytes; the limit is ${limits.maxBytes}.`);
+	if (limits?.maxSheets !== void 0) {
+		const count = await sheets(pdf);
+		if (count > limits.maxSheets) throw new RenderRefusedError(`The PDF has ${count} sheets; the limit is ${limits.maxSheets}.`);
+	}
+	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({
+		type: format,
+		fullPage,
+		...format === "jpeg" ? { quality: options.quality?.[0] ?? 90 } : {}
+	});
+	const session = await tab.context().newCDPSession(tab);
+	try {
+		const clip = await tab.evaluate((wholePage) => {
+			const scale = devicePixelRatio;
+			if (wholePage) return {
+				x: 0,
+				y: 0,
+				width: document.documentElement.scrollWidth,
+				height: document.documentElement.scrollHeight,
+				scale
+			};
+			return {
+				x: scrollX,
+				y: scrollY,
+				width: innerWidth,
+				height: innerHeight,
+				scale
+			};
+		}, fullPage);
+		for (const quality of options.quality ?? [
+			90,
+			80,
+			70
+		]) {
+			const { data } = await session.send("Page.captureScreenshot", {
+				format: "webp",
+				quality,
+				captureBeyondViewport: fullPage,
+				clip
+			});
+			const bytes = Buffer.from(data, "base64");
+			if (options.limits?.maxBytes === void 0 || bytes.byteLength <= options.limits.maxBytes) return bytes;
+		}
+	} finally {
+		await session.detach();
+	}
+	throw new RenderRefusedError(`The image is larger than ${options.limits?.maxBytes} bytes at every quality tried.`);
+}
+async function contentHeight(tab) {
+	const width = tab.viewportSize()?.width ?? FLUID_WIDTH;
+	await tab.setViewportSize({
+		width,
+		height: 1
+	});
+	const height = await tab.evaluate(() => Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0));
+	await tab.setViewportSize({
+		width,
+		height
+	});
+	return height;
+}
+async function openRenderer(options) {
+	let browser;
+	try {
+		browser = await chromium.launch({
+			executablePath: options.executablePath,
+			args: [
+				...options.args ?? [],
+				...NO_NETWORK_ARGS,
+				...options.jsHeapMb ? [`--js-flags=--max-old-space-size=${options.jsHeapMb}`] : []
+			]
+		});
+	} catch (error) {
+		throw new RendererUnavailableError(`Chromium at ${options.executablePath} could not start: ${error.message}`);
+	}
+	const limit = options.concurrency ?? 2;
+	let running = 0;
+	const waiting = [];
+	const acquire = () => {
+		if (running < limit) {
+			running++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => waiting.push(resolve));
+	};
+	const release = () => {
+		const next = waiting.shift();
+		if (next) next();
+		else running--;
+	};
+	async function withTab(setup, body) {
+		await acquire();
+		let context;
+		try {
+			return await withinBound(setup.boundMs ?? 6e4, (async () => {
+				context = await browser.newContext({
+					viewport: setup.viewport,
+					deviceScaleFactor: setup.scale ?? 1,
+					javaScriptEnabled: setup.scripts,
+					offline: true
+				});
+				await context.route("**/*", (route) => route.request().url().startsWith("data:") ? route.continue() : route.abort("blockedbyclient"));
+				await context.routeWebSocket("**/*", (socket) => socket.close());
+				const tab = await context.newPage();
+				let ready;
+				const readyPromise = new Promise((resolve) => {
+					ready = resolve;
+				});
+				if (setup.waitForReady) await tab.exposeFunction("pageReady", () => ready?.());
+				await tab.setContent(setup.html, { waitUntil: "load" });
+				if (setup.waitForReady) await withinBound(PAGE_READY_BOUND_MS, readyPromise).catch(() => {
+					throw new RenderRefusedError(`The page did not call window.pageReady() within ${PAGE_READY_BOUND_MS / 1e3}s.`);
+				});
+				await tab.evaluate(() => document.fonts.ready.then(() => true)).catch(() => {});
+				await setup.beforeOutput?.(tab);
+				return body(tab);
+			})());
+		} finally {
+			await context?.close().catch(() => {});
+			release();
+		}
+	}
+	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(),
+			dir: page.dir,
+			lang: page.lang,
+			css,
+			relayKeys: false,
+			reportHeight: false
+		});
+	}
+	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
+		};
+		return {
+			width: page.size.width,
+			height: page.size.height === "auto" ? 800 : page.size.height
+		};
+	}
+	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 = {}) {
+			return finishPdf(await renderPagePdf(Page.parse(input), opts), opts);
+		},
+		async pageImage(input, opts = {}) {
+			const page = Page.parse(input);
+			const viewport = pageViewport(page, opts.width);
+			const grows = page.size === "fluid" || typeof page.size === "object" && page.size.height === "auto";
+			return withTab({
+				viewport,
+				scripts: page.scripts === "sandboxed",
+				scale: opts.scale,
+				html: pageDocument(page, opts),
+				waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
+				boundMs: opts.boundMs,
+				beforeOutput: opts.beforeOutput
+			}, async (tab) => {
+				if (grows) await contentHeight(tab);
+				return image(tab, opts, false);
+			});
+		},
+		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
+			});
+		},
+		async slideImage(deck, index, opts = {}) {
+			const slide = deck.slides[index];
+			if (!slide) throw new RangeError(`The deck has no slide ${index + 1}.`);
+			const single = {
+				...deck,
+				slides: [slide]
+			};
+			const css = `${fontFaces(opts.fonts)}${opts.css ?? ""}`;
+			const html = printableDeck(single, {
+				inline: opts.inline,
+				css
+			});
+			return withTab({
+				viewport: deck.size,
+				scripts: deck.scripts === "sandboxed",
+				scale: opts.scale,
+				html,
+				waitForReady: false,
+				boundMs: opts.boundMs,
+				beforeOutput: opts.beforeOutput
+			}, (tab) => image(tab, opts, false));
+		},
+		close: () => browser.close()
+	};
+}
+//#endregion
+export { CONTAINER_ARGS, PAGE_READY_BOUND_MS, RENDER_BOUND_MS, RenderRefusedError, RenderTimeoutError, RendererUnavailableError, captureImage, fontFaces, openRenderer };

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 };