@segnavia/render 0.4.0 → 0.6.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/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");