@segnavia/render 0.1.0 → 0.3.0

package/dist/color/tables.js

@@ -0,0 +1,255 @@
+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";
+//#region src/color/tables.ts
+function packed(bytes, view, offset, length, width, bounds) {
+	need(offset, length * width, bounds);
+	return {
+		length,
+		get(index) {
+			if (!Number.isInteger(index) || index < 0 || index >= length) throw new Error(`${bounds.name} sample index ${index} is outside length ${length}`);
+			return width === 1 ? checked(bytes, offset + index, `${bounds.name} samples`) / 255 : u16(view, offset + index * 2, bounds) / 65535;
+		}
+	};
+}
+const parametric = [
+	(p, x) => clamp(x) ** checked(p, 0, "parametric curve"),
+	(p, x) => {
+		const g = checked(p, 0, "parametric curve"), a = checked(p, 1, "parametric curve"), b = checked(p, 2, "parametric curve");
+		return x >= -b / a ? (a * x + b) ** g : 0;
+	},
+	(p, x) => {
+		const g = checked(p, 0, "parametric curve"), a = checked(p, 1, "parametric curve"), b = checked(p, 2, "parametric curve"), c = checked(p, 3, "parametric curve");
+		return x >= -b / a ? (a * x + b) ** g + c : c;
+	},
+	(p, x) => {
+		const g = checked(p, 0, "parametric curve"), a = checked(p, 1, "parametric curve"), b = checked(p, 2, "parametric curve"), c = checked(p, 3, "parametric curve");
+		return x >= checked(p, 4, "parametric curve") ? (a * x + b) ** g : c * x;
+	},
+	(p, x) => {
+		const g = checked(p, 0, "parametric curve"), a = checked(p, 1, "parametric curve"), b = checked(p, 2, "parametric curve"), c = checked(p, 3, "parametric curve"), d = checked(p, 4, "parametric curve"), e = checked(p, 5, "parametric curve"), f = checked(p, 6, "parametric curve");
+		return x >= d ? (a * x + b) ** g + e : c * x + f;
+	}
+];
+function parseCurve(bytes, view, offset, bounds) {
+	need(offset, 12, bounds);
+	const type = signature(bytes, offset, bounds);
+	if (type === "curv") {
+		const count = u32(view, offset + 8, bounds);
+		need(offset + 12, count * 2, bounds);
+		if (count === 0) return {
+			curve: (value) => value,
+			size: 12
+		};
+		if (count === 1) {
+			const gamma = u16(view, offset + 12, bounds) / 256;
+			return {
+				curve: (value) => clamp(value) ** gamma,
+				size: 14
+			};
+		}
+		const values = packed(bytes, view, offset + 12, count, 2, bounds);
+		return {
+			curve: (value) => interpolate(values, value),
+			size: 12 + count * 2
+		};
+	}
+	if (type !== "para") return refuse(`curve tag type ${JSON.stringify(type)}`, "curv or para");
+	const kind = u16(view, offset + 8, bounds), counts = [
+		1,
+		3,
+		4,
+		5,
+		7
+	];
+	if (kind > 4) refuse(`parametric curve function ${kind}`, "functions 0 through 4");
+	const count = checked(counts, kind, "parametric curve function");
+	need(offset + 12, count * 4, bounds);
+	const parameters = Array.from({ length: count }, (_, index) => fixed(view, offset + 12 + index * 4, bounds));
+	const evaluate = checked(parametric, kind, "parametric curve function");
+	return {
+		curve: (value) => evaluate(parameters, value),
+		size: 12 + count * 4
+	};
+}
+function curvesAt(bytes, view, offset, count, bounds) {
+	const curves = [];
+	let cursor = offset;
+	for (let index = 0; index < count; index++) {
+		const parsed = parseCurve(bytes, view, cursor, bounds);
+		curves.push(parsed.curve);
+		cursor = align4(cursor + parsed.size);
+	}
+	return curves;
+}
+function channels(bytes, offset, expectedInputs, expectedOutputs, bounds) {
+	need(offset + 8, 2, bounds);
+	const inputs = checked(bytes, offset + 8, `${bounds.name} header`), outputs = checked(bytes, offset + 9, `${bounds.name} header`);
+	if (inputs !== expectedInputs || outputs !== expectedOutputs) refuse(`${bounds.name} channel count ${inputs}->${outputs}`, `${expectedInputs}->${expectedOutputs}`);
+}
+function parseMft(bytes, view, record, type, inputs, outputs) {
+	const { offset } = record;
+	need(offset, type === "mft1" ? 48 : 52, record);
+	channels(bytes, offset, inputs, outputs, record);
+	const pointCount = checked(bytes, offset + 10, `${type} header`);
+	if (pointCount < 2) refuse(`${type} grid point count ${pointCount}`, "at least 2");
+	const matrix = Array.from({ length: 9 }, (_, index) => fixed(view, offset + 12 + index * 4, record));
+	const inputEntries = type === "mft1" ? 256 : u16(view, offset + 48, record), outputEntries = type === "mft1" ? 256 : u16(view, offset + 50, record);
+	if (inputEntries < 2 || outputEntries < 2) refuse(`${type} table entry counts ${inputEntries}/${outputEntries}`, "at least 2 entries");
+	const width = type === "mft1" ? 1 : 2;
+	let cursor = offset + (type === "mft1" ? 48 : 52);
+	const inputTables = Array.from({ length: inputs }, () => {
+		const result = packed(bytes, view, cursor, inputEntries, width, record);
+		cursor += inputEntries * width;
+		return result;
+	});
+	const gridLength = pointCount ** inputs * outputs, grid = packed(bytes, view, cursor, gridLength, width, record);
+	cursor += gridLength * width;
+	const outputTables = Array.from({ length: outputs }, () => {
+		const result = packed(bytes, view, cursor, outputEntries, width, record);
+		cursor += outputEntries * width;
+		return result;
+	});
+	const points = Array.from({ length: inputs }, () => pointCount);
+	return {
+		inputChannels: inputs,
+		outputChannels: outputs,
+		encoding: type,
+		run(values) {
+			let current = values.map((value, channel) => interpolate(checked(inputTables, channel, `${type} input tables`), value));
+			if (inputs === 3) {
+				const fixedMatrix = [
+					checked(matrix, 0, `${type} matrix`),
+					checked(matrix, 1, `${type} matrix`),
+					checked(matrix, 2, `${type} matrix`),
+					checked(matrix, 3, `${type} matrix`),
+					checked(matrix, 4, `${type} matrix`),
+					checked(matrix, 5, `${type} matrix`),
+					checked(matrix, 6, `${type} matrix`),
+					checked(matrix, 7, `${type} matrix`),
+					checked(matrix, 8, `${type} matrix`)
+				];
+				current = matrix3(fixedMatrix, matrixInput(current));
+			}
+			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));
+		}
+	};
+}
+function mabGrid(bytes, view, record, type, offset, inputs, outputs) {
+	if (!offset) return {
+		points: [],
+		grid: void 0
+	};
+	need(offset, 20, record);
+	const points = Array.from(bytes.subarray(offset, offset + inputs));
+	const badPoint = points.find((point) => point < 2);
+	if (badPoint !== void 0) refuse(`${type} CLUT grid point count ${badPoint}`, "at least 2");
+	const precision = checked(bytes, offset + 16, `${type} CLUT`);
+	if (precision !== 1 && precision !== 2) refuse(`${type} CLUT precision ${precision}`, "1 or 2 bytes");
+	return {
+		points,
+		grid: packed(bytes, view, offset + 20, points.reduce((a, b) => a * b, outputs), precision, record)
+	};
+}
+function parseMab(bytes, view, record, type, inputs, outputs) {
+	const { offset } = record;
+	need(offset, 32, record);
+	channels(bytes, offset, inputs, outputs, record);
+	const relative = (at) => {
+		const value = u32(view, offset + at, record), absolute = value === 0 ? 0 : offset + value;
+		if (absolute) need(absolute, 1, record);
+		return absolute;
+	};
+	const bOffset = relative(12), matrixOffset = relative(16), mOffset = relative(20), clutOffset = relative(24), aOffset = relative(28);
+	const bCurves = bOffset ? curvesAt(bytes, view, bOffset, type === "mAB " ? outputs : inputs, record) : [];
+	const mCurves = mOffset ? curvesAt(bytes, view, mOffset, type === "mAB " ? outputs : inputs, record) : [];
+	const aCurves = aOffset ? curvesAt(bytes, view, aOffset, type === "mAB " ? inputs : outputs, record) : [];
+	if (matrixOffset) need(matrixOffset, 48, record);
+	const matrix = matrixOffset ? Array.from({ length: 12 }, (_, index) => fixed(view, matrixOffset + index * 4, record)) : [];
+	const { points, grid } = mabGrid(bytes, view, record, type, clutOffset, inputs, outputs);
+	const apply = (curves, values) => curves.length ? values.map((value, index) => checked(curves, index, `${type} curves`)(value)) : [...values];
+	const applyMatrix = (values) => {
+		if (!matrix.length) return [...values];
+		const [x, y, z] = matrixInput(values);
+		return [
+			0,
+			1,
+			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);
+	return {
+		inputChannels: inputs,
+		outputChannels: outputs,
+		encoding: type,
+		run(values) {
+			return type === "mAB " ? apply(bCurves, applyMatrix(apply(mCurves, clut(apply(aCurves, values))))) : apply(aCurves, clut(apply(mCurves, applyMatrix(apply(bCurves, values)))));
+		}
+	};
+}
+function matrixTables(bytes, view, records) {
+	const names = [
+		"rXYZ",
+		"gXYZ",
+		"bXYZ",
+		"rTRC",
+		"gTRC",
+		"bTRC"
+	];
+	if (!names.every((name) => records[name])) return void 0;
+	const record = (name) => {
+		const found = records[name];
+		if (!found) throw new Error(`ICC profile is missing ${name} after its tag set was validated`);
+		return found;
+	};
+	for (const name of names.slice(0, 3)) if (record(name).type !== "XYZ ") refuse(`${name} tag type ${record(name).type}`, "XYZ ");
+	const columns = names.slice(0, 3).map((name) => {
+		const tag = record(name);
+		need(tag.offset, 20, tag);
+		return [
+			fixed(view, tag.offset + 8, tag),
+			fixed(view, tag.offset + 12, tag),
+			fixed(view, tag.offset + 16, tag)
+		];
+	});
+	const curves = names.slice(3).map((name) => parseCurve(bytes, view, record(name).offset, record(name)).curve);
+	const matrix = [
+		checked(checked(columns, 0, "colorants"), 0, "red"),
+		checked(checked(columns, 1, "colorants"), 0, "green"),
+		checked(checked(columns, 2, "colorants"), 0, "blue"),
+		checked(checked(columns, 0, "colorants"), 1, "red"),
+		checked(checked(columns, 1, "colorants"), 1, "green"),
+		checked(checked(columns, 2, "colorants"), 1, "blue"),
+		checked(checked(columns, 0, "colorants"), 2, "red"),
+		checked(checked(columns, 1, "colorants"), 2, "green"),
+		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,
+			outputChannels: 3,
+			encoding: "mAB ",
+			run: (input) => matrix3(matrix, matrixInput(input.map((value, index) => checked(curves, index, "RGB curves")(value))))
+		},
+		b2a: {
+			inputChannels: 3,
+			outputChannels: 3,
+			encoding: REVERSE_LUT,
+			run: (input) => matrix3(inverse, matrixInput(input)).map((value, index) => invertCurve(checked(curves, index, "RGB curves"), value))
+		}
+	};
+}
+//#endregion
+export { matrixTables, parseCurve, parseMab, parseMft };

