modern-pdf-lib 0.35.0 → 0.37.0

package/dist/{src-C-mBizNU.cjs → src-CbPUzRbg.cjs}

@@ -19503,15 +19503,15 @@ const D50_WHITE_POINT = [
 	.8249
 ];
 /** CIE constant δ = 6/29; the linear/cubic break is at t ≤ δ. */
-const LAB_DELTA = 6 / 29;
+const LAB_DELTA$2 = 6 / 29;
 /** 3δ² — slope of the inverse linear branch. */
-const LAB_3_DELTA_SQUARED = 3 * LAB_DELTA * LAB_DELTA;
+const LAB_3_DELTA_SQUARED$1 = 3 * LAB_DELTA$2 * LAB_DELTA$2;
 /** Inverse of the CIE L*a*b* nonlinearity f(t). */
 function labInverseF(t) {
-	return t > LAB_DELTA ? t * t * t : LAB_3_DELTA_SQUARED * (t - 4 / 29);
+	return t > LAB_DELTA$2 ? t * t * t : LAB_3_DELTA_SQUARED$1 * (t - 4 / 29);
 }
 /** Apply the sRGB transfer function (linear → companded), input clamped 0..1. */
-function linearToSrgb(c) {
+function linearToSrgb$1(c) {
 	const clamped = c < 0 ? 0 : c > 1 ? 1 : c;
 	const v = clamped <= .0031308 ? 12.92 * clamped : 1.055 * clamped ** (1 / 2.4) - .055;
 	return v < 0 ? 0 : v > 1 ? 1 : v;
@@ -19545,9 +19545,9 @@ function labToRgb(L, a, b, whitePoint = D50_WHITE_POINT) {
 	const gLin = -.9787684 * X + 1.9161415 * Y + .033454 * Z;
 	const bLin = .0719453 * X - .2289914 * Y + 1.4052427 * Z;
 	return [
-		linearToSrgb(rLin),
-		linearToSrgb(gLin),
-		linearToSrgb(bLin)
+		linearToSrgb$1(rLin),
+		linearToSrgb$1(gLin),
+		linearToSrgb$1(bLin)
 	];
 }
 //#endregion
@@ -20153,7 +20153,7 @@ function breakLongWord$1(word, font, size, limit) {
 //#endregion
 //#region src/core/pdfFunctions.ts
 /** Clamp `x` into the inclusive `[lo, hi]` interval. */
-function clamp(x, lo, hi) {
+function clamp$1(x, lo, hi) {
 	if (x < lo) return lo;
 	if (x > hi) return hi;
 	return x;
@@ -20173,14 +20173,14 @@ function clampToRange(out, range) {
 	for (let i = 0; i < out.length; i++) {
 		const lo = range[2 * i];
 		const hi = range[2 * i + 1];
-		if (lo !== void 0 && hi !== void 0) out[i] = clamp(out[i], lo, hi);
+		if (lo !== void 0 && hi !== void 0) out[i] = clamp$1(out[i], lo, hi);
 	}
 	return out;
 }
 function evaluateExponential(fn, inputs) {
 	const c0 = fn.c0 ?? [0];
 	const c1 = fn.c1 ?? [1];
-	const x = clamp(inputs[0] ?? 0, fn.domain[0] ?? 0, fn.domain[1] ?? 1);
+	const x = clamp$1(inputs[0] ?? 0, fn.domain[0] ?? 0, fn.domain[1] ?? 1);
 	const xn = fn.n === 1 ? x : x ** fn.n;
 	const count = Math.max(c0.length, c1.length);
 	const out = [];
@@ -20194,7 +20194,7 @@ function evaluateExponential(fn, inputs) {
 function evaluateStitching(fn, inputs) {
 	const d0 = fn.domain[0] ?? 0;
 	const d1 = fn.domain[1] ?? 1;
-	const x = clamp(inputs[0] ?? 0, d0, d1);
+	const x = clamp$1(inputs[0] ?? 0, d0, d1);
 	const k = fn.functions.length;
 	let i = 0;
 	while (i < fn.bounds.length && x >= fn.bounds[i]) i++;
@@ -20212,10 +20212,10 @@ function evaluateSampled(fn, inputs) {
 	for (let j = 0; j < m; j++) {
 		const dMin = fn.domain[2 * j] ?? 0;
 		const dMax = fn.domain[2 * j + 1] ?? 1;
-		const x = clamp(inputs[j] ?? 0, dMin, dMax);
+		const x = clamp$1(inputs[j] ?? 0, dMin, dMax);
 		const size = fn.size[j] ?? 1;
 		const enc = interpolate(x, dMin, dMax, fn.encode ? fn.encode[2 * j] ?? 0 : 0, fn.encode ? fn.encode[2 * j + 1] ?? size - 1 : size - 1);
-		e.push(clamp(enc, 0, size - 1));
+		e.push(clamp$1(enc, 0, size - 1));
 	}
 	const lower = [];
 	const frac = [];
@@ -20561,7 +20561,7 @@ function evaluatePostScript(fn, inputs) {
 	for (let j = 0; j < m; j++) {
 		const dMin = fn.domain[2 * j] ?? 0;
 		const dMax = fn.domain[2 * j + 1] ?? 1;
-		stack.push(clamp(inputs[j] ?? 0, dMin, dMax));
+		stack.push(clamp$1(inputs[j] ?? 0, dMin, dMax));
 	}
 	execPostScript(program, stack);
 	const nOut = Math.floor(fn.range.length / 2);
@@ -29116,6 +29116,2276 @@ function getNumber(dict, key) {
 	if (obj !== void 0 && obj.kind === "number") return obj.value;
 }
 //#endregion
+//#region src/text/bidi.ts
+/** UAX #9 §3.3.2: the maximum explicit embedding depth. */
+const MAX_DEPTH = 125;
+/**
+* Classify a Unicode scalar value into its {@link BC} Bidi_Class.
+*
+* Range-based subset of DerivedBidiClass.txt (Unicode 16.0.0). Covers Latin,
+* Hebrew, Arabic, the digit groups, neutrals/weaks and all explicit-format and
+* isolate characters. Anything outside the listed ranges falls back to the
+* Unicode default class for that area (`R`/`AL` in the default-RTL blocks,
+* else `L`).
+*
+* @param cp Unicode scalar value (code point).
+* @returns The character's Bidi_Class.
+*/
+function bidiClass(cp) {
+	switch (cp) {
+		case 8234: return "LRE";
+		case 8235: return "RLE";
+		case 8237: return "LRO";
+		case 8238: return "RLO";
+		case 8236: return "PDF";
+		case 8294: return "LRI";
+		case 8295: return "RLI";
+		case 8296: return "FSI";
+		case 8297: return "PDI";
+		default: break;
+	}
+	if (cp < 128) {
+		if (cp === 10 || cp === 13 || cp === 28 || cp === 29 || cp === 30 || cp === 133) return "B";
+		if (cp === 9 || cp === 11 || cp === 31) return "S";
+		if (cp === 12 || cp === 32) return "WS";
+		if (cp >= 48 && cp <= 57) return "EN";
+		if (cp === 43 || cp === 45) return "ES";
+		if (cp === 35 || cp === 36 || cp === 37) return "ET";
+		if (cp === 44 || cp === 46 || cp === 47 || cp === 58) return "CS";
+		if (cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122) return "L";
+		return "ON";
+	}
+	if (cp === 133) return "B";
+	if (cp === 160) return "CS";
+	if (cp === 163 || cp === 164 || cp === 165 || cp === 176 || cp === 177) return "ET";
+	if (cp === 171 || cp === 187) return "ON";
+	if (cp >= 1425 && cp <= 1469) return "NSM";
+	if (cp === 1471 || cp === 1473 || cp === 1474 || cp === 1476 || cp === 1477 || cp === 1479) return "NSM";
+	if (cp >= 1424 && cp <= 1535) return "R";
+	if (cp >= 1536 && cp <= 1541) return "AN";
+	if (cp >= 1632 && cp <= 1641) return "AN";
+	if (cp === 1643 || cp === 1644) return "AN";
+	if (cp === 1642) return "ET";
+	if (cp >= 1776 && cp <= 1785) return "EN";
+	if (cp >= 1552 && cp <= 1562) return "NSM";
+	if (cp >= 1611 && cp <= 1631) return "NSM";
+	if (cp === 1648) return "NSM";
+	if (cp >= 1750 && cp <= 1756) return "NSM";
+	if (cp >= 1759 && cp <= 1764) return "NSM";
+	if (cp === 1767 || cp === 1768) return "NSM";
+	if (cp >= 1770 && cp <= 1773) return "NSM";
+	if (cp >= 1536 && cp <= 1791) return "AL";
+	if (cp >= 1792 && cp <= 1871) return "AL";
+	if (cp >= 1872 && cp <= 1919) return "AL";
+	if (cp >= 1920 && cp <= 1983) return "AL";
+	if (cp === 8232) return "WS";
+	if (cp === 8233) return "B";
+	if (cp >= 8192 && cp <= 8202) return "WS";
+	if (cp === 8203) return "BN";
+	if (cp === 8206) return "L";
+	if (cp === 8207) return "R";
+	if (cp === 1564) return "AL";
+	if (cp === 8239) return "CS";
+	if (cp === 8287) return "WS";
+	if (cp === 12288) return "WS";
+	if (cp === 65279) return "BN";
+	if (cp >= 768 && cp <= 879) return "NSM";
+	if (cp >= 8400 && cp <= 8447) return "NSM";
+	return "L";
+}
+/**
+* Map of opening bracket → closing bracket and vice versa for UAX #9 N0
+* (paired brackets). Subset of BidiBrackets.txt (Unicode 16.0.0) covering the
+* ASCII and common CJK/typographic pairs. Canonical-equivalent singletons
+* (U+2329/U+232A) are folded onto their canonical forms per BD16.
+*/
+const BRACKET_PAIRS = /* @__PURE__ */ new Map([
+	[40, {
+		other: 41,
+		open: true
+	}],
+	[41, {
+		other: 40,
+		open: false
+	}],
+	[91, {
+		other: 93,
+		open: true
+	}],
+	[93, {
+		other: 91,
+		open: false
+	}],
+	[123, {
+		other: 125,
+		open: true
+	}],
+	[125, {
+		other: 123,
+		open: false
+	}],
+	[3898, {
+		other: 3899,
+		open: true
+	}],
+	[3899, {
+		other: 3898,
+		open: false
+	}],
+	[3900, {
+		other: 3901,
+		open: true
+	}],
+	[3901, {
+		other: 3900,
+		open: false
+	}],
+	[5787, {
+		other: 5788,
+		open: true
+	}],
+	[5788, {
+		other: 5787,
+		open: false
+	}],
+	[8261, {
+		other: 8262,
+		open: true
+	}],
+	[8262, {
+		other: 8261,
+		open: false
+	}],
+	[8317, {
+		other: 8318,
+		open: true
+	}],
+	[8318, {
+		other: 8317,
+		open: false
+	}],
+	[8333, {
+		other: 8334,
+		open: true
+	}],
+	[8334, {
+		other: 8333,
+		open: false
+	}],
+	[9001, {
+		other: 9002,
+		open: true
+	}],
+	[9002, {
+		other: 9001,
+		open: false
+	}],
+	[10088, {
+		other: 10089,
+		open: true
+	}],
+	[10089, {
+		other: 10088,
+		open: false
+	}],
+	[10090, {
+		other: 10091,
+		open: true
+	}],
+	[10091, {
+		other: 10090,
+		open: false
+	}],
+	[10092, {
+		other: 10093,
+		open: true
+	}],
+	[10093, {
+		other: 10092,
+		open: false
+	}],
+	[10094, {
+		other: 10095,
+		open: true
+	}],
+	[10095, {
+		other: 10094,
+		open: false
+	}],
+	[10096, {
+		other: 10097,
+		open: true
+	}],
+	[10097, {
+		other: 10096,
+		open: false
+	}],
+	[10098, {
+		other: 10099,
+		open: true
+	}],
+	[10099, {
+		other: 10098,
+		open: false
+	}],
+	[10100, {
+		other: 10101,
+		open: true
+	}],
+	[10101, {
+		other: 10100,
+		open: false
+	}],
+	[10214, {
+		other: 10215,
+		open: true
+	}],
+	[10215, {
+		other: 10214,
+		open: false
+	}],
+	[10216, {
+		other: 10217,
+		open: true
+	}],
+	[10217, {
+		other: 10216,
+		open: false
+	}],
+	[10218, {
+		other: 10219,
+		open: true
+	}],
+	[10219, {
+		other: 10218,
+		open: false
+	}],
+	[10220, {
+		other: 10221,
+		open: true
+	}],
+	[10221, {
+		other: 10220,
+		open: false
+	}],
+	[10222, {
+		other: 10223,
+		open: true
+	}],
+	[10223, {
+		other: 10222,
+		open: false
+	}],
+	[10627, {
+		other: 10628,
+		open: true
+	}],
+	[10628, {
+		other: 10627,
+		open: false
+	}],
+	[12296, {
+		other: 12297,
+		open: true
+	}],
+	[12297, {
+		other: 12296,
+		open: false
+	}],
+	[12298, {
+		other: 12299,
+		open: true
+	}],
+	[12299, {
+		other: 12298,
+		open: false
+	}],
+	[12300, {
+		other: 12301,
+		open: true
+	}],
+	[12301, {
+		other: 12300,
+		open: false
+	}],
+	[12302, {
+		other: 12303,
+		open: true
+	}],
+	[12303, {
+		other: 12302,
+		open: false
+	}],
+	[12304, {
+		other: 12305,
+		open: true
+	}],
+	[12305, {
+		other: 12304,
+		open: false
+	}],
+	[12308, {
+		other: 12309,
+		open: true
+	}],
+	[12309, {
+		other: 12308,
+		open: false
+	}],
+	[12310, {
+		other: 12311,
+		open: true
+	}],
+	[12311, {
+		other: 12310,
+		open: false
+	}],
+	[12312, {
+		other: 12313,
+		open: true
+	}],
+	[12313, {
+		other: 12312,
+		open: false
+	}],
+	[12314, {
+		other: 12315,
+		open: true
+	}],
+	[12315, {
+		other: 12314,
+		open: false
+	}]
+]);
+/** BD16 canonical-equivalence folding for bracket matching. */
+function canonicalBracket(cp) {
+	if (cp === 12296) return 9001;
+	if (cp === 12297) return 9002;
+	return cp;
+}
+/** True if `bc` is a removed-by-X9 explicit/BN type. */
+function isRemovedByX9(bc) {
+	return bc === "RLE" || bc === "LRE" || bc === "RLO" || bc === "LRO" || bc === "PDF" || bc === "BN";
+}
+/** Strong direction (0 = L, 1 = R) implied by an embedding level's parity. */
+function dirFromLevel(level) {
+	return level % 2 === 0 ? "L" : "R";
+}
+/**
+* Compute the first-strong base level over `types`, skipping the contents of
+* isolate initiators (LRI/RLI/FSI ... matching PDI) per UAX #9 P2/P3, X5c.
+* Returns 0 (LTR) when no strong character is found.
+*/
+function computeBaseLevel(types) {
+	let isolateDepth = 0;
+	for (const t of types) if (t === "LRI" || t === "RLI" || t === "FSI") isolateDepth++;
+	else if (t === "PDI") {
+		if (isolateDepth > 0) isolateDepth--;
+	} else if (isolateDepth === 0) {
+		if (t === "L") return 0;
+		if (t === "R" || t === "AL") return 1;
+	}
+	return 0;
+}
+/**
+* Resolve explicit embedding levels and per-character override directions
+* (UAX #9 X1–X8 plus the isolate rules X5a/X5b/X5c/X6a). Mutates `levels` and
+* returns an array of resolved working types (with overrides applied and X9
+* removals tagged as BN).
+*/
+function resolveExplicit(types, baseLevel, levels) {
+	const result = types.slice();
+	const stack = [{
+		level: baseLevel,
+		override: "neutral",
+		isolate: false
+	}];
+	let overflowIsolate = 0;
+	let overflowEmbedding = 0;
+	let validIsolate = 0;
+	const n = types.length;
+	const matchingPDI = computeMatchingPDI(types);
+	for (let i = 0; i < n; i++) {
+		const t = types[i];
+		const top = stack[stack.length - 1];
+		switch (t) {
+			case "RLE":
+			case "LRE":
+			case "RLO":
+			case "LRO": {
+				levels[i] = top.level;
+				result[i] = "BN";
+				const newLevel = t === "RLE" || t === "RLO" ? nextOddLevel(top.level) : nextEvenLevel(top.level);
+				if (newLevel <= MAX_DEPTH && overflowIsolate === 0 && overflowEmbedding === 0) stack.push({
+					level: newLevel,
+					override: t === "RLO" ? "R" : t === "LRO" ? "L" : "neutral",
+					isolate: false
+				});
+				else if (overflowIsolate === 0) overflowEmbedding++;
+				break;
+			}
+			case "RLI":
+			case "LRI":
+			case "FSI": {
+				levels[i] = top.level;
+				if (top.override !== "neutral") result[i] = top.override;
+				let isRTL = t === "RLI";
+				if (t === "FSI") {
+					const pdi = matchingPDI[i];
+					isRTL = computeBaseLevel(types.slice(i + 1, pdi)) === 1;
+				}
+				const newLevel = isRTL ? nextOddLevel(top.level) : nextEvenLevel(top.level);
+				if (newLevel <= MAX_DEPTH && overflowIsolate === 0 && overflowEmbedding === 0) {
+					validIsolate++;
+					stack.push({
+						level: newLevel,
+						override: "neutral",
+						isolate: true
+					});
+				} else overflowIsolate++;
+				break;
+			}
+			case "PDI": {
+				if (overflowIsolate > 0) overflowIsolate--;
+				else if (validIsolate > 0) {
+					overflowEmbedding = 0;
+					while (!stack[stack.length - 1].isolate) stack.pop();
+					stack.pop();
+					validIsolate--;
+				}
+				const after = stack[stack.length - 1];
+				levels[i] = after.level;
+				if (after.override !== "neutral") result[i] = after.override;
+				break;
+			}
+			case "PDF":
+				levels[i] = top.level;
+				result[i] = "BN";
+				if (overflowIsolate > 0) {} else if (overflowEmbedding > 0) overflowEmbedding--;
+				else if (!top.isolate && stack.length >= 2) stack.pop();
+				break;
+			case "B":
+				stack.length = 1;
+				stack[0] = {
+					level: baseLevel,
+					override: "neutral",
+					isolate: false
+				};
+				overflowIsolate = 0;
+				overflowEmbedding = 0;
+				validIsolate = 0;
+				levels[i] = baseLevel;
+				break;
+			case "BN":
+				levels[i] = top.level;
+				break;
+			default:
+				levels[i] = top.level;
+				if (top.override !== "neutral") result[i] = top.override;
+				break;
+		}
+	}
+	return result;
+}
+/** Next odd level strictly greater than `level` (for RTL embeddings). */
+function nextOddLevel(level) {
+	return level % 2 === 0 ? level + 1 : level + 2;
+}
+/** Next even level strictly greater than `level` (for LTR embeddings). */
+function nextEvenLevel(level) {
+	return level % 2 === 0 ? level + 2 : level + 1;
+}
+/**
+* BD9: for each isolate initiator, find the index of its matching PDI (or `n`
+* if unmatched). Non-initiator positions map to `-1`.
+*/
+function computeMatchingPDI(types) {
+	const n = types.length;
+	const out = new Array(n).fill(-1);
+	for (let i = 0; i < n; i++) {
+		const t = types[i];
+		if (t === "LRI" || t === "RLI" || t === "FSI") {
+			let depth = 1;
+			let j = i + 1;
+			for (; j < n; j++) {
+				const tj = types[j];
+				if (tj === "LRI" || tj === "RLI" || tj === "FSI") depth++;
+				else if (tj === "PDI") {
+					depth--;
+					if (depth === 0) break;
+				}
+			}
+			out[i] = j;
+		}
+	}
+	return out;
+}
+/**
+* Build the isolating run sequences (UAX #9 X10 / BD13) from the resolved
+* levels, skipping characters removed by X9. Computes each sequence's sos/eos
+* boundary directions from the higher of the adjacent levels (rule X10).
+*/
+function buildIsolatingRunSequences(types, levels, baseLevel) {
+	const n = types.length;
+	const retained = [];
+	for (let i = 0; i < n; i++) if (!isRemovedByX9(types[i])) retained.push(i);
+	const levelRuns = [];
+	let cur = [];
+	let curLevel = -1;
+	for (const i of retained) {
+		if (levels[i] !== curLevel) {
+			if (cur.length > 0) levelRuns.push(cur);
+			cur = [];
+			curLevel = levels[i];
+		}
+		cur.push(i);
+	}
+	if (cur.length > 0) levelRuns.push(cur);
+	const runByStart = /* @__PURE__ */ new Map();
+	for (let r = 0; r < levelRuns.length; r++) runByStart.set(levelRuns[r][0], r);
+	const matchingPDI = computeMatchingPDI(types);
+	const matchingInitiator = new Array(n).fill(-1);
+	for (let i = 0; i < n; i++) {
+		const t = types[i];
+		if ((t === "LRI" || t === "RLI" || t === "FSI") && matchingPDI[i] < n) matchingInitiator[matchingPDI[i]] = i;
+	}
+	const used = new Array(levelRuns.length).fill(false);
+	const sequences = [];
+	for (let r = 0; r < levelRuns.length; r++) {
+		if (used[r]) continue;
+		const first = levelRuns[r][0];
+		if (types[first] === "PDI" && matchingInitiator[first] >= 0) continue;
+		const seqIndices = [];
+		let runIdx = r;
+		for (;;) {
+			used[runIdx] = true;
+			const run = levelRuns[runIdx];
+			for (const idx of run) seqIndices.push(idx);
+			const last = run[run.length - 1];
+			const t = types[last];
+			if ((t === "LRI" || t === "RLI" || t === "FSI") && matchingPDI[last] < n) {
+				const next = runByStart.get(matchingPDI[last]);
+				if (next === void 0 || used[next]) break;
+				runIdx = next;
+			} else break;
+		}
+		const seqLevel = levels[seqIndices[0]];
+		const startPos = retained.indexOf(seqIndices[0]);
+		const endPos = retained.indexOf(seqIndices[seqIndices.length - 1]);
+		const prevLevel = startPos > 0 ? levels[retained[startPos - 1]] : baseLevel;
+		const lastType = types[seqIndices[seqIndices.length - 1]];
+		const nextLevel = (lastType === "LRI" || lastType === "RLI" || lastType === "FSI") && matchingPDI[seqIndices[seqIndices.length - 1]] >= n || endPos === retained.length - 1 ? baseLevel : levels[retained[endPos + 1]];
+		sequences.push({
+			indices: seqIndices,
+			sos: dirFromLevel(Math.max(seqLevel, prevLevel)),
+			eos: dirFromLevel(Math.max(seqLevel, nextLevel))
+		});
+	}
+	return sequences;
+}
+/** Apply the weak-type rules W1–W7 to one isolating run sequence in place. */
+function resolveWeak(seq, types) {
+	const idx = seq.indices;
+	const m = idx.length;
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "NSM") if (k === 0) types[i] = seq.sos;
+		else {
+			const prev = types[idx[k - 1]];
+			types[i] = prev === "LRI" || prev === "RLI" || prev === "FSI" || prev === "PDI" ? "ON" : prev;
+		}
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "EN") {
+			let strong = seq.sos;
+			for (let j = k - 1; j >= 0; j--) {
+				const tj = types[idx[j]];
+				if (tj === "R" || tj === "L" || tj === "AL") {
+					strong = tj;
+					break;
+				}
+			}
+			if (strong === "AL") types[i] = "AN";
+		}
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "AL") types[i] = "R";
+	}
+	for (let k = 1; k < m - 1; k++) {
+		const i = idx[k];
+		const prev = types[idx[k - 1]];
+		const next = types[idx[k + 1]];
+		if (types[i] === "ES" && prev === "EN" && next === "EN") types[i] = "EN";
+		else if (types[i] === "CS" && prev === next && (prev === "EN" || prev === "AN")) types[i] = prev;
+	}
+	for (let k = 0; k < m; k++) {
+		if (types[idx[k]] !== "ET") continue;
+		let end = k;
+		while (end < m && types[idx[end]] === "ET") end++;
+		const before = k > 0 ? types[idx[k - 1]] : seq.sos;
+		const after = end < m ? types[idx[end]] : seq.eos;
+		if (before === "EN" || after === "EN") for (let j = k; j < end; j++) types[idx[j]] = "EN";
+		k = end - 1;
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "ES" || types[i] === "ET" || types[i] === "CS") types[i] = "ON";
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "EN") {
+			let strong = seq.sos;
+			for (let j = k - 1; j >= 0; j--) {
+				const tj = types[idx[j]];
+				if (tj === "R" || tj === "L") {
+					strong = tj;
+					break;
+				}
+			}
+			if (strong === "L") types[i] = "L";
+		}
+	}
+}
+/** True if a working type counts as a "neutral or isolate formatting" char (NI). */
+function isNI(t) {
+	return t === "B" || t === "S" || t === "WS" || t === "ON" || t === "FSI" || t === "LRI" || t === "RLI" || t === "PDI";
+}
+/** Apply N0 (paired brackets) then N1/N2 to one isolating run sequence. */
+function resolveNeutral(seq, types, levels, codepoints) {
+	const idx = seq.indices;
+	const m = idx.length;
+	const e = dirFromLevel(levels[idx[0]]);
+	resolveBrackets(seq, types, codepoints, e);
+	let k = 0;
+	while (k < m) {
+		if (!isNI(types[idx[k]])) {
+			k++;
+			continue;
+		}
+		let end = k;
+		while (end < m && isNI(types[idx[end]])) end++;
+		const beforeRaw = k > 0 ? types[idx[k - 1]] : seq.sos;
+		const afterRaw = end < m ? types[idx[end]] : seq.eos;
+		const before = beforeRaw === "EN" || beforeRaw === "AN" ? "R" : beforeRaw;
+		const resolved = before === (afterRaw === "EN" || afterRaw === "AN" ? "R" : afterRaw) && (before === "L" || before === "R") ? before : e;
+		for (let j = k; j < end; j++) types[idx[j]] = resolved;
+		k = end;
+	}
+}
+/** N0 paired-bracket resolution (UAX #9 N0 with BD16 pairing). */
+function resolveBrackets(seq, types, codepoints, e) {
+	const idx = seq.indices;
+	const m = idx.length;
+	const stack = [];
+	const pairs = [];
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] !== "ON") continue;
+		const cp = canonicalBracket(codepoints[i]);
+		const info = BRACKET_PAIRS.get(codepoints[i]);
+		if (!info) continue;
+		if (info.open) {
+			if (stack.length >= 63) break;
+			stack.push({
+				bracket: canonicalBracket(info.other),
+				seqPos: k
+			});
+		} else for (let s = stack.length - 1; s >= 0; s--) if (stack[s].bracket === cp) {
+			pairs.push({
+				open: stack[s].seqPos,
+				close: k
+			});
+			stack.length = s;
+			break;
+		}
+	}
+	pairs.sort((a, b) => a.open - b.open);
+	for (const pair of pairs) {
+		let foundE = false;
+		let foundOpposite = false;
+		const opposite = e === "L" ? "R" : "L";
+		for (let k = pair.open + 1; k < pair.close; k++) {
+			const t = strongClass(types[idx[k]]);
+			if (t === e) {
+				foundE = true;
+				break;
+			}
+			if (t === opposite) foundOpposite = true;
+		}
+		let setDir = null;
+		if (foundE) setDir = e;
+		else if (foundOpposite) {
+			let context = seq.sos;
+			for (let k = pair.open - 1; k >= 0; k--) {
+				const t = strongClass(types[idx[k]]);
+				if (t === "L" || t === "R") {
+					context = t;
+					break;
+				}
+			}
+			setDir = context === opposite ? opposite : e;
+		}
+		if (setDir) {
+			types[idx[pair.open]] = setDir;
+			types[idx[pair.close]] = setDir;
+			for (let k = pair.open + 1; k < m; k++) if (originalIsNSM(idx[k], codepoints)) types[idx[k]] = setDir;
+			else break;
+			for (let k = pair.close + 1; k < m; k++) if (originalIsNSM(idx[k], codepoints)) types[idx[k]] = setDir;
+			else break;
+		}
+	}
+}
+/** Reduce a working type to the strong direction it counts as for N0 (EN/AN→R). */
+function strongClass(t) {
+	if (t === "L") return "L";
+	if (t === "R" || t === "EN" || t === "AN") return "R";
+	return null;
+}
+/** True if the original code point at logical index `i` has Bidi_Class NSM. */
+function originalIsNSM(i, codepoints) {
+	return bidiClass(codepoints[i]) === "NSM";
+}
+/** Resolve implicit embedding levels (UAX #9 I1/I2) for one sequence. */
+function resolveImplicit(seq, types, levels) {
+	for (const i of seq.indices) {
+		const level = levels[i];
+		const t = types[i];
+		if (level % 2 === 0) {
+			if (t === "R") levels[i] = level + 1;
+			else if (t === "AN" || t === "EN") levels[i] = level + 2;
+		} else if (t === "L" || t === "EN" || t === "AN") levels[i] = level + 1;
+	}
+}
+/**
+* L1: reset to the paragraph level (1) segment/paragraph separators, and
+* (2) any sequence of whitespace / isolate formatting chars preceding a
+* separator or the end of the line. Operates on a single line (= the whole
+* paragraph here, since we do not perform line breaking).
+*/
+function resetWhitespaceLevels(originalTypes, levels, baseLevel) {
+	const n = levels.length;
+	let resetFrom = n;
+	for (let i = n - 1; i >= 0; i--) {
+		const t = originalTypes[i];
+		if (t === "B" || t === "S") {
+			levels[i] = baseLevel;
+			for (let j = i + 1; j < resetFrom; j++) levels[j] = baseLevel;
+			resetFrom = i;
+		} else if (t === "WS" || t === "FSI" || t === "LRI" || t === "RLI" || t === "PDI" || isRemovedByX9(t)) {} else {
+			if (resetFrom === n) {}
+			resetFrom = i + 1 > resetFrom ? resetFrom : i + 1;
+			resetFrom = i + 1;
+		}
+	}
+	for (let i = n - 1; i >= 0; i--) {
+		const t = originalTypes[i];
+		if (t === "WS" || t === "FSI" || t === "LRI" || t === "RLI" || t === "PDI" || isRemovedByX9(t)) levels[i] = baseLevel;
+		else break;
+	}
+}
+/** L2: reorder code-unit indices into visual order from the resolved levels. */
+function reorderLevels(levels) {
+	const n = levels.length;
+	const order = Array.from({ length: n }, (_, i) => i);
+	if (n === 0) return order;
+	let highest = 0;
+	let lowestOdd = 127;
+	for (const l of levels) {
+		if (l > highest) highest = l;
+		if (l % 2 === 1 && l < lowestOdd) lowestOdd = l;
+	}
+	for (let level = highest; level >= lowestOdd; level--) {
+		let i = 0;
+		while (i < n) if (levels[order[i]] >= level) {
+			let j = i;
+			while (j < n && levels[order[j]] >= level) j++;
+			for (let a = i, b = j - 1; a < b; a++, b--) {
+				const tmp = order[a];
+				order[a] = order[b];
+				order[b] = tmp;
+			}
+			i = j;
+		} else i++;
+	}
+	return order;
+}
+/**
+* Run the Unicode Bidirectional Algorithm (UAX #9) over `text`.
+*
+* Indices in the result refer to UTF-16 code units of the input string (the
+* same units JavaScript's `string[i]` and `.length` use). Astral characters
+* (surrogate pairs) are classified by their scalar value but occupy two code
+* units, both assigned the same level.
+*
+* @param text The logical-order input string.
+* @param base Paragraph direction: `'ltr'` / `'rtl'` force the base level;
+*   `'auto'` (the default) derives it from the first strong character (P2/P3).
+* @returns The resolved levels, same-level runs, visual order and base level.
+*/
+function resolveBidi(text, base = "auto") {
+	const n = text.length;
+	const codepoints = new Array(n);
+	for (let i = 0; i < n; i++) {
+		const c = text.charCodeAt(i);
+		if (c >= 55296 && c <= 56319 && i + 1 < n) {
+			const c2 = text.charCodeAt(i + 1);
+			if (c2 >= 56320 && c2 <= 57343) {
+				const scalar = (c - 55296) * 1024 + (c2 - 56320) + 65536;
+				codepoints[i] = scalar;
+				codepoints[i + 1] = scalar;
+				i++;
+				continue;
+			}
+		}
+		codepoints[i] = c;
+	}
+	const originalTypes = codepoints.map(bidiClass);
+	let baseLevel;
+	if (base === "ltr") baseLevel = 0;
+	else if (base === "rtl") baseLevel = 1;
+	else baseLevel = computeBaseLevel(originalTypes);
+	const levels = new Array(n).fill(baseLevel);
+	if (n === 0) return {
+		runs: [],
+		levels: [],
+		visualOrder: [],
+		baseLevel
+	};
+	const workingTypes = resolveExplicit(originalTypes, baseLevel, levels);
+	const sequences = buildIsolatingRunSequences(workingTypes, levels, baseLevel);
+	for (const seq of sequences) {
+		resolveWeak(seq, workingTypes);
+		resolveNeutral(seq, workingTypes, levels, codepoints);
+		resolveImplicit(seq, workingTypes, levels);
+	}
+	resetWhitespaceLevels(originalTypes, levels, baseLevel);
+	const visualOrder = reorderLevels(levels);
+	const runs = [];
+	let start = 0;
+	while (start < n) {
+		const level = levels[start];
+		let end = start + 1;
+		while (end < n && levels[end] === level) end++;
+		runs.push({
+			text: text.slice(start, end),
+			level,
+			direction: dirFromLevel(level) === "L" ? "ltr" : "rtl",
+			start,
+			length: end - start
+		});
+		start = end;
+	}
+	return {
+		runs,
+		levels,
+		visualOrder,
+		baseLevel
+	};
+}
+/**
+* Convenience wrapper that returns `text` reordered into visual (left-to-right)
+* order via {@link resolveBidi}'s L2 result.
+*
+* Note: this performs pure reordering of code units. It does not apply Arabic
+* cursive shaping or mirror neutral glyphs; callers that need shaped glyphs
+* should pass the resolved runs to a shaping engine.
+*
+* @param text The logical-order input string.
+* @param base Paragraph direction (see {@link resolveBidi}).
+* @returns The visually reordered string.
+*/
+function reorderVisual(text, base = "auto") {
+	const { visualOrder } = resolveBidi(text, base);
+	let out = "";
+	for (const i of visualOrder) out += text[i];
+	return out;
+}
+//#endregion
+//#region src/assets/font/variableFont.ts
+function readTableDirectory$1(data) {
+	if (data.length < 12) return null;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const numTables = view.getUint16(4, false);
+	const dirEnd = 12 + numTables * 16;
+	if (numTables === 0 || dirEnd > data.length) return null;
+	const tables = /* @__PURE__ */ new Map();
+	for (let i = 0; i < numTables; i++) {
+		const recOff = 12 + i * 16;
+		const tag = String.fromCharCode(data[recOff], data[recOff + 1], data[recOff + 2], data[recOff + 3]);
+		const offset = view.getUint32(recOff + 8, false);
+		const length = view.getUint32(recOff + 12, false);
+		tables.set(tag, {
+			offset,
+			length
+		});
+	}
+	return tables;
+}
+/**
+* Read a Fixed (16.16 signed) value: a big-endian int32 divided by 65536.
+* Used by 'fvar' for axis min/default/max and instance coordinates.
+*/
+function readFixed(view, off) {
+	return view.getInt32(off, false) / 65536;
+}
+/**
+* Read an F2DOT14 (2.14 signed) value: a big-endian int16 divided by 16384.
+* Used by 'avar' for AxisValueMap from/to coordinates.
+*/
+function readF2Dot14(view, off) {
+	return view.getInt16(off, false) / 16384;
+}
+function parseAvar(data, rec, expectedAxisCount) {
+	if (rec.offset + 8 > data.length) return void 0;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	if (view.getUint16(rec.offset, false) !== 1) return void 0;
+	const axisCount = view.getUint16(rec.offset + 6, false);
+	if (axisCount !== expectedAxisCount) return void 0;
+	const segmentMaps = [];
+	let cursor = rec.offset + 8;
+	const tableEnd = rec.offset + rec.length;
+	for (let a = 0; a < axisCount; a++) {
+		if (cursor + 2 > data.length || cursor + 2 > tableEnd) return void 0;
+		const positionMapCount = view.getUint16(cursor, false);
+		cursor += 2;
+		const recordsBytes = positionMapCount * 4;
+		if (cursor + recordsBytes > data.length || cursor + recordsBytes > tableEnd) return;
+		const maps = [];
+		for (let i = 0; i < positionMapCount; i++) {
+			const from = readF2Dot14(view, cursor);
+			const to = readF2Dot14(view, cursor + 2);
+			maps.push({
+				fromCoordinate: from,
+				toCoordinate: to
+			});
+			cursor += 4;
+		}
+		segmentMaps.push(maps);
+	}
+	return segmentMaps;
+}
+/**
+* Parse the variable-font model from raw OpenType/TrueType font bytes.
+*
+* If the font has no 'fvar' table (or it is malformed / has zero axes), the
+* font is treated as non-variable and
+* `{ isVariable: false, axes: [], namedInstances: [] }` is returned.
+*
+* @param fontData Raw font file bytes (sfnt: TrueType 0x00010000 or 'OTTO' CFF).
+* @returns The parsed {@link VariableFontInfo}.
+*/
+function parseVariableFont(fontData) {
+	const notVariable = {
+		isVariable: false,
+		axes: [],
+		namedInstances: []
+	};
+	const tables = readTableDirectory$1(fontData);
+	if (!tables) return notVariable;
+	const fvar = tables.get("fvar");
+	if (!fvar) return notVariable;
+	if (fvar.offset + 16 > fontData.length) return notVariable;
+	const view = new DataView(fontData.buffer, fontData.byteOffset, fontData.byteLength);
+	if (view.getUint16(fvar.offset, false) !== 1) return notVariable;
+	const axesArrayOffset = view.getUint16(fvar.offset + 4, false);
+	const axisCount = view.getUint16(fvar.offset + 8, false);
+	const axisSize = view.getUint16(fvar.offset + 10, false);
+	const instanceCount = view.getUint16(fvar.offset + 12, false);
+	const instanceSize = view.getUint16(fvar.offset + 14, false);
+	if (axisCount === 0) return notVariable;
+	if (axisSize < 20) return notVariable;
+	const axes = [];
+	const axesStart = fvar.offset + axesArrayOffset;
+	const axesBytes = axisCount * axisSize;
+	if (axesStart + axesBytes > fontData.length) return notVariable;
+	for (let i = 0; i < axisCount; i++) {
+		const recOff = axesStart + i * axisSize;
+		const tag = String.fromCharCode(view.getUint8(recOff), view.getUint8(recOff + 1), view.getUint8(recOff + 2), view.getUint8(recOff + 3));
+		const minValue = readFixed(view, recOff + 4);
+		const defaultValue = readFixed(view, recOff + 8);
+		const maxValue = readFixed(view, recOff + 12);
+		const flags = view.getUint16(recOff + 16, false);
+		axes.push({
+			tag,
+			minValue,
+			defaultValue,
+			maxValue,
+			flags,
+			name: void 0
+		});
+	}
+	const coordsBytes = axisCount * 4;
+	const baseInstanceSize = coordsBytes + 4;
+	const hasPostScriptName = instanceSize >= baseInstanceSize + 2;
+	const namedInstances = [];
+	const instancesStart = axesStart + axesBytes;
+	if (instanceSize >= baseInstanceSize) {
+		if (instancesStart + instanceCount * instanceSize <= fontData.length) for (let i = 0; i < instanceCount; i++) {
+			const recOff = instancesStart + i * instanceSize;
+			const subfamilyNameID = view.getUint16(recOff, false);
+			const coordinates = {};
+			for (let a = 0; a < axisCount; a++) {
+				const value = readFixed(view, recOff + 4 + a * 4);
+				const axis = axes[a];
+				coordinates[axis.tag] = value;
+			}
+			const instance = {
+				nameId: subfamilyNameID,
+				coordinates,
+				name: void 0
+			};
+			if (hasPostScriptName) {
+				const psNameId = view.getUint16(recOff + 4 + coordsBytes, false);
+				instance.postScriptNameId = psNameId === 65535 ? void 0 : psNameId;
+			}
+			namedInstances.push(instance);
+		}
+	}
+	let avar;
+	const avarRec = tables.get("avar");
+	if (avarRec) avar = parseAvar(fontData, avarRec, axisCount);
+	const info = {
+		isVariable: true,
+		axes,
+		namedInstances
+	};
+	if (avar) info.avar = avar;
+	return info;
+}
+/**
+* Apply an 'avar' segment map to a default-normalized coordinate.
+*
+* The segment map is an ordered list of (from, to) pairs in normalized space.
+* The input is located between two consecutive `fromCoordinate` nodes and the
+* output is linearly interpolated between the corresponding `toCoordinate`
+* values. Per spec, a valid map includes the mandatory nodes (-1,-1), (0,0),
+* (1,1); if it does not span the input, the input is clamped to the map's
+* endpoints.
+*/
+function applyAvarSegmentMap(value, segmentMap) {
+	const n = segmentMap.length;
+	if (n === 0) return value;
+	const first = segmentMap[0];
+	if (value <= first.fromCoordinate) return first.toCoordinate;
+	const last = segmentMap[n - 1];
+	if (value >= last.fromCoordinate) return last.toCoordinate;
+	for (let i = 1; i < n; i++) {
+		const lo = segmentMap[i - 1];
+		const hi = segmentMap[i];
+		if (value >= lo.fromCoordinate && value <= hi.fromCoordinate) {
+			const span = hi.fromCoordinate - lo.fromCoordinate;
+			if (span <= 0) return lo.toCoordinate;
+			const t = (value - lo.fromCoordinate) / span;
+			return lo.toCoordinate + t * (hi.toCoordinate - lo.toCoordinate);
+		}
+	}
+	return value;
+}
+/**
+* Normalize a user-scale coordinate for an axis to the normalized [-1, 0, +1]
+* scale, per the OpenType default-normalization algorithm.
+*
+* Steps:
+*  1. Clamp `userValue` to the axis's [minValue, maxValue].
+*  2. Map to normalized space: minValue→-1, defaultValue→0, maxValue→+1, with
+*     linear interpolation on each side of the default (note: the slopes on the
+*     two sides differ unless the default is exactly centered).
+*  3. If an 'avar' `segmentMap` is supplied, apply it to the result; otherwise
+*     no avar adjustment is made (the caller can pass `info.avar[axisIndex]`).
+*
+* @param axis       The axis whose user-scale bounds define the normalization.
+* @param userValue  The user-scale coordinate (e.g. 250 for a 'wght' axis).
+* @param avar       Optional 'avar' segment map for this axis.
+* @returns The normalized coordinate in [-1, 1].
+*/
+function normalizeAxisCoordinate(axis, userValue, avar) {
+	const { minValue, defaultValue, maxValue } = axis;
+	let v = userValue;
+	if (v < minValue) v = minValue;
+	else if (v > maxValue) v = maxValue;
+	let normalized;
+	if (v < defaultValue) {
+		const denom = defaultValue - minValue;
+		normalized = denom === 0 ? 0 : -(defaultValue - v) / denom;
+	} else if (v > defaultValue) {
+		const denom = maxValue - defaultValue;
+		normalized = denom === 0 ? 0 : (v - defaultValue) / denom;
+	} else normalized = 0;
+	if (normalized < -1) normalized = -1;
+	else if (normalized > 1) normalized = 1;
+	if (avar && avar.length > 0) normalized = applyAvarSegmentMap(normalized, avar);
+	return normalized;
+}
+/**
+* Resolve a named instance's coordinates against the font's axes.
+*
+* Produces a complete axis-tag → user-scale-coordinate map covering every axis
+* in the font: any axis the instance does not specify is filled with that
+* axis's `defaultValue`, and any specified coordinate is clamped to the axis's
+* [minValue, maxValue] range (per the fvar "Variation Instance Selection"
+* rules). Coordinates for tags not present on any axis are ignored.
+*
+* @param info     The parsed variable-font model.
+* @param instance The named instance to resolve.
+* @returns A validated axis-tag → user-scale coordinate map.
+*/
+function resolveInstanceCoordinates(info, instance) {
+	const resolved = {};
+	for (const axis of info.axes) {
+		let value = instance.coordinates[axis.tag] ?? axis.defaultValue;
+		if (value < axis.minValue) value = axis.minValue;
+		else if (value > axis.maxValue) value = axis.maxValue;
+		resolved[axis.tag] = value;
+	}
+	return resolved;
+}
+//#endregion
+//#region src/assets/font/colorFont.ts
+/**
+* @module assets/font/colorFont
+*
+* COLR v0 + CPAL color-font parsing (layered color glyphs).
+*
+* This module reads the two OpenType tables that together describe simple,
+* layered color glyphs:
+*
+* - **CPAL** (Color Palette Table): one or more palettes, each a list of
+*   sRGB colors. Color records are stored on disk as **BGRA** bytes and are
+*   exposed here as **RGBA** (0..255 per channel).
+* - **COLR** v0 (Color Table, version 0): maps a *base* glyph to an ordered
+*   list of *layers*. Each layer is another glyph (a monochrome outline) plus
+*   a CPAL palette-entry index giving its color.
+*
+* A renderer paints a color glyph by drawing each layer's outline glyph filled
+* with that layer's resolved palette color, bottom layer first.
+*
+* ## Verified against the OpenType 1.9.1 specification
+*
+* - CPAL header v0 / v1 and the BGRA ColorRecord byte order:
+*   https://learn.microsoft.com/en-us/typography/opentype/spec/cpal
+*   - CPAL v0 header (big-endian): version(u16)\@0, numPaletteEntries(u16)\@2,
+*     numPalettes(u16)\@4, numColorRecords(u16)\@6,
+*     colorRecordsArrayOffset(Offset32)\@8, colorRecordIndices[numPalettes]
+*     (u16 each)\@12.
+*   - "Each color record specifies a color ... using 8-bit BGRA (blue, green,
+*     red, alpha) representation." ColorRecord = blue(u8), green(u8), red(u8),
+*     alpha(u8).
+*   - "colorRecordIndex = colorRecordIndices[paletteIndex] + paletteEntryIndex".
+* - COLR v0 header and records:
+*   https://learn.microsoft.com/en-us/typography/opentype/spec/colr
+*   - COLR v0 header (big-endian): version(u16)\@0, numBaseGlyphRecords(u16)\@2,
+*     baseGlyphRecordsOffset(Offset32)\@4, layerRecordsOffset(Offset32)\@8,
+*     numLayerRecords(u16)\@12.
+*   - BaseGlyph record (6 bytes): glyphID(u16), firstLayerIndex(u16),
+*     numLayers(u16). "The BaseGlyph records must be sorted in increasing
+*     glyphID order ... a binary search can be used" — we binary-search them.
+*   - Layer record (4 bytes): glyphID(u16), paletteIndex(u16).
+*
+* ## Scope
+*
+* - Only **COLR version 0** (flat layered glyphs) is parsed. **COLR version 1**
+*   (PaintColrLayers, gradients, affine transforms, compositing) is OUT OF
+*   SCOPE and intentionally not parsed here.
+* - The CPAL `paletteIndex` special value `0xFFFF` ("use the current text
+*   foreground color") is preserved on each layer via `paletteIndex` but cannot
+*   be resolved to an RGBA value here (there is no palette entry for it); such a
+*   layer is reported with `rgba = [0, 0, 0, 255]` as a neutral fallback. A
+*   renderer should substitute the active foreground color when it sees
+*   `paletteIndex === 0xFFFF`.
+* - This module exposes the *layer + palette model only*. Actually RENDERING or
+*   EMBEDDING color glyphs into a PDF (e.g. as a Type3 font) is OUT OF SCOPE and
+*   left to a consuming renderer.
+*
+* No external dependencies. No Buffer — uses Uint8Array and DataView.
+*/
+/** The CPAL special palette index meaning "use the text foreground color". */
+const FOREGROUND_PALETTE_INDEX = 65535;
+/**
+* Read the sfnt table directory. The directory is at offset 12 as a sequence
+* of 16-byte records: { tag[4], checksum[4], offset[4], length[4] }, all
+* big-endian. Supports sfnt version 0x00010000 (TrueType) and 'OTTO' (CFF);
+* the actual sfnt version value is not needed beyond reaching the directory.
+*
+* @returns A map from 4-char table tag to its offset/length, or `undefined`
+*   if the data is too small to contain a valid directory.
+*/
+function readTableDirectory(data) {
+	if (data.length < 12) return void 0;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const numTables = view.getUint16(4, false);
+	const requiredLen = 12 + numTables * 16;
+	if (data.length < requiredLen) return void 0;
+	const tables = /* @__PURE__ */ new Map();
+	for (let i = 0; i < numTables; i++) {
+		const off = 12 + i * 16;
+		const tag = String.fromCharCode(data[off], data[off + 1], data[off + 2], data[off + 3]);
+		const offset = view.getUint32(off + 8, false);
+		const length = view.getUint32(off + 12, false);
+		tables.set(tag, {
+			offset,
+			length
+		});
+	}
+	return tables;
+}
+/**
+* Return a `DataView` bounded to a single table, or `undefined` if the table
+* is absent or its declared extent falls outside the font data.
+*/
+function tableView(data, tables, tag) {
+	const rec = tables.get(tag);
+	if (rec === void 0) return void 0;
+	if (rec.offset + rec.length > data.length) return void 0;
+	return new DataView(data.buffer, data.byteOffset + rec.offset, rec.length);
+}
+/**
+* Parse the CPAL table into palettes of RGBA colors.
+*
+* Handles CPAL versions 0 and 1 (the v1 trailing offset arrays are ignored —
+* they only carry optional UI labels and palette-type flags). Color records
+* are read as BGRA bytes and converted to RGBA.
+*
+* @returns The parsed palettes, or `undefined` if the table is malformed.
+*/
+function parseCpal(view) {
+	if (view.byteLength < 12) return void 0;
+	const numPaletteEntries = view.getUint16(2, false);
+	const numPalettes = view.getUint16(4, false);
+	const numColorRecords = view.getUint16(6, false);
+	const colorRecordsArrayOffset = view.getUint32(8, false);
+	const indicesStart = 12;
+	if (indicesStart + numPalettes * 2 > view.byteLength) return void 0;
+	if (colorRecordsArrayOffset + numColorRecords * 4 > view.byteLength) return;
+	const colorRecordIndices = [];
+	for (let i = 0; i < numPalettes; i++) colorRecordIndices.push(view.getUint16(indicesStart + i * 2, false));
+	const palettes = [];
+	for (let p = 0; p < numPalettes; p++) {
+		const firstRecord = colorRecordIndices[p];
+		const colors = [];
+		for (let e = 0; e < numPaletteEntries; e++) {
+			const recIndex = firstRecord + e;
+			if (recIndex >= numColorRecords) break;
+			const recOff = colorRecordsArrayOffset + recIndex * 4;
+			const blue = view.getUint8(recOff + 0);
+			const green = view.getUint8(recOff + 1);
+			const red = view.getUint8(recOff + 2);
+			const alpha = view.getUint8(recOff + 3);
+			colors.push([
+				red,
+				green,
+				blue,
+				alpha
+			]);
+		}
+		palettes.push({ colors });
+	}
+	return palettes;
+}
+/**
+* Read the COLR v0 header. Returns `undefined` if the table is too small or
+* its declared offsets/counts fall outside the table.
+*/
+function readColrV0(view) {
+	if (view.byteLength < 14) return void 0;
+	const numBaseGlyphRecords = view.getUint16(2, false);
+	const baseGlyphRecordsOffset = view.getUint32(4, false);
+	const layerRecordsOffset = view.getUint32(8, false);
+	const numLayerRecords = view.getUint16(12, false);
+	if (baseGlyphRecordsOffset + numBaseGlyphRecords * 6 > view.byteLength || layerRecordsOffset + numLayerRecords * 4 > view.byteLength) return;
+	return {
+		baseGlyphRecordsOffset,
+		numBaseGlyphRecords,
+		layerRecordsOffset,
+		numLayerRecords,
+		view
+	};
+}
+/**
+* Binary-search the base-glyph records (sorted by glyphID, per spec) for the
+* record matching `glyphId`.
+*
+* @returns `{ firstLayerIndex, numLayers }` or `undefined` if not a base glyph.
+*/
+function findBaseGlyph(colr, glyphId) {
+	const { view, baseGlyphRecordsOffset } = colr;
+	let lo = 0;
+	let hi = colr.numBaseGlyphRecords - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const recOff = baseGlyphRecordsOffset + mid * 6;
+		const gid = view.getUint16(recOff, false);
+		if (gid === glyphId) return {
+			firstLayerIndex: view.getUint16(recOff + 2, false),
+			numLayers: view.getUint16(recOff + 4, false)
+		};
+		if (gid < glyphId) lo = mid + 1;
+		else hi = mid - 1;
+	}
+}
+/**
+* Parse a font's color capability and CPAL palettes.
+*
+* `hasColor` is true iff the font contains a 'COLR' table. The palettes come
+* from the 'CPAL' table (which is required whenever 'COLR' is present, per the
+* OpenType spec). Color records are returned as RGBA (converted from the on-disk
+* BGRA layout).
+*
+* @param fontData - Raw sfnt font bytes (TrueType 0x00010000 or 'OTTO').
+* @returns Color info; `{ hasColor: false, numPalettes: 0, palettes: [] }` if
+*   the font has no COLR/CPAL tables or cannot be parsed.
+*/
+function parseColorFont(fontData) {
+	const empty = {
+		hasColor: false,
+		numPalettes: 0,
+		palettes: []
+	};
+	const tables = readTableDirectory(fontData);
+	if (tables === void 0) return empty;
+	const hasColor = tables.has("COLR");
+	const cpalView = tableView(fontData, tables, "CPAL");
+	if (cpalView === void 0) return {
+		hasColor,
+		numPalettes: 0,
+		palettes: []
+	};
+	const palettes = parseCpal(cpalView);
+	if (palettes === void 0) return {
+		hasColor,
+		numPalettes: 0,
+		palettes: []
+	};
+	return {
+		hasColor,
+		numPalettes: palettes.length,
+		palettes
+	};
+}
+/**
+* Resolve the COLR v0 layers of a base glyph into colored layers.
+*
+* For each layer of the requested base glyph, the layer's outline glyph id is
+* returned together with its CPAL palette-entry index and the RGBA color that
+* index resolves to in the selected palette.
+*
+* A glyph that is **not** a COLR base glyph (or a font with no COLR/CPAL table)
+* returns `[]` — such a glyph is drawn as a normal monochrome glyph.
+*
+* The special palette index `0xFFFF` ("foreground color") is preserved on the
+* layer's `paletteIndex` but, having no palette entry, resolves to the neutral
+* fallback `[0, 0, 0, 255]`; a renderer should substitute the active text color.
+*
+* @param fontData - Raw sfnt font bytes.
+* @param glyphId - The base glyph id to expand.
+* @param paletteIndex - Which CPAL palette to resolve colors from. Defaults to
+*   palette 0 (the default palette). Out-of-range values fall back to palette 0.
+* @returns The ordered (bottom-first) list of colored layers, or `[]`.
+*/
+function getColorGlyphLayers(fontData, glyphId, paletteIndex = 0) {
+	const tables = readTableDirectory(fontData);
+	if (tables === void 0) return [];
+	const colrView = tableView(fontData, tables, "COLR");
+	if (colrView === void 0) return [];
+	const colr = readColrV0(colrView);
+	if (colr === void 0) return [];
+	const base = findBaseGlyph(colr, glyphId);
+	if (base === void 0) return [];
+	const cpalView = tableView(fontData, tables, "CPAL");
+	const palettes = cpalView !== void 0 ? parseCpal(cpalView) : void 0;
+	const selectedPalette = palettes !== void 0 && palettes.length > 0 ? palettes[paletteIndex] ?? palettes[0] : void 0;
+	const layers = [];
+	const { view, layerRecordsOffset, numLayerRecords } = colr;
+	for (let i = 0; i < base.numLayers; i++) {
+		const layerIndex = base.firstLayerIndex + i;
+		if (layerIndex >= numLayerRecords) break;
+		const recOff = layerRecordsOffset + layerIndex * 4;
+		const layerGid = view.getUint16(recOff, false);
+		const layerPaletteIndex = view.getUint16(recOff + 2, false);
+		let rgba = [
+			0,
+			0,
+			0,
+			255
+		];
+		if (layerPaletteIndex !== FOREGROUND_PALETTE_INDEX && selectedPalette !== void 0 && layerPaletteIndex < selectedPalette.colors.length) {
+			const c = selectedPalette.colors[layerPaletteIndex];
+			rgba = [
+				c[0],
+				c[1],
+				c[2],
+				c[3]
+			];
+		}
+		layers.push({
+			glyphId: layerGid,
+			paletteIndex: layerPaletteIndex,
+			rgba
+		});
+	}
+	return layers;
+}
+//#endregion
+//#region src/core/meshShading.ts
+/**
+* @module core/meshShading
+*
+* Mesh shadings — ShadingType 4, 5, 6 and 7 (ISO 32000-2:2020 §8.7.4.5.5–.8).
+*
+* Mesh shadings define colour over a 2-D region by tessellating it into either
+* Gouraud-shaded triangles (types 4 and 5) or parametric patches (types 6 and
+* 7). Unlike the dictionary-only shadings (types 1–3), a mesh shading's data is
+* carried in a **stream** whose body is a packed sequence of binary records.
+*
+* Bit-packing rule (ISO 32000-2 §8.7.4.5.5, "All vertex coordinates and colour
+* values shall be encoded as ... a sequence of bits ... most significant bit
+* first"): every value — flag, coordinate and colour component — is written
+* big-endian, MSB-first, into a continuous bit stream with **no padding between
+* values**. Only the very end of the stream is padded with zero bits up to the
+* next byte boundary. (§8.7.4.5.5 further notes each value may begin at any bit
+* position; there is no per-record byte alignment.)
+*
+* Numeric mapping (ISO 32000-2 §8.7.4.5.5, Table 84 /Decode semantics): a
+* coordinate or colour value is stored as an unsigned integer `v` in the range
+* `[0, 2^bits − 1]` and decoded as
+*   `decoded = Dmin + v · (Dmax − Dmin) / (2^bits − 1)`
+* where `[Dmin, Dmax]` is the matching pair in the shading's /Decode array. The
+* /Decode layout is `[xmin xmax ymin ymax c1min c1max … cnmin cnmax]` (or, when
+* /Function is present, a single `[tmin tmax]` colour pair). The builders here
+* take **decoded** user values and invert that mapping to obtain the raw
+* integers to pack, rounding to nearest.
+*
+* Record layouts verified against ISO 32000-2:2020:
+*  - Type 4 (§8.7.4.5.5): per vertex → flag (BitsPerFlag) · x · y · colour[n].
+*  - Type 5 (§8.7.4.5.6): per vertex → x · y · colour[n]; NO flag; adds
+*    /VerticesPerRow (≥ 2). Vertices are given row by row.
+*  - Type 6 (§8.7.4.5.7): per patch → flag (BitsPerFlag) · coordinate pairs ·
+*    colours. Flag 0 (new patch) = 12 coordinate pairs + 4 colours; flags 1–3
+*    (shared edge) = 8 coordinate pairs + 2 colours.
+*  - Type 7 (§8.7.4.5.8): like type 6 but flag 0 = 16 coordinate pairs +
+*    4 colours; flags 1–3 = 12 coordinate pairs + 2 colours.
+*
+* No Buffer — uses Uint8Array exclusively.
+*/
+/**
+* Accumulates unsigned integer values of arbitrary bit width into a byte
+* stream, big-endian and most-significant-bit-first, with no inter-value
+* padding. The final byte is zero-padded to the byte boundary on
+* {@link BitPacker.finish}.
+*
+* @internal
+*/
+var BitPacker = class {
+	bytes = [];
+	/** Bits already filled in the current (pending) byte, 0–7. */
+	bitPos = 0;
+	/** The partially filled current byte (high bits set first). */
+	current = 0;
+	/**
+	* Append `bits`-wide unsigned integer `value`, MSB first.
+	*
+	* @param value - non-negative integer in `[0, 2^bits − 1]`.
+	* @param bits - field width (1–32).
+	*/
+	push(value, bits) {
+		for (let i = bits - 1; i >= 0; i--) {
+			const bit = value >>> i & 1;
+			this.current = this.current << 1 | bit;
+			this.bitPos++;
+			if (this.bitPos === 8) {
+				this.bytes.push(this.current & 255);
+				this.current = 0;
+				this.bitPos = 0;
+			}
+		}
+	}
+	/**
+	* Flush the pending partial byte (zero-padded on the low bits) and return the
+	* packed buffer.
+	*/
+	finish() {
+		if (this.bitPos > 0) {
+			this.bytes.push(this.current << 8 - this.bitPos & 255);
+			this.current = 0;
+			this.bitPos = 0;
+		}
+		return Uint8Array.from(this.bytes);
+	}
+};
+/**
+* Invert the /Decode mapping for one value: given a decoded user value and its
+* `[min, max]` pair, return the raw unsigned integer in `[0, 2^bits − 1]`.
+*
+* `raw = round((decoded − min) / (max − min) · (2^bits − 1))`, clamped to the
+* representable range (ISO 32000-2 §8.7.4.5.5, /Decode semantics). A degenerate
+* `min == max` pair maps everything to 0.
+*
+* @internal
+*/
+function encodeValue(decoded, min, max, bits) {
+	const maxRaw = bits >= 32 ? 4294967295 : (1 << bits) - 1;
+	if (max === min) return 0;
+	const t = (decoded - min) / (max - min);
+	const raw = Math.round(t * maxRaw);
+	if (raw < 0) return 0;
+	if (raw > maxRaw) return maxRaw;
+	return raw;
+}
+/**
+* Number of colour components carried per vertex/corner:
+* 1 when a /Function is present (parametric `t`), else the count implied by the
+* colour /Decode pairs.
+*
+* @internal
+*/
+function colorComponentCount(common) {
+	if (common.function !== void 0) return 1;
+	const colorPairs = (common.decode.length - 4) / 2;
+	return Math.max(1, Math.trunc(colorPairs));
+}
+/**
+* Pack one vertex's coordinates then its colours (no flag) into `packer`.
+*
+* @internal
+*/
+function packVertexData(packer, vertex, common, nColor) {
+	const { decode, bitsPerCoordinate: bpcoord, bitsPerComponent: bpcomp } = common;
+	packer.push(encodeValue(vertex.x, decode[0] ?? 0, decode[1] ?? 1, bpcoord), bpcoord);
+	packer.push(encodeValue(vertex.y, decode[2] ?? 0, decode[3] ?? 1, bpcoord), bpcoord);
+	for (let k = 0; k < nColor; k++) {
+		const cmin = decode[4 + 2 * k] ?? 0;
+		const cmax = decode[5 + 2 * k] ?? 1;
+		const comp = vertex.color[k] ?? 0;
+		packer.push(encodeValue(comp, cmin, cmax, bpcomp), bpcomp);
+	}
+}
+/**
+* Pack a single `[x, y]` control point (coordinates only) into `packer`.
+*
+* @internal
+*/
+function packPoint(packer, point, common) {
+	const { decode, bitsPerCoordinate: bpcoord } = common;
+	packer.push(encodeValue(point[0], decode[0] ?? 0, decode[1] ?? 1, bpcoord), bpcoord);
+	packer.push(encodeValue(point[1], decode[2] ?? 0, decode[3] ?? 1, bpcoord), bpcoord);
+}
+/**
+* Pack one colour (n components) into `packer`.
+*
+* @internal
+*/
+function packColor(packer, color, common, nColor) {
+	const { decode, bitsPerComponent: bpcomp } = common;
+	for (let k = 0; k < nColor; k++) {
+		const cmin = decode[4 + 2 * k] ?? 0;
+		const cmax = decode[5 + 2 * k] ?? 1;
+		const comp = color[k] ?? 0;
+		packer.push(encodeValue(comp, cmin, cmax, bpcomp), bpcomp);
+	}
+}
+/**
+* Build the dictionary shared by every mesh shading and set the common keys.
+*
+* @internal
+*/
+function buildCommonDict(shadingType, common, includeFlag) {
+	const dict = new require_pdfObjects.PdfDict();
+	dict.set("/ShadingType", require_pdfObjects.PdfNumber.of(shadingType));
+	dict.set("/ColorSpace", common.colorSpace);
+	dict.set("/BitsPerCoordinate", require_pdfObjects.PdfNumber.of(common.bitsPerCoordinate));
+	dict.set("/BitsPerComponent", require_pdfObjects.PdfNumber.of(common.bitsPerComponent));
+	if (includeFlag) dict.set("/BitsPerFlag", require_pdfObjects.PdfNumber.of(common.bitsPerFlag));
+	dict.set("/Decode", require_pdfObjects.PdfArray.fromNumbers([...common.decode]));
+	if (common.function !== void 0) dict.set("/Function", common.function);
+	return dict;
+}
+/**
+* Build a free-form Gouraud-shaded triangle mesh shading
+* (ISO 32000-2 §8.7.4.5.5, /ShadingType 4).
+*
+* Each vertex is packed as `flag · x · y · colour[n]`, MSB-first, with the flag
+* `bitsPerFlag` wide.
+*
+* @param options - the common mesh keys plus the triangle/vertex data.
+* @returns a {@link PdfStream} whose dict has /ShadingType 4 and whose body is
+*          the packed vertex stream.
+*/
+function buildFreeFormGouraudShading(options) {
+	const dict = buildCommonDict(4, options, true);
+	const nColor = colorComponentCount(options);
+	const packer = new BitPacker();
+	for (const tri of options.triangles) for (const vertex of tri.vertices) {
+		packer.push(vertex.flag, options.bitsPerFlag);
+		packVertexData(packer, vertex, options, nColor);
+	}
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
+}
+/**
+* Build a lattice-form Gouraud-shaded triangle mesh shading
+* (ISO 32000-2 §8.7.4.5.6, /ShadingType 5).
+*
+* Vertices carry **no** flag; the mesh topology is implied by /VerticesPerRow.
+* Each vertex is packed as `x · y · colour[n]`, MSB-first.
+*
+* @param options - the common mesh keys (sans /BitsPerFlag) plus
+*                   /VerticesPerRow and the row-major vertex list.
+* @returns a {@link PdfStream} with /ShadingType 5 and /VerticesPerRow.
+*/
+function buildLatticeFormGouraudShading(options) {
+	const common = {
+		colorSpace: options.colorSpace,
+		bitsPerCoordinate: options.bitsPerCoordinate,
+		bitsPerComponent: options.bitsPerComponent,
+		bitsPerFlag: 8,
+		decode: options.decode,
+		function: options.function
+	};
+	const dict = buildCommonDict(5, common, false);
+	dict.set("/VerticesPerRow", require_pdfObjects.PdfNumber.of(options.verticesPerRow));
+	const nColor = colorComponentCount(common);
+	const packer = new BitPacker();
+	for (const vertex of options.vertices) packVertexData(packer, vertex, common, nColor);
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
+}
+/**
+* Build a Coons patch mesh shading
+* (ISO 32000-2 §8.7.4.5.7, /ShadingType 6).
+*
+* Each patch is packed as `flag · points · colours`. A flag-0 patch carries 12
+* control points and 4 corner colours; flags 1–3 carry 8 control points and 2
+* colours (the rest are inherited from the shared edge of the previous patch).
+*
+* @param options - the common mesh keys plus the patch list.
+* @returns a {@link PdfStream} with /ShadingType 6.
+*/
+function buildCoonsPatchShading(options) {
+	const dict = buildCommonDict(6, options, true);
+	const nColor = colorComponentCount(options);
+	const packer = new BitPacker();
+	for (const patch of options.patches) {
+		packer.push(patch.flag, options.bitsPerFlag);
+		for (const point of patch.points) packPoint(packer, point, options);
+		for (const color of patch.colors) packColor(packer, color, options, nColor);
+	}
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
+}
+/**
+* Build a tensor-product patch mesh shading
+* (ISO 32000-2 §8.7.4.5.8, /ShadingType 7).
+*
+* Identical packing to type 6 but a flag-0 patch carries 16 control points (the
+* 4 internal tensor points in addition to the 12 boundary points) plus 4 corner
+* colours; flags 1–3 carry 12 control points and 2 colours.
+*
+* @param options - the common mesh keys plus the patch list.
+* @returns a {@link PdfStream} with /ShadingType 7.
+*/
+function buildTensorPatchShading(options) {
+	const dict = buildCommonDict(7, options, true);
+	const nColor = colorComponentCount(options);
+	const packer = new BitPacker();
+	for (const patch of options.patches) {
+		packer.push(patch.flag, options.bitsPerFlag);
+		for (const point of patch.points) packPoint(packer, point, options);
+		for (const color of patch.colors) packColor(packer, color, options, nColor);
+	}
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
+}
+//#endregion
+//#region src/color/iccTransform.ts
+/**
+* ICC PCS reference white, D50, in XYZ (ICC.1:2010 §6.3.4.3 / Annex A,
+* encoded white point `[0.9642, 1.0000, 0.8249]`).
+*/
+const D50_WHITE = [
+	.9642,
+	1,
+	.8249
+];
+/** CIE L\*a\*b\* threshold δ = 6/29 (CIE 15:2004 §8.2.1). */
+const LAB_DELTA$1 = 6 / 29;
+/** δ³ — the f(t) breakpoint in the t domain. */
+const LAB_DELTA_CUBED$1 = LAB_DELTA$1 * LAB_DELTA$1 * LAB_DELTA$1;
+/** 1 / (3·δ²) — slope of the linear segment of f(t). */
+const LAB_LINEAR_SLOPE = 1 / (3 * LAB_DELTA$1 * LAB_DELTA$1);
+/** 4/29 — intercept of the linear segment of f(t). */
+const LAB_LINEAR_INTERCEPT = 4 / 29;
+const HEADER_SIZE = 128;
+const TAG_COUNT_OFFSET = 128;
+const TAG_TABLE_OFFSET = 132;
+const TAG_RECORD_SIZE = 12;
+/** Decode a 4-byte ASCII signature at `off`. */
+function readSig(data, off) {
+	return String.fromCharCode(data[off], data[off + 1], data[off + 2], data[off + 3]);
+}
+/** s15Fixed16Number → JS number (ICC.1:2010 §4.2): signed int32 / 65536. */
+function readS15Fixed16(view, off) {
+	return view.getInt32(off, false) / 65536;
+}
+/**
+* Read the tag table into a `sig → {offset,size}` map.
+*
+* @throws if the profile is shorter than a header + tag count, or the tag
+*         table extends past the end of the data.
+*/
+function readTagTable(data) {
+	if (data.length < TAG_TABLE_OFFSET) throw new Error(`ICC profile too short: ${data.length} bytes (need at least ${TAG_TABLE_OFFSET}).`);
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const count = view.getUint32(TAG_COUNT_OFFSET, false);
+	if (TAG_TABLE_OFFSET + count * TAG_RECORD_SIZE > data.length) throw new Error(`ICC tag table (${count} tags) overruns profile of ${data.length} bytes.`);
+	const table = /* @__PURE__ */ new Map();
+	for (let i = 0; i < count; i++) {
+		const rec = TAG_TABLE_OFFSET + i * TAG_RECORD_SIZE;
+		const sig = readSig(data, rec);
+		const offset = view.getUint32(rec + 4, false);
+		const size = view.getUint32(rec + 8, false);
+		table.set(sig, {
+			offset,
+			size
+		});
+	}
+	return table;
+}
+/**
+* Parse the matrix/TRC-relevant header fields and detect whether the profile
+* carries a complete matrix/TRC model.
+*
+* Reads the 128-byte ICC header (ICC.1:2010 §7.2): version (offset 8),
+* deviceClass (offset 12), data colour space (offset 16) and PCS (offset 20),
+* then inspects the tag table (§7.3) for the colorant + TRC tags.
+*
+* @param profile - Raw ICC profile bytes.
+* @returns Parsed {@link IccTransformInfo}.
+* @throws if the profile is too short to contain a header and tag table.
+*
+* @example
+* ```ts
+* import { parseIccTransform } from 'modern-pdf-lib';
+*
+* const info = parseIccTransform(profileBytes);
+* if (info.hasMatrixTrc && info.colorSpace === 'RGB ') {
+*   // safe to call deviceRgbToXyz
+* }
+* ```
+*/
+function parseIccTransform(profile) {
+	if (profile.length < HEADER_SIZE) throw new Error(`ICC profile too short: ${profile.length} bytes (need at least ${HEADER_SIZE}).`);
+	const version = new DataView(profile.buffer, profile.byteOffset, profile.byteLength).getUint32(8, false);
+	const deviceClass = readSig(profile, 12);
+	const colorSpace = readSig(profile, 16);
+	const pcs = readSig(profile, 20);
+	const table = readTagTable(profile);
+	let hasMatrixTrc;
+	if (colorSpace === "GRAY") hasMatrixTrc = table.has("kTRC");
+	else hasMatrixTrc = table.has("rXYZ") && table.has("gXYZ") && table.has("bXYZ") && table.has("rTRC") && table.has("gTRC") && table.has("bTRC");
+	return {
+		version,
+		deviceClass,
+		colorSpace,
+		pcs,
+		hasMatrixTrc
+	};
+}
+/**
+* Evaluate a TRC tag (`curv` or `para`) at a normalised input `x ∈ [0,1]`,
+* returning the linearised value in `[0,1]`.
+*
+*  - `curv` (ICC.1:2010 §10.6): `count` u16 follows the 8-byte type header.
+*    `count == 0` → identity; `count == 1` → a single u8Fixed8Number gamma
+*    (Y = X^g); `count >= 2` → a uInt16 sampled curve over the input domain
+*    [0,1], linearly interpolated, output normalised by 65535.
+*  - `para` (ICC.1:2010 §10.18): a u16 function type + s15Fixed16 parameters.
+*    Implements function types 0–4 from the spec.
+*
+* @throws if the tag type is neither `curv` nor `para`, or is truncated.
+*/
+function evalTrc(data, tag, x) {
+	const start = tag.offset;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const type = readSig(data, start);
+	const xi = x < 0 ? 0 : x > 1 ? 1 : x;
+	if (type === "curv") {
+		const count = view.getUint32(start + 8, false);
+		if (count === 0) return xi;
+		if (count === 1) return xi ** (view.getUint16(start + 12, false) / 256);
+		const lutStart = start + 12;
+		const pos = xi * (count - 1);
+		const i0 = Math.floor(pos);
+		const i1 = i0 >= count - 1 ? count - 1 : i0 + 1;
+		const frac = pos - i0;
+		const v0 = view.getUint16(lutStart + i0 * 2, false);
+		return (v0 + (view.getUint16(lutStart + i1 * 2, false) - v0) * frac) / 65535;
+	}
+	if (type === "para") {
+		const funcType = view.getUint16(start + 8, false);
+		const p = (i) => readS15Fixed16(view, start + 12 + i * 4);
+		const g = p(0);
+		switch (funcType) {
+			case 0: return xi ** g;
+			case 1: {
+				const a = p(1);
+				const b = p(2);
+				return a * xi + b >= 0 ? (a * xi + b) ** g : 0;
+			}
+			case 2: {
+				const a = p(1);
+				const b = p(2);
+				const c = p(3);
+				return (a * xi + b >= 0 ? (a * xi + b) ** g : 0) + c;
+			}
+			case 3: {
+				const a = p(1);
+				const b = p(2);
+				const c = p(3);
+				return xi >= p(4) ? (a * xi + b) ** g : c * xi;
+			}
+			case 4: {
+				const a = p(1);
+				const b = p(2);
+				const c = p(3);
+				const d = p(4);
+				const e = p(5);
+				const f = p(6);
+				return xi >= d ? (a * xi + b) ** g + e : c * xi + f;
+			}
+			default: throw new Error(`Unsupported parametricCurveType function type ${funcType} (ICC.1:2010 §10.18 defines 0–4).`);
+		}
+	}
+	throw new Error(`Unsupported TRC tag type '${type}': only 'curv' and 'para' are matrix/TRC curves (got a LUT/other type).`);
+}
+/** Read a 3-component colorant XYZ from an 'XYZ ' tag. */
+function readXyzTag(data, tag) {
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const type = readSig(data, tag.offset);
+	if (type !== "XYZ ") throw new Error(`Expected an 'XYZ ' colorant tag but found '${type}' (ICC.1:2010 §10.31).`);
+	return [
+		readS15Fixed16(view, tag.offset + 8),
+		readS15Fixed16(view, tag.offset + 12),
+		readS15Fixed16(view, tag.offset + 16)
+	];
+}
+/**
+* Transform a device colour through a **matrix/TRC** ICC profile into the
+* D50-relative PCS XYZ.
+*
+* For RGB (`colorSpace === 'RGB '`): each channel is linearised through its
+* `rTRC`/`gTRC`/`bTRC` curve, then multiplied by the colorant matrix whose
+* columns are the `rXYZ`/`gXYZ`/`bXYZ` tags (ICC.1:2010 §E.1.1).
+*
+* For GRAY (`colorSpace === 'GRAY'`): the single value is linearised through
+* `kTRC` and scaled by the media white point (`wtpt`, defaulting to D50).
+*
+* The result is **D50-relative XYZ**, matching the ICC PCS reference
+* illuminant; feed it directly to {@link xyzToLab} (whose default white point
+* is D50).
+*
+* @param profile - Raw ICC profile bytes.
+* @param rgb     - Device colour in `[0,1]`. For gray profiles only the first
+*                  component is used.
+* @returns PCS XYZ `[X, Y, Z]`, D50-relative.
+* @throws if the profile is **not** matrix/TRC (i.e. it is LUT-based —
+*         `mft1`/`mft2`/`mAB `/`mBA `), or its colour space is unsupported.
+*
+* @example
+* ```ts
+* import { deviceRgbToXyz } from 'modern-pdf-lib';
+*
+* const xyz = deviceRgbToXyz(srgbProfileBytes, [1, 1, 1]);
+* // ~ [0.9642, 1.0, 0.8249]  (D50 white)
+* ```
+*/
+function deviceRgbToXyz(profile, rgb) {
+	const info = parseIccTransform(profile);
+	const table = readTagTable(profile);
+	if (info.colorSpace === "GRAY") {
+		const kTrc = table.get("kTRC");
+		if (!kTrc) throw new Error("Gray ICC profile lacks a 'kTRC' tag; not a matrix/TRC profile.");
+		const lin = evalTrc(profile, kTrc, rgb[0]);
+		const wtptRec = table.get("wtpt");
+		const white = wtptRec ? readXyzTag(profile, wtptRec) : [
+			D50_WHITE[0],
+			D50_WHITE[1],
+			D50_WHITE[2]
+		];
+		return [
+			lin * white[0],
+			lin * white[1],
+			lin * white[2]
+		];
+	}
+	if (info.colorSpace !== "RGB ") throw new Error(`deviceRgbToXyz supports 'RGB ' and 'GRAY' profiles; got '${info.colorSpace}'.`);
+	if (!info.hasMatrixTrc) throw new Error("ICC profile is not matrix/TRC (LUT-based: mft1/mft2/mAB /mBA ); matrix/TRC transform cannot be applied. Use a CMM/LUT evaluator instead.");
+	const rTrc = table.get("rTRC");
+	const gTrc = table.get("gTRC");
+	const bTrc = table.get("bTRC");
+	const rLin = evalTrc(profile, rTrc, rgb[0]);
+	const gLin = evalTrc(profile, gTrc, rgb[1]);
+	const bLin = evalTrc(profile, bTrc, rgb[2]);
+	const rCol = readXyzTag(profile, table.get("rXYZ"));
+	const gCol = readXyzTag(profile, table.get("gXYZ"));
+	const bCol = readXyzTag(profile, table.get("bXYZ"));
+	return [
+		rCol[0] * rLin + gCol[0] * gLin + bCol[0] * bLin,
+		rCol[1] * rLin + gCol[1] * gLin + bCol[1] * bLin,
+		rCol[2] * rLin + gCol[2] * gLin + bCol[2] * bLin
+	];
+}
+/**
+* CIE L\*a\*b\* nonlinearity f(t) (CIE 15:2004 §8.2.1.1):
+*
+* ```
+*   f(t) = t^(1/3)                       for t >  δ³
+*   f(t) = t / (3·δ²) + 4/29             for t <= δ³,   δ = 6/29
+* ```
+*/
+function labF$1(t) {
+	return t > LAB_DELTA_CUBED$1 ? Math.cbrt(t) : t * LAB_LINEAR_SLOPE + LAB_LINEAR_INTERCEPT;
+}
+/**
+* Convert PCS XYZ to CIE L\*a\*b\* (CIE 15:2004 §8.2.1 / ICC PCS):
+*
+* ```
+*   L* = 116·f(Y/Yn) − 16
+*   a* = 500·(f(X/Xn) − f(Y/Yn))
+*   b* = 200·(f(Y/Yn) − f(Z/Zn))
+* ```
+*
+* with f as in {@link labF}. The default reference white is **D50**
+* `[0.9642, 1.0000, 0.8249]`, matching the ICC PCS (ICC.1:2010 §6.3.4.3), so
+* XYZ produced by {@link deviceRgbToXyz} maps straight through.
+*
+* @param xyz        - XYZ tristimulus, relative to `whitePoint`.
+* @param whitePoint - Reference white `[Xn, Yn, Zn]`. Defaults to D50.
+* @returns `[L*, a*, b*]`.
+*
+* @example
+* ```ts
+* import { xyzToLab } from 'modern-pdf-lib';
+*
+* xyzToLab([0.9642, 1.0, 0.8249]); // ~ [100, 0, 0]  (D50 white)
+* ```
+*/
+function xyzToLab(xyz, whitePoint = [
+	D50_WHITE[0],
+	D50_WHITE[1],
+	D50_WHITE[2]
+]) {
+	const fx = labF$1(xyz[0] / whitePoint[0]);
+	const fy = labF$1(xyz[1] / whitePoint[1]);
+	const fz = labF$1(xyz[2] / whitePoint[2]);
+	return [
+		116 * fy - 16,
+		500 * (fx - fy),
+		200 * (fy - fz)
+	];
+}
+//#endregion
+//#region src/color/colorConvert.ts
+/**
+* @module color/colorConvert
+*
+* Pure **device** colour-space conversions — no ICC, no chromatic adaptation
+* beyond what each standard formula already bakes in. These are the textbook
+* conversions used for previewing, picking and authoring colour; they are not
+* a substitute for ICC-based colour management.
+*
+* All channels are normalised to `0..1`, with two exceptions that follow the
+* natural ranges of their spaces:
+*  - **Hue** is in degrees `[0, 360)`.
+*  - **CIE L\*a\*b\*** uses its native ranges: `L ∈ [0, 100]`, `a`/`b`
+*    unbounded (typically `[-128, 127]`).
+*
+* ## Verified reference constants
+*
+* **sRGB transfer function** — IEC 61966-2-1:1999 (sRGB). The companded↔linear
+* piecewise curve:
+*  - expand (companded→linear): `c ≤ 0.04045 → c/12.92`,
+*    else `((c + 0.055)/1.055)^2.4`.
+*  - compress (linear→companded): `c ≤ 0.0031308 → 12.92·c`,
+*    else `1.055·c^(1/2.4) − 0.055`.
+*
+* **sRGB ↔ XYZ (D65) matrices** — IEC 61966-2-1, as tabulated by Bruce
+* Lindbloom (sRGB, reference white D65). Forward (linear sRGB → XYZ):
+* ```
+*   X = 0.4124564 R + 0.3575761 G + 0.1804375 B
+*   Y = 0.2126729 R + 0.7151522 G + 0.0721750 B
+*   Z = 0.0193339 R + 0.1191920 G + 0.9503041 B
+* ```
+* Inverse (XYZ → linear sRGB):
+* ```
+*   R =  3.2404542 X − 1.5371385 Y − 0.4985314 Z
+*   G = −0.9692660 X + 1.8760108 Y + 0.0415560 Z
+*   B =  0.0556434 X − 0.2040259 Y + 1.0572252 Z
+* ```
+*
+* **D65 reference white** — CIE 1931 2° observer, normalised to `Y = 1`:
+* `Xn = 0.95047, Yn = 1.00000, Zn = 1.08883`.
+*
+* **CIE L\*a\*b\*** — CIE 15 colorimetry, using the rational `δ = 6/29`
+* formulation (numerically identical to the `0.008856 / 903.3` form but
+* continuous at the join):
+* ```
+*   f(t) = t^(1/3)              if t > δ³
+*        = t/(3δ²) + 4/29       otherwise
+*   L = 116·f(Y/Yn) − 16
+*   a = 500·(f(X/Xn) − f(Y/Yn))
+*   b = 200·(f(Y/Yn) − f(Z/Zn))
+* ```
+* with the inverse `f⁻¹(t) = t³` if `t > δ` else `3δ²·(t − 4/29)`.
+*
+* > **Note on Lab white point.** This module's `rgbToLab` / `labToRgb` use the
+* > **D65** PCS that matches the sRGB→XYZ pipeline, per this module's spec.
+* > That differs from {@link module:core/colorSpacesCIE}'s `labToRgb`, which
+* > targets the **D50** ICC profile-connection-space convention. The two are
+* > intentionally distinct and should not be confused.
+*
+* No `Buffer` — plain `number` arithmetic and tuples only.
+*/
+/**
+* CIE 1931 2° D65 reference white, normalised so `Yn = 1`.
+* (IEC 61966-2-1 / CIE 15.)
+*/
+const D65_WHITE = [
+	.95047,
+	1,
+	1.08883
+];
+/** CIE Lab constant `δ = 6/29`. */
+const LAB_DELTA = 6 / 29;
+/** `δ³` — the linear/cubic break point for the forward nonlinearity `f(t)`. */
+const LAB_DELTA_CUBED = LAB_DELTA * LAB_DELTA * LAB_DELTA;
+/** `3δ²` — slope of the linear branch. */
+const LAB_3_DELTA_SQUARED = 3 * LAB_DELTA * LAB_DELTA;
+/** Clamp `x` to the closed interval `[lo, hi]`. */
+function clamp(x, lo, hi) {
+	return x < lo ? lo : x > hi ? hi : x;
+}
+/** Normalise a hue in degrees into `[0, 360)`. */
+function normalizeHue(h) {
+	const m = h % 360;
+	return m < 0 ? m + 360 : m;
+}
+/**
+* Convert device RGB to HSL.
+*
+* @param r - Red,   0..1.
+* @param g - Green, 0..1.
+* @param b - Blue,  0..1.
+* @returns `[h, s, l]` with `h` in `[0, 360)`, `s`/`l` in `0..1`.
+*/
+function rgbToHsl(r, g, b) {
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const delta = max - min;
+	const l = (max + min) / 2;
+	if (delta === 0) return [
+		0,
+		0,
+		l
+	];
+	const s = delta / (1 - Math.abs(2 * l - 1));
+	let h;
+	if (max === r) h = (g - b) / delta % 6;
+	else if (max === g) h = (b - r) / delta + 2;
+	else h = (r - g) / delta + 4;
+	h *= 60;
+	return [
+		normalizeHue(h),
+		s,
+		l
+	];
+}
+/**
+* Convert HSL to device RGB.
+*
+* @param h - Hue in degrees (any real; wrapped into `[0, 360)`).
+* @param s - Saturation, 0..1.
+* @param l - Lightness,  0..1.
+* @returns `[r, g, b]`, each 0..1.
+*/
+function hslToRgb(h, s, l) {
+	const hue = normalizeHue(h);
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+	const mAdd = l - c / 2;
+	let r1 = 0;
+	let g1 = 0;
+	let b1 = 0;
+	if (hue < 60) {
+		r1 = c;
+		g1 = x;
+	} else if (hue < 120) {
+		r1 = x;
+		g1 = c;
+	} else if (hue < 180) {
+		g1 = c;
+		b1 = x;
+	} else if (hue < 240) {
+		g1 = x;
+		b1 = c;
+	} else if (hue < 300) {
+		r1 = x;
+		b1 = c;
+	} else {
+		r1 = c;
+		b1 = x;
+	}
+	return [
+		r1 + mAdd,
+		g1 + mAdd,
+		b1 + mAdd
+	];
+}
+/**
+* Convert device RGB to HSV.
+*
+* @param r - Red,   0..1.
+* @param g - Green, 0..1.
+* @param b - Blue,  0..1.
+* @returns `[h, s, v]` with `h` in `[0, 360)`, `s`/`v` in `0..1`.
+*/
+function rgbToHsv(r, g, b) {
+	const max = Math.max(r, g, b);
+	const delta = max - Math.min(r, g, b);
+	const v = max;
+	if (delta === 0) return [
+		0,
+		0,
+		v
+	];
+	const s = max === 0 ? 0 : delta / max;
+	let h;
+	if (max === r) h = (g - b) / delta % 6;
+	else if (max === g) h = (b - r) / delta + 2;
+	else h = (r - g) / delta + 4;
+	h *= 60;
+	return [
+		normalizeHue(h),
+		s,
+		v
+	];
+}
+/**
+* Convert HSV to device RGB.
+*
+* @param h - Hue in degrees (any real; wrapped into `[0, 360)`).
+* @param s - Saturation, 0..1.
+* @param v - Value,      0..1.
+* @returns `[r, g, b]`, each 0..1.
+*/
+function hsvToRgb(h, s, v) {
+	const hue = normalizeHue(h);
+	const c = v * s;
+	const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+	const mAdd = v - c;
+	let r1 = 0;
+	let g1 = 0;
+	let b1 = 0;
+	if (hue < 60) {
+		r1 = c;
+		g1 = x;
+	} else if (hue < 120) {
+		r1 = x;
+		g1 = c;
+	} else if (hue < 180) {
+		g1 = c;
+		b1 = x;
+	} else if (hue < 240) {
+		g1 = x;
+		b1 = c;
+	} else if (hue < 300) {
+		r1 = x;
+		b1 = c;
+	} else {
+		r1 = c;
+		b1 = x;
+	}
+	return [
+		r1 + mAdd,
+		g1 + mAdd,
+		b1 + mAdd
+	];
+}
+/** Gamma-expand a companded sRGB channel to linear (IEC 61966-2-1). */
+function srgbToLinear(c) {
+	return c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
+}
+/** Gamma-compress a linear channel to companded sRGB (IEC 61966-2-1). */
+function linearToSrgb(c) {
+	return c <= .0031308 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - .055;
+}
+/**
+* Convert device (sRGB) RGB to CIE XYZ relative to the D65 white point.
+*
+* Gamma-expands each channel, then applies the IEC 61966-2-1 sRGB→XYZ D65
+* matrix. The returned `Y` is `1.0` for input white `(1, 1, 1)`.
+*
+* @param r - Red,   0..1.
+* @param g - Green, 0..1.
+* @param b - Blue,  0..1.
+* @returns `[X, Y, Z]` (D65, `Y = 1` for white).
+*/
+function rgbToXyz(r, g, b) {
+	const rl = srgbToLinear(r);
+	const gl = srgbToLinear(g);
+	const bl = srgbToLinear(b);
+	return [
+		.4124564 * rl + .3575761 * gl + .1804375 * bl,
+		.2126729 * rl + .7151522 * gl + .072175 * bl,
+		.0193339 * rl + .119192 * gl + .9503041 * bl
+	];
+}
+/**
+* Convert CIE XYZ (D65) to device (sRGB) RGB.
+*
+* Applies the inverse sRGB matrix, then gamma-companding. Results are clamped
+* to `0..1` to keep them in the displayable device gamut.
+*
+* @param x - CIE X (D65).
+* @param y - CIE Y (D65).
+* @param z - CIE Z (D65).
+* @returns `[r, g, b]`, each clamped to 0..1.
+*/
+function xyzToRgb(x, y, z) {
+	const rl = 3.2404542 * x - 1.5371385 * y - .4985314 * z;
+	const gl = -.969266 * x + 1.8760108 * y + .041556 * z;
+	const bl = .0556434 * x - .2040259 * y + 1.0572252 * z;
+	return [
+		clamp(linearToSrgb(rl), 0, 1),
+		clamp(linearToSrgb(gl), 0, 1),
+		clamp(linearToSrgb(bl), 0, 1)
+	];
+}
+/** Forward CIE Lab nonlinearity `f(t)`. */
+function labF(t) {
+	return t > LAB_DELTA_CUBED ? Math.cbrt(t) : t / LAB_3_DELTA_SQUARED + 4 / 29;
+}
+/**
+* Convert device (sRGB) RGB to CIE L\*a\*b\* via XYZ, using the D65 white
+* point.
+*
+* @param r - Red,   0..1.
+* @param g - Green, 0..1.
+* @param b - Blue,  0..1.
+* @returns `[L, a, b]` with `L ∈ [0, 100]`, `a`/`b` in their natural ranges.
+*/
+function rgbToLab(r, g, b) {
+	const [x, y, z] = rgbToXyz(r, g, b);
+	const fx = labF(x / D65_WHITE[0]);
+	const fy = labF(y / D65_WHITE[1]);
+	const fz = labF(z / D65_WHITE[2]);
+	return [
+		116 * fy - 16,
+		500 * (fx - fy),
+		200 * (fy - fz)
+	];
+}
+//#endregion
 //#region src/render/matrix.ts
 /** The identity transform. */
 function identity() {
@@ -33465,6 +35735,12 @@ Object.defineProperty(exports, "buildColorKeyMask", {
 		return buildColorKeyMask;
 	}
 });
