@segnavia/render 0.1.0 → 0.2.0

package/dist/color/binary.js

@@ -0,0 +1,27 @@
+import { refuse } from "./types.js";
+//#region src/color/binary.ts
+function need(offset, length, bounds) {
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > bounds.end) refuse(`truncated ${bounds.name} tag`, `${bounds.name} tag structure contained within its declared size`);
+}
+function signature(bytes, offset, bounds = {
+	end: bytes.length,
+	name: "profile"
+}) {
+	need(offset, 4, bounds);
+	return String.fromCharCode(...bytes.subarray(offset, offset + 4));
+}
+function u16(view, offset, bounds) {
+	need(offset, 2, bounds);
+	return view.getUint16(offset, false);
+}
+function u32(view, offset, bounds) {
+	need(offset, 4, bounds);
+	return view.getUint32(offset, false);
+}
+function fixed(view, offset, bounds) {
+	need(offset, 4, bounds);
+	return view.getInt32(offset, false) / 65536;
+}
+const align4 = (value) => Math.ceil(value / 4) * 4;
+//#endregion
+export { align4, fixed, need, signature, u16, u32 };

package/dist/color/black-point.js

@@ -0,0 +1,121 @@
+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 [
+		0,
+		0,
+		0
+	];
+	const device = perceptualB2a.run(tableEncode(pcs, perceptualB2a.encoding, major, [
+		0,
+		0,
+		0
+	], false));
+	const result = relativeA2b.run(device);
+	const returned = tableDecode(pcs, relativeA2b.encoding, major, [
+		checked(result, 0, "black-point A2B result"),
+		checked(result, 1, "black-point A2B result"),
+		checked(result, 2, "black-point A2B result")
+	]);
+	const lab = pcs === "Lab " ? returned : xyzToLab(returned);
+	return [
+		Math.min(50, lab[0]),
+		0,
+		0
+	];
+}
+function quadraticRoot(x, y) {
+	if (x.length < 4) return 0;
+	let sx = 0, sx2 = 0, sx3 = 0, sx4 = 0, sy = 0, syx = 0, syx2 = 0;
+	for (const [index, xn] of x.entries()) {
+		const yn = checked(y, index, "quadratic sample");
+		sx += xn;
+		sx2 += xn ** 2;
+		sx3 += xn ** 3;
+		sx4 += xn ** 4;
+		sy += yn;
+		syx += yn * xn;
+		syx2 += yn * xn ** 2;
+	}
+	const matrix = [
+		x.length,
+		sx,
+		sx2,
+		sx,
+		sx2,
+		sx3,
+		sx2,
+		sx3,
+		sx4
+	];
+	const inverse = tryInvert3(matrix);
+	if (!inverse) return 0;
+	const [c, b, a] = matrix3(inverse, [
+		sy,
+		syx,
+		syx2
+	]);
+	if (Math.abs(a) < 1e-10) return Math.abs(b) < 1e-10 ? 0 : Math.max(0, Math.min(50, -c / b));
+	const discriminant = b * b - 4 * a * c;
+	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];
+	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]))
+		];
+		const value = pcs === "Lab " ? lab : labToXyz(lab);
+		const device = relativeB2a.run(tableEncode(pcs, relativeB2a.encoding, major, value, false));
+		const run = relativeA2b.run(device);
+		const returned = tableDecode(pcs, relativeA2b.encoding, major, [
+			checked(run, 0, "black-point A2B result"),
+			checked(run, 1, "black-point A2B result"),
+			checked(run, 2, "black-point A2B result")
+		]);
+		inputRamp.push(lightness);
+		outputRamp.push(pcs === "Lab " ? returned[0] : xyzToLab(returned)[0]);
+	}
+	for (let index = 254; index > 0; index--) outputRamp[index] = Math.min(checked(outputRamp, index, "black-point output ramp"), checked(outputRamp, index + 1, "black-point output ramp"));
+	const minimum = checked(outputRamp, 0, "black-point output ramp"), maximum = checked(outputRamp, 255, "black-point output ramp");
+	if (!(minimum < maximum)) return [
+		0,
+		0,
+		0
+	];
+	if (inputRamp.every((value, index) => value <= minimum + .2 * (maximum - minimum) || Math.abs(value - checked(outputRamp, index, "black-point output ramp")) < 4)) return [...sourceBlack];
+	const x = [], y = [];
+	for (let index = 0; index < 256; index++) {
+		const normalized = (checked(outputRamp, index, "black-point output ramp") - minimum) / (maximum - minimum);
+		if (normalized >= .1 && normalized < .5) {
+			x.push(checked(inputRamp, index, "black-point input ramp"));
+			y.push(normalized);
+		}
+	}
+	return [
+		x.length < 3 ? 0 : quadraticRoot(x, y),
+		sourceBlack[1],
+		sourceBlack[2]
+	];
+}
+function compensateBlackPoint(profile, lab, reverse) {
+	const point = reverse ? profile.sourceBlackPoint : profile.destinationBlackPoint;
+	const black = profile.pcs === "Lab " ? point : xyzToLab(point);
+	const blackXyz = labToXyz(black), xyz = labToXyz(lab);
+	const channel = (value, white, blackValue) => {
+		const scale = (white - blackValue) / white;
+		return reverse ? (value - blackValue) / scale : blackValue + value * scale;
+	};
+	return xyzToLab([
+		channel(xyz[0], D50[0], blackXyz[0]),
+		channel(xyz[1], D50[1], blackXyz[1]),
+		channel(xyz[2], D50[2], blackXyz[2])
+	]);
+}
+//#endregion
+export { compensateBlackPoint, destinationBlackPoint, detectSourceBlackPoint };

