@segnavia/render 0.5.0 → 0.6.0

package/dist/browser-jpeg.js

@@ -0,0 +1,42 @@
+//#region src/browser-jpeg.ts
+function browserJpegDecoder(tab) {
+	return async (bytes) => {
+		const encoded = Buffer.from(bytes).toString("base64");
+		const decoded = await tab.evaluate(async (base64) => {
+			const binary = atob(base64);
+			const source = Uint8Array.from(binary, (value) => value.charCodeAt(0));
+			const bitmap = await createImageBitmap(new Blob([source], { type: "image/jpeg" }), {
+				colorSpaceConversion: "none",
+				premultiplyAlpha: "none"
+			});
+			try {
+				const context = new OffscreenCanvas(bitmap.width, bitmap.height).getContext("2d");
+				if (!context) throw new Error("Chromium could not create a 2D canvas for JPEG decoding");
+				context.drawImage(bitmap, 0, 0);
+				const rgba = context.getImageData(0, 0, bitmap.width, bitmap.height).data;
+				const rgb = new Uint8Array(bitmap.width * bitmap.height * 3);
+				for (let pixel = 0; pixel < bitmap.width * bitmap.height; pixel++) {
+					rgb[pixel * 3] = rgba[pixel * 4] ?? 0;
+					rgb[pixel * 3 + 1] = rgba[pixel * 4 + 1] ?? 0;
+					rgb[pixel * 3 + 2] = rgba[pixel * 4 + 2] ?? 0;
+				}
+				let value = "";
+				for (let offset = 0; offset < rgb.length; offset += 32768) value += String.fromCharCode(...rgb.subarray(offset, Math.min(rgb.length, offset + 32768)));
+				return {
+					width: bitmap.width,
+					height: bitmap.height,
+					rgb: btoa(value)
+				};
+			} finally {
+				bitmap.close();
+			}
+		}, encoded);
+		return {
+			width: decoded.width,
+			height: decoded.height,
+			rgb: new Uint8Array(Buffer.from(decoded.rgb, "base64"))
+		};
+	};
+}
+//#endregion
+export { browserJpegDecoder };

package/dist/color/black-point.js

