reamkit 1.27.0 → 1.28.0

package/dist/esm/pdf-reader/glyf-outline.js

@@ -0,0 +1,351 @@
+import { macGlyphName } from "./encodings.js";
+//#region src/pdf-reader/glyf-outline.ts
+/**
+* Prepare an embedded TrueType program for outline reading (§9.6.6).
+*
+* @param program The raw `/FontFile2` bytes.
+* @returns A reader, or `undefined` where the program carries no `glyf`/`loca`
+*          pair — an OpenType/CFF program under `/FontFile2` is one such, and
+*          its outlines are charstrings this does not read.
+*/
+function outlineSource(program) {
+	let tables;
+	try {
+		tables = sfntTables(program);
+	} catch {
+		return;
+	}
+	const head = tables.get("head");
+	const loca = tables.get("loca");
+	const glyf = tables.get("glyf");
+	if (!head || !loca || !glyf) return void 0;
+	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+	const unitsPerEm = safeUint16(view, head.offset + 18) || 1e3;
+	const longLoca = safeInt16(view, head.offset + 50) === 1;
+	const cache = /* @__PURE__ */ new Map();
+	const glyphRange = (gid) => {
+		const stride = longLoca ? 4 : 2;
+		const at = loca.offset + gid * stride;
+		if (at + stride * 2 > loca.offset + loca.length) return void 0;
+		const read = (o) => longLoca ? safeUint32(view, o) : safeUint16(view, o) * 2;
+		const start = read(at);
+		const end = read(at + stride);
+		if (end <= start) return void 0;
+		if (glyf.offset + end > program.length) return void 0;
+		return {
+			start: glyf.offset + start,
+			end: glyf.offset + end
+		};
+	};
+	const read = (gid, depth) => {
+		const range = glyphRange(gid);
+		if (!range) return void 0;
+		const contours = safeInt16(view, range.start);
+		if (contours >= 0) return simpleGlyph(view, range.start, contours, range.end);
+		if (depth >= MAX_COMPONENT_DEPTH) return void 0;
+		return compositeGlyph(view, range.start + 10, range.end, (sub) => read(sub, depth + 1));
+	};
+	return {
+		count: Math.max(0, Math.floor(loca.length / (longLoca ? 4 : 2)) - 1),
+		cmap: (tables.get("cmap")?.length ?? 0) > 0,
+		path: (gid) => {
+			const had = cache.get(gid);
+			if (had !== void 0 || cache.has(gid)) return had;
+			let out;
+			try {
+				const raw = read(gid, 0);
+				out = raw ? raw.map((seg) => scaleSeg(seg, 1 / unitsPerEm)) : void 0;
+			} catch {
+				out = void 0;
+			}
+			cache.set(gid, out);
+			return out;
+		}
+	};
+}
+/** A composite glyph may name another composite; this is where that stops. */
+var MAX_COMPONENT_DEPTH = 5;
+/**
+* §post format 2.0 — the NAME each glyph of a TrueType program goes by.
+*
+* A legacy eight-bit font is reached through this table and nothing else. Its
+* program carries no `cmap`, so a code cannot be turned into a character and
+* then into a glyph; what it can be turned into is a glyph NAME, through the
+* encoding the font dictionary states (Annex D.2) — and the name is looked up
+* here. TrueType_without_cmap.pdf is an Armenian face, Masis, whose `i` draws
+* ի: read as text its line came back "'>in", and drawn by name it is the line
+* the page shows.
+*
+* @param program The raw `/FontFile2` bytes.
+* @returns Glyph name → index, or `undefined` where the table is missing or
+*          states no names of its own (formats 1.0 and 3.0).
+*/
+function postGlyphNames(program) {
+	let tables;
+	try {
+		tables = sfntTables(program);
+	} catch {
+		return;
+	}
+	const post = tables.get("post");
+	if (!post || post.length < 34) return void 0;
+	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+	if (safeUint32(view, post.offset) !== POST_NAMED) return void 0;
+	const count = safeUint16(view, post.offset + 32);
+	const end = post.offset + post.length;
+	if (post.offset + 34 + count * 2 > end) return void 0;
+	const own = [];
+	for (let at = post.offset + 34 + count * 2; at < end;) {
+		const length = program[at] ?? 0;
+		if (at + 1 + length > end) break;
+		own.push(String.fromCharCode(...program.subarray(at + 1, at + 1 + length)));
+		at += 1 + length;
+	}
+	const out = /* @__PURE__ */ new Map();
+	for (let gid = 0; gid < count; gid++) {
+		const index = safeUint16(view, post.offset + 34 + gid * 2);
+		const name = index < MAC_ORDER_SIZE ? macGlyphName(index) : own[index - MAC_ORDER_SIZE];
+		if (name !== void 0 && name.length > 0 && !out.has(name)) out.set(name, gid);
+	}
+	return out.size > 0 ? out : void 0;
+}
+/** `post` version 2.0 — the only one that states names of its own. */
+var POST_NAMED = 131072;
+/** How many names the Macintosh standard order holds (§post). */
+var MAC_ORDER_SIZE = 258;
+/** The sfnt table directory: tag → where that table is. */
+function sfntTables(program) {
+	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+	const out = /* @__PURE__ */ new Map();
+	const count = safeUint16(view, 4);
+	for (let i = 0; i < count; i++) {
+		const at = 12 + i * 16;
+		if (at + 16 > program.length) break;
+		const tag = String.fromCharCode(program[at], program[at + 1], program[at + 2], program[at + 3]);
+		out.set(tag, {
+			offset: safeUint32(view, at + 8),
+			length: safeUint32(view, at + 12)
+		});
+	}
+	return out;
+}
+function simpleGlyph(view, start, contours, end) {
+	let at = start + 10;
+	const ends = [];
+	for (let i = 0; i < contours; i++, at += 2) ends.push(safeUint16(view, at));
+	const points = contours > 0 ? (ends[contours - 1] ?? -1) + 1 : 0;
+	if (points <= 0 || points > MAX_POINTS) return void 0;
+	at += 2 + safeUint16(view, at);
+	const flags = new Uint8Array(points);
+	for (let i = 0; i < points && at < end;) {
+		const flag = safeUint8(view, at++);
+		flags[i++] = flag;
+		if ((flag & 8) !== 0) {
+			let repeats = safeUint8(view, at++);
+			while (repeats-- > 0 && i < points) flags[i++] = flag;
+		}
+	}
+	const xs = new Int16Array(points);
+	let x = 0;
+	for (let i = 0; i < points; i++) {
+		const flag = flags[i];
+		if ((flag & 2) !== 0) {
+			const d = safeUint8(view, at++);
+			x += (flag & 16) !== 0 ? d : -d;
+		} else if ((flag & 16) === 0) {
+			x += safeInt16(view, at);
+			at += 2;
+		}
+		xs[i] = x;
+	}
+	const ys = new Int16Array(points);
+	let y = 0;
+	for (let i = 0; i < points; i++) {
+		const flag = flags[i];
+		if ((flag & 4) !== 0) {
+			const d = safeUint8(view, at++);
+			y += (flag & 32) !== 0 ? d : -d;
+		} else if ((flag & 32) === 0) {
+			y += safeInt16(view, at);
+			at += 2;
+		}
+		ys[i] = y;
+	}
+	const out = [];
+	let from = 0;
+	for (const last of ends) {
+		if (last >= points) break;
+		emitContour(out, flags, xs, ys, from, last);
+		from = last + 1;
+	}
+	return out.length > 0 ? out : void 0;
+}
+/** How many points one glyph may hold — a guard, not a format limit. */
+var MAX_POINTS = 1e4;
+function emitContour(out, flags, xs, ys, from, last) {
+	const n = last - from + 1;
+	if (n <= 0) return;
+	const on = (i) => (flags[from + (i % n + n) % n] & 1) !== 0;
+	const px = (i) => xs[from + (i % n + n) % n];
+	const py = (i) => ys[from + (i % n + n) % n];
+	let startIdx = 0;
+	while (startIdx < n && !on(startIdx)) startIdx++;
+	let cx;
+	let cy;
+	if (startIdx === n) {
+		startIdx = 0;
+		cx = (px(0) + px(n - 1)) / 2;
+		cy = (py(0) + py(n - 1)) / 2;
+	} else {
+		cx = px(startIdx);
+		cy = py(startIdx);
+	}
+	out.push({
+		op: "move",
+		x: cx,
+		y: cy
+	});
+	let i = startIdx + 1;
+	const stop = startIdx + n;
+	while (i <= stop) {
+		if (on(i)) {
+			out.push({
+				op: "line",
+				x: px(i),
+				y: py(i)
+			});
+			cx = px(i);
+			cy = py(i);
+			i++;
+			continue;
+		}
+		const qx = px(i);
+		const qy = py(i);
+		const nextOn = on(i + 1);
+		const ex = nextOn ? px(i + 1) : (qx + px(i + 1)) / 2;
+		const ey = nextOn ? py(i + 1) : (qy + py(i + 1)) / 2;
+		out.push({
+			op: "cubic",
+			x1: cx + 2 / 3 * (qx - cx),
+			y1: cy + 2 / 3 * (qy - cy),
+			x2: ex + 2 / 3 * (qx - ex),
+			y2: ey + 2 / 3 * (qy - ey),
+			x: ex,
+			y: ey
+		});
+		cx = ex;
+		cy = ey;
+		i += nextOn ? 2 : 1;
+	}
+	out.push({ op: "close" });
+}
+function compositeGlyph(view, start, end, component) {
+	const out = [];
+	let at = start;
+	for (let guard = 0; guard < MAX_COMPONENTS && at + 4 <= end; guard++) {
+		const flags = safeUint16(view, at);
+		const gid = safeUint16(view, at + 2);
+		at += 4;
+		let dx = 0;
+		let dy = 0;
+		if ((flags & 1) !== 0) {
+			if ((flags & 2) !== 0) {
+				dx = safeInt16(view, at);
+				dy = safeInt16(view, at + 2);
+			}
+			at += 4;
+		} else {
+			if ((flags & 2) !== 0) {
+				dx = safeInt8(view, at);
+				dy = safeInt8(view, at + 1);
+			}
+			at += 2;
+		}
+		let a = 1;
+		let b = 0;
+		let c = 0;
+		let d = 1;
+		if ((flags & 8) !== 0) {
+			a = d = f2dot14(view, at);
+			at += 2;
+		} else if ((flags & 64) !== 0) {
+			a = f2dot14(view, at);
+			d = f2dot14(view, at + 2);
+			at += 4;
+		} else if ((flags & 128) !== 0) {
+			a = f2dot14(view, at);
+			b = f2dot14(view, at + 2);
+			c = f2dot14(view, at + 4);
+			d = f2dot14(view, at + 6);
+			at += 8;
+		}
+		const sub = component(gid);
+		if (sub) for (const seg of sub) out.push(transformSeg(seg, a, b, c, d, dx, dy));
+		if ((flags & 32) === 0) break;
+	}
+	return out.length > 0 ? out : void 0;
+}
+/** How many components one composite glyph may place. */
+var MAX_COMPONENTS = 32;
+function transformSeg(seg, a, b, c, d, dx, dy) {
+	const at = (x, y) => [a * x + c * y + dx, b * x + d * y + dy];
+	if (seg.op === "close") return seg;
+	if (seg.op === "cubic") {
+		const [x1, y1] = at(seg.x1, seg.y1);
+		const [x2, y2] = at(seg.x2, seg.y2);
+		const [x, y] = at(seg.x, seg.y);
+		return {
+			op: "cubic",
+			x1,
+			y1,
+			x2,
+			y2,
+			x,
+			y
+		};
+	}
+	const [x, y] = at(seg.x, seg.y);
+	return {
+		op: seg.op,
+		x,
+		y
+	};
+}
+function scaleSeg(seg, k) {
+	if (seg.op === "close") return seg;
+	if (seg.op === "cubic") return {
+		op: "cubic",
+		x1: seg.x1 * k,
+		y1: seg.y1 * k,
+		x2: seg.x2 * k,
+		y2: seg.y2 * k,
+		x: seg.x * k,
+		y: seg.y * k
+	};
+	return {
+		op: seg.op,
+		x: seg.x * k,
+		y: seg.y * k
+	};
+}
+/** The 2.14 fixed-point a component transform is stated in. */
+function f2dot14(view, at) {
+	return safeInt16(view, at) / 16384;
+}
+function safeUint8(view, at) {
+	return at >= 0 && at < view.byteLength ? view.getUint8(at) : 0;
+}
+function safeInt8(view, at) {
+	return at >= 0 && at < view.byteLength ? view.getInt8(at) : 0;
+}
+function safeUint16(view, at) {
+	return at >= 0 && at + 2 <= view.byteLength ? view.getUint16(at) : 0;
+}
+function safeInt16(view, at) {
+	return at >= 0 && at + 2 <= view.byteLength ? view.getInt16(at) : 0;
+}
+function safeUint32(view, at) {
+	return at >= 0 && at + 4 <= view.byteLength ? view.getUint32(at) : 0;
+}
+//#endregion
+export { outlineSource, postGlyphNames };