package/dist/color/engine.js

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

package/dist/color/interpolation.js

@@ -0,0 +1,74 @@
+import { checked, clamp } from "./types.js";
+//#region src/color/interpolation.ts
+function interpolate(table, value) {
+	if (table.length === 0) throw new Error("ICC interpolation table is empty");
+	const position = clamp(value) * (table.length - 1);
+	const low = Math.floor(position);
+	const lower = table.get(low);
+	return lower + (table.get(Math.min(low + 1, table.length - 1)) - lower) * (position - low);
+}
+function layout(points, outputs, input) {
+	const base = input.map((value, axis) => {
+		const count = checked(points, axis, "CLUT dimensions");
+		return Math.min(count - 2, Math.floor(clamp(value) * (count - 1)));
+	});
+	return {
+		base,
+		fractions: input.map((value, axis) => clamp(value) * (checked(points, axis, "CLUT dimensions") - 1) - checked(base, axis, "CLUT base")),
+		stride: points.map((_, axis) => points.slice(axis + 1).reduce((a, b) => a * b, outputs))
+	};
+}
+function multilinear(grid, points, outputs, input) {
+	const { base, fractions, stride } = layout(points, outputs, input);
+	const result = Array.from({ length: outputs }, () => 0);
+	for (let mask = 0; mask < 2 ** input.length; mask++) {
+		let weight = 1;
+		let start = 0;
+		for (let axis = 0; axis < input.length; axis++) {
+			const high = (mask & 1 << axis) !== 0;
+			const fraction = checked(fractions, axis, "CLUT fractions");
+			weight *= high ? fraction : 1 - fraction;
+			start += (checked(base, axis, "CLUT base") + Number(high)) * checked(stride, axis, "CLUT stride");
+		}
+		for (let channel = 0; channel < outputs; channel++) result[channel] = checked(result, channel, "CLUT result") + weight * grid.get(start + channel);
+	}
+	return result;
+}
+function tetrahedral4(grid, points, outputs, input) {
+	const { base, fractions, stride } = layout(points, outputs, input);
+	const order = [
+		1,
+		2,
+		3
+	].sort((a, b) => checked(fractions, b, "CLUT fractions") - checked(fractions, a, "CLUT fractions"));
+	const plane = (first) => {
+		const corner = [
+			0,
+			0,
+			0,
+			0
+		];
+		let at = base.reduce((sum, value, axis) => sum + (value + (axis === 0 ? first : 0)) * checked(stride, axis, "CLUT stride"), 0);
+		let previous = Array.from({ length: outputs }, (_, channel) => grid.get(at + channel));
+		const result = [...previous];
+		for (const axis of order) {
+			corner[axis] = 1;
+			at = base.reduce((sum, value, index) => sum + (value + (index === 0 ? first : checked(corner, index, "CLUT corner"))) * checked(stride, index, "CLUT stride"), 0);
+			const next = Array.from({ length: outputs }, (_, channel) => grid.get(at + channel));
+			for (let channel = 0; channel < outputs; channel++) result[channel] = checked(result, channel, "CLUT result") + checked(fractions, axis, "CLUT fractions") * (checked(next, channel, "CLUT corner") - checked(previous, channel, "CLUT corner"));
+			previous = next;
+		}
+		return result;
+	};
+	const low = plane(0), high = plane(1);
+	return low.map((value, channel) => value + checked(fractions, 0, "CLUT fractions") * (checked(high, channel, "CLUT high plane") - value));
+}
+function matrixInput(values) {
+	return [
+		checked(values, 0, "matrix input"),
+		checked(values, 1, "matrix input"),
+		checked(values, 2, "matrix input")
+	];
+}
+//#endregion
+export { interpolate, matrixInput, multilinear, tetrahedral4 };