@@ -2,7 +2,7 @@ import { checked } from "./types.js";
 import { D50, labToXyz, matrix3, tableDecode, tableEncode, tryInvert3, xyzToLab } from "./spaces.js";
 //#region src/color/black-point.ts
 function detectSourceBlackPoint(colorSpace, pcs, major, relativeA2b, perceptualB2a) {
-	if (colorSpace !== "CMYK") return [
+	if (colorSpace !== "CMYK" && colorSpace !== "GRAY") return [
 		0,
 		0,
 		0
@@ -19,11 +19,12 @@ function detectSourceBlackPoint(colorSpace, pcs, major, relativeA2b, perceptualB
 		checked(result, 2, "black-point A2B result")
 	]);
 	const lab = pcs === "Lab " ? returned : xyzToLab(returned);
-	return [
+	const black = [
 		Math.min(50, lab[0]),
 		0,
 		0
 	];
+	return pcs === "Lab " ? black : labToXyz(black);
 }
 function quadraticRoot(x, y) {
 	if (x.length < 4) return 0;
@@ -61,14 +62,15 @@ function quadraticRoot(x, y) {
 	return discriminant <= 0 ? 0 : Math.max(0, Math.min(50, (-b + Math.sqrt(discriminant)) / (2 * a)));
 }
 function destinationBlackPoint(colorSpace, pcs, major, relativeA2b, relativeB2a, sourceBlack) {
-	if (colorSpace !== "CMYK") return [...sourceBlack];
+	if (colorSpace !== "CMYK" && colorSpace !== "GRAY") return [...sourceBlack];
+	const sourceLab = pcs === "Lab " ? sourceBlack : xyzToLab(sourceBlack);
 	const inputRamp = [], outputRamp = [];
 	for (let index = 0; index < 256; index++) {
 		const lightness = index * 100 / 255;
 		const lab = [
 			lightness,
-			Math.max(-50, Math.min(50, sourceBlack[1])),
-			Math.max(-50, Math.min(50, sourceBlack[2]))
+			Math.max(-50, Math.min(50, sourceLab[1])),
+			Math.max(-50, Math.min(50, sourceLab[2]))
 		];
 		const value = pcs === "Lab " ? lab : labToXyz(lab);
 		const device = relativeB2a.run(tableEncode(pcs, relativeB2a.encoding, major, value, false));
@@ -97,11 +99,12 @@ function destinationBlackPoint(colorSpace, pcs, major, relativeA2b, relativeB2a,
 			y.push(normalized);
 		}
 	}
-	return [
+	const result = [
 		x.length < 3 ? 0 : quadraticRoot(x, y),
-		sourceBlack[1],
-		sourceBlack[2]
+		sourceLab[1],
+		sourceLab[2]
 	];
+	return pcs === "Lab " ? result : labToXyz(result);
 }
 function compensateBlackPoint(profile, lab, reverse) {
 	const point = reverse ? profile.sourceBlackPoint : profile.destinationBlackPoint;

package/dist/color/engine.js

@@ -1,4 +1,4 @@
-import { clamp, color4, refuse } from "./types.js";
+import { clamp, color1, color4, refuse } from "./types.js";
 import { labToXyz, srgbToLab, tableEncode } from "./spaces.js";
 import { compensateBlackPoint } from "./black-point.js";
 //#region src/color/engine.ts
@@ -14,5 +14,12 @@ function toPress(profile, rgb) {
 		clamp(black)
 	];
 }
+function toGray(profile, rgb) {
+	if (profile.colorSpace !== "GRAY") refuse(`destination color space ${profile.colorSpace}`, "GRAY");
+	const lab = compensateBlackPoint(profile, srgbToLab(rgb), false);
+	const pcs = profile.pcs === "Lab " ? lab : labToXyz(lab);
+	const [gray] = color1(profile.b2a.run(tableEncode(profile.pcs, profile.b2a.encoding, profile.majorVersion, pcs, true)), "B2A result");
+	return [clamp(gray)];
+}
 //#endregion
-export { toPress };
+export { toGray, toPress };

package/dist/color/interpolation.js

@@ -34,6 +34,16 @@ function multilinear(grid, points, outputs, input) {
 	}
 	return result;
 }
+function linearGrid(grid, points, outputs, input) {
+	const count = checked(points, 0, "CLUT dimensions");
+	const position = clamp(checked(input, 0, "CLUT input")) * (count - 1);
+	const low = Math.min(count - 2, Math.floor(position));
+	const fraction = position - low;
+	return Array.from({ length: outputs }, (_, channel) => {
+		const lower = grid.get(low * outputs + channel);
+		return lower + (grid.get((low + 1) * outputs + channel) - lower) * fraction;
+	});
+}
 function tetrahedral4(grid, points, outputs, input) {
 	const { base, fractions, stride } = layout(points, outputs, input);
 	const order = [
@@ -71,4 +81,4 @@ function matrixInput(values) {
 	];
 }
 //#endregion
-export { interpolate, matrixInput, multilinear, tetrahedral4 };
+export { interpolate, linearGrid, matrixInput, multilinear, tetrahedral4 };

package/dist/color/profile.js

@@ -1,7 +1,7 @@
 import { REVERSE_LUT, checked, refuse } from "./types.js";
 import { destinationBlackPoint, detectSourceBlackPoint } from "./black-point.js";
 import { fixed, need, signature, u32 } from "./binary.js";
-import { matrixTables, parseMab, parseMft } from "./tables.js";
+import { grayTables, matrixTables, parseMab, parseMft } from "./tables.js";
 //#region src/color/profile.ts
 const MAX_PROFILE_BYTES = 33554432;
 function header(bytes, view, bounds) {
@@ -12,7 +12,7 @@ function header(bytes, view, bounds) {
 	const profileClass = signature(bytes, 12, bounds);
 	if (profileClass !== "prtr" && profileClass !== "mntr") refuse(`profile class ${JSON.stringify(profileClass)}`, "prtr or mntr");
 	const colorSpace = signature(bytes, 16, bounds);
-	if (colorSpace !== "CMYK" && colorSpace !== "RGB ") refuse(`color space ${JSON.stringify(colorSpace)}`, "CMYK or RGB");
+	if (colorSpace !== "CMYK" && colorSpace !== "GRAY" && colorSpace !== "RGB ") refuse(`color space ${JSON.stringify(colorSpace)}`, "CMYK, GRAY, or RGB");
 	const pcs = signature(bytes, 20, bounds);
 	if (pcs !== "Lab " && pcs !== "XYZ ") refuse(`PCS ${JSON.stringify(pcs)}`, "Lab or XYZ");
 	u32(view, 0, bounds);
@@ -55,6 +55,13 @@ function table(bytes, view, all, names, inputs, outputs) {
 	if (!record) throw new Error(`ICC profile is missing ${name} after its tag set was validated`);
 	return recordTable(bytes, view, record, inputs, outputs);
 }
+function optionalTable(bytes, view, all, names, inputs, outputs) {
+	const name = names.find((candidate) => all[candidate]);
+	if (!name) return void 0;
+	const record = all[name];
+	if (!record) throw new Error(`ICC profile is missing ${name} after its tag set was validated`);
+	return recordTable(bytes, view, record, inputs, outputs);
+}
 function readProfile(bytes) {
 	if (bytes.length > 33554432) refuse(`profile length ${bytes.length}`, `at most ${MAX_PROFILE_BYTES} bytes`);
 	const bounds = {
@@ -63,12 +70,15 @@ function readProfile(bytes) {
 	}, view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 	const parsed = header(bytes, view, bounds), all = records(bytes, view, bounds);
 	if (all.wtpt?.type !== "XYZ ") refuse(`white point tag type ${JSON.stringify(all.wtpt?.type ?? "missing")}`, "XYZ ");
-	const channels = parsed.colorSpace === "CMYK" ? 4 : 3;
+	const channels = parsed.colorSpace === "CMYK" ? 4 : parsed.colorSpace === "GRAY" ? 1 : 3;
 	const matrix = parsed.colorSpace === "RGB " ? matrixTables(bytes, view, all) : void 0;
-	const a2b = matrix?.a2b ?? table(bytes, view, all, ["A2B1", "A2B0"], channels, 3);
-	const b2a = matrix?.b2a ?? table(bytes, view, all, ["B2A1", "B2A0"], 3, channels);
-	const perceptualA2b = matrix?.a2b ?? table(bytes, view, all, ["A2B0", "A2B1"], channels, 3);
-	const perceptualB2a = matrix?.b2a ?? table(bytes, view, all, ["B2A0", "B2A1"], 3, channels);
+	const trcRecord = all.kTRC;
+	const gray = parsed.colorSpace === "GRAY" && trcRecord ? grayTables(bytes, view, trcRecord, parsed.pcs) : void 0;
+	const select = (names, inputs, outputs, fallback) => optionalTable(bytes, view, all, names, inputs, outputs) ?? fallback ?? table(bytes, view, all, names, inputs, outputs);
+	const a2b = matrix?.a2b ?? select(["A2B1", "A2B0"], channels, 3, gray?.a2b);
+	const b2a = matrix?.b2a ?? select(["B2A1", "B2A0"], 3, channels, gray?.b2a);
+	const perceptualA2b = matrix?.a2b ?? select(["A2B0", "A2B1"], channels, 3, gray?.a2b);
+	const perceptualB2a = matrix?.b2a ?? select(["B2A0", "B2A1"], 3, channels, gray?.b2a);
 	const gamutRecord = all.gamt, gamut = gamutRecord ? recordTable(bytes, view, gamutRecord, 3, 1) : void 0;
 	const white = all.wtpt;
 	if (!white) throw new Error("ICC profile is missing wtpt after its tag set was validated");

package/dist/color/tables.js

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

package/dist/color/types.js

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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { EffectsReport } from "./effects/types.js";
-import { PressImage, PressReport } from "./press/types.js";
+import { PressDestination, PressImage, PressReport } from "./press/types.js";
 import { Font, ImageOptions, RenderLimits, RenderOptions } from "./options.js";
 import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
 import { BookInput, Deck, ImpositionInput, PageInput } from "@segnavia/format";
@@ -33,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 Font, type ImageOptions, type PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };
+export { type EffectsReport, type Font, type ImageOptions, type PressDestination, type PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };

package/dist/index.js

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