+Object.defineProperty(exports, "buildCoonsPatchShading", {
+	enumerable: true,
+	get: function() {
+		return buildCoonsPatchShading;
+	}
+});
 Object.defineProperty(exports, "buildDPartRoot", {
 	enumerable: true,
 	get: function() {
@@ -33513,6 +35789,12 @@ Object.defineProperty(exports, "buildFieldLockDict", {
 		return buildFieldLockDict;
 	}
 });
+Object.defineProperty(exports, "buildFreeFormGouraudShading", {
+	enumerable: true,
+	get: function() {
+		return buildFreeFormGouraudShading;
+	}
+});
 Object.defineProperty(exports, "buildFunctionShading", {
 	enumerable: true,
 	get: function() {
@@ -33537,6 +35819,12 @@ Object.defineProperty(exports, "buildLab", {
 		return buildLab;
 	}
 });
+Object.defineProperty(exports, "buildLatticeFormGouraudShading", {
+	enumerable: true,
+	get: function() {
+		return buildLatticeFormGouraudShading;
+	}
+});
 Object.defineProperty(exports, "buildNamespace", {
 	enumerable: true,
 	get: function() {
@@ -33645,6 +35933,12 @@ Object.defineProperty(exports, "buildStencilMask", {
 		return buildStencilMask;
 	}
 });
+Object.defineProperty(exports, "buildTensorPatchShading", {
+	enumerable: true,
+	get: function() {
+		return buildTensorPatchShading;
+	}
+});
 Object.defineProperty(exports, "buildThresholdHalftone", {
 	enumerable: true,
 	get: function() {
@@ -33861,6 +36155,12 @@ Object.defineProperty(exports, "detectTransparency", {
 		return detectTransparency;
 	}
 });
+Object.defineProperty(exports, "deviceRgbToXyz", {
+	enumerable: true,
+	get: function() {
+		return deviceRgbToXyz;
+	}
+});
 Object.defineProperty(exports, "didYouMean", {
 	enumerable: true,
 	get: function() {
@@ -34263,6 +36563,12 @@ Object.defineProperty(exports, "getCertificationLevel", {
 		return getCertificationLevel;
 	}
 });
+Object.defineProperty(exports, "getColorGlyphLayers", {
+	enumerable: true,
+	get: function() {
+		return getColorGlyphLayers;
+	}
+});
 Object.defineProperty(exports, "getComponentDepths", {
 	enumerable: true,
 	get: function() {
@@ -34329,6 +36635,18 @@ Object.defineProperty(exports, "hasLtvData", {
 		return hasLtvData;
 	}
 });
+Object.defineProperty(exports, "hslToRgb", {
+	enumerable: true,
+	get: function() {
+		return hslToRgb;
+	}
+});
+Object.defineProperty(exports, "hsvToRgb", {
+	enumerable: true,
+	get: function() {
+		return hsvToRgb;
+	}
+});
 Object.defineProperty(exports, "identityTransferFunction", {
 	enumerable: true,
 	get: function() {
@@ -34467,6 +36785,12 @@ Object.defineProperty(exports, "nameHalftone", {
 		return nameHalftone;
 	}
 });
+Object.defineProperty(exports, "normalizeAxisCoordinate", {
+	enumerable: true,
+	get: function() {
+		return normalizeAxisCoordinate;
+	}
+});
 Object.defineProperty(exports, "normalizeComponentDepth", {
 	enumerable: true,
 	get: function() {
@@ -34503,12 +36827,24 @@ Object.defineProperty(exports, "parseCiiXml", {
 		return parseCiiXml;
 	}
 });
+Object.defineProperty(exports, "parseColorFont", {
+	enumerable: true,
+	get: function() {
+		return parseColorFont;
+	}
+});
 Object.defineProperty(exports, "parseExistingTrailer", {
 	enumerable: true,
 	get: function() {
 		return parseExistingTrailer;
 	}
 });
+Object.defineProperty(exports, "parseIccTransform", {
+	enumerable: true,
+	get: function() {
+		return parseIccTransform;
+	}
+});
 Object.defineProperty(exports, "parseTileInfo", {
 	enumerable: true,
 	get: function() {
@@ -34521,6 +36857,12 @@ Object.defineProperty(exports, "parseTimestampResponse", {
 		return parseTimestampResponse;
 	}
 });
+Object.defineProperty(exports, "parseVariableFont", {
+	enumerable: true,
+	get: function() {
+		return parseVariableFont;
+	}
+});
 Object.defineProperty(exports, "parseXmpMetadata", {
 	enumerable: true,
 	get: function() {
@@ -34695,6 +37037,12 @@ Object.defineProperty(exports, "renderToPdf", {
 		return renderToPdf;
 	}
 });
+Object.defineProperty(exports, "reorderVisual", {
+	enumerable: true,
+	get: function() {
+		return reorderVisual;
+	}
+});
 Object.defineProperty(exports, "replaceTemplateVariables", {
 	enumerable: true,
 	get: function() {
@@ -34707,6 +37055,12 @@ Object.defineProperty(exports, "requestTimestamp", {
 		return requestTimestamp;
 	}
 });
+Object.defineProperty(exports, "resolveBidi", {
+	enumerable: true,
+	get: function() {
+		return resolveBidi;
+	}
+});
 Object.defineProperty(exports, "resolveFallback", {
 	enumerable: true,
 	get: function() {
@@ -34719,6 +37073,36 @@ Object.defineProperty(exports, "resolveFieldReference", {
 		return resolveFieldReference;
 	}
 });
+Object.defineProperty(exports, "resolveInstanceCoordinates", {
+	enumerable: true,
+	get: function() {
+		return resolveInstanceCoordinates;
+	}
+});
+Object.defineProperty(exports, "rgbToHsl", {
+	enumerable: true,
+	get: function() {
+		return rgbToHsl;
+	}
+});
+Object.defineProperty(exports, "rgbToHsv", {
+	enumerable: true,
+	get: function() {
+		return rgbToHsv;
+	}
+});
+Object.defineProperty(exports, "rgbToLab", {
+	enumerable: true,
+	get: function() {
+		return rgbToLab;
+	}
+});
+Object.defineProperty(exports, "rgbToXyz", {
+	enumerable: true,
+	get: function() {
+		return rgbToXyz;
+	}
+});
 Object.defineProperty(exports, "sampleShadingColor", {
 	enumerable: true,
 	get: function() {
@@ -35061,5 +37445,17 @@ Object.defineProperty(exports, "wrapText", {
 		return wrapText$2;
 	}
 });
+Object.defineProperty(exports, "xyzToLab", {
+	enumerable: true,
+	get: function() {
+		return xyzToLab;
+	}
+});
+Object.defineProperty(exports, "xyzToRgb", {
+	enumerable: true,
+	get: function() {
+		return xyzToRgb;
+	}
+});
 
-//# sourceMappingURL=src-C-mBizNU.cjs.map
+//# sourceMappingURL=src-CbPUzRbg.cjs.map