package/dist/color/profile.js

@@ -0,0 +1,98 @@
+import { REVERSE_LUT, checked, refuse } from "./types.js";
+import { fixed, need, signature, u32 } from "./binary.js";
+import { destinationBlackPoint, detectSourceBlackPoint } from "./black-point.js";
+import { matrixTables, parseMab, parseMft } from "./tables.js";
+//#region src/color/profile.ts
+const MAX_PROFILE_BYTES = 33554432;
+function header(bytes, view, bounds) {
+	need(0, 132, bounds);
+	if (signature(bytes, 36, bounds) !== "acsp") refuse(`header signature ${JSON.stringify(signature(bytes, 36, bounds))}`, "\"acsp\"");
+	const major = checked(bytes, 8, "ICC header"), minor = checked(bytes, 9, "ICC header");
+	if (major !== 2 && major !== 4) refuse(`ICC version ${major}.${minor >> 4}`, "ICC version 2 or 4");
+	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");
+	const pcs = signature(bytes, 20, bounds);
+	if (pcs !== "Lab " && pcs !== "XYZ ") refuse(`PCS ${JSON.stringify(pcs)}`, "Lab or XYZ");
+	u32(view, 0, bounds);
+	return {
+		majorVersion: major,
+		profileClass,
+		colorSpace,
+		pcs
+	};
+}
+function records(bytes, view, bounds) {
+	const count = u32(view, 128, bounds);
+	if (count > 256) refuse(`tag count ${count}`, `at most 256 tags`);
+	if (count > (bytes.length - 132) / 12) refuse("truncated tag table", "tag records contained within the profile");
+	const result = {};
+	for (let index = 0; index < count; index++) {
+		const at = 132 + index * 12, name = signature(bytes, at, bounds), offset = u32(view, at + 4, bounds), size = u32(view, at + 8, bounds);
+		if (offset > bytes.length - 8 || size > bytes.length - offset) refuse(`truncated ${name} tag`, "tag data contained within the profile");
+		const record = {
+			offset,
+			size,
+			end: offset + size,
+			name,
+			type: ""
+		};
+		record.type = signature(bytes, offset, record);
+		result[name] = record;
+	}
+	return result;
+}
+function recordTable(bytes, view, record, inputs, outputs) {
+	if (record.type === "mft1" || record.type === "mft2") return parseMft(bytes, view, record, record.type, inputs, outputs);
+	if (record.type === "mAB " || record.type === "mBA ") return parseMab(bytes, view, record, record.type, inputs, outputs);
+	return refuse(`${record.name} tag type ${JSON.stringify(record.type)}`, `mft1, mft2, mAB , or ${REVERSE_LUT}`);
+}
+function table(bytes, view, all, names, inputs, outputs) {
+	const name = names.find((candidate) => all[candidate]);
+	if (!name) refuse(`missing ${names.join("/")} tag`, names.join(" or "));
+	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 = {
+		end: bytes.length,
+		name: "profile"
+	}, 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 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 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");
+	need(white.offset, 20, white);
+	const whitePoint = [
+		fixed(view, white.offset + 8, white),
+		fixed(view, white.offset + 12, white),
+		fixed(view, white.offset + 16, white)
+	];
+	const sourceBlackPoint = detectSourceBlackPoint(parsed.colorSpace, parsed.pcs, parsed.majorVersion, a2b, perceptualB2a);
+	const destination = destinationBlackPoint(parsed.colorSpace, parsed.pcs, parsed.majorVersion, a2b, b2a, sourceBlackPoint);
+	return {
+		...parsed,
+		version: `${parsed.majorVersion}.${checked(bytes, 9, "ICC header") >> 4}.${checked(bytes, 9, "ICC header") & 15}`,
+		whitePoint,
+		tags: Object.fromEntries(Object.entries(all).map(([name, record]) => [name, record.type])),
+		a2b,
+		b2a,
+		perceptualA2b,
+		perceptualB2a,
+		gamut,
+		sourceBlackPoint,
+		destinationBlackPoint: destination
+	};
+}
+//#endregion
+export { MAX_PROFILE_BYTES, readProfile };

package/dist/color/spaces.js