package/dist/esm/pdf-reader/glyph-names.js

@@ -1,3 +1,4 @@
+import { dingbatChar } from "./dingbats.js";
 //#region src/pdf-reader/glyph-names.ts
 /** Glyph name → the text it stands for. */
 var GLYPHS = {
@@ -22,6 +23,7 @@ var GLYPHS = {
 	Dcaron: "Ď",
 	Dcedilla: "Ḑ",
 	Ddotaccent: "Ḋ",
+	Delta: "∆",
 	Eacute: "É",
 	Ebreve: "Ĕ",
 	Ecaron: "Ě",
@@ -65,6 +67,7 @@ var GLYPHS = {
 	Lacute: "Ĺ",
 	Lcaron: "Ľ",
 	Lcedilla: "Ļ",
+	Lslash: "Ł",
 	Macute: "Ḿ",
 	Mdotaccent: "Ṁ",
 	Nacute: "Ń",
@@ -83,6 +86,7 @@ var GLYPHS = {
 	Ograve: "Ò",
 	Ohungarumlaut: "Ő",
 	Omacron: "Ō",
+	Omega: "Ω",
 	Oogonek: "Ǫ",
 	Oslash: "Ø",
 	Otilde: "Õ",
@@ -143,6 +147,7 @@ var GLYPHS = {
 	amacron: "ā",
 	ampersand: "&",
 	aogonek: "ą",
+	approxequal: "≈",
 	aring: "å",
 	asciicircum: "^",
 	asciitilde: "~",
@@ -223,6 +228,7 @@ var GLYPHS = {
 	gmacron: "ḡ",
 	grave: "`",
 	greater: ">",
+	greaterequal: "≥",
 	guillemotleft: "«",
 	guillemotright: "»",
 	guilsinglleft: "‹",
@@ -240,6 +246,8 @@ var GLYPHS = {
 	icircumflex: "î",
 	idieresis: "ï",
 	igrave: "ì",
+	infinity: "∞",
+	integral: "∫",
 	imacron: "ī",
 	iogonek: "į",
 	itilde: "ĩ",
@@ -252,7 +260,10 @@ var GLYPHS = {
 	lcaron: "ľ",
 	lcedilla: "ļ",
 	less: "<",
+	lessequal: "≤",
 	logicalnot: "¬",
+	lozenge: "◊",
+	lslash: "ł",
 	macron: "¯",
 	macute: "ḿ",
 	mdotaccent: "ṁ",
@@ -266,6 +277,7 @@ var GLYPHS = {
 	ndotaccent: "ṅ",
 	ngrave: "ǹ",
 	nine: "9",
+	notequal: "≠",
 	ntilde: "ñ",
 	numbersign: "#",
 	oacute: "ó",
@@ -292,12 +304,16 @@ var GLYPHS = {
 	paragraph: "¶",
 	parenleft: "(",
 	parenright: ")",
+	partialdiff: "∂",
 	pdotaccent: "ṗ",
 	percent: "%",
 	period: ".",
+	periodcentered: "·",
 	perthousand: "‰",
+	pi: "π",
 	plus: "+",
 	plusminus: "±",
+	product: "∏",
 	question: "?",
 	questiondown: "¿",
 	quotedbl: "\"",
@@ -308,6 +324,7 @@ var GLYPHS = {
 	quoteright: "’",
 	quotesinglbase: "‚",
 	quotesingle: "'",
+	radical: "√",
 	racute: "ŕ",
 	rcaron: "ř",
 	rcedilla: "ŗ",
@@ -328,6 +345,7 @@ var GLYPHS = {
 	softhyphen: "­",
 	space: " ",
 	sterling: "£",
+	summation: "∑",
 	tcaron: "ť",
 	tcedilla: "ţ",
 	tdieresis: "ẗ",
@@ -403,6 +421,8 @@ function textForGlyphName(name) {
 		const cp = parseInt(u[1], 16);
 		return cp <= 1114111 ? String.fromCodePoint(cp) : void 0;
 	}
+	const dingbat = dingbatChar(base);
+	if (dingbat !== void 0) return dingbat;
 }
 //#endregion
 export { textForGlyphName };

package/dist/esm/pdf-reader/icc.d.ts

@@ -0,0 +1,10 @@
+/** How a profile turns its own components into sRGB, each 0..1. */
+export type IccTransform = (comps: ReadonlyArray<number>) => [number, number, number];
+/**
+ * Read an ICC profile into a transform to sRGB.
+ *
+ * @param profile The raw profile bytes, as `/ICCBased`'s stream holds them.
+ * @returns The transform, or `undefined` for a profile whose form this does not
+ *          read — a CMYK one, a table-based one, or a damaged one.
+ */
+export declare function iccTransform(profile: Uint8Array): IccTransform | undefined;

package/dist/esm/pdf-reader/icc.js

@@ -0,0 +1,210 @@
+//#region src/pdf-reader/icc.ts
+/**
+* Read an ICC profile into a transform to sRGB.
+*
+* @param profile The raw profile bytes, as `/ICCBased`'s stream holds them.
+* @returns The transform, or `undefined` for a profile whose form this does not
+*          read — a CMYK one, a table-based one, or a damaged one.
+*/
+function iccTransform(profile) {
+	if (profile.length < HEADER_SIZE + 4) return void 0;
+	const view = new DataView(profile.buffer, profile.byteOffset, profile.byteLength);
+	const space = tag(profile, 16);
+	if (space !== "RGB " && space !== "GRAY") return void 0;
+	const tags = tagTable(profile, view);
+	if (!tags) return void 0;
+	const white = xyzTag(profile, view, tags.get("wtpt")) ?? D50;
+	if (space === "GRAY") {
+		const curve = curveTag(profile, view, tags.get("kTRC"));
+		if (!curve) return void 0;
+		return (comps) => {
+			const y = curve(clamp01(comps[0] ?? 0));
+			const [x, yy, z] = adapt([
+				white[0] * y,
+				white[1] * y,
+				white[2] * y
+			], white);
+			return toSrgb(x, yy, z);
+		};
+	}
+	const r = xyzTag(profile, view, tags.get("rXYZ"));
+	const g = xyzTag(profile, view, tags.get("gXYZ"));
+	const b = xyzTag(profile, view, tags.get("bXYZ"));
+	if (!r || !g || !b) return void 0;
+	const rc = curveTag(profile, view, tags.get("rTRC"));
+	const gc = curveTag(profile, view, tags.get("gTRC"));
+	const bc = curveTag(profile, view, tags.get("bTRC"));
+	if (!rc || !gc || !bc) return void 0;
+	return (comps) => {
+		const lr = rc(clamp01(comps[0] ?? 0));
+		const lg = gc(clamp01(comps[1] ?? 0));
+		const lb = bc(clamp01(comps[2] ?? 0));
+		const [ax, ay, az] = adapt([
+			r[0] * lr + g[0] * lg + b[0] * lb,
+			r[1] * lr + g[1] * lg + b[1] * lb,
+			r[2] * lr + g[2] * lg + b[2] * lb
+		], D50);
+		return toSrgb(ax, ay, az);
+	};
+}
+/** The profile header is fixed-length; the tag table follows it. */
+var HEADER_SIZE = 128;
+/** ICC.1:2010 §7.2.16 — the PCS every matrix/TRC profile is referred to. */
+var D50 = [
+	.9642,
+	1,
+	.8249
+];
+/** The white every sRGB screen is referred to. */
+var D65 = [
+	.9505,
+	1,
+	1.089
+];
+/** A four-byte signature, as the profile writes them. */
+function tag(data, at) {
+	return String.fromCharCode(data[at] ?? 0, data[at + 1] ?? 0, data[at + 2] ?? 0, data[at + 3] ?? 0);
+}
+/** §7.3 — the tag table: a count, then twelve bytes of signature/offset/size each. */
+function tagTable(data, view) {
+	const count = view.getUint32(HEADER_SIZE);
+	if (count === 0 || count > MAX_TAGS) return void 0;
+	const out = /* @__PURE__ */ new Map();
+	for (let i = 0; i < count; i++) {
+		const at = HEADER_SIZE + 4 + i * 12;
+		if (at + 12 > data.length) break;
+		const offset = view.getUint32(at + 4);
+		const size = view.getUint32(at + 8);
+		if (offset + size > data.length) continue;
+		out.set(tag(data, at), {
+			offset,
+			size
+		});
+	}
+	return out.size > 0 ? out : void 0;
+}
+/** No profile carries more tags than this; a bigger count is a damaged file. */
+var MAX_TAGS = 256;
+/** §10.31 `XYZType` — a signature, four reserved bytes, then three s15Fixed16. */
+function xyzTag(data, view, where) {
+	if (!where || where.size < 20 || tag(data, where.offset) !== "XYZ ") return void 0;
+	const at = where.offset + 8;
+	return [
+		s15(view, at),
+		s15(view, at + 4),
+		s15(view, at + 8)
+	];
+}
+/** The s15Fixed16 every ICC number is written as. */
+function s15(view, at) {
+	return view.getInt32(at) / 65536;
+}
+/**
+* §10.6/§10.18 — a tone curve, as the function that linearises one component.
+*
+* `curv` is a table: no entries is the identity, one is a gamma written as
+* u8Fixed8, and more is a sampled curve read by interpolation. `para` states
+* one of five formulas by their parameters, of which the sRGB-style type 3 is
+* the one every modern profile writes.
+*/
+function curveTag(data, view, where) {
+	if (!where || where.size < 12) return void 0;
+	const kind = tag(data, where.offset);
+	if (kind === "curv") {
+		const count = view.getUint32(where.offset + 8);
+		if (count === 0) return (v) => v;
+		if (count === 1) {
+			const gamma = view.getUint16(where.offset + 12) / 256;
+			return (v) => v ** gamma;
+		}
+		if (where.offset + 12 + count * 2 > data.length || count > MAX_CURVE_POINTS) return void 0;
+		const table = new Float64Array(count);
+		for (let i = 0; i < count; i++) table[i] = view.getUint16(where.offset + 12 + i * 2) / 65535;
+		return (v) => {
+			const at = clamp01(v) * (count - 1);
+			const i = Math.floor(at);
+			const lo = table[i] ?? 0;
+			return lo + ((table[Math.min(i + 1, count - 1)] ?? lo) - lo) * (at - i);
+		};
+	}
+	if (kind === "para") {
+		const type = view.getUint16(where.offset + 8);
+		const p = (i) => s15(view, where.offset + 12 + i * 4);
+		const g = p(0);
+		if (type === 0) return (v) => v ** g;
+		if (type === 1) {
+			const [a, b] = [p(1), p(2)];
+			return (v) => v >= -b / a ? (a * v + b) ** g : 0;
+		}
+		if (type === 2) {
+			const [a, b, c] = [
+				p(1),
+				p(2),
+				p(3)
+			];
+			return (v) => v >= -b / a ? (a * v + b) ** g + c : c;
+		}
+		if (type === 3) {
+			const [a, b, c, d] = [
+				p(1),
+				p(2),
+				p(3),
+				p(4)
+			];
+			return (v) => v >= d ? (a * v + b) ** g : c * v;
+		}
+		if (type === 4) {
+			const [a, b, c, d, e, f] = [
+				p(1),
+				p(2),
+				p(3),
+				p(4),
+				p(5),
+				p(6)
+			];
+			return (v) => v >= d ? (a * v + b) ** g + e : c * v + f;
+		}
+	}
+}
+/** No tone curve is sampled at more points than this. */
+var MAX_CURVE_POINTS = 65536;
+/** Bradford adaptation from the profile's white to the screen's. */
+function adapt(xyz, from) {
+	const cone = (x, y, z) => [
+		.8951 * x + .2664 * y - .1614 * z,
+		-.7502 * x + 1.7135 * y + .0367 * z,
+		.0389 * x - .0685 * y + 1.0296 * z
+	];
+	const [sx, sy, sz] = cone(from[0], from[1], from[2]);
+	const [dx, dy, dz] = cone(D65[0], D65[1], D65[2]);
+	const [cx, cy, cz] = cone(xyz[0], xyz[1], xyz[2]);
+	const [ax, ay, az] = [
+		cx * (sx === 0 ? 1 : dx / sx),
+		cy * (sy === 0 ? 1 : dy / sy),
+		cz * (sz === 0 ? 1 : dz / sz)
+	];
+	return [
+		.9869929 * ax - .1470543 * ay + .1599627 * az,
+		.4323053 * ax + .5183603 * ay + .0492912 * az,
+		-.0085287 * ax + .0400428 * ay + .9684867 * az
+	];
+}
+/** IEC 61966-2-1 — XYZ (D65) to sRGB, gamma and all. */
+function toSrgb(x, y, z) {
+	const r = 3.2404542 * x - 1.5371385 * y - .4985314 * z;
+	const g = -.969266 * x + 1.8760108 * y + .041556 * z;
+	const b = .0556434 * x - .2040259 * y + 1.0572252 * z;
+	return [
+		transfer(clamp01(r)),
+		transfer(clamp01(g)),
+		transfer(clamp01(b))
+	];
+}
+function transfer(v) {
+	return v <= .0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - .055;
+}
+function clamp01(v) {
+	return Math.min(1, Math.max(0, v));
+}
+//#endregion
+export { iccTransform };

package/dist/esm/pdf-reader/image-decode.d.ts

@@ -28,9 +28,10 @@ export type DecodedImage = {
  * colour spaces; Flate, LZW (EP12), RunLength, ASCII85, ASCIIHex and CCITT
  * Group 4 / Group 3 1-D fax (EP15) filters; PNG/TIFF predictors; bit depths
  * 1/2/4/8/16; an `/SMask` folded in as the PNG alpha channel; and a stencil
- * `/ImageMask` (§8.9.6.2) given back as RGBA in `fillHex`. Unsupported inputs
- * (Separation/DeviceN/Lab, CCITT Group 3 2-D) return a typed failure so the
- * caller records a loss.
+ * `/ImageMask` (§8.9.6.2) given back as RGBA in `fillHex`; `Lab` (§8.6.5.8) and
+ * a `Separation`/`DeviceN` through its own tint transform (§8.6.6.4).
+ * Unsupported inputs (CCITT Group 3 2-D) return a typed failure so the caller
+ * records a loss.
  *
  * @param file    The owning file.
  * @param stream  The image XObject, or an inline image wrapped as one.