package/dist/color/types.js

@@ -0,0 +1,21 @@
+//#region src/color/types.ts
+const REVERSE_LUT = "mBA ";
+function refuse(found, supported) {
+	throw new Error(`ICC profile has unsupported ${found}; supported: ${supported}`);
+}
+function checked(values, index, structure) {
+	const value = values[index];
+	if (value === void 0) throw new Error(`${structure} index ${index} is outside length ${values.length}`);
+	return value;
+}
+function color4(values, structure) {
+	return [
+		checked(values, 0, structure),
+		checked(values, 1, structure),
+		checked(values, 2, structure),
+		checked(values, 3, structure)
+	];
+}
+const clamp = (value) => Math.max(0, Math.min(1, value));
+//#endregion
+export { REVERSE_LUT, checked, clamp, color4, refuse };

package/dist/deck-pdf.js

@@ -0,0 +1,152 @@
+import { RenderRefusedError } from "./errors.js";
+import { pdfPixelBox } from "./pdf-geometry.js";
+import { composeImposedPdf, drawClippedPage, embedOnePage } from "./pdf-compose.js";
+import { Imposition, fitPage, impose, pagePlacementLayout } from "@segnavia/format";
+import { newNonce } from "@segnavia/frame/bridge";
+import { htmlSlideDocument, notesLayoutGeometry, printableDeck } from "@segnavia/frame/print-document";
+import { PDFDocument } from "pdf-lib";
+//#region src/deck-pdf.ts
+function nameSlideError(error, id) {
+	if (error instanceof Error) {
+		error.message = `Slide "${id}" could not be rendered: ${error.message}`;
+		throw error;
+	}
+	throw new Error(`Slide "${id}" could not be rendered: ${String(error)}`);
+}
+async function regularDeckPdf(deck, opts, services) {
+	const htmlSlides = deck.slides.flatMap((slide, index) => slide.content.kind === "html" ? [{
+		index,
+		id: slide.id,
+		html: slide.content.html
+	}] : []);
+	const css = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const notesGeometry = opts.layout === "notes" ? notesLayoutGeometry(deck.size, opts.notesPaper) : void 0;
+	const [printable, rendered] = await Promise.all([services.renderPdf({
+		viewport: notesGeometry ? {
+			width: Math.round(notesGeometry.sheet.width),
+			height: Math.round(notesGeometry.sheet.height)
+		} : deck.size,
+		scripts: deck.scripts === "sandboxed",
+		html: printableDeck(deck, {
+			...opts,
+			css,
+			omitHtmlSlideFrames: true
+		}),
+		boundMs: opts.boundMs,
+		beforeOutput: opts.beforeOutput
+	}, {
+		preferCSSPageSize: true,
+		printBackground: true
+	}), Promise.all(htmlSlides.map(async ({ index, id, html }) => {
+		try {
+			return {
+				index,
+				bytes: await services.renderPdf({
+					viewport: deck.size,
+					scripts: deck.scripts === "sandboxed",
+					html: htmlSlideDocument(deck, html, {
+						nonce: newNonce(),
+						css
+					}),
+					boundMs: opts.boundMs
+				}, {
+					width: `${deck.size.width}px`,
+					height: `${deck.size.height}px`,
+					printBackground: true,
+					pageRanges: "1",
+					margin: {
+						top: "0px",
+						right: "0px",
+						bottom: "0px",
+						left: "0px"
+					}
+				})
+			};
+		} catch (error) {
+			nameSlideError(error, id);
+		}
+	}))]);
+	const output = await PDFDocument.load(printable);
+	const pages = output.getPages();
+	const slideBox = notesGeometry?.slide ?? {
+		x: 0,
+		y: 0,
+		width: deck.size.width,
+		height: deck.size.height
+	};
+	const geometry = pdfPixelBox(slideBox, notesGeometry?.sheet.height ?? deck.size.height);
+	for (const item of rendered) {
+		const sheet = pages[item.index];
+		if (!sheet) throw new Error(`The print document has no sheet for slide "${deck.slides[item.index]?.id ?? item.index}".`);
+		const embedded = await embedOnePage(output, item.bytes, `The rendered slide "${deck.slides[item.index]?.id ?? item.index}"`);
+		drawClippedPage(sheet, embedded, geometry, geometry);
+	}
+	return services.finish(await output.save(), opts);
+}
+async function imposedDeckPdf(deck, imposition, opts, services) {
+	const css = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const imposed = impose(imposition, deck.slides.length);
+	const rendered = await Promise.all(deck.slides.map(async (slide, index) => {
+		const single = {
+			...deck,
+			slides: [slide]
+		};
+		try {
+			const html = slide.content.kind === "html" ? htmlSlideDocument(deck, slide.content.html, {
+				nonce: newNonce(),
+				css
+			}) : printableDeck(single, {
+				...opts,
+				layout: "slides",
+				imposition: void 0,
+				css
+			});
+			return {
+				index,
+				bytes: await services.renderPdf({
+					viewport: deck.size,
+					scripts: deck.scripts === "sandboxed",
+					html,
+					boundMs: opts.boundMs
+				}, {
+					width: `${deck.size.width}px`,
+					height: `${deck.size.height}px`,
+					printBackground: true,
+					pageRanges: "1",
+					margin: {
+						top: "0px",
+						right: "0px",
+						bottom: "0px",
+						left: "0px"
+					}
+				})
+			};
+		} catch (error) {
+			nameSlideError(error, slide.id);
+		}
+	}));
+	const placements = /* @__PURE__ */ new Map();
+	for (const placement of imposed.placements) {
+		const fit = fitPage({ size: deck.size }, placement, imposition.fit);
+		const group = placements.get(placement.page) ?? [];
+		group.push({
+			placement,
+			layout: pagePlacementLayout(deck.size, placement, fit)
+		});
+		placements.set(placement.page, group);
+	}
+	const pieces = rendered.map((item) => ({
+		key: String(item.index),
+		name: `The rendered slide "${deck.slides[item.index]?.id ?? item.index}"`,
+		bytes: item.bytes,
+		placements: placements.get(item.index) ?? []
+	}));
+	return services.finish(await composeImposedPdf(imposed, pieces), opts);
+}
+async function renderDeckPdf(deck, opts, services) {
+	if (!opts.imposition) return regularDeckPdf(deck, opts, services);
+	if (opts.layout === "notes") throw new RenderRefusedError("layout: 'notes' and imposition cannot be combined. Remove either layout: 'notes' or imposition to clear this refusal.");
+	return imposedDeckPdf(deck, Imposition.parse(opts.imposition), opts, services);
+}
+//#endregion
+export { renderDeckPdf };