@@ -0,0 +1,138 @@
+import { clamp, refuse } from "./types.js";
+//#region src/color/spaces.ts
+const D50 = [
+	.9642,
+	1,
+	.8249
+];
+function matrix3(matrix, input) {
+	const [m0, m1, m2, m3, m4, m5, m6, m7, m8] = matrix;
+	const [x, y, z] = input;
+	return [
+		m0 * x + m1 * y + m2 * z,
+		m3 * x + m4 * y + m5 * z,
+		m6 * x + m7 * y + m8 * z
+	];
+}
+function tryInvert3(m) {
+	const [m0, m1, m2, m3, m4, m5, m6, m7, m8] = m;
+	const determinant = m0 * (m4 * m8 - m5 * m7) - m1 * (m3 * m8 - m5 * m6) + m2 * (m3 * m7 - m4 * m6);
+	if (Math.abs(determinant) < 1e-12) return void 0;
+	return [
+		(m4 * m8 - m5 * m7) / determinant,
+		(m2 * m7 - m1 * m8) / determinant,
+		(m1 * m5 - m2 * m4) / determinant,
+		(m5 * m6 - m3 * m8) / determinant,
+		(m0 * m8 - m2 * m6) / determinant,
+		(m2 * m3 - m0 * m5) / determinant,
+		(m3 * m7 - m4 * m6) / determinant,
+		(m1 * m6 - m0 * m7) / determinant,
+		(m0 * m4 - m1 * m3) / determinant
+	];
+}
+function invert3(m) {
+	return tryInvert3(m) ?? refuse("singular RGB colorant matrix", "an invertible rXYZ/gXYZ/bXYZ matrix");
+}
+function labToXyz(lab) {
+	const [lightness, a, b] = lab;
+	const fy = (lightness + 16) / 116;
+	const convert = (value, white) => white * (value ** 3 > 216 / 24389 ? value ** 3 : (116 * value - 16) / 903.3);
+	return [
+		convert(fy + a / 500, D50[0]),
+		convert(fy, D50[1]),
+		convert(fy - b / 200, D50[2])
+	];
+}
+function xyzToLab(xyz) {
+	const convert = (value, white) => {
+		const ratio = value / white;
+		return ratio > 216 / 24389 ? Math.cbrt(ratio) : (903.3 * ratio + 16) / 116;
+	};
+	const [x, y, z] = xyz;
+	const fx = convert(x, D50[0]), fy = convert(y, D50[1]), fz = convert(z, D50[2]);
+	return [
+		116 * fy - 16,
+		500 * (fx - fy),
+		200 * (fy - fz)
+	];
+}
+function decodePcs(pcs, encoded) {
+	const [x, y, z] = encoded;
+	return pcs === "Lab " ? [
+		x * 100,
+		y * 255 - 128,
+		z * 255 - 128
+	] : [
+		x * (65535 / 32768),
+		y * (65535 / 32768),
+		z * (65535 / 32768)
+	];
+}
+function normalizePcs(pcs, value) {
+	const [x, y, z] = value;
+	return pcs === "Lab " ? [
+		x / 100,
+		(y + 128) / 255,
+		(z + 128) / 255
+	] : [
+		x * (32768 / 65535),
+		y * (32768 / 65535),
+		z * (32768 / 65535)
+	];
+}
+function tableEncode(pcs, encoding, major, value, clipped) {
+	const encoded = normalizePcs(pcs, value);
+	const prepared = clipped ? [
+		clamp(encoded[0]),
+		clamp(encoded[1]),
+		clamp(encoded[2])
+	] : encoded;
+	if (pcs !== "Lab " || encoding !== "mft2" || major !== 2) return prepared;
+	const scale = 65280 / 65535;
+	return [
+		prepared[0] * scale,
+		prepared[1] * scale,
+		prepared[2] * scale
+	];
+}
+function tableDecode(pcs, encoding, major, value) {
+	const scale = pcs === "Lab " && encoding === "mft2" && major === 2 ? 65535 / 65280 : 1;
+	return decodePcs(pcs, [
+		value[0] * scale,
+		value[1] * scale,
+		value[2] * scale
+	]);
+}
+const TO_D50 = [
+	1.0478112,
+	.0228866,
+	-.050127,
+	.0295424,
+	.9904844,
+	-.0170491,
+	-.0092345,
+	.0150436,
+	.7521316
+];
+const SRGB_TO_XYZ = [
+	.4124564,
+	.3575761,
+	.1804375,
+	.2126729,
+	.7151522,
+	.072175,
+	.0193339,
+	.119192,
+	.9503041
+];
+function srgbToLab(rgb) {
+	const convert = (value) => value <= .04045 ? value / 12.92 : ((value + .055) / 1.055) ** 2.4;
+	const [red, green, blue] = rgb;
+	return xyzToLab(matrix3(TO_D50, matrix3(SRGB_TO_XYZ, [
+		convert(red),
+		convert(green),
+		convert(blue)
+	])));
+}
+//#endregion
+export { D50, decodePcs, invert3, labToXyz, matrix3, srgbToLab, tableDecode, tableEncode, tryInvert3, xyzToLab };